!(function(){var rM=(Ae,Be)=>(Be=Symbol[Ae])?Be:Symbol.for("Symbol."+Ae),Sat=Ae=>{throw TypeError(Ae)},ti=Math.pow;var Eat=function(Ae,Be){this[0]=Ae,this[1]=Be};var p8=Ae=>{var Be=Ae[rM("asyncIterator")],pt=!1,oe,$={};return Be==null?(Be=Ae[rM("iterator")](),oe=fe=>$[fe]=Ye=>Be[fe](Ye)):(Be=Be.call(Ae),oe=fe=>$[fe]=Ye=>{if(pt){if(pt=!1,fe==="throw")throw Ye;return Ye}return pt=!0,{done:!1,value:new Eat(new Promise(ae=>{var Rt=Be[fe](Ye);Rt instanceof Object||Sat("Object expected"),ae(Rt)}),1)}}),$[rM("iterator")]=()=>$,oe("next"),"throw"in Be?oe("throw"):$.throw=fe=>{throw fe},"return"in Be&&oe("return"),$};(self.webpackChunkant_design_pro=self.webpackChunkant_design_pro||[]).push([[2261],{95327:function(Ae,Be,pt){"use strict";pt.d(Be,{P:function(){return bat}});var oe={};pt.r(oe),pt.d(oe,{add:function(){return ih},adjoint:function(){return hv},clone:function(){return dv},copy:function(){return Tc},create:function(){return Wn},determinant:function(){return $u},equals:function(){return ah},exactEquals:function(){return ki},frob:function(){return Sb},fromQuat:function(){return th},fromQuat2:function(){return Jd},fromRotation:function(){return ua},fromRotationTranslation:function(){return Ml},fromRotationTranslationScale:function(){return wb},fromRotationTranslationScaleOrigin:function(){return Ds},fromScaling:function(){return Is},fromTranslation:function(){return Lr},fromValues:function(){return Hd},fromXRotation:function(){return gv},fromYRotation:function(){return Qd},fromZRotation:function(){return Qa},frustum:function(){return Ob},getRotation:function(){return Pc},getScaling:function(){return fa},getTranslation:function(){return $n},identity:function(){return lr},invert:function(){return $i},lookAt:function(){return Yu},mul:function(){return Lc},multiply:function(){return Gn},multiplyScalar:function(){return Eb},multiplyScalarAndAdd:function(){return _v},ortho:function(){return eh},orthoNO:function(){return bv},orthoZO:function(){return nh},perspective:function(){return mv},perspectiveFromFieldOfView:function(){return Cc},perspectiveNO:function(){return yv},perspectiveZO:function(){return Zu},rotate:function(){return pv},rotateX:function(){return qd},rotateY:function(){return Kd},rotateZ:function(){return vv},scale:function(){return Ud},set:function(){return Vd},str:function(){return xv},sub:function(){return wv},subtract:function(){return Hu},targetTo:function(){return rh},translate:function(){return Ns},transpose:function(){return Xd}});var $={};pt.r($),pt.d($,{area:function(){return Lz},bottom:function(){return cc},bottomLeft:function(){return cc},bottomRight:function(){return cc},inside:function(){return cc},left:function(){return cc},outside:function(){return Iz},right:function(){return cc},spider:function(){return Bz},surround:function(){return Wz},top:function(){return cc},topLeft:function(){return cc},topRight:function(){return cc}});var fe={};pt.r(fe),pt.d(fe,{interpolateBlues:function(){return wG},interpolateBrBG:function(){return eG},interpolateBuGn:function(){return uG},interpolateBuPu:function(){return fG},interpolateCividis:function(){return AG},interpolateCool:function(){return NG},interpolateCubehelixDefault:function(){return LG},interpolateGnBu:function(){return dG},interpolateGreens:function(){return OG},interpolateGreys:function(){return SG},interpolateInferno:function(){return GG},interpolateMagma:function(){return WG},interpolateOrRd:function(){return hG},interpolateOranges:function(){return kG},interpolatePRGn:function(){return nG},interpolatePiYG:function(){return rG},interpolatePlasma:function(){return $G},interpolatePuBu:function(){return vG},interpolatePuBuGn:function(){return pG},interpolatePuOr:function(){return iG},interpolatePuRd:function(){return gG},interpolatePurples:function(){return EG},interpolateRainbow:function(){return IG},interpolateRdBu:function(){return aG},interpolateRdGy:function(){return oG},interpolateRdPu:function(){return yG},interpolateRdYlBu:function(){return sG},interpolateRdYlGn:function(){return cG},interpolateReds:function(){return MG},interpolateSinebow:function(){return FG},interpolateSpectral:function(){return lG},interpolateTurbo:function(){return BG},interpolateViridis:function(){return zG},interpolateWarm:function(){return RG},interpolateYlGn:function(){return bG},interpolateYlGnBu:function(){return mG},interpolateYlOrBr:function(){return xG},interpolateYlOrRd:function(){return _G},schemeAccent:function(){return AW},schemeBlues:function(){return F3},schemeBrBG:function(){return y3},schemeBuGn:function(){return M3},schemeBuPu:function(){return k3},schemeCategory10:function(){return kW},schemeDark2:function(){return TW},schemeGnBu:function(){return A3},schemeGreens:function(){return B3},schemeGreys:function(){return z3},schemeObservable10:function(){return PW},schemeOrRd:function(){return T3},schemeOranges:function(){return $3},schemePRGn:function(){return m3},schemePaired:function(){return CW},schemePastel1:function(){return LW},schemePastel2:function(){return RW},schemePiYG:function(){return b3},schemePuBu:function(){return C3},schemePuBuGn:function(){return P3},schemePuOr:function(){return x3},schemePuRd:function(){return L3},schemePurples:function(){return W3},schemeRdBu:function(){return _3},schemeRdGy:function(){return w3},schemeRdPu:function(){return R3},schemeRdYlBu:function(){return O3},schemeRdYlGn:function(){return S3},schemeReds:function(){return G3},schemeSet1:function(){return NW},schemeSet2:function(){return IW},schemeSet3:function(){return DW},schemeSpectral:function(){return E3},schemeTableau10:function(){return jW},schemeYlGn:function(){return I3},schemeYlGnBu:function(){return N3},schemeYlOrBr:function(){return D3},schemeYlOrRd:function(){return j3}});var Ye={};pt.r(Ye),pt.d(Ye,{geoAlbers:function(){return VD},geoAlbersUsa:function(){return NJ},geoAzimuthalEqualArea:function(){return IJ},geoAzimuthalEqualAreaRaw:function(){return gE},geoAzimuthalEquidistant:function(){return DJ},geoAzimuthalEquidistantRaw:function(){return yE},geoConicConformal:function(){return FJ},geoConicConformalRaw:function(){return qD},geoConicEqualArea:function(){return Q1},geoConicEqualAreaRaw:function(){return HD},geoConicEquidistant:function(){return zJ},geoConicEquidistantRaw:function(){return KD},geoEqualEarth:function(){return GJ},geoEqualEarthRaw:function(){return mE},geoEquirectangular:function(){return BJ},geoEquirectangularRaw:function(){return F0},geoGnomonic:function(){return $J},geoGnomonicRaw:function(){return bE},geoIdentity:function(){return ZJ},geoMercator:function(){return jJ},geoMercatorRaw:function(){return j0},geoNaturalEarth1:function(){return YJ},geoNaturalEarth1Raw:function(){return xE},geoOrthographic:function(){return HJ},geoOrthographicRaw:function(){return _E},geoProjection:function(){return Ms},geoProjectionMutator:function(){return pE},geoStereographic:function(){return VJ},geoStereographicRaw:function(){return wE},geoTransverseMercator:function(){return XJ},geoTransverseMercatorRaw:function(){return OE}});var ae={};pt.r(ae),pt.d(ae,{frequency:function(){return qet},id:function(){return Ket},name:function(){return Qet},weight:function(){return Uet}});var Rt=pt(67294),qt=pt(73935),Yt=pt.t(qt,2),ft=function(){return ft=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},ft.apply(this,arguments)},re=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})},Wt=function(t,e){var n={label:0,sent:function(){if(a[0]&1)throw a[1];return a[1]},trys:[],ops:[]},r,i,a,o=Object.create((typeof Iterator=="function"?Iterator:Object).prototype);return o.next=s(0),o.throw=s(1),o.return=s(2),typeof Symbol=="function"&&(o[Symbol.iterator]=function(){return this}),o;function s(l){return function(u){return c([l,u])}}function c(l){if(r)throw new TypeError("Generator is already executing.");for(;o&&(o=0,l[0]&&(n=0)),n;)try{if(r=1,i&&(a=l[0]&2?i.return:l[0]?i.throw||((a=i.return)&&a.call(i),0):i.next)&&!(a=a.call(i,l[1])).done)return a;switch(i=0,a&&(l=[l[0]&2,a.value]),l[0]){case 0:case 1:a=l;break;case 4:return n.label++,{value:l[1],done:!1};case 5:n.label++,i=l[1],l=[0];continue;case 7:l=n.ops.pop(),n.trys.pop();continue;default:if(a=n.trys,!(a=a.length>0&&a[a.length-1])&&(l[0]===6||l[0]===2)){n=0;continue}if(l[0]===3&&(!a||l[1]>a[0]&&l[1]<a[3])){n.label=l[1];break}if(l[0]===6&&n.label<a[1]){n.label=a[1],a=l;break}if(a&&n.label<a[2]){n.label=a[2],n.ops.push(l);break}a[2]&&n.ops.pop(),n.trys.pop();continue}l=e.call(t,n)}catch(u){l=[6,u],i=0}finally{r=a=0}if(l[0]&5)throw l[1];return{value:l[0]?l[1]:void 0,done:!0}}},ee=ft({},Yt),Xt=ee.version,kt=ee.render,St=ee.unmountComponentAtNode,bt;try{var Tt=Number((Xt||"").split(".")[0]);Tt>=18&&(bt=ee.createRoot)}catch(t){}function xe(t){var e=ee.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;e&&typeof e=="object"&&(e.usingClientEntryPoint=t)}var _e="__rc_react_root__";function _n(t,e){xe(!0);var n=e[_e]||bt(e);xe(!1),n.render(t),e[_e]=n}function Ue(t,e){kt(t,e)}function pn(t,e){}function gn(t,e){if(bt){_n(t,e);return}Ue(t,e)}function rn(t){return re(this,void 0,void 0,function(){return Wt(this,function(e){return[2,Promise.resolve().then(function(){var n;(n=t[_e])===null||n===void 0||n.unmount(),delete t[_e]})]})})}function Yn(t){St(t)}function Jn(t){}function Ce(t){return re(this,void 0,void 0,function(){return Wt(this,function(e){return bt!==void 0?[2,rn(t)]:(Yn(t),[2])})})}var Se=new Map;typeof document!="undefined"&&Se.set("tooltip",document.createElement("div"));var zr=function(t,e){e===void 0&&(e=!1);var n=null;if(e)n=Se.get("tooltip");else if(n=document.createElement("div"),t!=null&&t.key){var r=Se.get(t.key);r?n=r:Se.set(t.key,n)}return gn(t,n),n},di=function(t){if(typeof document=="undefined")return"loading";var e=t.attachShadow({mode:"open"}),n=document.createElement("div"),r=document.createElement("style");r.innerHTML=`.loading {
    display: inline-block;
    position: relative;
    width: 80px;
    height: 80px;
  }
  .loading div {
    position: absolute;
    top: 33px;
    width: 13px;
    height: 13px;
    border-radius: 50%;
    background: #ccc;
    animation-timing-function: cubic-bezier(0, 1, 1, 0);
  }
  .loading div:nth-child(1) {
    left: 8px;
    animation: loading1 0.6s infinite;
  }
  .loading div:nth-child(2) {
    left: 8px;
    animation: loading2 0.6s infinite;
  }
  .loading div:nth-child(3) {
    left: 32px;
    animation: loading2 0.6s infinite;
  }
  .loading div:nth-child(4) {
    left: 56px;
    animation: loading3 0.6s infinite;
  }
  @keyframes loading1 {
    0% {
      transform: scale(0);
    }
    100% {
      transform: scale(1);
    }
  }
  @keyframes loading3 {
    0% {
      transform: scale(1);
    }
    100% {
      transform: scale(0);
    }
  }
  @keyframes loading2 {
    0% {
      transform: translate(0, 0);
    }
    100% {
      transform: translate(24px, 0);
    }
  }
  `,n.classList.add("loading"),n.innerHTML="<div></div><div></div><div></div><div></div>",e.appendChild(r),e.appendChild(n)},Fi=function(t){var e=t.loadingTemplate,n=t.theme,r=n===void 0?"light":n,i=Rt.useRef(null);Rt.useEffect(function(){!e&&i.current&&di(i.current)},[]);var a=function(){return e||Rt.createElement("div",{ref:i})};return Rt.createElement("div",{className:"charts-loading-container",style:{position:"absolute",width:"100%",height:"100%",display:"flex",alignItems:"center",justifyContent:"center",left:0,top:0,zIndex:99,backgroundColor:r==="dark"?"rgb(20, 20, 20)":"rgb(255, 255, 255)"}},a())},hi=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),tr=function(t){hi(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.state={hasError:!1},n.renderError=function(r){var i=n.props.errorTemplate;switch(r){default:return typeof i=="function"?i(r):i||Rt.createElement("h5",null,"\u7EC4\u4EF6\u51FA\u9519\u4E86\uFF0C\u8BF7\u6838\u67E5\u540E\u91CD\u8BD5\uFF1A ",r.message)}},n}return e.getDerivedStateFromError=function(n){return{hasError:!0,error:n}},e.getDerivedStateFromProps=function(n,r){return r.children!==n.children?{children:n.children,hasError:!1,error:void 0}:null},e.prototype.render=function(){return this.state.hasError?this.renderError(this.state.error):Rt.createElement(Rt.Fragment,null,this.props.children)},e}(Rt.Component),rt=pt(96486),aa,Bi=function(){return aa||(aa=document.createElement("canvas").getContext("2d")),aa},Wr=function(t,e,n){if(n||arguments.length===2)for(var r=0,i=e.length,a;r<i;r++)(a||!(r in e))&&(a||(a=Array.prototype.slice.call(e,0,r)),a[r]=e[r]);return t.concat(a||Array.prototype.slice.call(e))},ya=(0,rt.memoize)(function(t,e){e===void 0&&(e={});var n=e.fontSize,r=e.fontFamily,i=r===void 0?"sans-serif":r,a=e.fontWeight,o=e.fontStyle,s=e.fontVariant,c=Bi();return c.font=[o,a,s,"".concat(n,"px"),i].join(" "),c.measureText((0,rt.isString)(t)?t:"")},function(t,e){return e===void 0&&(e={}),Wr([t],(0,rt.values)(e),!0).join("")}),oa=function(t,e){return e===void 0&&(e={}),ya(t,e).width},ks=function(t,e){e===void 0&&(e={});var n=ya(t,e);return n.actualBoundingBoxAscent+n.actualBoundingBoxDescent},Or=function(t){var e=/react|\.jsx|children:\[\(|return\s+[A-Za-z0-9].createElement\((?!['"][g|circle|ellipse|image|rect|line|polyline|polygon|text|path|html|mesh]['"])([^\)])*,/i;return e.test(t)},yn=function(){return yn=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},yn.apply(this,arguments)};function Xa(t,e){var n=(0,Rt.useRef)(),r=(0,Rt.useRef)(),i=(0,Rt.useRef)(null),a=e.onReady,o=e.onEvent,s=function(u,f){var d;u===void 0&&(u="image/png");var h=(d=i.current)===null||d===void 0?void 0:d.getElementsByTagName("canvas")[0];return h==null?void 0:h.toDataURL(u,f)},c=function(u,f,d){u===void 0&&(u="download"),f===void 0&&(f="image/png");var h=u;u.indexOf(".")===-1&&(h="".concat(u,".").concat(f.split("/")[1]));var v=s(f,d),g=document.createElement("a");return g.href=v,g.download=h,document.body.appendChild(g),g.click(),document.body.removeChild(g),g=null,h},l=function(u,f){f===void 0&&(f=!1);var d=Object.keys(u),h=f;d.forEach(function(v){var g=u[v];v==="tooltip"&&(h=!0),(0,rt.isFunction)(g)&&Or("".concat(g))?u[v]=function(){for(var y=[],b=0;b<arguments.length;b++)y[b]=arguments[b];return zr(g.apply(void 0,y),h)}:(0,rt.isArray)(g)?g.forEach(function(y){l(y,h)}):(0,rt.isObject)(g)?l(g,h):h=f})};return(0,Rt.useEffect)(function(){n.current&&!(0,rt.isEqual)(r.current,e)&&(r.current=(0,rt.cloneDeep)(e),l(e),n.current.update(e),n.current.render())},[e]),(0,Rt.useEffect)(function(){if(!i.current)return function(){return null};r.current||(r.current=(0,rt.cloneDeep)(e)),l(e);var u=new t(i.current,yn({},e));u.toDataURL=s,u.downloadImage=c,u.render(),n.current=u,a&&a(u);var f=function(d){o&&o(u,d)};return u.on("*",f),function(){n.current&&(n.current.destroy(),n.current.off("*",f),n.current=void 0)}},[]),{chart:n,container:i}}var Ua="*",As=function(){function t(){this._events={}}return t.prototype.on=function(e,n,r){return this._events[e]||(this._events[e]=[]),this._events[e].push({callback:n,once:!!r}),this},t.prototype.once=function(e,n){return this.on(e,n,!0)},t.prototype.emit=function(e){for(var n=this,r=[],i=1;i<arguments.length;i++)r[i-1]=arguments[i];var a=this._events[e]||[],o=this._events[Ua]||[],s=function(c){for(var l=c.length,u=0;u<l;u++)if(c[u]){var f=c[u],d=f.callback,h=f.once;h&&(c.splice(u,1),c.length===0&&delete n._events[e],l--,u--),d.apply(n,r)}};s(a),s(o)},t.prototype.off=function(e,n){if(!e)this._events={};else if(!n)delete this._events[e];else{for(var r=this._events[e]||[],i=r.length,a=0;a<i;a++)r[a].callback===n&&(r.splice(a,1),i--,a--);r.length===0&&delete this._events[e]}return this},t.prototype.getEvents=function(){return this._events},t}(),Ts=As;const Xo="main-layer",zi="label-layer",ma="element",_i="view",ba="plot",Gu="component",Wi="label",bc="area",wl="mask";var Ee=pt(1413),xt=pt(15671),Ot=pt(43144),ln=pt(74902),De=pt(53640),Me=pt(60136),Te=pt(97685),Ps=pt(26729),Lo=Ps,un=1e-6,Hn=typeof Float32Array!="undefined"?Float32Array:Array,Pr=Math.random;function xc(t){Hn=t}var _c=Math.PI/180;function wc(t){return t*_c}function qa(t,e){return Math.abs(t-e)<=un*Math.max(1,Math.abs(t),Math.abs(e))}Math.hypot||(Math.hypot=function(){for(var t=0,e=arguments.length;e--;)t+=arguments[e]*arguments[e];return Math.sqrt(t)});function me(){var t=new Hn(3);return Hn!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0),t}function wi(t){var e=new Hn(3);return e[0]=t[0],e[1]=t[1],e[2]=t[2],e}function sa(t){var e=t[0],n=t[1],r=t[2];return Math.hypot(e,n,r)}function sn(t,e,n){var r=new Hn(3);return r[0]=t,r[1]=e,r[2]=n,r}function ca(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t}function Gr(t,e,n,r){return t[0]=e,t[1]=n,t[2]=r,t}function Na(t,e,n){return t[0]=e[0]+n[0],t[1]=e[1]+n[1],t[2]=e[2]+n[2],t}function Ol(t,e,n){return t[0]=e[0]-n[0],t[1]=e[1]-n[1],t[2]=e[2]-n[2],t}function Bd(t,e,n){return t[0]=e[0]*n[0],t[1]=e[1]*n[1],t[2]=e[2]*n[2],t}function rv(t,e,n){return t[0]=e[0]/n[0],t[1]=e[1]/n[1],t[2]=e[2]/n[2],t}function iv(t,e){return t[0]=Math.ceil(e[0]),t[1]=Math.ceil(e[1]),t[2]=Math.ceil(e[2]),t}function zd(t,e){return t[0]=Math.floor(e[0]),t[1]=Math.floor(e[1]),t[2]=Math.floor(e[2]),t}function Wd(t,e,n){return t[0]=Math.min(e[0],n[0]),t[1]=Math.min(e[1],n[1]),t[2]=Math.min(e[2],n[2]),t}function Gd(t,e,n){return t[0]=Math.max(e[0],n[0]),t[1]=Math.max(e[1],n[1]),t[2]=Math.max(e[2],n[2]),t}function av(t,e){return t[0]=Math.round(e[0]),t[1]=Math.round(e[1]),t[2]=Math.round(e[2]),t}function Uo(t,e,n){return t[0]=e[0]*n,t[1]=e[1]*n,t[2]=e[2]*n,t}function Sl(t,e,n,r){return t[0]=e[0]+n[0]*r,t[1]=e[1]+n[1]*r,t[2]=e[2]+n[2]*r,t}function Oc(t,e){var n=e[0]-t[0],r=e[1]-t[1],i=e[2]-t[2];return Math.hypot(n,r,i)}function ov(t,e){var n=e[0]-t[0],r=e[1]-t[1],i=e[2]-t[2];return n*n+r*r+i*i}function sv(t){var e=t[0],n=t[1],r=t[2];return e*e+n*n+r*r}function Sc(t,e){return t[0]=-e[0],t[1]=-e[1],t[2]=-e[2],t}function Ec(t,e){return t[0]=1/e[0],t[1]=1/e[1],t[2]=1/e[2],t}function xa(t,e){var n=e[0],r=e[1],i=e[2],a=n*n+r*r+i*i;return a>0&&(a=1/Math.sqrt(a)),t[0]=e[0]*a,t[1]=e[1]*a,t[2]=e[2]*a,t}function la(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]}function Mc(t,e,n){var r=e[0],i=e[1],a=e[2],o=n[0],s=n[1],c=n[2];return t[0]=i*c-a*s,t[1]=a*o-r*c,t[2]=r*s-i*o,t}function El(t,e,n,r){var i=e[0],a=e[1],o=e[2];return t[0]=i+r*(n[0]-i),t[1]=a+r*(n[1]-a),t[2]=o+r*(n[2]-o),t}function $d(t,e,n,r,i,a){var o=a*a,s=o*(2*a-3)+1,c=o*(a-2)+a,l=o*(a-1),u=o*(3-2*a);return t[0]=e[0]*s+n[0]*c+r[0]*l+i[0]*u,t[1]=e[1]*s+n[1]*c+r[1]*l+i[1]*u,t[2]=e[2]*s+n[2]*c+r[2]*l+i[2]*u,t}function cv(t,e,n,r,i,a){var o=1-a,s=o*o,c=a*a,l=s*o,u=3*a*s,f=3*c*o,d=c*a;return t[0]=e[0]*l+n[0]*u+r[0]*f+i[0]*d,t[1]=e[1]*l+n[1]*u+r[1]*f+i[1]*d,t[2]=e[2]*l+n[2]*u+r[2]*f+i[2]*d,t}function lv(t,e){e=e||1;var n=glMatrix.RANDOM()*2*Math.PI,r=glMatrix.RANDOM()*2-1,i=Math.sqrt(1-r*r)*e;return t[0]=Math.cos(n)*i,t[1]=Math.sin(n)*i,t[2]=r*e,t}function er(t,e,n){var r=e[0],i=e[1],a=e[2],o=n[3]*r+n[7]*i+n[11]*a+n[15];return o=o||1,t[0]=(n[0]*r+n[4]*i+n[8]*a+n[12])/o,t[1]=(n[1]*r+n[5]*i+n[9]*a+n[13])/o,t[2]=(n[2]*r+n[6]*i+n[10]*a+n[14])/o,t}function Zd(t,e,n){var r=e[0],i=e[1],a=e[2];return t[0]=r*n[0]+i*n[3]+a*n[6],t[1]=r*n[1]+i*n[4]+a*n[7],t[2]=r*n[2]+i*n[5]+a*n[8],t}function pi(t,e,n){var r=n[0],i=n[1],a=n[2],o=n[3],s=e[0],c=e[1],l=e[2],u=i*l-a*c,f=a*s-r*l,d=r*c-i*s,h=i*d-a*f,v=a*u-r*d,g=r*f-i*u,y=o*2;return u*=y,f*=y,d*=y,h*=2,v*=2,g*=2,t[0]=s+u+h,t[1]=c+f+v,t[2]=l+d+g,t}function Oi(t,e,n,r){var i=[],a=[];return i[0]=e[0]-n[0],i[1]=e[1]-n[1],i[2]=e[2]-n[2],a[0]=i[0],a[1]=i[1]*Math.cos(r)-i[2]*Math.sin(r),a[2]=i[1]*Math.sin(r)+i[2]*Math.cos(r),t[0]=a[0]+n[0],t[1]=a[1]+n[1],t[2]=a[2]+n[2],t}function j(t,e,n,r){var i=[],a=[];return i[0]=e[0]-n[0],i[1]=e[1]-n[1],i[2]=e[2]-n[2],a[0]=i[2]*Math.sin(r)+i[0]*Math.cos(r),a[1]=i[1],a[2]=i[2]*Math.cos(r)-i[0]*Math.sin(r),t[0]=a[0]+n[0],t[1]=a[1]+n[1],t[2]=a[2]+n[2],t}function z(t,e,n,r){var i=[],a=[];return i[0]=e[0]-n[0],i[1]=e[1]-n[1],i[2]=e[2]-n[2],a[0]=i[0]*Math.cos(r)-i[1]*Math.sin(r),a[1]=i[0]*Math.sin(r)+i[1]*Math.cos(r),a[2]=i[2],t[0]=a[0]+n[0],t[1]=a[1]+n[1],t[2]=a[2]+n[2],t}function H(t,e){var n=t[0],r=t[1],i=t[2],a=e[0],o=e[1],s=e[2],c=Math.sqrt(n*n+r*r+i*i),l=Math.sqrt(a*a+o*o+s*s),u=c*l,f=u&&la(t,e)/u;return Math.acos(Math.min(Math.max(f,-1),1))}function U(t){return t[0]=0,t[1]=0,t[2]=0,t}function it(t){return"vec3("+t[0]+", "+t[1]+", "+t[2]+")"}function at(t,e){return t[0]===e[0]&&t[1]===e[1]&&t[2]===e[2]}function K(t,e){var n=t[0],r=t[1],i=t[2],a=e[0],o=e[1],s=e[2];return Math.abs(n-a)<=un*Math.max(1,Math.abs(n),Math.abs(a))&&Math.abs(r-o)<=un*Math.max(1,Math.abs(r),Math.abs(o))&&Math.abs(i-s)<=un*Math.max(1,Math.abs(i),Math.abs(s))}var J=Ol,ct=null,ut=null,Dt=Oc,Ht=null,ie=sa,Ft=null,Jt=function(){var t=me();return function(e,n,r,i,a,o){var s,c;for(n||(n=3),r||(r=0),i?c=Math.min(i*n+r,e.length):c=e.length,s=r;s<c;s+=n)t[0]=e[s],t[1]=e[s+1],t[2]=e[s+2],a(t,t,o),e[s]=t[0],e[s+1]=t[1],e[s+2]=t[2];return e}}();function Gt(){var t=new Hn(4);return Hn!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0,t[3]=0),t}function Nt(t){var e=new Hn(4);return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e}function he(t,e,n,r){var i=new Hn(4);return i[0]=t,i[1]=e,i[2]=n,i[3]=r,i}function ne(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t}function pe(t,e,n,r,i){return t[0]=e,t[1]=n,t[2]=r,t[3]=i,t}function Ut(t,e,n){return t[0]=e[0]+n[0],t[1]=e[1]+n[1],t[2]=e[2]+n[2],t[3]=e[3]+n[3],t}function ve(t,e,n){return t[0]=e[0]-n[0],t[1]=e[1]-n[1],t[2]=e[2]-n[2],t[3]=e[3]-n[3],t}function He(t,e,n){return t[0]=e[0]*n[0],t[1]=e[1]*n[1],t[2]=e[2]*n[2],t[3]=e[3]*n[3],t}function Si(t,e,n){return t[0]=e[0]/n[0],t[1]=e[1]/n[1],t[2]=e[2]/n[2],t[3]=e[3]/n[3],t}function Ei(t,e){return t[0]=Math.ceil(e[0]),t[1]=Math.ceil(e[1]),t[2]=Math.ceil(e[2]),t[3]=Math.ceil(e[3]),t}function vi(t,e){return t[0]=Math.floor(e[0]),t[1]=Math.floor(e[1]),t[2]=Math.floor(e[2]),t[3]=Math.floor(e[3]),t}function Mi(t,e,n){return t[0]=Math.min(e[0],n[0]),t[1]=Math.min(e[1],n[1]),t[2]=Math.min(e[2],n[2]),t[3]=Math.min(e[3],n[3]),t}function Gi(t,e,n){return t[0]=Math.max(e[0],n[0]),t[1]=Math.max(e[1],n[1]),t[2]=Math.max(e[2],n[2]),t[3]=Math.max(e[3],n[3]),t}function nr(t,e){return t[0]=Math.round(e[0]),t[1]=Math.round(e[1]),t[2]=Math.round(e[2]),t[3]=Math.round(e[3]),t}function wn(t,e,n){return t[0]=e[0]*n,t[1]=e[1]*n,t[2]=e[2]*n,t[3]=e[3]*n,t}function kc(t,e,n,r){return t[0]=e[0]+n[0]*r,t[1]=e[1]+n[1]*r,t[2]=e[2]+n[2]*r,t[3]=e[3]+n[3]*r,t}function Yd(t,e){var n=e[0]-t[0],r=e[1]-t[1],i=e[2]-t[2],a=e[3]-t[3];return Math.hypot(n,r,i,a)}function Ac(t,e){var n=e[0]-t[0],r=e[1]-t[1],i=e[2]-t[2],a=e[3]-t[3];return n*n+r*r+i*i+a*a}function _a(t){var e=t[0],n=t[1],r=t[2],i=t[3];return Math.hypot(e,n,r,i)}function Cr(t){var e=t[0],n=t[1],r=t[2],i=t[3];return e*e+n*n+r*r+i*i}function Cs(t,e){return t[0]=-e[0],t[1]=-e[1],t[2]=-e[2],t[3]=-e[3],t}function Ls(t,e){return t[0]=1/e[0],t[1]=1/e[1],t[2]=1/e[2],t[3]=1/e[3],t}function Rs(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=n*n+r*r+i*i+a*a;return o>0&&(o=1/Math.sqrt(o)),t[0]=n*o,t[1]=r*o,t[2]=i*o,t[3]=a*o,t}function Ka(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]+t[3]*e[3]}function iM(t,e,n,r){var i=n[0]*r[1]-n[1]*r[0],a=n[0]*r[2]-n[2]*r[0],o=n[0]*r[3]-n[3]*r[0],s=n[1]*r[2]-n[2]*r[1],c=n[1]*r[3]-n[3]*r[1],l=n[2]*r[3]-n[3]*r[2],u=e[0],f=e[1],d=e[2],h=e[3];return t[0]=f*l-d*c+h*s,t[1]=-(u*l)+d*o-h*a,t[2]=u*c-f*o+h*i,t[3]=-(u*s)+f*a-d*i,t}function uv(t,e,n,r){var i=e[0],a=e[1],o=e[2],s=e[3];return t[0]=i+r*(n[0]-i),t[1]=a+r*(n[1]-a),t[2]=o+r*(n[2]-o),t[3]=s+r*(n[3]-s),t}function aM(t,e){e=e||1;var n,r,i,a,o,s;do n=glMatrix.RANDOM()*2-1,r=glMatrix.RANDOM()*2-1,o=n*n+r*r;while(o>=1);do i=glMatrix.RANDOM()*2-1,a=glMatrix.RANDOM()*2-1,s=i*i+a*a;while(s>=1);var c=Math.sqrt((1-o)/s);return t[0]=e*n,t[1]=e*r,t[2]=e*i*c,t[3]=e*a*c,t}function Ro(t,e,n){var r=e[0],i=e[1],a=e[2],o=e[3];return t[0]=n[0]*r+n[4]*i+n[8]*a+n[12]*o,t[1]=n[1]*r+n[5]*i+n[9]*a+n[13]*o,t[2]=n[2]*r+n[6]*i+n[10]*a+n[14]*o,t[3]=n[3]*r+n[7]*i+n[11]*a+n[15]*o,t}function oM(t,e,n){var r=e[0],i=e[1],a=e[2],o=n[0],s=n[1],c=n[2],l=n[3],u=l*r+s*a-c*i,f=l*i+c*r-o*a,d=l*a+o*i-s*r,h=-o*r-s*i-c*a;return t[0]=u*l+h*-o+f*-c-d*-s,t[1]=f*l+h*-s+d*-o-u*-c,t[2]=d*l+h*-c+u*-s-f*-o,t[3]=e[3],t}function sM(t){return t[0]=0,t[1]=0,t[2]=0,t[3]=0,t}function fv(t){return"vec4("+t[0]+", "+t[1]+", "+t[2]+", "+t[3]+")"}function xb(t,e){return t[0]===e[0]&&t[1]===e[1]&&t[2]===e[2]&&t[3]===e[3]}function _b(t,e){var n=t[0],r=t[1],i=t[2],a=t[3],o=e[0],s=e[1],c=e[2],l=e[3];return Math.abs(n-o)<=un*Math.max(1,Math.abs(n),Math.abs(o))&&Math.abs(r-s)<=un*Math.max(1,Math.abs(r),Math.abs(s))&&Math.abs(i-c)<=un*Math.max(1,Math.abs(i),Math.abs(c))&&Math.abs(a-l)<=un*Math.max(1,Math.abs(a),Math.abs(l))}var cM=null,lM=null,uM=null,cr=null,rr=null,fM=null,dM=null,hM=function(){var t=Gt();return function(e,n,r,i,a,o){var s,c;for(n||(n=4),r||(r=0),i?c=Math.min(i*n+r,e.length):c=e.length,s=r;s<c;s+=n)t[0]=e[s],t[1]=e[s+1],t[2]=e[s+2],t[3]=e[s+3],a(t,t,o),e[s]=t[0],e[s+1]=t[1],e[s+2]=t[2],e[s+3]=t[3];return e}}();function Wn(){var t=new Hn(16);return Hn!=Float32Array&&(t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=0,t[12]=0,t[13]=0,t[14]=0),t[0]=1,t[5]=1,t[10]=1,t[15]=1,t}function dv(t){var e=new Hn(16);return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e[9]=t[9],e[10]=t[10],e[11]=t[11],e[12]=t[12],e[13]=t[13],e[14]=t[14],e[15]=t[15],e}function Tc(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4],t[5]=e[5],t[6]=e[6],t[7]=e[7],t[8]=e[8],t[9]=e[9],t[10]=e[10],t[11]=e[11],t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15],t}function Hd(t,e,n,r,i,a,o,s,c,l,u,f,d,h,v,g){var y=new Hn(16);return y[0]=t,y[1]=e,y[2]=n,y[3]=r,y[4]=i,y[5]=a,y[6]=o,y[7]=s,y[8]=c,y[9]=l,y[10]=u,y[11]=f,y[12]=d,y[13]=h,y[14]=v,y[15]=g,y}function Vd(t,e,n,r,i,a,o,s,c,l,u,f,d,h,v,g,y){return t[0]=e,t[1]=n,t[2]=r,t[3]=i,t[4]=a,t[5]=o,t[6]=s,t[7]=c,t[8]=l,t[9]=u,t[10]=f,t[11]=d,t[12]=h,t[13]=v,t[14]=g,t[15]=y,t}function lr(t){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function Xd(t,e){if(t===e){var n=e[1],r=e[2],i=e[3],a=e[6],o=e[7],s=e[11];t[1]=e[4],t[2]=e[8],t[3]=e[12],t[4]=n,t[6]=e[9],t[7]=e[13],t[8]=r,t[9]=a,t[11]=e[14],t[12]=i,t[13]=o,t[14]=s}else t[0]=e[0],t[1]=e[4],t[2]=e[8],t[3]=e[12],t[4]=e[1],t[5]=e[5],t[6]=e[9],t[7]=e[13],t[8]=e[2],t[9]=e[6],t[10]=e[10],t[11]=e[14],t[12]=e[3],t[13]=e[7],t[14]=e[11],t[15]=e[15];return t}function $i(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=e[4],s=e[5],c=e[6],l=e[7],u=e[8],f=e[9],d=e[10],h=e[11],v=e[12],g=e[13],y=e[14],b=e[15],x=n*s-r*o,_=n*c-i*o,w=n*l-a*o,O=r*c-i*s,E=r*l-a*s,M=i*l-a*c,k=u*g-f*v,A=u*y-d*v,P=u*b-h*v,C=f*y-d*g,N=f*b-h*g,L=d*b-h*y,R=x*L-_*N+w*C+O*P-E*A+M*k;return R?(R=1/R,t[0]=(s*L-c*N+l*C)*R,t[1]=(i*N-r*L-a*C)*R,t[2]=(g*M-y*E+b*O)*R,t[3]=(d*E-f*M-h*O)*R,t[4]=(c*P-o*L-l*A)*R,t[5]=(n*L-i*P+a*A)*R,t[6]=(y*w-v*M-b*_)*R,t[7]=(u*M-d*w+h*_)*R,t[8]=(o*N-s*P+l*k)*R,t[9]=(r*P-n*N-a*k)*R,t[10]=(v*E-g*w+b*x)*R,t[11]=(f*w-u*E-h*x)*R,t[12]=(s*A-o*C-c*k)*R,t[13]=(n*C-r*A+i*k)*R,t[14]=(g*_-v*O-y*x)*R,t[15]=(u*O-f*_+d*x)*R,t):null}function hv(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=e[4],s=e[5],c=e[6],l=e[7],u=e[8],f=e[9],d=e[10],h=e[11],v=e[12],g=e[13],y=e[14],b=e[15];return t[0]=s*(d*b-h*y)-f*(c*b-l*y)+g*(c*h-l*d),t[1]=-(r*(d*b-h*y)-f*(i*b-a*y)+g*(i*h-a*d)),t[2]=r*(c*b-l*y)-s*(i*b-a*y)+g*(i*l-a*c),t[3]=-(r*(c*h-l*d)-s*(i*h-a*d)+f*(i*l-a*c)),t[4]=-(o*(d*b-h*y)-u*(c*b-l*y)+v*(c*h-l*d)),t[5]=n*(d*b-h*y)-u*(i*b-a*y)+v*(i*h-a*d),t[6]=-(n*(c*b-l*y)-o*(i*b-a*y)+v*(i*l-a*c)),t[7]=n*(c*h-l*d)-o*(i*h-a*d)+u*(i*l-a*c),t[8]=o*(f*b-h*g)-u*(s*b-l*g)+v*(s*h-l*f),t[9]=-(n*(f*b-h*g)-u*(r*b-a*g)+v*(r*h-a*f)),t[10]=n*(s*b-l*g)-o*(r*b-a*g)+v*(r*l-a*s),t[11]=-(n*(s*h-l*f)-o*(r*h-a*f)+u*(r*l-a*s)),t[12]=-(o*(f*y-d*g)-u*(s*y-c*g)+v*(s*d-c*f)),t[13]=n*(f*y-d*g)-u*(r*y-i*g)+v*(r*d-i*f),t[14]=-(n*(s*y-c*g)-o*(r*y-i*g)+v*(r*c-i*s)),t[15]=n*(s*d-c*f)-o*(r*d-i*f)+u*(r*c-i*s),t}function $u(t){var e=t[0],n=t[1],r=t[2],i=t[3],a=t[4],o=t[5],s=t[6],c=t[7],l=t[8],u=t[9],f=t[10],d=t[11],h=t[12],v=t[13],g=t[14],y=t[15],b=e*o-n*a,x=e*s-r*a,_=e*c-i*a,w=n*s-r*o,O=n*c-i*o,E=r*c-i*s,M=l*v-u*h,k=l*g-f*h,A=l*y-d*h,P=u*g-f*v,C=u*y-d*v,N=f*y-d*g;return b*N-x*C+_*P+w*A-O*k+E*M}function Gn(t,e,n){var r=e[0],i=e[1],a=e[2],o=e[3],s=e[4],c=e[5],l=e[6],u=e[7],f=e[8],d=e[9],h=e[10],v=e[11],g=e[12],y=e[13],b=e[14],x=e[15],_=n[0],w=n[1],O=n[2],E=n[3];return t[0]=_*r+w*s+O*f+E*g,t[1]=_*i+w*c+O*d+E*y,t[2]=_*a+w*l+O*h+E*b,t[3]=_*o+w*u+O*v+E*x,_=n[4],w=n[5],O=n[6],E=n[7],t[4]=_*r+w*s+O*f+E*g,t[5]=_*i+w*c+O*d+E*y,t[6]=_*a+w*l+O*h+E*b,t[7]=_*o+w*u+O*v+E*x,_=n[8],w=n[9],O=n[10],E=n[11],t[8]=_*r+w*s+O*f+E*g,t[9]=_*i+w*c+O*d+E*y,t[10]=_*a+w*l+O*h+E*b,t[11]=_*o+w*u+O*v+E*x,_=n[12],w=n[13],O=n[14],E=n[15],t[12]=_*r+w*s+O*f+E*g,t[13]=_*i+w*c+O*d+E*y,t[14]=_*a+w*l+O*h+E*b,t[15]=_*o+w*u+O*v+E*x,t}function Ns(t,e,n){var r=n[0],i=n[1],a=n[2],o,s,c,l,u,f,d,h,v,g,y,b;return e===t?(t[12]=e[0]*r+e[4]*i+e[8]*a+e[12],t[13]=e[1]*r+e[5]*i+e[9]*a+e[13],t[14]=e[2]*r+e[6]*i+e[10]*a+e[14],t[15]=e[3]*r+e[7]*i+e[11]*a+e[15]):(o=e[0],s=e[1],c=e[2],l=e[3],u=e[4],f=e[5],d=e[6],h=e[7],v=e[8],g=e[9],y=e[10],b=e[11],t[0]=o,t[1]=s,t[2]=c,t[3]=l,t[4]=u,t[5]=f,t[6]=d,t[7]=h,t[8]=v,t[9]=g,t[10]=y,t[11]=b,t[12]=o*r+u*i+v*a+e[12],t[13]=s*r+f*i+g*a+e[13],t[14]=c*r+d*i+y*a+e[14],t[15]=l*r+h*i+b*a+e[15]),t}function Ud(t,e,n){var r=n[0],i=n[1],a=n[2];return t[0]=e[0]*r,t[1]=e[1]*r,t[2]=e[2]*r,t[3]=e[3]*r,t[4]=e[4]*i,t[5]=e[5]*i,t[6]=e[6]*i,t[7]=e[7]*i,t[8]=e[8]*a,t[9]=e[9]*a,t[10]=e[10]*a,t[11]=e[11]*a,t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15],t}function pv(t,e,n,r){var i=r[0],a=r[1],o=r[2],s=Math.hypot(i,a,o),c,l,u,f,d,h,v,g,y,b,x,_,w,O,E,M,k,A,P,C,N,L,R,I;return s<un?null:(s=1/s,i*=s,a*=s,o*=s,c=Math.sin(n),l=Math.cos(n),u=1-l,f=e[0],d=e[1],h=e[2],v=e[3],g=e[4],y=e[5],b=e[6],x=e[7],_=e[8],w=e[9],O=e[10],E=e[11],M=i*i*u+l,k=a*i*u+o*c,A=o*i*u-a*c,P=i*a*u-o*c,C=a*a*u+l,N=o*a*u+i*c,L=i*o*u+a*c,R=a*o*u-i*c,I=o*o*u+l,t[0]=f*M+g*k+_*A,t[1]=d*M+y*k+w*A,t[2]=h*M+b*k+O*A,t[3]=v*M+x*k+E*A,t[4]=f*P+g*C+_*N,t[5]=d*P+y*C+w*N,t[6]=h*P+b*C+O*N,t[7]=v*P+x*C+E*N,t[8]=f*L+g*R+_*I,t[9]=d*L+y*R+w*I,t[10]=h*L+b*R+O*I,t[11]=v*L+x*R+E*I,e!==t&&(t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15]),t)}function qd(t,e,n){var r=Math.sin(n),i=Math.cos(n),a=e[4],o=e[5],s=e[6],c=e[7],l=e[8],u=e[9],f=e[10],d=e[11];return e!==t&&(t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15]),t[4]=a*i+l*r,t[5]=o*i+u*r,t[6]=s*i+f*r,t[7]=c*i+d*r,t[8]=l*i-a*r,t[9]=u*i-o*r,t[10]=f*i-s*r,t[11]=d*i-c*r,t}function Kd(t,e,n){var r=Math.sin(n),i=Math.cos(n),a=e[0],o=e[1],s=e[2],c=e[3],l=e[8],u=e[9],f=e[10],d=e[11];return e!==t&&(t[4]=e[4],t[5]=e[5],t[6]=e[6],t[7]=e[7],t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15]),t[0]=a*i-l*r,t[1]=o*i-u*r,t[2]=s*i-f*r,t[3]=c*i-d*r,t[8]=a*r+l*i,t[9]=o*r+u*i,t[10]=s*r+f*i,t[11]=c*r+d*i,t}function vv(t,e,n){var r=Math.sin(n),i=Math.cos(n),a=e[0],o=e[1],s=e[2],c=e[3],l=e[4],u=e[5],f=e[6],d=e[7];return e!==t&&(t[8]=e[8],t[9]=e[9],t[10]=e[10],t[11]=e[11],t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15]),t[0]=a*i+l*r,t[1]=o*i+u*r,t[2]=s*i+f*r,t[3]=c*i+d*r,t[4]=l*i-a*r,t[5]=u*i-o*r,t[6]=f*i-s*r,t[7]=d*i-c*r,t}function Lr(t,e){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=e[0],t[13]=e[1],t[14]=e[2],t[15]=1,t}function Is(t,e){return t[0]=e[0],t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=e[1],t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=e[2],t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function ua(t,e,n){var r=n[0],i=n[1],a=n[2],o=Math.hypot(r,i,a),s,c,l;return o<un?null:(o=1/o,r*=o,i*=o,a*=o,s=Math.sin(e),c=Math.cos(e),l=1-c,t[0]=r*r*l+c,t[1]=i*r*l+a*s,t[2]=a*r*l-i*s,t[3]=0,t[4]=r*i*l-a*s,t[5]=i*i*l+c,t[6]=a*i*l+r*s,t[7]=0,t[8]=r*a*l+i*s,t[9]=i*a*l-r*s,t[10]=a*a*l+c,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t)}function gv(t,e){var n=Math.sin(e),r=Math.cos(e);return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=r,t[6]=n,t[7]=0,t[8]=0,t[9]=-n,t[10]=r,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function Qd(t,e){var n=Math.sin(e),r=Math.cos(e);return t[0]=r,t[1]=0,t[2]=-n,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=n,t[9]=0,t[10]=r,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function Qa(t,e){var n=Math.sin(e),r=Math.cos(e);return t[0]=r,t[1]=n,t[2]=0,t[3]=0,t[4]=-n,t[5]=r,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function Ml(t,e,n){var r=e[0],i=e[1],a=e[2],o=e[3],s=r+r,c=i+i,l=a+a,u=r*s,f=r*c,d=r*l,h=i*c,v=i*l,g=a*l,y=o*s,b=o*c,x=o*l;return t[0]=1-(h+g),t[1]=f+x,t[2]=d-b,t[3]=0,t[4]=f-x,t[5]=1-(u+g),t[6]=v+y,t[7]=0,t[8]=d+b,t[9]=v-y,t[10]=1-(u+h),t[11]=0,t[12]=n[0],t[13]=n[1],t[14]=n[2],t[15]=1,t}function Jd(t,e){var n=new Hn(3),r=-e[0],i=-e[1],a=-e[2],o=e[3],s=e[4],c=e[5],l=e[6],u=e[7],f=r*r+i*i+a*a+o*o;return f>0?(n[0]=(s*o+u*r+c*a-l*i)*2/f,n[1]=(c*o+u*i+l*r-s*a)*2/f,n[2]=(l*o+u*a+s*i-c*r)*2/f):(n[0]=(s*o+u*r+c*a-l*i)*2,n[1]=(c*o+u*i+l*r-s*a)*2,n[2]=(l*o+u*a+s*i-c*r)*2),Ml(t,e,n),t}function $n(t,e){return t[0]=e[12],t[1]=e[13],t[2]=e[14],t}function fa(t,e){var n=e[0],r=e[1],i=e[2],a=e[4],o=e[5],s=e[6],c=e[8],l=e[9],u=e[10];return t[0]=Math.hypot(n,r,i),t[1]=Math.hypot(a,o,s),t[2]=Math.hypot(c,l,u),t}function Pc(t,e){var n=new Hn(3);fa(n,e);var r=1/n[0],i=1/n[1],a=1/n[2],o=e[0]*r,s=e[1]*i,c=e[2]*a,l=e[4]*r,u=e[5]*i,f=e[6]*a,d=e[8]*r,h=e[9]*i,v=e[10]*a,g=o+u+v,y=0;return g>0?(y=Math.sqrt(g+1)*2,t[3]=.25*y,t[0]=(f-h)/y,t[1]=(d-c)/y,t[2]=(s-l)/y):o>u&&o>v?(y=Math.sqrt(1+o-u-v)*2,t[3]=(f-h)/y,t[0]=.25*y,t[1]=(s+l)/y,t[2]=(d+c)/y):u>v?(y=Math.sqrt(1+u-o-v)*2,t[3]=(d-c)/y,t[0]=(s+l)/y,t[1]=.25*y,t[2]=(f+h)/y):(y=Math.sqrt(1+v-o-u)*2,t[3]=(s-l)/y,t[0]=(d+c)/y,t[1]=(f+h)/y,t[2]=.25*y),t}function wb(t,e,n,r){var i=e[0],a=e[1],o=e[2],s=e[3],c=i+i,l=a+a,u=o+o,f=i*c,d=i*l,h=i*u,v=a*l,g=a*u,y=o*u,b=s*c,x=s*l,_=s*u,w=r[0],O=r[1],E=r[2];return t[0]=(1-(v+y))*w,t[1]=(d+_)*w,t[2]=(h-x)*w,t[3]=0,t[4]=(d-_)*O,t[5]=(1-(f+y))*O,t[6]=(g+b)*O,t[7]=0,t[8]=(h+x)*E,t[9]=(g-b)*E,t[10]=(1-(f+v))*E,t[11]=0,t[12]=n[0],t[13]=n[1],t[14]=n[2],t[15]=1,t}function Ds(t,e,n,r,i){var a=e[0],o=e[1],s=e[2],c=e[3],l=a+a,u=o+o,f=s+s,d=a*l,h=a*u,v=a*f,g=o*u,y=o*f,b=s*f,x=c*l,_=c*u,w=c*f,O=r[0],E=r[1],M=r[2],k=i[0],A=i[1],P=i[2],C=(1-(g+b))*O,N=(h+w)*O,L=(v-_)*O,R=(h-w)*E,I=(1-(d+b))*E,D=(y+x)*E,G=(v+_)*M,F=(y-x)*M,W=(1-(d+g))*M;return t[0]=C,t[1]=N,t[2]=L,t[3]=0,t[4]=R,t[5]=I,t[6]=D,t[7]=0,t[8]=G,t[9]=F,t[10]=W,t[11]=0,t[12]=n[0]+k-(C*k+R*A+G*P),t[13]=n[1]+A-(N*k+I*A+F*P),t[14]=n[2]+P-(L*k+D*A+W*P),t[15]=1,t}function th(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=n+n,s=r+r,c=i+i,l=n*o,u=r*o,f=r*s,d=i*o,h=i*s,v=i*c,g=a*o,y=a*s,b=a*c;return t[0]=1-f-v,t[1]=u+b,t[2]=d-y,t[3]=0,t[4]=u-b,t[5]=1-l-v,t[6]=h+g,t[7]=0,t[8]=d+y,t[9]=h-g,t[10]=1-l-f,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t}function Ob(t,e,n,r,i,a,o){var s=1/(n-e),c=1/(i-r),l=1/(a-o);return t[0]=a*2*s,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=a*2*c,t[6]=0,t[7]=0,t[8]=(n+e)*s,t[9]=(i+r)*c,t[10]=(o+a)*l,t[11]=-1,t[12]=0,t[13]=0,t[14]=o*a*2*l,t[15]=0,t}function yv(t,e,n,r,i){var a=1/Math.tan(e/2),o;return t[0]=a/n,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=a,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,i!=null&&i!==1/0?(o=1/(r-i),t[10]=(i+r)*o,t[14]=2*i*r*o):(t[10]=-1,t[14]=-2*r),t}var mv=yv;function Zu(t,e,n,r,i){var a=1/Math.tan(e/2),o;return t[0]=a/n,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=a,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[11]=-1,t[12]=0,t[13]=0,t[15]=0,i!=null&&i!==1/0?(o=1/(r-i),t[10]=i*o,t[14]=i*r*o):(t[10]=-1,t[14]=-r),t}function Cc(t,e,n,r){var i=Math.tan(e.upDegrees*Math.PI/180),a=Math.tan(e.downDegrees*Math.PI/180),o=Math.tan(e.leftDegrees*Math.PI/180),s=Math.tan(e.rightDegrees*Math.PI/180),c=2/(o+s),l=2/(i+a);return t[0]=c,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=l,t[6]=0,t[7]=0,t[8]=-((o-s)*c*.5),t[9]=(i-a)*l*.5,t[10]=r/(n-r),t[11]=-1,t[12]=0,t[13]=0,t[14]=r*n/(n-r),t[15]=0,t}function bv(t,e,n,r,i,a,o){var s=1/(e-n),c=1/(r-i),l=1/(a-o);return t[0]=-2*s,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*c,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=2*l,t[11]=0,t[12]=(e+n)*s,t[13]=(i+r)*c,t[14]=(o+a)*l,t[15]=1,t}var eh=bv;function nh(t,e,n,r,i,a,o){var s=1/(e-n),c=1/(r-i),l=1/(a-o);return t[0]=-2*s,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*c,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=l,t[11]=0,t[12]=(e+n)*s,t[13]=(i+r)*c,t[14]=a*l,t[15]=1,t}function Yu(t,e,n,r){var i,a,o,s,c,l,u,f,d,h,v=e[0],g=e[1],y=e[2],b=r[0],x=r[1],_=r[2],w=n[0],O=n[1],E=n[2];return Math.abs(v-w)<un&&Math.abs(g-O)<un&&Math.abs(y-E)<un?lr(t):(u=v-w,f=g-O,d=y-E,h=1/Math.hypot(u,f,d),u*=h,f*=h,d*=h,i=x*d-_*f,a=_*u-b*d,o=b*f-x*u,h=Math.hypot(i,a,o),h?(h=1/h,i*=h,a*=h,o*=h):(i=0,a=0,o=0),s=f*o-d*a,c=d*i-u*o,l=u*a-f*i,h=Math.hypot(s,c,l),h?(h=1/h,s*=h,c*=h,l*=h):(s=0,c=0,l=0),t[0]=i,t[1]=s,t[2]=u,t[3]=0,t[4]=a,t[5]=c,t[6]=f,t[7]=0,t[8]=o,t[9]=l,t[10]=d,t[11]=0,t[12]=-(i*v+a*g+o*y),t[13]=-(s*v+c*g+l*y),t[14]=-(u*v+f*g+d*y),t[15]=1,t)}function rh(t,e,n,r){var i=e[0],a=e[1],o=e[2],s=r[0],c=r[1],l=r[2],u=i-n[0],f=a-n[1],d=o-n[2],h=u*u+f*f+d*d;h>0&&(h=1/Math.sqrt(h),u*=h,f*=h,d*=h);var v=c*d-l*f,g=l*u-s*d,y=s*f-c*u;return h=v*v+g*g+y*y,h>0&&(h=1/Math.sqrt(h),v*=h,g*=h,y*=h),t[0]=v,t[1]=g,t[2]=y,t[3]=0,t[4]=f*y-d*g,t[5]=d*v-u*y,t[6]=u*g-f*v,t[7]=0,t[8]=u,t[9]=f,t[10]=d,t[11]=0,t[12]=i,t[13]=a,t[14]=o,t[15]=1,t}function xv(t){return"mat4("+t[0]+", "+t[1]+", "+t[2]+", "+t[3]+", "+t[4]+", "+t[5]+", "+t[6]+", "+t[7]+", "+t[8]+", "+t[9]+", "+t[10]+", "+t[11]+", "+t[12]+", "+t[13]+", "+t[14]+", "+t[15]+")"}function Sb(t){return Math.hypot(t[0],t[1],t[2],t[3],t[4],t[5],t[6],t[7],t[8],t[9],t[10],t[11],t[12],t[13],t[14],t[15])}function ih(t,e,n){return t[0]=e[0]+n[0],t[1]=e[1]+n[1],t[2]=e[2]+n[2],t[3]=e[3]+n[3],t[4]=e[4]+n[4],t[5]=e[5]+n[5],t[6]=e[6]+n[6],t[7]=e[7]+n[7],t[8]=e[8]+n[8],t[9]=e[9]+n[9],t[10]=e[10]+n[10],t[11]=e[11]+n[11],t[12]=e[12]+n[12],t[13]=e[13]+n[13],t[14]=e[14]+n[14],t[15]=e[15]+n[15],t}function Hu(t,e,n){return t[0]=e[0]-n[0],t[1]=e[1]-n[1],t[2]=e[2]-n[2],t[3]=e[3]-n[3],t[4]=e[4]-n[4],t[5]=e[5]-n[5],t[6]=e[6]-n[6],t[7]=e[7]-n[7],t[8]=e[8]-n[8],t[9]=e[9]-n[9],t[10]=e[10]-n[10],t[11]=e[11]-n[11],t[12]=e[12]-n[12],t[13]=e[13]-n[13],t[14]=e[14]-n[14],t[15]=e[15]-n[15],t}function Eb(t,e,n){return t[0]=e[0]*n,t[1]=e[1]*n,t[2]=e[2]*n,t[3]=e[3]*n,t[4]=e[4]*n,t[5]=e[5]*n,t[6]=e[6]*n,t[7]=e[7]*n,t[8]=e[8]*n,t[9]=e[9]*n,t[10]=e[10]*n,t[11]=e[11]*n,t[12]=e[12]*n,t[13]=e[13]*n,t[14]=e[14]*n,t[15]=e[15]*n,t}function _v(t,e,n,r){return t[0]=e[0]+n[0]*r,t[1]=e[1]+n[1]*r,t[2]=e[2]+n[2]*r,t[3]=e[3]+n[3]*r,t[4]=e[4]+n[4]*r,t[5]=e[5]+n[5]*r,t[6]=e[6]+n[6]*r,t[7]=e[7]+n[7]*r,t[8]=e[8]+n[8]*r,t[9]=e[9]+n[9]*r,t[10]=e[10]+n[10]*r,t[11]=e[11]+n[11]*r,t[12]=e[12]+n[12]*r,t[13]=e[13]+n[13]*r,t[14]=e[14]+n[14]*r,t[15]=e[15]+n[15]*r,t}function ki(t,e){return t[0]===e[0]&&t[1]===e[1]&&t[2]===e[2]&&t[3]===e[3]&&t[4]===e[4]&&t[5]===e[5]&&t[6]===e[6]&&t[7]===e[7]&&t[8]===e[8]&&t[9]===e[9]&&t[10]===e[10]&&t[11]===e[11]&&t[12]===e[12]&&t[13]===e[13]&&t[14]===e[14]&&t[15]===e[15]}function ah(t,e){var n=t[0],r=t[1],i=t[2],a=t[3],o=t[4],s=t[5],c=t[6],l=t[7],u=t[8],f=t[9],d=t[10],h=t[11],v=t[12],g=t[13],y=t[14],b=t[15],x=e[0],_=e[1],w=e[2],O=e[3],E=e[4],M=e[5],k=e[6],A=e[7],P=e[8],C=e[9],N=e[10],L=e[11],R=e[12],I=e[13],D=e[14],G=e[15];return Math.abs(n-x)<=un*Math.max(1,Math.abs(n),Math.abs(x))&&Math.abs(r-_)<=un*Math.max(1,Math.abs(r),Math.abs(_))&&Math.abs(i-w)<=un*Math.max(1,Math.abs(i),Math.abs(w))&&Math.abs(a-O)<=un*Math.max(1,Math.abs(a),Math.abs(O))&&Math.abs(o-E)<=un*Math.max(1,Math.abs(o),Math.abs(E))&&Math.abs(s-M)<=un*Math.max(1,Math.abs(s),Math.abs(M))&&Math.abs(c-k)<=un*Math.max(1,Math.abs(c),Math.abs(k))&&Math.abs(l-A)<=un*Math.max(1,Math.abs(l),Math.abs(A))&&Math.abs(u-P)<=un*Math.max(1,Math.abs(u),Math.abs(P))&&Math.abs(f-C)<=un*Math.max(1,Math.abs(f),Math.abs(C))&&Math.abs(d-N)<=un*Math.max(1,Math.abs(d),Math.abs(N))&&Math.abs(h-L)<=un*Math.max(1,Math.abs(h),Math.abs(L))&&Math.abs(v-R)<=un*Math.max(1,Math.abs(v),Math.abs(R))&&Math.abs(g-I)<=un*Math.max(1,Math.abs(g),Math.abs(I))&&Math.abs(y-D)<=un*Math.max(1,Math.abs(y),Math.abs(D))&&Math.abs(b-G)<=un*Math.max(1,Math.abs(b),Math.abs(G))}var Lc=Gn,wv=Hu;function oh(){var t=new Hn(9);return Hn!=Float32Array&&(t[1]=0,t[2]=0,t[3]=0,t[5]=0,t[6]=0,t[7]=0),t[0]=1,t[4]=1,t[8]=1,t}function Mb(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[4],t[4]=e[5],t[5]=e[6],t[6]=e[8],t[7]=e[9],t[8]=e[10],t}function pM(t){var e=new glMatrix.ARRAY_TYPE(9);return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e[4]=t[4],e[5]=t[5],e[6]=t[6],e[7]=t[7],e[8]=t[8],e}function vM(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[4]=e[4],t[5]=e[5],t[6]=e[6],t[7]=e[7],t[8]=e[8],t}function kb(t,e,n,r,i,a,o,s,c){var l=new Hn(9);return l[0]=t,l[1]=e,l[2]=n,l[3]=r,l[4]=i,l[5]=a,l[6]=o,l[7]=s,l[8]=c,l}function gM(t,e,n,r,i,a,o,s,c,l){return t[0]=e,t[1]=n,t[2]=r,t[3]=i,t[4]=a,t[5]=o,t[6]=s,t[7]=c,t[8]=l,t}function kl(t){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=1,t[5]=0,t[6]=0,t[7]=0,t[8]=1,t}function yM(t,e){if(t===e){var n=e[1],r=e[2],i=e[5];t[1]=e[3],t[2]=e[6],t[3]=n,t[5]=e[7],t[6]=r,t[7]=i}else t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8];return t}function mM(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=e[4],s=e[5],c=e[6],l=e[7],u=e[8],f=u*o-s*l,d=-u*a+s*c,h=l*a-o*c,v=n*f+r*d+i*h;return v?(v=1/v,t[0]=f*v,t[1]=(-u*r+i*l)*v,t[2]=(s*r-i*o)*v,t[3]=d*v,t[4]=(u*n-i*c)*v,t[5]=(-s*n+i*a)*v,t[6]=h*v,t[7]=(-l*n+r*c)*v,t[8]=(o*n-r*a)*v,t):null}function Ov(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=e[4],s=e[5],c=e[6],l=e[7],u=e[8];return t[0]=o*u-s*l,t[1]=i*l-r*u,t[2]=r*s-i*o,t[3]=s*c-a*u,t[4]=n*u-i*c,t[5]=i*a-n*s,t[6]=a*l-o*c,t[7]=r*c-n*l,t[8]=n*o-r*a,t}function Ab(t){var e=t[0],n=t[1],r=t[2],i=t[3],a=t[4],o=t[5],s=t[6],c=t[7],l=t[8];return e*(l*a-o*c)+n*(-l*i+o*s)+r*(c*i-a*s)}function js(t,e,n){var r=e[0],i=e[1],a=e[2],o=e[3],s=e[4],c=e[5],l=e[6],u=e[7],f=e[8],d=n[0],h=n[1],v=n[2],g=n[3],y=n[4],b=n[5],x=n[6],_=n[7],w=n[8];return t[0]=d*r+h*o+v*l,t[1]=d*i+h*s+v*u,t[2]=d*a+h*c+v*f,t[3]=g*r+y*o+b*l,t[4]=g*i+y*s+b*u,t[5]=g*a+y*c+b*f,t[6]=x*r+_*o+w*l,t[7]=x*i+_*s+w*u,t[8]=x*a+_*c+w*f,t}function sh(t,e,n){var r=e[0],i=e[1],a=e[2],o=e[3],s=e[4],c=e[5],l=e[6],u=e[7],f=e[8],d=n[0],h=n[1];return t[0]=r,t[1]=i,t[2]=a,t[3]=o,t[4]=s,t[5]=c,t[6]=d*r+h*o+l,t[7]=d*i+h*s+u,t[8]=d*a+h*c+f,t}function bM(t,e,n){var r=e[0],i=e[1],a=e[2],o=e[3],s=e[4],c=e[5],l=e[6],u=e[7],f=e[8],d=Math.sin(n),h=Math.cos(n);return t[0]=h*r+d*o,t[1]=h*i+d*s,t[2]=h*a+d*c,t[3]=h*o-d*r,t[4]=h*s-d*i,t[5]=h*c-d*a,t[6]=l,t[7]=u,t[8]=f,t}function xM(t,e,n){var r=n[0],i=n[1];return t[0]=r*e[0],t[1]=r*e[1],t[2]=r*e[2],t[3]=i*e[3],t[4]=i*e[4],t[5]=i*e[5],t[6]=e[6],t[7]=e[7],t[8]=e[8],t}function _M(t,e){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=1,t[5]=0,t[6]=e[0],t[7]=e[1],t[8]=1,t}function Al(t,e){var n=Math.sin(e),r=Math.cos(e);return t[0]=r,t[1]=n,t[2]=0,t[3]=-n,t[4]=r,t[5]=0,t[6]=0,t[7]=0,t[8]=1,t}function Ja(t,e){return t[0]=e[0],t[1]=0,t[2]=0,t[3]=0,t[4]=e[1],t[5]=0,t[6]=0,t[7]=0,t[8]=1,t}function Tb(t,e){return t[0]=e[0],t[1]=e[1],t[2]=0,t[3]=e[2],t[4]=e[3],t[5]=0,t[6]=e[4],t[7]=e[5],t[8]=1,t}function wM(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=n+n,s=r+r,c=i+i,l=n*o,u=r*o,f=r*s,d=i*o,h=i*s,v=i*c,g=a*o,y=a*s,b=a*c;return t[0]=1-f-v,t[3]=u-b,t[6]=d+y,t[1]=u+b,t[4]=1-l-v,t[7]=h-g,t[2]=d-y,t[5]=h+g,t[8]=1-l-f,t}function OM(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=e[4],s=e[5],c=e[6],l=e[7],u=e[8],f=e[9],d=e[10],h=e[11],v=e[12],g=e[13],y=e[14],b=e[15],x=n*s-r*o,_=n*c-i*o,w=n*l-a*o,O=r*c-i*s,E=r*l-a*s,M=i*l-a*c,k=u*g-f*v,A=u*y-d*v,P=u*b-h*v,C=f*y-d*g,N=f*b-h*g,L=d*b-h*y,R=x*L-_*N+w*C+O*P-E*A+M*k;return R?(R=1/R,t[0]=(s*L-c*N+l*C)*R,t[1]=(c*P-o*L-l*A)*R,t[2]=(o*N-s*P+l*k)*R,t[3]=(i*N-r*L-a*C)*R,t[4]=(n*L-i*P+a*A)*R,t[5]=(r*P-n*N-a*k)*R,t[6]=(g*M-y*E+b*O)*R,t[7]=(y*w-v*M-b*_)*R,t[8]=(v*E-g*w+b*x)*R,t):null}function SM(t,e,n){return t[0]=2/e,t[1]=0,t[2]=0,t[3]=0,t[4]=-2/n,t[5]=0,t[6]=-1,t[7]=1,t[8]=1,t}function EM(t){return"mat3("+t[0]+", "+t[1]+", "+t[2]+", "+t[3]+", "+t[4]+", "+t[5]+", "+t[6]+", "+t[7]+", "+t[8]+")"}function MM(t){return Math.hypot(t[0],t[1],t[2],t[3],t[4],t[5],t[6],t[7],t[8])}function ch(t,e,n){return t[0]=e[0]+n[0],t[1]=e[1]+n[1],t[2]=e[2]+n[2],t[3]=e[3]+n[3],t[4]=e[4]+n[4],t[5]=e[5]+n[5],t[6]=e[6]+n[6],t[7]=e[7]+n[7],t[8]=e[8]+n[8],t}function ot(t,e,n){return t[0]=e[0]-n[0],t[1]=e[1]-n[1],t[2]=e[2]-n[2],t[3]=e[3]-n[3],t[4]=e[4]-n[4],t[5]=e[5]-n[5],t[6]=e[6]-n[6],t[7]=e[7]-n[7],t[8]=e[8]-n[8],t}function _t(t,e,n){return t[0]=e[0]*n,t[1]=e[1]*n,t[2]=e[2]*n,t[3]=e[3]*n,t[4]=e[4]*n,t[5]=e[5]*n,t[6]=e[6]*n,t[7]=e[7]*n,t[8]=e[8]*n,t}function vt(t,e,n,r){return t[0]=e[0]+n[0]*r,t[1]=e[1]+n[1]*r,t[2]=e[2]+n[2]*r,t[3]=e[3]+n[3]*r,t[4]=e[4]+n[4]*r,t[5]=e[5]+n[5]*r,t[6]=e[6]+n[6]*r,t[7]=e[7]+n[7]*r,t[8]=e[8]+n[8]*r,t}function se(t,e){return t[0]===e[0]&&t[1]===e[1]&&t[2]===e[2]&&t[3]===e[3]&&t[4]===e[4]&&t[5]===e[5]&&t[6]===e[6]&&t[7]===e[7]&&t[8]===e[8]}function ze(t,e){var n=t[0],r=t[1],i=t[2],a=t[3],o=t[4],s=t[5],c=t[6],l=t[7],u=t[8],f=e[0],d=e[1],h=e[2],v=e[3],g=e[4],y=e[5],b=e[6],x=e[7],_=e[8];return Math.abs(n-f)<=glMatrix.EPSILON*Math.max(1,Math.abs(n),Math.abs(f))&&Math.abs(r-d)<=glMatrix.EPSILON*Math.max(1,Math.abs(r),Math.abs(d))&&Math.abs(i-h)<=glMatrix.EPSILON*Math.max(1,Math.abs(i),Math.abs(h))&&Math.abs(a-v)<=glMatrix.EPSILON*Math.max(1,Math.abs(a),Math.abs(v))&&Math.abs(o-g)<=glMatrix.EPSILON*Math.max(1,Math.abs(o),Math.abs(g))&&Math.abs(s-y)<=glMatrix.EPSILON*Math.max(1,Math.abs(s),Math.abs(y))&&Math.abs(c-b)<=glMatrix.EPSILON*Math.max(1,Math.abs(c),Math.abs(b))&&Math.abs(l-x)<=glMatrix.EPSILON*Math.max(1,Math.abs(l),Math.abs(x))&&Math.abs(u-_)<=glMatrix.EPSILON*Math.max(1,Math.abs(u),Math.abs(_))}var Sn=null,ei=null;function je(){var t=new Hn(4);return Hn!=Float32Array&&(t[0]=0,t[1]=0,t[2]=0),t[3]=1,t}function Sv(t){return t[0]=0,t[1]=0,t[2]=0,t[3]=1,t}function qo(t,e,n){n=n*.5;var r=Math.sin(n);return t[0]=r*e[0],t[1]=r*e[1],t[2]=r*e[2],t[3]=Math.cos(n),t}function Ia(t,e){var n=Math.acos(e[3])*2,r=Math.sin(n/2);return r>glMatrix.EPSILON?(t[0]=e[0]/r,t[1]=e[1]/r,t[2]=e[2]/r):(t[0]=1,t[1]=0,t[2]=0),n}function lh(t,e){var n=Vu(t,e);return Math.acos(2*n*n-1)}function Ko(t,e,n){var r=e[0],i=e[1],a=e[2],o=e[3],s=n[0],c=n[1],l=n[2],u=n[3];return t[0]=r*u+o*s+i*l-a*c,t[1]=i*u+o*c+a*s-r*l,t[2]=a*u+o*l+r*c-i*s,t[3]=o*u-r*s-i*c-a*l,t}function Tl(t,e,n){n*=.5;var r=e[0],i=e[1],a=e[2],o=e[3],s=Math.sin(n),c=Math.cos(n);return t[0]=r*c+o*s,t[1]=i*c+a*s,t[2]=a*c-i*s,t[3]=o*c-r*s,t}function uh(t,e,n){n*=.5;var r=e[0],i=e[1],a=e[2],o=e[3],s=Math.sin(n),c=Math.cos(n);return t[0]=r*c-a*s,t[1]=i*c+o*s,t[2]=a*c+r*s,t[3]=o*c-i*s,t}function fh(t,e,n){n*=.5;var r=e[0],i=e[1],a=e[2],o=e[3],s=Math.sin(n),c=Math.cos(n);return t[0]=r*c+i*s,t[1]=i*c-r*s,t[2]=a*c+o*s,t[3]=o*c-a*s,t}function Fn(t,e){var n=e[0],r=e[1],i=e[2];return t[0]=n,t[1]=r,t[2]=i,t[3]=Math.sqrt(Math.abs(1-n*n-r*r-i*i)),t}function Pb(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=Math.sqrt(n*n+r*r+i*i),s=Math.exp(a),c=o>0?s*Math.sin(o)/o:0;return t[0]=n*c,t[1]=r*c,t[2]=i*c,t[3]=s*Math.cos(o),t}function Ev(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=Math.sqrt(n*n+r*r+i*i),s=o>0?Math.atan2(o,a)/o:0;return t[0]=n*s,t[1]=r*s,t[2]=i*s,t[3]=.5*Math.log(n*n+r*r+i*i+a*a),t}function dh(t,e,n){return Ev(t,e),Bs(t,t,n),Pb(t,t),t}function hh(t,e,n,r){var i=e[0],a=e[1],o=e[2],s=e[3],c=n[0],l=n[1],u=n[2],f=n[3],d,h,v,g,y;return h=i*c+a*l+o*u+s*f,h<0&&(h=-h,c=-c,l=-l,u=-u,f=-f),1-h>un?(d=Math.acos(h),v=Math.sin(d),g=Math.sin((1-r)*d)/v,y=Math.sin(r*d)/v):(g=1-r,y=r),t[0]=g*i+y*c,t[1]=g*a+y*l,t[2]=g*o+y*u,t[3]=g*s+y*f,t}function kM(t){var e=glMatrix.RANDOM(),n=glMatrix.RANDOM(),r=glMatrix.RANDOM(),i=Math.sqrt(1-e),a=Math.sqrt(e);return t[0]=i*Math.sin(2*Math.PI*n),t[1]=i*Math.cos(2*Math.PI*n),t[2]=a*Math.sin(2*Math.PI*r),t[3]=a*Math.cos(2*Math.PI*r),t}function ph(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=n*n+r*r+i*i+a*a,s=o?1/o:0;return t[0]=-n*s,t[1]=-r*s,t[2]=-i*s,t[3]=a*s,t}function vh(t,e){return t[0]=-e[0],t[1]=-e[1],t[2]=-e[2],t[3]=e[3],t}function Qo(t,e){var n=e[0]+e[4]+e[8],r;if(n>0)r=Math.sqrt(n+1),t[3]=.5*r,r=.5/r,t[0]=(e[5]-e[7])*r,t[1]=(e[6]-e[2])*r,t[2]=(e[1]-e[3])*r;else{var i=0;e[4]>e[0]&&(i=1),e[8]>e[i*3+i]&&(i=2);var a=(i+1)%3,o=(i+2)%3;r=Math.sqrt(e[i*3+i]-e[a*3+a]-e[o*3+o]+1),t[i]=.5*r,r=.5/r,t[3]=(e[a*3+o]-e[o*3+a])*r,t[a]=(e[a*3+i]+e[i*3+a])*r,t[o]=(e[o*3+i]+e[i*3+o])*r}return t}function Fs(t,e,n,r){var i=.5*Math.PI/180;e*=i,n*=i,r*=i;var a=Math.sin(e),o=Math.cos(e),s=Math.sin(n),c=Math.cos(n),l=Math.sin(r),u=Math.cos(r);return t[0]=a*c*u-o*s*l,t[1]=o*s*u+a*c*l,t[2]=o*c*l-a*s*u,t[3]=o*c*u+a*s*l,t}function Cb(t){return"quat("+t[0]+", "+t[1]+", "+t[2]+", "+t[3]+")"}var gh=Nt,Mv=he,Pl=ne,Cl=pe,Lb=Ut,Rc=Ko,Bs=wn,Vu=Ka,AM=uv,TM=_a,PM=null,yh=Cr,mh=null,Nc=Rs,CM=xb,Rb=_b,LM=function(){var t=me(),e=sn(1,0,0),n=sn(0,1,0);return function(r,i,a){var o=la(i,a);return o<-.999999?(Mc(t,e,i),ie(t)<1e-6&&Mc(t,n,i),xa(t,t),qo(r,t,Math.PI),r):o>.999999?(r[0]=0,r[1]=0,r[2]=0,r[3]=1,r):(Mc(t,i,a),r[0]=t[0],r[1]=t[1],r[2]=t[2],r[3]=1+o,Nc(r,r))}}(),RM=function(){var t=je(),e=je();return function(n,r,i,a,o,s){return hh(t,r,o,s),hh(e,i,a,s),hh(n,t,e,2*s*(1-s)),n}}(),ni=function(){var t=oh();return function(e,n,r,i){return t[0]=r[0],t[3]=r[1],t[6]=r[2],t[1]=i[0],t[4]=i[1],t[7]=i[2],t[2]=-n[0],t[5]=-n[1],t[8]=-n[2],Nc(e,Qo(e,t))}}();function ri(){var t=new Hn(2);return Hn!=Float32Array&&(t[0]=0,t[1]=0),t}function NM(t){var e=new glMatrix.ARRAY_TYPE(2);return e[0]=t[0],e[1]=t[1],e}function IM(t,e){var n=new glMatrix.ARRAY_TYPE(2);return n[0]=t,n[1]=e,n}function kv(t,e){return t[0]=e[0],t[1]=e[1],t}function Nb(t,e,n){return t[0]=e,t[1]=n,t}function Av(t,e,n){return t[0]=e[0]+n[0],t[1]=e[1]+n[1],t}function Xu(t,e,n){return t[0]=e[0]-n[0],t[1]=e[1]-n[1],t}function Tv(t,e,n){return t[0]=e[0]*n[0],t[1]=e[1]*n[1],t}function Ll(t,e,n){return t[0]=e[0]/n[0],t[1]=e[1]/n[1],t}function Uu(t,e){return t[0]=Math.ceil(e[0]),t[1]=Math.ceil(e[1]),t}function qu(t,e){return t[0]=Math.floor(e[0]),t[1]=Math.floor(e[1]),t}function bh(t,e,n){return t[0]=Math.min(e[0],n[0]),t[1]=Math.min(e[1],n[1]),t}function Rl(t,e,n){return t[0]=Math.max(e[0],n[0]),t[1]=Math.max(e[1],n[1]),t}function DM(t,e){return t[0]=Math.round(e[0]),t[1]=Math.round(e[1]),t}function jM(t,e,n){return t[0]=e[0]*n,t[1]=e[1]*n,t}function FM(t,e,n,r){return t[0]=e[0]+n[0]*r,t[1]=e[1]+n[1]*r,t}function BM(t,e){var n=e[0]-t[0],r=e[1]-t[1];return Math.hypot(n,r)}function zM(t,e){var n=e[0]-t[0],r=e[1]-t[1];return n*n+r*r}function xh(t){var e=t[0],n=t[1];return Math.hypot(e,n)}function Ku(t){var e=t[0],n=t[1];return e*e+n*n}function Ib(t,e){return t[0]=-e[0],t[1]=-e[1],t}function Z(t,e){return t[0]=1/e[0],t[1]=1/e[1],t}function Ic(t,e){var n=e[0],r=e[1],i=n*n+r*r;return i>0&&(i=1/Math.sqrt(i)),t[0]=e[0]*i,t[1]=e[1]*i,t}function Qu(t,e){return t[0]*e[0]+t[1]*e[1]}function Da(t,e,n){var r=e[0]*n[1]-e[1]*n[0];return t[0]=t[1]=0,t[2]=r,t}function fn(t,e,n,r){var i=e[0],a=e[1];return t[0]=i+r*(n[0]-i),t[1]=a+r*(n[1]-a),t}function WM(t,e){e=e||1;var n=glMatrix.RANDOM()*2*Math.PI;return t[0]=Math.cos(n)*e,t[1]=Math.sin(n)*e,t}function GM(t,e,n){var r=e[0],i=e[1];return t[0]=n[0]*r+n[2]*i,t[1]=n[1]*r+n[3]*i,t}function $M(t,e,n){var r=e[0],i=e[1];return t[0]=n[0]*r+n[2]*i+n[4],t[1]=n[1]*r+n[3]*i+n[5],t}function Dc(t,e,n){var r=e[0],i=e[1];return t[0]=n[0]*r+n[3]*i+n[6],t[1]=n[1]*r+n[4]*i+n[7],t}function ZM(t,e,n){var r=e[0],i=e[1];return t[0]=n[0]*r+n[4]*i+n[12],t[1]=n[1]*r+n[5]*i+n[13],t}function YM(t,e,n,r){var i=e[0]-n[0],a=e[1]-n[1],o=Math.sin(r),s=Math.cos(r);return t[0]=i*s-a*o+n[0],t[1]=i*o+a*s+n[1],t}function HM(t,e){var n=t[0],r=t[1],i=e[0],a=e[1],o=Math.sqrt(n*n+r*r)*Math.sqrt(i*i+a*a),s=o&&(n*i+r*a)/o;return Math.acos(Math.min(Math.max(s,-1),1))}function VM(t){return t[0]=0,t[1]=0,t}function XM(t){return"vec2("+t[0]+", "+t[1]+")"}function No(t,e){return t[0]===e[0]&&t[1]===e[1]}function UM(t,e){var n=t[0],r=t[1],i=e[0],a=e[1];return Math.abs(n-i)<=glMatrix.EPSILON*Math.max(1,Math.abs(n),Math.abs(i))&&Math.abs(r-a)<=glMatrix.EPSILON*Math.max(1,Math.abs(r),Math.abs(a))}var qM=null,KM=null,QM=null,JM=null,Jo=null,tk=null,ek=null,nk=function(){var t=ri();return function(e,n,r,i,a,o){var s,c;for(n||(n=2),r||(r=0),i?c=Math.min(i*n+r,e.length):c=e.length,s=r;s<c;s+=n)t[0]=e[s],t[1]=e[s+1],a(t,t,o),e[s]=t[0],e[s+1]=t[1];return e}}();function Vn(t){return typeof t=="number"}function Zi(t,e){return Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1]))}function ge(t){return t==null}function ir(t){return typeof t=="string"}var Db=function(t,e,n){return t<e?e:t>n?n:t},mn=Db,_h=function(t,e){return _h=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(n,r){n.__proto__=r}||function(n,r){for(var i in r)Object.prototype.hasOwnProperty.call(r,i)&&(n[i]=r[i])},_h(t,e)};function ar(t,e){if(typeof e!="function"&&e!==null)throw new TypeError("Class extends value "+String(e)+" is not a constructor or null");_h(t,e);function n(){this.constructor=t}t.prototype=e===null?Object.create(e):(n.prototype=e.prototype,new n)}var At=function(){return At=Object.assign||function(e){for(var n,r=1,i=arguments.length;r<i;r++){n=arguments[r];for(var a in n)Object.prototype.hasOwnProperty.call(n,a)&&(e[a]=n[a])}return e},At.apply(this,arguments)};function $r(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n}function jb(t,e,n,r){var i=arguments.length,a=i<3?e:r===null?r=Object.getOwnPropertyDescriptor(e,n):r,o;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")a=Reflect.decorate(t,e,n,r);else for(var s=t.length-1;s>=0;s--)(o=t[s])&&(a=(i<3?o(a):i>3?o(e,n,a):o(e,n))||a);return i>3&&a&&Object.defineProperty(e,n,a),a}function Pv(t,e){return function(n,r){e(n,r,t)}}function Cv(t,e,n,r,i,a){function o(b){if(b!==void 0&&typeof b!="function")throw new TypeError("Function expected");return b}for(var s=r.kind,c=s==="getter"?"get":s==="setter"?"set":"value",l=!e&&t?r.static?t:t.prototype:null,u=e||(l?Object.getOwnPropertyDescriptor(l,r.name):{}),f,d=!1,h=n.length-1;h>=0;h--){var v={};for(var g in r)v[g]=g==="access"?{}:r[g];for(var g in r.access)v.access[g]=r.access[g];v.addInitializer=function(b){if(d)throw new TypeError("Cannot add initializers after decoration has completed");a.push(o(b||null))};var y=(0,n[h])(s==="accessor"?{get:u.get,set:u.set}:u[c],v);if(s==="accessor"){if(y===void 0)continue;if(y===null||typeof y!="object")throw new TypeError("Object expected");(f=o(y.get))&&(u.get=f),(f=o(y.set))&&(u.set=f),(f=o(y.init))&&i.unshift(f)}else(f=o(y))&&(s==="field"?i.unshift(f):u[c]=f)}l&&Object.defineProperty(l,r.name,u),d=!0}function Fb(t,e,n){for(var r=arguments.length>2,i=0;i<e.length;i++)n=r?e[i].call(t,n):e[i].call(t);return r?n:void 0}function Bb(t){return typeof t=="symbol"?t:"".concat(t)}function wh(t,e,n){return typeof e=="symbol"&&(e=e.description?"[".concat(e.description,"]"):""),Object.defineProperty(t,"name",{configurable:!0,value:n?"".concat(n," ",e):e})}function Nl(t,e){if(typeof Reflect=="object"&&typeof Reflect.metadata=="function")return Reflect.metadata(t,e)}function Ju(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})}function zb(t,e){var n={label:0,sent:function(){if(a[0]&1)throw a[1];return a[1]},trys:[],ops:[]},r,i,a,o=Object.create((typeof Iterator=="function"?Iterator:Object).prototype);return o.next=s(0),o.throw=s(1),o.return=s(2),typeof Symbol=="function"&&(o[Symbol.iterator]=function(){return this}),o;function s(l){return function(u){return c([l,u])}}function c(l){if(r)throw new TypeError("Generator is already executing.");for(;o&&(o=0,l[0]&&(n=0)),n;)try{if(r=1,i&&(a=l[0]&2?i.return:l[0]?i.throw||((a=i.return)&&a.call(i),0):i.next)&&!(a=a.call(i,l[1])).done)return a;switch(i=0,a&&(l=[l[0]&2,a.value]),l[0]){case 0:case 1:a=l;break;case 4:return n.label++,{value:l[1],done:!1};case 5:n.label++,i=l[1],l=[0];continue;case 7:l=n.ops.pop(),n.trys.pop();continue;default:if(a=n.trys,!(a=a.length>0&&a[a.length-1])&&(l[0]===6||l[0]===2)){n=0;continue}if(l[0]===3&&(!a||l[1]>a[0]&&l[1]<a[3])){n.label=l[1];break}if(l[0]===6&&n.label<a[1]){n.label=a[1],a=l;break}if(a&&n.label<a[2]){n.label=a[2],n.ops.push(l);break}a[2]&&n.ops.pop(),n.trys.pop();continue}l=e.call(t,n)}catch(u){l=[6,u],i=0}finally{r=a=0}if(l[0]&5)throw l[1];return{value:l[0]?l[1]:void 0,done:!0}}}var tf=Object.create?function(t,e,n,r){r===void 0&&(r=n);var i=Object.getOwnPropertyDescriptor(e,n);(!i||("get"in i?!e.__esModule:i.writable||i.configurable))&&(i={enumerable:!0,get:function(){return e[n]}}),Object.defineProperty(t,r,i)}:function(t,e,n,r){r===void 0&&(r=n),t[r]=e[n]};function Wb(t,e){for(var n in t)n!=="default"&&!Object.prototype.hasOwnProperty.call(e,n)&&tf(e,t,n)}function gi(t){var e=typeof Symbol=="function"&&Symbol.iterator,n=e&&t[e],r=0;if(n)return n.call(t);if(t&&typeof t.length=="number")return{next:function(){return t&&r>=t.length&&(t=void 0),{value:t&&t[r++],done:!t}}};throw new TypeError(e?"Object is not iterable.":"Symbol.iterator is not defined.")}function V(t,e){var n=typeof Symbol=="function"&&t[Symbol.iterator];if(!n)return t;var r=n.call(t),i,a=[],o;try{for(;(e===void 0||e-- >0)&&!(i=r.next()).done;)a.push(i.value)}catch(s){o={error:s}}finally{try{i&&!i.done&&(n=r.return)&&n.call(r)}finally{if(o)throw o.error}}return a}function zs(){for(var t=[],e=0;e<arguments.length;e++)t=t.concat(V(arguments[e]));return t}function wa(){for(var t=0,e=0,n=arguments.length;e<n;e++)t+=arguments[e].length;for(var r=Array(t),i=0,e=0;e<n;e++)for(var a=arguments[e],o=0,s=a.length;o<s;o++,i++)r[i]=a[o];return r}function te(t,e,n){if(n||arguments.length===2)for(var r=0,i=e.length,a;r<i;r++)(a||!(r in e))&&(a||(a=Array.prototype.slice.call(e,0,r)),a[r]=e[r]);return t.concat(a||Array.prototype.slice.call(e))}function jc(t){return this instanceof jc?(this.v=t,this):new jc(t)}function Lv(t,e,n){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var r=n.apply(t,e||[]),i,a=[];return i=Object.create((typeof AsyncIterator=="function"?AsyncIterator:Object).prototype),s("next"),s("throw"),s("return",o),i[Symbol.asyncIterator]=function(){return this},i;function o(h){return function(v){return Promise.resolve(v).then(h,f)}}function s(h,v){r[h]&&(i[h]=function(g){return new Promise(function(y,b){a.push([h,g,y,b])>1||c(h,g)})},v&&(i[h]=v(i[h])))}function c(h,v){try{l(r[h](v))}catch(g){d(a[0][3],g)}}function l(h){h.value instanceof jc?Promise.resolve(h.value.v).then(u,f):d(a[0][2],h)}function u(h){c("next",h)}function f(h){c("throw",h)}function d(h,v){h(v),a.shift(),a.length&&c(a[0][0],a[0][1])}}function Il(t){var e,n;return e={},r("next"),r("throw",function(i){throw i}),r("return"),e[Symbol.iterator]=function(){return this},e;function r(i,a){e[i]=t[i]?function(o){return(n=!n)?{value:jc(t[i](o)),done:!1}:a?a(o):o}:a}}function ts(t){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var e=t[Symbol.asyncIterator],n;return e?e.call(t):(t=typeof gi=="function"?gi(t):t[Symbol.iterator](),n={},r("next"),r("throw"),r("return"),n[Symbol.asyncIterator]=function(){return this},n);function r(a){n[a]=t[a]&&function(o){return new Promise(function(s,c){o=t[a](o),i(s,c,o.done,o.value)})}}function i(a,o,s,c){Promise.resolve(c).then(function(l){a({value:l,done:s})},o)}}function Rv(t,e){return Object.defineProperty?Object.defineProperty(t,"raw",{value:e}):t.raw=e,t}var Gb=Object.create?function(t,e){Object.defineProperty(t,"default",{enumerable:!0,value:e})}:function(t,e){t.default=e},Fc=function(t){return Fc=Object.getOwnPropertyNames||function(e){var n=[];for(var r in e)Object.prototype.hasOwnProperty.call(e,r)&&(n[n.length]=r);return n},Fc(t)};function $b(t){if(t&&t.__esModule)return t;var e={};if(t!=null)for(var n=Fc(t),r=0;r<n.length;r++)n[r]!=="default"&&tf(e,t,n[r]);return Gb(e,t),e}function Nv(t){return t&&t.__esModule?t:{default:t}}function Rr(t,e,n,r){if(n==="a"&&!r)throw new TypeError("Private accessor was defined without a getter");if(typeof e=="function"?t!==e||!r:!e.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return n==="m"?r:n==="a"?r.call(t):r?r.value:e.get(t)}function Oh(t,e,n,r,i){if(r==="m")throw new TypeError("Private method is not writable");if(r==="a"&&!i)throw new TypeError("Private accessor was defined without a setter");if(typeof e=="function"?t!==e||!i:!e.has(t))throw new TypeError("Cannot write private member to an object whose class did not declare it");return r==="a"?i.call(t,n):i?i.value=n:e.set(t,n),n}function Iv(t,e){if(e===null||typeof e!="object"&&typeof e!="function")throw new TypeError("Cannot use 'in' operator on non-object");return typeof t=="function"?e===t:t.has(e)}function to(t,e,n){if(e!=null){if(typeof e!="object"&&typeof e!="function")throw new TypeError("Object expected.");var r,i;if(n){if(!Symbol.asyncDispose)throw new TypeError("Symbol.asyncDispose is not defined.");r=e[Symbol.asyncDispose]}if(r===void 0){if(!Symbol.dispose)throw new TypeError("Symbol.dispose is not defined.");r=e[Symbol.dispose],n&&(i=r)}if(typeof r!="function")throw new TypeError("Object not disposable.");i&&(r=function(){try{i.call(this)}catch(a){return Promise.reject(a)}}),t.stack.push({value:e,dispose:r,async:n})}else n&&t.stack.push({async:!0});return e}var Sh=typeof SuppressedError=="function"?SuppressedError:function(t,e,n){var r=new Error(n);return r.name="SuppressedError",r.error=t,r.suppressed=e,r};function ef(t){function e(a){t.error=t.hasError?new Sh(a,t.error,"An error was suppressed during disposal."):a,t.hasError=!0}var n,r=0;function i(){for(;n=t.stack.pop();)try{if(!n.async&&r===1)return r=0,t.stack.push(n),Promise.resolve().then(i);if(n.dispose){var a=n.dispose.call(n.value);if(n.async)return r|=2,Promise.resolve(a).then(i,function(o){return e(o),i()})}else r|=1}catch(o){e(o)}if(r===1)return t.hasError?Promise.reject(t.error):Promise.resolve();if(t.hasError)throw t.error}return i()}function Ws(t,e){return typeof t=="string"&&/^\.\.?\//.test(t)?t.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i,function(n,r,i,a,o){return r?e?".jsx":".js":i&&(!a||!o)?n:i+a+"."+o.toLowerCase()+"js"}):t}var Zb={__extends:ar,__assign:At,__rest:$r,__decorate:jb,__param:Pv,__esDecorate:Cv,__runInitializers:Fb,__propKey:Bb,__setFunctionName:wh,__metadata:Nl,__awaiter:Ju,__generator:zb,__createBinding:tf,__exportStar:Wb,__values:gi,__read:V,__spread:zs,__spreadArrays:wa,__spreadArray:te,__await:jc,__asyncGenerator:Lv,__asyncDelegator:Il,__asyncValues:ts,__makeTemplateObject:Rv,__importStar:$b,__importDefault:Nv,__classPrivateFieldGet:Rr,__classPrivateFieldSet:Oh,__classPrivateFieldIn:Iv,__addDisposableResource:to,__disposeResources:ef,__rewriteRelativeImportExtension:Ws},Zr={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0};function nf(t){return Array.isArray(t)&&t.every(function(e){var n=e[0].toLowerCase();return Zr[n]===e.length-1&&"achlmqstvz".includes(n)})}function Dv(t){return nf(t)&&t.every(function(e){var n=e[0];return n===n.toUpperCase()})}function jv(t){return Dv(t)&&t.every(function(e){var n=e[0];return"ACLMQZ".includes(n)})}var Fv={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null};function rf(t){for(var e=t.pathValue[t.segmentStart],n=e.toLowerCase(),r=t.data;r.length>=Zr[n]&&(n==="m"&&r.length>2?(t.segments.push([e].concat(r.splice(0,2))),n="l",e=e==="m"?"l":"L"):t.segments.push([e].concat(r.splice(0,Zr[n]))),!!Zr[n]););}function Yb(t){var e=t.index,n=t.pathValue,r=n.charCodeAt(e);if(r===48){t.param=0,t.index+=1;return}if(r===49){t.param=1,t.index+=1;return}t.err='[path-util]: invalid Arc flag "'.concat(n[e],'", expecting 0 or 1 at index ').concat(e)}function Dl(t){return t>=48&&t<=57||t===43||t===45||t===46}function Gs(t){return t>=48&&t<=57}function Hb(t){var e=t.max,n=t.pathValue,r=t.index,i=r,a=!1,o=!1,s=!1,c=!1,l;if(i>=e){t.err="[path-util]: Invalid path value at index ".concat(i,', "pathValue" is missing param');return}if(l=n.charCodeAt(i),(l===43||l===45)&&(i+=1,l=n.charCodeAt(i)),!Gs(l)&&l!==46){t.err="[path-util]: Invalid path value at index ".concat(i,', "').concat(n[i],'" is not a number');return}if(l!==46){if(a=l===48,i+=1,l=n.charCodeAt(i),a&&i<e&&l&&Gs(l)){t.err="[path-util]: Invalid path value at index ".concat(r,', "').concat(n[r],'" illegal number');return}for(;i<e&&Gs(n.charCodeAt(i));)i+=1,o=!0;l=n.charCodeAt(i)}if(l===46){for(c=!0,i+=1;Gs(n.charCodeAt(i));)i+=1,s=!0;l=n.charCodeAt(i)}if(l===101||l===69){if(c&&!o&&!s){t.err="[path-util]: Invalid path value at index ".concat(i,', "').concat(n[i],'" invalid float exponent');return}if(i+=1,l=n.charCodeAt(i),(l===43||l===45)&&(i+=1),i<e&&Gs(n.charCodeAt(i)))for(;i<e&&Gs(n.charCodeAt(i));)i+=1;else{t.err="[path-util]: Invalid path value at index ".concat(i,', "').concat(n[i],'" invalid integer exponent');return}}t.index=i,t.param=+t.pathValue.slice(r,i)}function Vb(t){var e=[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279];return t===10||t===13||t===8232||t===8233||t===32||t===9||t===11||t===12||t===160||t>=5760&&e.includes(t)}function es(t){for(var e=t.pathValue,n=t.max;t.index<n&&Vb(e.charCodeAt(t.index));)t.index+=1}function Xb(t){switch(t|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}}function Ub(t){return(t|32)===97}function Eh(t){var e=t.max,n=t.pathValue,r=t.index,i=n.charCodeAt(r),a=Zr[n[r].toLowerCase()];if(t.segmentStart=r,!Xb(i)){t.err='[path-util]: Invalid path value "'.concat(n[r],'" is not a path command');return}if(t.index+=1,es(t),t.data=[],!a){rf(t);return}for(;;){for(var o=a;o>0;o-=1){if(Ub(i)&&(o===3||o===4)?Yb(t):Hb(t),t.err.length)return;t.data.push(t.param),es(t),t.index<e&&n.charCodeAt(t.index)===44&&(t.index+=1,es(t))}if(t.index>=t.max||!Dl(n.charCodeAt(t.index)))break}rf(t)}var Bv=function(){function t(e){this.pathValue=e,this.segments=[],this.max=e.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}return t}();function qb(t){if(nf(t))return[].concat(t);var e=new Bv(t);for(es(e);e.index<e.max&&!e.err.length;)Eh(e);return e.err?e.err:e.segments}function Kb(t){if(Dv(t))return[].concat(t);var e=qb(t),n=0,r=0,i=0,a=0;return e.map(function(o){var s=o.slice(1).map(Number),c=o[0],l=c.toUpperCase();if(c==="M")return n=s[0],r=s[1],i=n,a=r,["M",n,r];var u;if(c!==l)switch(l){case"A":u=[l,s[0],s[1],s[2],s[3],s[4],s[5]+n,s[6]+r];break;case"V":u=[l,s[0]+r];break;case"H":u=[l,s[0]+n];break;default:{var f=s.map(function(h,v){return h+(v%2?r:n)});u=[l].concat(f)}}else u=[l].concat(s);var d=u.length;switch(l){case"Z":n=i,r=a;break;case"H":n=u[1];break;case"V":r=u[1];break;default:n=u[d-2],r=u[d-1],l==="M"&&(i=n,a=r)}return u})}function Qb(t,e){var n=t[0],r=e.x1,i=e.y1,a=e.x2,o=e.y2,s=t.slice(1).map(Number),c=t;if("TQ".includes(n)||(e.qx=null,e.qy=null),n==="H")c=["L",t[1],i];else if(n==="V")c=["L",r,t[1]];else if(n==="S"){var l=r*2-a,u=i*2-o;e.x1=l,e.y1=u,c=["C",l,u].concat(s)}else if(n==="T"){var f=r*2-e.qx,d=i*2-e.qy;e.qx=f,e.qy=d,c=["Q",f,d].concat(s)}else if(n==="Q"){var h=s[0],v=s[1];e.qx=h,e.qy=v}return c}function jl(t){if(jv(t))return[].concat(t);for(var e=Kb(t),n=At({},Fv),r=0;r<e.length;r+=1){e[r]=Qb(e[r],n);var i=e[r],a=i.length;n.x1=+i[a-2],n.y1=+i[a-1],n.x2=+i[a-4]||n.x1,n.y2=+i[a-3]||n.y1}return e}function eo(t,e,n){var r=t[0],i=t[1],a=e[0],o=e[1];return[r+(a-r)*n,i+(o-i)*n]}function Mh(t,e,n,r,i){var a=Zi([t,e],[n,r]),o={x:0,y:0};if(typeof i=="number")if(i<=0)o={x:t,y:e};else if(i>=a)o={x:n,y:r};else{var s=eo([t,e],[n,r],i/a),c=s[0],l=s[1];o={x:c,y:l}}return{length:a,point:o,min:{x:Math.min(t,n),y:Math.min(e,r)},max:{x:Math.max(t,n),y:Math.max(e,r)}}}function af(t,e){var n=t.x,r=t.y,i=e.x,a=e.y,o=n*i+r*a,s=Math.sqrt((Math.pow(n,2)+Math.pow(r,2))*(Math.pow(i,2)+Math.pow(a,2))),c=n*a-r*i<0?-1:1,l=c*Math.acos(o/s);return l}function zv(t,e,n,r,i,a,o,s,c,l){var u=Math.abs,f=Math.sin,d=Math.cos,h=Math.sqrt,v=Math.PI,g=u(n),y=u(r),b=(i%360+360)%360,x=b*(v/180);if(t===s&&e===c)return{x:t,y:e};if(g===0||y===0)return Mh(t,e,s,c,l).point;var _=(t-s)/2,w=(e-c)/2,O={x:d(x)*_+f(x)*w,y:-f(x)*_+d(x)*w},E=Math.pow(O.x,2)/Math.pow(g,2)+Math.pow(O.y,2)/Math.pow(y,2);E>1&&(g*=h(E),y*=h(E));var M=Math.pow(g,2)*Math.pow(y,2)-Math.pow(g,2)*Math.pow(O.y,2)-Math.pow(y,2)*Math.pow(O.x,2),k=Math.pow(g,2)*Math.pow(O.y,2)+Math.pow(y,2)*Math.pow(O.x,2),A=M/k;A=A<0?0:A;var P=(a!==o?1:-1)*h(A),C={x:P*(g*O.y/y),y:P*(-(y*O.x)/g)},N={x:d(x)*C.x-f(x)*C.y+(t+s)/2,y:f(x)*C.x+d(x)*C.y+(e+c)/2},L={x:(O.x-C.x)/g,y:(O.y-C.y)/y},R=af({x:1,y:0},L),I={x:(-O.x-C.x)/g,y:(-O.y-C.y)/y},D=af(L,I);!o&&D>0?D-=2*v:o&&D<0&&(D+=2*v),D%=2*v;var G=R+D*l,F=g*d(G),W=y*f(G),X={x:d(x)*F-f(x)*W+N.x,y:f(x)*F+d(x)*W+N.y};return X}function Wv(t,e,n,r,i,a,o,s,c,l,u){var f,d=u.bbox,h=d===void 0?!0:d,v=u.length,g=v===void 0?!0:v,y=u.sampleSize,b=y===void 0?30:y,x=typeof l=="number",_=t,w=e,O=0,E=[_,w,O],M=[_,w],k=0,A={x:0,y:0},P=[{x:_,y:w}];x&&l<=0&&(A={x:_,y:w});for(var C=0;C<=b;C+=1){if(k=C/b,f=zv(t,e,n,r,i,a,o,s,c,k),_=f.x,w=f.y,h&&P.push({x:_,y:w}),g&&(O+=Zi(M,[_,w])),M=[_,w],x&&O>=l&&l>E[2]){var N=(O-l)/(O-E[2]);A={x:M[0]*(1-N)+E[0]*N,y:M[1]*(1-N)+E[1]*N}}E=[_,w,O]}return x&&l>=O&&(A={x:s,y:c}),{length:O,point:A,min:{x:Math.min.apply(null,P.map(function(L){return L.x})),y:Math.min.apply(null,P.map(function(L){return L.y}))},max:{x:Math.max.apply(null,P.map(function(L){return L.x})),y:Math.max.apply(null,P.map(function(L){return L.y}))}}}function Gv(t,e,n,r,i,a,o,s,c){var l=1-c;return{x:Math.pow(l,3)*t+3*Math.pow(l,2)*c*n+3*l*Math.pow(c,2)*i+Math.pow(c,3)*o,y:Math.pow(l,3)*e+3*Math.pow(l,2)*c*r+3*l*Math.pow(c,2)*a+Math.pow(c,3)*s}}function Fl(t,e,n,r,i,a,o,s,c,l){var u,f=l.bbox,d=f===void 0?!0:f,h=l.length,v=h===void 0?!0:h,g=l.sampleSize,y=g===void 0?10:g,b=typeof c=="number",x=t,_=e,w=0,O=[x,_,w],E=[x,_],M=0,k={x:0,y:0},A=[{x,y:_}];b&&c<=0&&(k={x,y:_});for(var P=0;P<=y;P+=1){if(M=P/y,u=Gv(t,e,n,r,i,a,o,s,M),x=u.x,_=u.y,d&&A.push({x,y:_}),v&&(w+=Zi(E,[x,_])),E=[x,_],b&&w>=c&&c>O[2]){var C=(w-c)/(w-O[2]);k={x:E[0]*(1-C)+O[0]*C,y:E[1]*(1-C)+O[1]*C}}O=[x,_,w]}return b&&c>=w&&(k={x:o,y:s}),{length:w,point:k,min:{x:Math.min.apply(null,A.map(function(N){return N.x})),y:Math.min.apply(null,A.map(function(N){return N.y}))},max:{x:Math.max.apply(null,A.map(function(N){return N.x})),y:Math.max.apply(null,A.map(function(N){return N.y}))}}}function Jb(t,e,n,r,i,a,o){var s=1-o;return{x:Math.pow(s,2)*t+2*s*o*n+Math.pow(o,2)*i,y:Math.pow(s,2)*e+2*s*o*r+Math.pow(o,2)*a}}function $v(t,e,n,r,i,a,o,s){var c,l=s.bbox,u=l===void 0?!0:l,f=s.length,d=f===void 0?!0:f,h=s.sampleSize,v=h===void 0?10:h,g=typeof o=="number",y=t,b=e,x=0,_=[y,b,x],w=[y,b],O=0,E={x:0,y:0},M=[{x:y,y:b}];g&&o<=0&&(E={x:y,y:b});for(var k=0;k<=v;k+=1){if(O=k/v,c=Jb(t,e,n,r,i,a,O),y=c.x,b=c.y,u&&M.push({x:y,y:b}),d&&(x+=Zi(w,[y,b])),w=[y,b],g&&x>=o&&o>_[2]){var A=(x-o)/(x-_[2]);E={x:w[0]*(1-A)+_[0]*A,y:w[1]*(1-A)+_[1]*A}}_=[y,b,x]}return g&&o>=x&&(E={x:i,y:a}),{length:x,point:E,min:{x:Math.min.apply(null,M.map(function(P){return P.x})),y:Math.min.apply(null,M.map(function(P){return P.y}))},max:{x:Math.max.apply(null,M.map(function(P){return P.x})),y:Math.max.apply(null,M.map(function(P){return P.y}))}}}function kh(t,e,n){for(var r,i,a,o,s,c,l=jl(t),u=typeof e=="number",f,d=[],h,v=0,g=0,y=0,b=0,x,_=[],w=[],O=0,E={x:0,y:0},M=E,k=E,A=E,P=0,C=0,N=l.length;C<N;C+=1)x=l[C],h=x[0],f=h==="M",d=f?d:[v,g].concat(x.slice(1)),f?(y=x[1],b=x[2],E={x:y,y:b},M=E,O=0,u&&e<.001&&(A=E)):h==="L"?(r=Mh(d[0],d[1],d[2],d[3],(e||0)-P),O=r.length,E=r.min,M=r.max,k=r.point):h==="A"?(i=Wv(d[0],d[1],d[2],d[3],d[4],d[5],d[6],d[7],d[8],(e||0)-P,n||{}),O=i.length,E=i.min,M=i.max,k=i.point):h==="C"?(a=Fl(d[0],d[1],d[2],d[3],d[4],d[5],d[6],d[7],(e||0)-P,n||{}),O=a.length,E=a.min,M=a.max,k=a.point):h==="Q"?(o=$v(d[0],d[1],d[2],d[3],d[4],d[5],(e||0)-P,n||{}),O=o.length,E=o.min,M=o.max,k=o.point):h==="Z"&&(d=[v,g,y,b],s=Mh(d[0],d[1],d[2],d[3],(e||0)-P),O=s.length,E=s.min,M=s.max,k=s.point),u&&P<e&&P+O>=e&&(A=k),w.push(M),_.push(E),P+=O,c=h!=="Z"?x.slice(-2):[y,b],v=c[0],g=c[1];return u&&e>=P&&(A={x:v,y:g}),{length:P,point:A,min:{x:Math.min.apply(null,_.map(function(L){return L.x})),y:Math.min.apply(null,_.map(function(L){return L.y}))},max:{x:Math.max.apply(null,w.map(function(L){return L.x})),y:Math.max.apply(null,w.map(function(L){return L.y}))}}}function tx(t,e){return kh(t,void 0,At(At({},e),{bbox:!1,length:!0})).length}function Nr(t){return Array.isArray(t)}var of=function(t){if(Nr(t))return t.reduce(function(e,n){return Math.min(e,n)},t[0])};function Bc(t){if(!Array.isArray(t))return-1/0;var e=t.length;if(!e)return-1/0;for(var n=t[0],r=1;r<e;r++)n=Math.max(n,t[r]);return n}var Zv=1e-5;function $s(t,e,n){return n===void 0&&(n=Zv),t===e||Math.abs(t-e)<n}var ex=function(t,e){return(t%e+e)%e},sf=ex;function Je(t,e,n){if(t[n].length>7){t[n].shift();for(var r=t[n],i=n;r.length;)e[n]="A",t.splice(i+=1,0,["C"].concat(r.splice(0,6)));t.splice(n,1)}}function nx(t){return jv(t)&&t.every(function(e){var n=e[0];return"MC".includes(n)})}function cf(t,e,n){var r=t*Math.cos(n)-e*Math.sin(n),i=t*Math.sin(n)+e*Math.cos(n);return{x:r,y:i}}function Zs(t,e,n,r,i,a,o,s,c,l){var u=t,f=e,d=n,h=r,v=s,g=c,y=Math.PI*120/180,b=Math.PI/180*(+i||0),x=[],_,w,O,E,M;if(l)w=l[0],O=l[1],E=l[2],M=l[3];else{_=cf(u,f,-b),u=_.x,f=_.y,_=cf(v,g,-b),v=_.x,g=_.y;var k=(u-v)/2,A=(f-g)/2,P=k*k/(d*d)+A*A/(h*h);P>1&&(P=Math.sqrt(P),d*=P,h*=P);var C=d*d,N=h*h,L=(a===o?-1:1)*Math.sqrt(Math.abs((C*N-C*A*A-N*k*k)/(C*A*A+N*k*k)));E=L*d*A/h+(u+v)/2,M=L*-h*k/d+(f+g)/2,w=Math.asin(((f-M)/h*Math.pow(10,9)>>0)/Math.pow(10,9)),O=Math.asin(((g-M)/h*Math.pow(10,9)>>0)/Math.pow(10,9)),w=u<E?Math.PI-w:w,O=v<E?Math.PI-O:O,w<0&&(w=Math.PI*2+w),O<0&&(O=Math.PI*2+O),o&&w>O&&(w-=Math.PI*2),!o&&O>w&&(O-=Math.PI*2)}var R=O-w;if(Math.abs(R)>y){var I=O,D=v,G=g;O=w+y*(o&&O>w?1:-1),v=E+d*Math.cos(O),g=M+h*Math.sin(O),x=Zs(v,g,d,h,i,0,o,D,G,[O,I,E,M])}R=O-w;var F=Math.cos(w),W=Math.sin(w),X=Math.cos(O),Q=Math.sin(O),tt=Math.tan(R/4),nt=4/3*d*tt,ht=4/3*h*tt,lt=[u,f],wt=[u+nt*W,f-ht*F],yt=[v+nt*Q,g-ht*X],gt=[v,g];if(wt[0]=2*lt[0]-wt[0],wt[1]=2*lt[1]-wt[1],l)return wt.concat(yt,gt,x);x=wt.concat(yt,gt,x);for(var Bt=[],Lt=0,It=x.length;Lt<It;Lt+=1)Bt[Lt]=Lt%2?cf(x[Lt-1],x[Lt],b).y:cf(x[Lt],x[Lt+1],b).x;return Bt}function Yv(t,e,n,r,i,a){var o=.3333333333333333,s=2/3;return[o*t+s*n,o*e+s*r,o*i+s*n,o*a+s*r,i,a]}var Hv=function(t,e,n,r){var i=.5,a=eo([t,e],[n,r],i);return te(te([],a,!0),[n,r,n,r],!1)};function rx(t,e){var n=t[0],r=t.slice(1).map(Number),i=r[0],a=r[1],o,s=e.x1,c=e.y1,l=e.x,u=e.y;switch("TQ".includes(n)||(e.qx=null,e.qy=null),n){case"M":return e.x=i,e.y=a,t;case"A":return o=[s,c].concat(r),["C"].concat(Zs(o[0],o[1],o[2],o[3],o[4],o[5],o[6],o[7],o[8],o[9]));case"Q":return e.qx=i,e.qy=a,o=[s,c].concat(r),["C"].concat(Yv(o[0],o[1],o[2],o[3],o[4],o[5]));case"L":return["C"].concat(Hv(s,c,i,a));case"Z":return s===l&&c===u?["C",s,c,l,u,l,u]:["C"].concat(Hv(s,c,l,u));default:}return t}function Yi(t,e){if(e===void 0&&(e=!1),nx(t)){var n=[].concat(t);return e?[n,[]]:n}for(var r=jl(t),i=At({},Fv),a=[],o="",s=r.length,c,l,u=[],f=0;f<s;f+=1){r[f]&&(o=r[f][0]),a[f]=o;var d=rx(r[f],i);r[f]=d,Je(r,a,f),s=r.length,o==="Z"&&u.push(f),c=r[f],l=c.length,i.x1=+c[l-2],i.y1=+c[l-1],i.x2=+c[l-4]||i.x1,i.y2=+c[l-3]||i.y1}return e?[r,u]:r}function ix(t,e){e===void 0&&(e=.5);var n=t.slice(0,2),r=t.slice(2,4),i=t.slice(4,6),a=t.slice(6,8),o=eo(n,r,e),s=eo(r,i,e),c=eo(i,a,e),l=eo(o,s,e),u=eo(s,c,e),f=eo(l,u,e);return[["C"].concat(o,l,f),["C"].concat(u,c,a)]}function Bl(t){return t.map(function(e,n,r){var i=n&&r[n-1].slice(-2).concat(e.slice(1)),a=n?Fl(i[0],i[1],i[2],i[3],i[4],i[5],i[6],i[7],i[8],{bbox:!1}).length:0,o;return n?o=a?ix(i):[e,e]:o=[e],{s:e,ss:o,l:a}})}function lf(t,e,n){var r=Bl(t),i=Bl(e),a=r.length,o=i.length,s=r.filter(function(y){return y.l}).length,c=i.filter(function(y){return y.l}).length,l=r.filter(function(y){return y.l}).reduce(function(y,b){var x=b.l;return y+x},0)/s||0,u=i.filter(function(y){return y.l}).reduce(function(y,b){var x=b.l;return y+x},0)/c||0,f=n||Math.max(a,o),d=[l,u],h=[f-a,f-o],v=0,g=[r,i].map(function(y,b){return y.l===f?y.map(function(x){return x.s}):y.map(function(x,_){return v=_&&h[b]&&x.l>=d[b],h[b]-=v?1:0,v?x.ss:[x.s]}).flat()});return g[0].length===g[1].length?g:lf(g[0],g[1],f)}function Vv(t,e,n,r,i,a,o,s){return 3*((s-e)*(n+i)-(o-t)*(r+a)+r*(t-i)-n*(e-a)+s*(i+t/3)-o*(a+e/3))/20}function Xv(t){var e=0,n=0,r=0;return Yi(t).map(function(i){var a;switch(i[0]){case"M":return e=i[1],n=i[2],0;default:var o=i.slice(1),s=o[0],c=o[1],l=o[2],u=o[3],f=o[4],d=o[5];return r=Vv(e,n,s,c,l,u,f,d),a=i.slice(-2),e=a[0],n=a[1],r}}).reduce(function(i,a){return i+a},0)}function Hi(t){return Xv(t)>=0}function ns(t){var e=t.slice(1).map(function(n,r,i){return r?i[r-1].slice(-2).concat(n.slice(1)):t[0].slice(1).concat(n.slice(1))}).map(function(n){return n.map(function(r,i){return n[n.length-i-2*(1-i%2)]})}).reverse();return[["M"].concat(e[0].slice(0,2))].concat(e.map(function(n){return["C"].concat(n.slice(2))}))}function Ah(t){return t.map(function(e){return Array.isArray(e)?[].concat(e):e})}function Uv(t){var e=t.length,n=e-1;return t.map(function(r,i){return t.map(function(a,o){var s=i+o,c;return o===0||t[s]&&t[s][0]==="M"?(c=t[s],["M"].concat(c.slice(-2))):(s>=e&&(s-=n),t[s])})})}function uf(t,e){var n=t.length-1,r=[],i=0,a=0,o=Uv(t);return o.forEach(function(s,c){t.slice(1).forEach(function(l,u){a+=Zi(t[(c+u)%n].slice(-2),e[u%n].slice(-2))}),r[c]=a,a=0}),i=r.indexOf(Math.min.apply(null,r)),o[i]}var qv=function(t){return t===void 0},En=qv,Kv={}.toString,Th=function(t,e){return Kv.call(t)==="[object "+e+"]"},ff=Th,rs=function(t){return ff(t,"Boolean")},Qv=rs;function Xn(t){return typeof t=="function"}var zl=function(t){var e=typeof t;return t!==null&&e==="object"||e==="function"};function Jv(t,e,n){return kh(t,e,At(At({},n),{bbox:!1,length:!0})).point}var Kt=pt(4942),tg=pt(61120);function ax(t,e){for(;!{}.hasOwnProperty.call(t,e)&&(t=(0,tg.Z)(t))!==null;);return t}function Ph(){return Ph=typeof Reflect!="undefined"&&Reflect.get?Reflect.get.bind():function(t,e,n){var r=ax(t,e);if(r){var i=Object.getOwnPropertyDescriptor(r,e);return i.get?i.get.call(arguments.length<3?t:n):i.value}},Ph.apply(null,arguments)}function Ch(t,e,n,r){var i=Ph((0,tg.Z)(1&r?t.prototype:t),e,n);return 2&r&&typeof i=="function"?function(a){return i.apply(n,a)}:i}function li(t,e,n,r){var i=t-n,a=e-r;return Math.sqrt(i*i+a*a)}function df(t,e){var n=Math.min.apply(Math,te([],V(t),!1)),r=Math.min.apply(Math,te([],V(e),!1)),i=Math.max.apply(Math,te([],V(t),!1)),a=Math.max.apply(Math,te([],V(e),!1));return{x:n,y:r,width:i-n,height:a-r}}function Lh(t){return(t+Math.PI*2)%(Math.PI*2)}function Rh(t,e){var n=Math.abs(t);return e>0?n:n*-1}function Vi(t,e,n,r,i,a){var o=n,s=r;if(o===0||s===0)return{x:t,y:e};for(var c=i-t,l=a-e,u=Math.abs(c),f=Math.abs(l),d=o*o,h=s*s,v=Math.PI/4,g=0,y=0,b=0;b<4;b++){g=o*Math.cos(v),y=s*Math.sin(v);var x=(d-h)*Math.pow(Math.cos(v),3)/o,_=(h-d)*Math.pow(Math.sin(v),3)/s,w=g-x,O=y-_,E=u-x,M=f-_,k=Math.hypot(O,w),A=Math.hypot(M,E),P=k*Math.asin((w*M-O*E)/(k*A)),C=P/Math.sqrt(d+h-g*g-y*y);v+=C,v=Math.min(Math.PI/2,Math.max(0,v))}return{x:t+Rh(g,c),y:e+Rh(y,l)}}function no(t,e,n,r,i,a,o,s){return-1*n*Math.cos(i)*Math.sin(s)-r*Math.sin(i)*Math.cos(s)}function ox(t,e,n,r,i,a,o,s){return-1*n*Math.sin(i)*Math.sin(s)+r*Math.cos(i)*Math.cos(s)}function sx(t,e,n){return Math.atan(-e/t*Math.tan(n))}function hf(t,e,n){return Math.atan(e/(t*Math.tan(n)))}function zc(t,e,n,r,i,a){return n*Math.cos(i)*Math.cos(a)-r*Math.sin(i)*Math.sin(a)+t}function eg(t,e,n,r,i,a){return n*Math.sin(i)*Math.cos(a)+r*Math.cos(i)*Math.sin(a)+e}function ng(t,e,n,r){var i=Math.atan2(r*t,n*e);return(i+Math.PI*2)%(Math.PI*2)}function rg(t,e,n){return{x:t*Math.cos(n),y:e*Math.sin(n)}}function Nh(t,e,n){var r=Math.cos(n),i=Math.sin(n);return[t*r-e*i,t*i+e*r]}function Wc(t,e,n,r,i,a,o){for(var s=sx(n,r,i),c=1/0,l=-1/0,u=[a,o],f=-Math.PI*2;f<=Math.PI*2;f+=Math.PI){var d=s+f;a<o?a<d&&d<o&&u.push(d):o<d&&d<a&&u.push(d)}for(var f=0;f<u.length;f++){var h=zc(t,e,n,r,i,u[f]);h<c&&(c=h),h>l&&(l=h)}for(var v=hf(n,r,i),g=1/0,y=-1/0,b=[a,o],f=-Math.PI*2;f<=Math.PI*2;f+=Math.PI){var x=v+f;a<o?a<x&&x<o&&b.push(x):o<x&&x<a&&b.push(x)}for(var f=0;f<b.length;f++){var _=eg(t,e,n,r,i,b[f]);_<g&&(g=_),_>y&&(y=_)}return{x:c,y:g,width:l-c,height:y-g}}function pf(t,e,n,r,i,a,o,s,c){var l=Nh(s-t,c-e,-i),u=__read(l,2),f=u[0],d=u[1],h=Vi(0,0,n,r,f,d),v=ng(n,r,h.x,h.y);v<a?h=rg(n,r,a):v>o&&(h=rg(n,r,o));var g=Nh(h.x,h.y,i);return{x:g[0]+t,y:g[1]+e}}function rk(t,e,n,r,i,a,o,s){var c=(o-a)*s+a,l=no(t,e,n,r,i,a,o,c),u=ox(t,e,n,r,i,a,o,c);return Lh(Math.atan2(u,l))}var ig=1e-4;function Ih(t,e,n,r,i,a){var o=-1,s=1/0,c=[n,r],l=20;a&&a>200&&(l=a/10);for(var u=1/l,f=u/10,d=0;d<=l;d++){var h=d*u,v=[i.apply(void 0,te([],V(t.concat([h])),!1)),i.apply(void 0,te([],V(e.concat([h])),!1))],g=li(c[0],c[1],v[0],v[1]);g<s&&(o=h,s=g)}if(o===0)return{x:t[0],y:e[0]};if(o===1){var y=t.length;return{x:t[y-1],y:e[y-1]}}s=1/0;for(var d=0;d<32&&!(f<ig);d++){var b=o-f,x=o+f,v=[i.apply(void 0,te([],V(t.concat([b])),!1)),i.apply(void 0,te([],V(e.concat([b])),!1))],g=li(c[0],c[1],v[0],v[1]);if(b>=0&&g<s)o=b,s=g;else{var _=[i.apply(void 0,te([],V(t.concat([x])),!1)),i.apply(void 0,te([],V(e.concat([x])),!1))],w=li(c[0],c[1],_[0],_[1]);x<=1&&w<s?(o=x,s=w):f*=.5}}return{x:i.apply(void 0,te([],V(t.concat([o])),!1)),y:i.apply(void 0,te([],V(e.concat([o])),!1))}}function vf(t,e){for(var n=0,r=t.length,i=0;i<r;i++){var a=t[i],o=e[i],s=t[(i+1)%r],c=e[(i+1)%r];n+=li(a,o,s,c)}return n/2}function cx(t,e,n,r){return df([t,n],[e,r])}function Wl(t,e,n,r){return li(t,e,n,r)}function Oa(t,e,n,r,i){return{x:(1-i)*t+i*n,y:(1-i)*e+i*r}}function gf(t,e,n,r,i,a){var o=(n-t)*(i-t)+(r-e)*(a-e);if(o<0)return li(t,e,i,a);var s=(n-t)*(n-t)+(r-e)*(r-e);return o>s?li(n,r,i,a):ag(t,e,n,r,i,a)}function ag(t,e,n,r,i,a){var o=[n-t,r-e];if(No(o,[0,0]))return Math.sqrt((i-t)*(i-t)+(a-e)*(a-e));var s=[-o[1],o[0]];Ic(s,s);var c=[i-t,a-e];return Math.abs(Qu(c,s))}function lx(t,e,n,r){return Math.atan2(r-e,n-t)}function ro(t,e,n,r,i){var a=1-i;return a*a*a*t+3*e*i*a*a+3*n*i*i*a+r*i*i*i}function Dh(t,e,n,r,i){var a=1-i;return 3*(a*a*(e-t)+2*a*i*(n-e)+i*i*(r-n))}function yf(t,e,n,r){var i=-3*t+9*e-9*n+3*r,a=6*t-12*e+6*n,o=3*e-3*t,s=[],c,l,u;if($s(i,0))$s(a,0)||(c=-o/a,c>=0&&c<=1&&s.push(c));else{var f=a*a-4*i*o;$s(f,0)?s.push(-a/(2*i)):f>0&&(u=Math.sqrt(f),c=(-a+u)/(2*i),l=(-a-u)/(2*i),c>=0&&c<=1&&s.push(c),l>=0&&l<=1&&s.push(l))}return s}function ux(t,e,n,r,i,a,o,s,c){var l=ro(t,n,i,o,c),u=ro(e,r,a,s,c),f=Oa(t,e,n,r,c),d=Oa(n,r,i,a,c),h=Oa(i,a,o,s,c),v=Oa(f.x,f.y,d.x,d.y,c),g=Oa(d.x,d.y,h.x,h.y,c);return[[t,e,f.x,f.y,v.x,v.y,l,u],[l,u,g.x,g.y,h.x,h.y,o,s]]}function mf(t,e,n,r,i,a,o,s,c){if(c===0)return vf([t,n,i,o],[e,r,a,s]);var l=ux(t,e,n,r,i,a,o,s,.5),u=__spreadArray(__spreadArray([],__read(l[0]),!1),[c-1],!1),f=__spreadArray(__spreadArray([],__read(l[1]),!1),[c-1],!1);return mf.apply(void 0,__spreadArray([],__read(u),!1))+mf.apply(void 0,__spreadArray([],__read(f),!1))}function Io(t,e,n,r,i,a,o,s){for(var c=[t,o],l=[e,s],u=yf(t,n,i,o),f=yf(e,r,a,s),d=0;d<u.length;d++)c.push(ro(t,n,i,o,u[d]));for(var d=0;d<f.length;d++)l.push(ro(e,r,a,s,f[d]));return df(c,l)}function fx(t,e,n,r,i,a,o,s){return mf(t,e,n,r,i,a,o,s,3)}function og(t,e,n,r,i,a,o,s,c,l,u){return Ih([t,n,i,o],[e,r,a,s],c,l,ro,u)}function sg(t,e,n,r,i,a,o,s,c,l,u){var f=og(t,e,n,r,i,a,o,s,c,l,u);return li(f.x,f.y,c,l)}function dx(t,e,n,r,i,a,o,s,c){return{x:ro(t,n,i,o,c),y:ro(e,r,a,s,c)}}function ik(t,e,n,r,i,a,o,s,c){var l=Dh(t,n,i,o,c),u=Dh(e,r,a,s,c);return Lh(Math.atan2(u,l))}function cg(t){for(var e=0,n=[],r=0;r<t.length-1;r++){var i=t[r],a=t[r+1],o=li(i[0],i[1],a[0],a[1]),s={from:i,to:a,length:o};n.push(s),e+=o}return{segments:n,totalLength:e}}function io(t){if(t.length<2)return 0;for(var e=0,n=0;n<t.length-1;n++){var r=t[n],i=t[n+1];e+=li(r[0],r[1],i[0],i[1])}return e}function bf(t,e){if(e>1||e<0||t.length<2)return null;var n=cg(t),r=n.segments,i=n.totalLength;if(i===0)return{x:t[0][0],y:t[0][1]};for(var a=0,o=null,s=0;s<r.length;s++){var c=r[s],l=c.from,u=c.to,f=c.length/i;if(e>=a&&e<=a+f){var d=(e-a)/f;o=Oa(l[0],l[1],u[0],u[1],d);break}a+=f}return o}function xf(t,e){if(e>1||e<0||t.length<2)return 0;for(var n=cg(t),r=n.segments,i=n.totalLength,a=0,o=0,s=0;s<r.length;s++){var c=r[s],l=c.from,u=c.to,f=c.length/i;if(e>=a&&e<=a+f){o=Math.atan2(u[1]-l[1],u[0]-l[0]);break}a+=f}return o}function _f(t,e,n){for(var r=1/0,i=0;i<t.length-1;i++){var a=t[i],o=t[i+1],s=gf(a[0],a[1],o[0],o[1],e,n);s<r&&(r=s)}return r}function wf(t){for(var e=[],n=[],r=0;r<t.length;r++){var i=t[r];e.push(i[0]),n.push(i[1])}return df(e,n)}function Gc(t){return io(t)}function Pe(t,e){return bf(t,e)}function jh(t,e,n){return _f(t,e,n)}function lg(t,e){return xf(t,e)}function ao(t){var e=t.slice(0);return t.length&&e.push(t[0]),e}function ak(t){return wf(t)}function ug(t){return io(ao(t))}function hx(t,e){return bf(ao(t),e)}function Ai(t,e,n){return _f(ao(t),e,n)}function ok(t,e){return xf(ao(t),e)}function Gl(t,e,n,r){var i=1-r;return i*i*t+2*r*i*e+r*r*n}function Fh(t,e,n){var r=t+n-2*e;if($s(r,0))return[.5];var i=(t-e)/r;return i<=1&&i>=0?[i]:[]}function px(t,e,n,r,i,a,o){var s=Gl(t,n,i,o),c=Gl(e,r,a,o),l=Oa(t,e,n,r,o),u=Oa(n,r,i,a,o);return[[t,e,l.x,l.y,s,c],[s,c,u.x,u.y,i,a]]}function Of(t,e,n,r,i,a,o){if(o===0)return(li(t,e,n,r)+li(n,r,i,a)+li(t,e,i,a))/2;var s=px(t,e,n,r,i,a,.5),c=s[0],l=s[1];return c.push(o-1),l.push(o-1),Of.apply(void 0,__spreadArray([],__read(c),!1))+Of.apply(void 0,__spreadArray([],__read(l),!1))}function vx(t,e,n,r,i,a){var o=Fh(t,n,i)[0],s=Fh(e,r,a)[0],c=[t,i],l=[e,a];return o!==void 0&&c.push(Gl(t,n,i,o)),s!==void 0&&l.push(Gl(e,r,a,s)),df(c,l)}function sk(t,e,n,r,i,a){return Of(t,e,n,r,i,a,3)}function gx(t,e,n,r,i,a,o,s){return Ih([t,n,i],[e,r,a],o,s,Gl)}function Do(t,e,n,r,i,a,o,s){var c=gx(t,e,n,r,i,a,o,s);return li(c.x,c.y,o,s)}var Mn=pt(74165),oo=pt(15861),Ys=pt(37762),jo=pt(91);var yx=typeof globalThis!="undefined"?globalThis:typeof window!="undefined"?window:typeof pt.g!="undefined"?pt.g:typeof self!="undefined"?self:{},fg={exports:{}};(function(t,e){(function(n,r){t.exports=r()})(yx,function(){function n(O,E,M,k,A){r(O,E,M||0,k||O.length-1,A||a)}function r(O,E,M,k,A){for(;k>M;){if(k-M>600){var P=k-M+1,C=E-M+1,N=Math.log(P),L=.5*Math.exp(2*N/3),R=.5*Math.sqrt(N*L*(P-L)/P)*(C-P/2<0?-1:1),I=Math.max(M,Math.floor(E-C*L/P+R)),D=Math.min(k,Math.floor(E+(P-C)*L/P+R));r(O,E,I,D,A)}var G=O[E],F=M,W=k;for(i(O,M,E),A(O[k],G)>0&&i(O,M,k);F<W;){for(i(O,F,W),F++,W--;A(O[F],G)<0;)F++;for(;A(O[W],G)>0;)W--}A(O[M],G)===0?i(O,M,W):(W++,i(O,W,k)),W<=E&&(M=W+1),E<=W&&(k=W-1)}}function i(O,E,M){var k=O[E];O[E]=O[M],O[M]=k}function a(O,E){return O<E?-1:O>E?1:0}var o=function(E){E===void 0&&(E=9),this._maxEntries=Math.max(4,E),this._minEntries=Math.max(2,Math.ceil(this._maxEntries*.4)),this.clear()};o.prototype.all=function(){return this._all(this.data,[])},o.prototype.search=function(E){var M=this.data,k=[];if(!x(E,M))return k;for(var A=this.toBBox,P=[];M;){for(var C=0;C<M.children.length;C++){var N=M.children[C],L=M.leaf?A(N):N;x(E,L)&&(M.leaf?k.push(N):b(E,L)?this._all(N,k):P.push(N))}M=P.pop()}return k},o.prototype.collides=function(E){var M=this.data;if(!x(E,M))return!1;for(var k=[];M;){for(var A=0;A<M.children.length;A++){var P=M.children[A],C=M.leaf?this.toBBox(P):P;if(x(E,C)){if(M.leaf||b(E,C))return!0;k.push(P)}}M=k.pop()}return!1},o.prototype.load=function(E){if(!(E&&E.length))return this;if(E.length<this._minEntries){for(var M=0;M<E.length;M++)this.insert(E[M]);return this}var k=this._build(E.slice(),0,E.length-1,0);if(!this.data.children.length)this.data=k;else if(this.data.height===k.height)this._splitRoot(this.data,k);else{if(this.data.height<k.height){var A=this.data;this.data=k,k=A}this._insert(k,this.data.height-k.height-1,!0)}return this},o.prototype.insert=function(E){return E&&this._insert(E,this.data.height-1),this},o.prototype.clear=function(){return this.data=_([]),this},o.prototype.remove=function(E,M){if(!E)return this;for(var k=this.data,A=this.toBBox(E),P=[],C=[],N,L,R;k||P.length;){if(k||(k=P.pop(),L=P[P.length-1],N=C.pop(),R=!0),k.leaf){var I=s(E,k.children,M);if(I!==-1)return k.children.splice(I,1),P.push(k),this._condense(P),this}!R&&!k.leaf&&b(k,A)?(P.push(k),C.push(N),N=0,L=k,k=k.children[0]):L?(N++,k=L.children[N],R=!1):k=null}return this},o.prototype.toBBox=function(E){return E},o.prototype.compareMinX=function(E,M){return E.minX-M.minX},o.prototype.compareMinY=function(E,M){return E.minY-M.minY},o.prototype.toJSON=function(){return this.data},o.prototype.fromJSON=function(E){return this.data=E,this},o.prototype._all=function(E,M){for(var k=[];E;)E.leaf?M.push.apply(M,E.children):k.push.apply(k,E.children),E=k.pop();return M},o.prototype._build=function(E,M,k,A){var P=k-M+1,C=this._maxEntries,N;if(P<=C)return N=_(E.slice(M,k+1)),c(N,this.toBBox),N;A||(A=Math.ceil(Math.log(P)/Math.log(C)),C=Math.ceil(P/Math.pow(C,A-1))),N=_([]),N.leaf=!1,N.height=A;var L=Math.ceil(P/C),R=L*Math.ceil(Math.sqrt(C));w(E,M,k,R,this.compareMinX);for(var I=M;I<=k;I+=R){var D=Math.min(I+R-1,k);w(E,I,D,L,this.compareMinY);for(var G=I;G<=D;G+=L){var F=Math.min(G+L-1,D);N.children.push(this._build(E,G,F,A-1))}}return c(N,this.toBBox),N},o.prototype._chooseSubtree=function(E,M,k,A){for(;A.push(M),!(M.leaf||A.length-1===k);){for(var P=1/0,C=1/0,N=void 0,L=0;L<M.children.length;L++){var R=M.children[L],I=h(R),D=g(E,R)-I;D<C?(C=D,P=I<P?I:P,N=R):D===C&&I<P&&(P=I,N=R)}M=N||M.children[0]}return M},o.prototype._insert=function(E,M,k){var A=k?E:this.toBBox(E),P=[],C=this._chooseSubtree(A,this.data,M,P);for(C.children.push(E),u(C,A);M>=0&&P[M].children.length>this._maxEntries;)this._split(P,M),M--;this._adjustParentBBoxes(A,P,M)},o.prototype._split=function(E,M){var k=E[M],A=k.children.length,P=this._minEntries;this._chooseSplitAxis(k,P,A);var C=this._chooseSplitIndex(k,P,A),N=_(k.children.splice(C,k.children.length-C));N.height=k.height,N.leaf=k.leaf,c(k,this.toBBox),c(N,this.toBBox),M?E[M-1].children.push(N):this._splitRoot(k,N)},o.prototype._splitRoot=function(E,M){this.data=_([E,M]),this.data.height=E.height+1,this.data.leaf=!1,c(this.data,this.toBBox)},o.prototype._chooseSplitIndex=function(E,M,k){for(var A,P=1/0,C=1/0,N=M;N<=k-M;N++){var L=l(E,0,N,this.toBBox),R=l(E,N,k,this.toBBox),I=y(L,R),D=h(L)+h(R);I<P?(P=I,A=N,C=D<C?D:C):I===P&&D<C&&(C=D,A=N)}return A||k-M},o.prototype._chooseSplitAxis=function(E,M,k){var A=E.leaf?this.compareMinX:f,P=E.leaf?this.compareMinY:d,C=this._allDistMargin(E,M,k,A),N=this._allDistMargin(E,M,k,P);C<N&&E.children.sort(A)},o.prototype._allDistMargin=function(E,M,k,A){E.children.sort(A);for(var P=this.toBBox,C=l(E,0,M,P),N=l(E,k-M,k,P),L=v(C)+v(N),R=M;R<k-M;R++){var I=E.children[R];u(C,E.leaf?P(I):I),L+=v(C)}for(var D=k-M-1;D>=M;D--){var G=E.children[D];u(N,E.leaf?P(G):G),L+=v(N)}return L},o.prototype._adjustParentBBoxes=function(E,M,k){for(var A=k;A>=0;A--)u(M[A],E)},o.prototype._condense=function(E){for(var M=E.length-1,k=void 0;M>=0;M--)E[M].children.length===0?M>0?(k=E[M-1].children,k.splice(k.indexOf(E[M]),1)):this.clear():c(E[M],this.toBBox)};function s(O,E,M){if(!M)return E.indexOf(O);for(var k=0;k<E.length;k++)if(M(O,E[k]))return k;return-1}function c(O,E){l(O,0,O.children.length,E,O)}function l(O,E,M,k,A){A||(A=_(null)),A.minX=1/0,A.minY=1/0,A.maxX=-1/0,A.maxY=-1/0;for(var P=E;P<M;P++){var C=O.children[P];u(A,O.leaf?k(C):C)}return A}function u(O,E){return O.minX=Math.min(O.minX,E.minX),O.minY=Math.min(O.minY,E.minY),O.maxX=Math.max(O.maxX,E.maxX),O.maxY=Math.max(O.maxY,E.maxY),O}function f(O,E){return O.minX-E.minX}function d(O,E){return O.minY-E.minY}function h(O){return(O.maxX-O.minX)*(O.maxY-O.minY)}function v(O){return O.maxX-O.minX+(O.maxY-O.minY)}function g(O,E){return(Math.max(E.maxX,O.maxX)-Math.min(E.minX,O.minX))*(Math.max(E.maxY,O.maxY)-Math.min(E.minY,O.minY))}function y(O,E){var M=Math.max(O.minX,E.minX),k=Math.max(O.minY,E.minY),A=Math.min(O.maxX,E.maxX),P=Math.min(O.maxY,E.maxY);return Math.max(0,A-M)*Math.max(0,P-k)}function b(O,E){return O.minX<=E.minX&&O.minY<=E.minY&&E.maxX<=O.maxX&&E.maxY<=O.maxY}function x(O,E){return E.minX<=O.maxX&&E.minY<=O.maxY&&E.maxX>=O.minX&&E.maxY>=O.minY}function _(O){return{children:O,height:1,leaf:!0,minX:1/0,minY:1/0,maxX:-1/0,maxY:-1/0}}function w(O,E,M,k,A){for(var P=[E,M];P.length;)if(M=P.pop(),E=P.pop(),!(M-E<=k)){var C=E+Math.ceil((M-E)/k/2)*k;n(O,C,E,M,A),P.push(E,C,C,M)}}return o})})(fg);var $l=fg.exports,dt=function(t){return t.GROUP="g",t.FRAGMENT="fragment",t.CIRCLE="circle",t.ELLIPSE="ellipse",t.IMAGE="image",t.RECT="rect",t.LINE="line",t.POLYLINE="polyline",t.POLYGON="polygon",t.TEXT="text",t.PATH="path",t.HTML="html",t.MESH="mesh",t}({}),Zl=function(t){return t[t.ZERO=0]="ZERO",t[t.NEGATIVE_ONE=1]="NEGATIVE_ONE",t}({}),is=function(){function t(){(0,xt.Z)(this,t),this.plugins=[]}return(0,Ot.Z)(t,[{key:"addRenderingPlugin",value:function(n){this.plugins.push(n),this.context.renderingPlugins.push(n)}},{key:"removeAllRenderingPlugins",value:function(){var n=this;this.plugins.forEach(function(r){var i=n.context.renderingPlugins.indexOf(r);i>=0&&n.context.renderingPlugins.splice(i,1)})}}])}(),mx=function(){function t(e){(0,xt.Z)(this,t),this.clipSpaceNearZ=Zl.NEGATIVE_ONE,this.plugins=[],this.config=(0,Ee.Z)({enableDirtyCheck:!0,enableCulling:!1,enableAutoRendering:!0,enableDirtyRectangleRendering:!0,enableDirtyRectangleRenderingDebug:!1,enableSizeAttenuation:!0,enableRenderingOptimization:!1},e)}return(0,Ot.Z)(t,[{key:"registerPlugin",value:function(n){var r=this.plugins.findIndex(function(i){return i===n});r===-1&&this.plugins.push(n)}},{key:"unregisterPlugin",value:function(n){var r=this.plugins.findIndex(function(i){return i===n});r>-1&&this.plugins.splice(r,1)}},{key:"getPlugins",value:function(){return this.plugins}},{key:"getPlugin",value:function(n){return this.plugins.find(function(r){return r.name===n})}},{key:"getConfig",value:function(){return this.config}},{key:"setConfig",value:function(n){Object.assign(this.config,n)}}])}(),Bh=Na,$c=ca,dg=Gd,hg=Wd,pg=Uo,Yl=J,xr=function(){function t(){(0,xt.Z)(this,t),this.center=[0,0,0],this.halfExtents=[0,0,0],this.min=[0,0,0],this.max=[0,0,0]}return(0,Ot.Z)(t,[{key:"update",value:function(n,r){$c(this.center,n),$c(this.halfExtents,r),Yl(this.min,this.center,this.halfExtents),Bh(this.max,this.center,this.halfExtents)}},{key:"setMinMax",value:function(n,r){Bh(this.center,r,n),pg(this.center,this.center,.5),Yl(this.halfExtents,r,n),pg(this.halfExtents,this.halfExtents,.5),$c(this.min,n),$c(this.max,r)}},{key:"getMin",value:function(){return this.min}},{key:"getMax",value:function(){return this.max}},{key:"add",value:function(n){if(!t.isEmpty(n)){if(t.isEmpty(this)){this.setMinMax(n.getMin(),n.getMax());return}var r=this.center,i=r[0],a=r[1],o=r[2],s=this.halfExtents,c=s[0],l=s[1],u=s[2],f=i-c,d=i+c,h=a-l,v=a+l,g=o-u,y=o+u,b=n.center,x=b[0],_=b[1],w=b[2],O=n.halfExtents,E=O[0],M=O[1],k=O[2],A=x-E,P=x+E,C=_-M,N=_+M,L=w-k,R=w+k;A<f&&(f=A),P>d&&(d=P),C<h&&(h=C),N>v&&(v=N),L<g&&(g=L),R>y&&(y=R),r[0]=(f+d)*.5,r[1]=(h+v)*.5,r[2]=(g+y)*.5,s[0]=(d-f)*.5,s[1]=(v-h)*.5,s[2]=(y-g)*.5,this.min[0]=f,this.min[1]=h,this.min[2]=g,this.max[0]=d,this.max[1]=v,this.max[2]=y}}},{key:"setFromTransformedAABB",value:function(n,r){var i=this.center,a=this.halfExtents,o=n.center,s=n.halfExtents,c=r[0],l=r[4],u=r[8],f=r[1],d=r[5],h=r[9],v=r[2],g=r[6],y=r[10],b=Math.abs(c),x=Math.abs(l),_=Math.abs(u),w=Math.abs(f),O=Math.abs(d),E=Math.abs(h),M=Math.abs(v),k=Math.abs(g),A=Math.abs(y);i[0]=r[12]+c*o[0]+l*o[1]+u*o[2],i[1]=r[13]+f*o[0]+d*o[1]+h*o[2],i[2]=r[14]+v*o[0]+g*o[1]+y*o[2],a[0]=b*s[0]+x*s[1]+_*s[2],a[1]=w*s[0]+O*s[1]+E*s[2],a[2]=M*s[0]+k*s[1]+A*s[2],Yl(this.min,i,a),Bh(this.max,i,a)}},{key:"intersects",value:function(n){var r=this.getMax(),i=this.getMin(),a=n.getMax(),o=n.getMin();return i[0]<=a[0]&&r[0]>=o[0]&&i[1]<=a[1]&&r[1]>=o[1]&&i[2]<=a[2]&&r[2]>=o[2]}},{key:"intersection",value:function(n){if(!this.intersects(n))return null;var r=new t,i=dg([0,0,0],this.getMin(),n.getMin()),a=hg([0,0,0],this.getMax(),n.getMax());return r.setMinMax(i,a),r}},{key:"getNegativeFarPoint",value:function(n){return n.pnVertexFlag===273?$c([0,0,0],this.min):n.pnVertexFlag===272?[this.min[0],this.min[1],this.max[2]]:n.pnVertexFlag===257?[this.min[0],this.max[1],this.min[2]]:n.pnVertexFlag===256?[this.min[0],this.max[1],this.max[2]]:n.pnVertexFlag===17?[this.max[0],this.min[1],this.min[2]]:n.pnVertexFlag===16?[this.max[0],this.min[1],this.max[2]]:n.pnVertexFlag===1?[this.max[0],this.max[1],this.min[2]]:[this.max[0],this.max[1],this.max[2]]}},{key:"getPositiveFarPoint",value:function(n){return n.pnVertexFlag===273?$c([0,0,0],this.max):n.pnVertexFlag===272?[this.max[0],this.max[1],this.min[2]]:n.pnVertexFlag===257?[this.max[0],this.min[1],this.max[2]]:n.pnVertexFlag===256?[this.max[0],this.min[1],this.min[2]]:n.pnVertexFlag===17?[this.min[0],this.max[1],this.max[2]]:n.pnVertexFlag===16?[this.min[0],this.max[1],this.min[2]]:n.pnVertexFlag===1?[this.min[0],this.min[1],this.max[2]]:[this.min[0],this.min[1],this.min[2]]}}],[{key:"isEmpty",value:function(n){return!n||n.halfExtents[0]===0&&n.halfExtents[1]===0&&n.halfExtents[2]===0}}])}(),Hl=function(){function t(e,n){(0,xt.Z)(this,t),this.distance=e||0,this.normal=n||sn(0,1,0),this.updatePNVertexFlag()}return(0,Ot.Z)(t,[{key:"updatePNVertexFlag",value:function(){this.pnVertexFlag=(+(this.normal[0]>=0)<<8)+(+(this.normal[1]>=0)<<4)+ +(this.normal[2]>=0)}},{key:"distanceToPoint",value:function(n){return la(n,this.normal)-this.distance}},{key:"normalize",value:function(){var n=1/ie(this.normal);Uo(this.normal,this.normal,n),this.distance*=n}},{key:"intersectsLine",value:function(n,r,i){var a=this.distanceToPoint(n),o=this.distanceToPoint(r),s=a/(a-o),c=s>=0&&s<=1;return c&&i&&El(i,n,r,s),c}}])}(),as=function(t){return t[t.OUTSIDE=4294967295]="OUTSIDE",t[t.INSIDE=0]="INSIDE",t[t.INDETERMINATE=2147483647]="INDETERMINATE",t}({}),vg=function(){function t(e){if((0,xt.Z)(this,t),this.planes=[],e)this.planes=e;else for(var n=0;n<6;n++)this.planes.push(new Hl)}return(0,Ot.Z)(t,[{key:"extractFromVPMatrix",value:function(n){var r=(0,Te.Z)(n,16),i=r[0],a=r[1],o=r[2],s=r[3],c=r[4],l=r[5],u=r[6],f=r[7],d=r[8],h=r[9],v=r[10],g=r[11],y=r[12],b=r[13],x=r[14],_=r[15];Gr(this.planes[0].normal,s-i,f-c,g-d),this.planes[0].distance=_-y,Gr(this.planes[1].normal,s+i,f+c,g+d),this.planes[1].distance=_+y,Gr(this.planes[2].normal,s+a,f+l,g+h),this.planes[2].distance=_+b,Gr(this.planes[3].normal,s-a,f-l,g-h),this.planes[3].distance=_-b,Gr(this.planes[4].normal,s-o,f-u,g-v),this.planes[4].distance=_-x,Gr(this.planes[5].normal,s+o,f+u,g+v),this.planes[5].distance=_+x,this.planes.forEach(function(w){w.normalize(),w.updatePNVertexFlag()})}}])}(),ii=function(){function t(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:0,n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0;(0,xt.Z)(this,t),this.x=0,this.y=0,this.x=e,this.y=n}return(0,Ot.Z)(t,[{key:"clone",value:function(){return new t(this.x,this.y)}},{key:"copyFrom",value:function(n){this.x=n.x,this.y=n.y}}])}(),Fo=function(){function t(e,n,r,i){(0,xt.Z)(this,t),this.x=e,this.y=n,this.width=r,this.height=i,this.left=e,this.right=e+r,this.top=n,this.bottom=n+i}return(0,Ot.Z)(t,[{key:"toJSON",value:function(){}}],[{key:"fromRect",value:function(n){return new t(n.x,n.y,n.width,n.height)}},{key:"applyTransform",value:function(n,r){var i=he(n.x,n.y,0,1),a=he(n.x+n.width,n.y,0,1),o=he(n.x,n.y+n.height,0,1),s=he(n.x+n.width,n.y+n.height,0,1),c=Gt(),l=Gt(),u=Gt(),f=Gt();Ro(c,i,r),Ro(l,a,r),Ro(u,o,r),Ro(f,s,r);var d=Math.min(c[0],l[0],u[0],f[0]),h=Math.min(c[1],l[1],u[1],f[1]),v=Math.max(c[0],l[0],u[0],f[0]),g=Math.max(c[1],l[1],u[1],f[1]);return t.fromRect({x:d,y:h,width:v-d,height:g-h})}}])}(),kn="Method not implemented.",Ti="Use document.documentElement instead.",Hs="Cannot append a destroyed element.";function Zc(t){return t===void 0?0:t>360||t<-360?t%360:t}var Sf=me();function Pi(t){var e=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,r=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!0;return Array.isArray(t)&&t.length===3?r?wi(t):ca(Sf,t):Vn(t)?r?sn(t,e,n):Gr(Sf,t,e,n):r?sn(t[0],t[1]||e,t[2]||n):Gr(Sf,t[0],t[1]||e,t[2]||n)}var bx=Math.PI/180;function Cn(t){return t*bx}var xx=180/Math.PI;function Sa(t){return t*xx}var _x=.9;function ck(t){return t%=400,t<0&&(t+=400),t*_x}function lk(t){return t/360}function wx(t){return 360*t}var Ef=Math.PI/2;function Ox(t,e){var n=e[0],r=e[1],i=e[2],a=e[3],o=n*n,s=r*r,c=i*i,l=a*a,u=o+s+c+l,f=n*a-r*i;return f>.499995*u?(t[0]=Ef,t[1]=2*Math.atan2(r,n),t[2]=0):f<-.499995*u?(t[0]=-Ef,t[1]=2*Math.atan2(r,n),t[2]=0):(t[0]=Math.asin(2*(n*i-a*r)),t[1]=Math.atan2(2*(n*a+r*i),1-2*(c+l)),t[2]=Math.atan2(2*(n*r+i*a),1-2*(s+c))),t}function gg(t,e){var n,r,i=fa(me(),e),a=(0,Te.Z)(i,3),o=a[0],s=a[1],c=a[2],l=Math.asin(-e[2]/o);return l<Ef?l>-Ef?(n=Math.atan2(e[6]/s,e[10]/c),r=Math.atan2(e[1]/o,e[0]/o)):(r=0,n=-Math.atan2(e[4]/s,e[5]/s)):(r=0,n=Math.atan2(e[4]/s,e[5]/s)),t[0]=n,t[1]=l,t[2]=r,t}function Mf(t,e){return e.length===16?gg(t,e):Ox(t,e)}function yg(t,e,n,r,i){var a=Math.cos(t),o=Math.sin(t);return kb(r*a,i*o,0,-r*o,i*a,0,e,n,1)}function Sx(t,e,n,r,i,a,o){var s=arguments.length>7&&arguments[7]!==void 0?arguments[7]:!1,c=2*a,l=n-e,u=r-i,f=c/l,d=c/u,h=(n+e)/l,v=(r+i)/u,g,y,b=o-a,x=o*a;return s?(g=-o/b,y=-x/b):(g=-(o+a)/b,y=-2*x/b),t[0]=f,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=d,t[6]=0,t[7]=0,t[8]=h,t[9]=v,t[10]=g,t[11]=-1,t[12]=0,t[13]=0,t[14]=y,t[15]=0,t}function mg(t){var e=t[0],n=t[1],r=t[3],i=t[4],a=Math.sqrt(e*e+n*n),o=Math.sqrt(r*r+i*i),s=e*i-n*r;if(s<0&&(e<i?a=-a:o=-o),a){var c=1/a;e*=c,n*=c}if(o){var l=1/o;r*=l,i*=l}var u=Math.atan2(n,e),f=Sa(u);return[t[6],t[7],a,o,f]}var so=Wn(),Ea=Wn(),Vl=Gt(),Le=[me(),me(),me()],bg=me();function Ex(t,e,n,r,i,a){if(!Mx(so,t)||(Tc(Ea,so),Ea[3]=0,Ea[7]=0,Ea[11]=0,Ea[15]=1,Math.abs($u(Ea))<1e-8))return!1;var o=so[3],s=so[7],c=so[11],l=so[12],u=so[13],f=so[14],d=so[15];if(o!==0||s!==0||c!==0){Vl[0]=o,Vl[1]=s,Vl[2]=c,Vl[3]=d;var h=$i(Ea,Ea);if(!h)return!1;Xd(Ea,Ea),Ro(i,Vl,Ea)}else i[0]=i[1]=i[2]=0,i[3]=1;if(e[0]=l,e[1]=u,e[2]=f,kx(Le,so),n[0]=sa(Le[0]),xa(Le[0],Le[0]),r[0]=la(Le[0],Le[1]),Xi(Le[1],Le[1],Le[0],1,-r[0]),n[1]=sa(Le[1]),xa(Le[1],Le[1]),r[0]/=n[1],r[1]=la(Le[0],Le[2]),Xi(Le[2],Le[2],Le[0],1,-r[1]),r[2]=la(Le[1],Le[2]),Xi(Le[2],Le[2],Le[1],1,-r[2]),n[2]=sa(Le[2]),xa(Le[2],Le[2]),r[1]/=n[2],r[2]/=n[2],Mc(bg,Le[1],Le[2]),la(Le[0],bg)<0)for(var v=0;v<3;v++)n[v]*=-1,Le[v][0]*=-1,Le[v][1]*=-1,Le[v][2]*=-1;return a[0]=.5*Math.sqrt(Math.max(1+Le[0][0]-Le[1][1]-Le[2][2],0)),a[1]=.5*Math.sqrt(Math.max(1-Le[0][0]+Le[1][1]-Le[2][2],0)),a[2]=.5*Math.sqrt(Math.max(1-Le[0][0]-Le[1][1]+Le[2][2],0)),a[3]=.5*Math.sqrt(Math.max(1+Le[0][0]+Le[1][1]+Le[2][2],0)),Le[2][1]>Le[1][2]&&(a[0]=-a[0]),Le[0][2]>Le[2][0]&&(a[1]=-a[1]),Le[1][0]>Le[0][1]&&(a[2]=-a[2]),!0}function Mx(t,e){var n=e[15];if(n===0)return!1;for(var r=1/n,i=0;i<16;i++)t[i]=e[i]*r;return!0}function kx(t,e){t[0][0]=e[0],t[0][1]=e[1],t[0][2]=e[2],t[1][0]=e[4],t[1][1]=e[5],t[1][2]=e[6],t[2][0]=e[8],t[2][1]=e[9],t[2][2]=e[10]}function Xi(t,e,n,r,i){t[0]=e[0]*r+n[0]*i,t[1]=e[1]*r+n[1]*i,t[2]=e[2]*r+n[2]*i}var Ln=function(t){return t[t.ORBITING=0]="ORBITING",t[t.EXPLORING=1]="EXPLORING",t[t.TRACKING=2]="TRACKING",t}({}),zh=function(t){return t[t.DEFAULT=0]="DEFAULT",t[t.ROTATIONAL=1]="ROTATIONAL",t[t.TRANSLATIONAL=2]="TRANSLATIONAL",t[t.CINEMATIC=3]="CINEMATIC",t}({}),Ma=function(t){return t[t.ORTHOGRAPHIC=0]="ORTHOGRAPHIC",t[t.PERSPECTIVE=1]="PERSPECTIVE",t}({}),Wh={UPDATED:"updated"},xg=2e-4,_g=function(){function t(){(0,xt.Z)(this,t),this.clipSpaceNearZ=Zl.NEGATIVE_ONE,this.eventEmitter=new Lo,this.matrix=Wn(),this.right=sn(1,0,0),this.up=sn(0,1,0),this.forward=sn(0,0,1),this.position=sn(0,0,1),this.focalPoint=sn(0,0,0),this.distanceVector=sn(0,0,-1),this.distance=1,this.azimuth=0,this.elevation=0,this.roll=0,this.relAzimuth=0,this.relElevation=0,this.relRoll=0,this.dollyingStep=0,this.maxDistance=1/0,this.minDistance=-1/0,this.zoom=1,this.rotateWorld=!1,this.fov=30,this.near=.1,this.far=1e3,this.aspect=1,this.projectionMatrix=Wn(),this.projectionMatrixInverse=Wn(),this.jitteredProjectionMatrix=void 0,this.enableUpdate=!0,this.type=Ln.EXPLORING,this.trackingMode=zh.DEFAULT,this.projectionMode=Ma.PERSPECTIVE,this.frustum=new vg,this.orthoMatrix=Wn()}return(0,Ot.Z)(t,[{key:"isOrtho",value:function(){return this.projectionMode===Ma.ORTHOGRAPHIC}},{key:"getProjectionMode",value:function(){return this.projectionMode}},{key:"getPerspective",value:function(){return this.jitteredProjectionMatrix||this.projectionMatrix}},{key:"getPerspectiveInverse",value:function(){return this.projectionMatrixInverse}},{key:"getFrustum",value:function(){return this.frustum}},{key:"getPosition",value:function(){return this.position}},{key:"getFocalPoint",value:function(){return this.focalPoint}},{key:"getDollyingStep",value:function(){return this.dollyingStep}},{key:"getNear",value:function(){return this.near}},{key:"getFar",value:function(){return this.far}},{key:"getZoom",value:function(){return this.zoom}},{key:"getOrthoMatrix",value:function(){return this.orthoMatrix}},{key:"getView",value:function(){return this.view}},{key:"setEnableUpdate",value:function(n){this.enableUpdate=n}},{key:"setType",value:function(n,r){return this.type=n,this.type===Ln.EXPLORING?this.setWorldRotation(!0):this.setWorldRotation(!1),this._getAngles(),this.type===Ln.TRACKING&&r!==void 0&&this.setTrackingMode(r),this}},{key:"setProjectionMode",value:function(n){return this.projectionMode=n,this}},{key:"setTrackingMode",value:function(n){if(this.type!==Ln.TRACKING)throw new Error("Impossible to set a tracking mode if the camera is not of tracking type");return this.trackingMode=n,this}},{key:"setWorldRotation",value:function(n){return this.rotateWorld=n,this._getAngles(),this}},{key:"getViewTransform",value:function(){return $i(Wn(),this.matrix)}},{key:"getWorldTransform",value:function(){return this.matrix}},{key:"jitterProjectionMatrix",value:function(n,r){var i=Lr(Wn(),[n,r,0]);this.jitteredProjectionMatrix=Gn(Wn(),i,this.projectionMatrix)}},{key:"clearJitterProjectionMatrix",value:function(){this.jitteredProjectionMatrix=void 0}},{key:"setMatrix",value:function(n){return this.matrix=n,this._update(),this}},{key:"setProjectionMatrix",value:function(n){this.projectionMatrix=n}},{key:"setFov",value:function(n){return this.setPerspective(this.near,this.far,n,this.aspect),this}},{key:"setAspect",value:function(n){return this.setPerspective(this.near,this.far,this.fov,n),this}},{key:"setNear",value:function(n){return this.projectionMode===Ma.PERSPECTIVE?this.setPerspective(n,this.far,this.fov,this.aspect):this.setOrthographic(this.left,this.rright,this.top,this.bottom,n,this.far),this}},{key:"setFar",value:function(n){return this.projectionMode===Ma.PERSPECTIVE?this.setPerspective(this.near,n,this.fov,this.aspect):this.setOrthographic(this.left,this.rright,this.top,this.bottom,this.near,n),this}},{key:"setViewOffset",value:function(n,r,i,a,o,s){return this.aspect=n/r,this.view===void 0&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=n,this.view.fullHeight=r,this.view.offsetX=i,this.view.offsetY=a,this.view.width=o,this.view.height=s,this.projectionMode===Ma.PERSPECTIVE?this.setPerspective(this.near,this.far,this.fov,this.aspect):this.setOrthographic(this.left,this.rright,this.top,this.bottom,this.near,this.far),this}},{key:"clearViewOffset",value:function(){return this.view!==void 0&&(this.view.enabled=!1),this.projectionMode===Ma.PERSPECTIVE?this.setPerspective(this.near,this.far,this.fov,this.aspect):this.setOrthographic(this.left,this.rright,this.top,this.bottom,this.near,this.far),this}},{key:"setZoom",value:function(n){return this.zoom=n,this.projectionMode===Ma.ORTHOGRAPHIC?this.setOrthographic(this.left,this.rright,this.top,this.bottom,this.near,this.far):this.projectionMode===Ma.PERSPECTIVE&&this.setPerspective(this.near,this.far,this.fov,this.aspect),this}},{key:"setZoomByViewportPoint",value:function(n,r){var i=this.canvas.viewport2Canvas({x:r[0],y:r[1]}),a=i.x,o=i.y,s=this.roll;this.rotate(0,0,-s),this.setPosition(a,o),this.setFocalPoint(a,o),this.setZoom(n),this.rotate(0,0,s);var c=this.canvas.viewport2Canvas({x:r[0],y:r[1]}),l=c.x,u=c.y,f=sn(l-a,u-o,0),d=la(f,this.right)/sa(this.right),h=la(f,this.up)/sa(this.up),v=this.getPosition(),g=(0,Te.Z)(v,2),y=g[0],b=g[1],x=this.getFocalPoint(),_=(0,Te.Z)(x,2),w=_[0],O=_[1];return this.setPosition(y-d,b-h),this.setFocalPoint(w-d,O-h),this}},{key:"setPerspective",value:function(n,r,i,a){var o;this.projectionMode=Ma.PERSPECTIVE,this.fov=i,this.near=n,this.far=r,this.aspect=a;var s=this.near*Math.tan(Cn(.5*this.fov))/this.zoom,c=2*s,l=this.aspect*c,u=-.5*l;if((o=this.view)!==null&&o!==void 0&&o.enabled){var f=this.view.fullWidth,d=this.view.fullHeight;u+=this.view.offsetX*l/f,s-=this.view.offsetY*c/d,l*=this.view.width/f,c*=this.view.height/d}return Sx(this.projectionMatrix,u,u+l,s-c,s,n,this.far,this.clipSpaceNearZ===Zl.ZERO),$i(this.projectionMatrixInverse,this.projectionMatrix),this.triggerUpdate(),this}},{key:"setOrthographic",value:function(n,r,i,a,o,s){var c;this.projectionMode=Ma.ORTHOGRAPHIC,this.rright=r,this.left=n,this.top=i,this.bottom=a,this.near=o,this.far=s;var l=(this.rright-this.left)/(2*this.zoom),u=(this.top-this.bottom)/(2*this.zoom),f=(this.rright+this.left)/2,d=(this.top+this.bottom)/2,h=f-l,v=f+l,g=d+u,y=d-u;if((c=this.view)!==null&&c!==void 0&&c.enabled){var b=(this.rright-this.left)/this.view.fullWidth/this.zoom,x=(this.top-this.bottom)/this.view.fullHeight/this.zoom;h+=b*this.view.offsetX,v=h+b*this.view.width,g-=x*this.view.offsetY,y=g-x*this.view.height}return this.clipSpaceNearZ===Zl.NEGATIVE_ONE?eh(this.projectionMatrix,h,v,g,y,o,s):nh(this.projectionMatrix,h,v,g,y,o,s),$i(this.projectionMatrixInverse,this.projectionMatrix),this._getOrthoMatrix(),this.triggerUpdate(),this}},{key:"setPosition",value:function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:this.position[1],i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:this.position[2],a=Pi(n,r,i);return this._setPosition(a),this.setFocalPoint(this.focalPoint),this.triggerUpdate(),this}},{key:"setFocalPoint",value:function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:this.focalPoint[1],i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:this.focalPoint[2],a=sn(0,1,0);if(this.focalPoint=Pi(n,r,i),this.trackingMode===zh.CINEMATIC){var o=Ol(me(),this.focalPoint,this.position);n=o[0],r=o[1],i=o[2];var s=sa(o),c=Sa(Math.asin(r/s)),l=90+Sa(Math.atan2(i,n)),u=Wn();Kd(u,u,Cn(l)),qd(u,u,Cn(c)),a=er(me(),[0,1,0],u)}return $i(this.matrix,Yu(Wn(),this.position,this.focalPoint,a)),this._getAxes(),this._getDistance(),this._getAngles(),this.triggerUpdate(),this}},{key:"getDistance",value:function(){return this.distance}},{key:"getDistanceVector",value:function(){return this.distanceVector}},{key:"setDistance",value:function(n){if(this.distance===n||n<0)return this;this.distance=n,this.distance<xg&&(this.distance=xg),this.dollyingStep=this.distance/100;var r=me();n=this.distance;var i=this.forward,a=this.focalPoint;return r[0]=n*i[0]+a[0],r[1]=n*i[1]+a[1],r[2]=n*i[2]+a[2],this._setPosition(r),this.triggerUpdate(),this}},{key:"setMaxDistance",value:function(n){return this.maxDistance=n,this}},{key:"setMinDistance",value:function(n){return this.minDistance=n,this}},{key:"setAzimuth",value:function(n){return this.azimuth=Zc(n),this.computeMatrix(),this._getAxes(),this.type===Ln.ORBITING||this.type===Ln.EXPLORING?this._getPosition():this.type===Ln.TRACKING&&this._getFocalPoint(),this.triggerUpdate(),this}},{key:"getAzimuth",value:function(){return this.azimuth}},{key:"setElevation",value:function(n){return this.elevation=Zc(n),this.computeMatrix(),this._getAxes(),this.type===Ln.ORBITING||this.type===Ln.EXPLORING?this._getPosition():this.type===Ln.TRACKING&&this._getFocalPoint(),this.triggerUpdate(),this}},{key:"getElevation",value:function(){return this.elevation}},{key:"setRoll",value:function(n){return this.roll=Zc(n),this.computeMatrix(),this._getAxes(),this.type===Ln.ORBITING||this.type===Ln.EXPLORING?this._getPosition():this.type===Ln.TRACKING&&this._getFocalPoint(),this.triggerUpdate(),this}},{key:"getRoll",value:function(){return this.roll}},{key:"_update",value:function(){this._getAxes(),this._getPosition(),this._getDistance(),this._getAngles(),this._getOrthoMatrix(),this.triggerUpdate()}},{key:"computeMatrix",value:function(){var n=qo(je(),[0,0,1],Cn(this.roll));lr(this.matrix);var r=qo(je(),[1,0,0],Cn((this.rotateWorld&&this.type!==Ln.TRACKING||this.type===Ln.TRACKING?1:-1)*this.elevation)),i=qo(je(),[0,1,0],Cn((this.rotateWorld&&this.type!==Ln.TRACKING||this.type===Ln.TRACKING?1:-1)*this.azimuth)),a=Ko(je(),i,r);a=Ko(je(),a,n);var o=th(Wn(),a);this.type===Ln.ORBITING||this.type===Ln.EXPLORING?(Ns(this.matrix,this.matrix,this.focalPoint),Gn(this.matrix,this.matrix,o),Ns(this.matrix,this.matrix,[0,0,this.distance])):this.type===Ln.TRACKING&&(Ns(this.matrix,this.matrix,this.position),Gn(this.matrix,this.matrix,o))}},{key:"_setPosition",value:function(n,r,i){this.position=Pi(n,r,i);var a=this.matrix;a[12]=this.position[0],a[13]=this.position[1],a[14]=this.position[2],a[15]=1,this._getOrthoMatrix()}},{key:"_getAxes",value:function(){ca(this.right,Pi(Ro(Gt(),[1,0,0,0],this.matrix))),ca(this.up,Pi(Ro(Gt(),[0,1,0,0],this.matrix))),ca(this.forward,Pi(Ro(Gt(),[0,0,1,0],this.matrix))),xa(this.right,this.right),xa(this.up,this.up),xa(this.forward,this.forward)}},{key:"_getAngles",value:function(){var n=this.distanceVector[0],r=this.distanceVector[1],i=this.distanceVector[2],a=sa(this.distanceVector);if(a===0){this.elevation=0,this.azimuth=0;return}this.type===Ln.TRACKING?(this.elevation=Sa(Math.asin(r/a)),this.azimuth=Sa(Math.atan2(-n,-i))):this.rotateWorld?(this.elevation=Sa(Math.asin(r/a)),this.azimuth=Sa(Math.atan2(-n,-i))):(this.elevation=-Sa(Math.asin(r/a)),this.azimuth=-Sa(Math.atan2(-n,-i)))}},{key:"_getPosition",value:function(){ca(this.position,Pi(Ro(Gt(),[0,0,0,1],this.matrix))),this._getDistance()}},{key:"_getFocalPoint",value:function(){Zd(this.distanceVector,[0,0,-this.distance],Mb(oh(),this.matrix)),Na(this.focalPoint,this.position,this.distanceVector),this._getDistance()}},{key:"_getDistance",value:function(){this.distanceVector=Ol(me(),this.focalPoint,this.position),this.distance=sa(this.distanceVector),this.dollyingStep=this.distance/100}},{key:"_getOrthoMatrix",value:function(){if(this.projectionMode===Ma.ORTHOGRAPHIC){var n=this.position,r=qo(je(),[0,0,1],-this.roll*Math.PI/180);Ds(this.orthoMatrix,r,sn((this.rright-this.left)/2-n[0],(this.top-this.bottom)/2-n[1],0),sn(this.zoom,this.zoom,1),n)}}},{key:"triggerUpdate",value:function(){if(this.enableUpdate){var n=this.getViewTransform(),r=Gn(Wn(),this.getPerspective(),n);this.getFrustum().extractFromVPMatrix(r),this.eventEmitter.emit(Wh.UPDATED)}}},{key:"rotate",value:function(n,r,i){throw new Error(kn)}},{key:"pan",value:function(n,r){throw new Error(kn)}},{key:"dolly",value:function(n){throw new Error(kn)}},{key:"createLandmark",value:function(n,r){throw new Error(kn)}},{key:"gotoLandmark",value:function(n,r){throw new Error(kn)}},{key:"cancelLandmarkAnimation",value:function(){throw new Error(kn)}}])}(),Ax=function(t){return t[t.Standard=0]="Standard",t}({}),kf=function(t){return t[t.ADDED=0]="ADDED",t[t.REMOVED=1]="REMOVED",t[t.Z_INDEX_CHANGED=2]="Z_INDEX_CHANGED",t}({}),Af={absolutePath:[],hasArc:!1,segments:[],polygons:[],polylines:[],curve:null,totalLength:0,rect:new Fo(0,0,0,0)},zt=function(t){return t.COORDINATE="<coordinate>",t.COLOR="<color>",t.PAINT="<paint>",t.NUMBER="<number>",t.ANGLE="<angle>",t.OPACITY_VALUE="<opacity-value>",t.SHADOW_BLUR="<shadow-blur>",t.LENGTH="<length>",t.PERCENTAGE="<percentage>",t.LENGTH_PERCENTAGE="<length> | <percentage>",t.LENGTH_PERCENTAGE_12="[<length> | <percentage>]{1,2}",t.LENGTH_PERCENTAGE_14="[<length> | <percentage>]{1,4}",t.LIST_OF_POINTS="<list-of-points>",t.PATH="<path>",t.FILTER="<filter>",t.Z_INDEX="<z-index>",t.OFFSET_DISTANCE="<offset-distance>",t.DEFINED_PATH="<defined-path>",t.MARKER="<marker>",t.TRANSFORM="<transform>",t.TRANSFORM_ORIGIN="<transform-origin>",t.TEXT="<text>",t.TEXT_TRANSFORM="<text-transform>",t}({});function Gh(t,e,n){t.prototype=e.prototype=n,n.constructor=t}function wg(t,e){var n=Object.create(t.prototype);for(var r in e)n[r]=e[r];return n}function Xl(){}var Ul=.7,Tf=1/Ul,Yc="\\s*([+-]?\\d+)\\s*",ql="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*",co="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*",Tx=/^#([0-9a-f]{3,8})$/,Px=new RegExp(`^rgb\\(${Yc},${Yc},${Yc}\\)$`),Cx=new RegExp(`^rgb\\(${co},${co},${co}\\)$`),Lx=new RegExp(`^rgba\\(${Yc},${Yc},${Yc},${ql}\\)$`),Rx=new RegExp(`^rgba\\(${co},${co},${co},${ql}\\)$`),Nx=new RegExp(`^hsl\\(${ql},${co},${co}\\)$`),Ix=new RegExp(`^hsla\\(${ql},${co},${co},${ql}\\)$`),Og={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Gh(Xl,Kl,{copy(t){return Object.assign(new this.constructor,this,t)},displayable(){return this.rgb().displayable()},hex:Sg,formatHex:Sg,formatHex8:Dx,formatHsl:jx,formatRgb:Pf,toString:Pf});function Sg(){return this.rgb().formatHex()}function Dx(){return this.rgb().formatHex8()}function jx(){return Tg(this).formatHsl()}function Pf(){return this.rgb().formatRgb()}function Kl(t){var e,n;return t=(t+"").trim().toLowerCase(),(e=Tx.exec(t))?(n=e[1].length,e=parseInt(e[1],16),n===6?Eg(e):n===3?new Ui(e>>8&15|e>>4&240,e>>4&15|e&240,(e&15)<<4|e&15,1):n===8?Cf(e>>24&255,e>>16&255,e>>8&255,(e&255)/255):n===4?Cf(e>>12&15|e>>8&240,e>>8&15|e>>4&240,e>>4&15|e&240,((e&15)<<4|e&15)/255):null):(e=Px.exec(t))?new Ui(e[1],e[2],e[3],1):(e=Cx.exec(t))?new Ui(e[1]*255/100,e[2]*255/100,e[3]*255/100,1):(e=Lx.exec(t))?Cf(e[1],e[2],e[3],e[4]):(e=Rx.exec(t))?Cf(e[1]*255/100,e[2]*255/100,e[3]*255/100,e[4]):(e=Nx.exec(t))?Ag(e[1],e[2]/100,e[3]/100,1):(e=Ix.exec(t))?Ag(e[1],e[2]/100,e[3]/100,e[4]):Og.hasOwnProperty(t)?Eg(Og[t]):t==="transparent"?new Ui(NaN,NaN,NaN,0):null}function Eg(t){return new Ui(t>>16&255,t>>8&255,t&255,1)}function Cf(t,e,n,r){return r<=0&&(t=e=n=NaN),new Ui(t,e,n,r)}function Fx(t){return t instanceof Xl||(t=Kl(t)),t?(t=t.rgb(),new Ui(t.r,t.g,t.b,t.opacity)):new Ui}function Bx(t,e,n,r){return arguments.length===1?Fx(t):new Ui(t,e,n,r==null?1:r)}function Ui(t,e,n,r){this.r=+t,this.g=+e,this.b=+n,this.opacity=+r}Gh(Ui,Bx,wg(Xl,{brighter(t){return t=t==null?Tf:Math.pow(Tf,t),new Ui(this.r*t,this.g*t,this.b*t,this.opacity)},darker(t){return t=t==null?Ul:Math.pow(Ul,t),new Ui(this.r*t,this.g*t,this.b*t,this.opacity)},rgb(){return this},clamp(){return new Ui(Vs(this.r),Vs(this.g),Vs(this.b),Ql(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:Mg,formatHex:Mg,formatHex8:zx,formatRgb:kg,toString:kg}));function Mg(){return`#${lo(this.r)}${lo(this.g)}${lo(this.b)}`}function zx(){return`#${lo(this.r)}${lo(this.g)}${lo(this.b)}${lo((isNaN(this.opacity)?1:this.opacity)*255)}`}function kg(){const t=Ql(this.opacity);return`${t===1?"rgb(":"rgba("}${Vs(this.r)}, ${Vs(this.g)}, ${Vs(this.b)}${t===1?")":`, ${t})`}`}function Ql(t){return isNaN(t)?1:Math.max(0,Math.min(1,t))}function Vs(t){return Math.max(0,Math.min(255,Math.round(t)||0))}function lo(t){return t=Vs(t),(t<16?"0":"")+t.toString(16)}function Ag(t,e,n,r){return r<=0?t=e=n=NaN:n<=0||n>=1?t=e=NaN:e<=0&&(t=NaN),new ja(t,e,n,r)}function Tg(t){if(t instanceof ja)return new ja(t.h,t.s,t.l,t.opacity);if(t instanceof Xl||(t=Kl(t)),!t)return new ja;if(t instanceof ja)return t;t=t.rgb();var e=t.r/255,n=t.g/255,r=t.b/255,i=Math.min(e,n,r),a=Math.max(e,n,r),o=NaN,s=a-i,c=(a+i)/2;return s?(e===a?o=(n-r)/s+(n<r)*6:n===a?o=(r-e)/s+2:o=(e-n)/s+4,s/=c<.5?a+i:2-a-i,o*=60):s=c>0&&c<1?0:o,new ja(o,s,c,t.opacity)}function Wx(t,e,n,r){return arguments.length===1?Tg(t):new ja(t,e,n,r==null?1:r)}function ja(t,e,n,r){this.h=+t,this.s=+e,this.l=+n,this.opacity=+r}Gh(ja,Wx,wg(Xl,{brighter(t){return t=t==null?Tf:Math.pow(Tf,t),new ja(this.h,this.s,this.l*t,this.opacity)},darker(t){return t=t==null?Ul:Math.pow(Ul,t),new ja(this.h,this.s,this.l*t,this.opacity)},rgb(){var t=this.h%360+(this.h<0)*360,e=isNaN(t)||isNaN(this.s)?0:this.s,n=this.l,r=n+(n<.5?n:1-n)*e,i=2*n-r;return new Ui($h(t>=240?t-240:t+120,i,r),$h(t,i,r),$h(t<120?t+240:t-120,i,r),this.opacity)},clamp(){return new ja(Pg(this.h),Lf(this.s),Lf(this.l),Ql(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const t=Ql(this.opacity);return`${t===1?"hsl(":"hsla("}${Pg(this.h)}, ${Lf(this.s)*100}%, ${Lf(this.l)*100}%${t===1?")":`, ${t})`}`}}));function Pg(t){return t=(t||0)%360,t<0?t+360:t}function Lf(t){return Math.max(0,Math.min(1,t||0))}function $h(t,e,n){return(t<60?e+(n-e)*t/60:t<180?n:t<240?e+(n-e)*(240-t)/60:e)*255}function Ir(t,e){if(typeof t!="function"||e!=null&&typeof e!="function")throw new TypeError("Expected a function");var n=function(){for(var i=arguments.length,a=new Array(i),o=0;o<i;o++)a[o]=arguments[o];var s=e?e.apply(this,a):a[0],c=n.cache;if(c.has(s))return c.get(s);var l=t.apply(this,a);return n.cache=c.set(s,l)||c,l};return n.cache=new(Ir.Cache||Map),Ir.cacheList.push(n.cache),n}Ir.Cache=Map,Ir.cacheList=[],Ir.clearCache=function(){Ir.cacheList.forEach(function(t){return t.clear()})};var Zt=function(t){return t[t.kUnknown=0]="kUnknown",t[t.kNumber=1]="kNumber",t[t.kPercentage=2]="kPercentage",t[t.kEms=3]="kEms",t[t.kPixels=4]="kPixels",t[t.kRems=5]="kRems",t[t.kDegrees=6]="kDegrees",t[t.kRadians=7]="kRadians",t[t.kGradians=8]="kGradians",t[t.kTurns=9]="kTurns",t[t.kMilliseconds=10]="kMilliseconds",t[t.kSeconds=11]="kSeconds",t[t.kInteger=12]="kInteger",t}({}),Fa=function(t){return t[t.kUNumber=0]="kUNumber",t[t.kUPercent=1]="kUPercent",t[t.kULength=2]="kULength",t[t.kUAngle=3]="kUAngle",t[t.kUTime=4]="kUTime",t[t.kUOther=5]="kUOther",t}({}),Gx=function(t){return t[t.kYes=0]="kYes",t[t.kNo=1]="kNo",t}({}),$x=function(t){return t[t.kYes=0]="kYes",t[t.kNo=1]="kNo",t}({}),Zx=[{name:"em",unit_type:Zt.kEms},{name:"px",unit_type:Zt.kPixels},{name:"deg",unit_type:Zt.kDegrees},{name:"rad",unit_type:Zt.kRadians},{name:"grad",unit_type:Zt.kGradians},{name:"ms",unit_type:Zt.kMilliseconds},{name:"s",unit_type:Zt.kSeconds},{name:"rem",unit_type:Zt.kRems},{name:"turn",unit_type:Zt.kTurns}],Hc=function(t){return t[t.kUnknownType=0]="kUnknownType",t[t.kUnparsedType=1]="kUnparsedType",t[t.kKeywordType=2]="kKeywordType",t[t.kUnitType=3]="kUnitType",t[t.kSumType=4]="kSumType",t[t.kProductType=5]="kProductType",t[t.kNegateType=6]="kNegateType",t[t.kInvertType=7]="kInvertType",t[t.kMinType=8]="kMinType",t[t.kMaxType=9]="kMaxType",t[t.kClampType=10]="kClampType",t[t.kTransformType=11]="kTransformType",t[t.kPositionType=12]="kPositionType",t[t.kURLImageType=13]="kURLImageType",t[t.kColorType=14]="kColorType",t[t.kUnsupportedColorType=15]="kUnsupportedColorType",t}({}),Yx=function(e){return Zx.find(function(n){return n.name===e}).unit_type},Hx=function(e){return e?e==="number"?Zt.kNumber:e==="percent"||e==="%"?Zt.kPercentage:Yx(e):Zt.kUnknown},Cg=function(e){switch(e){case Zt.kNumber:case Zt.kInteger:return Fa.kUNumber;case Zt.kPercentage:return Fa.kUPercent;case Zt.kPixels:return Fa.kULength;case Zt.kMilliseconds:case Zt.kSeconds:return Fa.kUTime;case Zt.kDegrees:case Zt.kRadians:case Zt.kGradians:case Zt.kTurns:return Fa.kUAngle;default:return Fa.kUOther}},Lg=function(e){switch(e){case Fa.kUNumber:return Zt.kNumber;case Fa.kULength:return Zt.kPixels;case Fa.kUPercent:return Zt.kPercentage;case Fa.kUTime:return Zt.kSeconds;case Fa.kUAngle:return Zt.kDegrees;default:return Zt.kUnknown}},Rg=function(e){var n=1;switch(e){case Zt.kPixels:case Zt.kDegrees:case Zt.kSeconds:break;case Zt.kMilliseconds:n=.001;break;case Zt.kRadians:n=180/Math.PI;break;case Zt.kGradians:n=.9;break;case Zt.kTurns:n=360;break}return n},Zh=function(e){switch(e){case Zt.kNumber:case Zt.kInteger:return"";case Zt.kPercentage:return"%";case Zt.kEms:return"em";case Zt.kRems:return"rem";case Zt.kPixels:return"px";case Zt.kDegrees:return"deg";case Zt.kRadians:return"rad";case Zt.kGradians:return"grad";case Zt.kMilliseconds:return"ms";case Zt.kSeconds:return"s";case Zt.kTurns:return"turn"}return""},Rf=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"toString",value:function(){return this.buildCSSText(Gx.kNo,$x.kNo,"")}},{key:"isNumericValue",value:function(){return this.getType()>=Hc.kUnitType&&this.getType()<=Hc.kClampType}}],[{key:"isAngle",value:function(n){return n===Zt.kDegrees||n===Zt.kRadians||n===Zt.kGradians||n===Zt.kTurns}},{key:"isLength",value:function(n){return n>=Zt.kEms&&n<Zt.kDegrees}},{key:"isRelativeUnit",value:function(n){return n===Zt.kPercentage||n===Zt.kEms||n===Zt.kRems}},{key:"isTime",value:function(n){return n===Zt.kSeconds||n===Zt.kMilliseconds}}])}(),Vx=function(t){function e(n){var r;return(0,xt.Z)(this,e),r=(0,De.Z)(this,e),r.colorSpace=n,r}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"getType",value:function(){return Hc.kColorType}},{key:"to",value:function(r){return this}}])}(Rf),Ba=function(t){return t[t.Constant=0]="Constant",t[t.LinearGradient=1]="LinearGradient",t[t.RadialGradient=2]="RadialGradient",t}({}),Nf=function(t){function e(n,r){var i;return(0,xt.Z)(this,e),i=(0,De.Z)(this,e),i.type=n,i.value=r,i}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"clone",value:function(){return new e(this.type,this.value)}},{key:"buildCSSText",value:function(r,i,a){return a}},{key:"getType",value:function(){return Hc.kColorType}}])}(Rf),ka=function(t){function e(n){var r;return(0,xt.Z)(this,e),r=(0,De.Z)(this,e),r.value=n,r}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"clone",value:function(){return new e(this.value)}},{key:"getType",value:function(){return Hc.kKeywordType}},{key:"buildCSSText",value:function(r,i,a){return a+this.value}}])}(Rf),Xx=function(e){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:"",r="";return Number.isFinite(e)?r="NaN":e>0?r="infinity":r="-infinity",r+=n},Yh=function(e){return Lg(Cg(e))},Rn=function(t){function e(n){var r,i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Zt.kNumber;(0,xt.Z)(this,e),r=(0,De.Z)(this,e);var a;return typeof i=="string"?a=Hx(i):a=i,r.unit=a,r.value=n,r}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"clone",value:function(){return new e(this.value,this.unit)}},{key:"equals",value:function(r){var i=r;return this.value===i.value&&this.unit===i.unit}},{key:"getType",value:function(){return Hc.kUnitType}},{key:"convertTo",value:function(r){if(this.unit===r)return new e(this.value,this.unit);var i=Yh(this.unit);if(i!==Yh(r)||i===Zt.kUnknown)return null;var a=Rg(this.unit)/Rg(r);return new e(this.value*a,r)}},{key:"buildCSSText",value:function(r,i,a){var o;switch(this.unit){case Zt.kUnknown:break;case Zt.kInteger:o=Number(this.value).toFixed(0);break;case Zt.kNumber:case Zt.kPercentage:case Zt.kEms:case Zt.kRems:case Zt.kPixels:case Zt.kDegrees:case Zt.kRadians:case Zt.kGradians:case Zt.kMilliseconds:case Zt.kSeconds:case Zt.kTurns:{var s=-999999,c=999999,l=this.value,u=Zh(this.unit);if(l<s||l>c){var f=Zh(this.unit);!Number.isFinite(l)||Number.isNaN(l)?o=Xx(l,f):o=l+(f||"")}else o="".concat(l).concat(u)}}return a+=o,a}}])}(Rf),za=new Rn(0,"px");new Rn(1,"px");var Xs=new Rn(0,"deg"),Hh=function(t){function e(n,r,i){var a,o=arguments.length>3&&arguments[3]!==void 0?arguments[3]:1,s=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1;return(0,xt.Z)(this,e),a=(0,De.Z)(this,e,["rgb"]),a.r=n,a.g=r,a.b=i,a.alpha=o,a.isNone=s,a}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"clone",value:function(){return new e(this.r,this.g,this.b,this.alpha)}},{key:"buildCSSText",value:function(r,i,a){return"".concat(a,"rgba(").concat(this.r,",").concat(this.g,",").concat(this.b,",").concat(this.alpha,")")}}])}(Vx),Ng=new ka("unset"),Ux=new ka("initial"),qx=new ka("inherit"),Vc={"":Ng,unset:Ng,initial:Ux,inherit:qx},Kx=function(e){return Vc[e]||(Vc[e]=new ka(e)),Vc[e]},Vh=new Hh(0,0,0,0,!0),Xh=new Hh(0,0,0,0),Uh=Ir(function(t,e,n,r){return new Hh(t,e,n,r)},function(t,e,n,r){return"rgba(".concat(t,",").concat(e,",").concat(n,",").concat(r,")")}),Un=function(e){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Zt.kNumber;return new Rn(e,n)};new Rn(50,"%");function Ig(t){var e=t.type,n=t.value;return e==="hex"?"#".concat(n):e==="literal"?n:e==="rgb"?"rgb(".concat(n.join(","),")"):"rgba(".concat(n.join(","),")")}var Dg=function(){var t={linearGradient:/^(linear\-gradient)/i,repeatingLinearGradient:/^(repeating\-linear\-gradient)/i,radialGradient:/^(radial\-gradient)/i,repeatingRadialGradient:/^(repeating\-radial\-gradient)/i,conicGradient:/^(conic\-gradient)/i,sideOrCorner:/^to (left (top|bottom)|right (top|bottom)|top (left|right)|bottom (left|right)|left|right|top|bottom)/i,extentKeywords:/^(closest\-side|closest\-corner|farthest\-side|farthest\-corner|contain|cover)/,positionKeywords:/^(left|center|right|top|bottom)/i,pixelValue:/^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))px/,percentageValue:/^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))\%/,emValue:/^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))em/,angleValue:/^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,startCall:/^\(/,endCall:/^\)/,comma:/^,/,hexColor:/^\#([0-9a-fA-F]+)/,literalColor:/^([a-zA-Z]+)/,rgbColor:/^rgb/i,rgbaColor:/^rgba/i,number:/^(([0-9]*\.[0-9]+)|([0-9]+\.?))/},e="";function n(G){throw new Error("".concat(e,": ").concat(G))}function r(){var G=i();return e.length>0&&n("Invalid input not EOF"),G}function i(){return _(a)}function a(){return o("linear-gradient",t.linearGradient,c)||o("repeating-linear-gradient",t.repeatingLinearGradient,c)||o("radial-gradient",t.radialGradient,f)||o("repeating-radial-gradient",t.repeatingRadialGradient,f)||o("conic-gradient",t.conicGradient,f)}function o(G,F,W){return s(F,function(X){var Q=W();return Q&&(I(t.comma)||n("Missing comma before color stops")),{type:G,orientation:Q,colorStops:_(w)}})}function s(G,F){var W=I(G);if(W){I(t.startCall)||n("Missing (");var X=F(W);return I(t.endCall)||n("Missing )"),X}}function c(){return l()||u()}function l(){return R("directional",t.sideOrCorner,1)}function u(){return R("angular",t.angleValue,1)}function f(){var G,F=d(),W;return F&&(G=[],G.push(F),W=e,I(t.comma)&&(F=d(),F?G.push(F):e=W)),G}function d(){var G=h()||v();if(G)G.at=y();else{var F=g();if(F){G=F;var W=y();W&&(G.at=W)}else{var X=b();X&&(G={type:"default-radial",at:X})}}return G}function h(){var G=R("shape",/^(circle)/i,0);return G&&(G.style=L()||g()),G}function v(){var G=R("shape",/^(ellipse)/i,0);return G&&(G.style=C()||g()),G}function g(){return R("extent-keyword",t.extentKeywords,1)}function y(){if(R("position",/^at/,0)){var G=b();return G||n("Missing positioning value"),G}}function b(){var G=x();if(G.x||G.y)return{type:"position",value:G}}function x(){return{x:C(),y:C()}}function _(G){var F=G(),W=[];if(F)for(W.push(F);I(t.comma);)F=G(),F?W.push(F):n("One extra comma");return W}function w(){var G=O();return G||n("Expected color definition"),G.length=C(),G}function O(){return M()||A()||k()||E()}function E(){return R("literal",t.literalColor,0)}function M(){return R("hex",t.hexColor,1)}function k(){return s(t.rgbColor,function(){return{type:"rgb",value:_(P)}})}function A(){return s(t.rgbaColor,function(){return{type:"rgba",value:_(P)}})}function P(){return I(t.number)[1]}function C(){return R("%",t.percentageValue,1)||N()||L()}function N(){return R("position-keyword",t.positionKeywords,1)}function L(){return R("px",t.pixelValue,1)||R("em",t.emValue,1)}function R(G,F,W){var X=I(F);if(X)return{type:G,value:X[W]}}function I(G){var F=/^[\n\r\t\s]+/.exec(e);F&&D(F[0].length);var W=G.exec(e);return W&&D(W[0].length),W}function D(G){e=e.substring(G)}return function(G){return e=G,r()}}();function jg(t,e,n,r){var i=Cn(r.value),a=0,o=0,s=a+e/2,c=o+n/2,l=Math.abs(e*Math.cos(i))+Math.abs(n*Math.sin(i)),u=t[0]+s-Math.cos(i)*l/2,f=t[1]+c-Math.sin(i)*l/2,d=t[0]+s+Math.cos(i)*l/2,h=t[1]+c+Math.sin(i)*l/2;return{x1:u,y1:f,x2:d,y2:h}}function Qx(t,e,n,r,i,a){var o=r.value,s=i.value;r.unit===Zt.kPercentage&&(o=r.value/100*e),i.unit===Zt.kPercentage&&(s=i.value/100*n);var c=Math.max(Zi([0,0],[o,s]),Zi([0,n],[o,s]),Zi([e,n],[o,s]),Zi([e,0],[o,s]));return a&&(a instanceof Rn?c=a.value:a instanceof ka&&(a.value==="closest-side"?c=Math.min(o,e-o,s,n-s):a.value==="farthest-side"?c=Math.max(o,e-o,s,n-s):a.value==="closest-corner"&&(c=Math.min(Zi([0,0],[o,s]),Zi([0,n],[o,s]),Zi([e,n],[o,s]),Zi([e,0],[o,s]))))),{x:o+t[0],y:s+t[1],r:c}}var Jx=/^l\s*\(\s*([\d.]+)\s*\)\s*(.*)/i,t2=/^r\s*\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)\s*(.*)/i,If=/^p\s*\(\s*([axyn])\s*\)\s*(.*)/i,Jl=/[\d.]+:(#[^\s]+|[^\)]+\))/gi;function e2(t){var e,n=t.length;if(t[n-1].length=(e=t[n-1].length)!==null&&e!==void 0?e:{type:"%",value:"100"},n>1){var r;t[0].length=(r=t[0].length)!==null&&r!==void 0?r:{type:"%",value:"0"}}for(var i=0,a=Number(t[0].length.value),o=1;o<n;o++){var s,c=(s=t[o].length)===null||s===void 0?void 0:s.value;if(!ge(c)&&!ge(a)){for(var l=1;l<o-i;l++)t[i+l].length={type:"%",value:"".concat(a+(Number(c)-a)*l/(o-i))};i=o,a=Number(c)}}}var n2={left:180,top:-90,bottom:90,right:0,"left top":225,"top left":225,"left bottom":135,"bottom left":135,"right top":-45,"top right":-45,"right bottom":45,"bottom right":45},qh=Ir(function(t){var e;return t.type==="angular"?e=Number(t.value):e=n2[t.value]||0,Un(e,"deg")}),Fg=Ir(function(t){var e=50,n=50,r="%",i="%";if((t==null?void 0:t.type)==="position"){var a=t.value,o=a.x,s=a.y;(o==null?void 0:o.type)==="position-keyword"&&(o.value==="left"?e=0:o.value==="center"?e=50:o.value==="right"?e=100:o.value==="top"?n=0:o.value==="bottom"&&(n=100)),(s==null?void 0:s.type)==="position-keyword"&&(s.value==="left"?e=0:s.value==="center"?n=50:s.value==="right"?e=100:s.value==="top"?n=0:s.value==="bottom"&&(n=100)),((o==null?void 0:o.type)==="px"||(o==null?void 0:o.type)==="%"||(o==null?void 0:o.type)==="em")&&(r=o==null?void 0:o.type,e=Number(o.value)),((s==null?void 0:s.type)==="px"||(s==null?void 0:s.type)==="%"||(s==null?void 0:s.type)==="em")&&(i=s==null?void 0:s.type,n=Number(s.value))}return{cx:Un(e,r),cy:Un(n,i)}}),r2=Ir(function(t){if(t.indexOf("linear")>-1||t.indexOf("radial")>-1){var e=Dg(t);return e.map(function(s){var c=s.type,l=s.orientation,u=s.colorStops;e2(u);var f=u.map(function(_){return{offset:Un(Number(_.length.value),"%"),color:Ig(_)}});if(c==="linear-gradient")return new Nf(Ba.LinearGradient,{angle:l?qh(l):Xs,steps:f});if(c==="radial-gradient"&&(l||(l=[{type:"shape",value:"circle"}]),l[0].type==="shape"&&l[0].value==="circle")){var d=Fg(l[0].at),h=d.cx,v=d.cy,g;if(l[0].style){var y=l[0].style,b=y.type,x=y.value;b==="extent-keyword"?g=Kx(x):g=Un(x,b)}return new Nf(Ba.RadialGradient,{cx:h,cy:v,size:g,steps:f})}})}var n=t[0];if(t[1]==="("||t[2]==="("){if(n==="l"){var r=Jx.exec(t);if(r){var i,a=((i=r[2].match(Jl))===null||i===void 0?void 0:i.map(function(s){return s.split(":")}))||[];return[new Nf(Ba.LinearGradient,{angle:Un(parseFloat(r[1]),"deg"),steps:a.map(function(s){var c=(0,Te.Z)(s,2),l=c[0],u=c[1];return{offset:Un(Number(l)*100,"%"),color:u}})})]}}else if(n==="r"){var o=i2(t);if(o)if(ir(o))t=o;else return[new Nf(Ba.RadialGradient,o)]}else if(n==="p")return a2(t)}});function i2(t){var e=t2.exec(t);if(e){var n,r=((n=e[4].match(Jl))===null||n===void 0?void 0:n.map(function(i){return i.split(":")}))||[];return{cx:Un(50,"%"),cy:Un(50,"%"),steps:r.map(function(i){var a=(0,Te.Z)(i,2),o=a[0],s=a[1];return{offset:Un(Number(o)*100,"%"),color:s}})}}return null}function a2(t){var e=If.exec(t);if(e){var n=e[1],r=e[2];switch(n){case"a":n="repeat";break;case"x":n="repeat-x";break;case"y":n="repeat-y";break;case"n":n="no-repeat";break;default:n="no-repeat"}return{image:r,repetition:n}}return null}function uk(t){return!!t.type&&!!t.value}function Us(t){return t&&!!t.image}function Df(t){return t&&!ge(t.r)&&!ge(t.g)&&!ge(t.b)}var os=Ir(function(t){if(Us(t))return(0,Ee.Z)({repetition:"repeat"},t);if(ge(t)&&(t=""),t==="transparent")return Xh;if(t==="currentColor")t="black";else if(t==="none")return Vh;var e=r2(t);if(e)return e;var n=Kl(t),r=[0,0,0,0];return n!==null&&(r[0]=n.r||0,r[1]=n.g||0,r[2]=n.b||0,r[3]=n.opacity),Uh.apply(void 0,r)});function o2(t,e){if(!(!Df(t)||!Df(e)))return[[Number(t.r),Number(t.g),Number(t.b),Number(t.alpha)],[Number(e.r),Number(e.g),Number(e.b),Number(e.alpha)],function(n){var r=n.slice();if(r[3])for(var i=0;i<3;i++)r[i]=Math.round(mn(r[i],0,255));return r[3]=mn(r[3],0,1),"rgba(".concat(r.join(","),")")}]}function tu(t,e){if(ge(e))return Un(0,"px");if(e="".concat(e).trim().toLowerCase(),isFinite(Number(e))){if("px".search(t)>=0)return Un(Number(e),"px");if("deg".search(t)>=0)return Un(Number(e),"deg")}var n=[];e=e.replace(t,function(i){return n.push(i),"U".concat(i)});var r="U(".concat(t.source,")");return n.map(function(i){return Un(Number(e.replace(new RegExp("U".concat(i),"g"),"").replace(new RegExp(r,"g"),"*0")),i)})[0]}var Bg=function(e){return tu(new RegExp("px","g"),e)},s2=Ir(Bg),c2=function(e){return tu(new RegExp("%","g"),e)};Ir(c2);var Aa=function(e){return Vn(e)||isFinite(Number(e))?Un(Number(e)||0,"px"):tu(new RegExp("px|%|em|rem","g"),e)},Kh=Ir(Aa),zg=function(e){return tu(new RegExp("deg|rad|grad|turn","g"),e)},qs=Ir(zg);function We(t,e,n,r){var i=arguments.length>4&&arguments[4]!==void 0?arguments[4]:0,a="",o=t.value||0,s=e.value||0,c=Yh(t.unit),l=t.convertTo(c),u=e.convertTo(c);return l&&u?(o=l.value,s=u.value,a=Zh(t.unit)):(Rn.isLength(t.unit)||Rn.isLength(e.unit))&&(o=bn(t,i,n),s=bn(e,i,n),a="px"),[o,s,function(f){return r&&(f=Math.max(f,0)),f+a}]}function qi(t){var e=0;return t.unit===Zt.kDegrees?e=t.value:t.unit===Zt.kRadians?e=Sa(Number(t.value)):t.unit===Zt.kTurns?e=wx(Number(t.value)):t.value&&(e=t.value),e}function Ci(t,e){var n;return Array.isArray(t)?n=t.map(function(r){return Number(r)}):ir(t)?n=t.split(" ").map(function(r){return Number(r)}):Vn(t)&&(n=[t]),e===2?n.length===1?[n[0],n[0]]:[n[0],n[1]]:e===4?n.length===1?[n[0],n[0],n[0],n[0]]:n.length===2?[n[0],n[1],n[0],n[1]]:n.length===3?[n[0],n[1],n[2],n[1]]:[n[0],n[1],n[2],n[3]]:e==="even"&&n.length%2===1?[].concat((0,ln.Z)(n),(0,ln.Z)(n)):n}function bn(t,e,n){var r=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!1;if(t.unit===Zt.kPixels)return Number(t.value);if(t.unit===Zt.kPercentage&&n){var i=n.nodeName===dt.GROUP?n.getLocalBounds():n.getGeometryBounds();return(r?i.min[e]:0)+t.value/100*i.halfExtents[e]*2}return 0}var l2=function(e){return tu(/deg|rad|grad|turn|px|%/g,e)},ss=["blur","brightness","drop-shadow","contrast","grayscale","sepia","saturate","hue-rotate","invert"];function u2(){var t=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"";if(t=t.toLowerCase().trim(),t==="none")return[];for(var e=/\s*([\w-]+)\(([^)]*)\)/g,n=[],r,i=0;r=e.exec(t);){if(r.index!==i)return[];if(i=r.index+r[0].length,ss.indexOf(r[1])>-1&&n.push({name:r[1],params:r[2].split(" ").map(function(a){return l2(a)||os(a)})}),e.lastIndex===t.length)return n}return[]}function Wg(t){return t.toString()}var Gg=function(e){return typeof e=="number"?Un(e):/^\s*[-+]?(\d*\.)?\d+\s*$/.test(e)?Un(Number(e)):Un(0)},Qh=Ir(Gg);Ir(function(t){return ir(t)?t.split(" ").map(Qh):t.map(Qh)});function Jh(t,e){return[t,e,Wg]}function eu(t,e){return function(n,r){return[n,r,function(i){return Wg(mn(i,t,e))}]}}function $g(t,e){if(t.length===e.length)return[t,e,function(n){return n}]}function Wa(t){return t.parsedStyle.d.totalLength===0&&(t.parsedStyle.d.totalLength=tx(t.parsedStyle.d.absolutePath)),t.parsedStyle.d.totalLength}function Zg(t){return t.parsedStyle.points.totalLength===0&&(t.parsedStyle.points.totalLength=Gc(t.parsedStyle.points.points)),t.parsedStyle.points.totalLength}function jf(t){for(var e=0;e<t.length;e++){var n=t[e-1],r=t[e],i=r[0];if(i==="M"&&n){var a=n[0],o=[r[1],r[2]],s=void 0;a==="L"||a==="M"?s=[n[1],n[2]]:(a==="C"||a==="A"||a==="Q")&&(s=[n[n.length-2],n[n.length-1]]),s&&nu(o,s)&&(t.splice(e,1),e--)}}}function mr(t){for(var e=!1,n=t.length,r=0;r<n;r++){var i=t[r],a=i[0];if(a==="C"||a==="A"||a==="Q"){e=!0;break}}return e}function _r(t){for(var e=[],n=[],r=[],i=0;i<t.length;i++){var a=t[i],o=a[0];o==="M"?(r.length&&(n.push(r),r=[]),r.push([a[1],a[2]])):o==="Z"?r.length&&(e.push(r),r=[]):r.push([a[1],a[2]])}return r.length>0&&n.push(r),{polygons:e,polylines:n}}function nu(t,e){return t[0]===e[0]&&t[1]===e[1]}function f2(t,e){for(var n=[],r=[],i=[],a=0;a<t.length;a++){var o=t[a],s=o.currentPoint,c=o.params,l=o.prePoint,u=void 0;switch(o.command){case"Q":u=vx(l[0],l[1],c[1],c[2],c[3],c[4]);break;case"C":u=Io(l[0],l[1],c[1],c[2],c[3],c[4],c[5],c[6]);break;case"A":var f=o.arcParams;u=Wc(f.cx,f.cy,f.rx,f.ry,f.xRotation,f.startAngle,f.endAngle);break;default:n.push(s[0]),r.push(s[1]);break}u&&(o.box=u,n.push(u.x,u.x+u.width),r.push(u.y,u.y+u.height)),e&&(o.command==="L"||o.command==="M")&&o.prePoint&&o.nextPoint&&i.push(o)}n=n.filter(function(w){return!Number.isNaN(w)&&w!==1/0&&w!==-1/0}),r=r.filter(function(w){return!Number.isNaN(w)&&w!==1/0&&w!==-1/0});var d=of(n),h=of(r),v=Bc(n),g=Bc(r);if(i.length===0)return{x:d,y:h,width:v-d,height:g-h};for(var y=0;y<i.length;y++){var b=i[y],x=b.currentPoint,_=void 0;x[0]===d?(_=Ff(b,e),d-=_.xExtra):x[0]===v&&(_=Ff(b,e),v+=_.xExtra),x[1]===h?(_=Ff(b,e),h-=_.yExtra):x[1]===g&&(_=Ff(b,e),g+=_.yExtra)}return{x:d,y:h,width:v-d,height:g-h}}function Ff(t,e){var n=t.prePoint,r=t.currentPoint,i=t.nextPoint,a=Math.pow(r[0]-n[0],2)+Math.pow(r[1]-n[1],2),o=Math.pow(r[0]-i[0],2)+Math.pow(r[1]-i[1],2),s=Math.pow(n[0]-i[0],2)+Math.pow(n[1]-i[1],2),c=Math.acos((a+o-s)/(2*Math.sqrt(a)*Math.sqrt(o)));if(!c||Math.sin(c)===0||$s(c,0))return{xExtra:0,yExtra:0};var l=Math.abs(Math.atan2(i[1]-r[1],i[0]-r[0])),u=Math.abs(Math.atan2(i[0]-r[0],i[1]-r[1]));l=l>Math.PI/2?Math.PI-l:l,u=u>Math.PI/2?Math.PI-u:u;var f={xExtra:Math.cos(c/2-l)*(e/2*(1/Math.sin(c/2)))-e/2||0,yExtra:Math.cos(u-c/2)*(e/2*(1/Math.sin(c/2)))-e/2||0};return f}function Yg(t,e){return[e[0]+(e[0]-t[0]),e[1]+(e[1]-t[1])]}var Hg=function(e,n){var r=e.x*n.x+e.y*n.y,i=Math.sqrt((Math.pow(e.x,2)+Math.pow(e.y,2))*(Math.pow(n.x,2)+Math.pow(n.y,2))),a=e.x*n.y-e.y*n.x<0?-1:1,o=a*Math.acos(r/i);return o},Vg=function(e,n,r,i,a,o,s,c){n=Math.abs(n),r=Math.abs(r),i=sf(i,360);var l=Cn(i);if(e.x===s.x&&e.y===s.y)return{x:e.x,y:e.y,ellipticalArcAngle:0};if(n===0||r===0)return{x:0,y:0,ellipticalArcAngle:0};var u=(e.x-s.x)/2,f=(e.y-s.y)/2,d={x:Math.cos(l)*u+Math.sin(l)*f,y:-Math.sin(l)*u+Math.cos(l)*f},h=Math.pow(d.x,2)/Math.pow(n,2)+Math.pow(d.y,2)/Math.pow(r,2);h>1&&(n*=Math.sqrt(h),r*=Math.sqrt(h));var v=Math.pow(n,2)*Math.pow(r,2)-Math.pow(n,2)*Math.pow(d.y,2)-Math.pow(r,2)*Math.pow(d.x,2),g=Math.pow(n,2)*Math.pow(d.y,2)+Math.pow(r,2)*Math.pow(d.x,2),y=v/g;y=y<0?0:y;var b=(a!==o?1:-1)*Math.sqrt(y),x={x:b*(n*d.y/r),y:b*(-(r*d.x)/n)},_={x:Math.cos(l)*x.x-Math.sin(l)*x.y+(e.x+s.x)/2,y:Math.sin(l)*x.x+Math.cos(l)*x.y+(e.y+s.y)/2},w={x:(d.x-x.x)/n,y:(d.y-x.y)/r},O=Hg({x:1,y:0},w),E={x:(-d.x-x.x)/n,y:(-d.y-x.y)/r},M=Hg(w,E);!o&&M>0?M-=2*Math.PI:o&&M<0&&(M+=2*Math.PI),M%=2*Math.PI;var k=O+M*c,A=n*Math.cos(k),P=r*Math.sin(k),C={x:Math.cos(l)*A-Math.sin(l)*P+_.x,y:Math.sin(l)*A+Math.cos(l)*P+_.y,ellipticalArcStartAngle:O,ellipticalArcEndAngle:O+M,ellipticalArcAngle:k,ellipticalArcCenter:_,resultantRx:n,resultantRy:r};return C};function d2(t){for(var e=[],n=null,r=null,i=null,a=0,o=t.length,s=0;s<o;s++){var c=t[s];r=t[s+1];var l=c[0],u={command:l,prePoint:n,params:c,startTangent:null,endTangent:null,currentPoint:null,nextPoint:null,arcParams:null,box:null,cubicParams:null};switch(l){case"M":i=[c[1],c[2]],a=s;break;case"A":var f=Ug(n,c);u.arcParams=f;break}if(l==="Z")n=i,r=t[a+1];else{var d=c.length;n=[c[d-2],c[d-1]]}r&&r[0]==="Z"&&(r=t[a],e[a]&&(e[a].prePoint=n)),u.currentPoint=n,e[a]&&nu(n,e[a].currentPoint)&&(e[a].prePoint=u.prePoint);var h=r?[r[r.length-2],r[r.length-1]]:null;u.nextPoint=h;var v=u.prePoint;if(["L","H","V"].includes(l))u.startTangent=[v[0]-n[0],v[1]-n[1]],u.endTangent=[n[0]-v[0],n[1]-v[1]];else if(l==="Q"){var g=[c[1],c[2]];u.startTangent=[v[0]-g[0],v[1]-g[1]],u.endTangent=[n[0]-g[0],n[1]-g[1]]}else if(l==="T"){var y=e[s-1],b=Yg(y.currentPoint,v);y.command==="Q"?(u.command="Q",u.startTangent=[v[0]-b[0],v[1]-b[1]],u.endTangent=[n[0]-b[0],n[1]-b[1]]):(u.command="TL",u.startTangent=[v[0]-n[0],v[1]-n[1]],u.endTangent=[n[0]-v[0],n[1]-v[1]])}else if(l==="C"){var x=[c[1],c[2]],_=[c[3],c[4]];u.startTangent=[v[0]-x[0],v[1]-x[1]],u.endTangent=[n[0]-_[0],n[1]-_[1]],u.startTangent[0]===0&&u.startTangent[1]===0&&(u.startTangent=[x[0]-_[0],x[1]-_[1]]),u.endTangent[0]===0&&u.endTangent[1]===0&&(u.endTangent=[_[0]-x[0],_[1]-x[1]])}else if(l==="S"){var w=e[s-1],O=Yg(w.currentPoint,v),E=[c[1],c[2]];w.command==="C"?(u.command="C",u.startTangent=[v[0]-O[0],v[1]-O[1]],u.endTangent=[n[0]-E[0],n[1]-E[1]]):(u.command="SQ",u.startTangent=[v[0]-E[0],v[1]-E[1]],u.endTangent=[n[0]-E[0],n[1]-E[1]])}else if(l==="A"){var M=tp(u,0),k=M.x,A=M.y,P=tp(u,1,!1),C=P.x,N=P.y;u.startTangent=[k,A],u.endTangent=[C,N]}e.push(u)}return e}function tp(t,e){var n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!0,r=t.arcParams,i=r.rx,a=i===void 0?0:i,o=r.ry,s=o===void 0?0:o,c=r.xRotation,l=r.arcFlag,u=r.sweepFlag,f=Vg({x:t.prePoint[0],y:t.prePoint[1]},a,s,c,!!l,!!u,{x:t.currentPoint[0],y:t.currentPoint[1]},e),d=Vg({x:t.prePoint[0],y:t.prePoint[1]},a,s,c,!!l,!!u,{x:t.currentPoint[0],y:t.currentPoint[1]},n?e+.005:e-.005),h=d.x-f.x,v=d.y-f.y,g=Math.sqrt(h*h+v*v);return{x:-h/g,y:-v/g}}function cs(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1])}function ru(t,e){return cs(t)*cs(e)?(t[0]*e[0]+t[1]*e[1])/(cs(t)*cs(e)):1}function Xg(t,e){return(t[0]*e[1]<t[1]*e[0]?-1:1)*Math.acos(ru(t,e))}function Ug(t,e){var n=e[1],r=e[2],i=sf(Cn(e[3]),Math.PI*2),a=e[4],o=e[5],s=t[0],c=t[1],l=e[6],u=e[7],f=Math.cos(i)*(s-l)/2+Math.sin(i)*(c-u)/2,d=-1*Math.sin(i)*(s-l)/2+Math.cos(i)*(c-u)/2,h=f*f/(n*n)+d*d/(r*r);h>1&&(n*=Math.sqrt(h),r*=Math.sqrt(h));var v=n*n*(d*d)+r*r*(f*f),g=v?Math.sqrt((n*n*(r*r)-v)/v):1;a===o&&(g*=-1),isNaN(g)&&(g=0);var y=r?g*n*d/r:0,b=n?g*-r*f/n:0,x=(s+l)/2+Math.cos(i)*y-Math.sin(i)*b,_=(c+u)/2+Math.sin(i)*y+Math.cos(i)*b,w=[(f-y)/n,(d-b)/r],O=[(-1*f-y)/n,(-1*d-b)/r],E=Xg([1,0],w),M=Xg(w,O);return ru(w,O)<=-1&&(M=Math.PI),ru(w,O)>=1&&(M=0),o===0&&M>0&&(M-=2*Math.PI),o===1&&M<0&&(M+=2*Math.PI),{cx:x,cy:_,rx:nu(t,[l,u])?0:n,ry:nu(t,[l,u])?0:r,startAngle:E,endAngle:E+M,xRotation:i,arcFlag:a,sweepFlag:o}}function Bf(t,e,n){return t.reduce(function(r,i){var a="";if(i[0]==="M"||i[0]==="L"){var o=sn(i[1],i[2],0);n&&er(o,o,n),a="".concat(i[0]).concat(o[0],",").concat(o[1])}else if(i[0]==="Z")a=i[0];else if(i[0]==="C"){var s=sn(i[1],i[2],0),c=sn(i[3],i[4],0),l=sn(i[5],i[6],0);n&&(er(s,s,n),er(c,c,n),er(l,l,n)),a="".concat(i[0]).concat(s[0],",").concat(s[1],",").concat(c[0],",").concat(c[1],",").concat(l[0],",").concat(l[1])}else if(i[0]==="A"){var u=sn(i[6],i[7],0);n&&er(u,u,n),a="".concat(i[0]).concat(i[1],",").concat(i[2],",").concat(i[3],",").concat(i[4],",").concat(i[5],",").concat(u[0],",").concat(u[1])}else if(i[0]==="Q"){var f=sn(i[1],i[2],0),d=sn(i[3],i[4],0);n&&(er(f,f,n),er(d,d,n)),a="".concat(i[0]).concat(i[1],",").concat(i[2],",").concat(i[3],",").concat(i[4],"}")}return r+=a},"")}function da(t,e,n,r){return[["M",t,e],["L",n,r]]}function Ks(t,e,n,r){var i=(-1+Math.sqrt(2))/3*4,a=t*i,o=e*i,s=n-t,c=n+t,l=r-e,u=r+e;return[["M",s,r],["C",s,r-o,n-a,l,n,l],["C",n+a,l,c,r-o,c,r],["C",c,r+o,n+a,u,n,u],["C",n-a,u,s,r+o,s,r],["Z"]]}function h2(t,e){var n=t.map(function(r,i){return[i===0?"M":"L",r[0],r[1]]});return e&&n.push(["Z"]),n}function p2(t,e,n,r,i){if(i){var a=(0,Te.Z)(i,4),o=a[0],s=a[1],c=a[2],l=a[3],u=t>0?1:-1,f=e>0?1:-1,d=u+f!==0?1:0;return[["M",u*o+n,r],["L",t-u*s+n,r],s?["A",s,s,0,0,d,t+n,f*s+r]:null,["L",t+n,e-f*c+r],c?["A",c,c,0,0,d,t+n-u*c,e+r]:null,["L",n+u*l,e+r],l?["A",l,l,0,0,d,n,e+r-f*l]:null,["L",n,f*o+r],o?["A",o,o,0,0,d,u*o+n,r]:null,["Z"]].filter(function(h){return h})}return[["M",n,r],["L",n+t,r],["L",n+t,r+e],["L",n,r+e],["Z"]]}function qg(t){var e=arguments.length>1&&arguments[1]!==void 0?arguments[1]:t.getLocalTransform(),n=[];switch(t.nodeName){case dt.LINE:var r=t.parsedStyle,i=r.x1,a=i===void 0?0:i,o=r.y1,s=o===void 0?0:o,c=r.x2,l=c===void 0?0:c,u=r.y2,f=u===void 0?0:u;n=da(a,s,l,f);break;case dt.CIRCLE:{var d=t.parsedStyle,h=d.r,v=h===void 0?0:h,g=d.cx,y=g===void 0?0:g,b=d.cy,x=b===void 0?0:b;n=Ks(v,v,y,x);break}case dt.ELLIPSE:{var _=t.parsedStyle,w=_.rx,O=w===void 0?0:w,E=_.ry,M=E===void 0?0:E,k=_.cx,A=k===void 0?0:k,P=_.cy,C=P===void 0?0:P;n=Ks(O,M,A,C);break}case dt.POLYLINE:case dt.POLYGON:var N=t.parsedStyle.points;n=h2(N.points,t.nodeName===dt.POLYGON);break;case dt.RECT:var L=t.parsedStyle,R=L.width,I=R===void 0?0:R,D=L.height,G=D===void 0?0:D,F=L.x,W=F===void 0?0:F,X=L.y,Q=X===void 0?0:X,tt=L.radius,nt=tt&&tt.some(function(lt){return lt!==0});n=p2(I,G,W,Q,nt&&tt.map(function(lt){return mn(lt,0,Math.min(Math.abs(I)/2,Math.abs(G)/2))}));break;case dt.PATH:var ht=t.parsedStyle.d.absolutePath;n=(0,ln.Z)(ht);break}if(n.length)return Bf(n,t,e)}function fk(t){var e=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,r=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,i=arguments.length>4&&arguments[4]!==void 0?arguments[4]:0,a=t.map(function(o,s){var c=o[0],l=t[s+1],u=s===0&&(e!==0||n!==0),f=(s===t.length-1||l&&(l[0]==="M"||l[0]==="Z"))&&r!==0&&i!==0,d=u?[e,n]:[0,0],h=_slicedToArray(d,2),v=h[0],g=h[1],y=f?[r,i]:[0,0],b=_slicedToArray(y,2),x=b[0],_=b[1];switch(c){case"M":return"M ".concat(o[1]+v,",").concat(o[2]+g);case"L":return"L ".concat(o[1]+x,",").concat(o[2]+_);case"Q":return"Q ".concat(o[1]," ").concat(o[2],",").concat(o[3]+x," ").concat(o[4]+_);case"C":return"C ".concat(o[1]," ").concat(o[2],",").concat(o[3]," ").concat(o[4],",").concat(o[5]+x," ").concat(o[6]+_);case"A":return"A ".concat(o[1]," ").concat(o[2]," ").concat(o[3]," ").concat(o[4]," ").concat(o[5]," ").concat(o[6]," ").concat(o[7]).concat(f?" L ".concat(o[6]+r,",").concat(o[7]+i):"");case"Z":return"Z";default:return null}}).filter(function(o){return o!==null}).join(" ");return~a.indexOf("NaN")?"":a}var Kg=function(e){if(e===""||Array.isArray(e)&&e.length===0)return{absolutePath:[],hasArc:!1,segments:[],polygons:[],polylines:[],curve:null,totalLength:0,rect:{x:0,y:0,width:0,height:0}};var n;try{n=jl(e)}catch(h){n=jl(""),console.error("[g]: Invalid SVG Path definition: ".concat(e))}jf(n);var r=mr(n),i=_r(n),a=i.polygons,o=i.polylines,s=d2(n),c=f2(s,0),l=c.x,u=c.y,f=c.width,d=c.height;return{absolutePath:n,hasArc:r,segments:s,polygons:a,polylines:o,totalLength:0,rect:{x:Number.isFinite(l)?l:0,y:Number.isFinite(u)?u:0,width:Number.isFinite(f)?f:0,height:Number.isFinite(d)?d:0}}},Qg=Ir(Kg);function uo(t){return ir(t)?Qg(t):Kg(t)}function Ve(t,e,n){var r=t.curve,i=e.curve;(!r||r.length===0)&&(r=Yi(t.absolutePath,!1),t.curve=r),(!i||i.length===0)&&(i=Yi(e.absolutePath,!1),e.curve=i);var a=[r,i];r.length!==i.length&&(a=lf(r,i));var o=Hi(a[0])!==Hi(a[1])?ns(a[0]):Ah(a[0]);return[o,uf(a[1],o),function(s){return s}]}function Jg(t,e){var n;return ir(t)?n=t.split(" ").map(function(r){var i=r.split(","),a=(0,Te.Z)(i,2),o=a[0],s=a[1];return[Number(o),Number(s)]}):n=t,{points:n,totalLength:0,segments:[]}}function Ta(t,e){return[t.points,e.points,function(n){return n}]}var ur=null,Xc=/\s*(\w+)\(([^)]*)\)/g;function Ge(t){return function(e){var n=0;return t.map(function(r){return r===ur?e[n++]:r})}}function Qs(t){return t}var Uc={matrix:["NNNNNN",[ur,ur,0,0,ur,ur,0,0,0,0,1,0,ur,ur,0,1],Qs],matrix3d:["NNNNNNNNNNNNNNNN",Qs],rotate:["A"],rotateX:["A"],rotateY:["A"],rotateZ:["A"],rotate3d:["NNNA"],perspective:["L"],scale:["Nn",Ge([ur,ur,new Rn(1)]),Qs],scaleX:["N",Ge([ur,new Rn(1),new Rn(1)]),Ge([ur,new Rn(1)])],scaleY:["N",Ge([new Rn(1),ur,new Rn(1)]),Ge([new Rn(1),ur])],scaleZ:["N",Ge([new Rn(1),new Rn(1),ur])],scale3d:["NNN",Qs],skew:["Aa",null,Qs],skewX:["A",null,Ge([ur,Xs])],skewY:["A",null,Ge([Xs,ur])],translate:["Tt",Ge([ur,ur,za]),Qs],translateX:["T",Ge([ur,za,za]),Ge([ur,za])],translateY:["T",Ge([za,ur,za]),Ge([za,ur])],translateZ:["L",Ge([za,za,ur])],translate3d:["TTL",Qs]};function iu(t){for(var e=[],n=t.length,r=0;r<n;r++){var i=t[r],a=i[0],o=i.slice(1);a==="translate"||a==="skew"?o.length===1&&o.push(0):a==="scale"&&o.length===1&&o.push(o[0]);var s=Uc[a];if(!s)return[];var c=o.map(function(l){return Un(l)});e.push({t:a,d:c})}return e}function ty(t){if(Array.isArray(t))return iu(t);if(t=(t||"none").trim(),t==="none")return[];var e=[],n,r=0;for(Xc.lastIndex=0;n=Xc.exec(t);){if(n.index!==r)return[];r=n.index+n[0].length;var i=n[1],a=Uc[i];if(!a)return[];var o=n[2].split(","),s=a[0];if(s.length<o.length)return[];for(var c=[],l=0;l<s.length;l++){var u=o[l],f=s[l],d=void 0;if(u?d={A:function(v){return v.trim()==="0"?Xs:qs(v)},N:Qh,T:Kh,L:s2}[f.toUpperCase()](u):d={a:Xs,n:c[0],t:za}[f],d===void 0)return[];c.push(d)}if(e.push({t:i,d:c}),Xc.lastIndex===t.length)return e}return[]}function v2(t){if(Array.isArray(t))return iu(t);if(t=(t||"none").trim(),t==="none")return[];var e=[],n,r=0;for(Xc.lastIndex=0;n=Xc.exec(t);){if(n.index!==r)return[];r=n.index+n[0].length;var i=n[1],a=Uc[i];if(!a)return[];var o=n[2].split(","),s=a[0];if(s.length<o.length)return[];for(var c=[],l=0;l<s.length;l++){var u=o[l],f=s[l],d=void 0;if(u?d={A:function(v){return v.trim()==="0"?Xs:zg(v)},N:Gg,T:Aa,L:Bg}[f.toUpperCase()](u):d={a:Xs,n:c[0],t:za}[f],d===void 0)return[];c.push(d)}if(e.push({t:i,d:c}),Xc.lastIndex===t.length)return e}return[]}function g2(t){var e,n,r,i;switch(t.t){case"rotateX":return i=Cn(qi(t.d[0])),[1,0,0,0,0,Math.cos(i),Math.sin(i),0,0,-Math.sin(i),Math.cos(i),0,0,0,0,1];case"rotateY":return i=Cn(qi(t.d[0])),[Math.cos(i),0,-Math.sin(i),0,0,1,0,0,Math.sin(i),0,Math.cos(i),0,0,0,0,1];case"rotate":case"rotateZ":return i=Cn(qi(t.d[0])),[Math.cos(i),Math.sin(i),0,0,-Math.sin(i),Math.cos(i),0,0,0,0,1,0,0,0,0,1];case"rotate3d":e=t.d[0].value,n=t.d[1].value,r=t.d[2].value,i=Cn(qi(t.d[3]));var a=e*e+n*n+r*r;if(a===0)e=1,n=0,r=0;else if(a!==1){var o=Math.sqrt(a);e/=o,n/=o,r/=o}var s=Math.sin(i/2),c=s*Math.cos(i/2),l=s*s;return[1-2*(n*n+r*r)*l,2*(e*n*l+r*c),2*(e*r*l-n*c),0,2*(e*n*l-r*c),1-2*(e*e+r*r)*l,2*(n*r*l+e*c),0,2*(e*r*l+n*c),2*(n*r*l-e*c),1-2*(e*e+n*n)*l,0,0,0,0,1];case"scale":return[t.d[0].value,0,0,0,0,t.d[1].value,0,0,0,0,1,0,0,0,0,1];case"scaleX":return[t.d[0].value,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];case"scaleY":return[1,0,0,0,0,t.d[0].value,0,0,0,0,1,0,0,0,0,1];case"scaleZ":return[1,0,0,0,0,1,0,0,0,0,t.d[0].value,0,0,0,0,1];case"scale3d":return[t.d[0].value,0,0,0,0,t.d[1].value,0,0,0,0,t.d[2].value,0,0,0,0,1];case"skew":var u=Cn(qi(t.d[0])),f=Cn(qi(t.d[1]));return[1,Math.tan(f),0,0,Math.tan(u),1,0,0,0,0,1,0,0,0,0,1];case"skewX":return i=Cn(qi(t.d[0])),[1,0,0,0,Math.tan(i),1,0,0,0,0,1,0,0,0,0,1];case"skewY":return i=Cn(qi(t.d[0])),[1,Math.tan(i),0,0,0,1,0,0,0,0,1,0,0,0,0,1];case"translate":return e=bn(t.d[0],0,null)||0,n=bn(t.d[1],0,null)||0,[1,0,0,0,0,1,0,0,0,0,1,0,e,n,0,1];case"translateX":return e=bn(t.d[0],0,null)||0,[1,0,0,0,0,1,0,0,0,0,1,0,e,0,0,1];case"translateY":return n=bn(t.d[0],0,null)||0,[1,0,0,0,0,1,0,0,0,0,1,0,0,n,0,1];case"translateZ":return r=bn(t.d[0],0,null)||0,[1,0,0,0,0,1,0,0,0,0,1,0,0,0,r,1];case"translate3d":return e=bn(t.d[0],0,null)||0,n=bn(t.d[1],0,null)||0,r=bn(t.d[2],0,null)||0,[1,0,0,0,0,1,0,0,0,0,1,0,e,n,r,1];case"perspective":var d=bn(t.d[0],0,null)||0,h=d?-1/d:0;return[1,0,0,0,0,1,0,0,0,0,1,h,0,0,0,1];case"matrix":return[t.d[0].value,t.d[1].value,0,0,t.d[2].value,t.d[3].value,0,0,0,0,1,0,t.d[4].value,t.d[5].value,0,1];case"matrix3d":return t.d.map(function(v){return v.value})}}function y2(t,e){return[t[0]*e[0]+t[4]*e[1]+t[8]*e[2]+t[12]*e[3],t[1]*e[0]+t[5]*e[1]+t[9]*e[2]+t[13]*e[3],t[2]*e[0]+t[6]*e[1]+t[10]*e[2]+t[14]*e[3],t[3]*e[0]+t[7]*e[1]+t[11]*e[2]+t[15]*e[3],t[0]*e[4]+t[4]*e[5]+t[8]*e[6]+t[12]*e[7],t[1]*e[4]+t[5]*e[5]+t[9]*e[6]+t[13]*e[7],t[2]*e[4]+t[6]*e[5]+t[10]*e[6]+t[14]*e[7],t[3]*e[4]+t[7]*e[5]+t[11]*e[6]+t[15]*e[7],t[0]*e[8]+t[4]*e[9]+t[8]*e[10]+t[12]*e[11],t[1]*e[8]+t[5]*e[9]+t[9]*e[10]+t[13]*e[11],t[2]*e[8]+t[6]*e[9]+t[10]*e[10]+t[14]*e[11],t[3]*e[8]+t[7]*e[9]+t[11]*e[10]+t[15]*e[11],t[0]*e[12]+t[4]*e[13]+t[8]*e[14]+t[12]*e[15],t[1]*e[12]+t[5]*e[13]+t[9]*e[14]+t[13]*e[15],t[2]*e[12]+t[6]*e[13]+t[10]*e[14]+t[14]*e[15],t[3]*e[12]+t[7]*e[13]+t[11]*e[14]+t[15]*e[15]]}function m2(t){return t.length===0?[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]:t.map(g2).reduce(y2)}function ey(t){var e=[0,0,0],n=[1,1,1],r=[0,0,0],i=[0,0,0,1],a=[0,0,0,1];return Ex(m2(t),e,n,r,i,a),[[e,n,r,a,i]]}var b2=function(){function t(r,i){for(var a=[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],o=0;o<4;o++)for(var s=0;s<4;s++)for(var c=0;c<4;c++)a[o][s]+=i[o][c]*r[c][s];return a}function e(r){return r[0][2]===0&&r[0][3]===0&&r[1][2]===0&&r[1][3]===0&&r[2][0]===0&&r[2][1]===0&&r[2][2]===1&&r[2][3]===0&&r[3][2]===0&&r[3][3]===1}function n(r,i,a,o,s){for(var c=[[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]],l=0;l<4;l++)c[l][3]=s[l];for(var u=0;u<3;u++)for(var f=0;f<3;f++)c[3][u]+=r[f]*c[f][u];var d=o[0],h=o[1],v=o[2],g=o[3],y=[[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]];y[0][0]=1-2*(h*h+v*v),y[0][1]=2*(d*h-v*g),y[0][2]=2*(d*v+h*g),y[1][0]=2*(d*h+v*g),y[1][1]=1-2*(d*d+v*v),y[1][2]=2*(h*v-d*g),y[2][0]=2*(d*v-h*g),y[2][1]=2*(h*v+d*g),y[2][2]=1-2*(d*d+h*h),c=t(c,y);var b=[[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]];a[2]&&(b[2][1]=a[2],c=t(c,b)),a[1]&&(b[2][1]=0,b[2][0]=a[0],c=t(c,b)),a[0]&&(b[2][0]=0,b[1][0]=a[0],c=t(c,b));for(var x=0;x<3;x++)for(var _=0;_<3;_++)c[x][_]*=i[x];return e(c)?[c[0][0],c[0][1],c[1][0],c[1][1],c[3][0],c[3][1]]:c[0].concat(c[1],c[2],c[3])}return n}();function x2(t){return t.toFixed(6).replace(".000000","")}function ep(t,e){var n,r;return t.decompositionPair!==e&&(t.decompositionPair=e,n=ey(t)),e.decompositionPair!==t&&(e.decompositionPair=t,r=ey(e)),n[0]===null||r[0]===null?[[!1],[!0],function(i){return i?e[0].d:t[0].d}]:(n[0].push(0),r[0].push(1),[n,r,function(i){var a=w2(n[0][3],r[0][3],i[5]),o=b2(i[0],i[1],i[2],a,i[4]),s=o.map(x2).join(",");return s}])}function _2(t,e){for(var n=0,r=0;r<t.length;r++)n+=t[r]*e[r];return n}function w2(t,e,n){var r=_2(t,e);r=mn(r,-1,1);var i=[];if(r===1)i=t;else for(var a=Math.acos(r),o=Math.sin(n*a)*1/Math.sqrt(1-r*r),s=0;s<4;s++)i.push(t[s]*(Math.cos(n*a)-r*o)+e[s]*o);return i}function np(t){return t.replace(/[XY]/,"")}function rp(t){return t.replace(/(X|Y|Z|3d)?$/,"3d")}var ip=function(e,n){return e==="perspective"&&n==="perspective"||(e==="matrix"||e==="matrix3d")&&(n==="matrix"||n==="matrix3d")};function O2(t,e,n){var r=!1;if(!t.length||!e.length){t.length||(r=!0,t=e,e=[]);for(var i=function(){var C=t[a],N=C.t,L=C.d,R=N.substring(0,5)==="scale"?1:0;e.push({t:N,d:L.map(function(I){return typeof I=="number"?Un(R):Un(R,I.unit)})})},a=0;a<t.length;a++)i()}var o=[],s=[],c=[];if(t.length!==e.length){var l=ep(t,e);o=[l[0]],s=[l[1]],c=[["matrix",[l[2]]]]}else for(var u=0;u<t.length;u++){var f=t[u].t,d=e[u].t,h=t[u].d,v=e[u].d,g=Uc[f],y=Uc[d],b=void 0;if(ip(f,d)){var x=ep([t[u]],[e[u]]);o.push(x[0]),s.push(x[1]),c.push(["matrix",[x[2]]]);continue}else if(f===d)b=f;else if(g[2]&&y[2]&&np(f)===np(d))b=np(f),h=g[2](h),v=y[2](v);else if(g[1]&&y[1]&&rp(f)===rp(d))b=rp(f),h=g[1](h),v=y[1](v);else{var _=ep(t,e);o=[_[0]],s=[_[1]],c=[["matrix",[_[2]]]];break}for(var w=[],O=[],E=[],M=0;M<h.length;M++){var k=We(h[M],v[M],n,!1,M);w[M]=k[0],O[M]=k[1],E.push(k[2])}o.push(w),s.push(O),c.push([b,E])}if(r){var A=o;o=s,s=A}return[o,s,function(P){return P.map(function(C,N){var L=C.map(function(R,I){return c[N][1][I](R)}).join(",");return c[N][0]==="matrix"&&L.split(",").length===16&&(c[N][0]="matrix3d"),c[N][0]==="matrix3d"&&L.split(",").length===6&&(c[N][0]="matrix"),"".concat(c[N][0],"(").concat(L,")")}).join(" ")}]}var ap=Ir(function(t){if(ir(t)){if(t==="text-anchor")return[Un(0,"px"),Un(0,"px")];var e=t.split(" ");return e.length===1&&(e[0]==="top"||e[0]==="bottom"?(e[1]=e[0],e[0]="center"):e[1]="center"),e.length!==2?null:[Kh(ny(e[0])),Kh(ny(e[1]))]}return[Un(t[0]||0,"px"),Un(t[1]||0,"px")]});function ny(t){return t==="center"?"50%":t==="left"||t==="top"?"0%":t==="right"||t==="bottom"?"100%":t}var op=[{n:"display",k:["none"]},{n:"opacity",int:!0,inh:!0,d:"1",syntax:zt.OPACITY_VALUE},{n:"fillOpacity",int:!0,inh:!0,d:"1",syntax:zt.OPACITY_VALUE},{n:"strokeOpacity",int:!0,inh:!0,d:"1",syntax:zt.OPACITY_VALUE},{n:"fill",int:!0,k:["none"],d:"none",syntax:zt.PAINT},{n:"fillRule",k:["nonzero","evenodd"],d:"nonzero"},{n:"stroke",int:!0,k:["none"],d:"none",syntax:zt.PAINT,l:!0},{n:"shadowType",k:["inner","outer","both"],d:"outer",l:!0},{n:"shadowColor",int:!0,syntax:zt.COLOR},{n:"shadowOffsetX",int:!0,l:!0,d:"0",syntax:zt.LENGTH_PERCENTAGE},{n:"shadowOffsetY",int:!0,l:!0,d:"0",syntax:zt.LENGTH_PERCENTAGE},{n:"shadowBlur",int:!0,l:!0,d:"0",syntax:zt.SHADOW_BLUR},{n:"lineWidth",int:!0,inh:!0,d:"1",l:!0,a:["strokeWidth"],syntax:zt.LENGTH_PERCENTAGE},{n:"increasedLineWidthForHitTesting",inh:!0,d:"0",l:!0,syntax:zt.LENGTH_PERCENTAGE},{n:"lineJoin",inh:!0,l:!0,a:["strokeLinejoin"],k:["miter","bevel","round"],d:"miter"},{n:"lineCap",inh:!0,l:!0,a:["strokeLinecap"],k:["butt","round","square"],d:"butt"},{n:"lineDash",int:!0,inh:!0,k:["none"],a:["strokeDasharray"],syntax:zt.LENGTH_PERCENTAGE_12},{n:"lineDashOffset",int:!0,inh:!0,d:"0",a:["strokeDashoffset"],syntax:zt.LENGTH_PERCENTAGE},{n:"offsetPath",syntax:zt.DEFINED_PATH},{n:"offsetDistance",int:!0,syntax:zt.OFFSET_DISTANCE},{n:"dx",int:!0,l:!0,d:"0",syntax:zt.LENGTH_PERCENTAGE},{n:"dy",int:!0,l:!0,d:"0",syntax:zt.LENGTH_PERCENTAGE},{n:"zIndex",ind:!0,int:!0,d:"0",k:["auto"],syntax:zt.Z_INDEX},{n:"visibility",k:["visible","hidden"],ind:!0,inh:!0,int:!0,d:"visible"},{n:"pointerEvents",inh:!0,k:["none","auto","stroke","fill","painted","visible","visiblestroke","visiblefill","visiblepainted","all"],d:"auto"},{n:"filter",ind:!0,l:!0,k:["none"],d:"none",syntax:zt.FILTER},{n:"clipPath",syntax:zt.DEFINED_PATH},{n:"textPath",syntax:zt.DEFINED_PATH},{n:"textPathSide",k:["left","right"],d:"left"},{n:"textPathStartOffset",l:!0,d:"0",syntax:zt.LENGTH_PERCENTAGE},{n:"transform",p:100,int:!0,k:["none"],d:"none",syntax:zt.TRANSFORM},{n:"transformOrigin",p:100,d:"0 0",l:!0,syntax:zt.TRANSFORM_ORIGIN},{n:"cx",int:!0,l:!0,d:"0",syntax:zt.COORDINATE},{n:"cy",int:!0,l:!0,d:"0",syntax:zt.COORDINATE},{n:"cz",int:!0,l:!0,d:"0",syntax:zt.COORDINATE},{n:"r",int:!0,l:!0,d:"0",syntax:zt.LENGTH_PERCENTAGE},{n:"rx",int:!0,l:!0,d:"0",syntax:zt.LENGTH_PERCENTAGE},{n:"ry",int:!0,l:!0,d:"0",syntax:zt.LENGTH_PERCENTAGE},{n:"x",int:!0,l:!0,d:"0",syntax:zt.COORDINATE},{n:"y",int:!0,l:!0,d:"0",syntax:zt.COORDINATE},{n:"z",int:!0,l:!0,d:"0",syntax:zt.COORDINATE},{n:"width",int:!0,l:!0,k:["auto","fit-content","min-content","max-content"],d:"0",syntax:zt.LENGTH_PERCENTAGE},{n:"height",int:!0,l:!0,k:["auto","fit-content","min-content","max-content"],d:"0",syntax:zt.LENGTH_PERCENTAGE},{n:"radius",int:!0,l:!0,d:"0",syntax:zt.LENGTH_PERCENTAGE_14},{n:"x1",int:!0,l:!0,syntax:zt.COORDINATE},{n:"y1",int:!0,l:!0,syntax:zt.COORDINATE},{n:"z1",int:!0,l:!0,syntax:zt.COORDINATE},{n:"x2",int:!0,l:!0,syntax:zt.COORDINATE},{n:"y2",int:!0,l:!0,syntax:zt.COORDINATE},{n:"z2",int:!0,l:!0,syntax:zt.COORDINATE},{n:"d",int:!0,l:!0,d:"",syntax:zt.PATH,p:50},{n:"points",int:!0,l:!0,syntax:zt.LIST_OF_POINTS,p:50},{n:"text",l:!0,d:"",syntax:zt.TEXT,p:50},{n:"textTransform",l:!0,inh:!0,k:["capitalize","uppercase","lowercase","none"],d:"none",syntax:zt.TEXT_TRANSFORM,p:51},{n:"font",l:!0},{n:"fontSize",int:!0,inh:!0,d:"16px",l:!0,syntax:zt.LENGTH_PERCENTAGE},{n:"fontFamily",l:!0,inh:!0,d:"sans-serif"},{n:"fontStyle",l:!0,inh:!0,k:["normal","italic","oblique"],d:"normal"},{n:"fontWeight",l:!0,inh:!0,k:["normal","bold","bolder","lighter"],d:"normal"},{n:"fontVariant",l:!0,inh:!0,k:["normal","small-caps"],d:"normal"},{n:"lineHeight",l:!0,syntax:zt.LENGTH,int:!0,d:"0"},{n:"letterSpacing",l:!0,syntax:zt.LENGTH,int:!0,d:"0"},{n:"miterLimit",l:!0,syntax:zt.NUMBER,d:function(e){return e===dt.PATH||e===dt.POLYGON||e===dt.POLYLINE?"4":"10"}},{n:"wordWrap",l:!0},{n:"wordWrapWidth",l:!0},{n:"maxLines",l:!0},{n:"textOverflow",l:!0,d:"clip"},{n:"leading",l:!0},{n:"textBaseline",l:!0,inh:!0,k:["top","hanging","middle","alphabetic","ideographic","bottom"],d:"alphabetic"},{n:"textAlign",l:!0,inh:!0,k:["start","center","middle","end","left","right"],d:"start"},{n:"markerStart",syntax:zt.MARKER},{n:"markerEnd",syntax:zt.MARKER},{n:"markerMid",syntax:zt.MARKER},{n:"markerStartOffset",syntax:zt.LENGTH,l:!0,int:!0,d:"0"},{n:"markerEndOffset",syntax:zt.LENGTH,l:!0,int:!0,d:"0"}],S2=new Set(op.filter(function(t){return!!t.l}).map(function(t){return t.n})),Yr={},Ki=function(){function t(e){var n=this;(0,xt.Z)(this,t),this.runtime=e,op.forEach(function(r){n.registerMetadata(r)})}return(0,Ot.Z)(t,[{key:"registerMetadata",value:function(n){[n.n].concat((0,ln.Z)(n.a||[])).forEach(function(r){Yr[r]=n})}},{key:"getPropertySyntax",value:function(n){return this.runtime.CSSPropertySyntaxFactory[n]}},{key:"processProperties",value:function(n,r){var i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{skipUpdateAttribute:!1,skipParse:!1,forceUpdateGeometry:!1,usedAttributes:[],memoize:!0};Object.assign(n.attributes,r);var a=n.parsedStyle.clipPath,o=n.parsedStyle.offsetPath;E2(n,r);var s=!!i.forceUpdateGeometry;if(!s){for(var c in r)if(S2.has(c)){s=!0;break}}var l=ry(n);l.has("fill")&&r.fill&&(n.parsedStyle.fill=os(r.fill)),l.has("stroke")&&r.stroke&&(n.parsedStyle.stroke=os(r.stroke)),l.has("shadowColor")&&r.shadowColor&&(n.parsedStyle.shadowColor=os(r.shadowColor)),l.has("filter")&&r.filter&&(n.parsedStyle.filter=u2(r.filter)),l.has("radius")&&!ge(r.radius)&&(n.parsedStyle.radius=Ci(r.radius,4)),l.has("lineDash")&&!ge(r.lineDash)&&(n.parsedStyle.lineDash=Ci(r.lineDash,"even")),l.has("points")&&r.points&&(n.parsedStyle.points=Jg(r.points)),l.has("d")&&r.d===""&&(n.parsedStyle.d=(0,Ee.Z)({},Af)),l.has("d")&&r.d&&(n.parsedStyle.d=uo(r.d)),l.has("textTransform")&&r.textTransform&&this.runtime.CSSPropertySyntaxFactory[zt.TEXT_TRANSFORM].calculator(null,null,{value:r.textTransform},n,null),l.has("clipPath")&&!En(r.clipPath)&&this.runtime.CSSPropertySyntaxFactory[zt.DEFINED_PATH].calculator("clipPath",a,r.clipPath,n,this.runtime),l.has("offsetPath")&&r.offsetPath&&this.runtime.CSSPropertySyntaxFactory[zt.DEFINED_PATH].calculator("offsetPath",o,r.offsetPath,n,this.runtime),l.has("transform")&&r.transform&&(n.parsedStyle.transform=ty(r.transform)),l.has("transformOrigin")&&r.transformOrigin&&(n.parsedStyle.transformOrigin=ap(r.transformOrigin)),l.has("markerStart")&&r.markerStart&&(n.parsedStyle.markerStart=this.runtime.CSSPropertySyntaxFactory[zt.MARKER].calculator(null,r.markerStart,r.markerStart,null,null)),l.has("markerEnd")&&r.markerEnd&&(n.parsedStyle.markerEnd=this.runtime.CSSPropertySyntaxFactory[zt.MARKER].calculator(null,r.markerEnd,r.markerEnd,null,null)),l.has("markerMid")&&r.markerMid&&(n.parsedStyle.markerMid=this.runtime.CSSPropertySyntaxFactory[zt.MARKER].calculator("",r.markerMid,r.markerMid,null,null)),l.has("zIndex")&&!ge(r.zIndex)&&this.runtime.CSSPropertySyntaxFactory[zt.Z_INDEX].postProcessor(n),l.has("offsetDistance")&&!ge(r.offsetDistance)&&this.runtime.CSSPropertySyntaxFactory[zt.OFFSET_DISTANCE].postProcessor(n),l.has("transform")&&r.transform&&this.runtime.CSSPropertySyntaxFactory[zt.TRANSFORM].postProcessor(n),l.has("transformOrigin")&&r.transformOrigin&&this.runtime.CSSPropertySyntaxFactory[zt.TRANSFORM_ORIGIN].postProcessor(n),s&&(n.geometry.dirty=!0,n.renderable.boundsDirty=!0,n.renderable.renderBoundsDirty=!0,i.forceUpdateGeometry||this.runtime.sceneGraphService.dirtifyToRoot(n))}},{key:"updateGeometry",value:function(n){var r=n.nodeName,i=this.runtime.geometryUpdaterFactory[r];if(i){var a=n.geometry;a.contentBounds||(a.contentBounds=new xr),a.renderBounds||(a.renderBounds=new xr);var o=n.parsedStyle,s=i.update(o,n),c=s.cx,l=c===void 0?0:c,u=s.cy,f=u===void 0?0:u,d=s.cz,h=d===void 0?0:d,v=s.hwidth,g=v===void 0?0:v,y=s.hheight,b=y===void 0?0:y,x=s.hdepth,_=x===void 0?0:x,w=[Math.abs(g),Math.abs(b),_],O=o.stroke,E=o.lineWidth,M=E===void 0?1:E,k=o.increasedLineWidthForHitTesting,A=k===void 0?0:k,P=o.shadowType,C=P===void 0?"outer":P,N=o.shadowColor,L=o.filter,R=L===void 0?[]:L,I=o.transformOrigin,D=[l,f,h];a.contentBounds.update(D,w);var G=r===dt.POLYLINE||r===dt.POLYGON||r===dt.PATH?Math.SQRT2:.5,F=O&&!O.isNone;if(F){var W=((M||0)+(A||0))*G;w[0]+=W,w[1]+=W}if(a.renderBounds.update(D,w),N&&C&&C!=="inner"){var X=a.renderBounds,Q=X.min,tt=X.max,nt=o.shadowBlur,ht=o.shadowOffsetX,lt=o.shadowOffsetY,wt=nt||0,yt=ht||0,gt=lt||0,Bt=Q[0]-wt+yt,Lt=tt[0]+wt+yt,It=Q[1]-wt+gt,jt=tt[1]+wt+gt;Q[0]=Math.min(Q[0],Bt),tt[0]=Math.max(tt[0],Lt),Q[1]=Math.min(Q[1],It),tt[1]=Math.max(tt[1],jt),a.renderBounds.setMinMax(Q,tt)}R.forEach(function(be){var Ne=be.name,Pn=be.params;if(Ne==="blur"){var qr=Pn[0].value;a.renderBounds.update(a.renderBounds.center,Na(a.renderBounds.halfExtents,a.renderBounds.halfExtents,[qr,qr,0]))}else if(Ne==="drop-shadow"){var fi=Pn[0].value,yr=Pn[1].value,oi=Pn[2].value,Kr=a.renderBounds,si=Kr.min,Kn=Kr.max,Qr=si[0]-oi+fi,Di=Kn[0]+oi+fi,ci=si[1]-oi+yr,ce=Kn[1]+oi+yr;si[0]=Math.min(si[0],Qr),Kn[0]=Math.max(Kn[0],Di),si[1]=Math.min(si[1],ci),Kn[1]=Math.max(Kn[1],ce),a.renderBounds.setMinMax(si,Kn)}}),n.geometry.dirty=!1;var Qt=g<0,ue=b<0,ye=(Qt?-1:1)*(I?bn(I[0],0,n,!0):0),Ke=(ue?-1:1)*(I?bn(I[1],1,n,!0):0);(ye||Ke)&&n.setOrigin(ye,Ke)}}},{key:"updateSizeAttenuation",value:function(n,r){n.style.isSizeAttenuation?(n.style.rawLineWidth||(n.style.rawLineWidth=n.style.lineWidth),n.style.lineWidth=(n.style.rawLineWidth||1)/r,n.nodeName===dt.CIRCLE&&(n.style.rawR||(n.style.rawR=n.style.r),n.style.r=(n.style.rawR||1)/r)):(n.style.rawLineWidth&&(n.style.lineWidth=n.style.rawLineWidth,delete n.style.rawLineWidth),n.nodeName===dt.CIRCLE&&n.style.rawR&&(n.style.r=n.style.rawR,delete n.style.rawR))}}])}();function E2(t,e){var n=ry(t);for(var r in e)n.has(r)&&(t.parsedStyle[r]=e[r])}function ry(t){return t.constructor.PARSED_STYLE_LIST}var M2=function(){function t(){(0,xt.Z)(this,t),this.mixer=Jh}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i,a){return qi(i)}}])}(),iy=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i,a,o){return i instanceof ka&&(i=null),o.sceneGraphService.updateDisplayObjectDependency(n,r,i,a),n==="clipPath"&&a.forEach(function(s){s.childNodes.length===0&&o.sceneGraphService.dirtifyToRoot(s)}),i}}])}(),k2=function(){function t(){(0,xt.Z)(this,t),this.parser=os,this.mixer=o2}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i,a){return i instanceof ka?i.value==="none"?Vh:Xh:i}}])}(),A2=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i){return i instanceof ka?[]:i}}])}();function ay(t){var e=t.parsedStyle,n=e.fontSize;return ge(n)?null:n}var zf=function(){function t(){(0,xt.Z)(this,t),this.mixer=Jh}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i,a,o){if(Vn(i))return i;if(Rn.isRelativeUnit(i.unit)){if(i.unit===Zt.kPercentage)return 0;if(i.unit===Zt.kEms){if(a.parentNode){var s=ay(a.parentNode);if(s)return s*=i.value,s}return 0}if(i.unit===Zt.kRems){var c;if(a!=null&&(c=a.ownerDocument)!==null&&c!==void 0&&c.documentElement){var l=ay(a.ownerDocument.documentElement);if(l)return l*=i.value,l}return 0}}else return i.value}}])}(),T2=function(){function t(){(0,xt.Z)(this,t),this.mixer=$g}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i){return i.map(function(a){return a.value})}}])}(),P2=function(){function t(){(0,xt.Z)(this,t),this.mixer=$g}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i){return i.map(function(a){return a.value})}}])}(),C2=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i,a){var o;i instanceof ka&&(i=null);var s=(o=i)===null||o===void 0?void 0:o.cloneNode(!0);return s&&(s.style.isMarker=!0),s}}])}(),oy=function(){function t(){(0,xt.Z)(this,t),this.mixer=Jh}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i){return i.value}}])}(),sy=function(){function t(){(0,xt.Z)(this,t),this.mixer=eu(0,1)}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i){return i.value}},{key:"postProcessor",value:function(n){var r=n.parsedStyle,i=r.offsetPath,a=r.offsetDistance;if(i){var o=i.nodeName;if(o===dt.LINE||o===dt.PATH||o===dt.POLYLINE){var s=i.getPoint(a);s&&n.setLocalPosition(s.x,s.y)}}}}])}(),L2=function(){function t(){(0,xt.Z)(this,t),this.mixer=eu(0,1)}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i){return i.value}}])}(),R2=function(){function t(){(0,xt.Z)(this,t),this.parser=uo,this.mixer=Ve}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i){return i instanceof ka&&i.value==="unset"?{absolutePath:[],hasArc:!1,segments:[],polygons:[],polylines:[],curve:null,totalLength:0,rect:new Fo(0,0,0,0)}:i}}])}(),N2=(0,Ot.Z)(function t(){(0,xt.Z)(this,t),this.mixer=Ta}),I2=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.mixer=eu(0,1/0),n}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(zf),qc=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i,a){return i instanceof ka?i.value==="unset"?"":i.value:"".concat(i)}},{key:"postProcessor",value:function(n){n.nodeValue="".concat(n.parsedStyle.text)||""}}])}(),D2=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i,a){var o=a.getAttribute("text");if(o){var s=o;i.value==="capitalize"?s=o.charAt(0).toUpperCase()+o.slice(1):i.value==="lowercase"?s=o.toLowerCase():i.value==="uppercase"&&(s=o.toUpperCase()),a.parsedStyle.text=s}return i.value}}])}(),dk=function(e){return Object.fromEntries(Object.entries(e).filter(function(n){var r=_slicedToArray(n,2),i=r[1];return i!==void 0}))},sp=new WeakMap;function j2(t,e,n){if(t){var r=typeof t=="string"?document.getElementById(t):t;sp.has(r)&&sp.get(r).destroy(n),sp.set(r,e)}}var cp=typeof window!="undefined"&&typeof window.document!="undefined";function cy(t){return!!t.getAttribute}function ly(t,e){for(var n=0,r=t.length;n<r;){var i=n+r>>>1;uy(t[i],e)<0?n=i+1:r=i}return n}function uy(t,e){var n=Number(t.parsedStyle.zIndex||0),r=Number(e.parsedStyle.zIndex||0);if(n===r){var i=t.parentNode;if(i){var a=i.childNodes||[];return a.indexOf(t)-a.indexOf(e)}}return n-r}function fy(t){var e=t;do{var n,r=(n=e.parsedStyle)===null||n===void 0?void 0:n.clipPath;if(r)return e;e=e.parentElement}while(e!==null);return null}var dy="px";function F2(t,e,n){cp&&t.style&&(t.style.width=e+dy,t.style.height=n+dy)}function hy(t,e){if(cp)return document.defaultView.getComputedStyle(t,null).getPropertyValue(e)}function B2(t){var e=hy(t,"width");return e==="auto"?t.offsetWidth:parseFloat(e)}function z2(t){var e=hy(t,"height");return e==="auto"?t.offsetHeight:parseFloat(e)}var W2=1,G2={touchstart:"pointerdown",touchend:"pointerup",touchendoutside:"pointerupoutside",touchmove:"pointermove",touchcancel:"pointercancel"},lp=typeof performance=="object"&&performance.now?performance:Date;function Wf(t){return t.nodeName===dt.FRAGMENT?!0:t.getRootNode().nodeName===dt.FRAGMENT}function Js(){var t=arguments.length>0&&arguments[0]!==void 0?arguments[0]:"auto",e=arguments.length>1?arguments[1]:void 0,n=arguments.length>2?arguments[2]:void 0,r=!1,i=!1,a=!!e&&!e.isNone,o=!!n&&!n.isNone;return t==="visiblepainted"||t==="painted"||t==="auto"?(r=a,i=o):t==="visiblefill"||t==="fill"?r=!0:t==="visiblestroke"||t==="stroke"?i=!0:(t==="visible"||t==="all")&&(r=!0,i=!0),[r,i]}var $2=1,Z2=function(){return $2++},fo=typeof self=="object"&&self.self===self?self:typeof pt.g=="object"&&pt.g.global===pt.g?pt.g:{},Y2=Date.now(),H2=function(){return fo.performance&&typeof fo.performance.now=="function"?fo.performance.now():Date.now()-Y2},au={},py=Date.now(),V2=function(e){if(typeof e!="function")throw new TypeError("".concat(e," is not a function"));var n=Date.now(),r=n-py,i=r>16?0:16-r,a=Z2();return au[a]=e,Object.keys(au).length>1||setTimeout(function(){py=n;var o=au;au={},Object.keys(o).forEach(function(s){return o[s](H2())})},i),a},X2=function(e){delete au[e]},U2=["","webkit","moz","ms","o"],vy=function(e){return typeof e!="string"?V2:e===""?fo.requestAnimationFrame:fo["".concat(e,"RequestAnimationFrame")]},q2=function(e){return typeof e!="string"?X2:e===""?fo.cancelAnimationFrame:fo["".concat(e,"CancelAnimationFrame")]||fo["".concat(e,"CancelRequestAnimationFrame")]},K2=function(e,n){for(var r=0;e[r]!==void 0;){if(n(e[r]))return e[r];r+=1}},Gf=K2(U2,function(t){return!!vy(t)}),$f=vy(Gf),up=q2(Gf);fo.requestAnimationFrame=$f,fo.cancelAnimationFrame=up;var Q2=function(){function t(){(0,xt.Z)(this,t),this.callbacks=[]}return(0,Ot.Z)(t,[{key:"getCallbacksNum",value:function(){return this.callbacks.length}},{key:"tapPromise",value:function(n,r){this.callbacks.push(r)}},{key:"promise",value:function(){for(var n=arguments.length,r=new Array(n),i=0;i<n;i++)r[i]=arguments[i];return Promise.all(this.callbacks.map(function(a){return a.apply(void 0,r)}))}}])}(),J2=function(){function t(){(0,xt.Z)(this,t),this.callbacks=[]}return(0,Ot.Z)(t,[{key:"tapPromise",value:function(n,r){this.callbacks.push(r)}},{key:"promise",value:function(){var e=(0,oo.Z)((0,Mn.Z)().mark(function r(){var i,a,o,s,c=arguments;return(0,Mn.Z)().wrap(function(u){for(;;)switch(u.prev=u.next){case 0:if(!this.callbacks.length){u.next=14;break}return u.next=3,(i=this.callbacks)[0].apply(i,c);case 3:a=u.sent,o=0;case 5:if(!(o<this.callbacks.length-1)){u.next=13;break}return s=this.callbacks[o],u.next=9,s(a);case 9:a=u.sent;case 10:o++,u.next=5;break;case 13:return u.abrupt("return",a);case 14:return u.abrupt("return",null);case 15:case"end":return u.stop()}},r,this)}));function n(){return e.apply(this,arguments)}return n}()}])}(),Li=function(){function t(){(0,xt.Z)(this,t),this.callbacks=[]}return(0,Ot.Z)(t,[{key:"tap",value:function(n,r){this.callbacks.push(r)}},{key:"call",value:function(){for(var n=arguments.length,r=new Array(n),i=0;i<n;i++)r[i]=arguments[i];var a=arguments;this.callbacks.forEach(function(o){o.apply(void 0,a)})}}])}(),ou=function(){function t(){(0,xt.Z)(this,t),this.callbacks=[]}return(0,Ot.Z)(t,[{key:"tap",value:function(n,r){this.callbacks.push(r)}},{key:"call",value:function(){for(var n=arguments.length,r=new Array(n),i=0;i<n;i++)r[i]=arguments[i];if(this.callbacks.length){for(var a=arguments,o=this.callbacks[0].apply(void 0,a),s=0;s<this.callbacks.length-1;s++){var c=this.callbacks[s];o=c(o)}return o}return null}}])}(),t_=["serif","sans-serif","monospace","cursive","fantasy","system-ui"],e_=/([\"\'])[^\'\"]+\1/;function n_(t){for(var e=t.fontSize,n=e===void 0?16:e,r=t.fontFamily,i=r===void 0?"sans-serif":r,a=t.fontStyle,o=a===void 0?"normal":a,s=t.fontVariant,c=s===void 0?"normal":s,l=t.fontWeight,u=l===void 0?"normal":l,f=Vn(n)&&"".concat(n,"px")||"16px",d=i.split(","),h=d.length-1;h>=0;h--){var v=d[h].trim();!e_.test(v)&&t_.indexOf(v)<0&&(v='"'.concat(v,'"')),d[h]=v}return"".concat(o," ").concat(c," ").concat(u," ").concat(f," ").concat(d.join(","))}function yi(t,e,n){return lr(t),t[4]=Math.tan(e),t[1]=Math.tan(n),t}var br=Wn(),r_=Wn(),i_={scale:function(e){Is(br,[e[0].value,e[1].value,1])},scaleX:function(e){Is(br,[e[0].value,1,1])},scaleY:function(e){Is(br,[1,e[0].value,1])},scaleZ:function(e){Is(br,[1,1,e[0].value])},scale3d:function(e){Is(br,[e[0].value,e[1].value,e[2].value])},translate:function(e){Lr(br,[e[0].value,e[1].value,0])},translateX:function(e){Lr(br,[e[0].value,0,0])},translateY:function(e){Lr(br,[0,e[0].value,0])},translateZ:function(e){Lr(br,[0,0,e[0].value])},translate3d:function(e){Lr(br,[e[0].value,e[1].value,e[2].value])},rotate:function(e){Qa(br,Cn(qi(e[0])))},rotateX:function(e){gv(br,Cn(qi(e[0])))},rotateY:function(e){Qd(br,Cn(qi(e[0])))},rotateZ:function(e){Qa(br,Cn(qi(e[0])))},rotate3d:function(e){ua(br,Cn(qi(e[3])),[e[0].value,e[1].value,e[2].value])},skew:function(e){yi(br,Cn(e[0].value),Cn(e[1].value))},skewX:function(e){yi(br,Cn(e[0].value),0)},skewY:function(e){yi(br,0,Cn(e[0].value))},matrix:function(e){Vd(br,e[0].value,e[1].value,0,0,e[2].value,e[3].value,0,0,0,0,1,0,e[4].value,e[5].value,0,1)},matrix3d:function(e){Vd.apply(oe,[br].concat((0,ln.Z)(e.map(function(n){return n.value}))))}},a_=sn(1,1,1),o_=me(),Zf={translate:function(e,n){Ct.sceneGraphService.setLocalScale(e,a_,!1),Ct.sceneGraphService.setLocalEulerAngles(e,o_,void 0,void 0,!1),Ct.sceneGraphService.setLocalPosition(e,[n[0].value,n[1].value,0],!1),Ct.sceneGraphService.dirtifyLocal(e,e.transformable)}};function gy(t,e){if(t.length){if(t.length===1&&Zf[t[0].t]){Zf[t[0].t](e,t[0].d);return}for(var n=lr(r_),r=0;r<t.length;r++){var i=t[r],a=i.t,o=i.d,s=i_[a];s&&(s(o),Lc(n,n,br))}e.setLocalTransform(n)}else e.resetLocalTransform();return e.getLocalTransform()}var fp=function(){function t(){(0,xt.Z)(this,t),this.parser=v2,this.mixer=O2}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i,a){return i instanceof ka?[]:i}},{key:"postProcessor",value:function(n){gy(n.parsedStyle.transform,n)}}])}(),s_=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"postProcessor",value:function(n){var r=n.parsedStyle.transformOrigin;r[0].unit===Zt.kPixels&&r[1].unit===Zt.kPixels?n.setOrigin(r[0].value,r[1].value):n.getGeometryBounds()}}])}(),c_=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"calculator",value:function(n,r,i,a){return i.value}},{key:"postProcessor",value:function(n){if(n.parentNode){var r=n.parentNode,i=r.renderable,a=r.sortable;i&&(i.dirty=!0),a&&(a.dirty=!0,a.dirtyReason=kf.Z_INDEX_CHANGED)}}}])}(),l_=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"update",value:function(n,r){var i=n.cx,a=i===void 0?0:i,o=n.cy,s=o===void 0?0:o,c=n.r,l=c===void 0?0:c;return{cx:a,cy:s,hwidth:l,hheight:l}}}])}(),u_=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"update",value:function(n,r){var i=n.cx,a=i===void 0?0:i,o=n.cy,s=o===void 0?0:o,c=n.rx,l=c===void 0?0:c,u=n.ry,f=u===void 0?0:u;return{cx:a,cy:s,hwidth:l,hheight:f}}}])}(),yy=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"update",value:function(n){var r=n.x1,i=n.y1,a=n.x2,o=n.y2,s=Math.min(r,a),c=Math.max(r,a),l=Math.min(i,o),u=Math.max(i,o),f=c-s,d=u-l,h=f/2,v=d/2;return{cx:s+h,cy:l+v,hwidth:h,hheight:v}}}])}(),f_=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"update",value:function(n){var r=n.d,i=r.rect,a=i.x,o=i.y,s=i.width,c=i.height,l=s/2,u=c/2;return{cx:a+l,cy:o+u,hwidth:l,hheight:u}}}])}(),d_=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"update",value:function(n){if(n.points&&Nr(n.points.points)){var r=n.points.points,i=Math.min.apply(Math,(0,ln.Z)(r.map(function(d){return d[0]}))),a=Math.max.apply(Math,(0,ln.Z)(r.map(function(d){return d[0]}))),o=Math.min.apply(Math,(0,ln.Z)(r.map(function(d){return d[1]}))),s=Math.max.apply(Math,(0,ln.Z)(r.map(function(d){return d[1]}))),c=a-i,l=s-o,u=c/2,f=l/2;return{cx:i+u,cy:o+f,hwidth:u,hheight:f}}return{cx:0,cy:0,hwidth:0,hheight:0}}}])}(),h_=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"update",value:function(n,r){var i=n.x,a=i===void 0?0:i,o=n.y,s=o===void 0?0:o,c=n.src,l=n.width,u=l===void 0?0:l,f=n.height,d=f===void 0?0:f,h=u,v=d;return c&&!ir(c)&&(h||(h=c.width,n.width=h),v||(v=c.height,n.height=v)),{cx:a+h/2,cy:s+v/2,hwidth:h/2,hheight:v/2}}}])}(),dp=function(){function t(e){(0,xt.Z)(this,t),this.globalRuntime=e}return(0,Ot.Z)(t,[{key:"isReadyToMeasure",value:function(n,r){var i=n.text;return i}},{key:"update",value:function(n,r){var i,a=n.text,o=n.textAlign,s=o===void 0?"start":o,c=n.lineWidth,l=c===void 0?1:c,u=n.textBaseline,f=u===void 0?"alphabetic":u,d=n.dx,h=d===void 0?0:d,v=n.dy,g=v===void 0?0:v,y=n.x,b=y===void 0?0:y,x=n.y,_=x===void 0?0:x;if(!this.isReadyToMeasure(n,r))return n.metrics={font:"",width:0,height:0,lines:[],lineWidths:[],lineHeight:0,maxLineWidth:0,fontProperties:{ascent:0,descent:0,fontSize:0},lineMetrics:[]},{hwidth:0,hheight:0,cx:0,cy:0};var w=(r==null||(i=r.ownerDocument)===null||i===void 0||(i=i.defaultView)===null||i===void 0?void 0:i.getConfig())||{},O=w.offscreenCanvas,E=this.globalRuntime.textService.measureText(a,n,O);n.metrics=E;var M=E.width,k=E.height,A=M/2,P=k/2,C=b+A;s==="center"||s==="middle"?C+=l/2-A:(s==="right"||s==="end")&&(C+=l-A*2);var N=_-P;return f==="middle"?N+=P:f==="top"||f==="hanging"?N+=P*2:f==="alphabetic"||(f==="bottom"||f==="ideographic")&&(N+=0),h&&(C+=h),g&&(N+=g),{cx:C,cy:N,hwidth:A,hheight:P}}}])}(),hp=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"update",value:function(n,r){return{cx:0,cy:0,hwidth:0,hheight:0}}}])}(),p_=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"update",value:function(n,r){var i=n.x,a=i===void 0?0:i,o=n.y,s=o===void 0?0:o,c=n.width,l=c===void 0?0:c,u=n.height,f=u===void 0?0:u;return{cx:a+l/2,cy:s+f/2,hwidth:l/2,hheight:f/2}}}])}();function hk(t){return!!t.type}var Yf=function(){function t(e){(0,xt.Z)(this,t),this.eventPhase=t.prototype.NONE,this.bubbles=!0,this.cancelBubble=!0,this.cancelable=!1,this.defaultPrevented=!1,this.propagationStopped=!1,this.propagationImmediatelyStopped=!1,this.layer=new ii,this.page=new ii,this.canvas=new ii,this.viewport=new ii,this.composed=!1,this.NONE=0,this.CAPTURING_PHASE=1,this.AT_TARGET=2,this.BUBBLING_PHASE=3,this.manager=e}return(0,Ot.Z)(t,[{key:"name",get:function(){return this.type}},{key:"layerX",get:function(){return this.layer.x}},{key:"layerY",get:function(){return this.layer.y}},{key:"pageX",get:function(){return this.page.x}},{key:"pageY",get:function(){return this.page.y}},{key:"x",get:function(){return this.canvas.x}},{key:"y",get:function(){return this.canvas.y}},{key:"canvasX",get:function(){return this.canvas.x}},{key:"canvasY",get:function(){return this.canvas.y}},{key:"viewportX",get:function(){return this.viewport.x}},{key:"viewportY",get:function(){return this.viewport.y}},{key:"composedPath",value:function(){return this.manager&&(!this.path||this.path[0]!==this.target)&&(this.path=this.target?this.manager.propagationPath(this.target):[]),this.path}},{key:"propagationPath",get:function(){return this.composedPath()}},{key:"preventDefault",value:function(){this.nativeEvent instanceof Event&&this.nativeEvent.cancelable&&this.nativeEvent.preventDefault(),this.defaultPrevented=!0}},{key:"stopImmediatePropagation",value:function(){this.propagationImmediatelyStopped=!0}},{key:"stopPropagation",value:function(){this.propagationStopped=!0}},{key:"initEvent",value:function(){}},{key:"initUIEvent",value:function(){}},{key:"clone",value:function(){throw new Error(kn)}}])}(),my=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.client=new ii,n.movement=new ii,n.offset=new ii,n.global=new ii,n.screen=new ii,n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"clientX",get:function(){return this.client.x}},{key:"clientY",get:function(){return this.client.y}},{key:"movementX",get:function(){return this.movement.x}},{key:"movementY",get:function(){return this.movement.y}},{key:"offsetX",get:function(){return this.offset.x}},{key:"offsetY",get:function(){return this.offset.y}},{key:"globalX",get:function(){return this.global.x}},{key:"globalY",get:function(){return this.global.y}},{key:"screenX",get:function(){return this.screen.x}},{key:"screenY",get:function(){return this.screen.y}},{key:"getModifierState",value:function(r){return"getModifierState"in this.nativeEvent&&this.nativeEvent.getModifierState(r)}},{key:"initMouseEvent",value:function(){throw new Error(kn)}}])}(Yf),pp=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.width=0,n.height=0,n.isPrimary=!1,n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"getCoalescedEvents",value:function(){return this.type==="pointermove"||this.type==="mousemove"||this.type==="touchmove"?[this]:[]}},{key:"getPredictedEvents",value:function(){throw new Error("getPredictedEvents is not supported!")}},{key:"clone",value:function(){return this.manager.clonePointerEvent(this)}}])}(my),vp=function(t){function e(){return(0,xt.Z)(this,e),(0,De.Z)(this,e,arguments)}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"clone",value:function(){return this.manager.cloneWheelEvent(this)}}])}(my),Nn=function(t){function e(n,r){var i;return(0,xt.Z)(this,e),i=(0,De.Z)(this,e,[null]),i.type=n,i.detail=r,Object.assign(i,r),i}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(Yf),by=new WeakMap,xy=function(){function t(){(0,xt.Z)(this,t),this.emitter=new Lo}return(0,Ot.Z)(t,[{key:"on",value:function(n,r,i){return this.addEventListener(n,r,i),this}},{key:"addEventListener",value:function(n,r,i){var a=!1,o=!1;if(Qv(i))a=i;else if(i){var s=i.capture;a=s===void 0?!1:s;var c=i.once;o=c===void 0?!1:c}a&&(n+="capture"),r=Xn(r)?r:r.handleEvent;var l=Xn(r)?void 0:r;return o?this.emitter.once(n,r,l):this.emitter.on(n,r,l),this}},{key:"off",value:function(n,r,i){return n?this.removeEventListener(n,r,i):this.removeAllEventListeners(),this}},{key:"removeAllEventListeners",value:function(){var n;(n=this.emitter)===null||n===void 0||n.removeAllListeners()}},{key:"removeEventListener",value:function(n,r,i){var a;if(!this.emitter)return this;var o=Qv(i)?i:i==null?void 0:i.capture;o&&(n+="capture"),r=Xn(r)?r:(a=r)===null||a===void 0?void 0:a.handleEvent;var s=Xn(r)?void 0:r;return this.emitter.off(n,r,s),this}},{key:"emit",value:function(n,r){this.dispatchEvent(new Nn(n,r))}},{key:"dispatchEvent",value:function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,i=by.get(this);if(!i){var a;this.document?i=this:this.defaultView?i=this.defaultView:i=(a=this.ownerDocument)===null||a===void 0?void 0:a.defaultView,i&&by.set(this,i)}if(i){if(n.manager=i.getEventService(),!n.manager)return!1;n.defaultPrevented=!1,n.path?n.path.length=0:n.page=[],r||(n.target=this),n.manager.dispatchEvent(n,n.type,r)}else this.emitter.emit(n.type,n);return!n.defaultPrevented}}])}(),fr=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.shadow=!1,n.ownerDocument=null,n.isConnected=!1,n.baseURI="",n.childNodes=[],n.nodeType=0,n.nodeName="",n.nodeValue=null,n.parentNode=null,n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"textContent",get:function(){var r="";this.nodeName===dt.TEXT&&(r+=this.style.text);var i=(0,Ys.Z)(this.childNodes),a;try{for(i.s();!(a=i.n()).done;){var o=a.value;o.nodeName===dt.TEXT?r+=o.nodeValue:r+=o.textContent}}catch(s){i.e(s)}finally{i.f()}return r},set:function(r){var i=this;this.childNodes.slice().forEach(function(a){i.removeChild(a)}),this.nodeName===dt.TEXT&&(this.style.text="".concat(r))}},{key:"getRootNode",value:function(){var r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return this.parentNode?this.parentNode.getRootNode(r):r.composed&&this.host?this.host.getRootNode(r):this}},{key:"hasChildNodes",value:function(){return this.childNodes.length>0}},{key:"isDefaultNamespace",value:function(r){throw new Error(kn)}},{key:"lookupNamespaceURI",value:function(r){throw new Error(kn)}},{key:"lookupPrefix",value:function(r){throw new Error(kn)}},{key:"normalize",value:function(){throw new Error(kn)}},{key:"isEqualNode",value:function(r){return this===r}},{key:"isSameNode",value:function(r){return this.isEqualNode(r)}},{key:"parent",get:function(){return this.parentNode}},{key:"parentElement",get:function(){return null}},{key:"nextSibling",get:function(){return null}},{key:"previousSibling",get:function(){return null}},{key:"firstChild",get:function(){return this.childNodes.length>0?this.childNodes[0]:null}},{key:"lastChild",get:function(){return this.childNodes.length>0?this.childNodes[this.childNodes.length-1]:null}},{key:"compareDocumentPosition",value:function(r){if(r===this)return 0;for(var i=r,a=this,o=[i],s=[a];(c=i.parentNode)!==null&&c!==void 0?c:a.parentNode;){var c;i=i.parentNode?(o.push(i.parentNode),i.parentNode):i,a=a.parentNode?(s.push(a.parentNode),a.parentNode):a}if(i!==a)return e.DOCUMENT_POSITION_DISCONNECTED|e.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC|e.DOCUMENT_POSITION_PRECEDING;var l=o.length>s.length?o:s,u=l===o?s:o;if(l[l.length-u.length]===u[0])return l===o?e.DOCUMENT_POSITION_CONTAINED_BY|e.DOCUMENT_POSITION_FOLLOWING:e.DOCUMENT_POSITION_CONTAINS|e.DOCUMENT_POSITION_PRECEDING;for(var f=l.length-u.length,d=u.length-1;d>=0;d--){var h=u[d],v=l[f+d];if(v!==h){var g=h.parentNode.childNodes;return g.indexOf(h)<g.indexOf(v)?u===o?e.DOCUMENT_POSITION_PRECEDING:e.DOCUMENT_POSITION_FOLLOWING:l===o?e.DOCUMENT_POSITION_PRECEDING:e.DOCUMENT_POSITION_FOLLOWING}}return e.DOCUMENT_POSITION_FOLLOWING}},{key:"contain",value:function(r){return this.contains(r)}},{key:"contains",value:function(r){for(var i=r;i&&this!==i;)i=i.parentNode;return!!i}},{key:"getAncestor",value:function(r){for(var i=this;r>0&&i;)i=i.parentNode,r--;return i}},{key:"forEach",value:function(r){for(var i=[this];i.length>0;){var a=i.pop(),o=r(a);if(o===!1)break;for(var s=a.childNodes.length-1;s>=0;s--)i.push(a.childNodes[s])}}}],[{key:"isNode",value:function(r){return!!r.childNodes}}])}(xy);fr.DOCUMENT_POSITION_DISCONNECTED=1,fr.DOCUMENT_POSITION_PRECEDING=2,fr.DOCUMENT_POSITION_FOLLOWING=4,fr.DOCUMENT_POSITION_CONTAINS=8,fr.DOCUMENT_POSITION_CONTAINED_BY=16,fr.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC=32;var v_=2048,g_=function(){function t(e,n){var r=this;(0,xt.Z)(this,t),this.nativeHTMLMap=new WeakMap,this.cursor="default",this.mappingTable={},this.mappingState={trackingData:{}},this.eventPool=new Map,this.tmpMatrix=Wn(),this.tmpVec3=me(),this.onPointerDown=function(i){var a=r.createPointerEvent(i);if(r.dispatchEvent(a,"pointerdown"),a.pointerType==="touch")r.dispatchEvent(a,"touchstart");else if(a.pointerType==="mouse"||a.pointerType==="pen"){var o=a.button===2;r.dispatchEvent(a,o?"rightdown":"mousedown")}var s=r.trackingData(i.pointerId);s.pressTargetsByButton[i.button]=a.composedPath(),r.freeEvent(a)},this.onPointerUp=function(i){var a=lp.now(),o=r.createPointerEvent(i,void 0,void 0,r.context.config.alwaysTriggerPointerEventOnCanvas?r.rootTarget:void 0);if(r.dispatchEvent(o,"pointerup"),o.pointerType==="touch")r.dispatchEvent(o,"touchend");else if(o.pointerType==="mouse"||o.pointerType==="pen"){var s=o.button===2;r.dispatchEvent(o,s?"rightup":"mouseup")}var c=r.trackingData(i.pointerId),l=r.findMountedTarget(c.pressTargetsByButton[i.button]),u=l;if(l&&!o.composedPath().includes(l)){for(var f=l;f&&!o.composedPath().includes(f);){if(o.currentTarget=f,r.notifyTarget(o,"pointerupoutside"),o.pointerType==="touch")r.notifyTarget(o,"touchendoutside");else if(o.pointerType==="mouse"||o.pointerType==="pen"){var d=o.button===2;r.notifyTarget(o,d?"rightupoutside":"mouseupoutside")}fr.isNode(f)&&(f=f.parentNode)}delete c.pressTargetsByButton[i.button],u=f}if(u){var h,v=r.clonePointerEvent(o,"click");v.target=u,v.path=[],c.clicksByButton[i.button]||(c.clicksByButton[i.button]={clickCount:0,target:v.target,timeStamp:a});var g=r.context.renderingContext.root.ownerDocument.defaultView,y=c.clicksByButton[i.button];y.target===v.target&&a-y.timeStamp<g.getConfig().dblClickSpeed?++y.clickCount:y.clickCount=1,y.target=v.target,y.timeStamp=a,v.detail=y.clickCount,(h=o.detail)!==null&&h!==void 0&&h.preventClick||(!r.context.config.useNativeClickEvent&&(v.pointerType==="mouse"||v.pointerType==="touch")&&r.dispatchEvent(v,"click"),r.dispatchEvent(v,"pointertap")),r.freeEvent(v)}r.freeEvent(o)},this.onPointerMove=function(i){var a=r.createPointerEvent(i,void 0,void 0,r.context.config.alwaysTriggerPointerEventOnCanvas?r.rootTarget:void 0),o=a.pointerType==="mouse"||a.pointerType==="pen",s=r.trackingData(i.pointerId),c=r.findMountedTarget(s.overTargets);if(s.overTargets&&c!==a.target){var l=i.type==="mousemove"?"mouseout":"pointerout",u=r.createPointerEvent(i,l,c||void 0);if(r.dispatchEvent(u,"pointerout"),o&&r.dispatchEvent(u,"mouseout"),!a.composedPath().includes(c)){var f=r.createPointerEvent(i,"pointerleave",c||void 0);for(f.eventPhase=f.AT_TARGET;f.target&&!a.composedPath().includes(f.target);)f.currentTarget=f.target,r.notifyTarget(f),o&&r.notifyTarget(f,"mouseleave"),fr.isNode(f.target)&&(f.target=f.target.parentNode);r.freeEvent(f)}r.freeEvent(u)}if(c!==a.target){var d=i.type==="mousemove"?"mouseover":"pointerover",h=r.clonePointerEvent(a,d);r.dispatchEvent(h,"pointerover"),o&&r.dispatchEvent(h,"mouseover");for(var v=c&&fr.isNode(c)&&c.parentNode;v&&v!==(fr.isNode(r.rootTarget)&&r.rootTarget.parentNode)&&v!==a.target;)v=v.parentNode;var g=!v||v===(fr.isNode(r.rootTarget)&&r.rootTarget.parentNode);if(g){var y=r.clonePointerEvent(a,"pointerenter");for(y.eventPhase=y.AT_TARGET;y.target&&y.target!==c&&y.target!==(fr.isNode(r.rootTarget)&&r.rootTarget.parentNode);)y.currentTarget=y.target,r.notifyTarget(y),o&&r.notifyTarget(y,"mouseenter"),fr.isNode(y.target)&&(y.target=y.target.parentNode);r.freeEvent(y)}r.freeEvent(h)}r.dispatchEvent(a,"pointermove"),a.pointerType==="touch"&&r.dispatchEvent(a,"touchmove"),o&&(r.dispatchEvent(a,"mousemove"),r.cursor=r.getCursor(a.target)),s.overTargets=a.composedPath(),r.freeEvent(a)},this.onPointerOut=function(i){var a=r.trackingData(i.pointerId);if(a.overTargets){var o=i.pointerType==="mouse"||i.pointerType==="pen",s=r.findMountedTarget(a.overTargets),c=r.createPointerEvent(i,"pointerout",s||void 0);r.dispatchEvent(c),o&&r.dispatchEvent(c,"mouseout");var l=r.createPointerEvent(i,"pointerleave",s||void 0);for(l.eventPhase=l.AT_TARGET;l.target&&l.target!==(fr.isNode(r.rootTarget)&&r.rootTarget.parentNode);)l.currentTarget=l.target,r.notifyTarget(l),o&&r.notifyTarget(l,"mouseleave"),fr.isNode(l.target)&&(l.target=l.target.parentNode);a.overTargets=null,r.freeEvent(c),r.freeEvent(l)}r.cursor=null},this.onPointerOver=function(i){var a=r.trackingData(i.pointerId),o=r.createPointerEvent(i),s=o.pointerType==="mouse"||o.pointerType==="pen";r.dispatchEvent(o,"pointerover"),s&&r.dispatchEvent(o,"mouseover"),o.pointerType==="mouse"&&(r.cursor=r.getCursor(o.target));var c=r.clonePointerEvent(o,"pointerenter");for(c.eventPhase=c.AT_TARGET;c.target&&c.target!==(fr.isNode(r.rootTarget)&&r.rootTarget.parentNode);)c.currentTarget=c.target,r.notifyTarget(c),s&&r.notifyTarget(c,"mouseenter"),fr.isNode(c.target)&&(c.target=c.target.parentNode);a.overTargets=o.composedPath(),r.freeEvent(o),r.freeEvent(c)},this.onPointerUpOutside=function(i){var a=r.trackingData(i.pointerId),o=r.findMountedTarget(a.pressTargetsByButton[i.button]),s=r.createPointerEvent(i);if(o){for(var c=o;c;)s.currentTarget=c,r.notifyTarget(s,"pointerupoutside"),s.pointerType==="touch"||(s.pointerType==="mouse"||s.pointerType==="pen")&&r.notifyTarget(s,s.button===2?"rightupoutside":"mouseupoutside"),fr.isNode(c)&&(c=c.parentNode);delete a.pressTargetsByButton[i.button]}r.freeEvent(s)},this.onWheel=function(i){var a=r.createWheelEvent(i);r.dispatchEvent(a),r.freeEvent(a)},this.onClick=function(i){if(r.context.config.useNativeClickEvent){var a=r.createPointerEvent(i);r.dispatchEvent(a),r.freeEvent(a)}},this.onPointerCancel=function(i){var a=r.createPointerEvent(i,void 0,void 0,r.context.config.alwaysTriggerPointerEventOnCanvas?r.rootTarget:void 0);r.dispatchEvent(a),r.freeEvent(a)},this.globalRuntime=e,this.context=n}return(0,Ot.Z)(t,[{key:"init",value:function(){this.rootTarget=this.context.renderingContext.root.parentNode,this.addEventMapping("pointerdown",this.onPointerDown),this.addEventMapping("pointerup",this.onPointerUp),this.addEventMapping("pointermove",this.onPointerMove),this.addEventMapping("pointerout",this.onPointerOut),this.addEventMapping("pointerleave",this.onPointerOut),this.addEventMapping("pointercancel",this.onPointerCancel),this.addEventMapping("pointerover",this.onPointerOver),this.addEventMapping("pointerupoutside",this.onPointerUpOutside),this.addEventMapping("wheel",this.onWheel),this.addEventMapping("click",this.onClick)}},{key:"destroy",value:function(){this.mappingTable={},this.mappingState={},this.eventPool.clear()}},{key:"getScale",value:function(){var n=this.context.contextService.getBoundingClientRect(),r=1,i=1,a=this.context.contextService.getDomElement();if(a&&n){var o=a.offsetWidth,s=a.offsetHeight;o&&s&&(r=n.width/o,i=n.height/s)}return{scaleX:r,scaleY:i,bbox:n}}},{key:"client2Viewport",value:function(n){var r=this.getScale(),i=r.scaleX,a=r.scaleY,o=r.bbox;return new ii((n.x-((o==null?void 0:o.left)||0))/i,(n.y-((o==null?void 0:o.top)||0))/a)}},{key:"viewport2Client",value:function(n){var r=this.getScale(),i=r.scaleX,a=r.scaleY,o=r.bbox;return new ii((n.x+((o==null?void 0:o.left)||0))*i,(n.y+((o==null?void 0:o.top)||0))*a)}},{key:"viewport2Canvas",value:function(n){var r=n.x,i=n.y,a=this.rootTarget.defaultView,o=a.getCamera(),s=this.context.config,c=s.width,l=s.height,u=o.getPerspectiveInverse(),f=o.getWorldTransform(),d=Gn(this.tmpMatrix,f,u),h=Gr(this.tmpVec3,r/c*2-1,(1-i/l)*2-1,0);return er(h,h,d),new ii(h[0],h[1])}},{key:"canvas2Viewport",value:function(n){var r=this.rootTarget.defaultView,i=r.getCamera(),a=i.getPerspective(),o=i.getViewTransform(),s=Gn(this.tmpMatrix,a,o),c=Gr(this.tmpVec3,n.x,n.y,0);er(this.tmpVec3,this.tmpVec3,s);var l=this.context.config,u=l.width,f=l.height;return new ii((c[0]+1)/2*u,(1-(c[1]+1)/2)*f)}},{key:"setPickHandler",value:function(n){this.pickHandler=n}},{key:"addEventMapping",value:function(n,r){this.mappingTable[n]||(this.mappingTable[n]=[]),this.mappingTable[n].push({fn:r,priority:0}),this.mappingTable[n].sort(function(i,a){return i.priority-a.priority})}},{key:"mapEvent",value:function(n){if(this.rootTarget){var r=this.mappingTable[n.type];if(r)for(var i=0,a=r.length;i<a;i++)r[i].fn(n);else console.warn("[EventService]: Event mapping not defined for ".concat(n.type))}}},{key:"dispatchEvent",value:function(n,r,i){if(!i)n.propagationStopped=!1,n.propagationImmediatelyStopped=!1,this.propagate(n,r);else{n.eventPhase=n.AT_TARGET;var a=this.rootTarget.defaultView||null;n.currentTarget=a,this.notifyListeners(n,r)}}},{key:"propagate",value:function(n,r){if(n.target){var i=n.composedPath();n.eventPhase=n.CAPTURING_PHASE;for(var a=i.length-1;a>=1;a--)if(n.currentTarget=i[a],this.notifyTarget(n,r),n.propagationStopped||n.propagationImmediatelyStopped)return;if(n.eventPhase=n.AT_TARGET,n.currentTarget=n.target,this.notifyTarget(n,r),!(n.propagationStopped||n.propagationImmediatelyStopped)){var o=i.indexOf(n.currentTarget);n.eventPhase=n.BUBBLING_PHASE;for(var s=o+1;s<i.length;s++)if(n.currentTarget=i[s],this.notifyTarget(n,r),n.propagationStopped||n.propagationImmediatelyStopped)return}}}},{key:"propagationPath",value:function(n){var r=[n],i=this.rootTarget.defaultView||null;if(i&&i===n)return r.unshift(i.document),r;for(var a=0;a<v_&&n!==this.rootTarget;a++)fr.isNode(n)&&n.parentNode&&(r.push(n.parentNode),n=n.parentNode);return i&&r.push(i),r}},{key:"hitTest",value:function(n){var r=n.viewportX,i=n.viewportY,a=this.context.config,o=a.width,s=a.height,c=a.disableHitTesting;return r<0||i<0||r>o||i>s?null:!c&&this.pickHandler(n)||this.rootTarget||null}},{key:"isNativeEventFromCanvas",value:function(n,r){var i,a=r==null?void 0:r.target;if((i=a)!==null&&i!==void 0&&i.shadowRoot&&(a=r.composedPath()[0]),a){if(a===n)return!0;if(n&&n.contains)return n.contains(a)}return r!=null&&r.composedPath?r.composedPath().indexOf(n)>-1:!1}},{key:"getExistedHTML",value:function(n){if(n.nativeEvent.composedPath)for(var r=0,i=n.nativeEvent.composedPath();r<i.length;r++){var a=i[r],o=this.nativeHTMLMap.get(a);if(o)return o}return null}},{key:"pickTarget",value:function(n){return this.hitTest({clientX:n.clientX,clientY:n.clientY,viewportX:n.viewportX,viewportY:n.viewportY,x:n.canvasX,y:n.canvasY})}},{key:"createPointerEvent",value:function(n,r,i,a){var o=this.allocateEvent(pp);this.copyPointerData(n,o),this.copyMouseData(n,o),this.copyData(n,o),o.nativeEvent=n.nativeEvent,o.originalEvent=n;var s=this.getExistedHTML(o),c=this.context.contextService.getDomElement();return o.target=i!=null?i:s||this.isNativeEventFromCanvas(c,o.nativeEvent)&&this.pickTarget(o)||a,typeof r=="string"&&(o.type=r),o}},{key:"createWheelEvent",value:function(n){var r=this.allocateEvent(vp);this.copyWheelData(n,r),this.copyMouseData(n,r),this.copyData(n,r),r.nativeEvent=n.nativeEvent,r.originalEvent=n;var i=this.getExistedHTML(r),a=this.context.contextService.getDomElement();return r.target=i||this.isNativeEventFromCanvas(a,r.nativeEvent)&&this.pickTarget(r),r}},{key:"trackingData",value:function(n){return this.mappingState.trackingData[n]||(this.mappingState.trackingData[n]={pressTargetsByButton:{},clicksByButton:{},overTarget:null}),this.mappingState.trackingData[n]}},{key:"cloneWheelEvent",value:function(n){var r=this.allocateEvent(vp);return r.nativeEvent=n.nativeEvent,r.originalEvent=n.originalEvent,this.copyWheelData(n,r),this.copyMouseData(n,r),this.copyData(n,r),r.target=n.target,r.path=n.composedPath().slice(),r.type=n.type,r}},{key:"clonePointerEvent",value:function(n,r){var i=this.allocateEvent(pp);return i.nativeEvent=n.nativeEvent,i.originalEvent=n.originalEvent,this.copyPointerData(n,i),this.copyMouseData(n,i),this.copyData(n,i),i.target=n.target,i.path=n.composedPath().slice(),i.type=r!=null?r:i.type,i}},{key:"copyPointerData",value:function(n,r){r.pointerId=n.pointerId,r.width=n.width,r.height=n.height,r.isPrimary=n.isPrimary,r.pointerType=n.pointerType,r.pressure=n.pressure,r.tangentialPressure=n.tangentialPressure,r.tiltX=n.tiltX,r.tiltY=n.tiltY,r.twist=n.twist}},{key:"copyMouseData",value:function(n,r){r.altKey=n.altKey,r.button=n.button,r.buttons=n.buttons,r.ctrlKey=n.ctrlKey,r.metaKey=n.metaKey,r.shiftKey=n.shiftKey,r.client.copyFrom(n.client),r.movement.copyFrom(n.movement),r.canvas.copyFrom(n.canvas),r.screen.copyFrom(n.screen),r.global.copyFrom(n.global),r.offset.copyFrom(n.offset)}},{key:"copyWheelData",value:function(n,r){r.deltaMode=n.deltaMode,r.deltaX=n.deltaX,r.deltaY=n.deltaY,r.deltaZ=n.deltaZ}},{key:"copyData",value:function(n,r){r.isTrusted=n.isTrusted,r.timeStamp=lp.now(),r.type=n.type,r.detail=n.detail,r.view=n.view,r.page.copyFrom(n.page),r.viewport.copyFrom(n.viewport)}},{key:"allocateEvent",value:function(n){this.eventPool.has(n)||this.eventPool.set(n,[]);var r=this.eventPool.get(n).pop()||new n(this);return r.eventPhase=r.NONE,r.currentTarget=null,r.path=[],r.target=null,r}},{key:"freeEvent",value:function(n){if(n.manager!==this)throw new Error("It is illegal to free an event not managed by this EventBoundary!");var r=n.constructor;this.eventPool.has(r)||this.eventPool.set(r,[]),this.eventPool.get(r).push(n)}},{key:"notifyTarget",value:function(n,r){r=r!=null?r:n.type;var i=n.eventPhase===n.CAPTURING_PHASE||n.eventPhase===n.AT_TARGET?"".concat(r,"capture"):r;this.notifyListeners(n,i),n.eventPhase===n.AT_TARGET&&this.notifyListeners(n,r)}},{key:"notifyListeners",value:function(n,r){var i=n.currentTarget.emitter,a=i._events[r];if(a)if("fn"in a)a.once&&i.removeListener(r,a.fn,void 0,!0),a.fn.call(n.currentTarget||a.context,n);else for(var o=0;o<a.length&&!n.propagationImmediatelyStopped;o++)a[o].once&&i.removeListener(r,a[o].fn,void 0,!0),a[o].fn.call(n.currentTarget||a[o].context,n)}},{key:"findMountedTarget",value:function(n){if(!n)return null;for(var r=n[n.length-1],i=n.length-2;i>=0;i--){var a=n[i];if(a===this.rootTarget||fr.isNode(a)&&a.parentNode===r)r=n[i];else break}return r}},{key:"getCursor",value:function(n){for(var r=n;r;){var i=cy(r)&&r.getAttribute("cursor");if(i)return i;r=fr.isNode(r)&&r.parentNode}}}])}(),gp=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"getOrCreateCanvas",value:function(n,r){if(this.canvas)return this.canvas;if(n||Ct.offscreenCanvas)this.canvas=n||Ct.offscreenCanvas,this.context=this.canvas.getContext("2d",(0,Ee.Z)({willReadFrequently:!0},r));else try{this.canvas=new window.OffscreenCanvas(0,0),this.context=this.canvas.getContext("2d",(0,Ee.Z)({willReadFrequently:!0},r)),(!this.context||!this.context.measureText)&&(this.canvas=document.createElement("canvas"),this.context=this.canvas.getContext("2d"))}catch(i){this.canvas=document.createElement("canvas"),this.context=this.canvas.getContext("2d",(0,Ee.Z)({willReadFrequently:!0},r))}return this.canvas.width=10,this.canvas.height=10,this.canvas}},{key:"getOrCreateContext",value:function(n,r){return this.context?this.context:(this.getOrCreateCanvas(n,r),this.context)}}],[{key:"createCanvas",value:function(){try{return new window.OffscreenCanvas(0,0)}catch(n){}try{return document.createElement("canvas")}catch(n){}return null}}])}(),Kc=function(t){return t[t.CAMERA_CHANGED=0]="CAMERA_CHANGED",t[t.DISPLAY_OBJECT_CHANGED=1]="DISPLAY_OBJECT_CHANGED",t[t.NONE=2]="NONE",t}({}),y_=function(){function t(e,n){(0,xt.Z)(this,t),this.inited=!1,this.stats={total:0,rendered:0},this.zIndexCounter=0,this.hooks={init:new Li,initAsync:new Q2,dirtycheck:new ou,cull:new ou,beginFrame:new Li,beforeRender:new Li,render:new Li,afterRender:new Li,endFrame:new Li,destroy:new Li,pick:new J2,pickSync:new ou,pointerDown:new Li,pointerUp:new Li,pointerMove:new Li,pointerOut:new Li,pointerOver:new Li,pointerWheel:new Li,pointerCancel:new Li,click:new Li},this.globalRuntime=e,this.context=n}return(0,Ot.Z)(t,[{key:"init",value:function(n){var r=this,i=(0,Ee.Z)((0,Ee.Z)({},this.globalRuntime),this.context);this.context.renderingPlugins.forEach(function(a){a.apply(i,r.globalRuntime)}),this.hooks.init.call(),this.hooks.initAsync.getCallbacksNum()===0?(this.inited=!0,n()):this.hooks.initAsync.promise().then(function(){r.inited=!0,n()}).catch(function(a){})}},{key:"getStats",value:function(){return this.stats}},{key:"disableDirtyRectangleRendering",value:function(){var n=this.context.config.renderer,r=n.getConfig(),i=r.enableDirtyRectangleRendering;return!i||this.context.renderingContext.renderReasons.has(Kc.CAMERA_CHANGED)}},{key:"render",value:function(n,r,i){var a=this;this.stats.total=0,this.stats.rendered=0,this.zIndexCounter=0;var o=this.context.renderingContext;if(this.globalRuntime.sceneGraphService.syncHierarchy(o.root),this.globalRuntime.sceneGraphService.triggerPendingEvents(),o.renderReasons.size&&this.inited){o.dirtyRectangleRenderingDisabled=this.disableDirtyRectangleRendering();var s=o.renderReasons.size===1&&o.renderReasons.has(Kc.CAMERA_CHANGED),c=!n.disableRenderHooks||!(n.disableRenderHooks&&s);c&&this.renderDisplayObject(o.root,n,o),this.hooks.beginFrame.call(r),c&&o.renderListCurrentFrame.forEach(function(l){a.hooks.beforeRender.call(l),a.hooks.render.call(l),a.hooks.afterRender.call(l)}),this.hooks.endFrame.call(r),o.renderListCurrentFrame=[],o.renderReasons.clear(),i()}}},{key:"renderDisplayObject",value:function(n,r,i){var a=this,o=r.renderer.getConfig(),s=o.enableDirtyCheck,c=o.enableCulling;function l(v){var g=v.renderable,y=v.sortable,b=s?g.dirty||i.dirtyRectangleRenderingDisabled?v:null:v;if(b){var x=c?a.hooks.cull.call(b,a.context.camera):b;x&&(a.stats.rendered+=1,i.renderListCurrentFrame.push(x))}g.dirty=!1,y.renderOrder=a.zIndexCounter,a.zIndexCounter+=1,a.stats.total+=1,y.dirty&&(a.sort(v,y),y.dirty=!1,y.dirtyChildren=[],y.dirtyReason=void 0)}for(var u=[n];u.length>0;){var f=u.pop();l(f);for(var d=f.sortable.sorted||f.childNodes,h=d.length-1;h>=0;h--)u.push(d[h])}}},{key:"sort",value:function(n,r){r.sorted&&r.dirtyReason!==kf.Z_INDEX_CHANGED?r.dirtyChildren.forEach(function(i){var a=n.childNodes.indexOf(i);if(a===-1){var o=r.sorted.indexOf(i);o>=0&&r.sorted.splice(o,1)}else if(r.sorted.length===0)r.sorted.push(i);else{var s=ly(r.sorted,i);r.sorted.splice(s,0,i)}}):r.sorted=n.childNodes.slice().sort(uy)}},{key:"destroy",value:function(){this.inited=!1,this.hooks.destroy.call(),this.globalRuntime.sceneGraphService.clearPendingEvents()}},{key:"dirtify",value:function(){this.context.renderingContext.renderReasons.add(Kc.DISPLAY_OBJECT_CHANGED)}}])}(),m_=/\[\s*(.*)=(.*)\s*\]/,b_=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"selectOne",value:function(n,r){var i=this;if(n.startsWith("."))return r.find(function(c){return((c==null?void 0:c.classList)||[]).indexOf(i.getIdOrClassname(n))>-1});if(n.startsWith("#"))return r.find(function(c){return c.id===i.getIdOrClassname(n)});if(n.startsWith("[")){var a=this.getAttribute(n),o=a.name,s=a.value;return o?r.find(function(c){return r!==c&&(o==="name"?c.name===s:i.attributeToString(c,o)===s)}):null}return r.find(function(c){return r!==c&&c.nodeName===n})}},{key:"selectAll",value:function(n,r){var i=this;if(n.startsWith("."))return r.findAll(function(c){return r!==c&&((c==null?void 0:c.classList)||[]).indexOf(i.getIdOrClassname(n))>-1});if(n.startsWith("#"))return r.findAll(function(c){return r!==c&&c.id===i.getIdOrClassname(n)});if(n.startsWith("[")){var a=this.getAttribute(n),o=a.name,s=a.value;return o?r.findAll(function(c){return r!==c&&(o==="name"?c.name===s:i.attributeToString(c,o)===s)}):[]}return r.findAll(function(c){return r!==c&&c.nodeName===n})}},{key:"is",value:function(n,r){if(n.startsWith("."))return r.className===this.getIdOrClassname(n);if(n.startsWith("#"))return r.id===this.getIdOrClassname(n);if(n.startsWith("[")){var i=this.getAttribute(n),a=i.name,o=i.value;return a==="name"?r.name===o:this.attributeToString(r,a)===o}return r.nodeName===n}},{key:"getIdOrClassname",value:function(n){return n.substring(1)}},{key:"getAttribute",value:function(n){var r=n.match(m_),i="",a="";return r&&r.length>2&&(i=r[1].replace(/"/g,""),a=r[2].replace(/"/g,"")),{name:i,value:a}}},{key:"attributeToString",value:function(n,r){if(!n.getAttribute)return"";var i=n.getAttribute(r);return ge(i)?"":i.toString?i.toString():""}}])}(),$e=function(t){return t.ATTR_MODIFIED="DOMAttrModified",t.INSERTED="DOMNodeInserted",t.MOUNTED="DOMNodeInsertedIntoDocument",t.REMOVED="removed",t.UNMOUNTED="DOMNodeRemovedFromDocument",t.REPARENT="reparent",t.DESTROY="destroy",t.BOUNDS_CHANGED="bounds-changed",t.CULLED="culled",t}({}),ho=function(t){function e(n,r,i,a,o,s,c,l){var u;return(0,xt.Z)(this,e),u=(0,De.Z)(this,e,[null]),u.relatedNode=r,u.prevValue=i,u.newValue=a,u.attrName=o,u.attrChange=s,u.prevParsedValue=c,u.newParsedValue=l,u.type=n,u}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(Yf);ho.ADDITION=2,ho.MODIFICATION=1,ho.REMOVAL=3;function _y(t){var e=t.renderable;e&&(e.renderBoundsDirty=!0,e.boundsDirty=!0)}var x_=new ho($e.REPARENT,null,"","","",0,"",""),p=ri(),m=me(),S=sn(1,1,1),T=Wn(),B=ri(),Y=me(),q=Wn(),et=je(),st=me(),Et=je(),Mt=me(),Pt=me(),Vt=me(),de=Wn(),ke=je(),Xe=je(),we=je(),tn={affectChildren:!0},dn=function(){function t(e){(0,xt.Z)(this,t),this.pendingEvents=new Map,this.boundsChangedEvent=new Nn($e.BOUNDS_CHANGED),this.displayObjectDependencyMap=new WeakMap,this.runtime=e}return(0,Ot.Z)(t,[{key:"matches",value:function(n,r){return this.runtime.sceneGraphSelector.is(n,r)}},{key:"querySelector",value:function(n,r){return this.runtime.sceneGraphSelector.selectOne(n,r)}},{key:"querySelectorAll",value:function(n,r){return this.runtime.sceneGraphSelector.selectAll(n,r)}},{key:"attach",value:function(n,r,i){var a,o=!1;n.parentNode&&(o=n.parentNode!==r,this.detach(n));var s=n.nodeName===dt.FRAGMENT,c=Wf(r);n.parentNode=r;var l=s?n.childNodes:[n];Vn(i)?l.forEach(function(h){r.childNodes.splice(i,0,h),h.parentNode=r}):l.forEach(function(h){r.childNodes.push(h),h.parentNode=r});var u=r,f=u.sortable;if((f!=null&&(a=f.sorted)!==null&&a!==void 0&&a.length||n.parsedStyle.zIndex)&&(f.dirtyChildren.indexOf(n)===-1&&f.dirtyChildren.push(n),f.dirty=!0,f.dirtyReason=kf.ADDED),!c){if(s)this.dirtifyFragment(n);else{var d=n.transformable;d&&this.dirtifyWorld(n,d)}o&&n.dispatchEvent(x_)}}},{key:"detach",value:function(n){if(n.parentNode){var r,i,a=n.transformable,o=n.parentNode,s=o.sortable;(s!=null&&(r=s.sorted)!==null&&r!==void 0&&r.length||(i=n.style)!==null&&i!==void 0&&i.zIndex)&&(s.dirtyChildren.indexOf(n)===-1&&s.dirtyChildren.push(n),s.dirty=!0,s.dirtyReason=kf.REMOVED);var c=n.parentNode.childNodes.indexOf(n);c>-1&&n.parentNode.childNodes.splice(c,1),a&&this.dirtifyWorld(n,a),n.parentNode=null}}},{key:"getOrigin",value:function(n){return n.getGeometryBounds(),n.transformable.origin}},{key:"setOrigin",value:function(n,r){var i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0;typeof r=="number"&&(r=[r,i,a]);var o=n.transformable;if(!(r[0]===o.origin[0]&&r[1]===o.origin[1]&&r[2]===o.origin[2])){var s=o.origin;s[0]=r[0],s[1]=r[1],s[2]=r[2]||0,this.dirtifyLocal(n,o)}}},{key:"rotate",value:function(n,r){var i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0;typeof r=="number"&&(r=sn(r,i,a));var o=n.transformable;if(n.parentNode===null||!n.parentNode.transformable)this.rotateLocal(n,r);else{var s=et;Fs(s,r[0],r[1],r[2]);var c=this.getRotation(n),l=this.getRotation(n.parentNode);Pl(we,l),ph(we,we),Ko(s,we,s),Ko(o.localRotation,s,c),Nc(o.localRotation,o.localRotation),this.dirtifyLocal(n,o)}}},{key:"rotateLocal",value:function(n,r){var i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0;typeof r=="number"&&(r=sn(r,i,a));var o=n.transformable;Fs(Xe,r[0],r[1],r[2]),Rc(o.localRotation,o.localRotation,Xe),this.dirtifyLocal(n,o)}},{key:"setEulerAngles",value:function(n,r){var i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0;typeof r=="number"&&(r=sn(r,i,a));var o=n.transformable;if(n.parentNode===null||!n.parentNode.transformable)this.setLocalEulerAngles(n,r);else{Fs(o.localRotation,r[0],r[1],r[2]);var s=this.getRotation(n.parentNode);Pl(ke,ph(et,s)),Rc(o.localRotation,o.localRotation,ke),this.dirtifyLocal(n,o)}}},{key:"setLocalEulerAngles",value:function(n,r){var i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0,o=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!0;typeof r=="number"&&(r=sn(r,i,a));var s=n.transformable;Fs(s.localRotation,r[0],r[1],r[2]),o&&this.dirtifyLocal(n,s)}},{key:"translateLocal",value:function(n,r){var i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0;typeof r=="number"&&(r=sn(r,i,a));var o=n.transformable;K(r,m)||(pi(r,r,o.localRotation),Na(o.localPosition,o.localPosition,r),this.dirtifyLocal(n,o))}},{key:"setPosition",value:function(n,r){var i,a=n.transformable;if(Vt[0]=r[0],Vt[1]=r[1],Vt[2]=(i=r[2])!==null&&i!==void 0?i:0,!K(this.getPosition(n),Vt)){if(ca(a.position,Vt),n.parentNode===null||!n.parentNode.transformable)ca(a.localPosition,Vt);else{var o=n.parentNode.transformable;Tc(de,o.worldTransform),$i(de,de),er(a.localPosition,Vt,de)}this.dirtifyLocal(n,a)}}},{key:"setLocalPosition",value:function(n,r){var i,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!0,o=n.transformable;Pt[0]=r[0],Pt[1]=r[1],Pt[2]=(i=r[2])!==null&&i!==void 0?i:0,!K(o.localPosition,Pt)&&(ca(o.localPosition,Pt),a&&this.dirtifyLocal(n,o))}},{key:"scaleLocal",value:function(n,r){var i,a=n.transformable;Bd(a.localScale,a.localScale,Gr(Y,r[0],r[1],(i=r[2])!==null&&i!==void 0?i:1)),this.dirtifyLocal(n,a)}},{key:"setLocalScale",value:function(n,r){var i,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!0,o=n.transformable;Gr(Y,r[0],r[1],(i=r[2])!==null&&i!==void 0?i:o.localScale[2]),!K(Y,o.localScale)&&(ca(o.localScale,Y),a&&this.dirtifyLocal(n,o))}},{key:"translate",value:function(n,r){var i=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0,a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:0;typeof r=="number"&&(r=Gr(Y,r,i,a)),!K(r,m)&&(Na(Y,this.getPosition(n),r),this.setPosition(n,Y))}},{key:"setRotation",value:function(n,r,i,a,o){var s=n.transformable;if(typeof r=="number"&&(r=Mv(r,i,a,o)),n.parentNode===null||!n.parentNode.transformable)this.setLocalRotation(n,r);else{var c=this.getRotation(n.parentNode);Pl(et,c),ph(et,et),Ko(s.localRotation,et,r),Nc(s.localRotation,s.localRotation),this.dirtifyLocal(n,s)}}},{key:"setLocalRotation",value:function(n,r,i,a,o){var s=arguments.length>5&&arguments[5]!==void 0?arguments[5]:!0;typeof r=="number"&&(r=Cl(et,r,i,a,o));var c=n.transformable;Pl(c.localRotation,r),s&&this.dirtifyLocal(n,c)}},{key:"setLocalSkew",value:function(n,r,i){var a=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!0;typeof r=="number"&&(r=Nb(B,r,i));var o=n.transformable;kv(o.localSkew,r),a&&this.dirtifyLocal(n,o)}},{key:"dirtifyLocal",value:function(n,r){Wf(n)||r.localDirtyFlag||(r.localDirtyFlag=!0,r.dirtyFlag||this.dirtifyWorld(n,r))}},{key:"dirtifyWorld",value:function(n,r){r.dirtyFlag||this.unfreezeParentToRoot(n),this.dirtifyWorldInternal(n,r),this.dirtifyToRoot(n,!0)}},{key:"dirtifyFragment",value:function(n){var r=n.transformable;r&&(r.frozen=!1,r.dirtyFlag=!0,r.localDirtyFlag=!0);var i=n.renderable;i&&(i.renderBoundsDirty=!0,i.boundsDirty=!0,i.dirty=!0);for(var a=n.childNodes.length,o=0;o<a;o++)this.dirtifyFragment(n.childNodes[o]);n.nodeName===dt.FRAGMENT&&this.pendingEvents.set(n,!1)}},{key:"triggerPendingEvents",value:function(){var n=this,r=new Set,i=function(o,s){!o.isConnected||r.has(o)||o.nodeName===dt.FRAGMENT||(n.boundsChangedEvent.detail=s,n.boundsChangedEvent.target=o,o.isMutationObserved?o.dispatchEvent(n.boundsChangedEvent):o.ownerDocument.defaultView.dispatchEvent(n.boundsChangedEvent,!0),r.add(o))};this.pendingEvents.forEach(function(a,o){o.nodeName!==dt.FRAGMENT&&(tn.affectChildren=a,a?o.forEach(function(s){i(s,tn)}):i(o,tn))}),r.clear(),this.clearPendingEvents()}},{key:"clearPendingEvents",value:function(){this.pendingEvents.clear()}},{key:"dirtifyToRoot",value:function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,i=n;for(i.renderable&&(i.renderable.dirty=!0);i;)_y(i),i=i.parentNode;r&&n.forEach(function(a){_y(a)}),this.informDependentDisplayObjects(n),this.pendingEvents.set(n,r)}},{key:"updateDisplayObjectDependency",value:function(n,r,i,a){if(r&&r!==i){var o=this.displayObjectDependencyMap.get(r);if(o&&o[n]){var s=o[n].indexOf(a);o[n].splice(s,1)}}if(i){var c=this.displayObjectDependencyMap.get(i);c||(this.displayObjectDependencyMap.set(i,{}),c=this.displayObjectDependencyMap.get(i)),c[n]||(c[n]=[]),c[n].push(a)}}},{key:"informDependentDisplayObjects",value:function(n){var r=this,i=this.displayObjectDependencyMap.get(n);i&&Object.keys(i).forEach(function(a){i[a].forEach(function(o){r.dirtifyToRoot(o,!0),o.dispatchEvent(new ho($e.ATTR_MODIFIED,o,r,r,a,ho.MODIFICATION,r,r)),o.isCustomElement&&o.isConnected&&o.attributeChangedCallback&&o.attributeChangedCallback(a,r,r)})})}},{key:"getPosition",value:function(n){var r=n.transformable;return $n(r.position,this.getWorldTransform(n,r))}},{key:"getRotation",value:function(n){var r=n.transformable;return Pc(r.rotation,this.getWorldTransform(n,r))}},{key:"getScale",value:function(n){var r=n.transformable;return fa(r.scaling,this.getWorldTransform(n,r))}},{key:"getWorldTransform",value:function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:n.transformable;return!r.localDirtyFlag&&!r.dirtyFlag||(n.parentNode&&n.parentNode.transformable&&this.getWorldTransform(n.parentNode),this.sync(n,r)),r.worldTransform}},{key:"getLocalPosition",value:function(n){return n.transformable.localPosition}},{key:"getLocalRotation",value:function(n){return n.transformable.localRotation}},{key:"getLocalScale",value:function(n){return n.transformable.localScale}},{key:"getLocalSkew",value:function(n){return n.transformable.localSkew}},{key:"calcLocalTransform",value:function(n){var r=n.localSkew[0]!==0||n.localSkew[1]!==0;if(r){Ds(n.localTransform,n.localRotation,n.localPosition,sn(1,1,1),n.origin),(n.localSkew[0]!==0||n.localSkew[1]!==0)&&(lr(q),q[4]=Math.tan(n.localSkew[0]),q[1]=Math.tan(n.localSkew[1]),Gn(n.localTransform,n.localTransform,q));var i=Ds(q,Cl(et,0,0,0,1),Gr(Y,1,1,1),n.localScale,n.origin);Gn(n.localTransform,n.localTransform,i)}else{var a=n.localTransform,o=n.localPosition,s=n.localRotation,c=n.localScale,l=n.origin,u=o[0]!==0||o[1]!==0||o[2]!==0,f=s[3]!==1||s[0]!==0||s[1]!==0||s[2]!==0,d=c[0]!==1||c[1]!==1||c[2]!==1,h=l[0]!==0||l[1]!==0||l[2]!==0;!f&&!d&&!h?u?Lr(a,o):lr(a):Ds(a,s,o,c,l)}}},{key:"getLocalTransform",value:function(n){var r=n.transformable;return r.localDirtyFlag&&(this.calcLocalTransform(r),r.localDirtyFlag=!1),r.localTransform}},{key:"setLocalTransform",value:function(n,r){var i=$n(st,r),a=Pc(Et,r),o=fa(Mt,r);this.setLocalScale(n,o,!1),this.setLocalPosition(n,i,!1),this.setLocalRotation(n,a,void 0,void 0,void 0,!1),this.dirtifyLocal(n,n.transformable)}},{key:"resetLocalTransform",value:function(n){this.setLocalScale(n,S,!1),this.setLocalPosition(n,m,!1),this.setLocalEulerAngles(n,m,void 0,void 0,!1),this.setLocalSkew(n,p,void 0,!1),this.dirtifyLocal(n,n.transformable)}},{key:"getTransformedGeometryBounds",value:function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,i=arguments.length>2?arguments[2]:void 0,a=this.getGeometryBounds(n,r);if(!xr.isEmpty(a)){var o=i||new xr;return o.setFromTransformedAABB(a,this.getWorldTransform(n)),o}return null}},{key:"getGeometryBounds",value:function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,i=n,a=i.geometry;a.dirty&&Ct.styleValueRegistry.updateGeometry(n);var o=r?a.renderBounds:a.contentBounds||null;return o||new xr}},{key:"getBounds",value:function(n){var r=this,i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,a=n,o=a.renderable;if(!o.boundsDirty&&!i&&o.bounds)return o.bounds;if(!o.renderBoundsDirty&&i&&o.renderBounds)return o.renderBounds;var s=i?o.renderBounds:o.bounds,c=this.getTransformedGeometryBounds(n,i,s),l=n.childNodes;if(l.forEach(function(d){var h=r.getBounds(d,i);h&&(c?c.add(h):(c=s||new xr,c.update(h.center,h.halfExtents)))}),c||(c=new xr),i){var u=fy(n);if(u){var f=u.parsedStyle.clipPath.getBounds(i);c?f&&(c=f.intersection(c)):c.update(f.center,f.halfExtents)}}return i?(o.renderBounds=c,o.renderBoundsDirty=!1):(o.bounds=c,o.boundsDirty=!1),c}},{key:"getLocalBounds",value:function(n){if(n.parentNode){var r=T;n.parentNode.transformable&&(r=$i(q,this.getWorldTransform(n.parentNode)));var i=this.getBounds(n);if(!xr.isEmpty(i)){var a=new xr;return a.setFromTransformedAABB(i,r),a}}return this.getBounds(n)}},{key:"getBoundingClientRect",value:function(n){var r,i,a=this.getGeometryBounds(n);xr.isEmpty(a)||(i=new xr,i.setFromTransformedAABB(a,this.getWorldTransform(n)));var o=(r=n.ownerDocument)===null||r===void 0||(r=r.defaultView)===null||r===void 0?void 0:r.getContextService().getBoundingClientRect();if(i){var s=i.getMin(),c=(0,Te.Z)(s,2),l=c[0],u=c[1],f=i.getMax(),d=(0,Te.Z)(f,2),h=d[0],v=d[1];return new Fo(l+((o==null?void 0:o.left)||0),u+((o==null?void 0:o.top)||0),h-l,v-u)}return new Fo((o==null?void 0:o.left)||0,(o==null?void 0:o.top)||0,0,0)}},{key:"dirtifyWorldInternal",value:function(n,r){var i=this;if(!r.dirtyFlag){r.dirtyFlag=!0,r.frozen=!1,n.childNodes.forEach(function(s){var c=s.transformable;c.dirtyFlag||i.dirtifyWorldInternal(s,c)});var a=n,o=a.renderable;o&&(o.renderBoundsDirty=!0,o.boundsDirty=!0,o.dirty=!0)}}},{key:"syncHierarchy",value:function(n){var r=n.transformable;if(!r.frozen){r.frozen=!0,(r.localDirtyFlag||r.dirtyFlag)&&this.sync(n,r);for(var i=n.childNodes,a=0;a<i.length;a++)this.syncHierarchy(i[a])}}},{key:"sync",value:function(n,r){if(r.localDirtyFlag&&(this.calcLocalTransform(r),r.localDirtyFlag=!1),r.dirtyFlag){var i=n.parentNode,a=i&&i.transformable;i===null||!a?Tc(r.worldTransform,r.localTransform):Gn(r.worldTransform,a.worldTransform,r.localTransform),r.dirtyFlag=!1}}},{key:"unfreezeParentToRoot",value:function(n){for(var r=n.parentNode;r;){var i=r.transformable;i&&(i.frozen=!1),r=r.parentNode}}}])}(),Hr={MetricsString:"|\xC9q\xC5",BaselineSymbol:"M",BaselineMultiplier:1.4,HeightMultiplier:2,Newlines:[10,13],BreakingSpaces:[9,32,8192,8193,8194,8195,8196,8197,8198,8200,8201,8202,8287,12288]},mi=/[a-zA-Z0-9\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff!"#$%&'()*+,-./:;]/,ha=/[!%),.:;?\]}¢°·'""†‡›℃∶、。〃〆〕〗〞﹚﹜！＂％＇），．：；？！］｝～]/,Sr=/[$(£¥·'"〈《「『【〔〖〝﹙﹛＄（．［｛￡￥]/,Ga=/[!),.:;?\]}¢·–—'"•"、。〆〞〕〉》」︰︱︲︳﹐﹑﹒﹓﹔﹕﹖﹘﹚﹜！），．：；？︶︸︺︼︾﹀﹂﹗］｜｝､]/,Bo=/[([{£¥'"‵〈《「『〔〝︴﹙﹛（｛︵︷︹︻︽︿﹁﹃﹏]/,wy=/[)\]｝〕〉》」』】〙〗〟'"｠»ヽヾーァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖㇰㇱㇲㇳㇴㇵㇶㇷㇸㇹㇺㇻㇼㇽㇾㇿ々〻‐゠–〜?!‼⁇⁈⁉・、:;,。.]/,v8=/[([｛〔〈《「『【〘〖〝'"｟«—...‥〳〴〵]/,g8=/[!%),.:;?\]}¢°'"†‡℃〆〈《「『〕！％），．：；？］｝]/,y8=/[$([{£¥'"々〇〉》」〔＄（［｛｠￥￦#]/,m8=new RegExp("".concat(ha.source,"|").concat(Ga.source,"|").concat(wy.source,"|").concat(g8.source)),b8=new RegExp("".concat(Sr.source,"|").concat(Bo.source,"|").concat(v8.source,"|").concat(y8.source)),x8=function(){function t(e){var n=this;(0,xt.Z)(this,t),this.fontMetricsCache={},this.shouldBreakByKinsokuShorui=function(r,i){return n.isBreakingSpace(i)?!1:!!(r&&(b8.exec(i)||m8.exec(r)))},this.trimByKinsokuShorui=function(r){var i=(0,ln.Z)(r),a=i[i.length-2];if(!a)return r;var o=a[a.length-1];return i[i.length-2]=a.slice(0,-1),i[i.length-1]=o+i[i.length-1],i},this.runtime=e}return(0,Ot.Z)(t,[{key:"measureFont",value:function(n,r){if(this.fontMetricsCache[n])return this.fontMetricsCache[n];var i={ascent:0,descent:0,fontSize:0},a=this.runtime.offscreenCanvasCreator.getOrCreateCanvas(r),o=this.runtime.offscreenCanvasCreator.getOrCreateContext(r,{willReadFrequently:!0});o.font=n;var s=Hr.MetricsString+Hr.BaselineSymbol,c=Math.ceil(o.measureText(s).width),l=Math.ceil(o.measureText(Hr.BaselineSymbol).width),u=Hr.HeightMultiplier*l;l=l*Hr.BaselineMultiplier|0,a.width=c,a.height=u,o.fillStyle="#f00",o.fillRect(0,0,c,u),o.font=n,o.textBaseline="alphabetic",o.fillStyle="#000",o.fillText(s,0,l);var f=o.getImageData(0,0,c||1,u||1).data,d=f.length,h=c*4,v=0,g=0,y=!1;for(v=0;v<l;++v){for(var b=0;b<h;b+=4)if(f[g+b]!==255){y=!0;break}if(!y)g+=h;else break}for(i.ascent=l-v,g=d-h,y=!1,v=u;v>l;--v){for(var x=0;x<h;x+=4)if(f[g+x]!==255){y=!0;break}if(!y)g-=h;else break}return i.descent=v-l,i.fontSize=i.ascent+i.descent,this.fontMetricsCache[n]=i,i}},{key:"measureText",value:function(n,r,i){var a=r.fontSize,o=a===void 0?16:a,s=r.wordWrap,c=s===void 0?!1:s,l=r.lineHeight,u=r.lineWidth,f=u===void 0?1:u,d=r.textBaseline,h=d===void 0?"alphabetic":d,v=r.textAlign,g=v===void 0?"start":v,y=r.letterSpacing,b=y===void 0?0:y,x=r.textPath;r.textPathSide,r.textPathStartOffset;var _=r.leading,w=_===void 0?0:_,O=n_(r),E=this.measureFont(O,i);E.fontSize===0&&(E.fontSize=o,E.ascent=o);var M=this.runtime.offscreenCanvasCreator.getOrCreateContext(i);M.font=O,r.isOverflowing=!1;var k=c?this.wordWrap(n,r,i):n,A=k.split(/(?:\r\n|\r|\n)/),P=new Array(A.length),C=0;if(x){x.getTotalLength();for(var N=0;N<A.length;N++)M.measureText(A[N]).width+(A[N].length-1)*b}else{for(var L=0;L<A.length;L++){var R=M.measureText(A[L]).width+(A[L].length-1)*b;P[L]=R,C=Math.max(C,R)}var I=C+f,D=l||E.fontSize+f,G=Math.max(D,E.fontSize+f)+(A.length-1)*(D+w);D+=w;var F=0;return h==="middle"?F=-G/2:h==="bottom"||h==="alphabetic"||h==="ideographic"?F=-G:(h==="top"||h==="hanging")&&(F=0),{font:O,width:I,height:G,lines:A,lineWidths:P,lineHeight:D,maxLineWidth:C,fontProperties:E,lineMetrics:P.map(function(W,X){var Q=0;return g==="center"||g==="middle"?Q-=W/2:(g==="right"||g==="end")&&(Q-=W),new Fo(Q-f/2,F+X*D,W+f,D)})}}}},{key:"wordWrap",value:function(n,r,i){var a=this,o=this,s=r.wordWrapWidth,c=s===void 0?0:s,l=r.letterSpacing,u=l===void 0?0:l,f=r.maxLines,d=f===void 0?1/0:f,h=r.textOverflow,v=this.runtime.offscreenCanvasCreator.getOrCreateContext(i),g=c+u,y="";h==="ellipsis"?y="...":h&&h!=="clip"&&(y=h);var b=Array.from(n),x=[],_=0,w=0,O=0,E={},M=function(F){return a.getFromCache(F,u,E,v)},k=M(y);function A(G,F,W,X){for(;M(G)<X&&F<b.length-1&&!o.isNewline(b[F+1]);)F+=1,G+=b[F];for(;M(G)>X&&F>W;)F-=1,G=G.slice(0,-1);return{lineTxt:G,txtLastCharIndex:F}}function P(G,F){if(!(k<=0||k>g)){if(!x[G]){x[G]=y;return}var W=A(x[G],F,O+1,g-k);x[G]=W.lineTxt+y}}for(var C=0;C<b.length;C++){var N=b[C],L=b[C-1],R=b[C+1],I=M(N);if(this.isNewline(N)){if(_+1>=d){r.isOverflowing=!0,C<b.length-1&&P(_,C-1);break}O=C-1,_+=1,w=0,x[_]="";continue}if(w>0&&w+I>g){var D=A(x[_],C-1,O+1,g);if(D.txtLastCharIndex!==C-1){if(x[_]=D.lineTxt,D.txtLastCharIndex===b.length-1)break;C=D.txtLastCharIndex+1,N=b[C],L=b[C-1],R=b[C+1],I=M(N)}if(_+1>=d){r.isOverflowing=!0,P(_,C-1);break}if(O=C-1,_+=1,w=0,x[_]="",this.isBreakingSpace(N))continue;this.canBreakInLastChar(N)||(x=this.trimToBreakable(x),w=this.sumTextWidthByCache(x[_]||"",M)),this.shouldBreakByKinsokuShorui(N,R)&&(x=this.trimByKinsokuShorui(x),w+=M(L||""))}w+=I,x[_]=(x[_]||"")+N}return x.join(`
`)}},{key:"isBreakingSpace",value:function(n){return typeof n!="string"?!1:Hr.BreakingSpaces.indexOf(n.charCodeAt(0))>=0}},{key:"isNewline",value:function(n){return typeof n!="string"?!1:Hr.Newlines.indexOf(n.charCodeAt(0))>=0}},{key:"trimToBreakable",value:function(n){var r=(0,ln.Z)(n),i=r[r.length-2],a=this.findBreakableIndex(i);if(a===-1||!i)return r;var o=i.slice(a,a+1),s=this.isBreakingSpace(o),c=a+1,l=a+(s?0:1);return r[r.length-1]+=i.slice(c,i.length),r[r.length-2]=i.slice(0,l),r}},{key:"canBreakInLastChar",value:function(n){return!(n&&mi.test(n))}},{key:"sumTextWidthByCache",value:function(n,r){return n.split("").reduce(function(i,a){return i+r(a)},0)}},{key:"findBreakableIndex",value:function(n){for(var r=n.length-1;r>=0;r--)if(!mi.test(n[r]))return r;return-1}},{key:"getFromCache",value:function(n,r,i,a){var o=i[n];if(typeof o!="number"){var s=n.length*r,c=a.measureText(n);o=c.width+s,i[n]=o}return o}}])}(),Ct={},_8=function(t){var e=new h_,n=new d_;return t={},(0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)(t,dt.FRAGMENT,null),dt.CIRCLE,new l_),dt.ELLIPSE,new u_),dt.RECT,e),dt.IMAGE,e),dt.GROUP,new hp),dt.LINE,new yy),dt.TEXT,new dp(Ct)),dt.POLYLINE,n),dt.POLYGON,n),(0,Kt.Z)((0,Kt.Z)((0,Kt.Z)(t,dt.PATH,new f_),dt.HTML,new p_),dt.MESH,null)}(),w8=function(t){var e=new k2,n=new zf;return t={},(0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)(t,zt.PERCENTAGE,null),zt.NUMBER,new oy),zt.ANGLE,new M2),zt.DEFINED_PATH,new iy),zt.PAINT,e),zt.COLOR,e),zt.FILTER,new A2),zt.LENGTH,n),zt.LENGTH_PERCENTAGE,n),zt.LENGTH_PERCENTAGE_12,new T2),(0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)(t,zt.LENGTH_PERCENTAGE_14,new P2),zt.COORDINATE,new zf),zt.OFFSET_DISTANCE,new sy),zt.OPACITY_VALUE,new L2),zt.PATH,new R2),zt.LIST_OF_POINTS,new N2),zt.SHADOW_BLUR,new I2),zt.TEXT,new qc),zt.TEXT_TRANSFORM,new D2),zt.TRANSFORM,new fp),(0,Kt.Z)((0,Kt.Z)((0,Kt.Z)(t,zt.TRANSFORM_ORIGIN,new s_),zt.Z_INDEX,new c_),zt.MARKER,new C2)}(),O8=function(){return typeof globalThis!="undefined"?globalThis:typeof self!="undefined"?self:typeof window!="undefined"?window:typeof pt.g!="undefined"?pt.g:{}};Ct.CameraContribution=_g,Ct.AnimationTimeline=null,Ct.EasingFunction=null,Ct.offscreenCanvasCreator=new gp,Ct.sceneGraphSelector=new b_,Ct.sceneGraphService=new dn(Ct),Ct.textService=new x8(Ct),Ct.geometryUpdaterFactory=_8,Ct.CSSPropertySyntaxFactory=w8,Ct.styleValueRegistry=new Ki(Ct),Ct.layoutRegistry=null,Ct.globalThis=O8(),Ct.enableStyleSyntax=!0,Ct.enableSizeAttenuation=!1;var pk=0;function Mat(){pk=0}var __=new ho($e.INSERTED,null,"","","",0,"",""),w_=new ho($e.REMOVED,null,"","","",0,"",""),vk=new Nn($e.DESTROY),S8=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.entity=pk++,n.renderable={bounds:void 0,boundsDirty:!0,renderBounds:void 0,renderBoundsDirty:!0,dirtyRenderBounds:void 0,dirty:!1},n.cullable={strategy:Ax.Standard,visibilityPlaneMask:-1,visible:!0,enable:!0},n.transformable={dirtyFlag:!1,localDirtyFlag:!1,frozen:!1,localPosition:[0,0,0],localRotation:[0,0,0,1],localScale:[1,1,1],localTransform:[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],localSkew:[0,0],position:[0,0,0],rotation:[0,0,0,1],scaling:[1,1,1],worldTransform:[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],origin:[0,0,0]},n.sortable={dirty:!1,sorted:void 0,renderOrder:0,dirtyChildren:[],dirtyReason:void 0},n.geometry={contentBounds:void 0,renderBounds:void 0,dirty:!0},n.rBushNode={aabb:void 0},n.namespaceURI="g",n.scrollLeft=0,n.scrollTop=0,n.clientTop=0,n.clientLeft=0,n.destroyed=!1,n.style={},n.computedStyle={},n.parsedStyle={},n.attributes={},n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"className",get:function(){return this.getAttribute("class")||""},set:function(r){this.setAttribute("class",r)}},{key:"classList",get:function(){return this.className.split(" ").filter(function(r){return r!==""})}},{key:"tagName",get:function(){return this.nodeName}},{key:"children",get:function(){return this.childNodes}},{key:"childElementCount",get:function(){return this.childNodes.length}},{key:"firstElementChild",get:function(){return this.firstChild}},{key:"lastElementChild",get:function(){return this.lastChild}},{key:"parentElement",get:function(){return this.parentNode}},{key:"nextSibling",get:function(){if(this.parentNode){var r=this.parentNode.childNodes.indexOf(this);return this.parentNode.childNodes[r+1]||null}return null}},{key:"previousSibling",get:function(){if(this.parentNode){var r=this.parentNode.childNodes.indexOf(this);return this.parentNode.childNodes[r-1]||null}return null}},{key:"cloneNode",value:function(r){throw new Error(kn)}},{key:"appendChild",value:function(r,i){var a;if(r.destroyed)throw new Error(Hs);return Ct.sceneGraphService.attach(r,this,i),(a=this.ownerDocument)!==null&&a!==void 0&&a.defaultView&&(!Wf(this)&&r.nodeName===dt.FRAGMENT?this.ownerDocument.defaultView.mountFragment(r):this.ownerDocument.defaultView.mountChildren(r)),this.isMutationObserved&&(__.relatedNode=this,r.dispatchEvent(__)),r}},{key:"insertBefore",value:function(r,i){if(!i)this.appendChild(r);else{r.parentElement&&r.parentElement.removeChild(r);var a=this.childNodes.indexOf(i);a===-1?this.appendChild(r):this.appendChild(r,a)}return r}},{key:"replaceChild",value:function(r,i){var a=this.childNodes.indexOf(i);return this.removeChild(i),this.appendChild(r,a),i}},{key:"removeChild",value:function(r){var i;return w_.relatedNode=this,r.dispatchEvent(w_),(i=r.ownerDocument)!==null&&i!==void 0&&i.defaultView&&r.ownerDocument.defaultView.unmountChildren(r),Ct.sceneGraphService.detach(r),r}},{key:"removeChildren",value:function(){for(var r=this.childNodes.length-1;r>=0;r--){var i=this.childNodes[r];this.removeChild(i)}}},{key:"destroyChildren",value:function(){for(var r=this.childNodes.length-1;r>=0;r--){var i=this.childNodes[r];i.childNodes.length>0&&i.destroyChildren(),i.destroy()}}},{key:"matches",value:function(r){return Ct.sceneGraphService.matches(r,this)}},{key:"getElementById",value:function(r){return Ct.sceneGraphService.querySelector("#".concat(r),this)}},{key:"getElementsByName",value:function(r){return Ct.sceneGraphService.querySelectorAll('[name="'.concat(r,'"]'),this)}},{key:"getElementsByClassName",value:function(r){return Ct.sceneGraphService.querySelectorAll(".".concat(r),this)}},{key:"getElementsByTagName",value:function(r){return Ct.sceneGraphService.querySelectorAll(r,this)}},{key:"querySelector",value:function(r){return Ct.sceneGraphService.querySelector(r,this)}},{key:"querySelectorAll",value:function(r){return Ct.sceneGraphService.querySelectorAll(r,this)}},{key:"closest",value:function(r){var i=this;do{if(Ct.sceneGraphService.matches(r,i))return i;i=i.parentElement}while(i!==null);return null}},{key:"find",value:function(r){var i=this,a=null;return this.forEach(function(o){return o!==i&&r(o)?(a=o,!1):!0}),a}},{key:"findAll",value:function(r){var i=this,a=[];return this.forEach(function(o){o!==i&&r(o)&&a.push(o)}),a}},{key:"after",value:function(){var r=this;if(this.parentNode){for(var i=this.parentNode.childNodes.indexOf(this),a=arguments.length,o=new Array(a),s=0;s<a;s++)o[s]=arguments[s];o.forEach(function(c,l){var u;return(u=r.parentNode)===null||u===void 0?void 0:u.appendChild(c,i+l+1)})}}},{key:"before",value:function(){if(this.parentNode){for(var r,i=this.parentNode.childNodes.indexOf(this),a=arguments.length,o=new Array(a),s=0;s<a;s++)o[s]=arguments[s];var c=o[0],l=o.slice(1);this.parentNode.appendChild(c,i),(r=c).after.apply(r,(0,ln.Z)(l))}}},{key:"replaceWith",value:function(){this.after.apply(this,arguments),this.remove()}},{key:"append",value:function(){for(var r=this,i=arguments.length,a=new Array(i),o=0;o<i;o++)a[o]=arguments[o];a.forEach(function(s){return r.appendChild(s)})}},{key:"prepend",value:function(){for(var r=this,i=arguments.length,a=new Array(i),o=0;o<i;o++)a[o]=arguments[o];a.forEach(function(s,c){return r.appendChild(s,c)})}},{key:"replaceChildren",value:function(){for(;this.childNodes.length&&this.firstChild;)this.removeChild(this.firstChild);this.append.apply(this,arguments)}},{key:"remove",value:function(){return this.parentNode?this.parentNode.removeChild(this):this}},{key:"destroy",value:function(){this.destroyChildren(),this.dispatchEvent(vk),this.remove(),this.emitter.removeAllListeners(),this.destroyed=!0}},{key:"getGeometryBounds",value:function(){return Ct.sceneGraphService.getGeometryBounds(this)}},{key:"getRenderBounds",value:function(){return Ct.sceneGraphService.getBounds(this,!0)}},{key:"getBounds",value:function(){return Ct.sceneGraphService.getBounds(this)}},{key:"getLocalBounds",value:function(){return Ct.sceneGraphService.getLocalBounds(this)}},{key:"getBoundingClientRect",value:function(){return Ct.sceneGraphService.getBoundingClientRect(this)}},{key:"getClientRects",value:function(){return[this.getBoundingClientRect()]}},{key:"computedStyleMap",value:function(){return new Map(Object.entries(this.computedStyle))}},{key:"getAttributeNames",value:function(){return Object.keys(this.attributes)}},{key:"getAttribute",value:function(r){if(typeof r!="symbol"){var i=this.attributes[r];return i}}},{key:"hasAttribute",value:function(r){return this.getAttributeNames().includes(r)}},{key:"hasAttributes",value:function(){return!!this.getAttributeNames().length}},{key:"removeAttribute",value:function(r){this.setAttribute(r,null),delete this.attributes[r]}},{key:"setAttribute",value:function(r,i,a,o){this.attributes[r]=i}},{key:"getAttributeNS",value:function(r,i){throw new Error(kn)}},{key:"getAttributeNode",value:function(r){throw new Error(kn)}},{key:"getAttributeNodeNS",value:function(r,i){throw new Error(kn)}},{key:"hasAttributeNS",value:function(r,i){throw new Error(kn)}},{key:"removeAttributeNS",value:function(r,i){throw new Error(kn)}},{key:"removeAttributeNode",value:function(r){throw new Error(kn)}},{key:"setAttributeNS",value:function(r,i,a){throw new Error(kn)}},{key:"setAttributeNode",value:function(r){throw new Error(kn)}},{key:"setAttributeNodeNS",value:function(r){throw new Error(kn)}},{key:"toggleAttribute",value:function(r,i){throw new Error(kn)}}])}(fr);function xn(t){return!!(t!=null&&t.nodeName)}var E8=Ct.globalThis.Proxy?Ct.globalThis.Proxy:function(){},ls=new ho($e.ATTR_MODIFIED,null,null,null,null,ho.MODIFICATION,null,null),yp=me(),M8=je(),or=function(t){function e(n){var r;return(0,xt.Z)(this,e),r=(0,De.Z)(this,e),r.isCustomElement=!1,r.isMutationObserved=!1,r.activeAnimations=[],r.config=n,r.id=n.id||"",r.name=n.name||"",(n.className||n.class)&&(r.className=n.className||n.class),r.nodeName=n.type||dt.GROUP,n.initialParsedStyle&&Object.assign(r.parsedStyle,n.initialParsedStyle),r.initAttributes(n.style),Ct.enableStyleSyntax&&(r.style=new E8({setProperty:function(a,o){r.setAttribute(a,o)},getPropertyValue:function(a){return r.getAttribute(a)},removeProperty:function(a){r.removeAttribute(a)},item:function(){return""}},{get:function(a,o){return a[o]!==void 0?a[o]:r.getAttribute(o)},set:function(a,o,s){return r.setAttribute(o,s),!0}})),r}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"destroy",value:function(){Ch(e,"destroy",this,3)([]),this.getAnimations().forEach(function(r){r.cancel()})}},{key:"cloneNode",value:function(r,i){var a=(0,Ee.Z)({},this.attributes);for(var o in a){var s=a[o];xn(s)&&o!=="clipPath"&&o!=="offsetPath"&&o!=="textPath"&&(a[o]=s.cloneNode(r)),i&&(a[o]=i(o,s))}var c=new this.constructor((0,Ee.Z)((0,Ee.Z)({},this.config),{},{style:a}));return c.setLocalTransform(this.getLocalTransform()),r&&this.children.forEach(function(l){if(!l.style.isMarker){var u=l.cloneNode(r);c.appendChild(u)}}),c}},{key:"initAttributes",value:function(){var r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},i={forceUpdateGeometry:!0};Ct.styleValueRegistry.processProperties(this,r,i),this.renderable.dirty=!0}},{key:"setAttribute",value:function(r,i){var a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1,o=arguments.length>3&&arguments[3]!==void 0?arguments[3]:!0;En(i)||(a||i!==this.attributes[r])&&(this.internalSetAttribute(r,i,{memoize:o}),Ch(e,"setAttribute",this,3)([r,i]))}},{key:"internalSetAttribute",value:function(r,i){var a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{},o=this.renderable,s=this.attributes[r],c=this.parsedStyle[r];Ct.styleValueRegistry.processProperties(this,(0,Kt.Z)({},r,i),a),o.dirty=!0;var l=this.parsedStyle[r];if(this.isConnected&&(ls.relatedNode=this,ls.prevValue=s,ls.newValue=i,ls.attrName=r,ls.prevParsedValue=c,ls.newParsedValue=l,this.isMutationObserved?this.dispatchEvent(ls):(ls.target=this,this.ownerDocument.defaultView.dispatchEvent(ls,!0))),this.isCustomElement&&this.isConnected||!this.isCustomElement){var u,f;(u=(f=this).attributeChangedCallback)===null||u===void 0||u.call(f,r,s,i,c,l)}}},{key:"getBBox",value:function(){var r=this.getBounds(),i=r.getMin(),a=(0,Te.Z)(i,2),o=a[0],s=a[1],c=r.getMax(),l=(0,Te.Z)(c,2),u=l[0],f=l[1];return new Fo(o,s,u-o,f-s)}},{key:"setOrigin",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0;return Ct.sceneGraphService.setOrigin(this,Pi(r,i,a,!1)),this}},{key:"getOrigin",value:function(){return Ct.sceneGraphService.getOrigin(this)}},{key:"setPosition",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0;return Ct.sceneGraphService.setPosition(this,Pi(r,i,a,!1)),this}},{key:"setLocalPosition",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0;return Ct.sceneGraphService.setLocalPosition(this,Pi(r,i,a,!1)),this}},{key:"translate",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0;return Ct.sceneGraphService.translate(this,Pi(r,i,a,!1)),this}},{key:"translateLocal",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0;return Ct.sceneGraphService.translateLocal(this,Pi(r,i,a,!1)),this}},{key:"getPosition",value:function(){return Ct.sceneGraphService.getPosition(this)}},{key:"getLocalPosition",value:function(){return Ct.sceneGraphService.getLocalPosition(this)}},{key:"scale",value:function(r,i,a){return this.scaleLocal(r,i,a)}},{key:"scaleLocal",value:function(r,i,a){return typeof r=="number"&&(i=i||r,a=a||r,r=Pi(r,i,a,!1)),Ct.sceneGraphService.scaleLocal(this,r),this}},{key:"setLocalScale",value:function(r,i,a){return typeof r=="number"&&(i=i||r,a=a||r,r=Pi(r,i,a,!1)),Ct.sceneGraphService.setLocalScale(this,r),this}},{key:"getLocalScale",value:function(){return Ct.sceneGraphService.getLocalScale(this)}},{key:"getScale",value:function(){return Ct.sceneGraphService.getScale(this)}},{key:"getEulerAngles",value:function(){var r=Mf(yp,Ct.sceneGraphService.getWorldTransform(this)),i=(0,Te.Z)(r,3),a=i[2];return Sa(a)}},{key:"getLocalEulerAngles",value:function(){var r=Mf(yp,Ct.sceneGraphService.getLocalRotation(this)),i=(0,Te.Z)(r,3),a=i[2];return Sa(a)}},{key:"setEulerAngles",value:function(r){return Ct.sceneGraphService.setEulerAngles(this,0,0,r),this}},{key:"setLocalEulerAngles",value:function(r){return Ct.sceneGraphService.setLocalEulerAngles(this,0,0,r),this}},{key:"rotateLocal",value:function(r,i,a){return ge(i)&&ge(a)?Ct.sceneGraphService.rotateLocal(this,0,0,r):Ct.sceneGraphService.rotateLocal(this,r,i,a),this}},{key:"rotate",value:function(r,i,a){return ge(i)&&ge(a)?Ct.sceneGraphService.rotate(this,0,0,r):Ct.sceneGraphService.rotate(this,r,i,a),this}},{key:"setRotation",value:function(r,i,a,o){return Ct.sceneGraphService.setRotation(this,r,i,a,o),this}},{key:"setLocalRotation",value:function(r,i,a,o){return Ct.sceneGraphService.setLocalRotation(this,r,i,a,o),this}},{key:"setLocalSkew",value:function(r,i){return Ct.sceneGraphService.setLocalSkew(this,r,i),this}},{key:"getRotation",value:function(){return Ct.sceneGraphService.getRotation(this)}},{key:"getLocalRotation",value:function(){return Ct.sceneGraphService.getLocalRotation(this)}},{key:"getLocalSkew",value:function(){return Ct.sceneGraphService.getLocalSkew(this)}},{key:"getLocalTransform",value:function(){return Ct.sceneGraphService.getLocalTransform(this)}},{key:"getWorldTransform",value:function(){return Ct.sceneGraphService.getWorldTransform(this)}},{key:"setLocalTransform",value:function(r){return Ct.sceneGraphService.setLocalTransform(this,r),this}},{key:"resetLocalTransform",value:function(){Ct.sceneGraphService.resetLocalTransform(this)}},{key:"getAnimations",value:function(){return this.activeAnimations}},{key:"animate",value:function(r,i){var a,o=(a=this.ownerDocument)===null||a===void 0?void 0:a.timeline;return o?o.play(this,r,i):null}},{key:"isVisible",value:function(){var r;return((r=this.parsedStyle)===null||r===void 0?void 0:r.visibility)!=="hidden"}},{key:"interactive",get:function(){return this.isInteractive()},set:function(r){this.style.pointerEvents=r?"auto":"none"}},{key:"isInteractive",value:function(){var r;return((r=this.parsedStyle)===null||r===void 0?void 0:r.pointerEvents)!=="none"}},{key:"isCulled",value:function(){return!!(this.cullable&&this.cullable.enable&&!this.cullable.visible)}},{key:"toFront",value:function(){return this.parentNode&&(this.style.zIndex=Math.max.apply(Math,(0,ln.Z)(this.parentNode.children.map(function(r){return Number(r.style.zIndex)})))+1),this}},{key:"toBack",value:function(){return this.parentNode&&(this.style.zIndex=Math.min.apply(Math,(0,ln.Z)(this.parentNode.children.map(function(r){return Number(r.style.zIndex)})))-1),this}},{key:"getConfig",value:function(){return this.config}},{key:"attr",value:function(){for(var r=this,i=arguments.length,a=new Array(i),o=0;o<i;o++)a[o]=arguments[o];var s=a[0],c=a[1];return s?zl(s)?(Object.keys(s).forEach(function(l){r.setAttribute(l,s[l])}),this):a.length===2?(this.setAttribute(s,c),this):this.attributes[s]:this.attributes}},{key:"getMatrix",value:function(r){var i=r||this.getWorldTransform(),a=$n(yp,i),o=(0,Te.Z)(a,2),s=o[0],c=o[1],l=fa(yp,i),u=(0,Te.Z)(l,2),f=u[0],d=u[1],h=Pc(M8,i),v=Mf(yp,h),g=(0,Te.Z)(v,3),y=g[0],b=g[2];return yg(y||b,s,c,f,d)}},{key:"getLocalMatrix",value:function(){return this.getMatrix(this.getLocalTransform())}},{key:"setMatrix",value:function(r){var i=mg(r),a=(0,Te.Z)(i,5),o=a[0],s=a[1],c=a[2],l=a[3],u=a[4];this.setEulerAngles(u).setPosition(o,s).setLocalScale(c,l)}},{key:"setLocalMatrix",value:function(r){var i=mg(r),a=(0,Te.Z)(i,5),o=a[0],s=a[1],c=a[2],l=a[3],u=a[4];this.setLocalEulerAngles(u).setLocalPosition(o,s).setLocalScale(c,l)}},{key:"show",value:function(){this.forEach(function(r){r.style.visibility="visible"})}},{key:"hide",value:function(){this.forEach(function(r){r.style.visibility="hidden"})}},{key:"getCount",value:function(){return this.childElementCount}},{key:"getParent",value:function(){return this.parentElement}},{key:"getChildren",value:function(){return this.children}},{key:"getFirst",value:function(){return this.firstElementChild}},{key:"getLast",value:function(){return this.lastElementChild}},{key:"getChildByIndex",value:function(r){return this.children[r]||null}},{key:"add",value:function(r,i){return this.appendChild(r,i)}},{key:"set",value:function(r,i){this.config[r]=i}},{key:"get",value:function(r){return this.config[r]}},{key:"moveTo",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0;return this.setPosition(r,i,a),this}},{key:"move",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:0,a=arguments.length>2&&arguments[2]!==void 0?arguments[2]:0;return this.setPosition(r,i,a),this}},{key:"setZIndex",value:function(r){return this.style.zIndex=r,this}}])}(S8);or.PARSED_STYLE_LIST=new Set(["class","className","clipPath","cursor","display","draggable","droppable","fill","fillOpacity","fillRule","filter","increasedLineWidthForHitTesting","lineCap","lineDash","lineDashOffset","lineJoin","lineWidth","miterLimit","hitArea","offsetDistance","offsetPath","offsetX","offsetY","opacity","pointerEvents","shadowColor","shadowType","shadowBlur","shadowOffsetX","shadowOffsetY","stroke","strokeOpacity","strokeWidth","strokeLinecap","strokeLineJoin","strokeDasharray","strokeDashoffset","transform","transformOrigin","textTransform","visibility","zIndex"]);var tc=function(t){function e(){var n=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return(0,xt.Z)(this,e),(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.CIRCLE},n)])}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(or);tc.PARSED_STYLE_LIST=new Set([].concat((0,ln.Z)(or.PARSED_STYLE_LIST),["cx","cy","cz","r","isBillboard","isSizeAttenuation"]));var k8=["style"],mp=function(t){function e(){var n,r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},i=r.style,a=(0,jo.Z)(r,k8);return(0,xt.Z)(this,e),n=(0,De.Z)(this,e,[(0,Ee.Z)({style:i},a)]),n.isCustomElement=!0,n}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(or);mp.PARSED_STYLE_LIST=new Set(["class","className","clipPath","cursor","draggable","droppable","opacity","pointerEvents","transform","transformOrigin","zIndex","visibility"]);var Oy=function(t){function e(){var n=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return(0,xt.Z)(this,e),(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.ELLIPSE},n)])}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(or);Oy.PARSED_STYLE_LIST=new Set([].concat((0,ln.Z)(or.PARSED_STYLE_LIST),["cx","cy","cz","rx","ry","isBillboard","isSizeAttenuation"]));var A8=function(t){function e(){return(0,xt.Z)(this,e),(0,De.Z)(this,e,[{type:dt.FRAGMENT}])}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(or);A8.PARSED_STYLE_LIST=new Set(["class","className"]);var ui=function(t){function e(){var n=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return(0,xt.Z)(this,e),(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.GROUP},n)])}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(or);ui.PARSED_STYLE_LIST=new Set(["class","className","clipPath","cursor","draggable","droppable","opacity","pointerEvents","transform","transformOrigin","zIndex","visibility"]);var T8=["style"],bp=function(t){function e(){var n,r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},i=r.style,a=(0,jo.Z)(r,T8);return(0,xt.Z)(this,e),n=(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.HTML,style:i},a)]),n.cullable.enable=!1,n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"getDomElement",value:function(){return this.parsedStyle.$el}},{key:"getClientRects",value:function(){return[this.getBoundingClientRect()]}},{key:"getLocalBounds",value:function(){if(this.parentNode){var r=$i(Wn(),this.parentNode.getWorldTransform()),i=this.getBounds();if(!xr.isEmpty(i)){var a=new xr;return a.setFromTransformedAABB(i,r),a}}return this.getBounds()}}])}(or);bp.PARSED_STYLE_LIST=new Set([].concat((0,ln.Z)(or.PARSED_STYLE_LIST),["x","y","$el","innerHTML","width","height"]));var Sy=function(t){function e(){var n=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return(0,xt.Z)(this,e),(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.IMAGE},n)])}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(or);Sy.PARSED_STYLE_LIST=new Set([].concat((0,ln.Z)(or.PARSED_STYLE_LIST),["x","y","z","src","width","height","isBillboard","billboardRotation","isSizeAttenuation","keepAspectRatio"]));var P8=["style"],su=function(t){function e(){var n,r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},i=r.style,a=(0,jo.Z)(r,P8);(0,xt.Z)(this,e),n=(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.LINE,style:(0,Ee.Z)({x1:0,y1:0,x2:0,y2:0,z1:0,z2:0},i)},a)]),n.markerStartAngle=0,n.markerEndAngle=0;var o=n.parsedStyle,s=o.markerStart,c=o.markerEnd;return s&&xn(s)&&(n.markerStartAngle=s.getLocalEulerAngles(),n.appendChild(s)),c&&xn(c)&&(n.markerEndAngle=c.getLocalEulerAngles(),n.appendChild(c)),n.transformMarker(!0),n.transformMarker(!1),n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"attributeChangedCallback",value:function(r,i,a,o,s){r==="x1"||r==="y1"||r==="x2"||r==="y2"||r==="markerStartOffset"||r==="markerEndOffset"?(this.transformMarker(!0),this.transformMarker(!1)):r==="markerStart"?(o&&xn(o)&&(this.markerStartAngle=0,o.remove()),s&&xn(s)&&(this.markerStartAngle=s.getLocalEulerAngles(),this.appendChild(s),this.transformMarker(!0))):r==="markerEnd"&&(o&&xn(o)&&(this.markerEndAngle=0,o.remove()),s&&xn(s)&&(this.markerEndAngle=s.getLocalEulerAngles(),this.appendChild(s),this.transformMarker(!1)))}},{key:"transformMarker",value:function(r){var i=this.parsedStyle,a=i.markerStart,o=i.markerEnd,s=i.markerStartOffset,c=i.markerEndOffset,l=i.x1,u=i.x2,f=i.y1,d=i.y2,h=r?a:o;if(!(!h||!xn(h))){var v=0,g,y,b,x,_,w;r?(b=l,x=f,g=u-l,y=d-f,_=s||0,w=this.markerStartAngle):(b=u,x=d,g=l-u,y=f-d,_=c||0,w=this.markerEndAngle),v=Math.atan2(y,g),h.setLocalEulerAngles(v*180/Math.PI+w),h.setLocalPosition(b+Math.cos(v)*_,x+Math.sin(v)*_)}}},{key:"getPoint",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,a=this.parsedStyle,o=a.x1,s=a.y1,c=a.x2,l=a.y2,u=Oa(o,s,c,l,r),f=u.x,d=u.y,h=er(me(),sn(f,d,0),i?this.getWorldTransform():this.getLocalTransform());return new ii(h[0],h[1])}},{key:"getPointAtLength",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;return this.getPoint(r/this.getTotalLength(),i)}},{key:"getTotalLength",value:function(){var r=this.parsedStyle,i=r.x1,a=r.y1,o=r.x2,s=r.y2;return Wl(i,a,o,s)}}])}(or);su.PARSED_STYLE_LIST=new Set([].concat((0,ln.Z)(or.PARSED_STYLE_LIST),["x1","y1","x2","y2","z1","z2","isBillboard","isSizeAttenuation","markerStart","markerEnd","markerStartOffset","markerEndOffset"]));var C8=["style"],Qi=function(t){function e(){var n,r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},i=r.style,a=(0,jo.Z)(r,C8);(0,xt.Z)(this,e),n=(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.PATH,style:i,initialParsedStyle:{miterLimit:4,d:(0,Ee.Z)({},Af)}},a)]),n.markerStartAngle=0,n.markerEndAngle=0,n.markerMidList=[];var o=n.parsedStyle,s=o.markerStart,c=o.markerEnd,l=o.markerMid;return s&&xn(s)&&(n.markerStartAngle=s.getLocalEulerAngles(),n.appendChild(s)),l&&xn(l)&&n.placeMarkerMid(l),c&&xn(c)&&(n.markerEndAngle=c.getLocalEulerAngles(),n.appendChild(c)),n.transformMarker(!0),n.transformMarker(!1),n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"attributeChangedCallback",value:function(r,i,a,o,s){r==="d"?(this.transformMarker(!0),this.transformMarker(!1),this.placeMarkerMid(this.parsedStyle.markerMid)):r==="markerStartOffset"||r==="markerEndOffset"?(this.transformMarker(!0),this.transformMarker(!1)):r==="markerStart"?(o&&xn(o)&&(this.markerStartAngle=0,o.remove()),s&&xn(s)&&(this.markerStartAngle=s.getLocalEulerAngles(),this.appendChild(s),this.transformMarker(!0))):r==="markerEnd"?(o&&xn(o)&&(this.markerEndAngle=0,o.remove()),s&&xn(s)&&(this.markerEndAngle=s.getLocalEulerAngles(),this.appendChild(s),this.transformMarker(!1))):r==="markerMid"&&this.placeMarkerMid(s)}},{key:"transformMarker",value:function(r){var i=this.parsedStyle,a=i.markerStart,o=i.markerEnd,s=i.markerStartOffset,c=i.markerEndOffset,l=r?a:o;if(!(!l||!xn(l))){var u=0,f,d,h,v,g,y;if(r){var b=this.getStartTangent(),x=(0,Te.Z)(b,2),_=x[0],w=x[1];h=w[0],v=w[1],f=_[0]-w[0],d=_[1]-w[1],g=s||0,y=this.markerStartAngle}else{var O=this.getEndTangent(),E=(0,Te.Z)(O,2),M=E[0],k=E[1];h=k[0],v=k[1],f=M[0]-k[0],d=M[1]-k[1],g=c||0,y=this.markerEndAngle}u=Math.atan2(d,f),l.setLocalEulerAngles(u*180/Math.PI+y),l.setLocalPosition(h+Math.cos(u)*g,v+Math.sin(u)*g)}}},{key:"placeMarkerMid",value:function(r){var i=this.parsedStyle.d.segments;if(this.markerMidList.forEach(function(u){u.remove()}),r&&xn(r))for(var a=1;a<i.length-1;a++){var o=(0,Te.Z)(i[a].currentPoint,2),s=o[0],c=o[1],l=a===1?r:r.cloneNode(!0);this.markerMidList.push(l),this.appendChild(l),l.setLocalPosition(s,c)}}},{key:"getTotalLength",value:function(){return Wa(this)}},{key:"getPointAtLength",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,a=this.parsedStyle.d.absolutePath,o=Jv(a,r),s=o.x,c=o.y,l=er(me(),sn(s,c,0),i?this.getWorldTransform():this.getLocalTransform());return new ii(l[0],l[1])}},{key:"getPoint",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;return this.getPointAtLength(r*Wa(this),i)}},{key:"getStartTangent",value:function(){var r=this.parsedStyle.d.segments,i=[];if(r.length>1){var a=r[0].currentPoint,o=r[1].currentPoint,s=r[1].startTangent;i=[],s?(i.push([a[0]-s[0],a[1]-s[1]]),i.push([a[0],a[1]])):(i.push([o[0],o[1]]),i.push([a[0],a[1]]))}return i}},{key:"getEndTangent",value:function(){var r=this.parsedStyle.d.segments,i=r.length,a=[];if(i>1){var o=r[i-2].currentPoint,s=r[i-1].currentPoint,c=r[i-1].endTangent;a=[],c?(a.push([s[0]-c[0],s[1]-c[1]]),a.push([s[0],s[1]])):(a.push([o[0],o[1]]),a.push([s[0],s[1]]))}return a}}])}(or);Qi.PARSED_STYLE_LIST=new Set([].concat((0,ln.Z)(or.PARSED_STYLE_LIST),["d","markerStart","markerMid","markerEnd","markerStartOffset","markerEndOffset","isBillboard","isSizeAttenuation"]));var L8=["style"],cu=function(t){function e(){var n,r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},i=r.style,a=(0,jo.Z)(r,L8);(0,xt.Z)(this,e),n=(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.POLYGON,style:i,initialParsedStyle:{points:{points:[],totalLength:0,segments:[]},miterLimit:4,isClosed:!0}},a)]),n.markerStartAngle=0,n.markerEndAngle=0,n.markerMidList=[];var o=n.parsedStyle,s=o.markerStart,c=o.markerEnd,l=o.markerMid;return s&&xn(s)&&(n.markerStartAngle=s.getLocalEulerAngles(),n.appendChild(s)),l&&xn(l)&&n.placeMarkerMid(l),c&&xn(c)&&(n.markerEndAngle=c.getLocalEulerAngles(),n.appendChild(c)),n.transformMarker(!0),n.transformMarker(!1),n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"attributeChangedCallback",value:function(r,i,a,o,s){r==="points"?(this.transformMarker(!0),this.transformMarker(!1),this.placeMarkerMid(this.parsedStyle.markerMid)):r==="markerStartOffset"||r==="markerEndOffset"?(this.transformMarker(!0),this.transformMarker(!1)):r==="markerStart"?(o&&xn(o)&&(this.markerStartAngle=0,o.remove()),s&&xn(s)&&(this.markerStartAngle=s.getLocalEulerAngles(),this.appendChild(s),this.transformMarker(!0))):r==="markerEnd"?(o&&xn(o)&&(this.markerEndAngle=0,o.remove()),s&&xn(s)&&(this.markerEndAngle=s.getLocalEulerAngles(),this.appendChild(s),this.transformMarker(!1))):r==="markerMid"&&this.placeMarkerMid(s)}},{key:"transformMarker",value:function(r){var i=this.parsedStyle,a=i.markerStart,o=i.markerEnd,s=i.markerStartOffset,c=i.markerEndOffset,l=i.points,u=l||{},f=u.points,d=r?a:o;if(!(!d||!xn(d)||!f)){var h=0,v,g,y,b,x,_;if(y=f[0][0],b=f[0][1],r)v=f[1][0]-f[0][0],g=f[1][1]-f[0][1],x=s||0,_=this.markerStartAngle;else{var w=f.length;this.parsedStyle.isClosed?(v=f[w-1][0]-f[0][0],g=f[w-1][1]-f[0][1]):(y=f[w-1][0],b=f[w-1][1],v=f[w-2][0]-f[w-1][0],g=f[w-2][1]-f[w-1][1]),x=c||0,_=this.markerEndAngle}h=Math.atan2(g,v),d.setLocalEulerAngles(h*180/Math.PI+_),d.setLocalPosition(y+Math.cos(h)*x,b+Math.sin(h)*x)}}},{key:"placeMarkerMid",value:function(r){var i=this.parsedStyle.points,a=i||{},o=a.points;if(this.markerMidList.forEach(function(f){f.remove()}),this.markerMidList=[],r&&xn(r)&&o)for(var s=1;s<(this.parsedStyle.isClosed?o.length:o.length-1);s++){var c=o[s][0],l=o[s][1],u=s===1?r:r.cloneNode(!0);this.markerMidList.push(u),this.appendChild(u),u.setLocalPosition(c,l)}}}])}(or);cu.PARSED_STYLE_LIST=new Set([].concat((0,ln.Z)(or.PARSED_STYLE_LIST),["points","markerStart","markerMid","markerEnd","markerStartOffset","markerEndOffset","isClosed","isBillboard","isSizeAttenuation"]));var R8=["style"],Ey=function(t){function e(){var n=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},r=n.style,i=(0,jo.Z)(n,R8);return(0,xt.Z)(this,e),(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.POLYLINE,style:r,initialParsedStyle:{points:{points:[],totalLength:0,segments:[]},miterLimit:4,isClosed:!1}},i)])}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"getTotalLength",value:function(){return Zg(this)}},{key:"getPointAtLength",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;return this.getPoint(r/this.getTotalLength(),i)}},{key:"getPoint",value:function(r){var i=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,a=this.parsedStyle.points.points;if(this.parsedStyle.points.segments.length===0){var o=[],s=0,c,l,u=this.getTotalLength();a.forEach(function(b,x){a[x+1]&&(c=[0,0],c[0]=s/u,l=Wl(b[0],b[1],a[x+1][0],a[x+1][1]),s+=l,c[1]=s/u,o.push(c))}),this.parsedStyle.points.segments=o}var f=0,d=0;this.parsedStyle.points.segments.forEach(function(b,x){r>=b[0]&&r<=b[1]&&(f=(r-b[0])/(b[1]-b[0]),d=x)});var h=Oa(a[d][0],a[d][1],a[d+1][0],a[d+1][1],f),v=h.x,g=h.y,y=er(me(),sn(v,g,0),i?this.getWorldTransform():this.getLocalTransform());return new ii(y[0],y[1])}},{key:"getStartTangent",value:function(){var r=this.parsedStyle.points.points,i=[];return i.push([r[1][0],r[1][1]]),i.push([r[0][0],r[0][1]]),i}},{key:"getEndTangent",value:function(){var r=this.parsedStyle.points.points,i=r.length-1,a=[];return a.push([r[i-1][0],r[i-1][1]]),a.push([r[i][0],r[i][1]]),a}}])}(cu);Ey.PARSED_STYLE_LIST=new Set([].concat((0,ln.Z)(cu.PARSED_STYLE_LIST),["points","markerStart","markerMid","markerEnd","markerStartOffset","markerEndOffset","isBillboard"]));var Qc=function(t){function e(){var n=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return(0,xt.Z)(this,e),(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.RECT},n)])}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(or);Qc.PARSED_STYLE_LIST=new Set([].concat((0,ln.Z)(or.PARSED_STYLE_LIST),["x","y","z","width","height","isBillboard","isSizeAttenuation","radius"]));var N8=["style"],po=function(t){function e(){var n=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},r=n.style,i=(0,jo.Z)(n,N8);return(0,xt.Z)(this,e),(0,De.Z)(this,e,[(0,Ee.Z)({type:dt.TEXT,style:(0,Ee.Z)({fill:"black"},r)},i)])}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"getComputedTextLength",value:function(){var r;return this.getGeometryBounds(),((r=this.parsedStyle.metrics)===null||r===void 0?void 0:r.maxLineWidth)||0}},{key:"getLineBoundingRects",value:function(){var r;return this.getGeometryBounds(),((r=this.parsedStyle.metrics)===null||r===void 0?void 0:r.lineMetrics)||[]}},{key:"isOverflowing",value:function(){return this.getGeometryBounds(),!!this.parsedStyle.isOverflowing}}])}(or);po.PARSED_STYLE_LIST=new Set([].concat((0,ln.Z)(or.PARSED_STYLE_LIST),["x","y","z","isBillboard","billboardRotation","isSizeAttenuation","text","textAlign","textBaseline","fontStyle","fontSize","fontFamily","fontWeight","fontVariant","lineHeight","letterSpacing","leading","wordWrap","wordWrapWidth","maxLines","textOverflow","isOverflowing","textPath","textDecorationLine","textDecorationColor","textDecorationStyle","textPathSide","textPathStartOffset","metrics","dx","dy"]));var I8=function(){function t(){(0,xt.Z)(this,t),this.registry={},this.define(dt.CIRCLE,tc),this.define(dt.ELLIPSE,Oy),this.define(dt.RECT,Qc),this.define(dt.IMAGE,Sy),this.define(dt.LINE,su),this.define(dt.GROUP,ui),this.define(dt.PATH,Qi),this.define(dt.POLYGON,cu),this.define(dt.POLYLINE,Ey),this.define(dt.TEXT,po),this.define(dt.HTML,bp)}return(0,Ot.Z)(t,[{key:"define",value:function(n,r){this.registry[n]=r}},{key:"get",value:function(n){return this.registry[n]}}])}(),gk={number:function(e){return new Rn(e)},percent:function(e){return new Rn(e,"%")},px:function(e){return new Rn(e,"px")},em:function(e){return new Rn(e,"em")},rem:function(e){return new Rn(e,"rem")},deg:function(e){return new Rn(e,"deg")},grad:function(e){return new Rn(e,"grad")},rad:function(e){return new Rn(e,"rad")},turn:function(e){return new Rn(e,"turn")},s:function(e){return new Rn(e,"s")},ms:function(e){return new Rn(e,"ms")},registerProperty:function(e){var n=e.name,r=e.inherits,i=e.interpolable,a=e.initialValue,o=e.syntax;Ct.styleValueRegistry.registerMetadata({n,inh:r,int:i,d:a,syntax:o})},registerLayout:function(e,n){Ct.layoutRegistry.registerLayout(e,n)}},D8=function(t){function e(){var n;(0,xt.Z)(this,e),n=(0,De.Z)(this,e),n.defaultView=null,n.ownerDocument=null,n.nodeName="document";try{n.timeline=new Ct.AnimationTimeline(n)}catch(i){}var r={};return op.forEach(function(i){var a=i.n,o=i.inh,s=i.d;o&&s&&(r[a]=Xn(s)?s(dt.GROUP):s)}),n.documentElement=new ui({id:"g-root",style:r}),n.documentElement.ownerDocument=n,n.documentElement.parentNode=n,n.childNodes=[n.documentElement],n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"children",get:function(){return this.childNodes}},{key:"childElementCount",get:function(){return this.childNodes.length}},{key:"firstElementChild",get:function(){return this.firstChild}},{key:"lastElementChild",get:function(){return this.lastChild}},{key:"createElement",value:function(r,i){if(r==="svg")return this.documentElement;var a=this.defaultView.customElements.get(r);a||(console.warn("Unsupported tagName: ",r),a=r==="tspan"?po:ui);var o=new a(i);return o.ownerDocument=this,o}},{key:"createElementNS",value:function(r,i,a){return this.createElement(i,a)}},{key:"cloneNode",value:function(r){throw new Error(kn)}},{key:"destroy",value:function(){try{this.documentElement.destroyChildren(),this.timeline.destroy()}catch(r){}}},{key:"elementsFromBBox",value:function(r,i,a,o){var s=this.defaultView.context.rBushRoot,c=s.search({minX:r,minY:i,maxX:a,maxY:o}),l=[];return c.forEach(function(u){var f=u.displayObject,d=f.parsedStyle.pointerEvents,h=d===void 0?"auto":d,v=["auto","visiblepainted","visiblefill","visiblestroke","visible"].includes(h);(!v||v&&f.isVisible())&&!f.isCulled()&&f.isInteractive()&&l.push(f)}),l.sort(function(u,f){return f.sortable.renderOrder-u.sortable.renderOrder}),l}},{key:"elementFromPointSync",value:function(r,i){var a=this.defaultView.canvas2Viewport({x:r,y:i}),o=a.x,s=a.y,c=this.defaultView.getConfig(),l=c.width,u=c.height;if(o<0||s<0||o>l||s>u)return null;var f=this.defaultView.viewport2Client({x:o,y:s}),d=f.x,h=f.y,v=this.defaultView.getRenderingService().hooks.pickSync.call({topmost:!0,position:{x:r,y:i,viewportX:o,viewportY:s,clientX:d,clientY:h},picked:[]}),g=v.picked;return g&&g[0]||this.documentElement}},{key:"elementFromPoint",value:function(){var n=(0,oo.Z)((0,Mn.Z)().mark(function i(a,o){var s,c,l,u,f,d,h,v,g,y,b;return(0,Mn.Z)().wrap(function(_){for(;;)switch(_.prev=_.next){case 0:if(s=this.defaultView.canvas2Viewport({x:a,y:o}),c=s.x,l=s.y,u=this.defaultView.getConfig(),f=u.width,d=u.height,!(c<0||l<0||c>f||l>d)){_.next=4;break}return _.abrupt("return",null);case 4:return h=this.defaultView.viewport2Client({x:c,y:l}),v=h.x,g=h.y,_.next=7,this.defaultView.getRenderingService().hooks.pick.promise({topmost:!0,position:{x:a,y:o,viewportX:c,viewportY:l,clientX:v,clientY:g},picked:[]});case 7:return y=_.sent,b=y.picked,_.abrupt("return",b&&b[0]||this.documentElement);case 10:case"end":return _.stop()}},i,this)}));function r(i,a){return n.apply(this,arguments)}return r}()},{key:"elementsFromPointSync",value:function(r,i){var a=this.defaultView.canvas2Viewport({x:r,y:i}),o=a.x,s=a.y,c=this.defaultView.getConfig(),l=c.width,u=c.height;if(o<0||s<0||o>l||s>u)return[];var f=this.defaultView.viewport2Client({x:o,y:s}),d=f.x,h=f.y,v=this.defaultView.getRenderingService().hooks.pickSync.call({topmost:!1,position:{x:r,y:i,viewportX:o,viewportY:s,clientX:d,clientY:h},picked:[]}),g=v.picked;return g[g.length-1]!==this.documentElement&&g.push(this.documentElement),g}},{key:"elementsFromPoint",value:function(){var n=(0,oo.Z)((0,Mn.Z)().mark(function i(a,o){var s,c,l,u,f,d,h,v,g,y,b;return(0,Mn.Z)().wrap(function(_){for(;;)switch(_.prev=_.next){case 0:if(s=this.defaultView.canvas2Viewport({x:a,y:o}),c=s.x,l=s.y,u=this.defaultView.getConfig(),f=u.width,d=u.height,!(c<0||l<0||c>f||l>d)){_.next=4;break}return _.abrupt("return",[]);case 4:return h=this.defaultView.viewport2Client({x:c,y:l}),v=h.x,g=h.y,_.next=7,this.defaultView.getRenderingService().hooks.pick.promise({topmost:!1,position:{x:a,y:o,viewportX:c,viewportY:l,clientX:v,clientY:g},picked:[]});case 7:return y=_.sent,b=y.picked,b[b.length-1]!==this.documentElement&&b.push(this.documentElement),_.abrupt("return",b);case 11:case"end":return _.stop()}},i,this)}));function r(i,a){return n.apply(this,arguments)}return r}()},{key:"appendChild",value:function(r,i){throw new Error(Ti)}},{key:"insertBefore",value:function(r,i){throw new Error(Ti)}},{key:"removeChild",value:function(r,i){throw new Error(Ti)}},{key:"replaceChild",value:function(r,i,a){throw new Error(Ti)}},{key:"append",value:function(){throw new Error(Ti)}},{key:"prepend",value:function(){throw new Error(Ti)}},{key:"getElementById",value:function(r){return this.documentElement.getElementById(r)}},{key:"getElementsByName",value:function(r){return this.documentElement.getElementsByName(r)}},{key:"getElementsByTagName",value:function(r){return this.documentElement.getElementsByTagName(r)}},{key:"getElementsByClassName",value:function(r){return this.documentElement.getElementsByClassName(r)}},{key:"querySelector",value:function(r){return this.documentElement.querySelector(r)}},{key:"querySelectorAll",value:function(r){return this.documentElement.querySelectorAll(r)}},{key:"find",value:function(r){return this.documentElement.find(r)}},{key:"findAll",value:function(r){return this.documentElement.findAll(r)}}])}(fr),yk=function(){function t(e){(0,xt.Z)(this,t),this.strategies=e}return(0,Ot.Z)(t,[{key:"apply",value:function(n){var r=n.camera,i=n.renderingService,a=n.renderingContext,o=this.strategies;i.hooks.cull.tap(t.tag,function(s){if(s){var c=s.cullable;return o.length===0?c.visible=a.unculledEntities.indexOf(s.entity)>-1:c.visible=o.every(function(l){return l.isVisible(r,s)}),!s.isCulled()&&s.isVisible()?s:(s.dispatchEvent(new Nn($e.CULLED)),null)}return s}),i.hooks.afterRender.tap(t.tag,function(s){s.cullable.visibilityPlaneMask=-1})}}])}();yk.tag="Culling";var mk=function(){function t(){var e=this;(0,xt.Z)(this,t),this.autoPreventDefault=!1,this.rootPointerEvent=new pp(null),this.rootWheelEvent=new vp(null),this.onPointerMove=function(n){var r,i=(r=e.context.renderingContext.root)===null||r===void 0||(r=r.ownerDocument)===null||r===void 0?void 0:r.defaultView;if(!(i.supportsTouchEvents&&n.pointerType==="touch")){var a=e.normalizeToPointerEvent(n,i),o=(0,Ys.Z)(a),s;try{for(o.s();!(s=o.n()).done;){var c=s.value,l=e.bootstrapEvent(e.rootPointerEvent,c,i,n);e.context.eventService.mapEvent(l)}}catch(u){o.e(u)}finally{o.f()}e.setCursor(e.context.eventService.cursor)}},this.onClick=function(n){var r,i=(r=e.context.renderingContext.root)===null||r===void 0||(r=r.ownerDocument)===null||r===void 0?void 0:r.defaultView,a=e.normalizeToPointerEvent(n,i),o=(0,Ys.Z)(a),s;try{for(o.s();!(s=o.n()).done;){var c=s.value,l=e.bootstrapEvent(e.rootPointerEvent,c,i,n);e.context.eventService.mapEvent(l)}}catch(u){o.e(u)}finally{o.f()}e.setCursor(e.context.eventService.cursor)}}return(0,Ot.Z)(t,[{key:"apply",value:function(n){var r=this;this.context=n;var i=n.renderingService,a=this.context.renderingContext.root.ownerDocument.defaultView;this.context.eventService.setPickHandler(function(o){var s=r.context.renderingService.hooks.pickSync.call({position:o,picked:[],topmost:!0}),c=s.picked;return c[0]||null}),i.hooks.pointerWheel.tap(t.tag,function(o){var s=r.normalizeWheelEvent(o);r.context.eventService.mapEvent(s)}),i.hooks.pointerDown.tap(t.tag,function(o){if(!(a.supportsTouchEvents&&o.pointerType==="touch")){var s=r.normalizeToPointerEvent(o,a);if(r.autoPreventDefault&&s[0].isNormalized){var c=o.cancelable||!("cancelable"in o);c&&o.preventDefault()}var l=(0,Ys.Z)(s),u;try{for(l.s();!(u=l.n()).done;){var f=u.value,d=r.bootstrapEvent(r.rootPointerEvent,f,a,o);r.context.eventService.mapEvent(d)}}catch(h){l.e(h)}finally{l.f()}r.setCursor(r.context.eventService.cursor)}}),i.hooks.pointerUp.tap(t.tag,function(o){if(!(a.supportsTouchEvents&&o.pointerType==="touch")){var s=r.context.contextService.getDomElement(),c=r.context.eventService.isNativeEventFromCanvas(s,o),l=c?"":"outside",u=r.normalizeToPointerEvent(o,a),f=(0,Ys.Z)(u),d;try{for(f.s();!(d=f.n()).done;){var h=d.value,v=r.bootstrapEvent(r.rootPointerEvent,h,a,o);v.type+=l,r.context.eventService.mapEvent(v)}}catch(g){f.e(g)}finally{f.f()}r.setCursor(r.context.eventService.cursor)}}),i.hooks.pointerMove.tap(t.tag,this.onPointerMove),i.hooks.pointerOver.tap(t.tag,this.onPointerMove),i.hooks.pointerOut.tap(t.tag,this.onPointerMove),i.hooks.click.tap(t.tag,this.onClick),i.hooks.pointerCancel.tap(t.tag,function(o){var s=r.normalizeToPointerEvent(o,a),c=(0,Ys.Z)(s),l;try{for(c.s();!(l=c.n()).done;){var u=l.value,f=r.bootstrapEvent(r.rootPointerEvent,u,a,o);r.context.eventService.mapEvent(f)}}catch(d){c.e(d)}finally{c.f()}r.setCursor(r.context.eventService.cursor)})}},{key:"bootstrapEvent",value:function(n,r,i,a){n.view=i,n.originalEvent=null,n.nativeEvent=a,n.pointerId=r.pointerId,n.width=r.width,n.height=r.height,n.isPrimary=r.isPrimary,n.pointerType=r.pointerType,n.pressure=r.pressure,n.tangentialPressure=r.tangentialPressure,n.tiltX=r.tiltX,n.tiltY=r.tiltY,n.twist=r.twist,this.transferMouseData(n,r);var o=this.context.eventService.client2Viewport({x:r.clientX,y:r.clientY}),s=o.x,c=o.y;n.viewport.x=s,n.viewport.y=c;var l=this.context.eventService.viewport2Canvas(n.viewport),u=l.x,f=l.y;return n.canvas.x=u,n.canvas.y=f,n.global.copyFrom(n.canvas),n.offset.copyFrom(n.canvas),n.isTrusted=a.isTrusted,n.type==="pointerleave"&&(n.type="pointerout"),n.type.startsWith("mouse")&&(n.type=n.type.replace("mouse","pointer")),n.type.startsWith("touch")&&(n.type=G2[n.type]||n.type),n}},{key:"normalizeWheelEvent",value:function(n){var r=this.rootWheelEvent;this.transferMouseData(r,n),r.deltaMode=n.deltaMode,r.deltaX=n.deltaX,r.deltaY=n.deltaY,r.deltaZ=n.deltaZ;var i=this.context.eventService.client2Viewport({x:n.clientX,y:n.clientY}),a=i.x,o=i.y;r.viewport.x=a,r.viewport.y=o;var s=this.context.eventService.viewport2Canvas(r.viewport),c=s.x,l=s.y;return r.canvas.x=c,r.canvas.y=l,r.global.copyFrom(r.canvas),r.offset.copyFrom(r.canvas),r.nativeEvent=n,r.type=n.type,r}},{key:"transferMouseData",value:function(n,r){n.isTrusted=r.isTrusted,n.srcElement=r.srcElement,n.timeStamp=lp.now(),n.type=r.type,n.altKey=r.altKey,n.metaKey=r.metaKey,n.shiftKey=r.shiftKey,n.ctrlKey=r.ctrlKey,n.button=r.button,n.buttons=r.buttons,n.client.x=r.clientX,n.client.y=r.clientY,n.movement.x=r.movementX,n.movement.y=r.movementY,n.page.x=r.pageX,n.page.y=r.pageY,n.screen.x=r.screenX,n.screen.y=r.screenY,n.relatedTarget=null}},{key:"setCursor",value:function(n){this.context.contextService.applyCursorStyle(n||this.context.config.cursor||"default")}},{key:"normalizeToPointerEvent",value:function(n,r){var i=[];if(r.isTouchEvent(n))for(var a=0;a<n.changedTouches.length;a++){var o=n.changedTouches[a];En(o.button)&&(o.button=0),En(o.buttons)&&(o.buttons=1),En(o.isPrimary)&&(o.isPrimary=n.touches.length===1&&n.type==="touchstart"),En(o.width)&&(o.width=o.radiusX||1),En(o.height)&&(o.height=o.radiusY||1),En(o.tiltX)&&(o.tiltX=0),En(o.tiltY)&&(o.tiltY=0),En(o.pointerType)&&(o.pointerType="touch"),En(o.pointerId)&&(o.pointerId=o.identifier||0),En(o.pressure)&&(o.pressure=o.force||.5),En(o.twist)&&(o.twist=0),En(o.tangentialPressure)&&(o.tangentialPressure=0),o.isNormalized=!0,o.type=n.type,i.push(o)}else if(r.isMouseEvent(n)){var s=n;En(s.isPrimary)&&(s.isPrimary=!0),En(s.width)&&(s.width=1),En(s.height)&&(s.height=1),En(s.tiltX)&&(s.tiltX=0),En(s.tiltY)&&(s.tiltY=0),En(s.pointerType)&&(s.pointerType="mouse"),En(s.pointerId)&&(s.pointerId=W2),En(s.pressure)&&(s.pressure=.5),En(s.twist)&&(s.twist=0),En(s.tangentialPressure)&&(s.tangentialPressure=0),s.isNormalized=!0,i.push(s)}else i.push(n);return i}}])}();mk.tag="Event";var j8=[dt.CIRCLE,dt.ELLIPSE,dt.IMAGE,dt.RECT,dt.LINE,dt.POLYLINE,dt.POLYGON,dt.TEXT,dt.PATH,dt.HTML],F8=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"isVisible",value:function(n,r){var i,a=r.cullable;if(!a.enable)return!0;var o=r.getRenderBounds();if(xr.isEmpty(o))return!1;var s=n.getFrustum(),c=(i=r.parentNode)===null||i===void 0||(i=i.cullable)===null||i===void 0?void 0:i.visibilityPlaneMask;return a.visibilityPlaneMask=this.computeVisibilityWithPlaneMask(r,o,c||as.INDETERMINATE,s.planes),a.visible=a.visibilityPlaneMask!==as.OUTSIDE,a.visible}},{key:"computeVisibilityWithPlaneMask",value:function(n,r,i,a){if(i===as.OUTSIDE||i===as.INSIDE)return i;for(var o=as.INSIDE,s=j8.indexOf(n.nodeName)>-1,c=0,l=a.length;c<l;++c){var u=1<<c;if(i&u&&!(s&&(c===4||c===5))){var f=a[c],d=f.normal,h=f.distance;if(la(d,r.getPositiveFarPoint(a[c]))+h<0)return as.OUTSIDE;la(d,r.getNegativeFarPoint(a[c]))+h<0&&(o|=u)}}return o}}])}(),bk=function(){function t(){(0,xt.Z)(this,t),this.syncTasks=new Map,this.isFirstTimeRendering=!0,this.syncing=!1,this.isFirstTimeRenderingFinished=!1}return(0,Ot.Z)(t,[{key:"apply",value:function(n){var r=this,i,a=n.renderingService,o=n.renderingContext,s=n.rBushRoot,c=o.root.ownerDocument.defaultView;this.rBush=s;var l=function(g){var y=g.target;y.renderable.dirty=!0,a.dirtify()},u=function(g){r.syncTasks.set(g.target,g.detail.affectChildren),a.dirtify()},f=function(g){var y=g.target;Ct.enableSizeAttenuation&&Ct.styleValueRegistry.updateSizeAttenuation(y,c.getCamera().getZoom())},d=function(g){var y=g.target,b=y.rBushNode;b.aabb&&r.rBush.remove(b.aabb),r.syncTasks.delete(y),Ct.sceneGraphService.dirtifyToRoot(y),a.dirtify()};a.hooks.init.tap(t.tag,function(){c.addEventListener($e.MOUNTED,f),c.addEventListener($e.UNMOUNTED,d),c.addEventListener($e.ATTR_MODIFIED,l),c.addEventListener($e.BOUNDS_CHANGED,u)}),a.hooks.destroy.tap(t.tag,function(){c.removeEventListener($e.MOUNTED,f),c.removeEventListener($e.UNMOUNTED,d),c.removeEventListener($e.ATTR_MODIFIED,l),c.removeEventListener($e.BOUNDS_CHANGED,u),r.syncTasks.clear()});var h=(i=Ct.globalThis.requestIdleCallback)!==null&&i!==void 0?i:$f.bind(Ct.globalThis);a.hooks.endFrame.tap(t.tag,function(){r.isFirstTimeRendering?(r.isFirstTimeRendering=!1,r.syncing=!0,h(function(){r.syncRTree(!0),r.isFirstTimeRenderingFinished=!0})):r.syncRTree()})}},{key:"syncNode",value:function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;if(n.isConnected){var i=n.rBushNode;i.aabb&&this.rBush.remove(i.aabb);var a=n.getRenderBounds();if(a){var o=n.renderable;r&&(o.dirtyRenderBounds||(o.dirtyRenderBounds=new xr),o.dirtyRenderBounds.update(a.center,a.halfExtents));var s=a.getMin(),c=(0,Te.Z)(s,2),l=c[0],u=c[1],f=a.getMax(),d=(0,Te.Z)(f,2),h=d[0],v=d[1];i.aabb||(i.aabb={}),i.aabb.displayObject=n,i.aabb.minX=l,i.aabb.minY=u,i.aabb.maxX=h,i.aabb.maxY=v}if(i.aabb&&!isNaN(i.aabb.maxX)&&!isNaN(i.aabb.maxX)&&!isNaN(i.aabb.minX)&&!isNaN(i.aabb.minY))return i.aabb}}},{key:"syncRTree",value:function(){var n=this,r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!1;if(!(!r&&(this.syncing||this.syncTasks.size===0))){this.syncing=!0;var i=[],a=new Set,o=function(c){if(!a.has(c)&&c.renderable){var l=n.syncNode(c,r);l&&(i.push(l),a.add(c))}};this.syncTasks.forEach(function(s,c){s&&c.forEach(o);for(var l=c;l;)o(l),l=l.parentElement}),this.rBush.load(i),i.length=0,this.syncing=!1}}}])}();bk.tag="Prepare";function kat(t){return!!t.document}var vo=function(t){return t.READY="ready",t.BEFORE_RENDER="beforerender",t.RERENDER="rerender",t.AFTER_RENDER="afterrender",t.BEFORE_DESTROY="beforedestroy",t.AFTER_DESTROY="afterdestroy",t.RESIZE="resize",t.DIRTY_RECTANGLE="dirtyrectangle",t.RENDERER_CHANGED="rendererchanged",t}({}),xk=500,B8=.1,z8=1e3,My=new Nn($e.MOUNTED),ky=new Nn($e.UNMOUNTED),O_=new Nn(vo.BEFORE_RENDER),_k=new Nn(vo.RERENDER),S_=new Nn(vo.AFTER_RENDER),wk=function(t){function e(n){var r;(0,xt.Z)(this,e),r=(0,De.Z)(this,e),r.Element=or,r.inited=!1,r.context={};var i=n.container,a=n.canvas,o=n.renderer,s=n.width,c=n.height,l=n.background,u=n.cursor,f=n.supportsMutipleCanvasesInOneContainer,d=n.cleanUpOnDestroy,h=d===void 0?!0:d,v=n.offscreenCanvas,g=n.devicePixelRatio,y=n.requestAnimationFrame,b=n.cancelAnimationFrame,x=n.createImage,_=n.supportsTouchEvents,w=n.supportsPointerEvents,O=n.isTouchEvent,E=n.isMouseEvent,M=n.dblClickSpeed,k=s,A=c,P=g||cp&&window.devicePixelRatio||1;return P=P>=1?Math.ceil(P):1,a&&(k=s||B2(a)||a.width/P,A=c||z2(a)||a.height/P),r.customElements=new I8,r.devicePixelRatio=P,r.requestAnimationFrame=y!=null?y:$f.bind(Ct.globalThis),r.cancelAnimationFrame=b!=null?b:up.bind(Ct.globalThis),r.supportsTouchEvents=_!=null?_:"ontouchstart"in Ct.globalThis,r.supportsPointerEvents=w!=null?w:!!Ct.globalThis.PointerEvent,r.isTouchEvent=O!=null?O:function(C){return r.supportsTouchEvents&&C instanceof Ct.globalThis.TouchEvent},r.isMouseEvent=E!=null?E:function(C){return!Ct.globalThis.MouseEvent||C instanceof Ct.globalThis.MouseEvent&&(!r.supportsPointerEvents||!(C instanceof Ct.globalThis.PointerEvent))},v&&(Ct.offscreenCanvas=v),r.document=new D8,r.document.defaultView=r,f||j2(i,r,h),r.initRenderingContext((0,Ee.Z)((0,Ee.Z)({},n),{},{width:k,height:A,background:l!=null?l:"transparent",cursor:u!=null?u:"default",cleanUpOnDestroy:h,devicePixelRatio:P,requestAnimationFrame:r.requestAnimationFrame,cancelAnimationFrame:r.cancelAnimationFrame,supportsTouchEvents:r.supportsTouchEvents,supportsPointerEvents:r.supportsPointerEvents,isTouchEvent:r.isTouchEvent,isMouseEvent:r.isMouseEvent,dblClickSpeed:M!=null?M:200,createImage:x!=null?x:function(){return new window.Image}})),r.initDefaultCamera(k,A,o.clipSpaceNearZ),r.initRenderer(o,!0),r}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"initRenderingContext",value:function(r){this.context.config=r,this.context.renderingContext={root:this.document.documentElement,renderListCurrentFrame:[],unculledEntities:[],renderReasons:new Set,force:!1,dirty:!1}}},{key:"initDefaultCamera",value:function(r,i,a){var o=this,s=new Ct.CameraContribution;s.clipSpaceNearZ=a,s.setType(Ln.EXPLORING,zh.DEFAULT).setPosition(r/2,i/2,xk).setFocalPoint(r/2,i/2,0).setOrthographic(r/-2,r/2,i/2,i/-2,B8,z8),s.canvas=this,s.eventEmitter.on(Wh.UPDATED,function(){o.context.renderingContext.renderReasons.add(Kc.CAMERA_CHANGED),Ct.enableSizeAttenuation&&o.getConfig().renderer.getConfig().enableSizeAttenuation&&o.updateSizeAttenuation()}),this.context.camera=s}},{key:"updateSizeAttenuation",value:function(){var r=this.getCamera().getZoom();this.document.documentElement.forEach(function(i){Ct.styleValueRegistry.updateSizeAttenuation(i,r)})}},{key:"getConfig",value:function(){return this.context.config}},{key:"getRoot",value:function(){return this.document.documentElement}},{key:"getCamera",value:function(){return this.context.camera}},{key:"getContextService",value:function(){return this.context.contextService}},{key:"getEventService",value:function(){return this.context.eventService}},{key:"getRenderingService",value:function(){return this.context.renderingService}},{key:"getRenderingContext",value:function(){return this.context.renderingContext}},{key:"getStats",value:function(){return this.getRenderingService().getStats()}},{key:"ready",get:function(){var r=this;return this.readyPromise||(this.readyPromise=new Promise(function(i){r.resolveReadyPromise=function(){i(r)}}),this.inited&&this.resolveReadyPromise()),this.readyPromise}},{key:"destroy",value:function(){var r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:!0,i=arguments.length>1?arguments[1]:void 0;Ir.clearCache(),i||this.dispatchEvent(new Nn(vo.BEFORE_DESTROY)),this.frameId&&this.cancelAnimationFrame(this.frameId);var a=this.getRoot();r&&(this.unmountChildren(a),this.document.destroy(),this.getEventService().destroy()),this.getRenderingService().destroy(),this.getContextService().destroy(),this.context.rBushRoot&&this.context.rBushRoot.clear(),i||this.dispatchEvent(new Nn(vo.AFTER_DESTROY));var o=function(c){c.currentTarget=null,c.manager=null,c.target=null,c.relatedNode=null};o(My),o(ky),o(O_),o(_k),o(S_),o(ls),o(__),o(w_),o(vk)}},{key:"changeSize",value:function(r,i){this.resize(r,i)}},{key:"resize",value:function(r,i){var a=this.context.config;a.width=r,a.height=i,this.getContextService().resize(r,i);var o=this.context.camera,s=o.getProjectionMode();o.setPosition(r/2,i/2,xk).setFocalPoint(r/2,i/2,0),s===Ma.ORTHOGRAPHIC?o.setOrthographic(r/-2,r/2,i/2,i/-2,o.getNear(),o.getFar()):o.setAspect(r/i),this.dispatchEvent(new Nn(vo.RESIZE,{width:r,height:i}))}},{key:"appendChild",value:function(r,i){return this.document.documentElement.appendChild(r,i)}},{key:"insertBefore",value:function(r,i){return this.document.documentElement.insertBefore(r,i)}},{key:"removeChild",value:function(r){return this.document.documentElement.removeChild(r)}},{key:"removeChildren",value:function(){this.document.documentElement.removeChildren()}},{key:"destroyChildren",value:function(){this.document.documentElement.destroyChildren()}},{key:"render",value:function(r){var i=this;r&&(O_.detail=r,S_.detail=r),this.dispatchEvent(O_);var a=this.getRenderingService();a.render(this.getConfig(),r,function(){i.dispatchEvent(_k)}),this.dispatchEvent(S_)}},{key:"run",value:function(){var r=this,i=function(o,s){r.render(s),r.frameId=r.requestAnimationFrame(i)};i()}},{key:"initRenderer",value:function(r){var i=this,a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1;if(!r)throw new Error("Renderer is required.");this.inited=!1,this.readyPromise=void 0,this.context.rBushRoot=new $l,this.context.renderingPlugins=[],this.context.renderingPlugins.push(new mk,new bk,new yk([new F8])),this.loadRendererContainerModule(r),this.context.contextService=new this.context.ContextService((0,Ee.Z)((0,Ee.Z)({},Ct),this.context)),this.context.renderingService=new y_(Ct,this.context),this.context.eventService=new g_(Ct,this.context),this.context.eventService.init(),this.context.contextService.init?(this.context.contextService.init(),this.initRenderingService(r,a,!0)):this.context.contextService.initAsync().then(function(){i.initRenderingService(r,a)}).catch(function(o){console.error(o)})}},{key:"initRenderingService",value:function(r){var i=this,a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!1,o=arguments.length>2&&arguments[2]!==void 0?arguments[2]:!1;this.context.renderingService.init(function(){i.inited=!0,a?o?i.requestAnimationFrame(function(){i.dispatchEvent(new Nn(vo.READY))}):i.dispatchEvent(new Nn(vo.READY)):i.dispatchEvent(new Nn(vo.RENDERER_CHANGED)),i.readyPromise&&i.resolveReadyPromise(),a||i.getRoot().forEach(function(s){var c=s,l=c.renderable;l&&(l.renderBoundsDirty=!0,l.boundsDirty=!0,l.dirty=!0)}),i.mountChildren(i.getRoot()),r.getConfig().enableAutoRendering&&i.run()})}},{key:"loadRendererContainerModule",value:function(r){var i=this,a=r.getPlugins();a.forEach(function(o){o.context=i.context,o.init(Ct)})}},{key:"setRenderer",value:function(r){var i=this.getConfig();if(i.renderer!==r){var a=i.renderer;i.renderer=r,this.destroy(!1,!0),(0,ln.Z)((a==null?void 0:a.getPlugins())||[]).reverse().forEach(function(o){o.destroy(Ct)}),this.initRenderer(r)}}},{key:"setCursor",value:function(r){var i=this.getConfig();i.cursor=r,this.getContextService().applyCursorStyle(r)}},{key:"unmountChildren",value:function(r){var i=this;r.childNodes.forEach(function(a){i.unmountChildren(a)}),this.inited&&(r.isMutationObserved?r.dispatchEvent(ky):(ky.target=r,this.dispatchEvent(ky,!0)),r!==this.document.documentElement&&(r.ownerDocument=null),r.isConnected=!1),r.isCustomElement&&r.disconnectedCallback&&r.disconnectedCallback()}},{key:"mountChildren",value:function(r){var i=this,a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:Wf(r);this.inited?r.isConnected||(r.ownerDocument=this.document,r.isConnected=!0,a||(r.isMutationObserved?r.dispatchEvent(My):(My.target=r,this.dispatchEvent(My,!0)))):console.warn("[g]: You are trying to call `canvas.appendChild` before canvas' initialization finished. You can either await `canvas.ready` or listen to `CanvasEvent.READY` manually.","appended child: ",r.nodeName),r.childNodes.forEach(function(o){i.mountChildren(o,a)}),r.isCustomElement&&r.connectedCallback&&r.connectedCallback()}},{key:"mountFragment",value:function(r){this.mountChildren(r,!1)}},{key:"client2Viewport",value:function(r){return this.getEventService().client2Viewport(r)}},{key:"viewport2Client",value:function(r){return this.getEventService().viewport2Client(r)}},{key:"viewport2Canvas",value:function(r){return this.getEventService().viewport2Canvas(r)}},{key:"canvas2Viewport",value:function(r){return this.getEventService().canvas2Viewport(r)}},{key:"getPointByClient",value:function(r,i){return this.client2Viewport({x:r,y:i})}},{key:"getClientByPoint",value:function(r,i){return this.viewport2Client({x:r,y:i})}}])}(xy);var W8=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.landmarks=[],n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"rotate",value:function(r,i,a){if(this.relElevation=Zc(i),this.relAzimuth=Zc(r),this.relRoll=Zc(a),this.elevation+=this.relElevation,this.azimuth+=this.relAzimuth,this.roll+=this.relRoll,this.type===Ln.EXPLORING){var o=qo(je(),[1,0,0],Cn((this.rotateWorld?1:-1)*this.relElevation)),s=qo(je(),[0,1,0],Cn((this.rotateWorld?1:-1)*this.relAzimuth)),c=qo(je(),[0,0,1],Cn(this.relRoll)),l=Ko(je(),s,o);l=Ko(je(),l,c);var u=th(Wn(),l);Ns(this.matrix,this.matrix,[0,0,-this.distance]),Gn(this.matrix,this.matrix,u),Ns(this.matrix,this.matrix,[0,0,this.distance])}else{if(Math.abs(this.elevation)>90)return this;this.computeMatrix()}return this._getAxes(),this.type===Ln.ORBITING||this.type===Ln.EXPLORING?this._getPosition():this.type===Ln.TRACKING&&this._getFocalPoint(),this._update(),this}},{key:"pan",value:function(r,i){var a=Pi(r,i,0),o=wi(this.position);return Na(o,o,Uo(me(),this.right,a[0])),Na(o,o,Uo(me(),this.up,a[1])),this._setPosition(o),this.triggerUpdate(),this}},{key:"dolly",value:function(r){var i=this.forward,a=wi(this.position),o=r*this.dollyingStep,s=this.distance+r*this.dollyingStep;return o=Math.max(Math.min(s,this.maxDistance),this.minDistance)-this.distance,a[0]+=o*i[0],a[1]+=o*i[1],a[2]+=o*i[2],this._setPosition(a),this.type===Ln.ORBITING||this.type===Ln.EXPLORING?this._getDistance():this.type===Ln.TRACKING&&Na(this.focalPoint,a,this.distanceVector),this.triggerUpdate(),this}},{key:"cancelLandmarkAnimation",value:function(){this.landmarkAnimationID!==void 0&&this.canvas.cancelAnimationFrame(this.landmarkAnimationID)}},{key:"createLandmark",value:function(r){var i,a,o,s,c=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},l=c.position,u=l===void 0?this.position:l,f=c.focalPoint,d=f===void 0?this.focalPoint:f,h=c.roll,v=c.zoom,g=new Ct.CameraContribution;g.setType(this.type,void 0),g.setPosition(u[0],(i=u[1])!==null&&i!==void 0?i:this.position[1],(a=u[2])!==null&&a!==void 0?a:this.position[2]),g.setFocalPoint(d[0],(o=d[1])!==null&&o!==void 0?o:this.focalPoint[1],(s=d[2])!==null&&s!==void 0?s:this.focalPoint[2]),g.setRoll(h!=null?h:this.roll),g.setZoom(v!=null?v:this.zoom);var y={name:r,matrix:dv(g.getWorldTransform()),right:wi(g.right),up:wi(g.up),forward:wi(g.forward),position:wi(g.getPosition()),focalPoint:wi(g.getFocalPoint()),distanceVector:wi(g.getDistanceVector()),distance:g.getDistance(),dollyingStep:g.getDollyingStep(),azimuth:g.getAzimuth(),elevation:g.getElevation(),roll:g.getRoll(),relAzimuth:g.relAzimuth,relElevation:g.relElevation,relRoll:g.relRoll,zoom:g.getZoom()};return this.landmarks.push(y),y}},{key:"gotoLandmark",value:function(r){var i=this,a=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},o=ir(r)?this.landmarks.find(function(C){return C.name===r}):r;if(o){var s=Vn(a)?{duration:a}:a,c=s.easing,l=c===void 0?"linear":c,u=s.duration,f=u===void 0?100:u,d=s.easingFunction,h=d===void 0?void 0:d,v=s.onfinish,g=v===void 0?void 0:v,y=s.onframe,b=y===void 0?void 0:y,x=.01;this.cancelLandmarkAnimation();var _=o.position,w=o.focalPoint,O=o.zoom,E=o.roll,M=h||Ct.EasingFunction(l),k,A=function(){i.setFocalPoint(w),i.setPosition(_),i.setRoll(E),i.setZoom(O),i.computeMatrix(),i.triggerUpdate(),g==null||g()};if(f===0)return A();var P=function(N){k===void 0&&(k=N);var L=N-k;if(L>=f){A();return}var R=M(L/f),I=me(),D=me(),G=1,F=0;El(I,i.focalPoint,w,R),El(D,i.position,_,R),F=i.roll*(1-R)+E*R,G=i.zoom*(1-R)+O*R,i.setFocalPoint(I),i.setPosition(D),i.setRoll(F),i.setZoom(G);var W=Dt(I,w)+Dt(D,_);if(W<=x&&O===void 0&&E===void 0)return A();i.computeMatrix(),i.triggerUpdate(),L<f&&(b==null||b(R),i.landmarkAnimationID=i.canvas.requestAnimationFrame(P))};this.canvas.requestAnimationFrame(P)}}}])}(_g);Ct.CameraContribution=W8;var Ok=null,Aat=0,Sk=new WeakMap,Tat=null,Pat=null,Ay,ec;function Cat(t,e){return Ay=new Ok(t,e)}function Lat(t){return ec||(ec=Ok.copy(Ay),ec.oldValue=t,ec)}function Rat(){Ay=ec=void 0}function G8(t){return t===ec||t===Ay}function Nat(t,e){return t===e?t:ec&&G8(t)?ec:null}function $8(t){t.nodes.forEach(function(e){var n=Sk.get(e);n&&n.forEach(function(r){r.observer===t&&r.removeTransientObservers()})})}function Iat(t,e){for(var n=t;n;n=n.parentNode){var r=Sk.get(n);if(r)for(var i=0;i<r.length;i++){var a=r[i],o=a.options;if(!(n!==t&&!o.subtree)){var s=e(o);s&&a.enqueue(s)}}}}var E_=!1,M_=null;function Dat(t){M_.push(t),E_||(E_=!0,typeof runtime.globalThis!="undefined"?runtime.globalThis.setTimeout(k_):k_())}function k_(){E_=!1;var t=M_;M_=[],t.sort(function(n,r){return n.uid-r.uid});var e=!1;t.forEach(function(n){var r=n.takeRecords();$8(n),r.length&&(n.callback(r,n),e=!0)}),e&&k_()}var A_=function(t){function e(n,r,i,a){var o;return(0,xt.Z)(this,e),o=(0,De.Z)(this,e,[n]),o.currentTime=i,o.timelineTime=a,o.target=r,o.type="finish",o.bubbles=!1,o.currentTarget=r,o.defaultPrevented=!1,o.eventPhase=o.AT_TARGET,o.timeStamp=Date.now(),o.currentTime=i,o.timelineTime=a,o}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(Yf),Z8=0,Y8=function(){function t(e,n){var r;(0,xt.Z)(this,t),this.currentTimePending=!1,this._idle=!0,this._paused=!1,this._finishedFlag=!0,this._currentTime=0,this._playbackRate=1,this._inTimeline=!0,this.effect=e,e.animation=this,this.timeline=n,this.id="".concat(Z8++),this._inEffect=!!this.effect.update(0),this._totalDuration=Number((r=this.effect)===null||r===void 0?void 0:r.getComputedTiming().endTime),this._holdTime=0,this._paused=!1,this.oldPlayState="idle",this.updatePromises()}return(0,Ot.Z)(t,[{key:"pending",get:function(){return this._startTime===null&&!this._paused&&this.playbackRate!==0||this.currentTimePending}},{key:"playState",get:function(){return this._idle?"idle":this._isFinished?"finished":this._paused?"paused":"running"}},{key:"ready",get:function(){var n=this;return this.readyPromise||(this.timeline.animationsWithPromises.indexOf(this)===-1&&this.timeline.animationsWithPromises.push(this),this.readyPromise=new Promise(function(r,i){n.resolveReadyPromise=function(){r(n)},n.rejectReadyPromise=function(){i(new Error)}}),this.pending||this.resolveReadyPromise()),this.readyPromise}},{key:"finished",get:function(){var n=this;return this.finishedPromise||(this.timeline.animationsWithPromises.indexOf(this)===-1&&this.timeline.animationsWithPromises.push(this),this.finishedPromise=new Promise(function(r,i){n.resolveFinishedPromise=function(){r(n)},n.rejectFinishedPromise=function(){i(new Error)}}),this.playState==="finished"&&this.resolveFinishedPromise()),this.finishedPromise}},{key:"currentTime",get:function(){return this.updatePromises(),this._idle||this.currentTimePending?null:this._currentTime},set:function(n){if(n=Number(n),!isNaN(n)){if(this.timeline.restart(),!this._paused&&this._startTime!==null){var r;this._startTime=Number((r=this.timeline)===null||r===void 0?void 0:r.currentTime)-n/this.playbackRate}this.currentTimePending=!1,this._currentTime!==n&&(this._idle&&(this._idle=!1,this._paused=!0),this.tickCurrentTime(n,!0),this.timeline.applyDirtiedAnimation(this))}}},{key:"startTime",get:function(){return this._startTime},set:function(n){if(n!==null){if(this.updatePromises(),n=Number(n),isNaN(n)||this._paused||this._idle)return;this._startTime=n,this.tickCurrentTime((Number(this.timeline.currentTime)-this._startTime)*this.playbackRate),this.timeline.applyDirtiedAnimation(this),this.updatePromises()}}},{key:"playbackRate",get:function(){return this._playbackRate},set:function(n){if(n!==this._playbackRate){this.updatePromises();var r=this.currentTime;this._playbackRate=n,this.startTime=null,this.playState!=="paused"&&this.playState!=="idle"&&(this._finishedFlag=!1,this._idle=!1,this.ensureAlive(),this.timeline.applyDirtiedAnimation(this)),r!==null&&(this.currentTime=r),this.updatePromises()}}},{key:"_isFinished",get:function(){return!this._idle&&(this._playbackRate>0&&Number(this._currentTime)>=this._totalDuration||this._playbackRate<0&&Number(this._currentTime)<=0)}},{key:"totalDuration",get:function(){return this._totalDuration}},{key:"_needsTick",get:function(){return this.pending||this.playState==="running"||!this._finishedFlag}},{key:"updatePromises",value:function(){var n=this.oldPlayState,r=this.pending?"pending":this.playState;return this.readyPromise&&r!==n&&(r==="idle"?(this.rejectReadyPromise(),this.readyPromise=void 0):n==="pending"?this.resolveReadyPromise():r==="pending"&&(this.readyPromise=void 0)),this.finishedPromise&&r!==n&&(r==="idle"?(this.rejectFinishedPromise(),this.finishedPromise=void 0):r==="finished"?this.resolveFinishedPromise():n==="finished"&&(this.finishedPromise=void 0)),this.oldPlayState=r,this.readyPromise||this.finishedPromise}},{key:"play",value:function(){this.updatePromises(),this._paused=!1,(this._isFinished||this._idle)&&(this.rewind(),this._startTime=null),this._finishedFlag=!1,this._idle=!1,this.ensureAlive(),this.timeline.applyDirtiedAnimation(this),this.timeline.animations.indexOf(this)===-1&&this.timeline.animations.push(this),this.updatePromises()}},{key:"pause",value:function(){this.updatePromises(),this.currentTime&&(this._holdTime=this.currentTime),!this._isFinished&&!this._paused&&!this._idle?this.currentTimePending=!0:this._idle&&(this.rewind(),this._idle=!1),this._startTime=null,this._paused=!0,this.updatePromises()}},{key:"finish",value:function(){this.updatePromises(),!this._idle&&(this.currentTime=this._playbackRate>0?this._totalDuration:0,this._startTime=this._totalDuration-this.currentTime,this.currentTimePending=!1,this.timeline.applyDirtiedAnimation(this),this.updatePromises())}},{key:"cancel",value:function(){var n=this;if(this.updatePromises(),!!this._inEffect&&(this._inEffect=!1,this._idle=!0,this._paused=!1,this._finishedFlag=!0,this._currentTime=0,this._startTime=null,this.effect.update(null),this.timeline.applyDirtiedAnimation(this),this.updatePromises(),this.oncancel)){var r=new A_(null,this,this.currentTime,null);setTimeout(function(){n.oncancel(r)})}}},{key:"reverse",value:function(){this.updatePromises();var n=this.currentTime;this.playbackRate*=-1,this.play(),n!==null&&(this.currentTime=n),this.updatePromises()}},{key:"updatePlaybackRate",value:function(n){this.playbackRate=n}},{key:"targetAnimations",value:function(){var n,r=(n=this.effect)===null||n===void 0?void 0:n.target;return r.getAnimations()}},{key:"markTarget",value:function(){var n=this.targetAnimations();n.indexOf(this)===-1&&n.push(this)}},{key:"unmarkTarget",value:function(){var n=this.targetAnimations(),r=n.indexOf(this);r!==-1&&n.splice(r,1)}},{key:"tick",value:function(n,r){!this._idle&&!this._paused&&(this._startTime===null?r&&(this.startTime=n-this._currentTime/this.playbackRate):this._isFinished||this.tickCurrentTime((n-this._startTime)*this.playbackRate)),r&&(this.currentTimePending=!1,this.fireEvents(n))}},{key:"rewind",value:function(){if(this.playbackRate>=0)this.currentTime=0;else if(this._totalDuration<1/0)this.currentTime=this._totalDuration;else throw new Error("Unable to rewind negative playback rate animation with infinite duration")}},{key:"persist",value:function(){throw new Error(kn)}},{key:"addEventListener",value:function(n,r,i){throw new Error(kn)}},{key:"removeEventListener",value:function(n,r,i){throw new Error(kn)}},{key:"dispatchEvent",value:function(n){throw new Error(kn)}},{key:"commitStyles",value:function(){throw new Error(kn)}},{key:"ensureAlive",value:function(){if(this.playbackRate<0&&this.currentTime===0){var n;this._inEffect=!!((n=this.effect)!==null&&n!==void 0&&n.update(-1))}else{var r;this._inEffect=!!((r=this.effect)!==null&&r!==void 0&&r.update(this.currentTime))}!this._inTimeline&&(this._inEffect||!this._finishedFlag)&&(this._inTimeline=!0,this.timeline.animations.push(this))}},{key:"tickCurrentTime",value:function(n,r){n!==this._currentTime&&(this._currentTime=n,this._isFinished&&!r&&(this._currentTime=this._playbackRate>0?this._totalDuration:0),this.ensureAlive())}},{key:"fireEvents",value:function(n){var r=this;if(this._isFinished){if(!this._finishedFlag){if(this.onfinish){var i=new A_(null,this,this.currentTime,n);setTimeout(function(){r.onfinish&&r.onfinish(i)})}this._finishedFlag=!0}}else{if(this.onframe&&this.playState==="running"){var a=new A_(null,this,this.currentTime,n);this.onframe(a)}this._finishedFlag=!1}}}])}(),H8=4,V8=.001,X8=1e-7,U8=10,xp=11,Ty=1/(xp-1),q8=typeof Float32Array=="function",Ek=function(e,n){return 1-3*n+3*e},Mk=function(e,n){return 3*n-6*e},kk=function(e){return 3*e},Py=function(e,n,r){return((Ek(n,r)*e+Mk(n,r))*e+kk(n))*e},Ak=function(e,n,r){return 3*Ek(n,r)*e*e+2*Mk(n,r)*e+kk(n)},K8=function(e,n,r,i,a){var o,s,c=0;do s=n+(r-n)/2,o=Py(s,i,a)-e,o>0?r=s:n=s;while(Math.abs(o)>X8&&++c<U8);return s},Q8=function(e,n,r,i){for(var a=0;a<H8;++a){var o=Ak(n,r,i);if(o===0)return n;var s=Py(n,r,i)-e;n-=s/o}return n},T_=function(e,n,r,i){if(!(e>=0&&e<=1&&r>=0&&r<=1))throw new Error("bezier x values must be in [0, 1] range");if(e===n&&r===i)return function(c){return c};for(var a=q8?new Float32Array(xp):new Array(xp),o=0;o<xp;++o)a[o]=Py(o*Ty,e,r);var s=function(l){for(var u=0,f=1,d=xp-1;f!==d&&a[f]<=l;++f)u+=Ty;--f;var h=(l-a[f])/(a[f+1]-a[f]),v=u+h*Ty,g=Ak(v,e,r);return g>=V8?Q8(l,v,e,r):g===0?v:K8(l,u,u+Ty,e,r)};return function(c){return c===0||c===1?c:Py(s(c),n,i)}},J8=function(e){return e=e.replace(/([A-Z])/g,function(n){return"-".concat(n.toLowerCase())}),e.charAt(0)==="-"?e.substring(1):e},Cy=function(e){return Math.pow(e,2)},Ly=function(e){return Math.pow(e,3)},Ry=function(e){return Math.pow(e,4)},Ny=function(e){return Math.pow(e,5)},Iy=function(e){return Math.pow(e,6)},Dy=function(e){return 1-Math.cos(e*Math.PI/2)},jy=function(e){return 1-Math.sqrt(1-e*e)},Fy=function(e){return e*e*(3*e-2)},By=function(e){for(var n,r=4;e<((n=Math.pow(2,--r))-1)/11;);return 1/Math.pow(4,3-r)-7.5625*Math.pow((n*3-2)/22-e,2)},zy=function(e){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[],r=(0,Te.Z)(n,2),i=r[0],a=i===void 0?1:i,o=r[1],s=o===void 0?.5:o,c=mn(Number(a),1,10),l=mn(Number(s),.1,2);return e===0||e===1?e:-c*Math.pow(2,10*(e-1))*Math.sin((e-1-l/(Math.PI*2)*Math.asin(1/c))*(Math.PI*2)/l)},_p=function(e){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[],r=arguments.length>2?arguments[2]:void 0,i=(0,Te.Z)(n,4),a=i[0],o=a===void 0?1:a,s=i[1],c=s===void 0?100:s,l=i[2],u=l===void 0?10:l,f=i[3],d=f===void 0?0:f;o=mn(o,.1,1e3),c=mn(c,.1,1e3),u=mn(u,.1,1e3),d=mn(d,.1,1e3);var h=Math.sqrt(c/o),v=u/(2*Math.sqrt(c*o)),g=v<1?h*Math.sqrt(1-v*v):0,y=1,b=v<1?(v*h+-d)/g:-d+h,x=r?r*e/1e3:e;return v<1?x=Math.exp(-x*v*h)*(y*Math.cos(g*x)+b*Math.sin(g*x)):x=(y+b*x)*Math.exp(-x*h),e===0||e===1?e:1-x},P_=function(e){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[],r=n,i=(0,Te.Z)(r,2),a=i[0],o=a===void 0?10:a,s=i[1],c=s==="start"?Math.ceil:Math.floor;return c(mn(e,0,1)*o)/o},Tk=function(e){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[],r=(0,Te.Z)(n,4),i=r[0],a=r[1],o=r[2],s=r[3];return T_(i,a,o,s)(e)},Wy=T_(.42,0,1,1),go=function(e){return function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[],i=arguments.length>2?arguments[2]:void 0;return 1-e(1-n,r,i)}},yo=function(e){return function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[],i=arguments.length>2?arguments[2]:void 0;return n<.5?e(n*2,r,i)/2:1-e(n*-2+2,r,i)/2}},mo=function(e){return function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[],i=arguments.length>2?arguments[2]:void 0;return n<.5?(1-e(1-n*2,r,i))/2:(e(n*2-1,r,i)+1)/2}},Pk={steps:P_,"step-start":function(e){return P_(e,[1,"start"])},"step-end":function(e){return P_(e,[1,"end"])},linear:function(e){return e},"cubic-bezier":Tk,ease:function(e){return Tk(e,[.25,.1,.25,1])},in:Wy,out:go(Wy),"in-out":yo(Wy),"out-in":mo(Wy),"in-quad":Cy,"out-quad":go(Cy),"in-out-quad":yo(Cy),"out-in-quad":mo(Cy),"in-cubic":Ly,"out-cubic":go(Ly),"in-out-cubic":yo(Ly),"out-in-cubic":mo(Ly),"in-quart":Ry,"out-quart":go(Ry),"in-out-quart":yo(Ry),"out-in-quart":mo(Ry),"in-quint":Ny,"out-quint":go(Ny),"in-out-quint":yo(Ny),"out-in-quint":mo(Ny),"in-expo":Iy,"out-expo":go(Iy),"in-out-expo":yo(Iy),"out-in-expo":mo(Iy),"in-sine":Dy,"out-sine":go(Dy),"in-out-sine":yo(Dy),"out-in-sine":mo(Dy),"in-circ":jy,"out-circ":go(jy),"in-out-circ":yo(jy),"out-in-circ":mo(jy),"in-back":Fy,"out-back":go(Fy),"in-out-back":yo(Fy),"out-in-back":mo(Fy),"in-bounce":By,"out-bounce":go(By),"in-out-bounce":yo(By),"out-in-bounce":mo(By),"in-elastic":zy,"out-elastic":go(zy),"in-out-elastic":yo(zy),"out-in-elastic":mo(zy),spring:_p,"spring-in":_p,"spring-out":go(_p),"spring-in-out":yo(_p),"spring-out-in":mo(_p)},tj=function(e){return J8(e).replace(/^ease-/,"").replace(/(\(|\s).+/,"").toLowerCase().trim()},ej=function(e){return Pk[tj(e)]||Pk.linear},nj=function(e){return e},rj=1,ij=.5,Ck=0;function Lk(t,e){return function(n){if(n>=1)return 1;var r=1/t;return n+=e*r,n-n%r}}var Gy="\\s*(-?\\d+\\.?\\d*|-?\\.\\d+)\\s*",aj=new RegExp("cubic-bezier\\(".concat(Gy,",").concat(Gy,",").concat(Gy,",").concat(Gy,"\\)")),oj=/steps\(\s*(\d+)\s*\)/,sj=/steps\(\s*(\d+)\s*,\s*(start|middle|end)\s*\)/;function C_(t){var e=aj.exec(t);if(e)return T_.apply(void 0,(0,ln.Z)(e.slice(1).map(Number)));var n=oj.exec(t);if(n)return Lk(Number(n[1]),Ck);var r=sj.exec(t);return r?Lk(Number(r[1]),{start:rj,middle:ij,end:Ck}[r[2]]):ej(t)}function cj(t){return Math.abs(lj(t)/(t.playbackRate||1))}function lj(t){var e;return t.duration===0||t.iterations===0?0:(t.duration==="auto"?0:Number(t.duration))*((e=t.iterations)!==null&&e!==void 0?e:1)}var Rk=0,L_=1,$y=2,Nk=3;function uj(t,e,n){if(e===null)return Rk;var r=n.endTime;return e<Math.min(n.delay,r)?L_:e>=Math.min(n.delay+t+n.endDelay,r)?$y:Nk}function fj(t,e,n,r,i){switch(r){case L_:return e==="backwards"||e==="both"?0:null;case Nk:return n-i;case $y:return e==="forwards"||e==="both"?t:null;case Rk:return null}}function dj(t,e,n,r,i){var a=i;return t===0?e!==L_&&(a+=n):a+=r/t,a}function hj(t,e,n,r,i,a){var o=t===1/0?e%1:t%1;return o===0&&n===$y&&r!==0&&(i!==0||a===0)&&(o=1),o}function pj(t,e,n,r){return t===$y&&e===1/0?1/0:n===1?Math.floor(r)-1:Math.floor(r)}function vj(t,e,n){var r=t;if(t!=="normal"&&t!=="reverse"){var i=e;t==="alternate-reverse"&&(i+=1),r="normal",i!==1/0&&i%2!==0&&(r="reverse")}return r==="normal"?n:1-n}function gj(t,e,n){var r=uj(t,e,n),i=fj(t,n.fill,e,r,n.delay);if(i===null)return null;var a=n.duration==="auto"?0:n.duration,o=dj(a,r,n.iterations,i,n.iterationStart),s=hj(o,n.iterationStart,r,n.iterations,i,a),c=pj(r,n.iterations,s,o),l=vj(n.direction,c,s);return n.currentIteration=c,n.progress=l,n.easingFunction(l)}function yj(t,e,n){var r=mj(t,e),i=bj(r,n);return function(a,o){if(o!==null)i.filter(function(c){return o>=c.applyFrom&&o<c.applyTo}).forEach(function(c){var l=o-c.startOffset,u=c.endOffset-c.startOffset,f=u===0?0:l/u;a.setAttribute(c.property,c.interpolation(f),!1,!1)});else for(var s in r)Ik(s)&&a.setAttribute(s,null)}}function Ik(t){return t!=="offset"&&t!=="easing"&&t!=="composite"&&t!=="computedOffset"}function mj(t,e){for(var n={},r=0;r<t.length;r++)for(var i in t[r])if(Ik(i)){var a={offset:t[r].offset,computedOffset:t[r].computedOffset,easing:t[r].easing,easingFunction:C_(t[r].easing)||e.easingFunction,value:t[r][i]};n[i]=n[i]||[],n[i].push(a)}return n}function bj(t,e){var n=[];for(var r in t)for(var i=t[r],a=0;a<i.length-1;a++){var o=a,s=a+1,c=i[o].computedOffset,l=i[s].computedOffset,u=c,f=l;a===0&&(u=-1/0,l===0&&(s=o)),a===i.length-2&&(f=1/0,c===1&&(o=s)),n.push({applyFrom:u,applyTo:f,startOffset:i[o].computedOffset,endOffset:i[s].computedOffset,easingFunction:i[o].easingFunction,property:r,interpolation:xj(r,i[o].value,i[s].value,e)})}return n.sort(function(d,h){return d.startOffset-h.startOffset}),n}var Dk=function(e,n,r){return function(i){var a=jk(e,n,i);return Vn(a)?a:r(a)}};function xj(t,e,n,r){var i=Yr[t];if(i&&i.syntax&&i.int){var a=Ct.styleValueRegistry.getPropertySyntax(i.syntax);if(a){var o=a.parser,s=o?o(e,r):e,c=o?o(n,r):n,l=a.mixer(s,c,r);if(l){var u=Dk.apply(void 0,(0,ln.Z)(l));return function(f){return f===0?e:f===1?n:u(f)}}}}return Dk(!1,!0,function(f){return f?n:e})}function jk(t,e,n){if(typeof t=="number"&&typeof e=="number")return t*(1-n)+e*n;if(typeof t=="boolean"&&typeof e=="boolean"||typeof t=="string"&&typeof e=="string")return n<.5?t:e;if(Array.isArray(t)&&Array.isArray(e)){for(var r=t.length,i=e.length,a=Math.max(r,i),o=[],s=0;s<a;s++)o.push(jk(t[s<r?s:r-1],e[s<i?s:i-1],n));return o}throw new Error("Mismatched interpolation arguments ".concat(t,":").concat(e))}var _j=function(){function t(){(0,xt.Z)(this,t),this.delay=0,this.direction="normal",this.duration="auto",this._easing="linear",this.easingFunction=nj,this.endDelay=0,this.fill="auto",this.iterationStart=0,this.iterations=1,this.currentIteration=null,this.progress=null}return(0,Ot.Z)(t,[{key:"easing",get:function(){return this._easing},set:function(n){this.easingFunction=C_(n),this._easing=n}}])}();function wj(t){var e=[];for(var n in t)if(!(n in["easing","offset","composite"])){var r=t[n];Array.isArray(r)||(r=[r]);for(var i=r.length,a=0;a<i;a++){if(!e[a]){var o={};"offset"in t&&(o.offset=Number(t.offset)),"easing"in t&&(o.easing=t.easing),"composite"in t&&(o.composite=t.composite),e[a]=o}r[a]!==void 0&&r[a]!==null&&(e[a][n]=r[a])}}return e.sort(function(s,c){return(s.computedOffset||0)-(c.computedOffset||0)}),e}function Fk(t,e){if(t===null)return[];Array.isArray(t)||(t=wj(t));for(var n=t.map(function(c){var l={};e!=null&&e.composite&&(l.composite="auto");for(var u in c){var f=c[u];if(u==="offset"){if(f!==null){if(f=Number(f),!isFinite(f))throw new Error("Keyframe offsets must be numbers.");if(f<0||f>1)throw new Error("Keyframe offsets must be between 0 and 1.");l.computedOffset=f}}else if(u==="composite"&&["replace","add","accumulate","auto"].indexOf(f)===-1)throw new Error("".concat(f," compositing is not supported"));l[u]=f}return l.offset===void 0&&(l.offset=null),l.easing===void 0&&(l.easing=(e==null?void 0:e.easing)||"linear"),l.composite===void 0&&(l.composite="auto"),l}),r=!0,i=-1/0,a=0;a<n.length;a++){var o=n[a].offset;if(ge(o))r=!1;else{if(o<i)throw new TypeError("Keyframes are not loosely sorted by offset. Sort or specify offsets.");i=o}}n=n.filter(function(c){return Number(c.offset)>=0&&Number(c.offset)<=1});function s(){var c,l=n,u=l.length;if(n[u-1].computedOffset=Number((c=n[u-1].offset)!==null&&c!==void 0?c:1),u>1){var f;n[0].computedOffset=Number((f=n[0].offset)!==null&&f!==void 0?f:0)}for(var d=0,h=Number(n[0].computedOffset),v=1;v<u;v++){var g=n[v].computedOffset;if(!ge(g)&&!ge(h)){for(var y=1;y<v-d;y++)n[d+y].computedOffset=h+(Number(g)-h)*y/(v-d);d=v,h=Number(g)}}}return r||s(),n}var Oj="backwards|forwards|both|none".split("|"),Sj="reverse|alternate|alternate-reverse".split("|");function Ej(t,e){var n=new _j;return e&&(n.fill="both",n.duration="auto"),typeof t=="number"&&!isNaN(t)?n.duration=t:t!==void 0&&Object.keys(t).forEach(function(r){if(t[r]!==void 0&&t[r]!==null&&t[r]!=="auto"){if((typeof n[r]=="number"||r==="duration")&&(typeof t[r]!="number"||isNaN(t[r]))||r==="fill"&&Oj.indexOf(t[r])===-1||r==="direction"&&Sj.indexOf(t[r])===-1)return;n[r]=t[r]}}),n}function Mj(t,e){return t=kj(t!=null?t:{duration:"auto"}),Ej(t,e)}function kj(t){return typeof t=="number"&&(isNaN(t)?t={duration:"auto"}:t={duration:t}),t}var Aj=function(){function t(e,n,r){var i=this;(0,xt.Z)(this,t),this.composite="replace",this.iterationComposite="replace",this.target=e,this.timing=Mj(r,!1),this.timing.effect=this,this.timing.activeDuration=cj(this.timing),this.timing.endTime=Math.max(0,this.timing.delay+this.timing.activeDuration+this.timing.endDelay),this.normalizedKeyframes=Fk(n,this.timing),this.interpolations=yj(this.normalizedKeyframes,this.timing,this.target);var a=Ct.globalThis.Proxy;this.computedTiming=a?new a(this.timing,{get:function(s,c){return c==="duration"?s.duration==="auto"?0:s.duration:c==="fill"?s.fill==="auto"?"none":s.fill:c==="localTime"?i.animation&&i.animation.currentTime||null:c==="currentIteration"?!i.animation||i.animation.playState!=="running"?null:s.currentIteration||0:c==="progress"?!i.animation||i.animation.playState!=="running"?null:s.progress||0:s[c]},set:function(){return!0}}):this.timing}return(0,Ot.Z)(t,[{key:"applyInterpolations",value:function(){this.interpolations(this.target,Number(this.timeFraction))}},{key:"update",value:function(n){return n===null?!1:(this.timeFraction=gj(this.timing.activeDuration,n,this.timing),this.timeFraction!==null)}},{key:"getKeyframes",value:function(){return this.normalizedKeyframes}},{key:"setKeyframes",value:function(n){this.normalizedKeyframes=Fk(n)}},{key:"getComputedTiming",value:function(){return this.computedTiming}},{key:"getTiming",value:function(){return this.timing}},{key:"updateTiming",value:function(n){var r=this;Object.keys(n||{}).forEach(function(i){r.timing[i]=n[i]})}}])}();function Bk(t,e){return Number(t.id)-Number(e.id)}var Tj=function(){function t(e){var n=this;(0,xt.Z)(this,t),this.animations=[],this.ticking=!1,this.timelineTicking=!1,this.hasRestartedThisFrame=!1,this.animationsWithPromises=[],this.inTick=!1,this.pendingEffects=[],this.currentTime=null,this.rafId=0,this.rafCallbacks=[],this.webAnimationsNextTick=function(r){n.currentTime=r,n.discardAnimations(),n.animations.length===0?n.timelineTicking=!1:n.requestAnimationFrame(n.webAnimationsNextTick)},this.processRafCallbacks=function(r){var i=n.rafCallbacks;n.rafCallbacks=[],r<Number(n.currentTime)&&(r=Number(n.currentTime)),n.animations.sort(Bk),n.animations=n.tick(r,!0,n.animations)[0],i.forEach(function(a){a[1](r)}),n.applyPendingEffects()},this.document=e}return(0,Ot.Z)(t,[{key:"getAnimations",value:function(){return this.discardAnimations(),this.animations.slice()}},{key:"isTicking",value:function(){return this.inTick}},{key:"play",value:function(n,r,i){var a=new Aj(n,r,i),o=new Y8(a,this);return this.animations.push(o),this.restartWebAnimationsNextTick(),o.updatePromises(),o.play(),o.updatePromises(),o}},{key:"applyDirtiedAnimation",value:function(n){var r=this;if(!this.inTick){n.markTarget();var i=n.targetAnimations();i.sort(Bk);var a=this.tick(Number(this.currentTime),!1,i.slice())[1];a.forEach(function(o){var s=r.animations.indexOf(o);s!==-1&&r.animations.splice(s,1)}),this.applyPendingEffects()}}},{key:"restart",value:function(){return this.ticking||(this.ticking=!0,this.requestAnimationFrame(function(){}),this.hasRestartedThisFrame=!0),this.hasRestartedThisFrame}},{key:"destroy",value:function(){this.document.defaultView.cancelAnimationFrame(this.frameId)}},{key:"applyPendingEffects",value:function(){this.pendingEffects.forEach(function(n){n==null||n.applyInterpolations()}),this.pendingEffects=[]}},{key:"updateAnimationsPromises",value:function(){this.animationsWithPromises=this.animationsWithPromises.filter(function(n){return n.updatePromises()})}},{key:"discardAnimations",value:function(){this.updateAnimationsPromises(),this.animations=this.animations.filter(function(n){return n.playState!=="finished"&&n.playState!=="idle"})}},{key:"restartWebAnimationsNextTick",value:function(){this.timelineTicking||(this.timelineTicking=!0,this.requestAnimationFrame(this.webAnimationsNextTick))}},{key:"rAF",value:function(n){var r=this.rafId++;return this.rafCallbacks.length===0&&(this.frameId=this.document.defaultView.requestAnimationFrame(this.processRafCallbacks)),this.rafCallbacks.push([r,n]),r}},{key:"requestAnimationFrame",value:function(n){var r=this;return this.rAF(function(i){r.updateAnimationsPromises(),n(i),r.updateAnimationsPromises()})}},{key:"tick",value:function(n,r,i){var a=this,o,s;this.inTick=!0,this.hasRestartedThisFrame=!1,this.currentTime=n,this.ticking=!1;var c=[],l=[],u=[],f=[];return i.forEach(function(d){d.tick(n,r),d._inEffect?(l.push(d.effect),d.markTarget()):(c.push(d.effect),d.unmarkTarget()),d._needsTick&&(a.ticking=!0);var h=d._inEffect||d._needsTick;d._inTimeline=h,h?u.push(d):f.push(d)}),(o=this.pendingEffects).push.apply(o,c),(s=this.pendingEffects).push.apply(s,l),this.ticking&&this.requestAnimationFrame(function(){}),this.inTick=!1,[u,f]}}])}();Ct.EasingFunction=C_,Ct.AnimationTimeline=Tj;var Pj=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const R_=(t,e,n)=>[["M",t-n,e],["A",n,n,0,1,0,t+n,e],["A",n,n,0,1,0,t-n,e],["Z"]];R_.style=["fill"];const zk=R_.bind(void 0);zk.style=["stroke","lineWidth"];const Zy=(t,e,n)=>[["M",t-n,e-n],["L",t+n,e-n],["L",t+n,e+n],["L",t-n,e+n],["Z"]];Zy.style=["fill"];const Wk=Zy.bind(void 0);Wk.style=["fill"];const Gk=Zy.bind(void 0);Gk.style=["stroke","lineWidth"];const N_=(t,e,n)=>{const r=n*.618;return[["M",t-r,e],["L",t,e-n],["L",t+r,e],["L",t,e+n],["Z"]]};N_.style=["fill"];const $k=N_.bind(void 0);$k.style=["stroke","lineWidth"];const I_=(t,e,n)=>{const r=n*Math.sin(.3333333333333333*Math.PI);return[["M",t-n,e+r],["L",t,e-r],["L",t+n,e+r],["Z"]]};I_.style=["fill"];const Zk=I_.bind(void 0);Zk.style=["stroke","lineWidth"];const D_=(t,e,n)=>{const r=n*Math.sin(.3333333333333333*Math.PI);return[["M",t-n,e-r],["L",t+n,e-r],["L",t,e+r],["Z"]]};D_.style=["fill"];const Yk=D_.bind(void 0);Yk.style=["stroke","lineWidth"];const j_=(t,e,n)=>{const r=n/2*Math.sqrt(3);return[["M",t,e-n],["L",t+r,e-n/2],["L",t+r,e+n/2],["L",t,e+n],["L",t-r,e+n/2],["L",t-r,e-n/2],["Z"]]};j_.style=["fill"];const Hk=j_.bind(void 0);Hk.style=["stroke","lineWidth"];const F_=(t,e,n)=>{const r=n-1.5;return[["M",t-n,e-r],["L",t+n,e+r],["L",t+n,e-r],["L",t-n,e+r],["Z"]]};F_.style=["fill"];const Vk=F_.bind(void 0);Vk.style=["stroke","lineWidth"];const Xk=(t,e,n)=>[["M",t,e+n],["L",t,e-n]];Xk.style=["stroke","lineWidth"];const Uk=(t,e,n)=>[["M",t-n,e-n],["L",t+n,e+n],["M",t+n,e-n],["L",t-n,e+n]];Uk.style=["stroke","lineWidth"];const qk=(t,e,n)=>[["M",t-n/2,e-n],["L",t+n/2,e-n],["M",t,e-n],["L",t,e+n],["M",t-n/2,e+n],["L",t+n/2,e+n]];qk.style=["stroke","lineWidth"];const Kk=(t,e,n)=>[["M",t-n,e],["L",t+n,e],["M",t,e-n],["L",t,e+n]];Kk.style=["stroke","lineWidth"];const Qk=(t,e,n)=>[["M",t-n,e],["L",t+n,e]];Qk.style=["stroke","lineWidth"];const B_=(t,e,n)=>[["M",t-n,e],["L",t+n,e]];B_.style=["stroke","lineWidth"];const Jk=B_.bind(void 0);Jk.style=["stroke","lineWidth"];const tA=(t,e,n)=>[["M",t-n,e],["A",n/2,n/2,0,1,1,t,e],["A",n/2,n/2,0,1,0,t+n,e]];tA.style=["stroke","lineWidth"];const eA=(t,e,n)=>[["M",t-n-1,e-2.5],["L",t,e-2.5],["L",t,e+2.5],["L",t+n+1,e+2.5]];eA.style=["stroke","lineWidth"];const nA=(t,e,n)=>[["M",t-n-1,e+2.5],["L",t,e+2.5],["L",t,e-2.5],["L",t+n+1,e-2.5]];nA.style=["stroke","lineWidth"];const rA=(t,e,n)=>[["M",t-(n+1),e+2.5],["L",t-n/2,e+2.5],["L",t-n/2,e-2.5],["L",t+n/2,e-2.5],["L",t+n/2,e+2.5],["L",t+n+1,e+2.5]];rA.style=["stroke","lineWidth"];const iA=(t,e,n)=>[["M",t-5,e+2.5],["L",t-5,e],["L",t,e],["L",t,e-3],["L",t,e+3],["L",t+6.5,e+3]];iA.style=["stroke","lineWidth"];const Hf=new Map([["bowtie",F_],["cross",Uk],["dash",Jk],["diamond",N_],["dot",B_],["hexagon",j_],["hollowBowtie",Vk],["hollowDiamond",$k],["hollowHexagon",Hk],["hollowPoint",zk],["hollowSquare",Gk],["hollowTriangle",Zk],["hollowTriangleDown",Yk],["hv",eA],["hvh",rA],["hyphen",Qk],["line",Xk],["plus",Kk],["point",R_],["rect",Wk],["smooth",tA],["square",Zy],["tick",qk],["triangleDown",D_],["triangle",I_],["vh",nA],["vhv",iA]]);function Cj(t,e){var{d:n,fill:r,lineWidth:i,path:a,stroke:o,color:s}=e,c=Pj(e,["d","fill","lineWidth","path","stroke","color"]);const l=Hf.get(t)||Hf.get("point");return(...u)=>new Qi({style:Object.assign(Object.assign({},c),{d:l(...u),stroke:l.style.includes("stroke")?s||o:"",fill:l.style.includes("fill")?s||r:"",lineWidth:l.style.includes("lineWidth")?i||i||2:0})})}function Lj(t,e){Hf.set(t,e)}function jat(t){Hf.delete(t)}const aA={};function oA(t,e){t.startsWith("symbol.")?Lj(t.split(".").pop(),e):Object.assign(aA,{[t]:e})}function Rj(t,e){var n=e.cx,r=n===void 0?0:n,i=e.cy,a=i===void 0?0:i,o=e.r;t.arc(r,a,o,0,Math.PI*2,!1)}function Nj(t,e){var n=e.cx,r=n===void 0?0:n,i=e.cy,a=i===void 0?0:i,o=e.rx,s=e.ry;if(t.ellipse)t.ellipse(r,a,o,s,0,0,Math.PI*2,!1);else{var c=o>s?o:s,l=o>s?1:o/s,u=o>s?s/o:1;t.save(),t.scale(l,u),t.arc(r,a,c,0,Math.PI*2)}}function Ij(t,e){var n=e.x1,r=e.y1,i=e.x2,a=e.y2,o=e.markerStart,s=e.markerEnd,c=e.markerStartOffset,l=e.markerEndOffset,u=0,f=0,d=0,h=0,v=0,g,y;o&&xn(o)&&c&&(g=i-n,y=a-r,v=Math.atan2(y,g),u=Math.cos(v)*(c||0),f=Math.sin(v)*(c||0)),s&&xn(s)&&l&&(g=n-i,y=r-a,v=Math.atan2(y,g),d=Math.cos(v)*(l||0),h=Math.sin(v)*(l||0)),t.moveTo(n+u,r+f),t.lineTo(i+d,a+h)}function Dj(t,e){var n=e.markerStart,r=e.markerEnd,i=e.markerStartOffset,a=e.markerEndOffset,o=e.d,s=o.absolutePath,c=o.segments,l=0,u=0,f=0,d=0,h=0,v,g;if(n&&xn(n)&&i){var y=n.parentNode.getStartTangent(),b=(0,Te.Z)(y,2),x=b[0],_=b[1];v=x[0]-_[0],g=x[1]-_[1],h=Math.atan2(g,v),l=Math.cos(h)*(i||0),u=Math.sin(h)*(i||0)}if(r&&xn(r)&&a){var w=r.parentNode.getEndTangent(),O=(0,Te.Z)(w,2),E=O[0],M=O[1];v=E[0]-M[0],g=E[1]-M[1],h=Math.atan2(g,v),f=Math.cos(h)*(a||0),d=Math.sin(h)*(a||0)}for(var k=0;k<s.length;k++){var A=s[k],P=A[0],C=s[k+1],N=k===0&&(l!==0||u!==0),L=(k===s.length-1||C&&(C[0]==="M"||C[0]==="Z"))&&f!==0&&d!==0,R=N?[l,u]:[0,0],I=(0,Te.Z)(R,2),D=I[0],G=I[1],F=L?[f,d]:[0,0],W=(0,Te.Z)(F,2),X=W[0],Q=W[1];switch(P){case"M":t.moveTo(A[1]+D,A[2]+G);break;case"L":t.lineTo(A[1]+X,A[2]+Q);break;case"Q":t.quadraticCurveTo(A[1],A[2],A[3]+X,A[4]+Q);break;case"C":t.bezierCurveTo(A[1],A[2],A[3],A[4],A[5]+X,A[6]+Q);break;case"A":{var tt=c[k].arcParams,nt=tt.cx,ht=tt.cy,lt=tt.rx,wt=tt.ry,yt=tt.startAngle,gt=tt.endAngle,Bt=tt.xRotation,Lt=tt.sweepFlag;if(t.ellipse)t.ellipse(nt,ht,lt,wt,Bt,yt,gt,!!(1-Lt));else{var It=lt>wt?lt:wt,jt=lt>wt?1:lt/wt,Qt=lt>wt?wt/lt:1;t.translate(nt,ht),t.rotate(Bt),t.scale(jt,Qt),t.arc(0,0,It,yt,gt,!!(1-Lt)),t.scale(1/jt,1/Qt),t.rotate(-Bt),t.translate(-nt,-ht)}L&&t.lineTo(A[6]+f,A[7]+d);break}case"Z":t.closePath();break}}}function jj(t,e){var n=e.markerStart,r=e.markerEnd,i=e.markerStartOffset,a=e.markerEndOffset,o=e.points.points,s=o.length,c=o[0][0],l=o[0][1],u=o[s-1][0],f=o[s-1][1],d=0,h=0,v=0,g=0,y=0,b,x;n&&xn(n)&&i&&(b=o[1][0]-o[0][0],x=o[1][1]-o[0][1],y=Math.atan2(x,b),d=Math.cos(y)*(i||0),h=Math.sin(y)*(i||0)),r&&xn(r)&&a&&(b=o[s-1][0]-o[0][0],x=o[s-1][1]-o[0][1],y=Math.atan2(x,b),v=Math.cos(y)*(a||0),g=Math.sin(y)*(a||0)),t.moveTo(c+(d||v),l+(h||g));for(var _=1;_<s-1;_++){var w=o[_];t.lineTo(w[0],w[1])}t.lineTo(u,f)}function Fj(t,e){var n=e.markerStart,r=e.markerEnd,i=e.markerStartOffset,a=e.markerEndOffset,o=e.points.points,s=o.length,c=o[0][0],l=o[0][1],u=o[s-1][0],f=o[s-1][1],d=0,h=0,v=0,g=0,y=0,b,x;n&&xn(n)&&i&&(b=o[1][0]-o[0][0],x=o[1][1]-o[0][1],y=Math.atan2(x,b),d=Math.cos(y)*(i||0),h=Math.sin(y)*(i||0)),r&&xn(r)&&a&&(b=o[s-2][0]-o[s-1][0],x=o[s-2][1]-o[s-1][1],y=Math.atan2(x,b),v=Math.cos(y)*(a||0),g=Math.sin(y)*(a||0)),t.moveTo(c+d,l+h);for(var _=1;_<s-1;_++){var w=o[_];t.lineTo(w[0],w[1])}t.lineTo(u+v,f+g)}function Bj(t,e){var n=e.x,r=n===void 0?0:n,i=e.y,a=i===void 0?0:i,o=e.radius,s=e.width,c=e.height,l=s,u=c,f=o&&o.some(function(O){return O!==0});if(!f)t.rect(r,a,l,u);else{var d=s>0?1:-1,h=c>0?1:-1,v=d+h===0,g=o.map(function(O){return mn(O,0,Math.min(Math.abs(l)/2,Math.abs(u)/2))}),y=(0,Te.Z)(g,4),b=y[0],x=y[1],_=y[2],w=y[3];t.moveTo(d*b+r,a),t.lineTo(l-d*x+r,a),x!==0&&t.arc(l-d*x+r,h*x+a,x,-h*Math.PI/2,d>0?0:Math.PI,v),t.lineTo(l+r,u-h*_+a),_!==0&&t.arc(l-d*_+r,u-h*_+a,_,d>0?0:Math.PI,h>0?Math.PI/2:1.5*Math.PI,v),t.lineTo(d*w+r,u+a),w!==0&&t.arc(d*w+r,u-h*w+a,w,h>0?Math.PI/2:-Math.PI/2,d>0?Math.PI:0,v),t.lineTo(r,h*b+a),b!==0&&t.arc(d*b+r,h*b+a,b,d>0?Math.PI:0,h>0?Math.PI*1.5:Math.PI/2,v)}}var zj=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.name="canvas-path-generator",n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"init",value:function(){var r,i=(r={},(0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)(r,dt.CIRCLE,Rj),dt.ELLIPSE,Nj),dt.RECT,Bj),dt.LINE,Ij),dt.POLYLINE,Fj),dt.POLYGON,jj),dt.PATH,Dj),dt.TEXT,void 0),dt.GROUP,void 0),dt.IMAGE,void 0),(0,Kt.Z)((0,Kt.Z)((0,Kt.Z)(r,dt.HTML,void 0),dt.MESH,void 0),dt.FRAGMENT,void 0));this.context.pathGeneratorFactory=i}},{key:"destroy",value:function(){delete this.context.pathGeneratorFactory}}])}(is);var Wj=me(),Gj=me(),$j=me(),Zj=Wn(),sA=function(){function t(){var e=this;(0,xt.Z)(this,t),this.isHit=function(n,r,i,a){var o=e.context.pointInPathPickerFactory[n.nodeName];if(o){var s=$i(Zj,i),c=er(Gj,Gr($j,r[0],r[1],0),s);if(o(n,new ii(c[0],c[1]),a,e.isPointInPath,e.context,e.runtime))return!0}return!1},this.isPointInPath=function(n,r){var i=e.runtime.offscreenCanvasCreator.getOrCreateContext(e.context.config.offscreenCanvas),a=e.context.pathGeneratorFactory[n.nodeName];return a&&(i.beginPath(),a(i,n.parsedStyle),i.closePath()),i.isPointInPath(r.x,r.y)}}return(0,Ot.Z)(t,[{key:"apply",value:function(n,r){var i,a=this,o=n.renderingService,s=n.renderingContext;this.context=n,this.runtime=r;var c=(i=s.root)===null||i===void 0?void 0:i.ownerDocument;o.hooks.pick.tapPromise(t.tag,function(){var l=(0,oo.Z)((0,Mn.Z)().mark(function u(f){return(0,Mn.Z)().wrap(function(h){for(;;)switch(h.prev=h.next){case 0:return h.abrupt("return",a.pick(c,f));case 1:case"end":return h.stop()}},u)}));return function(u){return l.apply(this,arguments)}}()),o.hooks.pickSync.tap(t.tag,function(l){return a.pick(c,l)})}},{key:"pick",value:function(n,r){var i=r.topmost,a=r.position,o=a.x,s=a.y,c=Gr(Wj,o,s,0),l=n.elementsFromBBox(c[0],c[1],c[0],c[1]),u=[],f=(0,Ys.Z)(l),d;try{for(f.s();!(d=f.n()).done;){var h=d.value,v=h.getWorldTransform(),g=this.isHit(h,c,v,!1);if(g){var y=fy(h);if(y){var b=y.parsedStyle.clipPath,x=this.isHit(b,c,b.getWorldTransform(),!0);if(x){if(i)return r.picked=[h],r;u.push(h)}}else{if(i)return r.picked=[h],r;u.push(h)}}}}catch(_){f.e(_)}finally{f.f()}return r.picked=u,r}}])}();sA.tag="CanvasPicker";function Yj(t,e,n){var r=t.parsedStyle,i=r.cx,a=i===void 0?0:i,o=r.cy,s=o===void 0?0:o,c=r.r,l=r.fill,u=r.stroke,f=r.lineWidth,d=f===void 0?1:f,h=r.increasedLineWidthForHitTesting,v=h===void 0?0:h,g=r.pointerEvents,y=g===void 0?"auto":g,b=(d+v)/2,x=li(a,s,e.x,e.y),_=Js(y,l,u),w=(0,Te.Z)(_,2),O=w[0],E=w[1];return O&&E||n?x<=c+b:O?x<=c:E?x>=c-b&&x<=c+b:!1}function Yy(t,e,n,r){return t/(n*n)+e/(r*r)}function Hj(t,e,n){var r=t.parsedStyle,i=r.cx,a=i===void 0?0:i,o=r.cy,s=o===void 0?0:o,c=r.rx,l=r.ry,u=r.fill,f=r.stroke,d=r.lineWidth,h=d===void 0?1:d,v=r.increasedLineWidthForHitTesting,g=v===void 0?0:v,y=r.pointerEvents,b=y===void 0?"auto":y,x=e.x,_=e.y,w=Js(b,u,f),O=(0,Te.Z)(w,2),E=O[0],M=O[1],k=(h+g)/2,A=(x-a)*(x-a),P=(_-s)*(_-s);return E&&M||n?Yy(A,P,c+k,l+k)<=1:E?Yy(A,P,c,l)<=1:M?Yy(A,P,c-k,l-k)>=1&&Yy(A,P,c+k,l+k)<=1:!1}function lu(t,e,n,r,i,a){return i>=t&&i<=t+n&&a>=e&&a<=e+r}function Vj(t,e,n,r,i,a,o){var s=i/2;return lu(t-s,e-s,n,i,a,o)||lu(t+n-s,e-s,i,r,a,o)||lu(t+s,e+r-s,n,i,a,o)||lu(t-s,e+s,i,r,a,o)}function Hy(t,e,n,r,i,a,o,s){var c=(Math.atan2(s-e,o-t)+Math.PI*2)%(Math.PI*2),l={x:t+n*Math.cos(c),y:e+n*Math.sin(c)};return li(l.x,l.y,o,s)<=a/2}function Jc(t,e,n,r,i,a,o){var s=Math.min(t,n),c=Math.max(t,n),l=Math.min(e,r),u=Math.max(e,r),f=i/2;return a>=s-f&&a<=c+f&&o>=l-f&&o<=u+f?ag(t,e,n,r,a,o)<=i/2:!1}function cA(t,e,n,r,i){var a=t.length;if(a<2)return!1;for(var o=0;o<a-1;o++){var s=t[o][0],c=t[o][1],l=t[o+1][0],u=t[o+1][1];if(Jc(s,c,l,u,e,n,r))return!0}if(i){var f=t[0],d=t[a-1];if(Jc(f[0],f[1],d[0],d[1],e,n,r))return!0}return!1}var Xj=1e-6;function z_(t){return Math.abs(t)<Xj?0:t<0?-1:1}function Uj(t,e,n){return(n[0]-t[0])*(e[1]-t[1])===(e[0]-t[0])*(n[1]-t[1])&&Math.min(t[0],e[0])<=n[0]&&n[0]<=Math.max(t[0],e[0])&&Math.min(t[1],e[1])<=n[1]&&n[1]<=Math.max(t[1],e[1])}function lA(t,e,n){var r=!1,i=t.length;if(i<=2)return!1;for(var a=0;a<i;a++){var o=t[a],s=t[(a+1)%i];if(Uj(o,s,[e,n]))return!0;z_(o[1]-n)>0!=z_(s[1]-n)>0&&z_(e-(n-o[1])*(o[0]-s[0])/(o[1]-s[1])-o[0])<0&&(r=!r)}return r}function uA(t,e,n){for(var r=!1,i=0;i<t.length;i++){var a=t[i];if(r=lA(a,e,n),r)break}return r}function qj(t,e,n){var r=t.parsedStyle,i=r.x1,a=r.y1,o=r.x2,s=r.y2,c=r.lineWidth,l=c===void 0?1:c,u=r.increasedLineWidthForHitTesting,f=u===void 0?0:u,d=r.pointerEvents,h=d===void 0?"auto":d,v=r.fill,g=r.stroke,y=Js(h,v,g),b=(0,Te.Z)(y,2),x=b[1];return!x&&!n||!l?!1:Jc(i,a,o,s,l+f,e.x,e.y)}function Kj(t,e,n,r,i){for(var a=!1,o=e/2,s=0;s<t.length;s++){var c=t[s],l=c.currentPoint,u=c.params,f=c.prePoint,d=c.box;if(!(d&&!lu(d.x-o,d.y-o,d.width+e,d.height+e,n,r)))switch(c.command){case"L":case"Z":if(a=Jc(f[0],f[1],l[0],l[1],e,n,r),a)return!0;break;case"Q":var h=Do(f[0],f[1],u[1],u[2],u[3],u[4],n,r);if(a=h<=e/2,a)return!0;break;case"C":var v=sg(f[0],f[1],u[1],u[2],u[3],u[4],u[5],u[6],n,r,i);if(a=v<=e/2,a)return!0;break;case"A":c.cubicParams||(c.cubicParams=Zs(f[0],f[1],u[1],u[2],u[3],u[4],u[5],u[6],u[7],void 0));for(var g=c.cubicParams,y=f,b=0;b<g.length;b+=6){var x=sg(y[0],y[1],g[b],g[b+1],g[b+2],g[b+3],g[b+4],g[b+5],n,r,i);if(y=[g[b+4],g[b+5]],a=x<=e/2,a)return!0}break}}return a}function Qj(t,e,n,r,i,a){var o=t.parsedStyle,s=o.lineWidth,c=s===void 0?1:s,l=o.increasedLineWidthForHitTesting,u=l===void 0?0:l,f=o.stroke,d=o.fill,h=o.d,v=o.pointerEvents,g=v===void 0?"auto":v,y=h.segments,b=h.hasArc,x=h.polylines,_=h.polygons,w=Js(g,(_==null?void 0:_.length)&&d,f),O=(0,Te.Z)(w,2),E=O[0],M=O[1],k=Wa(t),A=!1;return E||n?(b?A=r(t,e):A=uA(_,e.x,e.y)||uA(x,e.x,e.y),A):((M||n)&&(A=Kj(y,c+u,e.x,e.y,k)),A)}function Jj(t,e,n){var r=t.parsedStyle,i=r.stroke,a=r.fill,o=r.lineWidth,s=o===void 0?1:o,c=r.increasedLineWidthForHitTesting,l=c===void 0?0:c,u=r.points,f=r.pointerEvents,d=f===void 0?"auto":f,h=Js(d,a,i),v=(0,Te.Z)(h,2),g=v[0],y=v[1],b=!1;return(y||n)&&(b=cA(u.points,s+l,e.x,e.y,!0)),!b&&(g||n)&&(b=lA(u.points,e.x,e.y)),b}function tF(t,e,n){var r=t.parsedStyle,i=r.lineWidth,a=i===void 0?1:i,o=r.increasedLineWidthForHitTesting,s=o===void 0?0:o,c=r.points,l=r.pointerEvents,u=l===void 0?"auto":l,f=r.fill,d=r.stroke,h=Js(u,f,d),v=(0,Te.Z)(h,2),g=v[1];return!g&&!n||!a?!1:cA(c.points,a+s,e.x,e.y,!1)}function eF(t,e,n,r,i){var a=t.parsedStyle,o=a.radius,s=a.fill,c=a.stroke,l=a.lineWidth,u=l===void 0?1:l,f=a.increasedLineWidthForHitTesting,d=f===void 0?0:f,h=a.x,v=h===void 0?0:h,g=a.y,y=g===void 0?0:g,b=a.width,x=a.height,_=a.pointerEvents,w=_===void 0?"auto":_,O=Js(w,s,c),E=(0,Te.Z)(O,2),M=E[0],k=E[1],A=o&&o.some(function(L){return L!==0}),P=u+d;if(A){var N=!1;return(k||n)&&(N=nF(v,y,b,x,o.map(function(L){return mn(L,0,Math.min(Math.abs(b)/2,Math.abs(x)/2))}),P,e.x,e.y)),!N&&(M||n)&&(N=r(t,e)),N}else{var C=P/2;if(M&&k||n)return lu(v-C,y-C,b+C,x+C,e.x,e.y);if(M)return lu(v,y,b,x,e.x,e.y);if(k)return Vj(v,y,b,x,P,e.x,e.y)}return!1}function nF(t,e,n,r,i,a,o,s){var c=(0,Te.Z)(i,4),l=c[0],u=c[1],f=c[2],d=c[3];return Jc(t+l,e,t+n-u,e,a,o,s)||Jc(t+n,e+u,t+n,e+r-f,a,o,s)||Jc(t+n-f,e+r,t+d,e+r,a,o,s)||Jc(t,e+r-d,t,e+l,a,o,s)||Hy(t+n-u,e+u,u,1.5*Math.PI,2*Math.PI,a,o,s)||Hy(t+n-f,e+r-f,f,0,.5*Math.PI,a,o,s)||Hy(t+d,e+r-d,d,.5*Math.PI,Math.PI,a,o,s)||Hy(t+l,e+l,l,Math.PI,1.5*Math.PI,a,o,s)}function rF(t,e,n,r,i,a){var o=t.parsedStyle,s=o.pointerEvents,c=s===void 0?"auto":s,l=o.x,u=l===void 0?0:l,f=o.y,d=f===void 0?0:f,h=o.width,v=o.height;if(c==="non-transparent-pixel"){var g=i.config.offscreenCanvas,y=a.offscreenCanvasCreator.getOrCreateCanvas(g),b=a.offscreenCanvasCreator.getOrCreateContext(g,{willReadFrequently:!0});y.width=h,y.height=v,i.defaultStyleRendererFactory[dt.IMAGE].render(b,(0,Ee.Z)((0,Ee.Z)({},t.parsedStyle),{},{x:0,y:0}),t,void 0,void 0,void 0);var x=b.getImageData(e.x-u,e.y-d,1,1).data;return x.every(function(_){return _!==0})}return!0}function iF(t,e,n,r){var i=t.getGeometryBounds();return e.x>=i.min[0]&&e.y>=i.min[1]&&e.x<=i.max[0]&&e.y<=i.max[1]}var aF=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.name="canvas-picker",n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"init",value:function(){var r,i=(r={},(0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)(r,dt.CIRCLE,Yj),dt.ELLIPSE,Hj),dt.RECT,eF),dt.LINE,qj),dt.POLYLINE,tF),dt.POLYGON,Jj),dt.PATH,Qj),dt.TEXT,iF),dt.GROUP,null),dt.IMAGE,rF),(0,Kt.Z)((0,Kt.Z)(r,dt.HTML,null),dt.MESH,null));this.context.pointInPathPickerFactory=i,this.addRenderingPlugin(new sA)}},{key:"destroy",value:function(){delete this.context.pointInPathPickerFactory,this.removeAllRenderingPlugins()}}])}(is);function us(t,e){if(!{}.hasOwnProperty.call(t,e))throw new TypeError("attempted to use private field on non-instance");return t}var oF=0;function sF(t){return"__private_"+oF+++"_"+t}var cF=function(){function t(){(0,xt.Z)(this,t),this.cacheStore=new Map}return(0,Ot.Z)(t,[{key:"onRefAdded",value:function(n){}},{key:"has",value:function(n){return this.cacheStore.has(n)}},{key:"put",value:function(n,r,i){return this.cacheStore.has(n)?!1:(this.cacheStore.set(n,{value:r,counter:new Set([i])}),this.onRefAdded(i),!0)}},{key:"get",value:function(n,r){var i=this.cacheStore.get(n);return i?(i.counter.has(r)||(i.counter.add(r),this.onRefAdded(r)),i.value):null}},{key:"update",value:function(n,r,i){var a=this.cacheStore.get(n);return a?(a.value=(0,Ee.Z)((0,Ee.Z)({},a.value),r),a.counter.has(i)||(a.counter.add(i),this.onRefAdded(i)),!0):!1}},{key:"release",value:function(n,r){var i=this.cacheStore.get(n);return i?(i.counter.delete(r),i.counter.size<=0&&this.cacheStore.delete(n),!0):!1}},{key:"releaseRef",value:function(n){var r=this;Array.from(this.cacheStore.keys()).forEach(function(i){r.release(i,n)})}},{key:"getSize",value:function(){return this.cacheStore.size}},{key:"clear",value:function(){this.cacheStore.clear()}}])}(),W_=[],G_=[],$_=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,null,[{key:"stop",value:function(){var n=arguments.length>0&&arguments[0]!==void 0?arguments[0]:t.api;t.rafId&&(n.cancelAnimationFrame(t.rafId),t.rafId=null)}},{key:"executeTask",value:function(){var n=arguments.length>0&&arguments[0]!==void 0?arguments[0]:t.api;W_.length<=0&&G_.length<=0||(G_.forEach(function(r){return r()}),G_=W_.splice(0,t.TASK_NUM_PER_FRAME),t.rafId=n.requestAnimationFrame(function(){t.executeTask(n)}))}},{key:"sliceImage",value:function(n,r,i,a){for(var o=arguments.length>4&&arguments[4]!==void 0?arguments[4]:0,s=arguments.length>5&&arguments[5]!==void 0?arguments[5]:t.api,c=n.naturalWidth||n.width,l=n.naturalHeight||n.height,u=r-o,f=i-o,d=Math.ceil(c/u),h=Math.ceil(l/f),v={tileSize:[r,i],gridSize:[h,d],tiles:Array(h).fill(null).map(function(){return Array(d).fill(null)})},g=function(x){for(var _=function(E){W_.push(function(){var M=E*u,k=x*f,A=[Math.min(r,c-M),Math.min(i,l-k)],P=A[0],C=A[1],N=s.createCanvas();N.width=r,N.height=i;var L=N.getContext("2d");L.drawImage(n,M,k,P,C,0,0,P,C),v.tiles[x][E]={x:M,y:k,tileX:E,tileY:x,data:N},a()})},w=0;w<d;w++)_(w)},y=0;y<h;y++)g(y);return t.stop(),t.executeTask(),v}}])}();$_.TASK_NUM_PER_FRAME=10;var $a=new cF;$a.onRefAdded=function(e){var n=this;e.addEventListener($e.DESTROY,function(){n.releaseRef(e)},{once:!0})};var Z_=function(){function t(e,n){(0,xt.Z)(this,t),this.gradientCache={},this.patternCache={},this.context=e,this.runtime=n}return(0,Ot.Z)(t,[{key:"getImageSync",value:function(n,r,i){var a=ir(n)?n:n.src;if($a.has(a)){var o=$a.get(a,r);if(o.img.complete)return i==null||i(o),o}return this.getOrCreateImage(n,r).then(function(s){i==null||i(s)}).catch(function(s){console.error(s)}),null}},{key:"getOrCreateImage",value:function(n,r){var i=this,a=ir(n)?n:n.src;if(!ir(n)&&!$a.has(a)){var o={img:n,size:[n.naturalWidth||n.width,n.naturalHeight||n.height],tileSize:Vy(n)};$a.put(a,o,r)}if($a.has(a)){var s=$a.get(a,r);return s.img.complete?Promise.resolve(s):new Promise(function(c,l){s.img.addEventListener("load",function(){s.size=[s.img.naturalWidth||s.img.width,s.img.naturalHeight||s.img.height],s.tileSize=Vy(s.img),c(s)}),s.img.addEventListener("error",function(u){l(u)})})}return new Promise(function(c,l){var u=i.context.config.createImage();if(u){var f={img:u,size:[0,0],tileSize:Vy(u)};$a.put(a,f,r),u.onload=function(){f.size=[u.naturalWidth||u.width,u.naturalHeight||u.height],f.tileSize=Vy(f.img),c(f)},u.onerror=function(d){l(d)},u.crossOrigin="Anonymous",u.src=a}})}},{key:"createDownSampledImage",value:function(){var e=(0,oo.Z)((0,Mn.Z)().mark(function r(i,a){var o,s,c,l,u,f,d,h,v,g,y,b,x,_;return(0,Mn.Z)().wrap(function(O){for(;;)switch(O.prev=O.next){case 0:return O.next=2,this.getOrCreateImage(i,a);case 2:if(o=O.sent,typeof o.downSamplingRate=="undefined"){O.next=5;break}return O.abrupt("return",o);case 5:if(s=this.context.config.enableLargeImageOptimization,c=typeof s=="boolean"?{}:s,l=c.maxDownSampledImageSize,u=l===void 0?2048:l,f=c.downSamplingRateThreshold,d=f===void 0?.5:f,h=this.runtime.globalThis.createImageBitmap,v=(0,Te.Z)(o.size,2),g=v[0],y=v[1],b=o.img,x=Math.min((u+u)/(g+y),Math.max(.01,Math.min(d,.5))),_=(0,Ee.Z)((0,Ee.Z)({},o),{},{downSamplingRate:x}),$a.update(o.img.src,_,a),!h){O.next=25;break}return O.prev=14,O.next=17,h(o.img,{resizeWidth:g*x,resizeHeight:y*x});case 17:b=O.sent,O.next=23;break;case 20:O.prev=20,O.t0=O.catch(14),x=1;case 23:O.next=26;break;case 25:x=1;case 26:return _=(0,Ee.Z)((0,Ee.Z)({},this.getImageSync(i,a)),{},{downSampled:b,downSamplingRate:x}),$a.update(o.img.src,_,a),O.abrupt("return",_);case 29:case"end":return O.stop()}},r,this,[[14,20]])}));function n(r,i){return e.apply(this,arguments)}return n}()},{key:"createImageTiles",value:function(){var e=(0,oo.Z)((0,Mn.Z)().mark(function r(i,a,o,s){var c,l,u,f,d;return(0,Mn.Z)().wrap(function(v){for(;;)switch(v.prev=v.next){case 0:return v.next=2,this.getOrCreateImage(i,s);case 2:return c=v.sent,l=s.ownerDocument.defaultView,u=l.requestAnimationFrame,f=l.cancelAnimationFrame,$_.api={requestAnimationFrame:u,cancelAnimationFrame:f,createCanvas:function(){return gp.createCanvas()}},d=(0,Ee.Z)((0,Ee.Z)({},c),$_.sliceImage(c.img,c.tileSize[0],c.tileSize[0],o)),$a.update(c.img.src,d,s),v.abrupt("return",d);case 8:case"end":return v.stop()}},r,this)}));function n(r,i,a,o){return e.apply(this,arguments)}return n}()},{key:"releaseImage",value:function(n,r){$a.release(ir(n)?n:n.src,r)}},{key:"releaseImageRef",value:function(n){$a.releaseRef(n)}},{key:"getOrCreatePatternSync",value:function(n,r,i,a,o,s,c){var l=this.generatePatternKey(r);if(l&&this.patternCache[l])return this.patternCache[l];var u=r.image,f=r.repetition,d=r.transform,h,v=!1;if(ir(u)){var g=this.getImageSync(u,n,c);h=g==null?void 0:g.img}else a?(h=a,v=!0):h=u;var y=h&&i.createPattern(h,f);if(y){var b;d?b=gy(ty(d),new or({})):b=lr(Wn()),v&&Ud(b,b,[1/o,1/o,1]),y.setTransform({a:b[0],b:b[1],c:b[4],d:b[5],e:b[12]+s[0],f:b[13]+s[1]})}return l&&y&&(this.patternCache[l]=y),y}},{key:"getOrCreateGradient",value:function(n,r){var i=this.generateGradientKey(n),a=n.type,o=n.steps,s=n.min,c=n.width,l=n.height,u=n.angle,f=n.cx,d=n.cy,h=n.size;if(this.gradientCache[i])return this.gradientCache[i];var v=null;if(a===Ba.LinearGradient){var g=jg(s,c,l,u),y=g.x1,b=g.y1,x=g.x2,_=g.y2;v=r.createLinearGradient(y,b,x,_)}else if(a===Ba.RadialGradient){var w=Qx(s,c,l,f,d,h),O=w.x,E=w.y,M=w.r;v=r.createRadialGradient(O,E,0,O,E,M)}return v&&(o.forEach(function(k){var A=k.offset,P=k.color;if(A.unit===Zt.kPercentage){var C;(C=v)===null||C===void 0||C.addColorStop(A.value/100,P.toString())}}),this.gradientCache[i]=v),this.gradientCache[i]}},{key:"generateGradientKey",value:function(n){var r=n.type,i=n.min,a=n.width,o=n.height,s=n.steps,c=n.angle,l=n.cx,u=n.cy,f=n.size;return"gradient-".concat(r,"-").concat((c==null?void 0:c.toString())||0,"-").concat((l==null?void 0:l.toString())||0,"-").concat((u==null?void 0:u.toString())||0,"-").concat((f==null?void 0:f.toString())||0,"-").concat(i[0],"-").concat(i[1],"-").concat(a,"-").concat(o,"-").concat(s.map(function(d){var h=d.offset,v=d.color;return"".concat(h).concat(v)}).join("-"))}},{key:"generatePatternKey",value:function(n){var r=n.image,i=n.repetition;if(ir(r))return"pattern-".concat(r,"-").concat(i);if(r.nodeName==="rect")return"pattern-".concat(r.entity,"-").concat(i)}}])}();Z_.isSupportTile=!!gp.createCanvas();function Vy(t){if(!t.complete)return[0,0];var e=t.naturalWidth||t.width,n=t.naturalHeight||t.height,r=256;return[256,512].forEach(function(i){var a=Math.ceil(n/i),o=Math.ceil(e/i);a*o<1e3&&(r=i)}),[r,r]}var fA=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"apply",value:function(n){var r=n.renderingService,i=n.renderingContext,a=n.imagePool,o=i.root.ownerDocument.defaultView,s=function(f,d,h){var v=f.parsedStyle,g=v.width,y=v.height;g&&!y?f.setAttribute("height",h/d*g):!g&&y&&f.setAttribute("width",d/h*y)},c=function(f){var d=f.target,h=d.nodeName,v=d.attributes;if(h===dt.IMAGE){var g=v.src,y=v.keepAspectRatio;a.getImageSync(g,d,function(b){var x=b.img,_=x.width,w=x.height;y&&s(d,_,w),d.renderable.dirty=!0,r.dirtify()})}},l=function(f){var d=f.target,h=f.attrName,v=f.prevValue,g=f.newValue;d.nodeName!==dt.IMAGE||h!=="src"||(v!==g&&a.releaseImage(v,d),ir(g)&&a.getOrCreateImage(g,d).then(function(y){var b=y.img,x=b.width,_=b.height;d.attributes.keepAspectRatio&&s(d,x,_),d.renderable.dirty=!0,r.dirtify()}).catch(function(){}))};r.hooks.init.tap(t.tag,function(){o.addEventListener($e.MOUNTED,c),o.addEventListener($e.ATTR_MODIFIED,l)}),r.hooks.destroy.tap(t.tag,function(){o.removeEventListener($e.MOUNTED,c),o.removeEventListener($e.ATTR_MODIFIED,l)})}}])}();fA.tag="LoadImage";var lF=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.name="image-loader",n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"init",value:function(r){this.context.imagePool=new Z_(this.context,r),this.addRenderingPlugin(new fA)}},{key:"destroy",value:function(){this.removeAllRenderingPlugins()}}])}(is);var Vr=sF("renderState"),dA=function(){function t(e){(0,xt.Z)(this,t),this.removedRBushNodeAABBs=[],this.renderQueue=[],Object.defineProperty(this,Vr,{writable:!0,value:{restoreStack:[],prevObject:null,currentContext:new Map}}),this.clearFullScreenLastFrame=!1,this.clearFullScreen=!1,this.vpMatrix=Wn(),this.dprMatrix=Wn(),this.tmpMat4=Wn(),this.vec3a=me(),this.vec3b=me(),this.vec3c=me(),this.vec3d=me(),this.canvasRendererPluginOptions=e}return(0,Ot.Z)(t,[{key:"apply",value:function(n,r){var i=this;this.context=n;var a=this.context,o=a.config,s=a.camera,c=a.renderingService,l=a.renderingContext,u=a.rBushRoot,f=a.pathGeneratorFactory,d=o.renderer.getConfig().enableRenderingOptimization;o.renderer.getConfig().enableDirtyCheck=!1,o.renderer.getConfig().enableDirtyRectangleRendering=!1,this.rBush=u,this.pathGeneratorFactory=f;var h=n.contextService,v=l.root.ownerDocument.defaultView,g=function(_){var w=_.target,O=w.rBushNode;O.aabb&&i.removedRBushNodeAABBs.push(O.aabb)},y=function(_){var w=_.target,O=w.rBushNode;O.aabb&&i.removedRBushNodeAABBs.push(O.aabb)};c.hooks.init.tap(t.tag,function(){v.addEventListener($e.UNMOUNTED,g),v.addEventListener($e.CULLED,y);var x=h.getDPR(),_=o.width,w=o.height,O=h.getContext();i.clearRect(O,0,0,_*x,w*x,o.background)}),c.hooks.destroy.tap(t.tag,function(){v.removeEventListener($e.UNMOUNTED,g),v.removeEventListener($e.CULLED,y),i.renderQueue=[],i.removedRBushNodeAABBs=[],us(i,Vr)[Vr]={restoreStack:[],prevObject:null,currentContext:null}}),c.hooks.beginFrame.tap(t.tag,function(){var x,_=h.getContext(),w=h.getDPR(),O=o.width,E=o.height,M=i.canvasRendererPluginOptions,k=M.dirtyObjectNumThreshold,A=M.dirtyObjectRatioThreshold,P=c.getStats(),C=P.total,N=P.rendered,L=N/C;i.clearFullScreen=i.clearFullScreenLastFrame||!((x=v.context.renderingPlugins[1])!==null&&x!==void 0&&x.isFirstTimeRenderingFinished)||c.disableDirtyRectangleRendering()||N>k&&L>A,_&&(typeof _.resetTransform=="function"?_.resetTransform():_.setTransform(1,0,0,1,0,0),i.clearFullScreen&&i.clearRect(_,0,0,O*w,E*w,o.background))});var b=function(_,w){for(var O=[_];O.length>0;){var E=O.pop();E.isVisible()&&!E.isCulled()&&(d?i.renderDisplayObjectOptimized(E,w,i.context,us(i,Vr)[Vr],r):i.renderDisplayObject(E,w,i.context,us(i,Vr)[Vr],r));for(var M=E.sortable.sorted||E.childNodes,k=M.length-1;k>=0;k--)O.push(M[k])}};c.hooks.endFrame.tap(t.tag,function(){if(l.root.childNodes.length===0){i.clearFullScreenLastFrame=!0;return}d=o.renderer.getConfig().enableRenderingOptimization,us(i,Vr)[Vr]={restoreStack:[],prevObject:null,currentContext:us(i,Vr)[Vr].currentContext},us(i,Vr)[Vr].currentContext.clear(),i.clearFullScreenLastFrame=!1;var x=h.getContext(),_=h.getDPR();if(Is(i.dprMatrix,[_,_,1]),Gn(i.vpMatrix,i.dprMatrix,s.getOrthoMatrix()),i.clearFullScreen)d?(x.save(),b(l.root,x),x.restore()):b(l.root,x),i.removedRBushNodeAABBs=[];else{var w=i.safeMergeAABB.apply(i,[i.mergeDirtyAABBs(i.renderQueue)].concat((0,ln.Z)(i.removedRBushNodeAABBs.map(function(lt){var wt=lt.minX,yt=lt.minY,gt=lt.maxX,Bt=lt.maxY,Lt=new xr;return Lt.setMinMax([wt,yt,0],[gt,Bt,0]),Lt}))));if(i.removedRBushNodeAABBs=[],xr.isEmpty(w)){i.renderQueue=[];return}var O=i.convertAABB2Rect(w),E=O.x,M=O.y,k=O.width,A=O.height,P=er(i.vec3a,[E,M,0],i.vpMatrix),C=er(i.vec3b,[E+k,M,0],i.vpMatrix),N=er(i.vec3c,[E,M+A,0],i.vpMatrix),L=er(i.vec3d,[E+k,M+A,0],i.vpMatrix),R=Math.min(P[0],C[0],L[0],N[0]),I=Math.min(P[1],C[1],L[1],N[1]),D=Math.max(P[0],C[0],L[0],N[0]),G=Math.max(P[1],C[1],L[1],N[1]),F=Math.floor(R),W=Math.floor(I),X=Math.ceil(D-R),Q=Math.ceil(G-I);x.save(),i.clearRect(x,F,W,X,Q,o.background),x.beginPath(),x.rect(F,W,X,Q),x.clip(),x.setTransform(i.vpMatrix[0],i.vpMatrix[1],i.vpMatrix[4],i.vpMatrix[5],i.vpMatrix[12],i.vpMatrix[13]);var tt=o.renderer.getConfig(),nt=tt.enableDirtyRectangleRenderingDebug;nt&&v.dispatchEvent(new Nn(vo.DIRTY_RECTANGLE,{dirtyRect:{x:F,y:W,width:X,height:Q}}));var ht=i.searchDirtyObjects(w);ht.sort(function(lt,wt){return lt.sortable.renderOrder-wt.sortable.renderOrder}).forEach(function(lt){lt&&lt.isVisible()&&!lt.isCulled()&&i.renderDisplayObject(lt,x,i.context,us(i,Vr)[Vr],r)}),x.restore(),i.renderQueue.forEach(function(lt){i.saveDirtyAABB(lt)}),i.renderQueue=[]}us(i,Vr)[Vr].restoreStack.forEach(function(){x.restore()}),us(i,Vr)[Vr].restoreStack=[]}),c.hooks.render.tap(t.tag,function(x){i.clearFullScreen||i.renderQueue.push(x)})}},{key:"clearRect",value:function(n,r,i,a,o,s){n.clearRect(r,i,a,o),s&&(n.fillStyle=s,n.fillRect(r,i,a,o))}},{key:"renderDisplayObjectOptimized",value:function(n,r,i,a,o){var s=n.nodeName,c=!1,l=!1,u=this.context.styleRendererFactory[s],f=this.pathGeneratorFactory[s],d=n.parsedStyle.clipPath;if(d){c=!a.prevObject||!ki(d.getWorldTransform(),a.prevObject.getWorldTransform()),c&&(this.applyWorldTransform(r,d),a.prevObject=null);var h=this.pathGeneratorFactory[d.nodeName];h&&(r.save(),l=!0,r.beginPath(),h(r,d.parsedStyle),r.closePath(),r.clip())}if(u){c=!a.prevObject||!ki(n.getWorldTransform(),a.prevObject.getWorldTransform()),c&&this.applyWorldTransform(r,n);var v=!a.prevObject;if(!v){var g=a.prevObject.nodeName;s===dt.TEXT?v=g!==dt.TEXT:s===dt.IMAGE?v=g!==dt.IMAGE:v=g===dt.TEXT||g===dt.IMAGE}u.applyStyleToContext(r,n,v,a),a.prevObject=n}f&&(r.beginPath(),f(r,n.parsedStyle),s!==dt.LINE&&s!==dt.PATH&&s!==dt.POLYLINE&&r.closePath()),u&&u.drawToContext(r,n,us(this,Vr)[Vr],this,o),l&&r.restore(),n.renderable.dirty=!1}},{key:"renderDisplayObject",value:function(n,r,i,a,o){var s=n.nodeName,c=a.restoreStack[a.restoreStack.length-1];c&&!(n.compareDocumentPosition(c)&fr.DOCUMENT_POSITION_CONTAINS)&&(r.restore(),a.restoreStack.pop());var l=this.context.styleRendererFactory[s],u=this.pathGeneratorFactory[s],f=n.parsedStyle.clipPath;if(f){this.applyWorldTransform(r,f);var d=this.pathGeneratorFactory[f.nodeName];d&&(r.save(),a.restoreStack.push(n),r.beginPath(),d(r,f.parsedStyle),r.closePath(),r.clip())}l&&(this.applyWorldTransform(r,n),r.save(),this.applyAttributesToContext(r,n)),u&&(r.beginPath(),u(r,n.parsedStyle),s!==dt.LINE&&s!==dt.PATH&&s!==dt.POLYLINE&&r.closePath()),l&&(l.render(r,n.parsedStyle,n,i,this,o),r.restore()),n.renderable.dirty=!1}},{key:"applyAttributesToContext",value:function(n,r){var i=r.parsedStyle,a=i.stroke,o=i.fill,s=i.opacity,c=i.lineDash,l=i.lineDashOffset;c&&n.setLineDash(c),ge(l)||(n.lineDashOffset=l),ge(s)||(n.globalAlpha*=s),!ge(a)&&!Array.isArray(a)&&!a.isNone&&(n.strokeStyle=r.attributes.stroke),!ge(o)&&!Array.isArray(o)&&!o.isNone&&(n.fillStyle=r.attributes.fill)}},{key:"convertAABB2Rect",value:function(n){var r=n.getMin(),i=n.getMax(),a=Math.floor(r[0]),o=Math.floor(r[1]),s=Math.ceil(i[0]),c=Math.ceil(i[1]),l=s-a,u=c-o;return{x:a,y:o,width:l,height:u}}},{key:"mergeDirtyAABBs",value:function(n){var r=new xr;return n.forEach(function(i){var a=i.getRenderBounds();r.add(a);var o=i.renderable.dirtyRenderBounds;o&&r.add(o)}),r}},{key:"searchDirtyObjects",value:function(n){var r=n.getMin(),i=(0,Te.Z)(r,2),a=i[0],o=i[1],s=n.getMax(),c=(0,Te.Z)(s,2),l=c[0],u=c[1],f=this.rBush.search({minX:a,minY:o,maxX:l,maxY:u});return f.map(function(d){var h=d.displayObject;return h})}},{key:"saveDirtyAABB",value:function(n){var r=n.renderable;r.dirtyRenderBounds||(r.dirtyRenderBounds=new xr);var i=n.getRenderBounds();i&&r.dirtyRenderBounds.update(i.center,i.halfExtents)}},{key:"applyWorldTransform",value:function(n,r,i){i?(Tc(this.tmpMat4,r.getLocalTransform()),Gn(this.tmpMat4,i,this.tmpMat4),Gn(this.tmpMat4,this.vpMatrix,this.tmpMat4)):(Tc(this.tmpMat4,r.getWorldTransform()),Gn(this.tmpMat4,this.vpMatrix,this.tmpMat4)),n.setTransform(this.tmpMat4[0],this.tmpMat4[1],this.tmpMat4[4],this.tmpMat4[5],this.tmpMat4[12],this.tmpMat4[13])}},{key:"safeMergeAABB",value:function(){for(var n=new xr,r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return i.forEach(function(o){n.add(o)}),n}}])}();dA.tag="CanvasRenderer";function Xy(t,e,n,r,i,a,o){var s,c;if(t.image.nodeName==="rect"){var l=t.image.parsedStyle,u=l.width,f=l.height;c=r.contextService.getDPR();var d=r.config.offscreenCanvas;s=a.offscreenCanvasCreator.getOrCreateCanvas(d),s.width=u*c,s.height=f*c;var h=a.offscreenCanvasCreator.getOrCreateContext(d),v={restoreStack:[],prevObject:null,currentContext:new Map};t.image.forEach(function(y){i.renderDisplayObject(y,h,r,v,a)}),v.restoreStack.forEach(function(){h.restore()})}var g=o.getOrCreatePatternSync(e,t,n,s,c,e.getGeometryBounds().min,function(){e.renderable.dirty=!0,r.renderingService.dirtify()});return g}function Uy(t,e,n,r){var i;if(t.type===Ba.LinearGradient||t.type===Ba.RadialGradient){var a=e.getGeometryBounds(),o=a&&a.halfExtents[0]*2||1,s=a&&a.halfExtents[1]*2||1,c=a&&a.min||[0,0];i=r.getOrCreateGradient((0,Ee.Z)((0,Ee.Z)({type:t.type},t.value),{},{min:c,width:o,height:s}),n)}return i}var qy=["shadowBlur","shadowOffsetX","shadowOffsetY"],hA=["lineCap","lineJoin","miterLimit"],ai={globalAlpha:1,shadowBlur:0,shadowOffsetX:0,shadowOffsetY:0,shadowColor:"#000",filter:"none",globalCompositeOperation:"source-over",strokeStyle:"#000",strokeOpacity:1,lineWidth:1,lineDash:[],lineDashOffset:0,lineCap:"butt",lineJoin:"miter",miterLimit:10,fillStyle:"#000",fillOpacity:1},pA={};function Er(t,e,n,r){var i=r.has(e)?r.get(e):ai[e];return i!==n&&(e==="lineDash"?t.setLineDash(n):t[e]=n,r.set(e,n)),i}var uF=function(){function t(e){(0,xt.Z)(this,t),this.imagePool=e}return(0,Ot.Z)(t,[{key:"applyAttributesToContext",value:function(n,r){}},{key:"render",value:function(n,r,i,a,o,s){}},{key:"applyCommonStyleToContext",value:function(n,r,i,a){var o=i?pA:a.prevObject.parsedStyle,s=r.parsedStyle;(i||s.opacity!==o.opacity)&&Er(n,"globalAlpha",ge(s.opacity)?ai.globalAlpha:s.opacity,a.currentContext),(i||s.blend!==o.blend)&&Er(n,"globalCompositeOperation",ge(s.blend)?ai.globalCompositeOperation:s.blend,a.currentContext)}},{key:"applyStrokeFillStyleToContext",value:function(n,r,i,a){var o=i?pA:a.prevObject.parsedStyle,s=r.parsedStyle,c=s.lineWidth,l=c===void 0?ai.lineWidth:c,u=s.fill&&!s.fill.isNone,f=s.stroke&&!s.stroke.isNone&&l>0;if(f){if(i||r.attributes.stroke!==a.prevObject.attributes.stroke){var d=!ge(s.stroke)&&!Array.isArray(s.stroke)&&!s.stroke.isNone?r.attributes.stroke:ai.strokeStyle;Er(n,"strokeStyle",d,a.currentContext)}(i||s.lineWidth!==o.lineWidth)&&Er(n,"lineWidth",ge(s.lineWidth)?ai.lineWidth:s.lineWidth,a.currentContext),(i||s.lineDash!==o.lineDash)&&Er(n,"lineDash",s.lineDash||ai.lineDash,a.currentContext),(i||s.lineDashOffset!==o.lineDashOffset)&&Er(n,"lineDashOffset",ge(s.lineDashOffset)?ai.lineDashOffset:s.lineDashOffset,a.currentContext);for(var h=0;h<hA.length;h++){var v=hA[h];(i||s[v]!==o[v])&&Er(n,v,ge(s[v])?ai[v]:s[v],a.currentContext)}}if(u&&(i||r.attributes.fill!==a.prevObject.attributes.fill)){var g=!ge(s.fill)&&!Array.isArray(s.fill)&&!s.fill.isNone?r.attributes.fill:ai.fillStyle;Er(n,"fillStyle",g,a.currentContext)}}},{key:"applyStyleToContext",value:function(n,r,i,a){var o=r.nodeName;this.applyCommonStyleToContext(n,r,i,a),o===dt.IMAGE||this.applyStrokeFillStyleToContext(n,r,i,a)}},{key:"applyShadowAndFilterStyleToContext",value:function(n,r,i,a){var o=r.parsedStyle;if(i){Er(n,"shadowColor",o.shadowColor.toString(),a.currentContext);for(var s=0;s<qy.length;s++){var c=qy[s];Er(n,c,o[c]||ai[c],a.currentContext)}}o.filter&&o.filter.length&&Er(n,"filter",r.attributes.filter,a.currentContext)}},{key:"clearShadowAndFilterStyleForContext",value:function(n,r,i,a){var o=arguments.length>4&&arguments[4]!==void 0?arguments[4]:!1;if(r){Er(n,"shadowColor",ai.shadowColor,a.currentContext);for(var s=0;s<qy.length;s++){var c=qy[s];Er(n,c,ai[c],a.currentContext)}}if(i)if(r&&o){var l=n.filter;!ge(l)&&l.indexOf("drop-shadow")>-1&&Er(n,"filter",l.replace(/drop-shadow\([^)]*\)/,"").trim()||ai.filter,a.currentContext)}else Er(n,"filter",ai.filter,a.currentContext)}},{key:"fillToContext",value:function(n,r,i,a,o){var s=this,c=r.parsedStyle,l=c.fill,u=c.fillRule,f=null;if(Array.isArray(l)&&l.length>0)l.forEach(function(h){var v=Er(n,"fillStyle",Uy(h,r,n,s.imagePool),i.currentContext);f=f!=null?f:v,u?n.fill(u):n.fill()});else{if(Us(l)){var d=Xy(l,r,n,r.ownerDocument.defaultView.context,a,o,this.imagePool);d&&(n.fillStyle=d,f=!0)}u?n.fill(u):n.fill()}f!==null&&Er(n,"fillStyle",f,i.currentContext)}},{key:"strokeToContext",value:function(n,r,i,a,o){var s=this,c=r.parsedStyle.stroke,l=null;if(Array.isArray(c)&&c.length>0)c.forEach(function(d){var h=Er(n,"strokeStyle",Uy(d,r,n,s.imagePool),i.currentContext);l=l!=null?l:h,n.stroke()});else{if(Us(c)){var u=Xy(c,r,n,r.ownerDocument.defaultView.context,a,o,this.imagePool);if(u){var f=Er(n,"strokeStyle",u,i.currentContext);l=l!=null?l:f}}n.stroke()}l!==null&&Er(n,"strokeStyle",l,i.currentContext)}},{key:"drawToContext",value:function(n,r,i,a,o){var s,c=r.nodeName,l=r.parsedStyle,u=l.opacity,f=u===void 0?ai.globalAlpha:u,d=l.fillOpacity,h=d===void 0?ai.fillOpacity:d,v=l.strokeOpacity,g=v===void 0?ai.strokeOpacity:v,y=l.lineWidth,b=y===void 0?ai.lineWidth:y,x=l.fill&&!l.fill.isNone,_=l.stroke&&!l.stroke.isNone&&b>0;if(!(!x&&!_)){var w=!ge(l.shadowColor)&&l.shadowBlur>0,O=l.shadowType==="inner",E=((s=l.fill)===null||s===void 0?void 0:s.alpha)===0,M=!!(l.filter&&l.filter.length),k=w&&_&&(c===dt.PATH||c===dt.LINE||c===dt.POLYLINE||E||O),A=null;if(x){k||this.applyShadowAndFilterStyleToContext(n,r,w,i);var P=f*h;A=Er(n,"globalAlpha",P,i.currentContext),this.fillToContext(n,r,i,a,o),k||this.clearShadowAndFilterStyleForContext(n,w,M,i)}if(_){var C=!1,N=f*g,L=Er(n,"globalAlpha",N,i.currentContext);if(A=x?A:L,k&&(this.applyShadowAndFilterStyleToContext(n,r,w,i),C=!0,O)){var R=n.globalCompositeOperation;n.globalCompositeOperation="source-atop",this.strokeToContext(n,r,i,a,o),n.globalCompositeOperation=R,this.clearShadowAndFilterStyleForContext(n,w,M,i,!0)}this.strokeToContext(n,r,i,a,o),C&&this.clearShadowAndFilterStyleForContext(n,w,M,i)}A!==null&&Er(n,"globalAlpha",A,i.currentContext)}}}])}(),Y_=function(t){function e(){return(0,xt.Z)(this,e),(0,De.Z)(this,e,arguments)}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"render",value:function(r,i,a,o,s,c){var l=i.fill,u=i.fillRule,f=i.opacity,d=f===void 0?1:f,h=i.fillOpacity,v=h===void 0?1:h,g=i.stroke,y=i.strokeOpacity,b=y===void 0?1:y,x=i.lineWidth,_=x===void 0?1:x,w=i.lineCap,O=i.lineJoin,E=i.shadowType,M=i.shadowColor,k=i.shadowBlur,A=i.filter,P=i.miterLimit,C=l&&!l.isNone,N=g&&!g.isNone&&_>0,L=(l==null?void 0:l.alpha)===0,R=!!(A&&A.length),I=!ge(M)&&k>0,D=a.nodeName,G=E==="inner",F=N&&I&&(D===dt.PATH||D===dt.LINE||D===dt.POLYLINE||L||G);C&&(r.globalAlpha=d*v,F||Ky(a,r,I),vA(r,a,l,u,o,s,c,this.imagePool),F||this.clearShadowAndFilter(r,R,I)),N&&(r.globalAlpha=d*b,r.lineWidth=_,ge(P)||(r.miterLimit=P),ge(w)||(r.lineCap=w),ge(O)||(r.lineJoin=O),F&&(G&&(r.globalCompositeOperation="source-atop"),Ky(a,r,!0),G&&(H_(r,a,g,o,s,c,this.imagePool),r.globalCompositeOperation=ai.globalCompositeOperation,this.clearShadowAndFilter(r,R,!0))),H_(r,a,g,o,s,c,this.imagePool))}},{key:"clearShadowAndFilter",value:function(r,i,a){if(a&&(r.shadowColor="transparent",r.shadowBlur=0),i){var o=r.filter;!ge(o)&&o.indexOf("drop-shadow")>-1&&(r.filter=o.replace(/drop-shadow\([^)]*\)/,"").trim()||"none")}}}])}(uF);function Ky(t,e,n){var r=t.parsedStyle,i=r.filter,a=r.shadowColor,o=r.shadowBlur,s=r.shadowOffsetX,c=r.shadowOffsetY;i&&i.length&&(e.filter=t.style.filter),n&&(e.shadowColor=a.toString(),e.shadowBlur=o||0,e.shadowOffsetX=s||0,e.shadowOffsetY=c||0)}function vA(t,e,n,r,i,a,o,s){var c=arguments.length>8&&arguments[8]!==void 0?arguments[8]:!1;Array.isArray(n)?n.forEach(function(l){t.fillStyle=Uy(l,e,t,s),c||(r?t.fill(r):t.fill())}):(Us(n)&&(t.fillStyle=Xy(n,e,t,i,a,o,s)),c||(r?t.fill(r):t.fill()))}function H_(t,e,n,r,i,a,o){var s=arguments.length>7&&arguments[7]!==void 0?arguments[7]:!1;Array.isArray(n)?n.forEach(function(c){t.strokeStyle=Uy(c,e,t,o),s||t.stroke()}):(Us(n)&&(t.strokeStyle=Xy(n,e,t,r,i,a,o)),s||t.stroke())}function fF(t,e){var n=(0,Te.Z)(t,4),r=n[0],i=n[1],a=n[2],o=n[3],s=(0,Te.Z)(e,4),c=s[0],l=s[1],u=s[2],f=s[3],d=Math.max(r,c),h=Math.max(i,l),v=Math.min(r+a,c+u),g=Math.min(i+o,l+f);return v<=d||g<=h?null:[d,h,v-d,g-h]}function dF(t,e){var n=er(me(),[t[0],t[1],0],e),r=er(me(),[t[0]+t[2],t[1],0],e),i=er(me(),[t[0],t[1]+t[3],0],e),a=er(me(),[t[0]+t[2],t[1]+t[3],0],e);return[Math.min(n[0],r[0],i[0],a[0]),Math.min(n[1],r[1],i[1],a[1]),Math.max(n[0],r[0],i[0],a[0])-Math.min(n[0],r[0],i[0],a[0]),Math.max(n[1],r[1],i[1],a[1])-Math.min(n[1],r[1],i[1],a[1])]}var hF=function(t){function e(){return(0,xt.Z)(this,e),(0,De.Z)(this,e,arguments)}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"renderDownSampled",value:function(r,i,a,o){var s=o.src,c=o.imageCache;if(!c.downSampled){this.imagePool.createDownSampledImage(s,a).then(function(){a.ownerDocument&&(a.renderable.dirty=!0,a.ownerDocument.defaultView.context.renderingService.dirtify())}).catch(function(l){console.error(l)});return}r.drawImage(c.downSampled,Math.floor(o.drawRect[0]),Math.floor(o.drawRect[1]),Math.ceil(o.drawRect[2]),Math.ceil(o.drawRect[3]))}},{key:"renderTile",value:function(r,i,a,o){var s=o.src,c=o.imageCache,l=o.imageRect,u=o.drawRect,f=c.size,d=r.getTransform(),h=d.a,v=d.b,g=d.c,y=d.d,b=d.e,x=d.f;if(r.resetTransform(),!(c!=null&&c.gridSize)){this.imagePool.createImageTiles(s,[],function(){a.ownerDocument&&(a.renderable.dirty=!0,a.ownerDocument.defaultView.context.renderingService.dirtify())},a).catch(function(I){console.error(I)});return}for(var _=[f[0]/l[2],f[1]/l[3]],w=[c.tileSize[0]/_[0],c.tileSize[1]/_[1]],O=[Math.floor((u[0]-l[0])/w[0]),Math.ceil((u[0]+u[2]-l[0])/w[0])],E=O[0],M=O[1],k=[Math.floor((u[1]-l[1])/w[1]),Math.ceil((u[1]+u[3]-l[1])/w[1])],A=k[0],P=k[1],C=A;C<=P;C++)for(var N=E;N<=M;N++){var L=c.tiles[C][N];if(L){var R=[Math.floor(l[0]+L.tileX*w[0]),Math.floor(l[1]+L.tileY*w[1]),Math.ceil(w[0]),Math.ceil(w[1])];r.drawImage(L.data,R[0],R[1],R[2],R[3])}}r.setTransform(h,v,g,y,b,x)}},{key:"render",value:function(r,i,a){var o=i.x,s=o===void 0?0:o,c=i.y,l=c===void 0?0:c,u=i.width,f=i.height,d=i.src,h=i.shadowColor,v=i.shadowBlur,g=this.imagePool.getImageSync(d,a),y=g==null?void 0:g.img,b=u,x=f;if(y){b||(b=y.width),x||(x=y.height);var _=!ge(h)&&v>0;Ky(a,r,_);try{var w=a.ownerDocument.defaultView.getContextService().getDomElement(),O=w.width,E=w.height,M=r.getTransform(),k=M.a,A=M.b,P=M.c,C=M.d,N=M.e,L=M.f,R=Hd(k,P,0,0,A,C,0,0,0,0,1,0,N,L,0,1),I=dF([s,l,b,x],R),D=fF([0,0,O,E],I);if(!D)return;if(!a.ownerDocument.defaultView.getConfig().enableLargeImageOptimization){e.renderFull(r,i,a,{image:y,drawRect:[s,l,b,x]});return}var G=I[2]/g.size[0];if(G<(g.downSamplingRate||.5)){this.renderDownSampled(r,i,a,{src:d,imageCache:g,drawRect:[s,l,b,x]});return}if(!Z_.isSupportTile){e.renderFull(r,i,a,{image:y,drawRect:[s,l,b,x]});return}this.renderTile(r,i,a,{src:d,imageCache:g,imageRect:I,drawRect:D})}catch(F){}}}},{key:"drawToContext",value:function(r,i,a,o,s){this.render(r,i.parsedStyle,i)}}],[{key:"renderFull",value:function(r,i,a,o){r.drawImage(o.image,Math.floor(o.drawRect[0]),Math.floor(o.drawRect[1]),Math.ceil(o.drawRect[2]),Math.ceil(o.drawRect[3]))}}])}(Y_),pF=function(t){function e(){return(0,xt.Z)(this,e),(0,De.Z)(this,e,arguments)}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"render",value:function(r,i,a,o,s,c){a.getBounds();var l=i.lineWidth,u=l===void 0?1:l,f=i.textAlign,d=f===void 0?"start":f,h=i.textBaseline,v=h===void 0?"alphabetic":h,g=i.lineJoin,y=g===void 0?"miter":g,b=i.miterLimit,x=b===void 0?10:b,_=i.letterSpacing,w=_===void 0?0:_,O=i.stroke,E=i.fill,M=i.fillRule,k=i.fillOpacity,A=k===void 0?1:k,P=i.strokeOpacity,C=P===void 0?1:P,N=i.opacity,L=N===void 0?1:N,R=i.metrics,I=i.x,D=I===void 0?0:I,G=i.y,F=G===void 0?0:G,W=i.dx,X=i.dy,Q=i.shadowColor,tt=i.shadowBlur,nt=R.font,ht=R.lines,lt=R.height,wt=R.lineHeight,yt=R.lineMetrics;r.font=nt,r.lineWidth=u,r.textAlign=d==="middle"?"center":d;var gt=v;gt==="alphabetic"&&(gt="bottom"),r.lineJoin=y,ge(x)||(r.miterLimit=x);var Bt=F;v==="middle"?Bt+=-lt/2-wt/2:v==="bottom"||v==="alphabetic"||v==="ideographic"?Bt+=-lt:(v==="top"||v==="hanging")&&(Bt+=-wt);var Lt=D+(W||0);Bt+=X||0,ht.length===1&&(gt==="bottom"?(gt="middle",Bt-=.5*lt):gt==="top"&&(gt="middle",Bt+=.5*lt)),r.textBaseline=gt;var It=!ge(Q)&&tt>0;Ky(a,r,It);for(var jt=0;jt<ht.length;jt++){var Qt=u/2+Lt;Bt+=wt,!ge(O)&&!O.isNone&&u&&this.drawLetterSpacing(r,a,ht[jt],yt[jt],d,Qt,Bt,w,E,M,A,O,C,L,!0,o,s,c),ge(E)||this.drawLetterSpacing(r,a,ht[jt],yt[jt],d,Qt,Bt,w,E,M,A,O,C,L,!1,o,s,c)}}},{key:"drawLetterSpacing",value:function(r,i,a,o,s,c,l,u,f,d,h,v,g,y,b,x,_,w){if(u===0){b?this.strokeText(r,i,a,c,l,v,g,x,_,w):this.fillText(r,i,a,c,l,f,d,h,y,x,_,w);return}var O=r.textAlign;r.textAlign="left";var E=c;s==="center"||s==="middle"?E=c-o.width/2:(s==="right"||s==="end")&&(E=c-o.width);for(var M=Array.from(a),k=r.measureText(a).width,A=0,P=0;P<M.length;++P){var C=M[P];b?this.strokeText(r,i,C,E,l,v,g,x,_,w):this.fillText(r,i,C,E,l,f,d,h,y,x,_,w),A=r.measureText(a.substring(P+1)).width,E+=k-A+u,k=A}r.textAlign=O}},{key:"fillText",value:function(r,i,a,o,s,c,l,u,f,d,h,v){vA(r,i,c,l,d,h,v,this.imagePool,!0);var g,y=!ge(u)&&u!==1;y&&(g=r.globalAlpha,r.globalAlpha=u*f),r.fillText(a,o,s),y&&(r.globalAlpha=g)}},{key:"strokeText",value:function(r,i,a,o,s,c,l,u,f,d){H_(r,i,c,u,f,d,this.imagePool,!0);var h,v=!ge(l)&&l!==1;v&&(h=r.globalAlpha,r.globalAlpha=l),r.strokeText(a,o,s),v&&(r.globalAlpha=h)}},{key:"drawToContext",value:function(r,i,a,o,s){this.render(r,i.parsedStyle,i,i.ownerDocument.defaultView.context,o,s)}}])}(Y_),vF=function(t){function e(){var n,r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return(0,xt.Z)(this,e),n=(0,De.Z)(this,e),n.name="canvas-renderer",n.options=r,n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"init",value:function(){var r,i=(0,Ee.Z)({dirtyObjectNumThreshold:500,dirtyObjectRatioThreshold:.8},this.options),a=this.context.imagePool,o=new Y_(a),s=(r={},(0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)((0,Kt.Z)(r,dt.CIRCLE,o),dt.ELLIPSE,o),dt.RECT,o),dt.IMAGE,new hF(a)),dt.TEXT,new pF(a)),dt.LINE,o),dt.POLYLINE,o),dt.POLYGON,o),dt.PATH,o),dt.GROUP,void 0),(0,Kt.Z)((0,Kt.Z)((0,Kt.Z)(r,dt.HTML,void 0),dt.MESH,void 0),dt.FRAGMENT,void 0));this.context.defaultStyleRendererFactory=s,this.context.styleRendererFactory=s,this.addRenderingPlugin(new dA(i))}},{key:"destroy",value:function(){this.removeAllRenderingPlugins(),delete this.context.defaultStyleRendererFactory,delete this.context.styleRendererFactory}}])}(is);var gA=function(){function t(){(0,xt.Z)(this,t)}return(0,Ot.Z)(t,[{key:"apply",value:function(n,r){var i=this,a=n.renderingService,o=n.renderingContext,s=n.config;this.context=n;var c=o.root.ownerDocument.defaultView,l=function(k){a.hooks.pointerMove.call(k)},u=function(k){a.hooks.pointerUp.call(k)},f=function(k){a.hooks.pointerDown.call(k)},d=function(k){a.hooks.pointerOver.call(k)},h=function(k){a.hooks.pointerOut.call(k)},v=function(k){a.hooks.pointerCancel.call(k)},g=function(k){a.hooks.pointerWheel.call(k)},y=function(k){a.hooks.click.call(k)},b=function(k){r.globalThis.document.addEventListener("pointermove",l,!0),k.addEventListener("pointerdown",f,!0),k.addEventListener("pointerleave",h,!0),k.addEventListener("pointerover",d,!0),r.globalThis.addEventListener("pointerup",u,!0),r.globalThis.addEventListener("pointercancel",v,!0)},x=function(k){k.addEventListener("touchstart",f,!0),k.addEventListener("touchend",u,!0),k.addEventListener("touchmove",l,!0),k.addEventListener("touchcancel",v,!0)},_=function(k){r.globalThis.document.addEventListener("mousemove",l,!0),k.addEventListener("mousedown",f,!0),k.addEventListener("mouseout",h,!0),k.addEventListener("mouseover",d,!0),r.globalThis.addEventListener("mouseup",u,!0)},w=function(k){r.globalThis.document.removeEventListener("pointermove",l,!0),k.removeEventListener("pointerdown",f,!0),k.removeEventListener("pointerleave",h,!0),k.removeEventListener("pointerover",d,!0),r.globalThis.removeEventListener("pointerup",u,!0),r.globalThis.removeEventListener("pointercancel",v,!0)},O=function(k){k.removeEventListener("touchstart",f,!0),k.removeEventListener("touchend",u,!0),k.removeEventListener("touchmove",l,!0),k.removeEventListener("touchcancel",v,!0)},E=function(k){r.globalThis.document.removeEventListener("mousemove",l,!0),k.removeEventListener("mousedown",f,!0),k.removeEventListener("mouseout",h,!0),k.removeEventListener("mouseover",d,!0),r.globalThis.removeEventListener("mouseup",u,!0)};a.hooks.init.tap(t.tag,function(){var M=i.context.contextService.getDomElement();r.globalThis.navigator.msPointerEnabled?(M.style.msContentZooming="none",M.style.msTouchAction="none"):c.supportsPointerEvents&&(M.style.touchAction="none"),c.supportsPointerEvents?b(M):_(M),c.supportsTouchEvents&&x(M),s.useNativeClickEvent&&M.addEventListener("click",y,!0),M.addEventListener("wheel",g,{passive:!0,capture:!0})}),a.hooks.destroy.tap(t.tag,function(){var M=i.context.contextService.getDomElement();r.globalThis.navigator.msPointerEnabled?(M.style.msContentZooming="",M.style.msTouchAction=""):c.supportsPointerEvents&&(M.style.touchAction=""),c.supportsPointerEvents?w(M):E(M),c.supportsTouchEvents&&O(M),s.useNativeClickEvent&&M.removeEventListener("click",y,!0),M.removeEventListener("wheel",g,!0)})}}])}();gA.tag="DOMInteraction";var gF=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.name="dom-interaction",n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"init",value:function(){this.addRenderingPlugin(new gA)}},{key:"destroy",value:function(){this.removeAllRenderingPlugins()}}])}(is);var yF="g-canvas-camera",yA=function(){function t(){(0,xt.Z)(this,t),this.displayObjectHTMLElementMap=new WeakMap}return(0,Ot.Z)(t,[{key:"joinTransformMatrix",value:function(n){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:[0,0,0];return"matrix(".concat([n[0],n[1],n[4],n[5],n[12]+r[0],n[13]+r[1]].join(","),")")}},{key:"apply",value:function(n,r){var i=this,a=n.camera,o=n.renderingContext,s=n.renderingService;this.context=n;var c=o.root.ownerDocument.defaultView,l=c.context.eventService.nativeHTMLMap,u=function(b,x){x.style.transform=i.joinTransformMatrix(b.getWorldTransform(),b.getOrigin())},f=function(b){var x=b.target;if(x.nodeName===dt.HTML){i.$camera||(i.$camera=i.createCamera(a));var _=i.getOrCreateEl(x);i.$camera.appendChild(_),Object.keys(x.attributes).forEach(function(w){i.updateAttribute(w,x)}),u(x,_),l.set(_,x)}},d=function(b){var x=b.target;if(x.nodeName===dt.HTML&&i.$camera){var _=i.getOrCreateEl(x);_&&(_.remove(),l.delete(_))}},h=function(b){var x=b.target;if(x.nodeName===dt.HTML){var _=b.attrName;i.updateAttribute(_,x)}},v=function(b){var x=b.target,_=x.nodeName===dt.FRAGMENT?x.childNodes:[x];_.forEach(function(w){if(w.nodeName===dt.HTML){var O=i.getOrCreateEl(w);u(w,O)}})},g=function(){if(i.$camera){var b=i.context.config,x=b.width,_=b.height;i.$camera.parentElement.style.width="".concat(x||0,"px"),i.$camera.parentElement.style.height="".concat(_||0,"px")}};s.hooks.init.tap(t.tag,function(){c.addEventListener(vo.RESIZE,g),c.addEventListener($e.MOUNTED,f),c.addEventListener($e.UNMOUNTED,d),c.addEventListener($e.ATTR_MODIFIED,h),c.addEventListener($e.BOUNDS_CHANGED,v)}),s.hooks.endFrame.tap(t.tag,function(){i.$camera&&o.renderReasons.has(Kc.CAMERA_CHANGED)&&(i.$camera.style.transform=i.joinTransformMatrix(a.getOrthoMatrix()))}),s.hooks.destroy.tap(t.tag,function(){i.$camera&&i.$camera.remove(),c.removeEventListener(vo.RESIZE,g),c.removeEventListener($e.MOUNTED,f),c.removeEventListener($e.UNMOUNTED,d),c.removeEventListener($e.ATTR_MODIFIED,h),c.removeEventListener($e.BOUNDS_CHANGED,v)})}},{key:"createCamera",value:function(n){var r=this.context.config,i=r.document,a=r.width,o=r.height,s=this.context.contextService.getDomElement(),c=s.parentNode;if(c){var l=yF,u=c.querySelector("#".concat(l));if(!u){var f=(i||document).createElement("div");f.style.overflow="hidden",f.style.pointerEvents="none",f.style.position="absolute",f.style.left="0px",f.style.top="0px",f.style.width="".concat(a||0,"px"),f.style.height="".concat(o||0,"px");var d=(i||document).createElement("div");u=d,d.id=l,d.style.position="absolute",d.style.left="".concat(s.offsetLeft||0,"px"),d.style.top="".concat(s.offsetTop||0,"px"),d.style.transformOrigin="left top",d.style.transform=this.joinTransformMatrix(n.getOrthoMatrix()),d.style.pointerEvents="none",d.style.width="100%",d.style.height="100%",f.appendChild(d),c.appendChild(f)}return u}return null}},{key:"getOrCreateEl",value:function(n){var r=this.context.config.document,i=this.displayObjectHTMLElementMap.get(n);return i||(i=(r||document).createElement("div"),n.parsedStyle.$el=i,this.displayObjectHTMLElementMap.set(n,i),n.id&&(i.id=n.id),n.name&&i.setAttribute("name",n.name),n.className&&(i.className=n.className),i.style.position="absolute",i.style["will-change"]="transform",i.style.transform=this.joinTransformMatrix(n.getWorldTransform(),n.getOrigin())),i}},{key:"updateAttribute",value:function(n,r){var i=this.getOrCreateEl(r);switch(n){case"innerHTML":var a=r.parsedStyle.innerHTML;ir(a)?i.innerHTML=a:(i.innerHTML="",i.appendChild(a));break;case"x":i.style.left="".concat(r.parsedStyle.x,"px");break;case"y":i.style.top="".concat(r.parsedStyle.y,"px");break;case"transformOrigin":var o=r.parsedStyle.transformOrigin;i.style["transform-origin"]="".concat(o[0].buildCSSText(null,null,"")," ").concat(o[1].buildCSSText(null,null,""));break;case"width":var s=r.parsedStyle.width;i.style.width=Vn(s)?"".concat(s,"px"):s.toString();break;case"height":var c=r.parsedStyle.height;i.style.height=Vn(c)?"".concat(c,"px"):c.toString();break;case"zIndex":var l=r.parsedStyle.zIndex;i.style["z-index"]="".concat(l);break;case"visibility":var u=r.parsedStyle.visibility;i.style.visibility=u;break;case"pointerEvents":var f=r.parsedStyle.pointerEvents,d=f===void 0?"auto":f;i.style.pointerEvents=d;break;case"opacity":var h=r.parsedStyle.opacity;i.style.opacity="".concat(h);break;case"fill":var v=r.parsedStyle.fill,g="";Df(v)?v.isNone?g="transparent":g=r.getAttribute("fill"):Array.isArray(v)?g=r.getAttribute("fill"):Us(v),i.style.background=g;break;case"stroke":var y=r.parsedStyle.stroke,b="";Df(y)?y.isNone?b="transparent":b=r.getAttribute("stroke"):Array.isArray(y)?b=r.getAttribute("stroke"):Us(y),i.style["border-color"]=b,i.style["border-style"]="solid";break;case"lineWidth":var x=r.parsedStyle.lineWidth;i.style["border-width"]="".concat(x||0,"px");break;case"lineDash":i.style["border-style"]="dashed";break;case"filter":var _=r.style.filter;i.style.filter=_;break;default:!ge(r.style[n])&&r.style[n]!==""&&(i.style[n]=r.style[n])}}}])}();yA.tag="HTMLRendering";var mF=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.name="html-renderer",n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"init",value:function(){this.addRenderingPlugin(new yA)}},{key:"destroy",value:function(){this.removeAllRenderingPlugins()}}])}(is);var bF=function(){function t(e){(0,xt.Z)(this,t),this.renderingContext=e.renderingContext,this.canvasConfig=e.config}return(0,Ot.Z)(t,[{key:"init",value:function(){var n=this.canvasConfig,r=n.container,i=n.canvas;if(i)this.$canvas=i,r&&i.parentElement!==r&&r.appendChild(i),this.$container=i.parentElement,this.canvasConfig.container=this.$container;else if(r&&(this.$container=ir(r)?document.getElementById(r):r,this.$container)){var a=document.createElement("canvas");this.$container.appendChild(a),this.$container.style.position||(this.$container.style.position="relative"),this.$canvas=a}this.context=this.$canvas.getContext("2d"),this.resize(this.canvasConfig.width,this.canvasConfig.height)}},{key:"getContext",value:function(){return this.context}},{key:"getDomElement",value:function(){return this.$canvas}},{key:"getDPR",value:function(){return this.dpr}},{key:"getBoundingClientRect",value:function(){if(this.$canvas.getBoundingClientRect)return this.$canvas.getBoundingClientRect()}},{key:"destroy",value:function(){this.$container&&this.$canvas&&this.$canvas.parentNode&&this.$container.removeChild(this.$canvas)}},{key:"resize",value:function(n,r){var i=this.canvasConfig.devicePixelRatio;this.dpr=i,this.$canvas&&(this.$canvas.width=this.dpr*n,this.$canvas.height=this.dpr*r,F2(this.$canvas,n,r)),this.renderingContext.renderReasons.add(Kc.CAMERA_CHANGED)}},{key:"applyCursorStyle",value:function(n){this.$container&&this.$container.style&&(this.$container.style.cursor=n)}},{key:"toDataURL",value:function(){var e=(0,oo.Z)((0,Mn.Z)().mark(function r(){var i,a,o,s=arguments;return(0,Mn.Z)().wrap(function(l){for(;;)switch(l.prev=l.next){case 0:return i=s.length>0&&s[0]!==void 0?s[0]:{},a=i.type,o=i.encoderOptions,l.abrupt("return",this.context.canvas.toDataURL(a,o));case 3:case"end":return l.stop()}},r,this)}));function n(){return e.apply(this,arguments)}return n}()}])}(),xF=function(t){function e(){var n;(0,xt.Z)(this,e);for(var r=arguments.length,i=new Array(r),a=0;a<r;a++)i[a]=arguments[a];return n=(0,De.Z)(this,e,[].concat(i)),n.name="canvas-context-register",n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"init",value:function(){this.context.ContextService=bF}},{key:"destroy",value:function(){delete this.context.ContextService}}])}(is),mA=function(t){function e(n){var r;return(0,xt.Z)(this,e),r=(0,De.Z)(this,e,[n]),r.registerPlugin(new xF),r.registerPlugin(new lF),r.registerPlugin(new zj),r.registerPlugin(new vF),r.registerPlugin(new gF),r.registerPlugin(new aF),r.registerPlugin(new mF),r}return(0,Me.Z)(e,t),(0,Ot.Z)(e)}(mx);var bA=function(){function t(e){(0,xt.Z)(this,t),this.dragndropPluginOptions=e}return(0,Ot.Z)(t,[{key:"apply",value:function(n){var r=this,i=n.renderingService,a=n.renderingContext,o=a.root.ownerDocument,s=o.defaultView,c=function(u){var f=u.target,d=f===o,h=d&&r.dragndropPluginOptions.isDocumentDraggable?o:f.closest&&f.closest("[draggable=true]");if(h){var v=!1,g=u.timeStamp,y=[u.clientX,u.clientY],b=null,x=[u.clientX,u.clientY],_=function(){var O=(0,oo.Z)((0,Mn.Z)().mark(function E(M){var k,A,P,C,N,L;return(0,Mn.Z)().wrap(function(I){for(;;)switch(I.prev=I.next){case 0:if(v){I.next=8;break}if(k=M.timeStamp-g,A=Zi([M.clientX,M.clientY],y),!(k<=r.dragndropPluginOptions.dragstartTimeThreshold||A<=r.dragndropPluginOptions.dragstartDistanceThreshold)){I.next=5;break}return I.abrupt("return");case 5:M.type="dragstart",h.dispatchEvent(M),v=!0;case 8:if(M.type="drag",M.dx=M.clientX-x[0],M.dy=M.clientY-x[1],h.dispatchEvent(M),x=[M.clientX,M.clientY],d){I.next=21;break}return P=r.dragndropPluginOptions.overlap==="pointer"?[M.canvasX,M.canvasY]:f.getBounds().center,I.next=17,o.elementsFromPoint(P[0],P[1]);case 17:C=I.sent,N=C[C.indexOf(f)+1],L=(N==null?void 0:N.closest("[droppable=true]"))||(r.dragndropPluginOptions.isDocumentDroppable?o:null),b!==L&&(b&&(M.type="dragleave",M.target=b,b.dispatchEvent(M)),L&&(M.type="dragenter",M.target=L,L.dispatchEvent(M)),b=L,b&&(M.type="dragover",M.target=b,b.dispatchEvent(M)));case 21:case"end":return I.stop()}},E)}));return function(M){return O.apply(this,arguments)}}();s.addEventListener("pointermove",_);var w=function(E){if(v){E.detail={preventClick:!0};var M=E.clone();b&&(M.type="drop",M.target=b,b.dispatchEvent(M)),M.type="dragend",h.dispatchEvent(M),v=!1}s.removeEventListener("pointermove",_)};f.addEventListener("pointerup",w,{once:!0}),f.addEventListener("pointerupoutside",w,{once:!0})}};i.hooks.init.tap(t.tag,function(){s.addEventListener("pointerdown",c)}),i.hooks.destroy.tap(t.tag,function(){s.removeEventListener("pointerdown",c)})}}])}();bA.tag="Dragndrop";var xA=function(t){function e(){var n,r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return(0,xt.Z)(this,e),n=(0,De.Z)(this,e),n.name="dragndrop",n.options=r,n}return(0,Me.Z)(e,t),(0,Ot.Z)(e,[{key:"init",value:function(){this.addRenderingPlugin(new bA((0,Ee.Z)({overlap:"pointer",isDocumentDraggable:!1,isDocumentDroppable:!1,dragstartDistanceThreshold:0,dragstartTimeThreshold:0},this.options)))}},{key:"destroy",value:function(){this.removeAllRenderingPlugins()}},{key:"setOptions",value:function(r){Object.assign(this.plugins[0].dragndropPluginOptions,r)}}])}(is);function _F(t,e,n){var r;return function(){var i=this,a=arguments,o=function(){r=null,n||t.apply(i,a)},s=n&&!r;clearTimeout(r),r=setTimeout(o,e),s&&t.apply(i,a)}}var _A=_F,wF=function(t){return typeof t=="object"&&t!==null},V_=wF,OF=function(t){if(!V_(t)||!ff(t,"Object"))return!1;if(Object.getPrototypeOf(t)===null)return!0;for(var e=t;Object.getPrototypeOf(e)!==null;)e=Object.getPrototypeOf(e);return Object.getPrototypeOf(t)===e},nc=OF,SF=5;function EF(t,e){if(Object.hasOwn)return Object.hasOwn(t,e);if(t==null)throw new TypeError("Cannot convert undefined or null to object");return Object.prototype.hasOwnProperty.call(Object(t),e)}function wA(t,e,n,r){n=n||0,r=r||SF;for(var i in e)if(EF(e,i)){var a=e[i];a!==null&&nc(a)?(nc(t[i])||(t[i]={}),n<r?wA(t[i],a,n+1,r):t[i]=e[i]):Nr(a)?(t[i]=[],t[i]=t[i].concat(a)):a!==void 0&&(t[i]=a)}}var MF=function(t){for(var e=[],n=1;n<arguments.length;n++)e[n-1]=arguments[n];for(var r=0;r<e.length;r+=1)wA(t,e[r]);return t},mt=MF;class kF extends Map{constructor(e,n=EA){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:n}}),e!=null)for(const[r,i]of e)this.set(r,i)}get(e){return super.get(X_(this,e))}has(e){return super.has(X_(this,e))}set(e,n){return super.set(OA(this,e),n)}delete(e){return super.delete(SA(this,e))}}class Fat extends null{constructor(e,n=EA){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:n}}),e!=null)for(const r of e)this.add(r)}has(e){return super.has(X_(this,e))}add(e){return super.add(OA(this,e))}delete(e){return super.delete(SA(this,e))}}function X_({_intern:t,_key:e},n){const r=e(n);return t.has(r)?t.get(r):n}function OA({_intern:t,_key:e},n){const r=e(n);return t.has(r)?t.get(r):(t.set(r,n),n)}function SA({_intern:t,_key:e},n){const r=e(n);return t.has(r)&&(n=t.get(r),t.delete(r)),n}function EA(t){return t!==null&&typeof t=="object"?t.valueOf():t}function wp(t){return t}function dr(t,...e){return Vf(t,wp,wp,e)}function Qy(t,...e){return Vf(t,Array.from,wp,e)}function MA(t,e){for(let n=1,r=e.length;n<r;++n)t=t.flatMap(i=>i.pop().map(([a,o])=>[...i,a,o]));return t}function Bat(t,...e){return MA(Qy(t,...e),e)}function zat(t,e,...n){return MA(Jy(t,e,...n),n)}function U_(t,e,...n){return Vf(t,wp,e,n)}function Jy(t,e,...n){return Vf(t,Array.from,e,n)}function Wat(t,...e){return Vf(t,identity,kA,e)}function Gat(t,...e){return Vf(t,Array.from,kA,e)}function kA(t){if(t.length!==1)throw new Error("duplicate key");return t[0]}function Vf(t,e,n,r){return function i(a,o){if(o>=r.length)return n(a);const s=new kF,c=r[o++];let l=-1;for(const u of a){const f=c(u,++l,a),d=s.get(f);d?d.push(u):s.set(f,[u])}for(const[u,f]of s)s.set(u,i(f,o));return e(s)}(t,0)}var AA=function(t){return ge(t)?"":t.toString()},AF=function(t){var e=AA(t);return e.charAt(0).toLowerCase()+e.substring(1)},TA=AF,TF=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})};function uu(t){return t}function q_(t){return t.reduce((e,n)=>(r,...i)=>n(e(r,...i),...i),uu)}function PF(t){return t.reduce((e,n)=>r=>TF(this,void 0,void 0,function*(){const i=yield e(r);return n(i)}),uu)}function K_(t){return t.replace(/( |^)[a-z]/g,e=>e.toUpperCase())}function Xf(t=""){throw new Error(t)}function Q_(t,e){const{attributes:n}=e,r=new Set(["id","className"]);for(const[i,a]of Object.entries(n))r.has(i)||t.attr(i,a)}function qn(t){return t!=null&&!Number.isNaN(t)}function $at(t,e){return t+(e-t)*Math.random()}function CF(t){const e=new Map;return n=>{if(e.has(n))return e.get(n);const r=t(n);return e.set(n,r),r}}function LF(t,e){const{transform:n}=t.style,i=(a=>a==="none"||a===void 0)(n)?"":n;t.style.transform=`${i} ${e}`.trimStart()}function $t(t,e){return PA(t,e)||{}}function PA(t,e){const n=Object.entries(t||{}).filter(([r])=>r.startsWith(e)).map(([r,i])=>[TA(r.replace(e,"").trim()),i]).filter(([r])=>!!r);return n.length===0?null:Object.fromEntries(n)}function Zat(t,e){return Object.fromEntries(Object.entries(t).map(([n,r])=>[`${e}${upperFirst(n)}`,r]))}function RF(t,e){return Object.fromEntries(Object.entries(t).filter(([n])=>e.find(r=>n.startsWith(r))))}function J_(t,...e){return Object.fromEntries(Object.entries(t).filter(([n])=>e.every(r=>!n.startsWith(r))))}function CA(t,e){if(t===void 0)return null;if(typeof t=="number")return t;const n=+t.replace("%","");return Number.isNaN(n)?null:n/100*e}function Uf(t){return typeof t=="object"&&!(t instanceof Date)&&t!==null&&!Array.isArray(t)}function rc(t){return t===null||t===!1}function LA(t,e,n=5,r=0){if(!(r>=n)){for(const i of Object.keys(e)){const a=e[i];!nc(a)||!nc(t[i])?t[i]=a:LA(t[i],a,n,r+1)}return t}}function Oe(t){return new Xr([t],null,t,t.ownerDocument)}class Xr{constructor(e=null,n=null,r=null,i=null,a=[null,null,null,null,null],o=[],s=[]){this._elements=Array.from(e),this._data=n,this._parent=r,this._document=i,this._enter=a[0],this._update=a[1],this._exit=a[2],this._merge=a[3],this._split=a[4],this._transitions=o,this._facetElements=s}selectAll(e){const n=typeof e=="string"?this._parent.querySelectorAll(e):e;return new Xr(n,null,this._elements[0],this._document)}selectFacetAll(e){const n=typeof e=="string"?this._parent.querySelectorAll(e):e;return new Xr(this._elements,null,this._parent,this._document,void 0,void 0,n)}select(e){const n=typeof e=="string"?this._parent.querySelectorAll(e)[0]||null:e;return new Xr([n],null,n,this._document)}append(e){const n=typeof e=="function"?e:()=>this.createElement(e),r=[];if(this._data!==null){for(let i=0;i<this._data.length;i++){const a=this._data[i],[o,s]=Array.isArray(a)?a:[a,null],c=n(o,i);c.__data__=o,s!==null&&(c.__fromElements__=s),this._parent.appendChild(c),r.push(c)}return new Xr(r,null,this._parent,this._document)}else{for(let i=0;i<this._elements.length;i++){const a=this._elements[i],o=a.__data__,s=n(o,i);a.appendChild(s),r.push(s)}return new Xr(r,null,r[0],this._document)}}maybeAppend(e,n,r){const i=this._elements[0],a=i.getElementById(e);if(a)return new Xr([a],null,this._parent,this._document);const o=typeof n=="string"?this.createElement(n):n();return o.id=e,r&&(o.className=r),i.appendChild(o),new Xr([o],null,this._parent,this._document)}data(e,n=i=>i,r=()=>null){const i=[],a=[],o=new Set(this._elements),s=[],c=new Set,l=new Map(this._elements.map((h,v)=>[n(h.__data__,v),h])),u=new Map(this._facetElements.map((h,v)=>[n(h.__data__,v),h])),f=dr(this._elements,h=>r(h.__data__));for(let h=0;h<e.length;h++){const v=e[h],g=n(v,h),y=r(v,h);if(l.has(g)){const b=l.get(g);b.__data__=v,b.__facet__=!1,a.push(b),o.delete(b),l.delete(g)}else if(u.has(g)){const b=u.get(g);b.__data__=v,b.__facet__=!0,a.push(b),u.delete(g)}else if(f.has(g)){const b=f.get(g);s.push([v,b]);for(const x of b)o.delete(x);f.delete(g)}else if(l.has(y)){const b=l.get(y);b.__toData__?b.__toData__.push(v):b.__toData__=[v],c.add(b),o.delete(b)}else i.push(v)}const d=[new Xr([],i,this._parent,this._document),new Xr(a,null,this._parent,this._document),new Xr(o,null,this._parent,this._document),new Xr([],s,this._parent,this._document),new Xr(c,null,this._parent,this._document)];return new Xr(this._elements,null,this._parent,this._document,d)}merge(e){const n=[...this._elements,...e._elements],r=[...this._transitions,...e._transitions];return new Xr(n,null,this._parent,this._document,void 0,r)}createElement(e){if(this._document)return this._document.createElement(e,{});const n=Xr.registry[e];return n?new n:Xf(`Unknown node type: ${e}`)}join(e=o=>o,n=o=>o,r=o=>o.remove(),i=o=>o,a=o=>o.remove()){const o=e(this._enter),s=n(this._update),c=r(this._exit),l=i(this._merge),u=a(this._split);return s.merge(o).merge(c).merge(l).merge(u)}remove(){for(let e=0;e<this._elements.length;e++){const n=this._transitions[e];if(n){const r=Array.isArray(n)?n:[n];Promise.all(r.map(i=>i.finished)).then(()=>{this._elements[e].remove()})}else this._elements[e].remove()}return new Xr([],null,this._parent,this._document,void 0,this._transitions)}each(e){for(let n=0;n<this._elements.length;n++){const r=this._elements[n],i=r.__data__;e(i,n,r)}return this}attr(e,n){const r=typeof n!="function"?()=>n:n;return this.each(function(i,a,o){n!==void 0&&(o[e]=r(i,a,o))})}style(e,n){const r=typeof n!="function"?()=>n:n;return this.each(function(i,a,o){n!==void 0&&(o.style[e]=r(i,a,o))})}transition(e){const n=typeof e!="function"?()=>e:e,{_transitions:r}=this;return this.each(function(i,a,o){r[a]=n(i,a,o)})}on(e,n){return this.each(function(r,i,a){a.addEventListener(e,n)}),this}call(e,...n){return e(this,...n),this}node(){return this._elements[0]}nodes(){return this._elements}transitions(){return this._transitions}parent(){return this._parent}}Xr.registry={g:ui,rect:Qc,circle:tc,path:Qi,text:po,ellipse:Oy,image:Sy,line:su,polygon:cu,polyline:Ey,html:bp};const In={BEFORE_RENDER:"beforerender",AFTER_RENDER:"afterrender",BEFORE_PAINT:"beforepaint",AFTER_PAINT:"afterpaint",BEFORE_CHANGE_DATA:"beforechangedata",AFTER_CHANGE_DATA:"afterchangedata",BEFORE_CLEAR:"beforeclear",AFTER_CLEAR:"afterclear",BEFORE_DESTROY:"beforedestroy",AFTER_DESTROY:"afterdestroy",BEFORE_CHANGE_SIZE:"beforechangesize",AFTER_CHANGE_SIZE:"afterchangesize",POINTER_TAP:"pointertap",POINTER_DOWN:"pointerdown",POINTER_UP:"pointerup",POINTER_OVER:"pointerover",POINTER_OUT:"pointerout",POINTER_MOVE:"pointermove",POINTER_ENTER:"pointerenter",POINTER_LEAVE:"pointerleave",POINTER_UPOUTSIDE:"pointerupoutside",DRAG_START:"dragstart",DRAG:"drag",DRAG_END:"dragend",DRAG_ENTER:"dragenter",DRAG_LEAVE:"dragleave",DRAG_OVER:"dragover",DROP:"DROP",CLICK:"click",DBLCLICK:"dblclick"};var NF=function(t){var e=AA(t);return e.charAt(0).toUpperCase()+e.substring(1)},tl=NF;function IF(t){return Math.abs(t=Math.round(t))>=1e21?t.toLocaleString("en").replace(/,/g,""):t.toString(10)}function tm(t,e){if((n=(t=e?t.toExponential(e-1):t.toExponential()).indexOf("e"))<0)return null;var n,r=t.slice(0,n);return[r.length>1?r[0]+r.slice(2):r,+t.slice(n+1)]}function DF(t){return t=tm(Math.abs(t)),t?t[1]:NaN}function jF(t,e){return function(n,r){for(var i=n.length,a=[],o=0,s=t[0],c=0;i>0&&s>0&&(c+s+1>r&&(s=Math.max(1,r-c)),a.push(n.substring(i-=s,i+s)),!((c+=s+1)>r));)s=t[o=(o+1)%t.length];return a.reverse().join(e)}}function FF(t){return function(e){return e.replace(/[0-9]/g,function(n){return t[+n]})}}var BF=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function tw(t){if(!(e=BF.exec(t)))throw new Error("invalid format: "+t);var e;return new ew({fill:e[1],align:e[2],sign:e[3],symbol:e[4],zero:e[5],width:e[6],comma:e[7],precision:e[8]&&e[8].slice(1),trim:e[9],type:e[10]})}tw.prototype=ew.prototype;function ew(t){this.fill=t.fill===void 0?" ":t.fill+"",this.align=t.align===void 0?">":t.align+"",this.sign=t.sign===void 0?"-":t.sign+"",this.symbol=t.symbol===void 0?"":t.symbol+"",this.zero=!!t.zero,this.width=t.width===void 0?void 0:+t.width,this.comma=!!t.comma,this.precision=t.precision===void 0?void 0:+t.precision,this.trim=!!t.trim,this.type=t.type===void 0?"":t.type+""}ew.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function zF(t){t:for(var e=t.length,n=1,r=-1,i;n<e;++n)switch(t[n]){case".":r=i=n;break;case"0":r===0&&(r=n),i=n;break;default:if(!+t[n])break t;r>0&&(r=0);break}return r>0?t.slice(0,r)+t.slice(i+1):t}var RA;function WF(t,e){var n=tm(t,e);if(!n)return t+"";var r=n[0],i=n[1],a=i-(RA=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,o=r.length;return a===o?r:a>o?r+new Array(a-o+1).join("0"):a>0?r.slice(0,a)+"."+r.slice(a):"0."+new Array(1-a).join("0")+tm(t,Math.max(0,e+a-1))[0]}function NA(t,e){var n=tm(t,e);if(!n)return t+"";var r=n[0],i=n[1];return i<0?"0."+new Array(-i).join("0")+r:r.length>i+1?r.slice(0,i+1)+"."+r.slice(i+1):r+new Array(i-r.length+2).join("0")}var IA={"%":(t,e)=>(t*100).toFixed(e),b:t=>Math.round(t).toString(2),c:t=>t+"",d:IF,e:(t,e)=>t.toExponential(e),f:(t,e)=>t.toFixed(e),g:(t,e)=>t.toPrecision(e),o:t=>Math.round(t).toString(8),p:(t,e)=>NA(t*100,e),r:NA,s:WF,X:t=>Math.round(t).toString(16).toUpperCase(),x:t=>Math.round(t).toString(16)};function DA(t){return t}var jA=Array.prototype.map,FA=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function GF(t){var e=t.grouping===void 0||t.thousands===void 0?DA:jF(jA.call(t.grouping,Number),t.thousands+""),n=t.currency===void 0?"":t.currency[0]+"",r=t.currency===void 0?"":t.currency[1]+"",i=t.decimal===void 0?".":t.decimal+"",a=t.numerals===void 0?DA:FF(jA.call(t.numerals,String)),o=t.percent===void 0?"%":t.percent+"",s=t.minus===void 0?"\u2212":t.minus+"",c=t.nan===void 0?"NaN":t.nan+"";function l(f){f=tw(f);var d=f.fill,h=f.align,v=f.sign,g=f.symbol,y=f.zero,b=f.width,x=f.comma,_=f.precision,w=f.trim,O=f.type;O==="n"?(x=!0,O="g"):IA[O]||(_===void 0&&(_=12),w=!0,O="g"),(y||d==="0"&&h==="=")&&(y=!0,d="0",h="=");var E=g==="$"?n:g==="#"&&/[boxX]/.test(O)?"0"+O.toLowerCase():"",M=g==="$"?r:/[%p]/.test(O)?o:"",k=IA[O],A=/[defgprs%]/.test(O);_=_===void 0?6:/[gprs]/.test(O)?Math.max(1,Math.min(21,_)):Math.max(0,Math.min(20,_));function P(C){var N=E,L=M,R,I,D;if(O==="c")L=k(C)+L,C="";else{C=+C;var G=C<0||1/C<0;if(C=isNaN(C)?c:k(Math.abs(C),_),w&&(C=zF(C)),G&&+C==0&&v!=="+"&&(G=!1),N=(G?v==="("?v:s:v==="-"||v==="("?"":v)+N,L=(O==="s"?FA[8+RA/3]:"")+L+(G&&v==="("?")":""),A){for(R=-1,I=C.length;++R<I;)if(D=C.charCodeAt(R),48>D||D>57){L=(D===46?i+C.slice(R+1):C.slice(R))+L,C=C.slice(0,R);break}}}x&&!y&&(C=e(C,1/0));var F=N.length+C.length+L.length,W=F<b?new Array(b-F+1).join(d):"";switch(x&&y&&(C=e(W+C,W.length?b-L.length:1/0),W=""),h){case"<":C=N+C+L+W;break;case"=":C=N+W+C+L;break;case"^":C=W.slice(0,F=W.length>>1)+N+C+L+W.slice(F);break;default:C=W+N+C+L;break}return a(C)}return P.toString=function(){return f+""},P}function u(f,d){var h=l((f=tw(f),f.type="f",f)),v=Math.max(-8,Math.min(8,Math.floor(DF(d)/3)))*3,g=Math.pow(10,-v),y=FA[8+v/3];return function(b){return h(g*b)+y}}return{format:l,formatPrefix:u}}var em,el,$F;ZF({thousands:",",grouping:[3],currency:["$",""]});function ZF(t){return em=GF(t),el=em.format,$F=em.formatPrefix,em}function fs(t,e){return Object.entries(t).reduce((n,[r,i])=>(n[r]=e(i,r,t),n),{})}function fu(t){return t.map((e,n)=>n)}function Yat(t){const e=t.length,n=t[0].length,r=new Array(n).fill(0).map(()=>new Array(e));for(let i=0;i<n;i++)for(let a=0;a<e;a++)r[i][a]=t[a][i];return r}function YF(t){return t[0]}function BA(t){return t[t.length-1]}function Hat(t){return!t.some(Array.isArray)}function HF(t){return Array.from(new Set(t))}function zA(t,e){const n=[[],[]];return t.forEach(r=>{n[e(r)?0:1].push(r)}),n}function WA(t,e=t.length){if(e===1)return t.map(r=>[r]);const n=[];for(let r=0;r<t.length;r++){const i=t.slice(r+1);WA(i,e-1).forEach(o=>{n.push([t[r],...o])})}return n}function VF(t){if(t.length===1)return[t];const e=[];for(let n=1;n<=t.length;n++)e.push(...WA(t,n));return e}var XF=function(t){return t!==null&&typeof t!="function"&&isFinite(t.length)},qf=XF,nw=function(t,e){if(t===e)return!0;if(!t||!e||ir(t)||ir(e))return!1;if(qf(t)||qf(e)){if(t.length!==e.length)return!1;for(var n=!0,r=0;r<t.length&&(n=nw(t[r],e[r]),!!n);r++);return n}if(V_(t)||V_(e)){var i=Object.keys(t),a=Object.keys(e);if(i.length!==a.length)return!1;for(var n=!0,r=0;r<i.length&&(n=nw(t[i[r]],e[i[r]]),!!n);r++);return n}return!1},GA=nw;function bo(t,e){let n=0;if(e===void 0)for(let r of t)(r=+r)&&(n+=r);else{let r=-1;for(let i of t)(i=+e(i,++r,t))&&(n+=i)}return n}function Dn(t,e){let n;if(e===void 0)for(const r of t)r!=null&&(n<r||n===void 0&&r>=r)&&(n=r);else{let r=-1;for(let i of t)(i=e(i,++r,t))!=null&&(n<i||n===void 0&&i>=i)&&(n=i)}return n}function Vat(t){return t*Math.PI/180}function Xat(t){return t*180/Math.PI}function UF(t,e){return t=t%(2*Math.PI),e=e%(2*Math.PI),t<0&&(t=2*Math.PI+t),e<0&&(e=2*Math.PI+e),t>=e&&(e=e+2*Math.PI),{startAngle:t,endAngle:e}}const $A=(t={})=>{const e={startAngle:-Math.PI/2,endAngle:Math.PI*3/2,innerRadius:0,outerRadius:1},n=Object.assign(Object.assign({},e),t);return Object.assign(Object.assign({},n),UF(n.startAngle,n.endAngle))},Op=t=>{const{startAngle:e,endAngle:n,innerRadius:r,outerRadius:i}=$A(t);return[["translate",0,.5],["reflect.y"],["translate",0,-.5],["polar",e,n,r,i]]};Op.props={};const ZA=(t={})=>{const e={startAngle:-Math.PI/2,endAngle:Math.PI*3/2,innerRadius:0,outerRadius:1};return Object.assign(Object.assign({},e),t)},rw=t=>{const{startAngle:e,endAngle:n,innerRadius:r,outerRadius:i}=ZA(t);return[["transpose"],["translate",.5,.5],["reflect"],["translate",-.5,-.5],...Op({startAngle:e,endAngle:n,innerRadius:r,outerRadius:i})]};rw.props={};function nm(t,e,n){return Math.max(e,Math.min(t,n))}function rm(t,e=10){return typeof t!="number"||Math.abs(t)<1e-15?t:parseFloat(t.toFixed(e))}const qF=[["legendCategory",[[["color","discrete"],["opacity","discrete"],["shape","discrete"],["size","constant"]],[["color","discrete"],["opacity","constant"],["shape","discrete"],["size","constant"]],[["color","discrete"],["opacity","discrete"],["shape","constant"],["size","constant"]],[["color","discrete"],["opacity","constant"],["shape","constant"],["size","constant"]],[["color","constant"],["opacity","discrete"],["shape","discrete"],["size","constant"]],[["color","constant"],["opacity","constant"],["shape","discrete"],["size","constant"]],[["color","constant"],["opacity","discrete"],["shape","constant"],["size","constant"]],[["color","discrete"],["shape","discrete"],["size","constant"]],[["color","discrete"],["opacity","discrete"],["shape","discrete"]],[["color","discrete"],["opacity","discrete"],["size","constant"]],[["color","discrete"],["opacity","constant"],["shape","discrete"]],[["color","discrete"],["opacity","constant"],["size","constant"]],[["color","discrete"],["shape","constant"],["size","constant"]],[["color","discrete"],["opacity","discrete"],["shape","constant"]],[["color","discrete"],["opacity","constant"],["shape","constant"]],[["color","constant"],["shape","discrete"],["size","constant"]],[["color","constant"],["opacity","discrete"],["shape","discrete"]],[["color","constant"],["opacity","discrete"],["size","constant"]],[["color","constant"],["opacity","constant"],["shape","discrete"]],[["color","constant"],["opacity","discrete"],["shape","constant"]],[["color","discrete"],["shape","discrete"]],[["color","discrete"],["size","constant"]],[["color","discrete"],["opacity","discrete"]],[["color","discrete"],["opacity","constant"]],[["color","discrete"],["shape","constant"]],[["color","constant"],["shape","discrete"]],[["color","constant"],["size","constant"]],[["color","constant"],["opacity","discrete"]],[["color","discrete"]]]],["legendContinuousSize",[[["color","continuous"],["opacity","continuous"],["size","continuous"]],[["color","constant"],["opacity","continuous"],["size","continuous"]],[["color","continuous"],["size","continuous"]],[["color","constant"],["size","continuous"]],[["size","continuous"],["opacity","continuous"]],[["size","continuous"]]]],["legendContinuousBlockSize",[[["color","distribution"],["opacity","distribution"],["size","distribution"]],[["color","distribution"],["size","distribution"]]]],["legendContinuousBlock",[[["color","distribution"],["opacity","continuous"]],[["color","distribution"]]]],["legendContinuous",[[["color","continuous"],["opacity","continuous"]],[["color","continuous"]],[["opacity","continuous"]]]]];var YA=pt(17816);function hr(t){const{transformations:e}=t.getOptions();return e.map(([r])=>r).filter(r=>r==="transpose").length%2!==0}function Bn(t){const{transformations:e}=t.getOptions();return e.some(([n])=>n==="polar")}function Sp(t){const{transformations:e}=t.getOptions();return e.some(([n])=>n==="reflect")&&e.some(([n])=>n.startsWith("transpose"))}function HA(t){const{transformations:e}=t.getOptions();return e.some(([n])=>n==="helix")}function Ep(t){const{transformations:e}=t.getOptions();return e.some(([n])=>n==="parallel")}function VA(t){const{transformations:e}=t.getOptions();return e.some(([n])=>n==="fisheye")}function KF(t){return Ep(t)&&Bn(t)}function Kf(t){return HA(t)||Bn(t)}function XA(t){return Bn(t)&&hr(t)}function Uat(t){return Bn(t)||Ep(t)||Sp(t)||XA(t)}function QF(t){if(Kf(t)){const[e,n]=t.getSize(),r=t.getOptions().transformations.find(i=>i[0]==="polar");if(r)return Math.max(e,n)/2*r[4]}return 0}function im(t){const{transformations:e}=t.getOptions(),[,,,n,r]=e.find(i=>i[0]==="polar");return[+n,+r]}function iw(t,e=!0){const{transformations:n}=t.getOptions(),[,r,i]=n.find(a=>a[0]==="polar");return e?[+r*180/Math.PI,+i*180/Math.PI]:[r,i]}function JF(t,e){const{transformations:n}=t.getOptions(),[,...r]=n.find(i=>i[0]===e);return r}function UA(t,e){e(t),t.children&&t.children.forEach(function(n){n&&UA(n,e)})}function Mp(t){am(t,!0)}function nl(t){am(t,!1)}function am(t,e){var n=e?"visible":"hidden";UA(t,function(r){r.attr("visibility",n)})}function t9(t){return typeof t=="boolean"?!1:"enter"in t&&"update"in t&&"exit"in t}function qA(t){if(!t)return{enter:!1,update:!1,exit:!1};var e=["enter","update","exit"],n=Object.fromEntries(Object.entries(t).filter(function(r){var i=V(r,1),a=i[0];return!e.includes(a)}));return Object.fromEntries(e.map(function(r){return t9(t)?t[r]===!1?[r,!1]:[r,At(At({},t[r]),n)]:[r,n]}))}function Qf(t,e){t?t.finished.then(e):e()}function e9(t,e){t.length===0?e():Promise.all(t.map(function(n){return n==null?void 0:n.finished})).then(e)}function KA(t,e){"update"in t?t.update(e):t.attr(e)}function QA(t,e,n){if(e.length===0)return null;if(!n){var r=e.slice(-1)[0];return KA(t,{style:r}),null}return t.animate(e,n)}function n9(t,e){return!(t.nodeName!=="text"||e.nodeName!=="text"||t.attributes.text!==e.attributes.text)}function r9(t,e,n,r){if(r===void 0&&(r="destroy"),n9(t,e))return t.remove(),[null];var i=function(){r==="destroy"?t.destroy():r==="hide"&&nl(t),e.isVisible()&&Mp(e)};if(!n)return i(),[null];var a=n.duration,o=a===void 0?0:a,s=n.delay,c=s===void 0?0:s,l=Math.ceil(+o/2),u=+o/4,f=V(t.getGeometryBounds().center,2),d=f[0],h=f[1],v=V(e.getGeometryBounds().center,2),g=v[0],y=v[1],b=V([(d+g)/2-d,(h+y)/2-h],2),x=b[0],_=b[1],w=t.style.opacity,O=w===void 0?1:w,E=e.style.opacity,M=E===void 0?1:E,k=t.style.transform||"",A=e.style.transform||"",P=t.animate([{opacity:O,transform:"translate(0, 0) ".concat(k)},{opacity:0,transform:"translate(".concat(x,", ").concat(_,") ").concat(k)}],At(At({fill:"both"},n),{duration:c+l+u})),C=e.animate([{opacity:0,transform:"translate(".concat(-x,", ").concat(-_,") ").concat(A),offset:.01},{opacity:M,transform:"translate(0, 0) ".concat(A)}],At(At({fill:"both"},n),{duration:l+u,delay:c+l-u}));return Qf(C,i),[P,C]}function zo(t,e,n){var r={},i={};return Object.entries(e).forEach(function(a){var o=V(a,2),s=o[0],c=o[1];if(!ge(c)){var l=t.style[s]||t.parsedStyle[s]||0;l!==c&&(r[s]=l,i[s]=c)}}),n?QA(t,[r,i],At({fill:"both"},n)):(KA(t,i),null)}var i9=5,JA=function(t,e,n,r){n===void 0&&(n=0),r===void 0&&(r=i9),Object.entries(e).forEach(function(i){var a=V(i,2),o=a[0],s=a[1],c=t;Object.prototype.hasOwnProperty.call(e,o)&&(s?nc(s)?(nc(t[o])||(c[o]={}),n<r?JA(t[o],s,n+1,r):c[o]=e[o]):Nr(s)?(c[o]=[],c[o]=c[o].concat(s)):c[o]=s:c[o]=s)})},ic=function(t){for(var e=[],n=1;n<arguments.length;n++)e[n-1]=arguments[n];for(var r=0;r<e.length;r+=1)JA(t,e[r]);return t},a9=function(t){ar(e,t);function e(){for(var n=[],r=0;r<arguments.length;r++)n[r]=arguments[r];var i=t.apply(this,te([],V(n),!1))||this;return i.isMutationObserved=!0,i.addEventListener($e.INSERTED,function(){nl(i)}),i}return e}(ui);function tT(t){var e=t.appendChild(new a9({class:"offscreen"}));return nl(e),e}function o9(t){for(var e=t;e;){if(e.className==="offscreen")return!0;e=e.parent}return!1}function s9(){am(this,this.attributes.visibility!=="hidden")}var bi=function(t){ar(e,t);function e(n,r){r===void 0&&(r={});var i=t.call(this,ic({},{style:r},n))||this;return i.initialized=!1,i._defaultOptions=r,i}return Object.defineProperty(e.prototype,"offscreenGroup",{get:function(){return this._offscreen||(this._offscreen=tT(this)),this._offscreen},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"defaultOptions",{get:function(){return this._defaultOptions},enumerable:!1,configurable:!0}),e.prototype.connectedCallback=function(){this.render(this.attributes,this),this.bindEvents(this.attributes,this),this.initialized=!0},e.prototype.disconnectedCallback=function(){var n;(n=this._offscreen)===null||n===void 0||n.destroy()},e.prototype.attributeChangedCallback=function(n){n==="visibility"&&s9.call(this)},e.prototype.update=function(n,r){var i;return this.attr(ic({},this.attributes,n||{})),(i=this.render)===null||i===void 0?void 0:i.call(this,this.attributes,this,r)},e.prototype.clear=function(){this.removeChildren()},e.prototype.bindEvents=function(n,r){},e.prototype.getSubShapeStyle=function(n){var r=n.x,i=n.y,a=n.transform,o=n.transformOrigin,s=n.class,c=n.className,l=n.zIndex,u=$r(n,["x","y","transform","transformOrigin","class","className","zIndex"]);return u},e}(mp);function Pa(t,e,n,r,i){return r===void 0&&(r=!0),i===void 0&&(i=function(a){a.node().removeChildren()}),t?n(e):(r&&i(e),null)}function c9(t,e){if(t.length<=e)return t;for(var n=Math.floor(t.length/e),r=[],i=0;i<t.length;i+=n)r.push(t[i]);return r}var aw=function(t){ar(e,t);function e(n){n===void 0&&(n={});var r=n.style,i=$r(n,["style"]);return t.call(this,At({style:At({text:"",fill:"black",fontFamily:"sans-serif",fontSize:16,fontStyle:"normal",fontVariant:"normal",fontWeight:"normal",lineWidth:1,textAlign:"start",textBaseline:"middle"},r)},i))||this}return Object.defineProperty(e.prototype,"offscreenGroup",{get:function(){return this._offscreen||(this._offscreen=tT(this)),this._offscreen},enumerable:!1,configurable:!0}),e.prototype.disconnectedCallback=function(){var n;(n=this._offscreen)===null||n===void 0||n.destroy()},e}(po);function l9(t,e){var n=new Map;return t.forEach(function(r){var i=e(r);n.has(i)||n.set(i,[]),n.get(i).push(r)}),n}function u9(t){throw new Error(t)}var f9=function(){function t(i,a,o,s,c,l,u){i===void 0&&(i=null),a===void 0&&(a=null),o===void 0&&(o=null),s===void 0&&(s=null),c===void 0&&(c=[null,null,null,null,null]),l===void 0&&(l=[]),u===void 0&&(u=[]),e.add(this),this._elements=Array.from(i),this._data=a,this._parent=o,this._document=s,this._enter=c[0],this._update=c[1],this._exit=c[2],this._merge=c[3],this._split=c[4],this._transitions=l,this._facetElements=u}t.prototype.selectAll=function(i){var a=typeof i=="string"?this._parent.querySelectorAll(i):i;return new n(a,null,this._elements[0],this._document)},t.prototype.selectFacetAll=function(i){var a=typeof i=="string"?this._parent.querySelectorAll(i):i;return new n(this._elements,null,this._parent,this._document,void 0,void 0,a)},t.prototype.select=function(i){var a=typeof i=="string"?this._parent.querySelectorAll(i)[0]||null:i;return new n([a],null,a,this._document)},t.prototype.append=function(i){var a=this,o=typeof i=="function"?i:function(){return a.createElement(i)},s=[];if(this._data!==null){for(var c=0;c<this._data.length;c++){var l=this._data[c],u=V(Array.isArray(l)?l:[l,null],2),f=u[0],d=u[1],h=o(f,c);h.__data__=f,d!==null&&(h.__fromElements__=d),this._parent.appendChild(h),s.push(h)}return new n(s,null,this._parent,this._document)}for(var c=0;c<this._elements.length;c++){var v=this._elements[c],f=v.__data__,h=o(f,c);v.appendChild(h),s.push(h)}return new n(s,null,s[0],this._document)},t.prototype.maybeAppend=function(i,a){var o=Rr(this,e,"m",r).call(this,i[0]==="#"?i:"#".concat(i),a);return o.attr("id",i),o},t.prototype.maybeAppendByClassName=function(i,a){var o=i.toString(),s=Rr(this,e,"m",r).call(this,o[0]==="."?o:".".concat(o),a);return s.attr("className",o),s},t.prototype.maybeAppendByName=function(i,a){var o=Rr(this,e,"m",r).call(this,'[name="'.concat(i,'"]'),a);return o.attr("name",i),o},t.prototype.data=function(i,a,o){var s,c;a===void 0&&(a=function(P){return P}),o===void 0&&(o=function(){return null});for(var l=[],u=[],f=new Set(this._elements),d=[],h=new Set,v=new Map(this._elements.map(function(P,C){return[a(P.__data__,C),P]})),g=new Map(this._facetElements.map(function(P,C){return[a(P.__data__,C),P]})),y=l9(this._elements,function(P){return o(P.__data__)}),b=0;b<i.length;b++){var x=i[b],_=a(x,b),w=o(x,b);if(v.has(_)){var O=v.get(_);O.__data__=x,O.__facet__=!1,u.push(O),f.delete(O),v.delete(_)}else if(g.has(_)){var O=g.get(_);O.__data__=x,O.__facet__=!0,u.push(O),g.delete(_)}else if(y.has(_)){var E=y.get(_);d.push([x,E]);try{for(var M=(s=void 0,gi(E)),k=M.next();!k.done;k=M.next()){var O=k.value;f.delete(O)}}catch(P){s={error:P}}finally{try{k&&!k.done&&(c=M.return)&&c.call(M)}finally{if(s)throw s.error}}y.delete(_)}else if(v.has(w)){var O=v.get(w);O.__toData__?O.__toData__.push(x):O.__toData__=[x],h.add(O),f.delete(O)}else l.push(x)}var A=[new n([],l,this._parent,this._document),new n(u,null,this._parent,this._document),new n(f,null,this._parent,this._document),new n([],d,this._parent,this._document),new n(h,null,this._parent,this._document)];return new n(this._elements,null,this._parent,this._document,A)},t.prototype.merge=function(i){var a=te(te([],V(this._elements),!1),V(i._elements),!1),o=te(te([],V(this._transitions),!1),V(i._transitions),!1);return new n(a,null,this._parent,this._document,void 0,o)},t.prototype.createElement=function(i){if(this._document)return this._document.createElement(i,{});var a=n.registry[i];return a?new a:u9("Unknown node type: ".concat(i))},t.prototype.join=function(i,a,o,s,c){i===void 0&&(i=function(v){return v}),a===void 0&&(a=function(v){return v}),o===void 0&&(o=function(v){return v.remove()}),s===void 0&&(s=function(v){return v}),c===void 0&&(c=function(v){return v.remove()});var l=i(this._enter),u=a(this._update),f=o(this._exit),d=s(this._merge),h=c(this._split);return u.merge(l).merge(f).merge(d).merge(h)},t.prototype.remove=function(){for(var i=function(s){var c=a._elements[s],l=a._transitions[s];l?l.then(function(){return c.remove()}):c.remove()},a=this,o=0;o<this._elements.length;o++)i(o);return new n([],null,this._parent,this._document,void 0,this._transitions)},t.prototype.each=function(i){for(var a=0;a<this._elements.length;a++){var o=this._elements[a],s=o.__data__;i.call(o,s,a)}return this},t.prototype.attr=function(i,a){var o=typeof a!="function"?function(){return a}:a;return this.each(function(s,c){a!==void 0&&(this[i]=o.call(this,s,c))})},t.prototype.style=function(i,a,o){o===void 0&&(o=!0);var s=typeof a!="function"||!o?function(){return a}:a;return this.each(function(c,l){a!==void 0&&(this.style[i]=s.call(this,c,l))})},t.prototype.styles=function(i,a){return i===void 0&&(i={}),a===void 0&&(a=!0),this.each(function(o,s){var c=this;Object.entries(i).forEach(function(l){var u=V(l,2),f=u[0],d=u[1],h=typeof d!="function"||!a?function(){return d}:d;d!==void 0&&c.attr(f,h.call(c,o,s))})})},t.prototype.update=function(i,a){a===void 0&&(a=!0);var o=typeof i!="function"||!a?function(){return i}:i;return this.each(function(s,c){i&&this.update&&this.update(o.call(this,s,c))})},t.prototype.maybeUpdate=function(i,a){a===void 0&&(a=!0);var o=typeof i!="function"||!a?function(){return i}:i;return this.each(function(s,c){i&&this.update&&this.update(o.call(this,s,c))})},t.prototype.transition=function(i){var a=this._transitions;return this.each(function(o,s){a[s]=i.call(this,o,s)})},t.prototype.on=function(i,a){return this.each(function(){this.addEventListener(i,a)}),this},t.prototype.call=function(i){for(var a=[],o=1;o<arguments.length;o++)a[o-1]=arguments[o];return i.call.apply(i,te([this._parent,this],V(a),!1)),this},t.prototype.node=function(){return this._elements[0]},t.prototype.nodes=function(){return this._elements},t.prototype.transitions=function(){return this._transitions.filter(function(i){return!!i})},t.prototype.parent=function(){return this._parent};var e,n,r;return n=t,e=new WeakSet,r=function(a,o){var s=this._elements[0],c=s.querySelector(a);if(c)return new n([c],null,this._parent,this._document);var l=typeof o=="string"?this.createElement(o):o();return s.appendChild(l),new n([l],null,this._parent,this._document)},t.registry={g:ui,rect:Qc,circle:tc,path:Qi,text:aw,ellipse:Oy,image:Sy,line:su,polygon:cu,polyline:Ey,html:bp},t}();function Fe(t){return new f9([t],null,t,t.ownerDocument)}function d9(t,e,n){return t.querySelector(e)?Fe(t).select(e):Fe(t).append(n)}var xo=function(t,e){var n=function(i){return"".concat(e,"-").concat(i)},r=Object.fromEntries(Object.entries(t).map(function(i){var a=V(i,2),o=a[0],s=a[1],c=n(s);return[o,{name:c,class:".".concat(c),id:"#".concat(c),toString:function(){return c}}]}));return Object.assign(r,{prefix:n}),r},ow={data:[],animate:{enter:!1,update:{duration:100,easing:"ease-in-out-sine",fill:"both"},exit:{duration:100,fill:"both"}},showArrow:!0,showGrid:!0,showLabel:!0,showLine:!0,showTick:!0,showTitle:!0,showTrunc:!1,dataThreshold:100,lineLineWidth:1,lineStroke:"black",crossPadding:10,titleFill:"black",titleFontSize:12,titlePosition:"lb",titleSpacing:0,titleTextAlign:"center",titleTextBaseline:"middle",lineArrow:function(){return new Qi({style:{d:[["M",10,10],["L",-10,0],["L",10,-10],["L",0,0],["L",10,10],["Z"]],fill:"black",transformOrigin:"center"}})},labelAlign:"parallel",labelDirection:"positive",labelFontSize:12,labelSpacing:0,gridConnect:"line",gridControlAngles:[],gridDirection:"positive",gridLength:0,gridType:"segment",lineArrowOffset:15,lineArrowSize:10,tickDirection:"positive",tickLength:5,tickLineWidth:1,tickStroke:"black",labelOverlap:[]},qat=mt({},ow,{style:{type:"arc"}}),Kat=mt({},ow,{style:{}}),zn=xo({mainGroup:"main-group",gridGroup:"grid-group",grid:"grid",lineGroup:"line-group",line:"line",tickGroup:"tick-group",tick:"tick",tickItem:"tick-item",labelGroup:"label-group",label:"label",labelItem:"label-item",titleGroup:"title-group",title:"title",lineFirst:"line-first",lineSecond:"line-second"},"axis");function ac(t,e){return[t[0]*e,t[1]*e]}function kp(t,e){return[t[0]+e[0],t[1]+e[1]]}function sw(t,e){return[t[0]-e[0],t[1]-e[1]]}function du(t,e){return[Math.min(t[0],e[0]),Math.min(t[1],e[1])]}function hu(t,e){return[Math.max(t[0],e[0]),Math.max(t[1],e[1])]}function Ap(t,e){return Math.sqrt(Math.pow(t[0]-e[0],2)+Math.pow(t[1]-e[1],2))}function eT(t){if(t[0]===0&&t[1]===0)return[0,0];var e=Math.sqrt(Math.pow(t[0],2)+Math.pow(t[1],2));return[t[0]/e,t[1]/e]}function Qat(t,e,n){var r=__read(t,2),i=r[0],a=r[1],o=__read(e,2),s=o[0],c=o[1],l=i-s,u=a-c,f=Math.sin(n),d=Math.cos(n);return[l*d-u*f+s,l*f+u*d+c]}function h9(t,e){return e?[t[1],-t[0]]:[-t[1],t[0]]}function Jf(t){return t*Math.PI/180}function nT(t){return Number((t*180/Math.PI).toPrecision(5))}function cw(t){return t.toString().charAt(0).toUpperCase()+t.toString().slice(1)}function p9(t){return t.toString().charAt(0).toLowerCase()+t.toString().slice(1)}function v9(t,e){return"".concat(e).concat(cw(t))}function rT(t,e,n){var r;n===void 0&&(n=!0);var i=e||((r=t.match(/^([a-z][a-z0-9]+)/))===null||r===void 0?void 0:r[0])||"",a=t.replace(new RegExp("^(".concat(i,")")),"");return n?p9(a):a}function g9(t,e){Object.entries(e).forEach(function(n){var r=V(n,2),i=r[0],a=r[1];te([t],V(t.querySelectorAll(i)),!1).filter(function(o){return o.matches(i)}).forEach(function(o){if(o){var s=o;s.style.cssText+=Object.entries(a).reduce(function(c,l){return"".concat(c).concat(l.join(":"),";")},"")}})})}var om=function(t,e){if(!(t!=null&&t.startsWith(e)))return!1;var n=t[e.length];return n>="A"&&n<="Z"};function en(t,e,n){n===void 0&&(n=!1);var r={};return Object.entries(t).forEach(function(i){var a=V(i,2),o=a[0],s=a[1];if(!(o==="className"||o==="class")){if(om(o,"show")&&om(rT(o,"show"),e)!==n)o===v9(e,"show")?r[o]=s:r[o.replace(new RegExp(cw(e)),"")]=s;else if(!om(o,"show")&&om(o,e)!==n){var c=rT(o,e);c==="filter"&&typeof s=="function"||(r[c]=s)}}}),r}function ds(t,e){return Object.entries(t).reduce(function(n,r){var i=V(r,2),a=i[0],o=i[1];return a.startsWith("show")?n["show".concat(e).concat(a.slice(4))]=o:n["".concat(e).concat(cw(a))]=o,n},{})}function oc(t,e){e===void 0&&(e=["x","y","class","className"]);var n=["transform","transformOrigin","anchor","visibility","pointerEvents","zIndex","cursor","clipPath","clipPathTargets","offsetPath","offsetPathTargets","offsetDistance","draggable","droppable"],r={},i={};return Object.entries(t).forEach(function(a){var o=V(a,2),s=o[0],c=o[1];e.includes(s)||(n.indexOf(s)!==-1?i[s]=c:r[s]=c)}),[r,i]}function _o(t,e){return Xn(t)?t.apply(void 0,te([],V(e),!1)):t}function sm(t,e){return t.style.opacity||(t.style.opacity=1),zo(t,{opacity:0},e)}var y9=["$el","cx","cy","d","dx","dy","fill","fillOpacity","filter","fontFamily","fontSize","fontStyle","fontVariant","fontWeight","height","img","increasedLineWidthForHitTesting","innerHTML","isBillboard","billboardRotation","isSizeAttenuation","isClosed","isOverflowing","leading","letterSpacing","lineDash","lineHeight","lineWidth","markerEnd","markerEndOffset","markerMid","markerStart","markerStartOffset","maxLines","metrics","miterLimit","offsetX","offsetY","opacity","path","points","r","radius","rx","ry","shadowColor","src","stroke","strokeOpacity","text","textAlign","textBaseline","textDecorationColor","textDecorationLine","textDecorationStyle","textOverflow","textPath","textPathSide","textPathStartOffset","transform","transformOrigin","visibility","width","wordWrap","wordWrapWidth","x","x1","x2","y","y1","y2","z1","z2","zIndex"];function m9(t){return y9.includes(t)}function iT(t){var e={};for(var n in t)m9(n)&&(e[n]=t[n]);return e}var td=xo({lineGroup:"line-group",line:"line",regionGroup:"region-group",region:"region"},"grid");function aT(t){return t.reduce(function(e,n,r){return e.push(te([r===0?"M":"L"],V(n),!1)),e},[])}function b9(t,e,n){var r=e.connect,i=r===void 0?"line":r,a=e.center;if(i==="line")return aT(t);if(!a)return[];var o=Ap(t[0],a),s=n?0:1;return t.reduce(function(c,l,u){return u===0?c.push(te(["M"],V(l),!1)):c.push(te(["A",o,o,0,0,s],V(l),!1)),c},[])}function lw(t,e,n){return e.type==="surround"?b9(t,e,n):aT(t)}function x9(t,e,n){var r=n.type,i=n.connect,a=n.center,o=n.closed,s=o?[["Z"]]:[],c=V([lw(t,n),lw(e.slice().reverse(),n,!0)],2),l=c[0],u=c[1],f=V([t[0],e.slice(-1)[0]],2),d=f[0],h=f[1],v=function(x,_){return[l,x,u,_,s].flat()};if(i==="line"||r==="surround")return v([te(["L"],V(h),!1)],[te(["L"],V(d),!1)]);if(!a)throw new Error("Arc grid need to specified center");var g=V([Ap(h,a),Ap(d,a)],2),y=g[0],b=g[1];return v([te(["A",y,y,0,0,1],V(h),!1),te(["L"],V(h),!1)],[te(["A",b,b,0,0,0],V(d),!1),te(["L"],V(d),!1)])}function _9(t,e,n,r){var i=n.animate,a=n.isBillboard,o=e.map(function(s,c){return{id:s.id||"grid-line-".concat(c),d:lw(s.points,n)}});return t.selectAll(td.line.class).data(o,function(s){return s.id}).join(function(s){return s.append("path").each(function(c,l){var u=_o(iT(At({d:c.d},r)),[c,l,o]);this.attr(At({class:td.line.name,stroke:"#D9D9D9",lineWidth:1,lineDash:[4,4],isBillboard:a},u))})},function(s){return s.transition(function(c,l){var u=_o(iT(At({d:c.d},r)),[c,l,o]);return zo(this,u,i.update)})},function(s){return s.transition(function(){var c=this,l=sm(this,i.exit);return Qf(l,function(){return c.remove()}),l})}).transitions()}function w9(t,e,n){var r=n.animate,i=n.connect,a=n.areaFill;if(e.length<2||!a||!i)return[];for(var o=Array.isArray(a)?a:[a,"transparent"],s=function(v){return o[v%o.length]},c=[],l=0;l<e.length-1;l++){var u=V([e[l].points,e[l+1].points],2),f=u[0],d=u[1],h=x9(f,d,n);c.push({d:h,fill:s(l)})}return t.selectAll(td.region.class).data(c,function(v,g){return g}).join(function(v){return v.append("path").each(function(g,y){var b=_o(g,[g,y,c]);this.attr(b)}).attr("className",td.region.name)},function(v){return v.transition(function(g,y){var b=_o(g,[g,y,c]);return zo(this,b,r.update)})},function(v){return v.transition(function(){var g=this,y=sm(this,r.exit);return Qf(y,function(){return g.remove()}),y})}).transitions()}function O9(t){var e=t.data,n=e===void 0?[]:e,r=t.closed;return r?n.map(function(i){var a=i.points,o=V(a,1),s=o[0];return At(At({},i),{points:te(te([],V(a),!1),[s],!1)})}):n}var S9=function(t){ar(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}return e.prototype.render=function(n,r){var i=n.type,a=n.center,o=n.areaFill,s=n.closed,c=$r(n,["type","center","areaFill","closed"]),l=O9(n),u=Fe(r).maybeAppendByClassName(td.lineGroup,"g"),f=Fe(r).maybeAppendByClassName(td.regionGroup,"g"),d=_9(u,l,n,c),h=w9(f,l,n);return te(te([],V(d),!1),V(h),!1)},e}(bi),vn=function(t,e,n){for(var r=0,i=ir(e)?e.split("."):e;t&&r<i.length;)t=t[i[r++]];return t===void 0||r<i.length?n:t},E9=function(t,e){return function(n){return t*(1-n)+e*n}};function M9(t,e){var n=e?e.length:0,r=t?Math.min(n,t.length):0;return function(i){var a=new Array(r),o=new Array(n),s=0;for(s=0;s<r;++s)a[s]=uw(t[s],e[s]);for(;s<n;++s)o[s]=e[s];for(s=0;s<r;++s)o[s]=a[s](i);return o}}function k9(t,e){t===void 0&&(t={}),e===void 0&&(e={});var n={},r={};return Object.entries(e).forEach(function(i){var a=V(i,2),o=a[0],s=a[1];o in t?n[o]=uw(t[o],s):r[o]=s}),function(i){return Object.entries(n).forEach(function(a){var o=V(a,2),s=o[0],c=o[1];return r[s]=c(i)}),r}}function uw(t,e){return typeof t=="number"&&typeof e=="number"?E9(t,e):Array.isArray(t)&&Array.isArray(e)?M9(t,e):typeof t=="object"&&typeof e=="object"?k9(t,e):function(n){return t}}function A9(t,e,n,r){if(!r)return t.attr("__keyframe_data__",n),null;var i=r.duration,a=i===void 0?0:i,o=uw(e,n),s=Math.ceil(+a/16),c=new Array(s).fill(0).map(function(l,u,f){return{__keyframe_data__:o(u/(f.length-1))}});return t.animate(c,At({fill:"both"},r))}function pu(t){return typeof t=="function"?t():ir(t)||Vn(t)?new aw({style:{text:String(t)}}):t}function fw(t,e,n){n===void 0&&(n=!1);var r=t.getBBox(),i=r.width,a=r.height,o=e/Math.max(i,a);return n&&(t.style.transform="scale(".concat(o,")")),o}function oT(t,e){var n={},r=Array.isArray(e)?e:[e];for(var i in t)r.includes(i)||(n[i]=t[i]);return n}function sT(t,e){return Object.fromEntries(Object.entries(t).map(function(n){var r=V(n,2),i=r[0],a=r[1];return[i,_o(a,e)]}))}function Jat(t){if(t.type==="linear"){var e=t.startPos,n=t.endPos;return __spreadArray(__spreadArray([],__read(e),!1),__read(n),!1)}var r=t.startAngle,i=t.endAngle,a=t.center,o=t.radius;return __spreadArray(__spreadArray([r,i],__read(a),!1),[o],!1)}function dw(t,e){return e&&Xn(e)?t.filter(e):t}function cT(t,e){var n=e.startAngle,r=e.endAngle;return(r-n)*t+n}function cm(t,e){if(e.type==="linear"){var n=V(e.startPos,2),r=n[0],i=n[1],a=V(e.endPos,2),o=a[0],s=a[1],c=V([o-r,s-i],2),l=c[0],u=c[1];return eT([l,u])}var f=Jf(cT(t,e));return[-Math.sin(f),Math.cos(f)]}function hw(t,e,n){var r=cm(t,n);return h9(r,e!=="positive")}function Tp(t,e){return hw(t,e.labelDirection,e)}function T9(t,e){var n=V(e.startPos,2),r=n[0],i=n[1],a=V(e.endPos,2),o=a[0],s=a[1],c=V([o-r,s-i],2),l=c[0],u=c[1];return[r+l*t,i+u*t]}function P9(t,e){var n=e.radius,r=V(e.center,2),i=r[0],a=r[1],o=Jf(cT(t,e));return[i+n*Math.cos(o),a+n*Math.sin(o)]}function lm(t,e){return e.type==="linear"?T9(t,e):P9(t,e)}function lT(t){return cm(0,t)[1]===0}function uT(t){return cm(0,t)[0]===0}function fT(t,e){return e-t===360}function dT(t,e,n,r,i){var a=e-t,o=V([i,i],2),s=o[0],c=o[1],l=V([Jf(t),Jf(e)],2),u=l[0],f=l[1],d=function(P){return[n+i*Math.cos(P),r+i*Math.sin(P)]},h=V(d(u),2),v=h[0],g=h[1],y=V(d(f),2),b=y[0],x=y[1];if(fT(t,e)){var _=(f+u)/2,w=V(d(_),2),O=w[0],E=w[1];return[["M",v,g],["A",s,c,0,1,0,O,E],["A",s,c,0,1,0,b,x]]}var M=a>180?1:0,k=t>e?0:1,A=!1;return A?"M".concat(n,",").concat(r,",L").concat(v,",").concat(g,",A").concat(s,",").concat(c,",0,").concat(M,",").concat(k,",").concat(b,",").concat(x,",L").concat(n,",").concat(r):"M".concat(v,",").concat(g,",A").concat(s,",").concat(c,",0,").concat(M,",").concat(k,",").concat(b,",").concat(x)}function C9(t){var e=t.attributes,n=e.startAngle,r=e.endAngle,i=e.center,a=e.radius;return te(te([n,r],V(i),!1),[a],!1)}function L9(t,e,n,r){var i=e.startAngle,a=e.endAngle,o=e.center,s=e.radius;return t.selectAll(zn.line.class).data([{d:dT.apply(void 0,te(te([i,a],V(o),!1),[s],!1))}],function(c,l){return l}).join(function(c){return c.append("path").attr("className",zn.line.name).styles(e).styles({d:function(l){return l.d}})},function(c){return c.transition(function(){var l=this,u=A9(this,C9(this),te(te([i,a],V(o),!1),[s],!1),r.update);if(u){var f=function(){var d=vn(l.attributes,"__keyframe_data__");l.style.d=dT.apply(void 0,te([],V(d),!1))};u.onframe=f,u.onfinish=f}return u}).styles(e)},function(c){return c.remove()}).styles(n).transitions()}function R9(t,e){var n=e.truncRange,r=e.truncShape,i=e.lineExtension}function N9(t,e,n){n===void 0&&(n=[0,0]);var r=V([t,e,n],3),i=V(r[0],2),a=i[0],o=i[1],s=V(r[1],2),c=s[0],l=s[1],u=V(r[2],2),f=u[0],d=u[1],h=V([c-a,l-o],2),v=h[0],g=h[1],y=Math.sqrt(Math.pow(v,2)+Math.pow(g,2)),b=V([-f/y,d/y],2),x=b[0],_=b[1];return[x*v,x*g,_*v,_*g]}function hT(t){var e=V(t,2),n=V(e[0],2),r=n[0],i=n[1],a=V(e[1],2),o=a[0],s=a[1];return{x1:r,y1:i,x2:o,y2:s}}function I9(t,e,n,r){var i=e.showTrunc,a=e.startPos,o=e.endPos,s=e.truncRange,c=e.lineExtension,l=V([a,o],2),u=V(l[0],2),f=u[0],d=u[1],h=V(l[1],2),v=h[0],g=h[1],y=V(c?N9(a,o,c):new Array(4).fill(0),4),b=y[0],x=y[1],_=y[2],w=y[3],O=function(F){return t.selectAll(zn.line.class).data(F,function(W,X){return X}).join(function(W){return W.append("line").attr("className",function(X){return"".concat(zn.line.name," ").concat(X.className)}).styles(n).transition(function(X){return zo(this,hT(X.line),!1)})},function(W){return W.styles(n).transition(function(X){var Q=X.line;return zo(this,hT(Q),r.update)})},function(W){return W.remove()}).transitions()};if(!i||!s)return O([{line:[[f+b,d+x],[v+_,g+w]],className:zn.line.name}]);var E=V(s,2),M=E[0],k=E[1],A=v-f,P=g-d,C=V([f+A*M,d+P*M],2),N=C[0],L=C[1],R=V([f+A*k,d+P*k],2),I=R[0],D=R[1],G=O([{line:[[f+b,d+x],[N,L]],className:zn.lineFirst.name},{line:[[I,D],[v+_,g+w]],className:zn.lineSecond.name}]);return R9(t,e),G}function D9(t,e,n,r){var i=n.showArrow,a=n.showTrunc,o=n.lineArrow,s=n.lineArrowOffset,c=n.lineArrowSize,l;if(e==="arc"?l=t.select(zn.line.class):a?l=t.select(zn.lineSecond.class):l=t.select(zn.line.class),!i||!o||n.type==="arc"&&fT(n.startAngle,n.endAngle)){var u=l.node();u&&(u.style.markerEnd=void 0);return}var f=pu(o);f.attr(r),fw(f,c,!0),l.style("markerEnd",f).style("markerEndOffset",-s)}function j9(t,e,n){var r=e.type,i,a=en(e,"line");return r==="linear"?i=I9(t,e,oT(a,"arrow"),n):i=L9(t,e,oT(a,"arrow"),n),D9(t,r,e,a),i}function F9(t,e){return hw(t,e.gridDirection,e)}function pT(t){var e=t.type,n=t.gridCenter;return e==="linear"?n:n||t.center}function B9(t,e){var n=e.gridLength;return t.map(function(r,i){var a=r.value,o=V(lm(a,e),2),s=o[0],c=o[1],l=V(ac(F9(a,e),n),2),u=l[0],f=l[1];return{id:i,points:[[s,c],[s+u,c+f]]}})}function z9(t,e){var n=e.gridControlAngles,r=pT(e);if(!r)throw new Error("grid center is not provide");if(t.length<2)throw new Error("Invalid grid data");if(!n||n.length===0)throw new Error("Invalid gridControlAngles");var i=V(r,2),a=i[0],o=i[1];return t.map(function(s,c){var l=s.value,u=V(lm(l,e),2),f=u[0],d=u[1],h=V([f-a,d-o],2),v=h[0],g=h[1],y=[];return n.forEach(function(b){var x=Jf(b),_=V([Math.cos(x),Math.sin(x)],2),w=_[0],O=_[1],E=v*w-g*O+a,M=v*O+g*w+o;y.push([E,M])}),{points:y,id:c}})}function W9(t,e,n,r){var i=en(n,"grid"),a=i.type,o=i.areaFill,s=pT(n),c=dw(e,n.gridFilter),l=a==="segment"?B9(c,n):z9(c,n),u=At(At({},i),{center:s,areaFill:Xn(o)?c.map(function(f,d){return _o(o,[f,d,c])}):o,animate:r,data:l});return t.selectAll(zn.grid.class).data([1]).join(function(f){return f.append(function(){return new S9({style:u})}).attr("className",zn.grid.name)},function(f){return f.transition(function(){return this.update(u)})},function(f){return f.remove()}).transitions()}function Ri(t,e,n,r,i){return r===void 0&&(r=!0),i===void 0&&(i=!1),r&&t===e||i&&t===n?!0:t>e&&t<n}function G9(t){var e,n,r,i=t||1;function a(s,c){++e>i&&(r=n,o(1),++e),n[s]=c}function o(s){e=0,n=Object.create(null),s||(r=Object.create(null))}return o(),{clear:o,has:function(s){return n[s]!==void 0||r[s]!==void 0},get:function(s){var c=n[s];if(c!==void 0)return c;if((c=r[s])!==void 0)return a(s,c),c},set:function(s,c){n[s]!==void 0?n[s]=c:a(s,c)}}}var pw=new Map;function $9(t,e,n){n===void 0&&(n=128);var r=function(){for(var i=[],a=0;a<arguments.length;a++)i[a]=arguments[a];var o=e?e.apply(this,i):i[0];pw.has(t)||pw.set(t,G9(n));var s=pw.get(t);if(s.has(o))return s.get(o);var c=t.apply(this,i);return s.set(o,c),c};return r}var um,vw;function tot(t){vw=t}var Z9=$9(function(t,e){var n=e.fontSize,r=e.fontFamily,i=e.fontWeight,a=e.fontStyle,o=e.fontVariant;return vw?vw(t,n):(um||(um=Ct.offscreenCanvasCreator.getOrCreateContext(void 0)),um.font=[a,o,i,"".concat(n,"px"),r].join(" "),um.measureText(t).width)},function(t,e){return[t,Object.values(e||vT(t)).join()].join("")},4096),vT=function(t){var e=t.style.fontFamily||"sans-serif",n=t.style.fontWeight||"normal",r=t.style.fontStyle||"normal",i=t.style.fontVariant,a=t.style.fontSize;return a=typeof a=="object"?a.value:a,{fontSize:a,fontFamily:e,fontWeight:n,fontStyle:r,fontVariant:i}};function gT(t){return t.nodeName==="text"?t:t.nodeName==="g"&&t.children.length===1&&t.children[0].nodeName==="text"?t.children[0]:null}function yT(t,e){var n=gT(t);n&&n.attr(e)}function gw(t,e,n){n===void 0&&(n="..."),yT(t,{wordWrap:!0,wordWrapWidth:e,maxLines:1,textOverflow:n})}function Y9(t,e,n,r){n===void 0&&(n=2),r===void 0&&(r="top"),yT(t,{wordWrap:!0,wordWrapWidth:e,maxLines:n,textBaseline:r})}function H9(t,e,n){var r=t.getBBox(),i=r.width,a=r.height,o=V([e,n].map(function(l,u){var f;return l.includes("%")?parseFloat(((f=l.match(/[+-]?([0-9]*[.])?[0-9]+/))===null||f===void 0?void 0:f[0])||"0")/100*(u===0?i:a):l}),2),s=o[0],c=o[1];return[s,c]}function mT(t,e){if(e)try{var n=/translate\(([+-]*[\d]+[%]*),[ ]*([+-]*[\d]+[%]*)\)/g,r=e.replace(n,function(i,a,o){return"translate(".concat(H9(t,a,o),")")});t.attr("transform",r)}catch(i){}}var bT=function(t){return t!==void 0&&t!=null&&!Number.isNaN(t)};function Ni(t){if(Vn(t))return[t,t,t,t];if(Nr(t)){var e=t.length;if(e===1)return[t[0],t[0],t[0],t[0]];if(e===2)return[t[0],t[1],t[0],t[1]];if(e===3)return[t[0],t[1],t[2],t[1]];if(e===4)return t}return[0,0,0,0]}var yw=function(){function t(e,n,r,i){this.set(e,n,r,i)}return Object.defineProperty(t.prototype,"left",{get:function(){return this.x1},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"top",{get:function(){return this.y1},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"right",{get:function(){return this.x2},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"bottom",{get:function(){return this.y2},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"width",{get:function(){return this.defined("x2")&&this.defined("x1")?this.x2-this.x1:void 0},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"height",{get:function(){return this.defined("y2")&&this.defined("y1")?this.y2-this.y1:void 0},enumerable:!1,configurable:!0}),t.prototype.rotatedPoints=function(e,n,r){var i=this,a=i.x1,o=i.y1,s=i.x2,c=i.y2,l=Math.cos(e),u=Math.sin(e),f=n-n*l+r*u,d=r-n*u-r*l,h=[[l*a-u*c+f,u*a+l*c+d],[l*s-u*c+f,u*s+l*c+d],[l*a-u*o+f,u*a+l*o+d],[l*s-u*o+f,u*s+l*o+d]];return h},t.prototype.set=function(e,n,r,i){return r<e?(this.x2=e,this.x1=r):(this.x1=e,this.x2=r),i<n?(this.y2=n,this.y1=i):(this.y1=n,this.y2=i),this},t.prototype.defined=function(e){return this[e]!==Number.MAX_VALUE&&this[e]!==-Number.MAX_VALUE},t}();function fm(t,e){var n=t.getEulerAngles()||0;t.setEulerAngles(0);var r=t.getBounds(),i=V(r.min,2),a=i[0],o=i[1],s=V(r.max,2),c=s[0],l=s[1],u=t.getBBox(),f=u.width,d=u.height,h=d,v=0,g=0,y=a,b=o,x=gT(t);if(x){h-=1.5;var _=x.style.textAlign,w=x.style.textBaseline;_==="center"?y=(a+c)/2:(_==="right"||_==="end")&&(y=c),w==="middle"?b=(o+l)/2:w==="bottom"&&(b=l)}var O=V(Ni(e),4),E=O[0],M=E===void 0?0:E,k=O[1],A=k===void 0?0:k,P=O[2],C=P===void 0?M:P,N=O[3],L=N===void 0?A:N,R=new yw((v+=a)-L,(g+=o)-M,v+f+A,g+h+C);return t.setEulerAngles(n),R.rotatedPoints(Jf(n),y,b)}function Pp(t,e){return e[0]<=Math.max(t[0][0],t[1][0])&&e[0]<=Math.min(t[0][0],t[1][0])&&e[1]<=Math.max(t[0][1],t[1][1])&&e[1]<=Math.min(t[0][1],t[1][1])}function Cp(t,e,n){var r=(e[1]-t[1])*(n[0]-e[0])-(e[0]-t[0])*(n[1]-e[1]);return r===0?0:r<0?2:1}function V9(t,e){var n=Cp(t[0],t[1],e[0]),r=Cp(t[0],t[1],e[1]),i=Cp(e[0],e[1],t[0]),a=Cp(e[0],e[1],t[1]);return!!(n!==r&&i!==a||n===0&&Pp(t,e[0])||r===0&&Pp(t,e[1])||i===0&&Pp(e,t[0])||a===0&&Pp(e,t[1]))}function X9(t,e){var n=t.length;if(n<3)return!1;var r=[e,[9999,e[1]]],i=0,a=0;do{var o=[t[a],t[(a+1)%n]];if(V9(o,r)){if(Cp(o[0],e,o[1])===0)return Pp(o,e);i++}a=(a+1)%n}while(a!==0);return!!(i&1)}function U9(t,e){return e.every(function(n){return X9(t,n)})}function q9(t,e,n){var r=t.x1,i=t.x2,a=t.y1,o=t.y2,s=[[r,a],[i,a],[i,o],[r,o]],c=fm(e,n);return U9(s,c)}function xT(t,e){var n=V(t,4),r=n[0],i=n[1],a=n[2],o=n[3],s=V(e,4),c=s[0],l=s[1],u=s[2],f=s[3],d=a-r,h=o-i,v=u-c,g=f-l,y=d*g-v*h;if(y===0)return!1;var b=y>0,x=r-c,_=i-l,w=d*_-h*x;if(w<0===b)return!1;var O=v*_-g*x;return!(O<0===b||w>y===b||O>y===b)}function _T(t,e){var n=[[t[0],t[1],t[2],t[3]],[t[2],t[3],t[4],t[5]],[t[4],t[5],t[6],t[7]],[t[6],t[7],t[0],t[1]]];return n.some(function(r){return xT(e,r)})}var eot={lineToLine:xT,intersectBoxLine:_T,getBounds:fm};function K9(t,e,n){var r,i,a=fm(t,n).flat(1),o=fm(e,n).flat(1),s=[[a[0],a[1],a[2],a[3]],[a[0],a[1],a[4],a[5]],[a[4],a[5],a[6],a[7]],[a[2],a[3],a[6],a[7]]];try{for(var c=gi(s),l=c.next();!l.done;l=c.next()){var u=l.value;if(_T(o,u))return!0}}catch(f){r={error:f}}finally{try{l&&!l.done&&(i=c.return)&&i.call(c)}finally{if(r)throw r.error}}return!1}function Q9(t,e){var n=t.type,r=t.labelDirection,i=t.crossSize;if(!i)return!1;if(n==="arc"){var a=t.center,o=t.radius,s=V(a,2),c=s[0],l=s[1],u=r==="negative"?0:i,f=-o-u,d=o+u,h=V(Ni(e),4),v=h[0],g=h[1],y=h[2],b=h[3];return new yw(c+f-b,l+f-v,c+d+g,l+d+y)}var x=V(t.startPos,2),_=x[0],w=x[1],O=V(t.endPos,2),E=O[0],M=O[1],k=V(uT(t)?[-e,0,e,0]:[0,e,0,-e],4),A=k[0],P=k[1],C=k[2],N=k[3],L=Tp(0,t),R=ac(L,i),I=new yw(_,w,E,M);return I.x1+=N,I.y1+=A,I.x2+=P+R[0],I.y2+=C+R[1],I}function dm(t,e,n){var r,i,a=e.crossPadding,o=new Set,s=null,c=Q9(e,a),l=function(v){return c?q9(c,v):!0},u=function(v,g){return!v||!v.firstChild?!0:!K9(v.firstChild,g.firstChild,Ni(n))};try{for(var f=gi(t),d=f.next();!d.done;d=f.next()){var h=d.value;l(h)?!s||u(s,h)?s=h:(o.add(s),o.add(h)):o.add(h)}}catch(v){r={error:v}}finally{try{d&&!d.done&&(i=f.return)&&i.call(f)}finally{if(r)throw r.error}}return Array.from(o)}function mw(t,e){return e===void 0&&(e={}),ge(t)?0:typeof t=="number"?t:Math.floor(Z9(t,e))}function J9(t,e,n,r){if(!(t.length<=1)){var i=e.suffix,a=i===void 0?"...":i,o=e.minLength,s=e.maxLength,c=s===void 0?1/0:s,l=e.step,u=l===void 0?" ":l,f=e.margin,d=f===void 0?[0,0,0,0]:f,h=vT(r.getTextShape(t[0])),v=mw(u,h),g=o?mw(o,h):v,y=mw(c,h);(ge(y)||y===1/0)&&(y=Math.max.apply(null,t.map(function(R){return R.getBBox().width})));for(var b=t.slice(),x=V(d,4),_=x[0],w=_===void 0?0:_,O=x[1],E=O===void 0?0:O,M=x[2],k=M===void 0?w:M,A=x[3],P=A===void 0?E:A,C=function(R){if(b.forEach(function(I){r.ellipsis(r.getTextShape(I),R,a)}),b=dm(t,n,d),b.length<1)return{value:void 0}},N=y;N>g+v;N-=v){var L=C(N);if(typeof L=="object")return L.value}}}function not(t){var e=t&&t.getRenderBounds();if(!e)return{width:0,height:0};var n=e.getMax(),r=e.getMin();return{width:n[0]-r[0],height:n[1]-r[1]}}function wT(t){var e=t.getLocalBounds(),n=e.min,r=e.max,i=V([n,r],2),a=V(i[0],2),o=a[0],s=a[1],c=V(i[1],2),l=c[0],u=c[1];return{x:o,y:s,width:l-o,height:u-s,left:o,bottom:u,top:s,right:l}}function rot(t,e){var n=select(t).append("text").node();return n.attr(__assign(__assign({},e),{visibility:"hidden"})),n}function tB(t,e){var n=V(t,2),r=n[0],i=n[1],a=V(e,2),o=a[0],s=a[1];return r!==o&&i===s}function iot(t,e){var n=__read(t,2),r=n[0],i=n[1],a=__read(e,2),o=a[0],s=a[1];return r===o&&i!==s}function eB(t,e){var n,r,i=e.attributes;try{for(var a=gi(Object.entries(i)),o=a.next();!o.done;o=a.next()){var s=V(o.value,2),c=s[0],l=s[1];c!=="id"&&c!=="className"&&t.attr(c,l)}}catch(u){n={error:u}}finally{try{o&&!o.done&&(r=a.return)&&r.call(a)}finally{if(n)throw n.error}}}var nB={parity:function(t,e){var n=e.seq,r=n===void 0?2:n;return t.filter(function(i,a){return a%r?(nl(i),!1):!0})}},rB=function(t){return t.filter(bT)};function iB(t,e,n,r){var i=t.length,a=e.keepHeader,o=e.keepTail;if(!(i<=1||i===2&&a&&o)){var s=nB.parity,c=function(_){return _.forEach(r.show),_},l=2,u=t.slice(),f=t.slice(),d=Math.min.apply(Math,te([1],V(t.map(function(_){return _.getBBox().width})),!1));if(n.type==="linear"&&(lT(n)||uT(n))){var h=wT(t[0]).left,v=wT(t[i-1]).right,g=Math.abs(v-h)||1;l=Math.max(Math.floor(i*d/g),l)}var y,b;for(a&&(y=u.splice(0,1)[0]),o&&(b=u.splice(-1,1)[0],u.reverse()),c(u);l<t.length&&dm(rB(b?te(te([b],V(f),!1),[y],!1):te([y],V(f),!1)),n,e==null?void 0:e.margin).length;){if(b&&!y&&l%2===0){var x=u.splice(0,1);x.forEach(r.hide)}else if(b&&y){var x=u.splice(0,1);x.forEach(r.hide)}f=s(c(u),{seq:l}),l++}}}function aB(t,e,n,r){var i,a,o=e.optionalAngles,s=o===void 0?[0,45,90]:o,c=e.margin,l=e.recoverWhenFailed,u=l===void 0?!0:l,f=t.map(function(b){return b.getLocalEulerAngles()}),d=function(){return dm(t,n,c).length<1},h=function(b){return t.forEach(function(x,_){var w=Array.isArray(b)?b[_]:b;r.rotate(x,+w)})};try{for(var v=gi(s),g=v.next();!g.done;g=v.next()){var y=g.value;if(h(y),d())return}}catch(b){i={error:b}}finally{try{g&&!g.done&&(a=v.return)&&a.call(v)}finally{if(i)throw i.error}}u&&h(f)}function oB(t){var e=t.type,n=t.labelDirection;return e==="linear"&&lT(t)?n==="negative"?"bottom":"top":"middle"}function sB(t,e,n,r){var i=e.wordWrapWidth,a=i===void 0?50:i,o=e.maxLines,s=o===void 0?3:o,c=e.recoverWhenFailed,l=c===void 0?!0:c,u=e.margin,f=u===void 0?[0,0,0,0]:u,d=t.map(function(x){return x.attr("maxLines")||1}),h=Math.min.apply(Math,te([],V(d),!1)),v=function(){return dm(t,n,f).length<1},g=oB(n),y=function(x){return t.forEach(function(_,w){var O=Array.isArray(x)?x[w]:x;r.wrap(_,a,O,g)})};if(!(h>s)){for(var b=h;b<=s;b++)if(y(b),v())return;l&&y(d)}}var cB=new Map([["hide",iB],["rotate",aB],["ellipsis",J9],["wrap",sB]]);function lB(t,e,n){return e.labelOverlap.length<1?!1:n==="hide"?!o9(t[0]):n==="rotate"?!t.some(function(r){var i;return!!(!((i=r.attr("transform"))===null||i===void 0)&&i.includes("rotate"))}):n==="ellipsis"||n==="wrap"?t.filter(function(r){return r.querySelector("text")}).length>1:!0}function uB(t,e,n){var r=e.labelOverlap,i=r===void 0?[]:r;i.length&&i.forEach(function(a){var o=a.type,s=cB.get(o);lB(t,e,o)&&(s==null||s(t,a,e,n))})}function fB(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];var n=function(r){return r==="positive"?-1:1};return t.reduce(function(r,i){return r*n(i)},1)}function OT(t){for(var e=t;e<0;)e+=360;return Math.round(e%360)}function bw(t,e){var n=V(t,2),r=n[0],i=n[1],a=V(e,2),o=a[0],s=a[1],c=V([r*o+i*s,r*s-i*o],2),l=c[0],u=c[1];return Math.atan2(u,l)}function dB(t){var e=(t+360)%180;return Ri(e,-90,90)||(e+=180),e}function hB(t,e,n){var r,i=n.labelAlign,a=(r=e.style.transform)===null||r===void 0?void 0:r.includes("rotate");if(a)return e.getLocalEulerAngles();var o=0,s=Tp(t.value,n),c=cm(t.value,n);return i==="horizontal"?0:(i==="perpendicular"?o=bw([1,0],s):o=bw([c[0]<0?-1:1,0],c),dB(nT(o)))}function ST(t,e,n){var r=n.type,i=n.labelAlign,a=Tp(t,n),o=OT(e),s=OT(nT(bw([1,0],a))),c="center",l="middle";return r==="linear"?[90,270].includes(s)&&o===0?(c="center",l=a[1]===1?"top":"bottom"):!(s%180)&&[90,270].includes(o)?c="center":s===0?(Ri(o,0,90,!1,!0)||Ri(o,0,90)||Ri(o,270,360))&&(c="start"):s===90?Ri(o,0,90,!1,!0)?c="start":(Ri(o,90,180)||Ri(o,270,360))&&(c="end"):s===270?Ri(o,0,90,!1,!0)?c="end":(Ri(o,90,180)||Ri(o,270,360))&&(c="start"):s===180&&(o===90?c="start":(Ri(o,0,90)||Ri(o,270,360))&&(c="end")):i==="parallel"?Ri(s,0,180,!0)?l="top":l="bottom":i==="horizontal"?Ri(s,90,270,!1)?c="end":(Ri(s,270,360,!1)||Ri(s,0,90))&&(c="start"):i==="perpendicular"&&(Ri(s,90,270)?c="end":c="start"),{textAlign:c,textBaseline:l}}function pB(t,e,n){e.setLocalEulerAngles(t);var r=e.__data__.value,i=ST(r,t,n),a=e.querySelector(zn.labelItem.class);a&&MT(a,i)}function ET(t,e,n){var r=n.showTick,i=n.tickLength,a=n.tickDirection,o=n.labelDirection,s=n.labelSpacing,c=e.indexOf(t),l=_o(s,[t,c,e]),u=V([Tp(t.value,n),fB(o,a)],2),f=u[0],d=u[1],h=d===1?_o(r?i:0,[t,c,e]):0,v=V(kp(ac(f,l+h),lm(t.value,n)),2),g=v[0],y=v[1];return{x:g,y}}function vB(t,e,n,r){var i=r.labelFormatter,a=Xn(i)?function(){return pu(_o(i,[t,e,n,Tp(t.value,r)]))}:function(){return pu(t.label||"")};return a}function MT(t,e){t.nodeName==="text"&&t.attr(e)}function kT(t){uB(this.node().childNodes,t,{hide:nl,show:Mp,rotate:function(e,n){pB(+n,e,t)},ellipsis:function(e,n,r){e&&gw(e,n||1/0,r)},wrap:function(e,n,r){e&&Y9(e,n,r)},getTextShape:function(e){return e.querySelector("text")}})}function AT(t,e,n,r,i){var a=n.indexOf(e),o=Fe(t).append(vB(e,a,n,i)).attr("className",zn.labelItem.name).node(),s=V(oc(sT(r,[e,a,n])),2),c=s[0],l=s[1],u=l.transform,f=$r(l,["transform"]);mT(o,u);var d=hB(e,o,i);return o.getLocalEulerAngles()||o.setLocalEulerAngles(d),MT(o,At(At({},ST(e.value,d,i)),c)),t.attr(f),o}function gB(t,e,n,r){var i=dw(e,n.labelFilter),a=en(n,"label");return t.selectAll(zn.label.class).data(i,function(o,s){return s}).join(function(o){return o.append("g").attr("className",zn.label.name).transition(function(s){AT(this,s,e,a,n);var c=ET(s,e,n),l=c.x,u=c.y;return this.style.transform="translate(".concat(l,", ").concat(u,")"),null}).call(function(){kT.call(t,n)})},function(o){return o.transition(function(s){var c=this.querySelector(zn.labelItem.class),l=AT(this,s,e,a,n),u=r9(c,l,r.update),f=ET(s,e,n),d=f.x,h=f.y,v=zo(this,{transform:"translate(".concat(d,", ").concat(h,")")},r.update);return te(te([],V(u),!1),[v],!1)}).call(function(s){var c=vn(s,"_transitions").flat().filter(bT);e9(c,function(){kT.call(t,n)})})},function(o){return o.transition(function(){var s=this,c=sm(this.childNodes[0],r.exit);return Qf(c,function(){return Fe(s).remove()}),c})}).transitions()}function TT(t,e){return hw(t,e.tickDirection,e)}function yB(t,e){var n=V(t,2),r=n[0],i=n[1];return[[0,0],[r*e,i*e]]}function mB(t,e,n,r,i){var a=i.tickLength,o=V(yB(r,_o(a,[t,e,n])),2),s=V(o[0],2),c=s[0],l=s[1],u=V(o[1],2),f=u[0],d=u[1];return{x1:c,x2:f,y1:l,y2:d}}function bB(t,e,n,r,i){var a=i.tickFormatter,o=TT(e.value,i),s="line";return Xn(a)&&(s=function(){return _o(a,[e,n,r,o])}),t.append(s).attr("className",zn.tickItem.name)}function xB(t,e,n,r,i,a,o){var s=TT(t.value,a),c=mB(t,e,n,s,a),l=c.x1,u=c.x2,f=c.y1,d=c.y2,h=V(oc(sT(o,[t,e,n,s])),2),v=h[0],g=h[1];r.node().nodeName==="line"&&r.styles(At({x1:l,x2:u,y1:f,y2:d},v)),i.attr(g),r.styles(v)}function PT(t,e,n,r,i,a){var o=bB(Fe(this),t,e,n,r);xB(t,e,n,o,this,r,i);var s=V(lm(t.value,r),2),c=s[0],l=s[1];return zo(this,{transform:"translate(".concat(c,", ").concat(l,")")},a)}function _B(t,e,n,r){var i=dw(e,n.tickFilter),a=en(n,"tick");return t.selectAll(zn.tick.class).data(i,function(o){return o.id||o.label}).join(function(o){return o.append("g").attr("className",zn.tick.name).transition(function(s,c){return PT.call(this,s,c,i,n,a,!1)})},function(o){return o.transition(function(s,c){return this.removeChildren(),PT.call(this,s,c,i,n,a,r.update)})},function(o){return o.transition(function(){var s=this,c=sm(this.childNodes[0],r.exit);return Qf(c,function(){return s.remove()}),c})}).transitions()}var pr=function(){function t(e,n,r,i){e===void 0&&(e=0),n===void 0&&(n=0),r===void 0&&(r=0),i===void 0&&(i=0),this.x=0,this.y=0,this.width=0,this.height=0,this.x=e,this.y=n,this.width=r,this.height=i}return Object.defineProperty(t.prototype,"bottom",{get:function(){return this.y+this.height},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"left",{get:function(){return this.x},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"right",{get:function(){return this.x+this.width},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"top",{get:function(){return this.y},enumerable:!1,configurable:!0}),t.fromRect=function(e){return new t(e.x,e.y,e.width,e.height)},t.prototype.toJSON=function(){return{x:this.x,y:this.y,width:this.width,height:this.height,top:this.top,right:this.right,bottom:this.bottom,left:this.left}},t.prototype.isPointIn=function(e,n){return e>=this.left&&e<=this.right&&n>=this.top&&n<=this.bottom},t}();function aot(t){var e=t.getRenderBounds(),n=__read(e.min,2),r=n[0],i=n[1],a=__read(e.max,2),o=a[0],s=a[1],c=o-r,l=s-i;return new pr(r,i,c,l)}var CT=xo({text:"text"},"title");function hm(t){return/\S+-\S+/g.test(t)?t.split("-").map(function(e){return e[0]}):t.length>2?[t[0]]:t.split("")}function wB(t,e){var n=t.attributes,r=n.position,i=n.spacing,a=n.inset,o=n.text,s=t.getBBox(),c=e.getBBox(),l=hm(r),u=V(Ni(o?i:0),4),f=u[0],d=u[1],h=u[2],v=u[3],g=V(Ni(a),4),y=g[0],b=g[1],x=g[2],_=g[3],w=V([v+d,f+h],2),O=w[0],E=w[1],M=V([_+b,y+x],2),k=M[0],A=M[1];if(l[0]==="l")return new pr(s.x,s.y,c.width+s.width+O+k,Math.max(c.height+A,s.height));if(l[0]==="t")return new pr(s.x,s.y,Math.max(c.width+k,s.width),c.height+s.height+E+A);var P=V([e.attributes.width||c.width,e.attributes.height||c.height],2),C=P[0],N=P[1];return new pr(c.x,c.y,C+s.width+O+k,N+s.height+E+A)}function OB(t,e){var n=Object.entries(e).reduce(function(r,i){var a=V(i,2),o=a[0],s=a[1],c=t.node().attr(o);return c||(r[o]=s),r},{});t.styles(n)}function SB(t){var e,n,r,i,a=t,o=a.width,s=a.height,c=a.position,l=V([+o/2,+s/2],2),u=l[0],f=l[1],d=V([+u,+f,"center","middle"],4),h=d[0],v=d[1],g=d[2],y=d[3],b=hm(c);return b.includes("l")&&(e=V([0,"start"],2),h=e[0],g=e[1]),b.includes("r")&&(n=V([+o,"end"],2),h=n[0],g=n[1]),b.includes("t")&&(r=V([0,"top"],2),v=r[0],y=r[1]),b.includes("b")&&(i=V([+s,"bottom"],2),v=i[0],y=i[1]),{x:h,y:v,textAlign:g,textBaseline:y}}var LT=function(t){ar(e,t);function e(n){return t.call(this,n,{text:"",width:0,height:0,fill:"#4a505a",fontWeight:"bold",fontSize:12,fontFamily:"sans-serif",inset:0,spacing:0,position:"top-left"})||this}return e.prototype.getAvailableSpace=function(){var n=this,r=this.attributes,i=r.width,a=r.height,o=r.position,s=r.spacing,c=r.inset,l=n.querySelector(CT.text.class);if(!l)return new pr(0,0,+i,+a);var u=l.getBBox(),f=u.width,d=u.height,h=V(Ni(s),4),v=h[0],g=h[1],y=h[2],b=h[3],x=V([0,0,+i,+a],4),_=x[0],w=x[1],O=x[2],E=x[3],M=hm(o);if(M.includes("i"))return new pr(_,w,O,E);M.forEach(function(D,G){var F,W,X,Q;D==="t"&&(F=V(G===0?[d+y,+a-d-y]:[0,+a],2),w=F[0],E=F[1]),D==="r"&&(W=V([+i-f-b],1),O=W[0]),D==="b"&&(X=V([+a-d-v],1),E=X[0]),D==="l"&&(Q=V(G===0?[f+g,+i-f-g]:[0,+i],2),_=Q[0],O=Q[1])});var k=V(Ni(c),4),A=k[0],P=k[1],C=k[2],N=k[3],L=V([N+P,A+C],2),R=L[0],I=L[1];return new pr(_+N,w+A,O-R,E-I)},e.prototype.getBBox=function(){return this.title?this.title.getBBox():new pr(0,0,0,0)},e.prototype.render=function(n,r){var i=this,a=n.width,o=n.height,s=n.position,c=n.spacing,l=$r(n,["width","height","position","spacing"]),u=V(oc(l),1),f=u[0],d=SB(n),h=d.x,v=d.y,g=d.textAlign,y=d.textBaseline;Pa(!!l.text,Fe(r),function(b){i.title=b.maybeAppendByClassName(CT.text,"text").styles(f).call(OB,{x:h,y:v,textAlign:g,textBaseline:y}).node()})},e}(bi);function EB(t,e,n){var r=n.titlePosition,i=r===void 0?"lb":r,a=n.titleSpacing,o=hm(i),s=t.node().getLocalBounds(),c=V(s.min,2),l=c[0],u=c[1],f=V(s.halfExtents,2),d=f[0],h=f[1],v=V(e.node().getLocalBounds().halfExtents,2),g=v[0],y=v[1],b=V([l+d,u+h],2),x=b[0],_=b[1],w=V(Ni(a),4),O=w[0],E=w[1],M=w[2],k=w[3];if(["start","end"].includes(i)&&n.type==="linear"){var A=n.startPos,P=n.endPos,C=V(i==="start"?[A,P]:[P,A],2),N=C[0],L=C[1],R=eT([-L[0]+N[0],-L[1]+N[1]]),I=V(ac(R,O),2),D=I[0],G=I[1];return{x:N[0]+D,y:N[1]+G}}return o.includes("t")&&(_-=h+y+O),o.includes("r")&&(x+=d+g+E),o.includes("l")&&(x-=d+g+k),o.includes("b")&&(_+=h+y+M),{x,y:_}}function MB(t,e,n){var r=t.getGeometryBounds().halfExtents,i=r[1]*2;if(e==="vertical"){if(n==="left")return"rotate(-90) translate(0, ".concat(i/2,")");if(n==="right")return"rotate(-90) translate(0, -".concat(i/2,")")}return""}function RT(t,e,n,r,i){var a=en(r,"title"),o=V(oc(a),2),s=o[0],c=o[1],l=c.transform,u=c.transformOrigin,f=$r(c,["transform","transformOrigin"]);e.styles(f);var d=l||MB(t.node(),s.direction,s.position);t.styles(At(At({},s),{transformOrigin:u})),mT(t.node(),d);var h=EB(Fe(n._offscreen||n.querySelector(zn.mainGroup.class)),e,r),v=h.x,g=h.y,y=zo(e.node(),{transform:"translate(".concat(v,", ").concat(g,")")},i);return y}function kB(t,e,n,r){var i=n.titleText;return t.selectAll(zn.title.class).data([{title:i}].filter(function(a){return!!a.title}),function(a,o){return a.title}).join(function(a){return a.append(function(){return pu(i)}).attr("className",zn.title.name).transition(function(){return RT(Fe(this),t,e,n,r.enter)})},function(a){return a.transition(function(){return RT(Fe(this),t,e,n,r.update)})},function(a){return a.remove()}).transitions()}function NT(t,e,n,r){var i=t.showLine,a=t.showTick,o=t.showLabel,s=e.maybeAppendByClassName(zn.lineGroup,"g"),c=Pa(i,s,function(h){return j9(h,t,r)})||[],l=e.maybeAppendByClassName(zn.tickGroup,"g"),u=Pa(a,l,function(h){return _B(h,n,t,r)})||[],f=e.maybeAppendByClassName(zn.labelGroup,"g"),d=Pa(o,f,function(h){return gB(h,n,t,r)})||[];return te(te(te([],V(c),!1),V(u),!1),V(d),!1).filter(function(h){return!!h})}var xw=function(t){ar(e,t);function e(n){return t.call(this,n,ow)||this}return e.prototype.render=function(n,r,i){var a=this,o=n.titleText,s=n.data,c=n.animate,l=n.showTitle,u=n.showGrid,f=n.dataThreshold,d=n.truncRange,h=c9(s,f).filter(function(O){var E=O.value;return!(d&&E>d[0]&&E<d[1])}),v=qA(i===void 0?c:i),g=Fe(r).maybeAppendByClassName(zn.gridGroup,"g"),y=Pa(u,g,function(O){return W9(O,h,n,v)})||[],b=Fe(r).maybeAppendByClassName(zn.mainGroup,"g");o&&(!this.initialized&&v.enter||this.initialized&&v.update)&&NT(n,Fe(this.offscreenGroup),h,qA(!1));var x=NT(n,Fe(b.node()),h,v),_=Fe(r).maybeAppendByClassName(zn.titleGroup,"g"),w=Pa(l,_,function(O){return kB(O,a,n,v)})||[];return te(te(te([],V(y),!1),V(x),!1),V(w),!1).flat().filter(function(O){return!!O})},e}(bi),vu=function(t){return t};class Lp{constructor(e){this.options=mt({},this.getDefaultOptions()),this.update(e)}getOptions(){return this.options}update(e={}){this.options=mt({},this.options,e),this.rescale(e)}rescale(e){}}function pm(t,e){return e-t?n=>(n-t)/(e-t):n=>.5}function ed(t,...e){return e.reduce((n,r)=>i=>n(r(i)),t)}function _w(t,e,n,r,i){let a=n||0,o=r||t.length;const s=i||(c=>c);for(;a<o;){const c=Math.floor((a+o)/2);s(t[c])>e?o=c:a=c+1}return a}var AB=pt(19818),TB=pt.n(AB);function ww(t,e,n){let r=n;return r<0&&(r+=1),r>1&&(r-=1),r<1/6?t+(e-t)*6*r:r<1/2?e:r<2/3?t+(e-t)*(2/3-r)*6:t}function PB(t){const e=t[0]/360,n=t[1]/100,r=t[2]/100,i=t[3];if(n===0)return[r*255,r*255,r*255,i];const a=r<.5?r*(1+n):r+n-r*n,o=2*r-a,s=ww(o,a,e+1/3),c=ww(o,a,e),l=ww(o,a,e-1/3);return[s*255,c*255,l*255,i]}function IT(t){const e=TB().get(t);if(!e)return null;const{model:n,value:r}=e;return n==="rgb"?r:n==="hsl"?PB(r):null}const nd=(t,e)=>n=>t*(1-n)+e*n,CB=(t,e)=>{const n=IT(t),r=IT(e);return n===null||r===null?n?()=>t:()=>e:i=>{const a=new Array(4);for(let u=0;u<4;u+=1){const f=n[u],d=r[u];a[u]=f*(1-i)+d*i}const[o,s,c,l]=a;return`rgba(${Math.round(o)}, ${Math.round(s)}, ${Math.round(c)}, ${l})`}},Rp=(t,e)=>typeof t=="number"&&typeof e=="number"?nd(t,e):typeof t=="string"&&typeof e=="string"?CB(t,e):()=>t,LB=(t,e)=>{const n=nd(t,e);return r=>Math.round(n(r))};function RB(t){return t===null}function vm(t){return!En(t)&&!RB(t)&&!Number.isNaN(t)}const Ow=Math.sqrt(50),Sw=Math.sqrt(10),Ew=Math.sqrt(2);function gm(t,e,n){const r=(e-t)/Math.max(0,n),i=Math.floor(Math.log(r)/Math.LN10),a=r/ti(10,i);return i>=0?(a>=Ow?10:a>=Sw?5:a>=Ew?2:1)*ti(10,i):-ti(10,-i)/(a>=Ow?10:a>=Sw?5:a>=Ew?2:1)}function DT(t,e,n){const r=Math.abs(e-t)/Math.max(0,n);let i=ti(10,Math.floor(Math.log(r)/Math.LN10));const a=r/i;return a>=Ow?i*=10:a>=Sw?i*=5:a>=Ew&&(i*=2),e<t?-i:i}const jT=(t,e,n=5)=>{const r=[t,e];let i=0,a=r.length-1,o=r[i],s=r[a],c;return s<o&&([o,s]=[s,o],[i,a]=[a,i]),c=gm(o,s,n),c>0?(o=Math.floor(o/c)*c,s=Math.ceil(s/c)*c,c=gm(o,s,n)):c<0&&(o=Math.ceil(o*c)/c,s=Math.floor(s*c)/c,c=gm(o,s,n)),c>0?(r[i]=Math.floor(o/c)*c,r[a]=Math.ceil(s/c)*c):c<0&&(r[i]=Math.ceil(o*c)/c,r[a]=Math.floor(s*c)/c),r};function NB(t,e){const n=e<t?e:t,r=t>e?t:e;return i=>Math.min(Math.max(n,i),r)}const IB=(t,e,n)=>{const[r,i]=t,[a,o]=e;let s,c;return r<i?(s=pm(r,i),c=n(a,o)):(s=pm(i,r),c=n(o,a)),ed(c,s)},DB=(t,e,n)=>{const r=Math.min(t.length,e.length)-1,i=new Array(r),a=new Array(r),o=t[0]>t[r],s=o?[...t].reverse():t,c=o?[...e].reverse():e;for(let l=0;l<r;l+=1)i[l]=pm(s[l],s[l+1]),a[l]=n(c[l],c[l+1]);return l=>{const u=_w(t,l,1,r)-1,f=i[u],d=a[u];return ed(d,f)(l)}},FT=(t,e,n,r)=>(Math.min(t.length,e.length)>2?DB:IB)(t,e,r?LB:n);class ym extends Lp{getDefaultOptions(){return{domain:[0,1],range:[0,1],nice:!1,clamp:!1,round:!1,interpolate:nd,tickCount:5}}map(e){return vm(e)?this.output(e):this.options.unknown}invert(e){return vm(e)?this.input(e):this.options.unknown}nice(){if(!this.options.nice)return;const[e,n,r,...i]=this.getTickMethodOptions();this.options.domain=this.chooseNice()(e,n,r,...i)}getTicks(){const{tickMethod:e}=this.options,[n,r,i,...a]=this.getTickMethodOptions();return e(n,r,i,...a)}getTickMethodOptions(){const{domain:e,tickCount:n}=this.options,r=e[0],i=e[e.length-1];return[r,i,n]}chooseNice(){return jT}rescale(){this.nice();const[e,n]=this.chooseTransforms();this.composeOutput(e,this.chooseClamp(e)),this.composeInput(e,n,this.chooseClamp(n))}chooseClamp(e){const{clamp:n,range:r}=this.options,i=this.options.domain.map(e),a=Math.min(i.length,r.length);return n?NB(i[0],i[a-1]):vu}composeOutput(e,n){const{domain:r,range:i,round:a,interpolate:o}=this.options,s=FT(r.map(e),i,o,a);this.output=ed(s,n,e)}composeInput(e,n,r){const{domain:i,range:a}=this.options,o=FT(a,i.map(e),nd);this.input=ed(n,r,o)}}const gu=(t,e,n)=>{let r,i,a=t,o=e;if(a===o&&n>0)return[a];let s=gm(a,o,n);if(s===0||!Number.isFinite(s))return[];if(s>0){a=Math.ceil(a/s),o=Math.floor(o/s),i=new Array(r=Math.ceil(o-a+1));for(let c=0;c<r;c+=1)i[c]=(a+c)*s}else{s=-s,a=Math.ceil(a*s),o=Math.floor(o*s),i=new Array(r=Math.ceil(o-a+1));for(let c=0;c<r;c+=1)i[c]=(a+c)/s}return i};class Ji extends ym{getDefaultOptions(){return{domain:[0,1],range:[0,1],unknown:void 0,nice:!1,clamp:!1,round:!1,interpolate:Rp,tickMethod:gu,tickCount:5}}chooseTransforms(){return[vu,vu]}clone(){return new Ji(this.options)}}function jB(t,e){if(t){var n;if(Nr(t))for(var r=0,i=t.length;r<i&&(n=e(t[r],r),n!==!1);r++);else if(zl(t)){for(var a in t)if(t.hasOwnProperty(a)&&(n=e(t[a],a),n===!1))break}}}var Mw=jB,FB=function(t,e,n){if(!Nr(t)&&!nc(t))return t;var r=n;return Mw(t,function(i,a){r=e(r,i,a)}),r},BT=FB,kw=function(t,e){return BT(t,function(n,r,i){return e.includes(i)||(n[i]=r),n},{})};function sc(t,e){let n,r;if(e===void 0)for(const i of t)i!=null&&(n===void 0?i>=i&&(n=r=i):(n>i&&(n=i),r<i&&(r=i)));else{let i=-1;for(let a of t)(a=e(a,++i,t))!=null&&(n===void 0?a>=a&&(n=r=a):(n>a&&(n=a),r<a&&(r=a)))}return[n,r]}function zT(t){for(var e=1/0,n=1/0,r=-1/0,i=-1/0,a=0;a<t.length;a++){var o=t[a],s=o.x,c=o.y,l=o.width,u=o.height,f=V([s+l,c+u],2),d=f[0],h=f[1];s<e&&(e=s),c<n&&(n=c),d>r&&(r=d),h>i&&(i=h)}return new pr(e,n,r-e,i-n)}var BB=function(t,e,n){var r=t.width,i=t.height,a=n.flexDirection,o=a===void 0?"row":a,s=n.flexWrap,c=s===void 0?"nowrap":s,l=n.justifyContent,u=l===void 0?"flex-start":l,f=n.alignContent,d=f===void 0?"flex-start":f,h=n.alignItems,v=h===void 0?"flex-start":h,g=o==="row",y=o==="row"||o==="column",b=g?y?[1,0]:[-1,0]:y?[0,1]:[0,-1],x=V([0,0],2),_=x[0],w=x[1],O=e.map(function(L){var R,I=L.width,D=L.height,G=V([_,w],2),F=G[0],W=G[1];return R=V([_+I*b[0],w+D*b[1]],2),_=R[0],w=R[1],new pr(F,W,I,D)}),E=zT(O),M={"flex-start":0,"flex-end":g?r-E.width:i-E.height,center:g?(r-E.width)/2:(i-E.height)/2},k=O.map(function(L){var R=L.x,I=L.y,D=pr.fromRect(L);return D.x=g?R+M[u]:R,D.y=g?I:I+M[u],D}),A=zT(k),P=function(L){var R=V(g?["height",i]:["width",r],2),I=R[0],D=R[1];switch(v){case"flex-start":return 0;case"flex-end":return D-L[I];case"center":return D/2-L[I]/2;default:return 0}},C=k.map(function(L){var R=L.x,I=L.y,D=pr.fromRect(L);return D.x=g?R:R+P(D),D.y=g?I+P(D):I,D}),N=C.map(function(L){var R,I,D=pr.fromRect(L);return D.x+=(R=t.x)!==null&&R!==void 0?R:0,D.y+=(I=t.y)!==null&&I!==void 0?I:0,D});return N},zB=function(t,e,n){return[]},WB=function(t,e,n){if(e.length===0)return[];var r={flex:BB,grid:zB},i=n.display in r?r[n.display]:null;return(i==null?void 0:i.call(null,t,e,n))||[]},GB=function(t){ar(e,t);function e(n){var r=t.call(this,n)||this;r.layoutEvents=[$e.BOUNDS_CHANGED,$e.INSERTED,$e.REMOVED],r.$margin=Ni(0),r.$padding=Ni(0);var i=n.style||{},a=i.margin,o=a===void 0?0:a,s=i.padding,c=s===void 0?0:s;return r.margin=o,r.padding=c,r.isMutationObserved=!0,r.bindEvents(),r}return Object.defineProperty(e.prototype,"margin",{get:function(){return this.$margin},set:function(n){this.$margin=Ni(n)},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"padding",{get:function(){return this.$padding},set:function(n){this.$padding=Ni(n)},enumerable:!1,configurable:!0}),e.prototype.getBBox=function(){var n=this.attributes,r=n.x,i=r===void 0?0:r,a=n.y,o=a===void 0?0:a,s=n.width,c=n.height,l=V(this.$margin,4),u=l[0],f=l[1],d=l[2],h=l[3];return new pr(i-h,o-u,s+h+f,c+u+d)},e.prototype.appendChild=function(n,r){return n.isMutationObserved=!0,t.prototype.appendChild.call(this,n,r),n},e.prototype.getAvailableSpace=function(){var n=this.attributes,r=n.width,i=n.height,a=V(this.$padding,4),o=a[0],s=a[1],c=a[2],l=a[3],u=V(this.$margin,4),f=u[0],d=u[3];return new pr(l+d,o+f,r-l-s,i-o-c)},e.prototype.layout=function(){if(!(!this.attributes.display||!this.isConnected)&&!this.children.some(function(o){return!o.isConnected}))try{var n=this.attributes,r=n.x,i=n.y;this.style.transform="translate(".concat(r,", ").concat(i,")");var a=WB(this.getAvailableSpace(),this.children.map(function(o){return o.getBBox()}),this.attributes);this.children.forEach(function(o,s){var c=a[s],l=c.x,u=c.y;o.style.transform="translate(".concat(l,", ").concat(u,")")})}catch(o){}},e.prototype.bindEvents=function(){var n=this;this.layoutEvents.forEach(function(r){n.addEventListener(r,function(i){i.target&&(i.target.isMutationObserved=!0,n.layout())})})},e.prototype.attributeChangedCallback=function(n,r,i){n==="margin"?this.margin=i:n==="padding"&&(this.padding=i),this.layout()},e}(ui),$B=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function ZB(t){return class extends mp{constructor(e){super(e),this.descriptor=t}connectedCallback(){var e,n;(n=(e=this.descriptor).render)===null||n===void 0||n.call(e,this.attributes,this)}update(e={}){var n,r;this.attr(mt({},this.attributes,e)),(r=(n=this.descriptor).render)===null||r===void 0||r.call(n,this.attributes,this)}}}function WT(t,e,n){return t.querySelector(e)?Oe(t).select(e):Oe(t).append(n)}function mm(t){return Array.isArray(t)?t.join(", "):`${t||""}`}function GT(t,e){const n={display:"flex",flexDirection:"row",justifyContent:"flex-start",alignItems:"center"};let{flexDirection:r,justifyContent:i,alignItems:a}=n;const o={top:["row","flex-start","center"],bottom:["row","flex-start","center"],left:["column","flex-start","center"],right:["column","flex-start","center"],center:["column","center","center"]};return t in o&&([r,i,a]=o[t]),Object.assign({display:"flex",flexDirection:r,justifyContent:i,alignItems:a},e)}class $T extends GB{get child(){var e;return(e=this.children)===null||e===void 0?void 0:e[0]}update(e){var n;this.attr(e);const{subOptions:r}=e;(n=this.child)===null||n===void 0||n.update(r)}}class YB extends $T{update(e){var n;const{subOptions:r}=e;this.attr(e),(n=this.child)===null||n===void 0||n.update(r)}}function hs(t,e){var n;return(n=t.filter(r=>r.getOptions().name===e))===null||n===void 0?void 0:n[0]}function HB(t){return t==="horizontal"||t===0}function VB(t){return t==="vertical"||t===-Math.PI/2}function ZT(t,e,n){const{bbox:r}=t,{position:i="top",size:a,length:o}=e,s=["top","bottom","center"].includes(i),[c,l]=s?[r.height,r.width]:[r.width,r.height],{defaultSize:u,defaultLength:f}=n.props,d=a||u||c,h=o||f||l,v=s?"horizontal":"vertical",[g,y]=s?[h,d]:[d,h];return{orientation:v,width:g,height:y,size:d,length:h}}function XB(t){return t.find(e=>e.getOptions().domain.length>0).getOptions().domain}function bm(t){const e=["arrow","crosshairs","grid","handle","handleLabel","indicator","label","line","tick","tip","title","trunc"],{style:n}=t,r=$B(t,["style"]),i={};return Object.entries(r).forEach(([a,o])=>{e.includes(a)?i[`show${tl(a)}`]=o:i[a]=o}),Object.assign(Object.assign({},i),n)}var YT=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function HT(t,e){const{eulerAngles:n,origin:r}=e;r&&t.setOrigin(r),n&&t.rotate(n[0],n[1],n[2])}function VT(t){const{innerWidth:e,innerHeight:n,depth:r}=t.getOptions();return[e,n,r]}function UB(t,e){const{width:n,height:r}=e.getOptions();return i=>{if(!VA(e))return i;const a=t==="bottom"?[i,1]:[0,i],o=e.map(a);if(t==="bottom"){const s=o[0];return new Ji({domain:[0,n],range:[0,1]}).map(s)}else if(t==="left"){const s=o[1];return new Ji({domain:[0,r],range:[0,1]}).map(s)}return i}}function qB(t,e,n){if(t.getTicks)return t.getTicks();if(!n)return e;const[r,i]=sc(e,o=>+o),{tickCount:a}=t.getOptions();return n(r,i,a)}function KB(t,e){if(Bn(e))return h=>h;const n=e.getOptions(),{innerWidth:r,innerHeight:i,insetTop:a,insetBottom:o,insetLeft:s,insetRight:c}=n,[l,u,f]=t==="left"||t==="right"?[a,o,i]:[s,c,r],d=new Ji({domain:[0,1],range:[l/f,1-u/f]});return h=>d.map(h)}function XT(t,e,n,r,i,a,o,s){var c;(n!==void 0||a!==void 0)&&t.update(Object.assign(Object.assign({},n&&{tickCount:n}),a&&{tickMethod:a}));const l=qB(t,e,a),u=i?l.filter(i):l,f=b=>b instanceof Date?String(b):typeof b=="object"&&b?b:String(b),d=r||((c=t.getFormatter)===null||c===void 0?void 0:c.call(t))||f,h=KB(o,s),v=UB(o,s),g=b=>["top","bottom","center","outer"].includes(b),y=b=>["left","right"].includes(b);return Bn(s)||hr(s)?u.map((b,x,_)=>{var w,O;const E=((w=t.getBandWidth)===null||w===void 0?void 0:w.call(t,b))/2||0,M=h(t.map(b)+E);return{value:Sp(s)&&o==="center"||hr(s)&&((O=t.getTicks)===null||O===void 0?void 0:O.call(t))&&g(o)||hr(s)&&y(o)?1-M:M,label:f(d(rm(b),x,_)),id:String(x)}}):u.map((b,x,_)=>{var w;const O=((w=t.getBandWidth)===null||w===void 0?void 0:w.call(t,b))/2||0,E=v(h(t.map(b)+O));return{value:y(o)?1-E:E,label:f(d(rm(b),x,_)),id:String(x)}})}function QB(t,e,n="xy"){const[r,i,a]=VT(e);return n==="xy"?t.includes("bottom")||t.includes("top")?i:r:n==="xz"?t.includes("bottom")||t.includes("top")?a:r:t.includes("bottom")||t.includes("top")?i:a}function JB(t=[],e){if(t.length>0)return t;const{labelAutoRotate:n,labelAutoHide:r,labelAutoEllipsis:i,labelAutoWrap:a}=e,o=[],s=(c,l)=>{l&&o.push(Object.assign(Object.assign({},c),l))};return s({type:"rotate",optionalAngles:[0,15,30,45,60,90]},n),s({type:"ellipsis",minLength:20},i),s({type:"hide"},r),s({type:"wrap",wordWrapWidth:100,maxLines:3,recoveryWhenFail:!0},a),o}function t7(t,e,n,r,i){const{x:a,y:o,width:s,height:c}=e,l=[a+s/2,o+c/2],u=Math.min(s,c)/2,[f,d]=iw(i),[h,v]=VT(i),g=Math.min(h,v)/2,y={center:l,radius:u,startAngle:f,endAngle:d,gridLength:(r-n)*g};if(t==="inner"){const{insetLeft:b,insetTop:x}=i.getOptions();return Object.assign(Object.assign({},y),{center:[l[0]-b,l[1]-x],labelAlign:"perpendicular",labelDirection:"positive",tickDirection:"positive",gridDirection:"negative"})}return Object.assign(Object.assign({},y),{labelAlign:"parallel",labelDirection:"negative",tickDirection:"negative",gridDirection:"positive"})}function e7(t,e,n){return XA(e)||Ep(e)?!1:t===void 0?!!n.getTicks:t}function n7(t){const{depth:e}=t.getOptions();return e?{tickIsBillboard:!0,lineIsBillboard:!0,labelIsBillboard:!0,titleIsBillboard:!0,gridIsBillboard:!0}:{}}function r7(t,e,n,r,i){const{x:a,y:o,width:s,height:c}=n;if(t==="bottom")return{startPos:[a,o],endPos:[a+s,o]};if(t==="left")return{startPos:[a+s,o+c],endPos:[a+s,o]};if(t==="right")return{startPos:[a,o+c],endPos:[a,o]};if(t==="top")return{startPos:[a,o+c],endPos:[a+s,o+c]};if(t==="center"){if(e==="vertical")return{startPos:[a,o],endPos:[a,o+c]};if(e==="horizontal")return{startPos:[a,o],endPos:[a+s,o]};if(typeof e=="number"){const[l,u]=r.getCenter(),[f,d]=im(r),[h,v]=iw(r),g=Math.min(s,c)/2,{insetLeft:y,insetTop:b}=r.getOptions(),x=f*g,_=d*g,[w,O]=[l+a-y,u+o-b],[E,M]=[Math.cos(e),Math.sin(e)],k=[w+_*E,O+_*M],A=[w+x*E,O+x*M],P=()=>{const{domain:N}=i.getOptions();return N.length},C=Bn(r)&&i?P():3;return{startPos:k,endPos:A,gridClosed:Math.abs(v-h-360)<1e-6,gridCenter:[w,O],gridControlAngles:new Array(C).fill(0).map((N,L,R)=>(v-h)/C*L)}}}return{}}const i7=t=>{const{order:e,size:n,position:r,orientation:i,labelFormatter:a,tickFilter:o,tickCount:s,tickMethod:c,important:l={},style:u={},indexBBox:f,title:d,grid:h=!1}=t,v=YT(t,["order","size","position","orientation","labelFormatter","tickFilter","tickCount","tickMethod","important","style","indexBBox","title","grid"]);return({scales:[g],value:y,coordinate:b,theme:x})=>{const{bbox:_}=y,{domain:w}=g.getOptions(),O=XT(g,w,s,a,o,c,r,b),E=f?O.map((L,R)=>{const I=f.get(R);return!I||I[0]!==L.label?L:Object.assign(Object.assign({},L),{bbox:I[1]})}):O,[M,k]=im(b),A=t7(r,_,M,k,b),{axis:P,axisArc:C={}}=x,N=bm(mt({},P,C,A,Object.assign(Object.assign({type:"arc",data:E,titleText:mm(d),grid:h},v),l)));return new xw({style:kw(N,["transform"])})}};function a7(t,e,n,r,i,a){const o=n.axis,s=["top","right","bottom","left"].includes(i)?n[`axis${K_(i)}`]:n.axisLinear,c=t.getOptions().name,l=n[`axis${tl(c)}`]||{};return Object.assign({},o,s,l)}function o7(t,e,n,r,i,a){const o=a7(t,e,n,r,i,a);return i==="center"?Object.assign(Object.assign(Object.assign(Object.assign({},o),{labelDirection:r==="right"?"negative":"positive"}),r==="center"?{labelTransform:"translate(50%,0)"}:null),{tickDirection:r==="right"?"negative":"positive",labelSpacing:r==="center"?0:4,titleSpacing:VB(a)?10:0,tick:r==="center"?!1:void 0}):o}const s7=t=>{const{direction:e="left",important:n={},labelFormatter:r,order:i,orientation:a,actualPosition:o,position:s,size:c,style:l={},title:u,tickCount:f,tickFilter:d,tickMethod:h,transform:v,indexBBox:g}=t,y=YT(t,["direction","important","labelFormatter","order","orientation","actualPosition","position","size","style","title","tickCount","tickFilter","tickMethod","transform","indexBBox"]);return({scales:b,value:x,coordinate:_,theme:w})=>{const{bbox:O}=x,[E]=b,{domain:M,xScale:k}=E.getOptions(),A=o7(E,_,w,e,s,a),P=Object.assign(Object.assign(Object.assign({},A),l),y),C=QB(o||s,_,t.plane),N=r7(s,a,O,_,k),L=n7(_),R=XT(E,M,f,r,d,h,s,_),I=g?R.map((F,W)=>{const X=g.get(W);return!X||X[0]!==F.label?F:Object.assign(Object.assign({},F),{bbox:X[1]})}):R,D=Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({},P),{type:"linear",data:I,crossSize:c,titleText:mm(u),labelOverlap:JB(v,P),grid:e7(P.grid,_,E),gridLength:C,line:!0,indexBBox:g}),P.line?null:{lineOpacity:0}),N),L),n);return D.labelOverlap.find(F=>F.type==="hide")&&(D.crossSize=!1),new xw({className:"axis",style:bm(D)})}},UT=t=>e=>{const{labelFormatter:n,labelFilter:r=()=>!0}=e;return i=>{var a;const{scales:[o]}=i,s=((a=o.getTicks)===null||a===void 0?void 0:a.call(o))||o.getOptions().domain,c=typeof n=="string"?el(n):n,l=(f,d,h)=>r(s[d],d,s),u=Object.assign(Object.assign({},e),{labelFormatter:c,labelFilter:l,scale:o});return t(u)(i)}},rl=UT(s7),qT=UT(i7);rl.props={defaultPosition:"center",defaultSize:45,defaultOrder:0,defaultCrossPadding:[12,12],defaultPadding:[12,12]},qT.props={defaultPosition:"outer",defaultOrientation:"vertical",defaultSize:45,defaultOrder:0,defaultCrossPadding:[12,12],defaultPadding:[12,12]};var c7=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function l7(t){const e=t%(Math.PI*2);return e===Math.PI/2?{titleTransform:"translate(0, 50%)"}:e>-Math.PI/2&&e<Math.PI/2?{titleTransform:"translate(50%, 0)"}:e>Math.PI/2&&e<Math.PI*3/2?{titleTransform:"translate(-50%, 0)"}:{}}function u7(t,e,n,r){const{radar:i}=t,[a]=r,o=a.getOptions().name,[s,c]=iw(n),{axisRadar:l={}}=e;return Object.assign(Object.assign({},l),{grid:o==="position",gridConnect:"line",gridControlAngles:new Array(i.count).fill(0).map((u,f)=>(c-s)/i.count*f)})}const KT=t=>{const{important:e={}}=t,n=c7(t,["important"]);return r=>{const{theme:i,coordinate:a,scales:o}=r;return rl(Object.assign(Object.assign(Object.assign({},n),l7(t.orientation)),{important:Object.assign(Object.assign({},u7(t,i,a,o)),e)}))(r)}};KT.props=Object.assign(Object.assign({},rl.props),{defaultPosition:"center"});function xm(t,e){return+t.toPrecision(e)}function oot(t){return t.toLocaleString()}function sot(t){return t.toExponential()}function cot(t,e){return e===void 0&&(e=0),Math.abs(t)<1e3?String(t):"".concat(xm(t/1e3,e).toLocaleString(),"K")}var lot=function(t,e,n){return t<0&&Number.isFinite(t)?e:n},uot=function(t,e,n){return t>0&&Number.isFinite(t)?e:n},fot=function(t,e){return t*e},dot=function(t,e){return t/2+(e||0)/2};function _m(t){var e=t.canvas,n=t.touches,r=t.offsetX,i=t.offsetY;if(e){var a=e.x,o=e.y;return[a,o]}if(n){var s=n[0],c=s.clientX,l=s.clientY;return[c,l]}return r&&i?[r,i]:[0,0]}var f7={backgroundFill:"#262626",backgroundLineCap:"round",backgroundLineWidth:1,backgroundStroke:"#333",backgroundZIndex:-1,formatter:function(t){return t.toString()},labelFill:"#fff",labelFontSize:12,labelTextBaseline:"middle",padding:[2,4],position:"right",radius:0,zIndex:999},Aw=xo({background:"background",labelGroup:"label-group",label:"label"},"indicator"),d7=function(t){ar(e,t);function e(n){var r=t.call(this,n,f7)||this;return r.point=[0,0],r.group=r.appendChild(new ui({})),r.isMutationObserved=!0,r}return e.prototype.renderBackground=function(){if(this.label){var n=this.attributes,r=n.position,i=n.padding,a=V(Ni(i),4),o=a[0],s=a[1],c=a[2],l=a[3],u=this.label.node().getLocalBounds(),f=u.min,d=u.max,h=new pr(f[0]-l,f[1]-o,d[0]+s-f[0]+l,d[1]+c-f[1]+o),v=this.getPath(r,h),g=en(this.attributes,"background");this.background=Fe(this.group).maybeAppendByClassName(Aw.background,"path").styles(At(At({},g),{d:v})),this.group.appendChild(this.label.node())}},e.prototype.renderLabel=function(){var n=this.attributes,r=n.formatter,i=n.labelText,a=en(this.attributes,"label"),o=V(oc(a),2),s=o[0],c=o[1],l=s.text,u=$r(s,["text"]);if(this.label=Fe(this.group).maybeAppendByClassName(Aw.labelGroup,"g").styles(c),!!i){var f=this.label.maybeAppendByClassName(Aw.label,function(){return pu(r(i))}).style("text",r(i).toString());f.selectAll("text").styles(u)}},e.prototype.adjustLayout=function(){var n=V(this.point,2),r=n[0],i=n[1],a=this.attributes,o=a.x,s=a.y;this.group.attr("transform","translate(".concat(o-r,", ").concat(s-i,")"))},e.prototype.getPath=function(n,r){var i=this.attributes.radius,a=r.x,o=r.y,s=r.width,c=r.height,l=[["M",a+i,o],["L",a+s-i,o],["A",i,i,0,0,1,a+s,o+i],["L",a+s,o+c-i],["A",i,i,0,0,1,a+s-i,o+c],["L",a+i,o+c],["A",i,i,0,0,1,a,o+c-i],["L",a,o+i],["A",i,i,0,0,1,a+i,o],["Z"]],u={top:4,right:6,bottom:0,left:2},f=u[n],d=this.createCorner([l[f].slice(-2),l[f+1].slice(-2)]);return l.splice.apply(l,te([f+1,1],V(d),!1)),l[0][0]="M",l},e.prototype.createCorner=function(n,r){r===void 0&&(r=10);var i=.8,a=tB.apply(void 0,te([],V(n),!1)),o=V(n,2),s=V(o[0],2),c=s[0],l=s[1],u=V(o[1],2),f=u[0],d=u[1],h=V(a?[f-c,[c,f]]:[d-l,[l,d]],2),v=h[0],g=V(h[1],2),y=g[0],b=g[1],x=v/2,_=v/Math.abs(v),w=r*_,O=w/2,E=w*Math.sqrt(3)/2*i,M=V([y,y+x-O,y+x,y+x+O,b],5),k=M[0],A=M[1],P=M[2],C=M[3],N=M[4];return a?(this.point=[P,l-E],[["L",k,l],["L",A,l],["L",P,l-E],["L",C,l],["L",N,l]]):(this.point=[c+E,P],[["L",c,k],["L",c,A],["L",c+E,P],["L",c,C],["L",c,N]])},e.prototype.applyVisibility=function(){var n=this.attributes.visibility;n==="hidden"?nl(this):Mp(this)},e.prototype.bindEvents=function(){this.label.on($e.BOUNDS_CHANGED,this.renderBackground)},e.prototype.render=function(){this.renderLabel(),this.renderBackground(),this.adjustLayout(),this.applyVisibility()},e}(bi),QT={fill:"#fff",lineWidth:1,radius:2,size:10,stroke:"#bfbfbf",strokeOpacity:1,zIndex:0},JT={fill:"#000",fillOpacity:.45,fontSize:12,textAlign:"center",textBaseline:"middle",zIndex:1},tP={x:0,y:0,orientation:"horizontal",showLabel:!0,type:"start"},ps=xo({foreground:"foreground",handle:"handle",selection:"selection",sparkline:"sparkline",sparklineGroup:"sparkline-group",track:"track",brushArea:"brush-area"},"slider"),il=xo({labelGroup:"label-group",label:"label",iconGroup:"icon-group",icon:"icon",iconRect:"icon-rect",iconLine:"icon-line"},"handle"),h7=function(t){ar(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}return e.prototype.render=function(n,r){var i=n.x,a=n.y,o=n.size,s=o===void 0?10:o,c=n.radius,l=c===void 0?s/4:c,u=n.orientation,f=$r(n,["x","y","size","radius","orientation"]),d=s,h=d*2.4,v=Fe(r).maybeAppendByClassName(il.iconRect,"rect").styles(At(At({},f),{width:d,height:h,radius:l,x:i-d/2,y:a-h/2,transformOrigin:"center"})),g=i+1/3*d-d/2,y=i+2/3*d-d/2,b=a+1/4*h-h/2,x=a+3/4*h-h/2;v.maybeAppendByClassName("".concat(il.iconLine,"-1"),"line").styles(At({x1:g,x2:g,y1:b,y2:x},f)),v.maybeAppendByClassName("".concat(il.iconLine,"-2"),"line").styles(At({x1:y,x2:y,y1:b,y2:x},f)),u==="vertical"&&(v.node().style.transform="rotate(90)")},e}(bi),eP=function(t){ar(e,t);function e(n){return t.call(this,n,tP)||this}return e.prototype.renderLabel=function(n){var r=this,i=this.attributes,a=i.x,o=i.y,s=i.showLabel,c=en(this.attributes,"label"),l=c.x,u=l===void 0?0:l,f=c.y,d=f===void 0?0:f,h=c.transform,v=c.transformOrigin,g=$r(c,["x","y","transform","transformOrigin"]),y=V(oc(g,[]),2),b=y[0],x=y[1],_=Fe(n).maybeAppendByClassName(il.labelGroup,"g").styles(x),w=At(At({},JT),b),O=w.text,E=$r(w,["text"]);Pa(!!s,_,function(M){r.label=M.maybeAppendByClassName(il.label,"text").styles(At(At({},E),{x:a+u,y:o+d,transform:h,transformOrigin:v,text:"".concat(O)})),r.label.on("mousedown",function(k){k.stopPropagation()}),r.label.on("touchstart",function(k){k.stopPropagation()})})},e.prototype.renderIcon=function(n){var r=this.attributes,i=r.x,a=r.y,o=r.orientation,s=r.type,c=At(At({x:i,y:a,orientation:o},QT),en(this.attributes,"icon")),l=this.attributes.iconShape,u=l===void 0?function(){return new h7({style:c})}:l,f=Fe(n).maybeAppendByClassName(il.iconGroup,"g");f.selectAll(il.icon.class).data([u]).join(function(d){return d.append(typeof u=="string"?u:function(){return u(s)}).attr("className",il.icon.name)},function(d){return d.update(c)},function(d){return d.remove()})},e.prototype.render=function(n,r){this.renderIcon(r),this.renderLabel(r)},e}(bi),nP=function(t,e,n){return[["M",t-n,e],["A",n,n,0,1,0,t+n,e],["A",n,n,0,1,0,t-n,e],["Z"]]},p7=nP,v7=function(t,e,n){return[["M",t-n,e-n],["L",t+n,e-n],["L",t+n,e+n],["L",t-n,e+n],["Z"]]},g7=function(t,e,n){return[["M",t-n,e],["L",t,e-n],["L",t+n,e],["L",t,e+n],["Z"]]},y7=function(t,e,n){var r=n*Math.sin(.3333333333333333*Math.PI);return[["M",t-n,e+r],["L",t,e-r],["L",t+n,e+r],["Z"]]},m7=function(t,e,n){var r=n*Math.sin(.3333333333333333*Math.PI);return[["M",t-n,e-r],["L",t+n,e-r],["L",t,e+r],["Z"]]},b7=function(t,e,n){var r=n/2*Math.sqrt(3);return[["M",t,e-n],["L",t+r,e-n/2],["L",t+r,e+n/2],["L",t,e+n],["L",t-r,e+n/2],["L",t-r,e-n/2],["Z"]]},x7=function(t,e,n){var r=n-1.5;return[["M",t-n,e-r],["L",t+n,e+r],["L",t+n,e-r],["L",t-n,e+r],["Z"]]},rP=function(t,e,n){return[["M",t,e+n],["L",t,e-n]]},_7=function(t,e,n){return[["M",t-n,e-n],["L",t+n,e+n],["M",t+n,e-n],["L",t-n,e+n]]},w7=function(t,e,n){return[["M",t-n/2,e-n],["L",t+n/2,e-n],["M",t,e-n],["L",t,e+n],["M",t-n/2,e+n],["L",t+n/2,e+n]]},O7=function(t,e,n){return[["M",t-n,e],["L",t+n,e],["M",t,e-n],["L",t,e+n]]},S7=function(t,e,n){return[["M",t-n,e],["L",t+n,e]]},iP=function(t,e,n){return[["M",t-n,e],["L",t+n,e]]},E7=iP,M7=function(t,e,n){return[["M",t-n,e],["A",n/2,n/2,0,1,1,t,e],["A",n/2,n/2,0,1,0,t+n,e]]},k7=function(t,e,n){return[["M",t-n-1,e-2.5],["L",t,e-2.5],["L",t,e+2.5],["L",t+n+1,e+2.5]]},A7=function(t,e,n){return[["M",t-n-1,e+2.5],["L",t,e+2.5],["L",t,e-2.5],["L",t+n+1,e-2.5]]},T7=function(t,e,n){return[["M",t-(n+1),e+2.5],["L",t-n/2,e+2.5],["L",t-n/2,e-2.5],["L",t+n/2,e-2.5],["L",t+n/2,e+2.5],["L",t+n+1,e+2.5]]};function P7(t,e){return[["M",t-5,e+2.5],["L",t-5,e],["L",t,e],["L",t,e-3],["L",t,e+3],["L",t+6.5,e+3]]}var C7=function(t,e,n){return[["M",t-n,e-n],["L",t+n,e],["L",t-n,e+n],["Z"]]};function L7(t){var e="default";if(zl(t)&&t instanceof Image)e="image";else if(Xn(t))e="symbol";else if(ir(t)){var n=new RegExp("data:(image|text)");t.match(n)?e="base64":/^(https?:\/\/(([a-zA-Z0-9]+-?)+[a-zA-Z0-9]+\.)+[a-zA-Z]+)(:\d+)?(\/.*)?(\?.*)?(#.*)?$/.test(t)?e="url":e="symbol"}return e}function R7(t){var e=L7(t);return["base64","url","image"].includes(e)?"image":t&&e==="symbol"?"path":null}var An=function(t){ar(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}return e.prototype.render=function(n,r){var i=n.x,a=i===void 0?0:i,o=n.y,s=o===void 0?0:o,c=this.getSubShapeStyle(n),l=c.symbol,u=c.size,f=u===void 0?16:u,d=$r(c,["symbol","size"]),h=R7(l);Pa(!!h,Fe(r),function(v){v.maybeAppendByClassName("marker",h).attr("className","marker ".concat(h,"-marker")).call(function(g){if(h==="image"){var y=f*2;g.styles({img:l,width:y,height:y,x:a-f,y:s-f})}else{var y=f/2,b=Xn(l)?l:e.getSymbol(l);g.styles(At({d:b==null?void 0:b(a,s,y)},d))}})})},e.MARKER_SYMBOL_MAP=new Map,e.registerSymbol=function(n,r){e.MARKER_SYMBOL_MAP.set(n,r)},e.getSymbol=function(n){return e.MARKER_SYMBOL_MAP.get(n)},e.getSymbols=function(){return Array.from(e.MARKER_SYMBOL_MAP.keys())},e}(bi);An.registerSymbol("cross",_7),An.registerSymbol("hyphen",S7),An.registerSymbol("line",rP),An.registerSymbol("plus",O7),An.registerSymbol("tick",w7),An.registerSymbol("circle",nP),An.registerSymbol("point",p7),An.registerSymbol("bowtie",x7),An.registerSymbol("hexagon",b7),An.registerSymbol("square",v7),An.registerSymbol("diamond",g7),An.registerSymbol("triangle",y7),An.registerSymbol("triangle-down",m7),An.registerSymbol("line",rP),An.registerSymbol("dot",iP),An.registerSymbol("dash",E7),An.registerSymbol("smooth",M7),An.registerSymbol("hv",k7),An.registerSymbol("vh",A7),An.registerSymbol("hvh",T7),An.registerSymbol("vhv",P7);function N7(t,e,n){var r=Math.round((t-n)/e);return n+r*e}function I7(t,e,n){var r=1.4,i=r*n;return[["M",t-n,e-i],["L",t+n,e-i],["L",t+n,e+i],["L",t-n,e+i],["Z"]]}var aP=1.4,oP=.4;function D7(t,e,n){var r=n,i=r*aP,a=r/2,o=r/6,s=t+i*oP;return[["M",t,e],["L",s,e+a],["L",t+i,e+a],["L",t+i,e-a],["L",s,e-a],["Z"],["M",s,e+o],["L",t+i-2,e+o],["M",s,e-o],["L",t+i-2,e-o]]}function j7(t,e,n){var r=n,i=r*aP,a=r/2,o=r/6,s=e+i*oP;return[["M",t,e],["L",t-a,s],["L",t-a,e+i],["L",t+a,e+i],["L",t+a,s],["Z"],["M",t-o,s],["L",t-o,e+i-2],["M",t+o,s],["L",t+o,e+i-2]]}An.registerSymbol("hiddenHandle",I7),An.registerSymbol("verticalHandle",D7),An.registerSymbol("horizontalHandle",j7);var hot=function(t,e,n){return t===void 0&&(t="horizontal"),t==="horizontal"?e:n};function F7(t,e,n,r){var i;r===void 0&&(r=4);var a=V(t,2),o=a[0],s=a[1],c=V(e,2),l=c[0],u=c[1],f=V(n,2),d=f[0],h=f[1],v=V([l,u],2),g=v[0],y=v[1],b=y-g;return g>y&&(i=V([y,g],2),g=i[0],y=i[1]),b>s-o?[o,s]:g<o?d===o&&h===y?[o,y]:[o,b+o]:y>s?h===s&&d===g?[g,s]:[s-b,s]:[g,y]}function vs(t,e,n){return t===void 0&&(t="horizontal"),t==="horizontal"?e:n}var Np=xo({markerGroup:"marker-group",marker:"marker",labelGroup:"label-group",label:"label"},"handle"),sP={showLabel:!0,formatter:function(t){return t.toString()},markerSize:25,markerStroke:"#c5c5c5",markerFill:"#fff",markerLineWidth:1,labelFontSize:12,labelFill:"#c5c5c5",labelText:"",orientation:"vertical",spacing:0},B7=function(t){ar(e,t);function e(n){return t.call(this,n,sP)||this}return e.prototype.render=function(n,r){var i=Fe(r).maybeAppendByClassName(Np.markerGroup,"g");this.renderMarker(i);var a=Fe(r).maybeAppendByClassName(Np.labelGroup,"g");this.renderLabel(a)},e.prototype.renderMarker=function(n){var r=this,i=this.attributes,a=i.orientation,o=i.markerSymbol,s=o===void 0?vs(a,"horizontalHandle","verticalHandle"):o;Pa(!!s,n,function(c){var l=en(r.attributes,"marker"),u=At({symbol:s},l);r.marker=c.maybeAppendByClassName(Np.marker,function(){return new An({style:u})}).update(u)})},e.prototype.renderLabel=function(n){var r=this,i=this.attributes,a=i.showLabel,o=i.orientation,s=i.spacing,c=s===void 0?0:s,l=i.formatter;Pa(a,n,function(u){var f,d=en(r.attributes,"label"),h=d.text,v=$r(d,["text"]),g=((f=u.select(Np.marker.class))===null||f===void 0?void 0:f.node().getBBox())||{},y=g.width,b=y===void 0?0:y,x=g.height,_=x===void 0?0:x,w=V(vs(o,[0,_+c,"center","top"],[b+c,0,"start","middle"]),4),O=w[0],E=w[1],M=w[2],k=w[3];u.maybeAppendByClassName(Np.label,"text").styles(At(At({},v),{x:O,y:E,text:l(h).toString(),textAlign:M,textBaseline:k}))})},e}(bi),cP={showTitle:!0,padding:0,orientation:"horizontal",backgroundFill:"transparent",titleText:"",titleSpacing:4,titlePosition:"top-left",titleFill:"#2C3542",titleFontWeight:"bold",titleFontFamily:"sans-serif",titleFontSize:12},z7=ic({},cP,{}),W7=ic({},cP,ds(sP,"handle"),{color:["#d0e3fa","#acc7f6","#8daaf2","#6d8eea","#4d73cd","#325bb1","#5a3e75","#8c3c79","#e23455","#e7655b"],indicatorBackgroundFill:"#262626",indicatorLabelFill:"white",indicatorLabelFontSize:12,indicatorVisibility:"hidden",labelAlign:"value",labelDirection:"positive",labelSpacing:5,showHandle:!0,showIndicator:!0,showLabel:!0,slidable:!0,titleText:"",type:"continuous"}),G7=.01,pot=.5,Ii=xo({title:"title",titleGroup:"title-group",items:"items",itemsGroup:"items-group",contentGroup:"content-group",ribbonGroup:"ribbon-group",ribbon:"ribbon",handlesGroup:"handles-group",handle:"handle",startHandle:"start-handle",endHandle:"end-handle",labelGroup:"label-group",label:"label",indicator:"indicator"},"legend");function $7(t,e){for(var n=1;n<t.length;n+=1){var r=t[n-1],i=t[n];if(e>=r&&e<=i)return[r,i]}return[e,e]}function Z7(t,e,n){var r=Array.from(e),i=t.length;return new Array(i).fill(0).reduce(function(a,o,s){var c=r[s%r.length];return a+=" ".concat(t[s],":").concat(c).concat(s<i-1?" ".concat(t[s+1],":").concat(c):"")},"l(".concat(n==="horizontal"?"0":"270",")"))}function lP(t,e){var n=V($7(t,e),2),r=n[0],i=n[1];return{tick:e>(r+i)/2?i:r,range:[r,i]}}var Ip=xo({trackGroup:"background-group",track:"background",selectionGroup:"ribbon-group",selection:"ribbon",clipPath:"clip-path"},"ribbon");function uP(t){var e=t.orientation,n=t.size,r=t.length;return vs(e,[r,n],[n,r])}function fP(t){var e=t.type,n=V(uP(t),2),r=n[0],i=n[1];return e==="size"?[["M",0,i],["L",0+r,0],["L",0+r,i],["Z"]]:[["M",0,i],["L",0,0],["L",0+r,0],["L",0+r,i],["Z"]]}function Y7(t){return fP(t)}function H7(t){var e=t.orientation,n=t.color,r=t.block,i=t.partition,a;if(Xn(n)){var o=20;a=new Array(o).fill(0).map(function(l,u,f){return n(u/(f.length-1))})}else a=n;var s=a.length,c=a.map(function(l){return os(l).toString()});return s?s===1?c[0]:r?Z7(i,c,e):c.reduce(function(l,u,f){return l+=" ".concat(f/(s-1),":").concat(u)},"l(".concat(vs(e,"0","270"),")")):""}function V7(t){var e=t.orientation,n=t.range;if(!n)return[];var r=V(uP(t),2),i=r[0],a=r[1],o=V(n,2),s=o[0],c=o[1],l=vs(e,s*i,0),u=vs(e,0,s*a),f=vs(e,c*i,i),d=vs(e,a,c*a);return[["M",l,u],["L",l,d],["L",f,d],["L",f,u],["Z"]]}function X7(t,e){var n=en(e,"track");t.maybeAppendByClassName(Ip.track,"path").styles(At({d:fP(e)},n))}function U7(t,e){var n=en(e,"selection"),r=H7(e),i=t.maybeAppendByClassName(Ip.selection,"path").styles(At({d:Y7(e),fill:r},n)),a=i.maybeAppendByClassName(Ip.clipPath,"path").styles({d:V7(e)}).node();i.style("clipPath",a)}var q7=function(t){ar(e,t);function e(n){return t.call(this,n,{type:"color",orientation:"horizontal",size:30,range:[0,1],length:200,block:!1,partition:[],color:["#fff","#000"],trackFill:"#e5e5e5"})||this}return e.prototype.render=function(n,r){var i=Fe(r).maybeAppendByClassName(Ip.trackGroup,"g");X7(i,n);var a=Fe(r).maybeAppendByClassName(Ip.selectionGroup,"g");U7(a,n)},e}(bi);function K7(t){return{min:Math.min.apply(Math,te([],V(t.map(function(e){return e.value})),!1)),max:Math.max.apply(Math,te([],V(t.map(function(e){return e.value})),!1))}}var Q7=function(t){ar(e,t);function e(n){var r=t.call(this,n,W7)||this;return r.eventToOffsetScale=new Ji({}),r.innerRibbonScale=new Ji({}),r.cacheLabelBBox=null,r.cacheHandleBBox=null,r.onHovering=function(i){var a=r.attributes,o=a.data,s=a.block;i.stopPropagation();var c=r.getValueByCanvasPoint(i);if(s){var l=lP(o.map(function(d){var h=d.value;return h}),c).range,u=r.getRealSelection(l);r.showIndicator((l[0]+l[1])/2,"".concat(u[0],"-").concat(u[1])),r.dispatchIndicated(c,l)}else{var f=r.getTickValue(c);r.showIndicator(f,"".concat(r.getRealValue(f))),r.dispatchIndicated(f)}},r.onDragStart=function(i){return function(a){a.stopPropagation(),r.attributes.slidable&&(r.target=i,r.prevValue=r.getTickValue(r.getValueByCanvasPoint(a)),document.addEventListener("mousemove",r.onDragging),document.addEventListener("touchmove",r.onDragging),document.addEventListener("mouseleave",r.onDragEnd),document.addEventListener("mouseup",r.onDragEnd),document.addEventListener("mouseup",r.onDragEnd),document.addEventListener("touchend",r.onDragEnd))}},r.onDragging=function(i){var a=r.target;r.updateMouse();var o=V(r.selection,2),s=o[0],c=o[1],l=r.getTickValue(r.getValueByCanvasPoint(i)),u=l-r.prevValue;a==="start"?s!==l&&r.updateSelection(l,c):a==="end"?c!==l&&r.updateSelection(s,l):a==="ribbon"&&u!==0&&(r.prevValue=l,r.updateSelection(u,u,!0))},r.onDragEnd=function(){r.style.cursor="pointer",document.removeEventListener("mousemove",r.onDragging),document.removeEventListener("touchmove",r.onDragging),document.removeEventListener("mouseup",r.onDragEnd),document.removeEventListener("touchend",r.onDragEnd)},r}return Object.defineProperty(e.prototype,"handleOffsetRatio",{get:function(){return this.ifHorizontal(.5,.5)},enumerable:!1,configurable:!0}),e.prototype.getBBox=function(){var n=this.attributes,r=n.width,i=n.height;return new pr(0,0,r,i)},e.prototype.render=function(n,r){var i=this,a=n.showLabel;this.renderTitle(Fe(r));var o=this.availableSpace,s=o.x,c=o.y,l=Fe(r).maybeAppendByClassName(Ii.contentGroup,"g").styles({transform:"translate(".concat(s,", ").concat(c,")")}),u=l.maybeAppendByClassName(Ii.labelGroup,"g").styles({zIndex:1});Pa(!!a,u,function(d){i.renderLabel(d)});var f=l.maybeAppendByClassName(Ii.ribbonGroup,"g").styles({zIndex:0});this.handlesGroup=l.maybeAppendByClassName(Ii.handlesGroup,"g").styles({zIndex:2}),this.renderHandles(),this.renderRibbon(f),this.renderIndicator(l),this.adjustLabel(),this.adjustHandles()},Object.defineProperty(e.prototype,"range",{get:function(){var n=this.attributes,r=n.data,i=n.domain;return i?{min:i[0],max:i[1]}:K7(r)},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"ribbonScale",{get:function(){var n=this.range,r=n.min,i=n.max;return this.innerRibbonScale.update({domain:[r,i],range:[0,1]}),this.innerRibbonScale},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"ribbonRange",{get:function(){var n=V(this.selection,2),r=n[0],i=n[1],a=this.ribbonScale;return[a.map(r),a.map(i)]},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"selection",{get:function(){var n=this.range,r=n.min,i=n.max,a=this.attributes.defaultValue,o=a===void 0?[r,i]:a,s=V(o,2),c=s[0],l=s[1];return[c,l]},enumerable:!1,configurable:!0}),e.prototype.ifHorizontal=function(n,r){return vs(this.attributes.orientation,typeof n=="function"?n():n,typeof r=="function"?r():r)},e.prototype.renderTitle=function(n){var r=this.attributes,i=r.showTitle,a=r.titleText,o=r.width,s=r.height,c=en(this.attributes,"title"),l=At(At({},c),{width:o,height:s,text:a}),u=this;n.selectAll(Ii.title.class).data(i?[a]:[]).join(function(f){return f.append(function(){return new LT({style:l})}).attr("className",Ii.title.name).each(function(){u.title=this})},function(f){return f.update(l)},function(f){return f.each(function(){u.title=void 0}).remove()})},Object.defineProperty(e.prototype,"availableSpace",{get:function(){if(this.title)return this.title.getAvailableSpace();var n=this.attributes,r=n.width,i=n.height;return new pr(0,0,r,i)},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"labelFixedSpacing",{get:function(){var n=this.attributes.showTick;return n?5:0},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"labelPosition",{get:function(){var n=this.attributes,r=n.orientation,i=n.labelDirection,a={vertical:{positive:"right",negative:"left"},horizontal:{positive:"bottom",negative:"top"}};return a[r][i]},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"labelBBox",{get:function(){var n,r=this.attributes.showLabel;if(!r)return new pr(0,0,0,0);if(this.cacheLabelBBox)return this.cacheLabelBBox;var i=((n=this.label.querySelector(zn.labelGroup.class))===null||n===void 0?void 0:n.children.slice(-1)[0]).getBBox(),a=i.width,o=i.height;return this.cacheLabelBBox=new pr(0,0,a,o),this.cacheLabelBBox},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"labelShape",{get:function(){var n=this.attributes,r=n.showLabel,i=n.labelSpacing,a=i===void 0?0:i;if(!r)return{width:0,height:0,size:0,length:0};var o=this.labelBBox,s=o.width,c=o.height,l=this.ifHorizontal(c,s)+a+this.labelFixedSpacing,u=this.ifHorizontal(s,c);return{width:s,height:c,size:l,length:u}},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"ribbonBBox",{get:function(){var n=this.attributes,r=n.showHandle,i=n.ribbonSize,a=this.availableSpace,o=a.width,s=a.height,c=this.labelShape,l=c.size,u=c.length,f=V(this.ifHorizontal([s,o],[o,s]),2),d=f[0],h=f[1],v=r?this.handleShape:{size:0,length:0},g=v.size,y=v.length,b=this.handleOffsetRatio,x=0,_=this.labelPosition;i?x=i:["bottom","right"].includes(_)?x=Math.min(d-l,(d-g)/b):d*(1-b)>g?x=Math.max(d-l,0):x=Math.max((d-l-g)/b,0);var w=Math.max(y,u),O=h-w,E=V(this.ifHorizontal([O,x],[x,O]),2),M=E[0],k=E[1],A=["top","left"].includes(_)?l:0,P=V(this.ifHorizontal([w/2,A],[A,w/2]),2),C=P[0],N=P[1];return new pr(C,N,M,k)},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"ribbonShape",{get:function(){var n=this.ribbonBBox,r=n.width,i=n.height;return this.ifHorizontal({size:i,length:r},{size:r,length:i})},enumerable:!1,configurable:!0}),e.prototype.renderRibbon=function(n){var r=this.attributes,i=r.data,a=r.type,o=r.orientation,s=r.color,c=r.block,l=en(this.attributes,"ribbon"),u=this.range,f=u.min,d=u.max,h=this.ribbonBBox,v=h.x,g=h.y,y=this.ribbonShape,b=y.length,x=y.size,_=ic({transform:"translate(".concat(v,", ").concat(g,")"),length:b,size:x,type:a,orientation:o,color:s,block:c,partition:i.map(function(w){return(w.value-f)/(d-f)}),range:this.ribbonRange},l);this.ribbon=n.maybeAppendByClassName(Ii.ribbon,function(){return new q7({style:_})}).update(_)},e.prototype.getHandleClassName=function(n){return"".concat(Ii.prefix("".concat(n,"-handle")))},e.prototype.renderHandles=function(){var n=this.attributes,r=n.showHandle,i=n.orientation,a=en(this.attributes,"handle"),o=V(this.selection,2),s=o[0],c=o[1],l=At(At({},a),{orientation:i}),u=a.shape,f=u===void 0?"slider":u,d=f==="basic"?B7:eP,h=this;this.handlesGroup.selectAll(Ii.handle.class).data(r?[{value:s,type:"start"},{value:c,type:"end"}]:[],function(v){return v.type}).join(function(v){return v.append(function(){return new d({style:l})}).attr("className",function(g){var y=g.type;return"".concat(Ii.handle," ").concat(h.getHandleClassName(y))}).each(function(g){var y=g.type,b=g.value;this.update({labelText:b});var x="".concat(y,"Handle");h[x]=this,this.addEventListener("pointerdown",h.onDragStart(y))})},function(v){return v.update(l).each(function(g){var y=g.value;this.update({labelText:y})})},function(v){return v.each(function(g){var y=g.type,b="".concat(y,"Handle");h[b]=void 0}).remove()})},e.prototype.adjustHandles=function(){var n=V(this.selection,2),r=n[0],i=n[1];this.setHandlePosition("start",r),this.setHandlePosition("end",i)},Object.defineProperty(e.prototype,"handleBBox",{get:function(){if(this.cacheHandleBBox)return this.cacheHandleBBox;if(!this.attributes.showHandle)return new pr(0,0,0,0);var n=this.startHandle.getBBox(),r=n.width,i=n.height,a=this.endHandle.getBBox(),o=a.width,s=a.height,c=V([Math.max(r,o),Math.max(i,s)],2),l=c[0],u=c[1];return this.cacheHandleBBox=new pr(0,0,l,u),this.cacheHandleBBox},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"handleShape",{get:function(){var n=this.handleBBox,r=n.width,i=n.height,a=V(this.ifHorizontal([i,r],[r,i]),2),o=a[0],s=a[1];return{width:r,height:i,size:o,length:s}},enumerable:!1,configurable:!0}),e.prototype.setHandlePosition=function(n,r){var i=this.attributes.handleFormatter,a=this.ribbonBBox,o=a.x,s=a.y,c=this.ribbonShape.size,l=this.getOffset(r),u=V(this.ifHorizontal([o+l,s+c*this.handleOffsetRatio],[o+c*this.handleOffsetRatio,s+l]),2),f=u[0],d=u[1],h=this.handlesGroup.select(".".concat(this.getHandleClassName(n))).node();h==null||h.update({transform:"translate(".concat(f,", ").concat(d,")"),formatter:i})},e.prototype.renderIndicator=function(n){var r=en(this.attributes,"indicator");this.indicator=n.maybeAppendByClassName(Ii.indicator,function(){return new d7({})}).update(r)},Object.defineProperty(e.prototype,"labelData",{get:function(){var n=this,r=this.attributes.data;return r.reduce(function(i,a,o,s){var c,l,u=(c=a==null?void 0:a.id)!==null&&c!==void 0?c:o.toString();if(i.push(At(At({},a),{id:u,index:o,type:"value",label:(l=a==null?void 0:a.label)!==null&&l!==void 0?l:a.value.toString(),value:n.ribbonScale.map(a.value)})),o<s.length-1){var f=s[o+1],d=V([a.value,f.value],2),h=d[0],v=d[1],g=(h+v)/2;i.push(At(At({},a),{id:u,index:o,type:"range",range:[h,v],label:[h,v].join("~"),value:n.ribbonScale.map(g)}))}return i},[])},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"labelStyle",{get:function(){var n=V(["center","middle"],2),r=n[0],i=n[1],a=this.labelPosition;return a==="top"?i="bottom":a==="bottom"?i="top":a==="left"?r="end":a==="right"&&(r="start"),{labelTextAlign:r,labelTextBaseline:i}},enumerable:!1,configurable:!0}),e.prototype.renderLabel=function(n){var r=this.attributes,i=r.showTick,a=i===void 0?!1:i,o=r.labelFilter,s=r.labelFormatter,c=en(this.attributes,"tick"),l=en(this.attributes,"label"),u=l.align,f=ic(At({showLine:!1,showGrid:!1,showTick:a,type:"linear",startPos:[0,0],endPos:[0,0],tickDirection:"negative",labelTransform:"rotate(0)"},this.labelStyle),ds(c,"tick"),ds(l,"label"),{data:this.labelData}),d={tickFilter:function(v,g,y){return(v==null?void 0:v.type)!=="value"?!1:o?o(v,v.index,y.filter(function(b){return b.type!=="value"})):!0},labelFilter:function(v,g,y){return(v==null?void 0:v.type)!==u?!1:o?o(v,v.index,y.filter(function(b){return b.type===u})):!0},labelFormatter:s},h=At(At(At({},f),d),{labelOverlap:[{type:"hide"}]});this.label=n.maybeAppendByClassName(Ii.label,function(){return new xw({style:h})}).node(),this.label.update(h,!1)},Object.defineProperty(e.prototype,"labelAxisStyle",{get:function(){var n=this.attributes,r=n.showTick,i=n.labelDirection,a=n.labelSpacing,o=n.tickLength,s=this.ribbonShape.size,c=this.labelPosition,l=this.labelFixedSpacing,u=V([0,0,0],3),f=u[0],d=u[1],h=u[2],v=o!=null?o:s;return r?(h=v,d=l,i==="positive"?c==="right"?(f=v,h=v):c==="bottom"&&(f=h):i==="negative"&&(c==="top"||c==="left")&&(f=s)):i==="positive"?c==="right"?d=v:c==="bottom"&&(f=s+l,d=a):i==="negative"&&(c==="left"||c==="top")&&(d=a),{offset:f,spacing:d,tickLength:h}},enumerable:!1,configurable:!0}),e.prototype.adjustLabel=function(){var n=this.attributes.showLabel;if(n){var r=this.ribbonBBox,i=r.x,a=r.y,o=r.width,s=r.height,c=this.labelAxisStyle,l=c.offset,u=c.spacing,f=c.tickLength,d=V(this.ifHorizontal([[i,a+l],[i+o,a+l]],[[i+l,a+s],[i+l,a]]),2),h=d[0],v=d[1];this.label.update({startPos:h,endPos:v,tickLength:f,labelSpacing:u},!1)}},e.prototype.bindEvents=function(){this.style.cursor="pointer",this.ribbon.on("pointerdown",this.onDragStart("ribbon")),this.ribbon.on("pointermove",this.onHovering),this.addEventListener("pointerout",this.hideIndicator)},e.prototype.showIndicator=function(n,r){r===void 0&&(r="".concat(n));var i=this.attributes.showIndicator;if(!i||typeof n!="number"){this.hideIndicator();return}var a=this.range,o=a.min,s=a.max,c=this.ribbonBBox,l=c.x,u=c.y,f=mn(n,o,s),d=this.getOffset(f),h=this.ifHorizontal([d+l,u],[l,d+u]);this.indicator.update({x:h[0],y:h[1],position:this.ifHorizontal("top","left"),labelText:r}),Mp(this.indicator.node())},e.prototype.hideIndicator=function(){nl(this.indicator.node())},e.prototype.updateMouse=function(){this.attributes.slidable&&(this.style.cursor="grabbing")},e.prototype.setSelection=function(n,r){this.updateSelection(n,r)},e.prototype.updateSelection=function(n,r,i){var a;i===void 0&&(i=!1);var o=V(this.selection,2),s=o[0],c=o[1],l=V([n,r],2),u=l[0],f=l[1];i&&(u+=s,f+=c);var d=this.range,h=d.min,v=d.max;a=V(F7([h,v],[u,f],this.selection),2),u=a[0],f=a[1],this.update({defaultValue:[u,f]}),this.dispatchSelection()},Object.defineProperty(e.prototype,"step",{get:function(){var n=this.attributes.step,r=n===void 0?1:n,i=this.range,a=i.min,o=i.max;return En(r)?xm((o-a)*G7,0):r},enumerable:!1,configurable:!0}),e.prototype.getTickValue=function(n){var r=this.attributes,i=r.data,a=r.block,o=this.range.min;return a?lP(i.map(function(s){var c=s.value;return c}),n).tick:N7(n,this.step,o)},e.prototype.getValueByCanvasPoint=function(n){var r=this.range,i=r.min,a=r.max,o=V(this.ribbon.node().getPosition(),2),s=o[0],c=o[1],l=this.ifHorizontal(s,c),u=this.ifHorizontal.apply(this,te([],V(_m(n)),!1)),f=u-l,d=mn(this.getOffset(f,!0),i,a);return d},e.prototype.getOffset=function(n,r){r===void 0&&(r=!1);var i=this.range,a=i.min,o=i.max,s=this.ribbonShape.length,c=this.eventToOffsetScale;return c.update({domain:[a,o],range:[0,s]}),r?c.invert(n):c.map(n)},e.prototype.getRealSelection=function(n){var r=this.range.max,i=V(n,2),a=i[0],o=i[1];return this.ifHorizontal([a,o],[r-o,r-a])},e.prototype.getRealValue=function(n){var r=this.range.max;return this.ifHorizontal(n,r-n)},e.prototype.dispatchSelection=function(){var n=this.getRealSelection(this.selection),r=new Nn("valuechange",{detail:{value:n}});this.dispatchEvent(r)},e.prototype.dispatchIndicated=function(n,r){var i=this,a=this.range.max,o=this.ifHorizontal(function(){return{value:n,range:r}},function(){return{value:a-n,range:r?i.getRealSelection(r):void 0}}),s=new Nn("indicate",{detail:o});this.dispatchEvent(s)},e}(bi);class Dp extends Lp{getDefaultOptions(){return{range:[0],domain:[0,1],unknown:void 0,tickCount:5,tickMethod:gu}}map(e){const[n]=this.options.range;return n!==void 0?n:this.options.unknown}invert(e){const[n]=this.options.range;return e===n&&n!==void 0?this.options.domain:[]}getTicks(){const{tickMethod:e,domain:n,tickCount:r}=this.options,[i,a]=n;return!Vn(i)||!Vn(a)?[]:e(i,a,r)}clone(){return new Dp(this.options)}}class rd extends Lp{getDefaultOptions(){return{domain:[.5],range:[0,1]}}constructor(e){super(e)}map(e){if(!vm(e))return this.options.unknown;const n=_w(this.thresholds,e,0,this.n);return this.options.range[n]}invert(e){const{range:n}=this.options,r=n.indexOf(e),i=this.thresholds;return[i[r-1],i[r]]}clone(){return new rd(this.options)}rescale(){const{domain:e,range:n}=this.options;this.n=Math.min(e.length,n.length-1),this.thresholds=e}}function jp(t){return ge(t)?0:qf(t)?t.length:Object.keys(t).length}var J7=function(t,e){if(!qf(t))return-1;var n=Array.prototype.indexOf;if(n)return n.call(t,e);for(var r=-1,i=0;i<t.length;i++)if(t[i]===e){r=i;break}return r},dP=J7;function Fp(t){return Math.abs(t)<1e-14?t:parseFloat(t.toFixed(14))}const tz=[1,5,2,2.5,4,3],vot=null,hP=Number.EPSILON*100;function ez(t,e){return(t%e+e)%e}function nz(t){return Math.round(t*1e12)/1e12}function rz(t,e,n,r,i,a){const o=jp(e),s=dP(e,t);let c=0;const l=ez(r,a);return(l<hP||a-l<hP)&&r<=0&&i>=0&&(c=1),1-s/(o-1)-n+c}function iz(t,e,n){const r=jp(e);return 1-dP(e,t)/(r-1)-n+1}function az(t,e,n,r,i,a){const o=(t-1)/(a-i),s=(e-1)/(Math.max(a,r)-Math.min(n,i));return 2-Math.max(o/s,s/o)}function oz(t,e){return t>=e?2-(t-1)/(e-1):1}function sz(t,e,n,r){const i=e-t;return 1-.5*(ti(e-r,2)+ti(t-n,2))/ti(.1*i,2)}function cz(t,e,n){const r=e-t;if(n>r){const i=(n-r)/2;return 1-ti(i,2)/ti(.1*r,2)}return 1}function lz(){return 1}const Tw=(t,e,n=5,r=!0,i=tz,a=[.25,.2,.5,.05])=>{const o=n<0?0:Math.round(n);if(Number.isNaN(t)||Number.isNaN(e)||typeof t!="number"||typeof e!="number"||!o)return[];if(e-t<1e-15||o===1)return[t];const s={score:-2,lmin:0,lmax:0,lstep:0};let c=1;for(;c<1/0;){for(let v=0;v<i.length;v+=1){const g=i[v],y=iz(g,i,c);if(a[0]*y+a[1]+a[2]+a[3]<s.score){c=1/0;break}let b=2;for(;b<1/0;){const x=oz(b,o);if(a[0]*y+a[1]+a[2]*x+a[3]<s.score)break;const _=(e-t)/(b+1)/c/g;let w=Math.ceil(Math.log10(_));for(;w<1/0;){const O=c*g*ti(10,w),E=cz(t,e,O*(b-1));if(a[0]*y+a[1]*E+a[2]*x+a[3]<s.score)break;const M=Math.floor(e/O)*c-(b-1)*c,k=Math.ceil(t/O)*c;if(M<=k){const A=k-M;for(let P=0;P<=A;P+=1){const N=(M+P)*(O/c),L=N+O*(b-1),R=O,I=rz(g,i,c,N,L,R),D=sz(t,e,N,L),G=az(b,o,t,e,N,L),F=lz(),W=a[0]*I+a[1]*D+a[2]*G+a[3]*F;W>s.score&&(!r||N<=t&&L>=e)&&(s.lmin=N,s.lmax=L,s.lstep=R,s.score=W)}}w+=1}b+=1}}c+=1}const l=Fp(s.lmax),u=Fp(s.lmin),f=Fp(s.lstep),d=Math.floor(nz((l-u)/f))+1,h=new Array(d);h[0]=Fp(u);for(let v=1;v<d;v+=1)h[v]=Fp(h[v-1]+f);return h};class wm extends rd{getDefaultOptions(){return{domain:[0,1],range:[.5],nice:!1,tickCount:5,tickMethod:Tw}}constructor(e){super(e)}nice(){const{nice:e}=this.options;if(e){const[n,r,i]=this.getTickMethodOptions();this.options.domain=jT(n,r,i)}}getTicks(){const{tickMethod:e}=this.options,[n,r,i]=this.getTickMethodOptions();return e(n,r,i)}getTickMethodOptions(){const{domain:e,tickCount:n}=this.options,r=e[0],i=e[e.length-1];return[r,i,n]}rescale(){this.nice();const{range:e,domain:n}=this.options,[r,i]=n;this.n=e.length-1,this.thresholds=new Array(this.n);for(let a=0;a<this.n;a+=1)this.thresholds[a]=((a+1)*i-(a-this.n)*r)/(this.n+1)}invert(e){const[n,r]=super.invert(e),[i,a]=this.options.domain;return n===void 0&&r===void 0?[n,r]:[n||i,r||a]}getThresholds(){return this.thresholds}clone(){return new wm(this.options)}}function uz(t,e){const n=t.length;if(!n)return;if(n<2)return t[n-1];const r=(n-1)*e,i=Math.floor(r),a=t[i],o=t[i+1];return a+(o-a)*(r-i)}function fz(t,e,n=!1){const r=t;n||r.sort((a,o)=>a-o);const i=[];for(let a=1;a<e;a+=1)i.push(uz(r,a/e));return i}class Om extends rd{getDefaultOptions(){return{domain:[],range:[],tickCount:5,unknown:void 0,tickMethod:Tw}}constructor(e){super(e)}rescale(){const{domain:e,range:n}=this.options;this.n=n.length-1,this.thresholds=fz(e,this.n+1,!1)}invert(e){const[n,r]=super.invert(e),{domain:i}=this.options,a=i[0],o=i[i.length-1];return n===void 0&&r===void 0?[n,r]:[n||a,r||o]}getThresholds(){return this.thresholds}clone(){return new Om(this.options)}getTicks(){const{tickCount:e,domain:n,tickMethod:r}=this.options,i=n.length-1,a=n[0],o=n[i];return r(a,o,e)}}var dz=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function hz(t,e,n){return t.size=e,HB(n)?t.height=e:t.width=e,t}function pz(t,e,n){const{size:r}=e,i=ZT(t,e,n);return hz(i,r,i.orientation)}function vz(t){return e=>({value:e/t,label:String(e)})}function gz(t,e,n,r,i){const a=e.thresholds,o=vz(r);return Object.assign(Object.assign({},t),{color:i,data:[n,...a,r].map(o)})}function yz(t,e,n){const i=[-1/0,...e.thresholds,1/0].map((a,o)=>({value:o,label:a}));return Object.assign(Object.assign({},t),{data:i,color:n,labelFilter:(a,o)=>o>0&&o<i.length-1})}function Pw(t){const{domain:e}=t.getOptions(),[n,r]=[e[0],BA(e)];return[n,r]}function mz(t,e){const n=t.getOptions(),r=t.clone();return r.update(Object.assign(Object.assign({},n),{range:[os(e).toString()]})),r}function bz(t,e,n,r,i,a){const{length:o}=t,s=n||r,c=i.color?a.legendContinuous.ribbonFill||"black":a.color,l=e||mz(s,c),[u,f]=Pw(l),[d,h]=Pw([e,n,r].filter(v=>v!==void 0).find(v=>!(v instanceof Dp)));return Object.assign(Object.assign({},t),{domain:[d,h],data:l.getTicks().map(v=>({value:v})),color:new Array(Math.floor(o)).fill(0).map((v,g)=>{const y=(f-u)/(o-1)*g+u,b=l.map(y)||c,x=r?r.map(y):1;return b.replace(/rgb[a]*\(([\d]{1,3}) *, *([\d]{1,3}) *, *([\d]{1,3})[\S\s]*\)/,(_,w,O,E)=>`rgba(${w}, ${O}, ${E}, ${x})`)})})}function xz(t,e,n,r,i,a){const o=hs(t,"color"),s=pz(n,r,i);if(o instanceof rd){const{range:u}=o.getOptions(),[f,d]=Pw(o);return o instanceof wm||o instanceof Om?gz(s,o,f,d,u):yz(s,o,u)}const c=hs(t,"size"),l=hs(t,"opacity");return bz(s,o,c,l,e,a)}const al=t=>{const{labelFormatter:e,layout:n,order:r,orientation:i,position:a,size:o,title:s,style:c,crossPadding:l,padding:u}=t,f=dz(t,["labelFormatter","layout","order","orientation","position","size","title","style","crossPadding","padding"]);return({scales:d,value:h,theme:v,scale:g})=>{const{bbox:y}=h,{x:b,y:x,width:_,height:w}=y,O=GT(a,n),{legendContinuous:E={}}=v,M=bm(Object.assign({},E,Object.assign(Object.assign({titleText:mm(s),labelAlign:"value",labelFormatter:typeof e=="string"?A=>el(e)(A.label):e},xz(d,g,h,t,al,v)),c),f)),k=new $T({style:Object.assign(Object.assign({x:b,y:x,width:_,height:w},O),{subOptions:M})});return k.appendChild(new Q7({className:"legend-continuous",style:M})),k}};al.props={defaultPosition:"top",defaultOrientation:"vertical",defaultOrder:1,defaultSize:60,defaultLength:200,defaultLegendSize:60,defaultPadding:[20,10],defaultCrossPadding:[12,12]};const pP=t=>(...e)=>al(Object.assign({},{block:!0},t))(...e);pP.props=Object.assign(Object.assign({},al.props),{defaultPosition:"top",defaultOrientation:"horizontal"});const Cw=t=>e=>{const{scales:n}=e,r=hs(n,"size");return al(Object.assign({},{type:"size",data:r.getTicks().map((i,a)=>({value:i,label:String(i)}))},t))(e)};Cw.props=Object.assign(Object.assign({},al.props),{defaultPosition:"top",defaultOrientation:"horizontal"});const vP=t=>Cw(Object.assign({},{block:!0},t));vP.props=Object.assign(Object.assign({},al.props),{defaultPosition:"top",defaultOrientation:"horizontal"});var _z=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const gP=({static:t=!1}={})=>e=>{const{width:n,height:r,depth:i,paddingLeft:a,paddingRight:o,paddingTop:s,paddingBottom:c,padding:l,inset:u,insetLeft:f,insetTop:d,insetRight:h,insetBottom:v,margin:g,marginLeft:y,marginBottom:b,marginTop:x,marginRight:_,data:w,coordinate:O,theme:E,component:M,interaction:k,x:A,y:P,z:C,key:N,frame:L,labelTransform:R,parentKey:I,clip:D,viewStyle:G,title:F}=e,W=_z(e,["width","height","depth","paddingLeft","paddingRight","paddingTop","paddingBottom","padding","inset","insetLeft","insetTop","insetRight","insetBottom","margin","marginLeft","marginBottom","marginTop","marginRight","data","coordinate","theme","component","interaction","x","y","z","key","frame","labelTransform","parentKey","clip","viewStyle","title"]);return[Object.assign(Object.assign({type:"standardView",x:A,y:P,z:C,key:N,width:n,height:r,depth:i,padding:l,paddingLeft:a,paddingRight:o,paddingTop:s,inset:u,insetLeft:f,insetTop:d,insetRight:h,insetBottom:v,paddingBottom:c,theme:E,coordinate:O,component:M,interaction:k,frame:L,labelTransform:R,margin:g,marginLeft:y,marginBottom:b,marginTop:x,marginRight:_,parentKey:I,clip:D,style:G},!t&&{title:F}),{marks:[Object.assign(Object.assign(Object.assign({},W),{key:`${N}-0`,data:w}),t&&{title:F})]})]};gP.props={};var wz=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function Bp(t){return(e,...n)=>mt({},t(e,...n),e)}function yu(t){return(e,...n)=>mt({},e,t(e,...n))}function Oz(t){return t instanceof Date?!1:typeof t=="object"}function Lw(t,e){if(!t)return e;if(Array.isArray(t))return t;if(Oz(t)){const{value:n=e}=t,r=wz(t,["value"]);return Object.assign(Object.assign({},r),{value:n})}return t}var Rw=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const yP=()=>t=>{const{children:e}=t,n=Rw(t,["children"]);if(!Array.isArray(e))return[];const{data:r,scale:i={},axis:a={},legend:o={},encode:s={},transform:c=[]}=n,l=Rw(n,["data","scale","axis","legend","encode","transform"]),u=e.map(f=>{var{data:d,scale:h={},axis:v={},legend:g={},encode:y={},transform:b=[]}=f,x=Rw(f,["data","scale","axis","legend","encode","transform"]);return Object.assign({data:Lw(d,r),scale:mt({},i,h),encode:mt({},s,y),transform:[...c,...b],axis:v&&a?mt({},a,v):!1,legend:g&&o?mt({},o,g):!1},x)});return[Object.assign(Object.assign({},l),{marks:u,type:"standardView"})]};yP.props={};function Mr([t,e],[n,r]){return[t-n,e-r]}function Sm([t,e],[n,r]){return[t+n,e+r]}function wr([t,e],[n,r]){return Math.sqrt(Math.pow(t-n,2)+Math.pow(e-r,2))}function wo([t,e]){return Math.atan2(e,t)}function id([t,e]){return wo([t,e])+Math.PI/2}function mP(t,e){const n=wo(t),r=wo(e);return n<r?r-n:Math.PI*2-(n-r)}function Nw(t){let e=1/0,n=-1/0,r=1/0,i=-1/0;for(const[s,c]of t)e=Math.min(s,e),n=Math.max(s,n),r=Math.min(c,r),i=Math.max(c,i);const a=n-e,o=i-r;return[e,r,a,o]}function bP([t,e],[n,r]){return[(t+n)/2,(e+r)/2]}function le(t,e){for(const[n,r]of Object.entries(e))t.style(n,r)}function Sz(t,e){return e.forEach((n,r)=>r===0?t.moveTo(n[0],n[1]):t.lineTo(n[0],n[1])),t.closePath(),t}function Ez(t,e,n){const{arrowSize:r}=n,i=typeof r=="string"?+parseFloat(r)/100*wr(t,e):r,a=Math.PI/6,o=Math.atan2(e[1]-t[1],e[0]-t[0]),s=Math.PI/2-o-a,c=[e[0]-i*Math.sin(s),e[1]-i*Math.cos(s)],l=o-a,u=[e[0]-i*Math.cos(l),e[1]-i*Math.sin(l)];return[c,u]}function zp(t,e,n,r,i){const a=wo(Mr(r,e))+Math.PI,o=wo(Mr(r,n))+Math.PI;return t.arc(r[0],r[1],i,a,o,o-a<0),t}function xP(t,e,n,r="y",i="between",a=!1){const o=(y,b)=>y==="y"||y===!0?b?180:90:b?90:0,s=r==="y"||r===!0?n:e,c=o(r,a),l=fu(s),[u,f]=sc(l,y=>s[y]),d=new Ji({domain:[u,f],range:[0,100]}),h=y=>Vn(s[y])&&!Number.isNaN(s[y])?d.map(s[y]):0,v={between:y=>`${t[y]} ${h(y)}%`,start:y=>y===0?`${t[y]} ${h(y)}%`:`${t[y-1]} ${h(y)}%, ${t[y]} ${h(y)}%`,end:y=>y===t.length-1?`${t[y]} ${h(y)}%`:`${t[y]} ${h(y)}%, ${t[y+1]} ${h(y)}%`},g=l.sort((y,b)=>h(y)-h(b)).map(v[i]||v.between).join(",");return`linear-gradient(${c}deg, ${g})`}function Em(t){const[e,n,r,i]=t;return[i,e,n,r]}function mu(t,e,n){const[r,i,,a]=hr(t)?Em(e):e,[o,s]=n,c=t.getCenter(),l=id(Mr(r,c)),u=id(Mr(i,c)),f=u===l&&o!==s?u+Math.PI*2:u;return{startAngle:l,endAngle:f-l>=0?f:Math.PI*2+f,innerRadius:wr(a,c),outerRadius:wr(r,c)}}function got(t){const e="connect";return Object.fromEntries(Object.entries(t).filter(([n])=>n.startsWith(e)).map(([n,r])=>[lowerFirst(n.replace(e,"").trim()),r]).filter(([n])=>n!==void 0))}function Iw(t){const{colorAttribute:e,opacityAttribute:n=e}=t;return`${n}Opacity`}function _P(t,e){if(!Bn(t))return"";const n=t.getCenter(),{transform:r}=e;return`translate(${n[0]}, ${n[1]}) ${r||""}`}function Dw(t){if(t.length===1)return t[0];const[[e,n,r=0],[i,a,o=0]]=t;return[(e+i)/2,(n+a)/2,(r+o)/2]}function wP(t){return t.replace(/-(\w)/g,function(e,n){return n.toUpperCase()})}function Mz(t){return t.replace(/([A-Z])/g,"-$1").toLowerCase()}var yot=Array.prototype.slice;function OP(t){return typeof t=="object"&&"length"in t?t:Array.from(t)}function vr(t){return function(){return t}}function SP(t){this._context=t}SP.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;default:this._context.lineTo(t,e);break}}};function Wp(t){return new SP(t)}const jw=Math.PI,Fw=2*jw,bu=1e-6,kz=Fw-bu;function EP(t){this._+=t[0];for(let e=1,n=t.length;e<n;++e)this._+=arguments[e]+t[e]}function Az(t){let e=Math.floor(t);if(!(e>=0))throw new Error(`invalid digits: ${t}`);if(e>15)return EP;const n=ti(10,e);return function(r){this._+=r[0];for(let i=1,a=r.length;i<a;++i)this._+=Math.round(arguments[i]*n)/n+r[i]}}class Mm{constructor(e){this._x0=this._y0=this._x1=this._y1=null,this._="",this._append=e==null?EP:Az(e)}moveTo(e,n){this._append`M${this._x0=this._x1=+e},${this._y0=this._y1=+n}`}closePath(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._append`Z`)}lineTo(e,n){this._append`L${this._x1=+e},${this._y1=+n}`}quadraticCurveTo(e,n,r,i){this._append`Q${+e},${+n},${this._x1=+r},${this._y1=+i}`}bezierCurveTo(e,n,r,i,a,o){this._append`C${+e},${+n},${+r},${+i},${this._x1=+a},${this._y1=+o}`}arcTo(e,n,r,i,a){if(e=+e,n=+n,r=+r,i=+i,a=+a,a<0)throw new Error(`negative radius: ${a}`);let o=this._x1,s=this._y1,c=r-e,l=i-n,u=o-e,f=s-n,d=u*u+f*f;if(this._x1===null)this._append`M${this._x1=e},${this._y1=n}`;else if(d>bu)if(!(Math.abs(f*c-l*u)>bu)||!a)this._append`L${this._x1=e},${this._y1=n}`;else{let h=r-o,v=i-s,g=c*c+l*l,y=h*h+v*v,b=Math.sqrt(g),x=Math.sqrt(d),_=a*Math.tan((jw-Math.acos((g+d-y)/(2*b*x)))/2),w=_/x,O=_/b;Math.abs(w-1)>bu&&this._append`L${e+w*u},${n+w*f}`,this._append`A${a},${a},0,0,${+(f*h>u*v)},${this._x1=e+O*c},${this._y1=n+O*l}`}}arc(e,n,r,i,a,o){if(e=+e,n=+n,r=+r,o=!!o,r<0)throw new Error(`negative radius: ${r}`);let s=r*Math.cos(i),c=r*Math.sin(i),l=e+s,u=n+c,f=1^o,d=o?i-a:a-i;this._x1===null?this._append`M${l},${u}`:(Math.abs(this._x1-l)>bu||Math.abs(this._y1-u)>bu)&&this._append`L${l},${u}`,r&&(d<0&&(d=d%Fw+Fw),d>kz?this._append`A${r},${r},0,1,${f},${e-s},${n-c}A${r},${r},0,1,${f},${this._x1=l},${this._y1=u}`:d>bu&&this._append`A${r},${r},0,${+(d>=jw)},${f},${this._x1=e+r*Math.cos(a)},${this._y1=n+r*Math.sin(a)}`)}rect(e,n,r,i){this._append`M${this._x0=this._x1=+e},${this._y0=this._y1=+n}h${r=+r}v${+i}h${-r}Z`}toString(){return this._}}function Oo(){return new Mm}Oo.prototype=Mm.prototype;function mot(t=3){return new Mm(+t)}function Bw(t){let e=3;return t.digits=function(n){if(!arguments.length)return e;if(n==null)e=null;else{const r=Math.floor(n);if(!(r>=0))throw new RangeError(`invalid digits: ${n}`);e=r}return t},()=>new Mm(e)}function MP(t){return t[0]}function kP(t){return t[1]}function xu(t,e){var n=vr(!0),r=null,i=Wp,a=null,o=Bw(s);t=typeof t=="function"?t:t===void 0?MP:vr(t),e=typeof e=="function"?e:e===void 0?kP:vr(e);function s(c){var l,u=(c=OP(c)).length,f,d=!1,h;for(r==null&&(a=i(h=o())),l=0;l<=u;++l)!(l<u&&n(f=c[l],l,c))===d&&((d=!d)?a.lineStart():a.lineEnd()),d&&a.point(+t(f,l,c),+e(f,l,c));if(h)return a=null,h+""||null}return s.x=function(c){return arguments.length?(t=typeof c=="function"?c:vr(+c),s):t},s.y=function(c){return arguments.length?(e=typeof c=="function"?c:vr(+c),s):e},s.defined=function(c){return arguments.length?(n=typeof c=="function"?c:vr(!!c),s):n},s.curve=function(c){return arguments.length?(i=c,r!=null&&(a=i(r)),s):i},s.context=function(c){return arguments.length?(c==null?r=a=null:a=i(r=c),s):r},s}function ad(t){const e=typeof t=="function"?t:t.render;return class extends mp{connectedCallback(){this.draw()}attributeChangedCallback(){this.draw()}draw(){e(this)}}}var zw=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function Tz(t){const{min:[e,n],max:[r,i]}=t.getLocalBounds();let a=0,o=0;return e>0&&(a=e),r<0&&(a=r),n>0&&(o=n),i<0&&(o=i),[a,o]}function Pz(t,e=[]){const[n=0,r=0,i=n,a=r]=e,o=t.parentNode,s=o.getEulerAngles();o.setEulerAngles(0);const{min:c,halfExtents:l}=t.getLocalBounds(),[u,f]=c,[d,h]=l;return o.setEulerAngles(s),{x:u-a,y:f-n,width:d*2+a+r,height:h*2+n+i}}const bot=(t,e,n)=>{const r=dist(t,e),i=dist(e,n),a=dist(n,t);return(Math.pow(r,2)+Math.pow(i,2)-Math.pow(a,2))/(2*r*i)};function Cz(t,e,n,r,i=!0,a=!0){const o=f=>xu()(f);if(!e[0]&&!e[1])return o([Tz(t),e]);if(!n.length)return o([[0,0],e]);const[s,c]=n,l=[...c],u=[...s];if(c[0]!==s[0]){const f=i?-4:4;l[1]=c[1],a&&!i&&(l[0]=Math.max(s[0],c[0]-f),c[1]<s[1]?u[1]=l[1]:(u[1]=s[1],u[0]=Math.max(u[0],l[0]-f))),!a&&!i&&(l[0]=Math.max(s[0],c[0]-f),c[1]>s[1]?u[1]=l[1]:(u[1]=s[1],u[0]=Math.max(u[0],l[0]-f))),!a&&i&&(l[0]=Math.min(s[0],c[0]-f),c[1]>s[1]?u[1]=l[1]:(u[1]=s[1],u[0]=Math.min(u[0],l[0]-f))),a&&i&&(l[0]=Math.min(s[0],c[0]-f),c[1]<s[1]?u[1]=l[1]:(u[1]=s[1],u[0]=Math.min(u[0],l[0]-f)))}return o([c,l,u,s,e])}const AP=ad(t=>{const e=t.attributes,{className:n,class:r,transform:i,rotate:a,labelTransform:o,labelTransformOrigin:s,x:c,y:l,x0:u=c,y0:f=l,text:d,background:h,connector:v,startMarker:g,endMarker:y,coordCenter:b,innerHTML:x}=e,_=zw(e,["className","class","transform","rotate","labelTransform","labelTransformOrigin","x","y","x0","y0","text","background","connector","startMarker","endMarker","coordCenter","innerHTML"]);if(t.style.transform=`translate(${c}, ${l})`,[c,l,u,f].some(F=>!Vn(F))){t.children.forEach(F=>F.remove());return}const w=$t(_,"background"),{padding:O}=w,E=zw(w,["padding"]),M=$t(_,"connector"),{points:k=[]}=M,A=zw(M,["points"]);let P;x?P=Oe(t).maybeAppend("html","html",n).style("zIndex",0).style("innerHTML",x).call(le,Object.assign({transform:o,transformOrigin:s},_)).node():P=Oe(t).maybeAppend("text","text").style("zIndex",0).style("text",d).call(le,Object.assign({textBaseline:"middle",transform:o,transformOrigin:s},_)).node();const C=Oe(t).maybeAppend("background","rect").style("zIndex",-1).call(le,Pz(P,O)).call(le,h?E:{}).node(),N=+u<b[0],L=+f<b[1],R=[+u-+c,+f-+l],I=Cz(C,R,k,b,N,L),D=g&&new An({id:"startMarker",style:Object.assign({x:0,y:0},$t(_,"startMarker"))}),G=y&&new An({id:"endMarker",style:Object.assign({x:0,y:0},$t(_,"endMarker"))});Oe(t).maybeAppend("connector","path").style("zIndex",0).style("d",I).style("markerStart",D).style("markerEnd",G).call(le,v?A:{})});function od(t,e){let n,r=-1,i=-1;if(e===void 0)for(const a of t)++i,a!=null&&(n<a||n===void 0&&a>=a)&&(n=a,r=i);else for(let a of t)(a=e(a,++i,t))!=null&&(n<a||n===void 0&&a>=a)&&(n=a,r=i);return r}function Lz(t,e,n,r){const i=e.length/2,a=e.slice(0,i),o=e.slice(i);let s=od(a,(h,v)=>Math.abs(h[1]-o[v][1]));s=Math.max(Math.min(s,i-2),1);const c=h=>[a[h][0],(a[h][1]+o[h][1])/2],l=c(s),u=c(s-1),f=c(s+1),d=wo(Mr(f,u))/Math.PI*180;return{x:l[0],y:l[1],transform:`rotate(${d})`,textAlign:"center",textBaseline:"middle"}}function TP(t,e,n,r){const{bounds:i}=n,[[a,o],[s,c]]=i,l=s-a,u=c-o,f=d=>{const{x:h,y:v}=d,g=CA(n.x,l),y=CA(n.y,u);return Object.assign(Object.assign({},d),{x:(g||h)+a,y:(y||v)+o})};return f(t==="left"?{x:0,y:u/2,textAlign:"start",textBaseline:"middle"}:t==="right"?{x:l,y:u/2,textAlign:"end",textBaseline:"middle"}:t==="top"?{x:l/2,y:0,textAlign:"center",textBaseline:"top"}:t==="bottom"?{x:l/2,y:u,textAlign:"center",textBaseline:"bottom"}:t==="top-left"?{x:0,y:0,textAlign:"start",textBaseline:"top"}:t==="top-right"?{x:l,y:0,textAlign:"end",textBaseline:"top"}:t==="bottom-left"?{x:0,y:u,textAlign:"start",textBaseline:"bottom"}:t==="bottom-right"?{x:l,y:u,textAlign:"end",textBaseline:"bottom"}:{x:l/2,y:u/2,textAlign:"center",textBaseline:"middle"})}function PP(t,e,n,r){const{y:i,y1:a,autoRotate:o,rotateToAlignArc:s}=n,c=r.getCenter(),l=mu(r,e,[i,a]),{innerRadius:u,outerRadius:f,startAngle:d,endAngle:h}=l,v=t==="inside"?(d+h)/2:h,g=Ww(v,o,s),y=(()=>{const[b,x]=e,_=u+(f-u)*.5,[w,O]=t==="inside"?Gp(c,v,_):bP(b,x);return{x:w,y:O}})();return Object.assign(Object.assign({},y),{textAlign:t==="inside"?"center":"start",textBaseline:"middle",rotate:g})}function Gp(t,e,n){return[t[0]+Math.sin(e)*n,t[1]-Math.cos(e)*n]}function Ww(t,e,n){if(!e)return 0;const r=n?0:Math.sin(t)<0?90:-90;return t/Math.PI*180+r}function Rz(t,e,n,r){const{y:i,y1:a,autoRotate:o,rotateToAlignArc:s,radius:c=.5,offset:l=0}=n,u=mu(r,e,[i,a]),{startAngle:f,endAngle:d}=u,h=r.getCenter(),v=(f+d)/2,y={textAlign:"center",textBaseline:"middle",rotate:Ww(v,o,s)},{innerRadius:b,outerRadius:x}=u,w=b+(x-b)*c+l,[O,E]=Gp(h,v,w);return Object.assign({x:O,y:E},y)}function CP(t){return t===void 0?null:t}function LP(t,e,n,r){const{bounds:i}=n,[a]=i;return{x:CP(a[0]),y:CP(a[1])}}function cc(t,e,n,r){const{bounds:i}=n;return i.length===1?LP(t,e,n,r):(Sp(r)?PP:Kf(r)?Rz:TP)(t,e,n,r)}function Nz(t,e,n,r,i){const[a,o]=Gp(t,e,n),[s,c]=Gp(t,e,r),l=Math.sin(e)>0?1:-1;return[[a,o],[s,c],[s+l*i,c]]}function RP(t,e,n){const r=mu(n,t,[e.y,e.y1]),{innerRadius:i,outerRadius:a}=r;return i+(a-i)}function NP(t,e,n){const r=mu(n,t,[e.y,e.y1]),{startAngle:i,endAngle:a}=r;return(i+a)/2}function Gw(t,e,n,r){const{autoRotate:i,rotateToAlignArc:a,offset:o=0,connector:s=!0,connectorLength:c=o,connectorLength2:l=0,connectorDistance:u=0}=n,f=r.getCenter(),d=NP(e,n,r),h=Math.sin(d)>0?1:-1,v=Ww(d,i,a),g={textAlign:h>0||Sp(r)?"start":"end",textBaseline:"middle",rotate:v},y=RP(e,n,r),b=y+(s?c:o),[[x,_],[w,O],[E,M]]=Nz(f,d,y,b,s?l:0),k=s?+u*h:0,A=E+k,P=M,C={connector:s,connectorPoints:[[w-A,O-P],[E-A,M-P]]};return Object.assign(Object.assign({x0:x,y0:_,x:E+k,y:M},g),C)}function Iz(t,e,n,r){const{bounds:i}=n;return i.length===1?LP(t,e,n,r):(Sp(r)?PP:Kf(r)?Gw:TP)(t,e,n,r)}function kr(t,e){return t==null||e==null?NaN:t<e?-1:t>e?1:t>=e?0:NaN}function Dz(t,e){return Array.from(e,n=>t[n])}function Wo(t,...e){if(typeof t[Symbol.iterator]!="function")throw new TypeError("values is not iterable");t=Array.from(t);let[n]=e;if(n&&n.length!==2||e.length>1){const r=Uint32Array.from(t,(i,a)=>a);return e.length>1?(e=e.map(i=>t.map(i)),r.sort((i,a)=>{for(const o of e){const s=$p(o[i],o[a]);if(s)return s}})):(n=t.map(n),r.sort((i,a)=>$p(n[i],n[a]))),Dz(t,r)}return t.sort(IP(n))}function IP(t=kr){if(t===kr)return $p;if(typeof t!="function")throw new TypeError("compare is not a function");return(e,n)=>{const r=t(e,n);return r||r===0?r:(t(n,n)===0)-(t(e,e)===0)}}function $p(t,e){return(t==null||!(t>=t))-(e==null||!(e>=e))||(t<e?-1:t>e?1:0)}function DP(t,e={}){const{labelHeight:n=14,height:r}=e,i=Wo(t,l=>l.y),a=i.length,o=new Array(a);for(let l=0;l<a;l++){const u=i[l],{y:f}=u;o[l]={y:f,y1:f+n,labels:[f]}}let s=!0;for(;s;){s=!1;for(let l=o.length-1;l>0;l--){const u=o[l],f=o[l-1];if(f.y1>u.y){s=!0,f.labels.push(...u.labels),o.splice(l,1),f.y1+=u.y1-u.y;const d=f.y1-f.y;f.y1=Math.max(Math.min(f.y1,r),d),f.y=f.y1-d}}}let c=0;for(const l of o){const{y:u,labels:f}=l;let d=u-n;for(const h of f){const v=i[c++],y=d+n-h;v.connectorPoints[0][1]-=y,v.y=d+n,d+=n}}}function jP(t,e){const n=Wo(t,s=>s.y),{height:r,labelHeight:i=14}=e,a=Math.ceil(r/i);if(n.length<=a)return DP(n,e);const o=[];for(let s=0;s<n.length;s++)s<n.length-a?(n[s].opacity=0,n[s].connector=!1):o.push(n[s]);DP(o,e)}var jz=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const km=new WeakMap;function Fz(t,e,n){const{connectorLength:r,connectorLength2:i,connectorDistance:a}=e,o=jz(Gw("outside",t,e,n),[]),s=n.getCenter(),c=RP(t,e,n),l=NP(t,e,n),u=c+r+i,f=Math.sin(l)>0?1:-1,d=s[0]+(u+ +a)*f,{x:h}=o,v=d-h;return o.x+=v,o.connectorPoints[0][0]-=v,o}function Bz(t,e,n,r,i,a){if(!Kf(r))return{};if(km.has(e))return km.get(e);const o=a.map(d=>Fz(d,n,r)),{width:s,height:c}=r.getOptions(),l=o.filter(d=>d.x<s/2),u=o.filter(d=>d.x>=s/2),f=Object.assign(Object.assign({},i),{height:c});return jP(l,f),jP(u,f),o.forEach((d,h)=>km.set(a[h],d)),km.get(e)}var zz=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function Wz(t,e,n,r){if(!Kf(r))return{};const{connectorLength:i,connectorLength2:a,connectorDistance:o}=n,s=zz(Gw("outside",e,n,r),[]),{x0:c,y0:l}=s,u=r.getCenter(),d=QF(r)+i,h=id([c-u[0],l-u[1]]),v=Math.sin(h)>0?1:-1,[g,y]=Gp(u,h,d);return s.x=g+(a+o)*v,s.y=y,s}var FP=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function Gz(t,e){return t!==void 0?t:Kf(e)?"inside":hr(e)?"right":"top"}function $z(t,e,n,r,i,a){const{position:o}=e,{render:s}=i,c=Gz(o,n),u=r[s?"htmlLabel":c==="inside"?"innerLabel":"label"],f=Object.assign({},u,e),d=$[wP(c)];if(!d)throw new Error(`Unknown position: ${c}`);return Object.assign(Object.assign({},u),d(c,t,f,n,i,a))}const BP=(t,e)=>{const{coordinate:n,theme:r}=e,{render:i}=t;return(a,o,s,c)=>{const{text:l,x:u,y:f,transform:d="",transformOrigin:h,className:v=""}=o,g=FP(o,["text","x","y","transform","transformOrigin","className"]),y=$z(a,o,n,r,t,c),{rotate:b=0,transform:x=""}=y,_=FP(y,["rotate","transform"]);return Oe(new AP).call(le,_).style("text",`${l}`).style("className",`${v} g2-label`).style("innerHTML",i?i(l,o.datum,o.index):void 0).style("labelTransform",`${x} rotate(${+b}) ${d}`.trim()).style("labelTransformOrigin",h).style("coordCenter",n.getCenter()).call(le,g).node()}};BP.props={defaultMarker:"point"};var Zz=function(t,e){if(!qf(t))return t;for(var n=[],r=0;r<t.length;r++){var i=t[r];e(i,r)&&n.push(i)}return n},zP=Zz;function Yz(t,e){return t==null||e==null?NaN:e<t?-1:e>t?1:e>=t?0:NaN}function ol(t){let e,n,r;t.length!==2?(e=kr,n=(s,c)=>kr(t(s),c),r=(s,c)=>t(s)-c):(e=t===kr||t===Yz?t:Hz,n=t,r=t);function i(s,c,l=0,u=s.length){if(l<u){if(e(c,c)!==0)return u;do{const f=l+u>>>1;n(s[f],c)<0?l=f+1:u=f}while(l<u)}return l}function a(s,c,l=0,u=s.length){if(l<u){if(e(c,c)!==0)return u;do{const f=l+u>>>1;n(s[f],c)<=0?l=f+1:u=f}while(l<u)}return l}function o(s,c,l=0,u=s.length){const f=i(s,c,l,u-1);return f>l&&r(s[f-1],c)>-r(s[f],c)?f-1:f}return{left:i,center:o,right:a}}function Hz(){return 0}function $w(t){return t===null?NaN:+t}function*Vz(t,e){if(e===void 0)for(let n of t)n!=null&&(n=+n)>=n&&(yield n);else{let n=-1;for(let r of t)(r=e(r,++n,t))!=null&&(r=+r)>=r&&(yield r)}}const WP=ol(kr),Xz=WP.right,Uz=WP.left,qz=ol($w).center;var Kz=Xz;function Qz(t,e,n){return Math.min(n,Math.max(e,t))}function Zp(t){return!!t.getBandWidth}function sd(t,e,n){if(!Zp(t))return t.invert(e);const{adjustedRange:r}=t,{domain:i}=t.getOptions(),a=n?-1:0,o=t.getStep(),s=n?r:r.map(u=>u+o),c=Uz(s,e),l=Qz(c+a,0,i.length-1);return i[l]}function sl(t,e,n){if(!e)return t.getOptions().domain;if(!Zp(t)){const c=Wo(e);if(!n)return c;const[l]=c,{range:u}=t.getOptions(),[f,d]=u,h=f>d?-1:1,v=t.invert(t.map(l)+h*n);return[l,v]}const{domain:r}=t.getOptions(),i=e[0],a=r.indexOf(i);if(n){const c=a+Math.round(r.length*n);return r.slice(a,c)}const o=e[e.length-1],s=r.indexOf(o);return r.slice(a,s+1)}function Am(t,e,n,r,i,a){const{x:o,y:s}=i,c=(h,v)=>{const[g,y]=a.invert(h);return[sd(o,g,v),sd(s,y,v)]},l=c([t,e],!0),u=c([n,r],!1),f=sl(o,[l[0],u[0]]),d=sl(s,[l[1],u[1]]);return[f,d]}function Tm(t,e){const[n,r]=t,i=a=>a.getStep?a.getStep():0;return[e.map(n),e.map(r)+i(e)]}function Jz(t,e,n){const{x:r,y:i}=e,[a,o]=t,s=Tm(a,r),c=Tm(o,i),l=[s[0],c[0]],u=[s[1],c[1]],[f,d]=n.map(l),[h,v]=n.map(u);return[f,d,h,v]}const GP=Math.abs,ta=Math.atan2,_u=Math.cos,tW=Math.max,Zw=Math.min,gs=Math.sin,cd=Math.sqrt,ea=1e-12,Yp=Math.PI,Pm=Yp/2,eW=2*Yp;function nW(t){return t>1?0:t<-1?Yp:Math.acos(t)}function $P(t){return t>=1?Pm:t<=-1?-Pm:Math.asin(t)}function rW(t){return t.innerRadius}function iW(t){return t.outerRadius}function aW(t){return t.startAngle}function oW(t){return t.endAngle}function sW(t){return t&&t.padAngle}function cW(t,e,n,r,i,a,o,s){var c=n-t,l=r-e,u=o-i,f=s-a,d=f*c-u*l;if(!(d*d<ea))return d=(u*(e-a)-f*(t-i))/d,[t+d*c,e+d*l]}function Cm(t,e,n,r,i,a,o){var s=t-n,c=e-r,l=(o?a:-a)/cd(s*s+c*c),u=l*c,f=-l*s,d=t+u,h=e+f,v=n+u,g=r+f,y=(d+v)/2,b=(h+g)/2,x=v-d,_=g-h,w=x*x+_*_,O=i-a,E=d*g-v*h,M=(_<0?-1:1)*cd(tW(0,O*O*w-E*E)),k=(E*_-x*M)/w,A=(-E*x-_*M)/w,P=(E*_+x*M)/w,C=(-E*x+_*M)/w,N=k-y,L=A-b,R=P-y,I=C-b;return N*N+L*L>R*R+I*I&&(k=P,A=C),{cx:k,cy:A,x01:-u,y01:-f,x11:k*(i/O-1),y11:A*(i/O-1)}}function Lm(){var t=rW,e=iW,n=vr(0),r=null,i=aW,a=oW,o=sW,s=null,c=Bw(l);function l(){var u,f,d=+t.apply(this,arguments),h=+e.apply(this,arguments),v=i.apply(this,arguments)-Pm,g=a.apply(this,arguments)-Pm,y=GP(g-v),b=g>v;if(s||(s=u=c()),h<d&&(f=h,h=d,d=f),!(h>ea))s.moveTo(0,0);else if(y>eW-ea)s.moveTo(h*_u(v),h*gs(v)),s.arc(0,0,h,v,g,!b),d>ea&&(s.moveTo(d*_u(g),d*gs(g)),s.arc(0,0,d,g,v,b));else{var x=v,_=g,w=v,O=g,E=y,M=y,k=o.apply(this,arguments)/2,A=k>ea&&(r?+r.apply(this,arguments):cd(d*d+h*h)),P=Zw(GP(h-d)/2,+n.apply(this,arguments)),C=P,N=P,L,R;if(A>ea){var I=$P(A/d*gs(k)),D=$P(A/h*gs(k));(E-=I*2)>ea?(I*=b?1:-1,w+=I,O-=I):(E=0,w=O=(v+g)/2),(M-=D*2)>ea?(D*=b?1:-1,x+=D,_-=D):(M=0,x=_=(v+g)/2)}var G=h*_u(x),F=h*gs(x),W=d*_u(O),X=d*gs(O);if(P>ea){var Q=h*_u(_),tt=h*gs(_),nt=d*_u(w),ht=d*gs(w),lt;if(y<Yp)if(lt=cW(G,F,nt,ht,Q,tt,W,X)){var wt=G-lt[0],yt=F-lt[1],gt=Q-lt[0],Bt=tt-lt[1],Lt=1/gs(nW((wt*gt+yt*Bt)/(cd(wt*wt+yt*yt)*cd(gt*gt+Bt*Bt)))/2),It=cd(lt[0]*lt[0]+lt[1]*lt[1]);C=Zw(P,(d-It)/(Lt-1)),N=Zw(P,(h-It)/(Lt+1))}else C=N=0}M>ea?N>ea?(L=Cm(nt,ht,G,F,h,N,b),R=Cm(Q,tt,W,X,h,N,b),s.moveTo(L.cx+L.x01,L.cy+L.y01),N<P?s.arc(L.cx,L.cy,N,ta(L.y01,L.x01),ta(R.y01,R.x01),!b):(s.arc(L.cx,L.cy,N,ta(L.y01,L.x01),ta(L.y11,L.x11),!b),s.arc(0,0,h,ta(L.cy+L.y11,L.cx+L.x11),ta(R.cy+R.y11,R.cx+R.x11),!b),s.arc(R.cx,R.cy,N,ta(R.y11,R.x11),ta(R.y01,R.x01),!b))):(s.moveTo(G,F),s.arc(0,0,h,x,_,!b)):s.moveTo(G,F),!(d>ea)||!(E>ea)?s.lineTo(W,X):C>ea?(L=Cm(W,X,Q,tt,d,-C,b),R=Cm(G,F,nt,ht,d,-C,b),s.lineTo(L.cx+L.x01,L.cy+L.y01),C<P?s.arc(L.cx,L.cy,C,ta(L.y01,L.x01),ta(R.y01,R.x01),!b):(s.arc(L.cx,L.cy,C,ta(L.y01,L.x01),ta(L.y11,L.x11),!b),s.arc(0,0,d,ta(L.cy+L.y11,L.cx+L.x11),ta(R.cy+R.y11,R.cx+R.x11),b),s.arc(R.cx,R.cy,C,ta(R.y11,R.x11),ta(R.y01,R.x01),!b))):s.arc(0,0,d,O,w,b)}if(s.closePath(),u)return s=null,u+""||null}return l.centroid=function(){var u=(+t.apply(this,arguments)+ +e.apply(this,arguments))/2,f=(+i.apply(this,arguments)+ +a.apply(this,arguments))/2-Yp/2;return[_u(f)*u,gs(f)*u]},l.innerRadius=function(u){return arguments.length?(t=typeof u=="function"?u:vr(+u),l):t},l.outerRadius=function(u){return arguments.length?(e=typeof u=="function"?u:vr(+u),l):e},l.cornerRadius=function(u){return arguments.length?(n=typeof u=="function"?u:vr(+u),l):n},l.padRadius=function(u){return arguments.length?(r=u==null?null:typeof u=="function"?u:vr(+u),l):r},l.startAngle=function(u){return arguments.length?(i=typeof u=="function"?u:vr(+u),l):i},l.endAngle=function(u){return arguments.length?(a=typeof u=="function"?u:vr(+u),l):a},l.padAngle=function(u){return arguments.length?(o=typeof u=="function"?u:vr(+u),l):o},l.context=function(u){return arguments.length?(s=u==null?null:u,l):s},l}var Rm=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function ZP(t,e,n,r,i={}){const{inset:a=0,radius:o=0,insetLeft:s=a,insetTop:c=a,insetRight:l=a,insetBottom:u=a,radiusBottomLeft:f=o,radiusBottomRight:d=o,radiusTopLeft:h=o,radiusTopRight:v=o,minWidth:g=-1/0,maxWidth:y=1/0,minHeight:b=-1/0}=i,x=Rm(i,["inset","radius","insetLeft","insetTop","insetRight","insetBottom","radiusBottomLeft","radiusBottomRight","radiusTopLeft","radiusTopRight","minWidth","maxWidth","minHeight"]);if(!Bn(r)&&!HA(r)){const k=!!hr(r),[A,,P]=k?Em(e):e,[C,N]=A,[L,R]=Mr(P,A),I=L>0?C:C+L,D=R>0?N:N+R,G=Math.abs(L),F=Math.abs(R),W=I+s,X=D+c,Q=G-(s+l),tt=F-(c+u),nt=k?nm(Q,b,1/0):nm(Q,g,y),ht=k?nm(tt,g,y):nm(tt,b,1/0),lt=k?W:W-(nt-Q)/2,wt=k?X-(ht-tt)/2:X-(ht-tt);return Oe(t.createElement("rect",{})).style("x",lt).style("y",wt).style("width",nt).style("height",ht).style("radius",[h,v,d,f]).call(le,x).node()}const{y:_,y1:w}=n,O=r.getCenter(),E=mu(r,e,[_,w]),M=Lm().cornerRadius(o).padAngle(a*Math.PI/180);return Oe(t.createElement("path",{})).style("d",M(E)).style("transform",`translate(${O[0]}, ${O[1]})`).style("radius",o).style("inset",a).call(le,x).node()}const Hp=(t,e)=>{const{colorAttribute:n,opacityAttribute:r="fill",first:i=!0,last:a=!0}=t,o=Rm(t,["colorAttribute","opacityAttribute","first","last"]),{coordinate:s,document:c}=e;return(l,u,f)=>{const{color:d,radius:h=0}=f,v=Rm(f,["color","radius"]),g=v.lineWidth||1,{stroke:y,radius:b=h,radiusTopLeft:x=b,radiusTopRight:_=b,radiusBottomRight:w=b,radiusBottomLeft:O=b,innerRadius:E=0,innerRadiusTopLeft:M=E,innerRadiusTopRight:k=E,innerRadiusBottomRight:A=E,innerRadiusBottomLeft:P=E,lineWidth:C=n==="stroke"||y?g:0,inset:N=0,insetLeft:L=N,insetRight:R=N,insetBottom:I=N,insetTop:D=N,minWidth:G,maxWidth:F,minHeight:W}=o,X=Rm(o,["stroke","radius","radiusTopLeft","radiusTopRight","radiusBottomRight","radiusBottomLeft","innerRadius","innerRadiusTopLeft","innerRadiusTopRight","innerRadiusBottomRight","innerRadiusBottomLeft","lineWidth","inset","insetLeft","insetRight","insetBottom","insetTop","minWidth","maxWidth","minHeight"]),{color:Q=d,opacity:tt}=u,nt=[i?x:M,i?_:k,a?w:A,a?O:P],ht=["radiusTopLeft","radiusTopRight","radiusBottomRight","radiusBottomLeft"];hr(s)&&ht.push(ht.shift());const lt=Object.assign(Object.assign({radius:b},Object.fromEntries(ht.map((wt,yt)=>[wt,nt[yt]]))),{inset:N,insetLeft:L,insetRight:R,insetBottom:I,insetTop:D,minWidth:G,maxWidth:F,minHeight:W});return Oe(ZP(c,l,u,s,lt)).call(le,v).style("fill","transparent").style(n,Q).style(Iw(t),tt).style("lineWidth",C).style("stroke",y===void 0?Q:y).call(le,X).node()}};Hp.props={defaultEnterAnimation:"scaleInY",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const lW={visibility:"visible",opacity:1,fillOpacity:1,strokeOpacity:1};function uW(t,e){var n;return(n=t.style[e])!==null&&n!==void 0?n:lW[e]}function Yw(t,e,n,r){t.style[e]=n,r&&t.children.forEach(i=>Yw(i,e,n,r))}function Hw(t){Yw(t,"visibility","hidden",!0)}function Nm(t){Yw(t,"visibility","visible",!0)}var Vp=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function cl(t){return Oe(t).selectAll(`.${ma}`).nodes().filter(e=>!e.__removed__)}function YP(t,e){return Vw(t,e).flatMap(({container:n})=>cl(n))}function Vw(t,e){return e.filter(n=>n!==t&&n.options.parentKey===t.options.key)}function ys(t){return Oe(t).select(`.${ba}`).node()}function HP(t){if(t.tagName==="g")return t.getRenderBounds();const e=t.getGeometryBounds(),n=new xr;return n.setFromTransformedAABB(e,t.getWorldTransform()),n}function Xp(t,e){const{offsetX:n,offsetY:r}=e,i=HP(t),{min:[a,o],max:[s,c]}=i,l=n<a||n>s,u=r<o||r>c;return l||u?null:[n-a,r-o]}function Xw(t,e){const{offsetX:n,offsetY:r}=e,[i,a,o,s]=fW(t);return[Math.min(o,Math.max(i,n))-i,Math.min(s,Math.max(a,r))-a]}function fW(t){const e=t.getRenderBounds(),{min:[n,r],max:[i,a]}=e;return[n,r,i,a]}function VP(t){return e=>e.__data__.color}function Uw(t){return e=>e.__data__.x}function wu(t){const e=Array.isArray(t)?t:[t],n=new Map(e.flatMap(r=>Array.from(r.markState.keys()).map(a=>[Im(r.key,a.key),a.data])));return r=>{const{index:i,markKey:a,viewKey:o}=r.__data__;return n.get(Im(o,a))[i]}}function lc(t,e=(r,i)=>r,n=(r,i,a)=>r.setAttribute(i,a)){const r="__states__",i="__ordinal__",a=u=>{const{[r]:f=[],[i]:d={}}=u,h=f.reduce((v,g)=>Object.assign(Object.assign({},v),t[g]),d);if(Object.keys(h).length!==0){for(const[v,g]of Object.entries(h)){const y=uW(u,v),b=e(g,u);n(u,v,b),v in d||(d[v]=y)}u[i]=d}},o=u=>{u[r]||(u[r]=[])};return{setState:(u,...f)=>{o(u),u[r]=[...f],a(u)},removeState:(u,...f)=>{o(u);for(const d of f){const h=u[r].indexOf(d);h!==-1&&u[r].splice(h,1)}a(u)},hasState:(u,f)=>(o(u),u[r].indexOf(f)!==-1)}}function dW(t){return t===void 0?!0:typeof t!="object"?!1:Object.keys(t).length===0}function Im(t,e){return`${t},${e}`}function ld(t,e){const r=(Array.isArray(t)?t:[t]).flatMap(a=>a.marks.map(o=>[Im(a.key,o.key),o.state])),i={};for(const a of e){const[o,s]=Array.isArray(a)?a:[a,{}];i[o]=r.reduce((c,l)=>{const[u,f={}]=l,d=dW(f[o])?s:f[o];for(const[h,v]of Object.entries(d)){const g=c[h],y=(b,x,_,w)=>{const O=Im(w.__data__.viewKey,w.__data__.markKey);return u!==O?g==null?void 0:g(b,x,_,w):typeof v!="function"?v:v(b,x,_,w)};c[h]=y}return c},{})}return i}function Up(t,e){const n=new Map(t.map((i,a)=>[i,a])),r=e?t.map(e):t;return(i,a)=>{if(typeof i!="function")return i;const o=n.get(a),s=e?e(a):a;return i(s,o,r,a)}}function XP(t){var{link:e=!1,valueof:n=(u,f)=>u,coordinate:r}=t,i=Vp(t,["link","valueof","coordinate"]);const a="element-link";if(!e)return[()=>{},()=>{}];const o=u=>u.__data__.points,s=(u,f)=>{const[,d,h]=u,[v,,,g]=f;return[d,v,g,h]};return[u=>{var f;if(u.length<=1)return;const d=Wo(u,(h,v)=>{const{x:g}=h.__data__,{x:y}=v.__data__;return g-y});for(let h=1;h<d.length;h++){const v=Oo(),g=d[h-1],y=d[h],[b,x,_,w]=s(o(g),o(y));v.moveTo(...b),v.lineTo(...x),v.lineTo(..._),v.lineTo(...w),v.closePath();const O=fs(i,A=>n(A,g)),{fill:E=g.getAttribute("fill")}=O,M=Vp(O,["fill"]),k=new Qi({className:a,style:Object.assign({d:v.toString(),fill:E,zIndex:-2},M)});(f=g.link)===null||f===void 0||f.remove(),g.parentNode.appendChild(k),g.link=k}},u=>{var f;(f=u.link)===null||f===void 0||f.remove(),u.link=null}]}function UP(t,e,n){const r=i=>{const{transform:a}=t.style;return a?`${a} ${i}`:i};if(Bn(n)){const{points:i}=t.__data__,[a,o]=hr(n)?Em(i):i,s=n.getCenter(),c=Mr(a,s),l=Mr(o,s),u=wo(c),f=mP(c,l),d=u+f/2,h=e*Math.cos(d),v=e*Math.sin(d);return r(`translate(${h}, ${v})`)}return hr(n)?r(`translate(${e}, 0)`):r(`translate(0, ${-e})`)}function qP(t){var{document:e,background:n,scale:r,coordinate:i,valueof:a}=t,o=Vp(t,["document","background","scale","coordinate","valueof"]);const s="element-background";if(!n)return[()=>{},()=>{}];const c=(b,x,_)=>{const w=b.invert(x),O=x+b.getBandWidth(w)/2,E=b.getStep(w)/2,M=E*_;return[O-E+M,O+E-M]},l=(b,x)=>{const{x:_}=r;if(!Zp(_))return[0,1];const{__data__:w}=b,{x:O}=w,[E,M]=c(_,O,x);return[E,M]},u=(b,x)=>{const{y:_}=r;if(!Zp(_))return[0,1];const{__data__:w}=b,{y:O}=w,[E,M]=c(_,O,x);return[E,M]},f=(b,x)=>{const{padding:_}=x,[w,O]=l(b,_),[E,M]=u(b,_),k=[[w,E],[O,E],[O,M],[w,M]].map(N=>i.map(N)),{__data__:A}=b,{y:P,y1:C}=A;return ZP(e,k,{y:P,y1:C},i,x)},d=(b,x)=>{const{transform:_="scale(1.2, 1.2)",transformOrigin:w="center center",stroke:O=""}=x,E=Vp(x,["transform","transformOrigin","stroke"]),M=Object.assign({transform:_,transformOrigin:w,stroke:O},E),k=b.cloneNode(!0);for(const[A,P]of Object.entries(M))k.style[A]=P;return k},h=()=>{const{x:b,y:x}=r;return[b,x].some(Zp)};return[b=>{b.background&&b.background.remove();const x=fs(o,N=>a(N,b)),{fill:_="#CCD6EC",fillOpacity:w=.3,zIndex:O=-2,padding:E=.001,lineWidth:M=0}=x,k=Vp(x,["fill","fillOpacity","zIndex","padding","lineWidth"]),A=Object.assign(Object.assign({},k),{fill:_,fillOpacity:w,zIndex:O,padding:E,lineWidth:M}),C=(h()?f:d)(b,A);C.className=s,b.parentNode.parentNode.appendChild(C),b.background=C},b=>{var x;(x=b.background)===null||x===void 0||x.remove(),b.background=null},b=>b.className===s]}function ll(t,e){const r=t.getRootNode().defaultView.getContextService().getDomElement();r!=null&&r.style&&(t.cursor=r.style.cursor,r.style.cursor=e)}function hW(t){ll(t,t.cursor)}function qw(t,e,n){return t.find(r=>Object.entries(e).every(([i,a])=>n(r)[i]===a))}function Dm(t,e){return Math.sqrt(Math.pow(t[0]-e[0],2)+Math.pow(t[1]-e[1],2))}function qp(t,e=!1){const n=zP(t,r=>!!r).map((r,i)=>[i===0?"M":"L",...r]);return e&&n.push(["Z"]),n}function KP(t){return t.querySelectorAll(".element")}function pW(t,e,n=0){const r=[["M",...e[1]]],i=Dm(t,e[1]),a=Dm(t,e[0]);return i===0?r.push(["L",...e[3]],["A",a,a,0,n,1,...e[0]],["Z"]):r.push(["A",i,i,0,n,0,...e[2]],["L",...e[3]],["A",a,a,0,n,1,...e[0]],["Z"]),r}function jm(t,e){if(e(t))return t;let n=t.parent;for(;n&&!e(n);)n=n.parent;return n}function QP(t,e){const{__data__:n}=t,{markKey:r,index:i,seriesIndex:a}=n,{markState:o}=e,s=Array.from(o.keys()).find(c=>c.key===r);if(s)return a?a.map(c=>s.data[c]):s.data[i]}function vW(t){return jm(t,e=>e.className==="component")}function gW(t){return jm(t,e=>e.className==="element")}function yW(t){return jm(t,e=>e.className==="label")}function xi(t,e,n,r=i=>!0){return i=>{if(!r(i))return;n.emit(`plot:${t}`,i);const{target:a}=i;if(!a)return;const{className:o}=a;if(o==="plot")return;const s=gW(a),c=vW(a),l=yW(a),u=s||c||l;if(!u)return;const{className:f,markType:d}=u,h=Object.assign(Object.assign({},i),{nativeEvent:!0});f==="element"?(h.data={data:QP(u,e)},n.emit(`element:${t}`,h),n.emit(`${d}:${t}`,h)):f==="label"?(h.data={data:u.attributes.datum},n.emit(`label:${t}`,h),n.emit(`${o}:${t}`,h)):(n.emit(`component:${t}`,h),n.emit(`${o}:${t}`,h))}}function JP(){return(t,e,n)=>{const{container:r,view:i}=t,a=xi(In.CLICK,i,n,M=>M.detail===1),o=xi(In.DBLCLICK,i,n,M=>M.detail===2),s=xi(In.POINTER_TAP,i,n),c=xi(In.POINTER_DOWN,i,n),l=xi(In.POINTER_UP,i,n),u=xi(In.POINTER_OVER,i,n),f=xi(In.POINTER_OUT,i,n),d=xi(In.POINTER_MOVE,i,n),h=xi(In.POINTER_ENTER,i,n),v=xi(In.POINTER_LEAVE,i,n),g=xi(In.POINTER_UPOUTSIDE,i,n),y=xi(In.DRAG_START,i,n),b=xi(In.DRAG,i,n),x=xi(In.DRAG_END,i,n),_=xi(In.DRAG_ENTER,i,n),w=xi(In.DRAG_LEAVE,i,n),O=xi(In.DRAG_OVER,i,n),E=xi(In.DROP,i,n);return r.addEventListener("click",a),r.addEventListener("click",o),r.addEventListener("pointertap",s),r.addEventListener("pointerdown",c),r.addEventListener("pointerup",l),r.addEventListener("pointerover",u),r.addEventListener("pointerout",f),r.addEventListener("pointermove",d),r.addEventListener("pointerenter",h),r.addEventListener("pointerleave",v),r.addEventListener("pointerupoutside",g),r.addEventListener("dragstart",y),r.addEventListener("drag",b),r.addEventListener("dragend",x),r.addEventListener("dragenter",_),r.addEventListener("dragleave",w),r.addEventListener("dragover",O),r.addEventListener("drop",E),()=>{r.removeEventListener("click",a),r.removeEventListener("click",o),r.removeEventListener("pointertap",s),r.removeEventListener("pointerdown",c),r.removeEventListener("pointerup",l),r.removeEventListener("pointerover",u),r.removeEventListener("pointerout",f),r.removeEventListener("pointermove",d),r.removeEventListener("pointerenter",h),r.removeEventListener("pointerleave",v),r.removeEventListener("pointerupoutside",g),r.removeEventListener("dragstart",y),r.removeEventListener("drag",b),r.removeEventListener("dragend",x),r.removeEventListener("dragenter",_),r.removeEventListener("dragleave",w),r.removeEventListener("dragover",O),r.removeEventListener("drop",E)}}}JP.props={reapplyWhenUpdate:!0};function mW(){return{"component.axisRadar":KT,"component.axisLinear":rl,"component.axisArc":qT,"component.legendContinuousBlock":pP,"component.legendContinuousBlockSize":vP,"component.legendContinuousSize":Cw,"interaction.event":JP,"composition.mark":gP,"composition.view":yP,"shape.label.label":BP}}var bW=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function gr(t,e){const n=Object.assign(Object.assign({},mW()),e),r=a=>{if(typeof a!="string")return a;const o=`${t}.${a}`;return n[o]||Xf(`Unknown Component: ${o}`)};return[(a,o)=>{const{type:s}=a,c=bW(a,["type"]);s||Xf("Plot type is required!");const l=r(s);return l==null?void 0:l(c,o)},r]}function t3(t){const{canvas:e,group:n}=t;return(e==null?void 0:e.document)||(n==null?void 0:n.ownerDocument)||Xf("Cannot find library document")}var e3=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function xW(t,e,n){const[r]=gr("coordinate",n),{innerHeight:i,innerWidth:a,insetLeft:o,insetTop:s,insetRight:c,insetBottom:l}=t,{coordinates:u=[]}=e,f=MW(u),d=f[0].type==="cartesian3D",h=Object.assign(Object.assign({},t),{x:o,y:s,width:a-o-c,height:i-l-s,transformations:f.flatMap(r)});return d?new YA.Coordinate3D(h):new YA.Coordinate(h)}function n3(t,e){const{coordinate:n={},coordinates:r}=t,i=e3(t,["coordinate","coordinates"]);if(r)return t;const{type:a,transform:o=[]}=n,s=e3(n,["type","transform"]);if(!a)return Object.assign(Object.assign({},i),{coordinates:o});const[,c]=gr("coordinate",e),{transform:l=!1}=c(a).props||{};if(l)throw new Error(`Unknown coordinate: ${a}.`);return Object.assign(Object.assign({},i),{coordinates:[Object.assign({type:a},s),...o]})}function Go(t,e){return t.filter(n=>n.type===e)}function Ou(t){return Go(t,"polar").length>0}function _W(t){return Go(t,"helix").length>0}function ud(t){return Go(t,"transpose").length%2===1}function wW(t){return Go(t,"parallel").length>0}function r3(t){return Go(t,"theta").length>0}function OW(t){return Go(t,"reflect").length>0}function Kp(t){return Go(t,"radial").length>0}function SW(t){return Go(t,"radar").length>0}function EW(t){return Go(t,"reflectY").length>0}function MW(t){return t.find(e=>e.type==="cartesian"||e.type==="cartesian3D")?t:[...t,{type:"cartesian"}]}function qe(t){for(var e=t.length/6|0,n=new Array(e),r=0;r<e;)n[r]="#"+t.slice(r*6,++r*6);return n}var kW=qe("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"),AW=qe("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666"),TW=qe("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666"),PW=qe("4269d0efb118ff725c6cc5b03ca951ff8ab7a463f297bbf59c6b4e9498a0"),CW=qe("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928"),LW=qe("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2"),RW=qe("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc"),NW=qe("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999"),IW=qe("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3"),DW=qe("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f"),jW=qe("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");function Fm(t,e,n){t.prototype=e.prototype=n,n.constructor=t}function Kw(t,e){var n=Object.create(t.prototype);for(var r in e)n[r]=e[r];return n}function fd(){}var Su=.7,dd=1/Su,hd="\\s*([+-]?\\d+)\\s*",Qp="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*",ms="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*",FW=/^#([0-9a-f]{3,8})$/,BW=new RegExp("^rgb\\(".concat(hd,",").concat(hd,",").concat(hd,"\\)$")),zW=new RegExp("^rgb\\(".concat(ms,",").concat(ms,",").concat(ms,"\\)$")),WW=new RegExp("^rgba\\(".concat(hd,",").concat(hd,",").concat(hd,",").concat(Qp,"\\)$")),GW=new RegExp("^rgba\\(".concat(ms,",").concat(ms,",").concat(ms,",").concat(Qp,"\\)$")),$W=new RegExp("^hsl\\(".concat(Qp,",").concat(ms,",").concat(ms,"\\)$")),ZW=new RegExp("^hsla\\(".concat(Qp,",").concat(ms,",").concat(ms,",").concat(Qp,"\\)$")),i3={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Fm(fd,Qw,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:a3,formatHex:a3,formatHex8:YW,formatHsl:HW,formatRgb:o3,toString:o3});function a3(){return this.rgb().formatHex()}function YW(){return this.rgb().formatHex8()}function HW(){return d3(this).formatHsl()}function o3(){return this.rgb().formatRgb()}function Qw(t){var e,n;return t=(t+"").trim().toLowerCase(),(e=FW.exec(t))?(n=e[1].length,e=parseInt(e[1],16),n===6?s3(e):n===3?new na(e>>8&15|e>>4&240,e>>4&15|e&240,(e&15)<<4|e&15,1):n===8?Bm(e>>24&255,e>>16&255,e>>8&255,(e&255)/255):n===4?Bm(e>>12&15|e>>8&240,e>>8&15|e>>4&240,e>>4&15|e&240,((e&15)<<4|e&15)/255):null):(e=BW.exec(t))?new na(e[1],e[2],e[3],1):(e=zW.exec(t))?new na(e[1]*255/100,e[2]*255/100,e[3]*255/100,1):(e=WW.exec(t))?Bm(e[1],e[2],e[3],e[4]):(e=GW.exec(t))?Bm(e[1]*255/100,e[2]*255/100,e[3]*255/100,e[4]):(e=$W.exec(t))?f3(e[1],e[2]/100,e[3]/100,1):(e=ZW.exec(t))?f3(e[1],e[2]/100,e[3]/100,e[4]):i3.hasOwnProperty(t)?s3(i3[t]):t==="transparent"?new na(NaN,NaN,NaN,0):null}function s3(t){return new na(t>>16&255,t>>8&255,t&255,1)}function Bm(t,e,n,r){return r<=0&&(t=e=n=NaN),new na(t,e,n,r)}function c3(t){return t instanceof fd||(t=Qw(t)),t?(t=t.rgb(),new na(t.r,t.g,t.b,t.opacity)):new na}function Jp(t,e,n,r){return arguments.length===1?c3(t):new na(t,e,n,r==null?1:r)}function na(t,e,n,r){this.r=+t,this.g=+e,this.b=+n,this.opacity=+r}Fm(na,Jp,Kw(fd,{brighter:function(e){return e=e==null?dd:Math.pow(dd,e),new na(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Su:Math.pow(Su,e),new na(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},clamp:function(){return new na(Eu(this.r),Eu(this.g),Eu(this.b),zm(this.opacity))},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:l3,formatHex:l3,formatHex8:VW,formatRgb:u3,toString:u3}));function l3(){return"#".concat(Mu(this.r)).concat(Mu(this.g)).concat(Mu(this.b))}function VW(){return"#".concat(Mu(this.r)).concat(Mu(this.g)).concat(Mu(this.b)).concat(Mu((isNaN(this.opacity)?1:this.opacity)*255))}function u3(){var t=zm(this.opacity);return"".concat(t===1?"rgb(":"rgba(").concat(Eu(this.r),", ").concat(Eu(this.g),", ").concat(Eu(this.b)).concat(t===1?")":", ".concat(t,")"))}function zm(t){return isNaN(t)?1:Math.max(0,Math.min(1,t))}function Eu(t){return Math.max(0,Math.min(255,Math.round(t)||0))}function Mu(t){return t=Eu(t),(t<16?"0":"")+t.toString(16)}function f3(t,e,n,r){return r<=0?t=e=n=NaN:n<=0||n>=1?t=e=NaN:e<=0&&(t=NaN),new $o(t,e,n,r)}function d3(t){if(t instanceof $o)return new $o(t.h,t.s,t.l,t.opacity);if(t instanceof fd||(t=Qw(t)),!t)return new $o;if(t instanceof $o)return t;t=t.rgb();var e=t.r/255,n=t.g/255,r=t.b/255,i=Math.min(e,n,r),a=Math.max(e,n,r),o=NaN,s=a-i,c=(a+i)/2;return s?(e===a?o=(n-r)/s+(n<r)*6:n===a?o=(r-e)/s+2:o=(e-n)/s+4,s/=c<.5?a+i:2-a-i,o*=60):s=c>0&&c<1?0:o,new $o(o,s,c,t.opacity)}function XW(t,e,n,r){return arguments.length===1?d3(t):new $o(t,e,n,r==null?1:r)}function $o(t,e,n,r){this.h=+t,this.s=+e,this.l=+n,this.opacity=+r}Fm($o,XW,Kw(fd,{brighter:function(e){return e=e==null?dd:Math.pow(dd,e),new $o(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Su:Math.pow(Su,e),new $o(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,n=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,i=r+(r<.5?r:1-r)*n,a=2*r-i;return new na(Jw(e>=240?e-240:e+120,a,i),Jw(e,a,i),Jw(e<120?e+240:e-120,a,i),this.opacity)},clamp:function(){return new $o(h3(this.h),Wm(this.s),Wm(this.l),zm(this.opacity))},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=zm(this.opacity);return"".concat(e===1?"hsl(":"hsla(").concat(h3(this.h),", ").concat(Wm(this.s)*100,"%, ").concat(Wm(this.l)*100,"%").concat(e===1?")":", ".concat(e,")"))}}));function h3(t){return t=(t||0)%360,t<0?t+360:t}function Wm(t){return Math.max(0,Math.min(1,t||0))}function Jw(t,e,n){return(t<60?e+(n-e)*t/60:t<180?n:t<240?e+(n-e)*(240-t)/60:e)*255}function p3(t,e,n,r,i){var a=t*t,o=a*t;return((1-3*t+3*a-o)*e+(4-6*a+3*o)*n+(1+3*t+3*a-3*o)*r+o*i)/6}function UW(t){var e=t.length-1;return function(n){var r=n<=0?n=0:n>=1?(n=1,e-1):Math.floor(n*e),i=t[r],a=t[r+1],o=r>0?t[r-1]:2*i-a,s=r<e-1?t[r+2]:2*a-i;return p3((n-r/e)*e,o,i,a,s)}}function qW(t){var e=t.length;return function(n){var r=Math.floor(((n%=1)<0?++n:n)*e),i=t[(r+e-1)%e],a=t[r%e],o=t[(r+1)%e],s=t[(r+2)%e];return p3((n-r/e)*e,i,a,o,s)}}var tO=function(t){return function(){return t}};function v3(t,e){return function(n){return t+n*e}}function KW(t,e,n){return t=Math.pow(t,n),e=Math.pow(e,n)-t,n=1/n,function(r){return Math.pow(t+r*e,n)}}function QW(t,e){var n=e-t;return n?v3(t,n>180||n<-180?n-360*Math.round(n/360):n):tO(isNaN(t)?e:t)}function JW(t){return(t=+t)==1?pd:function(e,n){return n-e?KW(e,n,t):tO(isNaN(e)?n:e)}}function pd(t,e){var n=e-t;return n?v3(t,n):tO(isNaN(t)?e:t)}var xot=function t(e){var n=JW(e);function r(i,a){var o=n((i=Jp(i)).r,(a=Jp(a)).r),s=n(i.g,a.g),c=n(i.b,a.b),l=pd(i.opacity,a.opacity);return function(u){return i.r=o(u),i.g=s(u),i.b=c(u),i.opacity=l(u),i+""}}return r.gamma=t,r}(1);function g3(t){return function(e){var n=e.length,r=new Array(n),i=new Array(n),a=new Array(n),o,s;for(o=0;o<n;++o)s=Jp(e[o]),r[o]=s.r||0,i[o]=s.g||0,a[o]=s.b||0;return r=t(r),i=t(i),a=t(a),s.opacity=1,function(c){return s.r=r(c),s.g=i(c),s.b=a(c),s+""}}}var tG=g3(UW),_ot=g3(qW),sr=t=>tG(t[t.length-1]),y3=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(qe),eG=sr(y3),m3=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(qe),nG=sr(m3),b3=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(qe),rG=sr(b3),x3=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(qe),iG=sr(x3),_3=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(qe),aG=sr(_3),w3=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(qe),oG=sr(w3),O3=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(qe),sG=sr(O3),S3=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(qe),cG=sr(S3),E3=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(qe),lG=sr(E3),M3=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(qe),uG=sr(M3),k3=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(qe),fG=sr(k3),A3=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(qe),dG=sr(A3),T3=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(qe),hG=sr(T3),P3=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(qe),pG=sr(P3),C3=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(qe),vG=sr(C3),L3=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(qe),gG=sr(L3),R3=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(qe),yG=sr(R3),N3=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(qe),mG=sr(N3),I3=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(qe),bG=sr(I3),D3=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(qe),xG=sr(D3),j3=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(qe),_G=sr(j3),F3=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(qe),wG=sr(F3),B3=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(qe),OG=sr(B3),z3=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(qe),SG=sr(z3),W3=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(qe),EG=sr(W3),G3=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(qe),MG=sr(G3),$3=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(qe),kG=sr($3);function AG(t){return t=Math.max(0,Math.min(1,t)),"rgb("+Math.max(0,Math.min(255,Math.round(-4.54-t*(35.34-t*(2381.73-t*(6402.7-t*(7024.72-t*2710.57)))))))+", "+Math.max(0,Math.min(255,Math.round(32.49+t*(170.73+t*(52.82-t*(131.46-t*(176.58-t*67.37)))))))+", "+Math.max(0,Math.min(255,Math.round(81.24+t*(442.36-t*(2482.43-t*(6167.24-t*(6614.94-t*2475.67)))))))+")"}var TG=Math.PI/180,PG=180/Math.PI,Z3=-.14861,eO=1.78277,nO=-.29227,Gm=-.90649,t0=1.97294,Y3=t0*Gm,H3=t0*eO,V3=eO*nO-Gm*Z3;function CG(t){if(t instanceof ku)return new ku(t.h,t.s,t.l,t.opacity);t instanceof na||(t=c3(t));var e=t.r/255,n=t.g/255,r=t.b/255,i=(V3*r+Y3*e-H3*n)/(V3+Y3-H3),a=r-i,o=(t0*(n-i)-nO*a)/Gm,s=Math.sqrt(o*o+a*a)/(t0*i*(1-i)),c=s?Math.atan2(o,a)*PG-120:NaN;return new ku(c<0?c+360:c,s,i,t.opacity)}function bs(t,e,n,r){return arguments.length===1?CG(t):new ku(t,e,n,r==null?1:r)}function ku(t,e,n,r){this.h=+t,this.s=+e,this.l=+n,this.opacity=+r}Fm(ku,bs,Kw(fd,{brighter:function(e){return e=e==null?dd:Math.pow(dd,e),new ku(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Su:Math.pow(Su,e),new ku(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*TG,n=+this.l,r=isNaN(this.s)?0:this.s*n*(1-n),i=Math.cos(e),a=Math.sin(e);return new na(255*(n+r*(Z3*i+eO*a)),255*(n+r*(nO*i+Gm*a)),255*(n+r*(t0*i)),this.opacity)}}));function X3(t){return function e(n){n=+n;function r(i,a){var o=t((i=bs(i)).h,(a=bs(a)).h),s=pd(i.s,a.s),c=pd(i.l,a.l),l=pd(i.opacity,a.opacity);return function(u){return i.h=o(u),i.s=s(u),i.l=c(Math.pow(u,n)),i.opacity=l(u),i+""}}return r.gamma=e,r}(1)}var wot=X3(QW),rO=X3(pd),LG=rO(bs(300,.5,0),bs(-240,.5,1)),RG=rO(bs(-100,.75,.35),bs(80,1.5,.8)),NG=rO(bs(260,.75,.35),bs(80,1.5,.8)),$m=bs();function IG(t){(t<0||t>1)&&(t-=Math.floor(t));var e=Math.abs(t-.5);return $m.h=360*t-100,$m.s=1.5-1.5*e,$m.l=.8-.9*e,$m+""}var Zm=Jp(),DG=Math.PI/3,jG=Math.PI*2/3;function FG(t){var e;return t=(.5-t)*Math.PI,Zm.r=255*(e=Math.sin(t))*e,Zm.g=255*(e=Math.sin(t+DG))*e,Zm.b=255*(e=Math.sin(t+jG))*e,Zm+""}function BG(t){return t=Math.max(0,Math.min(1,t)),"rgb("+Math.max(0,Math.min(255,Math.round(34.61+t*(1172.33-t*(10793.56-t*(33300.12-t*(38394.49-t*14825.05)))))))+", "+Math.max(0,Math.min(255,Math.round(23.31+t*(557.33+t*(1225.33-t*(3574.96-t*(1073.77+t*707.56)))))))+", "+Math.max(0,Math.min(255,Math.round(27.2+t*(3211.1-t*(15327.97-t*(27814-t*(22569.18-t*6838.66)))))))+")"}function Ym(t){var e=t.length;return function(n){return t[Math.max(0,Math.min(e-1,Math.floor(n*e)))]}}var zG=Ym(qe("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),WG=Ym(qe("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),GG=Ym(qe("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),$G=Ym(qe("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function ZG(t,e,n,r,i,a){const{guide:o={}}=n,s=t$(t,e,n);if(typeof s!="string")return n;const c=e$(s,t,e,n),l=KG(s,c,n);return Object.assign(Object.assign(Object.assign({},n),r$(s,t,e,n,r)),{domain:l,range:n$(s,t,e,n,l,i,a),expectedDomain:c,guide:o,name:t,type:s})}function YG(t,e){const n={};for(const r of t){const{values:i,name:a}=r,o=e[a];for(const s of i){const{name:c,value:l}=s;n[c]=l.map(u=>o.map(u))}}return n}function HG(t,e){const n=Array.from(t.values()).flatMap(i=>i.channels);Jy(n,i=>i.map(a=>e.get(a.scale.uid)),i=>i.name).filter(([,i])=>i.some(a=>typeof a.getOptions().groupTransform=="function")&&i.every(a=>a.getTicks)).map(i=>i[1]).forEach(i=>{const a=i.map(o=>o.getOptions().groupTransform)[0];a(i)})}function VG(t,e){var n;const{components:r=[]}=e,i=["scale","encode","axis","legend","data","transform"],a=Array.from(new Set(t.flatMap(s=>s.channels.map(c=>c.scale)))),o=new Map(a.map(s=>[s.name,s]));for(const s of r){const c=qG(s);for(const l of c){const u=o.get(l),f=((n=s.scale)===null||n===void 0?void 0:n[l])||{},{independent:d=!1}=f;if(u&&!d){const{guide:h}=u,v=typeof h=="boolean"?{}:h;u.guide=mt({},v,s),Object.assign(u,f)}else{const h=Object.assign(Object.assign({},f),{expectedDomain:f.domain,name:l,guide:kw(s,i)});a.push(h)}}}return a}function XG(t){if(!t||!Array.isArray(t))return[uu,uu];let e,n;return[a=>{var o;e=a.map.bind(a),n=(o=a.invert)===null||o===void 0?void 0:o.bind(a);const s=t.filter(([d])=>typeof d=="function"),c=t.filter(([d])=>typeof d!="function"),l=new Map(c);if(a.map=d=>{for(const[h,v]of s)if(h(d))return v;return l.has(d)?l.get(d):e(d)},!n)return a;const u=new Map(c.map(([d,h])=>[h,d])),f=new Map(s.map(([d,h])=>[h,d]));return a.invert=d=>f.has(d)?d:u.has(d)?u.get(d):n(d),a},a=>(e!==null&&(a.map=e),n!==null&&(a.invert=n),a)]}function U3(t,e){const n=Object.keys(t);for(const r of Object.values(e)){const{name:i}=r.getOptions();if(!(i in t))t[i]=r;else{const a=n.filter(c=>c.startsWith(i)).map(c=>+(c.replace(i,"")||0)),o=Dn(a)+1,s=`${i}${o}`;t[s]=r,r.getOptions().key=s}}return t}function q3(t,e){const[n]=gr("scale",e),{relations:r}=t,[i]=XG(r),a=n(t);return i(a)}function UG(t){const e=t.flatMap(n=>Array.from(n.values())).flatMap(n=>n.channels.map(r=>r.scale));K3(e,"x"),K3(e,"y")}function qG(t){const{channels:e=[],type:n,scale:r={}}=t,i=["shape","color","opacity","size"];return e.length!==0?e:n==="axisX"?["x"]:n==="axisY"?["y"]:n==="legends"?Object.keys(r).filter(a=>i.includes(a)):[]}function K3(t,e){const n=t.filter(({name:a,facet:o=!0})=>o&&a===e),r=n.flatMap(a=>a.domain),i=n.every(Q3)?sc(r):n.every(J3)?Array.from(new Set(r)):null;if(i!==null)for(const a of n)a.domain=i}function KG(t,e,n){const{ratio:r}=n;return r==null?e:Q3({type:t})?QG(e,r,t):J3({type:t})?JG(e,r):e}function QG(t,e,n){const r=t.map(Number),i=new Ji({domain:r,range:[r[0],r[0]+(r[r.length-1]-r[0])*e]});return n==="time"?t.map(a=>new Date(i.map(a))):t.map(a=>i.map(a))}function JG(t,e){const n=Math.round(t.length*e);return t.slice(0,n)}function Q3(t){const{type:e}=t;return typeof e!="string"?!1:["linear","log","pow","time"].includes(e)}function J3(t){const{type:e}=t;return typeof e!="string"?!1:["band","point","ordinal"].includes(e)}function t$(t,e,n){const{type:r,domain:i,range:a,quantitative:o,ordinal:s}=n;return r!==void 0?r:v$(e)?"identity":typeof a=="string"?"linear":(i||a||[]).length>2?iO(t,s):i!==void 0?rC([i])?iO(t,s):iC(e)?"time":eC(t,a,o):rC(e)?iO(t,s):iC(e)?"time":eC(t,a,o)}function e$(t,e,n,r){const{domain:i}=r;if(i!==void 0)return i;switch(t){case"linear":case"time":case"log":case"pow":case"sqrt":case"quantize":case"threshold":return nC(u$(n,r),r);case"band":case"ordinal":case"point":return f$(n);case"quantile":return d$(n);case"sequential":return nC(h$(n),r);default:return[]}}function n$(t,e,n,r,i,a,o){const{range:s}=r;if(typeof s=="string")return i$(s);if(s!==void 0)return s;const{rangeMin:c,rangeMax:l}=r;switch(t){case"linear":case"time":case"log":case"pow":case"sqrt":{const u=tC(n,r,i,a,o),[f,d]=p$(e,u);return[c!=null?c:f,l!=null?l:d]}case"band":case"point":{const u=e==="size"?5:0,f=e==="size"?10:1;return[c!=null?c:u,l!=null?l:f]}case"ordinal":return tC(n,r,i,a,o);case"sequential":return;case"constant":return[n[0][0]];default:return[]}}function r$(t,e,n,r,i){switch(t){case"linear":case"time":case"log":case"pow":case"sqrt":return s$(i,r);case"band":case"point":return c$(t,e,i,r);case"sequential":return o$(r);default:return r}}function tC(t,e,n,r,i){const[a]=gr("palette",i),{category10:o,category20:s}=r,c=HF(n).length<=o.length?o:s,{palette:l=c,offset:u}=e;if(Array.isArray(l))return l;try{return a({type:l})}catch(f){const d=a$(l,n,u);if(d)return d;throw new Error(`Unknown Component: ${l} `)}}function i$(t){return t.split("-")}function a$(t,e,n=r=>r){if(!t)return null;const r=tl(t),i=fe[`scheme${r}`],a=fe[`interpolate${r}`];if(!i&&!a)return null;if(i){if(!i.some(Array.isArray))return i;const o=i[e.length];if(o)return o}return e.map((o,s)=>a(n(s/e.length)))}function o$(t){const{palette:e="ylGnBu",offset:n}=t,r=tl(e),i=fe[`interpolate${r}`];if(!i)throw new Error(`Unknown palette: ${r}`);return{interpolator:n?a=>i(n(a)):i}}function s$(t,e){const{interpolate:n=Rp,nice:r=!1,tickCount:i=5}=e;return Object.assign(Object.assign({},e),{interpolate:n,nice:r,tickCount:i})}function c$(t,e,n,r){if(r.padding!==void 0||r.paddingInner!==void 0||r.paddingOuter!==void 0)return Object.assign(Object.assign({},r),{unknown:NaN});const i=l$(t,e,n),{paddingInner:a=i,paddingOuter:o=i}=r;return Object.assign(Object.assign({},r),{paddingInner:a,paddingOuter:o,padding:i,unknown:NaN})}function l$(t,e,n){return e==="enterDelay"||e==="enterDuration"||e==="size"?0:t==="band"?r3(n)?0:.1:t==="point"?.5:0}function iO(t,e){return e||(g$(t)?"point":"ordinal")}function eC(t,e,n){return n||(t!=="color"||e?"linear":"sequential")}function nC(t,e){if(t.length===0)return t;const{domainMin:n,domainMax:r}=e,[i,a]=t;return[n!=null?n:i,r!=null?r:a]}function u$(t,e){const{zero:n=!1}=e;let r=1/0,i=-1/0;for(const a of t)for(const o of a)qn(o)&&(r=Math.min(r,+o),i=Math.max(i,+o));return r===1/0?[]:n?[Math.min(0,r),i]:[r,i]}function f$(t){return Array.from(new Set(t.flat()))}function d$(t){return t.flat().sort()}function h$(t){let e=1/0,n=-1/0;for(const r of t)for(const i of r)qn(i)&&(e=Math.min(e,+i),n=Math.max(n,+i));return e===1/0?[]:[e<0?-n:e,n]}function p$(t,e){return t==="enterDelay"?[0,1e3]:t=="enterDuration"?[300,1e3]:t.startsWith("y")||t.startsWith("position")?[1,0]:t==="color"?[YF(e),BA(e)]:t==="opacity"?[0,1]:t==="size"?[1,10]:[0,1]}function rC(t){return aO(t,e=>{const n=typeof e;return n==="string"||n==="boolean"})}function iC(t){return aO(t,e=>e instanceof Date)}function v$(t){return aO(t,Uf)}function aO(t,e){for(const n of t)if(n.some(e))return!0;return!1}function g$(t){return t.startsWith("x")||t.startsWith("y")||t.startsWith("position")||t.startsWith("size")}function y$(t){return t.startsWith("x")||t.startsWith("y")||t.startsWith("position")||t==="enterDelay"||t==="enterDuration"||t==="updateDelay"||t==="updateDuration"||t==="exitDelay"||t==="exitDuration"}function m$(t){if(!t||!t.type)return!1;if(typeof t.type=="function")return!0;const{type:e,domain:n,range:r,interpolator:i}=t,a=n&&n.length>0,o=r&&r.length>0;return!!(["linear","sqrt","log","time","pow","threshold","quantize","quantile","ordinal","band","point"].includes(e)&&a&&o||["sequential"].includes(e)&&a&&(o||i)||["constant","identity"].includes(e)&&o)}const b$={linear:"linear",identity:"identity",log:"log",pow:"pow",sqrt:"sqrt",sequential:"sequential"},x$={threshold:"threshold",quantize:"quantize",quantile:"quantile"},_$={ordinal:"ordinal",band:"band",point:"point"},w$={constant:"constant"};var ul=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function O$(t,e,n){const{coordinates:r=[],title:i}=e,[,a]=gr("component",n),o=t.filter(({guide:u})=>u!==null),s=[],c=R$(e,t,n);if(s.push(...c),i){const{props:u}=a("title"),{defaultPosition:f,defaultOrientation:d,defaultOrder:h,defaultSize:v,defaultCrossPadding:g}=u,y=typeof i=="string"?{title:i}:i;s.push(Object.assign({type:"title",position:f,orientation:d,order:h,crossPadding:g[0],defaultSize:v},y))}return A$(o,r).forEach(([u,f])=>{const{props:d}=a(u),{defaultPosition:h,defaultPlane:v="xy",defaultOrientation:g,defaultSize:y,defaultOrder:b,defaultLength:x,defaultPadding:_=[0,0],defaultCrossPadding:w=[0,0]}=d,O=mt({},...f),{guide:E,field:M}=O,k=Array.isArray(E)?E:[E];for(const A of k){const[P,C]=C$(u,h,g,A,f,o,r);if(!P&&!C)continue;const N=P==="left"||P==="right",L=N?_[1]:_[0],R=N?w[1]:w[0],{size:I,order:D=b,length:G=x,padding:F=L,crossPadding:W=R}=A;s.push(Object.assign(Object.assign({title:M},A),{defaultSize:y,length:G,position:P,plane:v,orientation:C,padding:F,order:D,crossPadding:W,size:I,type:u,scales:f}))}}),s}function aC(t,e,n,r,i){const[a]=gr("component",r),{scaleInstances:o,scale:s,bbox:c}=t,l=ul(t,["scaleInstances","scale","bbox"]),u={bbox:c,library:r};return a(l)({coordinate:e,library:r,markState:i,scales:o,theme:n,value:u,scale:s})}function S$(t){return t.map(e=>{const n=mt(e,e.style);return delete n.style,n})}function Oot(t){return t.flatMap(e=>e.type=="group"?e.children:e)}function oC(t,e){const n=["left","right","bottom","top"];return Qy(t,({type:a,position:o,group:s})=>n.includes(o)?s===void 0?a.startsWith("legend")?`legend-${o}`:Symbol("independent"):s==="independent"?Symbol("independent"):s:Symbol("independent")).flatMap(([,a])=>{if(a.length===1)return a[0];if(e!==void 0){const u=a.filter(g=>g.length!==void 0).map(g=>g.length),f=bo(u);if(f>e)return a.forEach(g=>g.group=Symbol("independent")),a;const d=e-f,h=a.length-u.length,v=d/h;a.forEach(g=>{g.length===void 0&&(g.length=v)})}const o=Dn(a,u=>u.size),s=Dn(a,u=>u.order),c=Dn(a,u=>u.crossPadding),l=a[0].position;return{type:"group",size:o,order:s,position:l,children:a,crossPadding:c}})}function E$(t,e){const n=["shape","size","color","opacity"],r=(d,h)=>d==="constant"&&h==="size",i=t.filter(({type:d,name:h})=>typeof d=="string"&&n.includes(h)&&!r(d,h)),a=i.filter(({type:d})=>d==="constant"),o=i.filter(({type:d})=>d!=="constant"),c=Qy(o,d=>d.field?d.field:Symbol("independent")).map(([d,h])=>[d,[...h,...a]]).filter(([,d])=>d.some(h=>h.type!=="constant")),l=new Map(c);if(l.size===0)return[];const u=d=>d.sort(([h],[v])=>h.localeCompare(v));return Array.from(l).map(([,d])=>{const v=VF(d).sort((g,y)=>y.length-g.length).map(g=>({combination:g,option:g.map(y=>[y.name,M$(y)])}));for(const{option:g,combination:y}of v)if(!g.every(b=>b[1]==="constant")&&g.every(b=>b[1]==="discrete"||b[1]==="constant"))return["legendCategory",y];for(const[g,y]of qF)for(const{option:b,combination:x}of v)if(y.some(_=>GA(u(_),u(b))))return[g,x];return null}).filter(qn)}function M$(t){const{type:e}=t;return typeof e!="string"?null:e in b$?"continuous":e in _$?"discrete":e in x$?"distribution":e in w$?"constant":null}function k$(t,e){return t.map(n=>{const{name:r}=n;if(_W(e)||r3(e)||ud(e)&&(Ou(e)||Kp(e)))return null;if(r.startsWith("x"))return Ou(e)?["axisArc",[n]]:Kp(e)?["axisLinear",[n]]:[ud(e)?"axisY":"axisX",[n]];if(r.startsWith("y"))return Ou(e)?["axisLinear",[n]]:Kp(e)?["axisArc",[n]]:[ud(e)?"axisX":"axisY",[n]];if(r.startsWith("z"))return["axisZ",[n]];if(r.startsWith("position")){if(SW(e))return["axisRadar",[n]];if(!Ou(e))return["axisY",[n]]}return null}).filter(qn)}function A$(t,e){const n=t.filter(r=>m$(r));return[...E$(n,e),...k$(n,e)]}function oO(t){const e=Go(t,"polar");if(e.length){const r=e[e.length-1],{startAngle:i,endAngle:a}=$A(r);return[i,a]}const n=Go(t,"radial");if(n.length){const r=n[n.length-1],{startAngle:i,endAngle:a}=ZA(r);return[i,a]}return[-Math.PI/2,Math.PI/2*3]}function T$(t){const e=/position(\d*)/g.exec(t);return e?+e[1]:null}function P$(t,e,n,r,i){const{name:a}=n[0];if(t==="axisRadar"){const o=r.filter(f=>f.name.startsWith("position")),s=T$(a);if(a===o.slice(-1)[0].name||s===null)return[null,null];const[c,l]=oO(i);return["center",(l-c)/(o.length-1)*s+c]}if(t==="axisY"&&wW(i))return ud(i)?["center","horizontal"]:["center","vertical"];if(t==="axisLinear"){const[o]=oO(i);return["center",o]}return t==="axisArc"?e[0]==="inner"?["inner",null]:["outer",null]:Ou(i)?["center",null]:Kp(i)?["center",null]:t==="axisX"&&OW(i)||t==="axisX"&&EW(i)?["top",null]:e}function C$(t,e,n,r,i,a,o){const[s]=oO(o),c=[r.position||e,s!=null?s:n];return typeof t=="string"&&t.startsWith("axis")?P$(t,c,i,a,o):typeof t=="string"&&t.startsWith("legend")&&Ou(o)&&r.position==="center"?["center","vertical"]:c}function L$(t,e,n=[]){return t==="x"?ud(n)?`${e}Y`:`${e}X`:t==="y"?ud(n)?`${e}X`:`${e}Y`:null}function R$(t,e,n){const[,r]=gr("component",n),{coordinates:i}=t;function a(o,s,c,l){const u=L$(s,o,i);if(!l||!u)return;const{props:f}=r(u),{defaultPosition:d,defaultSize:h,defaultOrder:v,defaultCrossPadding:[g]}=f;return Object.assign(Object.assign({position:d,defaultSize:h,order:v,type:u,crossPadding:g},l),{scales:[c]})}return e.filter(o=>o.slider||o.scrollbar).flatMap(o=>{const{slider:s,scrollbar:c,name:l}=o;return[a("slider",l,o,s),a("scrollbar",l,o,c)]}).filter(o=>!!o)}function sC(t,e,n,r,i,a){const{type:o}=t;if(!["left","right","bottom","top"].includes(r)||typeof o!="string")return;const c=o;return(c.startsWith("axis")?F$:c.startsWith("group")?N$:c.startsWith("legendContinuous")?B$:c==="legendCategory"?z$:c.startsWith("slider")?j$:c==="title"?D$:c.startsWith("scrollbar")?I$:()=>{})(t,e,n,r,i,a)}function N$(t,e,n,r,i,a){const{children:o}=t,s=Dn(o,l=>l.crossPadding);o.forEach(l=>l.crossPadding=s),o.forEach(l=>sC(l,e,n,r,i,a));const c=Dn(o,l=>l.size);t.size=c,o.forEach(l=>l.size=c)}function I$(t,e,n,r,i,a){const{trackSize:o=6}=mt({},i.scrollbar,t);t.size=o}function D$(t,e,n,r,i,a){const o=mt({},i.title,t),{title:s,subtitle:c,spacing:l=0}=o,u=ul(o,["title","subtitle","spacing"]);if(s){const f=$t(u,"title"),d=Um(s,f);t.size=d.height}if(c){const f=$t(u,"subtitle"),d=Um(c,f);t.size+=l+d.height}}function j$(t,e,n,r,i,a){const o=()=>{const{slider:u}=i;return mt({},u,t)},{trackSize:s,handleIconSize:c}=o(),l=Math.max(s,c*2.4);t.size=l}function F$(t,e,n,r,i,a){var o;t.transform=t.transform||[{type:"hide"}];const s=r==="left"||r==="right",c=cC(t,r,i),{tickLength:l=0,labelSpacing:u=0,titleSpacing:f=0,labelAutoRotate:d}=c,h=ul(c,["tickLength","labelSpacing","titleSpacing","labelAutoRotate"]),v=Hm(t,a),g=Vm(h,v),y=l+u;if(g&&g.length){const x=Dn(g,w=>w.width),_=Dn(g,w=>w.height);if(s)t.size=x+y;else{const{tickFilter:w,labelTransform:O}=t;$$(v,g,e,n,w)&&!O&&d!==!1&&d!==null?(t.labelTransform="rotate(90)",t.size=x+y):(t.labelTransform=(o=t.labelTransform)!==null&&o!==void 0?o:"rotate(0)",t.size=_+y)}}else t.size=l;const b=Xm(h);b&&(s?t.size+=f+b.width:t.size+=f+b.height)}function B$(t,e,n,r,i,a){const s=(()=>{const{legendContinuous:w}=i;return mt({},w,t)})(),{labelSpacing:c=0,titleSpacing:l=0}=s,u=ul(s,["labelSpacing","titleSpacing"]),f=r==="left"||r==="right",d=$t(u,"ribbon"),{size:h}=d,v=$t(u,"handleIcon"),{size:g}=v,y=Math.max(h,g*2.4);t.size=y;const b=Hm(t,a),x=Vm(u,b);if(x){const w=f?"width":"height",O=Dn(x,E=>E[w]);t.size+=O+c}const _=Xm(u);_&&(f?t.size=Math.max(t.size,_.width):t.size+=l+_.height)}function z$(t,e,n,r,i,a){const s=(()=>{const{legendCategory:R}=i,{title:I}=t,[D,G]=Array.isArray(I)?[I,void 0]:[void 0,I];return mt({title:D},R,Object.assign(Object.assign({},t),{title:G}))})(),{itemSpacing:c,itemMarkerSize:l,titleSpacing:u,rowPadding:f,colPadding:d,maxCols:h=1/0,maxRows:v=1/0}=s,g=ul(s,["itemSpacing","itemMarkerSize","titleSpacing","rowPadding","colPadding","maxCols","maxRows"]),{cols:y,length:b}=t,x=R=>Math.min(R,v),_=R=>Math.min(R,h),w=r==="left"||r==="right",O=b===void 0?e+(w?0:n[0]+n[1]):b,E=Xm(g),M=Hm(t,a),k=Vm(g,M,"itemLabel"),A=Math.max(k[0].height,l)+f,P=(R,I=0)=>l+R+c[0]+I;w?(()=>{let R=-1/0,I=0,D=1,G=0,F=-1/0,W=-1/0;const X=E?E.height:0,Q=O-X;for(const{width:tt}of k){const nt=P(tt,d);R=Math.max(R,nt),I+A>Q?(D++,F=Math.max(F,G),W=Math.max(W,I),G=1,I=A):(I+=A,G++)}D<=1&&(F=G,W=I),t.size=R*_(D),t.length=W+X,mt(t,{cols:_(D),gridRow:F})})():typeof y=="number"?(()=>{const R=Math.ceil(k.length/y),I=Dn(k,D=>P(D.width))*y;t.size=A*x(R)-f,t.length=Math.min(I,O)})():(()=>{let R=1,I=0,D=-1/0;for(const{width:G}of k){const F=P(G,d);I+F>O?(D=Math.max(D,I),I=F,R++):I+=F}R===1&&(D=I),t.size=A*x(R)-f,t.length=D})(),E&&(w?t.size=Math.max(t.size,E.width):t.size+=u+E.height)}function Hm(t,e){const[n]=gr("scale",e),{scales:r,tickCount:i,tickMethod:a}=t,o=r.find(s=>s.type!=="constant"&&s.type!=="identity");return i!==void 0&&(o.tickCount=i),a!==void 0&&(o.tickMethod=a),n(o)}function Vm(t,e,n="label"){const{labelFormatter:r,tickFilter:i,label:a=!0}=t,o=ul(t,["labelFormatter","tickFilter","label"]);if(!a)return null;const s=W$(e,r,i),c=$t(o,n),l=s.map((d,h)=>Object.fromEntries(Object.entries(c).map(([v,g])=>[v,typeof g=="function"?g(d,h):g]))),u=s.map((d,h)=>{const v=l[h];return Um(d,v)});if(!l.some(d=>d.transform)){const d=s.map((h,v)=>v);t.indexBBox=new Map(d.map(h=>[h,[s[h],u[h]]]))}return u}function Xm(t){const e=l=>l===!1||l===null,{title:n}=t,r=ul(t,["title"]);if(e(n)||n===void 0)return null;const i=$t(r,"title"),{direction:a,transform:o}=i,s=Array.isArray(n)?n.join(","):n;return typeof s!="string"?null:Um(s,Object.assign(Object.assign({},i),{transform:o||(a==="vertical"?"rotate(-90)":"")}))}function cC(t,e,n){const{title:r}=t,[i,a]=Array.isArray(r)?[r,void 0]:[void 0,r],{axis:o,[`axis${K_(e)}`]:s}=n;return mt({title:i},o,s,Object.assign(Object.assign({},t),{title:a}))}function lC(t,e){const n=t.getTicks?t.getTicks():t.getOptions().domain;return e?n.filter(e):n}function W$(t,e,n){const i=lC(t,n).map(o=>typeof o=="number"?rm(o):o),a=e?typeof e=="string"?el(e):e:t.getFormatter?t.getFormatter():o=>`${o}`;return i.map(a)}function G$(t,e){return t.getBandWidth?t.getBandWidth(e)/2:0}function $$(t,e,n,r,i){if(bo(e,h=>h.width)>n)return!0;const o=t.clone();o.update({range:[0,n]});const s=lC(t,i),c=s.map(h=>o.map(h)+G$(o,h)),l=s.map((h,v)=>v),u=-r[0],f=n+r[1],d=(h,v)=>{const{width:g}=v;return[h-g/2,h+g/2]};for(let h=0;h<l.length;h++){const v=c[h],[g,y]=d(v,e[h]);if(g<u||y>f)return!0;const b=c[h+1];if(b){const[x]=d(b,e[h+1]);if(y>x)return!0}}return!1}function Um(t,e){const n=Z$(t),{filter:r}=e,i=ul(e,["filter"]);return n.attr(Object.assign(Object.assign({},i),{visibility:"none"})),n.getBBox()}function Z$(t){return t instanceof or?t:new po({style:{text:`${t}`}})}function Za(t,e){let n;if(e===void 0)for(const r of t)r!=null&&(n>r||n===void 0&&r>=r)&&(n=r);else{let r=-1;for(let i of t)(i=e(i,++r,t))!=null&&(n>i||n===void 0&&i>=i)&&(n=i)}return n}function Y$(t){const e=t.find(({type:i})=>i==="axisX"),n=t.find(({type:i})=>i==="axisY"),r=t.find(({type:i})=>i==="axisZ");e&&n&&r&&(e.plane="xy",n.plane="xy",r.plane="yz",r.origin=[e.bbox.x,e.bbox.y,0],r.eulerAngles=[0,-90,0],r.bbox.x=e.bbox.x,r.bbox.y=e.bbox.y,t.push(Object.assign(Object.assign({},e),{plane:"xz",showLabel:!1,showTitle:!1,origin:[e.bbox.x,e.bbox.y,0],eulerAngles:[-90,0,0]})),t.push(Object.assign(Object.assign({},n),{plane:"yz",showLabel:!1,showTitle:!1,origin:[n.bbox.x+n.bbox.width,n.bbox.y,0],eulerAngles:[0,-90,0]})),t.push(Object.assign(Object.assign({},r),{plane:"xz",actualPosition:"left",showLabel:!1,showTitle:!1,eulerAngles:[90,-90,0]})))}function H$(t,e,n,r){var i,a;const{width:o,height:s,depth:c,x:l=0,y:u=0,z:f=0,inset:d=(i=n.inset)!==null&&i!==void 0?i:0,insetLeft:h=d,insetTop:v=d,insetBottom:g=d,insetRight:y=d,margin:b=(a=n.margin)!==null&&a!==void 0?a:0,marginLeft:x=b,marginBottom:_=b,marginTop:w=b,marginRight:O=b,padding:E=n.padding,paddingBottom:M=E,paddingLeft:k=E,paddingRight:A=E,paddingTop:P=E}=X$(t,e,n,r),C=1/4,N=(Lt,It,jt,Qt,ue)=>{const{marks:ye}=e;if(ye.length===0)return[Qt,ue];if(Lt-Qt-ue-Lt*C>0)return[Qt,ue];const Ne=Lt*(1-C);return[It==="auto"?Ne*Qt/(Qt+ue):Qt,jt==="auto"?Ne*ue/(Qt+ue):ue]},L=Lt=>Lt==="auto"?20:Lt!=null?Lt:20,R=L(P),I=L(M),D=uC(t,s-R-I,[R+w,I+_],["left","right"],e,n,r),{paddingLeft:G,paddingRight:F}=D,W=o-x-O,[X,Q]=N(W,k,A,G,F),tt=W-X-Q,nt=uC(t,tt,[X+x,Q+O],["bottom","top"],e,n,r),{paddingTop:ht,paddingBottom:lt}=nt,wt=s-_-w,[yt,gt]=N(wt,M,P,lt,ht),Bt=wt-yt-gt;return{width:o,height:s,depth:c,insetLeft:h,insetTop:v,insetBottom:g,insetRight:y,innerWidth:tt,innerHeight:Bt,paddingLeft:X,paddingRight:Q,paddingTop:gt,paddingBottom:yt,marginLeft:x,marginBottom:_,marginTop:w,marginRight:O,x:l,y:u,z:f}}function V$(t){const{height:e,width:n,padding:r=0,paddingLeft:i=r,paddingRight:a=r,paddingTop:o=r,paddingBottom:s=r,margin:c=16,marginLeft:l=c,marginRight:u=c,marginTop:f=c,marginBottom:d=c,inset:h=0,insetLeft:v=h,insetRight:g=h,insetTop:y=h,insetBottom:b=h}=t,x=O=>O==="auto"?20:O,_=n-x(i)-x(a)-l-u-v-g,w=e-x(o)-x(s)-f-d-y-b;return{width:_,height:w}}function X$(t,e,n,r){const{coordinates:i}=e;if(!Ou(i)&&!Kp(i))return e;const a=t.filter(b=>typeof b.type=="string"&&b.type.startsWith("axis"));if(a.length===0)return e;const o=a.map(b=>{const x=b.type==="axisArc"?"arc":"linear";return cC(b,x,n)}),s=Dn(o,b=>{var x;return(x=b.labelSpacing)!==null&&x!==void 0?x:0}),c=a.flatMap((b,x)=>{const _=o[x],w=Hm(b,r);return Vm(_,w)}).filter(qn),l=Dn(c,b=>b.height)+s,u=a.flatMap((b,x)=>{const _=o[x];return Xm(_)}).filter(b=>b!==null),f=u.length===0?0:Dn(u,b=>b.height),{inset:d=l,insetLeft:h=d,insetBottom:v=d,insetTop:g=d+f,insetRight:y=d}=e;return Object.assign(Object.assign({},e),{insetLeft:h,insetBottom:v,insetTop:g,insetRight:y})}function uC(t,e,n,r,i,a,o){const s=dr(t,v=>v.position),{padding:c=a.padding,paddingLeft:l=c,paddingRight:u=c,paddingBottom:f=c,paddingTop:d=c}=i,h={paddingBottom:f,paddingLeft:l,paddingTop:d,paddingRight:u};for(const v of r){const g=`padding${K_(wP(v))}`,y=s.get(v)||[],b=h[g],x=A=>{A.size===void 0&&(A.size=A.defaultSize)},_=A=>{A.type==="group"?(A.children.forEach(x),A.size=Dn(A.children,P=>P.size)):A.size=A.defaultSize},w=A=>{A.size||(b!=="auto"?_(A):(sC(A,e,n,v,a,o),x(A)))},O=A=>{A.type.startsWith("axis")&&A.labelAutoHide===void 0&&(A.labelAutoHide=!0)},E=v==="bottom"||v==="top",M=Za(y,A=>A.order),k=y.filter(A=>A.type.startsWith("axis")&&A.order==M);if(k.length&&(k[0].crossPadding=0),typeof b=="number")y.forEach(x),y.forEach(O);else if(y.length===0)h[g]=0;else{const A=E?e+n[0]+n[1]:e,P=oC(y,A);P.forEach(w);const C=P.reduce((N,{size:L,crossPadding:R=12})=>N+L+R,0);h[g]=C}}return h}function U$(t,e,n){const r=dr(t,E=>`${E.plane||"xy"}-${E.position}`),{paddingLeft:i,paddingRight:a,paddingTop:o,paddingBottom:s,marginLeft:c,marginTop:l,marginBottom:u,marginRight:f,innerHeight:d,innerWidth:h,insetBottom:v,insetLeft:g,insetRight:y,insetTop:b,height:x,width:_,depth:w}=n,O={xy:sO({width:_,height:x,paddingLeft:i,paddingRight:a,paddingTop:o,paddingBottom:s,marginLeft:c,marginTop:l,marginBottom:u,marginRight:f,innerHeight:d,innerWidth:h,insetBottom:v,insetLeft:g,insetRight:y,insetTop:b}),yz:sO({width:w,height:x,paddingLeft:0,paddingRight:0,paddingTop:0,paddingBottom:0,marginLeft:0,marginTop:0,marginBottom:0,marginRight:0,innerWidth:w,innerHeight:x,insetBottom:0,insetLeft:0,insetRight:0,insetTop:0}),xz:sO({width:_,height:w,paddingLeft:0,paddingRight:0,paddingTop:0,paddingBottom:0,marginLeft:0,marginTop:0,marginBottom:0,marginRight:0,innerWidth:_,innerHeight:w,insetBottom:0,insetLeft:0,insetRight:0,insetTop:0})};for(const[E,M]of r.entries()){const[k,A]=E.split("-"),P=O[k][A],[C,N]=zA(M,L=>typeof L.type!="string"?!1:!!(A==="center"||L.type.startsWith("axis")&&["inner","outer"].includes(A)));C.length&&q$(C,e,P,A),N.length&&aZ(M,e,P)}}function sO({width:t,height:e,paddingLeft:n,paddingRight:r,paddingTop:i,paddingBottom:a,marginLeft:o,marginTop:s,marginBottom:c,marginRight:l,innerHeight:u,innerWidth:f,insetBottom:d,insetLeft:h,insetRight:v,insetTop:g}){const y=n+o,b=i+s,x=r+l,_=a+c,w=t-o-l,O=[y+h,b+g,f-h-v,u-g-d,"center",null,null];return{top:[y,0,f,b,"vertical",!0,kr,o,w],right:[t-x,b,x,u,"horizontal",!1,kr],bottom:[y,e-_,f,_,"vertical",!1,kr,o,w],left:[0,b,y,u,"horizontal",!0,kr],"top-left":[y,0,f,b,"vertical",!0,kr],"top-right":[y,0,f,b,"vertical",!0,kr],"bottom-left":[y,e-_,f,_,"vertical",!1,kr],"bottom-right":[y,e-_,f,_,"vertical",!1,kr],center:O,inner:O,outer:O}}function q$(t,e,n,r){const[i,a]=zA(t,o=>!!(typeof o.type=="string"&&o.type.startsWith("axis")));K$(i,e,n,r),oZ(a,e,n)}function K$(t,e,n,r){r==="center"?KF(e)?iZ(t,e,n,r):Bn(e)?tZ(t,e,n):Ep(e)&&eZ(t,e,n,t[0].orientation):r==="inner"?Q$(t,e,n):r==="outer"&&J$(t,e,n)}function Q$(t,e,n){const[r,i,,a]=n,[o,s]=e.getCenter(),[c]=im(e),l=a/2,u=c*l,f=o-u,d=s-u;for(let h=0;h<t.length;h++){const v=t[h];v.bbox={x:r+f,y:i+d,width:u*2,height:u*2}}}function J$(t,e,n){const[r,i,a,o]=n;for(const s of t)s.bbox={x:r,y:i,width:a,height:o}}function tZ(t,e,n){const[r,i,a,o]=n;for(const s of t)s.bbox={x:r,y:i,width:a,height:o}}function eZ(t,e,n,r){r==="horizontal"?rZ(t,e,n):r==="vertical"&&nZ(t,e,n)}function nZ(t,e,n){const[r,i,,a]=n,o=new Array(t.length).fill(0),c=e.map(o).filter((l,u)=>u%2===0).map(l=>l+r);for(let l=0;l<t.length;l++){const u=t[l],f=c[l],d=c[l+1]-f;u.bbox={x:f,y:i,width:d,height:a}}}function rZ(t,e,n){const[r,i,a]=n,o=new Array(t.length).fill(0),c=e.map(o).filter((l,u)=>u%2===1).map(l=>l+i);for(let l=0;l<t.length;l++){const u=t[l],f=c[l],d=c[l+1]-f;u.bbox={x:r,y:f,width:a,height:d}}}function iZ(t,e,n,r){const[i,a,o,s]=n;for(const c of t)c.bbox={x:i,y:a,width:o,height:s},c.radar={index:t.indexOf(c),count:t.length}}function aZ(t,e,n){const[r,i,a,o,s,c,l,u,f]=n,[d,h,v,g,y,b,x,_]=s==="vertical"?["y",i,"x",r,"height",o,"width",a]:["x",r,"y",i,"width",a,"height",o];t.sort((A,P)=>l==null?void 0:l(A.order,P.order));const w=A=>A==="title"||A==="group"||A.startsWith("legend"),O=(A,P,C)=>C===void 0?P:w(A)?C:P,E=(A,P,C)=>C===void 0?P:w(A)?C:P,M=c?h+b:h;for(let A=0,P=M;A<t.length;A++){const C=t[A],{crossPadding:N=0,type:L}=C,{size:R}=C;C.bbox={[d]:c?P-R-N:P+N,[v]:E(L,g,u),[y]:R,[x]:O(L,_,f)},P+=(R+N)*(c?-1:1)}const k=t.filter(A=>A.type==="group");for(const A of k){const{bbox:P,children:C}=A,N=P[x],L=N/C.length,R=C.reduce((W,X)=>{var Q;const tt=(Q=X.layout)===null||Q===void 0?void 0:Q.justifyContent;return tt||W},"flex-start"),I=C.map((W,X)=>{const{length:Q=L,padding:tt=0}=W;return Q+(X===C.length-1?0:tt)}),D=bo(I),G=N-D,F=R==="flex-start"?0:R==="center"?G/2:G;for(let W=0,X=P[v]+F;W<C.length;W++){const Q=C[W],{padding:tt=0}=Q,nt=W===C.length-1?0:tt;Q.bbox={[y]:P[y],[d]:P[d],[v]:X,[x]:I[W]-nt},mt(Q,{layout:{justifyContent:R}}),X+=I[W]}}}function oZ(t,e,n){if(t.length===0)return;const[r,i,a,o]=n,[s]=im(e),c=o/2*s/Math.sqrt(2),l=r+a/2,u=i+o/2;for(let f=0;f<t.length;f++){const d=t[f];d.bbox={x:l-c,y:u-c,width:c*2,height:c*2}}}function xs(t,e,n={},r=!1){if(rc(t)||Array.isArray(t)&&r)return t;const i=$t(t,e);return mt(n,i)}function qm(t,e={}){return rc(t)||Array.isArray(t)||!fC(t)?t:mt(e,t)}function fC(t){if(Object.keys(t).length===0)return!0;const{title:e,items:n}=t;return e!==void 0||n!==void 0}function _s(t,e){return typeof t=="object"?$t(t,e):t}var sZ=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})},vd=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function cZ(t,e,n){const{encode:r={},scale:i={},transform:a=[]}=e,o=vd(e,["encode","scale","transform"]);return[t,Object.assign(Object.assign({},o),{encode:r,scale:i,transform:a})]}function dC(t,e,n){return sZ(this,void 0,void 0,function*(){const{library:r}=n,{data:i}=e,[a]=gr("data",r),o=_Z(i),{transform:s=[]}=o,u=[vd(o,["transform"]),...s].map(h=>a(h,n)),f=yield PF(u)(i),d=i&&!Array.isArray(i)&&!Array.isArray(f)?{value:f}:f;return[Array.isArray(f)?fu(f):[],Object.assign(Object.assign({},e),{data:d})]})}function lZ(t,e,n){const{encode:r}=e;if(!r)return[t,e];const i={};for(const[a,o]of Object.entries(r))if(Array.isArray(o))for(let s=0;s<o.length;s++){const c=`${a}${s===0?"":s}`;i[c]=o[s]}else i[a]=o;return[t,Object.assign(Object.assign({},e),{encode:i})]}function uZ(t,e,n){const{encode:r,data:i}=e;if(!r)return[t,e];const a=fs(r,o=>mZ(o)?o:{type:bZ(i,o),value:o});return[t,Object.assign(Object.assign({},e),{encode:a})]}function fZ(t,e,n){const{encode:r}=e;if(!r)return[t,e];const i=fs(r,(a,o)=>{const{type:s}=a;return s!=="constant"||y$(o)?a:Object.assign(Object.assign({},a),{constant:!0})});return[t,Object.assign(Object.assign({},e),{encode:i})]}function dZ(t,e,n){const{encode:r,data:i}=e;if(!r)return[t,e];const{library:a}=n,o=SZ(a),s=fs(r,c=>o(i,c));return[t,Object.assign(Object.assign({},e),{encode:s})]}function hZ(t,e,n){const{tooltip:r={}}=e;return rc(r)?[t,e]:Array.isArray(r)?[t,Object.assign(Object.assign({},e),{tooltip:{items:r}})]:Uf(r)&&fC(r)?[t,Object.assign(Object.assign({},e),{tooltip:r})]:[t,Object.assign(Object.assign({},e),{tooltip:{items:[r]}})]}function pZ(t,e,n){const{data:r,encode:i,tooltip:a={}}=e;if(rc(a))return[t,e];const o=f=>{if(!f)return f;if(typeof f=="string")return t.map(d=>({name:f,value:r[d][f]}));if(Uf(f)){const{field:d,channel:h,color:v,name:g=d,valueFormatter:y=E=>E}=f,b=typeof y=="string"?el(y):y,x=h&&i[h],_=x&&i[h].field,w=g||_||h,O=[];for(const E of t){const M=d?r[E][d]:x?i[h].value[E]:null;O[E]={name:w,color:v,value:b(M)}}return O}if(typeof f=="function"){const d=[];for(const h of t){const v=f(r[h],h,r,i);Uf(v)?d[h]=v:d[h]={value:v}}return d}return f},{title:s,items:c=[]}=a,l=vd(a,["title","items"]),u=Object.assign({title:o(s),items:Array.isArray(c)?c.map(o):[]},l);return[t,Object.assign(Object.assign({},e),{tooltip:u})]}function vZ(t,e,n){const{encode:r}=e,i=vd(e,["encode"]);if(!r)return[t,e];const a=Object.entries(r),o=a.filter(([,c])=>{const{value:l}=c;return Array.isArray(l[0])}).flatMap(([c,l])=>{const u=[[c,new Array(t.length).fill(void 0)]],{value:f}=l,d=vd(l,["value"]);for(let h=0;h<f.length;h++){const v=f[h];if(Array.isArray(v))for(let g=0;g<v.length;g++){const y=u[g]||[`${c}${g}`,new Array(t).fill(void 0)];y[1][h]=v[g],u[g]=y}}return u.map(([h,v])=>[h,Object.assign({type:"column",value:v},d)])}),s=Object.fromEntries([...a,...o]);return[t,Object.assign(Object.assign({},i),{encode:s})]}function gZ(t,e,n){const{axis:r={},legend:i={},slider:a={},scrollbar:o={}}=e,s=(l,u)=>{if(typeof l=="boolean")return l?{}:null;const f=l[u];return f===void 0||f?f:null},c=typeof r=="object"?Array.from(new Set(["x","y","z",...Object.keys(r)])):["x","y","z"];return mt(e,{scale:Object.assign(Object.assign({},Object.fromEntries(c.map(l=>{const u=s(o,l);return[l,Object.assign({guide:s(r,l),slider:s(a,l),scrollbar:u},u&&{ratio:u.ratio===void 0?.5:u.ratio})]}))),{color:{guide:s(i,"color")},size:{guide:s(i,"size")},shape:{guide:s(i,"shape")},opacity:{guide:s(i,"opacity")}})}),[t,e]}function yZ(t,e,n){const{animate:r}=e;return r||r===void 0?[t,e]:(mt(e,{animate:{enter:{type:null},exit:{type:null},update:{type:null}}}),[t,e])}function mZ(t){if(typeof t!="object"||t instanceof Date||t===null)return!1;const{type:e}=t;return qn(e)}function bZ(t,e){return typeof e=="function"?"transform":typeof e=="string"&&xZ(t,e)?"field":"constant"}function xZ(t,e){return Array.isArray(t)?t.some(n=>n[e]!==void 0):!1}function _Z(t){if(Vn(t))return{type:"inline",value:t};if(!t)return{type:"inline",value:null};if(Array.isArray(t))return{type:"inline",value:t};const{type:e="inline"}=t,n=vd(t,["type"]);return Object.assign(Object.assign({},n),{type:e})}var hC=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})},wZ=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function OZ(t,e,n){return hC(this,void 0,void 0,function*(){const[r,i]=yield EZ(t,e,n),{encode:a,scale:o,data:s,tooltip:c}=i;if(Array.isArray(s)===!1)return null;const{channels:l}=e,u=Jy(Object.entries(a).filter(([,d])=>qn(d)),d=>d.map(([h,v])=>Object.assign({name:h},v)),([d])=>{var h;const v=(h=/([^\d]+)\d*$/.exec(d))===null||h===void 0?void 0:h[1],g=l.find(y=>y.name===v);return g!=null&&g.independent?d:v}),f=l.filter(d=>{const{name:h,required:v}=d;if(u.find(([g])=>g===h))return!0;if(v)throw new Error(`Missing encoding for channel: ${h}.`);return!1}).flatMap(d=>{const{name:h,scale:v,scaleKey:g,range:y,quantitative:b,ordinal:x}=d;return u.filter(([w])=>w.startsWith(h)).map(([w,O],E)=>{const M=O.some(D=>D.visual),k=O.some(D=>D.constant),A=o[w]||{},{independent:P=!1,key:C=g||w,type:N=k?"constant":M?"identity":v}=A,L=wZ(A,["independent","key","type"]),R=N==="constant",I=R?void 0:y;return{name:w,values:O,scaleKey:P||R?Symbol("independent"):C,scale:Object.assign(Object.assign({type:N,range:I},L),{quantitative:b,ordinal:x})}})});return[i,Object.assign(Object.assign({},e),{index:r,channels:f,tooltip:c})]})}function SZ(t){const[e]=gr("encode",t);return(n,r)=>r===void 0||n===void 0?null:Object.assign(Object.assign({},r),{type:"column",value:e(r)(n),field:MZ(r)})}function EZ(t,e,n){return hC(this,void 0,void 0,function*(){const{library:r}=n,[i]=gr("transform",r),{preInference:a=[],postInference:o=[]}=e,{transform:s=[]}=t,c=[cZ,dC,lZ,uZ,fZ,dZ,vZ,yZ,gZ,hZ,...a.map(i),...s.map(i),...o.map(i),pZ];let l=[],u=t;for(const f of c)[l,u]=yield f(l,u,n);return[l,u]})}function MZ(t){const{type:e,value:n}=t;return e==="field"&&typeof n=="string"?n:null}var uc=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})},fl=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function cO(t,e,n){var r;return uc(this,void 0,void 0,function*(){const{library:i}=n,[a]=gr("composition",i),[o]=gr("interaction",i),s=new Set(Object.keys(i).map(L=>{var R;return(R=/mark\.(.*)/.exec(L))===null||R===void 0?void 0:R[1]}).filter(qn)),c=new Set(Object.keys(i).map(L=>{var R;return(R=/component\.(.*)/.exec(L))===null||R===void 0?void 0:R[1]}).filter(qn)),l=L=>{const{type:R}=L;if(typeof R=="function"){const{props:I={}}=R,{composite:D=!0}=I;if(D)return"mark"}return typeof R!="string"?R:s.has(R)||c.has(R)?"mark":R},u=L=>l(L)==="mark",f=L=>l(L)==="standardView",d=L=>{const{type:R}=L;return typeof R!="string"?!1:!!c.has(R)},h=L=>{if(f(L))return[L];const R=l(L);return a({type:R,static:d(L)})(L)},v=[],g=new Map,y=new Map,b=[t],x=[];for(;b.length;){const L=b.shift();if(f(L)){const R=y.get(L),[I,D]=R?yC(R,L,i):yield vC(L,n);g.set(I,L),v.push(I);const G=D.flatMap(h).map(F=>n3(F,i));if(b.push(...G),G.every(f)){const F=yield Promise.all(G.map(W=>gC(W,n)));UG(F);for(let W=0;W<G.length;W++){const X=G[W],Q=F[W];y.set(X,Q)}}}else{const R=u(L)?L:yield _C(L,n),I=h(R);Array.isArray(I)?b.push(...I):typeof I=="function"&&x.push(I())}}n.emitter.emit(In.BEFORE_PAINT);const _=new Map,w=new Map,O=[];e.selectAll(ws(_i)).data(v,L=>L.key).join(L=>L.append("g").attr("className",_i).attr("id",R=>R.key).call(pC).each(function(R,I,D){uO(R,Oe(D),O,n),_.set(R,D)}),L=>L.call(pC).each(function(R,I,D){uO(R,Oe(D),O,n),w.set(R,D)}),L=>L.each(function(R,I,D){const G=D.nameInteraction.values();for(const F of G)F.destroy()}).remove());const E=(L,R,I)=>Array.from(L.entries()).map(([D,G])=>{const F=I||new Map,W=(tt,nt=ht=>ht)=>F.set(tt,nt),X=g.get(D),Q=AZ(Oe(G),X,n);return{view:D,container:G,options:X,setState:W,update:(tt,nt)=>uc(this,void 0,void 0,function*(){const lt=q_(Array.from(F.values()))(X);return yield Q(lt,tt,()=>{Nr(nt)&&R(L,nt,F)})})}}),M=(L=w,R,I)=>{var D;const G=E(L,M,I);for(const F of G){const{options:W,container:X}=F,Q=X.nameInteraction;let tt=Km(W);R&&(tt=tt.filter(nt=>R.includes(nt[0])));for(const nt of tt){const[ht,lt]=nt,wt=Q.get(ht);if(wt&&((D=wt.destroy)===null||D===void 0||D.call(wt)),lt){const gt=lO(F.view,ht,lt,o)(F,G,n.emitter);Q.set(ht,{destroy:gt})}}}},k=E(_,M);for(const L of k){const{options:R}=L,I=new Map;L.container.nameInteraction=I;for(const D of Km(R)){const[G,F]=D;if(F){const X=lO(L.view,G,F,o)(L,k,n.emitter);I.set(G,{destroy:X})}}}M();const{width:A,height:P}=t,C=[];for(const L of x){const R=new Promise(I=>uc(this,void 0,void 0,function*(){for(const D of L){const G=Object.assign({width:A,height:P},D);yield cO(G,e,n)}I()}));C.push(R)}n.views=v,(r=n.animations)===null||r===void 0||r.forEach(L=>L==null?void 0:L.cancel()),n.animations=O,n.emitter.emit(In.AFTER_PAINT);const N=O.filter(qn).map($Z).map(L=>L.finished);return Promise.all([...N,...C])})}function pC(t){t.style("transform",e=>`translate(${e.layout.x}, ${e.layout.y})`)}function kZ(t){const[,e]=gr("interaction",t);return n=>{const[r,i]=n;try{return[r,e(r)]}catch(a){return[r,i.type]}}}function AZ(t,e,n){const{library:r}=n,i=kZ(r),a=c=>c[1]&&c[1].props&&c[1].props.reapplyWhenUpdate,s=Km(e).map(i).filter(a).map(c=>c[0]);return(c,l,u)=>uc(this,void 0,void 0,function*(){const f=[],[d,h]=yield vC(c,n);uO(d,t,f,n);for(const v of s.filter(g=>g!==l))TZ(v,t,c,d,n);for(const v of h)cO(v,t,n);return u(),{options:c,view:d}})}function TZ(t,e,n,r,i){var a;const{library:o}=i,[s]=gr("interaction",o),l=e.node().nameInteraction,u=Km(n).find(([g])=>g===t),f=l.get(t);if(!f||((a=f.destroy)===null||a===void 0||a.call(f),!u[1]))return;const d=lO(r,t,u[1],s),h={options:n,view:r,container:e.node(),update:g=>Promise.resolve(g)},v=d(h,[],i.emitter);l.set(t,{destroy:v})}function vC(t,e){return uc(this,void 0,void 0,function*(){const{library:n}=e,r=yield CZ(t,e),i=PZ(r);t.interaction=i.interaction,t.coordinate=i.coordinate,t.marks=[...i.marks,...i.components];const a=n3(i,n),o=yield gC(a,e);return yC(o,a,n)})}function PZ(t){const{coordinate:e={},interaction:n={},style:r={},marks:i}=t,a=fl(t,["coordinate","interaction","style","marks"]),o=i.map(d=>d.coordinate||{}),s=i.map(d=>d.interaction||{}),c=i.map(d=>d.viewStyle||{}),l=[...o,e].reduceRight((d,h)=>mt(d,h),{}),u=[n,...s].reduce((d,h)=>mt(d,h),{}),f=[...c,r].reduce((d,h)=>mt(d,h),{});return Object.assign(Object.assign({},a),{marks:i,coordinate:l,interaction:u,style:f})}function CZ(t,e){return uc(this,void 0,void 0,function*(){const{library:n}=e,[r,i]=gr("mark",n),a=new Set(Object.keys(n).map(h=>{var v;return(v=/component\.(.*)/.exec(h))===null||v===void 0?void 0:v[1]}).filter(qn)),{marks:o}=t,s=[],c=[],l=[...o],{width:u,height:f}=V$(t),d={options:t,width:u,height:f};for(;l.length;){const[h]=l.splice(0,1),v=yield _C(h,e),{type:g=Xf("G2Mark type is required."),key:y}=v;if(a.has(g))c.push(v);else{const{props:b={}}=i(g),{composite:x=!0}=b;if(!x)s.push(v);else{const{data:_}=v,w=Object.assign(Object.assign({},v),{data:_&&(Array.isArray(_)?_:_.value)}),O=yield r(w,d),E=Array.isArray(O)?O:[O];l.unshift(...E.map((M,k)=>Object.assign(Object.assign({},M),{key:`${y}-${k}`})))}}}return Object.assign(Object.assign({},t),{marks:s,components:c})})}function gC(t,e){return uc(this,void 0,void 0,function*(){const{library:n}=e,[r]=gr("theme",n),[,i]=gr("mark",n),{theme:a,marks:o,coordinates:s=[]}=t,c=r(xC(a)),l=new Map;for(const f of o){const{type:d}=f,{props:h={}}=i(d),v=yield OZ(f,h,e);if(v){const[g,y]=v;l.set(g,y)}}const u=dr(Array.from(l.values()).flatMap(f=>f.channels),({scaleKey:f})=>f);for(const f of u.values()){const d=f.reduce((w,{scale:O})=>mt(w,O),{}),{scaleKey:h}=f[0],{values:v}=f[0],g=Array.from(new Set(v.map(w=>w.field).filter(qn))),y=mt({guide:{title:g.length===0?void 0:g},field:g[0]},d),{name:b}=f[0],x=f.flatMap(({values:w})=>w.map(O=>O.value)),_=Object.assign(Object.assign({},ZG(b,x,y,s,c,n)),{uid:Symbol("scale"),key:h});f.forEach(w=>w.scale=_)}return l})}function lO(t,e,n,r){const i=t.theme,a=typeof e=="string"?i[e]||{}:{};return r(mt(a,Object.assign({type:e},n)))}function yC(t,e,n){var r;const[i]=gr("mark",n),[a]=gr("theme",n),[o]=gr("labelTransform",n),{key:s,frame:c=!1,theme:l,clip:u,style:f={},labelTransform:d=[]}=e,h=a(xC(l)),v=Array.from(t.values()),g=VG(v,e),y=S$(O$(VZ(Array.from(g),v,t),e,n)),b=H$(y,e,h,n),x=xW(b,e,n),_=c?mt({mainLineWidth:1,mainStroke:"#000"},f):f;U$(oC(y),x,b),Y$(y);const w=new Map(Array.from(t.values()).flatMap(k=>{const{channels:A}=k;return A.map(({scale:P})=>[P.uid,q3(P,n)])}));HG(t,w);const O={};for(const k of y){const{scales:A=[]}=k,P=[];for(const C of A){const{name:N,uid:L}=C,R=(r=w.get(L))!==null&&r!==void 0?r:q3(C,n);P.push(R),N==="y"&&R.update(Object.assign(Object.assign({},R.getOptions()),{xScale:O.x})),U3(O,{[N]:R})}k.scaleInstances=P}const E=[];for(const[k,A]of t.entries()){const{children:P,dataDomain:C,modifier:N,key:L}=k,{index:R,channels:I,tooltip:D}=A,G=Object.fromEntries(I.map(({name:Lt,scale:It})=>[Lt,It])),F=fs(G,({uid:Lt})=>w.get(Lt));U3(O,F);const W=YG(I,F),X=i(k),[Q,tt,nt]=NZ(X(R,F,W,x)),ht=C||Q.length,lt=N?N(tt,ht,b):[],wt=Lt=>{var It,jt;return(jt=(It=D.title)===null||It===void 0?void 0:It[Lt])===null||jt===void 0?void 0:jt.value},yt=Lt=>D.items.map(It=>It[Lt]),gt=Q.map((Lt,It)=>{const jt=Object.assign({points:tt[It],transform:lt[It],index:Lt,markKey:L,viewKey:s},D&&{title:wt(Lt),items:yt(Lt)});for(const[Qt,ue]of Object.entries(W))jt[Qt]=ue[Lt],nt&&(jt[`series${tl(Qt)}`]=nt[It].map(ye=>ue[ye]));return nt&&(jt.seriesIndex=nt[It]),nt&&D&&(jt.seriesItems=nt[It].map(Qt=>yt(Qt)),jt.seriesTitle=nt[It].map(Qt=>wt(Qt))),jt});A.data=gt,A.index=Q;const Bt=P==null?void 0:P(gt,F,b);E.push(...Bt||[])}return[{layout:b,theme:h,coordinate:x,markState:t,key:s,clip:u,scale:O,style:_,components:y,labelTransform:q_(d.map(o))},E]}function uO(t,e,n,r){return uc(this,void 0,void 0,function*(){const{library:i}=r,{components:a,theme:o,layout:s,markState:c,coordinate:l,key:u,style:f,clip:d,scale:h}=t,{x:v,y:g,width:y,height:b}=s,x=fl(s,["x","y","width","height"]),_=["view","plot","main","content"],w=_.map((F,W)=>W),O=["a","margin","padding","inset"],E=_.map(F=>PA(Object.assign({},o.view,f),F)),M=O.map(F=>$t(x,F)),k=F=>F.style("x",W=>L[W].x).style("y",W=>L[W].y).style("width",W=>L[W].width).style("height",W=>L[W].height).each(function(W,X,Q){XZ(Oe(Q),E[W])});let A=0,P=0,C=y,N=b;const L=w.map(F=>{const W=M[F],{left:X=0,top:Q=0,bottom:tt=0,right:nt=0}=W;return A+=X,P+=Q,C-=X+nt,N-=Q+tt,{x:A,y:P,width:C,height:N}});e.selectAll(ws(bc)).data(w.filter(F=>qn(E[F])),F=>_[F]).join(F=>F.append("rect").attr("className",bc).style("zIndex",-2).call(k),F=>F.call(k),F=>F.remove());const R=FZ(c),I=R?{duration:R[1]}:!1;for(const[,F]of Qy(a,W=>`${W.type}-${W.position}`))F.forEach((W,X)=>W.index=X);const D=e.selectAll(ws(Gu)).data(a,F=>`${F.type}-${F.position}-${F.index}`).join(F=>F.append("g").style("zIndex",({zIndex:W})=>W||-1).attr("className",Gu).append(W=>aC(mt({animate:I,scale:h},W),l,o,i,c)),F=>F.transition(function(W,X,Q){const{preserve:tt=!1}=W;if(tt)return;const nt=aC(mt({animate:I,scale:h},W),l,o,i,c),{attributes:ht}=nt,[lt]=Q.childNodes;return lt.update(ht,!1)})).transitions();n.push(...D.flat().filter(qn));const G=e.selectAll(ws(ba)).data([s],()=>u).join(F=>F.append("rect").style("zIndex",0).style("fill","transparent").attr("className",ba).call(wC).call(SC,Array.from(c.keys())).call(EC,d),F=>F.call(SC,Array.from(c.keys())).call(W=>R?HZ(W,R):wC(W)).call(EC,d)).transitions();n.push(...G.flat());for(const[F,W]of c.entries()){const{data:X}=W,{key:Q,class:tt,type:nt}=F,ht=e.select(`#${Q}`),lt=WZ(F,W,t,r),wt=GZ(F,W,t,i),yt=ZZ(F,W,t,i),gt=YZ(F,W,t,i),Bt=BZ(e,ht,tt,"element"),Lt=ht.selectAll(ws(ma)).selectFacetAll(Bt).data(X,It=>It.key,It=>It.groupKey).join(It=>It.append(lt).attr("className",ma).attr("markType",nt).transition(function(jt,Qt,ue){return wt(jt,[ue])}),It=>It.call(jt=>{const Qt=jt.parent(),ue=CF(ye=>{const[Ke,be]=ye.getBounds().min;return[Ke,be]});jt.transition(function(ye,Ke,be){zZ(be,Qt,ue);const Ne=lt(ye,Ke),Pn=yt(ye,[be],[Ne]);return Pn!==null||(be.nodeName===Ne.nodeName&&Ne.nodeName!=="g"?Q_(be,Ne):(be.parentNode.replaceChild(Ne,be),Ne.className=ma,Ne.markType=nt,Ne.__data__=be.__data__)),Pn}).attr("markType",nt).attr("className",ma)}),It=>It.each(function(jt,Qt,ue){ue.__removed__=!0}).transition(function(jt,Qt,ue){return gt(jt,[ue])}).remove(),It=>It.append(lt).attr("className",ma).attr("markType",nt).transition(function(jt,Qt,ue){const{__fromElements__:ye}=ue,Ke=yt(jt,ye,[ue]);return new Xr(ye,null,ue.parentNode).transition(Ke).remove(),Ke}),It=>It.transition(function(jt,Qt,ue){const Ke=new Xr([],ue.__toData__,ue.parentNode).append(lt).attr("className",ma).attr("markType",nt).nodes();return yt(jt,[ue],Ke)}).remove()).transitions();n.push(...Lt.flat())}LZ(t,e,n,i,r)})}function LZ(t,e,n,r,i){const[a]=gr("labelTransform",r),{markState:o,labelTransform:s}=t,c=e.select(ws(zi)).node(),l=new Map,u=new Map,f=Array.from(o.entries()).flatMap(([b,x])=>{const{labels:_=[],key:w}=b,O=jZ(b,x,t,r,i),E=e.select(`#${w}`).selectAll(ws(ma)).nodes().filter(M=>!M.__removed__);return _.flatMap((M,k)=>{const{transform:A=[]}=M,P=fl(M,["transform"]);return E.flatMap(C=>{const N=RZ(P,k,C);return N.forEach(L=>{l.set(L,R=>O(Object.assign(Object.assign({},R),{element:C}))),u.set(L,M)}),N})})}),d=Oe(c).selectAll(ws(Wi)).data(f,b=>b.key).join(b=>b.append(x=>l.get(x)(x)).attr("className",Wi),b=>b.each(function(x,_,w){const E=l.get(x)(x);Q_(w,E)}),b=>b.remove()).nodes(),h=dr(d,b=>u.get(b.__data__)),{coordinate:v,layout:g}=t,y={canvas:i.canvas,coordinate:v,layout:g};for(const[b,x]of h){const{transform:_=[]}=b;q_(_.map(a))(x,y)}s&&s(d,y)}function RZ(t,e,n){const{seriesIndex:r,seriesKey:i,points:a,key:o,index:s}=n.__data__,c=DZ(n);if(!r)return[Object.assign(Object.assign({},t),{key:`${o}-${e}`,bounds:c,index:s,points:a,dependentElement:n})];const l=IZ(t),u=r.map((f,d)=>Object.assign(Object.assign({},t),{key:`${i[d]}-${e}`,bounds:[a[d]],index:f,points:a,dependentElement:n}));return l?l(u):u}function NZ([t,e,n]){if(n)return[t,e,n];const r=[],i=[];for(let a=0;a<t.length;a++){const o=t[a],s=e[a];s.every(([c,l])=>qn(c)&&qn(l))&&(r.push(o),i.push(s))}return[r,i]}function IZ(t){const{selector:e}=t;if(!e)return null;if(typeof e=="function")return e;if(e==="first")return n=>[n[0]];if(e==="last")return n=>[n[n.length-1]];throw new Error(`Unknown selector: ${e}`)}function DZ(t){const e=t.cloneNode(),n=t.getAnimations();e.style.visibility="hidden",n.forEach(o=>{const s=o.effect.getKeyframes();e.attr(s[s.length-1])}),t.parentNode.appendChild(e);const r=e.getLocalBounds();e.destroy();const{min:i,max:a}=r;return[i,a]}function jZ(t,e,n,r,i){const[a]=gr("shape",r),{data:o,encode:s}=t,{data:c,defaultLabelShape:l}=e,u=c.map(g=>g.points),f=fs(s,g=>g.value),{theme:d,coordinate:h}=n,v=Object.assign(Object.assign({},i),{document:t3(i),theme:d,coordinate:h});return g=>{const{index:y,points:b}=g,x=o[y],{formatter:_=W=>`${W}`,transform:w,style:O,render:E,selector:M,element:k}=g,A=fl(g,["formatter","transform","style","render","selector","element"]),P=fs(Object.assign(Object.assign({},A),O),W=>mC(W,x,y,o,{channel:f,element:k})),{shape:C=l,text:N}=P,L=fl(P,["shape","text"]),R=typeof _=="string"?el(_):_,I=Object.assign(Object.assign({},L),{text:R(N,x,y,o),datum:x}),D=Object.assign({type:`label.${C}`,render:E},L),G=a(D,v),F=bC(d,"label",C,"label");return G(b,I,F,u)}}function mC(t,e,n,r,i){return typeof t=="function"?t(e,n,r,i):typeof t!="string"?t:Uf(e)&&e[t]!==void 0?e[t]:t}function FZ(t){let e=-1/0,n=1/0;for(const[r,i]of t){const{animate:a={}}=r,{data:o}=i,{enter:s={},update:c={},exit:l={}}=a,{type:u,duration:f=300,delay:d=0}=c,{type:h,duration:v=300,delay:g=0}=s,{type:y,duration:b=300,delay:x=0}=l;for(const _ of o){const{updateType:w=u,updateDuration:O=f,updateDelay:E=d,enterType:M=h,enterDuration:k=v,enterDelay:A=g,exitDuration:P=b,exitDelay:C=x,exitType:N=y}=_;(w===void 0||w)&&(e=Math.max(e,O+E),n=Math.min(n,E)),(N===void 0||N)&&(e=Math.max(e,P+C),n=Math.min(n,C)),(M===void 0||M)&&(e=Math.max(e,k+A),n=Math.min(n,A))}}return e===-1/0?null:[n,e-n]}function BZ(t,e,n,r){return t.node().parentElement.findAll(a=>a.style.facet!==void 0&&a.style.facet===n&&a!==e.node()).flatMap(a=>a.getElementsByClassName(r))}function zZ(t,e,n){if(!t.__facet__)return;const r=t.parentNode.parentNode,i=e.parentNode,[a,o]=n(r),[s,c]=n(i),l=`translate(${a-s}, ${o-c})`;LF(t,l),e.append(t)}function WZ(t,e,n,r){const{library:i}=r,[a]=gr("shape",i),{data:o,encode:s}=t,{defaultShape:c,data:l,shape:u}=e,f=fs(s,x=>x.value),d=l.map(x=>x.points),{theme:h,coordinate:v}=n,{type:g,style:y={}}=t,b=Object.assign(Object.assign({},r),{document:t3(r),coordinate:v,theme:h});return x=>{const{shape:_=c}=y,{shape:w=_,points:O,seriesIndex:E,index:M}=x,k=fl(x,["shape","points","seriesIndex","index"]),A=Object.assign(Object.assign({},k),{index:M}),P=E?E.map(I=>o[I]):o[M],C=E||M,N=fs(y,I=>mC(I,P,C,o,{channel:f})),L=u[w]?u[w](N,b):a(Object.assign(Object.assign({},N),{type:OC(t,w)}),b),R=bC(h,g,w,c);return L(O,A,R,d)}}function bC(t,e,n,r){if(typeof e!="string")return;const{color:i}=t,a=t[e]||{},o=a[n]||a[r];return Object.assign({color:i},o)}function fO(t,e,n,r,i){var a,o;const[,s]=gr("shape",i),[c]=gr("animation",i),{defaultShape:l,shape:u}=n,{theme:f,coordinate:d}=r,v=`default${tl(t)}Animation`,{[v]:g}=((a=u[l])===null||a===void 0?void 0:a.props)||s(OC(e,l)).props,{[t]:y={}}=f,b=((o=e.animate)===null||o===void 0?void 0:o[t])||{},x={coordinate:d};return(_,w,O)=>{const{[`${t}Type`]:E,[`${t}Delay`]:M,[`${t}Duration`]:k,[`${t}Easing`]:A}=_,P=Object.assign({type:E||g},b);if(!P.type)return null;const L=c(P,x)(w,O,mt(y,{delay:M,duration:k,easing:A}));return Array.isArray(L)?L:[L]}}function GZ(t,e,n,r){return fO("enter",t,e,n,r)}function $Z(t){return t.finished.then(()=>{t.cancel()}),t}function ZZ(t,e,n,r){return fO("update",t,e,n,r)}function YZ(t,e,n,r){return fO("exit",t,e,n,r)}function xC(t={}){if(typeof t=="string")return{type:t};const{type:e="light"}=t,n=fl(t,["type"]);return Object.assign(Object.assign({},n),{type:e})}function Km(t){const e={event:!0,tooltip:!0,sliderFilter:!0,legendFilter:!0,scrollbarFilter:!0},{interaction:n={}}=t;return Object.entries(mt(e,n)).reverse()}function _C(t,e){return uc(this,void 0,void 0,function*(){const{data:n}=t,r=fl(t,["data"]);if(n==null)return t;const[,{data:i}]=yield dC([],{data:n},e);return Object.assign({data:i},r)})}function wC(t){t.style("transform",e=>`translate(${e.paddingLeft+e.marginLeft}, ${e.paddingTop+e.marginTop})`).style("width",e=>e.innerWidth).style("height",e=>e.innerHeight)}function HZ(t,e){const[n,r]=e;t.transition(function(i,a,o){const{transform:s,width:c,height:l}=o.style,{paddingLeft:u,paddingTop:f,innerWidth:d,innerHeight:h,marginLeft:v,marginTop:g}=i,y=[{transform:s,width:c,height:l},{transform:`translate(${u+v}, ${f+g})`,width:d,height:h}];return o.animate(y,{delay:n,duration:r,fill:"both"})})}function OC(t,e){const{type:n}=t;return typeof e=="string"?`${n}.${e}`:e}function SC(t,e){const n=a=>a.class!==void 0?`${a.class}`:"";t.nodes().length===0||(t.selectAll(ws(Xo)).data(e,a=>a.key).join(a=>a.append("g").attr("className",Xo).attr("id",o=>o.key).style("facet",n).style("fill","transparent").style("zIndex",o=>{var s;return(s=o.zIndex)!==null&&s!==void 0?s:0}),a=>a.style("facet",n).style("fill","transparent").style("zIndex",o=>{var s;return(s=o.zIndex)!==null&&s!==void 0?s:0}),a=>a.remove()),t.select(ws(zi)).node())||t.append("g").attr("className",zi).style("zIndex",0)}function ws(...t){return t.map(e=>`.${e}`).join("")}function EC(t,e){t.node()&&t.style("clipPath",n=>{if(!e)return null;const{paddingTop:r,paddingLeft:i,marginLeft:a,marginTop:o,innerWidth:s,innerHeight:c}=n;return new Qc({style:{x:i+a,y:r+o,width:s,height:c}})})}function VZ(t,e,n){var r;for(const[l]of n.entries())if(l.type==="cell")return t.filter(u=>u.name!=="shape");if(e.length!==1||t.some(l=>l.name==="shape"))return t;const{defaultShape:i}=e[0];if(!["point","line","rect","hollow"].includes(i))return t;const o={point:"point",line:"hyphen",rect:"square",hollow:"hollow"},c={field:((r=t.find(l=>l.name==="color"))===null||r===void 0?void 0:r.field)||null,name:"shape",type:"constant",domain:[],range:[o[i]]};return[...t,c]}function XZ(t,e){for(const[n,r]of Object.entries(e))t.style(n,r)}function UZ(...t){return e=>t.reduce((n,r)=>r(n),e)}function qZ(t){const{style:e,scale:n,type:r}=t,i={},a=vn(e,"columnWidthRatio");return a&&r==="interval"&&(i.x=Object.assign(Object.assign({},n==null?void 0:n.x),{padding:1-a})),Object.assign(Object.assign({},t),{scale:Object.assign(Object.assign({},n),i)})}function MC(t){const e=KZ(t);return e.children&&Array.isArray(e.children)&&(e.children=e.children.map(n=>MC(n))),e}function KZ(t){return UZ(qZ)(t)}function kC(t){const e=mt({},t),n=new Map([[e,null]]),r=new Map([[null,-1]]),i=[e];for(;i.length;){const a=i.shift();if(a.key===void 0){const s=n.get(a),c=r.get(a),l=s===null?"0":`${s.key}-${c}`;a.key=l}const{children:o=[]}=a;if(Array.isArray(o))for(let s=0;s<o.length;s++){const c=mt({},o[s]);o[s]=c,n.set(c,a),r.set(c,s),i.push(c)}}return e}function QZ(t,e){const n=new mA;return n.registerPlugin(new xA),new wk({width:t,height:e,container:document.createElement("div"),renderer:n})}function JZ(t,e={},n=()=>{},r=i=>{throw i}){const{width:i=640,height:a=480,depth:o=0}=t,s=MC(t),c=kC(s),{canvas:l=QZ(i,a),emitter:u=new Ts,library:f}=e;e.canvas=l,e.emitter=u;const{width:d,height:h}=l.getConfig();(d!==i||h!==a)&&l.resize(i,a),u.emit(In.BEFORE_RENDER);const v=Oe(l.document.documentElement);return l.ready.then(()=>cO(Object.assign(Object.assign({},c),{width:i,height:a,depth:o}),v,e)).then(()=>{if(o){const[g,y]=l.document.documentElement.getPosition();l.document.documentElement.setPosition(g,y,-o/2)}l.requestAnimationFrame(()=>{l.requestAnimationFrame(()=>{u.emit(In.AFTER_RENDER),n==null||n()})})}).catch(g=>{r==null||r(g)}),eY(l.getConfig().container)}function Sot(t,e={},n=()=>{},r=i=>{throw i}){var i;const{width:a=640,height:o=480}=t,s=kC(t),{group:c=new Group,emitter:l=new EventEmitter,library:u}=e;c!=null&&c.parentElement||error("renderToMountedElement can't render chart to unmounted group.");const f=select(c);return e.group=c,e.emitter=l,e.canvas=e.canvas||((i=c==null?void 0:c.ownerDocument)===null||i===void 0?void 0:i.defaultView),l.emit(ChartEvent.BEFORE_RENDER),plot(Object.assign(Object.assign({},s),{width:a,height:o}),f,e).then(()=>{var d;(d=e.canvas)===null||d===void 0||d.requestAnimationFrame(()=>{l.emit(ChartEvent.AFTER_RENDER),n==null||n()})}).catch(d=>{r==null||r(d)}),c}function AC(t,e={},n=!1){const{canvas:r,emitter:i}=e;r&&(tY(r),n?r.destroy():r.destroyChildren()),i.off()}function tY(t){const e=t.getRoot().querySelectorAll(`.${_i}`);e==null||e.forEach(n=>{const{nameInteraction:r=new Map}=n;(r==null?void 0:r.size)>0&&Array.from(r==null?void 0:r.values()).forEach(i=>{i==null||i.destroy()})})}function eY(t){return typeof t=="string"?document.getElementById(t):t}const gd=t=>t?parseInt(t):0;function nY(t){const e=getComputedStyle(t),n=t.clientWidth||gd(e.width),r=t.clientHeight||gd(e.height),i=gd(e.paddingLeft)+gd(e.paddingRight),a=gd(e.paddingTop)+gd(e.paddingBottom);return{width:n-i,height:r-a}}function Eot(t){const{height:e,width:n,padding:r=0,paddingLeft:i=r,paddingRight:a=r,paddingTop:o=r,paddingBottom:s=r,margin:c=0,marginLeft:l=c,marginRight:u=c,marginTop:f=c,marginBottom:d=c,inset:h=0,insetLeft:v=h,insetRight:g=h,insetTop:y=h,insetBottom:b=h}=t,x=O=>O==="auto"?20:O,_=n-x(i)-x(a)-l-u-v-g,w=e-x(o)-x(s)-f-d-y-b;return{width:_,height:w}}function dO(t,e){const n=[t];for(;n.length;){const r=n.shift();e&&e(r);const i=r.children||[];for(const a of i)n.push(a)}}class hO{constructor(e={},n){this.parentNode=null,this.children=[],this.index=0,this.type=n,this.value=e}map(e=n=>n){const n=e(this.value);return this.value=n,this}attr(e,n){return arguments.length===1?this.value[e]:this.map(r=>(r[e]=n,r))}append(e){const n=new e({});return n.children=[],this.push(n),n}push(e){return e.parentNode=this,e.index=this.children.length,this.children.push(e),this}remove(){const e=this.parentNode;if(e){const{children:n}=e,r=n.findIndex(i=>i===this);n.splice(r,1)}return this}getNodeByKey(e){let n=null;return dO(this,i=>{e===i.attr("key")&&(n=i)}),n}getNodesByType(e){const n=[];return dO(this,i=>{e===i.type&&n.push(i)}),n}getNodeByType(e){let n=null;return dO(this,r=>{n||e===r.type&&(n=r)}),n}call(e,...n){return e(this.map(),...n),this}getRoot(){let e=this;for(;e&&e.parentNode;)e=e.parentNode;return e}}var TC=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const pO=["width","height","depth","padding","paddingLeft","paddingRight","paddingBottom","paddingTop","inset","insetLeft","insetRight","insetTop","insetBottom","margin","marginLeft","marginRight","marginTop","marginBottom","autoFit","theme","title","interaction"],PC="__remove__",CC="__callback__",LC=1,RC=1;function rY(t){if(t===void 0){const e=document.createElement("div");return e[PC]=!0,e}return typeof t=="string"?document.getElementById(t):t}function iY(t){const e=t.parentNode;e&&e.removeChild(t)}function aY(t){if(t.type!==null)return t;const e=t.children[t.children.length-1];for(const n of pO)e.attr(n,t.attr(n));return e}function NC(t){return Object.assign(Object.assign({},t.value),{type:t.type})}function vO(t,e){const{width:n,height:r,autoFit:i,depth:a=0}=t;let o=640,s=480;if(i){const{width:c,height:l}=nY(e);o=c||o,s=l||s}return o=n||o,s=r||s,{width:Math.max(Vn(o)?o:LC,LC),height:Math.max(Vn(s)?s:RC,RC),depth:a}}function oY(t){const e=aY(t),n=[e],r=new Map;for(r.set(e,NC(e));n.length;){const i=n.pop(),a=r.get(i),{children:o=[]}=i;for(const s of o)if(s.type===CC)a.children=s.value;else{const c=NC(s),{children:l=[]}=a;l.push(c),n.push(s),r.set(s,c),a.children=l}}return r.get(e)}function sY(t,e){return typeof t=="function"?!0:new Set(Object.keys(e)).has(t)}function cY(t,e){return typeof t!="function"&&new Set(Object.keys(e)).has(t)}function lY(t,e,n,r,i){const{type:a}=t,{type:o=n||a}=e;if(cY(o,i)){for(const s of pO)t.attr(s)!==void 0&&e[s]===void 0&&(e[s]=t.attr(s));return e}if(sY(o,r)){const s={type:"view"},c=Object.assign({},e);for(const l of pO)c[l]!==void 0&&(s[l]=c[l],delete c[l]);return Object.assign(Object.assign({},s),{children:[c]})}return e}function uY(t,e,n){if(typeof t=="function")return e.mark;const i=Object.assign(Object.assign({},e),n)[t];if(!i)throw new Error(`Unknown mark: ${t}.`);return i}function fY(t,e,n){if(typeof t=="function"){const c=new hO;return c.value=t,c.type=CC,c}const{type:r,children:i}=t,a=TC(t,["type","children"]),o=uY(r,e,n),s=new o;return s.value=a,s.type=r,s}function dY(t,e){const{type:n,children:r}=e,i=TC(e,["type","children"]);t.type===n||n===void 0?LA(t.value,i):typeof n=="string"&&(t.type=n,t.value=i)}function hY(t,e,n,r){if(!t)return;const i=[[t,e]];for(;i.length;){const[a,o]=i.shift(),s=fY(o,n,r);Array.isArray(a.children)&&a.push(s);const{children:c}=o;if(Array.isArray(c))for(const l of c)i.push([s,l]);else typeof c=="function"&&i.push([s,c])}}function pY(t,e,n,r,i){const a=lY(t,e,n,r,i),o=[[null,t,a]];for(;o.length;){const[s,c,l]=o.shift();if(!c)hY(s,l,r,i);else if(!l)c.remove();else{dY(c,l);const{children:u}=l,{children:f}=c;if(Array.isArray(u)&&Array.isArray(f)){const d=Math.max(u.length,f.length);for(let h=0;h<d;h++){const v=u[h],g=f[h];o.push([c,g,v])}}else typeof u=="function"&&o.push([c,null,u])}}}function vY(){let t,e;return[new Promise((r,i)=>{e=r,t=i}),e,t]}function gY(t,e,{key:n=e}){t.prototype[e]=function(r){return arguments.length===0?this.attr(n):this.attr(n,r)}}function yY(t,e,{key:n=e}){t.prototype[e]=function(r){if(arguments.length===0)return this.attr(n);if(Array.isArray(r))return this.attr(n,r);const i=[...this.attr(n)||[],r];return this.attr(n,i)}}function mY(t,e,{key:n=e}){t.prototype[e]=function(r,i){if(arguments.length===0)return this.attr(n);if(arguments.length===1&&typeof r!="string")return this.attr(n,r);const a=this.attr(n)||{};return a[r]=arguments.length===1?!0:i,this.attr(n,a)}}function bY(t,e,n){t.prototype[e]=function(r){if(arguments.length===0)return this.attr(e);if(Array.isArray(r))return this.attr(e,{items:r});if(Uf(r)&&(r.title!==void 0||r.items!==void 0))return this.attr(e,r);if(r===null||r===!1)return this.attr(e,r);const i=this.attr(e)||{},{items:a=[]}=i;return a.push(r),i.items=a,this.attr(e,i)}}function xY(t,e,{ctor:n}){t.prototype[e]=function(r){const i=this.append(n);return e==="mark"&&(i.type=r),i}}function _Y(t,e,{ctor:n}){t.prototype[e]=function(){return this.type=null,this.append(n)}}function Qm(t){return e=>{for(const[n,r]of Object.entries(t)){const{type:i}=r;i==="value"?gY(e,n,r):i==="array"?yY(e,n,r):i==="object"?mY(e,n,r):i==="node"?xY(e,n,r):i==="container"?_Y(e,n,r):i==="mix"&&bY(e,n,r)}return e}}function IC(t){return Object.fromEntries(Object.entries(t).map(([e,n])=>[e,{type:"node",ctor:n}]))}const DC={encode:{type:"object"},scale:{type:"object"},data:{type:"value"},transform:{type:"array"},style:{type:"object"},animate:{type:"object"},coordinate:{type:"object"},interaction:{type:"object"},label:{type:"array",key:"labels"},axis:{type:"object"},legend:{type:"object"},slider:{type:"object"},scrollbar:{type:"object"},state:{type:"object"},layout:{type:"object"},theme:{type:"object"},title:{type:"value"}},wY=Object.assign(Object.assign({},DC),{tooltip:{type:"mix"},viewStyle:{type:"object"}}),OY=Object.assign(Object.assign({},DC),{labelTransform:{type:"array"}});var SY=function(t,e,n,r){var i=arguments.length,a=i<3?e:r===null?r=Object.getOwnPropertyDescriptor(e,n):r,o;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")a=Reflect.decorate(t,e,n,r);else for(var s=t.length-1;s>=0;s--)(o=t[s])&&(a=(i<3?o(a):i>3?o(e,n,a):o(e,n))||a);return i>3&&a&&Object.defineProperty(e,n,a),a};let Jm=class extends hO{changeData(e){var n;const r=this.getRoot();if(r)return this.attr("data",e),!((n=this.children)===null||n===void 0)&&n.length&&this.children.forEach(i=>{i.attr("data",e)}),r==null?void 0:r.render()}getView(){const e=this.getRoot(),{views:n}=e.getContext();if(n!=null&&n.length)return n.find(r=>r.key===this._key)}getScale(){var e;return(e=this.getView())===null||e===void 0?void 0:e.scale}getScaleByChannel(e){const n=this.getScale();if(n)return n[e]}getCoordinate(){var e;return(e=this.getView())===null||e===void 0?void 0:e.coordinate}getTheme(){var e;return(e=this.getView())===null||e===void 0?void 0:e.theme}getGroup(){const e=this._key;return e?this.getRoot().getContext().canvas.getRoot().getElementById(e):void 0}show(){const e=this.getGroup();e&&!e.isVisible()&&Nm(e)}hide(){const e=this.getGroup();e&&e.isVisible()&&Hw(e)}};Jm=SY([Qm(OY)],Jm);var EY=function(t,e,n,r){var i=arguments.length,a=i<3?e:r===null?r=Object.getOwnPropertyDescriptor(e,n):r,o;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")a=Reflect.decorate(t,e,n,r);else for(var s=t.length-1;s>=0;s--)(o=t[s])&&(a=(i<3?o(a):i>3?o(e,n,a):o(e,n))||a);return i>3&&a&&Object.defineProperty(e,n,a),a};let gO=class extends hO{changeData(e){const n=this.getRoot();if(n)return this.attr("data",e),n==null?void 0:n.render()}getMark(){var e;const n=(e=this.getRoot())===null||e===void 0?void 0:e.getView();if(!n)return;const{markState:r}=n,i=Array.from(r.keys()).find(a=>a.key===this.attr("key"));return r.get(i)}getScale(){var e;const n=(e=this.getRoot())===null||e===void 0?void 0:e.getView();if(n)return n==null?void 0:n.scale}getScaleByChannel(e){var n,r;const i=(n=this.getRoot())===null||n===void 0?void 0:n.getView();if(i)return(r=i==null?void 0:i.scale)===null||r===void 0?void 0:r[e]}getGroup(){const e=this.attr("key");return e?this.getRoot().getContext().canvas.getRoot().getElementById(e):void 0}};gO=EY([Qm(wY)],gO);var MY=function(t,e,n,r){var i=arguments.length,a=i<3?e:r===null?r=Object.getOwnPropertyDescriptor(e,n):r,o;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")a=Reflect.decorate(t,e,n,r);else for(var s=t.length-1;s>=0;s--)(o=t[s])&&(a=(i<3?o(a):i>3?o(e,n,a):o(e,n))||a);return i>3&&a&&Object.defineProperty(e,n,a),a},kY=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const AY="G2_CHART_KEY";class TY extends Jm{constructor(e){const{container:n,canvas:r,renderer:i,plugins:a,lib:o,createCanvas:s}=e,c=kY(e,["container","canvas","renderer","plugins","lib","createCanvas"]);super(c,"view"),this._hasBindAutoFit=!1,this._rendering=!1,this._trailing=!1,this._trailingResolve=null,this._trailingReject=null,this._previousDefinedType=null,this._onResize=_A(()=>{this.forceFit()},300),this._renderer=i||new mA,this._plugins=a||[],this._container=rY(n),this._emitter=new Ts,this._context={library:Object.assign(Object.assign({},o),aA),emitter:this._emitter,canvas:r,createCanvas:s},this._create()}render(){if(this._rendering)return this._addToTrailing();this._context.canvas||this._createCanvas(),this._bindAutoFit(),this._rendering=!0;const e=new Promise((a,o)=>JZ(this._computedOptions(),this._context,this._createResolve(a),this._createReject(o))),[n,r,i]=vY();return e.then(r).catch(i).then(()=>this._renderTrailing()),n}options(e){if(arguments.length===0)return oY(this);const{type:n}=e;return n&&(this._previousDefinedType=n),pY(this,e,this._previousDefinedType,this._marks,this._compositions),this}getContainer(){return this._container}getContext(){return this._context}on(e,n,r){return this._emitter.on(e,n,r),this}once(e,n){return this._emitter.once(e,n),this}emit(e,...n){return this._emitter.emit(e,...n),this}off(e,n){return this._emitter.off(e,n),this}clear(){const e=this.options();this.emit(In.BEFORE_CLEAR),this._reset(),AC(e,this._context,!1),this.emit(In.AFTER_CLEAR)}destroy(){const e=this.options();this.emit(In.BEFORE_DESTROY),this._unbindAutoFit(),this._reset(),AC(e,this._context,!0),this._container[PC]&&iY(this._container),this.emit(In.AFTER_DESTROY)}forceFit(){this.options.autoFit=!0;const{width:e,height:n}=vO(this.options(),this._container);if(e===this._width&&n===this._height)return Promise.resolve(this);this.emit(In.BEFORE_CHANGE_SIZE);const r=this.render();return r.then(()=>{this.emit(In.AFTER_CHANGE_SIZE)}),r}changeSize(e,n){if(e===this._width&&n===this._height)return Promise.resolve(this);this.emit(In.BEFORE_CHANGE_SIZE),this.attr("width",e),this.attr("height",n);const r=this.render();return r.then(()=>{this.emit(In.AFTER_CHANGE_SIZE)}),r}_create(){const{library:e}=this._context,n=a=>a.startsWith("mark.")||a==="component.axisX"||a==="component.axisY"||a==="component.legends",r=["mark.mark",...Object.keys(e).filter(n)];this._marks={};for(const a of r){const o=a.split(".").pop();class s extends gO{constructor(){super({},o)}}this._marks[o]=s,this[o]=function(c){const l=this.append(s);return o==="mark"&&(l.type=c),l}}const i=["composition.view",...Object.keys(e).filter(a=>a.startsWith("composition.")&&a!=="composition.mark")];this._compositions=Object.fromEntries(i.map(a=>{const o=a.split(".").pop();let s=class extends Jm{constructor(){super({},o)}};return s=MY([Qm(IC(this._marks))],s),[o,s]}));for(const a of Object.values(this._compositions))Qm(IC(this._compositions))(a);for(const a of i){const o=a.split(".").pop();this[o]=function(){const s=this._compositions[o];return this.type=null,this.append(s)}}}_reset(){const e=["theme","type","width","height","autoFit"];this.type="view",this.value=Object.fromEntries(Object.entries(this.value).filter(([n])=>n.startsWith("margin")||n.startsWith("padding")||n.startsWith("inset")||e.includes(n))),this.children=[]}_renderTrailing(){this._trailing&&(this._trailing=!1,this.render().then(()=>{const e=this._trailingResolve.bind(this);this._trailingResolve=null,e(this)}).catch(e=>{const n=this._trailingReject.bind(this);this._trailingReject=null,n(e)}))}_createResolve(e){return()=>{this._rendering=!1,e(this)}}_createReject(e){return n=>{this._rendering=!1,e(n)}}_computedOptions(){const e=this.options(),{key:n=AY}=e,{width:r,height:i,depth:a}=vO(e,this._container);return this._width=r,this._height=i,this._key=n,Object.assign(Object.assign({key:this._key},e),{width:r,height:i,depth:a})}_createCanvas(){const{width:e,height:n}=vO(this.options(),this._container);this._plugins.push(new xA),this._plugins.forEach(r=>this._renderer.registerPlugin(r)),this._context.canvas=new wk({container:this._container,width:e,height:n,renderer:this._renderer})}_addToTrailing(){var e;return(e=this._trailingResolve)===null||e===void 0||e.call(this,this),this._trailing=!0,new Promise((r,i)=>{this._trailingResolve=r,this._trailingReject=i})}_bindAutoFit(){const e=this.options(),{autoFit:n}=e;if(this._hasBindAutoFit){n||this._unbindAutoFit();return}n&&(this._hasBindAutoFit=!0,window.addEventListener("resize",this._onResize))}_unbindAutoFit(){this._hasBindAutoFit&&(this._hasBindAutoFit=!1,window.removeEventListener("resize",this._onResize))}}function PY(t,e){class n extends t{constructor(i){super(Object.assign(Object.assign({},i),{lib:e}))}}return n}var CY=Object.prototype.hasOwnProperty,yO=function(t,e){if(t===null||!nc(t))return{};var n={};return Mw(e,function(r){CY.call(t,r)&&(n[r]=t[r])}),n};function jC(t){t.x0=Math.round(t.x0),t.y0=Math.round(t.y0),t.x1=Math.round(t.x1),t.y1=Math.round(t.y1)}function e0(t,e,n,r,i){for(var a=t.children,o,s=-1,c=a.length,l=t.value&&(r-e)/t.value;++s<c;)o=a[s],o.y0=n,o.y1=i,o.x0=e,o.x1=e+=o.value*l}function LY(){var t=1,e=1,n=0,r=!1;function i(o){var s=o.height+1;return o.x0=o.y0=n,o.x1=t,o.y1=e/s,o.eachBefore(a(e,s)),r&&o.eachBefore(jC),o}function a(o,s){return function(c){c.children&&e0(c,c.x0,o*(c.depth+1)/s,c.x1,o*(c.depth+2)/s);var l=c.x0,u=c.y0,f=c.x1-n,d=c.y1-n;f<l&&(l=f=(l+f)/2),d<u&&(u=d=(u+d)/2),c.x0=l,c.y0=u,c.x1=f,c.y1=d}}return i.round=function(o){return arguments.length?(r=!!o,i):r},i.size=function(o){return arguments.length?(t=+o[0],e=+o[1],i):[t,e]},i.padding=function(o){return arguments.length?(n=+o,i):n},i}var RY=pt(9783);function NY(t){var e=0,n=t.children,r=n&&n.length;if(!r)e=1;else for(;--r>=0;)e+=n[r].value;t.value=e}function IY(){return this.eachAfter(NY)}var mO=pt(64599);function DY(t,e){var n=-1,r=mO(this),i;try{for(r.s();!(i=r.n()).done;){var a=i.value;t.call(e,a,++n,this)}}catch(o){r.e(o)}finally{r.f()}return this}function jY(t,e){for(var n=this,r=[n],i,a,o=-1;n=r.pop();)if(t.call(e,n,++o,this),i=n.children)for(a=i.length-1;a>=0;--a)r.push(i[a]);return this}function FY(t,e){for(var n=this,r=[n],i=[],a,o,s,c=-1;n=r.pop();)if(i.push(n),a=n.children)for(o=0,s=a.length;o<s;++o)r.push(a[o]);for(;n=i.pop();)t.call(e,n,++c,this);return this}function BY(t,e){var n=-1,r=mO(this),i;try{for(r.s();!(i=r.n()).done;){var a=i.value;if(t.call(e,a,++n,this))return a}}catch(o){r.e(o)}finally{r.f()}}function zY(t){return this.eachAfter(function(e){for(var n=+t(e.data)||0,r=e.children,i=r&&r.length;--i>=0;)n+=r[i].value;e.value=n})}function WY(t){return this.eachBefore(function(e){e.children&&e.children.sort(t)})}function GY(t){for(var e=this,n=$Y(e,t),r=[e];e!==n;)e=e.parent,r.push(e);for(var i=r.length;t!==n;)r.splice(i,0,t),t=t.parent;return r}function $Y(t,e){if(t===e)return t;var n=t.ancestors(),r=e.ancestors(),i=null;for(t=n.pop(),e=r.pop();t===e;)i=t,t=n.pop(),e=r.pop();return i}function ZY(){for(var t=this,e=[t];t=t.parent;)e.push(t);return e}function YY(){return Array.from(this)}function HY(){var t=[];return this.eachBefore(function(e){e.children||t.push(e)}),t}function VY(){var t=this,e=[];return t.each(function(n){n!==t&&e.push({source:n.parent,target:n})}),e}var FC=pt(15009),XY=FC().mark(BC);function BC(){var t,e,n,r,i,a;return FC().wrap(function(s){for(;;)switch(s.prev=s.next){case 0:t=this,n=[t];case 1:e=n.reverse(),n=[];case 2:if(!(t=e.pop())){s.next=8;break}return s.next=5,t;case 5:if(r=t.children)for(i=0,a=r.length;i<a;++i)n.push(r[i]);s.next=2;break;case 8:if(n.length){s.next=1;break}case 9:case"end":return s.stop()}},XY,this)}function yd(t,e){t instanceof Map?(t=[void 0,t],e===void 0&&(e=KY)):e===void 0&&(e=qY);for(var n=new md(t),r,i=[n],a,o,s,c;r=i.pop();)if((o=e(r.data))&&(c=(o=Array.from(o)).length))for(r.children=o,s=c-1;s>=0;--s)i.push(a=o[s]=new md(o[s])),a.parent=r,a.depth=r.depth+1;return n.eachBefore(zC)}function UY(){return yd(this).eachBefore(QY)}function qY(t){return t.children}function KY(t){return Array.isArray(t)?t[1]:null}function QY(t){t.data.value!==void 0&&(t.value=t.data.value),t.data=t.data.data}function zC(t){var e=0;do t.height=e;while((t=t.parent)&&t.height<++e)}function md(t){this.data=t,this.depth=this.height=0,this.parent=null}md.prototype=yd.prototype=RY({constructor:md,count:IY,each:DY,eachAfter:FY,eachBefore:jY,find:BY,sum:zY,sort:WY,path:GY,ancestors:ZY,descendants:YY,leaves:HY,links:VY,copy:UY},Symbol.iterator,BC);function bO(t,e){for(var n in e)e.hasOwnProperty(n)&&n!=="constructor"&&e[n]!==void 0&&(t[n]=e[n])}function JY(t,e,n,r){return e&&bO(t,e),n&&bO(t,n),r&&bO(t,r),t}const tH={field:"value",size:[1,1],round:!1,padding:0,sort:(t,e)=>e.value-t.value,as:["x","y"],ignoreParentValue:!0},eH="nodeIndex",n0="childNodeCount",nH="nodeAncestor",xO="Invalid field: it must be a string!";function rH(t,e){const{field:n,fields:r}=t;if(ir(n))return n;if(Nr(n))return console.warn(xO),n[0];if(console.warn(`${xO} will try to get fields instead.`),ir(r))return r;if(Nr(r)&&r.length)return r[0];if(e)return e;throw new TypeError(xO)}function iH(t){const e=[];if(t&&t.each){let n,r;t.each(i=>{var a,o;i.parent!==n?(n=i.parent,r=0):r+=1;const s=zP((((a=i.ancestors)===null||a===void 0?void 0:a.call(i))||[]).map(c=>e.find(l=>l.name===c.name)||c),({depth:c})=>c>0&&c<i.depth);i[nH]=s,i[n0]=((o=i.children)===null||o===void 0?void 0:o.length)||0,i[eH]=r,e.push(i)})}else t&&t.eachNode&&t.eachNode(n=>{e.push(n)});return e}function aH(t,e){e=JY({},tH,e);const n=e.as;if(!Nr(n)||n.length!==2)throw new TypeError('Invalid as: it must be an array with 2 strings (e.g. [ "x", "y" ])!');let r;try{r=rH(e)}catch(c){console.warn(c)}const a=(c=>LY().size(e.size).round(e.round).padding(e.padding)(yd(c).sum(l=>jp(l.children)?e.ignoreParentValue?0:l[r]-BT(l.children,(u,f)=>u+f[r],0):l[r]).sort(e.sort)))(t),o=n[0],s=n[1];return a.each(c=>{var l,u;c[o]=[c.x0,c.x1,c.x1,c.x0],c[s]=[c.y1,c.y1,c.y0,c.y0],c.name=c.name||((l=c.data)===null||l===void 0?void 0:l.name)||((u=c.data)===null||u===void 0?void 0:u.label),c.data.name=c.name,["x0","x1","y0","y1"].forEach(f=>{n.indexOf(f)===-1&&delete c[f]})}),iH(a)}var oH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const bd="sunburst",_O="markType",Mot="value",WC="path",t1="ancestor-node";function sH(t){const{data:e,encode:n}=t,{color:r,value:i}=n,o=aH(e,{field:i,type:"hierarchy.partition",as:["x","y"]}),s=[];return o.forEach(c=>{var l,u,f,d;if(c.depth===0)return null;let h=c.data.name;const v=[h];let g=Object.assign({},c);for(;g.depth>1;)h=`${(l=g.parent.data)===null||l===void 0?void 0:l.name} / ${h}`,v.unshift((u=g.parent.data)===null||u===void 0?void 0:u.name),g=g.parent;const y=Object.assign(Object.assign(Object.assign({},yO(c.data,[i])),{[WC]:h,[t1]:g.data.name}),c);r&&r!==t1&&(y[r]=c.data[r]||((d=(f=c.parent)===null||f===void 0?void 0:f.data)===null||d===void 0?void 0:d[r])),s.push(y)}),s.map(c=>{const l=c.x.slice(0,2),u=[c.y[2],c.y[0]];return l[0]===l[1]&&(u[0]=u[1]=(c.y[2]+c.y[0])/2),Object.assign(Object.assign({},c),{x:l,y:u,fillOpacity:Math.pow(.85,c.depth)})})}const GC={id:bd,encode:{x:"x",y:"y",key:WC,color:t1,value:"value"},axis:{x:!1,y:!1},style:{[_O]:bd,stroke:"#fff",lineWidth:.5,fillOpacity:"fillOpacity",[n0]:n0,depth:"depth"},state:{active:{zIndex:2,stroke:"#000"},inactive:{zIndex:1,stroke:"#fff"}},legend:!1,interaction:{drillDown:!0},coordinate:{type:"polar",innerRadius:.2}},$C=t=>{const{encode:e,data:n=[],legend:r}=t,i=oH(t,["encode","data","legend"]),a=Object.assign(Object.assign({},i.coordinate),{innerRadius:Math.max(vn(i,["coordinate","innerRadius"],.2),1e-5)}),o=Object.assign(Object.assign({},GC.encode),e),{value:s}=o,c=sH({encode:o,data:n});return console.log(c,"rectData"),[mt({},GC,Object.assign(Object.assign({type:"rect",data:c,encode:o,tooltip:{title:"path",items:[l=>({name:s,value:l[s]})]}},i),{coordinate:a}))]};$C.props={};var cH=Object.keys?function(t){return Object.keys(t)}:function(t){var e=[];return Mw(t,function(n,r){Xn(t)&&r==="prototype"||e.push(r)}),e},wO=cH,lH=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})};const uH=t=>t.querySelectorAll(".element").filter(e=>vn(e,["style",_O])===bd);function fH(t){return Oe(t).select(`.${ba}`).node()}const dH={rootText:"root",style:{fill:"rgba(0, 0, 0, 0.85)",fontSize:12,y:1},active:{fill:"rgba(0, 0, 0, 0.5)"}};function hH(t={}){const{breadCrumb:e={},isFixedColor:n=!1}=t,r=mt({},dH,e);return i=>{const{update:a,setState:o,container:s,view:c,options:l}=i,u=s.ownerDocument,f=fH(s),d=l.marks.find(({id:_})=>_===bd),{state:h}=d,v=u.createElement("g");f.appendChild(v);const g=(_,w)=>lH(this,void 0,void 0,function*(){if(v.removeChildren(),_){const O=u.createElement("text",{style:Object.assign({x:0,text:r.rootText,depth:0},r.style)});v.appendChild(O);let E="";const M=_==null?void 0:_.split(" / ");let k=r.style.y,A=v.getBBox().width;const P=f.getBBox().width,C=M.map((N,L)=>{const R=u.createElement("text",{style:Object.assign(Object.assign({x:A,text:" / "},r.style),{y:k})});v.appendChild(R),A+=R.getBBox().width,E=`${E}${N} / `;const I=u.createElement("text",{name:E.replace(/\s\/\s$/,""),style:Object.assign(Object.assign({text:N,x:A,depth:L+1},r.style),{y:k})});return v.appendChild(I),A+=I.getBBox().width,A>P&&(k=v.getBBox().height,A=0,R.attr({x:A,y:k}),A+=R.getBBox().width,I.attr({x:A,y:k}),A+=I.getBBox().width),I});[O,...C].forEach((N,L)=>{if(L===C.length)return;const R=Object.assign({},N.attributes);N.attr("cursor","pointer"),N.addEventListener("mouseenter",()=>{N.attr(r.active)}),N.addEventListener("mouseleave",()=>{N.attr(R)}),N.addEventListener("click",()=>{g(N.name,vn(N,["style","depth"]))})})}o("drillDown",O=>{const{marks:E}=O,M=E.map(k=>{if(k.id!==bd&&k.type!=="rect")return k;const{data:A}=k,P=Object.fromEntries(["color"].map(N=>[N,{domain:c.scale[N].getOptions().domain}])),C=A.filter(N=>{const L=N.path;return n||(N[t1]=L.split(" / ")[w]),_?new RegExp(`^${_}.+`).test(L):!0});return mt({},k,n?{data:C,scale:P}:{data:C})});return Object.assign(Object.assign({},O),{marks:M})}),yield a()}),y=_=>{const w=_.target;if(vn(w,["style",_O])!==bd||vn(w,["markType"])!=="rect"||!vn(w,["style",n0]))return;const O=vn(w,["__data__","key"]),E=vn(w,["style","depth"]);w.style.cursor="pointer",g(O,E)};f.addEventListener("click",y);const b=wO(Object.assign(Object.assign({},h.active),h.inactive)),x=()=>{uH(f).forEach(w=>{const O=vn(w,["style",n0]);if(vn(w,["style","cursor"])!=="pointer"&&O){w.style.cursor="pointer";const M=yO(w.attributes,b);w.addEventListener("mouseenter",()=>{w.attr(h.active)}),w.addEventListener("mouseleave",()=>{w.attr(mt(M,h.inactive))})}})};return f.addEventListener("mousemove",x),()=>{v.remove(),f.removeEventListener("click",y),f.removeEventListener("mousemove",x)}}}function pH(){return{"interaction.drillDown":hH,"mark.sunburst":$C}}const ZC=()=>[["cartesian"]];ZC.props={};const OO=()=>[["transpose"],["translate",.5,.5],["reflect.x"],["translate",-.5,-.5]];OO.props={transform:!0};const vH=(t={})=>{const e={startAngle:-Math.PI/2,endAngle:Math.PI*3/2,innerRadius:0,outerRadius:1};return Object.assign(Object.assign({},e),t)},YC=t=>{const{startAngle:e,endAngle:n,innerRadius:r,outerRadius:i}=vH(t);return[...OO(),...Op({startAngle:e,endAngle:n,innerRadius:r,outerRadius:i})]};YC.props={};const SO=()=>[["parallel",0,1,0,1]];SO.props={};const HC=({focusX:t=0,focusY:e=0,distortionX:n=2,distortionY:r=2,visual:i=!1})=>[["fisheye",t,e,n,r,i]];HC.props={transform:!0};const VC=t=>{const{startAngle:e=-Math.PI/2,endAngle:n=Math.PI*3/2,innerRadius:r=0,outerRadius:i=1}=t;return[...SO(),...Op({startAngle:e,endAngle:n,innerRadius:r,outerRadius:i})]};VC.props={};const XC=({startAngle:t=0,endAngle:e=Math.PI*6,innerRadius:n=0,outerRadius:r=1})=>[["translate",.5,.5],["reflect.y"],["translate",-.5,-.5],["helix",t,e,n,r]];XC.props={};const UC=({value:t})=>e=>e.map(()=>t);UC.props={};const qC=({value:t})=>e=>e.map(n=>n[t]);qC.props={};const KC=({value:t})=>e=>e.map(t);KC.props={};const QC=({value:t})=>()=>t;QC.props={};function Zn(t,e){if(t!==null)return{type:"column",value:t,field:e}}function r0(t,e){const n=Zn(t,e);return Object.assign(Object.assign({},n),{inferred:!0})}function e1(t,e){if(t!==null)return{type:"column",value:t,field:e,visual:!0}}function gH(t,e){const n=Zn(t,e);return Object.assign(Object.assign({},n),{constant:!1})}function dl(t,e){const n=[];for(const r of t)n[r]=e;return n}function hn(t,e){const n=t[e];if(!n)return[null,null];const{value:r,field:i=null}=n;return[r,i]}function i0(t,...e){for(const n of e)if(typeof n=="string"){const[r,i]=hn(t,n);if(r!==null)return[r,i]}else return[n,null];return[null,null]}function a0(t){return t instanceof Date?!1:typeof t=="object"}const o0=()=>(t,e)=>{const{encode:n}=e,{y1:r}=n;return r!==void 0?[t,e]:[t,mt({},e,{encode:{y1:r0(dl(t,0))}})]};o0.props={};const Au=()=>(t,e)=>{const{encode:n}=e,{x:r}=n;return r!==void 0?[t,e]:[t,mt({},e,{encode:{x:r0(dl(t,0))},scale:{x:{guide:null}}})]};Au.props={};const Tu=(t,e)=>Hp(Object.assign({colorAttribute:"fill"},t),e);Tu.props=Object.assign(Object.assign({},Hp.props),{defaultMarker:"square"});const n1=(t,e)=>Hp(Object.assign({colorAttribute:"stroke"},t),e);n1.props=Object.assign(Object.assign({},Hp.props),{defaultMarker:"hollowSquare"});function xd(){}function JC(t){this._context=t}JC.prototype={areaStart:xd,areaEnd:xd,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(t,e){t=+t,e=+e,this._point?this._context.lineTo(t,e):(this._point=1,this._context.moveTo(t,e))}};function EO(t){return new JC(t)}var t5=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function yH(t,e,n){const[r,i,a,o]=t;if(hr(n)){const l=[e?e[0][0]:i[0],i[1]],u=[e?e[3][0]:a[0],a[1]];return[r,l,u,o]}const s=[i[0],e?e[0][1]:i[1]],c=[a[0],e?e[3][1]:a[1]];return[r,s,c,o]}const MO=(t,e)=>{const{adjustPoints:n=yH}=t,r=t5(t,["adjustPoints"]),{coordinate:i,document:a}=e;return(o,s,c,l)=>{const{index:u}=s,{color:f}=c,d=t5(c,["color"]),h=l[u+1],v=n(o,h,i),g=!!hr(i),[y,b,x,_]=g?Em(v):v,{color:w=f,opacity:O}=s,E=xu().curve(EO)([y,b,x,_]);return Oe(a.createElement("path",{})).call(le,d).style("d",E).style("fill",w).style("fillOpacity",O).call(le,r).node()}};MO.props={defaultMarker:"square"};function mH(t,e,n){const[r,i,a,o]=t;if(hr(n)){const l=[e?e[0][0]:(i[0]+a[0])/2,i[1]],u=[e?e[3][0]:(i[0]+a[0])/2,a[1]];return[r,l,u,o]}const s=[i[0],e?e[0][1]:(i[1]+a[1])/2],c=[a[0],e?e[3][1]:(i[1]+a[1])/2];return[r,s,c,o]}const e5=(t,e)=>MO(Object.assign({adjustPoints:mH},t),e);e5.props={defaultMarker:"square"};function s0(t){return Math.abs(t)>10?String(t):t.toString().padStart(2,"0")}function bH(t){const e=t.getFullYear(),n=s0(t.getMonth()+1),r=s0(t.getDate()),i=`${e}-${n}-${r}`,a=t.getHours(),o=t.getMinutes(),s=t.getSeconds();return a||o||s?`${i} ${s0(a)}:${s0(o)}:${s0(s)}`:i}const r1=(t={})=>{const{channel:e="x"}=t;return(n,r)=>{const{encode:i}=r,{tooltip:a}=r;if(rc(a))return[n,r];const{title:o}=a;if(o!==void 0)return[n,r];const s=Object.keys(i).filter(l=>l.startsWith(e)).filter(l=>!i[l].inferred).map(l=>hn(i,l)).filter(([l])=>l).map(l=>l[0]);if(s.length===0)return[n,r];const c=[];for(const l of n)c[l]={value:s.map(u=>u[l]instanceof Date?bH(u[l]):u[l]).join(", ")};return[n,mt({},r,{tooltip:{title:c}})]}};r1.props={};const i1=t=>{const{channel:e}=t;return(n,r)=>{const{encode:i,tooltip:a}=r;if(rc(a))return[n,r];const{items:o=[]}=a;if(!o||o.length>0)return[n,r];const c=(Array.isArray(e)?e:[e]).flatMap(l=>Object.keys(i).filter(u=>u.startsWith(l)).map(u=>{const{field:f,value:d,inferred:h=!1,aggregate:v}=i[u];return h?null:v&&d?{channel:u}:f?{field:f}:d?{channel:u}:null}).filter(u=>u!==null));return[n,mt({},r,{tooltip:{items:c}})]}};i1.props={};var xH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const n5=()=>(t,e)=>{const{encode:n}=e,{key:r}=n,i=xH(n,["key"]);if(r!==void 0)return[t,e];const a=Object.values(i).map(({value:s})=>s),o=t.map(s=>a.filter(Array.isArray).map(c=>c[s]).join("-"));return[t,mt({},e,{encode:{key:Zn(o)}})]};n5.props={};function r5(t={}){const{shapes:e}=t;return[{name:"color"},{name:"opacity"},{name:"shape",range:e},{name:"enterType"},{name:"enterDelay",scaleKey:"enter"},{name:"enterDuration",scaleKey:"enter"},{name:"enterEasing"},{name:"key",scale:"identity"},{name:"groupKey",scale:"identity"},{name:"label",scale:"identity"}]}function pa(t={}){return[...r5(t),{name:"title",scale:"identity"}]}function kot(){return[{type:MaybeTitle,channel:"color"},{type:MaybeTooltip,channel:["x","y","z"]}]}function hl(){return[{type:r1,channel:"color"},{type:i1,channel:["x","y"]}]}function _d(){return[{type:r1,channel:"x"},{type:i1,channel:["y"]}]}function _H(){return[{type:r1,channel:"color"},{type:i1,channel:["position"]}]}function wd(t={}){return r5(t)}function Dr(){return[{type:n5}]}function Ur(){return[]}function kO(t,e){return t.getBandWidth(t.invert(e))}function Pu(t,e,n={}){const{x:r,y:i,series:a}=e,{x:o,y:s,series:c}=t,{style:{bandOffset:l=c?0:.5,bandOffsetX:u=l,bandOffsetY:f=l}={}}=n,d=!!(o!=null&&o.getBandWidth),h=!!(s!=null&&s.getBandWidth),v=!!(c!=null&&c.getBandWidth);return!d&&!h?g=>g:(g,y)=>{const b=d?kO(o,r[y]):0,x=h?kO(s,i[y]):0,w=v&&a?(kO(c,a[y])/2+ +a[y])*b:0,[O,E]=g;return[O+u*b+w,E+f*x]}}function a1(t){return parseFloat(t)/100}function AO(t,e,n,r){const{x:i,y:a}=n,{innerWidth:o,innerHeight:s}=r.getOptions(),c=Array.from(t,l=>{const u=i[l],f=a[l],d=typeof u=="string"?a1(u)*o:+u,h=typeof f=="string"?a1(f)*s:+f;return[[d,h]]});return[t,c]}function Os(t){return typeof t=="function"?t:e=>e[t]}function TO(t,e){return Array.from(t,Os(e))}function PO(t,e){const{source:n=u=>u.source,target:r=u=>u.target,value:i=u=>u.value}=e,{links:a,nodes:o}=t,s=TO(a,n),c=TO(a,r),l=TO(a,i);return{links:a.map((u,f)=>({target:c[f],source:s[f],value:l[f]})),nodes:o||Array.from(new Set([...s,...c]),u=>({key:u}))}}function i5(t,e){return t.getBandWidth(t.invert(e))}const a5={rect:Tu,hollow:n1,funnel:MO,pyramid:e5},o5=()=>(t,e,n,r)=>{const{x:i,y:a,y1:o,series:s,size:c}=n,l=e.x,u=e.series,[f]=r.getSize(),d=c?c.map(g=>+g/f):null,h=c?(g,y,b)=>{const x=g+y/2,_=d[b];return[x-_/2,x+_/2]}:(g,y,b)=>[g,g+y],v=Array.from(t,g=>{const y=i5(l,i[g]),b=u?i5(u,s==null?void 0:s[g]):1,x=y*b,_=(+(s==null?void 0:s[g])||0)*y,w=+i[g]+_,[O,E]=h(w,x,g),M=+a[g],k=+o[g];return[[O,M],[E,M],[E,k],[O,k]].map(L=>r.map(L))});return[t,v]};o5.props={defaultShape:"rect",defaultLabelShape:"label",composite:!1,shape:a5,channels:[...pa({shapes:Object.keys(a5)}),{name:"x",scale:"band",required:!0},{name:"y",required:!0},{name:"series",scale:"band"},{name:"size"}],preInference:[...Dr(),{type:o0},{type:Au}],postInference:[...Ur(),..._d()],interaction:{shareTooltip:!0}};const s5={rect:Tu,hollow:n1},c5=()=>(t,e,n,r)=>{const{x:i,x1:a,y:o,y1:s}=n,c=Array.from(t,l=>{const u=[+i[l],+o[l]],f=[+a[l],+o[l]],d=[+a[l],+s[l]],h=[+i[l],+s[l]];return[u,f,d,h].map(v=>r.map(v))});return[t,c]};c5.props={defaultShape:"rect",defaultLabelShape:"label",composite:!1,shape:s5,channels:[...pa({shapes:Object.keys(s5)}),{name:"x",required:!0},{name:"y",required:!0}],preInference:[...Dr(),{type:o0}],postInference:[...Ur(),..._d()],interaction:{shareTooltip:!0}};var l5=CO(Wp);function u5(t){this._curve=t}u5.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(t,e){this._curve.point(e*Math.sin(t),e*-Math.cos(t))}};function CO(t){function e(n){return new u5(t(n))}return e._curve=t,e}function c0(t){var e=t.curve;return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t.curve=function(n){return arguments.length?e(CO(n)):e()._curve},t}function wH(){return c0(xu().curve(l5))}var f5=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const OH=ad(t=>{const{d1:e,d2:n,style1:r,style2:i}=t.attributes,a=t.ownerDocument;Oe(t).maybeAppend("line",()=>a.createElement("path",{})).style("d",e).call(le,r),Oe(t).maybeAppend("line1",()=>a.createElement("path",{})).style("d",n).call(le,i)});function SH(t,e){const n=[],r=[];let i=!1,a=null;for(const o of t)!e(o[0])||!e(o[1])?i=!0:(n.push(o),i&&(i=!1,r.push([a,o])),a=o);return[n,r]}const So=(t,e)=>{const{curve:n,gradient:r=!1,gradientColor:i="between",defined:a=u=>!Number.isNaN(u)&&u!==void 0&&u!==null,connect:o=!1}=t,s=f5(t,["curve","gradient","gradientColor","defined","connect"]),{coordinate:c,document:l}=e;return(u,f,d)=>{const{color:h,lineWidth:v}=d,g=f5(d,["color","lineWidth"]),{color:y=h,size:b=v,seriesColor:x,seriesX:_,seriesY:w}=f,O=_P(c,f),E=hr(c),M=r&&x?xP(x,_,w,r,i,E):y,k=Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({},g),M&&{stroke:M}),b&&{lineWidth:b}),O&&{transform:O}),s);let A;if(Bn(c)){const I=c.getCenter();A=D=>wH().angle((G,F)=>id(Mr(D[F],I))).radius((G,F)=>wr(D[F],I)).defined(([G,F])=>a(G)&&a(F)).curve(n)(D)}else A=xu().x(I=>I[0]).y(I=>I[1]).defined(([I,D])=>a(I)&&a(D)).curve(n);const[P,C]=SH(u,a),N=$t(k,"connect"),L=!!C.length;if(!L||o&&!Object.keys(N).length)return Oe(l.createElement("path",{})).style("d",A(P)||[]).call(le,k).node();if(L&&!o)return Oe(l.createElement("path",{})).style("d",A(u)).call(le,k).node();const R=I=>I.map(A).join(",");return Oe(new OH).style("style1",Object.assign(Object.assign({},k),N)).style("style2",k).style("d1",R(C)).style("d2",A(u)).node()}};So.props={defaultMarker:"smooth",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const d5=(t,e)=>{const{coordinate:n}=e;return(...r)=>{const i=Bn(n)?EO:Wp;return So(Object.assign({curve:i},t),e)(...r)}};d5.props=Object.assign(Object.assign({},So.props),{defaultMarker:"line"});function LO(t,e,n){t._context.bezierCurveTo(t._x1+t._k*(t._x2-t._x0),t._y1+t._k*(t._y2-t._y0),t._x2+t._k*(t._x1-e),t._y2+t._k*(t._y1-n),t._x2,t._y2)}function RO(t,e){this._context=t,this._k=(1-e)/6}RO.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:LO(this,this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2,this._x1=t,this._y1=e;break;case 2:this._point=3;default:LO(this,t,e);break}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var Aot=function t(e){function n(r){return new RO(r,e)}return n.tension=function(r){return t(+r)},n}(0);function NO(t,e){this._context=t,this._k=(1-e)/6}NO.prototype={areaStart:xd,areaEnd:xd,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._x3=t,this._y3=e;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=e);break;case 2:this._point=3,this._x5=t,this._y5=e;break;default:LO(this,t,e);break}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var Tot=function t(e){function n(r){return new NO(r,e)}return n.tension=function(r){return t(+r)},n}(0);function h5(t,e,n){var r=t._x1,i=t._y1,a=t._x2,o=t._y2;if(t._l01_a>ea){var s=2*t._l01_2a+3*t._l01_a*t._l12_a+t._l12_2a,c=3*t._l01_a*(t._l01_a+t._l12_a);r=(r*s-t._x0*t._l12_2a+t._x2*t._l01_2a)/c,i=(i*s-t._y0*t._l12_2a+t._y2*t._l01_2a)/c}if(t._l23_a>ea){var l=2*t._l23_2a+3*t._l23_a*t._l12_a+t._l12_2a,u=3*t._l23_a*(t._l23_a+t._l12_a);a=(a*l+t._x1*t._l23_2a-e*t._l12_2a)/u,o=(o*l+t._y1*t._l23_2a-n*t._l12_2a)/u}t._context.bezierCurveTo(r,i,a,o,t._x2,t._y2)}function p5(t,e){this._context=t,this._alpha=e}p5.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){if(t=+t,e=+e,this._point){var n=this._x2-t,r=this._y2-e;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(n*n+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;break;case 2:this._point=3;default:h5(this,t,e);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var Pot=function t(e){function n(r){return e?new p5(r,e):new RO(r,0)}return n.alpha=function(r){return t(+r)},n}(.5);function v5(t,e){this._context=t,this._alpha=e}v5.prototype={areaStart:xd,areaEnd:xd,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(t,e){if(t=+t,e=+e,this._point){var n=this._x2-t,r=this._y2-e;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(n*n+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=t,this._y3=e;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=e);break;case 2:this._point=3,this._x5=t,this._y5=e;break;default:h5(this,t,e);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var g5=function t(e){function n(r){return e?new v5(r,e):new NO(r,0)}return n.alpha=function(r){return t(+r)},n}(.5);function y5(t){return t<0?-1:1}function m5(t,e,n){var r=t._x1-t._x0,i=e-t._x1,a=(t._y1-t._y0)/(r||i<0&&-0),o=(n-t._y1)/(i||r<0&&-0),s=(a*i+o*r)/(r+i);return(y5(a)+y5(o))*Math.min(Math.abs(a),Math.abs(o),.5*Math.abs(s))||0}function b5(t,e){var n=t._x1-t._x0;return n?(3*(t._y1-t._y0)/n-e)/2:e}function IO(t,e,n){var r=t._x0,i=t._y0,a=t._x1,o=t._y1,s=(a-r)/3;t._context.bezierCurveTo(r+s,i+s*e,a-s,o-s*n,a,o)}function o1(t){this._context=t}o1.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:IO(this,this._t0,b5(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){var n=NaN;if(t=+t,e=+e,!(t===this._x1&&e===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;break;case 2:this._point=3,IO(this,b5(this,n=m5(this,t,e)),n);break;default:IO(this,this._t0,n=m5(this,t,e));break}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=e,this._t0=n}}};function x5(t){this._context=new _5(t)}(x5.prototype=Object.create(o1.prototype)).point=function(t,e){o1.prototype.point.call(this,e,t)};function _5(t){this._context=t}_5.prototype={moveTo:function(t,e){this._context.moveTo(e,t)},closePath:function(){this._context.closePath()},lineTo:function(t,e){this._context.lineTo(e,t)},bezierCurveTo:function(t,e,n,r,i,a){this._context.bezierCurveTo(e,t,r,n,a,i)}};function w5(t){return new o1(t)}function O5(t){return new x5(t)}var EH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const S5=(t,e)=>{const n=EH(t,[]),{coordinate:r}=e;return(...i)=>{const a=Bn(r)?g5:hr(r)?O5:w5;return So(Object.assign({curve:a},n),e)(...i)}};S5.props=Object.assign(Object.assign({},So.props),{defaultMarker:"smooth"});function s1(t,e){this._context=t,this._t=e}s1.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&this._point===2&&this._context.lineTo(this._x,this._y),(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,e),this._context.lineTo(t,e);else{var n=this._x*(1-this._t)+t*this._t;this._context.lineTo(n,this._y),this._context.lineTo(n,e)}break}}this._x=t,this._y=e}};function E5(t){return new s1(t,.5)}function M5(t){return new s1(t,0)}function k5(t){return new s1(t,1)}const A5=(t,e)=>So(Object.assign({curve:k5},t),e);A5.props=Object.assign(Object.assign({},So.props),{defaultMarker:"hv"});const T5=(t,e)=>So(Object.assign({curve:M5},t),e);T5.props=Object.assign(Object.assign({},So.props),{defaultMarker:"vh"});const P5=(t,e)=>So(Object.assign({curve:E5},t),e);P5.props=Object.assign(Object.assign({},So.props),{defaultMarker:"hvh"});var MH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function kH(t,e,n,r,i){const a=Mr(n,e),o=wo(a),s=o+Math.PI/2,c=[r/2*Math.cos(s),r/2*Math.sin(s)],l=[i/2*Math.cos(s),i/2*Math.sin(s)],u=[i/2*Math.cos(o),i/2*Math.sin(o)],f=[r/2*Math.cos(o),r/2*Math.sin(o)],d=Sm(e,c),h=Sm(n,l),v=Sm(h,u),g=Sm(n,u),y=Mr(g,l),b=Mr(n,l),x=Mr(e,c),_=Mr(x,f),w=Mr(e,f),O=Mr(d,f);t.moveTo(...d),t.lineTo(...h),t.arcTo(...v,...g,i/2),t.arcTo(...y,...b,i/2),t.lineTo(...x),t.arcTo(..._,...w,r/2),t.arcTo(...O,...d,r/2),t.closePath()}const C5=(t,e)=>{const{document:n}=e;return(r,i,a)=>{const{seriesSize:o,color:s}=i,{color:c}=a,l=MH(a,["color"]),u=Oo();for(let f=0;f<r.length-1;f++){const d=r[f],h=r[f+1],v=o[f],g=o[f+1];[...d,...h].every(qn)&&kH(u,d,h,v,g)}return Oe(n.createElement("path",{})).call(le,l).style("fill",s||c).style("d",u.toString()).call(le,t).node()}};C5.props=Object.assign(Object.assign({},So.props),{defaultMarker:"line"});const L5=()=>(t,e)=>{const{style:n={},encode:r}=e,{series:i}=r,{gradient:a}=n;return!a||i?[t,e]:[t,mt({},e,{encode:{series:e1(dl(t,void 0))}})]};L5.props={};const DO=()=>(t,e)=>{const{encode:n}=e,{series:r,color:i}=n;if(r!==void 0||i===void 0)return[t,e];const[a,o]=hn(n,"color");return[t,mt({},e,{encode:{series:Zn(a,o)}})]};DO.props={};const R5={line:d5,smooth:S5,hv:A5,vh:T5,hvh:P5,trail:C5},AH=(t,e,n,r)=>{var i,a;const{series:o,x:s,y:c}=n,{x:l,y:u}=e;if(s===void 0||c===void 0)throw new Error("Missing encode for x or y channel.");const f=o?Array.from(dr(t,y=>o[y]).values()):[t],d=f.map(y=>y[0]).filter(y=>y!==void 0),h=(((i=l==null?void 0:l.getBandWidth)===null||i===void 0?void 0:i.call(l))||0)/2,v=(((a=u==null?void 0:u.getBandWidth)===null||a===void 0?void 0:a.call(u))||0)/2,g=Array.from(f,y=>y.map(b=>r.map([+s[b]+h,+c[b]+v])));return[d,g,f]},TH=(t,e,n,r)=>{const i=Object.entries(n).filter(([o])=>o.startsWith("position")).map(([,o])=>o);if(i.length===0)throw new Error("Missing encode for position channel.");const a=Array.from(t,o=>{const s=i.map(u=>+u[o]),c=r.map(s),l=[];for(let u=0;u<c.length;u+=2)l.push([c[u],c[u+1]]);return l});return[t,a]},N5=()=>(t,e,n,r)=>(Ep(r)?TH:AH)(t,e,n,r);N5.props={defaultShape:"line",defaultLabelShape:"label",composite:!1,shape:R5,channels:[...pa({shapes:Object.keys(R5)}),{name:"x"},{name:"y"},{name:"position",independent:!0},{name:"size"},{name:"series",scale:"band"}],preInference:[...Dr(),{type:L5},{type:DO}],postInference:[...Ur(),..._d(),..._H()],interaction:{shareTooltip:!0,seriesTooltip:!0,crosshairs:!0}};var PH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function I5(t,e,n,r){if(e.length===1)return;const{size:i}=n;if(t==="fixed")return i;if(t==="normal"||VA(r)){const[[a,o],[s,c]]=e,l=Math.abs((s-a)/2),u=Math.abs((c-o)/2);return Math.max(0,(l+u)/2)}return i}const on=(t,e)=>{const{colorAttribute:n,symbol:r,mode:i="auto"}=t,a=PH(t,["colorAttribute","symbol","mode"]),o=Hf.get(r)||Hf.get("point"),{coordinate:s,document:c}=e;return(l,u,f)=>{const{lineWidth:d,color:h}=f,v=a.stroke?d||1:d,{color:g=h,transform:y,opacity:b}=u,[x,_]=Dw(l),O=I5(i,l,u,s)||a.r||f.r;return Oe(c.createElement("path",{})).call(le,f).style("fill","transparent").style("d",o(x,_,O)).style("lineWidth",v).style("transform",y).style("transformOrigin",`${x-O} ${_-O}`).style("stroke",g).style(Iw(t),b).style(n,g).call(le,a).node()}};on.props={defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const D5=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"point"},t),e);D5.props=Object.assign({defaultMarker:"hollowPoint"},on.props);const j5=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"diamond"},t),e);j5.props=Object.assign({defaultMarker:"hollowDiamond"},on.props);const F5=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"hexagon"},t),e);F5.props=Object.assign({defaultMarker:"hollowHexagon"},on.props);const B5=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"square"},t),e);B5.props=Object.assign({defaultMarker:"hollowSquare"},on.props);const z5=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"triangle-down"},t),e);z5.props=Object.assign({defaultMarker:"hollowTriangleDown"},on.props);const W5=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"triangle"},t),e);W5.props=Object.assign({defaultMarker:"hollowTriangle"},on.props);const G5=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"bowtie"},t),e);G5.props=Object.assign({defaultMarker:"hollowBowtie"},on.props);var CH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const $5=(t,e)=>{const{colorAttribute:n,mode:r="auto"}=t,i=CH(t,["colorAttribute","mode"]),{coordinate:a,document:o}=e;return(s,c,l)=>{const{lineWidth:u,color:f}=l,d=i.stroke?u||1:u,{color:h=f,transform:v,opacity:g}=c,[y,b]=Dw(s),_=I5(r,s,c,a)||i.r||l.r;return Oe(o.createElement("circle",{})).call(le,l).style("fill","transparent").style("cx",y).style("cy",b).style("r",_).style("lineWidth",d).style("transform",v).style("transformOrigin",`${y} ${b}`).style("stroke",h).style(Iw(t),g).style(n,h).call(le,i).node()}},jO=(t,e)=>$5(Object.assign({colorAttribute:"fill"},t),e);jO.props={defaultMarker:"circle",defaultEnterAnimation:"fadeIn",defaultExitAnimation:"fadeOut"};const Z5=(t,e)=>$5(Object.assign({colorAttribute:"stroke"},t),e);Z5.props=Object.assign({defaultMarker:"hollowPoint"},jO.props);const Y5=(t,e)=>on(Object.assign({colorAttribute:"fill",symbol:"point"},t),e);Y5.props=Object.assign({defaultMarker:"point"},on.props);const H5=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"plus"},t),e);H5.props=Object.assign({defaultMarker:"plus"},on.props);const V5=(t,e)=>on(Object.assign({colorAttribute:"fill",symbol:"diamond"},t),e);V5.props=Object.assign({defaultMarker:"diamond"},on.props);const X5=(t,e)=>on(Object.assign({colorAttribute:"fill",symbol:"square"},t),e);X5.props=Object.assign({defaultMarker:"square"},on.props);const U5=(t,e)=>on(Object.assign({colorAttribute:"fill",symbol:"triangle"},t),e);U5.props=Object.assign({defaultMarker:"triangle"},on.props);const q5=(t,e)=>on(Object.assign({colorAttribute:"fill",symbol:"hexagon"},t),e);q5.props=Object.assign({defaultMarker:"hexagon"},on.props);const K5=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"cross"},t),e);K5.props=Object.assign({defaultMarker:"cross"},on.props);const Q5=(t,e)=>on(Object.assign({colorAttribute:"fill",symbol:"bowtie"},t),e);Q5.props=Object.assign({defaultMarker:"bowtie"},on.props);const J5=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"hyphen"},t),e);J5.props=Object.assign({defaultMarker:"hyphen"},on.props);const tL=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"line"},t),e);tL.props=Object.assign({defaultMarker:"line"},on.props);const eL=(t,e)=>on(Object.assign({colorAttribute:"stroke",symbol:"tick"},t),e);eL.props=Object.assign({defaultMarker:"tick"},on.props);const nL=(t,e)=>on(Object.assign({colorAttribute:"fill",symbol:"triangle-down"},t),e);nL.props=Object.assign({defaultMarker:"triangleDown"},on.props);const c1=()=>(t,e)=>{const{encode:n}=e,{y:r}=n;return r!==void 0?[t,e]:[t,mt({},e,{encode:{y:r0(dl(t,0))},scale:{y:{guide:null}}})]};c1.props={};const rL=()=>(t,e)=>{const{encode:n}=e,{size:r}=n;return r!==void 0?[t,e]:[t,mt({},e,{encode:{size:e1(dl(t,3))}})]};rL.props={};const iL={hollow:D5,hollowDiamond:j5,hollowHexagon:F5,hollowSquare:B5,hollowTriangleDown:z5,hollowTriangle:W5,hollowBowtie:G5,hollowCircle:Z5,point:Y5,plus:H5,diamond:V5,square:X5,triangle:U5,hexagon:q5,cross:K5,bowtie:Q5,hyphen:J5,line:tL,tick:eL,triangleDown:nL,circle:jO},aL=t=>(e,n,r,i)=>{const{x:a,y:o,x1:s,y1:c,size:l,dx:u,dy:f}=r,[d,h]=i.getSize(),v=Pu(n,r,t),g=b=>{const x=+((u==null?void 0:u[b])||0),_=+((f==null?void 0:f[b])||0),w=s?(+a[b]+ +s[b])/2:+a[b],O=c?(+o[b]+ +c[b])/2:+o[b],E=w+x,M=O+_;return[E,M]},y=l?Array.from(e,b=>{const[x,_]=g(b),w=+l[b],O=w/d,E=w/h,M=[x-O,_-E],k=[x+O,_+E];return[i.map(v(M,b)),i.map(v(k,b))]}):Array.from(e,b=>[i.map(v(g(b),b))]);return[e,y]};aL.props={defaultShape:"hollow",defaultLabelShape:"label",composite:!1,shape:iL,channels:[...pa({shapes:Object.keys(iL)}),{name:"x",required:!0},{name:"y",required:!0},{name:"series",scale:"band"},{name:"size",quantitative:"sqrt"},{name:"dx",scale:"identity"},{name:"dy",scale:"identity"}],preInference:[...Dr(),{type:Au},{type:c1}],postInference:[...Ur(),{type:rL},...hl()]};const oL=(t,e)=>{const{coordinate:n}=e;return(r,i,a)=>{const{color:o,text:s="",fontSize:c,rotate:l=0,transform:u=""}=i,f={text:String(s),stroke:o,fill:o,fontSize:c},[[d,h]]=r;return Oe(new AP).style("x",d).style("y",h).call(le,a).style("transform",`${u}rotate(${+l})`).style("coordCenter",n.getCenter()).call(le,f).call(le,t).node()}};oL.props={defaultMarker:"point",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};var FO=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function LH(t){const e=t/Math.sqrt(2),n=t*Math.sqrt(2),[r,i]=[-e,e-n],[a,o]=[0,0],[s,c]=[e,e-n];return[["M",r,i],["A",t,t,0,1,1,s,c],["L",a,o],["Z"]]}function RH(t){const{min:e,max:n}=t.getLocalBounds();return[(e[0]+n[0])*.5,(e[1]+n[1])*.5]}const NH=ad(t=>{const e=t.attributes,{class:n,x:r,y:i,transform:a}=e,o=FO(e,["class","x","y","transform"]),s=$t(o,"marker"),{size:c=24}=s,l=()=>LH(c/2),u=Oe(t).maybeAppend("marker",()=>new An({})).call(h=>h.node().update(Object.assign({symbol:l},s))).node(),[f,d]=RH(u);Oe(t).maybeAppend("text","text").style("x",f).style("y",d).call(le,o)}),sL=(t,e)=>{const n=FO(t,[]);return(r,i,a)=>{const{color:o}=a,s=FO(a,["color"]),{color:c=o,text:l=""}=i,u={text:String(l),stroke:c,fill:c},[[f,d]]=r;return Oe(new NH).call(le,s).style("transform",`translate(${f},${d})`).call(le,u).call(le,n).node()}};sL.props={defaultMarker:"point",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const cL=(t,e)=>{const{coordinate:n}=e;return(r,i,a)=>{const{color:o,text:s="",fontSize:c,rotate:l=0,transform:u=""}=i,f={text:String(s),stroke:o,fill:o,fontSize:c,textAlign:"center",textBaseline:"middle"},[[d,h]]=r;return Oe(new po).style("x",d).style("y",h).call(le,a).style("transformOrigin","center center").style("transform",`${u}rotate(${l}deg)`).style("coordCenter",n.getCenter()).call(le,f).call(le,t).node()}};cL.props={defaultMarker:"point",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const l1=()=>(t,e)=>{const{data:n}=e;if(!Array.isArray(n)||n.some(a0))return[t,e];const r=Array.isArray(n[0])?n:[n],i=r.map(o=>o[0]),a=r.map(o=>o[1]);return[t,mt({},e,{encode:{x:Zn(i),y:Zn(a)}})]};l1.props={};var lL=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const u1=()=>(t,e)=>{const{data:n,style:r={}}=e,i=lL(e,["data","style"]),{x:a,y:o}=r,s=lL(r,["x","y"]);if(a==null||o==null)return[t,e];const c=a||0,l=o||0;return[[0],mt({},i,{data:[0],cartesian:!0,encode:{x:Zn([c]),y:Zn([l])},scale:{x:{type:"identity",independent:!0,guide:null},y:{type:"identity",independent:!0,guide:null}},style:s})]};u1.props={};const uL={text:oL,badge:sL,tag:cL},fL=t=>{const{cartesian:e=!1}=t;return e?AO:(n,r,i,a)=>{const{x:o,y:s}=i,c=Pu(r,i,t),l=Array.from(n,u=>{const f=[+o[u],+s[u]];return[a.map(c(f,u))]});return[n,l]}};fL.props={defaultShape:"text",defaultLabelShape:"label",composite:!1,shape:uL,channels:[...pa({shapes:Object.keys(uL)}),{name:"x",required:!0},{name:"y",required:!0},{name:"text",scale:"identity"},{name:"fontSize",scale:"identity"},{name:"rotate",scale:"identity"}],preInference:[...Dr(),{type:l1},{type:u1}],postInference:[...Ur(),...hl()]};const BO=()=>(t,e)=>[t,mt({scale:{x:{padding:0},y:{padding:0}}},e)];BO.props={};const dL={cell:Tu,hollow:n1},hL=()=>(t,e,n,r)=>{const{x:i,y:a}=n,o=e.x,s=e.y,c=Array.from(t,l=>{const u=o.getBandWidth(o.invert(+i[l])),f=s.getBandWidth(s.invert(+a[l])),d=+i[l],h=+a[l],v=[d,h],g=[d+u,h],y=[d+u,h+f],b=[d,h+f];return[v,g,y,b].map(x=>r.map(x))});return[t,c]};hL.props={defaultShape:"cell",defaultLabelShape:"label",shape:dL,composite:!1,channels:[...pa({shapes:Object.keys(dL)}),{name:"x",required:!0,scale:"band"},{name:"y",required:!0,scale:"band"}],preInference:[...Dr(),{type:Au},{type:c1},{type:BO}],postInference:[...Ur(),...hl()]};function zO(t,e,n){var r=null,i=vr(!0),a=null,o=Wp,s=null,c=Bw(l);t=typeof t=="function"?t:t===void 0?MP:vr(+t),e=typeof e=="function"?e:vr(e===void 0?0:+e),n=typeof n=="function"?n:n===void 0?kP:vr(+n);function l(f){var d,h,v,g=(f=OP(f)).length,y,b=!1,x,_=new Array(g),w=new Array(g);for(a==null&&(s=o(x=c())),d=0;d<=g;++d){if(!(d<g&&i(y=f[d],d,f))===b)if(b=!b)h=d,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),v=d-1;v>=h;--v)s.point(_[v],w[v]);s.lineEnd(),s.areaEnd()}b&&(_[d]=+t(y,d,f),w[d]=+e(y,d,f),s.point(r?+r(y,d,f):_[d],n?+n(y,d,f):w[d]))}if(x)return s=null,x+""||null}function u(){return xu().defined(i).curve(o).context(a)}return l.x=function(f){return arguments.length?(t=typeof f=="function"?f:vr(+f),r=null,l):t},l.x0=function(f){return arguments.length?(t=typeof f=="function"?f:vr(+f),l):t},l.x1=function(f){return arguments.length?(r=f==null?null:typeof f=="function"?f:vr(+f),l):r},l.y=function(f){return arguments.length?(e=typeof f=="function"?f:vr(+f),n=null,l):e},l.y0=function(f){return arguments.length?(e=typeof f=="function"?f:vr(+f),l):e},l.y1=function(f){return arguments.length?(n=f==null?null:typeof f=="function"?f:vr(+f),l):n},l.lineX0=l.lineY0=function(){return u().x(t).y(e)},l.lineY1=function(){return u().x(t).y(n)},l.lineX1=function(){return u().x(r).y(e)},l.defined=function(f){return arguments.length?(i=typeof f=="function"?f:vr(!!f),l):i},l.curve=function(f){return arguments.length?(o=f,a!=null&&(s=o(a)),l):o},l.context=function(f){return arguments.length?(f==null?a=s=null:s=o(a=f),l):a},l}function IH(){var t=zO().curve(l5),e=t.curve,n=t.lineX0,r=t.lineX1,i=t.lineY0,a=t.lineY1;return t.angle=t.x,delete t.x,t.startAngle=t.x0,delete t.x0,t.endAngle=t.x1,delete t.x1,t.radius=t.y,delete t.y,t.innerRadius=t.y0,delete t.y0,t.outerRadius=t.y1,delete t.y1,t.lineStartAngle=function(){return c0(n())},delete t.lineX0,t.lineEndAngle=function(){return c0(r())},delete t.lineX1,t.lineInnerRadius=function(){return c0(i())},delete t.lineY0,t.lineOuterRadius=function(){return c0(a())},delete t.lineY1,t.curve=function(o){return arguments.length?e(CO(o)):e()._curve},t}var DH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function jH(t,e){const n=[],r=[],i=[];let a=!1,o=null;const s=t.length/2;for(let c=0;c<s;c++){const l=t[c],u=t[c+s];if([...l,...u].some(f=>!e(f)))a=!0;else{if(n.push(l),r.push(u),a&&o){a=!1;const[f,d]=o;i.push([f,l,d,u])}o=[l,u]}}return[n.concat(r),i]}const pL=ad(t=>{const{areaPath:e,connectPath:n,areaStyle:r,connectStyle:i}=t.attributes,a=t.ownerDocument;Oe(t).maybeAppend("connect-path",()=>a.createElement("path",{})).style("d",n).call(le,i),Oe(t).maybeAppend("area-path",()=>a.createElement("path",{})).style("d",e).call(le,r)}),Zo=(t,e)=>{const{curve:n,gradient:r=!1,defined:i=l=>!Number.isNaN(l)&&l!==void 0&&l!==null,connect:a=!1}=t,o=DH(t,["curve","gradient","defined","connect"]),{coordinate:s,document:c}=e;return(l,u,f)=>{const{color:d}=f,{color:h=d,seriesColor:v,seriesX:g,seriesY:y}=u,b=hr(s),x=_P(s,u),_=r&&v?xP(v,g,y,r,void 0,b):h,w=Object.assign(Object.assign(Object.assign(Object.assign({},f),{stroke:_,fill:_}),x&&{transform:x}),o),[O,E]=jH(l,i),M=$t(w,"connect"),k=!!E.length,A=P=>Oe(c.createElement("path",{})).style("d",P||"").call(le,w).node();if(Bn(s)){const P=C=>{const N=s.getCenter(),L=C.slice(0,C.length/2),R=C.slice(C.length/2);return IH().angle((I,D)=>id(Mr(L[D],N))).outerRadius((I,D)=>wr(L[D],N)).innerRadius((I,D)=>wr(R[D],N)).defined((I,D)=>[...L[D],...R[D]].every(i)).curve(n)(R)};return!k||a&&!Object.keys(M).length?A(P(O)):k&&!a?A(P(l)):Oe(new pL).style("areaStyle",w).style("connectStyle",Object.assign(Object.assign({},M),o)).style("areaPath",P(l)).style("connectPath",E.map(P).join("")).node()}else{const P=C=>{const N=C.slice(0,C.length/2),L=C.slice(C.length/2);return b?zO().y((R,I)=>N[I][1]).x1((R,I)=>N[I][0]).x0((R,I)=>L[I][0]).defined((R,I)=>[...N[I],...L[I]].every(i)).curve(n)(N):zO().x((R,I)=>N[I][0]).y1((R,I)=>N[I][1]).y0((R,I)=>L[I][1]).defined((R,I)=>[...N[I],...L[I]].every(i)).curve(n)(N)};return!k||a&&!Object.keys(M).length?A(P(O)):k&&!a?A(P(l)):Oe(new pL).style("areaStyle",w).style("connectStyle",Object.assign(Object.assign({},M),o)).style("areaPath",P(l)).style("connectPath",E.map(P).join("")).node()}}};Zo.props={defaultMarker:"smooth",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const vL=(t,e)=>{const{coordinate:n}=e;return(...r)=>{const i=Bn(n)?EO:Wp;return Zo(Object.assign({curve:i},t),e)(...r)}};vL.props=Object.assign(Object.assign({},Zo.props),{defaultMarker:"square"});var FH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const gL=(t,e)=>{const n=FH(t,[]),{coordinate:r}=e;return(...i)=>{const a=Bn(r)?g5:hr(r)?O5:w5;return Zo(Object.assign({curve:a},n),e)(...i)}};gL.props=Object.assign(Object.assign({},Zo.props),{defaultMarker:"smooth"});const yL=(t,e)=>(...n)=>Zo(Object.assign({curve:E5},t),e)(...n);yL.props=Object.assign(Object.assign({},Zo.props),{defaultMarker:"hvh"});const mL=(t,e)=>(...n)=>Zo(Object.assign({curve:M5},t),e)(...n);mL.props=Object.assign(Object.assign({},Zo.props),{defaultMarker:"vh"});const bL=(t,e)=>(...n)=>Zo(Object.assign({curve:k5},t),e)(...n);bL.props=Object.assign(Object.assign({},Zo.props),{defaultMarker:"hv"});const xL={area:vL,smooth:gL,hvh:yL,vh:mL,hv:bL},_L=()=>(t,e,n,r)=>{var i,a;const{x:o,y:s,y1:c,series:l}=n,{x:u,y:f}=e,d=l?Array.from(dr(t,b=>l[b]).values()):[t],h=d.map(b=>b[0]).filter(b=>b!==void 0),v=(((i=u==null?void 0:u.getBandWidth)===null||i===void 0?void 0:i.call(u))||0)/2,g=(((a=f==null?void 0:f.getBandWidth)===null||a===void 0?void 0:a.call(f))||0)/2,y=Array.from(d,b=>{const x=b.length,_=new Array(x*2);for(let w=0;w<b.length;w++){const O=b[w];_[w]=r.map([+o[O]+v,+s[O]+g]),_[x+w]=r.map([+o[O]+v,+c[O]+g])}return _});return[h,y,d]};_L.props={defaultShape:"area",defaultLabelShape:"label",composite:!1,shape:xL,channels:[...pa({shapes:Object.keys(xL)}),{name:"x",required:!0},{name:"y",required:!0},{name:"size"},{name:"series",scale:"band"}],preInference:[...Dr(),{type:DO},{type:o0},{type:BO}],postInference:[...Ur(),..._d()],interaction:{shareTooltip:!0,seriesTooltip:!0,crosshairs:!0}};const wL=()=>(t,e)=>{const{encode:n}=e,{y1:r}=n;if(r)return[t,e];const[i]=hn(n,"y");return[t,mt({},e,{encode:{y1:Zn([...i])}})]};wL.props={};const OL=()=>(t,e)=>{const{encode:n}=e,{x1:r}=n;if(r)return[t,e];const[i]=hn(n,"x");return[t,mt({},e,{encode:{x1:Zn([...i])}})]};OL.props={};var SL=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const WO=(t,e)=>{const{arrow:n=!0,arrowSize:r="40%"}=t,i=SL(t,["arrow","arrowSize"]),{document:a}=e;return(o,s,c)=>{const{defaultColor:l}=c,u=SL(c,["defaultColor"]),{color:f=l,transform:d}=s,[h,v]=o,g=Oo();if(g.moveTo(...h),g.lineTo(...v),n){const[y,b]=Ez(h,v,{arrowSize:r});g.moveTo(...y),g.lineTo(...v),g.lineTo(...b)}return Oe(a.createElement("path",{})).call(le,u).style("d",g.toString()).style("stroke",f).style("transform",d).call(le,i).node()}};WO.props={defaultMarker:"line",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const EL=(t,e)=>{const{arrow:n=!1}=t;return(...r)=>WO(Object.assign(Object.assign({},t),{arrow:n}),e)(...r)};EL.props={defaultMarker:"line",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};var ML=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const kL=(t,e)=>{const n=ML(t,[]),{coordinate:r,document:i}=e;return(a,o,s)=>{const{color:c}=s,l=ML(s,["color"]),{color:u=c,transform:f}=o,[d,h]=a,v=Oo();if(v.moveTo(d[0],d[1]),Bn(r)){const g=r.getCenter();v.quadraticCurveTo(g[0],g[1],h[0],h[1])}else{const g=bP(d,h),y=wr(d,h)/2;zp(v,d,h,g,y)}return Oe(i.createElement("path",{})).call(le,l).style("d",v.toString()).style("stroke",u).style("transform",f).call(le,n).node()}};kL.props={defaultMarker:"smooth",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};var AL=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const TL=(t,e)=>{const n=AL(t,[]),{document:r}=e;return(i,a,o)=>{const{color:s}=o,c=AL(o,["color"]),{color:l=s,transform:u}=a,[f,d]=i,h=Oo();return h.moveTo(f[0],f[1]),h.bezierCurveTo(f[0]/2+d[0]/2,f[1],f[0]/2+d[0]/2,d[1],d[0],d[1]),Oe(r.createElement("path",{})).call(le,c).style("d",h.toString()).style("stroke",l).style("transform",u).call(le,n).node()}};TL.props={defaultMarker:"smooth",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};var PL=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function BH(t,e,n,r){const i=Oo();if(Bn(n)){const a=n.getCenter(),o=wr(t,a),c=(wr(e,a)-o)*r+o;return i.moveTo(t[0],t[1]),zp(i,t,e,a,c),i.lineTo(e[0],e[1]),i}return hr(n)?(i.moveTo(t[0],t[1]),i.lineTo(t[0]+(e[0]-t[0])*r,t[1]),i.lineTo(t[0]+(e[0]-t[0])*r,e[1]),i.lineTo(e[0],e[1]),i):(i.moveTo(t[0],t[1]),i.lineTo(t[0],t[1]+(e[1]-t[1])*r),i.lineTo(e[0],t[1]+(e[1]-t[1])*r),i.lineTo(e[0],e[1]),i)}const CL=(t,e)=>{const{cornerRatio:n=1/3}=t,r=PL(t,["cornerRatio"]),{coordinate:i,document:a}=e;return(o,s,c)=>{const{defaultColor:l}=c,u=PL(c,["defaultColor"]),{color:f=l,transform:d}=s,[h,v]=o,g=BH(h,v,i,n);return Oe(a.createElement("path",{})).call(le,u).style("d",g.toString()).style("stroke",f).style("transform",d).call(le,r).node()}};CL.props={defaultMarker:"vhv",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const LL={link:EL,arc:kL,smooth:TL,vhv:CL},GO=t=>(e,n,r,i)=>{const{x:a,y:o,x1:s=a,y1:c=o}=r,l=Pu(n,r,t),u=e.map(f=>[i.map(l([+a[f],+o[f]],f)),i.map(l([+s[f],+c[f]],f))]);return[e,u]};GO.props={defaultShape:"link",defaultLabelShape:"label",composite:!1,shape:LL,channels:[...pa({shapes:Object.keys(LL)}),{name:"x",required:!0},{name:"y",required:!0}],preInference:[...Dr(),{type:wL},{type:OL}],postInference:[...Ur(),...hl()]};var zH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const RL=(t,e)=>{const{coordinate:n,document:r}=e;return(i,a,o)=>{const{color:s}=o,c=zH(o,["color"]),{color:l=s,src:u="",size:f=32,transform:d=""}=a;let{width:h=f,height:v=f}=t;const[[g,y]]=i,[b,x]=n.getSize();h=typeof h=="string"?a1(h)*b:h,v=typeof v=="string"?a1(v)*x:v;const _=g-Number(h)/2,w=y-Number(v)/2;return Oe(r.createElement("image",{})).call(le,c).style("x",_).style("y",w).style("src",u).style("stroke",l).style("transform",d).call(le,t).style("width",h).style("height",v).node()}};RL.props={defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const NL={image:RL},IL=t=>{const{cartesian:e}=t;return e?AO:(n,r,i,a)=>{const{x:o,y:s}=i,c=Pu(r,i,t),l=Array.from(n,u=>{const f=[+o[u],+s[u]];return[a.map(c(f,u))]});return[n,l]}};IL.props={defaultShape:"image",defaultLabelShape:"label",composite:!1,shape:NL,channels:[...pa({shapes:Object.keys(NL)}),{name:"x",required:!0},{name:"y",required:!0},{name:"src",scale:"identity"},{name:"size"}],preInference:[...Dr(),{type:l1},{type:u1}],postInference:[...Ur(),...hl()]};var WH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function GH(t,e){const n=Oo();if(Bn(e)){const r=e.getCenter(),i=[...t,t[0]],a=i.map(o=>wr(o,r));return i.forEach((o,s)=>{if(s===0){n.moveTo(o[0],o[1]);return}const c=a[s],l=t[s-1],u=a[s-1];u!==void 0&&Math.abs(c-u)<1e-10?zp(n,l,o,r,c):n.lineTo(o[0],o[1])}),n.closePath(),n}return Sz(n,t)}const DL=(t,e)=>{const{coordinate:n,document:r}=e;return(i,a,o)=>{const{color:s}=o,c=WH(o,["color"]),{color:l=s,transform:u}=a,f=GH(i,n);return Oe(r.createElement("path",{})).call(le,c).style("d",f.toString()).style("stroke",l).style("fill",l).style("transform",u).call(le,t).node()}};DL.props={defaultMarker:"square",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};var jL=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function $H(t,e){const[n,r,i,a]=t,o=Oo();if(Bn(e)){const s=e.getCenter(),c=wr(s,n);return o.moveTo(n[0],n[1]),o.quadraticCurveTo(s[0],s[1],i[0],i[1]),zp(o,i,a,s,c),o.quadraticCurveTo(s[0],s[1],r[0],r[1]),zp(o,r,n,s,c),o.closePath(),o}return o.moveTo(n[0],n[1]),o.bezierCurveTo(n[0]/2+i[0]/2,n[1],n[0]/2+i[0]/2,i[1],i[0],i[1]),o.lineTo(a[0],a[1]),o.bezierCurveTo(a[0]/2+r[0]/2,a[1],a[0]/2+r[0]/2,r[1],r[0],r[1]),o.lineTo(n[0],n[1]),o.closePath(),o}const FL=(t,e)=>{const n=jL(t,[]),{coordinate:r,document:i}=e;return(a,o,s)=>{const{color:c}=s,l=jL(s,["color"]),{color:u=c,transform:f}=o,d=$H(a,r);return Oe(i.createElement("path",{})).call(le,l).style("d",d.toString()).style("fill",u||c).style("stroke",u||c).style("transform",f).call(le,n).node()}};FL.props={defaultMarker:"square",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const BL={polygon:DL,ribbon:FL},zL=()=>(t,e,n,r)=>{const i=Object.entries(n).filter(([s])=>s.startsWith("x")).map(([,s])=>s),a=Object.entries(n).filter(([s])=>s.startsWith("y")).map(([,s])=>s),o=t.map(s=>{const c=[];for(let l=0;l<i.length;l++){const u=i[l][s];if(u===void 0)break;const f=a[l][s];c.push(r.map([+u,+f]))}return c});return[t,o]};zL.props={defaultShape:"polygon",defaultLabelShape:"label",composite:!1,shape:BL,channels:[...pa({shapes:Object.keys(BL)}),{name:"x",required:!0},{name:"y",required:!0}],preInference:[...Dr()],postInference:[...Ur(),...hl()]};var ZH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function YH(t,e){const n=Oo();if(!Bn(e))n.moveTo(...t[0]),n.lineTo(...t[1]),n.moveTo(...t[2]),n.lineTo(...t[3]),n.moveTo(...t[4]),n.lineTo(...t[5]),n.lineTo(...t[6]),n.lineTo(...t[7]),n.closePath(),n.moveTo(...t[8]),n.lineTo(...t[9]),n.moveTo(...t[10]),n.lineTo(...t[11]),n.moveTo(...t[12]),n.lineTo(...t[13]);else{const r=e.getCenter(),[i,a]=r,o=wo(Mr(t[0],r)),s=wo(Mr(t[1],r)),c=wr(r,t[2]),l=wr(r,t[3]),u=wr(r,t[8]),f=wr(r,t[10]),d=wr(r,t[11]);n.moveTo(...t[0]),n.arc(i,a,c,o,s),n.arc(i,a,c,s,o,!0),n.moveTo(...t[2]),n.lineTo(...t[3]),n.moveTo(...t[4]),n.arc(i,a,l,o,s),n.lineTo(...t[6]),n.arc(i,a,f,s,o,!0),n.closePath(),n.moveTo(...t[8]),n.arc(i,a,u,o,s),n.arc(i,a,u,s,o,!0),n.moveTo(...t[10]),n.lineTo(...t[11]),n.moveTo(...t[12]),n.arc(i,a,d,o,s),n.arc(i,a,d,s,o,!0)}return n}const WL=(t,e)=>{const{coordinate:n,document:r}=e;return(i,a,o)=>{const{color:s,transform:c}=a,{color:l,fill:u=l,stroke:f=l}=o,d=ZH(o,["color","fill","stroke"]),h=YH(i,n);return Oe(r.createElement("path",{})).call(le,d).style("d",h.toString()).style("stroke",f).style("fill",s||u).style("transform",c).call(le,t).node()}};WL.props={defaultMarker:"point",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};var HH=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function VH(t,e,n=4){const r=Oo();if(!Bn(e))return r.moveTo(...t[2]),r.lineTo(...t[3]),r.lineTo(t[3][0]-n,t[3][1]),r.lineTo(t[10][0]-n,t[10][1]),r.lineTo(t[10][0]+n,t[10][1]),r.lineTo(t[3][0]+n,t[3][1]),r.lineTo(...t[3]),r.closePath(),r.moveTo(...t[10]),r.lineTo(...t[11]),r.moveTo(t[3][0]+n/2,t[8][1]),r.arc(t[3][0],t[8][1],n/2,0,Math.PI*2),r.closePath(),r;const i=e.getCenter(),[a,o]=i,s=wr(i,t[3]),c=wr(i,t[8]),l=wr(i,t[10]),u=wo(Mr(t[2],i)),f=Math.asin(n/c),d=u-f,h=u+f;r.moveTo(...t[2]),r.lineTo(...t[3]),r.moveTo(Math.cos(d)*s+a,Math.sin(d)*s+o),r.arc(a,o,s,d,h),r.lineTo(Math.cos(h)*l+a,Math.sin(h)*l+o),r.arc(a,o,l,h,d,!0),r.lineTo(Math.cos(d)*s+a,Math.sin(d)*s+o),r.closePath(),r.moveTo(...t[10]),r.lineTo(...t[11]);const v=(d+h)/2;return r.moveTo(Math.cos(v)*(c+n/2)+a,Math.sin(v)*(c+n/2)+o),r.arc(Math.cos(v)*c+a,Math.sin(v)*c+o,n/2,v,Math.PI*2+v),r.closePath(),r}const GL=(t,e)=>{const{coordinate:n,document:r}=e;return(i,a,o)=>{const{color:s,transform:c}=a,l=4,{color:u,fill:f=u,stroke:d=u}=o,h=HH(o,["color","fill","stroke"]),v=VH(i,n,l);return Oe(r.createElement("path",{})).call(le,h).style("d",v.toString()).style("stroke",d).style("fill",s||f).style("transform",c).call(le,t).node()}};GL.props={defaultMarker:"point",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const $L={box:WL,violin:GL},ZL=()=>(t,e,n,r)=>{const{x:i,y:a,y1:o,y2:s,y3:c,y4:l,series:u}=n,f=e.x,d=e.series,h=Array.from(t,v=>{const g=f.getBandWidth(f.invert(+i[v])),y=d?d.getBandWidth(d.invert(+(u==null?void 0:u[v]))):1,b=g*y,x=(+(u==null?void 0:u[v])||0)*g,_=+i[v]+x+b/2,[w,O,E,M,k]=[+a[v],+o[v],+s[v],+c[v],+l[v]];return[[_-b/2,k],[_+b/2,k],[_,k],[_,M],[_-b/2,M],[_+b/2,M],[_+b/2,O],[_-b/2,O],[_-b/2,E],[_+b/2,E],[_,O],[_,w],[_-b/2,w],[_+b/2,w]].map(P=>r.map(P))});return[t,h]};ZL.props={defaultShape:"box",defaultLabelShape:"label",composite:!1,shape:$L,channels:[...pa({shapes:Object.keys($L)}),{name:"x",scale:"band",required:!0},{name:"y",required:!0},{name:"series",scale:"band"}],preInference:[...Dr(),{type:Au}],postInference:[...Ur(),..._d()],interaction:{shareTooltip:!0}};const YL={vector:WO},HL=()=>(t,e,n,r)=>{const{x:i,y:a,size:o,rotate:s}=n,[c,l]=r.getSize(),u=t.map(f=>{const d=+s[f]/180*Math.PI,h=+o[f],v=h/c,g=h/l,y=v*Math.cos(d),b=-g*Math.sin(d);return[r.map([+i[f]-y/2,+a[f]-b/2]),r.map([+i[f]+y/2,+a[f]+b/2])]});return[t,u]};HL.props={defaultShape:"vector",defaultLabelShape:"label",composite:!1,shape:YL,channels:[...pa({shapes:Object.keys(YL)}),{name:"x",required:!0},{name:"y",required:!0},{name:"rotate",required:!0,scale:"identity"},{name:"size",required:!0}],preInference:[...Dr()],postInference:[...Ur(),...hl()]};var VL=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function XH(t,e,n){return t.createElement("path",{style:Object.assign({d:`M ${e},${e} L -${e},0 L ${e},-${e} L 0,0 Z`,transformOrigin:"center"},n)})}function UH(t,e){if(!Bn(e))return xu().x(r=>r[0]).y(r=>r[1])(t);const n=e.getCenter();return Lm()({startAngle:0,endAngle:Math.PI*2,outerRadius:wr(t[0],n),innerRadius:wr(t[1],n)})}function qH(t,e){if(!Bn(t))return e;const[n,r]=t.getCenter();return`translate(${n}, ${r}) ${e||""}`}const $O=(t,e)=>{const{arrow:n,arrowSize:r=4}=t,i=VL(t,["arrow","arrowSize"]),{coordinate:a,document:o}=e;return(s,c,l)=>{const{color:u,lineWidth:f}=l,d=VL(l,["color","lineWidth"]),{color:h=u,size:v=f}=c,g=n?XH(o,r,Object.assign({fill:i.stroke||h,stroke:i.stroke||h},$t(i,"arrow"))):null,y=UH(s,a),b=qH(a,c.transform);return Oe(o.createElement("path",{})).call(le,d).style("d",y).style("stroke",h).style("lineWidth",v).style("transform",b).style("markerEnd",g).call(le,i).node()}};$O.props={defaultMarker:"line",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const XL=()=>(t,e)=>{const{data:n}=e;return!Array.isArray(n)||n.some(a0)?[t,e]:[t,mt({},e,{encode:{x:Zn(n)}})]};XL.props={};const UL={line:$O},qL=t=>(e,n,r,i)=>{const{x:a}=r,o=Pu(n,r,mt({style:{bandOffset:0}},t)),s=Array.from(e,c=>{const l=[a[c],1],u=[a[c],0];return[l,u].map(f=>i.map(o(f,c)))});return[e,s]};qL.props={defaultShape:"line",defaultLabelShape:"label",composite:!1,shape:UL,channels:[...wd({shapes:Object.keys(UL)}),{name:"x",required:!0}],preInference:[...Dr(),{type:XL}],postInference:[...Ur()]};const KL=()=>(t,e)=>{const{data:n}=e;return!Array.isArray(n)||n.some(a0)?[t,e]:[t,mt({},e,{encode:{y:Zn(n)}})]};KL.props={};const QL={line:$O},JL=t=>(e,n,r,i)=>{const{y:a}=r,o=Pu(n,r,mt({style:{bandOffset:0}},t)),s=Array.from(e,c=>{const l=[0,a[c]],u=[1,a[c]];return[l,u].map(f=>i.map(o(f,c)))});return[e,s]};JL.props={defaultShape:"line",defaultLabelShape:"label",composite:!1,shape:QL,channels:[...wd({shapes:Object.keys(QL)}),{name:"y",required:!0}],preInference:[...Dr(),{type:KL}],postInference:[...Ur()]};var tR=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function KH(t,e,n){return[["M",t,e],["L",t+2*n,e-n],["L",t+2*n,e+n],["Z"]]}function QH(t){return xu().x(e=>e[0]).y(e=>e[1])(t)}function JH(t,e,n,r,i=0){const[[a,o],[s,c]]=e;if(hr(t)){const d=a+n,h=s+r,v=d+i;return[[d,o],[v,o],[v,c],[h,c]]}const l=o-n,u=c-r,f=l-i;return[[a,l],[a,f],[s,f],[s,u]]}const eR=(t,e)=>{const{offset:n=0,offset1:r=n,offset2:i=n,connectLength1:a,endMarker:o=!0}=t,s=tR(t,["offset","offset1","offset2","connectLength1","endMarker"]),{coordinate:c}=e;return(l,u,f)=>{const{color:d,connectLength1:h}=f,v=tR(f,["color","connectLength1"]),{color:g,transform:y}=u,b=JH(c,l,r,i,a!=null?a:h),x=$t(Object.assign(Object.assign({},s),f),"endMarker");return Oe(new Qi).call(le,v).style("d",QH(b)).style("stroke",g||d).style("transform",y).style("markerEnd",o?new An({className:"marker",style:Object.assign(Object.assign({},x),{symbol:KH})}):null).call(le,s).node()}};eR.props={defaultMarker:"line",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const nR={connector:eR},rR=(...t)=>GO(...t);rR.props={defaultShape:"connector",defaultLabelShape:"label",composite:!1,shape:nR,channels:[...wd({shapes:Object.keys(nR)}),{name:"x",required:!0},{name:"y",required:!0}],preInference:[...Dr()],postInference:[...Ur()]};function iR(t,e,n,r){if(e)return()=>[0,1];const{[t]:i,[`${t}1`]:a}=n;return o=>{var s;const c=((s=r.getBandWidth)===null||s===void 0?void 0:s.call(r,r.invert(+a[o])))||0;return[i[o],a[o]+c]}}function ZO(t={}){const{extendX:e=!1,extendY:n=!1}=t;return(r,i,a,o)=>{const s=iR("x",e,a,i.x),c=iR("y",n,a,i.y),l=Array.from(r,u=>{const[f,d]=s(u),[h,v]=c(u);return[[f,h],[d,h],[d,v],[f,v]].map(_=>o.map(_))});return[r,l]}}const aR={range:Tu},oR=()=>ZO();oR.props={defaultShape:"range",defaultLabelShape:"label",composite:!1,shape:aR,channels:[...wd({shapes:Object.keys(aR)}),{name:"x",required:!0},{name:"y",required:!0}],preInference:[...Dr()],postInference:[...Ur()]};const sR=()=>(t,e)=>{const{data:n}=e;if(Array.isArray(n)&&(n.every(Array.isArray)||!n.some(a0))){const r=(i,a)=>Array.isArray(i[0])?i.map(o=>o[a]):[i[a]];return[t,mt({},e,{encode:{x:Zn(r(n,0)),x1:Zn(r(n,1))}})]}return[t,e]};sR.props={};const cR={range:Tu},lR=()=>ZO({extendY:!0});lR.props={defaultShape:"range",defaultLabelShape:"label",composite:!1,shape:cR,channels:[...wd({shapes:Object.keys(cR)}),{name:"x",required:!0}],preInference:[...Dr(),{type:sR}],postInference:[...Ur()]};const uR=()=>(t,e)=>{const{data:n}=e;if(Array.isArray(n)&&(n.every(Array.isArray)||!n.some(a0))){const r=(i,a)=>Array.isArray(i[0])?i.map(o=>o[a]):[i[a]];return[t,mt({},e,{encode:{y:Zn(r(n,0)),y1:Zn(r(n,1))}})]}return[t,e]};uR.props={};const fR={range:Tu},dR=()=>ZO({extendX:!0});dR.props={defaultShape:"range",defaultLabelShape:"label",composite:!1,shape:fR,channels:[...wd({shapes:Object.keys(fR)}),{name:"y",required:!0}],preInference:[...Dr(),{type:uR}],postInference:[...Ur()]};var hR=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const YO=(t,e)=>{const{arrow:n,colorAttribute:r}=t,i=hR(t,["arrow","colorAttribute"]),{coordinate:a,document:o}=e;return(s,c,l)=>{const{color:u,stroke:f}=l,d=hR(l,["color","stroke"]),{d:h,color:v=u}=c,[g,y]=a.getSize();return Oe(o.createElement("path",{})).call(le,d).style("d",typeof h=="function"?h({width:g,height:y}):h).style(r,v).call(le,i).node()}};YO.props={defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const pR=(t,e)=>YO(Object.assign({colorAttribute:"fill"},t),e);pR.props={defaultMarker:"hvh",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const vR=(t,e)=>YO(Object.assign({fill:"none",colorAttribute:"stroke"},t),e);vR.props={defaultMarker:"hvh",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const gR={path:pR,hollow:vR},yR=t=>(e,n,r,i)=>[e,e.map(()=>[[0,0]])];yR.props={defaultShape:"path",defaultLabelShape:"label",shape:gR,composite:!1,channels:[...pa({shapes:Object.keys(gR)}),{name:"d",scale:"identity"}],preInference:[...Dr()],postInference:[...Ur()]};var tV=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const mR=(t,e)=>{const{render:n}=t,r=tV(t,["render"]);return i=>{const[[a,o]]=i;return n(Object.assign(Object.assign({},r),{x:a,y:o}),e)}};mR.props={defaultMarker:"point",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const bR=()=>(t,e)=>{const{style:n={}}=e;return[t,mt({},e,{style:Object.assign(Object.assign({},n),Object.fromEntries(Object.entries(n).filter(([,r])=>typeof r=="function").map(([r,i])=>[r,()=>i])))})]};bR.props={};const eV={shape:mR},xR=t=>{const{cartesian:e}=t;return e?AO:(n,r,i,a)=>{const{x:o,y:s}=i,c=Pu(r,i,t),l=Array.from(n,u=>{const f=[+o[u],+s[u]];return[a.map(c(f,u))]});return[n,l]}};xR.props={defaultShape:"shape",defaultLabelShape:"label",composite:!1,shape:eV,channels:[{name:"x",required:!0},{name:"y",required:!0}],preInference:[...Dr(),{type:l1},{type:u1},{type:bR}]};var nV=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const _R=(t,e)=>{const{document:n}=e;return(r,i,a)=>{const{transform:o}=i,{color:s}=a,c=nV(a,["color"]),{color:l=s}=i,[u,...f]=r,d=Oo();return d.moveTo(...u),f.forEach(([h,v])=>{d.lineTo(h,v)}),d.closePath(),Oe(n.createElement("path",{})).call(le,c).style("d",d.toString()).style("stroke",l||s).style("fill",l||s).style("fillOpacity",.4).style("transform",o).call(le,t).node()}};_R.props={defaultMarker:"square",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const wR={density:_R},OR=()=>(t,e,n,r)=>{const{x:i,series:a}=n,o=Object.entries(n).filter(([f])=>f.startsWith("y")).map(([,f])=>f),s=Object.entries(n).filter(([f])=>f.startsWith("size")).map(([,f])=>f);if(i===void 0||o===void 0||s===void 0)throw new Error("Missing encode for x or y or size channel.");const c=e.x,l=e.series,u=Array.from(t,f=>{const d=c.getBandWidth(c.invert(+i[f])),h=l?l.getBandWidth(l.invert(+(a==null?void 0:a[f]))):1,v=d*h,g=(+(a==null?void 0:a[f])||0)*d,y=+i[f]+g+v/2;return[...o.map((x,_)=>[y+ +s[_][f]/t.length,+o[_][f]]),...o.map((x,_)=>[y-+s[_][f]/t.length,+o[_][f]]).reverse()].map(x=>r.map(x))});return[t,u]};OR.props={defaultShape:"density",defaultLabelShape:"label",composite:!1,shape:wR,channels:[...pa({shapes:Object.keys(wR)}),{name:"x",scale:"band",required:!0},{name:"y",required:!0},{name:"size",required:!0},{name:"series",scale:"band"},{name:"size",required:!0,scale:"identity"}],preInference:[...Dr(),{type:o0},{type:Au}],postInference:[...Ur(),..._d()],interaction:{shareTooltip:!0}};function SR(t){var e,n,r,i=t||1;function a(s,c){++e>i&&(r=n,o(1),++e),n[s]=c}function o(s){e=0,n=Object.create(null),s||(r=Object.create(null))}return o(),{clear:o,has:function(s){return n[s]!==void 0||r[s]!==void 0},get:function(s){var c=n[s];if(c!==void 0)return c;if((c=r[s])!==void 0)return a(s,c),c},set:function(s,c){n[s]!==void 0?n[s]=c:a(s,c)}}}const Cot=SR(3);function rV(t,e=(...r)=>`${r[0]}`,n=16){const r=SR(n);return(...i)=>{const a=e(...i);let o=r.get(a);return r.has(a)?r.get(a):(o=t(...i),r.set(a,o),o)}}function iV(t){return typeof t=="string"?t.split(" ").map(e=>{const[n,r]=e.split(":");return[+n,r]}):t}function f1(t,e,n){const r=t?t():document.createElement("canvas");return r.width=e,r.height=n,r}const aV=rV((t,e,n)=>{const r=f1(n,t*2,t*2),i=r.getContext("2d"),a=t,o=t;if(e===1)i.beginPath(),i.arc(a,o,t,0,2*Math.PI,!1),i.fillStyle="rgba(0,0,0,1)",i.fill();else{const s=i.createRadialGradient(a,o,t*e,a,o,t);s.addColorStop(0,"rgba(0,0,0,1)"),s.addColorStop(1,"rgba(0,0,0,0)"),i.fillStyle=s,i.fillRect(0,0,2*t,2*t)}return r},t=>`${t}`);function oV(t,e){const r=f1(e,256,1).getContext("2d"),i=r.createLinearGradient(0,0,256,1);return iV(t).forEach(([a,o])=>{i.addColorStop(a,o)}),r.fillStyle=i,r.fillRect(0,0,256,1),r.getImageData(0,0,256,1).data}function sV(t,e,n,r,i,a){const{blur:o}=i;let s=r.length;for(;s--;){const{x:c,y:l,value:u,radius:f}=r[s],d=Math.min(u,n),h=c-f,v=l-f,g=aV(f,1-o,a),y=(d-e)/(n-e);t.globalAlpha=Math.max(y,.001),t.drawImage(g,h,v)}return t}function cV(t,e,n,r,i){const{minOpacity:a,opacity:o,maxOpacity:s,useGradientOpacity:c}=i,l=0,u=0,f=e,d=n,h=t.getImageData(l,u,f,d),v=h.data,g=v.length;for(let y=3;y<g;y+=4){const b=v[y],x=b*4;if(!x)continue;const _=o||Math.max(0,Math.min(s,Math.max(a,b)));v[y-3]=r[x],v[y-2]=r[x+1],v[y-1]=r[x+2],v[y]=c?r[x+3]:_}return h}function lV(t,e,n,r,i,a,o){const s=Object.assign({blur:.85,minOpacity:0,opacity:.6,maxOpacity:1,gradient:[[.25,"rgb(0,0,255)"],[.55,"rgb(0,255,0)"],[.85,"yellow"],[1,"rgb(255,0,0)"]]},a);s.minOpacity*=255,s.opacity*=255,s.maxOpacity*=255;const l=f1(o,t,e).getContext("2d"),u=oV(s.gradient,o);l.clearRect(0,0,t,e),sV(l,n,r,i,s,o);const f=cV(l,t,e,u,s),h=f1(o,t,e).getContext("2d");return h.putImageData(f,0,0),h}var uV=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function fV(t,e){return Object.keys(t).reduce((n,r)=>{const i=t[r];return e(i,r)||(n[r]=i),n},{})}const ER=(t,e)=>{const{gradient:n,opacity:r,maxOpacity:i,minOpacity:a,blur:o,useGradientOpacity:s}=t,c=uV(t,["gradient","opacity","maxOpacity","minOpacity","blur","useGradientOpacity"]),{coordinate:l,createCanvas:u,document:f}=e;return(d,h,v)=>{const{transform:g}=h,[y,b]=l.getSize(),x=d.map(M=>({x:M[0],y:M[1],value:M[2],radius:M[3]})),_=Za(d,M=>M[2]),w=Dn(d,M=>M[2]),E=y&&b?lV(y,b,_,w,x,fV({gradient:n,opacity:r,minOpacity:a,maxOpacity:i,blur:o,useGradientOpacity:s},M=>M===void 0),u):{canvas:null};return Oe(f.createElement("image",{})).call(le,v).style("x",0).style("y",0).style("width",y).style("height",b).style("src",E.canvas.toDataURL()).style("transform",g).call(le,c).node()}};ER.props={defaultMarker:"point",defaultEnterAnimation:"fadeIn",defaultUpdateAnimation:"morphing",defaultExitAnimation:"fadeOut"};const MR={heatmap:ER},kR=t=>(e,n,r,i)=>{const{x:a,y:o,size:s,color:c}=r,l=Array.from(e,u=>{const f=s?+s[u]:40;return[...i.map([+a[u],+o[u]]),c[u],f]});return[[0],[l]]};kR.props={defaultShape:"heatmap",defaultLabelShape:"label",composite:!1,shape:MR,channels:[...pa({shapes:Object.keys(MR)}),{name:"x",required:!0},{name:"y",required:!0},{name:"color",scale:"identity",required:!0},{name:"size"}],preInference:[...Dr(),{type:Au},{type:c1}],postInference:[...Ur(),...hl()]};var dV=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})},hV=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function pV(t,e){const{text:n="text",value:r="value"}=e;return t.map(i=>Object.assign(Object.assign({},i),{text:i[n],value:i[r]}))}const vV=()=>({axis:!1,type:"text",encode:{x:"x",y:"y",text:"text",rotate:"rotate",fontSize:"size",shape:"tag"},scale:{x:{range:[0,1]},y:{range:[0,1]}},style:{fontFamily:t=>t.fontFamily}}),HO=(t,e)=>dV(void 0,void 0,void 0,function*(){const{width:n,height:r}=e,{data:i,encode:a={},scale:o,style:s={},layout:c={}}=t,l=hV(t,["data","encode","scale","style","layout"]),u=pV(i,a);return mt({},vV(),Object.assign(Object.assign({data:{value:u,transform:[Object.assign({type:"wordCloud",size:[n,r]},c)]},encode:a,scale:o,style:s},l),{axis:!1}))});HO.props={};const AR=()=>["#5B8FF9","#5AD8A6","#5D7092","#F6BD16","#6F5EF9","#6DC8EC","#945FB9","#FF9845","#1E9493","#FF99C3"];AR.props={};const TR=()=>["#5B8FF9","#CDDDFD","#5AD8A6","#CDF3E4","#5D7092","#CED4DE","#F6BD16","#FCEBB9","#6F5EF9","#D3CEFD","#6DC8EC","#D3EEF9","#945FB9","#DECFEA","#FF9845","#FFE0C7","#1E9493","#BBDEDE","#FF99C3","#FFE0ED"];TR.props={};const PR=t=>new Ji(t);PR.props={};const d1=Symbol("defaultUnknown");function CR(t,e,n){for(let r=0;r<e.length;r+=1)t.has(e[r])||t.set(n(e[r]),r)}function LR(t){const{value:e,from:n,to:r,mapper:i,notFoundReturn:a}=t;let o=i.get(e);if(o===void 0){if(a!==d1)return a;o=n.push(e)-1,i.set(e,o)}return r[o%r.length]}function RR(t){return t instanceof Date?e=>`${e}`:typeof t=="object"?e=>JSON.stringify(e):e=>e}class h1 extends Lp{getDefaultOptions(){return{domain:[],range:[],unknown:d1}}constructor(e){super(e)}map(e){return this.domainIndexMap.size===0&&CR(this.domainIndexMap,this.getDomain(),this.domainKey),LR({value:this.domainKey(e),mapper:this.domainIndexMap,from:this.getDomain(),to:this.getRange(),notFoundReturn:this.options.unknown})}invert(e){return this.rangeIndexMap.size===0&&CR(this.rangeIndexMap,this.getRange(),this.rangeKey),LR({value:this.rangeKey(e),mapper:this.rangeIndexMap,from:this.getRange(),to:this.getDomain(),notFoundReturn:this.options.unknown})}rescale(e){const[n]=this.options.domain,[r]=this.options.range;if(this.domainKey=RR(n),this.rangeKey=RR(r),!this.rangeIndexMap){this.rangeIndexMap=new Map,this.domainIndexMap=new Map;return}(!e||e.range)&&this.rangeIndexMap.clear(),(!e||e.domain||e.compare)&&(this.domainIndexMap.clear(),this.sortedDomain=void 0)}clone(){return new h1(this.options)}getRange(){return this.options.range}getDomain(){if(this.sortedDomain)return this.sortedDomain;const{domain:e,compare:n}=this.options;return this.sortedDomain=n?[...e].sort(n):e,this.sortedDomain}}const NR=t=>new h1(t);NR.props={};function IR({map:t,initKey:e},n){const r=e(n);return t.has(r)?t.get(r):n}function gV({map:t,initKey:e},n){const r=e(n);return t.has(r)?t.get(r):(t.set(r,n),n)}function yV({map:t,initKey:e},n){const r=e(n);return t.has(r)&&(n=t.get(r),t.delete(r)),n}function mV(t){return typeof t=="object"?t.valueOf():t}class DR extends Map{constructor(e){if(super(),this.map=new Map,this.initKey=mV,e!==null)for(const[n,r]of e)this.set(n,r)}get(e){return super.get(IR({map:this.map,initKey:this.initKey},e))}has(e){return super.has(IR({map:this.map,initKey:this.initKey},e))}set(e,n){return super.set(gV({map:this.map,initKey:this.initKey},e),n)}delete(e){return super.delete(yV({map:this.map,initKey:this.initKey},e))}}function bV(t){const e=Math.min(...t);return t.map(n=>n/e)}function xV(t,e){const n=t.length,r=e-n;return r>0?[...t,...new Array(r).fill(1)]:r<0?t.slice(0,e):t}function _V(t){return Math.round(t*1e12)/1e12}function wV(t){const{domain:e,range:n,paddingOuter:r,paddingInner:i,flex:a,round:o,align:s}=t,c=e.length,l=xV(a,c),[u,f]=n,d=f-u,h=2/c*r+1-1/c*i,v=d/h,g=v*i/c,y=v-c*g,b=bV(l),x=b.reduce((N,L)=>N+L),_=y/x,w=new DR(e.map((N,L)=>{const R=b[L]*_;return[N,o?Math.floor(R):R]})),O=new DR(e.map((N,L)=>{const I=b[L]*_+g;return[N,o?Math.floor(I):I]})),E=Array.from(O.values()).reduce((N,L)=>N+L),k=(d-(E-E/c*i))*s,A=u+k;let P=o?Math.round(A):A;const C=new Array(c);for(let N=0;N<c;N+=1){C[N]=_V(P);const L=e[N];P+=O.get(L)}return{valueBandWidth:w,valueStep:O,adjustedRange:C}}function OV(t){var e;const{domain:n}=t,r=n.length;if(r===0)return{valueBandWidth:void 0,valueStep:void 0,adjustedRange:[]};if(!!(!((e=t.flex)===null||e===void 0)&&e.length))return wV(t);const{range:a,paddingOuter:o,paddingInner:s,round:c,align:l}=t;let u,f,d=a[0];const v=a[1]-d,g=o*2,y=r-s;u=v/Math.max(1,g+y),c&&(u=Math.floor(u)),d+=(v-u*(r-s))*l,f=u*(1-s),c&&(d=Math.round(d),f=Math.round(f));const b=new Array(r).fill(0).map((x,_)=>d+_*u);return{valueStep:u,valueBandWidth:f,adjustedRange:b}}class pl extends h1{getDefaultOptions(){return{domain:[],range:[0,1],align:.5,round:!1,paddingInner:0,paddingOuter:0,padding:0,unknown:d1,flex:[]}}constructor(e){super(e)}clone(){return new pl(this.options)}getStep(e){return this.valueStep===void 0?1:typeof this.valueStep=="number"?this.valueStep:e===void 0?Array.from(this.valueStep.values())[0]:this.valueStep.get(e)}getBandWidth(e){return this.valueBandWidth===void 0?1:typeof this.valueBandWidth=="number"?this.valueBandWidth:e===void 0?Array.from(this.valueBandWidth.values())[0]:this.valueBandWidth.get(e)}getRange(){return this.adjustedRange}getPaddingInner(){const{padding:e,paddingInner:n}=this.options;return e>0?e:n}getPaddingOuter(){const{padding:e,paddingOuter:n}=this.options;return e>0?e:n}rescale(){super.rescale();const{align:e,domain:n,range:r,round:i,flex:a}=this.options,{adjustedRange:o,valueBandWidth:s,valueStep:c}=OV({align:e,range:r,round:i,flex:a,paddingInner:this.getPaddingInner(),paddingOuter:this.getPaddingOuter(),domain:n});this.valueStep=c,this.valueBandWidth=s,this.adjustedRange=o}}const jR=t=>new pl(t);jR.props={};class p1 extends Lp{getDefaultOptions(){return{domain:[0,1],range:[0,1],tickCount:5,unknown:void 0,tickMethod:Tw}}map(e){return vm(e)?e:this.options.unknown}invert(e){return this.map(e)}clone(){return new p1(this.options)}getTicks(){const{domain:e,tickCount:n,tickMethod:r}=this.options,[i,a]=e;return!Vn(i)||!Vn(a)?[]:r(i,a,n)}}const FR=t=>new p1(t);FR.props={};class VO extends pl{getDefaultOptions(){return{domain:[],range:[0,1],align:.5,round:!1,padding:0,unknown:d1,paddingInner:1,paddingOuter:0}}constructor(e){super(e)}getPaddingInner(){return 1}clone(){return new VO(this.options)}update(e){super.update(e)}getPaddingOuter(){return this.options.padding}}const BR=t=>new VO(t);BR.props={};var zR=/d{1,4}|M{1,4}|YY(?:YY)?|S{1,3}|Do|ZZ|Z|([HhMsDm])\1?|[aA]|"[^"]*"|'[^']*'/g,vl="\\d\\d?",gl="\\d\\d",SV="\\d{3}",EV="\\d{4}",l0="[^\\s]+",WR=/\[([^]*?)\]/gm;function GR(t,e){for(var n=[],r=0,i=t.length;r<i;r++)n.push(t[r].substr(0,e));return n}var $R=function(t){return function(e,n){var r=n[t].map(function(a){return a.toLowerCase()}),i=r.indexOf(e.toLowerCase());return i>-1?i:null}};function Cu(t){for(var e=[],n=1;n<arguments.length;n++)e[n-1]=arguments[n];for(var r=0,i=e;r<i.length;r++){var a=i[r];for(var o in a)t[o]=a[o]}return t}var ZR=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],YR=["January","February","March","April","May","June","July","August","September","October","November","December"],MV=GR(YR,3),kV=GR(ZR,3),HR={dayNamesShort:kV,dayNames:ZR,monthNamesShort:MV,monthNames:YR,amPm:["am","pm"],DoFn:function(t){return t+["th","st","nd","rd"][t%10>3?0:(t-t%10!==10?1:0)*t%10]}},v1=Cu({},HR),AV=function(t){return v1=Cu(v1,t)},VR=function(t){return t.replace(/[|\\{()[^$+*?.-]/g,"\\$&")},Ca=function(t,e){for(e===void 0&&(e=2),t=String(t);t.length<e;)t="0"+t;return t},TV={D:function(t){return String(t.getDate())},DD:function(t){return Ca(t.getDate())},Do:function(t,e){return e.DoFn(t.getDate())},d:function(t){return String(t.getDay())},dd:function(t){return Ca(t.getDay())},ddd:function(t,e){return e.dayNamesShort[t.getDay()]},dddd:function(t,e){return e.dayNames[t.getDay()]},M:function(t){return String(t.getMonth()+1)},MM:function(t){return Ca(t.getMonth()+1)},MMM:function(t,e){return e.monthNamesShort[t.getMonth()]},MMMM:function(t,e){return e.monthNames[t.getMonth()]},YY:function(t){return Ca(String(t.getFullYear()),4).substr(2)},YYYY:function(t){return Ca(t.getFullYear(),4)},h:function(t){return String(t.getHours()%12||12)},hh:function(t){return Ca(t.getHours()%12||12)},H:function(t){return String(t.getHours())},HH:function(t){return Ca(t.getHours())},m:function(t){return String(t.getMinutes())},mm:function(t){return Ca(t.getMinutes())},s:function(t){return String(t.getSeconds())},ss:function(t){return Ca(t.getSeconds())},S:function(t){return String(Math.round(t.getMilliseconds()/100))},SS:function(t){return Ca(Math.round(t.getMilliseconds()/10),2)},SSS:function(t){return Ca(t.getMilliseconds(),3)},a:function(t,e){return t.getHours()<12?e.amPm[0]:e.amPm[1]},A:function(t,e){return t.getHours()<12?e.amPm[0].toUpperCase():e.amPm[1].toUpperCase()},ZZ:function(t){var e=t.getTimezoneOffset();return(e>0?"-":"+")+Ca(Math.floor(Math.abs(e)/60)*100+Math.abs(e)%60,4)},Z:function(t){var e=t.getTimezoneOffset();return(e>0?"-":"+")+Ca(Math.floor(Math.abs(e)/60),2)+":"+Ca(Math.abs(e)%60,2)}},XR=function(t){return+t-1},UR=[null,vl],qR=[null,l0],KR=["isPm",l0,function(t,e){var n=t.toLowerCase();return n===e.amPm[0]?0:n===e.amPm[1]?1:null}],QR=["timezoneOffset","[^\\s]*?[\\+\\-]\\d\\d:?\\d\\d|[^\\s]*?Z?",function(t){var e=(t+"").match(/([+-]|\d\d)/gi);if(e){var n=+e[1]*60+parseInt(e[2],10);return e[0]==="+"?n:-n}return 0}],PV={D:["day",vl],DD:["day",gl],Do:["day",vl+l0,function(t){return parseInt(t,10)}],M:["month",vl,XR],MM:["month",gl,XR],YY:["year",gl,function(t){var e=new Date,n=+(""+e.getFullYear()).substr(0,2);return+(""+(+t>68?n-1:n)+t)}],h:["hour",vl,void 0,"isPm"],hh:["hour",gl,void 0,"isPm"],H:["hour",vl],HH:["hour",gl],m:["minute",vl],mm:["minute",gl],s:["second",vl],ss:["second",gl],YYYY:["year",EV],S:["millisecond","\\d",function(t){return+t*100}],SS:["millisecond",gl,function(t){return+t*10}],SSS:["millisecond",SV],d:UR,dd:UR,ddd:qR,dddd:qR,MMM:["month",l0,$R("monthNamesShort")],MMMM:["month",l0,$R("monthNames")],a:KR,A:KR,ZZ:QR,Z:QR},g1={default:"ddd MMM DD YYYY HH:mm:ss",shortDate:"M/D/YY",mediumDate:"MMM D, YYYY",longDate:"MMMM D, YYYY",fullDate:"dddd, MMMM D, YYYY",isoDate:"YYYY-MM-DD",isoDateTime:"YYYY-MM-DDTHH:mm:ssZ",shortTime:"HH:mm",mediumTime:"HH:mm:ss",longTime:"HH:mm:ss.SSS"},CV=function(t){return Cu(g1,t)},JR=function(t,e,n){if(e===void 0&&(e=g1.default),n===void 0&&(n={}),typeof t=="number"&&(t=new Date(t)),Object.prototype.toString.call(t)!=="[object Date]"||isNaN(t.getTime()))throw new Error("Invalid Date pass to format");e=g1[e]||e;var r=[];e=e.replace(WR,function(a,o){return r.push(o),"@@@"});var i=Cu(Cu({},v1),n);return e=e.replace(zR,function(a){return TV[a](t,i)}),e.replace(/@@@/g,function(){return r.shift()})};function LV(t,e,n){if(n===void 0&&(n={}),typeof e!="string")throw new Error("Invalid format in fecha parse");if(e=g1[e]||e,t.length>1e3)return null;var r=new Date,i={year:r.getFullYear(),month:0,day:1,hour:0,minute:0,second:0,millisecond:0,isPm:null,timezoneOffset:null},a=[],o=[],s=e.replace(WR,function(w,O){return o.push(VR(O)),"@@@"}),c={},l={};s=VR(s).replace(zR,function(w){var O=PV[w],E=O[0],M=O[1],k=O[3];if(c[E])throw new Error("Invalid format. "+E+" specified twice in format");return c[E]=!0,k&&(l[k]=!0),a.push(O),"("+M+")"}),Object.keys(l).forEach(function(w){if(!c[w])throw new Error("Invalid format. "+w+" is required in specified format")}),s=s.replace(/@@@/g,function(){return o.shift()});var u=t.match(new RegExp(s,"i"));if(!u)return null;for(var f=Cu(Cu({},v1),n),d=1;d<u.length;d++){var h=a[d-1],v=h[0],g=h[2],y=g?g(u[d],f):+u[d];if(y==null)return null;i[v]=y}i.isPm===1&&i.hour!=null&&+i.hour!=12?i.hour=+i.hour+12:i.isPm===0&&+i.hour==12&&(i.hour=0);var b;if(i.timezoneOffset==null){b=new Date(i.year,i.month,i.day,i.hour,i.minute,i.second,i.millisecond);for(var x=[["month","getMonth"],["day","getDate"],["hour","getHours"],["minute","getMinutes"],["second","getSeconds"]],d=0,_=x.length;d<_;d++)if(c[x[d][0]]&&i[x[d][0]]!==b[x[d][1]]())return null}else if(b=new Date(Date.UTC(i.year,i.month,i.day,i.hour,i.minute-i.timezoneOffset,i.second,i.millisecond)),i.month>11||i.month<0||i.day>31||i.day<1||i.hour>23||i.hour<0||i.minute>59||i.minute<0||i.second>59||i.second<0)return null;return b}var Lot={format:JR,parse:LV,defaultI18n:HR,setGlobalDateI18n:AV,setGlobalDateMasks:CV},Rot=null;const u0=1e3,f0=u0*60,d0=f0*60,Lu=d0*24,h0=Lu*7,tN=Lu*30,eN=Lu*365;function ra(t,e,n,r){const i=(l,u)=>{const f=h=>r(h)%u===0;let d=u;for(;d&&!f(l);)n(l,-1),d-=1;return l},a=(l,u)=>{u&&i(l,u),e(l)},o=(l,u)=>{const f=new Date(+l);return a(f,u),f},s=(l,u)=>{const f=new Date(+l-1);return a(f,u),n(f,u),a(f),f};return{ceil:s,floor:o,range:(l,u,f,d)=>{const h=[],v=Math.floor(f),g=d?s(l,f):s(l);for(let y=g;y<u;n(y,v),a(y))h.push(new Date(+y));return h},duration:t}}const RV=ra(1,t=>t,(t,e=1)=>{t.setTime(+t+e)},t=>t.getTime()),NV=ra(u0,t=>{t.setMilliseconds(0)},(t,e=1)=>{t.setTime(+t+u0*e)},t=>t.getSeconds()),IV=ra(f0,t=>{t.setSeconds(0,0)},(t,e=1)=>{t.setTime(+t+f0*e)},t=>t.getMinutes()),DV=ra(d0,t=>{t.setMinutes(0,0,0)},(t,e=1)=>{t.setTime(+t+d0*e)},t=>t.getHours()),jV=ra(Lu,t=>{t.setHours(0,0,0,0)},(t,e=1)=>{t.setTime(+t+Lu*e)},t=>t.getDate()-1),nN=ra(tN,t=>{t.setDate(1),t.setHours(0,0,0,0)},(t,e=1)=>{const n=t.getMonth();t.setMonth(n+e)},t=>t.getMonth()),FV=ra(h0,t=>{t.setDate(t.getDate()-t.getDay()%7),t.setHours(0,0,0,0)},(t,e=1)=>{t.setDate(t.getDate()+7*e)},t=>{const e=nN.floor(t),n=new Date(+t);return Math.floor((+n-+e)/h0)}),BV=ra(eN,t=>{t.setMonth(0,1),t.setHours(0,0,0,0)},(t,e=1)=>{const n=t.getFullYear();t.setFullYear(n+e)},t=>t.getFullYear()),rN={millisecond:RV,second:NV,minute:IV,hour:DV,day:jV,week:FV,month:nN,year:BV},zV=ra(1,t=>t,(t,e=1)=>{t.setTime(+t+e)},t=>t.getTime()),WV=ra(u0,t=>{t.setUTCMilliseconds(0)},(t,e=1)=>{t.setTime(+t+u0*e)},t=>t.getUTCSeconds()),GV=ra(f0,t=>{t.setUTCSeconds(0,0)},(t,e=1)=>{t.setTime(+t+f0*e)},t=>t.getUTCMinutes()),$V=ra(d0,t=>{t.setUTCMinutes(0,0,0)},(t,e=1)=>{t.setTime(+t+d0*e)},t=>t.getUTCHours()),ZV=ra(Lu,t=>{t.setUTCHours(0,0,0,0)},(t,e=1)=>{t.setTime(+t+Lu*e)},t=>t.getUTCDate()-1),iN=ra(tN,t=>{t.setUTCDate(1),t.setUTCHours(0,0,0,0)},(t,e=1)=>{const n=t.getUTCMonth();t.setUTCMonth(n+e)},t=>t.getUTCMonth()),YV=ra(h0,t=>{t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7)%7),t.setUTCHours(0,0,0,0)},(t,e=1)=>{t.setTime(+t+h0*e)},t=>{const e=iN.floor(t),n=new Date(+t);return Math.floor((+n-+e)/h0)}),HV=ra(eN,t=>{t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},(t,e=1)=>{const n=t.getUTCFullYear();t.setUTCFullYear(n+e)},t=>t.getUTCFullYear()),aN={millisecond:zV,second:WV,minute:GV,hour:$V,day:ZV,week:YV,month:iN,year:HV};function VV(t){const e=t?aN:rN,{year:n,month:r,week:i,day:a,hour:o,minute:s,second:c,millisecond:l}=e;return{tickIntervals:[[c,1],[c,5],[c,15],[c,30],[s,1],[s,5],[s,15],[s,30],[o,1],[o,3],[o,6],[o,12],[a,1],[a,2],[i,1],[r,1],[r,3],[n,1]],year:n,millisecond:l}}function oN(t,e,n,r,i){const a=+t,o=+e,{tickIntervals:s,year:c,millisecond:l}=VV(i),u=([y,b])=>y.duration*b,f=r?(o-a)/r:n||5,d=r||(o-a)/f,h=s.length,v=_w(s,d,0,h,u);let g;if(v===h){const y=DT(a/c.duration,o/c.duration,f);g=[c,y]}else if(v){const y=d/u(s[v-1])<u(s[v])/d,[b,x]=y?s[v-1]:s[v],_=r?Math.ceil(r/b.duration):x;g=[b,_]}else{const y=Math.max(DT(a,o,f),1);g=[l,y]}return g}const XV=(t,e,n,r,i)=>{const a=t>e,o=a?e:t,s=a?t:e,[c,l]=oN(o,s,n,r,i),u=c.range(o,new Date(+s+1),l,!0);return a?u.reverse():u},UV=(t,e,n,r,i)=>{const a=t>e,o=a?e:t,s=a?t:e,[c,l]=oN(o,s,n,r,i),u=[c.floor(o,l),c.ceil(s,l)];return a?u.reverse():u};function qV(t,e){const{second:n,minute:r,hour:i,day:a,week:o,month:s,year:c}=e;return n.floor(t)<t?".SSS":r.floor(t)<t?":ss":i.floor(t)<t?"hh:mm":a.floor(t)<t?"hh A":s.floor(t)<t?o.floor(t)<t?"MMM DD":"ddd DD":c.floor(t)<t?"MMMM":"YYYY"}function KV(t){const e=t.getTimezoneOffset(),n=new Date(t);return n.setMinutes(n.getMinutes()+e,n.getSeconds(),n.getMilliseconds()),n}class XO extends ym{getDefaultOptions(){return{domain:[new Date(2e3,0,1),new Date(2e3,0,2)],range:[0,1],nice:!1,tickCount:5,tickInterval:void 0,unknown:void 0,clamp:!1,tickMethod:XV,interpolate:nd,mask:void 0,utc:!1}}chooseTransforms(){return[r=>+r,r=>new Date(r)]}chooseNice(){return UV}getTickMethodOptions(){const{domain:e,tickCount:n,tickInterval:r,utc:i}=this.options,a=e[0],o=e[e.length-1];return[a,o,n,r,i]}getFormatter(){const{mask:e,utc:n}=this.options,r=n?aN:rN,i=n?KV:vu;return a=>JR(i(a),e||qV(a,r))}clone(){return new XO(this.options)}}const sN=t=>new XO(t);sN.props={};const cN=t=>e=>-t(-e),UO=(t,e)=>{const n=Math.log(t),r=t===Math.E?Math.log:t===10?Math.log10:t===2?Math.log2:i=>Math.log(i)/n;return e?cN(r):r},qO=(t,e)=>{const n=t===Math.E?Math.exp:r=>ti(t,r);return e?cN(n):n},QV=(t,e,n,r=10)=>{const i=t<0,a=qO(r,i),o=UO(r,i),s=e<t,c=s?e:t,l=s?t:e;let u=o(c),f=o(l),d=[];if(!(r%1)&&f-u<n){if(u=Math.floor(u),f=Math.ceil(f),i)for(;u<=f;u+=1){const h=a(u);for(let v=r-1;v>=1;v-=1){const g=h*v;if(g>l)break;g>=c&&d.push(g)}}else for(;u<=f;u+=1){const h=a(u);for(let v=1;v<r;v+=1){const g=h*v;if(g>l)break;g>=c&&d.push(g)}}d.length*2<n&&(d=gu(c,l,n))}else{const h=n===-1?f-u:Math.min(f-u,n);d=gu(u,f,h).map(a)}return s?d.reverse():d},JV=(t,e,n,r)=>{const i=t<0,a=UO(r,i),o=qO(r,i),s=t>e,c=s?e:t,l=s?t:e,u=[o(Math.floor(a(c))),o(Math.ceil(a(l)))];return s?u.reverse():u};class KO extends ym{getDefaultOptions(){return{domain:[1,10],range:[0,1],base:10,interpolate:Rp,tickMethod:QV,tickCount:5}}chooseNice(){return JV}getTickMethodOptions(){const{domain:e,tickCount:n,base:r}=this.options,i=e[0],a=e[e.length-1];return[i,a,n,r]}chooseTransforms(){const{base:e,domain:n}=this.options,r=n[0]<0;return[UO(e,r),qO(e,r)]}clone(){return new KO(this.options)}}const lN=t=>new KO(t);lN.props={};const tX=t=>e=>e<0?-ti(-e,t):ti(e,t),eX=t=>e=>e<0?-ti(-e,1/t):ti(e,1/t),nX=t=>t<0?-Math.sqrt(-t):Math.sqrt(t);class y1 extends ym{getDefaultOptions(){return{domain:[0,1],range:[0,1],nice:!1,clamp:!1,round:!1,exponent:2,interpolate:Rp,tickMethod:gu,tickCount:5}}constructor(e){super(e)}chooseTransforms(){const{exponent:e}=this.options;if(e===1)return[vu,vu];const n=e===.5?nX:tX(e),r=eX(e);return[n,r]}clone(){return new y1(this.options)}}const uN=t=>new y1(t);uN.props={};class QO extends y1{getDefaultOptions(){return{domain:[0,1],range:[0,1],nice:!1,clamp:!1,round:!1,interpolate:Rp,tickMethod:gu,tickCount:5,exponent:.5}}constructor(e){super(e)}update(e){super.update(e)}clone(){return new QO(this.options)}}const fN=t=>new QO(t);fN.props={};const dN=t=>new rd(t);dN.props={};const hN=t=>new Om(t);hN.props={};const pN=t=>new wm(t);pN.props={};const rX=t=>e=>{const n=t(e);return Vn(n)?Math.round(n):n};function iX(t,e){return n=>{n.prototype.rescale=function(){this.initRange(),this.nice();const[r]=this.chooseTransforms();this.composeOutput(r,this.chooseClamp(r))},n.prototype.initRange=function(){const{interpolator:r}=this.options;this.options.range=t(r)},n.prototype.composeOutput=function(r,i){const{domain:a,interpolator:o,round:s}=this.getOptions(),c=e(a.map(r)),l=s?rX(o):o;this.output=ed(l,c,i,r)},n.prototype.invert=void 0}}var aX=function(t,e,n,r){var i=arguments.length,a=i<3?e:r===null?r=Object.getOwnPropertyDescriptor(e,n):r,o;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")a=Reflect.decorate(t,e,n,r);else for(var s=t.length-1;s>=0;s--)(o=t[s])&&(a=(i<3?o(a):i>3?o(e,n,a):o(e,n))||a);return i>3&&a&&Object.defineProperty(e,n,a),a},JO;function oX(t){return[t(0),t(1)]}const sX=t=>{const[e,n]=t;return ed(nd(0,1),pm(e,n))};let tS=JO=class extends Ji{getDefaultOptions(){return{domain:[0,1],unknown:void 0,nice:!1,clamp:!1,round:!1,interpolator:vu,tickMethod:gu,tickCount:5}}constructor(e){super(e)}clone(){return new JO(this.options)}};tS=JO=aX([iX(oX,sX)],tS);const vN=t=>new tS(t);vN.props={};const gN=t=>new Dp(t);gN.props={};function eS({colorDefault:t,colorBlack:e,colorWhite:n,colorStroke:r,colorBackground:i,padding1:a,padding2:o,padding3:s,alpha90:c,alpha65:l,alpha45:u,alpha25:f,alpha10:d,category10:h,category20:v,sizeDefault:g=1,padding:y="auto",margin:b=16}){return{padding:y,margin:b,size:g,color:t,category10:h,category20:v,enter:{duration:300,fill:"both",delay:0},update:{duration:300,fill:"both",delay:0},exit:{duration:300,fill:"both",delay:0},view:{viewFill:i,plotFill:"transparent",mainFill:"transparent",contentFill:"transparent"},line:{line:{fill:"",strokeOpacity:1,lineWidth:1,lineCap:"round"}},point:{point:{r:3,fillOpacity:.95,lineWidth:0},hollow:{r:3,strokeOpacity:.95,lineWidth:1},plus:{r:3,strokeOpacity:.95,lineWidth:3},diamond:{r:3,strokeOpacity:.95,lineWidth:1}},interval:{rect:{fillOpacity:.95},hollow:{fill:"",strokeOpacity:1,lineWidth:2}},area:{area:{fillOpacity:.85,lineWidth:0}},polygon:{polygon:{fillOpacity:.95}},cell:{cell:{fillOpacity:.95},hollow:{fill:"",strokeOpacity:1,lineWidth:2}},rect:{rect:{fillOpacity:.95},hollow:{fill:"",strokeOpacity:1,lineWidth:2}},link:{link:{fill:"",strokeOpacity:1}},vector:{vector:{fillOpacity:1}},box:{box:{fillOpacity:.95,stroke:e,lineWidth:1}},text:{text:{fill:"#1D2129",fontSize:12,lineWidth:0,connectorStroke:r,connectorStrokeOpacity:.45,connectorLineWidth:1,backgroundFill:r,backgroundFillOpacity:.15,backgroundPadding:[2,4],startMarkerSymbol:"circle",startMarkerSize:4,endMarkerSymbol:"circle",endMarkerSize:4},badge:{fill:"#1D2129",fillOpacity:.65,lineWidth:0,fontSize:10,textAlign:"center",textBaseline:"middle",markerFill:r,markerFillOpacity:.25,markerStrokeOpacity:0}},lineX:{line:{stroke:r,strokeOpacity:.45,lineWidth:1}},lineY:{line:{stroke:r,strokeOpacity:.45,lineWidth:1}},rangeX:{range:{fill:r,fillOpacity:.15,lineWidth:0}},rangeY:{range:{fill:r,fillOpacity:.15,lineWidth:0}},connector:{connector:{stroke:r,strokeOpacity:.45,lineWidth:1,connectLength1:12,endMarker:!0,endMarkerSize:6,endMarkerFill:r,endMarkerFillOpacity:.95}},axis:{arrow:!1,gridLineDash:[3,4],gridLineWidth:.5,gridStroke:e,gridStrokeOpacity:d,labelAlign:"horizontal",labelFill:e,labelOpacity:u,labelFontSize:12,labelFontWeight:"normal",labelSpacing:a,line:!1,lineLineWidth:.5,lineStroke:e,lineStrokeOpacity:u,tickLength:4,tickLineWidth:1,tickStroke:e,tickOpacity:u,titleFill:e,titleOpacity:c,titleFontSize:12,titleFontWeight:"normal",titleSpacing:12,titleTransformOrigin:"center",lineArrowOffset:6,lineArrowSize:6},axisTop:{gridDirection:"positive",labelDirection:"negative",tickDirection:"negative",titlePosition:"top",titleSpacing:12,labelSpacing:4,titleTextBaseline:"middle"},axisBottom:{gridDirection:"negative",labelDirection:"positive",tickDirection:"positive",titlePosition:"bottom",titleSpacing:12,labelSpacing:4,titleTextBaseline:"bottom",titleTransform:"translate(0, 8)"},axisLeft:{gridDirection:"positive",labelDirection:"negative",labelSpacing:4,tickDirection:"negative",titlePosition:"left",titleSpacing:12,titleTextBaseline:"middle",titleDirection:"vertical",titleTransform:"rotate(-90) translate(0, -8)",titleTransformOrigin:"center"},axisRight:{gridDirection:"negative",labelDirection:"positive",labelSpacing:4,tickDirection:"positive",titlePosition:"right",titleSpacing:12,titleTextBaseline:"top",titleDirection:"vertical",titleTransformOrigin:"center"},axisLinear:{girdClosed:!0,gridConnect:"arc",gridDirection:"negative",gridType:"surround",titlePosition:"top",titleSpacing:0},axisArc:{title:!1,titlePosition:"inner",line:!1,tick:!0,labelSpacing:4},axisRadar:{girdClosed:!0,gridStrokeOpacity:.3,gridType:"surround",label:!1,tick:!1,titlePosition:"start"},legendCategory:{backgroundFill:"transparent",itemBackgroundFill:"transparent",itemLabelFill:e,itemLabelFillOpacity:c,itemLabelFontSize:12,itemLabelFontWeight:"normal",itemMarkerFillOpacity:1,itemMarkerSize:8,itemSpacing:[a,a],itemValueFill:e,itemValueFillOpacity:.65,itemValueFontSize:12,itemValueFontWeight:"normal",navButtonFill:e,navButtonFillOpacity:.65,navPageNumFill:e,navPageNumFillOpacity:.45,navPageNumFontSize:12,padding:8,title:!1,titleFill:e,titleFillOpacity:.65,titleFontSize:12,titleFontWeight:"normal",titleSpacing:4,tickStroke:e,tickStrokeOpacity:.25,rowPadding:a,colPadding:o,maxRows:3,maxCols:3},legendContinuous:{handleHeight:12,handleLabelFill:e,handleLabelFillOpacity:u,handleLabelFontSize:12,handleLabelFontWeight:"normal",handleMarkerFill:e,handleMarkerFillOpacity:.6,handleMarkerLineWidth:1,handleMarkerStroke:e,handleMarkerStrokeOpacity:.25,handleWidth:10,labelFill:e,labelFillOpacity:u,labelFontSize:12,labelFontWeight:"normal",labelSpacing:3,tick:!0,tickLength:12,ribbonSize:12,ribbonFill:"#aaa",handle:!0,handleLabel:!1,handleShape:"slider",handleIconSize:12/1.8,indicator:!1,titleFontSize:12,titleSpacing:4,titleFontWeight:"normal",titleFillOpacity:c,tickStroke:e,tickStrokeOpacity:u},label:{fill:e,fillOpacity:.65,fontSize:12,fontWeight:"normal",stroke:void 0,offset:12,connectorStroke:e,connectorStrokeOpacity:.45,connectorLineWidth:1,connectorLength:12,connectorLength2:8,connectorDistance:4},innerLabel:{fill:n,fontSize:12,fillOpacity:.85,fontWeight:"normal",stroke:void 0,offset:0},htmlLabel:{fontSize:12,opacity:.65,color:e,fontWeight:"normal"},slider:{trackSize:16,trackFill:r,trackFillOpacity:1,selectionFill:t,selectionFillOpacity:.15,handleIconSize:10,handleIconFill:"#f7f7f7",handleIconFillOpacity:1,handleIconStroke:e,handleIconStrokeOpacity:.25,handleIconLineWidth:1,handleIconRadius:2,handleLabelFill:e,handleLabelFillOpacity:.45,handleLabelFontSize:12,handleLabelFontWeight:"normal"},scrollbar:{padding:[0,0,0,0],trackSize:6,isRound:!0,slidable:!0,scrollable:!0,trackFill:"#e5e5e5",trackFillOpacity:0,thumbFill:"#000",thumbFillOpacity:.15,thumbHighlightedFillOpacity:.2},title:{spacing:8,titleFill:e,titleFillOpacity:c,titleFontSize:16,titleFontWeight:"bold",titleTextBaseline:"top",subtitleFill:e,subtitleFillOpacity:l,subtitleFontSize:12,subtitleFontWeight:"normal",subtitleTextBaseline:"top"},tooltip:{css:{".g2-tooltip":{"font-family":"sans-serif"}}}}}const cX=eS({colorBlack:"#1D2129",colorWhite:"#ffffff",colorStroke:"#416180",colorDefault:"#1783FF",colorBackground:"transparent",category10:["#1783FF","#00C9C9","#F0884D","#D580FF","#7863FF","#60C42D","#BD8F24","#FF80CA","#2491B3","#17C76F"],category20:["#1783FF","#00C9C9","#F0884D","#D580FF","#7863FF","#60C42D","#BD8F24","#FF80CA","#2491B3","#17C76F","#AABA01","#BC7CFC","#237CBC","#2DE379","#CE8032","#FF7AF4","#545FD3","#AFE410","#D8C608","#FFA1E0"],padding1:8,padding2:12,padding3:20,alpha90:.9,alpha65:.65,alpha45:.45,alpha25:.25,alpha10:.1}),nS=t=>mt({},cX,t);nS.props={};const yN=t=>mt({},nS(),{category10:"category10",category20:"category20"},t);yN.props={};const lX=eS({colorBlack:"#fff",colorWhite:"#000",colorStroke:"#416180",colorDefault:"#1783FF",colorBackground:"transparent",category10:["#1783FF","#00C9C9","#F0884D","#D580FF","#7863FF","#60C42D","#BD8F24","#FF80CA","#2491B3","#17C76F"],category20:["#1783FF","#00C9C9","#F0884D","#D580FF","#7863FF","#60C42D","#BD8F24","#FF80CA","#2491B3","#17C76F","#AABA01","#BC7CFC","#237CBC","#2DE379","#CE8032","#FF7AF4","#545FD3","#AFE410","#D8C608","#FFA1E0"],padding1:8,padding2:12,padding3:20,alpha90:.9,alpha65:.65,alpha45:.45,alpha25:.25,alpha10:.25}),mN=t=>mt({},lX,{tooltip:{crosshairsStroke:"#fff",crosshairsLineWidth:1,crosshairsStrokeOpacity:.25,css:{".g2-tooltip":{background:"#1f1f1f",opacity:.95},".g2-tooltip-title":{color:"#A6A6A6"},".g2-tooltip-list-item-name-label":{color:"#A6A6A6"},".g2-tooltip-list-item-value":{color:"#A6A6A6"}}}},t),bN=t=>Object.assign({},mN(),{category10:"category10",category20:"category20"},t);bN.props={};const uX=eS({colorBlack:"#000",colorWhite:"#fff",colorStroke:"#888",colorDefault:"#4e79a7",colorBackground:"transparent",category10:["#4e79a7","#f28e2c","#e15759","#76b7b2","#59a14f","#edc949","#af7aa1","#ff9da7","#9c755f","#bab0ab"],category20:["#4e79a7","#f28e2c","#e15759","#76b7b2","#59a14f","#edc949","#af7aa1","#ff9da7","#9c755f","#bab0ab"],padding1:8,padding2:12,padding3:20,alpha90:.9,alpha65:.65,alpha45:.45,alpha25:.25,alpha10:.1}),xN=t=>mt({},uX,{text:{text:{fontSize:10}},axis:{gridLineDash:[0,0],gridLineWidth:1,gridStroke:"#ddd",gridStrokeOpacity:1,labelOpacity:1,labelStrokeOpacity:1,labelFontSize:10,line:!0,lineLineWidth:1,lineStroke:"#888",lineStrokeOpacity:1,tickLength:5,tickStrokeOpacity:1,titleOpacity:1,titleStrokeOpacity:1,titleFillOpacity:1,titleFontSize:11,titleFontWeight:"bold"},axisLeft:{gridFilter:(e,n)=>n!==0},axisRight:{gridFilter:(e,n)=>n!==0},legendCategory:{itemLabelFillOpacity:1,itemLabelFontSize:10,itemValueFillOpacity:1,itemValueFontSize:10,titleFillOpacity:1,titleFontSize:11,titleFontWeight:"bold"},legendContinuous:{handleLabelFontSize:10,labelFillOpacity:.45,labelFontSize:10},label:{fontSize:10},innerLabel:{fontSize:10},htmlLabel:{fontSize:10},slider:{handleLabelFontSize:10,trackFillOpacity:.05}},t);xN.props={};const _N=t=>(...e)=>{const n=rl(Object.assign({},{crossPadding:50},t))(...e);return HT(n,t),n};_N.props=Object.assign(Object.assign({},rl.props),{defaultPosition:"bottom"});function jot(){}const wN=t=>(...e)=>{const n=rl(Object.assign({},{crossPadding:10},t))(...e);return HT(n,t),n};wN.props=Object.assign(Object.assign({},rl.props),{defaultPosition:"left"});var rS=function(){},fX=function(t,e,n){var r=t,i=ir(e)?e.split("."):e;return i.forEach(function(a,o){o<i.length-1?(zl(r[a])||(r[a]=Vn(i[o+1])?[]:{}),r=r[a]):r[a]=n}),t};function dX(t,e){return t.reduce(function(n,r){return(n[r[e]]=n[r[e]]||[]).push(r),n},{})}function hX(t){var e;return((e=t[0])===null||e===void 0?void 0:e.map(function(n,r){return t.map(function(i){return i[r]})}))||[]}var Eo=xo({prevBtnGroup:"prev-btn-group",prevBtn:"prev-btn",nextBtnGroup:"next-btn-group",nextBtn:"next-btn",pageInfoGroup:"page-info-group",pageInfo:"page-info",playWindow:"play-window",contentGroup:"content-group",controller:"controller",clipPath:"clip-path"},"navigator"),pX=function(t){ar(e,t);function e(n){var r=t.call(this,n,{x:0,y:0,animate:{easing:"linear",duration:200,fill:"both"},buttonCursor:"pointer",buttonFill:"black",buttonD:C7(0,0,6),buttonSize:12,controllerPadding:5,controllerSpacing:5,formatter:function(i,a){return"".concat(i,"/").concat(a)},defaultPage:0,loop:!1,orientation:"horizontal",pageNumFill:"black",pageNumFontSize:12,pageNumTextAlign:"start",pageNumTextBaseline:"middle"})||this;return r.playState="idle",r.contentGroup=r.appendChild(new ui({class:Eo.contentGroup.name})),r.playWindow=r.contentGroup.appendChild(new ui({class:Eo.playWindow.name})),r.innerCurrPage=r.defaultPage,r}return Object.defineProperty(e.prototype,"defaultPage",{get:function(){var n=this.attributes.defaultPage;return mn(n,0,Math.max(this.pageViews.length-1,0))},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"pageViews",{get:function(){return this.playWindow.children},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"controllerShape",{get:function(){return this.totalPages>1?{width:55,height:0}:{width:0,height:0}},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"pageShape",{get:function(){var n=this.pageViews,r=V(hX(n.map(function(f){var d=f.getBBox(),h=d.width,v=d.height;return[h,v]})).map(function(f){return Math.max.apply(Math,te([],V(f),!1))}),2),i=r[0],a=r[1],o=this.attributes,s=o.pageWidth,c=s===void 0?i:s,l=o.pageHeight,u=l===void 0?a:l;return{pageWidth:c,pageHeight:u}},enumerable:!1,configurable:!0}),e.prototype.getContainer=function(){return this.playWindow},Object.defineProperty(e.prototype,"totalPages",{get:function(){return this.pageViews.length},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"currPage",{get:function(){return this.innerCurrPage},enumerable:!1,configurable:!0}),e.prototype.getBBox=function(){var n=t.prototype.getBBox.call(this),r=n.x,i=n.y,a=this.controllerShape,o=this.pageShape,s=o.pageWidth,c=o.pageHeight;return new pr(r,i,s+a.width,c)},e.prototype.goTo=function(n){var r=this,i=this.attributes.animate,a=this,o=a.currPage,s=a.playState,c=a.playWindow,l=a.pageViews;if(s!=="idle"||n<0||l.length<=0||n>=l.length)return null;l[o].setLocalPosition(0,0),this.prepareFollowingPage(n);var u=V(this.getFollowingPageDiff(n),2),f=u[0],d=u[1];this.playState="running";var h=QA(c,[{transform:"translate(0, 0)"},{transform:"translate(".concat(-f,", ").concat(-d,")")}],i);return Qf(h,function(){r.innerCurrPage=n,r.playState="idle",r.setVisiblePages([n]),r.updatePageInfo()}),h},e.prototype.prev=function(){var n=this.attributes.loop,r=this.pageViews.length,i=this.currPage;if(!n&&i<=0)return null;var a=n?(i-1+r)%r:mn(i-1,0,r);return this.goTo(a)},e.prototype.next=function(){var n=this.attributes.loop,r=this.pageViews.length,i=this.currPage;if(!n&&i>=r-1)return null;var a=n?(i+1)%r:mn(i+1,0,r);return this.goTo(a)},e.prototype.renderClipPath=function(n){var r=this.pageShape,i=r.pageWidth,a=r.pageHeight;if(!i||!a){this.contentGroup.style.clipPath=void 0;return}this.clipPath=n.maybeAppendByClassName(Eo.clipPath,"rect").styles({width:i,height:a}),this.contentGroup.attr("clipPath",this.clipPath.node())},e.prototype.setVisiblePages=function(n){this.playWindow.children.forEach(function(r,i){n.includes(i)?Mp(r):nl(r)})},e.prototype.adjustControllerLayout=function(){var n=this,r=n.prevBtnGroup,i=n.nextBtnGroup,a=n.pageInfoGroup,o=this.attributes,s=o.orientation,c=o.controllerPadding,l=a.getBBox(),u=l.width,f=l.height,d=V(s==="horizontal"?[-180,0]:[-90,90],2),h=d[0],v=d[1];r.setLocalEulerAngles(h),i.setLocalEulerAngles(v);var g=r.getBBox(),y=g.width,b=g.height,x=i.getBBox(),_=x.width,w=x.height,O=Math.max(y,u,_),E=s==="horizontal"?{offset:[[0,0],[y/2+c,0],[y+u+c*2,0]],textAlign:"start"}:{offset:[[O/2,-b-c],[O/2,0],[O/2,w+c]],textAlign:"center"},M=V(E.offset,3),k=V(M[0],2),A=k[0],P=k[1],C=V(M[1],2),N=C[0],L=C[1],R=V(M[2],2),I=R[0],D=R[1],G=E.textAlign,F=a.querySelector("text");F&&(F.style.textAlign=G),r.setLocalPosition(A,P),a.setLocalPosition(N,L),i.setLocalPosition(I,D)},e.prototype.updatePageInfo=function(){var n,r=this,i=r.currPage,a=r.pageViews,o=r.attributes.formatter;a.length<2||((n=this.pageInfoGroup.querySelector(Eo.pageInfo.class))===null||n===void 0||n.attr("text",o(i+1,a.length)),this.adjustControllerLayout())},e.prototype.getFollowingPageDiff=function(n){var r=this.currPage;if(r===n)return[0,0];var i=this.attributes.orientation,a=this.pageShape,o=a.pageWidth,s=a.pageHeight,c=n<r?-1:1;return i==="horizontal"?[c*o,0]:[0,c*s]},e.prototype.prepareFollowingPage=function(n){var r=this,i=r.currPage,a=r.pageViews;if(this.setVisiblePages([n,i]),n!==i){var o=V(this.getFollowingPageDiff(n),2),s=o[0],c=o[1];a[n].setLocalPosition(s,c)}},e.prototype.renderController=function(n){var r=this,i=this.attributes.controllerSpacing,a=this.pageShape,o=a.pageWidth,s=a.pageHeight,c=this.pageViews.length>=2,l=n.maybeAppendByClassName(Eo.controller,"g");if(am(l.node(),c),!!c){var u=en(this.attributes,"button"),f=en(this.attributes,"pageNum"),d=V(oc(u),2),h=d[0],v=d[1],g=h.size,y=$r(h,["size"]),b=!l.select(Eo.prevBtnGroup.class).node(),x=l.maybeAppendByClassName(Eo.prevBtnGroup,"g").styles(v);this.prevBtnGroup=x.node();var _=x.maybeAppendByClassName(Eo.prevBtn,"path"),w=l.maybeAppendByClassName(Eo.nextBtnGroup,"g").styles(v);this.nextBtnGroup=w.node();var O=w.maybeAppendByClassName(Eo.nextBtn,"path");[_,O].forEach(function(M){M.styles(At(At({},y),{transformOrigin:"center"})),fw(M.node(),g,!0)});var E=l.maybeAppendByClassName(Eo.pageInfoGroup,"g");this.pageInfoGroup=E.node(),E.maybeAppendByClassName(Eo.pageInfo,"text").styles(f),this.updatePageInfo(),l.node().setLocalPosition(o+i,s/2),b&&(this.prevBtnGroup.addEventListener("click",function(){r.prev()}),this.nextBtnGroup.addEventListener("click",function(){r.next()}))}},e.prototype.render=function(n,r){var i=n.x,a=i===void 0?0:i,o=n.y,s=o===void 0?0:o;this.attr("transform","translate(".concat(a,", ").concat(s,")"));var c=Fe(r);this.renderClipPath(c),this.renderController(c),this.setVisiblePages([this.defaultPage]),this.goTo(this.defaultPage)},e.prototype.bindEvents=function(){var n=this,r=_A(function(){return n.render(n.attributes,n)},50);this.playWindow.addEventListener($e.INSERTED,r),this.playWindow.addEventListener($e.REMOVED,r)},e}(bi),Ya=xo({layout:"flex",markerGroup:"marker-group",marker:"marker",labelGroup:"label-group",label:"label",valueGroup:"value-group",value:"value",backgroundGroup:"background-group",background:"background"},"legend-category-item");function vX(t){var e=t.querySelector(Ya.marker.class);return e?e.style:{}}var gX=function(t){ar(e,t);function e(n){return t.call(this,n,{span:[1,1],marker:function(){return new tc({style:{r:6}})},markerSize:10,labelFill:"#646464",valueFill:"#646464",labelFontSize:12,valueFontSize:12,labelTextBaseline:"middle",valueTextBaseline:"middle"})||this}return Object.defineProperty(e.prototype,"showValue",{get:function(){var n=this.attributes.valueText;return n?typeof n=="string"||typeof n=="number"?n!=="":typeof n=="function"?!0:n.attr("text")!=="":!1},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"actualSpace",{get:function(){var n=this.labelGroup,r=this.valueGroup,i=this.attributes.markerSize,a=n.node().getBBox(),o=a.width,s=a.height,c=r.node().getBBox(),l=c.width,u=c.height;return{markerWidth:i,labelWidth:o,valueWidth:l,height:Math.max(i,s,u)}},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"span",{get:function(){var n=this.attributes.span;if(!n)return[1,1];var r=V(Ni(n),2),i=r[0],a=r[1],o=this.showValue?a:0,s=i+o;return[i/s,o/s]},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"shape",{get:function(){var n,r=this.attributes,i=r.markerSize,a=r.width,o=this.actualSpace,s=o.markerWidth,c=o.height,l=this.actualSpace,u=l.labelWidth,f=l.valueWidth,d=V(this.spacing,2),h=d[0],v=d[1];if(a){var g=a-i-h-v,y=V(this.span,2),b=y[0],x=y[1];n=V([b*g,x*g],2),u=n[0],f=n[1]}var _=s+u+f+h+v;return{width:_,height:c,markerWidth:s,labelWidth:u,valueWidth:f}},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"spacing",{get:function(){var n=this.attributes.spacing;if(!n)return[0,0];var r=V(Ni(n),2),i=r[0],a=r[1];return this.showValue?[i,a]:[i,0]},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"layout",{get:function(){var n=this.shape,r=n.markerWidth,i=n.labelWidth,a=n.valueWidth,o=n.width,s=n.height,c=V(this.spacing,2),l=c[0],u=c[1];return{height:s,width:o,markerWidth:r,labelWidth:i,valueWidth:a,position:[r/2,r+l,r+i+l+u]}},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"scaleSize",{get:function(){var n=vX(this.markerGroup.node()),r=this.attributes,i=r.markerSize,a=r.markerStrokeWidth,o=a===void 0?n.strokeWidth:a,s=r.markerLineWidth,c=s===void 0?n.lineWidth:s,l=r.markerStroke,u=l===void 0?n.stroke:l,f=+(o||c||(u?1:0))*Math.sqrt(2),d=this.markerGroup.node().getBBox(),h=d.width,v=d.height;return(1-f/Math.max(h,v))*i},enumerable:!1,configurable:!0}),e.prototype.renderMarker=function(n){var r=this,i=this.attributes.marker,a=en(this.attributes,"marker");this.markerGroup=n.maybeAppendByClassName(Ya.markerGroup,"g").style("zIndex",0),Pa(!!i,this.markerGroup,function(){var o,s=r.markerGroup.node(),c=(o=s.childNodes)===null||o===void 0?void 0:o[0],l=typeof i=="string"?new An({style:{symbol:i},className:Ya.marker.name}):i();c?l.nodeName===c.nodeName?c instanceof An?c.update(At(At({},a),{symbol:i})):(eB(c,l),Fe(c).styles(a)):(c.remove(),Fe(l).attr("className",Ya.marker.name).styles(a),s.appendChild(l)):(l instanceof An||Fe(l).attr("className",Ya.marker.name).styles(a),s.appendChild(l)),r.markerGroup.node().scale(1/r.markerGroup.node().getScale()[0]);var u=fw(r.markerGroup.node(),r.scaleSize,!0);r.markerGroup.node().style._transform="scale(".concat(u,")")})},e.prototype.renderLabel=function(n){var r=en(this.attributes,"label"),i=r.text,a=$r(r,["text"]);this.labelGroup=n.maybeAppendByClassName(Ya.labelGroup,"g").style("zIndex",0),this.labelGroup.maybeAppendByClassName(Ya.label,function(){return pu(i)}).styles(a)},e.prototype.renderValue=function(n){var r=this,i=en(this.attributes,"value"),a=i.text,o=$r(i,["text"]);this.valueGroup=n.maybeAppendByClassName(Ya.valueGroup,"g").style("zIndex",0),Pa(this.showValue,this.valueGroup,function(){r.valueGroup.maybeAppendByClassName(Ya.value,function(){return pu(a)}).styles(o)})},e.prototype.renderBackground=function(n){var r=this.shape,i=r.width,a=r.height,o=en(this.attributes,"background");this.background=n.maybeAppendByClassName(Ya.backgroundGroup,"g").style("zIndex",-1),this.background.maybeAppendByClassName(Ya.background,"rect").styles(At({width:i,height:a},o))},e.prototype.adjustLayout=function(){var n=this.layout,r=n.labelWidth,i=n.valueWidth,a=n.height,o=V(n.position,3),s=o[0],c=o[1],l=o[2],u=a/2;this.markerGroup.styles({transform:"translate(".concat(s,", ").concat(u,")").concat(this.markerGroup.node().style._transform)}),this.labelGroup.styles({transform:"translate(".concat(c,", ").concat(u,")")}),gw(this.labelGroup.select(Ya.label.class).node(),Math.ceil(r)),this.showValue&&(this.valueGroup.styles({transform:"translate(".concat(l,", ").concat(u,")")}),gw(this.valueGroup.select(Ya.value.class).node(),Math.ceil(i)))},e.prototype.render=function(n,r){var i=Fe(r),a=n.x,o=a===void 0?0:a,s=n.y,c=s===void 0?0:s;i.styles({transform:"translate(".concat(o,", ").concat(c,")")}),this.renderMarker(i),this.renderLabel(i),this.renderValue(i),this.renderBackground(i),this.adjustLayout()},e}(bi),Ru=xo({page:"item-page",navigator:"navigator",item:"item"},"items"),ON=function(t,e,n){return n===void 0&&(n=!0),t?e(t):n},yX=function(t){ar(e,t);function e(n){var r=t.call(this,n,{data:[],gridRow:1/0,gridCol:void 0,padding:0,width:1e3,height:100,rowPadding:0,colPadding:0,layout:"flex",orientation:"horizontal",click:rS,mouseenter:rS,mouseleave:rS})||this;return r.navigatorShape=[0,0],r}return Object.defineProperty(e.prototype,"pageViews",{get:function(){return this.navigator.getContainer()},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"grid",{get:function(){var n=this.attributes,r=n.gridRow,i=n.gridCol,a=n.data;if(!r&&!i)throw new Error("gridRow and gridCol can not be set null at the same time");return r&&i?[r,i]:r?[r,a.length]:[a.length,i]},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"renderData",{get:function(){var n=this.attributes,r=n.data,i=n.layout,a=en(this.attributes,"item"),o=r.map(function(s,c){var l=s.id,u=l===void 0?c:l,f=s.label,d=s.value;return{id:"".concat(u),index:c,style:At({layout:i,labelText:f,valueText:d},Object.fromEntries(Object.entries(a).map(function(h){var v=V(h,2),g=v[0],y=v[1];return[g,_o(y,[s,c,r])]})))}});return o},enumerable:!1,configurable:!0}),e.prototype.getGridLayout=function(){var n=this,r=this.attributes,i=r.orientation,a=r.width,o=r.rowPadding,s=r.colPadding,c=V(this.navigatorShape,1),l=c[0],u=V(this.grid,2),f=u[0],d=u[1],h=d*f,v=0;return this.pageViews.children.map(function(g,y){var b,x,_=Math.floor(y/h),w=y%h,O=n.ifHorizontal(d,f),E=[Math.floor(w/O),w%O];i==="vertical"&&E.reverse();var M=V(E,2),k=M[0],A=M[1],P=(a-l-(d-1)*s)/d,C=g.getBBox().height,N=V([0,0],2),L=N[0],R=N[1];return i==="horizontal"?(b=V([v,k*(C+o)],2),L=b[0],R=b[1],v=A===d-1?0:v+P+s):(x=V([A*(P+s),v],2),L=x[0],R=x[1],v=k===f-1?0:v+C+o),{page:_,index:y,row:k,col:A,pageIndex:w,width:P,height:C,x:L,y:R}})},e.prototype.getFlexLayout=function(){var n=this.attributes,r=n.width,i=n.height,a=n.rowPadding,o=n.colPadding,s=V(this.navigatorShape,1),c=s[0],l=V(this.grid,2),u=l[0],f=l[1],d=V([r-c,i],2),h=d[0],v=d[1],g=V([0,0,0,0,0,0,0,0],8),y=g[0],b=g[1],x=g[2],_=g[3],w=g[4],O=g[5],E=g[6],M=g[7];return this.pageViews.children.map(function(k,A){var P,C,N,L,R=k.getBBox(),I=R.width,D=R.height,G=E===0?0:o,F=E+G+I;if(F<=h&&ON(w,function(X){return X<f}))return P=V([E+G,M,F],3),y=P[0],b=P[1],E=P[2],{width:I,height:D,x:y,y:b,page:x,index:A,pageIndex:_++,row:O,col:w++};C=V([O+1,0,0,M+D+a],4),O=C[0],w=C[1],E=C[2],M=C[3];var W=M+D;return W<=v&&ON(O,function(X){return X<u})?(N=V([E,M,I],3),y=N[0],b=N[1],E=N[2],{width:I,height:D,x:y,y:b,page:x,index:A,pageIndex:_++,row:O,col:w++}):(L=V([0,0,I,0,x+1,0,0,0],8),y=L[0],b=L[1],E=L[2],M=L[3],x=L[4],_=L[5],O=L[6],w=L[7],{width:I,height:D,x:y,y:b,page:x,index:A,pageIndex:_++,row:O,col:w++})})},Object.defineProperty(e.prototype,"itemsLayout",{get:function(){this.navigatorShape=[0,0];var n=this.attributes.layout==="grid"?this.getGridLayout:this.getFlexLayout,r=n.call(this);return r.slice(-1)[0].page>0?(this.navigatorShape=[55,0],n.call(this)):r},enumerable:!1,configurable:!0}),e.prototype.ifHorizontal=function(n,r){var i=this.attributes.orientation;return vs(i,n,r)},e.prototype.flattenPage=function(n){n.querySelectorAll(Ru.item.class).forEach(function(r){n.appendChild(r)}),n.querySelectorAll(Ru.page.class).forEach(function(r){var i=n.removeChild(r);i.destroy()})},e.prototype.renderItems=function(n){var r=this.attributes,i=r.click,a=r.mouseenter,o=r.mouseleave;this.flattenPage(n);var s=this.dispatchCustomEvent.bind(this);Fe(n).selectAll(Ru.item.class).data(this.renderData,function(c){return c.id}).join(function(c){return c.append(function(l){var u=l.style;return new gX({style:u})}).attr("className",Ru.item.name).on("click",function(){i==null||i(this),s("itemClick",{item:this})}).on("pointerenter",function(){a==null||a(this),s("itemMouseenter",{item:this})}).on("pointerleave",function(){o==null||o(this),s("itemMouseleave",{item:this})})},function(c){return c.each(function(l){var u=l.style;this.update(u)})},function(c){return c.remove()})},e.prototype.relayoutNavigator=function(){var n,r=this.attributes,i=r.layout,a=r.width,o=((n=this.pageViews.children[0])===null||n===void 0?void 0:n.getBBox().height)||0,s=V(this.navigatorShape,2),c=s[0],l=s[1];this.navigator.update(i==="grid"?{pageWidth:a-c,pageHeight:o-l}:{})},e.prototype.adjustLayout=function(){var n=this,r=Object.entries(dX(this.itemsLayout,"page")).map(function(a){var o=V(a,2),s=o[0],c=o[1];return{page:s,layouts:c}}),i=te([],V(this.navigator.getContainer().children),!1);r.forEach(function(a){var o=a.layouts,s=n.pageViews.appendChild(new ui({className:Ru.page.name}));o.forEach(function(c){var l=c.x,u=c.y,f=c.index,d=c.width,h=c.height,v=i[f];s.appendChild(v),fX(v,"__layout__",c),v.update({x:l,y:u,width:d,height:h})})}),this.relayoutNavigator()},e.prototype.renderNavigator=function(n){var r=this.attributes.orientation,i=en(this.attributes,"nav"),a=ic({orientation:r},i),o=this;return n.selectAll(Ru.navigator.class).data(["nav"]).join(function(s){return s.append(function(){return new pX({style:a})}).attr("className",Ru.navigator.name).each(function(){o.navigator=this})},function(s){return s.each(function(){this.update(a)})},function(s){return s.remove()}),this.navigator},e.prototype.getBBox=function(){return this.navigator.getBBox()},e.prototype.render=function(n,r){var i=this.attributes.data;if(!(!i||i.length===0)){var a=this.renderNavigator(Fe(r));this.renderItems(a.getContainer()),this.adjustLayout()}},e.prototype.dispatchCustomEvent=function(n,r){var i=new Nn(n,{detail:r});this.dispatchEvent(i)},e}(bi),mX=function(t){ar(e,t);function e(n){return t.call(this,n,z7)||this}return e.prototype.renderTitle=function(n,r,i){var a=this.attributes,o=a.showTitle,s=a.titleText,c=en(this.attributes,"title"),l=V(oc(c),2),u=l[0],f=l[1];this.titleGroup=n.maybeAppendByClassName(Ii.titleGroup,"g").styles(f);var d=At(At({width:r,height:i},u),{text:o?s:""});this.title=this.titleGroup.maybeAppendByClassName(Ii.title,function(){return new LT({style:d})}).update(d)},e.prototype.renderItems=function(n,r){var i=r.x,a=r.y,o=r.width,s=r.height,c=en(this.attributes,"title",!0),l=V(oc(c),2),u=l[0],f=l[1],d=At(At({},u),{width:o,height:s,x:0,y:0});this.itemsGroup=n.maybeAppendByClassName(Ii.itemsGroup,"g").styles(At(At({},f),{transform:"translate(".concat(i,", ").concat(a,")")}));var h=this;this.itemsGroup.selectAll(Ii.items.class).data(["items"]).join(function(v){return v.append(function(){return new yX({style:d})}).attr("className",Ii.items.name).each(function(){h.items=Fe(this)})},function(v){return v.update(d)},function(v){return v.remove()})},e.prototype.adjustLayout=function(){var n=this.attributes.showTitle;if(n){var r=this.title.node().getAvailableSpace(),i=r.x,a=r.y;this.itemsGroup.node().style.transform="translate(".concat(i,", ").concat(a,")")}},Object.defineProperty(e.prototype,"availableSpace",{get:function(){var n=this.attributes,r=n.showTitle,i=n.width,a=n.height;return r?this.title.node().getAvailableSpace():new pr(0,0,i,a)},enumerable:!1,configurable:!0}),e.prototype.getBBox=function(){var n,r,i=(n=this.title)===null||n===void 0?void 0:n.node(),a=(r=this.items)===null||r===void 0?void 0:r.node();return!i||!a?t.prototype.getBBox.call(this):wB(i,a)},e.prototype.render=function(n,r){var i=this.attributes,a=i.width,o=i.height,s=i.x,c=s===void 0?0:s,l=i.y,u=l===void 0?0:l,f=Fe(r);r.style.transform="translate(".concat(c,", ").concat(u,")"),this.renderTitle(f,a,o),this.renderItems(f,this.availableSpace),this.adjustLayout()},e}(bi);function p0(t){if(qf(t)){var e=t;return e[e.length-1]}}var bX=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function xX(t,e){const n=hs(t,"shape"),r=hs(t,"color"),i=n?n.clone():null,a=[];for(const[s,c]of e){const l=s.type,f=((r==null?void 0:r.getOptions().domain.length)>0?r==null?void 0:r.getOptions().domain:c.data).map((d,h)=>{var v;return i?i.map(d||"point"):((v=s==null?void 0:s.style)===null||v===void 0?void 0:v.shape)||c.defaultShape||"point"});typeof l=="string"&&a.push([l,f])}if(a.length===0)return["point",["point"]];if(a.length===1||!n)return a[0];const{range:o}=n.getOptions();return a.map(([s,c])=>{let l=0;for(let u=0;u<a.length;u++){const f=o[u%o.length];c[u]===f&&l++}return[l/c.length,[s,c]]}).sort((s,c)=>c[0]-s[0])[0][1]}function _X(t,e){const{scales:n,library:r,markState:i}=e,[a,o]=xX(n,i),{itemMarker:s,itemMarkerSize:c}=t,l=(d,h)=>{var v,g,y;const b=((y=(g=(v=r[`mark.${a}`])===null||v===void 0?void 0:v.props)===null||g===void 0?void 0:g.shape[d])===null||y===void 0?void 0:y.props.defaultMarker)||p0(d.split(".")),x=typeof c=="function"?c(h):c;return()=>Cj(b,{color:h.color})(0,0,x)},u=d=>`${o[d]}`;return hs(n,"shape")&&!s?(d,h)=>l(u(h),d):typeof s=="function"?(d,h)=>{const v=s(d.id,h);return typeof v=="string"?l(v,d):v}:(d,h)=>l(s||u(h),d)}function wX(t){const e=hs(t,"opacity");if(e){const{range:n}=e.getOptions();return(r,i)=>n[i]}}function OX(t,e){const n=hs(t,"size");return n instanceof p1?n.map(NaN)*2:e}function SX(t,e){const{labelFormatter:n=d=>`${d}`}=t,{scales:r,theme:i}=e,a=i.legendCategory.itemMarkerSize,o=OX(r,a),s={itemMarker:_X(Object.assign(Object.assign({},t),{itemMarkerSize:o}),e),itemMarkerSize:o,itemMarkerOpacity:wX(r)},c=typeof n=="string"?el(n):n,l=hs(r,"color"),u=XB(r),f=l?d=>l.map(d):()=>e.theme.color;return Object.assign(Object.assign({},s),{data:u.map(d=>({id:d,label:c(d),color:f(d)}))})}function EX(t,e,n){const{position:r}=e;if(r==="center"){const{bbox:o}=t,{width:s,height:c}=o;return{width:s,height:c}}const{width:i,height:a}=ZT(t,e,n);return{width:i,height:a}}const iS=t=>{const{labelFormatter:e,layout:n,order:r,orientation:i,position:a,size:o,title:s,cols:c,itemMarker:l}=t,u=bX(t,["labelFormatter","layout","order","orientation","position","size","title","cols","itemMarker"]),{gridRow:f}=u;return d=>{const{value:h,theme:v}=d,{bbox:g}=h,{width:y,height:b}=EX(h,t,iS),x=GT(a,n),_=Object.assign(Object.assign(Object.assign(Object.assign({orientation:["right","left","center"].includes(a)?"vertical":"horizontal",width:y,height:b,layout:c!==void 0?"grid":"flex"},c!==void 0&&{gridCol:c}),f!==void 0&&{gridRow:f}),{titleText:mm(s)}),SX(t,d)),{legendCategory:w={}}=v,O=bm(Object.assign({},w,_,u)),E=new YB({style:Object.assign(Object.assign({x:g.x,y:g.y,width:g.width,height:g.height},x),{subOptions:O})});return E.appendChild(new mX({className:"legend-category",style:O})),E}};iS.props={defaultPosition:"top",defaultOrder:1,defaultSize:40,defaultCrossPadding:[12,12],defaultPadding:[12,12]};const SN=t=>()=>new ui;SN.props={};var MX=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function EN(t,e,n,r){switch(r){case"center":return{x:t+n/2,y:e,textAlign:"middle"};case"right":return{x:t+n,y:e,textAlign:"right"};default:return{x:t,y:e,textAlign:"left"}}}const kX=ZB({render(t,e){const{width:n,title:r,subtitle:i,spacing:a=2,align:o="left",x:s,y:c}=t,l=MX(t,["width","title","subtitle","spacing","align","x","y"]);e.style.transform=`translate(${s}, ${c})`;const u=$t(l,"title"),f=$t(l,"subtitle"),h=WT(e,".title","text").attr("className","title").call(le,Object.assign(Object.assign(Object.assign({},EN(0,0,n,o)),{fontSize:14,textBaseline:"top",text:r}),u)).node().getLocalBounds();WT(e,".sub-title","text").attr("className","sub-title").call(v=>{if(!i)return v.node().remove();v.node().attr(Object.assign(Object.assign(Object.assign({},EN(0,h.max[1]+a,n,o)),{fontSize:12,textBaseline:"top",text:i}),f))})}}),MN=t=>({value:e,theme:n})=>{const{x:r,y:i,width:a,height:o}=e.bbox;return new kX({style:mt({},n.title,Object.assign({x:r,y:i,width:a,height:o},t))})};MN.props={defaultPosition:"top",defaultOrder:2,defaultSize:36,defaultCrossPadding:[20,20],defaultPadding:[12,12]};var aS=function(t){if(typeof t!="object"||t===null)return t;var e;if(Nr(t)){e=[];for(var n=0,r=t.length;n<r;n++)typeof t[n]=="object"&&t[n]!=null?e[n]=aS(t[n]):e[n]=t[n]}else{e={};for(var i in t)typeof t[i]=="object"&&t[i]!=null?e[i]=aS(t[i]):e[i]=t[i]}return e},oS=aS,AX=function(t){ar(e,t);function e(n){var r=this,i=n.style,a=$r(n,["style"]);return r=t.call(this,mt({},{type:"column"},At({style:i},a)))||this,r.columnsGroup=new ui({name:"columns"}),r.appendChild(r.columnsGroup),r.render(),r}return e.prototype.render=function(){var n=this.attributes,r=n.columns,i=n.x,a=n.y;this.columnsGroup.style.transform="translate(".concat(i,", ").concat(a,")"),Fe(this.columnsGroup).selectAll(".column").data(r.flat()).join(function(o){return o.append("rect").attr("className","column").each(function(s){this.attr(s)})},function(o){return o.each(function(s){this.attr(s)})},function(o){return o.remove()})},e.prototype.update=function(n){this.attr(ic({},this.attributes,n)),this.render()},e.prototype.clear=function(){this.removeChildren()},e}(or),TX=function(t){ar(e,t);function e(n){var r=this,i=n.style,a=$r(n,["style"]);return r=t.call(this,mt({},{type:"lines"},At({style:i},a)))||this,r.linesGroup=r.appendChild(new ui),r.areasGroup=r.appendChild(new ui),r.render(),r}return e.prototype.render=function(){var n=this.attributes,r=n.lines,i=n.areas,a=n.x,o=n.y;this.style.transform="translate(".concat(a,", ").concat(o,")"),r&&this.renderLines(r),i&&this.renderAreas(i)},e.prototype.clear=function(){this.linesGroup.removeChildren(),this.areasGroup.removeChildren()},e.prototype.update=function(n){this.attr(ic({},this.attributes,n)),this.render()},e.prototype.renderLines=function(n){Fe(this.linesGroup).selectAll(".line").data(n).join(function(r){return r.append("path").attr("className","line").each(function(i){this.attr(i)})},function(r){return r.each(function(i){this.attr(i)})},function(r){return r.remove()})},e.prototype.renderAreas=function(n){Fe(this.linesGroup).selectAll(".area").data(n).join(function(r){return r.append("path").attr("className","area").each(function(i){this.attr(i)})},function(r){return r.each(function(i){this.style(i)})},function(r){return r.remove()})},e}(or);function PX(t,e,n,r){var i,a=[],o=!!r,s,c,l=[1/0,1/0],u=[-1/0,-1/0],f,d,h;if(o){i=V(r,2),l=i[0],u=i[1];for(var v=0,g=t.length;v<g;v+=1){var y=t[v];l=du(l,y),u=hu(u,y)}}for(var v=0,b=t.length;v<b;v+=1){var y=t[v];if(v===0&&!n)h=y;else if(v===b-1&&!n)d=y,a.push(h),a.push(d);else{var x=[v?v-1:b-1,v-1][n?0:1];s=t[x],c=t[n?(v+1)%b:v+1];var _=[0,0];_=sw(c,s),_=ac(_,e);var w=Ap(y,s),O=Ap(y,c),E=w+O;E!==0&&(w/=E,O/=E);var M=ac(_,-w),k=ac(_,O);d=kp(y,M),f=kp(y,k),f=du(f,hu(c,y)),f=hu(f,du(c,y)),M=sw(f,y),M=ac(M,-w/O),d=kp(y,M),d=du(d,hu(s,y)),d=hu(d,du(s,y)),k=sw(y,d),k=ac(k,O/w),f=kp(y,k),o&&(d=hu(d,l),d=du(d,u),f=hu(f,l),f=du(f,u)),a.push(h),a.push(d),h=f}}return n&&a.push(a.shift()),a}function CX(t,e,n){var r;e===void 0&&(e=!1),n===void 0&&(n=[[0,0],[1,1]]);for(var i=!!e,a=[],o=0,s=t.length;o<s;o+=2)a.push([t[o],t[o+1]]);for(var c=PX(a,.4,i,n),l=a.length,u=[],f,d,h,o=0;o<l-1;o+=1)f=c[o*2],d=c[o*2+1],h=a[o+1],u.push(["C",f[0],f[1],d[0],d[1],h[0],h[1]]);return i&&(f=c[l],d=c[l+1],r=V(a,1),h=r[0],u.push(["C",f[0],f[1],d[0],d[1],h[0],h[1]])),u}function LX(t,e){var n,r=e.x,i=e.y,a=V(i.getOptions().range||[0,0],2),o=a[0],s=a[1];return s>o&&(n=V([o,s],2),s=n[0],o=n[1]),t.map(function(c){var l=c.map(function(u,f){return[r.map(f),mn(i.map(u),s,o)]});return l})}function v0(t,e){e===void 0&&(e=!1);var n=e?t.length-1:0,r=t.map(function(i,a){return te([a===n?"M":"L"],V(i),!1)});return e?r.reverse():r}function m1(t,e){if(e===void 0&&(e=!1),t.length<=2)return v0(t);for(var n=[],r=t.length,i=0;i<r;i+=1){var a=e?t[r-i-1]:t[i];GA(a,n.slice(-2))||n.push.apply(n,te([],V(a),!1))}var o=CX(n,!1);return e?o.unshift(te(["M"],V(t[r-1]),!1)):o.unshift(te(["M"],V(t[0]),!1)),o}function sS(t,e,n){var r=oS(t);return r.push(["L",e,n],["L",0,n],["Z"]),r}function RX(t,e,n,r){return t.map(function(i){return sS(e?m1(i):v0(i),n,r)})}function NX(t,e,n){for(var r=[],i=t.length-1;i>=0;i-=1){var a=t[i],o=v0(a),s=void 0;if(i===0)s=sS(o,e,n);else{var c=t[i-1],l=v0(c,!0);l[0][0]="L",s=te(te(te([],V(o),!1),V(l),!1),[["Z"]],!1)}r.push(s)}return r}function IX(t,e,n){for(var r=[],i=t.length-1;i>=0;i-=1){var a=t[i],o=m1(a),s=void 0;if(i===0)s=sS(o,e,n);else{var c=t[i-1],l=m1(c,!0),u=a[0];l[0][0]="L",s=te(te(te([],V(o),!1),V(l),!1),[te(["M"],V(u),!1),["Z"]],!1)}r.push(s)}return r}var DX=function(t,e){if(Nr(t)){for(var n,r=1/0,i=0;i<t.length;i++){var a=t[i],o=Xn(e)?e(a):a[e];o<r&&(n=a,r=o)}return n}},jX=function(t,e){if(Nr(t)){for(var n,r=-1/0,i=0;i<t.length;i++){var a=t[i],o=Xn(e)?e(a):a[e];o>r&&(n=a,r=o)}return n}};function kN(t){return t.length===0?[0,0]:[of(DX(t,function(e){return of(e)||0})),Bc(jX(t,function(e){return Bc(e)||0}))]}function AN(t){for(var e=oS(t),n=e[0].length,r=V([Array(n).fill(0),Array(n).fill(0)],2),i=r[0],a=r[1],o=0;o<e.length;o+=1)for(var s=e[o],c=0;c<n;c+=1)s[c]>=0?(s[c]+=i[c],i[c]=s[c]):(s[c]+=a[c],a[c]=s[c]);return e}var FX=function(t){ar(e,t);function e(n){return t.call(this,n,{type:"line",x:0,y:0,width:200,height:20,isStack:!1,color:["#83daad","#edbf45","#d2cef9","#e290b3","#6f63f4"],smooth:!0,lineLineWidth:1,areaOpacity:0,isGroup:!1,columnLineWidth:1,columnStroke:"#fff",scale:1,spacing:0})||this}return Object.defineProperty(e.prototype,"rawData",{get:function(){var n=this.attributes.data;if(!n||(n==null?void 0:n.length)===0)return[[]];var r=oS(n);return Vn(r[0])?[r]:r},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"data",{get:function(){return this.attributes.isStack?AN(this.rawData):this.rawData},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"scales",{get:function(){return this.createScales(this.data)},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"baseline",{get:function(){var n=this.scales.y,r=V(n.getOptions().domain||[0,0],2),i=r[0],a=r[1];return a<0?n.map(a):n.map(i<0?0:i)},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"containerShape",{get:function(){var n=this.attributes,r=n.width,i=n.height;return{width:r,height:i}},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"linesStyle",{get:function(){var n=this,r=this.attributes,i=r.type,a=r.isStack,o=r.smooth;if(i!=="line")throw new Error("linesStyle can only be used in line type");var s=en(this.attributes,"area"),c=en(this.attributes,"line"),l=this.containerShape.width,u=this.data;if(u[0].length===0)return{lines:[],areas:[]};var f=this.scales,d=f.x,h=f.y,v=LX(u,{type:"line",x:d,y:h}),g=[];if(s){var y=this.baseline;a?g=o?IX(v,l,y):NX(v,l,y):g=RX(v,o,l,y)}return{lines:v.map(function(b,x){return At({stroke:n.getColor(x),d:o?m1(b):v0(b)},c)}),areas:g.map(function(b,x){return At({d:b,fill:n.getColor(x)},s)})}},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"columnsStyle",{get:function(){var n=this,r=en(this.attributes,"column"),i=this.attributes,a=i.isStack,o=i.type,s=i.scale;if(o!=="column")throw new Error("columnsStyle can only be used in column type");var c=this.containerShape.height,l=this.rawData;if(!l)return{columns:[]};a&&(l=AN(l));var u=this.createScales(l),f=u.x,d=u.y,h=V(kN(l),2),v=h[0],g=h[1],y=new Ji({domain:[0,g-(v>0?0:v)],range:[0,c*s]}),b=f.getBandWidth(),x=this.rawData;return{columns:l.map(function(_,w){return _.map(function(O,E){var M=b/l.length,k=function(){return{x:f.map(E)+M*w,y:O>=0?d.map(O):d.map(0),width:M,height:y.map(Math.abs(O))}},A=function(){return{x:f.map(E),y:d.map(O),width:b,height:y.map(x[w][E])}};return At(At({fill:n.getColor(w)},r),a?A():k())})})}},enumerable:!1,configurable:!0}),e.prototype.render=function(n,r){d9(r,".container","rect").attr("className","container").node();var i=n.type,a=n.x,o=n.y,s="spark".concat(i),c=At({x:a,y:o},i==="line"?this.linesStyle:this.columnsStyle);Fe(r).selectAll(".spark").data([i]).join(function(l){return l.append(function(u){return u==="line"?new TX({className:s,style:c}):new AX({className:s,style:c})}).attr("className","spark ".concat(s))},function(l){return l.update(c)},function(l){return l.remove()})},e.prototype.getColor=function(n){var r=this.attributes.color;return Nr(r)?r[n%r.length]:Xn(r)?r.call(null,n):r},e.prototype.createScales=function(n){var r,i,a=this.attributes,o=a.type,s=a.scale,c=a.range,l=c===void 0?[]:c,u=a.spacing,f=this.containerShape,d=f.width,h=f.height,v=V(kN(n),2),g=v[0],y=v[1],b=new Ji({domain:[(r=l[0])!==null&&r!==void 0?r:g,(i=l[1])!==null&&i!==void 0?i:y],range:[h,h*(1-s)]});return o==="line"?{type:o,x:new Ji({domain:[0,n[0].length-1],range:[0,d]}),y:b}:{type:o,x:new pl({domain:n[0].map(function(x,_){return _}),range:[0,d],paddingInner:u,paddingOuter:u/2,align:.5}),y:b}},e.tag="sparkline",e}(bi),TN=function(t){ar(e,t);function e(n){var r=t.call(this,n,At(At(At({x:0,y:0,animate:{duration:100,fill:"both"},brushable:!0,formatter:function(i){return i.toString()},handleSpacing:2,orientation:"horizontal",padding:0,autoFitLabel:!0,scrollable:!0,selectionFill:"#5B8FF9",selectionFillOpacity:.45,selectionZIndex:2,showHandle:!0,showLabel:!0,slidable:!0,trackFill:"#416180",trackLength:200,trackOpacity:.05,trackSize:20,trackZIndex:-1,values:[0,1],type:"range",selectionType:"select",handleIconOffset:0},ds(tP,"handle")),ds(QT,"handleIcon")),ds(JT,"handleLabel")))||this;return r.range=[0,1],r.onDragStart=function(i){return function(a){a.stopPropagation(),r.target=i,r.prevPos=r.getOrientVal(_m(a));var o=r.availableSpace,s=o.x,c=o.y,l=r.getBBox(),u=l.x,f=l.y;r.selectionStartPos=r.getRatio(r.prevPos-r.getOrientVal([s,c])-r.getOrientVal([+u,+f])),r.selectionWidth=0,document.addEventListener("pointermove",r.onDragging),document.addEventListener("pointerup",r.onDragEnd)}},r.onDragging=function(i){var a=r.attributes,o=a.slidable,s=a.brushable,c=a.type;i.stopPropagation();var l=r.getOrientVal(_m(i)),u=l-r.prevPos;if(u){var f=r.getRatio(u);switch(r.target){case"start":o&&r.setValuesOffset(f);break;case"end":o&&r.setValuesOffset(0,f);break;case"selection":o&&r.setValuesOffset(f,f);break;case"track":if(!s)return;r.selectionWidth+=f,c==="range"?r.innerSetValues([r.selectionStartPos,r.selectionStartPos+r.selectionWidth].sort(),!0):r.innerSetValues([0,r.selectionStartPos+r.selectionWidth],!0);break;default:break}r.prevPos=l}},r.onDragEnd=function(){document.removeEventListener("pointermove",r.onDragging),document.removeEventListener("pointermove",r.onDragging),document.removeEventListener("pointerup",r.onDragEnd),r.target="",r.updateHandlesPosition(!1)},r.onValueChange=function(i){var a=r.attributes,o=a.onChange,s=a.type,c=s==="range"?i:i[1],l=s==="range"?r.getValues():r.getValues()[1],u=new Nn("valuechange",{detail:{oldValue:c,value:l}});r.dispatchEvent(u),o==null||o(l)},r.selectionStartPos=0,r.selectionWidth=0,r.prevPos=0,r.target="",r}return Object.defineProperty(e.prototype,"values",{get:function(){return this.attributes.values},set:function(n){this.attributes.values=this.clampValues(n)},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"sparklineStyle",{get:function(){var n=this.attributes.orientation;if(n!=="horizontal")return null;var r=en(this.attributes,"sparkline");return At(At({zIndex:0},this.availableSpace),r)},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"shape",{get:function(){var n=this.attributes,r=n.trackLength,i=n.trackSize,a=V(this.getOrientVal([[r,i],[i,r]]),2),o=a[0],s=a[1];return{width:o,height:s}},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"availableSpace",{get:function(){var n=this.attributes,r=n.x,i=n.y,a=n.padding,o=V(Ni(a),4),s=o[0],c=o[1],l=o[2],u=o[3],f=this.shape,d=f.width,h=f.height;return{x:u,y:s,width:d-(u+c),height:h-(s+l)}},enumerable:!1,configurable:!0}),e.prototype.getValues=function(){return this.values},e.prototype.setValues=function(n,r){n===void 0&&(n=[0,0]),r===void 0&&(r=!1),this.attributes.values=n;var i=r===!1?!1:this.attributes.animate;this.updateSelectionArea(i),this.updateHandlesPosition(i)},e.prototype.updateSelectionArea=function(n){var r=this.calcSelectionArea();this.foregroundGroup.selectAll(ps.selection.class).each(function(i,a){zo(this,r[a],n)})},e.prototype.updateHandlesPosition=function(n){this.attributes.showHandle&&(this.startHandle&&zo(this.startHandle,this.getHandleStyle("start"),n),this.endHandle&&zo(this.endHandle,this.getHandleStyle("end"),n))},e.prototype.innerSetValues=function(n,r){n===void 0&&(n=[0,0]),r===void 0&&(r=!1);var i=this.values,a=this.clampValues(n);this.attributes.values=a,this.setValues(a),r&&this.onValueChange(i)},e.prototype.renderTrack=function(n){var r=this.attributes,i=r.x,a=r.y,o=en(this.attributes,"track");this.trackShape=Fe(n).maybeAppendByClassName(ps.track,"rect").styles(At(At({x:i,y:a},this.shape),o))},e.prototype.renderBrushArea=function(n){var r=this.attributes,i=r.x,a=r.y,o=r.brushable;this.brushArea=Fe(n).maybeAppendByClassName(ps.brushArea,"rect").styles(At({x:i,y:a,fill:"transparent",cursor:o?"crosshair":"default"},this.shape))},e.prototype.renderSparkline=function(n){var r=this,i=this.attributes,a=i.x,o=i.y,s=i.orientation,c=Fe(n).maybeAppendByClassName(ps.sparklineGroup,"g");Pa(s==="horizontal",c,function(l){var u=At(At({},r.sparklineStyle),{x:a,y:o});l.maybeAppendByClassName(ps.sparkline,function(){return new FX({style:u})}).update(u)})},e.prototype.renderHandles=function(){var n=this,r,i=this.attributes,a=i.showHandle,o=i.type,s=o==="range"?["start","end"]:["end"],c=a?s:[],l=this;(r=this.foregroundGroup)===null||r===void 0||r.selectAll(ps.handle.class).data(c.map(function(u){return{type:u}}),function(u){return u.type}).join(function(u){return u.append(function(f){var d=f.type;return new eP({style:n.getHandleStyle(d)})}).each(function(f){var d=f.type;this.attr("class","".concat(ps.handle.name," ").concat(d,"-handle"));var h="".concat(d,"Handle");l[h]=this,this.addEventListener("pointerdown",l.onDragStart(d))})},function(u){return u.each(function(f){var d=f.type;this.update(l.getHandleStyle(d))})},function(u){return u.each(function(f){var d=f.type,h="".concat(d,"Handle");l[h]=void 0}).remove()})},e.prototype.renderSelection=function(n){var r=this.attributes,i=r.x,a=r.y,o=r.type,s=r.selectionType;this.foregroundGroup=Fe(n).maybeAppendByClassName(ps.foreground,"g");var c=en(this.attributes,"selection"),l=function(f){return f.style("visibility",function(d){return d.show?"visible":"hidden"}).style("cursor",function(d){return s==="select"?"grab":s==="invert"?"crosshair":"default"}).styles(At(At({},c),{transform:"translate(".concat(i,", ").concat(a,")")}))},u=this;this.foregroundGroup.selectAll(ps.selection.class).data(o==="value"?[]:this.calcSelectionArea().map(function(f,d){return{style:At({},f),index:d,show:s==="select"?d===1:d!==1}}),function(f){return f.index}).join(function(f){return f.append("rect").attr("className",ps.selection.name).call(l).each(function(d,h){var v=this;h===1?(u.selectionShape=Fe(this),this.on("pointerdown",function(g){v.attr("cursor","grabbing"),u.onDragStart("selection")(g)}),u.dispatchCustomEvent(this,"pointerenter","selectionMouseenter"),u.dispatchCustomEvent(this,"pointerleave","selectionMouseleave"),u.dispatchCustomEvent(this,"click","selectionClick"),this.addEventListener("pointerdown",function(){v.attr("cursor","grabbing")}),this.addEventListener("pointerup",function(){v.attr("cursor","pointer")}),this.addEventListener("pointerover",function(){v.attr("cursor","pointer")})):this.on("pointerdown",u.onDragStart("track"))})},function(f){return f.call(l)},function(f){return f.remove()}),this.updateSelectionArea(!1),this.renderHandles()},e.prototype.render=function(n,r){this.renderTrack(r),this.renderSparkline(r),this.renderBrushArea(r),this.renderSelection(r)},e.prototype.clampValues=function(n,r){var i;r===void 0&&(r=4);var a=V(this.range,2),o=a[0],s=a[1],c=V(this.getValues().map(function(y){return xm(y,r)}),2),l=c[0],u=c[1],f=Array.isArray(n)?n:[l,n!=null?n:u],d=V((f||[l,u]).map(function(y){return xm(y,r)}),2),h=d[0],v=d[1];if(this.attributes.type==="value")return[0,mn(v,o,s)];h>v&&(i=V([v,h],2),h=i[0],v=i[1]);var g=v-h;return g>s-o?[o,s]:h<o?l===o&&u===v?[o,v]:[o,g+o]:v>s?u===s&&l===h?[h,s]:[s-g,s]:[h,v]},e.prototype.calcSelectionArea=function(n){var r=V(this.clampValues(n),2),i=r[0],a=r[1],o=this.availableSpace,s=o.x,c=o.y,l=o.width,u=o.height;return this.getOrientVal([[{y:c,height:u,x:s,width:i*l},{y:c,height:u,x:i*l+s,width:(a-i)*l},{y:c,height:u,x:a*l,width:(1-a)*l}],[{x:s,width:l,y:c,height:i*u},{x:s,width:l,y:i*u+c,height:(a-i)*u},{x:s,width:l,y:a*u,height:(1-a)*u}]])},e.prototype.calcHandlePosition=function(n){var r=this.attributes.handleIconOffset,i=this.availableSpace,a=i.x,o=i.y,s=i.width,c=i.height,l=V(this.clampValues(),2),u=l[0],f=l[1],d=n==="start"?-r:r,h=(n==="start"?u:f)*this.getOrientVal([s,c])+d;return{x:a+this.getOrientVal([h,s/2]),y:o+this.getOrientVal([c/2,h])}},e.prototype.inferTextStyle=function(n){var r=this.attributes.orientation;return r==="horizontal"?{}:n==="start"?{transformOrigin:"left center",transform:"rotate(90)",textAlign:"start"}:n==="end"?{transformOrigin:"right center",transform:"rotate(90)",textAlign:"end"}:{}},e.prototype.calcHandleText=function(n){var r,i=this.attributes,a=i.type,o=i.orientation,s=i.formatter,c=i.autoFitLabel,l=en(this.attributes,"handle"),u=en(l,"label"),f=l.spacing,d=this.getHandleSize(),h=this.clampValues(),v=n==="start"?h[0]:h[1],g=s(v),y=new aw({style:At(At(At({},u),this.inferTextStyle(n)),{text:g})}),b=y.getBBox(),x=b.width,_=b.height;if(y.destroy(),!c){if(a==="value")return{text:g,x:0,y:-_-f};var w=f+d+(o==="horizontal"?x/2:0);return r={text:g},r[o==="horizontal"?"x":"y"]=n==="start"?-w:w,r}var O=0,E=0,M=this.availableSpace,k=M.width,A=M.height,P=this.calcSelectionArea()[1],C=P.x,N=P.y,L=P.width,R=P.height,I=f+d;if(o==="horizontal"){var D=I+x/2;if(n==="start"){var G=C-I-x;O=G>0?-D:D}else{var F=k-C-L-I>x;O=F?D:-D}}else{var W=I,X=_+I;n==="start"?E=N-d>_?-X:W:E=A-(N+R)-d>_?X:-W}return{x:O,y:E,text:g}},e.prototype.getHandleLabelStyle=function(n){var r=en(this.attributes,"handleLabel");return At(At(At({},r),this.calcHandleText(n)),this.inferTextStyle(n))},e.prototype.getHandleIconStyle=function(){var n=this.attributes.handleIconShape,r=en(this.attributes,"handleIcon"),i=this.getOrientVal(["ew-resize","ns-resize"]),a=this.getHandleSize();return At({cursor:i,shape:n,size:a},r)},e.prototype.getHandleStyle=function(n){var r=this.attributes,i=r.x,a=r.y,o=r.showLabel,s=r.showLabelOnInteraction,c=r.orientation,l=this.calcHandlePosition(n),u=l.x,f=l.y,d=this.calcHandleText(n),h=o;return!o&&s&&(this.target?h=!0:h=!1),At(At(At({},ds(this.getHandleIconStyle(),"icon")),ds(At(At({},this.getHandleLabelStyle(n)),d),"label")),{transform:"translate(".concat(u+i,", ").concat(f+a,")"),orientation:c,showLabel:h,type:n,zIndex:3})},e.prototype.getHandleSize=function(){var n=this.attributes,r=n.handleIconSize,i=n.width,a=n.height;return r||Math.floor((this.getOrientVal([+a,+i])+4)/2.4)},e.prototype.getOrientVal=function(n){var r=V(n,2),i=r[0],a=r[1],o=this.attributes.orientation;return o==="horizontal"?i:a},e.prototype.setValuesOffset=function(n,r,i){r===void 0&&(r=0),i===void 0&&(i=!1);var a=this.attributes.type,o=V(this.getValues(),2),s=o[0],c=o[1],l=a==="range"?n:0,u=[s+l,c+r].sort();i?this.setValues(u):this.innerSetValues(u,!0)},e.prototype.getRatio=function(n){var r=this.availableSpace,i=r.width,a=r.height;return n/this.getOrientVal([i,a])},e.prototype.dispatchCustomEvent=function(n,r,i){var a=this;n.on(r,function(o){o.stopPropagation(),a.dispatchEvent(new Nn(i,{detail:o}))})},e.prototype.bindEvents=function(){this.addEventListener("wheel",this.onScroll);var n=this.brushArea;this.dispatchCustomEvent(n,"click","trackClick"),this.dispatchCustomEvent(n,"pointerenter","trackMouseenter"),this.dispatchCustomEvent(n,"pointerleave","trackMouseleave"),n.on("pointerdown",this.onDragStart("track"))},e.prototype.onScroll=function(n){var r=this.attributes.scrollable;if(r){var i=n.deltaX,a=n.deltaY,o=a||i,s=this.getRatio(o);this.setValuesOffset(s,s,!0)}},e.tag="slider",e}(bi),BX=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function zX(t,e,n){const{x:r,y:i,width:a,height:o}=t;if(e==="left")return[r+a-n,i];if(e==="right")return[r,i];if(e==="bottom")return[r,i];if(e==="top")return[r,i+o-n]}const g0=t=>{const{orientation:e,labelFormatter:n,size:r,style:i={},position:a}=t,o=BX(t,["orientation","labelFormatter","size","style","position"]);return s=>{var c;const{scales:[l],value:u,theme:f,coordinate:d}=s,{bbox:h}=u,{width:v,height:g}=h,{slider:y={}}=f,b=((c=l.getFormatter)===null||c===void 0?void 0:c.call(l))||(k=>k+""),x=typeof n=="string"?el(n):n,_=e==="horizontal",w=hr(d)&&_,{trackSize:O=y.trackSize}=i,[E,M]=zX(h,a,O);return new TN({className:"slider",style:Object.assign({},y,Object.assign(Object.assign({x:E,y:M,trackLength:_?v:g,orientation:e,formatter:k=>{const A=x||b,P=w?1-k:k,C=sd(l,P,!0);return A(C)},sparklineData:GX(t,s)},i),o))})}};function WX(t,e){const[n]=Array.from(t.entries()).filter(([i])=>i.type==="line"||i.type==="area").filter(([i])=>i.slider).map(([i])=>{const{encode:a,slider:o}=i;if(o!=null&&o.x){const s=c=>{const l=a[c];return[c,l?l.value:void 0]};return Object.fromEntries(e.map(s))}});if(!(n!=null&&n.series))return n==null?void 0:n.y;const r=n.series.reduce((i,a,o)=>(i[a]=i[a]||[],i[a].push(n.y[o]),i),{});return Object.values(r)}function GX(t,e){const{markState:n}=e;return Nr(t.sparklineData)?t.sparklineData:WX(n,["y","series"])}g0.props={defaultPosition:"bottom",defaultSize:24,defaultOrder:1,defaultCrossPadding:[12,12],defaultPadding:[12,12]};const PN=t=>g0(Object.assign(Object.assign({},t),{orientation:"horizontal"}));PN.props=Object.assign(Object.assign({},g0.props),{defaultPosition:"bottom"});const CN=t=>g0(Object.assign(Object.assign({},t),{orientation:"vertical"}));CN.props=Object.assign(Object.assign({},g0.props),{defaultPosition:"left"});var $X=function(t){ar(e,t);function e(n){var r=t.call(this,n,{x:0,y:0,isRound:!0,orientation:"vertical",padding:[2,2,2,2],scrollable:!0,slidable:!0,thumbCursor:"default",trackSize:10,value:0})||this;return r.range=[0,1],r.onValueChange=function(i){var a=r.attributes.value;if(i!==a){var o={detail:{oldValue:i,value:a}};r.dispatchEvent(new Nn("scroll",o)),r.dispatchEvent(new Nn("valuechange",o))}},r.onTrackClick=function(i){var a=r.attributes.slidable;if(a){var o=V(r.getLocalPosition(),2),s=o[0],c=o[1],l=V(r.padding,4),u=l[0],f=l[3],d=r.getOrientVal([s+f,c+u]),h=r.getOrientVal(_m(i)),v=(h-d)/r.trackLength;r.setValue(v,!0)}},r.onThumbMouseenter=function(i){r.dispatchEvent(new Nn("thumbMouseenter",{detail:i.detail}))},r.onTrackMouseenter=function(i){r.dispatchEvent(new Nn("trackMouseenter",{detail:i.detail}))},r.onThumbMouseleave=function(i){r.dispatchEvent(new Nn("thumbMouseleave",{detail:i.detail}))},r.onTrackMouseleave=function(i){r.dispatchEvent(new Nn("trackMouseleave",{detail:i.detail}))},r}return Object.defineProperty(e.prototype,"padding",{get:function(){var n=this.attributes.padding;return Ni(n)},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"value",{get:function(){var n=this.attributes.value,r=V(this.range,2),i=r[0],a=r[1];return mn(n,i,a)},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"trackLength",{get:function(){var n=this.attributes,r=n.viewportLength,i=n.trackLength,a=i===void 0?r:i;return a},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"availableSpace",{get:function(){var n=this.attributes.trackSize,r=this.trackLength,i=V(this.padding,4),a=i[0],o=i[1],s=i[2],c=i[3],l=V(this.getOrientVal([[r,n],[n,r]]),2),u=l[0],f=l[1];return{x:c,y:a,width:+u-(c+o),height:+f-(a+s)}},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"trackRadius",{get:function(){var n=this.attributes,r=n.isRound,i=n.trackSize;return r?i/2:0},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"thumbRadius",{get:function(){var n=this.attributes,r=n.isRound,i=n.thumbRadius;if(!r)return 0;var a=this.availableSpace,o=a.width,s=a.height;return i||this.getOrientVal([s,o])/2},enumerable:!1,configurable:!0}),e.prototype.getValues=function(n){n===void 0&&(n=this.value);var r=this.attributes,i=r.viewportLength,a=r.contentLength,o=i/a,s=V(this.range,2),c=s[0],l=s[1],u=n*(l-c-o);return[u,u+o]},e.prototype.getValue=function(){return this.value},e.prototype.renderSlider=function(n){var r=this.attributes,i=r.x,a=r.y,o=r.orientation,s=r.trackSize,c=r.padding,l=r.slidable,u=en(this.attributes,"track"),f=en(this.attributes,"thumb"),d=At(At({x:i,y:a,brushable:!1,orientation:o,padding:c,selectionRadius:this.thumbRadius,showHandle:!1,slidable:l,trackLength:this.trackLength,trackRadius:this.trackRadius,trackSize:s,values:this.getValues()},ds(u,"track")),ds(f,"selection"));this.slider=Fe(n).maybeAppendByClassName("scrollbar",function(){return new TN({style:d})}).update(d).node()},e.prototype.render=function(n,r){this.renderSlider(r)},e.prototype.setValue=function(n,r){r===void 0&&(r=!1);var i=this.attributes.value,a=V(this.range,2),o=a[0],s=a[1];this.slider.setValues(this.getValues(mn(n,o,s)),r),this.onValueChange(i)},e.prototype.bindEvents=function(){var n=this;this.slider.addEventListener("trackClick",function(r){r.stopPropagation(),n.onTrackClick(r.detail)}),this.onHover()},e.prototype.getOrientVal=function(n){var r=this.attributes.orientation;return r==="horizontal"?n[0]:n[1]},e.prototype.onHover=function(){this.slider.addEventListener("selectionMouseenter",this.onThumbMouseenter),this.slider.addEventListener("trackMouseenter",this.onTrackMouseenter),this.slider.addEventListener("selectionMouseleave",this.onThumbMouseleave),this.slider.addEventListener("trackMouseleave",this.onTrackMouseleave)},e.tag="scrollbar",e}(bi),ZX=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const y0=t=>{const{orientation:e,labelFormatter:n,style:r}=t,i=ZX(t,["orientation","labelFormatter","style"]);return({scales:[a],value:o,theme:s})=>{const{bbox:c}=o,{x:l,y:u,width:f,height:d}=c,{scrollbar:h={}}=s,{ratio:v,range:g}=a.getOptions(),y=e==="horizontal"?f:d,b=y/v,[x,_]=g,w=_>x?0:1;return new $X({className:"g2-scrollbar",style:Object.assign({},h,Object.assign(Object.assign(Object.assign(Object.assign({},r),{x:l,y:u,trackLength:y,value:w}),i),{orientation:e,contentLength:b,viewportLength:y}))})}};y0.props={defaultPosition:"bottom",defaultSize:24,defaultOrder:1,defaultCrossPadding:[12,12],defaultPadding:[12,12]};const LN=t=>y0(Object.assign(Object.assign({},t),{orientation:"horizontal"}));LN.props=Object.assign(Object.assign({},y0.props),{defaultPosition:"bottom"});const RN=t=>y0(Object.assign(Object.assign({},t),{orientation:"vertical"}));RN.props=Object.assign(Object.assign({},y0.props),{defaultPosition:"left"});const cS=(t,e)=>{const{coordinate:r}=e;return(i,a,o)=>{const[s]=i,{transform:c="",fillOpacity:l=1,strokeOpacity:u=1,opacity:f=1}=s.style,[d,h]=hr(r)?["left bottom",`scale(1, ${1e-4})`]:["left top",`scale(${1e-4}, 1)`],v=[{transform:`${c} ${h}`.trimStart(),transformOrigin:d,fillOpacity:0,strokeOpacity:0,opacity:0},{transform:`${c} ${h}`.trimStart(),transformOrigin:d,fillOpacity:l,strokeOpacity:u,opacity:f,offset:.01},{transform:`${c} scale(1, 1)`.trimStart(),transformOrigin:d,fillOpacity:l,strokeOpacity:u,opacity:f}];return s.animate(v,Object.assign(Object.assign({},o),t))}},YX=(t,e)=>{const{coordinate:r}=e;return(i,a,o)=>{const[s]=i,{transform:c="",fillOpacity:l=1,strokeOpacity:u=1,opacity:f=1}=s.style,[d,h]=hr(r)?["left bottom",`scale(1, ${1e-4})`]:["left top",`scale(${1e-4}, 1)`],v=[{transform:`${c} scale(1, 1)`.trimStart(),transformOrigin:d},{transform:`${c} ${h}`.trimStart(),transformOrigin:d,fillOpacity:l,strokeOpacity:u,opacity:f,offset:.99},{transform:`${c} ${h}`.trimStart(),transformOrigin:d,fillOpacity:0,strokeOpacity:0,opacity:0}];return s.animate(v,Object.assign(Object.assign({},o),t))}},NN=(t,e)=>{const{coordinate:r}=e;return gk.registerProperty({name:"scaleInYRadius",inherits:!1,initialValue:"",interpolable:!0,syntax:zt.NUMBER}),(i,a,o)=>{const[s]=i,c=u=>{const{__data__:f,style:d}=u,{radius:h=0,inset:v=0,fillOpacity:g=1,strokeOpacity:y=1,opacity:b=1}=d,{points:x,y:_,y1:w}=f,O=mu(r,x,[_,w]),{innerRadius:E,outerRadius:M}=O,k=Lm().cornerRadius(h).padAngle(v*Math.PI/180),A=new Qi({}),P=L=>(A.attr({d:k(L)}),qg(A)),C=[{scaleInYRadius:E+1e-4,fillOpacity:0,strokeOpacity:0,opacity:0},{scaleInYRadius:E+1e-4,fillOpacity:g,strokeOpacity:y,opacity:b,offset:.01},{scaleInYRadius:M,fillOpacity:g,strokeOpacity:y,opacity:b}],N=u.animate(C,Object.assign(Object.assign({},o),t));return N.onframe=function(){u.style.d=P(Object.assign(Object.assign({},O),{outerRadius:Number(u.style.scaleInYRadius)}))},N.onfinish=function(){u.style.d=P(Object.assign(Object.assign({},O),{outerRadius:M}))},N},l=u=>{const{style:f}=u,{transform:d="",fillOpacity:h=1,strokeOpacity:v=1,opacity:g=1}=f,[y,b]=hr(r)?["left top",`scale(${1e-4}, 1)`]:["left bottom",`scale(1, ${1e-4})`],x=[{transform:`${d} ${b}`.trimStart(),transformOrigin:y,fillOpacity:0,strokeOpacity:0,opacity:0},{transform:`${d} ${b}`.trimStart(),transformOrigin:y,fillOpacity:h,strokeOpacity:v,opacity:g,offset:.01},{transform:`${d} scale(1, 1)`.trimStart(),transformOrigin:y,fillOpacity:h,strokeOpacity:v,opacity:g}];return u.animate(x,Object.assign(Object.assign({},o),t))};return Bn(r)?c(s):l(s)}},HX=(t,e)=>{const{coordinate:r}=e;return(i,a,o)=>{const[s]=i,{transform:c="",fillOpacity:l=1,strokeOpacity:u=1,opacity:f=1}=s.style,[d,h]=hr(r)?["left top",`scale(${1e-4}, 1)`]:["left bottom",`scale(1, ${1e-4})`],v=[{transform:`${c} scale(1, 1)`.trimStart(),transformOrigin:d},{transform:`${c} ${h}`.trimStart(),transformOrigin:d,fillOpacity:l,strokeOpacity:u,opacity:f,offset:.99},{transform:`${c} ${h}`.trimStart(),transformOrigin:d,fillOpacity:0,strokeOpacity:0,opacity:0}];return s.animate(v,Object.assign(Object.assign({},o),t))}},IN=(t,e)=>{gk.registerProperty({name:"waveInArcAngle",inherits:!1,initialValue:"",interpolable:!0,syntax:zt.NUMBER});const{coordinate:r}=e;return(i,a,o)=>{const[s]=i;if(!Bn(r))return cS(t,e)(i,a,o);const{__data__:c,style:l}=s,{radius:u=0,inset:f=0,fillOpacity:d=1,strokeOpacity:h=1,opacity:v=1}=l,{points:g,y,y1:b}=c,x=Lm().cornerRadius(u).padAngle(f*Math.PI/180),_=mu(r,g,[y,b]),{startAngle:w,endAngle:O}=_,E=[{waveInArcAngle:w+1e-4,fillOpacity:0,strokeOpacity:0,opacity:0},{waveInArcAngle:w+1e-4,fillOpacity:d,strokeOpacity:h,opacity:v,offset:.01},{waveInArcAngle:O,fillOpacity:d,strokeOpacity:h,opacity:v}],M=s.animate(E,Object.assign(Object.assign({},o),t));return M.onframe=function(){s.style.d=x(Object.assign(Object.assign({},_),{endAngle:Number(s.style.waveInArcAngle)}))},M.onfinish=function(){s.style.d=x(Object.assign(Object.assign({},_),{endAngle:O}))},M}};IN.props={};const DN=t=>(e,n,r)=>{const[i]=e,{fillOpacity:a=1,strokeOpacity:o=1,opacity:s=1}=i.style,c=[{fillOpacity:0,strokeOpacity:0,opacity:0},{fillOpacity:a,strokeOpacity:o,opacity:s}];return i.animate(c,Object.assign(Object.assign({},r),t))};DN.props={};const jN=t=>(e,n,r)=>{const[i]=e,{fillOpacity:a=1,strokeOpacity:o=1,opacity:s=1}=i.style,c=[{fillOpacity:a,strokeOpacity:o,opacity:s},{fillOpacity:0,strokeOpacity:0,opacity:0}];return i.animate(c,Object.assign(Object.assign({},r),t))};jN.props={};const VX=t=>(n,r,i)=>{const[a]=n,{transform:o="",fillOpacity:s=1,strokeOpacity:c=1,opacity:l=1}=a.style,u="center center",f=[{transform:`${o} scale(${1e-4})`.trimStart(),transformOrigin:u,fillOpacity:0,strokeOpacity:0,opacity:0},{transform:`${o} scale(${1e-4})`.trimStart(),transformOrigin:u,fillOpacity:s,strokeOpacity:c,opacity:l,offset:.01},{transform:`${o} scale(1)`.trimStart(),transformOrigin:u,fillOpacity:s,strokeOpacity:c,opacity:l}];return a.animate(f,Object.assign(Object.assign({},i),t))},XX=t=>(n,r,i)=>{const[a]=n,{transform:o="",fillOpacity:s=1,strokeOpacity:c=1,opacity:l=1}=a.style,u="center center",f=[{transform:`${o} scale(1)`.trimStart(),transformOrigin:u},{transform:`${o} scale(${1e-4})`.trimStart(),transformOrigin:u,fillOpacity:s,strokeOpacity:c,opacity:l,offset:.99},{transform:`${o} scale(${1e-4})`.trimStart(),transformOrigin:u,fillOpacity:0,strokeOpacity:0,opacity:0}];return a.animate(f,Object.assign(Object.assign({},i),t))},FN=t=>(e,n,r)=>{var i,a;const[o]=e,s=((a=(i=o).getTotalLength)===null||a===void 0?void 0:a.call(i))||0,c=[{lineDash:[0,s]},{lineDash:[s,0]}];return o.animate(c,Object.assign(Object.assign({},r),t))};FN.props={};const UX={opacity:1,strokeOpacity:1,fillOpacity:1,lineWidth:0,x:0,y:0,cx:0,cy:0,r:0,rx:0,ry:0,width:0,height:0},qX={[dt.CIRCLE]:["cx","cy","r"],[dt.ELLIPSE]:["cx","cy","rx","ry"],[dt.RECT]:["x","y","width","height"],[dt.IMAGE]:["x","y","width","height"],[dt.LINE]:["x1","y1","x2","y2"],[dt.POLYLINE]:["points"],[dt.POLYGON]:["points"]};function Od(t,e,n=!1){const r={};for(const i of e){const a=t.style[i];a?r[i]=a:n&&(r[i]=UX[i])}return r}const m0=["fill","stroke","fillOpacity","strokeOpacity","opacity","lineWidth"];function lS(t){const{min:e,max:n}=t.getLocalBounds(),[r,i]=e,[a,o]=n,s=o-i,c=a-r;return[r,i,c,s]}function KX(t){const[e,n,r,i]=t;return`
    M ${e} ${n}
    L ${e+r} ${n}
    L ${e+r} ${n+i}
    L ${e} ${n+i}
    Z
  `}function QX(t,e){const[n,r,i,a]=lS(t),o=a/i,s=Math.ceil(Math.sqrt(e/o)),c=Math.ceil(e/s),l=[],u=a/c;let f=0,d=e;for(;d>0;){const h=Math.min(d,s),v=i/h;for(let g=0;g<h;g++){const y=n+g*v,b=r+f*u;l.push(KX([y,b,v,u]))}d-=h,f+=1}return l}function JX(t="pack"){return typeof t=="function"?t:QX}function tU(t,e,n){let{transform:r}=t.style;const{transform:i}=e.style;BN(e,t);let a=m0;if(t.nodeName===dt.GROUP){const[c,l,u,f]=lS(t),[d,h,v,g]=lS(e),y=c-d,b=l-h,x=u/v,_=f/g;r=`translate(${y}, ${b}) scale(${x}, ${_})`}else a=a.concat(qX[t.nodeName]||[]);const o=[Object.assign({transform:r!=null?r:"none"},Od(t,a,!0)),Object.assign({transform:i!=null?i:"none"},Od(e,a,!0))];return e.animate(o,n)}function BN(t,e){t.__data__=e.__data__,t.className=e.className,t.markType=e.markType,e.parentNode.replaceChild(t,e)}function eU(t,e){const{nodeName:n}=t;if(n==="path")return t;const r=new Qi({style:Object.assign(Object.assign({},Od(t,m0)),{d:e})});return BN(r,t),r}function zN(t,e){const n=t.indexOf(e),r=t.lastIndexOf(e);return n===r}function nU(t){return!zN(t,"m")||!zN(t,"M")}function WN(t){const e=qg(t);if(e&&!nU(e))return e}function GN(t){const{nodeName:e}=t;if(e==="path"){const n=vn(t,"attributes");return n.markerEnd||n.markerStart}return!1}function uS(t,e,n,r){const{nodeName:i}=e,{nodeName:a}=n,o=WN(e),s=WN(n),c=i===a&&i!=="path",l=o===void 0||s===void 0,u=GN(e)||GN(n);if(c||l||u)return tU(e,n,r);const f=eU(t,o),d=[Object.assign({},Od(e,m0)),Object.assign({},Od(n,m0))];if(o!==s){d[0].d=o,d[1].d=s;const h=f.animate(d,r);return h.onfinish=()=>{const v=f.style.d;Q_(f,n),f.style.d=v,f.style.transform="none"},f.style.transform="none",h}return null}function rU(t,e,n,r){t.style.visibility="hidden";const i=r(t,e.length);return e.map((a,o)=>{const s=new Qi({style:Object.assign({d:i[o]},Od(t,m0))});return uS(a,s,a,n)})}function iU(t,e,n,r){const i=r(e,t.length),{fillOpacity:a=1,strokeOpacity:o=1,opacity:s=1}=e.style,c=[{fillOpacity:0,strokeOpacity:0,opacity:0},{fillOpacity:0,strokeOpacity:0,opacity:0,offset:.99},{fillOpacity:a,strokeOpacity:o,opacity:s}],l=e.animate(c,n);return[...t.map((f,d)=>{const h=new Qi({style:{d:i[d],fill:e.style.fill}});return uS(f,f,h,n)}),l]}const $N=t=>(e,n,r)=>{const i=JX(t.split),a=Object.assign(Object.assign({},r),t),{length:o}=e,{length:s}=n;if(o===1&&s===1||o>1&&s>1){const[c]=e,[l]=n;return uS(c,c,l,a)}if(o===1&&s>1){const[c]=e;return rU(c,n,a,i)}if(o>1&&s===1){const[c]=n;return iU(e,c,a,i)}return null};$N.props={};const ZN=(t,e)=>(n,r,i)=>{const[a]=n,{min:[o,s],halfExtents:c}=a.getLocalBounds(),l=c[0]*2,u=c[1]*2,f=new Qi({style:{d:`M${o},${s}L${o+l},${s}L${o+l},${s+u}L${o},${s+u}Z`}});return a.appendChild(f),a.style.clipPath=f,cS(t,e)([f],r,i)};ZN.props={};const YN=(t,e)=>(n,r,i)=>{const[a]=n,{min:[o,s],halfExtents:c}=a.getLocalBounds(),l=c[0]*2,u=c[1]*2,f=new Qi({style:{d:`M${o},${s}L${o+l},${s}L${o+l},${s+u}L${o},${s+u}Z`}});return a.appendChild(f),a.style.clipPath=f,NN(t,e)([f],r,i)};YN.props={};var aU=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function oU(t,{elements:e,datum:n,groupKey:r=f=>f,link:i=!1,background:a=!1,delay:o=60,scale:s,coordinate:c,emitter:l,state:u={}}){var f;const d=e(t),h=new Set(d),v=dr(d,r),g=Up(d,n),[y,b]=XP(Object.assign({elements:d,valueof:g,link:i,coordinate:c},$t(u.active,"link"))),[x,_,w]=qP(Object.assign({document:t.ownerDocument,scale:s,coordinate:c,background:a,valueof:g},$t(u.active,"background"))),O=mt(u,{active:Object.assign({},((f=u.active)===null||f===void 0?void 0:f.offset)&&{transform:(...G)=>{const F=u.active.offset(...G),[,W]=G;return UP(d[W],F,c)}})}),{setState:E,removeState:M,hasState:k}=lc(O,g);let A;const P=G=>{const{target:F,nativeEvent:W=!0}=G;if(!h.has(F))return;A&&clearTimeout(A);const X=r(F),Q=v.get(X),tt=new Set(Q);for(const nt of d)tt.has(nt)?k(nt,"active")||E(nt,"active"):(E(nt,"inactive"),b(nt)),nt!==F&&_(nt);x(F),y(Q),W&&l.emit("element:highlight",{nativeEvent:W,data:{data:n(F),group:Q.map(n)}})},C=()=>{A&&clearTimeout(A),A=setTimeout(()=>{N(),A=null},o)},N=(G=!0)=>{for(const F of d)M(F,"active","inactive"),_(F),b(F);G&&l.emit("element:unhighlight",{nativeEvent:G})},L=G=>{const{target:F}=G;a&&!w(F)||!a&&!h.has(F)||(o>0?C():N())},R=()=>{N()};t.addEventListener("pointerover",P),t.addEventListener("pointerout",L),t.addEventListener("pointerleave",R);const I=G=>{const{nativeEvent:F}=G;F||N(!1)},D=G=>{const{nativeEvent:F}=G;if(F)return;const{data:W}=G.data,X=qw(d,W,n);X&&P({target:X,nativeEvent:!1})};return l.on("element:highlight",D),l.on("element:unhighlight",I),()=>{t.removeEventListener("pointerover",P),t.removeEventListener("pointerout",L),t.removeEventListener("pointerleave",R),l.off("element:highlight",D),l.off("element:unhighlight",I);for(const G of d)_(G),b(G)}}function b1(t){var{delay:e,createGroup:n,background:r=!1,link:i=!1}=t,a=aU(t,["delay","createGroup","background","link"]);return(o,s,c)=>{const{container:l,view:u,options:f}=o,{scale:d,coordinate:h}=u,v=ys(l);return oU(v,Object.assign({elements:cl,datum:wu(u),groupKey:n?n(u):void 0,coordinate:h,scale:d,state:ld(f,[["active",r?{}:{lineWidth:"1",stroke:"#000"}],"inactive"]),background:r,link:i,delay:e,emitter:c},a))}}b1.props={reapplyWhenUpdate:!0};function HN(t){return b1(Object.assign(Object.assign({},t),{createGroup:Uw}))}HN.props={reapplyWhenUpdate:!0};function VN(t){return b1(Object.assign(Object.assign({},t),{createGroup:VP}))}VN.props={reapplyWhenUpdate:!0};var sU=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function cU(t,{elements:e,datum:n,groupKey:r=f=>f,link:i=!1,single:a=!1,coordinate:o,background:s=!1,scale:c,emitter:l,state:u={}}){var f;const d=e(t),h=new Set(d),v=dr(d,r),g=Up(d,n),[y,b]=XP(Object.assign({link:i,elements:d,valueof:g,coordinate:o},$t(u.selected,"link"))),[x,_]=qP(Object.assign({document:t.ownerDocument,background:s,coordinate:o,scale:c,valueof:g},$t(u.selected,"background"))),w=mt(u,{selected:Object.assign({},((f=u.selected)===null||f===void 0?void 0:f.offset)&&{transform:(...R)=>{const I=u.selected.offset(...R),[,D]=R;return UP(d[D],I,o)}})}),{setState:O,removeState:E,hasState:M}=lc(w,g),k=(R=!0)=>{for(const I of d)E(I,"selected","unselected"),b(I),_(I);R&&l.emit("element:unselect",{nativeEvent:!0})},A=(R,I,D=!0)=>{if(M(I,"selected"))k();else{const G=r(I),F=v.get(G),W=new Set(F);for(const X of d)W.has(X)?O(X,"selected"):(O(X,"unselected"),b(X)),X!==I&&_(X);if(y(F),x(I),!D)return;l.emit("element:select",Object.assign(Object.assign({},R),{nativeEvent:D,data:{data:[n(I),...F.map(n)]}}))}},P=(R,I,D=!0)=>{const G=r(I),F=v.get(G),W=new Set(F);if(M(I,"selected")){if(!d.some(Q=>!W.has(Q)&&M(Q,"selected")))return k();for(const Q of F)O(Q,"unselected"),b(Q),_(Q)}else{const X=F.some(Q=>M(Q,"selected"));for(const Q of d)W.has(Q)?O(Q,"selected"):M(Q,"selected")||O(Q,"unselected");!X&&i&&y(F),x(I)}D&&l.emit("element:select",Object.assign(Object.assign({},R),{nativeEvent:D,data:{data:d.filter(X=>M(X,"selected")).map(n)}}))},C=R=>{const{target:I,nativeEvent:D=!0}=R;return h.has(I)?a?A(R,I,D):P(R,I,D):k()};t.addEventListener("click",C);const N=R=>{const{nativeEvent:I,data:D}=R;if(I)return;const G=a?D.data.slice(0,1):D.data;for(const F of G){const W=qw(d,F,n);C({target:W,nativeEvent:!1})}},L=()=>{k(!1)};return l.on("element:select",N),l.on("element:unselect",L),()=>{for(const R of d)b(R);t.removeEventListener("click",C),l.off("element:select",N),l.off("element:unselect",L)}}function x1(t){var{createGroup:e,background:n=!1,link:r=!1}=t,i=sU(t,["createGroup","background","link"]);return(a,o,s)=>{const{container:c,view:l,options:u}=a,{coordinate:f,scale:d}=l,h=ys(c);return cU(h,Object.assign({elements:cl,datum:wu(l),groupKey:e?e(l):void 0,coordinate:f,scale:d,state:ld(u,[["selected",n?{}:{lineWidth:"1",stroke:"#000"}],"unselected"]),background:n,link:r,emitter:s},i))}}x1.props={reapplyWhenUpdate:!0};function XN(t){return x1(Object.assign(Object.assign({},t),{createGroup:Uw}))}XN.props={reapplyWhenUpdate:!0};function UN(t){return x1(Object.assign(Object.assign({},t),{createGroup:VP}))}UN.props={reapplyWhenUpdate:!0};var Nu=function(t,e,n){var r,i,a,o,s=0;n||(n={});var c=function(){s=n.leading===!1?0:Date.now(),r=null,o=t.apply(i,a),r||(i=a=null)},l=function(){var u=Date.now();!s&&n.leading===!1&&(s=u);var f=e-(u-s);return i=this,a=arguments,f<=0||f>e?(r&&(clearTimeout(r),r=null),s=u,o=t.apply(i,a),r||(i=a=null)):!r&&n.trailing!==!1&&(r=setTimeout(c,f)),o};return l.cancel=function(){clearTimeout(r),s=0,r=i=a=null},l};function lU(t){const{coordinate:e={}}=t,{transform:n=[]}=e,r=n.find(a=>a.type==="fisheye");if(r)return r;const i={type:"fisheye"};return n.push(i),e.transform=n,t.coordinate=e,i}function uU({wait:t=30,leading:e,trailing:n=!1}){return r=>{const{options:i,update:a,setState:o,container:s}=r,c=ys(s),l=Nu(u=>{const f=Xp(c,u);if(!f){o("fisheye"),a();return}o("fisheye",d=>{const h=mt({},d,{interaction:{tooltip:{preserve:!0}}});for(const b of h.marks)b.animate=!1;const[v,g]=f,y=lU(h);return y.focusX=v,y.focusY=g,y.visual=!0,h}),a()},t,{leading:e,trailing:n});return c.addEventListener("pointerenter",l),c.addEventListener("pointermove",l),c.addEventListener("pointerleave",l),()=>{c.removeEventListener("pointerenter",l),c.removeEventListener("pointermove",l),c.removeEventListener("pointerleave",l)}}}var fU=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})},dU=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function hU(t){const{transform:e=[]}=t,n=e.find(i=>i.type==="normalizeY");if(n)return n;const r={type:"normalizeY"};return e.push(r),t.transform=e,r}function pU(t,e,n){const[r]=Array.from(t.entries()).filter(([i])=>i.type===e).map(([i])=>{const{encode:a}=i,o=s=>{const c=a[s];return[s,c?c.value:void 0]};return Object.fromEntries(n.map(o))});return r}function qN(t){var{wait:e=20,leading:n,trailing:r=!1,labelFormatter:i=o=>`${o}`}=t,a=dU(t,["wait","leading","trailing","labelFormatter"]);return o=>{const{view:s,container:c,update:l,setState:u}=o,{markState:f,scale:d,coordinate:h}=s,v=pU(f,"line",["x","y","series"]);if(!v)return;const{y:g,x:y,series:b=[]}=v,x=g.map((G,F)=>F),_=Wo(x.map(G=>y[G])),w=ys(c),O=c.getElementsByClassName(ma),E=c.getElementsByClassName(Wi),k=dr(E,G=>G.__data__.key.split("-")[0]),A=new su({style:Object.assign({x1:0,y1:0,x2:0,y2:w.getAttribute("height"),stroke:"black",lineWidth:1},$t(a,"rule"))}),P=new po({style:Object.assign({x:0,y:w.getAttribute("height"),text:"",fontSize:10},$t(a,"label"))});A.append(P),w.appendChild(A);const C=(G,F,W)=>{const[X]=G.invert(W),Q=F.invert(X);return _[qz(_,Q)]},N=(G,F)=>{A.setAttribute("x1",G[0]),A.setAttribute("x2",G[0]),P.setAttribute("text",i(F))};let L;const R=G=>fU(this,void 0,void 0,function*(){const{x:F}=d,W=C(h,F,G);N(G,W),u("chartIndex",Q=>{const tt=mt({},Q),nt=tt.marks.find(gt=>gt.type==="line"),lt=Dn(U_(x,gt=>Dn(gt,Bt=>+g[Bt])/Za(gt,Bt=>+g[Bt]),gt=>b[gt]).values()),wt=[1/lt,lt];mt(nt,{scale:{y:{domain:wt}}});const yt=hU(nt);yt.groupBy="color",yt.basis=(gt,Bt)=>{const Lt=gt[ol(It=>y[+It]).center(gt,W)];return Bt[Lt]};for(const gt of tt.marks)gt.animate=!1;return tt}),L=(yield l("chartIndex")).view}),I=G=>{const{scale:F,coordinate:W}=L,{x:X,y:Q}=F,tt=C(W,X,G);N(G,tt);for(const nt of O){const{seriesIndex:ht,key:lt}=nt.__data__,wt=ht[ol(Qt=>y[+Qt]).center(ht,tt)],yt=[0,Q.map(1)],gt=[0,Q.map(g[wt]/g[ht[0]])],[,Bt]=W.map(yt),[,Lt]=W.map(gt),It=Bt-Lt;nt.setAttribute("transform",`translate(0, ${It})`);const jt=k.get(lt)||[];for(const Qt of jt)Qt.setAttribute("dy",It)}},D=Nu(G=>{const F=Xp(w,G);F&&I(F)},e,{leading:n,trailing:r});return R([0,0]),w.addEventListener("pointerenter",D),w.addEventListener("pointermove",D),w.addEventListener("pointerleave",D),()=>{A.remove(),w.removeEventListener("pointerenter",D),w.removeEventListener("pointermove",D),w.removeEventListener("pointerleave",D)}}}qN.props={reapplyWhenUpdate:!0};function b0(t,e){let n,r=-1,i=-1;if(e===void 0)for(const a of t)++i,a!=null&&(n>a||n===void 0&&a>=a)&&(n=a,r=i);else for(let a of t)(a=e(a,++i,t))!=null&&(n>a||n===void 0&&a>=a)&&(n=a,r=i);return r}function x0(t,e){let n=0,r=0;if(e===void 0)for(let i of t)i!=null&&(i=+i)>=i&&(++n,r+=i);else{let i=-1;for(let a of t)(a=e(a,++i,t))!=null&&(a=+a)>=a&&(++n,r+=a)}if(n)return r/n}function KN(t){var e=document.createElement("div");e.innerHTML=t;var n=e.childNodes[0];return n&&e.contains(n)&&e.removeChild(n),n}function vU(t,e){return!t||!e?t:t.replace(/\\?\{([^{}]+)\}/g,function(n,r){return n.charAt(0)==="\\"?n.slice(1):e[r]===void 0?"":e[r]})}var gU=vU,QN=function(t,e){if(e==null){t.innerHTML="";return}t.replaceChildren?Array.isArray(e)?t.replaceChildren.apply(t,te([],V(e),!1)):t.replaceChildren(e):(t.innerHTML="",Array.isArray(e)?e.forEach(function(n){return t.appendChild(n)}):t.appendChild(e))};function fS(t){return t===void 0&&(t=""),{CONTAINER:"".concat(t,"tooltip"),TITLE:"".concat(t,"tooltip-title"),LIST:"".concat(t,"tooltip-list"),LIST_ITEM:"".concat(t,"tooltip-list-item"),NAME:"".concat(t,"tooltip-list-item-name"),MARKER:"".concat(t,"tooltip-list-item-marker"),NAME_LABEL:"".concat(t,"tooltip-list-item-name-label"),VALUE:"".concat(t,"tooltip-list-item-value"),CROSSHAIR_X:"".concat(t,"tooltip-crosshair-x"),CROSSHAIR_Y:"".concat(t,"tooltip-crosshair-y")}}var JN={overflow:"hidden","white-space":"nowrap","text-overflow":"ellipsis"};function yU(t){var e;t===void 0&&(t="");var n=fS(t);return e={},e[".".concat(n.CONTAINER)]={position:"absolute",visibility:"visible","z-index":8,transition:"visibility 0.2s cubic-bezier(0.23, 1, 0.32, 1), left 0.4s cubic-bezier(0.23, 1, 0.32, 1), top 0.4s cubic-bezier(0.23, 1, 0.32, 1)","background-color":"rgba(255, 255, 255, 0.96)","box-shadow":"0 6px 12px 0 rgba(0, 0, 0, 0.12)","border-radius":"4px",color:"rgba(0, 0, 0, 0.65)","font-size":"12px","line-height":"20px",padding:"12px","min-width":"120px","max-width":"360px","font-family":"Roboto-Regular"},e[".".concat(n.TITLE)]={color:"rgba(0, 0, 0, 0.45)"},e[".".concat(n.LIST)]={margin:"0px","list-style-type":"none",padding:"0px"},e[".".concat(n.LIST_ITEM)]={"list-style-type":"none",display:"flex","line-height":"2em","align-items":"center","justify-content":"space-between","white-space":"nowrap"},e[".".concat(n.MARKER)]={width:"8px",height:"8px","border-radius":"50%",display:"inline-block","margin-right":"4px"},e[".".concat(n.NAME)]={display:"flex","align-items":"center","max-width":"216px"},e[".".concat(n.NAME_LABEL)]=At({flex:1},JN),e[".".concat(n.VALUE)]=At({display:"inline-block",float:"right",flex:1,"text-align":"right","min-width":"28px","margin-left":"30px",color:"rgba(0, 0, 0, 0.85)"},JN),e[".".concat(n.CROSSHAIR_X)]={position:"absolute",width:"1px","background-color":"rgba(0, 0, 0, 0.25)"},e[".".concat(n.CROSSHAIR_Y)]={position:"absolute",height:"1px","background-color":"rgba(0, 0, 0, 0.25)"},e}var mU=function(t){ar(e,t);function e(n){var r=this,i,a,o=(a=(i=n.style)===null||i===void 0?void 0:i.template)===null||a===void 0?void 0:a.prefixCls,s=fS(o);return r=t.call(this,n,{data:[],x:0,y:0,visibility:"visible",title:"",position:"bottom-right",offset:[5,5],enterable:!1,container:{x:0,y:0},bounding:null,template:{prefixCls:"",container:'<div class="'.concat(s.CONTAINER,'"></div>'),title:'<div class="'.concat(s.TITLE,'"></div>'),item:'<li class="'.concat(s.LIST_ITEM,`" data-index={index}>
        <span class="`).concat(s.NAME,`">
          <span class="`).concat(s.MARKER,`" style="background:{color}"></span>
          <span class="`).concat(s.NAME_LABEL,`" title="{name}">{name}</span>
        </span>
        <span class="`).concat(s.VALUE,`" title="{value}">{value}</span>
      </li>`)},style:yU(o)})||this,r.timestamp=-1,r.prevCustomContentKey=r.attributes.contentKey,r.initShape(),r.render(r.attributes,r),r}return Object.defineProperty(e.prototype,"HTMLTooltipElement",{get:function(){return this.element},enumerable:!1,configurable:!0}),e.prototype.getContainer=function(){return this.element},Object.defineProperty(e.prototype,"elementSize",{get:function(){var n=this.element.offsetWidth,r=this.element.offsetHeight;return{width:n,height:r}},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"HTMLTooltipItemsElements",{get:function(){var n=this.attributes,r=n.data,i=n.template;return r.map(function(a,o){var s=a.name,c=s===void 0?"":s,l=a.color,u=l===void 0?"black":l,f=a.index,d=$r(a,["name","color","index"]),h=At({name:c,color:u,index:f!=null?f:o},d);return KN(gU(i.item,h))})},enumerable:!1,configurable:!0}),e.prototype.render=function(n,r){this.renderHTMLTooltipElement(),this.updatePosition()},e.prototype.destroy=function(){var n;(n=this.element)===null||n===void 0||n.remove(),t.prototype.destroy.call(this)},e.prototype.show=function(n,r){var i=this;if(n!==void 0&&r!==void 0){var a=this.element.style.visibility==="hidden",o=function(){i.attributes.x=n!=null?n:i.attributes.x,i.attributes.y=r!=null?r:i.attributes.y,i.updatePosition()};a?this.closeTransition(o):o()}this.element.style.visibility="visible"},e.prototype.hide=function(n,r){n===void 0&&(n=0),r===void 0&&(r=0);var i=this.attributes.enterable;i&&this.isCursorEntered(n,r)||(this.element.style.visibility="hidden")},e.prototype.initShape=function(){var n=this.attributes.template;this.element=KN(n.container),this.id&&this.element.setAttribute("id",this.id)},e.prototype.renderCustomContent=function(){if(!(this.prevCustomContentKey!==void 0&&this.prevCustomContentKey===this.attributes.contentKey)){this.prevCustomContentKey=this.attributes.contentKey;var n=this.attributes.content;n&&(typeof n=="string"?this.element.innerHTML=n:QN(this.element,n))}},e.prototype.renderHTMLTooltipElement=function(){var n,r,i=this.attributes,a=i.template,o=i.title,s=i.enterable,c=i.style,l=i.content,u=fS(a.prefixCls),f=this.element;if(this.element.style.pointerEvents=s?"auto":"none",l)this.renderCustomContent();else{o?(f.innerHTML=a.title,f.getElementsByClassName(u.TITLE)[0].innerHTML=o):(r=(n=f.getElementsByClassName(u.TITLE))===null||n===void 0?void 0:n[0])===null||r===void 0||r.remove();var d=this.HTMLTooltipItemsElements,h=document.createElement("ul");h.className=u.LIST,QN(h,d);var v=this.element.querySelector(".".concat(u.LIST));v?v.replaceWith(h):f.appendChild(h)}g9(f,c)},e.prototype.getRelativeOffsetFromCursor=function(n){var r=this.attributes,i=r.position,a=r.offset,o=n||i,s=o.split("-"),c={left:[-1,0],right:[1,0],top:[0,-1],bottom:[0,1]},l=this.elementSize,u=l.width,f=l.height,d=[-u/2,-f/2];return s.forEach(function(h){var v=V(d,2),g=v[0],y=v[1],b=V(c[h],2),x=b[0],_=b[1];d=[g+(u/2+a[0])*x,y+(f/2+a[1])*_]}),d},e.prototype.setOffsetPosition=function(n){var r=V(n,2),i=r[0],a=r[1],o=this.attributes,s=o.x,c=s===void 0?0:s,l=o.y,u=l===void 0?0:l,f=o.container,d=f.x,h=f.y;this.element.style.left="".concat(+c+d+i,"px"),this.element.style.top="".concat(+u+h+a,"px")},e.prototype.updatePosition=function(){var n=this.attributes.showDelay,r=n===void 0?60:n,i=Date.now();this.timestamp>0&&i-this.timestamp<r||(this.timestamp=i,this.setOffsetPosition(this.autoPosition(this.getRelativeOffsetFromCursor())))},e.prototype.autoPosition=function(n){var r=V(n,2),i=r[0],a=r[1],o=this.attributes,s=o.x,c=o.y,l=o.bounding,u=o.position;if(!l)return[i,a];var f=this.element,d=f.offsetWidth,h=f.offsetHeight,v=V([+s+i,+c+a],2),g=v[0],y=v[1],b={left:"right",right:"left",top:"bottom",bottom:"top"},x=l.x,_=l.y,w=l.width,O=l.height,E={left:g<x,right:g+d>x+w,top:y<_,bottom:y+h>_+O},M=[];u.split("-").forEach(function(A){E[A]?M.push(b[A]):M.push(A)});var k=M.join("-");return this.getRelativeOffsetFromCursor(k)},e.prototype.isCursorEntered=function(n,r){if(this.element){var i=this.element.getBoundingClientRect(),a=i.x,o=i.y,s=i.width,c=i.height;return new pr(a,o,s,c).isPointIn(n,r)}return!1},e.prototype.closeTransition=function(n){var r=this,i=this.element.style.transition;this.element.style.transition="none",n(),setTimeout(function(){r.element.style.transition=i},10)},e.tag="tooltip",e}(bi),Iu=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function _1(t,e){return e?typeof e=="string"?document.querySelector(e):e:t.ownerDocument.defaultView.getContextService().getDomElement().parentElement}function bU(t){const e=t.getRenderBounds(),{min:[n,r],max:[i,a]}=e;return{x:n,y:r,width:i-n,height:a-r}}function xU(t,e){const n=t.getBoundingClientRect(),r=e.getBoundingClientRect();return{x:n.x-r.x,y:n.y-r.y}}function _U(t,e,n,r,i,a,o,s={},c=[10,10]){const l={".g2-tooltip":{},".g2-tooltip-title":{overflow:"hidden","white-space":"nowrap","text-overflow":"ellipsis"}},u=new mU({className:"tooltip",style:{x:e,y:n,container:o,data:[],bounding:a,position:r,enterable:i,title:"",offset:c,template:{prefixCls:"g2-"},style:mt(l,s)}});return t.appendChild(u.HTMLTooltipElement),u}function t4({root:t,data:e,x:n,y:r,render:i,event:a,single:o,position:s="right-bottom",enterable:c=!1,css:l,mount:u,bounding:f,offset:d}){const h=_1(t,u),v=_1(t),g=o?v:t,y=f||bU(t),b=xU(v,h),{tooltipElement:x=_U(h,n,r,s,c,y,b,l,d)}=g,{items:_,title:w=""}=e;x.update(Object.assign({x:n,y:r,data:_,title:w,position:s,enterable:c,container:b},i!==void 0&&{content:i(a,{items:_,title:w})})),g.tooltipElement=x}function yl({root:t,single:e,emitter:n,nativeEvent:r=!0,event:i=null}){r&&n.emit("tooltip:hide",{nativeEvent:r});const a=_1(t),o=e?a:t,{tooltipElement:s}=o;s&&s.hide(i==null?void 0:i.clientX,i==null?void 0:i.clientY),a4(t),o4(t),s4(t)}function dS({root:t,single:e}){const n=_1(t),r=e?n:t;if(!r)return;const{tooltipElement:i}=r;i&&(i.destroy(),r.tooltipElement=void 0),a4(t),o4(t),s4(t)}function e4(t){const{value:e}=t;return Object.assign(Object.assign({},t),{value:e===void 0?"undefined":e})}function wU(t){const{__data__:e}=t,{title:n,items:r=[]}=e,i=r.filter(qn).map(a=>{var{color:o=n4(t)}=a,s=Iu(a,["color"]);return Object.assign(Object.assign({},s),{color:o})}).map(e4);return Object.assign(Object.assign({},n&&{title:n}),{items:i})}function OU(t,e){const{color:n,series:r,facet:i=!1}=t,{color:a,series:o}=e,s=c=>c&&c.invert&&!(c instanceof pl)&&!(c instanceof Dp);if(s(r))return r.clone().invert(o);if(o&&r instanceof pl&&r.invert(o)!==a&&!i)return r.invert(o);if(s(n)){const c=n.invert(a);return Array.isArray(c)?null:c}return null}function n4(t){const e=t.getAttribute("fill"),n=t.getAttribute("stroke"),{__data__:r}=t,{color:i=e&&e!=="transparent"?e:n}=r;return i}function r4(t,e=n=>n){const n=new Map(t.map(r=>[e(r),r]));return Array.from(n.values())}function i4(t,e,n,r=t.map(a=>a.__data__),i={}){const a=c=>c instanceof Date?+c:c,o=r4(r.map(c=>c.title),a).filter(qn),s=r.flatMap((c,l)=>{const u=t[l],{items:f=[],title:d}=c,h=f.filter(qn),v=n!==void 0?n:f.length<=1;return h.map(g=>{var{color:y=n4(u)||i.color,name:b}=g,x=Iu(g,["color","name"]);const _=OU(e,c),w=v?_||b:b||_;return Object.assign(Object.assign({},x),{color:y,name:w||d})})}).map(e4);return Object.assign(Object.assign({},o.length>0&&{title:o.join(",")}),{items:r4(s,c=>`(${a(c.name)}, ${a(c.value)}, ${a(c.color)})`)})}function SU(t,e,n,r){var{plotWidth:i,plotHeight:a,mainWidth:o,mainHeight:s,startX:c,startY:l,transposed:u,polar:f,insetLeft:d,insetTop:h}=r,v=Iu(r,["plotWidth","plotHeight","mainWidth","mainHeight","startX","startY","transposed","polar","insetLeft","insetTop"]);const g=Object.assign({lineWidth:1,stroke:"#1b1e23",strokeOpacity:.5},v),y=(E,M,k)=>{const A=new tc({style:Object.assign({cx:E,cy:M,r:k},g)});return t.appendChild(A),A},b=(E,M,k,A)=>{const P=new su({style:Object.assign({x1:E,x2:M,y1:k,y2:A},g)});return t.appendChild(P),P},_=((E,M)=>{if(M.length===1)return M[0];const k=M.map(P=>wr(P,E)),A=b0(k,P=>P);return M[A]})(n,e),w=()=>u?[c+_[0],c+_[0],l,l+a]:[c,c+i,_[1]+l,_[1]+l],O=()=>{const E=c+d+o/2,M=l+h+s/2,k=wr([E,M],_);return[E,M,k]};if(f){const[E,M,k]=O(),A=t.ruleX||y(E,M,k);A.style.cx=E,A.style.cy=M,A.style.r=k,t.ruleX=A}else{const[E,M,k,A]=w(),P=t.ruleX||b(E,M,k,A);P.style.x1=E,P.style.x2=M,P.style.y1=k,P.style.y2=A,t.ruleX=P}}function EU(t,e,n){var{plotWidth:r,plotHeight:i,mainWidth:a,mainHeight:o,startX:s,startY:c,transposed:l,polar:u,insetLeft:f,insetTop:d}=n,h=Iu(n,["plotWidth","plotHeight","mainWidth","mainHeight","startX","startY","transposed","polar","insetLeft","insetTop"]);const v=Object.assign({lineWidth:1,stroke:"#1b1e23",strokeOpacity:.5},h),g=e.map(A=>A[1]),y=e.map(A=>A[0]),b=x0(g),x=x0(y),_=()=>{if(u){const A=Math.min(a,o)/2,P=s+f+a/2,C=c+d+o/2,N=wo(Mr([x,b],[P,C])),L=P+A*Math.cos(N),R=C+A*Math.sin(N);return[P,L,C,R]}return l?[s,s+r,b+c,b+c]:[x+s,x+s,c,c+i]},[w,O,E,M]=_(),k=()=>{const A=new su({style:Object.assign({x1:w,x2:O,y1:E,y2:M},v)});return t.appendChild(A),A};if(y.length>0){const A=t.ruleY||k();A.style.x1=w,A.style.x2=O,A.style.y1=E,A.style.y2=M,t.ruleY=A}}function a4(t){t.ruleY&&(t.ruleY.remove(),t.ruleY=void 0)}function o4(t){t.ruleX&&(t.ruleX.remove(),t.ruleX=void 0)}function MU(t,{data:e,style:n,theme:r}){t.markers&&t.markers.forEach(o=>o.remove());const{type:i=""}=n,a=e.filter(o=>{const[{x:s,y:c}]=o;return qn(s)&&qn(c)}).map(o=>{const[{color:s,element:c},l]=o,u=s||c.style.fill||c.style.stroke||r.color,f=i==="hollow"?"transparent":u,d=i==="hollow"?u:"#fff";return new tc({className:"g2-tooltip-marker",style:Object.assign({cx:l[0],cy:l[1],fill:f,r:4,stroke:d,lineWidth:2},n)})});for(const o of a)t.appendChild(o);t.markers=a}function s4(t){t.markers&&(t.markers.forEach(e=>e.remove()),t.markers=[])}function c4(t,e){return Array.from(t.values()).some(n=>{var r;return(r=n.interaction)===null||r===void 0?void 0:r[e]})}function fc(t,e){return t===void 0?e:t}function l4(t){const{title:e,items:n}=t;return n.length===0&&e===void 0}function kU(t){return Array.from(t.values()).some(e=>{var n;return((n=e.interaction)===null||n===void 0?void 0:n.seriesTooltip)&&e.tooltip})}function u4(t,e){var{elements:n,sort:r,filter:i,scale:a,coordinate:o,crosshairs:s,crosshairsX:c,crosshairsY:l,render:u,groupName:f,emitter:d,wait:h=50,leading:v=!0,trailing:g=!1,startX:y=0,startY:b=0,body:x=!0,single:_=!0,position:w,enterable:O,mount:E,bounding:M,theme:k,offset:A,disableNative:P=!1,marker:C=!0,preserve:N=!1,style:L={},css:R={}}=e,I=Iu(e,["elements","sort","filter","scale","coordinate","crosshairs","crosshairsX","crosshairsY","render","groupName","emitter","wait","leading","trailing","startX","startY","body","single","position","enterable","mount","bounding","theme","offset","disableNative","marker","preserve","style","css"]);const D=n(t),G=hr(o),F=Bn(o),W=mt(L,I),{innerWidth:X,innerHeight:Q,width:tt,height:nt,insetLeft:ht,insetTop:lt}=o.getOptions(),wt=[],yt=[];for(const ce of D){const{__data__:Ie}=ce,{seriesX:Qe,title:nn,items:Qn}=Ie;Qe?wt.push(ce):(nn||Qn)&&yt.push(ce)}const gt=ce=>ce.markType==="interval",Bt=yt.length&&yt.every(gt)&&!Bn(o),Lt=ce=>ce.__data__.x,jt=!!a.x.getBandWidth&&yt.length>0;wt.sort((ce,Ie)=>{const Qe=G?0:1,nn=Qn=>Qn.getBounds().min[Qe];return G?nn(Ie)-nn(ce):nn(ce)-nn(Ie)});const Qt=ce=>{const Ie=G?1:0,{min:Qe,max:nn}=ce.getLocalBounds();return Wo([Qe[Ie],nn[Ie]])};Bt?D.sort((ce,Ie)=>Lt(ce)-Lt(Ie)):yt.sort((ce,Ie)=>{const[Qe,nn]=Qt(ce),[Qn,Fr]=Qt(Ie),Br=(Qe+nn)/2,ji=(Qn+Fr)/2;return G?ji-Br:Br-ji});const ue=new Map(wt.map(ce=>{const{__data__:Ie}=ce,{seriesX:Qe}=Ie,nn=Qe.map((Fr,Br)=>Br),Qn=Wo(nn,Fr=>Qe[+Fr]);return[ce,[Qn,Qe]]})),{x:ye}=a,Ke=ye!=null&&ye.getBandWidth?ye.getBandWidth()/2:0,be=ce=>{const[Ie]=o.invert(ce);return Ie-Ke},Ne=(ce,Ie,Qe,nn)=>{const{_x:Qn}=ce,Fr=Qn!==void 0?ye.map(Qn):be(Ie),Br=nn.filter(qn),[ji,Co]=Wo([Br[0],Br[Br.length-1]]),Vo=ji===Co;if(!jt&&(Fr<ji||Fr>Co)&&!Vo)return null;const jd=ol(mc=>nn[+mc]).center,tv=jd(Qe,Fr);return Qe[tv]},Pn=Bt?(ce,Ie)=>{const Qe=ol(Lt).center,nn=Qe(Ie,be(ce)),Qn=Ie[nn];return dr(Ie,Lt).get(Lt(Qn))}:(ce,Ie)=>{const nn=ce[G?1:0],Qn=Ie.filter(ji=>{const[Co,Vo]=Qt(ji);return nn>=Co&&nn<=Vo});if(!jt||Qn.length>0)return Qn;const Fr=ol(ji=>{const[Co,Vo]=Qt(ji);return(Co+Vo)/2}).center,Br=Fr(Ie,nn);return[Ie[Br]].filter(qn)},qr=(ce,Ie)=>{const{__data__:Qe}=ce;return Object.fromEntries(Object.entries(Qe).filter(([nn])=>nn.startsWith("series")&&nn!=="series").map(([nn,Qn])=>{const Fr=Qn[Ie];return[TA(nn.replace("series","")),Fr]}))},fi=Nu(ce=>{var Ie;const Qe=Xp(t,ce);if(!Qe)return;const nn=HP(t),Qn=nn.min[0],Fr=nn.min[1],Br=[Qe[0]-y,Qe[1]-b];if(!Br)return;const ji=Pn(Br,yt),Co=[],Vo=[];for(const Jr of wt){const[ev,nM]=ue.get(Jr),nv=Ne(ce,Br,ev,nM);if(nv!==null){Co.push(Jr);const bb=qr(Jr,nv),{x:_at,y:wat}=bb,Oat=o.map([(_at||0)+Ke,wat||0]);Vo.push([Object.assign(Object.assign({},bb),{element:Jr}),Oat])}}const jd=Array.from(new Set(Vo.map(Jr=>Jr[0].x))),tv=jd[b0(jd,Jr=>Math.abs(Jr-be(Br)))],mc=Vo.filter(Jr=>Jr[0].x===tv),tM=[...mc.map(Jr=>Jr[0]),...ji.map(Jr=>Jr.__data__)],mb=[...Co,...ji],Fd=i4(mb,a,f,tM,k);if(r&&Fd.items.sort((Jr,ev)=>r(Jr)-r(ev)),i&&(Fd.items=Fd.items.filter(i)),mb.length===0||l4(Fd)){yr(ce);return}if(x&&t4({root:t,data:Fd,x:Qe[0]+Qn,y:Qe[1]+Fr,render:u,event:ce,single:_,position:w,enterable:O,mount:E,bounding:M,css:R,offset:A}),s||c||l){const Jr=$t(W,"crosshairs"),ev=Object.assign(Object.assign({},Jr),$t(W,"crosshairsX")),nM=Object.assign(Object.assign({},Jr),$t(W,"crosshairsY")),nv=mc.map(bb=>bb[1]);c&&SU(t,nv,Qe,Object.assign(Object.assign({},ev),{plotWidth:X,plotHeight:Q,mainWidth:tt,mainHeight:nt,insetLeft:ht,insetTop:lt,startX:y,startY:b,transposed:G,polar:F})),l&&EU(t,nv,Object.assign(Object.assign({},nM),{plotWidth:X,plotHeight:Q,mainWidth:tt,mainHeight:nt,insetLeft:ht,insetTop:lt,startX:y,startY:b,transposed:G,polar:F}))}if(C){const Jr=$t(W,"marker");MU(t,{data:mc,style:Jr,theme:k})}const eM=(Ie=mc[0])===null||Ie===void 0?void 0:Ie[0].x,xat=eM!=null?eM:be(Br);d.emit("tooltip:show",Object.assign(Object.assign({},ce),{nativeEvent:!0,data:Object.assign(Object.assign({},Fd),{data:{x:sd(a.x,xat,!0)}})}))},h,{leading:v,trailing:g}),yr=ce=>{yl({root:t,single:_,emitter:d,event:ce})},oi=()=>{dS({root:t,single:_})},Kr=ce=>{var Ie,{nativeEvent:Qe,data:nn,offsetX:Qn,offsetY:Fr}=ce,Br=Iu(ce,["nativeEvent","data","offsetX","offsetY"]);if(Qe)return;const ji=(Ie=nn==null?void 0:nn.data)===null||Ie===void 0?void 0:Ie.x,Vo=a.x.map(ji),[jd,tv]=o.map([Vo,.5]),mc=t.getRenderBounds(),tM=mc.min[0],mb=mc.min[1];fi(Object.assign(Object.assign({},Br),{offsetX:Qn!==void 0?Qn:tM+jd,offsetY:Fr!==void 0?Fr:mb+tv,_x:ji}))},si=()=>{yl({root:t,single:_,emitter:d,nativeEvent:!1})},Kn=()=>{ci(),oi()},Qr=()=>{Di()},Di=()=>{P||(t.addEventListener("pointerenter",fi),t.addEventListener("pointermove",fi),t.addEventListener("pointerleave",ce=>{Xp(t,ce)||yr(ce)}))},ci=()=>{P||(t.removeEventListener("pointerenter",fi),t.removeEventListener("pointermove",fi),t.removeEventListener("pointerleave",yr))};return Di(),d.on("tooltip:show",Kr),d.on("tooltip:hide",si),d.on("tooltip:disable",Kn),d.on("tooltip:enable",Qr),()=>{ci(),d.off("tooltip:show",Kr),d.off("tooltip:hide",si),d.off("tooltip:disable",Kn),d.off("tooltip:enable",Qr),N?yl({root:t,single:_,emitter:d,nativeEvent:!1}):oi()}}function AU(t,{elements:e,coordinate:n,scale:r,render:i,groupName:a,sort:o,filter:s,emitter:c,wait:l=50,leading:u=!0,trailing:f=!1,groupKey:d=C=>C,single:h=!0,position:v,enterable:g,datum:y,view:b,mount:x,bounding:_,theme:w,offset:O,shared:E=!1,body:M=!0,disableNative:k=!1,preserve:A=!1,css:P={}}){var C,N;const L=e(t),R=dr(L,d),I=It=>It.markType==="interval",D=L.every(I)&&!Bn(n),G=r.x,F=r.series,W=(N=(C=G==null?void 0:G.getBandWidth)===null||C===void 0?void 0:C.call(G))!==null&&N!==void 0?N:0,X=F?It=>{const jt=Math.round(1/F.valueBandWidth);return It.__data__.x+It.__data__.series*W+W/(jt*2)}:It=>It.__data__.x+W/2;D&&L.sort((It,jt)=>X(It)-X(jt));const Q=It=>{const{target:jt}=It;return jm(jt,Qt=>Qt.classList?Qt.classList.includes("element"):!1)},tt=D?It=>{const jt=Xp(t,It);if(!jt)return;const[Qt]=n.invert(jt),ue=ol(X).center,ye=ue(L,Qt),Ke=L[ye];return!E&&L.find(Ne=>Ne!==Ke&&X(Ne)===X(Ke))?Q(It):Ke}:Q,nt=Nu(It=>{const jt=tt(It);if(!jt){yl({root:t,single:h,emitter:c,event:It});return}const Qt=d(jt),ue=R.get(Qt);if(!ue)return;const ye=ue.length===1&&!E?wU(ue[0]):i4(ue,r,a,void 0,w);if(o&&ye.items.sort((Ne,Pn)=>o(Ne)-o(Pn)),s&&(ye.items=ye.items.filter(s)),l4(ye)){yl({root:t,single:h,emitter:c,event:It});return}const{offsetX:Ke,offsetY:be}=It;M&&t4({root:t,data:ye,x:Ke,y:be,render:i,event:It,single:h,position:v,enterable:g,mount:x,bounding:_,css:P,offset:O}),c.emit("tooltip:show",Object.assign(Object.assign({},It),{nativeEvent:!0,data:Object.assign(Object.assign({},ye),{data:QP(jt,b)})}))},l,{leading:u,trailing:f}),ht=It=>{yl({root:t,single:h,emitter:c,event:It})},lt=()=>{k||(t.addEventListener("pointermove",nt),t.addEventListener("pointerleave",ht))},wt=()=>{k||(t.removeEventListener("pointermove",nt),t.removeEventListener("pointerleave",ht))},yt=({nativeEvent:It,offsetX:jt,offsetY:Qt,data:ue})=>{if(It)return;const{data:ye}=ue,Ke=qw(L,ye,y);if(!Ke)return;const be=Ke.getBBox(),{x:Ne,y:Pn,width:qr,height:fi}=be,yr=t.getBBox();nt({target:Ke,offsetX:jt!==void 0?jt+yr.x:Ne+qr/2,offsetY:Qt!==void 0?Qt+yr.y:Pn+fi/2})},gt=({nativeEvent:It}={})=>{It||yl({root:t,single:h,emitter:c,nativeEvent:!1})},Bt=()=>{wt(),dS({root:t,single:h})},Lt=()=>{lt()};return c.on("tooltip:show",yt),c.on("tooltip:hide",gt),c.on("tooltip:enable",Lt),c.on("tooltip:disable",Bt),lt(),()=>{wt(),c.off("tooltip:show",yt),c.off("tooltip:hide",gt),A?yl({root:t,single:h,emitter:c,nativeEvent:!1}):dS({root:t,single:h})}}function f4(t){const{shared:e,crosshairs:n,crosshairsX:r,crosshairsY:i,series:a,name:o,item:s=()=>({}),facet:c=!1}=t,l=Iu(t,["shared","crosshairs","crosshairsX","crosshairsY","series","name","item","facet"]);return(u,f,d)=>{const{container:h,view:v}=u,{scale:g,markState:y,coordinate:b,theme:x}=v,_=c4(y,"seriesTooltip"),w=c4(y,"crosshairs"),O=ys(h),E=fc(a,_),M=fc(n,w);if(E&&kU(y)&&!c)return u4(O,Object.assign(Object.assign({},l),{theme:x,elements:cl,scale:g,coordinate:b,crosshairs:M,crosshairsX:fc(fc(r,n),!1),crosshairsY:fc(i,M),item:s,emitter:d}));if(E&&c){const k=f.filter(R=>R!==u&&R.options.parentKey===u.options.key),A=YP(u,f),P=k[0].view.scale,C=O.getBounds(),N=C.min[0],L=C.min[1];return Object.assign(P,{facet:!0}),u4(O.parentNode.parentNode,Object.assign(Object.assign({},l),{theme:x,elements:()=>A,scale:P,coordinate:b,crosshairs:fc(n,w),crosshairsX:fc(fc(r,n),!1),crosshairsY:fc(i,M),item:s,startX:N,startY:L,emitter:d}))}return AU(O,Object.assign(Object.assign({},l),{datum:wu(v),elements:cl,scale:g,coordinate:b,groupKey:e?Uw(v):void 0,item:s,emitter:d,view:v,theme:x,shared:e}))}}f4.props={reapplyWhenUpdate:!0};var w1=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})};const d4="legend-category",TU="legend-continuous",PU="items-item",CU="legend-category-item-marker",LU="legend-category-item-label";function h4(t){return t.getElementsByClassName(CU)[0]}function p4(t){return t.getElementsByClassName(LU)[0]}function v4(t){return t.getElementsByClassName(PU)}function hS(t){return t.getElementsByClassName(d4)}function g4(t){return t.getElementsByClassName(TU)}function RU(t,e){[...hS(t),...g4(t)].forEach(r=>{e(r,i=>i)})}function pS(t){let e=t.parentNode;for(;e&&!e.__data__;)e=e.parentNode;return e.__data__}function Fot(t){let e=t;for(;e&&!e.attr("class").startsWith("legend");)e=e.children[0];return e.attributes}function NU(t,{legends:e,marker:n,label:r,datum:i,filter:a,emitter:o,channel:s,state:c={}}){const l=new Map,u=new Map,f=new Map,{unselected:d={markerStroke:"#aaa",markerFill:"#aaa",labelFill:"#aaa"}}=c,h={unselected:$t(d,"marker")},v={unselected:$t(d,"label")},{setState:g,removeState:y}=lc(h,void 0),{setState:b,removeState:x}=lc(v,void 0),_=Array.from(e(t));let w=_.map(i);const O=()=>{for(const k of _){const A=i(k),P=n(k),C=r(k);w.includes(A)?(y(P,"unselected"),x(C,"unselected")):(g(P,"unselected"),b(C,"unselected"))}};for(const k of _){const A=()=>{ll(t,"pointer")},P=()=>{hW(t)},C=N=>w1(this,void 0,void 0,function*(){const L=i(k),R=w.indexOf(L);R===-1?w.push(L):w.splice(R,1),yield a(w),O();const{nativeEvent:I=!0}=N;I&&(w.length===_.length?o.emit("legend:reset",{nativeEvent:I}):o.emit("legend:filter",Object.assign(Object.assign({},N),{nativeEvent:I,data:{channel:s,values:w}})))});k.addEventListener("click",C),k.addEventListener("pointerenter",A),k.addEventListener("pointerout",P),l.set(k,C),u.set(k,A),f.set(k,P)}const E=k=>w1(this,void 0,void 0,function*(){const{nativeEvent:A}=k;if(A)return;const{data:P}=k,{channel:C,values:N}=P;C===s&&(w=N,yield a(w),O())}),M=k=>w1(this,void 0,void 0,function*(){const{nativeEvent:A}=k;A||(w=_.map(i),yield a(w),O())});return o.on("legend:filter",E),o.on("legend:reset",M),()=>{for(const k of _)k.removeEventListener("click",l.get(k)),k.removeEventListener("pointerenter",u.get(k)),k.removeEventListener("pointerout",f.get(k)),o.off("legend:filter",E),o.off("legend:reset",M)}}function IU(t,{legend:e,filter:n,emitter:r,channel:i}){const a=({detail:{value:o}})=>{n(o),r.emit({nativeEvent:!0,data:{channel:i,values:o}})};return e.addEventListener("valuechange",a),()=>{e.removeEventListener("valuechange",a)}}function y4(t,{legend:e,channel:n,value:r,ordinal:i,channels:a,allChannels:o,facet:s=!1}){return w1(this,void 0,void 0,function*(){const{view:c,update:l,setState:u}=t;u(e,f=>{const{marks:d}=f,h=d.map(v=>{if(v.type==="legends")return v;const{transform:g=[],data:y=[]}=v,b=g.findIndex(({type:w})=>w.startsWith("group")||w.startsWith("bin")),x=[...g];y.length&&x.splice(b+1,0,{type:"filter",[n]:{value:r,ordinal:i}});const _=Object.fromEntries(a.map(w=>[w,{domain:c.scale[w].getOptions().domain}]));return mt({},v,Object.assign(Object.assign({transform:x,scale:_},!i&&{animate:!1}),{legend:s?!1:Object.fromEntries(o.map(w=>[w,{preserve:!0}]))}))});return Object.assign(Object.assign({},f),{marks:h})}),yield l()})}function DU(t,e){for(const n of t)y4(n,Object.assign(Object.assign({},e),{facet:!0}))}function jU(){return(t,e,n)=>{const{container:r}=t,i=e.filter(f=>f!==t),a=i.length>0,o=f=>pS(f).scales.map(d=>d.name),s=[...hS(r),...g4(r)],c=s.flatMap(o),l=a?Nu(DU,50,{trailing:!0}):Nu(y4,50,{trailing:!0}),u=s.map(f=>{const{name:d,domain:h}=pS(f).scales[0],v=o(f),g={legend:f,channel:d,channels:v,allChannels:c};return f.className===d4?NU(r,{legends:v4,marker:h4,label:p4,datum:y=>{const{__data__:b}=y,{index:x}=b;return h[x]},filter:y=>{const b=Object.assign(Object.assign({},g),{value:y,ordinal:!0});l(a?i:t,b)},state:f.attributes.state,channel:d,emitter:n}):IU(r,{legend:f,filter:y=>{const b=Object.assign(Object.assign({},g),{value:y,ordinal:!1});l(a?i:t,b)},emitter:n,channel:d})});return()=>{u.forEach(f=>f())}}}function FU(){return(t,e,n)=>{const{container:r,view:i,options:a}=t,o=hS(r),s=cl(r),c=h=>pS(h).scales[0].name,l=h=>{const{scale:{[h]:v}}=i;return v},u=ld(a,["active","inactive"]),f=Up(s,wu(i)),d=[];for(const h of o){const v=X=>{const{data:Q}=h.attributes,{__data__:tt}=X,{index:nt}=tt;return Q[nt].label},g=c(h),y=v4(h),b=l(g),x=dr(s,X=>b.invert(X.__data__[g])),{state:_={}}=h.attributes,{inactive:w={}}=_,{setState:O,removeState:E}=lc(u,f),M={inactive:$t(w,"marker")},k={inactive:$t(w,"label")},{setState:A,removeState:P}=lc(M),{setState:C,removeState:N}=lc(k),L=X=>{for(const Q of y){const tt=h4(Q),nt=p4(Q);Q===X||X===null?(P(tt,"inactive"),N(nt,"inactive")):(A(tt,"inactive"),C(nt,"inactive"))}},R=(X,Q)=>{const tt=v(Q),nt=new Set(x.get(tt));for(const lt of s)nt.has(lt)?O(lt,"active"):O(lt,"inactive");L(Q);const{nativeEvent:ht=!0}=X;ht&&n.emit("legend:highlight",Object.assign(Object.assign({},X),{nativeEvent:ht,data:{channel:g,value:tt}}))},I=new Map;for(const X of y){const Q=tt=>{R(tt,X)};X.addEventListener("pointerover",Q),I.set(X,Q)}const D=X=>{for(const tt of s)E(tt,"inactive","active");L(null);const{nativeEvent:Q=!0}=X;Q&&n.emit("legend:unhighlight",{nativeEvent:Q})},G=X=>{const{nativeEvent:Q,data:tt}=X;if(Q)return;const{channel:nt,value:ht}=tt;if(nt!==g)return;const lt=y.find(wt=>v(wt)===ht);lt&&R({nativeEvent:!1},lt)},F=X=>{const{nativeEvent:Q}=X;Q||D({nativeEvent:!1})};h.addEventListener("pointerleave",D),n.on("legend:highlight",G),n.on("legend:unhighlight",F);const W=()=>{h.removeEventListener(D),n.off("legend:highlight",G),n.off("legend:unhighlight",F);for(const[X,Q]of I)X.removeEventListener(Q)};d.push(W)}return()=>d.forEach(h=>h())}}var Mo=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function BU(t,e){const[n,r,i,a]=t,[o,s,c,l]=e;return!(o>i||c<n||s>a||l<r)}function zU(t,e,n,r,i){const[a,o,s,c]=i;return[Math.max(a,Math.min(t,n)),Math.max(o,Math.min(e,r)),Math.min(s,Math.max(t,n)),Math.min(c,Math.max(e,r))]}function WU(t){const{width:e,height:n}=t.getBBox();return[0,0,e,n]}function dc(t,e){for(const[n,r]of Object.entries(e))t.style(n,r)}const m4=ad(t=>{const e=t.attributes,{x:n,y:r,width:i,height:a,class:o,renders:s={},handleSize:c=10,document:l}=e,u=Mo(e,["x","y","width","height","class","renders","handleSize","document"]);if(!l||i===void 0||a===void 0||n===void 0||r===void 0)return;const f=c/2,d=(ht,lt,wt)=>{ht.handle||(ht.handle=wt.createElement("rect"),ht.append(ht.handle));const{handle:yt}=ht;return yt.attr(lt),yt},h=$t(J_(u,"handleNW","handleNE"),"handleN"),{render:v=d}=h,g=Mo(h,["render"]),y=$t(u,"handleE"),{render:b=d}=y,x=Mo(y,["render"]),_=$t(J_(u,"handleSE","handleSW"),"handleS"),{render:w=d}=_,O=Mo(_,["render"]),E=$t(u,"handleW"),{render:M=d}=E,k=Mo(E,["render"]),A=$t(u,"handleNW"),{render:P=d}=A,C=Mo(A,["render"]),N=$t(u,"handleNE"),{render:L=d}=N,R=Mo(N,["render"]),I=$t(u,"handleSE"),{render:D=d}=I,G=Mo(I,["render"]),F=$t(u,"handleSW"),{render:W=d}=F,X=Mo(F,["render"]),Q=(ht,lt)=>{const{id:wt}=ht,yt=lt(ht,ht.attributes,l);yt.id=wt,yt.style.draggable=!0},tt=ht=>()=>{const lt=ad(wt=>Q(wt,ht));return new lt({})},nt=Oe(t).attr("className",o).style("transform",`translate(${n}, ${r})`).style("draggable",!0);nt.maybeAppend("selection","rect").style("draggable",!0).style("fill","transparent").call(dc,Object.assign(Object.assign({width:i,height:a},J_(u,"handle")),{transform:void 0})),nt.maybeAppend("handle-n",tt(v)).style("x",f).style("y",-f).style("width",i-c).style("height",c).style("fill","transparent").call(dc,g),nt.maybeAppend("handle-e",tt(b)).style("x",i-f).style("y",f).style("width",c).style("height",a-c).style("fill","transparent").call(dc,x),nt.maybeAppend("handle-s",tt(w)).style("x",f).style("y",a-f).style("width",i-c).style("height",c).style("fill","transparent").call(dc,O),nt.maybeAppend("handle-w",tt(M)).style("x",-f).style("y",f).style("width",c).style("height",a-c).style("fill","transparent").call(dc,k),nt.maybeAppend("handle-nw",tt(P)).style("x",-f).style("y",-f).style("width",c).style("height",c).style("fill","transparent").call(dc,C),nt.maybeAppend("handle-ne",tt(L)).style("x",i-f).style("y",-f).style("width",c).style("height",c).style("fill","transparent").call(dc,R),nt.maybeAppend("handle-se",tt(D)).style("x",i-f).style("y",a-f).style("width",c).style("height",c).style("fill","transparent").call(dc,G),nt.maybeAppend("handle-sw",tt(W)).style("x",-f).style("y",a-f).style("width",c).style("height",c).style("fill","transparent").call(dc,X)});function vS(t,e){var{brushed:n=()=>{},brushended:r=()=>{},brushcreated:i=()=>{},brushstarted:a=()=>{},brushupdated:o=()=>{},extent:s=WU(t),brushRegion:c=(yt,gt,Bt,Lt,It)=>[yt,gt,Bt,Lt],reverse:l=!1,fill:u="#777",fillOpacity:f="0.3",stroke:d="#fff",selectedHandles:h=["handle-n","handle-e","handle-s","handle-w","handle-nw","handle-ne","handle-se","handle-sw"]}=e,v=Mo(e,["brushed","brushended","brushcreated","brushstarted","brushupdated","extent","brushRegion","reverse","fill","fillOpacity","stroke","selectedHandles"]);let g=null,y=null,b=null,x=null,_=null,w=!1;const[O,E,M,k]=s;ll(t,"crosshair"),t.style.draggable=!0;const A=(yt,gt,Bt)=>{if(a(Bt),x&&x.remove(),_&&_.remove(),g=[yt,gt],l)return P();C()},P=()=>{_=new Qi({style:Object.assign(Object.assign({},v),{fill:u,fillOpacity:f,stroke:d,pointerEvents:"none"})}),x=new m4({style:{x:0,y:0,width:0,height:0,draggable:!0,document:t.ownerDocument},className:"mask"}),t.appendChild(_),t.appendChild(x)},C=()=>{x=new m4({style:Object.assign(Object.assign({document:t.ownerDocument,x:0,y:0},v),{fill:u,fillOpacity:f,stroke:d,draggable:!0}),className:"mask"}),t.appendChild(x)},N=(yt=!0)=>{x&&x.remove(),_&&_.remove(),g=null,y=null,b=null,w=!1,x=null,_=null,r(yt)},L=(yt,gt,Bt=!0)=>{const[Lt,It,jt,Qt]=zU(yt[0],yt[1],gt[0],gt[1],s),[ue,ye,Ke,be]=c(Lt,It,jt,Qt,s);return l?I(ue,ye,Ke,be):R(ue,ye,Ke,be),n(ue,ye,Ke,be,Bt),[ue,ye,Ke,be]},R=(yt,gt,Bt,Lt)=>{x.style.x=yt,x.style.y=gt,x.style.width=Bt-yt,x.style.height=Lt-gt},I=(yt,gt,Bt,Lt)=>{_.style.d=`
      M${O},${E}L${M},${E}L${M},${k}L${O},${k}Z
      M${yt},${gt}L${yt},${Lt}L${Bt},${Lt}L${Bt},${gt}Z
    `,x.style.x=yt,x.style.y=gt,x.style.width=Bt-yt,x.style.height=Lt-gt},D=yt=>{const gt=(ye,Ke,be,Ne,Pn)=>ye+Ke<Ne?Ne-Ke:ye+be>Pn?Pn-be:ye,Bt=yt[0]-b[0],Lt=yt[1]-b[1],It=gt(Bt,g[0],y[0],O,M),jt=gt(Lt,g[1],y[1],E,k),Qt=[g[0]+It,g[1]+jt],ue=[y[0]+It,y[1]+jt];L(Qt,ue)},G={"handle-n":{vector:[0,1,0,0],cursor:"ns-resize"},"handle-e":{vector:[0,0,1,0],cursor:"ew-resize"},"handle-s":{vector:[0,0,0,1],cursor:"ns-resize"},"handle-w":{vector:[1,0,0,0],cursor:"ew-resize"},"handle-nw":{vector:[1,1,0,0],cursor:"nwse-resize"},"handle-ne":{vector:[0,1,1,0],cursor:"nesw-resize"},"handle-se":{vector:[0,0,1,1],cursor:"nwse-resize"},"handle-sw":{vector:[1,0,0,1],cursor:"nesw-resize"}},F=yt=>X(yt)||W(yt),W=yt=>{const{id:gt}=yt;return h.indexOf(gt)===-1?!1:new Set(Object.keys(G)).has(gt)},X=yt=>yt===x.getElementById("selection"),Q=yt=>{const{target:gt}=yt,[Bt,Lt]=Xw(t,yt);if(!x||!F(gt)){A(Bt,Lt,yt),w=!0;return}F(gt)&&(b=[Bt,Lt])},tt=yt=>{const{target:gt}=yt,Bt=Xw(t,yt);if(!g)return;if(!b)return L(g,Bt);if(X(gt))return D(Bt);const[Lt,It]=[Bt[0]-b[0],Bt[1]-b[1]],{id:jt}=gt;if(G[jt]){const[Qt,ue,ye,Ke]=G[jt].vector;return L([g[0]+Lt*Qt,g[1]+It*ue],[y[0]+Lt*ye,y[1]+It*Ke])}},nt=yt=>{if(b){b=null;const{x:jt,y:Qt,width:ue,height:ye}=x.style;g=[jt,Qt],y=[jt+ue,Qt+ye],o(jt,Qt,jt+ue,Qt+ye,yt);return}y=Xw(t,yt);const[gt,Bt,Lt,It]=L(g,y);w=!1,i(gt,Bt,Lt,It,yt)},ht=yt=>{const{target:gt}=yt;x&&!F(gt)&&N()},lt=yt=>{const{target:gt}=yt;!x||!F(gt)||w?ll(t,"crosshair"):X(gt)?ll(t,"move"):W(gt)&&ll(t,G[gt.id].cursor)},wt=()=>{ll(t,"default")};return t.addEventListener("dragstart",Q),t.addEventListener("drag",tt),t.addEventListener("dragend",nt),t.addEventListener("click",ht),t.addEventListener("pointermove",lt),t.addEventListener("pointerleave",wt),{mask:x,move(yt,gt,Bt,Lt,It=!0){x||A(yt,gt,{}),g=[yt,gt],y=[Bt,Lt],L([yt,gt],[Bt,Lt],It)},remove(yt=!0){x&&N(yt)},destroy(){x&&N(!1),ll(t,"default"),t.removeEventListener("dragstart",Q),t.removeEventListener("drag",tt),t.removeEventListener("dragend",nt),t.removeEventListener("click",ht),t.removeEventListener("pointermove",lt),t.removeEventListener("pointerleave",wt)}}}function gS(t,e,n){return e.filter(r=>{if(r===t)return!1;const{interaction:i={}}=r.options;return Object.values(i).find(a=>a.brushKey===n)})}function GU(t,e,n){return gS(t,e,n).map(r=>ys(r.container))}function $U(t,e,n){return gS(t,e,n).map(r=>r.options)}function b4(t,e){var{elements:n,selectedHandles:r,siblings:i=tt=>[],datum:a,brushRegion:o,extent:s,reverse:c,scale:l,coordinate:u,series:f=!1,key:d=tt=>tt,bboxOf:h=tt=>{const{x:nt,y:ht,width:lt,height:wt}=tt.style;return{x:nt,y:ht,width:lt,height:wt}},state:v={},emitter:g}=e,y=Mo(e,["elements","selectedHandles","siblings","datum","brushRegion","extent","reverse","scale","coordinate","series","key","bboxOf","state","emitter"]);const b=n(t),x=i(t),_=x.flatMap(n),w=Up(b,a),O=$t(y,"mask"),{setState:E,removeState:M}=lc(v,w),k=new Map,{width:A,height:P,x:C=0,y:N=0}=h(t),L=s||[0,0,A,P],R=()=>{for(const tt of[...b,..._])M(tt,"active","inactive")},I=(tt,nt,ht,lt)=>{var wt;for(const gt of x)(wt=gt.brush)===null||wt===void 0||wt.remove();const yt=new Set;for(const gt of b){const{min:Bt,max:Lt}=gt.getLocalBounds(),[It,jt]=Bt,[Qt,ue]=Lt;BU([It,jt,Qt,ue],[tt,nt,ht,lt])?(E(gt,"active"),yt.add(d(gt))):E(gt,"inactive")}for(const gt of _)yt.has(d(gt))?E(gt,"active"):E(gt,"inactive")},D=()=>{for(const tt of b)M(tt,"inactive");for(const tt of k.values())tt.remove();k.clear()},G=(tt,nt,ht,lt)=>{const wt=gt=>{const Bt=gt.cloneNode();return Bt.__data__=gt.__data__,gt.parentNode.appendChild(Bt),k.set(gt,Bt),Bt},yt=new Qc({style:{x:tt+C,y:nt+N,width:ht-tt,height:lt-nt}});t.appendChild(yt);for(const gt of b){const Bt=k.get(gt)||wt(gt);Bt.style.clipPath=yt,E(gt,"inactive"),E(Bt,"active")}},F=vS(t,Object.assign(Object.assign({},O),{extent:L,brushRegion:o,reverse:c,selectedHandles:r,brushended:tt=>{const nt=f?D:R;tt&&g.emit("brush:remove",{nativeEvent:!0}),nt()},brushed:(tt,nt,ht,lt,wt)=>{const yt=Am(tt,nt,ht,lt,l,u);wt&&g.emit("brush:highlight",{nativeEvent:!0,data:{selection:yt}}),(f?G:I)(tt,nt,ht,lt)},brushcreated:(tt,nt,ht,lt,wt)=>{const yt=Am(tt,nt,ht,lt,l,u);g.emit("brush:end",Object.assign(Object.assign({},wt),{nativeEvent:!0,data:{selection:yt}}))},brushupdated:(tt,nt,ht,lt,wt)=>{const yt=Am(tt,nt,ht,lt,l,u);g.emit("brush:end",Object.assign(Object.assign({},wt),{nativeEvent:!0,data:{selection:yt}}))},brushstarted:tt=>{g.emit("brush:start",tt)}})),W=({nativeEvent:tt,data:nt})=>{if(tt)return;const{selection:ht}=nt,[lt,wt,yt,gt]=Jz(ht,l,u);F.move(lt,wt,yt,gt,!1)};g.on("brush:highlight",W);const X=({nativeEvent:tt}={})=>{tt||F.remove(!1)};g.on("brush:remove",X);const Q=F.destroy.bind(F);return F.destroy=()=>{g.off("brush:highlight",W),g.off("brush:remove",X),Q()},F}function yS(t){var{facet:e,brushKey:n}=t,r=Mo(t,["facet","brushKey"]);return(i,a,o)=>{const{container:s,view:c,options:l}=i,u=ys(s),f={maskFill:"#777",maskFillOpacity:"0.3",maskStroke:"#fff",reverse:!1},d=["active",["inactive",{opacity:.5}]],{scale:h,coordinate:v}=c;if(e){const y=u.getBounds(),b=y.min[0],x=y.min[1],_=y.max[0],w=y.max[1];return b4(u.parentNode.parentNode,Object.assign(Object.assign({elements:()=>YP(i,a),datum:wu(Vw(i,a).map(O=>O.view)),brushRegion:(O,E,M,k)=>[O,E,M,k],extent:[b,x,_,w],state:ld(Vw(i,a).map(O=>O.options),d),emitter:o,scale:h,coordinate:v,selectedHandles:void 0},f),r))}const g=b4(u,Object.assign(Object.assign({elements:cl,key:y=>y.__data__.key,siblings:()=>GU(i,a,n),datum:wu([c,...gS(i,a,n).map(y=>y.view)]),brushRegion:(y,b,x,_)=>[y,b,x,_],extent:void 0,state:ld([l,...$U(i,a,n)],d),emitter:o,scale:h,coordinate:v,selectedHandles:void 0},f),r));return u.brush=g,()=>g.destroy()}}function mS(t,e,n,r,i){const[,a,,o]=i;return[t,a,n,o]}function ZU(t){return yS(Object.assign(Object.assign({},t),{brushRegion:mS,selectedHandles:["handle-e","handle-w"]}))}function bS(t,e,n,r,i){const[a,,o]=i;return[a,e,o,r]}function YU(t){return yS(Object.assign(Object.assign({},t),{brushRegion:bS,selectedHandles:["handle-n","handle-s"]}))}var xS=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const HU="axis",VU="axis-line",XU="axis-main-group",x4="axis-hot-area";function UU(t){return t.getElementsByClassName(HU)}function _4(t){return t.getElementsByClassName(VU)[0]}function qU(t){return t.getElementsByClassName(XU)[0]}function w4(t){return qU(t).getLocalBounds()}function KU(t,e){var{cross:n,offsetX:r,offsetY:i}=e,a=xS(e,["cross","offsetX","offsetY"]);const o=w4(t),s=_4(t),[c]=s.getLocalBounds().min,[l,u]=o.min,[f,d]=o.max,h=(f-l)*2;return{brushRegion:bS,hotZone:new Qc({className:x4,style:Object.assign({width:n?h/2:h,transform:`translate(${(n?l:c-h/2).toFixed(2)}, ${u})`,height:d-u},a)}),extent:n?(v,g,y,b)=>[-1/0,g,1/0,b]:(v,g,y,b)=>[Math.floor(l-r),g,Math.ceil(f-r),b]}}function QU(t,e){var{offsetY:n,offsetX:r,cross:i=!1}=e,a=xS(e,["offsetY","offsetX","cross"]);const o=w4(t),s=_4(t),[,c]=s.getLocalBounds().min,[l,u]=o.min,[f,d]=o.max,h=d-u;return{brushRegion:mS,hotZone:new Qc({className:x4,style:Object.assign({width:f-l,height:i?h:h*2,transform:`translate(${l}, ${i?u:c-h})`},a)}),extent:i?(v,g,y,b)=>[v,-1/0,y,1/0]:(v,g,y,b)=>[v,Math.floor(u-n),y,Math.ceil(d-n)]}}function JU(t,e){var{axes:n,elements:r,points:i,horizontal:a,datum:o,offsetY:s,offsetX:c,reverse:l=!1,state:u={},emitter:f,coordinate:d}=e,h=xS(e,["axes","elements","points","horizontal","datum","offsetY","offsetX","reverse","state","emitter","coordinate"]);const v=r(t),g=n(t),y=Up(v,o),{setState:b,removeState:x}=lc(u,y),_=new Map,w=$t(h,"mask"),O=W=>Array.from(_.values()).every(([X,Q,tt,nt])=>W.some(([ht,lt])=>ht>=X&&ht<=tt&&lt>=Q&&lt<=nt)),E=g.map(W=>W.attributes.scale),M=W=>W.length>2?[W[0],W[W.length-1]]:W,k=new Map,A=()=>{k.clear();for(let W=0;W<g.length;W++){const X=E[W],{domain:Q}=X.getOptions();k.set(W,M(Q))}};A();const P=(W,X)=>{const Q=[];for(const nt of v){const ht=i(nt);O(ht)?(b(nt,"active"),Q.push(nt)):b(nt,"inactive")}if(k.set(W,N(Q,W)),!X)return;const tt=()=>{if(!L)return Array.from(k.values());const nt=[];for(const[ht,lt]of k){const wt=E[ht],{name:yt}=wt.getOptions();yt==="x"?nt[0]=lt:nt[1]=lt}return nt};f.emit("brushAxis:highlight",{nativeEvent:!0,data:{selection:tt()}})},C=W=>{for(const X of v)x(X,"active","inactive");A(),W&&f.emit("brushAxis:remove",{nativeEvent:!0})},N=(W,X)=>{const Q=E[X],{name:tt}=Q.getOptions(),nt=W.map(ht=>{const lt=ht.__data__;return Q.invert(lt[tt])});return M(sl(Q,nt))},L=g.some(a)&&g.some(W=>!a(W)),R=[];for(let W=0;W<g.length;W++){const X=g[W],Q=a(X)?QU:KU,{hotZone:tt,brushRegion:nt,extent:ht}=Q(X,{offsetY:s,offsetX:c,cross:L,zIndex:999,fill:"transparent"});X.parentNode.appendChild(tt);const lt=vS(tt,Object.assign(Object.assign({},w),{reverse:l,brushRegion:nt,brushended(wt){_.delete(X),Array.from(_.entries()).length===0?C(wt):P(W,wt)},brushed(wt,yt,gt,Bt,Lt){_.set(X,ht(wt,yt,gt,Bt)),P(W,Lt)}}));R.push(lt)}const I=(W={})=>{const{nativeEvent:X}=W;X||R.forEach(Q=>Q.remove(!1))},D=(W,X,Q)=>{const[tt,nt]=W,ht=yt=>yt.getStep?yt.getStep():0,lt=G(tt,X,Q),wt=G(nt,X,Q)+ht(X);return a(Q)?[lt,-1/0,wt,1/0]:[-1/0,lt,1/0,wt]},G=(W,X,Q)=>{const{height:tt,width:nt}=d.getOptions(),ht=X.clone();return a(Q)?ht.update({range:[0,nt]}):ht.update({range:[tt,0]}),ht.map(W)},F=W=>{const{nativeEvent:X}=W;if(X)return;const{selection:Q}=W.data;for(let tt=0;tt<R.length;tt++){const nt=Q[tt],ht=R[tt],lt=g[tt];if(nt){const wt=E[tt];ht.move(...D(nt,wt,lt),!1)}else ht.remove(!1)}};return f.on("brushAxis:remove",I),f.on("brushAxis:highlight",F),()=>{R.forEach(W=>W.destroy()),f.off("brushAxis:remove",I),f.off("brushAxis:highlight",F)}}function tq(t){return(e,n,r)=>{const{container:i,view:a,options:o}=e,s=ys(i),{x:c,y:l}=s.getBBox(),{coordinate:u}=a;return JU(i,Object.assign({elements:cl,axes:UU,offsetY:l,offsetX:c,points:f=>f.__data__.points,horizontal:f=>{const{startPos:[d,h],endPos:[v,g]}=f.attributes;return d!==v&&h===g},datum:wu(a),state:ld(o,["active",["inactive",{opacity:.5}]]),coordinate:u,emitter:r},t))}}var eq=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})},O4=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function nq(t=300){let e=null;return n=>{const{timeStamp:r}=n;return e!==null&&r-e<t?(e=r,!0):(e=r,!1)}}function rq(t,e){var{filter:n,reset:r,brushRegion:i,extent:a,reverse:o,emitter:s,scale:c,coordinate:l,selection:u,series:f=!1}=e,d=O4(e,["filter","reset","brushRegion","extent","reverse","emitter","scale","coordinate","selection","series"]);const h=$t(d,"mask"),{width:v,height:g}=t.getBBox(),y=a||[0,0,v,g],b=nq(),x=vS(t,Object.assign(Object.assign({},h),{extent:y,brushRegion:i,reverse:o,brushcreated:_}));t.addEventListener("click",w);function _(E,M,k,A,P){P.nativeEvent=!0,n(u(E,M,k,A),P),x.remove()}function w(E){b(E)&&(E.nativeEvent=!0,r(E))}const O=({nativeEvent:E,data:M})=>{if(E)return;const{selection:k}=M;n(k,{nativeEvent:!1})};return s.on("brush:filter",O),()=>{x.destroy(),s.off("brush:filter",O),t.removeEventListener("click",w)}}function _S(t){var{hideX:e=!0,hideY:n=!0}=t,r=O4(t,["hideX","hideY"]);return(i,a,o)=>{const{container:s,view:c,options:l,update:u,setState:f}=i,d=ys(s),h={maskFill:"#777",maskFillOpacity:"0.3",maskStroke:"#fff",unhighlightedOpacity:.5,reverse:!1};let v=!1,g=!1,y=c;const{scale:b,coordinate:x}=c;return rq(d,Object.assign(Object.assign({brushRegion:(_,w,O,E)=>[_,w,O,E],selection:(_,w,O,E)=>{const{scale:M,coordinate:k}=y;return Am(_,w,O,E,M,k)},filter:(_,w)=>eq(this,void 0,void 0,function*(){if(g)return;g=!0;const[O,E]=_;f("brushFilter",k=>{const{marks:A}=k,P=A.map(C=>mt({axis:Object.assign(Object.assign({},e&&{x:{transform:[{type:"hide"}]}}),n&&{y:{transform:[{type:"hide"}]}})},C,{scale:{x:{domain:O,nice:!1},y:{domain:E,nice:!1}}}));return Object.assign(Object.assign({},l),{marks:P,clip:!0})}),o.emit("brush:filter",Object.assign(Object.assign({},w),{data:{selection:[O,E]}})),y=(yield u()).view,g=!1,v=!0}),reset:_=>{if(g||!v)return;const{scale:w}=c,{x:O,y:E}=w,M=O.getOptions().domain,k=E.getOptions().domain;o.emit("brush:filter",Object.assign(Object.assign({},_),{data:{selection:[M,k]}})),v=!1,y=c,f("brushFilter"),u()},extent:void 0,emitter:o,scale:b,coordinate:x},h),r))}}function iq(t){return _S(Object.assign(Object.assign({hideX:!0},t),{brushRegion:mS}))}function aq(t){return _S(Object.assign(Object.assign({hideY:!0},t),{brushRegion:bS}))}var oq=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})};const sq="slider";function cq(t,e,n,r=!1,i="x",a="y"){const{marks:o}=t,s=o.map(c=>{var l,u;return mt({axis:{x:{transform:[{type:"hide"}]},y:{transform:[{type:"hide"}]}}},c,{scale:e,[n]:Object.assign(Object.assign({},((l=c[n])===null||l===void 0?void 0:l[i])&&{[i]:Object.assign({preserve:!0},r&&{ratio:null})}),((u=c[n])===null||u===void 0?void 0:u[a])&&{[a]:{preserve:!0}}),animate:!1})});return Object.assign(Object.assign({},t),{marks:s,clip:!0,animate:!1})}function lq(t,e,n){const[r,i]=t,a=n?c=>1-c:c=>c,o=sd(e,a(r),!0),s=sd(e,a(i),!1);return sl(e,[o,s])}function O1(t){return[t[0],t[t.length-1]]}function S4({initDomain:t={},className:e=sq,prefix:n="slider",setValue:r=(l,u)=>l.setValues(u),hasState:i=!1,wait:a=50,leading:o=!0,trailing:s=!1,getInitValues:c=l=>{var u;const f=(u=l==null?void 0:l.attributes)===null||u===void 0?void 0:u.values;if(f[0]!==0||f[1]!==1)return f}}){return(l,u,f)=>{const{container:d,view:h,update:v,setState:g}=l,y=d.getElementsByClassName(e);if(!y.length)return()=>{};let b=!1;const{scale:x,coordinate:_,layout:w}=h,{paddingLeft:O,paddingTop:E,paddingBottom:M,paddingRight:k}=w,{x:A,y:P}=x,C=hr(_),N=D=>{const G=D==="vertical"?"y":"x",F=D==="vertical"?"x":"y";return C?[F,G]:[G,F]},L=new Map,R=new Set,I={x:t.x||A.getOptions().domain,y:t.y||P.getOptions().domain};for(const D of y){const{orientation:G}=D.attributes,[F,W]=N(G),X=`${n}${tl(F)}:filter`,Q=F==="x",{ratio:tt}=A.getOptions(),{ratio:nt}=P.getOptions(),ht=gt=>{if(gt.data){const{selection:Qt}=gt.data,[ue=O1(I.x),ye=O1(I.y)]=Qt;return Q?[sl(A,ue,tt),sl(P,ye,nt)]:[sl(P,ye,nt),sl(A,ue,tt)]}const{value:Bt}=gt.detail,Lt=x[F],It=lq(Bt,Lt,C&&G==="horizontal"),jt=I[W];return[It,jt]},lt=Nu(gt=>oq(this,void 0,void 0,function*(){const{initValue:Bt=!1}=gt;if(b&&!Bt)return;b=!0;const{nativeEvent:Lt=!0}=gt,[It,jt]=ht(gt);if(I[F]=It,I[W]=jt,Lt){const Qt=Q?It:jt,ue=Q?jt:It;f.emit(X,Object.assign(Object.assign({},gt),{nativeEvent:Lt,data:{selection:[O1(Qt),O1(ue)]}}))}g(D,Qt=>Object.assign(Object.assign({},cq(Qt,{[F]:{domain:It,nice:!1}},n,i,F,W)),{paddingLeft:O,paddingTop:E,paddingBottom:M,paddingRight:k})),yield v(),b=!1}),a,{leading:o,trailing:s}),wt=gt=>{const{nativeEvent:Bt}=gt;if(Bt)return;const{data:Lt}=gt,{selection:It}=Lt,[jt,Qt]=It;D.dispatchEvent(new Nn("valuechange",{data:Lt,nativeEvent:!1}));const ue=Q?Tm(jt,A):Tm(Qt,P);r(D,ue)};f.on(X,wt),D.addEventListener("valuechange",lt),L.set(D,lt),R.add([X,wt]);const yt=c(D);yt&&D.dispatchEvent(new Nn("valuechange",{detail:{value:yt},nativeEvent:!1,initValue:!0}))}return()=>{for(const[D,G]of L)D.removeEventListener("valuechange",G);for(const[D,G]of R)f.off(D,G)}}}const E4="g2-scrollbar";function uq(t={}){return(e,n,r)=>{const{view:i,container:a}=e;if(!a.getElementsByClassName(E4).length)return()=>{};const{scale:s}=i,{x:c,y:l}=s,u={x:[...c.getOptions().domain],y:[...l.getOptions().domain]};return c.update({domain:c.getOptions().expectedDomain}),l.update({domain:l.getOptions().expectedDomain}),S4(Object.assign(Object.assign({},t),{initDomain:u,className:E4,prefix:"scrollbar",hasState:!0,setValue:(d,h)=>d.setValue(h[0]),getInitValues:d=>{const h=d.slider.attributes.values;if(h[0]!==0)return h}}))(e,n,r)}}var fq=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function dq(t,e,n){return`<${t} style="${Object.entries(n).map(([r,i])=>`${Mz(r)}:${i}`).join(";")}">${e}</${t}>`}const hq={backgroundColor:"rgba(0,0,0,0.75)",color:"#fff",width:"max-content",padding:"1px 4px",fontSize:"12px",borderRadius:"2.5px",boxShadow:"0 3px 6px -4px rgba(0,0,0,0.12), 0 6px 16px 0 rgba(0,0,0,0.08), 0 9px 28px 8px rgba(0,0,0,0.05)"};function M4(t){return t.nodeName!=="text"?!1:!!t.isOverflowing()}function k4(t){var{offsetX:e=8,offsetY:n=8}=t,r=fq(t,["offsetX","offsetY"]);return i=>{const{container:a}=i,[o,s]=a.getBounds().min,c=$t(r,"tip"),l=new Set,u=d=>{const{target:h}=d;if(!M4(h)){d.stopPropagation();return}const{offsetX:v,offsetY:g}=d,y=v+e-o,b=g+n-s;if(h.tip){h.tip.style.x=y,h.tip.style.y=b;return}const{text:x}=h.style,_=new bp({className:"poptip",style:{innerHTML:dq("div",x,Object.assign(Object.assign({},hq),c)),x:y,y:b}});a.appendChild(_),h.tip=_,l.add(_)},f=d=>{const{target:h}=d;if(!M4(h)){d.stopPropagation();return}h.tip&&(h.tip.remove(),h.tip=null,l.delete(h.tip))};return a.addEventListener("pointerover",u),a.addEventListener("pointerout",f),()=>{a.removeEventListener("pointerover",u),a.removeEventListener("pointerout",f),l.forEach(d=>d.remove())}}}k4.props={reapplyWhenUpdate:!0};function pq(t,e){var n=wO(e),r=n.length;if(ge(t))return!r;for(var i=0;i<r;i+=1){var a=n[i];if(e[a]!==t[a]||!(a in t))return!1}return!0}var vq=pq;function gq(t,e){if(!Nr(t))return null;var n;if(Xn(e)&&(n=e),nc(e)&&(n=function(i){return vq(i,e)}),n){for(var r=0;r<t.length;r+=1)if(n(t[r]))return t[r]}return null}var Sd=gq;function S1(t){return t==null?null:A4(t)}function A4(t){if(typeof t!="function")throw new Error;return t}var yq={depth:-1},T4={},wS={};function mq(t){return t.id}function bq(t){return t.parentId}function OS(){var t=mq,e=bq,n;function r(i){var a=Array.from(i),o=t,s=e,c,l,u,f,d,h,v,g,y=new Map;if(n!=null){var b=a.map(function(k,A){return xq(n(k,A,i))}),x=b.map(P4),_=new Set(b).add(""),w=mO(x),O;try{for(w.s();!(O=w.n()).done;){var E=O.value;_.has(E)||(_.add(E),b.push(E),x.push(P4(E)),a.push(wS))}}catch(k){w.e(k)}finally{w.f()}o=function(A,P){return b[P]},s=function(A,P){return x[P]}}for(u=0,c=a.length;u<c;++u)l=a[u],h=a[u]=new md(l),(v=o(l,u,i))!=null&&(v+="")&&(g=h.id=v,y.set(g,y.has(g)?T4:h)),(v=s(l,u,i))!=null&&(v+="")&&(h.parent=v);for(u=0;u<c;++u)if(h=a[u],v=h.parent){if(d=y.get(v),!d)throw new Error("missing: "+v);if(d===T4)throw new Error("ambiguous: "+v);d.children?d.children.push(h):d.children=[h],h.parent=d}else{if(f)throw new Error("multiple roots");f=h}if(!f)throw new Error("no root");if(n!=null){for(;f.data===wS&&f.children.length===1;)f=f.children[0],--c;for(var M=a.length-1;M>=0&&(h=a[M],h.data===wS);--M)h.data=null}if(f.parent=yq,f.eachBefore(function(k){k.depth=k.parent.depth+1,--c}).eachBefore(zC),f.parent=null,c>0)throw new Error("cycle");return f}return r.id=function(i){return arguments.length?(t=S1(i),r):t},r.parentId=function(i){return arguments.length?(e=S1(i),r):e},r.path=function(i){return arguments.length?(n=S1(i),r):n},r}function xq(t){t="".concat(t);var e=t.length;return SS(t,e-1)&&!SS(t,e-2)&&(t=t.slice(0,-1)),t[0]==="/"?t:"/".concat(t)}function P4(t){var e=t.length;if(e<2)return"";for(;--e>1&&!SS(t,e););return t.slice(0,e)}function SS(t,e){if(t[e]==="/"){for(var n=0;e>0&&t[--e]==="\\";)++n;if(!(n&1))return!0}return!1}function _q(t,e,n,r,i){var a=t.children,o,s=a.length,c,l=new Array(s+1);for(l[0]=c=o=0;o<s;++o)l[o+1]=c+=a[o].value;u(0,s,t.value,e,n,r,i);function u(f,d,h,v,g,y,b){if(f>=d-1){var x=a[f];x.x0=v,x.y0=g,x.x1=y,x.y1=b;return}for(var _=l[f],w=h/2+_,O=f+1,E=d-1;O<E;){var M=O+E>>>1;l[M]<w?O=M+1:E=M}w-l[O-1]<l[O]-w&&f+1<O&&--O;var k=l[O]-_,A=h-k;if(y-v>b-g){var P=h?(v*A+y*k)/h:y;u(f,O,k,v,g,P,b),u(O,d,A,P,g,y,b)}else{var C=h?(g*A+b*k)/h:b;u(f,O,k,v,g,y,C),u(O,d,A,v,C,y,b)}}}function E1(t,e,n,r,i){for(var a=t.children,o,s=-1,c=a.length,l=t.value&&(i-n)/t.value;++s<c;)o=a[s],o.x0=e,o.x1=r,o.y0=n,o.y1=n+=o.value*l}function wq(t,e,n,r,i){(t.depth&1?E1:e0)(t,e,n,r,i)}var C4=(1+Math.sqrt(5))/2;function L4(t,e,n,r,i,a){for(var o=[],s=e.children,c,l,u=0,f=0,d=s.length,h,v,g=e.value,y,b,x,_,w,O,E;u<d;){h=i-n,v=a-r;do y=s[f++].value;while(!y&&f<d);for(b=x=y,O=Math.max(v/h,h/v)/(g*t),E=y*y*O,w=Math.max(x/E,E/b);f<d;++f){if(y+=l=s[f].value,l<b&&(b=l),l>x&&(x=l),E=y*y*O,_=Math.max(x/E,E/b),_>w){y-=l;break}w=_}o.push(c={value:y,dice:h<v,children:s.slice(u,f)}),c.dice?e0(c,n,r,i,g?r+=v*y/g:a):E1(c,n,r,g?n+=h*y/g:i,a),g-=y,u=f}return o}var R4=function t(e){function n(r,i,a,o,s){L4(e,r,i,a,o,s)}return n.ratio=function(r){return t((r=+r)>1?r:1)},n}(C4),Oq=function t(e){function n(r,i,a,o,s){if((c=r._squarify)&&c.ratio===e)for(var c,l,u,f,d=-1,h,v=c.length,g=r.value;++d<v;){for(l=c[d],u=l.children,f=l.value=0,h=u.length;f<h;++f)l.value+=u[f].value;l.dice?e0(l,i,a,o,g?a+=(s-a)*l.value/g:s):E1(l,i,a,g?i+=(o-i)*l.value/g:o,s),g-=l.value}else r._squarify=c=L4(e,r,i,a,o,s),c.ratio=e}return n.ratio=function(r){return t((r=+r)>1?r:1)},n}(C4);function Du(){return 0}function Ed(t){return function(){return t}}function Sq(){var t=R4,e=!1,n=1,r=1,i=[0],a=Du,o=Du,s=Du,c=Du,l=Du;function u(d){return d.x0=d.y0=0,d.x1=n,d.y1=r,d.eachBefore(f),i=[0],e&&d.eachBefore(jC),d}function f(d){var h=i[d.depth],v=d.x0+h,g=d.y0+h,y=d.x1-h,b=d.y1-h;y<v&&(v=y=(v+y)/2),b<g&&(g=b=(g+b)/2),d.x0=v,d.y0=g,d.x1=y,d.y1=b,d.children&&(h=i[d.depth+1]=a(d)/2,v+=l(d)-h,g+=o(d)-h,y-=s(d)-h,b-=c(d)-h,y<v&&(v=y=(v+y)/2),b<g&&(g=b=(g+b)/2),t(d,v,g,y,b))}return u.round=function(d){return arguments.length?(e=!!d,u):e},u.size=function(d){return arguments.length?(n=+d[0],r=+d[1],u):[n,r]},u.tile=function(d){return arguments.length?(t=A4(d),u):t},u.padding=function(d){return arguments.length?u.paddingInner(d).paddingOuter(d):u.paddingInner()},u.paddingInner=function(d){return arguments.length?(a=typeof d=="function"?d:Ed(+d),u):a},u.paddingOuter=function(d){return arguments.length?u.paddingTop(d).paddingRight(d).paddingBottom(d).paddingLeft(d):u.paddingTop()},u.paddingTop=function(d){return arguments.length?(o=typeof d=="function"?d:Ed(+d),u):o},u.paddingRight=function(d){return arguments.length?(s=typeof d=="function"?d:Ed(+d),u):s},u.paddingBottom=function(d){return arguments.length?(c=typeof d=="function"?d:Ed(+d),u):c},u.paddingLeft=function(d){return arguments.length?(l=typeof d=="function"?d:Ed(+d),u):l},u}function Eq(t,e){return Array.isArray(t)?typeof e=="function"?OS().path(e)(t):OS()(t):yd(t)}function N4(t,e=[t.data.name]){t.id=t.id||t.data.name,t.path=e,t.children&&t.children.forEach(n=>{n.id=`${t.id}/${n.data.name}`,n.path=[...e,n.data.name],N4(n,n.path)})}function I4(t){const e=vn(t,["data","name"]);e.replaceAll&&(t.path=e.replaceAll(".","/").split("/")),t.children&&t.children.forEach(n=>{I4(n)})}function Mq(t,e){const n={treemapBinary:_q,treemapDice:e0,treemapSlice:E1,treemapSliceDice:wq,treemapSquarify:R4,treemapResquarify:Oq},r=t==="treemapSquarify"?n[t].ratio(e):n[t];if(!r)throw new TypeError("Invalid tile method!");return r}function D4(t,e,n){const{value:r}=n,i=Mq(e.tile,e.ratio),a=Eq(t,e.path);Nr(t)?I4(a):N4(a),r?a.sum(c=>e.ignoreParentValue&&c.children?0:Os(r)(c)).sort(e.sort):a.count(),Sq().tile(i).size(e.size).round(e.round).paddingInner(e.paddingInner).paddingOuter(e.paddingOuter).paddingTop(e.paddingTop).paddingRight(e.paddingRight).paddingBottom(e.paddingBottom).paddingLeft(e.paddingLeft)(a);const o=a.descendants().map(c=>Object.assign(c,{id:c.id.replace(/^\//,""),x:[c.x0,c.x1],y:[c.y0,c.y1]}));return[o.filter(typeof e.layer=="function"?e.layer:c=>c.height===e.layer),o]}var kq=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})},Aq=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function Tq(t){return Oe(t).select(`.${ba}`).node()}const Pq={breadCrumbFill:"rgba(0, 0, 0, 0.85)",breadCrumbFontSize:12,breadCrumbY:12,activeFill:"rgba(0, 0, 0, 0.5)"};function Cq(t={}){const{originData:e=[],layout:n}=t,r=Aq(t,["originData","layout"]),i=mt({},Pq,r),a=$t(i,"breadCrumb"),o=$t(i,"active");return s=>{const{update:c,setState:l,container:u,options:f}=s,d=Tq(u),h=f.marks[0],{state:v}=h,g=new ui;d.appendChild(g);const y=(w,O)=>kq(this,void 0,void 0,function*(){if(g.removeChildren(),O){let E="",M=a.y,k=0;const A=[],P=d.getBBox().width,C=w.map((N,L)=>{E=`${E}${N}/`,A.push(N);const R=new po({name:E.replace(/\/$/,""),style:Object.assign(Object.assign({text:N,x:k,path:[...A],depth:L},a),{y:M})});g.appendChild(R),k+=R.getBBox().width;const I=new po({style:Object.assign(Object.assign({x:k,text:" / "},a),{y:M})});return g.appendChild(I),k+=I.getBBox().width,k>P&&(M=g.getBBox().height+a.y,k=0,R.attr({x:k,y:M}),k+=R.getBBox().width,I.attr({x:k,y:M}),k+=I.getBBox().width),L===jp(w)-1&&I.remove(),R});C.forEach((N,L)=>{if(L===jp(C)-1)return;const R=Object.assign({},N.attributes);N.attr("cursor","pointer"),N.addEventListener("mouseenter",()=>{N.attr(o)}),N.addEventListener("mouseleave",()=>{N.attr(R)}),N.addEventListener("click",()=>{y(vn(N,["style","path"]),vn(N,["style","depth"]))})})}RU(u,l),l("treemapDrillDown",E=>{const{marks:M}=E,k=w.join("/"),A=M.map(P=>{if(P.type!=="rect")return P;let C=e;if(O){const L=e.filter(F=>{const W=vn(F,["id"]);return W&&(W.match(`${k}/`)||k.match(W))}).map(F=>({value:F.height===0?vn(F,["value"]):void 0,name:vn(F,["id"])})),{paddingLeft:R,paddingBottom:I,paddingRight:D}=n,G=Object.assign(Object.assign({},n),{paddingTop:(n.paddingTop||g.getBBox().height+10)/(O+1),paddingLeft:R/(O+1),paddingBottom:I/(O+1),paddingRight:D/(O+1),path:F=>F.name,layer:F=>F.depth===O+1});C=D4(L,G,{value:"value"})[0]}else C=e.filter(L=>L.depth===1);const N=[];return C.forEach(({path:L})=>{N.push(p0(L))}),mt({},P,{data:C,scale:{color:{domain:N}}})});return Object.assign(Object.assign({},E),{marks:A})}),yield c(void 0,["legendFilter"])}),b=w=>{const O=w.target;if(vn(O,["markType"])!=="rect")return;const E=vn(O,["__data__","key"]),M=Sd(e,k=>k.id===E);vn(M,"height")&&y(vn(M,"path"),vn(M,"depth"))};d.addEventListener("click",b);const x=wO(Object.assign(Object.assign({},v.active),v.inactive)),_=()=>{KP(d).forEach(O=>{const E=vn(O,["style","cursor"]),M=Sd(e,k=>k.id===vn(O,["__data__","key"]));if(E!=="pointer"&&(M!=null&&M.height)){O.style.cursor="pointer";const k=yO(O.attributes,x);O.addEventListener("mouseenter",()=>{O.attr(v.active)}),O.addEventListener("mouseleave",()=>{O.attr(mt(k,v.inactive))})}})};return _(),d.addEventListener("mousemove",_),()=>{g.remove(),d.removeEventListener("click",b),d.removeEventListener("mousemove",_)}}}var ES=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})},Lq=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const Rq={pointR:6,pointStrokeWidth:1,pointStroke:"#888",pointActiveStroke:"#f5f5f5",pathStroke:"#888",pathLineDash:[3,4],labelFontSize:12,labelFill:"#888",labelStroke:"#fff",labelLineWidth:1,labelY:-6,labelX:2},MS="movePoint",j4=t=>{const e=t.target,{markType:n}=e;n==="line"&&(e.attr("_lineWidth",e.attr("lineWidth")||1),e.attr("lineWidth",e.attr("_lineWidth")+3)),n==="interval"&&(e.attr("_opacity",e.attr("opacity")||1),e.attr("opacity",.7*e.attr("_opacity")))},F4=t=>{const e=t.target,{markType:n}=e;n==="line"&&e.attr("lineWidth",e.attr("_lineWidth")),n==="interval"&&e.attr("opacity",e.attr("_opacity"))},Nq=(t,e,n)=>e.map(r=>["x","color"].reduce((a,o)=>{const s=n[o];return s&&r[s]!==t[s]?!1:a},!0)?Object.assign(Object.assign({},r),t):r),Iq=t=>{const e=vn(t,["__data__","y"]),r=vn(t,["__data__","y1"])-e,{__data__:{data:i,encode:a,transform:o},childNodes:s}=t.parentNode,c=Sd(o,({type:f})=>f==="normalizeY"),l=vn(a,["y","field"]),u=i[s.indexOf(t)][l];return(f,d=!1)=>c||d?f/(1-f)/(r/(1-r))*u:f},Dq=(t,e)=>{const n=vn(t,["__data__","seriesItems",e,"0","value"]),r=vn(t,["__data__","seriesIndex",e]),{__data__:{data:i,encode:a,transform:o}}=t.parentNode,s=Sd(o,({type:u})=>u==="normalizeY"),c=vn(a,["y","field"]),l=i[r][c];return u=>s?n===1?u:u/(1-u)/(n/(1-n))*l:u},B4=(t,e,n)=>{t.forEach((r,i)=>{r.attr("stroke",e[1]===i?n.activeStroke:n.stroke)})},z4=(t,e,n,r)=>{const i=new Qi({style:n}),a=new po({style:r});return e.appendChild(a),t.appendChild(i),[i,a]},W4=(t,e)=>{if(!vn(t,["options","range","indexOf"]))return;const r=t.options.range.indexOf(e);return t.sortedDomain[r]},kS=(t,e,n)=>{const r=Dm(t,e),a=Dm(t,n)/r,o=t[0]+(e[0]-t[0])*a,s=t[1]+(e[1]-t[1])*a;return[o,s]};function jq(t={}){const{selection:e=[],precision:n=2}=t,r=Lq(t,["selection","precision"]),i=Object.assign(Object.assign({},Rq),r||{}),a=$t(i,"path"),o=$t(i,"label"),s=$t(i,"point");return(c,l,u)=>{const{update:f,setState:d,container:h,view:v,options:{marks:g,coordinate:y}}=c,b=ys(h);let x=KP(b),_,w=e;const{transform:O=[],type:E}=y,M=!!Sd(O,({type:F})=>F==="transpose"),k=E==="polar",A=E==="theta",P=!!Sd(x,({markType:F})=>F==="area");P&&(x=x.filter(({markType:F})=>F==="area"));const C=new ui({style:{zIndex:2}});b.appendChild(C);const N=()=>{u.emit("element-point:select",{nativeEvent:!0,data:{selection:w}})},L=(F,W)=>{u.emit("element-point:moved",{nativeEvent:!0,data:{changeData:F,data:W}})},R=F=>{const W=F.target;w=[W.parentNode.childNodes.indexOf(W)],N(),D(W)},I=F=>{const{data:{selection:W},nativeEvent:X}=F;if(X)return;w=W;const Q=vn(x,[w==null?void 0:w[0]]);Q&&D(Q)},D=F=>{const{attributes:W,markType:X,__data__:Q}=F,{stroke:tt}=W,{points:nt,seriesTitle:ht,color:lt,title:wt,seriesX:yt,y1:gt}=Q;if(M&&X!=="interval")return;const{scale:Bt,coordinate:Lt}=(_==null?void 0:_.view)||v,{color:It,y:jt,x:Qt}=Bt,ue=Lt.getCenter();C.removeChildren();let ye;const Ke=(be,Ne,Pn,qr)=>ES(this,void 0,void 0,function*(){return d("elementPointMove",fi=>{var yr;const oi=(((yr=_==null?void 0:_.options)===null||yr===void 0?void 0:yr.marks)||g).map(Kr=>{if(!qr.includes(Kr.type))return Kr;const{data:si,encode:Kn}=Kr,Di=Object.keys(Kn).reduce((ce,Ie)=>{const Qe=Kn[Ie];return Ie==="x"&&(ce[Qe]=be),Ie==="y"&&(ce[Qe]=Ne),Ie==="color"&&(ce[Qe]=Pn),ce},{}),ci=Nq(Di,si,Kn);return L(Di,ci),mt({},Kr,{data:ci,animate:!1})});return Object.assign(Object.assign({},fi),{marks:oi})}),yield f("elementPointMove")});if(["line","area"].includes(X))nt.forEach((be,Ne)=>{const Pn=Qt.invert(yt[Ne]);if(!Pn)return;const qr=new tc({name:MS,style:Object.assign({cx:be[0],cy:be[1],fill:tt},s)}),fi=Dq(F,Ne);qr.addEventListener("mousedown",yr=>{const oi=Lt.output([yt[Ne],0]),Kr=ht==null?void 0:ht.length;h.attr("cursor","move"),w[1]!==Ne&&(w[1]=Ne,N()),B4(C.childNodes,w,s);const[si,Kn]=z4(C,qr,a,o),Qr=ci=>{const ce=be[1]+ci.clientY-ye[1];if(P)if(k){const Ie=be[0]+ci.clientX-ye[0],[Qe,nn]=kS(ue,oi,[Ie,ce]),[,Qn]=Lt.output([1,jt.output(0)]),[,Fr]=Lt.invert([Qe,Qn-(nt[Ne+Kr][1]-nn)]),Br=(Ne+1)%Kr,ji=(Ne-1+Kr)%Kr,Co=qp([nt[ji],[Qe,nn],ht[Br]&&nt[Br]]);Kn.attr("text",fi(jt.invert(Fr)).toFixed(n)),si.attr("d",Co),qr.attr("cx",Qe),qr.attr("cy",nn)}else{const[,Ie]=Lt.output([1,jt.output(0)]),[,Qe]=Lt.invert([be[0],Ie-(nt[Ne+Kr][1]-ce)]),nn=qp([nt[Ne-1],[be[0],ce],ht[Ne+1]&&nt[Ne+1]]);Kn.attr("text",fi(jt.invert(Qe)).toFixed(n)),si.attr("d",nn),qr.attr("cy",ce)}else{const[,Ie]=Lt.invert([be[0],ce]),Qe=qp([nt[Ne-1],[be[0],ce],nt[Ne+1]]);Kn.attr("text",jt.invert(Ie).toFixed(n)),si.attr("d",Qe),qr.attr("cy",ce)}};ye=[yr.clientX,yr.clientY],window.addEventListener("mousemove",Qr);const Di=()=>ES(this,void 0,void 0,function*(){if(h.attr("cursor","default"),window.removeEventListener("mousemove",Qr),h.removeEventListener("mouseup",Di),En(Kn.attr("text")))return;const ci=Number(Kn.attr("text")),ce=W4(It,lt);_=yield Ke(Pn,ci,ce,["line","area"]),Kn.remove(),si.remove(),D(F)});h.addEventListener("mouseup",Di)}),C.appendChild(qr)}),B4(C.childNodes,w,s);else if(X==="interval"){let be=[(nt[0][0]+nt[1][0])/2,nt[0][1]];M?be=[nt[0][0],(nt[0][1]+nt[1][1])/2]:A&&(be=nt[0]);const Ne=Iq(F),Pn=new tc({name:MS,style:Object.assign(Object.assign({cx:be[0],cy:be[1],fill:tt},s),{stroke:s.activeStroke})});Pn.addEventListener("mousedown",qr=>{h.attr("cursor","move");const fi=W4(It,lt),[yr,oi]=z4(C,Pn,a,o),Kr=Kn=>{if(M){const Qr=be[0]+Kn.clientX-ye[0],[Di]=Lt.output([jt.output(0),jt.output(0)]),[,ci]=Lt.invert([Di+(Qr-nt[2][0]),be[1]]),ce=qp([[Qr,nt[0][1]],[Qr,nt[1][1]],nt[2],nt[3]],!0);oi.attr("text",Ne(jt.invert(ci)).toFixed(n)),yr.attr("d",ce),Pn.attr("cx",Qr)}else if(A){const Qr=be[1]+Kn.clientY-ye[1],Di=be[0]+Kn.clientX-ye[0],[ci,ce]=kS(ue,[Di,Qr],be),[Ie,Qe]=kS(ue,[Di,Qr],nt[1]),nn=Lt.invert([ci,ce])[1],Qn=gt-nn;if(Qn<0)return;const Fr=pW(ue,[[ci,ce],[Ie,Qe],nt[2],nt[3]],Qn>.5?1:0);oi.attr("text",Ne(Qn,!0).toFixed(n)),yr.attr("d",Fr),Pn.attr("cx",ci),Pn.attr("cy",ce)}else{const Qr=be[1]+Kn.clientY-ye[1],[,Di]=Lt.output([1,jt.output(0)]),[,ci]=Lt.invert([be[0],Di-(nt[2][1]-Qr)]),ce=qp([[nt[0][0],Qr],[nt[1][0],Qr],nt[2],nt[3]],!0);oi.attr("text",Ne(jt.invert(ci)).toFixed(n)),yr.attr("d",ce),Pn.attr("cy",Qr)}};ye=[qr.clientX,qr.clientY],window.addEventListener("mousemove",Kr);const si=()=>ES(this,void 0,void 0,function*(){if(h.attr("cursor","default"),h.removeEventListener("mouseup",si),window.removeEventListener("mousemove",Kr),En(oi.attr("text")))return;const Kn=Number(oi.attr("text"));_=yield Ke(wt,Kn,fi,[X]),oi.remove(),yr.remove(),D(F)});h.addEventListener("mouseup",si)}),C.appendChild(Pn)}};x.forEach((F,W)=>{w[0]===W&&D(F),F.addEventListener("click",R),F.addEventListener("mouseenter",j4),F.addEventListener("mouseleave",F4)});const G=F=>{const W=F==null?void 0:F.target;(!W||W.name!==MS&&!x.includes(W))&&(w=[],N(),C.removeChildren())};return u.on("element-point:select",I),u.on("element-point:unselect",G),h.addEventListener("mousedown",G),()=>{C.remove(),u.off("element-point:select",I),u.off("element-point:unselect",G),h.removeEventListener("mousedown",G),x.forEach(F=>{F.removeEventListener("click",R),F.removeEventListener("mouseenter",j4),F.removeEventListener("mouseleave",F4)})}}}var Fq=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const G4=()=>t=>{const{children:e}=t;if(!Array.isArray(e))return[];const{x:n=0,y:r=0,width:i,height:a,data:o}=t;return e.map(s=>{var{data:c,x:l,y:u,width:f,height:d}=s,h=Fq(s,["data","x","y","width","height"]);return Object.assign(Object.assign({},h),{data:Lw(c,o),x:l!=null?l:n,y:u!=null?u:r,width:f!=null?f:i,height:d!=null?d:a})})};G4.props={};var Bq=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const $4=()=>t=>{const{children:e}=t;if(!Array.isArray(e))return[];const{direction:n="row",ratio:r=e.map(()=>1),padding:i=0,data:a}=t,[o,s,c,l]=n==="col"?["y","height","width","x"]:["x","width","height","y"],u=r.reduce((g,y)=>g+y),f=t[s]-i*(e.length-1),d=r.map(g=>f*(g/u)),h=[];let v=t[o]||0;for(let g=0;g<d.length;g+=1){const y=e[g],{data:b}=y,x=Bq(y,["data"]),_=Lw(b,a);h.push(Object.assign({[o]:v,[s]:d[g],[l]:t[l]||0,[c]:t[c],data:_},x)),v+=d[g]+i}return h};$4.props={};class _0{constructor(e){this.$value=e}static of(e){return new _0(e)}call(e,...n){return this.$value=e(this.$value,...n),this}value(){return this.$value}}var zq=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const Wq=Bp(t=>{const{encode:e,data:n,scale:r,shareSize:i=!1}=t,{x:a,y:o}=e,s=(c,l)=>{var u;if(c===void 0||!i)return{};const f=dr(n,v=>v[c]),d=((u=r==null?void 0:r[l])===null||u===void 0?void 0:u.domain)||Array.from(f.keys()),h=d.map(v=>f.has(v)?f.get(v).length:1);return{domain:d,flex:h}};return{scale:{x:Object.assign(Object.assign({paddingOuter:0,paddingInner:.1,guide:a===void 0?null:{position:"top"}},a===void 0&&{paddingInner:0}),s(a,"x")),y:Object.assign(Object.assign({range:[0,1],paddingOuter:0,paddingInner:.1,guide:o===void 0?null:{position:"right"}},o===void 0&&{paddingInner:0}),s(o,"y"))}}}),AS=yu(t=>{const{data:e,scale:n,legend:r}=t,i=[t];let a,o,s;for(;i.length;){const d=i.shift(),{children:h,encode:v={},scale:g={},legend:y={}}=d,{color:b}=v,{color:x}=g,{color:_}=y;b!==void 0&&(a=b),x!==void 0&&(o=x),_!==void 0&&(s=_),Array.isArray(h)&&i.push(...h)}const c=()=>{var d;const h=(d=n==null?void 0:n.color)===null||d===void 0?void 0:d.domain;if(h!==void 0)return[h];if(a===void 0)return[void 0];const v=typeof a=="function"?a:y=>y[a],g=e.map(v);return g.some(y=>typeof y=="number")?[sc(g)]:[Array.from(new Set(g)),"ordinal"]},l=typeof a=="string"?a:"",[u,f]=c();return Object.assign({encode:{color:{type:"column",value:u!=null?u:[]}},scale:{color:mt({},o,{domain:u,type:f})}},r===void 0&&{legend:{color:mt({title:l},s)}})}),TS=Bp(()=>({animate:{enterType:"fadeIn"}})),PS=yu(()=>({frame:!1,encode:{shape:"hollow"},style:{lineWidth:0}})),CS=yu(()=>({type:"cell"})),Z4=yu(t=>{const{data:e}=t;return{data:{type:"inline",value:e,transform:[{type:"custom",callback:()=>{const{data:r,encode:i}=t,{x:a,y:o}=i,s=a?Array.from(new Set(r.map(u=>u[a]))):[],c=o?Array.from(new Set(r.map(u=>u[o]))):[];return(()=>{if(s.length&&c.length){const u=[];for(const f of s)for(const d of c)u.push({[a]:f,[o]:d});return u}if(s.length)return s.map(u=>({[a]:u}));if(c.length)return c.map(u=>({[o]:u}))})()}}]}}}),Y4=yu((t,e=Gq,n=$q,r=Zq,i={})=>{const{data:a,encode:o,children:s,scale:c,x:l=0,y:u=0,shareData:f=!1,key:d}=t,{value:h}=a,{x:v,y:g}=o,{color:y}=c,{domain:b}=y;return{children:(_,w,O)=>{const{x:E,y:M}=w,{paddingLeft:k,paddingTop:A,marginLeft:P,marginTop:C}=O,{domain:N}=E.getOptions(),{domain:L}=M.getOptions(),R=fu(_),I=_.map(e),D=_.map(({x:tt,y:nt})=>[E.invert(tt),M.invert(nt)]),F=D.map(([tt,nt])=>ht=>{const{[v]:lt,[g]:wt}=ht;return(v!==void 0?lt===tt:!0)&&(g!==void 0?wt===nt:!0)}).map(tt=>h.filter(tt)),W=f?Dn(F,tt=>tt.length):void 0,X=D.map(([tt,nt])=>({columnField:v,columnIndex:N.indexOf(tt),columnValue:tt,columnValuesLength:N.length,rowField:g,rowIndex:L.indexOf(nt),rowValue:nt,rowValuesLength:L.length})),Q=X.map(tt=>Array.isArray(s)?s:[s(tt)].flat(1));return R.flatMap(tt=>{const[nt,ht,lt,wt]=I[tt],yt=X[tt],gt=F[tt];return Q[tt].map(Lt=>{var It,jt,{scale:Qt,key:ue,facet:ye=!0,axis:Ke={},legend:be={}}=Lt,Ne=zq(Lt,["scale","key","facet","axis","legend"]);const Pn=((It=Qt==null?void 0:Qt.y)===null||It===void 0?void 0:It.guide)||Ke.y,qr=((jt=Qt==null?void 0:Qt.x)===null||jt===void 0?void 0:jt.guide)||Ke.x,fi={x:{tickCount:v?5:void 0},y:{tickCount:g?5:void 0}},yr=ye?gt:gt.length===0?[]:h,oi={color:{domain:b}},Kr={x:H4(qr,n)(yt,yr),y:H4(Pn,r)(yt,yr)};return Object.assign(Object.assign({key:`${ue}-${tt}`,data:yr,margin:0,x:nt+k+l+P,y:ht+A+u+C,parentKey:d,width:lt,height:wt,paddingLeft:0,paddingRight:0,paddingTop:0,paddingBottom:0,frame:!!yr.length,dataDomain:W,scale:mt(fi,Qt,oi),axis:mt({},Ke,Kr),legend:!1},Ne),i)})})}}});function Gq(t){const{points:e}=t;return Nw(e)}function M1(t,e){return e.length?mt({title:!1,tick:null,label:null},t):mt({title:!1,tick:null,label:null,grid:null},t)}function $q(t){return(e,n)=>{const{rowIndex:r,rowValuesLength:i,columnIndex:a,columnValuesLength:o}=e;if(r!==i-1)return M1(t,n);const s=a!==o-1?!1:void 0,c=n.length?void 0:null;return mt({title:s,grid:c},t)}}function Zq(t){return(e,n)=>{const{rowIndex:r,columnIndex:i}=e;if(i!==0)return M1(t,n);const a=r!==0?!1:void 0,o=n.length?void 0:null;return mt({title:a,grid:o},t)}}function H4(t,e){return typeof t=="function"?t:t===null||t===!1?()=>null:e(t)}const V4=()=>t=>[_0.of(t).call(CS).call(AS).call(TS).call(Wq).call(PS).call(Z4).call(Y4).value()];V4.props={};var LS=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const Yq=Bp(t=>({scale:{x:{guide:null,paddingOuter:0,paddingInner:.1},y:{guide:null,range:[0,1],paddingOuter:0,paddingInner:.1}}})),Hq=yu(t=>{const{data:e,children:n,x:r=0,y:i=0,key:a}=t;return{children:(s,c,l)=>{const{x:u,y:f}=c,{paddingLeft:d,paddingTop:h,marginLeft:v,marginTop:g}=l,{domain:y}=u.getOptions(),{domain:b}=f.getOptions(),x=fu(s),_=s.map(({points:M})=>Nw(M)),w=s.map(({x:M,y:k})=>[u.invert(M),f.invert(k)]),O=w.map(([M,k])=>({columnField:M,columnIndex:y.indexOf(M),columnValue:M,columnValuesLength:y.length,rowField:k,rowIndex:b.indexOf(k),rowValue:k,rowValuesLength:b.length})),E=O.map(M=>Array.isArray(n)?n:[n(M)].flat(1));return x.flatMap(M=>{const[k,A,P,C]=_[M],[N,L]=w[M],R=O[M];return E[M].map(D=>{var G,F;const{scale:W,key:X,encode:Q,axis:tt,interaction:nt}=D,ht=LS(D,["scale","key","encode","axis","interaction"]),lt=(G=W==null?void 0:W.y)===null||G===void 0?void 0:G.guide,wt=(F=W==null?void 0:W.x)===null||F===void 0?void 0:F.guide,yt={x:{facet:!1},y:{facet:!1}},gt={x:Xq(wt)(R,e),y:Uq(lt)(R,e)},Bt={x:{tickCount:5},y:{tickCount:5}};return Object.assign({data:e,parentKey:a,key:`${X}-${M}`,x:k+d+r+v,y:A+h+i+g,width:P,height:C,margin:0,paddingLeft:0,paddingRight:0,paddingTop:0,paddingBottom:0,frame:!0,scale:mt(yt,W),axis:mt(Bt,tt,gt),legend:!1,encode:mt({},Q,{x:N,y:L}),interaction:mt({},nt,{legendFilter:!1})},ht)})})}}}),Vq=yu(t=>{const{encode:e}=t,n=LS(t,["encode"]),{position:r=[],x:i=r,y:a=[...r].reverse()}=e,o=LS(e,["position","x","y"]),s=[];for(const c of[i].flat(1))for(const l of[a].flat(1))s.push({$x:c,$y:l});return Object.assign(Object.assign({},n),{data:s,encode:Object.assign(Object.assign({},o),{x:"$x",y:"$y"}),scale:Object.assign(Object.assign({},[i].flat(1).length===1&&{x:{paddingInner:0}}),[a].flat(1).length===1&&{y:{paddingInner:0}})})});function Xq(t){return typeof t=="function"?t:t===null?()=>null:(e,n)=>{const{rowIndex:r,rowValuesLength:i}=e;if(r!==i-1)return M1(t,n)}}function Uq(t){return typeof t=="function"?t:t===null?()=>null:(e,n)=>{const{columnIndex:r}=e;if(r!==0)return M1(t,n)}}const qq=()=>t=>[_0.of(t).call(CS).call(AS).call(Hq).call(Vq).call(TS).call(PS).call(Yq).value()];var Kq=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const Qq=Bp(t=>({scale:{x:{guide:{type:"axisArc"},paddingOuter:0,paddingInner:.1},y:{guide:null,range:[0,1],paddingOuter:0,paddingInner:.1}}})),Jq=Bp(t=>({coordinate:{type:"polar"}})),tK=t=>{const{encode:e}=t,n=Kq(t,["encode"]),{position:r}=e;return Object.assign(Object.assign({},n),{encode:{x:r}})};function X4(t){return e=>null}function eK(t){const{points:e}=t,[n,r,i,a]=e,o=wr(n,a),s=Mr(n,a),c=Mr(r,i),l=mP(s,c),u=1/Math.sin(l/2),f=o/(1+u),d=f*Math.sqrt(2),[h,v]=i,y=id(s)+l/2,b=f*u,x=h+b*Math.sin(y),_=v-b*Math.cos(y);return[x-d/2,_-d/2,d,d]}const nK=()=>t=>[_0.of(t).call(CS).call(tK).call(AS).call(Jq).call(Z4).call(Y4,eK,X4,X4,{frame:!1}).call(TS).call(PS).call(Qq).value()];function rK(t,e,n){const i=n,a=[0,i],o=[-i+1,1];if(t==="normal")return a;if(t==="reverse")return o;if(t==="alternate")return e%2===0?a:o;if(t==="reverse-alternate")return e%2===0?o:a}function iK(t,e,n){const r=[t];for(;r.length;){const i=r.pop();i.animate=mt({enter:{duration:e},update:{duration:e,easing:n,type:"morphing",fill:"both"},exit:{type:"fadeOut",duration:e}},i.animate||{});const{children:a}=i;Array.isArray(a)&&r.push(...a)}return t}const U4=()=>t=>{const{children:e=[],duration:n=1e3,iterationCount:r=1,direction:i="normal",easing:a="ease-in-out-sine"}=t,o=e.length;if(!Array.isArray(e)||o===0)return[];const{key:s}=e[0],c=e.map(l=>Object.assign(Object.assign({},l),{key:s})).map(l=>iK(l,n,a));return function*(){let l=0,u;for(;r==="infinite"||l<r;){const[f,d]=rK(i,l,o);for(let h=f;h<d;h+=1){const v=Math.abs(h);u!==v&&(yield c[v]),u=v}l++}}};U4.props={};function ml(t,e,n){const{encode:r}=n;if(t===null)return[e];const i=aK(t).map(o=>{var s;return[o,(s=hn(r,o))===null||s===void 0?void 0:s[0]]}).filter(([,o])=>qn(o)),a=o=>i.map(([,s])=>s[o]).join("-");return Array.from(dr(e,a).values())}function q4(t){return Array.isArray(t)?cK(t):typeof t=="function"?sK(t):t==="series"?oK:t==="value"?lK:t==="sum"?uK:t==="maxIndex"?fK:null}function K4(t,e){for(const n of t)n.sort(e)}function Q4(t,e){return(e==null?void 0:e.domain)||Array.from(new Set(t))}function aK(t){return Array.isArray(t)?t:[t]}function oK(t,e,n){return w0(r=>n[r])}function sK(t){return(e,n,r)=>w0(i=>t(e[i]))}function cK(t){return(e,n,r)=>(i,a)=>t.reduce((o,s)=>o!==0?o:kr(e[i][s],e[a][s]),0)}function lK(t,e,n){return w0(r=>e[r])}function uK(t,e,n){const r=fu(t),i=Array.from(dr(r,o=>n[+o]).entries()),a=new Map(i.map(([o,s])=>[o,s.reduce((c,l)=>c+ +e[l])]));return w0(o=>a.get(n[o]))}function fK(t,e,n){const r=fu(t),i=Array.from(dr(r,o=>n[+o]).entries()),a=new Map(i.map(([o,s])=>[o,od(s,c=>e[c])]));return w0(o=>a.get(n[o]))}function w0(t){return(e,n)=>kr(t(e),t(n))}const J4=(t={})=>{const{groupBy:e="x",orderBy:n=null,reverse:r=!1,y:i="y",y1:a="y1",series:o=!0}=t;return(s,c)=>{var l;const{data:u,encode:f,style:d={}}=c,[h,v]=hn(f,"y"),[g,y]=hn(f,"y1"),[b]=o?i0(f,"series","color"):hn(f,"color"),x=ml(e,s,c),w=((l=q4(n))!==null&&l!==void 0?l:()=>null)(u,h,b);w&&K4(x,w);const O=new Array(s.length),E=new Array(s.length),M=new Array(s.length),k=[],A=[];for(const I of x){r&&I.reverse();const D=g?+g[I[0]]:0,G=[],F=[];for(const lt of I){const wt=M[lt]=+h[lt]-D;wt<0?F.push(lt):wt>=0&&G.push(lt)}const W=G.length>0?G:F,X=F.length>0?F:G;let Q=G.length-1,tt=0;for(;Q>0&&h[W[Q]]===0;)Q--;for(;tt<X.length-1&&h[X[tt]]===0;)tt++;k.push(W[Q]),A.push(X[tt]);let nt=D;for(const lt of F.reverse()){const wt=M[lt];nt=O[lt]=(E[lt]=nt)+wt}let ht=D;for(const lt of G){const wt=M[lt];wt>0?ht=O[lt]=(E[lt]=ht)+wt:O[lt]=E[lt]=ht}}const P=new Set(k),C=new Set(A),N=i==="y"?O:E,L=a==="y"?O:E;let R;return c.type==="point"?R={y0:r0(h,v),y:Zn(N,v)}:R={y0:r0(h,v),y:Zn(N,v),y1:Zn(L,y)},[s,mt({},c,{encode:Object.assign({},R),style:Object.assign({first:(I,D)=>P.has(D),last:(I,D)=>C.has(D)},d)})]}};J4.props={};function tI(t,e){let n=0;if(e===void 0)for(let r of t)r!=null&&(r=+r)>=r&&++n;else{let r=-1;for(let i of t)(i=e(i,++r,t))!=null&&(i=+i)>=i&&++n}return n}function dK(t,e){let n=0,r,i=0,a=0;if(e===void 0)for(let o of t)o!=null&&(o=+o)>=o&&(r=o-i,i+=r/++n,a+=r*(o-i));else{let o=-1;for(let s of t)(s=e(s,++o,t))!=null&&(s=+s)>=s&&(r=s-i,i+=r/++n,a+=r*(s-i))}if(n>1)return a/(n-1)}function eI(t,e){const n=dK(t,e);return n&&Math.sqrt(n)}function hK(t,e,n){const r=tI(t),i=eI(t);return r&&i?Math.ceil((n-e)*Math.cbrt(r)/(3.49*i)):1}var nI=Array.prototype,pK=nI.slice,Bot=nI.map;function RS(t){return()=>t}const vK=Math.sqrt(50),gK=Math.sqrt(10),yK=Math.sqrt(2);function k1(t,e,n){const r=(e-t)/Math.max(0,n),i=Math.floor(Math.log10(r)),a=r/Math.pow(10,i),o=a>=vK?10:a>=gK?5:a>=yK?2:1;let s,c,l;return i<0?(l=Math.pow(10,-i)/o,s=Math.round(t*l),c=Math.round(e*l),s/l<t&&++s,c/l>e&&--c,l=-l):(l=Math.pow(10,i)*o,s=Math.round(t/l),c=Math.round(e/l),s*l<t&&++s,c*l>e&&--c),c<s&&.5<=n&&n<2?k1(t,e,n*2):[s,c,l]}function mK(t,e,n){if(e=+e,t=+t,n=+n,!(n>0))return[];if(t===e)return[t];const r=e<t,[i,a,o]=r?k1(e,t,n):k1(t,e,n);if(!(a>=i))return[];const s=a-i+1,c=new Array(s);if(r)if(o<0)for(let l=0;l<s;++l)c[l]=(a-l)/-o;else for(let l=0;l<s;++l)c[l]=(a-l)*o;else if(o<0)for(let l=0;l<s;++l)c[l]=(i+l)/-o;else for(let l=0;l<s;++l)c[l]=(i+l)*o;return c}function O0(t,e,n){return e=+e,t=+t,n=+n,k1(t,e,n)[2]}function zot(t,e,n){e=+e,t=+t,n=+n;const r=e<t,i=r?O0(e,t,n):O0(t,e,n);return(r?-1:1)*(i<0?1/-i:i)}function bK(t,e,n){let r;for(;;){const i=O0(t,e,n);if(i===r||i===0||!isFinite(i))return[t,e];i>0?(t=Math.floor(t/i)*i,e=Math.ceil(e/i)*i):i<0&&(t=Math.ceil(t*i)/i,e=Math.floor(e*i)/i),r=i}}function xK(t){return Math.max(1,Math.ceil(Math.log(tI(t))/Math.LN2)+1)}function _K(){var t=wp,e=sc,n=xK;function r(i){Array.isArray(i)||(i=Array.from(i));var a,o=i.length,s,c,l=new Array(o);for(a=0;a<o;++a)l[a]=t(i[a],a,i);var u=e(l),f=u[0],d=u[1],h=n(l,f,d);if(!Array.isArray(h)){const _=d,w=+h;if(e===sc&&([f,d]=bK(f,d,w)),h=mK(f,d,w),h[0]<=f&&(c=O0(f,d,w)),h[h.length-1]>=d)if(_>=d&&e===sc){const O=O0(f,d,w);isFinite(O)&&(O>0?d=(Math.floor(d/O)+1)*O:O<0&&(d=(Math.ceil(d*-O)+1)/-O))}else h.pop()}for(var v=h.length,g=0,y=v;h[g]<=f;)++g;for(;h[y-1]>d;)--y;(g||y<v)&&(h=h.slice(g,y),v=y-g);var b=new Array(v+1),x;for(a=0;a<=v;++a)x=b[a]=[],x.x0=a>0?h[a-1]:f,x.x1=a<v?h[a]:d;if(isFinite(c)){if(c>0)for(a=0;a<o;++a)(s=l[a])!=null&&f<=s&&s<=d&&b[Math.min(v,Math.floor((s-f)/c))].push(i[a]);else if(c<0){for(a=0;a<o;++a)if((s=l[a])!=null&&f<=s&&s<=d){const _=Math.floor((f-s)*c);b[Math.min(v,_+(h[_]<=s))].push(i[a])}}}else for(a=0;a<o;++a)(s=l[a])!=null&&f<=s&&s<=d&&b[Kz(h,s,0,v)].push(i[a]);return b}return r.value=function(i){return arguments.length?(t=typeof i=="function"?i:RS(i),r):t},r.domain=function(i){return arguments.length?(e=typeof i=="function"?i:RS([i[0],i[1]]),r):e},r.thresholds=function(i){return arguments.length?(n=typeof i=="function"?i:RS(Array.isArray(i)?pK.call(i):i),r):n},r}function NS(t,e,n=0,r=1/0,i){if(e=Math.floor(e),n=Math.floor(Math.max(0,n)),r=Math.floor(Math.min(t.length-1,r)),!(n<=e&&e<=r))return t;for(i=i===void 0?$p:IP(i);r>n;){if(r-n>600){const c=r-n+1,l=e-n+1,u=Math.log(c),f=.5*Math.exp(2*u/3),d=.5*Math.sqrt(u*f*(c-f)/c)*(l-c/2<0?-1:1),h=Math.max(n,Math.floor(e-l*f/c+d)),v=Math.min(r,Math.floor(e+(c-l)*f/c+d));NS(t,e,h,v,i)}const a=t[e];let o=n,s=r;for(S0(t,n,e),i(t[r],a)>0&&S0(t,n,r);o<s;){for(S0(t,o,s),++o,--s;i(t[o],a)<0;)++o;for(;i(t[s],a)>0;)--s}i(t[n],a)===0?S0(t,n,s):(++s,S0(t,s,r)),s<=e&&(n=s+1),e<=s&&(r=s-1)}return t}function S0(t,e,n){const r=t[e];t[e]=t[n],t[n]=r}function wK(t,e=kr){let n,r=!1;if(e.length===1){let i;for(const a of t){const o=e(a);(r?kr(o,i)>0:kr(o,o)===0)&&(n=a,i=o,r=!0)}}else for(const i of t)(r?e(i,n)>0:e(i,i)===0)&&(n=i,r=!0);return n}function A1(t,e,n){if(t=Float64Array.from(Vz(t,n)),!(!(r=t.length)||isNaN(e=+e))){if(e<=0||r<2)return Za(t);if(e>=1)return Dn(t);var r,i=(r-1)*e,a=Math.floor(i),o=Dn(NS(t,a).subarray(0,a+1)),s=Za(t.subarray(a+1));return o+(s-o)*(i-a)}}function Wot(t,e,n=number){if(!(!(r=t.length)||isNaN(e=+e))){if(e<=0||r<2)return+n(t[0],0,t);if(e>=1)return+n(t[r-1],r-1,t);var r,i=(r-1)*e,a=Math.floor(i),o=+n(t[a],a,t),s=+n(t[a+1],a+1,t);return o+(s-o)*(i-a)}}function OK(t,e,n=$w){if(!isNaN(e=+e)){if(r=Float64Array.from(t,(s,c)=>$w(n(t[c],c,t))),e<=0)return b0(r);if(e>=1)return od(r);var r,i=Uint32Array.from(t,(s,c)=>c),a=r.length-1,o=Math.floor(a*e);return NS(i,o,0,a,(s,c)=>$p(r[s],r[c])),o=wK(i.subarray(0,o+1),s=>r[s]),o>=0?o:-1}}function IS(t,e){return A1(t,.5,e)}function SK(t,e){return OK(t,.5,e)}var EK=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function bl(t){return e=>e===null?t:`${t} of ${e}`}function MK(t){if(typeof t=="function")return[t,null];const n={mean:kK,max:TK,count:CK,first:RK,last:NK,sum:LK,min:PK,median:AK}[t];if(!n)throw new Error(`Unknown reducer: ${t}.`);return n()}function kK(){const t=(n,r)=>x0(n,i=>+r[i]),e=bl("mean");return[t,e]}function AK(){const t=(n,r)=>IS(n,i=>+r[i]),e=bl("median");return[t,e]}function TK(){const t=(n,r)=>Dn(n,i=>+r[i]),e=bl("max");return[t,e]}function PK(){const t=(n,r)=>Za(n,i=>+r[i]),e=bl("min");return[t,e]}function CK(){const t=(n,r)=>n.length,e=bl("count");return[t,e]}function LK(){const t=(n,r)=>bo(n,i=>+r[i]),e=bl("sum");return[t,e]}function RK(){const t=(n,r)=>r[n[0]],e=bl("first");return[t,e]}function NK(){const t=(n,r)=>r[n[n.length-1]],e=bl("last");return[t,e]}const DS=(t={})=>{const{groupBy:e}=t,n=EK(t,["groupBy"]);return(r,i)=>{const{data:a,encode:o}=i,s=e(r,i);if(!s)return[r,i];const c=(h,v)=>{if(h)return h;const{from:g}=v;if(!g)return h;const[,y]=hn(o,g);return y},l=Object.entries(n).map(([h,v])=>{const[g,y]=MK(v),[b,x]=hn(o,h),_=c(x,v),w=s.map(O=>g(O,b!=null?b:a));return[h,Object.assign(Object.assign({},gH(w,(y==null?void 0:y(_))||_)),{aggregate:!0})]}),u=Object.keys(o).map(h=>{const[v,g]=hn(o,h),y=s.map(b=>v[b[0]]);return[h,Zn(y,g)]}),f=s.map(h=>a[h[0]]);return[fu(s),mt({},i,{data:f,encode:Object.fromEntries([...u,...l])})]}};DS.props={};var IK=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const rI="thresholds";function DK(t){const[e,n]=sc(t);return Math.min(200,hK(t,e,n))}const jS=(t={})=>{const{groupChannels:e=["color"],binChannels:n=["x","y"]}=t,r=IK(t,["groupChannels","binChannels"]),i={},a=(o,s)=>{const{encode:c}=s,l=n.map(v=>{const[g]=hn(c,v);return g}),u=$t(r,rI),f=o.filter(v=>l.every(g=>qn(g[v]))),d=[...e.map(v=>{const[g]=hn(c,v);return g}).filter(qn).map(v=>g=>v[g]),...n.map((v,g)=>{const y=l[g],b=u[v]||DK(y),x=_K().thresholds(b).value(w=>+y[w])(f),_=new Map(x.flatMap(w=>{const{x0:O,x1:E}=w,M=`${O},${E}`;return w.map(k=>[k,M])}));return i[v]=_,w=>_.get(w)})],h=v=>d.map(g=>g(v)).join("-");return Array.from(dr(f,h).values())};return DS(Object.assign(Object.assign(Object.assign({},Object.fromEntries(Object.entries(r).filter(([o])=>!o.startsWith(rI)))),Object.fromEntries(n.flatMap(o=>{const s=([l])=>+i[o].get(l).split(",")[0],c=([l])=>+i[o].get(l).split(",")[1];return c.from=o,[[o,s],[`${o}1`,c]]}))),{groupBy:a}))};jS.props={};const iI=(t={})=>{const{thresholds:e}=t;return jS(Object.assign(Object.assign({},t),{thresholdsX:e,groupChannels:["color"],binChannels:["x"]}))};iI.props={};var jK=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const aI=(t={})=>{const{groupBy:e="x",reverse:n=!1,orderBy:r,padding:i}=t,a=jK(t,["groupBy","reverse","orderBy","padding"]);return(o,s)=>{const{data:c,encode:l,scale:u}=s,{series:f}=u,[d]=hn(l,"y"),[h]=i0(l,"series","color"),v=Q4(h,f),g=mt({},s,{scale:{series:{domain:v,paddingInner:i}}}),y=ml(e,o,s),b=q4(r);if(!b)return[o,mt(g,{encode:{series:Zn(h)}})];const x=b(c,d,h);x&&K4(y,x);const _=new Array(o.length);for(const w of y){n&&w.reverse();for(let O=0;O<w.length;O++)_[w[O]]=v[O]}return[o,mt(g,{encode:{series:Zn(r?_:h)}})]}};aI.props={};function T1(t,e,n){if(t===null)return[-.5,.5];const r=Q4(t,e),a=new pl({domain:r,range:[0,1],padding:n}).getBandWidth();return[-a/2,a/2]}function P1(t,e,n){return e*(1-t)+n*t}const oI=(t={})=>{const{padding:e=0,paddingX:n=e,paddingY:r=e,random:i=Math.random}=t;return(a,o)=>{const{encode:s,scale:c}=o,{x:l,y:u}=c,[f]=hn(s,"x"),[d]=hn(s,"y"),h=T1(f,l,n),v=T1(d,u,r),g=a.map(()=>P1(i(),...v)),y=a.map(()=>P1(i(),...h));return[a,mt({scale:{x:{padding:.5},y:{padding:.5}}},o,{encode:{dy:Zn(g),dx:Zn(y)}})]}};oI.props={};const sI=(t={})=>{const{padding:e=0,random:n=Math.random}=t;return(r,i)=>{const{encode:a,scale:o}=i,{x:s}=o,[c]=hn(a,"x"),l=T1(c,s,e),u=r.map(()=>P1(n(),...l));return[r,mt({scale:{x:{padding:.5}}},i,{encode:{dx:Zn(u)}})]}};sI.props={};const cI=(t={})=>{const{padding:e=0,random:n=Math.random}=t;return(r,i)=>{const{encode:a,scale:o}=i,{y:s}=o,[c]=hn(a,"y"),l=T1(c,s,e),u=r.map(()=>P1(n(),...l));return[r,mt({scale:{y:{padding:.5}}},i,{encode:{dy:Zn(u)}})]}};cI.props={};var FK=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const lI=(t={})=>{const{groupBy:e="x"}=t;return(n,r)=>{const{encode:i}=r,{x:a}=i,o=FK(i,["x"]),s=Object.entries(o).filter(([d])=>d.startsWith("y")).map(([d])=>[d,hn(i,d)[0]]),c=s.map(([d])=>[d,new Array(n.length)]),l=ml(e,n,r),u=new Array(l.length);for(let d=0;d<l.length;d++){const v=l[d].flatMap(b=>s.map(([,x])=>+x[b])),[g,y]=sc(v);u[d]=(g+y)/2}const f=Math.max(...u);for(let d=0;d<l.length;d++){const h=f-u[d],v=l[d];for(const g of v)for(let y=0;y<s.length;y++){const[,b]=s[y],[,x]=c[y];x[g]=+b[g]+h}}return[n,mt({},r,{encode:Object.fromEntries(c.map(([d,h])=>[d,Zn(h,hn(i,d)[1])]))})]}};lI.props={};const uI=(t={})=>{const{groupBy:e="x",series:n=!0}=t;return(r,i)=>{const{encode:a}=i,[o]=hn(a,"y"),[s,c]=hn(a,"y1"),[l]=n?i0(a,"series","color"):hn(a,"color"),u=ml(e,r,i),f=new Array(r.length);for(const d of u){const h=d.map(v=>+o[v]);for(let v=0;v<d.length;v++){const g=d[v],y=Math.max(...h.filter((b,x)=>x!==v));f[g]=+o[g]>y?y:o[g]}}return[r,mt({},i,{encode:{y1:Zn(f,c)}})]}};uI.props={};const fI=t=>{const{groupBy:e=["x"],reducer:n=(o,s)=>s[o[0]],orderBy:r=null,reverse:i=!1,duration:a}=t;return(o,s)=>{const{encode:c}=s,u=(Array.isArray(e)?e:[e]).map(y=>[y,hn(c,y)[0]]);if(u.length===0)return[o,s];let f=[o];for(const[,y]of u){const b=[];for(const x of f){const _=Array.from(dr(x,w=>y[w]).values());b.push(..._)}f=b}if(r){const[y]=hn(c,r);y&&f.sort((b,x)=>n(b,y)-n(x,y)),i&&f.reverse()}const d=(a||3e3)/f.length,[h]=a?[dl(o,d)]:i0(c,"enterDuration",dl(o,d)),[v]=i0(c,"enterDelay",dl(o,0)),g=new Array(o.length);for(let y=0,b=0;y<f.length;y++){const x=f[y],_=Dn(x,w=>+h[w]);for(const w of x)g[w]=+v[w]+b;b+=_}return[o,mt({},s,{encode:{enterDuration:e1(h),enterDelay:e1(g)}})]}};fI.props={};var BK=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function zK(t){return typeof t=="function"?t:{min:(n,r)=>Za(n,i=>r[+i]),max:(n,r)=>Dn(n,i=>r[+i]),first:(n,r)=>r[n[0]],last:(n,r)=>r[n[n.length-1]],mean:(n,r)=>x0(n,i=>r[+i]),median:(n,r)=>IS(n,i=>r[+i]),sum:(n,r)=>bo(n,i=>r[+i]),deviation:(n,r)=>eI(n,i=>r[+i])}[t]||Dn}const dI=(t={})=>{const{groupBy:e="x",basis:n="max"}=t;return(r,i)=>{const{encode:a,tooltip:o}=i,{x:s}=a,c=BK(a,["x"]),l=Object.entries(c).filter(([g])=>g.startsWith("y")).map(([g])=>[g,hn(a,g)[0]]),[,u]=l.find(([g])=>g==="y"),f=l.map(([g])=>[g,new Array(r.length)]),d=ml(e,r,i),h=zK(n);for(const g of d){const y=h(g,u);for(const b of g)for(let x=0;x<l.length;x++){const[,_]=l[x],[,w]=f[x];w[b]=+_[b]/y}}const v=rc(o)||(o==null?void 0:o.items)&&(o==null?void 0:o.items.length)!==0;return[r,mt({},i,Object.assign({encode:Object.fromEntries(f.map(([g,y])=>[g,Zn(y,hn(a,g)[1])]))},!v&&a.y0&&{tooltip:{items:[{channel:"y0"}]}}))]}};dI.props={};function hI(t,e){return[t[0]]}function WK(t,e){const n=t.length-1;return[t[n]]}function GK(t,e){const n=od(t,r=>e[r]);return[t[n]]}function $K(t,e){const n=b0(t,r=>e[r]);return[t[n]]}function ZK(t){return typeof t=="function"?t:{first:hI,last:WK,max:GK,min:$K}[t]||hI}const C1=(t={})=>{const{groupBy:e="series",channel:n,selector:r}=t;return(i,a)=>{const{encode:o}=a,s=ml(e,i,a),[c]=hn(o,n),l=ZK(r);return[s.flatMap(u=>l(u,c)),a]}};C1.props={};var YK=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const pI=(t={})=>{const{selector:e}=t,n=YK(t,["selector"]);return C1(Object.assign({channel:"x",selector:e},n))};pI.props={};var HK=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const vI=(t={})=>{const{selector:e}=t,n=HK(t,["selector"]);return C1(Object.assign({channel:"y",selector:e},n))};vI.props={};var VK=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const E0=(t={})=>{const{channels:e=["x","y"]}=t,n=VK(t,["channels"]),r=(i,a)=>ml(e,i,a);return DS(Object.assign(Object.assign({},n),{groupBy:r}))};E0.props={};const gI=(t={})=>E0(Object.assign(Object.assign({},t),{channels:["x","color","series"]}));gI.props={};const yI=(t={})=>E0(Object.assign(Object.assign({},t),{channels:["y","color","series"]}));yI.props={};const mI=(t={})=>E0(Object.assign(Object.assign({},t),{channels:["color"]}));mI.props={};function XK(t,e,n){return(e.length!==2?Wo(U_(t,e,n),([r,i],[a,o])=>kr(i,o)||kr(r,a)):Wo(dr(t,n),([r,i],[a,o])=>e(i,o)||kr(r,a))).map(([r])=>r)}var bI=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function UK(t,e,n){const{by:r=t,reducer:i="max"}=e,[a]=hn(n,r);if(typeof i=="function")return o=>i(o,a);if(i==="max")return o=>Dn(o,s=>+a[s]);if(i==="min")return o=>Za(o,s=>+a[s]);if(i==="sum")return o=>bo(o,s=>+a[s]);if(i==="median")return o=>IS(o,s=>+a[s]);if(i==="mean")return o=>x0(o,s=>+a[s]);if(i==="first")return o=>a[o[0]];if(i==="last")return o=>a[o[o.length-1]];throw new Error(`Unknown reducer: ${i}`)}function qK(t,e,n){const{reverse:r,channel:i}=n,{encode:a}=e,[o]=hn(a,i),s=Wo(t,c=>o[c]);return r&&s.reverse(),[s,e]}function KK(t,e,n){if(!Array.isArray(n))return t;const r=new Set(n);return t.filter(i=>r.has(e[i]))}function QK(t,e,n){var r;const{reverse:i,slice:a,channel:o}=n,s=bI(n,["reverse","slice","channel"]),{encode:c,scale:l={}}=e,u=(r=l[o])===null||r===void 0?void 0:r.domain,[f]=hn(c,o),d=UK(o,s,c),h=KK(t,f,u),v=XK(h,d,b=>f[b]);i&&v.reverse();const g=typeof a=="number"?[0,a]:a,y=a?v.slice(...g):v;return[t,mt(e,{scale:{[o]:{domain:y}}})]}const L1=(t={})=>{const{reverse:e=!1,slice:n,channel:r,ordinal:i=!0}=t,a=bI(t,["reverse","slice","channel","ordinal"]);return(o,s)=>i?QK(o,s,Object.assign({reverse:e,slice:n,channel:r},a)):qK(o,s,Object.assign({reverse:e,slice:n,channel:r},a))};L1.props={};const xI=(t={})=>L1(Object.assign(Object.assign({},t),{channel:"x"}));xI.props={};const _I=(t={})=>L1(Object.assign(Object.assign({},t),{channel:"y"}));_I.props={};const wI=(t={})=>L1(Object.assign(Object.assign({},t),{channel:"color"}));wI.props={};function JK(t,e){return typeof e=="string"?t.map(n=>n[e]):t.map(e)}function tQ(t,e){if(typeof t=="function")return n=>t(n,e);if(t==="sum")return n=>bo(n,r=>+e[r]);throw new Error(`Unknown reducer: ${t}`)}const OI=(t={})=>{const{field:e,channel:n="y",reducer:r="sum"}=t;return(i,a)=>{const{data:o,encode:s}=a,[c]=hn(s,"x"),l=e?JK(o,e):hn(s,n)[0],u=tQ(r,l),f=Jy(i,u,d=>c[d]).map(d=>d[1]);return[i,mt({},a,{scale:{x:{flex:f}}})]}};OI.props={};function eQ(t){const{padding:e=0,direction:n="col"}=t;return(r,i,a)=>{const o=r.length;if(o===0)return[];const{innerWidth:s,innerHeight:c}=a,l=c/s;let u=Math.ceil(Math.sqrt(i/l)),f=s/u,d=Math.ceil(i/u),h=d*f;for(;h>c;)u=u+1,f=s/u,d=Math.ceil(i/u),h=d*f;const v=c-d*f,g=d<=1?0:v/(d-1),[y,b]=d<=1?[(s-o*f)/(o-1),(c-f)/2]:[0,0];return r.map((x,_)=>{const[w,O,E,M]=Nw(x),k=n==="col"?_%u:Math.floor(_/d),A=n==="col"?Math.floor(_/u):_%d,P=k*f,C=(d-A-1)*f+v,N=(f-e)/E,L=(f-e)/M,R=P-w+y*k+1/2*e,I=C-O-g*A-b+1/2*e;return`translate(${R}, ${I}) scale(${N}, ${L})`})}}const SI=t=>(e,n)=>[e,mt({},n,{modifier:eQ(t),axis:!1})];SI.props={};function nQ(t,e,n,r){const i=t.length;if(r>=i||r===0)return t;const a=h=>e[t[h]]*1,o=h=>n[t[h]]*1,s=[],c=(i-2)/(r-2);let l=0,u,f,d;s.push(l);for(let h=0;h<r-2;h++){let v=0,g=0,y=Math.floor((h+1)*c)+1,b=Math.floor((h+2)*c)+1;b=Math.min(b,i);const x=b-y;for(;y<b;y++)v+=a(y),g+=o(y);v/=x,g/=x;let _=Math.floor((h+0)*c)+1;const w=Math.floor((h+1)*c)+1,O=[a(l),o(l)];for(u=f=-1;_<w;_++)f=Math.abs((O[0]-v)*(a(_)-O[1])-(O[0]-o(_))*(g-O[0]))*.5,f>u&&(u=f,d=_);s.push(d),l=d}return s.push(i-1),s.map(h=>t[h])}function rQ(t){if(typeof t=="function")return t;if(t==="lttb")return nQ;const e={first:r=>[r[0]],last:r=>[r[r.length-1]],min:(r,i,a)=>[r[b0(r,o=>a[o])]],max:(r,i,a)=>[r[od(r,o=>a[o])]],median:(r,i,a)=>[r[SK(r,o=>a[o])]]},n=e[t]||e.median;return(r,i,a,o)=>{const s=Math.max(1,Math.floor(r.length/o));return iQ(r,s).flatMap(l=>n(l,i,a))}}function iQ(t,e){const n=t.length,r=[];let i=0;for(;i<n;)r.push(t.slice(i,i+=e));return r}const EI=(t={})=>{const{strategy:e="median",thresholds:n=2e3,groupBy:r=["series","color"]}=t,i=rQ(e);return(a,o)=>{const{encode:s}=o,c=ml(r,a,o),[l]=hn(s,"x"),[u]=hn(s,"y");return[c.flatMap(f=>i(f,l,u,n)),o]}};EI.props={};function aQ(t){return typeof t=="object"?[t.value,t.ordinal]:[t,!0]}function oQ(t){var e;const{encode:n}=t,r=Object.assign(Object.assign({},t),{encode:Object.assign(Object.assign({},t.encode),{y:Object.assign(Object.assign({},t.encode.y),{value:[]})})}),i=(e=n==null?void 0:n.color)===null||e===void 0?void 0:e.field;if(!n||!i)return r;let a;for(const[o,s]of Object.entries(n))(o==="x"||o==="y")&&s.field===i&&(a=Object.assign(Object.assign({},a),{[o]:Object.assign(Object.assign({},s),{value:[]})}));return a?Object.assign(Object.assign({},t),{encode:Object.assign(Object.assign({},t.encode),a)}):r}const MI=(t={})=>(e,n)=>{const{encode:r,data:i}=n,a=Object.entries(t).map(([u,f])=>{const[d]=hn(r,u);if(!d)return null;const[h,v=!0]=aQ(f);if(typeof h=="function")return g=>h(d[g]);if(v){const g=Array.isArray(h)?h:[h];return g.length===0?null:y=>g.includes(d[y])}else{const[g,y]=h;return b=>d[b]>=g&&d[b]<=y}}).filter(qn),o=u=>a.every(f=>f(u)),s=e.filter(o),c=s.map((u,f)=>f);if(a.length===0){const u=oQ(n);return[e,u]}const l=Object.entries(r).map(([u,f])=>[u,Object.assign(Object.assign({},f),{value:c.map(d=>f.value[s[d]]).filter(d=>d!==void 0)})]);return[c,mt({},n,{encode:Object.fromEntries(l),data:s.map(u=>i[u])})]};MI.props={};var kI={},FS={},BS=34,M0=10,zS=13;function AI(t){return new Function("d","return {"+t.map(function(e,n){return JSON.stringify(e)+": d["+n+'] || ""'}).join(",")+"}")}function sQ(t,e){var n=AI(t);return function(r,i){return e(n(r),i,t)}}function TI(t){var e=Object.create(null),n=[];return t.forEach(function(r){for(var i in r)i in e||n.push(e[i]=i)}),n}function La(t,e){var n=t+"",r=n.length;return r<e?new Array(e-r+1).join(0)+n:n}function cQ(t){return t<0?"-"+La(-t,6):t>9999?"+"+La(t,6):La(t,4)}function lQ(t){var e=t.getUTCHours(),n=t.getUTCMinutes(),r=t.getUTCSeconds(),i=t.getUTCMilliseconds();return isNaN(t)?"Invalid Date":cQ(t.getUTCFullYear(),4)+"-"+La(t.getUTCMonth()+1,2)+"-"+La(t.getUTCDate(),2)+(i?"T"+La(e,2)+":"+La(n,2)+":"+La(r,2)+"."+La(i,3)+"Z":r?"T"+La(e,2)+":"+La(n,2)+":"+La(r,2)+"Z":n||e?"T"+La(e,2)+":"+La(n,2)+"Z":"")}function uQ(t){var e=new RegExp('["'+t+`
\r]`),n=t.charCodeAt(0);function r(f,d){var h,v,g=i(f,function(y,b){if(h)return h(y,b-1);v=y,h=d?sQ(y,d):AI(y)});return g.columns=v||[],g}function i(f,d){var h=[],v=f.length,g=0,y=0,b,x=v<=0,_=!1;f.charCodeAt(v-1)===M0&&--v,f.charCodeAt(v-1)===zS&&--v;function w(){if(x)return FS;if(_)return _=!1,kI;var E,M=g,k;if(f.charCodeAt(M)===BS){for(;g++<v&&f.charCodeAt(g)!==BS||f.charCodeAt(++g)===BS;);return(E=g)>=v?x=!0:(k=f.charCodeAt(g++))===M0?_=!0:k===zS&&(_=!0,f.charCodeAt(g)===M0&&++g),f.slice(M+1,E-1).replace(/""/g,'"')}for(;g<v;){if((k=f.charCodeAt(E=g++))===M0)_=!0;else if(k===zS)_=!0,f.charCodeAt(g)===M0&&++g;else if(k!==n)continue;return f.slice(M,E)}return x=!0,f.slice(M,v)}for(;(b=w())!==FS;){for(var O=[];b!==kI&&b!==FS;)O.push(b),b=w();d&&(O=d(O,y++))==null||h.push(O)}return h}function a(f,d){return f.map(function(h){return d.map(function(v){return u(h[v])}).join(t)})}function o(f,d){return d==null&&(d=TI(f)),[d.map(u).join(t)].concat(a(f,d)).join(`
`)}function s(f,d){return d==null&&(d=TI(f)),a(f,d).join(`
`)}function c(f){return f.map(l).join(`
`)}function l(f){return f.map(u).join(t)}function u(f){return f==null?"":f instanceof Date?lQ(f):e.test(f+="")?'"'+f.replace(/"/g,'""')+'"':f}return{parse:r,parseRows:i,format:o,formatBody:s,formatRows:c,formatRow:l,formatValue:u}}function fQ(t){for(var e in t){var n=t[e].trim(),r,i;if(!n)n=null;else if(n==="true")n=!0;else if(n==="false")n=!1;else if(n==="NaN")n=NaN;else if(!isNaN(r=+n))n=r;else if(i=n.match(/^([-+]\d{2})?\d{4}(-\d{2}(-\d{2})?)?(T\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/))dQ&&i[4]&&!i[7]&&(n=n.replace(/-/g,"/").replace(/T/," ")),n=new Date(n);else continue;t[e]=n}return t}const dQ=new Date("2019-01-01T00:00").getHours()||new Date("2019-07-01T00:00").getHours();var hQ=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})};const PI=t=>{const{value:e,format:n=e.split(".").pop(),delimiter:r=",",autoType:i=!0}=t;return()=>hQ(void 0,void 0,void 0,function*(){const a=yield fetch(e);if(n==="csv"){const o=yield a.text();return uQ(r).parse(o,i?fQ:uu)}else if(n==="json")return yield a.json();throw new Error(`Unknown format: ${n}.`)})};PI.props={};const CI=t=>{const{value:e}=t;return()=>e};CI.props={};function pQ(t,e){return t.map(n=>{if(Array.isArray(n)){const[r,i=e]=n;return[r,i]}return[n,e]})}const LI=t=>{const{fields:e=[]}=t,n=pQ(e,!0);return r=>{const i=(a,o)=>n.reduce((s,[c,l=!0])=>s!==0?s:l?a[c]<o[c]?-1:+(a[c]!==o[c]):a[c]>o[c]?-1:+(a[c]!==o[c]),0);return[...r].sort(i)}};LI.props={};function Got(t){return t!=null&&!Number.isNaN(t)}const RI=t=>{const{callback:e}=t;return n=>Array.isArray(n)?[...n].sort(e):n};RI.props={};function vQ(t){return t!=null&&!Number.isNaN(t)}const NI=t=>{const{callback:e=vQ}=t;return n=>n.filter(e)};NI.props={};function gQ(t,e=[]){return e.reduce((n,r)=>(r in t&&(n[r]=t[r]),n),{})}const II=t=>{const{fields:e}=t;return n=>n.map(r=>gQ(r,e))};II.props={};function yQ(t){return Object.keys(t).length===0}const DI=t=>e=>{if(!t||yQ(t))return e;const n=r=>Object.entries(r).reduce((i,[a,o])=>(i[t[a]||a]=o,i),{});return e.map(n)};DI.props={};function mQ(t){return!t||Object.keys(t).length===0}const jI=t=>{const{fields:e,key:n="key",value:r="value"}=t;return i=>mQ(e)?i:i.flatMap(a=>e.map(o=>Object.assign(Object.assign({},a),{[n]:o,[r]:a[o]})))};jI.props={};const FI=t=>{const{start:e,end:n}=t;return r=>r.slice(e,n)};FI.props={};const BI=t=>{const{callback:e=uu}=t;return n=>e(n)};BI.props={};const zI=t=>{const{callback:e=uu}=t;return n=>Array.isArray(n)?n.map(e):n};zI.props={};function WI(t){return typeof t=="string"?e=>e[t]:t}const GI=t=>{const{join:e,on:n,select:r=[],as:i=r,unknown:a=NaN}=t,[o,s]=n,c=WI(s),l=WI(o),u=U_(e,([f])=>f,f=>c(f));return f=>f.map(d=>{const h=u.get(l(d));return Object.assign(Object.assign({},d),r.reduce((v,g,y)=>(v[i[y]]=h?h[g]:a,v),{}))})};GI.props={};var bQ=pt(53843),xQ=pt.n(bQ);function $ot(t){return t!=null&&!Number.isNaN(t)}const $I=t=>{const{field:e,groupBy:n,as:r=["y","size"],min:i,max:a,size:o=10,width:s}=t,[c,l]=r;return u=>Array.from(dr(u,d=>n.map(h=>d[h]).join("-")).values()).map(d=>{const h=xQ().create(d.map(y=>y[e]),{min:i,max:a,size:o,width:s}),v=h.map(y=>y.x),g=h.map(y=>y.y);return Object.assign(Object.assign({},d[0]),{[c]:v,[l]:g})})};$I.props={};const ZI=()=>t=>(console.log("G2 data section:",t),t);ZI.props={};var _Q=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})};function wQ(t,e){return{set(n,r,i){if(e[n]===void 0)return this;const a=r?r.call(null,e[n]):e[n];return i?i.call(null,a):typeof t[n]=="function"?t[n](a):t[n]=a,this},setAsync(n,r,i){return _Q(this,void 0,void 0,function*(){if(e[n]===void 0)return this;const a=r?yield r.call(null,e[n]):e[n];return i?i.call(null,a):typeof t[n]=="function"?t[n](a):t[n]=a,this})}}}const WS=Math.PI/180,k0=64,R1=2048;function OQ(t){return t.text}function SQ(){return"serif"}function YI(){return"normal"}function EQ(t){return t.value}function MQ(){return~~(Math.random()*2)*90}function kQ(){return 1}function AQ(){}function TQ(t,e,n,r){if(e.sprite)return;const i=t.context,a=t.ratio;i.clearRect(0,0,(k0<<5)/a,R1/a);let o=0,s=0,c=0;const l=n.length;for(--r;++r<l;){e=n[r],i.save(),i.font=e.style+" "+e.weight+" "+~~((e.size+1)/a)+"px "+e.font;let d=i.measureText(e.text+"m").width*a,h=e.size<<1;if(e.rotate){const v=Math.sin(e.rotate*WS),g=Math.cos(e.rotate*WS),y=d*g,b=d*v,x=h*g,_=h*v;d=Math.max(Math.abs(y+_),Math.abs(y-_))+31>>5<<5,h=~~Math.max(Math.abs(b+x),Math.abs(b-x))}else d=d+31>>5<<5;if(h>c&&(c=h),o+d>=k0<<5&&(o=0,s+=c,c=0),s+h>=R1)break;i.translate((o+(d>>1))/a,(s+(h>>1))/a),e.rotate&&i.rotate(e.rotate*WS),i.fillText(e.text,0,0),e.padding&&(i.lineWidth=2*e.padding,i.strokeText(e.text,0,0)),i.restore(),e.width=d,e.height=h,e.xoff=o,e.yoff=s,e.x1=d>>1,e.y1=h>>1,e.x0=-e.x1,e.y0=-e.y1,e.hasText=!0,o+=d}const u=i.getImageData(0,0,(k0<<5)/a,R1/a).data,f=[];for(;--r>=0;){if(e=n[r],!e.hasText)continue;const d=e.width,h=d>>5;let v=e.y1-e.y0;for(let b=0;b<v*h;b++)f[b]=0;if(o=e.xoff,o==null)return;s=e.yoff;let g=0,y=-1;for(let b=0;b<v;b++){for(let x=0;x<d;x++){const _=h*b+(x>>5),w=u[(s+b)*(k0<<5)+(o+x)<<2]?1<<31-x%32:0;f[_]|=w,g|=w}g?y=b:(e.y0++,v--,b--,s++)}e.y1=e.y0+y,e.sprite=f.slice(0,(e.y1-e.y0)*h)}}function PQ(t,e,n){n>>=5;const r=t.sprite,i=t.width>>5,a=t.x-(i<<4),o=a&127,s=32-o,c=t.y1-t.y0;let l=(t.y+t.y0)*n+(a>>5),u;for(let f=0;f<c;f++){u=0;for(let d=0;d<=i;d++)if((u<<s|(d<i?(u=r[f*i+d])>>>o:0))&e[l+d])return!0;l+=n}return!1}function CQ(t,e){const n=t[0],r=t[1];e.x+e.x0<n.x&&(n.x=e.x+e.x0),e.y+e.y0<n.y&&(n.y=e.y+e.y0),e.x+e.x1>r.x&&(r.x=e.x+e.x1),e.y+e.y1>r.y&&(r.y=e.y+e.y1)}function LQ(t,e){return t.x+t.x1>e[0].x&&t.x+t.x0<e[1].x&&t.y+t.y1>e[0].y&&t.y+t.y0<e[1].y}function HI(t){const e=t[0]/t[1];return function(n){return[e*(n*=.1)*Math.cos(n),n*Math.sin(n)]}}function RQ(t){const n=4*t[0]/t[1];let r=0,i=0;return function(a){const o=a<0?-1:1;switch(Math.sqrt(1+4*o*a)-o&3){case 0:r+=n;break;case 1:i+=4;break;case 2:r-=n;break;default:i-=4;break}return[r,i]}}function VI(t){const e=[];let n=-1;for(;++n<t;)e[n]=0;return e}function NQ(){return document.createElement("canvas")}function hc(t){return typeof t=="function"?t:function(){return t}}const IQ={archimedean:HI,rectangular:RQ};function DQ(){let t=[256,256],e=OQ,n=SQ,r=EQ,i=YI,a=MQ,o=kQ,s=HI,c=Math.random,l=AQ,u=[],f=null,d=1/0,h=NQ;const v=YI,g={};g.start=function(){const[x,_]=t,w=y(h()),O=g.board?g.board:VI((t[0]>>5)*t[1]),E=u.length,M=[],k=u.map(function(N,L,R){return N.text=e.call(this,N,L,R),N.font=n.call(this,N,L,R),N.style=v.call(this,N,L,R),N.weight=i.call(this,N,L,R),N.rotate=a.call(this,N,L,R),N.size=~~r.call(this,N,L,R),N.padding=o.call(this,N,L,R),N}).sort(function(N,L){return L.size-N.size});let A=-1,P=g.board?[{x:0,y:0},{x,y:_}]:void 0;f&&clearInterval(f),f=setInterval(C,0),C();function C(){const N=Date.now();for(;Date.now()-N<d&&++A<E;){const L=k[A];L.x=x*(c()+.5)>>1,L.y=_*(c()+.5)>>1,TQ(w,L,k,A),L.hasText&&b(O,L,P)&&(l.call(null,"word",{cloud:g,word:L}),M.push(L),P?g.hasImage||CQ(P,L):P=[{x:L.x+L.x0,y:L.y+L.y0},{x:L.x+L.x1,y:L.y+L.y1}],L.x-=t[0]>>1,L.y-=t[1]>>1)}g._tags=M,g._bounds=P,A>=E&&(g.stop(),l.call(null,"end",{cloud:g,words:M,bounds:P}))}return g},g.stop=function(){return f&&(clearInterval(f),f=null),g};function y(x){x.width=x.height=1;const _=Math.sqrt(x.getContext("2d").getImageData(0,0,1,1).data.length>>2);x.width=(k0<<5)/_,x.height=R1/_;const w=x.getContext("2d");return w.fillStyle=w.strokeStyle="red",w.textAlign="center",w.textBaseline="middle",{context:w,ratio:_}}function b(x,_,w){const O=_.x,E=_.y,M=Math.sqrt(t[0]*t[0]+t[1]*t[1]),k=s(t),A=c()<.5?1:-1;let P,C=-A,N,L;for(;(P=k(C+=A))&&(N=~~P[0],L=~~P[1],!(Math.min(Math.abs(N),Math.abs(L))>=M));)if(_.x=O+N,_.y=E+L,!(_.x+_.x0<0||_.y+_.y0<0||_.x+_.x1>t[0]||_.y+_.y1>t[1])&&(!w||!PQ(_,x,t[0]))&&(!w||LQ(_,w))){const R=_.sprite,I=_.width>>5,D=t[0]>>5,G=_.x-(I<<4),F=G&127,W=32-F,X=_.y1-_.y0;let Q,tt=(_.y+_.y0)*D+(G>>5);for(let nt=0;nt<X;nt++){Q=0;for(let ht=0;ht<=I;ht++)x[tt+ht]|=Q<<W|(ht<I?(Q=R[nt*I+ht])>>>F:0);tt+=D}return delete _.sprite,!0}return!1}return g.createMask=x=>{const _=document.createElement("canvas"),[w,O]=t;if(!w||!O)return;const E=w>>5,M=VI((w>>5)*O);_.width=w,_.height=O;const k=_.getContext("2d");k.drawImage(x,0,0,x.width,x.height,0,0,w,O);const A=k.getImageData(0,0,w,O).data;for(let P=0;P<O;P++)for(let C=0;C<w;C++){const N=E*P+(C>>5),L=P*w+C<<2,I=A[L]>=250&&A[L+1]>=250&&A[L+2]>=250?1<<31-C%32:0;M[N]|=I}g.board=M,g.hasImage=!0},g.timeInterval=function(x){d=x==null?1/0:x},g.words=function(x){u=x},g.size=function(x=[]){t=[+x[0],+x[1]]},g.text=function(x){e=hc(x)},g.font=function(x){n=hc(x)},g.fontWeight=function(x){i=hc(x)},g.rotate=function(x){a=hc(x)},g.canvas=function(x){h=hc(x)},g.spiral=function(x){s=IQ[x]||x},g.fontSize=function(x){r=hc(x)},g.padding=function(x){o=hc(x)},g.random=function(x){c=hc(x)},g.on=function(x){l=hc(x)},g}var jQ=function(t,e,n,r){function i(a){return a instanceof n?a:new n(function(o){o(a)})}return new(n||(n=Promise))(function(a,o){function s(u){try{l(r.next(u))}catch(f){o(f)}}function c(u){try{l(r.throw(u))}catch(f){o(f)}}function l(u){u.done?a(u.value):i(u.value).then(s,c)}l((r=r.apply(t,e||[])).next())})},FQ=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const BQ={fontSize:[20,60],font:"Impact",padding:2,rotate:function(){return(~~(Math.random()*6)-3)*30}};function zQ(t){return new Promise((e,n)=>{if(t instanceof HTMLImageElement){e(t);return}if(typeof t=="string"){const r=new Image;r.crossOrigin="anonymous",r.src=t,r.onload=()=>e(r),r.onerror=()=>{console.error(`'image ${t} load failed !!!'`),n()};return}n()})}function WQ(t,e){if(typeof t=="function")return t;if(Array.isArray(t)){const[n,r]=t;if(!e)return()=>(r+n)/2;const[i,a]=e;return a===i?()=>(r+n)/2:({value:o})=>(r-n)/(a-i)*(o-i)+n}return()=>t}const XI=(t,e)=>n=>jQ(void 0,void 0,void 0,function*(){const r=Object.assign({},BQ,t,{canvas:e.createCanvas}),i=DQ();yield wQ(i,r).set("fontSize",x=>{const _=n.map(w=>w.value);return WQ(x,[Za(_),Dn(_)])}).set("font").set("fontStyle").set("fontWeight").set("padding").set("rotate").set("size").set("spiral").set("timeInterval").set("random").set("text").set("on").set("canvas").setAsync("imageMask",zQ,i.createMask),i.words([...n]);const a=i.start(),[o,s]=r.size,c=[{x:0,y:0},{x:o,y:s}],{_bounds:l=c,_tags:u,hasImage:f}=a,d=u.map(x=>{var{x:_,y:w,font:O}=x,E=FQ(x,["x","y","font"]);return Object.assign(Object.assign({},E),{x:_+o/2,y:w+s/2,fontFamily:O})}),[{x:h,y:v},{x:g,y}]=l,b={text:"",value:0,opacity:0,fontSize:0};return d.push(Object.assign(Object.assign({},b),{x:f?0:h,y:f?0:v}),Object.assign(Object.assign({},b),{x:f?o:g,y:f?s:y})),d});XI.props={};function GQ(t,e){if(e<0||e>1)throw new Error("alpha must be between 0 and 1.");if(t.length===0)return[];let n=t[0];const r=[];for(const i of t){if(i==null){r.push(i),console.warn("EMA\uFF1AThe value is null or undefined",t);continue}n==null&&(n=i);const a=n*e+(1-e)*i;r.push(a),n=a}return r}const UI=t=>{const{field:e="y",alpha:n=.6,as:r=e}=t;return i=>{const a=i.map(s=>s[e]),o=GQ(a,n);return i.map((s,c)=>Object.assign(Object.assign({},s),{[r]:o[c]}))}};UI.props={};const qI=.01;function GS(t){const{min:e,max:n}=t;return[[e[0],e[1]],[n[0],n[1]]]}function KI(t,e,n=qI){const[r,i]=t,[a,o]=e;return r>=a[0]-n&&r<=o[0]+n&&i>=a[1]-n&&i<=o[1]+n}function $Q(t,e,n=qI){const[r,i]=t;return!(KI(r,e,n)&&KI(i,e,n))}function ZQ(t,e){const[n,r]=t,[i,a]=e;return n[0]<a[0]&&r[0]>i[0]&&n[1]<a[1]&&r[1]>i[1]}const YQ=t=>{const{priority:e}=t;return n=>{const r=[];return e&&n.sort(e),n.forEach(i=>{Nm(i);const a=i.getLocalBounds();r.some(s=>ZQ(GS(a),GS(s.getLocalBounds())))?Hw(i):r.push(i)}),n}};function HQ([t,e],[n,r]){return r>t&&e>n}function N1(){const t=new Map;return[r=>t.get(r),(r,i)=>t.set(r,i)]}function VQ(t){const e=t.cloneNode(!0),n=e.getElementById("connector");n&&e.removeChild(n);const{min:r,max:i}=e.getRenderBounds();return e.destroy(),{min:r,max:i}}const XQ=t=>{const{maxIterations:e=10,maxError:n=.1,padding:r=1}=t;return i=>{const a=i.length;if(a<=1)return i;const[o,s]=N1(),[c,l]=N1(),[u,f]=N1(),[d,h]=N1();for(const v of i){const{min:g,max:y}=VQ(v),[b,x]=g,[_,w]=y;s(v,x),l(v,x),f(v,w-x),h(v,[b,_])}for(let v=0;v<e;v++){i.sort((y,b)=>kr(c(y),c(b)));let g=0;for(let y=0;y<a-1;y++){const b=i[y];let x=y+1,_;for(;(_=i[x])&&!HQ(d(b),d(_));)x+=1;if(_){const w=c(b),O=u(b),E=c(_),M=E-(w+O);if(M<r){const k=(r-M)/2;g=Math.max(g,k),l(b,w-k),l(_,E+k)}}}if(g<n)break}for(const v of i)v.style.y+=c(v)-o(v);return i}},UQ=()=>t=>(t.forEach(e=>{Nm(e);const n=e.attr("bounds"),r=e.getLocalBounds();$Q(GS(r),n)&&Hw(e)}),t);function qQ(t){return typeof t=="object"?t:os(t)}function $S(t){let e=t/255;return e=e<=.03928?e/12.92:Math.pow((e+.055)/1.055,2.4),e}function QI(t,e,n){return .2126*$S(t)+.7152*$S(e)+.0722*$S(n)}function JI(t,e){if(!t||!e||t===e)return 1;const{r:n,g:r,b:i}=t,{r:a,g:o,b:s}=e,c=QI(n,r,i),l=QI(a,o,s);return(Math.max(c,l)+.05)/(Math.min(c,l)+.05)}function KQ(t,e){const n=od(e,r=>JI(t,qQ(r)));return e[n]}const QQ=t=>{const{threshold:e=4.5,palette:n=["#000","#fff"]}=t;return r=>(r.forEach(i=>{const a=i.attr("dependentElement").parsedStyle.fill,o=i.parsedStyle.fill;JI(o,a)<e&&i.attr("fill",KQ(a,n))}),r)},JQ=(t,e)=>{const[[n,r],[i,a]]=e,[[o,s],[c,l]]=t;let u=0,f=0;return o<n?u=n-o:c>i&&(u=i-c),s<r?f=r-s:l>a&&(f=a-l),[u,f]},tJ=()=>(t,{canvas:e,layout:n})=>(t.forEach(r=>{Nm(r);const{max:i,min:a}=r.getRenderBounds(),[o,s]=i,[c,l]=a,u=JQ([[c,l],[o,s]],[[n.x,n.y],[n.x+n.width,n.y+n.height]]);r.style.connector&&r.style.connectorPoints&&(r.style.connectorPoints[0][0]-=u[0],r.style.connectorPoints[0][1]-=u[1]),r.style.x+=u[0],r.style.y+=u[1]}),t);function eJ(){return{"data.fetch":PI,"data.inline":CI,"data.sortBy":LI,"data.sort":RI,"data.filter":NI,"data.pick":II,"data.rename":DI,"data.fold":jI,"data.slice":FI,"data.custom":BI,"data.map":zI,"data.join":GI,"data.kde":$I,"data.log":ZI,"data.wordCloud":XI,"data.ema":UI,"transform.stackY":J4,"transform.binX":iI,"transform.bin":jS,"transform.dodgeX":aI,"transform.jitter":oI,"transform.jitterX":sI,"transform.jitterY":cI,"transform.symmetryY":lI,"transform.diffY":uI,"transform.stackEnter":fI,"transform.normalizeY":dI,"transform.select":C1,"transform.selectX":pI,"transform.selectY":vI,"transform.groupX":gI,"transform.groupY":yI,"transform.groupColor":mI,"transform.group":E0,"transform.sortX":xI,"transform.sortY":_I,"transform.sortColor":wI,"transform.flexX":OI,"transform.pack":SI,"transform.sample":EI,"transform.filter":MI,"coordinate.cartesian":ZC,"coordinate.polar":Op,"coordinate.transpose":OO,"coordinate.theta":YC,"coordinate.parallel":SO,"coordinate.fisheye":HC,"coordinate.radial":rw,"coordinate.radar":VC,"coordinate.helix":XC,"encode.constant":UC,"encode.field":qC,"encode.transform":KC,"encode.column":QC,"mark.interval":o5,"mark.rect":c5,"mark.line":N5,"mark.point":aL,"mark.text":fL,"mark.cell":hL,"mark.area":_L,"mark.link":GO,"mark.image":IL,"mark.polygon":zL,"mark.box":ZL,"mark.vector":HL,"mark.lineX":qL,"mark.lineY":JL,"mark.connector":rR,"mark.range":oR,"mark.rangeX":lR,"mark.rangeY":dR,"mark.path":yR,"mark.shape":xR,"mark.density":OR,"mark.heatmap":kR,"mark.wordCloud":HO,"palette.category10":AR,"palette.category20":TR,"scale.linear":PR,"scale.ordinal":NR,"scale.band":jR,"scale.identity":FR,"scale.point":BR,"scale.time":sN,"scale.log":lN,"scale.pow":uN,"scale.sqrt":fN,"scale.threshold":dN,"scale.quantile":hN,"scale.quantize":pN,"scale.sequential":vN,"scale.constant":gN,"theme.classic":yN,"theme.classicDark":bN,"theme.academy":xN,"theme.light":nS,"theme.dark":mN,"component.axisX":_N,"component.axisY":wN,"component.legendCategory":iS,"component.legendContinuous":al,"component.legends":SN,"component.title":MN,"component.sliderX":PN,"component.sliderY":CN,"component.scrollbarX":LN,"component.scrollbarY":RN,"animation.scaleInX":cS,"animation.scaleOutX":YX,"animation.scaleInY":NN,"animation.scaleOutY":HX,"animation.waveIn":IN,"animation.fadeIn":DN,"animation.fadeOut":jN,"animation.zoomIn":VX,"animation.zoomOut":XX,"animation.pathIn":FN,"animation.morphing":$N,"animation.growInX":ZN,"animation.growInY":YN,"interaction.elementHighlight":b1,"interaction.elementHighlightByX":HN,"interaction.elementHighlightByColor":VN,"interaction.elementSelect":x1,"interaction.elementSelectByX":XN,"interaction.elementSelectByColor":UN,"interaction.fisheye":uU,"interaction.chartIndex":qN,"interaction.tooltip":f4,"interaction.legendFilter":jU,"interaction.legendHighlight":FU,"interaction.brushHighlight":yS,"interaction.brushXHighlight":ZU,"interaction.brushYHighlight":YU,"interaction.brushAxisHighlight":tq,"interaction.brushFilter":_S,"interaction.brushXFilter":iq,"interaction.brushYFilter":aq,"interaction.sliderFilter":S4,"interaction.scrollbarFilter":uq,"interaction.poptip":k4,"interaction.treemapDrillDown":Cq,"interaction.elementPointMove":jq,"composition.spaceLayer":G4,"composition.spaceFlex":$4,"composition.facetRect":V4,"composition.repeatMatrix":qq,"composition.facetCircle":nK,"composition.timingKeyframe":U4,"labelTransform.overlapHide":YQ,"labelTransform.overlapDodgeY":XQ,"labelTransform.overflowHide":UQ,"labelTransform.contrastReverse":QQ,"labelTransform.exceedAdjust":tJ}}var A0=t=>t;function I1(t,e){t&&eD.hasOwnProperty(t.type)&&eD[t.type](t,e)}var tD={Feature:function(t,e){I1(t.geometry,e)},FeatureCollection:function(t,e){for(var n=t.features,r=-1,i=n.length;++r<i;)I1(n[r].geometry,e)}},eD={Sphere:function(t,e){e.sphere()},Point:function(t,e){t=t.coordinates,e.point(t[0],t[1],t[2])},MultiPoint:function(t,e){for(var n=t.coordinates,r=-1,i=n.length;++r<i;)t=n[r],e.point(t[0],t[1],t[2])},LineString:function(t,e){ZS(t.coordinates,e,0)},MultiLineString:function(t,e){for(var n=t.coordinates,r=-1,i=n.length;++r<i;)ZS(n[r],e,0)},Polygon:function(t,e){nD(t.coordinates,e)},MultiPolygon:function(t,e){for(var n=t.coordinates,r=-1,i=n.length;++r<i;)nD(n[r],e)},GeometryCollection:function(t,e){for(var n=t.geometries,r=-1,i=n.length;++r<i;)I1(n[r],e)}};function ZS(t,e,n){var r=-1,i=t.length-n,a;for(e.lineStart();++r<i;)a=t[r],e.point(a[0],a[1],a[2]);e.lineEnd()}function nD(t,e){var n=-1,r=t.length;for(e.polygonStart();++n<r;)ZS(t[n],e,1);e.polygonEnd()}function Md(t,e){t&&tD.hasOwnProperty(t.type)?tD[t.type](t,e):I1(t,e)}class pc{constructor(){this._partials=new Float64Array(32),this._n=0}add(e){const n=this._partials;let r=0;for(let i=0;i<this._n&&i<32;i++){const a=n[i],o=e+a,s=Math.abs(e)<Math.abs(a)?e-(o-a):a-(o-e);s&&(n[r++]=s),e=o}return n[r]=e,this._n=r+1,this}valueOf(){const e=this._partials;let n=this._n,r,i,a,o=0;if(n>0){for(o=e[--n];n>0&&(r=o,i=e[--n],o=r+i,a=i-(o-r),!a););n>0&&(a<0&&e[n-1]<0||a>0&&e[n-1]>0)&&(i=a*2,r=o+i,i==r-o&&(o=r))}return o}}function Zot(t,e){const n=new pc;if(e===void 0)for(let r of t)(r=+r)&&n.add(r);else{let r=-1;for(let i of t)(i=+e(i,++r,t))&&n.add(i)}return+n}function Yot(t,e){const n=new pc;let r=-1;return Float64Array.from(t,e===void 0?i=>n.add(+i||0):i=>n.add(+e(i,++r,t)||0))}var Re=1e-6,rD=1e-12,cn=Math.PI,jr=cn/2,iD=cn/4,Ha=cn*2,ia=180/cn,Ar=cn/180,Tn=Math.abs,kd=Math.atan,vc=Math.atan2,an=Math.cos,D1=Math.ceil,aD=Math.exp,Hot=Math.floor,Vot=Math.hypot,j1=Math.log,YS=Math.pow,Ze=Math.sin,ko=Math.sign||function(t){return t>0?1:t<0?-1:0},Ra=Math.sqrt,HS=Math.tan;function oD(t){return t>1?0:t<-1?cn:Math.acos(t)}function Ao(t){return t>1?jr:t<-1?-jr:Math.asin(t)}function Xot(t){return(t=Ze(t/2))*t}function To(){}var VS=new pc,XS=new pc,sD,cD,US,qS,xl={point:To,lineStart:To,lineEnd:To,polygonStart:function(){xl.lineStart=nJ,xl.lineEnd=iJ},polygonEnd:function(){xl.lineStart=xl.lineEnd=xl.point=To,VS.add(Tn(XS)),XS=new pc},result:function(){var t=VS/2;return VS=new pc,t}};function nJ(){xl.point=rJ}function rJ(t,e){xl.point=lD,sD=US=t,cD=qS=e}function lD(t,e){XS.add(qS*t-US*e),US=t,qS=e}function iJ(){lD(sD,cD)}var uD=xl,Ad=1/0,F1=Ad,T0=-Ad,B1=T0,aJ={point:oJ,lineStart:To,lineEnd:To,polygonStart:To,polygonEnd:To,result:function(){var t=[[Ad,F1],[T0,B1]];return T0=B1=-(F1=Ad=1/0),t}};function oJ(t,e){t<Ad&&(Ad=t),t>T0&&(T0=t),e<F1&&(F1=e),e>B1&&(B1=e)}var z1=aJ,KS=0,QS=0,P0=0,W1=0,G1=0,Td=0,JS=0,tE=0,C0=0,fD,dD,Ss,Es,Yo={point:ju,lineStart:hD,lineEnd:pD,polygonStart:function(){Yo.lineStart=lJ,Yo.lineEnd=uJ},polygonEnd:function(){Yo.point=ju,Yo.lineStart=hD,Yo.lineEnd=pD},result:function(){var t=C0?[JS/C0,tE/C0]:Td?[W1/Td,G1/Td]:P0?[KS/P0,QS/P0]:[NaN,NaN];return KS=QS=P0=W1=G1=Td=JS=tE=C0=0,t}};function ju(t,e){KS+=t,QS+=e,++P0}function hD(){Yo.point=sJ}function sJ(t,e){Yo.point=cJ,ju(Ss=t,Es=e)}function cJ(t,e){var n=t-Ss,r=e-Es,i=Ra(n*n+r*r);W1+=i*(Ss+t)/2,G1+=i*(Es+e)/2,Td+=i,ju(Ss=t,Es=e)}function pD(){Yo.point=ju}function lJ(){Yo.point=fJ}function uJ(){vD(fD,dD)}function fJ(t,e){Yo.point=vD,ju(fD=Ss=t,dD=Es=e)}function vD(t,e){var n=t-Ss,r=e-Es,i=Ra(n*n+r*r);W1+=i*(Ss+t)/2,G1+=i*(Es+e)/2,Td+=i,i=Es*t-Ss*e,JS+=i*(Ss+t),tE+=i*(Es+e),C0+=i*3,ju(Ss=t,Es=e)}var gD=Yo;function yD(t){this._context=t}yD.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(t,e){switch(this._point){case 0:{this._context.moveTo(t,e),this._point=1;break}case 1:{this._context.lineTo(t,e);break}default:{this._context.moveTo(t+this._radius,e),this._context.arc(t,e,this._radius,0,Ha);break}}},result:To};var eE=new pc,nE,mD,bD,L0,R0,$1={point:To,lineStart:function(){$1.point=dJ},lineEnd:function(){nE&&xD(mD,bD),$1.point=To},polygonStart:function(){nE=!0},polygonEnd:function(){nE=null},result:function(){var t=+eE;return eE=new pc,t}};function dJ(t,e){$1.point=xD,mD=L0=t,bD=R0=e}function xD(t,e){L0-=t,R0-=e,eE.add(Ra(L0*L0+R0*R0)),L0=t,R0=e}var _D=$1;let wD,Z1,OD,SD;class ED{constructor(e){this._append=e==null?MD:hJ(e),this._radius=4.5,this._=""}pointRadius(e){return this._radius=+e,this}polygonStart(){this._line=0}polygonEnd(){this._line=NaN}lineStart(){this._point=0}lineEnd(){this._line===0&&(this._+="Z"),this._point=NaN}point(e,n){switch(this._point){case 0:{this._append`M${e},${n}`,this._point=1;break}case 1:{this._append`L${e},${n}`;break}default:{if(this._append`M${e},${n}`,this._radius!==OD||this._append!==Z1){const r=this._radius,i=this._;this._="",this._append`m0,${r}a${r},${r} 0 1,1 0,${-2*r}a${r},${r} 0 1,1 0,${2*r}z`,OD=r,Z1=this._append,SD=this._,this._=i}this._+=SD;break}}}result(){const e=this._;return this._="",e.length?e:null}}function MD(t){let e=1;this._+=t[0];for(const n=t.length;e<n;++e)this._+=arguments[e]+t[e]}function hJ(t){const e=Math.floor(t);if(!(e>=0))throw new RangeError(`invalid digits: ${t}`);if(e>15)return MD;if(e!==wD){const n=ti(10,e);wD=e,Z1=function(i){let a=1;this._+=i[0];for(const o=i.length;a<o;++a)this._+=Math.round(arguments[a]*n)/n+i[a]}}return Z1}function kD(t,e){let n=3,r=4.5,i,a;function o(s){return s&&(typeof r=="function"&&a.pointRadius(+r.apply(this,arguments)),Md(s,i(a))),a.result()}return o.area=function(s){return Md(s,i(uD)),uD.result()},o.measure=function(s){return Md(s,i(_D)),_D.result()},o.bounds=function(s){return Md(s,i(z1)),z1.result()},o.centroid=function(s){return Md(s,i(gD)),gD.result()},o.projection=function(s){return arguments.length?(i=s==null?(t=null,A0):(t=s).stream,o):t},o.context=function(s){return arguments.length?(a=s==null?(e=null,new ED(n)):new yD(e=s),typeof r!="function"&&a.pointRadius(r),o):e},o.pointRadius=function(s){return arguments.length?(r=typeof s=="function"?s:(a.pointRadius(+s),+s),o):r},o.digits=function(s){if(!arguments.length)return n;if(s==null)n=null;else{const c=Math.floor(s);if(!(c>=0))throw new RangeError(`invalid digits: ${s}`);n=c}return e===null&&(a=new ED(n)),o},o.projection(t).digits(n).context(e)}function Pd(t,e,n){t=+t,e=+e,n=(i=arguments.length)<2?(e=t,t=0,1):i<3?1:+n;for(var r=-1,i=Math.max(0,Math.ceil((e-t)/n))|0,a=new Array(i);++r<i;)a[r]=t+r*n;return a}function AD(t,e,n){var r=Pd(t,e-Re,n).concat(e);return function(i){return r.map(function(a){return[i,a]})}}function TD(t,e,n){var r=Pd(t,e-Re,n).concat(e);return function(i){return r.map(function(a){return[a,i]})}}function pJ(){var t,e,n,r,i,a,o,s,c=10,l=c,u=90,f=360,d,h,v,g,y=2.5;function b(){return{type:"MultiLineString",coordinates:x()}}function x(){return Pd(D1(r/u)*u,n,u).map(v).concat(Pd(D1(s/f)*f,o,f).map(g)).concat(Pd(D1(e/c)*c,t,c).filter(function(_){return Tn(_%u)>Re}).map(d)).concat(Pd(D1(a/l)*l,i,l).filter(function(_){return Tn(_%f)>Re}).map(h))}return b.lines=function(){return x().map(function(_){return{type:"LineString",coordinates:_}})},b.outline=function(){return{type:"Polygon",coordinates:[v(r).concat(g(o).slice(1),v(n).reverse().slice(1),g(s).reverse().slice(1))]}},b.extent=function(_){return arguments.length?b.extentMajor(_).extentMinor(_):b.extentMinor()},b.extentMajor=function(_){return arguments.length?(r=+_[0][0],n=+_[1][0],s=+_[0][1],o=+_[1][1],r>n&&(_=r,r=n,n=_),s>o&&(_=s,s=o,o=_),b.precision(y)):[[r,s],[n,o]]},b.extentMinor=function(_){return arguments.length?(e=+_[0][0],t=+_[1][0],a=+_[0][1],i=+_[1][1],e>t&&(_=e,e=t,t=_),a>i&&(_=a,a=i,i=_),b.precision(y)):[[e,a],[t,i]]},b.step=function(_){return arguments.length?b.stepMajor(_).stepMinor(_):b.stepMinor()},b.stepMajor=function(_){return arguments.length?(u=+_[0],f=+_[1],b):[u,f]},b.stepMinor=function(_){return arguments.length?(c=+_[0],l=+_[1],b):[c,l]},b.precision=function(_){return arguments.length?(y=+_,d=AD(a,i,90),h=TD(e,t,y),v=AD(s,o,90),g=TD(r,n,y),b):y},b.extentMajor([[-180,-90+Re],[180,90-Re]]).extentMinor([[-180,-80-Re],[180,80+Re]])}function vJ(){return pJ()()}function PD(){var t=[],e;return{point:function(n,r,i){e.push([n,r,i])},lineStart:function(){t.push(e=[])},lineEnd:To,rejoin:function(){t.length>1&&t.push(t.pop().concat(t.shift()))},result:function(){var n=t;return t=[],e=null,n}}}function Y1(t,e){return Tn(t[0]-e[0])<Re&&Tn(t[1]-e[1])<Re}function H1(t,e,n,r){this.x=t,this.z=e,this.o=n,this.e=r,this.v=!1,this.n=this.p=null}function CD(t,e,n,r,i){var a=[],o=[],s,c;if(t.forEach(function(v){if(!((g=v.length-1)<=0)){var g,y=v[0],b=v[g],x;if(Y1(y,b)){if(!y[2]&&!b[2]){for(i.lineStart(),s=0;s<g;++s)i.point((y=v[s])[0],y[1]);i.lineEnd();return}b[0]+=2*Re}a.push(x=new H1(y,v,null,!0)),o.push(x.o=new H1(y,null,x,!1)),a.push(x=new H1(b,v,null,!1)),o.push(x.o=new H1(b,null,x,!0))}}),!!a.length){for(o.sort(e),LD(a),LD(o),s=0,c=o.length;s<c;++s)o[s].e=n=!n;for(var l=a[0],u,f;;){for(var d=l,h=!0;d.v;)if((d=d.n)===l)return;u=d.z,i.lineStart();do{if(d.v=d.o.v=!0,d.e){if(h)for(s=0,c=u.length;s<c;++s)i.point((f=u[s])[0],f[1]);else r(d.x,d.n.x,1,i);d=d.n}else{if(h)for(u=d.p.z,s=u.length-1;s>=0;--s)i.point((f=u[s])[0],f[1]);else r(d.x,d.p.x,-1,i);d=d.p}d=d.o,u=d.z,h=!h}while(!d.v);i.lineEnd()}}}function LD(t){if(e=t.length){for(var e,n=0,r=t[0],i;++n<e;)r.n=i=t[n],i.p=r,r=i;r.n=i=t[0],i.p=r}}function rE(t){return[vc(t[1],t[0]),Ao(t[2])]}function Cd(t){var e=t[0],n=t[1],r=an(n);return[r*an(e),r*Ze(e),Ze(n)]}function V1(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]}function X1(t,e){return[t[1]*e[2]-t[2]*e[1],t[2]*e[0]-t[0]*e[2],t[0]*e[1]-t[1]*e[0]]}function iE(t,e){t[0]+=e[0],t[1]+=e[1],t[2]+=e[2]}function U1(t,e){return[t[0]*e,t[1]*e,t[2]*e]}function aE(t){var e=Ra(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=e,t[1]/=e,t[2]/=e}function oE(t){return Tn(t[0])<=cn?t[0]:ko(t[0])*((Tn(t[0])+cn)%Ha-cn)}function gJ(t,e){var n=oE(e),r=e[1],i=Ze(r),a=[Ze(n),-an(n),0],o=0,s=0,c=new pc;i===1?r=jr+Re:i===-1&&(r=-jr-Re);for(var l=0,u=t.length;l<u;++l)if(d=(f=t[l]).length)for(var f,d,h=f[d-1],v=oE(h),g=h[1]/2+iD,y=Ze(g),b=an(g),x=0;x<d;++x,v=w,y=E,b=M,h=_){var _=f[x],w=oE(_),O=_[1]/2+iD,E=Ze(O),M=an(O),k=w-v,A=k>=0?1:-1,P=A*k,C=P>cn,N=y*E;if(c.add(vc(N*A*Ze(P),b*M+N*an(P))),o+=C?k+A*Ha:k,C^v>=n^w>=n){var L=X1(Cd(h),Cd(_));aE(L);var R=X1(a,L);aE(R);var I=(C^k>=0?-1:1)*Ao(R[2]);(r>I||r===I&&(L[0]||L[1]))&&(s+=C^k>=0?1:-1)}}return(o<-Re||o<Re&&c<-rD)^s&1}function*yJ(t){for(const e of t)yield*p8(e)}function RD(t){return Array.from(yJ(t))}function ND(t,e,n,r){return function(i){var a=e(i),o=PD(),s=e(o),c=!1,l,u,f,d={point:h,lineStart:g,lineEnd:y,polygonStart:function(){d.point=b,d.lineStart=x,d.lineEnd=_,u=[],l=[]},polygonEnd:function(){d.point=h,d.lineStart=g,d.lineEnd=y,u=RD(u);var w=gJ(l,r);u.length?(c||(i.polygonStart(),c=!0),CD(u,bJ,w,n,i)):w&&(c||(i.polygonStart(),c=!0),i.lineStart(),n(null,null,1,i),i.lineEnd()),c&&(i.polygonEnd(),c=!1),u=l=null},sphere:function(){i.polygonStart(),i.lineStart(),n(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function h(w,O){t(w,O)&&i.point(w,O)}function v(w,O){a.point(w,O)}function g(){d.point=v,a.lineStart()}function y(){d.point=h,a.lineEnd()}function b(w,O){f.push([w,O]),s.point(w,O)}function x(){s.lineStart(),f=[]}function _(){b(f[0][0],f[0][1]),s.lineEnd();var w=s.clean(),O=o.result(),E,M=O.length,k,A,P;if(f.pop(),l.push(f),f=null,!!M){if(w&1){if(A=O[0],(k=A.length-1)>0){for(c||(i.polygonStart(),c=!0),i.lineStart(),E=0;E<k;++E)i.point((P=A[E])[0],P[1]);i.lineEnd()}return}M>1&&w&2&&O.push(O.pop().concat(O.shift())),u.push(O.filter(mJ))}}return d}}function mJ(t){return t.length>1}function bJ(t,e){return((t=t.x)[0]<0?t[1]-jr-Re:jr-t[1])-((e=e.x)[0]<0?e[1]-jr-Re:jr-e[1])}var ID=ND(function(){return!0},xJ,wJ,[-cn,-jr]);function xJ(t){var e=NaN,n=NaN,r=NaN,i;return{lineStart:function(){t.lineStart(),i=1},point:function(a,o){var s=a>0?cn:-cn,c=Tn(a-e);Tn(c-cn)<Re?(t.point(e,n=(n+o)/2>0?jr:-jr),t.point(r,n),t.lineEnd(),t.lineStart(),t.point(s,n),t.point(a,n),i=0):r!==s&&c>=cn&&(Tn(e-r)<Re&&(e-=r*Re),Tn(a-s)<Re&&(a-=s*Re),n=_J(e,n,a,o),t.point(r,n),t.lineEnd(),t.lineStart(),t.point(s,n),i=0),t.point(e=a,n=o),r=s},lineEnd:function(){t.lineEnd(),e=n=NaN},clean:function(){return 2-i}}}function _J(t,e,n,r){var i,a,o=Ze(t-n);return Tn(o)>Re?kd((Ze(e)*(a=an(r))*Ze(n)-Ze(r)*(i=an(e))*Ze(t))/(i*a*o)):(e+r)/2}function wJ(t,e,n,r){var i;if(t==null)i=n*jr,r.point(-cn,i),r.point(0,i),r.point(cn,i),r.point(cn,0),r.point(cn,-i),r.point(0,-i),r.point(-cn,-i),r.point(-cn,0),r.point(-cn,i);else if(Tn(t[0]-e[0])>Re){var a=t[0]<e[0]?cn:-cn;i=n*a/2,r.point(-a,i),r.point(0,i),r.point(a,i)}else r.point(e[0],e[1])}function DD(t,e,n,r,i,a){if(n){var o=an(e),s=Ze(e),c=r*n;i==null?(i=e+r*Ha,a=e-c/2):(i=jD(o,i),a=jD(o,a),(r>0?i<a:i>a)&&(i+=r*Ha));for(var l,u=i;r>0?u>a:u<a;u-=c)l=rE([o,-s*an(u),-s*Ze(u)]),t.point(l[0],l[1])}}function jD(t,e){e=Cd(e),e[0]-=t,aE(e);var n=oD(-e[1]);return((-e[2]<0?-n:n)+Ha-Re)%Ha}function Uot(){var t=constant([0,0]),e=constant(90),n=constant(2),r,i,a={point:o};function o(c,l){r.push(c=i(c,l)),c[0]*=degrees,c[1]*=degrees}function s(){var c=t.apply(this,arguments),l=e.apply(this,arguments)*radians,u=n.apply(this,arguments)*radians;return r=[],i=rotateRadians(-c[0]*radians,-c[1]*radians,0).invert,DD(a,l,u,1),c={type:"Polygon",coordinates:[r]},r=i=null,c}return s.center=function(c){return arguments.length?(t=typeof c=="function"?c:constant([+c[0],+c[1]]),s):t},s.radius=function(c){return arguments.length?(e=typeof c=="function"?c:constant(+c),s):e},s.precision=function(c){return arguments.length?(n=typeof c=="function"?c:constant(+c),s):n},s}function OJ(t){var e=an(t),n=2*Ar,r=e>0,i=Tn(e)>Re;function a(u,f,d,h){DD(h,t,n,d,u,f)}function o(u,f){return an(u)*an(f)>e}function s(u){var f,d,h,v,g;return{lineStart:function(){v=h=!1,g=1},point:function(y,b){var x=[y,b],_,w=o(y,b),O=r?w?0:l(y,b):w?l(y+(y<0?cn:-cn),b):0;if(!f&&(v=h=w)&&u.lineStart(),w!==h&&(_=c(f,x),(!_||Y1(f,_)||Y1(x,_))&&(x[2]=1)),w!==h)g=0,w?(u.lineStart(),_=c(x,f),u.point(_[0],_[1])):(_=c(f,x),u.point(_[0],_[1],2),u.lineEnd()),f=_;else if(i&&f&&r^w){var E;!(O&d)&&(E=c(x,f,!0))&&(g=0,r?(u.lineStart(),u.point(E[0][0],E[0][1]),u.point(E[1][0],E[1][1]),u.lineEnd()):(u.point(E[1][0],E[1][1]),u.lineEnd(),u.lineStart(),u.point(E[0][0],E[0][1],3)))}w&&(!f||!Y1(f,x))&&u.point(x[0],x[1]),f=x,h=w,d=O},lineEnd:function(){h&&u.lineEnd(),f=null},clean:function(){return g|(v&&h)<<1}}}function c(u,f,d){var h=Cd(u),v=Cd(f),g=[1,0,0],y=X1(h,v),b=V1(y,y),x=y[0],_=b-x*x;if(!_)return!d&&u;var w=e*b/_,O=-e*x/_,E=X1(g,y),M=U1(g,w),k=U1(y,O);iE(M,k);var A=E,P=V1(M,A),C=V1(A,A),N=P*P-C*(V1(M,M)-1);if(!(N<0)){var L=Ra(N),R=U1(A,(-P-L)/C);if(iE(R,M),R=rE(R),!d)return R;var I=u[0],D=f[0],G=u[1],F=f[1],W;D<I&&(W=I,I=D,D=W);var X=D-I,Q=Tn(X-cn)<Re,tt=Q||X<Re;if(!Q&&F<G&&(W=G,G=F,F=W),tt?Q?G+F>0^R[1]<(Tn(R[0]-I)<Re?G:F):G<=R[1]&&R[1]<=F:X>cn^(I<=R[0]&&R[0]<=D)){var nt=U1(A,(-P+L)/C);return iE(nt,M),[R,rE(nt)]}}}function l(u,f){var d=r?t:cn-t,h=0;return u<-d?h|=1:u>d&&(h|=2),f<-d?h|=4:f>d&&(h|=8),h}return ND(o,s,a,r?[0,-t]:[-cn,t-cn])}function SJ(t,e,n,r,i,a){var o=t[0],s=t[1],c=e[0],l=e[1],u=0,f=1,d=c-o,h=l-s,v;if(v=n-o,!(!d&&v>0)){if(v/=d,d<0){if(v<u)return;v<f&&(f=v)}else if(d>0){if(v>f)return;v>u&&(u=v)}if(v=i-o,!(!d&&v<0)){if(v/=d,d<0){if(v>f)return;v>u&&(u=v)}else if(d>0){if(v<u)return;v<f&&(f=v)}if(v=r-s,!(!h&&v>0)){if(v/=h,h<0){if(v<u)return;v<f&&(f=v)}else if(h>0){if(v>f)return;v>u&&(u=v)}if(v=a-s,!(!h&&v<0)){if(v/=h,h<0){if(v>f)return;v>u&&(u=v)}else if(h>0){if(v<u)return;v<f&&(f=v)}return u>0&&(t[0]=o+u*d,t[1]=s+u*h),f<1&&(e[0]=o+f*d,e[1]=s+f*h),!0}}}}}var N0=1e9,q1=-N0;function FD(t,e,n,r){function i(l,u){return t<=l&&l<=n&&e<=u&&u<=r}function a(l,u,f,d){var h=0,v=0;if(l==null||(h=o(l,f))!==(v=o(u,f))||c(l,u)<0^f>0)do d.point(h===0||h===3?t:n,h>1?r:e);while((h=(h+f+4)%4)!==v);else d.point(u[0],u[1])}function o(l,u){return Tn(l[0]-t)<Re?u>0?0:3:Tn(l[0]-n)<Re?u>0?2:1:Tn(l[1]-e)<Re?u>0?1:0:u>0?3:2}function s(l,u){return c(l.x,u.x)}function c(l,u){var f=o(l,1),d=o(u,1);return f!==d?f-d:f===0?u[1]-l[1]:f===1?l[0]-u[0]:f===2?l[1]-u[1]:u[0]-l[0]}return function(l){var u=l,f=PD(),d,h,v,g,y,b,x,_,w,O,E,M={point:k,lineStart:N,lineEnd:L,polygonStart:P,polygonEnd:C};function k(I,D){i(I,D)&&u.point(I,D)}function A(){for(var I=0,D=0,G=h.length;D<G;++D)for(var F=h[D],W=1,X=F.length,Q=F[0],tt,nt,ht=Q[0],lt=Q[1];W<X;++W)tt=ht,nt=lt,Q=F[W],ht=Q[0],lt=Q[1],nt<=r?lt>r&&(ht-tt)*(r-nt)>(lt-nt)*(t-tt)&&++I:lt<=r&&(ht-tt)*(r-nt)<(lt-nt)*(t-tt)&&--I;return I}function P(){u=f,d=[],h=[],E=!0}function C(){var I=A(),D=E&&I,G=(d=RD(d)).length;(D||G)&&(l.polygonStart(),D&&(l.lineStart(),a(null,null,1,l),l.lineEnd()),G&&CD(d,s,I,a,l),l.polygonEnd()),u=l,d=h=v=null}function N(){M.point=R,h&&h.push(v=[]),O=!0,w=!1,x=_=NaN}function L(){d&&(R(g,y),b&&w&&f.rejoin(),d.push(f.result())),M.point=k,w&&u.lineEnd()}function R(I,D){var G=i(I,D);if(h&&v.push([I,D]),O)g=I,y=D,b=G,O=!1,G&&(u.lineStart(),u.point(I,D));else if(G&&w)u.point(I,D);else{var F=[x=Math.max(q1,Math.min(N0,x)),_=Math.max(q1,Math.min(N0,_))],W=[I=Math.max(q1,Math.min(N0,I)),D=Math.max(q1,Math.min(N0,D))];SJ(F,W,t,e,n,r)?(w||(u.lineStart(),u.point(F[0],F[1])),u.point(W[0],W[1]),G||u.lineEnd(),E=!1):G&&(u.lineStart(),u.point(I,D),E=!1)}x=I,_=D,w=G}return M}}function sE(t,e){function n(r,i){return r=t(r,i),e(r[0],r[1])}return t.invert&&e.invert&&(n.invert=function(r,i){return r=e.invert(r,i),r&&t.invert(r[0],r[1])}),n}function cE(t,e){return Tn(t)>cn&&(t-=Math.round(t/Ha)*Ha),[t,e]}cE.invert=cE;function BD(t,e,n){return(t%=Ha)?e||n?sE(WD(t),GD(e,n)):WD(t):e||n?GD(e,n):cE}function zD(t){return function(e,n){return e+=t,Tn(e)>cn&&(e-=Math.round(e/Ha)*Ha),[e,n]}}function WD(t){var e=zD(t);return e.invert=zD(-t),e}function GD(t,e){var n=an(t),r=Ze(t),i=an(e),a=Ze(e);function o(s,c){var l=an(c),u=an(s)*l,f=Ze(s)*l,d=Ze(c),h=d*n+u*r;return[vc(f*i-h*a,u*n-d*r),Ao(h*i+f*a)]}return o.invert=function(s,c){var l=an(c),u=an(s)*l,f=Ze(s)*l,d=Ze(c),h=d*i-f*a;return[vc(f*i+d*a,u*n+h*r),Ao(h*n-u*r)]},o}function EJ(t){t=BD(t[0]*Ar,t[1]*Ar,t.length>2?t[2]*Ar:0);function e(n){return n=t(n[0]*Ar,n[1]*Ar),n[0]*=ia,n[1]*=ia,n}return e.invert=function(n){return n=t.invert(n[0]*Ar,n[1]*Ar),n[0]*=ia,n[1]*=ia,n},e}function qot(t){return{stream:I0(t)}}function I0(t){return function(e){var n=new lE;for(var r in t)n[r]=t[r];return n.stream=e,n}}function lE(){}lE.prototype={constructor:lE,point:function(t,e){this.stream.point(t,e)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};function uE(t,e,n){var r=t.clipExtent&&t.clipExtent();return t.scale(150).translate([0,0]),r!=null&&t.clipExtent(null),Md(n,t.stream(z1)),e(z1.result()),r!=null&&t.clipExtent(r),t}function K1(t,e,n){return uE(t,function(r){var i=e[1][0]-e[0][0],a=e[1][1]-e[0][1],o=Math.min(i/(r[1][0]-r[0][0]),a/(r[1][1]-r[0][1])),s=+e[0][0]+(i-o*(r[1][0]+r[0][0]))/2,c=+e[0][1]+(a-o*(r[1][1]+r[0][1]))/2;t.scale(150*o).translate([s,c])},n)}function fE(t,e,n){return K1(t,[[0,0],e],n)}function dE(t,e,n){return uE(t,function(r){var i=+e,a=i/(r[1][0]-r[0][0]),o=(i-a*(r[1][0]+r[0][0]))/2,s=-a*r[0][1];t.scale(150*a).translate([o,s])},n)}function hE(t,e,n){return uE(t,function(r){var i=+e,a=i/(r[1][1]-r[0][1]),o=-a*r[0][0],s=(i-a*(r[1][1]+r[0][1]))/2;t.scale(150*a).translate([o,s])},n)}var $D=16,MJ=an(30*Ar);function ZD(t,e){return+e?AJ(t,e):kJ(t)}function kJ(t){return I0({point:function(e,n){e=t(e,n),this.stream.point(e[0],e[1])}})}function AJ(t,e){function n(r,i,a,o,s,c,l,u,f,d,h,v,g,y){var b=l-r,x=u-i,_=b*b+x*x;if(_>4*e&&g--){var w=o+d,O=s+h,E=c+v,M=Ra(w*w+O*O+E*E),k=Ao(E/=M),A=Tn(Tn(E)-1)<Re||Tn(a-f)<Re?(a+f)/2:vc(O,w),P=t(A,k),C=P[0],N=P[1],L=C-r,R=N-i,I=x*L-b*R;(I*I/_>e||Tn((b*L+x*R)/_-.5)>.3||o*d+s*h+c*v<MJ)&&(n(r,i,a,o,s,c,C,N,A,w/=M,O/=M,E,g,y),y.point(C,N),n(C,N,A,w,O,E,l,u,f,d,h,v,g,y))}}return function(r){var i,a,o,s,c,l,u,f,d,h,v,g,y={point:b,lineStart:x,lineEnd:w,polygonStart:function(){r.polygonStart(),y.lineStart=O},polygonEnd:function(){r.polygonEnd(),y.lineStart=x}};function b(k,A){k=t(k,A),r.point(k[0],k[1])}function x(){f=NaN,y.point=_,r.lineStart()}function _(k,A){var P=Cd([k,A]),C=t(k,A);n(f,d,u,h,v,g,f=C[0],d=C[1],u=k,h=P[0],v=P[1],g=P[2],$D,r),r.point(f,d)}function w(){y.point=b,r.lineEnd()}function O(){x(),y.point=E,y.lineEnd=M}function E(k,A){_(i=k,A),a=f,o=d,s=h,c=v,l=g,y.point=_}function M(){n(f,d,u,h,v,g,a,o,i,s,c,l,$D,r),y.lineEnd=w,w()}return y}}var TJ=I0({point:function(t,e){this.stream.point(t*Ar,e*Ar)}});function PJ(t){return I0({point:function(e,n){var r=t(e,n);return this.stream.point(r[0],r[1])}})}function CJ(t,e,n,r,i){function a(o,s){return o*=r,s*=i,[e+t*o,n-t*s]}return a.invert=function(o,s){return[(o-e)/t*r,(n-s)/t*i]},a}function YD(t,e,n,r,i,a){if(!a)return CJ(t,e,n,r,i);var o=an(a),s=Ze(a),c=o*t,l=s*t,u=o/t,f=s/t,d=(s*n-o*e)/t,h=(s*e+o*n)/t;function v(g,y){return g*=r,y*=i,[c*g-l*y+e,n-l*g-c*y]}return v.invert=function(g,y){return[r*(u*g-f*y+d),i*(h-f*g-u*y)]},v}function Ms(t){return pE(function(){return t})()}function pE(t){var e,n=150,r=480,i=250,a=0,o=0,s=0,c=0,l=0,u,f=0,d=1,h=1,v=null,g=ID,y=null,b,x,_,w=A0,O=.5,E,M,k,A,P;function C(I){return k(I[0]*Ar,I[1]*Ar)}function N(I){return I=k.invert(I[0],I[1]),I&&[I[0]*ia,I[1]*ia]}C.stream=function(I){return A&&P===I?A:A=TJ(PJ(u)(g(E(w(P=I)))))},C.preclip=function(I){return arguments.length?(g=I,v=void 0,R()):g},C.postclip=function(I){return arguments.length?(w=I,y=b=x=_=null,R()):w},C.clipAngle=function(I){return arguments.length?(g=+I?OJ(v=I*Ar):(v=null,ID),R()):v*ia},C.clipExtent=function(I){return arguments.length?(w=I==null?(y=b=x=_=null,A0):FD(y=+I[0][0],b=+I[0][1],x=+I[1][0],_=+I[1][1]),R()):y==null?null:[[y,b],[x,_]]},C.scale=function(I){return arguments.length?(n=+I,L()):n},C.translate=function(I){return arguments.length?(r=+I[0],i=+I[1],L()):[r,i]},C.center=function(I){return arguments.length?(a=I[0]%360*Ar,o=I[1]%360*Ar,L()):[a*ia,o*ia]},C.rotate=function(I){return arguments.length?(s=I[0]%360*Ar,c=I[1]%360*Ar,l=I.length>2?I[2]%360*Ar:0,L()):[s*ia,c*ia,l*ia]},C.angle=function(I){return arguments.length?(f=I%360*Ar,L()):f*ia},C.reflectX=function(I){return arguments.length?(d=I?-1:1,L()):d<0},C.reflectY=function(I){return arguments.length?(h=I?-1:1,L()):h<0},C.precision=function(I){return arguments.length?(E=ZD(M,O=I*I),R()):Ra(O)},C.fitExtent=function(I,D){return K1(C,I,D)},C.fitSize=function(I,D){return fE(C,I,D)},C.fitWidth=function(I,D){return dE(C,I,D)},C.fitHeight=function(I,D){return hE(C,I,D)};function L(){var I=YD(n,0,0,d,h,f).apply(null,e(a,o)),D=YD(n,r-I[0],i-I[1],d,h,f);return u=BD(s,c,l),M=sE(e,D),k=sE(u,M),E=ZD(M,O),R()}function R(){return A=P=null,C}return function(){return e=t.apply(this,arguments),C.invert=e.invert&&N,L()}}function vE(t){var e=0,n=cn/3,r=pE(t),i=r(e,n);return i.parallels=function(a){return arguments.length?r(e=a[0]*Ar,n=a[1]*Ar):[e*ia,n*ia]},i}function LJ(t){var e=an(t);function n(r,i){return[r*e,Ze(i)/e]}return n.invert=function(r,i){return[r/e,Ao(i*e)]},n}function HD(t,e){var n=Ze(t),r=(n+Ze(e))/2;if(Tn(r)<Re)return LJ(t);var i=1+n*(2*r-n),a=Ra(i)/r;function o(s,c){var l=Ra(i-2*r*Ze(c))/r;return[l*Ze(s*=r),a-l*an(s)]}return o.invert=function(s,c){var l=a-c,u=vc(s,Tn(l))*ko(l);return l*r<0&&(u-=cn*ko(s)*ko(l)),[u/r,Ao((i-(s*s+l*l)*r*r)/(2*r))]},o}function Q1(){return vE(HD).scale(155.424).center([0,33.6442])}function VD(){return Q1().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function RJ(t){var e=t.length;return{point:function(n,r){for(var i=-1;++i<e;)t[i].point(n,r)},sphere:function(){for(var n=-1;++n<e;)t[n].sphere()},lineStart:function(){for(var n=-1;++n<e;)t[n].lineStart()},lineEnd:function(){for(var n=-1;++n<e;)t[n].lineEnd()},polygonStart:function(){for(var n=-1;++n<e;)t[n].polygonStart()},polygonEnd:function(){for(var n=-1;++n<e;)t[n].polygonEnd()}}}function NJ(){var t,e,n=VD(),r,i=Q1().rotate([154,0]).center([-2,58.5]).parallels([55,65]),a,o=Q1().rotate([157,0]).center([-3,19.9]).parallels([8,18]),s,c,l={point:function(d,h){c=[d,h]}};function u(d){var h=d[0],v=d[1];return c=null,r.point(h,v),c||(a.point(h,v),c)||(s.point(h,v),c)}u.invert=function(d){var h=n.scale(),v=n.translate(),g=(d[0]-v[0])/h,y=(d[1]-v[1])/h;return(y>=.12&&y<.234&&g>=-.425&&g<-.214?i:y>=.166&&y<.234&&g>=-.214&&g<-.115?o:n).invert(d)},u.stream=function(d){return t&&e===d?t:t=RJ([n.stream(e=d),i.stream(d),o.stream(d)])},u.precision=function(d){return arguments.length?(n.precision(d),i.precision(d),o.precision(d),f()):n.precision()},u.scale=function(d){return arguments.length?(n.scale(d),i.scale(d*.35),o.scale(d),u.translate(n.translate())):n.scale()},u.translate=function(d){if(!arguments.length)return n.translate();var h=n.scale(),v=+d[0],g=+d[1];return r=n.translate(d).clipExtent([[v-.455*h,g-.238*h],[v+.455*h,g+.238*h]]).stream(l),a=i.translate([v-.307*h,g+.201*h]).clipExtent([[v-.425*h+Re,g+.12*h+Re],[v-.214*h-Re,g+.234*h-Re]]).stream(l),s=o.translate([v-.205*h,g+.212*h]).clipExtent([[v-.214*h+Re,g+.166*h+Re],[v-.115*h-Re,g+.234*h-Re]]).stream(l),f()},u.fitExtent=function(d,h){return K1(u,d,h)},u.fitSize=function(d,h){return fE(u,d,h)},u.fitWidth=function(d,h){return dE(u,d,h)},u.fitHeight=function(d,h){return hE(u,d,h)};function f(){return t=e=null,u}return u.scale(1070)}function XD(t){return function(e,n){var r=an(e),i=an(n),a=t(r*i);return a===1/0?[2,0]:[a*i*Ze(e),a*Ze(n)]}}function D0(t){return function(e,n){var r=Ra(e*e+n*n),i=t(r),a=Ze(i),o=an(i);return[vc(e*a,r*o),Ao(r&&n*a/r)]}}var gE=XD(function(t){return Ra(2/(1+t))});gE.invert=D0(function(t){return 2*Ao(t/2)});function IJ(){return Ms(gE).scale(124.75).clipAngle(180-.001)}var yE=XD(function(t){return(t=oD(t))&&t/Ze(t)});yE.invert=D0(function(t){return t});function DJ(){return Ms(yE).scale(79.4188).clipAngle(180-.001)}function j0(t,e){return[t,j1(HS((jr+e)/2))]}j0.invert=function(t,e){return[t,2*kd(aD(e))-jr]};function jJ(){return UD(j0).scale(961/Ha)}function UD(t){var e=Ms(t),n=e.center,r=e.scale,i=e.translate,a=e.clipExtent,o=null,s,c,l;e.scale=function(f){return arguments.length?(r(f),u()):r()},e.translate=function(f){return arguments.length?(i(f),u()):i()},e.center=function(f){return arguments.length?(n(f),u()):n()},e.clipExtent=function(f){return arguments.length?(f==null?o=s=c=l=null:(o=+f[0][0],s=+f[0][1],c=+f[1][0],l=+f[1][1]),u()):o==null?null:[[o,s],[c,l]]};function u(){var f=cn*r(),d=e(EJ(e.rotate()).invert([0,0]));return a(o==null?[[d[0]-f,d[1]-f],[d[0]+f,d[1]+f]]:t===j0?[[Math.max(d[0]-f,o),s],[Math.min(d[0]+f,c),l]]:[[o,Math.max(d[1]-f,s)],[c,Math.min(d[1]+f,l)]])}return u()}function J1(t){return HS((jr+t)/2)}function qD(t,e){var n=an(t),r=t===e?Ze(t):j1(n/an(e))/j1(J1(e)/J1(t)),i=n*YS(J1(t),r)/r;if(!r)return j0;function a(o,s){i>0?s<-jr+Re&&(s=-jr+Re):s>jr-Re&&(s=jr-Re);var c=i/YS(J1(s),r);return[c*Ze(r*o),i-c*an(r*o)]}return a.invert=function(o,s){var c=i-s,l=ko(r)*Ra(o*o+c*c),u=vc(o,Tn(c))*ko(c);return c*r<0&&(u-=cn*ko(o)*ko(c)),[u/r,2*kd(YS(i/l,1/r))-jr]},a}function FJ(){return vE(qD).scale(109.5).parallels([30,30])}function F0(t,e){return[t,e]}F0.invert=F0;function BJ(){return Ms(F0).scale(152.63)}function KD(t,e){var n=an(t),r=t===e?Ze(t):(n-an(e))/(e-t),i=n/r+t;if(Tn(r)<Re)return F0;function a(o,s){var c=i-s,l=r*o;return[c*Ze(l),i-c*an(l)]}return a.invert=function(o,s){var c=i-s,l=vc(o,Tn(c))*ko(c);return c*r<0&&(l-=cn*ko(o)*ko(c)),[l/r,i-ko(r)*Ra(o*o+c*c)]},a}function zJ(){return vE(KD).scale(131.154).center([0,13.9389])}var B0=1.340264,z0=-.081106,W0=893e-6,G0=.003796,tb=Ra(3)/2,WJ=12;function mE(t,e){var n=Ao(tb*Ze(e)),r=n*n,i=r*r*r;return[t*an(n)/(tb*(B0+3*z0*r+i*(7*W0+9*G0*r))),n*(B0+z0*r+i*(W0+G0*r))]}mE.invert=function(t,e){for(var n=e,r=n*n,i=r*r*r,a=0,o,s,c;a<WJ&&(s=n*(B0+z0*r+i*(W0+G0*r))-e,c=B0+3*z0*r+i*(7*W0+9*G0*r),n-=o=s/c,r=n*n,i=r*r*r,!(Tn(o)<rD));++a);return[tb*t*(B0+3*z0*r+i*(7*W0+9*G0*r))/an(n),Ao(Ze(n)/tb)]};function GJ(){return Ms(mE).scale(177.158)}function bE(t,e){var n=an(e),r=an(t)*n;return[n*Ze(t)/r,Ze(e)/r]}bE.invert=D0(kd);function $J(){return Ms(bE).scale(144.049).clipAngle(60)}function ZJ(){var t=1,e=0,n=0,r=1,i=1,a=0,o,s,c=null,l,u,f,d=1,h=1,v=I0({point:function(w,O){var E=_([w,O]);this.stream.point(E[0],E[1])}}),g=A0,y,b;function x(){return d=t*r,h=t*i,y=b=null,_}function _(w){var O=w[0]*d,E=w[1]*h;if(a){var M=E*o-O*s;O=O*o+E*s,E=M}return[O+e,E+n]}return _.invert=function(w){var O=w[0]-e,E=w[1]-n;if(a){var M=E*o+O*s;O=O*o-E*s,E=M}return[O/d,E/h]},_.stream=function(w){return y&&b===w?y:y=v(g(b=w))},_.postclip=function(w){return arguments.length?(g=w,c=l=u=f=null,x()):g},_.clipExtent=function(w){return arguments.length?(g=w==null?(c=l=u=f=null,A0):FD(c=+w[0][0],l=+w[0][1],u=+w[1][0],f=+w[1][1]),x()):c==null?null:[[c,l],[u,f]]},_.scale=function(w){return arguments.length?(t=+w,x()):t},_.translate=function(w){return arguments.length?(e=+w[0],n=+w[1],x()):[e,n]},_.angle=function(w){return arguments.length?(a=w%360*Ar,s=Ze(a),o=an(a),x()):a*ia},_.reflectX=function(w){return arguments.length?(r=w?-1:1,x()):r<0},_.reflectY=function(w){return arguments.length?(i=w?-1:1,x()):i<0},_.fitExtent=function(w,O){return K1(_,w,O)},_.fitSize=function(w,O){return fE(_,w,O)},_.fitWidth=function(w,O){return dE(_,w,O)},_.fitHeight=function(w,O){return hE(_,w,O)},_}function xE(t,e){var n=e*e,r=n*n;return[t*(.8707-.131979*n+r*(-.013791+r*(.003971*n-.001529*r))),e*(1.007226+n*(.015085+r*(-.044475+.028874*n-.005916*r)))]}xE.invert=function(t,e){var n=e,r=25,i;do{var a=n*n,o=a*a;n-=i=(n*(1.007226+a*(.015085+o*(-.044475+.028874*a-.005916*o)))-e)/(1.007226+a*(.015085*3+o*(-.044475*7+.028874*9*a-.005916*11*o)))}while(Tn(i)>Re&&--r>0);return[t/(.8707+(a=n*n)*(-.131979+a*(-.013791+a*a*a*(.003971-.001529*a)))),n]};function YJ(){return Ms(xE).scale(175.295)}function _E(t,e){return[an(e)*Ze(t),Ze(e)]}_E.invert=D0(Ao);function HJ(){return Ms(_E).scale(249.5).clipAngle(90+Re)}function wE(t,e){var n=an(e),r=1+an(t)*n;return[n*Ze(t)/r,Ze(e)/r]}wE.invert=D0(function(t){return 2*kd(t)});function VJ(){return Ms(wE).scale(250).clipAngle(142)}function OE(t,e){return[j1(HS((jr+e)/2)),-t]}OE.invert=function(t,e){return[-e,2*kd(aD(t))-jr]};function XJ(){var t=UD(OE),e=t.center,n=t.rotate;return t.center=function(r){return arguments.length?e([-r[1],r[0]]):(r=e(),[r[1],-r[0]])},t.rotate=function(r){return arguments.length?n([r[0],r[1],r.length>2?r[2]+90:90]):(r=n(),[r[0],r[1],r[2]-90])},n([0,0,90]).scale(159.155)}var UJ=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function qJ(t){if(typeof t=="function")return t;const e=`geo${tl(t)}`,n=Ye[e];if(!n)throw new Error(`Unknown coordinate: ${t}`);return n}function KJ(t){return{type:"FeatureCollection",features:t.flatMap(e=>QJ(e).features)}}function QJ(t){const e={Point:"geometry",MultiPoint:"geometry",LineString:"geometry",MultiLineString:"geometry",Polygon:"geometry",MultiPolygon:"geometry",GeometryCollection:"geometry",Feature:"feature",FeatureCollection:"featureCollection"};if(!t||!t.type)return null;const n=e[t.type];if(!n)return null;if(n==="geometry")return{type:"FeatureCollection",features:[{type:"Feature",properties:{},geometry:t}]};if(n==="feature")return{type:"FeatureCollection",features:[t]};if(n==="featureCollection")return t}function JJ(t,e){var n;for(const[r,i]of Object.entries(e))(n=t[r])===null||n===void 0||n.call(t,i)}function ttt(t,e,n,r){const i=()=>{const s=e.filter(QD);return s.find(l=>l.sphere)?{type:"Sphere"}:KJ(s.filter(l=>!l.sphere).flatMap(l=>l.data.value))},{outline:a=i()}=r,{size:o="fitExtent"}=r;if(o==="fitExtent")return ett(t,a,n);if(o==="fitWidth")return ntt(t,a,n)}function ett(t,e,n){const{x:r,y:i,width:a,height:o}=n;t.fitExtent([[r,i],[a,o]],e)}function ntt(t,e,n){const{width:r,height:i}=n,[[a,o],[s,c]]=kD(t.fitWidth(r,e)).bounds(e),l=Math.ceil(c-o),u=Math.min(Math.ceil(s-a),l),f=t.scale()*(u-1)/u,[d,h]=t.translate(),v=h+(i-l)/2;t.scale(f).translate([d,v]).precision(.2)}function rtt(t){const{data:e}=t;if(Array.isArray(e))return Object.assign(Object.assign({},t),{data:{value:e}});const{type:n}=e;return n==="graticule10"?Object.assign(Object.assign({},t),{data:{value:[vJ()]}}):n==="sphere"?Object.assign(Object.assign({},t),{sphere:!0,data:{value:[{type:"Sphere"}]}}):t}function QD(t){return t.type==="geoPath"}const JD=()=>t=>{const{children:e,coordinate:n={}}=t;if(!Array.isArray(e))return[];const{type:r="equalEarth"}=n,i=UJ(n,["type"]),a=qJ(r),o=e.map(rtt);let s;function c(){return[["custom",(f,d,h,v)=>{const g=a();ttt(g,o,{x:f,y:d,width:h,height:v},i),JJ(g,i),s=kD(g);const b=new Ji({domain:[f,f+h]}),x=new Ji({domain:[d,d+v]}),_=O=>{const E=g(O);if(!E)return[null,null];const[M,k]=E;return[b.map(M),x.map(k)]},w=O=>{if(!O)return null;const[E,M]=O,k=[b.invert(E),x.invert(M)];return g.invert(k)};return{transform:O=>_(O),untransform:O=>w(O)}}]]}function l(f){const{style:d,tooltip:h={}}=f;return Object.assign(Object.assign({},f),{type:"path",tooltip:qm(h,{title:"id",items:[{channel:"color"}]}),style:Object.assign(Object.assign({},d),{d:v=>s(v)||[]})})}const u=f=>QD(f)?l(f):f;return[Object.assign(Object.assign({},t),{type:"view",scale:{x:{type:"identity"},y:{type:"identity"}},axis:!1,coordinate:{type:c},children:o.flatMap(u)})]};JD.props={};var itt=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const t6=()=>t=>{const{type:e,data:n,scale:r,encode:i,style:a,animate:o,key:s,state:c}=t,l=itt(t,["type","data","scale","encode","style","animate","key","state"]);return[Object.assign(Object.assign({type:"geoView"},l),{children:[{type:"geoPath",key:`${s}-0`,data:{value:n},scale:r,encode:i,style:a,animate:o,state:c}]})]};t6.props={};function att(){return{"composition.geoView":JD,"composition.geoPath":t6}}function ott(t){const e=+this._x.call(null,t),n=+this._y.call(null,t);return e6(this.cover(e,n),e,n,t)}function e6(t,e,n,r){if(isNaN(e)||isNaN(n))return t;var i,a=t._root,o={data:r},s=t._x0,c=t._y0,l=t._x1,u=t._y1,f,d,h,v,g,y,b,x;if(!a)return t._root=o,t;for(;a.length;)if((g=e>=(f=(s+l)/2))?s=f:l=f,(y=n>=(d=(c+u)/2))?c=d:u=d,i=a,!(a=a[b=y<<1|g]))return i[b]=o,t;if(h=+t._x.call(null,a.data),v=+t._y.call(null,a.data),e===h&&n===v)return o.next=a,i?i[b]=o:t._root=o,t;do i=i?i[b]=new Array(4):t._root=new Array(4),(g=e>=(f=(s+l)/2))?s=f:l=f,(y=n>=(d=(c+u)/2))?c=d:u=d;while((b=y<<1|g)===(x=(v>=d)<<1|h>=f));return i[x]=a,i[b]=o,t}function stt(t){var e,n,r=t.length,i,a,o=new Array(r),s=new Array(r),c=1/0,l=1/0,u=-1/0,f=-1/0;for(n=0;n<r;++n)isNaN(i=+this._x.call(null,e=t[n]))||isNaN(a=+this._y.call(null,e))||(o[n]=i,s[n]=a,i<c&&(c=i),i>u&&(u=i),a<l&&(l=a),a>f&&(f=a));if(c>u||l>f)return this;for(this.cover(c,l).cover(u,f),n=0;n<r;++n)e6(this,o[n],s[n],t[n]);return this}function ctt(t,e){if(isNaN(t=+t)||isNaN(e=+e))return this;var n=this._x0,r=this._y0,i=this._x1,a=this._y1;if(isNaN(n))i=(n=Math.floor(t))+1,a=(r=Math.floor(e))+1;else{for(var o=i-n||1,s=this._root,c,l;n>t||t>=i||r>e||e>=a;)switch(l=(e<r)<<1|t<n,c=new Array(4),c[l]=s,s=c,o*=2,l){case 0:i=n+o,a=r+o;break;case 1:n=i-o,a=r+o;break;case 2:i=n+o,r=a-o;break;case 3:n=i-o,r=a-o;break}this._root&&this._root.length&&(this._root=s)}return this._x0=n,this._y0=r,this._x1=i,this._y1=a,this}function ltt(){var t=[];return this.visit(function(e){if(!e.length)do t.push(e.data);while(e=e.next)}),t}function utt(t){return arguments.length?this.cover(+t[0][0],+t[0][1]).cover(+t[1][0],+t[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}function va(t,e,n,r,i){this.node=t,this.x0=e,this.y0=n,this.x1=r,this.y1=i}function ftt(t,e,n){var r,i=this._x0,a=this._y0,o,s,c,l,u=this._x1,f=this._y1,d=[],h=this._root,v,g;for(h&&d.push(new va(h,i,a,u,f)),n==null?n=1/0:(i=t-n,a=e-n,u=t+n,f=e+n,n*=n);v=d.pop();)if(!(!(h=v.node)||(o=v.x0)>u||(s=v.y0)>f||(c=v.x1)<i||(l=v.y1)<a))if(h.length){var y=(o+c)/2,b=(s+l)/2;d.push(new va(h[3],y,b,c,l),new va(h[2],o,b,y,l),new va(h[1],y,s,c,b),new va(h[0],o,s,y,b)),(g=(e>=b)<<1|t>=y)&&(v=d[d.length-1],d[d.length-1]=d[d.length-1-g],d[d.length-1-g]=v)}else{var x=t-+this._x.call(null,h.data),_=e-+this._y.call(null,h.data),w=x*x+_*_;if(w<n){var O=Math.sqrt(n=w);i=t-O,a=e-O,u=t+O,f=e+O,r=h.data}}return r}function dtt(t){if(isNaN(u=+this._x.call(null,t))||isNaN(f=+this._y.call(null,t)))return this;var e,n=this._root,r,i,a,o=this._x0,s=this._y0,c=this._x1,l=this._y1,u,f,d,h,v,g,y,b;if(!n)return this;if(n.length)for(;;){if((v=u>=(d=(o+c)/2))?o=d:c=d,(g=f>=(h=(s+l)/2))?s=h:l=h,e=n,!(n=n[y=g<<1|v]))return this;if(!n.length)break;(e[y+1&3]||e[y+2&3]||e[y+3&3])&&(r=e,b=y)}for(;n.data!==t;)if(i=n,!(n=n.next))return this;return(a=n.next)&&delete n.next,i?(a?i.next=a:delete i.next,this):e?(a?e[y]=a:delete e[y],(n=e[0]||e[1]||e[2]||e[3])&&n===(e[3]||e[2]||e[1]||e[0])&&!n.length&&(r?r[b]=n:this._root=n),this):(this._root=a,this)}function htt(t){for(var e=0,n=t.length;e<n;++e)this.remove(t[e]);return this}function ptt(){return this._root}function vtt(){var t=0;return this.visit(function(e){if(!e.length)do++t;while(e=e.next)}),t}function gtt(t){var e=[],n,r=this._root,i,a,o,s,c;for(r&&e.push(new va(r,this._x0,this._y0,this._x1,this._y1));n=e.pop();)if(!t(r=n.node,a=n.x0,o=n.y0,s=n.x1,c=n.y1)&&r.length){var l=(a+s)/2,u=(o+c)/2;(i=r[3])&&e.push(new va(i,l,u,s,c)),(i=r[2])&&e.push(new va(i,a,u,l,c)),(i=r[1])&&e.push(new va(i,l,o,s,u)),(i=r[0])&&e.push(new va(i,a,o,l,u))}return this}function ytt(t){var e=[],n=[],r;for(this._root&&e.push(new va(this._root,this._x0,this._y0,this._x1,this._y1));r=e.pop();){var i=r.node;if(i.length){var a,o=r.x0,s=r.y0,c=r.x1,l=r.y1,u=(o+c)/2,f=(s+l)/2;(a=i[0])&&e.push(new va(a,o,s,u,f)),(a=i[1])&&e.push(new va(a,u,s,c,f)),(a=i[2])&&e.push(new va(a,o,f,u,l)),(a=i[3])&&e.push(new va(a,u,f,c,l))}n.push(r)}for(;r=n.pop();)t(r.node,r.x0,r.y0,r.x1,r.y1);return this}function mtt(t){return t[0]}function btt(t){return arguments.length?(this._x=t,this):this._x}function xtt(t){return t[1]}function _tt(t){return arguments.length?(this._y=t,this):this._y}function n6(t,e,n){var r=new SE(e==null?mtt:e,n==null?xtt:n,NaN,NaN,NaN,NaN);return t==null?r:r.addAll(t)}function SE(t,e,n,r,i,a){this._x=t,this._y=e,this._x0=n,this._y0=r,this._x1=i,this._y1=a,this._root=void 0}function r6(t){for(var e={data:t.data},n=e;t=t.next;)n=n.next={data:t.data};return e}var ga=n6.prototype=SE.prototype;ga.copy=function(){var t=new SE(this._x,this._y,this._x0,this._y0,this._x1,this._y1),e=this._root,n,r;if(!e)return t;if(!e.length)return t._root=r6(e),t;for(n=[{source:e,target:t._root=new Array(4)}];e=n.pop();)for(var i=0;i<4;++i)(r=e.source[i])&&(r.length?n.push({source:r,target:e.target[i]=new Array(4)}):e.target[i]=r6(r));return t},ga.add=ott,ga.addAll=stt,ga.cover=ctt,ga.data=ltt,ga.extent=utt,ga.find=ftt,ga.remove=dtt,ga.removeAll=htt,ga.root=ptt,ga.size=vtt,ga.visit=gtt,ga.visitAfter=ytt,ga.x=btt,ga.y=_tt;function Va(t){return function(){return t}}function Ld(t){return(t()-.5)*1e-6}var wtt={value:function(){}};function i6(){for(var t=0,e=arguments.length,n={},r;t<e;++t){if(!(r=arguments[t]+"")||r in n||/[\s.]/.test(r))throw new Error("illegal type: "+r);n[r]=[]}return new eb(n)}function eb(t){this._=t}function Ott(t,e){return t.trim().split(/^|\s+/).map(function(n){var r="",i=n.indexOf(".");if(i>=0&&(r=n.slice(i+1),n=n.slice(0,i)),n&&!e.hasOwnProperty(n))throw new Error("unknown type: "+n);return{type:n,name:r}})}eb.prototype=i6.prototype={constructor:eb,on:function(e,n){var r=this._,i=Ott(e+"",r),a,o=-1,s=i.length;if(arguments.length<2){for(;++o<s;)if((a=(e=i[o]).type)&&(a=Stt(r[a],e.name)))return a;return}if(n!=null&&typeof n!="function")throw new Error("invalid callback: "+n);for(;++o<s;)if(a=(e=i[o]).type)r[a]=a6(r[a],e.name,n);else if(n==null)for(a in r)r[a]=a6(r[a],e.name,null);return this},copy:function(){var e={},n=this._;for(var r in n)e[r]=n[r].slice();return new eb(e)},call:function(e,n){if((a=arguments.length-2)>0)for(var r=new Array(a),i=0,a,o;i<a;++i)r[i]=arguments[i+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],i=0,a=o.length;i<a;++i)o[i].value.apply(n,r)},apply:function(e,n,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var i=this._[e],a=0,o=i.length;a<o;++a)i[a].value.apply(n,r)}};function Stt(t,e){for(var n=0,r=t.length,i;n<r;++n)if((i=t[n]).name===e)return i.value}function a6(t,e,n){for(var r=0,i=t.length;r<i;++r)if(t[r].name===e){t[r]=wtt,t=t.slice(0,r).concat(t.slice(r+1));break}return n!=null&&t.push({name:e,value:n}),t}var Ett=i6,Rd=0,$0=0,Z0=0,o6=1e3,nb,Y0,rb=0,Fu=0,ib=0,H0=typeof performance=="object"&&performance.now?performance:Date,s6=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function c6(){return Fu||(s6(Mtt),Fu=H0.now()+ib)}function Mtt(){Fu=0}function EE(){this._call=this._time=this._next=null}EE.prototype=l6.prototype={constructor:EE,restart:function(t,e,n){if(typeof t!="function")throw new TypeError("callback is not a function");n=(n==null?c6():+n)+(e==null?0:+e),!this._next&&Y0!==this&&(Y0?Y0._next=this:nb=this,Y0=this),this._call=t,this._time=n,ME()},stop:function(){this._call&&(this._call=null,this._time=1/0,ME())}};function l6(t,e,n){var r=new EE;return r.restart(t,e,n),r}function ktt(){c6(),++Rd;for(var t=nb,e;t;)(e=Fu-t._time)>=0&&t._call.call(void 0,e),t=t._next;--Rd}function u6(){Fu=(rb=H0.now())+ib,Rd=$0=0;try{ktt()}finally{Rd=0,Ttt(),Fu=0}}function Att(){var t=H0.now(),e=t-rb;e>o6&&(ib-=e,rb=t)}function Ttt(){for(var t,e=nb,n,r=1/0;e;)e._call?(r>e._time&&(r=e._time),t=e,e=e._next):(n=e._next,e._next=null,e=t?t._next=n:nb=n);Y0=t,ME(r)}function ME(t){if(!Rd){$0&&($0=clearTimeout($0));var e=t-Fu;e>24?(t<1/0&&($0=setTimeout(u6,t-H0.now()-ib)),Z0&&(Z0=clearInterval(Z0))):(Z0||(rb=H0.now(),Z0=setInterval(Att,o6)),Rd=1,s6(u6))}}const Ptt=1664525,Ctt=1013904223,f6=4294967296;function Ltt(){let t=1;return()=>(t=(Ptt*t+Ctt)%f6)/f6}function Rtt(t){return t.x}function Ntt(t){return t.y}var Itt=10,Dtt=Math.PI*(3-Math.sqrt(5));function jtt(t){var e,n=1,r=.001,i=1-Math.pow(r,1/300),a=0,o=.6,s=new Map,c=l6(f),l=Ett("tick","end"),u=Ltt();t==null&&(t=[]);function f(){d(),l.call("tick",e),n<r&&(c.stop(),l.call("end",e))}function d(g){var y,b=t.length,x;g===void 0&&(g=1);for(var _=0;_<g;++_)for(n+=(a-n)*i,s.forEach(function(w){w(n)}),y=0;y<b;++y)x=t[y],x.fx==null?x.x+=x.vx*=o:(x.x=x.fx,x.vx=0),x.fy==null?x.y+=x.vy*=o:(x.y=x.fy,x.vy=0);return e}function h(){for(var g=0,y=t.length,b;g<y;++g){if(b=t[g],b.index=g,b.fx!=null&&(b.x=b.fx),b.fy!=null&&(b.y=b.fy),isNaN(b.x)||isNaN(b.y)){var x=Itt*Math.sqrt(.5+g),_=g*Dtt;b.x=x*Math.cos(_),b.y=x*Math.sin(_)}(isNaN(b.vx)||isNaN(b.vy))&&(b.vx=b.vy=0)}}function v(g){return g.initialize&&g.initialize(t,u),g}return h(),e={tick:d,restart:function(){return c.restart(f),e},stop:function(){return c.stop(),e},nodes:function(g){return arguments.length?(t=g,h(),s.forEach(v),e):t},alpha:function(g){return arguments.length?(n=+g,e):n},alphaMin:function(g){return arguments.length?(r=+g,e):r},alphaDecay:function(g){return arguments.length?(i=+g,e):+i},alphaTarget:function(g){return arguments.length?(a=+g,e):a},velocityDecay:function(g){return arguments.length?(o=1-g,e):1-o},randomSource:function(g){return arguments.length?(u=g,s.forEach(v),e):u},force:function(g,y){return arguments.length>1?(y==null?s.delete(g):s.set(g,v(y)),e):s.get(g)},find:function(g,y,b){var x=0,_=t.length,w,O,E,M,k;for(b==null?b=1/0:b*=b,x=0;x<_;++x)M=t[x],w=g-M.x,O=y-M.y,E=w*w+O*O,E<b&&(k=M,b=E);return k},on:function(g,y){return arguments.length>1?(l.on(g,y),e):l.on(g)}}}function Ftt(){var t,e,n,r,i=Va(-30),a,o=1,s=1/0,c=.81;function l(h){var v,g=t.length,y=n6(t,Rtt,Ntt).visitAfter(f);for(r=h,v=0;v<g;++v)e=t[v],y.visit(d)}function u(){if(t){var h,v=t.length,g;for(a=new Array(v),h=0;h<v;++h)g=t[h],a[g.index]=+i(g,h,t)}}function f(h){var v=0,g,y,b=0,x,_,w;if(h.length){for(x=_=w=0;w<4;++w)(g=h[w])&&(y=Math.abs(g.value))&&(v+=g.value,b+=y,x+=y*g.x,_+=y*g.y);h.x=x/b,h.y=_/b}else{g=h,g.x=g.data.x,g.y=g.data.y;do v+=a[g.data.index];while(g=g.next)}h.value=v}function d(h,v,g,y){if(!h.value)return!0;var b=h.x-e.x,x=h.y-e.y,_=y-v,w=b*b+x*x;if(_*_/c<w)return w<s&&(b===0&&(b=Ld(n),w+=b*b),x===0&&(x=Ld(n),w+=x*x),w<o&&(w=Math.sqrt(o*w)),e.vx+=b*h.value*r/w,e.vy+=x*h.value*r/w),!0;if(h.length||w>=s)return;(h.data!==e||h.next)&&(b===0&&(b=Ld(n),w+=b*b),x===0&&(x=Ld(n),w+=x*x),w<o&&(w=Math.sqrt(o*w)));do h.data!==e&&(_=a[h.data.index]*r/w,e.vx+=b*_,e.vy+=x*_);while(h=h.next)}return l.initialize=function(h,v){t=h,n=v,u()},l.strength=function(h){return arguments.length?(i=typeof h=="function"?h:Va(+h),u(),l):i},l.distanceMin=function(h){return arguments.length?(o=h*h,l):Math.sqrt(o)},l.distanceMax=function(h){return arguments.length?(s=h*h,l):Math.sqrt(s)},l.theta=function(h){return arguments.length?(c=h*h,l):Math.sqrt(c)},l}function Btt(t){return t.index}function d6(t,e){var n=t.get(e);if(!n)throw new Error("node not found: "+e);return n}function ztt(t){var e=Btt,n=f,r,i=Va(30),a,o,s,c,l,u=1;t==null&&(t=[]);function f(y){return 1/Math.min(s[y.source.index],s[y.target.index])}function d(y){for(var b=0,x=t.length;b<u;++b)for(var _=0,w,O,E,M,k,A,P;_<x;++_)w=t[_],O=w.source,E=w.target,M=E.x+E.vx-O.x-O.vx||Ld(l),k=E.y+E.vy-O.y-O.vy||Ld(l),A=Math.sqrt(M*M+k*k),A=(A-a[_])/A*y*r[_],M*=A,k*=A,E.vx-=M*(P=c[_]),E.vy-=k*P,O.vx+=M*(P=1-P),O.vy+=k*P}function h(){if(o){var y,b=o.length,x=t.length,_=new Map(o.map((O,E)=>[e(O,E,o),O])),w;for(y=0,s=new Array(b);y<x;++y)w=t[y],w.index=y,typeof w.source!="object"&&(w.source=d6(_,w.source)),typeof w.target!="object"&&(w.target=d6(_,w.target)),s[w.source.index]=(s[w.source.index]||0)+1,s[w.target.index]=(s[w.target.index]||0)+1;for(y=0,c=new Array(x);y<x;++y)w=t[y],c[y]=s[w.source.index]/(s[w.source.index]+s[w.target.index]);r=new Array(x),v(),a=new Array(x),g()}}function v(){if(o)for(var y=0,b=t.length;y<b;++y)r[y]=+n(t[y],y,t)}function g(){if(o)for(var y=0,b=t.length;y<b;++y)a[y]=+i(t[y],y,t)}return d.initialize=function(y,b){o=y,l=b,h()},d.links=function(y){return arguments.length?(t=y,h(),d):t},d.id=function(y){return arguments.length?(e=y,d):e},d.iterations=function(y){return arguments.length?(u=+y,d):u},d.strength=function(y){return arguments.length?(n=typeof y=="function"?y:Va(+y),v(),d):n},d.distance=function(y){return arguments.length?(i=typeof y=="function"?y:Va(+y),g(),d):i},d}function Wtt(t,e){var n,r=1;t==null&&(t=0),e==null&&(e=0);function i(){var a,o=n.length,s,c=0,l=0;for(a=0;a<o;++a)s=n[a],c+=s.x,l+=s.y;for(c=(c/o-t)*r,l=(l/o-e)*r,a=0;a<o;++a)s=n[a],s.x-=c,s.y-=l}return i.initialize=function(a){n=a},i.x=function(a){return arguments.length?(t=+a,i):t},i.y=function(a){return arguments.length?(e=+a,i):e},i.strength=function(a){return arguments.length?(r=+a,i):r},i}function Gtt(t){var e=Va(.1),n,r,i;typeof t!="function"&&(t=Va(t==null?0:+t));function a(s){for(var c=0,l=n.length,u;c<l;++c)u=n[c],u.vx+=(i[c]-u.x)*r[c]*s}function o(){if(n){var s,c=n.length;for(r=new Array(c),i=new Array(c),s=0;s<c;++s)r[s]=isNaN(i[s]=+t(n[s],s,n))?0:+e(n[s],s,n)}}return a.initialize=function(s){n=s,o()},a.strength=function(s){return arguments.length?(e=typeof s=="function"?s:Va(+s),o(),a):e},a.x=function(s){return arguments.length?(t=typeof s=="function"?s:Va(+s),o(),a):t},a}function $tt(t){var e=Va(.1),n,r,i;typeof t!="function"&&(t=Va(t==null?0:+t));function a(s){for(var c=0,l=n.length,u;c<l;++c)u=n[c],u.vy+=(i[c]-u.y)*r[c]*s}function o(){if(n){var s,c=n.length;for(r=new Array(c),i=new Array(c),s=0;s<c;++s)r[s]=isNaN(i[s]=+t(n[s],s,n))?0:+e(n[s],s,n)}}return a.initialize=function(s){n=s,o()},a.strength=function(s){return arguments.length?(e=typeof s=="function"?s:Va(+s),o(),a):e},a.y=function(s){return arguments.length?(t=typeof s=="function"?s:Va(+s),o(),a):t},a}var Ztt=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const Ytt={joint:!0},Htt={type:"link",axis:!1,legend:!1,encode:{x:[t=>t.source.x,t=>t.target.x],y:[t=>t.source.y,t=>t.target.y]},style:{stroke:"#999",strokeOpacity:.6}},Vtt={type:"point",axis:!1,legend:!1,encode:{x:"x",y:"y",size:5,color:"group",shape:"point"},style:{stroke:"#fff"}},Xtt={text:""};function Utt(t,e,n){const{nodes:r,links:i}=t,{joint:a,nodeStrength:o,linkStrength:s}=e,{nodeKey:c=v=>v.id,linkKey:l=v=>v.id}=n,u=Ftt(),f=ztt(i).id(Os(l));typeof o=="function"&&u.strength(o),typeof s=="function"&&f.strength(s);const d=jtt(r).force("link",f).force("charge",u);a?d.force("center",Wtt()):d.force("x",Gtt()).force("y",$tt()),d.stop();const h=Math.ceil(Math.log(d.alphaMin())/Math.log(1-d.alphaDecay()));for(let v=0;v<h;v++)d.tick();return{nodesData:r,linksData:i}}const h6=t=>{const{data:e,encode:n={},scale:r,style:i={},layout:a={},nodeLabels:o=[],linkLabels:s=[],animate:c={},tooltip:l={}}=t,{nodeKey:u=E=>E.id,linkKey:f=E=>E.id}=n,d=Ztt(n,["nodeKey","linkKey"]),h=Object.assign({nodeKey:u,linkKey:f},d),v=$t(h,"node"),g=$t(h,"link"),{links:y,nodes:b}=PO(e,h),{nodesData:x,linksData:_}=Utt({links:y,nodes:b},mt({},Ytt,a),h),w=xs(l,"link",{items:[E=>({name:"source",value:Os(f)(E.source)}),E=>({name:"target",value:Os(f)(E.target)})]}),O=xs(l,"node",{items:[E=>({name:"key",value:Os(u)(E)})]},!0);return[mt({},Htt,{data:_,encode:g,labels:s,style:$t(i,"link"),tooltip:w,animate:_s(c,"link")}),mt({},Vtt,{data:x,encode:Object.assign({},v),scale:r,style:$t(i,"node"),tooltip:O,labels:[Object.assign(Object.assign({},Xtt),$t(i,"label")),...o],animate:_s(c,"link")})]};h6.props={};function qtt(t,e){return t.parent===e.parent?1:2}function kE(t){var e=t.children;return e?e[0]:t.t}function AE(t){var e=t.children;return e?e[e.length-1]:t.t}function Ktt(t,e,n){var r=n/(e.i-t.i);e.c-=r,e.s+=n,t.c+=r,e.z+=n,e.m+=n}function Qtt(t){for(var e=0,n=0,r=t.children,i=r.length,a;--i>=0;)a=r[i],a.z+=e,a.m+=e,e+=a.s+(n+=a.c)}function Jtt(t,e,n){return t.a.parent===e.parent?t.a:n}function ab(t,e){this._=t,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=e}ab.prototype=Object.create(md.prototype);function tet(t){for(var e=new ab(t,0),n,r=[e],i,a,o,s;n=r.pop();)if(a=n._.children)for(n.children=new Array(s=a.length),o=s-1;o>=0;--o)r.push(i=n.children[o]=new ab(a[o],o)),i.parent=n;return(e.parent=new ab(null,0)).children=[e],e}function eet(){var t=qtt,e=1,n=1,r=null;function i(l){var u=tet(l);if(u.eachAfter(a),u.parent.m=-u.z,u.eachBefore(o),r)l.eachBefore(c);else{var f=l,d=l,h=l;l.eachBefore(function(x){x.x<f.x&&(f=x),x.x>d.x&&(d=x),x.depth>h.depth&&(h=x)});var v=f===d?1:t(f,d)/2,g=v-f.x,y=e/(d.x+v+g),b=n/(h.depth||1);l.eachBefore(function(x){x.x=(x.x+g)*y,x.y=x.depth*b})}return l}function a(l){var u=l.children,f=l.parent.children,d=l.i?f[l.i-1]:null;if(u){Qtt(l);var h=(u[0].z+u[u.length-1].z)/2;d?(l.z=d.z+t(l._,d._),l.m=l.z-h):l.z=h}else d&&(l.z=d.z+t(l._,d._));l.parent.A=s(l,d,l.parent.A||f[0])}function o(l){l._.x=l.z+l.parent.m,l.m+=l.parent.m}function s(l,u,f){if(u){for(var d=l,h=l,v=u,g=d.parent.children[0],y=d.m,b=h.m,x=v.m,_=g.m,w;v=AE(v),d=kE(d),v&&d;)g=kE(g),h=AE(h),h.a=l,w=v.z+x-d.z-y+t(v._,d._),w>0&&(Ktt(Jtt(v,l,f),l,w),y+=w,b+=w),x+=v.m,y+=d.m,_+=g.m,b+=h.m;v&&!AE(h)&&(h.t=v,h.m+=x-b),d&&!kE(g)&&(g.t=d,g.m+=y-_,f=l)}return f}function c(l){l.x*=e,l.y=l.depth*n}return i.separation=function(l){return arguments.length?(t=l,i):t},i.size=function(l){return arguments.length?(r=!1,e=+l[0],n=+l[1],i):r?null:[e,n]},i.nodeSize=function(l){return arguments.length?(r=!0,e=+l[0],n=+l[1],i):r?[e,n]:null},i}function net(t,e){return t.parent===e.parent?1:2}function ret(t){return t.reduce(iet,0)/t.length}function iet(t,e){return t+e.x}function aet(t){return 1+t.reduce(oet,0)}function oet(t,e){return Math.max(t,e.y)}function set(t){for(var e;e=t.children;)t=e[0];return t}function cet(t){for(var e;e=t.children;)t=e[e.length-1];return t}function uet(){var t=net,e=1,n=1,r=!1;function i(a){var o,s=0;a.eachAfter(function(d){var h=d.children;h?(d.x=ret(h),d.y=aet(h)):(d.x=o?s+=t(d,o):0,d.y=0,o=d)});var c=set(a),l=cet(a),u=c.x-t(c,l)/2,f=l.x+t(l,c)/2;return a.eachAfter(r?function(d){d.x=(d.x-a.x)*e,d.y=(a.y-d.y)*n}:function(d){d.x=(d.x-u)/(f-u)*e,d.y=(1-(a.y?d.y/a.y:1))*n})}return i.separation=function(a){return arguments.length?(t=a,i):t},i.size=function(a){return arguments.length?(r=!1,e=+a[0],n=+a[1],i):r?null:[e,n]},i.nodeSize=function(a){return arguments.length?(r=!0,e=+a[0],n=+a[1],i):r?[e,n]:null},i}const p6=t=>e=>n=>{const{field:r="value",nodeSize:i,separation:a,sortBy:o,as:s=["x","y"]}=e,[c,l]=s,u=yd(n,v=>v.children).sum(v=>v[r]).sort(o),f=t();f.size([1,1]),i&&f.nodeSize(i),a&&f.separation(a),f(u);const d=[];u.each(v=>{v[c]=v.x,v[l]=v.y,v.name=v.data.name,d.push(v)});const h=u.links();return h.forEach(v=>{v[c]=[v.source[c],v.target[c]],v[l]=[v.source[l],v.target[l]]}),{nodes:d,edges:h}},v6=t=>p6(uet)(t);v6.props={};const g6=t=>p6(eet)(t);g6.props={};const fet={sortBy:(t,e)=>e.value-t.value},det={axis:!1,legend:!1,type:"point",encode:{x:"x",y:"y",size:2,shape:"point"}},het={type:"link",encode:{x:"x",y:"y",shape:"smooth"}},pet={text:"",fontSize:10},y6=t=>{const{data:e,encode:n={},scale:r={},style:i={},layout:a={},nodeLabels:o=[],linkLabels:s=[],animate:c={},tooltip:l={}}=t,u=n==null?void 0:n.value,{nodes:f,edges:d}=g6(Object.assign(Object.assign(Object.assign({},fet),a),{field:u}))(e),h=xs(l,"node",{title:"name",items:["value"]},!0),v=xs(l,"link",{title:"",items:[g=>({name:"source",value:g.source.name}),g=>({name:"target",value:g.target.name})]});return[mt({},het,{data:d,encode:$t(n,"link"),scale:$t(r,"link"),labels:s,style:Object.assign({stroke:"#999"},$t(i,"link")),tooltip:v,animate:_s(c,"link")}),mt({},det,{data:f,scale:$t(r,"node"),encode:$t(n,"node"),labels:[Object.assign(Object.assign({},pet),$t(i,"label")),...o],style:Object.assign({},$t(i,"node")),tooltip:h,animate:_s(c,"node")})]};y6.props={};var vet=1664525,get=1013904223,m6=4294967296;function yet(){var t=1;return function(){return(t=(vet*t+get)%m6)/m6}}var met=pt(52677);function bet(t){return met(t)==="object"&&"length"in t?t:Array.from(t)}function xet(t,e){for(var n=t.length,r,i;n;)i=e()*n--|0,r=t[n],t[n]=t[i],t[i]=r;return t}function Kot(t){return b6(t,lcg())}function b6(t,e){for(var n=0,r=(t=xet(Array.from(t),e)).length,i=[],a,o;n<r;)a=t[n],o&&x6(o,a)?++n:(o=wet(i=_et(i,a)),n=0);return o}function _et(t,e){var n,r;if(TE(e,t))return[e];for(n=0;n<t.length;++n)if(ob(e,t[n])&&TE(V0(t[n],e),t))return[t[n],e];for(n=0;n<t.length-1;++n)for(r=n+1;r<t.length;++r)if(ob(V0(t[n],t[r]),e)&&ob(V0(t[n],e),t[r])&&ob(V0(t[r],e),t[n])&&TE(_6(t[n],t[r],e),t))return[t[n],t[r],e];throw new Error}function ob(t,e){var n=t.r-e.r,r=e.x-t.x,i=e.y-t.y;return n<0||n*n<r*r+i*i}function x6(t,e){var n=t.r-e.r+Math.max(t.r,e.r,1)*1e-9,r=e.x-t.x,i=e.y-t.y;return n>0&&n*n>r*r+i*i}function TE(t,e){for(var n=0;n<e.length;++n)if(!x6(t,e[n]))return!1;return!0}function wet(t){switch(t.length){case 1:return Oet(t[0]);case 2:return V0(t[0],t[1]);case 3:return _6(t[0],t[1],t[2])}}function Oet(t){return{x:t.x,y:t.y,r:t.r}}function V0(t,e){var n=t.x,r=t.y,i=t.r,a=e.x,o=e.y,s=e.r,c=a-n,l=o-r,u=s-i,f=Math.sqrt(c*c+l*l);return{x:(n+a+c/f*u)/2,y:(r+o+l/f*u)/2,r:(f+i+s)/2}}function _6(t,e,n){var r=t.x,i=t.y,a=t.r,o=e.x,s=e.y,c=e.r,l=n.x,u=n.y,f=n.r,d=r-o,h=r-l,v=i-s,g=i-u,y=c-a,b=f-a,x=r*r+i*i-a*a,_=x-o*o-s*s+c*c,w=x-l*l-u*u+f*f,O=h*v-d*g,E=(v*w-g*_)/(O*2)-r,M=(g*y-v*b)/O,k=(h*_-d*w)/(O*2)-i,A=(d*b-h*y)/O,P=M*M+A*A-1,C=2*(a+E*M+k*A),N=E*E+k*k-a*a,L=-(Math.abs(P)>1e-6?(C+Math.sqrt(C*C-4*P*N))/(2*P):N/C);return{x:r+E+M*L,y:i+k+A*L,r:L}}function w6(t,e,n){var r=t.x-e.x,i,a,o=t.y-e.y,s,c,l=r*r+o*o;l?(a=e.r+n.r,a*=a,c=t.r+n.r,c*=c,a>c?(i=(l+c-a)/(2*l),s=Math.sqrt(Math.max(0,c/l-i*i)),n.x=t.x-i*r-s*o,n.y=t.y-i*o+s*r):(i=(l+a-c)/(2*l),s=Math.sqrt(Math.max(0,a/l-i*i)),n.x=e.x+i*r-s*o,n.y=e.y+i*o+s*r)):(n.x=e.x+n.r,n.y=e.y)}function O6(t,e){var n=t.r+e.r-1e-6,r=e.x-t.x,i=e.y-t.y;return n>0&&n*n>r*r+i*i}function S6(t){var e=t._,n=t.next._,r=e.r+n.r,i=(e.x*n.r+n.x*e.r)/r,a=(e.y*n.r+n.y*e.r)/r;return i*i+a*a}function sb(t){this._=t,this.next=null,this.previous=null}function E6(t,e){if(!(a=(t=bet(t)).length))return 0;var n,r,i,a,o,s,c,l,u,f,d;if(n=t[0],n.x=0,n.y=0,!(a>1))return n.r;if(r=t[1],n.x=-r.r,r.x=n.r,r.y=0,!(a>2))return n.r+r.r;w6(r,n,i=t[2]),n=new sb(n),r=new sb(r),i=new sb(i),n.next=i.previous=r,r.next=n.previous=i,i.next=r.previous=n;t:for(c=3;c<a;++c){w6(n._,r._,i=t[c]),i=new sb(i),l=r.next,u=n.previous,f=r._.r,d=n._.r;do if(f<=d){if(O6(l._,i._)){r=l,n.next=r,r.previous=n,--c;continue t}f+=l._.r,l=l.next}else{if(O6(u._,i._)){n=u,n.next=r,r.previous=n,--c;continue t}d+=u._.r,u=u.previous}while(l!==u.next);for(i.previous=n,i.next=r,n.next=r.previous=r=i,o=S6(n);(i=i.next)!==r;)(s=S6(i))<o&&(n=i,o=s);r=n.next}for(n=[r._],i=r;(i=i.next)!==r;)n.push(i._);for(i=b6(n,e),c=0;c<a;++c)n=t[c],n.x-=i.x,n.y-=i.y;return i.r}function Qot(t){return E6(t,lcg()),t}function Eet(t){return Math.sqrt(t.value)}function Met(){var t=null,e=1,n=1,r=Du;function i(a){var o=yet();return a.x=e/2,a.y=n/2,t?a.eachBefore(M6(t)).eachAfter(PE(r,.5,o)).eachBefore(k6(1)):a.eachBefore(M6(Eet)).eachAfter(PE(Du,1,o)).eachAfter(PE(r,a.r/Math.min(e,n),o)).eachBefore(k6(Math.min(e,n)/(2*a.r))),a}return i.radius=function(a){return arguments.length?(t=S1(a),i):t},i.size=function(a){return arguments.length?(e=+a[0],n=+a[1],i):[e,n]},i.padding=function(a){return arguments.length?(r=typeof a=="function"?a:Ed(+a),i):r},i}function M6(t){return function(e){e.children||(e.r=Math.max(0,+t(e)||0))}}function PE(t,e,n){return function(r){if(i=r.children){var i,a,o=i.length,s=t(r)*e||0,c;if(s)for(a=0;a<o;++a)i[a].r+=s;if(c=E6(i,n),s)for(a=0;a<o;++a)i[a].r-=s;r.r=c+s}}}function k6(t){return function(e){var n=e.parent;e.r*=t,n&&(e.x=n.x+t*e.x,e.y=n.y+t*e.y)}}var ket=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const Aet=(t,e)=>({size:[t,e],padding:0,sort:(n,r)=>r.value-n.value}),Tet=(t,e,n)=>({type:"point",axis:!1,legend:!1,scale:{x:{domain:[0,t]},y:{domain:[0,e]},size:{type:"identity"}},encode:{x:"x",y:"y",size:"r",shape:"point"},style:{fill:n.color?void 0:r=>r.height===0?"#ddd":"#fff",stroke:n.color?void 0:r=>r.height===0?"":"#000"}}),Pet={text:"",position:"inside",textOverflow:"clip",wordWrap:!0,maxLines:1,wordWrapWidth:t=>t.r*2},Cet={title:t=>t.data.name,items:[{field:"value"}]},Let=(t,e,n)=>{const{value:r}=n,i=Nr(t)?OS().path(e.path)(t):yd(t);return r?i.sum(a=>Os(r)(a)).sort(e.sort):i.count(),Met().size(e.size).padding(e.padding)(i),i.descendants()},A6=(t,e)=>{const{width:n,height:r}=e,{data:i,encode:a={},scale:o={},style:s={},layout:c={},labels:l=[],tooltip:u={}}=t,f=ket(t,["data","encode","scale","style","layout","labels","tooltip"]),d=Tet(n,r,a),h=Let(i,mt({},Aet(n,r),c),mt({},d.encode,a)),v=$t(s,"label");return mt({},d,Object.assign(Object.assign({data:h,encode:a,scale:o,style:s,labels:[Object.assign(Object.assign({},Pet),v),...l]},f),{tooltip:qm(u,Cet),axis:!1}))};A6.props={};function Ret(t){return t.target.depth}function Net(t){return t.depth}function Iet(t,e){return e-1-t.height}function cb(t,e){return t.sourceLinks.length?t.depth:e-1}function Det(t){return t.targetLinks.length?t.depth:t.sourceLinks.length?Za(t.sourceLinks,Ret)-1:0}function lb(t){return function(){return t}}function T6(t,e){return ub(t.source,e.source)||t.index-e.index}function P6(t,e){return ub(t.target,e.target)||t.index-e.index}function ub(t,e){return t.y0-e.y0}function CE(t){return t.value}function jet(t){return t.index}function Fet(t){return t.nodes}function Bet(t){return t.links}function C6(t,e){const n=t.get(e);if(!n)throw new Error("missing: "+e);return n}function L6({nodes:t}){for(const e of t){let n=e.y0,r=n;for(const i of e.sourceLinks)i.y0=n+i.width/2,n+=i.width;for(const i of e.targetLinks)i.y1=r+i.width/2,r+=i.width}}function zet(){let t=0,e=0,n=1,r=1,i=24,a=8,o,s=jet,c=cb,l,u,f,d=Fet,h=Bet,v=6;function g(D){const G={nodes:d(D),links:h(D)};return y(G),b(G),x(G),_(G),E(G),L6(G),G}g.update=function(D){return L6(D),D},g.nodeId=function(D){return arguments.length?(s=typeof D=="function"?D:lb(D),g):s},g.nodeAlign=function(D){return arguments.length?(c=typeof D=="function"?D:lb(D),g):c},g.nodeDepth=function(D){return arguments.length?(l=D,g):l},g.nodeSort=function(D){return arguments.length?(u=D,g):u},g.nodeWidth=function(D){return arguments.length?(i=+D,g):i},g.nodePadding=function(D){return arguments.length?(a=o=+D,g):a},g.nodes=function(D){return arguments.length?(d=typeof D=="function"?D:lb(D),g):d},g.links=function(D){return arguments.length?(h=typeof D=="function"?D:lb(D),g):h},g.linkSort=function(D){return arguments.length?(f=D,g):f},g.size=function(D){return arguments.length?(t=e=0,n=+D[0],r=+D[1],g):[n-t,r-e]},g.extent=function(D){return arguments.length?(t=+D[0][0],n=+D[1][0],e=+D[0][1],r=+D[1][1],g):[[t,e],[n,r]]},g.iterations=function(D){return arguments.length?(v=+D,g):v};function y({nodes:D,links:G}){D.forEach((W,X)=>{W.index=X,W.sourceLinks=[],W.targetLinks=[]});const F=new Map(D.map(W=>[s(W),W]));if(G.forEach((W,X)=>{W.index=X;let{source:Q,target:tt}=W;typeof Q!="object"&&(Q=W.source=C6(F,Q)),typeof tt!="object"&&(tt=W.target=C6(F,tt)),Q.sourceLinks.push(W),tt.targetLinks.push(W)}),f!=null)for(const{sourceLinks:W,targetLinks:X}of D)W.sort(f),X.sort(f)}function b({nodes:D}){for(const G of D)G.value=G.fixedValue===void 0?Math.max(bo(G.sourceLinks,CE),bo(G.targetLinks,CE)):G.fixedValue}function x({nodes:D}){const G=D.length;let F=new Set(D),W=new Set,X=0;for(;F.size;){if(F.forEach(Q=>{Q.depth=X;for(const{target:tt}of Q.sourceLinks)W.add(tt)}),++X>G)throw new Error("circular link");F=W,W=new Set}if(l){const Q=Math.max(Dn(D,nt=>nt.depth)+1,0);let tt;for(let nt=0;nt<D.length;nt++)tt=D[nt],tt.depth=l.call(null,tt,Q)}}function _({nodes:D}){const G=D.length;let F=new Set(D),W=new Set,X=0;for(;F.size;){if(F.forEach(Q=>{Q.height=X;for(const{source:tt}of Q.targetLinks)W.add(tt)}),++X>G)throw new Error("circular link");F=W,W=new Set}}function w({nodes:D}){const G=Math.max(Dn(D,X=>X.depth)+1,0),F=(n-t-i)/(G-1),W=new Array(G).fill(0).map(()=>[]);for(const X of D){const Q=Math.max(0,Math.min(G-1,Math.floor(c.call(null,X,G))));X.layer=Q,X.x0=t+Q*F,X.x1=X.x0+i,W[Q]?W[Q].push(X):W[Q]=[X]}if(u)for(const X of W)X.sort(u);return W}function O(D){const G=Za(D,F=>(r-e-(F.length-1)*o)/bo(F,CE));for(const F of D){let W=e;for(const X of F){X.y0=W,X.y1=W+X.value*G,W=X.y1+o;for(const Q of X.sourceLinks)Q.width=Q.value*G}W=(r-W+o)/(F.length+1);for(let X=0;X<F.length;++X){const Q=F[X];Q.y0+=W*(X+1),Q.y1+=W*(X+1)}L(F)}}function E(D){const G=w(D);o=Math.min(a,(r-e)/(Dn(G,F=>F.length)-1)),O(G);for(let F=0;F<v;++F){const W=Math.pow(.99,F),X=Math.max(1-W,(F+1)/v);k(G,W,X),M(G,W,X)}}function M(D,G,F){for(let W=1,X=D.length;W<X;++W){const Q=D[W];for(const tt of Q){let nt=0,ht=0;for(const{source:wt,value:yt}of tt.targetLinks){const gt=yt*(tt.layer-wt.layer);nt+=R(wt,tt)*gt,ht+=gt}if(!(ht>0))continue;const lt=(nt/ht-tt.y0)*G;tt.y0+=lt,tt.y1+=lt,N(tt)}u===void 0&&Q.sort(ub),Q.length&&A(Q,F)}}function k(D,G,F){for(let W=D.length,X=W-2;X>=0;--X){const Q=D[X];for(const tt of Q){let nt=0,ht=0;for(const{target:wt,value:yt}of tt.sourceLinks){const gt=yt*(wt.layer-tt.layer);nt+=I(tt,wt)*gt,ht+=gt}if(!(ht>0))continue;const lt=(nt/ht-tt.y0)*G;tt.y0+=lt,tt.y1+=lt,N(tt)}u===void 0&&Q.sort(ub),Q.length&&A(Q,F)}}function A(D,G){const F=D.length>>1,W=D[F];C(D,W.y0-o,F-1,G),P(D,W.y1+o,F+1,G),C(D,r,D.length-1,G),P(D,e,0,G)}function P(D,G,F,W){for(;F<D.length;++F){const X=D[F],Q=(G-X.y0)*W;Q>1e-6&&(X.y0+=Q,X.y1+=Q),G=X.y1+o}}function C(D,G,F,W){for(;F>=0;--F){const X=D[F],Q=(X.y1-G)*W;Q>1e-6&&(X.y0-=Q,X.y1-=Q),G=X.y0-o}}function N({sourceLinks:D,targetLinks:G}){if(f===void 0){for(const{source:{sourceLinks:F}}of G)F.sort(P6);for(const{target:{targetLinks:F}}of D)F.sort(T6)}}function L(D){if(f===void 0)for(const{sourceLinks:G,targetLinks:F}of D)G.sort(P6),F.sort(T6)}function R(D,G){let F=D.y0-(D.sourceLinks.length-1)*o/2;for(const{target:W,width:X}of D.sourceLinks){if(W===G)break;F+=X+o}for(const{source:W,width:X}of G.targetLinks){if(W===D)break;F-=X}return F}function I(D,G){let F=G.y0-(G.targetLinks.length-1)*o/2;for(const{source:W,width:X}of G.targetLinks){if(W===D)break;F+=X+o}for(const{target:W,width:X}of D.sourceLinks){if(W===G)break;F-=X}return F}return g}const Wet={nodeAlign:"justify",nodeWidth:.008,nodePadding:.03,nodes:t=>t.nodes,links:t=>t.links,nodeSort:void 0,linkSort:void 0,iterations:6},Get={left:Net,right:Iet,center:Det,justify:cb};function $et(t){const e=typeof t;return e==="string"?Get[t]||cb:e==="function"?t:cb}const R6=t=>e=>{const{nodeId:n,nodeSort:r,nodeAlign:i,nodeWidth:a,nodePadding:o,nodeDepth:s,nodes:c,links:l,linkSort:u,iterations:f}=Object.assign({},Wet,t),d=zet().nodeSort(r).linkSort(u).links(l).nodes(c).nodeWidth(a).nodePadding(o).nodeDepth(s).nodeAlign($et(i)).iterations(f).extent([[0,0],[1,1]]);typeof n=="function"&&d.nodeId(n);const h=d(e),{nodes:v,links:g}=h,y=v.map(x=>{const{x0:_,x1:w,y0:O,y1:E}=x;return Object.assign(Object.assign({},x),{x:[_,w,w,_],y:[O,O,E,E]})}),b=g.map(x=>{const{source:_,target:w}=x,O=_.x1,E=w.x0,M=x.width/2;return Object.assign(Object.assign({},x),{x:[O,O,E,E],y:[x.y0+M,x.y0-M,x.y1+M,x.y1-M]})});return{nodes:y,links:b}};R6.props={};var Zet=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const Yet={nodeId:t=>t.key,nodeWidth:.02,nodePadding:.02},Het={type:"polygon",axis:!1,legend:!1,encode:{shape:"polygon",x:"x",y:"y"},scale:{x:{type:"identity"},y:{type:"identity"}},style:{stroke:"#000"}},Vet={type:"polygon",axis:!1,legend:!1,encode:{shape:"ribbon",x:"x",y:"y"},style:{fillOpacity:.5,stroke:void 0}},Xet={textAlign:t=>t.x[0]<.5?"start":"end",position:t=>t.x[0]<.5?"right":"left",fontSize:10},N6=t=>{const{data:e,encode:n={},scale:r,style:i={},layout:a={},nodeLabels:o=[],linkLabels:s=[],animate:c={},tooltip:l={},interaction:u}=t,{links:f,nodes:d}=PO(e,n),h=$t(n,"node"),v=$t(n,"link"),{key:g=P=>P.key,color:y=g}=h,{links:b,nodes:x}=R6(Object.assign(Object.assign(Object.assign({},Yet),{nodeId:Os(g)}),a))({links:f,nodes:d}),_=$t(i,"label"),{text:w=g,spacing:O=5}=_,E=Zet(_,["text","spacing"]),M=Os(g),k=xs(l,"node",{title:M,items:[{field:"value"}]},!0),A=xs(l,"link",{title:"",items:[P=>({name:"source",value:M(P.source)}),P=>({name:"target",value:M(P.target)})]});return[mt({},Het,{data:x,encode:Object.assign(Object.assign({},h),{color:y}),scale:r,style:$t(i,"node"),labels:[Object.assign(Object.assign(Object.assign({},Xet),{text:w,dx:P=>P.x[0]<.5?O:-O}),E),...o],tooltip:k,animate:_s(c,"node"),axis:!1,interaction:u}),mt({},Vet,{data:b,encode:v,labels:s,style:Object.assign({fill:v.color?void 0:"#aaa",lineWidth:0},$t(i,"link")),tooltip:A,animate:_s(c,"link"),interaction:u})]};N6.props={};function Uet(t,e){return e.value-t.value}function qet(t,e){return e.frequency-t.frequency}function Ket(t,e){return`${t.id}`.localeCompare(`${e.id}`)}function Qet(t,e){return`${t.name}`.localeCompare(`${e.name}`)}const Jet={y:0,thickness:.05,weight:!1,marginRatio:.1,id:t=>t.id,source:t=>t.source,target:t=>t.target,sourceWeight:t=>t.value||1,targetWeight:t=>t.value||1,sortBy:null};function tnt(t){const{y:e,thickness:n,weight:r,marginRatio:i,id:a,source:o,target:s,sourceWeight:c,targetWeight:l,sortBy:u}=Object.assign(Object.assign({},Jet),t);function f(y){const b=y.nodes.map(_=>Object.assign({},_)),x=y.edges.map(_=>Object.assign({},_));return d(b,x),h(b,x),v(b,x),g(b,x),{nodes:b,edges:x}}function d(y,b){b.forEach(w=>{w.source=o(w),w.target=s(w),w.sourceWeight=c(w),w.targetWeight=l(w)});const x=dr(b,w=>w.source),_=dr(b,w=>w.target);return y.forEach(w=>{w.id=a(w);const O=x.has(w.id)?x.get(w.id):[],E=_.has(w.id)?_.get(w.id):[];w.frequency=O.length+E.length,w.value=bo(O,M=>M.sourceWeight)+bo(E,M=>M.targetWeight)}),{nodes:y,edges:b}}function h(y,b){const x=typeof u=="function"?u:ae[u];x&&y.sort(x)}function v(y,b){const x=y.length;if(!x)throw Xf("Invalid nodes: it's empty!");if(!r){const O=1/x;return y.forEach((E,M)=>{E.x=(M+.5)*O,E.y=e}),{nodes:y,edges:b}}const _=i/(2*x),w=y.reduce((O,E)=>O+=E.value,0);return y.reduce((O,E)=>{E.weight=E.value/w,E.width=E.weight*(1-i),E.height=n;const M=_+O,k=M+E.width,A=e-n/2,P=A+n;return E.x=[M,k,k,M],E.y=[A,A,P,P],O+E.width+2*_},0),{nodes:y,edges:b}}function g(y,b){const x=new Map(y.map(O=>[O.id,O]));if(!r)return b.forEach(O=>{const E=o(O),M=s(O),k=x.get(E),A=x.get(M);k&&A&&(O.x=[k.x,A.x],O.y=[k.y,A.y])}),{nodes:y,edges:b};b.forEach(O=>{O.x=[0,0,0,0],O.y=[e,e,e,e]});const _=dr(b,O=>O.source),w=dr(b,O=>O.target);y.forEach(O=>{const{edges:E,width:M,x:k,y:A,value:P,id:C}=O,N=_.get(C)||[],L=w.get(C)||[];let R=0;N.map(I=>{const D=I.sourceWeight/P*M;I.x[0]=k[0]+R,I.x[1]=k[0]+R+D,R+=D}),L.forEach(I=>{const D=I.targetWeight/P*M;I.x[3]=k[0]+R,I.x[2]=k[0]+R+D,R+=D})})}return f}const LE=t=>e=>tnt(t)(e);LE.props={};var I6=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const RE={y:0,thickness:.05,marginRatio:.1,id:t=>t.key,source:t=>t.source,target:t=>t.target,sourceWeight:t=>t.value||1,targetWeight:t=>t.value||1,sortBy:null},ent={type:"polygon",axis:!1,legend:!1,encode:{shape:"polygon",x:"x",y:"y"},scale:{x:{type:"identity"},y:{type:"identity"}},style:{opacity:1,fillOpacity:1,lineWidth:1}},nnt={type:"polygon",axis:!1,legend:!1,encode:{shape:"ribbon",x:"x",y:"y"},style:{opacity:.5,lineWidth:1}},rnt={position:"outside",fontSize:10},D6=(t,e)=>{const{data:n,encode:r={},scale:i,style:a={},layout:o={},nodeLabels:s=[],linkLabels:c=[],animate:l={},tooltip:u={}}=t,{nodes:f,links:d}=PO(n,r),h=$t(r,"node"),v=$t(r,"link"),{key:g=I=>I.key,color:y=g}=h,{linkEncodeColor:b=I=>I.source}=v,{nodeWidthRatio:x=RE.thickness,nodePaddingRatio:_=RE.marginRatio}=o,w=I6(o,["nodeWidthRatio","nodePaddingRatio"]),{nodes:O,edges:E}=LE(Object.assign(Object.assign(Object.assign(Object.assign({},RE),{id:Os(g),thickness:x,marginRatio:_}),w),{weight:!0}))({nodes:f,edges:d}),M=$t(a,"label"),{text:k=g}=M,A=I6(M,["text"]),P=xs(u,"node",{title:"",items:[I=>({name:I.key,value:I.value})]},!0),C=xs(u,"link",{title:"",items:[I=>({name:`${I.source} -> ${I.target}`,value:I.value})]}),{height:N,width:L}=e,R=Math.min(N,L);return[mt({},nnt,{data:E,encode:Object.assign(Object.assign({},v),{color:b}),labels:c,style:Object.assign({fill:b?void 0:"#aaa"},$t(a,"link")),tooltip:C,animate:_s(l,"link")}),mt({},ent,{data:O,encode:Object.assign(Object.assign({},h),{color:y}),scale:i,style:$t(a,"node"),coordinate:{type:"polar",outerRadius:(R-20)/R,startAngle:-Math.PI*2,endAngle:0},labels:[Object.assign(Object.assign(Object.assign({},rnt),{text:k}),A),...s],tooltip:P,animate:_s(l,"node"),axis:!1})]};D6.props={};var int=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const ant=(t,e)=>({tile:"treemapSquarify",ratio:.5*(1+Math.sqrt(5)),size:[t,e],round:!1,ignoreParentValue:!0,padding:0,paddingInner:0,paddingOuter:0,paddingTop:0,paddingRight:0,paddingBottom:0,paddingLeft:0,sort:(n,r)=>r.value-n.value,layer:0}),ont=(t,e)=>({type:"rect",axis:!1,encode:{x:"x",y:"y",key:"id",color:n=>n.path[1]},scale:{x:{domain:[0,t],range:[0,1]},y:{domain:[0,e],range:[0,1]}},style:{stroke:"#fff"},state:{active:{opacity:.6},inactive:{opacity:1}}}),snt={fontSize:10,text:t=>p0(t.path),position:"inside",fill:"#000",textOverflow:"clip",wordWrap:!0,maxLines:1,wordWrapWidth:t=>t.x1-t.x0},cnt={title:t=>{var e,n;return(n=(e=t.path)===null||e===void 0?void 0:e.join)===null||n===void 0?void 0:n.call(e,".")},items:[{field:"value"}]},lnt={title:t=>p0(t.path),items:[{field:"value"}]},j6=(t,e)=>{const{width:n,height:r,options:i}=e,{data:a,encode:o={},scale:s,style:c={},layout:l={},labels:u=[],tooltip:f={}}=t,d=int(t,["data","encode","scale","style","layout","labels","tooltip"]),h=vn(i,["interaction","treemapDrillDown"]),v=mt({},ant(n,r),l,{layer:h?x=>x.depth===1:l.layer}),[g,y]=D4(a,v,o),b=$t(c,"label");return mt({},ont(n,r),Object.assign(Object.assign({data:g,scale:s,style:c,labels:[Object.assign(Object.assign({},snt),b),...u]},d),{encode:o,tooltip:qm(f,cnt),axis:!1}),h?{interaction:Object.assign(Object.assign({},d.interaction),{treemapDrillDown:h?Object.assign(Object.assign({},h),{originData:y,layout:v}):void 0}),encode:Object.assign({color:x=>p0(x.path)},o),tooltip:qm(f,lnt)}:{})};j6.props={};function unt(){return{"data.arc":LE,"data.cluster":v6,"mark.forceGraph":h6,"mark.tree":y6,"mark.pack":A6,"mark.sankey":N6,"mark.chord":D6,"mark.treemap":j6}}var F6=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};function fnt(t,e){return Za(t,n=>e[n])}function dnt(t,e){return Dn(t,n=>e[n])}function B6(t,e){const n=NE(t,e)*2.5-IE(t,e)*1.5;return Za(t,r=>e[r]>=n?e[r]:NaN)}function NE(t,e){return A1(t,.25,n=>e[n])}function hnt(t,e){return A1(t,.5,n=>e[n])}function IE(t,e){return A1(t,.75,n=>e[n])}function z6(t,e){const n=IE(t,e)*2.5-NE(t,e)*1.5;return Dn(t,r=>e[r]<=n?e[r]:NaN)}function pnt(){return(t,e)=>{const{encode:n}=e,{y:r,x:i}=n,{value:a}=r,{value:o}=i;return[Array.from(dr(t,l=>o[+l]).values()).flatMap(l=>{const u=B6(l,a),f=z6(l,a);return l.filter(d=>a[d]<u||a[d]>f)}),e]}}const W6=t=>{const{data:e,encode:n,style:r={},tooltip:i={},transform:a,animate:o}=t,s=F6(t,["data","encode","style","tooltip","transform","animate"]),{point:c=!0}=r,l=F6(r,["point"]),{y:u}=n,f={y:u,y1:u,y2:u,y3:u,y4:u},d={y1:NE,y2:hnt,y3:IE},h=xs(i,"box",{items:[{channel:"y",name:"min"},{channel:"y1",name:"q1"},{channel:"y2",name:"q2"},{channel:"y3",name:"q3"},{channel:"y4",name:"max"}]},!0),v=xs(i,"point",{title:{channel:"x"},items:[{name:"outlier",channel:"y"}]});if(!c)return Object.assign({type:"box",data:e,transform:[Object.assign(Object.assign({type:"groupX",y:fnt},d),{y4:dnt})],encode:Object.assign(Object.assign({},n),f),style:l,tooltip:h},s);const g=$t(l,"box"),y=$t(l,"point");return[Object.assign({type:"box",data:e,transform:[Object.assign(Object.assign({type:"groupX",y:B6},d),{y4:z6})],encode:Object.assign(Object.assign({},n),f),style:g,tooltip:h,animate:_s(o,"box")},s),{type:"point",data:e,transform:[{type:pnt}],encode:n,style:Object.assign({},y),tooltip:v,animate:_s(o,"point")}]};W6.props={};const G6=(t,e)=>Math.sqrt(Math.pow(t[0]-e[0],2)+Math.pow(t[1]-e[1],2))/2,vnt=(t,e)=>{if(!e)return;const{coordinate:n}=e;if(!(n!=null&&n.getCenter))return;const r=n.getCenter();return(i,a,o)=>{const{document:s}=e.canvas,{color:c,index:l}=a,u=s.createElement("g",{}),f=G6(i[0],i[1]),d=G6(i[0],r)*2,h=s.createElement("path",{style:Object.assign(Object.assign(Object.assign({d:[["M",...i[0]],["A",f,f,0,1,0,...i[1]],["A",d+f*2,d+f*2,0,0,0,...i[2]],["A",f,f,0,1,l===0?0:1,...i[3]],["A",d,d,0,0,1,...i[0]],["Z"]]},o),kw(t,["shape","last","first"])),{fill:c||o.color})});return u.appendChild(h),u}};var X0=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const gnt=(t,e)=>{const{shape:n,radius:r}=t,i=X0(t,["shape","radius"]),a=$t(i,"pointer"),o=$t(i,"pin"),{shape:s}=a,c=X0(a,["shape"]),{shape:l}=o,u=X0(o,["shape"]),{coordinate:f,theme:d}=e;return(h,v)=>{const g=h.map(R=>f.invert(R)),[y,b,x]=JF(f,"polar"),_=f.clone(),{color:w}=v,O=rw({startAngle:y,endAngle:b,innerRadius:x,outerRadius:r});O.push(["cartesian"]),_.update({transformations:O});const E=g.map(R=>_.map(R)),[M,k]=Dw(E),[A,P]=f.getCenter(),C=Object.assign(Object.assign({x1:M,y1:k,x2:A,y2:P,stroke:w},c),i),N=Object.assign(Object.assign({cx:A,cy:P,stroke:w},u),i),L=Oe(new ui);return rc(s)||(typeof s=="function"?L.append(()=>s(E,v,_,d)):L.append("line").call(le,C).node()),rc(l)||(typeof l=="function"?L.append(()=>l(E,v,_,d)):L.append("circle").call(le,N).node()),L.node()}},$6={coordinate:{type:"radial",innerRadius:.9,outerRadius:1,startAngle:-11/10*Math.PI,endAngle:1/10*Math.PI},axis:{x:!1},legend:!1,tooltip:!1,encode:{x:"x",y:"y",color:"color"},scale:{color:{range:["#30BF78","#D0D0D0"]}}},ynt={style:{shape:gnt,lineWidth:4,pointerLineCap:"round",pinR:10,pinFill:"#fff",radius:.6}},mnt={type:"text",style:{x:"50%",y:"60%",textAlign:"center",textBaseline:"middle",fontSize:20,fontWeight:800,fill:"#888"},tooltip:!1};function bnt(t){if(Vn(t)){const e=Math.max(0,Math.min(t,1));return{percent:e,target:e,total:1}}return t}function xnt(t,e){const{name:n="score",target:r,total:i,percent:a,thresholds:o=[]}=bnt(t),s=a||r,c=a?1:i,l=Object.assign({y:{domain:[0,c]}},e);return o.length?{targetData:[{x:n,y:s,color:"target"}],totalData:o.map((u,f)=>({x:n,y:f>=1?u-o[f-1]:u,color:f})),target:s,total:c,scale:l}:{targetData:[{x:n,y:s,color:"target"}],totalData:[{x:n,y:s,color:"target"},{x:n,y:c-s,color:"total"}],target:s,total:c,scale:l}}function _nt(t,{target:e,total:n}){const{content:r}=t;return r?r(e,n):e.toString()}const Z6=t=>{const{data:e={},scale:n={},style:r={},animate:i={},transform:a=[]}=t,o=X0(t,["data","scale","style","animate","transform"]),{targetData:s,totalData:c,target:l,total:u,scale:f}=xnt(e,n),d=$t(r,"text"),{tooltip:h}=d,v=X0(d,["tooltip"]),g=RF(r,["pointer","pin"]),y=$t(r,"arc"),b=y.shape;return[mt({},$6,Object.assign({type:"interval",transform:[{type:"stackY"}],data:c,scale:f,style:b==="round"?Object.assign(Object.assign({},y),{shape:vnt}):y,animate:typeof i=="object"?$t(i,"arc"):i},o)),mt({},$6,ynt,Object.assign({type:"point",data:s,scale:f,style:g,animate:typeof i=="object"?$t(i,"indicator"):i},o)),mt({},mnt,{style:Object.assign({text:_nt(v,{target:l,total:u})},v),tooltip:h,animate:typeof i=="object"?$t(i,"text"):i})]};Z6.props={};const Y6=5e3;function H6(t,e,n){return t+(e-t)*n}function wnt(t,e,n,r){return e===0?[[t+1/2*n/Math.PI/2,r/2],[t+1/2*n/Math.PI,r],[t+n/4,r]]:e===1?[[t+1/2*n/Math.PI/2*(Math.PI-2),r],[t+1/2*n/Math.PI/2*(Math.PI-1),r/2],[t+n/4,0]]:e===2?[[t+1/2*n/Math.PI/2,-r/2],[t+1/2*n/Math.PI,-r],[t+n/4,-r]]:[[t+1/2*n/Math.PI/2*(Math.PI-2),-r],[t+1/2*n/Math.PI/2*(Math.PI-1),-r/2],[t+n/4,0]]}function Ont(t,e,n,r,i,a,o){const s=Math.ceil(2*t/n*4)*4,c=[];let l=r;for(;l<-Math.PI*2;)l+=Math.PI*2;for(;l>0;)l-=Math.PI*2;l=l/Math.PI/2*n;const u=a-t+l-t*2;c.push(["M",u,e]);let f=0;for(let d=0;d<s;++d){const h=d%4,v=wnt(d*n/4,h,n,i);c.push(["C",v[0][0]+u,-v[0][1]+e,v[1][0]+u,-v[1][1]+e,v[2][0]+u,-v[2][1]+e]),d===s-1&&(f=v[2][0])}return c.push(["L",f+u,o+t]),c.push(["L",u,o+t]),c.push(["Z"]),c}function Snt(t,e,n,r,i,a,o,s,c,l,u){const{fill:f,fillOpacity:d,opacity:h}=i;for(let v=0;v<r;v++){const g=r<=1?1:v/(r-1),y=Ont(s,o+s*n,c,0,s/40,t,e),b=u.createElement("path",{style:{d:y,fill:f,opacity:H6(.2,.9,g)*Number(h||d)}});a.appendChild(b);try{if(l===!1)return;const x=[{transform:"translate(0, 0)"},{transform:`translate(${c*2}, 0)`}];b.animate(x,{duration:H6(.5*Y6,Y6,g)*2,iterations:1/0})}catch(x){console.warn("off-screen group animate error!")}}}function Ent(t,e,n){return`
      M ${t} ${e-n} 
      a ${n} ${n} 0 1 0 0 ${n*2}
      a ${n} ${n} 0 1 0 0 ${-n*2}
      Z
    `}function Mnt(t,e,n){const i=n*.618;return`
      M ${t-i} ${e-n}
      L ${t+i} ${e-n}
      L ${t+i} ${e+n}
      L ${t-i} ${e+n}
      Z
    `}function knt(t,e,n){return`
      M ${t} ${e-n}
      L ${t+n} ${e}
      L ${t} ${e+n}
      L ${t-n} ${e}
      Z
    `}function Ant(t,e,n){return`
      M ${t} ${e-n}
      L ${t+n} ${e+n}
      L ${t-n} ${e+n}
      Z
    `}function Tnt(t,e,n){const r=n*4/3,i=Math.max(r,n*2),a=r/2,o=t,s=a+e-i/2,c=Math.asin(a/((i-a)*.85)),l=Math.sin(c)*a,u=Math.cos(c)*a,f=o-u,d=s+l,h=t,v=s+a/Math.sin(c);return`
      M ${f} ${d}
      A ${a} ${a} 0 1 1 ${f+u*2} ${d}
      Q ${h} ${v} ${t} ${e+i/2}
      Q ${h} ${v} ${f} ${d}
      Z 
    `}const V6={pin:Tnt,rect:Mnt,circle:Ent,diamond:knt,triangle:Ant};var X6=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const Pnt=(t="circle")=>V6[t]||V6.circle,U6=(t,e)=>{if(!e)return;const{coordinate:n}=e,{liquidOptions:r,styleOptions:i}=t,{liquidShape:a,percent:o}=r,{background:s,outline:c={},wave:l={}}=i,u=X6(i,["background","outline","wave"]),{border:f=2,distance:d=0}=c,h=X6(c,["border","distance"]),{length:v=192,count:g=3}=l;return(y,b,x)=>{const{document:_}=e.canvas,{color:w,fillOpacity:O}=x,E=Object.assign(Object.assign({fill:w},x),u),M=_.createElement("g",{}),[k,A]=n.getCenter(),P=n.getSize(),C=Math.min(...P)/2,L=(Xn(a)?a:Pnt(a))(k,A,C,...P);if(Object.keys(s).length){const D=_.createElement("path",{style:Object.assign({d:L,fill:"#fff"},s)});M.appendChild(D)}if(o>0){const D=_.createElement("path",{style:{d:L}});M.appendChild(D),M.style.clipPath=D,Snt(k,A,1-o,g,E,M,D.getBBox().y,C*2,v,!0,_)}const R=_.createElement("path",{style:{d:L,fill:"transparent",lineWidth:f+2*d,stroke:"#fff"}}),I=_.createElement("path",{style:Object.assign(Object.assign(Object.assign({d:L,stroke:w,strokeOpacity:O,lineWidth:f},E),h),{fill:"transparent"})});return M.appendChild(R),M.appendChild(I),M}};U6.props={};var Cnt=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n};const Lnt={axis:{x:!1,y:!1},legend:!1,tooltip:!1,encode:{x:"type",y:"percent"},scale:{y:{domain:[0,1]}},style:{shape:U6},animate:{enter:{type:"fadeIn"}}},Rnt={type:"text",style:{x:"50%",y:"50%",textAlign:"center",textBaseline:"middle",fontSize:20,fontWeight:800,fill:"#888"},animate:{enter:{type:"fadeIn"}}},q6=t=>{const{data:e={},style:n={},animate:r}=t,i=Cnt(t,["data","style","animate"]),a=Math.max(0,Vn(e)?e:e==null?void 0:e.percent),o=[{percent:a,type:"liquid"}],s=Object.assign(Object.assign({},$t(n,"text")),$t(n,"content")),c=$t(n,"outline"),l=$t(n,"wave"),u=$t(n,"background");return[mt({},Lnt,Object.assign({type:"interval",data:o,style:{liquidOptions:{percent:a,liquidShape:n==null?void 0:n.shape},styleOptions:Object.assign(Object.assign({},n),{outline:c,wave:l,background:u})},animate:r},i)),mt({},Rnt,{style:Object.assign({text:`${rm(a*100)} %`},s),animate:r})]};q6.props={};var gc=pt(69916);const K6=1e-10;function Q6(t,e){const n=Int(t),r=n.filter(function(c){return Nnt(c,t)});let i=0,a=0,o;const s=[];if(r.length>1){const c=Dnt(r);for(o=0;o<r.length;++o){const u=r[o];u.angle=Math.atan2(u.x-c.x,u.y-c.y)}r.sort(function(u,f){return f.angle-u.angle});let l=r[r.length-1];for(o=0;o<r.length;++o){const u=r[o];a+=(l.x+u.x)*(u.y-l.y);const f={x:(u.x+l.x)/2,y:(u.y+l.y)/2};let d=null;for(let h=0;h<u.parentIndex.length;++h)if(l.parentIndex.indexOf(u.parentIndex[h])>-1){const v=t[u.parentIndex[h]],g=Math.atan2(u.x-v.x,u.y-v.y),y=Math.atan2(l.x-v.x,l.y-v.y);let b=y-g;b<0&&(b+=2*Math.PI);const x=y-b/2;let _=U0(f,{x:v.x+v.radius*Math.sin(x),y:v.y+v.radius*Math.cos(x)});_>v.radius*2&&(_=v.radius*2),(d===null||d.width>_)&&(d={circle:v,width:_,p1:u,p2:l})}d!==null&&(s.push(d),i+=DE(d.circle.radius,d.width),l=u)}}else{let c=t[0];for(o=1;o<t.length;++o)t[o].radius<c.radius&&(c=t[o]);let l=!1;for(o=0;o<t.length;++o)if(U0(t[o],c)>Math.abs(c.radius-t[o].radius)){l=!0;break}l?i=a=0:(i=c.radius*c.radius*Math.PI,s.push({circle:c,p1:{x:c.x,y:c.y+c.radius},p2:{x:c.x-K6,y:c.y+c.radius},width:c.radius*2}))}return a/=2,e&&(e.area=i+a,e.arcArea=i,e.polygonArea=a,e.arcs=s,e.innerPoints=r,e.intersectionPoints=n),i+a}function Nnt(t,e){for(let n=0;n<e.length;++n)if(U0(t,e[n])>e[n].radius+K6)return!1;return!0}function Int(t){const e=[];for(let n=0;n<t.length;++n)for(let r=n+1;r<t.length;++r){const i=t8(t[n],t[r]);for(let a=0;a<i.length;++a){const o=i[a];o.parentIndex=[n,r],e.push(o)}}return e}function DE(t,e){return t*t*Math.acos(1-e/t)-(t-e)*Math.sqrt(e*(2*t-e))}function U0(t,e){return Math.sqrt((t.x-e.x)*(t.x-e.x)+(t.y-e.y)*(t.y-e.y))}function J6(t,e,n){if(n>=t+e)return 0;if(n<=Math.abs(t-e))return Math.PI*Math.min(t,e)*Math.min(t,e);const r=t-(n*n-e*e+t*t)/(2*n),i=e-(n*n-t*t+e*e)/(2*n);return DE(t,r)+DE(e,i)}function t8(t,e){const n=U0(t,e),r=t.radius,i=e.radius;if(n>=r+i||n<=Math.abs(r-i))return[];const a=(r*r-i*i+n*n)/(2*n),o=Math.sqrt(r*r-a*a),s=t.x+a*(e.x-t.x)/n,c=t.y+a*(e.y-t.y)/n,l=-(e.y-t.y)*(o/n),u=-(e.x-t.x)*(o/n);return[{x:s+l,y:c-u},{x:s-l,y:c+u}]}function Dnt(t){const e={x:0,y:0};for(let n=0;n<t.length;++n)e.x+=t[n].x,e.y+=t[n].y;return e.x/=t.length,e.y/=t.length,e}function jnt(t,e){e=e||{},e.maxIterations=e.maxIterations||500;const n=e.initialLayout||Wnt,r=e.lossFunction||FE;t=Fnt(t);const i=n(t,e),a=[],o=[];let s;for(s in i)i.hasOwnProperty(s)&&(a.push(i[s].x),a.push(i[s].y),o.push(s));const l=(0,gc.nelderMead)(function(u){const f={};for(let d=0;d<o.length;++d){const h=o[d];f[h]={x:u[2*d],y:u[2*d+1],radius:i[h].radius}}return r(f,t)},a,e).x;for(let u=0;u<o.length;++u)s=o[u],i[s].x=l[2*u],i[s].y=l[2*u+1];return i}const e8=1e-10;function jE(t,e,n){return Math.min(t,e)*Math.min(t,e)*Math.PI<=n+e8?Math.abs(t-e):(0,gc.bisect)(function(r){return J6(t,e,r)-n},0,t+e)}function Fnt(t){t=t.slice();const e=[],n={};let r,i,a,o;for(r=0;r<t.length;++r){const s=t[r];s.sets.length==1?e.push(s.sets[0]):s.sets.length==2&&(a=s.sets[0],o=s.sets[1],n[[a,o]]=!0,n[[o,a]]=!0)}for(e.sort((s,c)=>s>c?1:-1),r=0;r<e.length;++r)for(a=e[r],i=r+1;i<e.length;++i)o=e[i],[a,o]in n||t.push({sets:[a,o],size:0});return t}function Bnt(t,e,n){const r=(0,gc.zerosM)(e.length,e.length),i=(0,gc.zerosM)(e.length,e.length);return t.filter(function(a){return a.sets.length==2}).map(function(a){const o=n[a.sets[0]],s=n[a.sets[1]],c=Math.sqrt(e[o].size/Math.PI),l=Math.sqrt(e[s].size/Math.PI),u=jE(c,l,a.size);r[o][s]=r[s][o]=u;let f=0;a.size+1e-10>=Math.min(e[o].size,e[s].size)?f=1:a.size<=1e-10&&(f=-1),i[o][s]=i[s][o]=f}),{distances:r,constraints:i}}function znt(t,e,n,r){let i=0,a;for(a=0;a<e.length;++a)e[a]=0;for(a=0;a<n.length;++a){const o=t[2*a],s=t[2*a+1];for(let c=a+1;c<n.length;++c){const l=t[2*c],u=t[2*c+1],f=n[a][c],d=r[a][c],h=(l-o)*(l-o)+(u-s)*(u-s),v=Math.sqrt(h),g=h-f*f;d>0&&v<=f||d<0&&v>=f||(i+=2*g*g,e[2*a]+=4*g*(o-l),e[2*a+1]+=4*g*(s-u),e[2*c]+=4*g*(l-o),e[2*c+1]+=4*g*(u-s))}}return i}function Wnt(t,e){let n=$nt(t,e);const r=e.lossFunction||FE;if(t.length>=8){const i=Gnt(t,e),a=r(i,t),o=r(n,t);a+1e-8<o&&(n=i)}return n}function Gnt(t,e){e=e||{};const n=e.restarts||10,r=[],i={};let a;for(a=0;a<t.length;++a){const g=t[a];g.sets.length==1&&(i[g.sets[0]]=r.length,r.push(g))}const o=Bnt(t,r,i);let s=o.distances;const c=o.constraints,l=(0,gc.norm2)(s.map(gc.norm2))/s.length;s=s.map(function(g){return g.map(function(y){return y/l})});const u=function(g,y){return znt(g,y,s,c)};let f,d;for(a=0;a<n;++a){const g=(0,gc.zeros)(s.length*2).map(Math.random);d=(0,gc.conjugateGradient)(u,g,e),(!f||d.fx<f.fx)&&(f=d)}const h=f.x,v={};for(a=0;a<r.length;++a){const g=r[a];v[g.sets[0]]={x:h[2*a]*l,y:h[2*a+1]*l,radius:Math.sqrt(g.size/Math.PI)}}if(e.history)for(a=0;a<e.history.length;++a)(0,gc.scale)(e.history[a].x,l);return v}function $nt(t,e){const n=e&&e.lossFunction?e.lossFunction:FE,r={},i={};let a;for(let f=0;f<t.length;++f){const d=t[f];d.sets.length==1&&(a=d.sets[0],r[a]={x:1e10,y:1e10,rowid:Object.keys(r).length,size:d.size,radius:Math.sqrt(d.size/Math.PI)},i[a]=[])}t=t.filter(function(f){return f.sets.length==2});for(let f=0;f<t.length;++f){const d=t[f];let h=d.hasOwnProperty("weight")?d.weight:1;const v=d.sets[0],g=d.sets[1];d.size+e8>=Math.min(r[v].size,r[g].size)&&(h=0),i[v].push({set:g,size:d.size,weight:h}),i[g].push({set:v,size:d.size,weight:h})}const o=[];for(a in i)if(i.hasOwnProperty(a)){let f=0;for(let d=0;d<i[a].length;++d)f+=i[a][d].size*i[a][d].weight;o.push({set:a,size:f})}function s(f,d){return d.size-f.size}o.sort(s);const c={};function l(f){return f.set in c}function u(f,d){r[d].x=f.x,r[d].y=f.y,c[d]=!0}u({x:0,y:0},o[0].set);for(let f=1;f<o.length;++f){const d=o[f].set,h=i[d].filter(l);if(a=r[d],h.sort(s),h.length===0)throw"ERROR: missing pairwise overlap information";const v=[];for(let b=0;b<h.length;++b){const x=r[h[b].set],_=jE(a.radius,x.radius,h[b].size);v.push({x:x.x+_,y:x.y}),v.push({x:x.x-_,y:x.y}),v.push({y:x.y+_,x:x.x}),v.push({y:x.y-_,x:x.x});for(let w=b+1;w<h.length;++w){const O=r[h[w].set],E=jE(a.radius,O.radius,h[w].size),M=t8({x:x.x,y:x.y,radius:_},{x:O.x,y:O.y,radius:E});for(let k=0;k<M.length;++k)v.push(M[k])}}let g=1e50,y=v[0];for(let b=0;b<v.length;++b){r[d].x=v[b].x,r[d].y=v[b].y;const x=n(r,t);x<g&&(g=x,y=v[b])}u(y,d)}return r}function FE(t,e){let n=0;function r(i){return i.map(function(a){return t[a]})}for(let i=0;i<e.length;++i){const a=e[i];let o;if(a.sets.length==1)continue;if(a.sets.length==2){const c=t[a.sets[0]],l=t[a.sets[1]];o=J6(c.radius,l.radius,U0(c,l))}else o=Q6(r(a.sets));const s=a.hasOwnProperty("weight")?a.weight:1;n+=s*(o-a.size)*(o-a.size)}return n}function Znt(t,e,n){n===null?t.sort(function(i,a){return a.radius-i.radius}):t.sort(n);let r;if(t.length>0){const i=t[0].x,a=t[0].y;for(r=0;r<t.length;++r)t[r].x-=i,t[r].y-=a}if(t.length==2&&distance(t[0],t[1])<Math.abs(t[1].radius-t[0].radius)&&(t[1].x=t[0].x+t[0].radius-t[1].radius-1e-10,t[1].y=t[0].y),t.length>1){const i=Math.atan2(t[1].x,t[1].y)-e;let a,o;const s=Math.cos(i),c=Math.sin(i);for(r=0;r<t.length;++r)a=t[r].x,o=t[r].y,t[r].x=s*a-c*o,t[r].y=c*a+s*o}if(t.length>2){let i=Math.atan2(t[2].x,t[2].y)-e;for(;i<0;)i+=2*Math.PI;for(;i>2*Math.PI;)i-=2*Math.PI;if(i>Math.PI){const a=t[1].y/(1e-10+t[1].x);for(r=0;r<t.length;++r){const o=(t[r].x+a*t[r].y)/(1+a*a);t[r].x=2*o-t[r].x,t[r].y=2*o*a-t[r].y}}}}function Ynt(t){t.map(function(o){o.parent=o});function e(o){return o.parent!==o&&(o.parent=e(o.parent)),o.parent}function n(o,s){const c=e(o),l=e(s);c.parent=l}for(let o=0;o<t.length;++o)for(let s=o+1;s<t.length;++s){const c=t[o].radius+t[s].radius;distance(t[o],t[s])+1e-10<c&&n(t[s],t[o])}const r={};let i;for(let o=0;o<t.length;++o)i=e(t[o]).parent.setid,i in r||(r[i]=[]),r[i].push(t[o]);t.map(function(o){delete o.parent});const a=[];for(i in r)r.hasOwnProperty(i)&&a.push(r[i]);return a}function BE(t){const e=function(n){const r=Math.max.apply(null,t.map(function(a){return a[n]+a.radius})),i=Math.min.apply(null,t.map(function(a){return a[n]-a.radius}));return{max:r,min:i}};return{xRange:e("x"),yRange:e("y")}}function Jot(t,e,n){e===null&&(e=Math.PI/2);let r=[],i,a;for(a in t)if(t.hasOwnProperty(a)){const d=t[a];r.push({x:d.x,y:d.y,radius:d.radius,setid:a})}const o=Ynt(r);for(i=0;i<o.length;++i){Znt(o[i],e,n);const d=BE(o[i]);o[i].size=(d.xRange.max-d.xRange.min)*(d.yRange.max-d.yRange.min),o[i].bounds=d}o.sort(function(d,h){return h.size-d.size}),r=o[0];let s=r.bounds;const c=(s.xRange.max-s.xRange.min)/50;function l(d,h,v){if(!d)return;const g=d.bounds;let y,b,x;h?y=s.xRange.max-g.xRange.min+c:(y=s.xRange.max-g.xRange.max,x=(g.xRange.max-g.xRange.min)/2-(s.xRange.max-s.xRange.min)/2,x<0&&(y+=x)),v?b=s.yRange.max-g.yRange.min+c:(b=s.yRange.max-g.yRange.max,x=(g.yRange.max-g.yRange.min)/2-(s.yRange.max-s.yRange.min)/2,x<0&&(b+=x));for(let _=0;_<d.length;++_)d[_].x+=y,d[_].y+=b,r.push(d[_])}let u=1;for(;u<o.length;)l(o[u],!0,!1),l(o[u+1],!1,!0),l(o[u+2],!0,!0),u+=3,s=BE(r);const f={};for(i=0;i<r.length;++i)f[r[i].setid]=r[i];return f}function Hnt(t,e,n,r){const i=[],a=[];for(const g in t)t.hasOwnProperty(g)&&(a.push(g),i.push(t[g]));e-=2*r,n-=2*r;const o=BE(i),s=o.xRange,c=o.yRange;if(s.max==s.min||c.max==c.min)return console.log("not scaling solution: zero size detected"),t;const l=e/(s.max-s.min),u=n/(c.max-c.min),f=Math.min(u,l),d=(e-(s.max-s.min)*f)/2,h=(n-(c.max-c.min)*f)/2,v={};for(let g=0;g<i.length;++g){const y=i[g];v[a[g]]={radius:f*y.radius,x:r+d+(y.x-s.min)*f,y:r+h+(y.y-c.min)*f}}return v}function Vnt(t,e,n){const r=[],i=t-n,a=e;return r.push("M",i,a),r.push("A",n,n,0,1,0,i+2*n,a),r.push("A",n,n,0,1,0,i,a),r.join(" ")}function Xnt(t){const e={};Q6(t,e);const n=e.arcs;if(n.length===0)return"M 0 0";if(n.length==1){const r=n[0].circle;return Vnt(r.x,r.y,r.radius)}else{const r=[`
M`,n[0].p2.x,n[0].p2.y];for(let i=0;i<n.length;++i){const a=n[i],o=a.circle.radius,s=a.width>o;r.push(`
A`,o,o,0,s?1:0,1,a.p1.x,a.p1.y)}return r.join(" ")}}const n8=t=>{const{sets:e="sets",size:n="size",as:r=["key","path"],padding:i=0}=t,[a,o]=r;return s=>{const c=s.map(f=>Object.assign(Object.assign({},f),{sets:f[e],size:f[n],[a]:f.sets.join("&")}));c.sort((f,d)=>f.sets.length-d.sets.length);const l=jnt(c);let u;return c.map(f=>{const d=f[e],h=({width:v,height:g})=>{u=u||Hnt(l,v,g,i);const y=d.map(x=>u[x]);let b=Xnt(y);return/[zZ]$/.test(b)||(b+=" Z"),b};return Object.assign(Object.assign({},f),{[o]:h})})}};n8.props={};function Unt(){return{"data.venn":n8,"mark.boxplot":W6,"mark.gauge":Z6,"mark.wordCloud":HO,"mark.liquid":q6}}function qnt(){return Object.assign(Object.assign(Object.assign(Object.assign({},att()),unt()),Unt()),eJ())}var fb=function(){return fb=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},fb.apply(this,arguments)},Knt=PY(TY,fb(fb({},qnt()),pH())),q0=function(){return q0=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},q0.apply(this,arguments)},Qnt=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n},Jnt=["renderer"],r8=["width","height","autoFit","theme","inset","insetLeft","insetRight","insetTop","insetBottom","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","depth","title","clip","children","type","data","direction"],zE="__transform__",trt="__skipDelCustomKeys__",Bu=function(t,e){return(0,rt.isBoolean)(e)?{type:t,available:e}:q0({type:t},e)},WE={xField:"encode.x",yField:"encode.y",colorField:"encode.color",angleField:"encode.y",keyField:"encode.key",sizeField:"encode.size",shapeField:"encode.shape",seriesField:"encode.series",positionField:"encode.position",textField:"encode.text",valueField:"encode.value",binField:"encode.x",srcField:"encode.src",linkColorField:"encode.linkColor",fontSizeField:"encode.fontSize",radius:"coordinate.outerRadius",innerRadius:"coordinate.innerRadius",startAngle:"coordinate.startAngle",endAngle:"coordinate.endAngle",focusX:"coordinate.focusX",focusY:"coordinate.focusY",distortionX:"coordinate.distortionX",distortionY:"coordinate.distortionY",visual:"coordinate.visual",stack:{target:"transform",value:function(t){return Bu("stackY",t)}},normalize:{target:"transform",value:function(t){return Bu("normalizeY",t)}},percent:{target:"transform",value:function(t){return Bu("normalizeY",t)}},group:{target:"transform",value:function(t){return Bu("dodgeX",t)}},sort:{target:"transform",value:function(t){return Bu("sortX",t)}},symmetry:{target:"transform",value:function(t){return Bu("symmetryY",t)}},diff:{target:"transform",value:function(t){return Bu("diffY",t)}},meta:{target:"scale",value:function(t){return t}},label:{target:"labels",value:function(t){return t}},shape:"style.shape",connectNulls:{target:"style",value:function(t){return(0,rt.isBoolean)(t)?{connect:t}:t}}},GE=["xField","yField","seriesField","colorField","keyField","positionField","meta","tooltip","animate","stack","normalize","percent","group","sort","symmetry","diff"],db=[{key:"annotations",extend_keys:[]},{key:"line",type:"line",extend_keys:GE},{key:"point",type:"point",extend_keys:GE},{key:"area",type:"area",extend_keys:GE}],ert=[{key:"transform",callback:function(t,e,n){var r;t[e]=t[e]||[];var i=n.available,a=i===void 0?!0:i,o=Qnt(n,["available"]);if(a)t[e].push(q0((r={},r[zE]=!0,r),o));else{var s=t[e].indexOf(function(c){return c.type===n.type});s!==-1&&t[e].splice(s,1)}}},{key:"labels",callback:function(t,e,n){var r;if(!n||(0,rt.isArray)(n)){t[e]=n||[];return}n.text||(n.text=t.yField),t[e]=t[e]||[],t[e].push(q0((r={},r[zE]=!0,r),n))}}],$E=[{key:"conversionTag",shape:"ConversionTag"},{key:"axisText",shape:"BidirectionalBarAxisText"}],nrt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),hb=function(){return hb=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},hb.apply(this,arguments)},rrt=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n},irt=function(t){nrt(e,t);function e(n){n===void 0&&(n={});var r=n.style,i=rrt(n,["style"]);return t.call(this,hb({style:hb({fill:"#eee"},r)},i))||this}return e}(cu),art=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),pb=function(){return pb=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},pb.apply(this,arguments)},ort=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n},i8=function(t){art(e,t);function e(n){n===void 0&&(n={});var r=n.style,i=ort(n,["style"]);return t.call(this,pb({style:pb({text:"",fontSize:12,textBaseline:"middle",textAlign:"center",fill:"#000",fontStyle:"normal",fontVariant:"normal",fontWeight:"normal",lineWidth:1},r)},i))||this}return e}(po),a8=function(t,e,n){if(n||arguments.length===2)for(var r=0,i=e.length,a;r<i;r++)(a||!(r in e))&&(a||(a=Array.prototype.slice.call(e,0,r)),a[r]=e[r]);return t.concat(a||Array.prototype.slice.call(e))},srt=function(t,e){if((0,rt.isArray)(e))return e},_l=function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];return rt.mergeWith.apply(void 0,a8(a8([],t,!1),[srt],!1))},crt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),o8=function(t){crt(e,t);function e(n,r,i){var a=t.call(this,{style:_l(i,r)})||this;return a.chart=n,a}return e.prototype.connectedCallback=function(){this.render(this.attributes,this),this.bindEvents(this.attributes,this)},e.prototype.disconnectedCallback=function(){},e.prototype.attributeChangedCallback=function(n){},e.prototype.update=function(n,r){var i;return this.attr(_l({},this.attributes,n||{})),(i=this.render)===null||i===void 0?void 0:i.call(this,this.attributes,this,r)},e.prototype.clear=function(){this.removeChildren()},e.prototype.getElementsLayout=function(){var n=this.chart.getContext().canvas,r=n.document.getElementsByClassName("element"),i=[];return r.forEach(function(a){var o=a.getBBox(),s=o.x,c=o.y,l=o.width,u=o.height,f=a.__data__;i.push({bbox:o,x:s,y:c,width:l,height:u,key:f.key,data:f})}),i},e.prototype.bindEvents=function(n,r){},e}(mp),lrt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),vb=function(){return vb=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},vb.apply(this,arguments)},urt=function(t){lrt(e,t);function e(n,r){return t.call(this,n,r,{type:e.tag})||this}return e.prototype.getConversionTagLayout=function(){var n=this.direction==="vertical",r=this.getElementsLayout(),i=r[0],a=i.x,o=i.y,s=i.height,c=i.width,l=i.data,u=["items",0,"value"],f=(0,rt.get)(l,u),d=n?r[1].y-o-s:r[1].x-a-c,h=[],v=this.attributes,g=v.size,y=g===void 0?40:g,b=v.arrowSize,x=b===void 0?20:b,_=v.spacing,w=_===void 0?4:_;return r.forEach(function(O,E){if(E>0){var M=O.x,k=O.y,A=O.height,P=O.width,C=O.data,N=O.key,L=(0,rt.get)(C,u),R=y/2;if(n){var I=M+P/2,D=k;h.push({points:[[I+R,D-d+w],[I+R,D-x-w],[I,D-w],[I-R,D-x-w],[I-R,D-d+w]],center:[I,D-d/2-w],width:d,value:[f,L],key:N})}else{var I=M,D=k+A/2;h.push({points:[[M-d+w,D-R],[M-x-w,D-R],[I-w,D],[M-x-w,D+R],[M-d+w,D+R]],center:[I-d/2-w,D],width:d,value:[f,L],key:N})}f=L}}),h},e.prototype.render=function(){this.setDirection(),this.drawConversionTag()},e.prototype.setDirection=function(){var n=this.chart.getCoordinate(),r=(0,rt.get)(n,"options.transformations"),i="horizontal";r.forEach(function(a){a.includes("transpose")&&(i="vertical")}),this.direction=i},e.prototype.drawConversionTag=function(){var n=this,r=this.getConversionTagLayout(),i=this.attributes,a=i.style,o=i.text,s=o.style,c=o.formatter;r.forEach(function(l){var u=l.points,f=l.center,d=l.value,h=l.key,v=d[0],g=d[1],y=f[0],b=f[1],x=new irt({style:vb({points:u,fill:"#eee"},a),id:"polygon-".concat(h)}),_=new i8({style:vb({x:y,y:b,text:(0,rt.isFunction)(c)?c(v,g):(g/v*100).toFixed(2)+"%"},s),id:"text-".concat(h)});n.appendChild(x),n.appendChild(_)})},e.prototype.update=function(){var n=this,r=this.getConversionTagLayout();r.forEach(function(i){var a=i.points,o=i.center,s=i.key,c=o[0],l=o[1],u=n.getElementById("polygon-".concat(s)),f=n.getElementById("text-".concat(s));u.setAttribute("points",a),f.setAttribute("x",c),f.setAttribute("y",l)})},e.tag="ConversionTag",e}(o8),ZE=32,s8=16,c8=48,frt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),K0=function(){return K0=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},K0.apply(this,arguments)},drt=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n},hrt=function(t){frt(e,t);function e(n,r){return t.call(this,n,r,{type:e.tag})||this}return e.prototype.render=function(){this.drawText()},e.prototype.getBidirectionalBarAxisTextLayout=function(){var n=this.attributes.layout,r=n==="vertical",i=this.getElementsLayout(),a=r?(0,rt.uniqBy)(i,"x"):(0,rt.uniqBy)(i,"y"),o=["title"],s=[],c=this.chart.getContext().views,l=(0,rt.get)(c,[0,"layout"]),u=l.width,f=l.height;return a.forEach(function(d){var h=d.x,v=d.y,g=d.height,y=d.width,b=d.data,x=d.key,_=(0,rt.get)(b,o);r?s.push({x:h+y/2,y:f,text:_,key:x}):s.push({x:u,y:v+g/2,text:_,key:x})}),(0,rt.uniqBy)(s,"text").length!==s.length&&(s=Object.values((0,rt.groupBy)(s,"text")).map(function(d){var h,v=d.reduce(function(g,y){return g+(r?y.x:y.y)},0);return K0(K0({},d[0]),(h={},h[r?"x":"y"]=v/d.length,h))})),s},e.prototype.transformLabelStyle=function(n){var r={},i=/^label[A-Z]/;return Object.keys(n).forEach(function(a){i.test(a)&&(r[a.replace("label","").replace(/^[A-Z]/,function(o){return o.toLowerCase()})]=n[a])}),r},e.prototype.drawText=function(){var n=this,r=this.getBidirectionalBarAxisTextLayout(),i=this.attributes,a=i.layout,o=i.labelFormatter,s=drt(i,["layout","labelFormatter"]);r.forEach(function(c){var l=c.x,u=c.y,f=c.text,d=c.key,h=new i8({style:K0({x:l,y:u,text:(0,rt.isFunction)(o)?o(f):f,wordWrap:!0,wordWrapWidth:a==="horizontal"?ZE*2:120,maxLines:2,textOverflow:"ellipsis"},n.transformLabelStyle(s)),id:"text-".concat(d)});n.appendChild(h)})},e.prototype.destroy=function(){this.clear()},e.prototype.update=function(){this.destroy(),this.drawText()},e.tag="BidirectionalBarAxisText",e}(o8),prt={ConversionTag:urt,BidirectionalBarAxisText:hrt},vrt=function(){function t(e,n){this.container=new Map,this.chart=e,this.config=n,this.init()}return t.prototype.init=function(){var e=this;$E.forEach(function(n){var r,i=n.key,a=n.shape,o=e.config[i];if(o){var s=new prt[a](e.chart,o),c=e.chart.getContext().canvas;c.appendChild(s),e.container.set(i,s)}else(r=e.container.get(i))===null||r===void 0||r.clear()})},t.prototype.update=function(){var e=this;this.container.size&&$E.forEach(function(n){var r=n.key,i=e.container.get(r);i==null||i.update()})},t}(),grt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Nd=function(){return Nd=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},Nd.apply(this,arguments)},l8="data-chart-source-type",On=function(t){grt(e,t);function e(n,r){var i=t.call(this)||this;return i.container=typeof n=="string"?document.getElementById(n):n,i.options=i.mergeOption(r),i.createG2(),i.bindEvents(),i}return e.prototype.getChartOptions=function(){return Nd(Nd({},(0,rt.pick)(this.options,Jnt)),{container:this.container})},e.prototype.getSpecOptions=function(){return this.type==="base"||this[trt]?Nd(Nd({},this.options),this.getChartOptions()):this.options},e.prototype.createG2=function(){if(!this.container)throw Error("The container is not initialized!");this.chart=new Knt(this.getChartOptions()),this.container.setAttribute(l8,"Ant Design Charts")},e.prototype.bindEvents=function(){var n=this;this.chart&&this.chart.on("*",function(r){r!=null&&r.type&&n.emit(r.type,r)})},e.prototype.getBaseOptions=function(){return{type:"view",autoFit:!0}},e.prototype.getDefaultOptions=function(){},e.prototype.render=function(){var n=this;this.type!=="base"&&this.execAdaptor(),this.chart.options(this.getSpecOptions()),this.chart.render().then(function(){n.annotation=new vrt(n.chart,n.options)}),this.bindSizeSensor()},e.prototype.update=function(n){this.options=this.mergeOption(n)},e.prototype.mergeOption=function(n){return _l({},this.getBaseOptions(),this.getDefaultOptions(),n)},e.prototype.changeData=function(n){this.chart.changeData(n)},e.prototype.changeSize=function(n,r){this.chart.changeSize(n,r)},e.prototype.destroy=function(){this.chart.destroy(),this.off(),this.container.removeAttribute(l8)},e.prototype.execAdaptor=function(){var n=this.getSchemaAdaptor();n({chart:this.chart,options:this.options})},e.prototype.triggerResize=function(){this.chart.forceFit()},e.prototype.bindSizeSensor=function(){var n=this,r=this.options.autoFit,i=r===void 0?!0:r;i&&this.chart.on(In.AFTER_CHANGE_SIZE,function(){n.annotation.update()})},e}(Ts),yrt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),mrt=function(t){yrt(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="base",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"line"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return function(n){return n}},e}(On),brt=function(t){var e=t.options,n=e.children,r=n===void 0?[]:n;return r.forEach(function(i){Object.keys(i).forEach(function(a){(0,rt.isArray)(i[a])&&a!=="data"&&(i[a]=i[a].filter(function(o){return!o[zE]}))})}),e},u8=function(t,e,n){if(n||arguments.length===2)for(var r=0,i=e.length,a;r<i;r++)(a||!(r in e))&&(a||(a=Array.prototype.slice.call(e,0,r)),a[r]=e[r]);return t.concat(a||Array.prototype.slice.call(e))},xrt=function(t){var e=t.children,n=e===void 0?[]:e,r=Object.keys(WE).concat(db.map(function(i){return i.key}));return r.forEach(function(i){delete t[i]}),n.forEach(function(i){Object.keys(i).forEach(function(a){r.includes(a)&&delete i[a]})}),Object.keys(t).forEach(function(i){u8(u8([],r8,!0),$E.map(function(a){return a.key}),!0).includes(i)||delete t[i]}),t},jn=function(t){var e=brt(t),n=e.children,r=n===void 0?[]:n,i=(0,rt.omit)(e,[].concat(r8,db.map(function(l){return l.key}))),a=function(l){var u;return(u=ert.find(function(f){return f.key===l}))===null||u===void 0?void 0:u.callback},o=function(l,u,f){var d=a(u);d?d(l,u,f):l[u]=_l({},l[u],f)},s=function(l){Object.keys(l).forEach(function(u){if(l[u]){var f=db.find(function(v){return v.key===u});if(f){var d=f.type,h=f.extend_keys;d?r.push(c(_l({},(0,rt.pick)(l,h),{type:d},l[u]))):(0,rt.isArray)(l[u])&&l[u].forEach(function(v){r.push(c(v))})}}})},c=function(l){return s(l),Object.keys(WE).forEach(function(u){var f=WE[u];if(!(0,rt.isUndefined)(l[u]))if((0,rt.isObject)(f)){var d=f.value,h=f.target,v=d(l[u]);o(l,h,v)}else(0,rt.set)(l,f,l[u])}),l};return r.forEach(function(l){var u=_l({},i,l);c(_l(l,u))}),s(e),xrt(e),t},YE=function(){return YE=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},YE.apply(this,arguments)};function _rt(t){var e=t.options,n=e.stack,r=e.tooltip,i=e.xField;if(!n)return t;var a=db.map(function(s){return s.type}).filter(function(s){return!!s}),o=!1;return a.forEach(function(s){e[s]&&(o=!0,(0,rt.set)(e,[s,"stack"],YE({y1:"y"},typeof n=="object"?n:{})))}),o&&!(0,rt.isBoolean)(r)&&!r&&(0,rt.set)(e,"tooltip",{title:i,items:[{channel:"y"}]}),t}function Tr(t){return(0,rt.flow)(_rt)(t)}function wrt(t){return(0,rt.flow)(Tr,jn)(t)}var Ort=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Srt=function(t){Ort(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="area",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"area"}],scale:{y:{nice:!0}},axis:{y:{title:!1},x:{title:!1}},interaction:{tooltip:{shared:!0}}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return wrt},e}(On),Id=function(){return Id=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},Id.apply(this,arguments)};function f8(t){var e=function(n){var r=n.options;(0,rt.get)(r,"children.length")>1&&(0,rt.set)(r,"children",[{type:"interval"}]);var i=r.scale,a=r.markBackground,o=r.data,s=r.children,c=r.yField,l=(0,rt.get)(i,"y.domain",[]);if(a&&l.length&&(0,rt.isArray)(o)){var u="domainMax",f=o.map(function(d){var h;return Id(Id({originData:Id({},d)},(0,rt.omit)(d,c)),(h={},h[u]=l[l.length-1],h))});s.unshift(Id({type:"interval",data:f,yField:u,tooltip:!1,style:{fill:"#eee"},label:!1},a))}return n};return(0,rt.flow)(e,Tr,jn)(t)}var Ert=function(){var t=function(e,n){return function(r){var i=e.fill,a=i===void 0?"#2888FF":i,o=e.stroke,s=e.fillOpacity,c=s===void 0?1:s,l=e.strokeOpacity,u=l===void 0?.2:l,f=e.pitch,d=f===void 0?8:f,h=r[0],v=r[1],g=r[2],y=r[3],b=(v[1]-h[1])/2,x=n.document,_=x.createElement("g",{}),w=x.createElement("polygon",{style:{points:[h,[h[0]-d,h[1]+b],[g[0]-d,h[1]+b],y],fill:a,fillOpacity:c,stroke:o,strokeOpacity:u,inset:30}}),O=x.createElement("polygon",{style:{points:[[h[0]-d,h[1]+b],v,g,[g[0]-d,h[1]+b]],fill:a,fillOpacity:c,stroke:o,strokeOpacity:u}}),E=x.createElement("polygon",{style:{points:[h,[h[0]-d,h[1]+b],v,[h[0]+d,h[1]+b]],fill:a,fillOpacity:c-.2}});return _.appendChild(w),_.appendChild(O),_.appendChild(E),_}};oA("shape.interval.bar25D",t)},Mrt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}();Ert();var krt=function(t){Mrt(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="Bar",n}return e.getDefaultOptions=function(){return{type:"view",coordinate:{transform:[{type:"transpose"}]},children:[{type:"interval"}],scale:{y:{nice:!0}},axis:{y:{title:!1},x:{title:!1}},interaction:{tooltip:{shared:!0},elementHighlight:{background:!0}}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return f8},e}(On),Art=function(){var t=function(e,n){return function(r){var i=e.fill,a=i===void 0?"#2888FF":i,o=e.stroke,s=e.fillOpacity,c=s===void 0?1:s,l=e.strokeOpacity,u=l===void 0?.2:l,f=e.pitch,d=f===void 0?8:f,h=r[1][0]-r[0][0],v=h/2+r[0][0],g=n.document,y=g.createElement("g",{}),b=g.createElement("polygon",{style:{points:[[r[0][0],r[0][1]],[v,r[1][1]+d],[v,r[3][1]+d],[r[3][0],r[3][1]]],fill:a,fillOpacity:c,stroke:o,strokeOpacity:u,inset:30}}),x=g.createElement("polygon",{style:{points:[[v,r[1][1]+d],[r[1][0],r[1][1]],[r[2][0],r[2][1]],[v,r[2][1]+d]],fill:a,fillOpacity:c,stroke:o,strokeOpacity:u}}),_=g.createElement("polygon",{style:{points:[[r[0][0],r[0][1]],[v,r[1][1]-d],[r[1][0],r[1][1]],[v,r[1][1]+d]],fill:a,fillOpacity:c-.2}});return y.appendChild(x),y.appendChild(b),y.appendChild(_),y}};oA("shape.interval.column25D",t)},Trt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}();Art();var Prt=function(t){Trt(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="column",n}return e.getDefaultOptions=function(){return{type:"view",scale:{y:{nice:!0}},interaction:{tooltip:{shared:!0},elementHighlight:{background:!0}},axis:{y:{title:!1},x:{title:!1}},children:[{type:"interval"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return f8},e}(On);function Crt(t){var e=function(r){var i=r.options,a=i.children,o=a===void 0?[]:a,s=i.legend;return s&&o.forEach(function(c){if(!(0,rt.get)(c,"colorField")){var l=(0,rt.get)(c,"yField");(0,rt.set)(c,"colorField",function(){return l})}}),r},n=function(r){var i=r.options,a=i.annotations,o=a===void 0?[]:a,s=i.children,c=s===void 0?[]:s,l=i.scale,u=!1;return(0,rt.get)(l,"y.key")||c.forEach(function(f,d){if(!(0,rt.get)(f,"scale.y.key")){var h="child".concat(d,"Scale");(0,rt.set)(f,"scale.y.key",h);var v=f.annotations,g=v===void 0?[]:v;g.length>0&&((0,rt.set)(f,"scale.y.independent",!1),g.forEach(function(y){(0,rt.set)(y,"scale.y.key",h)})),!u&&o.length>0&&(0,rt.get)(f,"scale.y.independent")===void 0&&(u=!0,(0,rt.set)(f,"scale.y.independent",!1),o.forEach(function(y){(0,rt.set)(y,"scale.y.key",h)}))}}),r};return(0,rt.flow)(e,n,Tr,jn)(t)}var Lrt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),d8=function(t){Lrt(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="DualAxes",n}return e.getDefaultOptions=function(){return{type:"view",axis:{y:{title:!1,tick:!1},x:{title:!1}},scale:{y:{independent:!0,nice:!0}}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Crt},e}(On);function Rrt(t){var e=function(a){var o=a.options,s=o.xField,c=o.colorField;return c||(0,rt.set)(o,"colorField",s),a},n=function(a){var o=a.options,s=o.compareField,c=o.transform,l=o.isTransposed,u=l===void 0?!0:l,f=o.coordinate;return c||(s?(0,rt.set)(o,"transform",[]):(0,rt.set)(o,"transform",[{type:"symmetryY"}])),!f&&u&&(0,rt.set)(o,"coordinate",{transform:[{type:"transpose"}]}),a},r=function(a){var o=a.options,s=o.compareField,c=o.seriesField,l=o.data,u=o.children,f=o.yField,d=o.isTransposed,h=d===void 0?!0:d;if(s||c){var v=Object.values((0,rt.groupBy)(l,function(g){return g[s||c]}));u[0].data=v[0],u.push({type:"interval",data:v[1],yField:function(g){return-g[f]}}),delete o.compareField,delete o.data}return c&&((0,rt.set)(o,"type","spaceFlex"),(0,rt.set)(o,"ratio",[1,1]),(0,rt.set)(o,"direction",h?"row":"col"),delete o.seriesField),a},i=function(a){var o=a.options,s=o.tooltip,c=o.xField,l=o.yField;return s||(0,rt.set)(o,"tooltip",{title:!1,items:[function(u){return{name:u[c],value:u[l]}}]}),a};return(0,rt.flow)(e,n,r,i,Tr,jn)(t)}var Nrt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Irt=function(t){Nrt(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="column",n}return e.getDefaultOptions=function(){return{type:"view",scale:{x:{padding:0}},animate:{enter:{type:"fadeIn"}},axis:!1,shapeField:"funnel",label:{position:"inside",transform:[{type:"contrastReverse"}]},children:[{type:"interval"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Rrt},e}(On);function Drt(t){return(0,rt.flow)(Tr,jn)(t)}var jrt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Frt=function(t){jrt(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="line",n}return e.getDefaultOptions=function(){return{type:"view",scale:{y:{nice:!0}},interaction:{tooltip:{shared:!0}},axis:{y:{title:!1},x:{title:!1}},children:[{type:"line"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Drt},e}(On);function Q0(t){switch(typeof t){case"function":return t;case"string":return function(e){return(0,rt.get)(e,[t])};default:return function(){return t}}}var Po=function(){return Po=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},Po.apply(this,arguments)};function Brt(t){var e=function(n){var r=n.options,i=r.angleField,a=r.data,o=r.label,s=r.tooltip,c=r.colorField,l=Q0(c);if((0,rt.isArray)(a)&&a.length>0){var u=a.reduce(function(d,h){return d+h[i]},0);if(u===0){var f=a.map(function(d){var h;return Po(Po({},d),(h={},h[i]=1,h))});(0,rt.set)(r,"data",f),o&&(0,rt.set)(r,"label",Po(Po({},o),{formatter:function(){return 0}})),s!==!1&&((0,rt.isFunction)(s)?(0,rt.set)(r,"tooltip",function(d,h,v){var g;return s(Po(Po({},d),(g={},g[i]=0,g)),h,v.map(function(y){var b;return Po(Po({},y),(b={},b[i]=0,b))}))}):(0,rt.set)(r,"tooltip",Po(Po({},s),{items:[function(d,h,v){return{name:l(d,h,v),value:0}}]})))}}return n};return(0,rt.flow)(e,jn)(t)}var zrt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Wrt=function(t){zrt(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="pie",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"interval"}],coordinate:{type:"theta"},transform:[{type:"stackY",reverse:!0}],animate:{enter:{type:"waveIn"}}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Brt},e}(On);function Grt(t){return(0,rt.flow)(Tr,jn)(t)}var $rt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Zrt=function(t){$rt(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="scatter",n}return e.getDefaultOptions=function(){return{axis:{y:{title:!1},x:{title:!1}},legend:{size:!1},children:[{type:"point"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Grt},e}(On);function Yrt(t){var e=function(n){return(0,rt.set)(n,"options.coordinate",{type:(0,rt.get)(n,"options.coordinateType","polar")}),n};return(0,rt.flow)(e,jn)(t)}var Hrt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Vrt=function(t){Hrt(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="radar",n}return e.getDefaultOptions=function(){return{axis:{x:{grid:!0,line:!0},y:{zIndex:1,title:!1,line:!0,nice:!0}},meta:{x:{padding:.5,align:0}},interaction:{tooltip:{style:{crosshairsLineDash:[4,4]}}},children:[{type:"line"}],coordinateType:"polar"}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Yrt},e}(On),yc=function(){return yc=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},yc.apply(this,arguments)},Xrt="__stock-range__",Urt="trend",qrt="up",Krt="down";function Qrt(t){var e=function(r){var i=r.options,a=i.data,o=i.yField;return r.options.data=(0,rt.map)(a,function(s){var c=s&&yc({},s);if(Array.isArray(o)&&c){var l=o[0],u=o[1],f=o[2],d=o[3];c[Urt]=c[l]<=c[u]?qrt:Krt,c[Xrt]=[c[l],c[u],c[f],c[d]]}return c}),r},n=function(r){var i=r.options,a=i.xField,o=i.yField,s=i.fallingFill,c=i.risingFill,l=o[0],u=o[1],f=o[2],d=o[3],h=Q0(a);return r.options.children=(0,rt.map)(r.options.children,function(v,g){var y=g===0;return yc(yc({},v),{tooltip:{title:function(b,x,_){var w=h(b,x,_);return w instanceof Date?w.toLocaleString():w},items:[{field:f},{field:d},{field:l},{field:u}]},encode:yc(yc({},v.encode||{}),{y:y?[f,d]:[l,u],color:function(b){return Math.sign(b[u]-b[l])}}),style:yc(yc({},v.style||{}),{lineWidth:y?1:10})})}),delete i.yField,r.options.legend={color:!1},s&&(0,rt.set)(r,"options.scale.color.range[0]",s),c&&(0,rt.set)(r,"options.scale.color.range[2]",c),r};return(0,rt.flow)(e,n,jn)(t)}var Jrt=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),tit=["#26a69a","#999999","#ef5350"],eit=function(t){Jrt(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="stock",n}return e.getDefaultOptions=function(){return{type:"view",scale:{color:{domain:[-1,0,1],range:tit},y:{nice:!0}},children:[{type:"link"},{type:"link"}],axis:{x:{title:!1,grid:!1},y:{title:!1,grid:!0,gridLineDash:null}},animate:{enter:{type:"scaleInY"}},interaction:{tooltip:{shared:!0,marker:!1,groupName:!1,crosshairs:!0}}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Qrt},e}(On);function nit(t){return(0,rt.flow)(Tr,jn)(t)}var rit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),iit=function(t){rit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="TinyLine",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"line",axis:!1}],animate:{enter:{type:"growInX",duration:500}},padding:0,margin:0,tooltip:!1}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return nit},e}(On);function ait(t){return(0,rt.flow)(Tr,jn)(t)}var oit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),sit=function(t){oit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="TinyArea",n}return e.getDefaultOptions=function(){return{type:"view",animate:{enter:{type:"growInX",duration:500}},children:[{type:"area",axis:!1}],padding:0,margin:0,tooltip:!1}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return ait},e}(On);function cit(t){return(0,rt.flow)(Tr,jn)(t)}var lit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),uit=function(t){lit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="TinyColumn",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"interval",axis:!1}],padding:0,margin:0,tooltip:!1}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return cit},e}(On),HE=function(){return HE=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},HE.apply(this,arguments)};function fit(t){var e=function(n){var r=n.options,i=r.percent,a=r.color,o=a===void 0?[]:a;if(!i)return n;var s={scale:{color:{range:o.length?o:[]}},data:[1,i]};return Object.assign(r,HE({},s)),n};return(0,rt.flow)(e,Tr,jn)(t)}var dit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),hit=function(t){dit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="TinyProgress",n}return e.getDefaultOptions=function(){return{type:"view",data:[],margin:0,padding:0,tooltip:!1,children:[{interaction:{tooltip:!1},coordinate:{transform:[{type:"transpose"}]},type:"interval",axis:!1,legend:!1,encode:{y:function(n){return n},color:function(n,r){return r}}}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return fit},e}(On),VE=function(){return VE=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},VE.apply(this,arguments)};function pit(t){var e=function(r){var i=r.options,a=i.radius,o=a===void 0?.8:a;return(0,rt.set)(r,"options.coordinate.innerRadius",o),r},n=function(r){var i=r.options,a=i.percent,o=i.color,s=o===void 0?[]:o;if(!a)return r;var c={scale:{color:{range:s.length?s:[]}},data:[1,a]};return Object.assign(i,VE({},c)),r};return(0,rt.flow)(e,n,Tr,jn)(t)}var vit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),git=function(t){vit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="TinyRing",n}return e.getDefaultOptions=function(){return{type:"view",data:[],margin:0,padding:0,coordinate:{type:"theta"},animate:{enter:{type:"waveIn"}},interaction:{tooltip:!1},tooltip:!1,children:[{type:"interval",axis:!1,legend:!1,encode:{y:function(n){return n},color:function(n,r){return r}}}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return pit},e}(On);function yit(t){return(0,rt.flow)(jn)(t)}var mit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),bit=function(t){mit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="rose",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"interval"}],coordinate:{type:"polar"},animate:{enter:{type:"waveIn"}}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return yit},e}(On),XE="__start__",Dd="__end__",UE="__waterfall_value__",qE=function(){return qE=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},qE.apply(this,arguments)},xit=function(t,e,n){if(n||arguments.length===2)for(var r=0,i=e.length,a;r<i;r++)(a||!(r in e))&&(a||(a=Array.prototype.slice.call(e,0,r)),a[r]=e[r]);return t.concat(a||Array.prototype.slice.call(e))};function _it(t){var e=function(r){var i=r.options,a=i.data,o=a===void 0?[]:a,s=i.yField;return o.length&&(o.reduce(function(c,l,u){var f,d=Q0(s),h=d(l,u,o);if(u===0||l.isTotal)l[XE]=0,l[Dd]=h,l[UE]=h;else{var v=(f=c[Dd])!==null&&f!==void 0?f:d(c,u,o);l[XE]=v,l[Dd]=v+h,l[UE]=c[Dd]}return l},[]),Object.assign(i,{yField:[XE,Dd]})),r},n=function(r){var i=r.options,a=i.data,o=a===void 0?[]:a,s=i.xField,c=i.children,l=i.linkStyle,u=xit([],o,!0);return u.reduce(function(f,d,h){return h>0&&(d.x1=f[s],d.x2=d[s],d.y1=f[Dd]),d},[]),u.shift(),c.push({type:"link",xField:["x1","x2"],yField:"y1",zIndex:-1,data:u,style:qE({stroke:"#697474"},l),label:!1,tooltip:!1}),r};return(0,rt.flow)(e,n,Tr,jn)(t)}var wit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Oit=function(t){wit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="waterfall",n}return e.getDefaultOptions=function(){return{type:"view",legend:null,tooltip:{field:UE,valueFormatter:"~s",name:"value"},axis:{y:{title:null,labelFormatter:"~s"},x:{title:null}},children:[{type:"interval",interaction:{elementHighlight:{background:!0}}}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return _it},e}(On);function Sit(t){var e=function(n){var r=n.options,i=r.data,a=r.binNumber,o=r.binWidth,s=r.children,c=r.channel,l=c===void 0?"count":c,u=(0,rt.get)(s,"[0].transform[0]",{});return(0,rt.isNumber)(o)?((0,rt.assign)(u,{thresholds:(0,rt.ceil)((0,rt.divide)(i.length,o)),y:l}),n):((0,rt.isNumber)(a)&&(0,rt.assign)(u,{thresholds:a,y:l}),n)};return(0,rt.flow)(e,Tr,jn)(t)}var Eit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Mit=function(t){Eit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="Histogram",n}return e.getDefaultOptions=function(){return{type:"view",autoFit:!0,axis:{y:{title:!1},x:{title:!1}},children:[{type:"rect",transform:[{type:"binX",y:"count"}],interaction:{elementHighlight:{background:!0}}}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Sit},e}(On);function kit(t){var e=function(r){var i=r.options,a=i.tooltip,o=a===void 0?{}:a,s=i.colorField,c=i.sizeField;return o&&!o.field&&(o.field=s||c),r},n=function(r){var i=r.options,a=i.mark,o=i.children;return a&&(o[0].type=a),r};return(0,rt.flow)(e,n,Tr,jn)(t)}var Ait=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Tit=function(t){Ait(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="heatmap",n}return e.getDefaultOptions=function(){return{type:"view",legend:null,tooltip:{valueFormatter:"~s"},axis:{y:{title:null,grid:!0},x:{title:null,grid:!0}},children:[{type:"point",interaction:{elementHighlight:{background:!0}}}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return kit},e}(On);function Pit(t){var e=function(n){var r=n.options.boxType,i=r===void 0?"box":r;return n.options.children[0].type=i,n};return(0,rt.flow)(e,Tr,jn)(t)}var Cit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Lit=function(t){Cit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="box",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"box"}],axis:{y:{title:!1},x:{title:!1}},tooltip:{items:[{name:"min",channel:"y"},{name:"q1",channel:"y1"},{name:"q2",channel:"y2"},{name:"q3",channel:"y3"},{name:"max",channel:"y4"}]}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Pit},e}(On);function Rit(t){var e=function(n){var r=n.options,i=r.data,a=[{type:"custom",callback:function(s){return{links:s}}}];if((0,rt.isArray)(i))i.length>0?(0,rt.set)(r,"data",{value:i,transform:a}):delete r.children;else if((0,rt.get)(i,"type")==="fetch"&&(0,rt.get)(i,"value")){var o=(0,rt.get)(i,"transform");(0,rt.isArray)(o)?(0,rt.set)(i,"transform",o.concat(a)):(0,rt.set)(i,"transform",a)}return n};return(0,rt.flow)(e,Tr,jn)(t)}var Nit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Iit=function(t){Nit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="sankey",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"sankey"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Rit},e}(On);function Dit(t){var e=t.options.layout,n=e===void 0?"horizontal":e;return t.options.coordinate.transform=n!=="horizontal"?void 0:[{type:"transpose"}],t}function jit(t){Dit(t);var e=t.options.layout,n=e===void 0?"horizontal":e;return t.options.children.forEach(function(r){var i;!((i=r==null?void 0:r.coordinate)===null||i===void 0)&&i.transform&&(r.coordinate.transform=n!=="horizontal"?void 0:[{type:"transpose"}])}),t}var Ho=function(){return Ho=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},Ho.apply(this,arguments)},gb=["#f0efff","#5B8FF9","#3D76DD"];function KE(t,e,n,r){r===void 0&&(r=!0);var i=0,a=!1,o=(0,rt.map)(t,function(s){var c,l,u=(0,rt.get)(s,[e]);if((0,rt.isNil)(u))return[];if((0,rt.isString)(u)){var f=Number(u);return isNaN(f)?[]:(c={},c[n]=s[n],c[e]=f,c)}return(0,rt.isArray)(u)?(a=!0,i=Math.max(i,u.length),(0,rt.map)(r?u.sort(function(d,h){return h-d}):u,function(d,h){var v;return v={},v[n]=s[n],v[e]=d,v.index=h,v})):(i=Math.max(1,i),l={},l[n]=s[n],l[e]=u,l)}).flat();return a?[o.map(function(s){return Ho({index:0},s)}),i]:[o,i]}function QE(t,e){return new Array(t).fill("").map(function(n,r){return(0,rt.isArray)(e)?e[r%e.length]:e})}function Fit(t){var e=function(i){var a=i.options,o=a.color,s=a.rangeField,c=s===void 0?"ranges":s,l=a.measureField,u=l===void 0?"measures":l,f=a.targetField,d=f===void 0?"targets":f,h=a.xField,v=h===void 0?"title":h,g=a.mapField,y=a.data,b=KE(y,c,v),x=b[0],_=b[1],w=KE(y,u,v,!1),O=w[0],E=w[1],M=KE(y,d,v,!1),k=M[0],A=M[1],P=(0,rt.get)(o,[c],gb[0]),C=(0,rt.get)(o,[u],gb[1]),N=(0,rt.get)(o,[d],gb[2]),L=[QE(_,P),QE(E,C),QE(A,N)].flat();return i.options.children=(0,rt.map)(i.options.children,function(R,I){var D=[x,O,k][I],G=[c,u,d][I];return Ho(Ho({},R),{data:D,encode:Ho(Ho({},R.encode||{}),{x:v,y:G,color:function(F){var W=F.index,X=(0,rt.isNumber)(W)?"".concat(G,"_").concat(W):G;return g?(0,rt.get)(g,[G,W],X):X}}),style:Ho(Ho({},R.style||{}),{zIndex:function(F){return-F[G]}}),labels:I!==0?(0,rt.map)(R.labels,function(F){return Ho(Ho({},F),{text:G})}):void 0})}),i.options.scale.color.range=L,i.options.legend.color.itemMarker=function(R){return g&&(0,rt.includes)(g==null?void 0:g[d],R)||(R==null?void 0:R.replace(/\_\d$/,""))===d?"line":"square"},i},n=function(i){var a=i.options.layout,o=a===void 0?"horizontal":a;return o!=="horizontal"&&(0,rt.set)(i,"options.children[2].shapeField","hyphen"),i},r=function(i){var a=i.options,o=a.range,s=o===void 0?{}:o,c=a.measure,l=c===void 0?{}:c,u=a.target,f=u===void 0?{}:u,d=a.children;return i.options.children=[s,l,f].map(function(h,v){return _l(d[v],h)}),i};return(0,rt.flow)(e,n,r,jit,jn)(t)}var Bit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),zit=function(t){Bit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="bullet",n}return e.getDefaultOptions=function(){return{type:"view",scale:{color:{range:gb}},legend:{color:{itemMarker:function(n){return n==="target"?"line":"square"}}},axis:{y:{title:!1},x:{title:!1}},children:[{type:"interval",style:{maxWidth:30},axis:{y:{grid:!0,gridLineWidth:2}}},{type:"interval",style:{maxWidth:20},transform:[{type:"stackY"}]},{type:"point",encode:{size:8,shape:"line"}}],interaction:{tooltip:{shared:!0}},coordinate:{transform:[{type:"transpose"}]}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Fit},e}(On);function Wit(t){var e=function(n){var r=n.options.data;return n.options.data={value:r},n};return(0,rt.flow)(e,Tr,jn)(t)}var Git=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),$it=function(t){Git(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="Gauge",n}return e.getDefaultOptions=function(){return{type:"view",legend:!1,children:[{type:"gauge"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Wit},e}(On);function Zit(t){var e=function(n){var r=n.options.percent;return(0,rt.isNumber)(r)&&((0,rt.set)(n,"options.data",r),delete n.options.percent),n};return(0,rt.flow)(e,Tr,jn)(t)}var Yit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Hit=function(t){Yit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="Liquid",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"liquid"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Zit},e}(On);function Vit(t){return(0,rt.flow)(Tr,jn)(t)}var Xit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Uit=function(t){Xit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="WordCloud",n}return e.getDefaultOptions=function(){return{type:"view",legend:!1,children:[{type:"wordCloud"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Vit},e}(On);function qit(t){var e=function(n){var r=n.options,i=r.data;return i&&(0,rt.set)(r,"data",{value:i}),n};return(0,rt.flow)(e,Tr,jn)(t)}var Kit=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),Qit=function(t){Kit(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="treemap",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"treemap"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return qit},e}(On),zu=function(){return zu=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},zu.apply(this,arguments)};function Jit(t){var e=function(i){var a=i.options,o=a.startAngle,s=a.maxAngle,c=a.coordinate,l=(0,rt.isNumber)(o)?o/(2*Math.PI)*360:-90,u=(0,rt.isNumber)(s)?(Number(s)+l)/180*Math.PI:Math.PI;return(0,rt.set)(i,["options","coordinate"],zu(zu({},c),{endAngle:u,startAngle:o!=null?o:-Math.PI/2})),i},n=function(i){var a=i.options,o=a.tooltip,s=a.xField,c=a.yField,l=Q0(s),u=Q0(c);return o||(0,rt.set)(a,"tooltip",{title:!1,items:[function(f,d,h){return{name:l(f,d,h),value:u(f,d,h)}}]}),i},r=function(i){var a=i.options,o=a.markBackground,s=a.children,c=a.scale,l=a.coordinate,u=a.xField,f=(0,rt.get)(c,"y.domain",[]);return o&&s.unshift(zu({type:"interval",xField:u,yField:f[f.length-1],colorField:o.color,scale:{color:{type:"identity"}},style:{fillOpacity:o.opacity,fill:o.color?void 0:"#e0e4ee"},coordinate:zu(zu({},l),{startAngle:-Math.PI/2,endAngle:1.5*Math.PI}),animate:!1},o)),i};return(0,rt.flow)(e,n,r,Tr,jn)(t)}var tat=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),eat=function(t){tat(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="radial",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"interval"}],coordinate:{type:"radial",innerRadius:.1,outerRadius:1,endAngle:Math.PI},animate:{enter:{type:"waveIn",duration:800}},axis:{y:{nice:!0,labelAutoHide:!0,labelAutoRotate:!1},x:{title:!1,nice:!0,labelAutoRotate:!1,labelAutoHide:{type:"equidistance",cfg:{minGap:6}}}}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return Jit},e}(On);function nat(t){return(0,rt.flow)(jn)(t)}var rat=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),iat=function(t){rat(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="CirclePacking",n}return e.getDefaultOptions=function(){return{legend:!1,type:"view",children:[{type:"pack"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return nat},e}(On),yb=function(){return yb=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},yb.apply(this,arguments)};function aat(t){var e=function(n){var r=n.options,i=r.xField,a=r.yField,o=r.seriesField,s=r.children,c=s==null?void 0:s.map(function(l){return yb(yb({},l),{xField:i,yField:a,seriesField:o,colorField:o,data:l.type==="density"?{transform:[{type:"kde",field:a,groupBy:[i,o]}]}:l.data})}).filter(function(l){return r.violinType!=="density"||l.type==="density"});return(0,rt.set)(r,"children",c),r.violinType==="polar"&&(0,rt.set)(r,"coordinate",{type:"polar"}),(0,rt.set)(r,"violinType",void 0),n};return(0,rt.flow)(e,Tr,jn)(t)}var oat=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),sat=function(t){oat(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="violin",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"density",sizeField:"size",tooltip:!1},{type:"boxplot",shapeField:"violin",style:{opacity:.5,point:!1}}],animate:{enter:{type:"fadeIn"}}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return aat},e}(On),J0=function(){return J0=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},J0.apply(this,arguments)},cat=function(t,e,n){if(n||arguments.length===2)for(var r=0,i=e.length,a;r<i;r++)(a||!(r in e))&&(a||(a=Array.prototype.slice.call(e,0,r)),a[r]=e[r]);return t.concat(a||Array.prototype.slice.call(e))};function lat(t){var e=function(a){var o=a.options,s=o.yField,c=o.children;return c.forEach(function(l,u){(0,rt.set)(l,"yField",s[u])}),a},n=function(a){var o=a.options,s=o.yField,c=o.children,l=o.data;if((0,rt.isPlainObject)(l))return a;var u=(0,rt.isArray)((0,rt.get)(l,[0]))?l:[l,l];return c.forEach(function(f,d){(0,rt.set)(f,"data",cat([],u[d].map(function(h){return J0({groupKey:s[d]},h)}),!0))}),a},r=function(a){var o=a.options,s=o.yField,c=s[0],l=s[1],u=o.tooltip;return u||(0,rt.set)(o,"tooltip",{items:[{field:c,value:c},{field:l,value:l}]}),a},i=function(a){var o=a.options,s=o.children,c=o.layout,l=o.coordinate.transform,u=o.paddingBottom,f=u===void 0?c8:u,d=o.paddingLeft,h=d===void 0?c8:d,v=o.axis;(0,rt.set)(o,"axisText",J0(J0({},(v==null?void 0:v.x)||{}),{layout:c}));var g=s[0],y=s[1];if(c==="vertical")(0,rt.set)(o,"direction","col"),(0,rt.set)(o,"paddingLeft",h),(0,rt.set)(o,"coordinate.transform",l.filter(function(O){return O.type!=="transpose"})),(0,rt.set)(g,"paddingBottom",s8),(0,rt.set)(y,"paddingTop",s8),(0,rt.set)(y,"axis",{x:{position:"top"}}),(0,rt.set)(y,"scale",{y:{range:[0,1]}});else{(0,rt.set)(o,"paddingBottom",f),(0,rt.set)(g,"scale",{y:{range:[0,1]}});var b=g.paddingRight,x=b===void 0?ZE:b,_=y.paddingLeft,w=_===void 0?ZE:_;(0,rt.set)(g,"paddingRight",x),(0,rt.set)(g,"axis",{x:{position:"right"}}),(0,rt.set)(y,"paddingLeft",w)}return a};return(0,rt.flow)(e,n,r,i,Tr,jn)(t)}var uat=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),fat=function(t){uat(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="BidirectionalBar",n}return e.getDefaultOptions=function(){return{type:"spaceFlex",coordinate:{transform:[{type:"transpose"}]},scale:{y:{nice:!0}},direction:"row",layout:"horizontal",legend:!1,axis:{y:{title:!1},x:{title:!1,label:!1}},children:[{type:"interval"},{type:"interval"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return lat},e}(On),Wu;(function(t){t.color="key",t.d="path"})(Wu||(Wu={}));function dat(t){var e=function(n){var r=n.options,i=r.data,a=r.setsField,o=r.sizeField;return(0,rt.isArray)(i)&&((0,rt.set)(r,"data",{type:"inline",value:i,transform:[{type:"venn",sets:a,size:o,as:[Wu.color,Wu.d]}]}),(0,rt.set)(r,"colorField",a),(0,rt.set)(r,["children","0","encode","d"],Wu.d)),(0,rt.set)(n,"options",(0,rt.omit)(r,["sizeField","setsField"])),n};return(0,rt.flow)(e,jn)(t)}var hat=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),pat=function(t){hat(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="venn",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"path"}],legend:{color:{itemMarker:"circle"}},encode:{color:Wu.color,d:Wu.d}}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return dat},e}(On);function vat(t){var e=function(n){return n};return(0,rt.flow)(e,jn)(t)}var gat=function(){var t=function(e,n){return t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,i){r.__proto__=i}||function(r,i){for(var a in i)Object.prototype.hasOwnProperty.call(i,a)&&(r[a]=i[a])},t(e,n)};return function(e,n){if(typeof n!="function"&&n!==null)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");t(e,n);function r(){this.constructor=e}e.prototype=n===null?Object.create(n):(r.prototype=n.prototype,new r)}}(),yat=function(t){gat(e,t);function e(){var n=t!==null&&t.apply(this,arguments)||this;return n.type="Sunburst",n}return e.getDefaultOptions=function(){return{type:"view",children:[{type:"sunburst"}]}},e.prototype.getDefaultOptions=function(){return e.getDefaultOptions()},e.prototype.getSchemaAdaptor=function(){return vat},e}(On),mat={Base:mrt,Line:Frt,Column:Prt,Pie:Wrt,Area:Srt,Bar:krt,DualAxes:d8,Funnel:Irt,Scatter:Zrt,Radar:Vrt,Rose:bit,Stock:eit,TinyLine:iit,TinyArea:sit,TinyColumn:uit,TinyProgress:hit,TinyRing:git,Waterfall:Oit,Histogram:Mit,Heatmap:Tit,Box:Lit,Sankey:Iit,Bullet:zit,Gauge:$it,Liquid:Hit,WordCloud:Uit,Treemap:Qit,RadialBar:eat,CirclePacking:iat,Violin:sat,BidirectionalBar:fat,Venn:pat,Mix:d8,Sunburst:yat},JE=function(){return JE=Object.assign||function(t){for(var e,n=1,r=arguments.length;n<r;n++){e=arguments[n];for(var i in e)Object.prototype.hasOwnProperty.call(e,i)&&(t[i]=e[i])}return t},JE.apply(this,arguments)},h8=function(t,e){var n={};for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&e.indexOf(r)<0&&(n[r]=t[r]);if(t!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,r=Object.getOwnPropertySymbols(t);i<r.length;i++)e.indexOf(r[i])<0&&Object.prototype.propertyIsEnumerable.call(t,r[i])&&(n[r[i]]=t[r[i]]);return n},bat=(0,Rt.forwardRef)(function(t,e){var n=t.chartType,r=n===void 0?"Base":n,i=h8(t,["chartType"]),a=i.containerStyle,o=a===void 0?{height:"inherit",flex:1}:a,s=i.containerAttributes,c=s===void 0?{}:s,l=i.className,u=i.loading,f=i.loadingTemplate,d=i.errorTemplate,h=h8(i,["containerStyle","containerAttributes","className","loading","loadingTemplate","errorTemplate"]),v=Xa(mat[r],h),g=v.chart,y=v.container;return(0,Rt.useImperativeHandle)(e,function(){return g.current}),Rt.createElement(tr,{errorTemplate:d},u&&Rt.createElement(Fi,{loadingTemplate:f}),Rt.createElement("div",JE({className:l,style:o,ref:y},c)))})},35099:function(Ae,Be,pt){"use strict";var oe=pt(67294),$=pt(95327),fe=function(){return fe=Object.assign||function(ae){for(var Rt,qt=1,Yt=arguments.length;qt<Yt;qt++){Rt=arguments[qt];for(var ft in Rt)Object.prototype.hasOwnProperty.call(Rt,ft)&&(ae[ft]=Rt[ft])}return ae},fe.apply(this,arguments)},Ye=(0,oe.forwardRef)(function(ae,Rt){return oe.createElement($.P,fe({},ae,{chartType:"Gauge",ref:Rt}))});Be.Z=Ye},63430:function(Ae,Be,pt){"use strict";var oe=pt(67294),$=pt(95327),fe=function(){return fe=Object.assign||function(ae){for(var Rt,qt=1,Yt=arguments.length;qt<Yt;qt++){Rt=arguments[qt];for(var ft in Rt)Object.prototype.hasOwnProperty.call(Rt,ft)&&(ae[ft]=Rt[ft])}return ae},fe.apply(this,arguments)},Ye=(0,oe.forwardRef)(function(ae,Rt){return oe.createElement($.P,fe({},ae,{chartType:"Pie",ref:Rt}))});Be.Z=Ye},17816:function(Ae,Be){(function(pt,oe){oe(Be)})(this,function(pt){"use strict";function oe(j){var z=typeof Symbol=="function"&&Symbol.iterator,H=z&&j[z],U=0;if(H)return H.call(j);if(j&&typeof j.length=="number")return{next:function(){return{value:(j=j&&U>=j.length?void 0:j)&&j[U++],done:!j}}};throw new TypeError(z?"Object is not iterable.":"Symbol.iterator is not defined.")}function $(j,z){var H=typeof Symbol=="function"&&j[Symbol.iterator];if(!H)return j;var U,it,at=H.call(j),K=[];try{for(;(z===void 0||0<z--)&&!(U=at.next()).done;)K.push(U.value)}catch(J){it={error:J}}finally{try{U&&!U.done&&(H=at.return)&&H.call(at)}finally{if(it)throw it.error}}return K}function fe(j,z,H){if(H||arguments.length===2)for(var U,it=0,at=z.length;it<at;it++)!U&&it in z||((U=U||Array.prototype.slice.call(z,0,it))[it]=z[it]);return j.concat(U||Array.prototype.slice.call(z))}function Ye(j){return Rt(j,"Function")}var ae={}.toString,Rt=function(j,z){return ae.call(j)==="[object "+z+"]"},qt=function(j){return Array.isArray?Array.isArray(j):Rt(j,"Array")},Yt=function(j){if(typeof(z=j)!="object"||z===null||!Rt(j,"Object"))return!1;var z;if(Object.getPrototypeOf(j)===null)return!0;for(var H=j;Object.getPrototypeOf(H)!==null;)H=Object.getPrototypeOf(H);return Object.getPrototypeOf(j)===H},ft=function(j){return Rt(j,"Number")},re=Object.values?function(j){return Object.values(j)}:function(j){var z,H=[],U=j,it=function(ct,ut){Ye(j)&&ut==="prototype"||H.push(ct)};if(U){if(qt(U))for(var at=0,K=U.length;at<K&&it(U[at],at)!==!1;at++);else if(z=typeof U,U!==null&&z=="object"||z=="function"){for(var J in U)if(U.hasOwnProperty(J)&&it(U[J],J)===!1)break}}return H},Wt=5;function ee(j){for(var z=[],H=1;H<arguments.length;H++)z[H-1]=arguments[H];for(var U=0;U<z.length;U+=1)(function it(at,K,J,ct){for(var ut in J=J||0,ct=ct||Wt,K){var Dt;K.hasOwnProperty(ut)&&((Dt=K[ut])!==null&&Yt(Dt)?(Yt(at[ut])||(at[ut]={}),J<ct?it(at[ut],Dt,J+1,ct):at[ut]=K[ut]):qt(Dt)?(at[ut]=[],at[ut]=at[ut].concat(Dt)):Dt!==void 0&&(at[ut]=Dt))}})(j,z[U]);return j}function Xt(j){return j}(function(j,z){var H;if(Ye(j))return(H=function(){for(var U=[],it=0;it<arguments.length;it++)U[it]=arguments[it];var at,K=z?z.apply(this,U):U[0],J=H.cache;return J.has(K)?J.get(K):(at=j.apply(this,U),J.set(K,at),at)}).cache=new Map;throw new TypeError("Expected a function")})(function(j,K){var H=(K=K===void 0?{}:K).fontSize,U=K.fontFamily,it=K.fontWeight,at=K.fontStyle,K=K.fontVariant;return(kt=kt||document.createElement("canvas").getContext("2d")).font=[at,K,it,H+"px",U].join(" "),kt.measureText(Rt(j,"String")?j:"").width},function(j,z){return function(){for(var H=0,U=0,it=arguments.length;U<it;U++)H+=arguments[U].length;for(var at=Array(H),K=0,U=0;U<it;U++)for(var J=arguments[U],ct=0,ut=J.length;ct<ut;ct++,K++)at[K]=J[ct];return at}([j],re(z=z===void 0?{}:z)).join("")});var kt,St=typeof Float32Array!="undefined"?Float32Array:Array;function bt(){var j=new St(9);return St!=Float32Array&&(j[1]=0,j[2]=0,j[3]=0,j[5]=0,j[6]=0,j[7]=0),j[0]=1,j[4]=1,j[8]=1,j}Math.hypot||(Math.hypot=function(){for(var j=0,z=arguments.length;z--;)j+=arguments[z]*arguments[z];return Math.sqrt(j)});var Tt=function(j,Ht,Ut){var U=Ht[0],it=Ht[1],at=Ht[2],K=Ht[3],J=Ht[4],ct=Ht[5],ut=Ht[6],Dt=Ht[7],Ht=Ht[8],ie=Ut[0],Ft=Ut[1],Jt=Ut[2],Gt=Ut[3],Nt=Ut[4],he=Ut[5],ne=Ut[6],pe=Ut[7],Ut=Ut[8];return j[0]=ie*U+Ft*K+Jt*ut,j[1]=ie*it+Ft*J+Jt*Dt,j[2]=ie*at+Ft*ct+Jt*Ht,j[3]=Gt*U+Nt*K+he*ut,j[4]=Gt*it+Nt*J+he*Dt,j[5]=Gt*at+Nt*ct+he*Ht,j[6]=ne*U+pe*K+Ut*ut,j[7]=ne*it+pe*J+Ut*Dt,j[8]=ne*at+pe*ct+Ut*Ht,j};function xe(){var j=new St(16);return St!=Float32Array&&(j[1]=0,j[2]=0,j[3]=0,j[4]=0,j[6]=0,j[7]=0,j[8]=0,j[9]=0,j[11]=0,j[12]=0,j[13]=0,j[14]=0),j[0]=1,j[5]=1,j[10]=1,j[15]=1,j}var _e=function(j,ne,H){var U=ne[0],it=ne[1],at=ne[2],K=ne[3],J=ne[4],ct=ne[5],ut=ne[6],Dt=ne[7],Ht=ne[8],ie=ne[9],Ft=ne[10],Jt=ne[11],Gt=ne[12],Nt=ne[13],he=ne[14],ne=ne[15],pe=H[0],Ut=H[1],ve=H[2],He=H[3];return j[0]=pe*U+Ut*J+ve*Ht+He*Gt,j[1]=pe*it+Ut*ct+ve*ie+He*Nt,j[2]=pe*at+Ut*ut+ve*Ft+He*he,j[3]=pe*K+Ut*Dt+ve*Jt+He*ne,pe=H[4],Ut=H[5],ve=H[6],He=H[7],j[4]=pe*U+Ut*J+ve*Ht+He*Gt,j[5]=pe*it+Ut*ct+ve*ie+He*Nt,j[6]=pe*at+Ut*ut+ve*Ft+He*he,j[7]=pe*K+Ut*Dt+ve*Jt+He*ne,pe=H[8],Ut=H[9],ve=H[10],He=H[11],j[8]=pe*U+Ut*J+ve*Ht+He*Gt,j[9]=pe*it+Ut*ct+ve*ie+He*Nt,j[10]=pe*at+Ut*ut+ve*Ft+He*he,j[11]=pe*K+Ut*Dt+ve*Jt+He*ne,pe=H[12],Ut=H[13],ve=H[14],He=H[15],j[12]=pe*U+Ut*J+ve*Ht+He*Gt,j[13]=pe*it+Ut*ct+ve*ie+He*Nt,j[14]=pe*at+Ut*ut+ve*Ft+He*he,j[15]=pe*K+Ut*Dt+ve*Jt+He*ne,j};function _n(j){for(var z=[],H=1;H<arguments.length;H++)z[H-1]=arguments[H];return j?z.reduce(function(U,it){return function(at){return it(U(at))}},j):Xt}function Ue(j){return j instanceof Float32Array||j instanceof Array}function pn(j,z,H){for(;j<z;)j+=2*Math.PI;for(;H<j;)j-=2*Math.PI;return j}me=new St(3),St!=Float32Array&&(me[0]=0,me[1]=0,me[2]=0),me=new St(4),St!=Float32Array&&(me[0]=0,me[1]=0,me[2]=0,me[3]=0);function gn(K,z,H,U,it){var at=(K=$(K,2))[0],K=K[1],J=bt();return at=[at,K],(K=J)[0]=1,K[1]=0,K[2]=0,K[3]=0,K[4]=1,K[5]=0,K[6]=at[0],K[7]=at[1],K[8]=1,K}function rn(j,...z){return z.reduce((H,U)=>it=>H(U(it)),j)}function Yn(j,z){return z-j?H=>(H-j)/(z-j):H=>.5}const Jn=Math.sqrt(50),Ce=Math.sqrt(10),Se=Math.sqrt(2);function zr(j,z,H){return z=(z-j)/Math.max(0,H),j=Math.floor(Math.log(z)/Math.LN10),H=z/ti(10,j),0<=j?(H>=Jn?10:H>=Ce?5:H>=Se?2:1)*ti(10,j):-ti(10,-j)/(H>=Jn?10:H>=Ce?5:H>=Se?2:1)}const di=(j,z,H=5)=>{j=[j,z];let U=0,it=j.length-1,at=j[U],K=j[it],J;return K<at&&([at,K]=[K,at],[U,it]=[it,U]),0<(J=zr(at,K,H))?(at=Math.floor(at/J)*J,K=Math.ceil(K/J)*J,J=zr(at,K,H)):J<0&&(at=Math.ceil(at*J)/J,K=Math.floor(K*J)/J,J=zr(at,K,H)),0<J?(j[U]=Math.floor(at/J)*J,j[it]=Math.ceil(K/J)*J):J<0&&(j[U]=Math.ceil(at*J)/J,j[it]=Math.floor(K*J)/J),j};function Fi(j){return j!=null&&!Number.isNaN(j)}function hi(j,z){return H=>{H.prototype.rescale=function(){this.initRange(),this.nice();var[U]=this.chooseTransforms();this.composeOutput(U,this.chooseClamp(U))},H.prototype.initRange=function(){var U=this.options.interpolator;this.options.range=j(U)},H.prototype.composeOutput=function(U,it){var at,{domain:J,interpolator:K,round:ct}=this.getOptions(),J=z(J.map(U)),ct=ct?(at=K,ut=>(ut=at(ut),ft(ut)?Math.round(ut):ut)):K;this.output=rn(ct,J,it,U)},H.prototype.invert=void 0}}var tr,me={exports:{}},qa={exports:{}},rt=function(j){return!(!j||typeof j=="string")&&(j instanceof Array||Array.isArray(j)||0<=j.length&&(j.splice instanceof Function||Object.getOwnPropertyDescriptor(j,j.length-1)&&j.constructor.name!=="String"))},aa=Array.prototype.concat,Bi=Array.prototype.slice,Wr=qa.exports=function(j){for(var z=[],H=0,U=j.length;H<U;H++){var it=j[H];rt(it)?z=aa.call(z,Bi.call(it)):z.push(it)}return z},ya=(Wr.wrap=function(j){return function(){return j(Wr(arguments))}},{aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]}),oa=qa.exports,ks=Object.hasOwnProperty,Or=Object.create(null);for(tr in ya)ks.call(ya,tr)&&(Or[ya[tr]]=tr);var yn=me.exports={to:{},get:{}};function Xa(j,z,H){return Math.min(Math.max(z,j),H)}function Ua(j){return j=Math.round(j).toString(16).toUpperCase(),j.length<2?"0"+j:j}yn.get=function(j){var z,H;switch(j.substring(0,3).toLowerCase()){case"hsl":z=yn.get.hsl(j),H="hsl";break;case"hwb":z=yn.get.hwb(j),H="hwb";break;default:z=yn.get.rgb(j),H="rgb"}return z?{model:H,value:z}:null},yn.get.rgb=function(j){if(!j)return null;var z,H,U,it=[0,0,0,1];if(z=j.match(/^#([a-f0-9]{6})([a-f0-9]{2})?$/i)){for(U=z[2],z=z[1],H=0;H<3;H++){var at=2*H;it[H]=parseInt(z.slice(at,2+at),16)}U&&(it[3]=parseInt(U,16)/255)}else if(z=j.match(/^#([a-f0-9]{3,4})$/i)){for(U=(z=z[1])[3],H=0;H<3;H++)it[H]=parseInt(z[H]+z[H],16);U&&(it[3]=parseInt(U+U,16)/255)}else{if(z=j.match(/^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/))for(H=0;H<3;H++)it[H]=parseInt(z[H+1],0);else{if(!(z=j.match(/^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/)))return(z=j.match(/^(\w+)$/))?z[1]==="transparent"?[0,0,0,0]:ks.call(ya,z[1])?((it=ya[z[1]])[3]=1,it):null:null;for(H=0;H<3;H++)it[H]=Math.round(2.55*parseFloat(z[H+1]))}z[4]&&(z[5]?it[3]=.01*parseFloat(z[4]):it[3]=parseFloat(z[4]))}for(H=0;H<3;H++)it[H]=Xa(it[H],0,255);return it[3]=Xa(it[3],0,1),it},yn.get.hsl=function(j){var z;return(j=j&&j.match(/^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/))?(z=parseFloat(j[4]),[(parseFloat(j[1])%360+360)%360,Xa(parseFloat(j[2]),0,100),Xa(parseFloat(j[3]),0,100),Xa(isNaN(z)?1:z,0,1)]):null},yn.get.hwb=function(j){var z;return(j=j&&j.match(/^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/))?(z=parseFloat(j[4]),[(parseFloat(j[1])%360+360)%360,Xa(parseFloat(j[2]),0,100),Xa(parseFloat(j[3]),0,100),Xa(isNaN(z)?1:z,0,1)]):null},yn.to.hex=function(){var j=oa(arguments);return"#"+Ua(j[0])+Ua(j[1])+Ua(j[2])+(j[3]<1?Ua(Math.round(255*j[3])):"")},yn.to.rgb=function(){var j=oa(arguments);return j.length<4||j[3]===1?"rgb("+Math.round(j[0])+", "+Math.round(j[1])+", "+Math.round(j[2])+")":"rgba("+Math.round(j[0])+", "+Math.round(j[1])+", "+Math.round(j[2])+", "+j[3]+")"},yn.to.rgb.percent=function(){var j=oa(arguments),z=Math.round(j[0]/255*100),H=Math.round(j[1]/255*100),U=Math.round(j[2]/255*100);return j.length<4||j[3]===1?"rgb("+z+"%, "+H+"%, "+U+"%)":"rgba("+z+"%, "+H+"%, "+U+"%, "+j[3]+")"},yn.to.hsl=function(){var j=oa(arguments);return j.length<4||j[3]===1?"hsl("+j[0]+", "+j[1]+"%, "+j[2]+"%)":"hsla("+j[0]+", "+j[1]+"%, "+j[2]+"%, "+j[3]+")"},yn.to.hwb=function(){var j=oa(arguments),z="";return 4<=j.length&&j[3]!==1&&(z=", "+j[3]),"hwb("+j[0]+", "+j[1]+"%, "+j[2]+"%"+z+")"},yn.to.keyword=function(j){return Or[j.slice(0,3)]};var As=me.exports;function Ts(j,z,H){let U=H;return U<0&&(U+=1),1<U&&--U,U<1/6?j+6*(z-j)*U:U<.5?z:U<2/3?j+(z-j)*(2/3-U)*6:j}function Xo(it){var z,H,U,it=As.get(it);return it?({model:it,value:z}=it,it==="rgb"?z:it==="hsl"?(z=(it=z)[0]/360,H=it[1]/100,U=it[2]/100,it=it[3],H==0?[255*U,255*U,255*U,it]:[255*Ts(H=2*U-(U=U<.5?U*(1+H):U+H-U*H),U,z+1/3),255*Ts(H,U,z),255*Ts(H,U,z-1/3),it]):null):null}const zi=(j,z)=>H=>j*(1-H)+z*H,ma=(j,z)=>{if(typeof j=="number"&&typeof z=="number")return zi(j,z);if(typeof j!="string"||typeof z!="string")return()=>j;{var H=j,U=z;const it=Xo(H),at=Xo(U);return it===null||at===null?it?()=>H:()=>U:K=>{var J=new Array(4);for(let Jt=0;Jt<4;Jt+=1){var ct=it[Jt],ut=at[Jt];J[Jt]=ct*(1-K)+ut*K}var[Dt,Ht,ie,Ft]=J;return`rgba(${Math.round(Dt)}, ${Math.round(Ht)}, ${Math.round(ie)}, ${Ft})`}}},_i=(j,z)=>{const H=zi(j,z);return U=>Math.round(H(U))};function ba({map:j,initKey:z},H){return z=z(H),j.has(z)?j.get(z):H}function Gu(j){return typeof j=="object"?j.valueOf():j}class Wi extends Map{constructor(z){if(super(),this.map=new Map,this.initKey=Gu,z!==null)for(var[H,U]of z)this.set(H,U)}get(z){return super.get(ba({map:this.map,initKey:this.initKey},z))}has(z){return super.has(ba({map:this.map,initKey:this.initKey},z))}set(z,H){return super.set(([{map:z,initKey:U},it]=[{map:this.map,initKey:this.initKey},z],U=U(it),z.has(U)?z.get(U):(z.set(U,it),it)),H);var U,it}delete(z){return super.delete(([{map:z,initKey:H},U]=[{map:this.map,initKey:this.initKey},z],H=H(U),z.has(H)&&(U=z.get(H),z.delete(H)),U));var H,U}}class bc{constructor(z){this.options=ee({},this.getDefaultOptions()),this.update(z)}getOptions(){return this.options}update(z={}){this.options=ee({},this.options,z),this.rescale(z)}rescale(z){}}const wl=Symbol("defaultUnknown");function Ee(j,z,H){for(let U=0;U<z.length;U+=1)j.has(z[U])||j.set(H(z[U]),U)}function xt(z){var{value:z,from:H,to:U,mapper:it,notFoundReturn:at}=z;let K=it.get(z);if(K===void 0){if(at!==wl)return at;K=H.push(z)-1,it.set(z,K)}return U[K%U.length]}function Ot(j){return j instanceof Date?z=>""+z:typeof j=="object"?z=>JSON.stringify(z):z=>z}class ln extends bc{getDefaultOptions(){return{domain:[],range:[],unknown:wl}}constructor(z){super(z)}map(z){return this.domainIndexMap.size===0&&Ee(this.domainIndexMap,this.getDomain(),this.domainKey),xt({value:this.domainKey(z),mapper:this.domainIndexMap,from:this.getDomain(),to:this.getRange(),notFoundReturn:this.options.unknown})}invert(z){return this.rangeIndexMap.size===0&&Ee(this.rangeIndexMap,this.getRange(),this.rangeKey),xt({value:this.rangeKey(z),mapper:this.rangeIndexMap,from:this.getRange(),to:this.getDomain(),notFoundReturn:this.options.unknown})}rescale(z){var[H]=this.options.domain,[U]=this.options.range;this.domainKey=Ot(H),this.rangeKey=Ot(U),this.rangeIndexMap?(z&&!z.range||this.rangeIndexMap.clear(),z&&!z.domain&&!z.compare||(this.domainIndexMap.clear(),this.sortedDomain=void 0)):(this.rangeIndexMap=new Map,this.domainIndexMap=new Map)}clone(){return new ln(this.options)}getRange(){return this.options.range}getDomain(){var z,H;return this.sortedDomain||({domain:z,compare:H}=this.options,this.sortedDomain=H?[...z].sort(H):z),this.sortedDomain}}function De(Nt){const{domain:z,range:H,paddingOuter:U,paddingInner:it,flex:at,round:K,align:J}=Nt;var ct=z.length,Ft=0<(Ft=(Nt=ct)-(ut=at).length)?[...ut,...new Array(Ft).fill(1)]:Ft<0?ut.slice(0,Nt):ut,[Nt,ut]=H,ut=ut-Nt,Gt=ut/(2/ct*U+1-1/ct*it);const Dt=Gt*it/ct;Gt-=ct*Dt;const Ht=function(Ut){const ve=Math.min(...Ut);return Ut.map(He=>He/ve)}(Ft),ie=Gt/Ht.reduce((Ut,ve)=>Ut+ve);var Ft=new Wi(z.map((Ut,ve)=>(ve=Ht[ve]*ie,[Ut,K?Math.floor(ve):ve]))),Jt=new Wi(z.map((Ut,ve)=>(ve=Ht[ve]*ie+Dt,[Ut,K?Math.floor(ve):ve]))),Gt=Array.from(Jt.values()).reduce((Ut,ve)=>Ut+ve),Nt=Nt+(ut-(Gt-Gt/ct*it))*J;let he=K?Math.round(Nt):Nt;var ne=new Array(ct);for(let Ut=0;Ut<ct;Ut+=1){ne[Ut]=(pe=he,Math.round(1e12*pe)/1e12);var pe=z[Ut];he+=Jt.get(pe)}return{valueBandWidth:Ft,valueStep:Jt,adjustedRange:ne}}class Me extends ln{getDefaultOptions(){return{domain:[],range:[0,1],align:.5,round:!1,paddingInner:0,paddingOuter:0,padding:0,unknown:wl,flex:[]}}constructor(z){super(z)}clone(){return new Me(this.options)}getStep(z){return this.valueStep===void 0?1:typeof this.valueStep=="number"?this.valueStep:z===void 0?Array.from(this.valueStep.values())[0]:this.valueStep.get(z)}getBandWidth(z){return this.valueBandWidth===void 0?1:typeof this.valueBandWidth=="number"?this.valueBandWidth:z===void 0?Array.from(this.valueBandWidth.values())[0]:this.valueBandWidth.get(z)}getRange(){return this.adjustedRange}getPaddingInner(){var{padding:z,paddingInner:H}=this.options;return 0<z?z:H}getPaddingOuter(){var{padding:z,paddingOuter:H}=this.options;return 0<z?z:H}rescale(){super.rescale();var{align:U,domain:z,range:it,round:at,flex:H}=this.options,{adjustedRange:U,valueBandWidth:it,valueStep:at}=function(ut){var J=ut.domain;if((J=J.length)===0)return{valueBandWidth:void 0,valueStep:void 0,adjustedRange:[]};if(!((ct=ut.flex)==null||!ct.length))return De(ut);var{range:ct,paddingOuter:ut,paddingInner:Dt,round:Ht,align:ie}=ut;let Ft,Jt,Gt=ct[0];return ct=ct[1]-Gt,Ft=ct/Math.max(1,2*ut+(J-Dt)),Ht&&(Ft=Math.floor(Ft)),Gt+=(ct-Ft*(J-Dt))*ie,Jt=Ft*(1-Dt),Ht&&(Gt=Math.round(Gt),Jt=Math.round(Jt)),ut=new Array(J).fill(0).map((Nt,he)=>Gt+he*Ft),{valueStep:Ft,valueBandWidth:Jt,adjustedRange:ut}}({align:U,range:it,round:at,flex:H,paddingInner:this.getPaddingInner(),paddingOuter:this.getPaddingOuter(),domain:z});this.valueStep=at,this.valueBandWidth=it,this.adjustedRange=U}}const Te=(j,z,H)=>{let U,it,at=j,K=z;if(at===K&&0<H)return[at];let J=zr(at,K,H);if(J===0||!Number.isFinite(J))return[];if(0<J){at=Math.ceil(at/J),K=Math.floor(K/J),it=new Array(U=Math.ceil(K-at+1));for(let ct=0;ct<U;ct+=1)it[ct]=(at+ct)*J}else{J=-J,at=Math.ceil(at*J),K=Math.floor(K*J),it=new Array(U=Math.ceil(K-at+1));for(let ct=0;ct<U;ct+=1)it[ct]=(at+ct)/J}return it},Ps=(U,at,H)=>{var[U,it]=U,[at,K]=at;let J,ct;return rn(ct=U<it?(J=Yn(U,it),H(at,K)):(J=Yn(it,U),H(K,at)),J)},Lo=(j,z,H)=>{const U=Math.min(j.length,z.length)-1,it=new Array(U),at=new Array(U);var K=j[0]>j[U],J=K?[...j].reverse():j,ct=K?[...z].reverse():z;for(let ut=0;ut<U;ut+=1)it[ut]=Yn(J[ut],J[ut+1]),at[ut]=H(ct[ut],ct[ut+1]);return ut=>{var Dt=function(ie,Ft,Jt,Gt,Nt){let he=Jt||0,ne=Gt||ie.length;for(var pe=Nt||(ve=>ve);he<ne;){var Ut=Math.floor((he+ne)/2);pe(ie[Ut])>Ft?ne=Ut:he=Ut+1}return he}(j,ut,1,U)-1,Ht=it[Dt];return rn(at[Dt],Ht)(ut)}},un=(j,z,H,U)=>(2<Math.min(j.length,z.length)?Lo:Ps)(j,z,U?_i:H);class Hn extends bc{getDefaultOptions(){return{domain:[0,1],range:[0,1],nice:!1,clamp:!1,round:!1,interpolate:zi,tickCount:5}}map(z){return Fi(z)?this.output(z):this.options.unknown}invert(z){return Fi(z)?this.input(z):this.options.unknown}nice(){var z,H,U,it;this.options.nice&&([z,H,U,...it]=this.getTickMethodOptions(),this.options.domain=this.chooseNice()(z,H,U,...it))}getTicks(){var z=this.options.tickMethod,[H,U,it,...at]=this.getTickMethodOptions();return z(H,U,it,...at)}getTickMethodOptions(){var{domain:z,tickCount:H}=this.options;return[z[0],z[z.length-1],H]}chooseNice(){return di}rescale(){this.nice();var[z,H]=this.chooseTransforms();this.composeOutput(z,this.chooseClamp(z)),this.composeInput(z,H,this.chooseClamp(H))}chooseClamp(U){var{clamp:H,range:it}=this.options,U=this.options.domain.map(U),it=Math.min(U.length,it.length);if(H){H=U[0],U=U[it-1];const at=U<H?U:H,K=U<H?H:U;return J=>Math.min(Math.max(at,J),K)}return Xt}composeOutput(z,H){var{domain:K,range:U,round:it,interpolate:at}=this.options,K=un(K.map(z),U,at,it);this.output=rn(K,H,z)}composeInput(z,H,U){var{domain:it,range:at}=this.options,at=un(at,it.map(z),zi);this.input=rn(H,U,at)}}class Pr extends Hn{getDefaultOptions(){return{domain:[0,1],range:[0,1],unknown:void 0,nice:!1,clamp:!1,round:!1,interpolate:ma,tickMethod:Te,tickCount:5}}chooseTransforms(){return[Xt,Xt]}clone(){return new Pr(this.options)}}class xc extends Me{getDefaultOptions(){return{domain:[],range:[0,1],align:.5,round:!1,padding:0,unknown:wl,paddingInner:1,paddingOuter:0}}constructor(z){super(z)}getPaddingInner(){return 1}clone(){return new xc(this.options)}update(z){super.update(z)}getPaddingOuter(){return this.options.padding}}function _c(j,z){for(var H=[],U=0,it=j.length;U<it;U++)H.push(j[U].substr(0,z));return H}var wc,qa=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],me=["January","February","March","April","May","June","July","August","September","October","November","December"],wi=_c(me,3);(function(j){for(var z=[],H=1;H<arguments.length;H++)z[H-1]=arguments[H];for(var U=0,it=z;U<it.length;U++){var at,K=it[U];for(at in K)j[at]=K[at]}})({},{dayNamesShort:_c(qa,3),dayNames:qa,monthNamesShort:wi,monthNames:me,amPm:["am","pm"],DoFn:function(j){return j+["th","st","nd","rd"][3<j%10?0:(j-j%10!=10?1:0)*j%10]}});var sa;let sn=wc=class extends Pr{getDefaultOptions(){return{domain:[0,1],unknown:void 0,nice:!1,clamp:!1,round:!1,interpolator:Xt,tickMethod:Te,tickCount:5}}constructor(j){super(j)}clone(){return new wc(this.options)}};sn=wc=function(j,z,H,U){var it,at=arguments.length,K=at<3?z:U===null?U=Object.getOwnPropertyDescriptor(z,H):U;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")K=Reflect.decorate(j,z,H,U);else for(var J=j.length-1;0<=J;J--)(it=j[J])&&(K=(at<3?it(K):3<at?it(z,H,K):it(z,H))||K);return 3<at&&K&&Object.defineProperty(z,H,K),K}([hi(function(j){return[j(0),j(1)]},z=>{var[z,H]=z;return rn(zi(0,1),Yn(z,H))})],sn);let ca=sa=class extends Pr{getDefaultOptions(){return{domain:[0,.5,1],unknown:void 0,nice:!1,clamp:!1,round:!1,interpolator:Xt,tickMethod:Te,tickCount:5}}constructor(j){super(j)}clone(){return new sa(this.options)}};ca=sa=function(j,z,H,U){var it,at=arguments.length,K=at<3?z:U===null?U=Object.getOwnPropertyDescriptor(z,H):U;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")K=Reflect.decorate(j,z,H,U);else for(var J=j.length-1;0<=J;J--)(it=j[J])&&(K=(at<3?it(K):3<at?it(z,H,K):it(z,H))||K);return 3<at&&K&&Object.defineProperty(z,H,K),K}([hi(function(j){return[j(0),j(.5),j(1)]},j=>{const[z,H,U]=j,it=rn(zi(0,.5),Yn(z,H)),at=rn(zi(.5,1),Yn(H,U));return K=>(z>U?K<H?at:it:K<H?it:at)(K)})],ca);function Gr(j,z,H,U,it){var at=new Pr({range:[z,z+U]}),K=new Pr({range:[H,H+it]});return{transform:function(ut){var ut=$(ut,2),ct=ut[0],ut=ut[1];return[at.map(ct),K.map(ut)]},untransform:function(ut){var ut=$(ut,2),ct=ut[0],ut=ut[1];return[at.invert(ct),K.invert(ut)]}}}function Na(j,z,H,U,it){return(0,$(j,1)[0])(z,H,U,it)}function Ol(j,z,H,U,it){return $(j,1)[0]}function Bd(ct,z,H,U,it){var at=(ct=$(ct,4))[0],K=ct[1],J=ct[2],ct=ct[3],ut=new Pr({range:[J,ct]}),Dt=new Pr({range:[at,K]}),Ht=1<(J=it/U)?1:J,ie=1<J?1/J:1;return{transform:function(Gt){var Gt=$(Gt,2),Jt=Gt[0],Gt=Gt[1],Jt=Dt.map(Jt),Gt=ut.map(Gt);return[.5*(Gt*Math.cos(Jt)*Ht)+.5,.5*(Gt*Math.sin(Jt)*ie)+.5]},untransform:function(Nt){var Nt=$(Nt,2),Jt=Nt[0],Nt=Nt[1],Jt=2*(Jt-.5)/Ht,Nt=2*(Nt-.5)/ie,Gt=Math.sqrt(Math.pow(Jt,2)+Math.pow(Nt,2)),Nt=pn(Math.atan2(Nt,Jt),at,K);return[Dt.invert(Nt),ut.invert(Gt)]}}}function rv(j,z,H,U,it){return{transform:function(K){var K=$(K,2),J=K[0];return[K[1],J]},untransform:function(K){var K=$(K,2),J=K[0];return[K[1],J]}}}function iv(j){for(var z=[],H=1;H<arguments.length;H++)z[H-1]=arguments[H];return Sl.apply(void 0,fe([[-1,-1]],$(z),!1))}function zd(j){for(var z=[],H=1;H<arguments.length;H++)z[H-1]=arguments[H];return Sl.apply(void 0,fe([[-1,1]],$(z),!1))}function Wd(j){for(var z=[],H=1;H<arguments.length;H++)z[H-1]=arguments[H];return Sl.apply(void 0,fe([[1,-1]],$(z),!1))}function Gd(K,z,H,U,it){var at,K=$(K,1)[0],J=bt();return J=J,K=K,at=Math.sin(K),K=Math.cos(K),J[0]=K,J[1]=at,J[2]=0,J[3]=-at,J[4]=K,J[5]=0,J[6]=0,J[7]=0,J[8]=1,J}function av(j,z,H,U,it){var at=(j=$(j,4))[0],K=j[1],J=j[2],ct=(j[3]-J)/(+K/(2*Math.PI)+1),ut=ct/(2*Math.PI),Dt=new Pr({range:[J,J+.99*ct]}),Ht=new Pr({range:[at,K]}),ie=1<(j=it/U)?1:j,Ft=1<j?1/j:1;return{transform:function(Nt){var Nt=$(Nt,2),Gt=Nt[0],Nt=Nt[1],Gt=Ht.map(Gt),Nt=Dt.map(Nt);return[.5*(Math.cos(Gt)*(ut*Gt+Nt)*ie)+.5,.5*(Math.sin(Gt)*(ut*Gt+Nt)*Ft)+.5]},untransform:function(Nt){var Nt=$(Nt,2),he=Nt[0],Nt=Nt[1],he=2*(he-.5)/ie,Nt=2*(Nt-.5)/Ft,Gt=Math.sqrt(Math.pow(he,2)+Math.pow(Nt,2)),Nt=pn(Math.atan2(Nt,he)+Math.floor(Gt/ct)*Math.PI*2,at,K),he=Gt-ut*Nt;return[Ht.invert(Nt),Dt.invert(he)]}}}function Uo(ct,z,H,U,it){var at=(ct=$(ct,4))[0],K=ct[1],J=ct[2],ct=ct[3],ut=new Pr({range:[J,ct]});return{transform:function(Dt){for(var Ht=[],ie=Dt.length,Ft=new xc({domain:new Array(ie).fill(0).map(function(he,ne){return ne}),range:[at,K]}),Jt=0;Jt<ie;Jt++){var Nt=Dt[Jt],Gt=Ft.map(Jt),Nt=ut.map(Nt);Ht.push(Gt,Nt)}return Ht},untransform:function(Dt){for(var Ht=[],ie=0;ie<Dt.length;ie+=2){var Ft=Dt[ie+1];Ht.push(ut.invert(Ft))}return Ht}}}var Sl=function(K,z,H,U,it){var K=$(K,2),at=K[0],K=K[1],J=bt();return at=[at,K],(K=J)[0]=at[0],K[1]=0,K[2]=0,K[3]=0,K[4]=at[1],K[5]=0,K[6]=0,K[7]=0,K[8]=1,K};function Oc(j){return 1/Math.tan(j)}function ov(j,z,H,U,it){var at=Oc($(j,1)[0]);return{transform:function(ct){var ct=$(ct,2),J=ct[0],ct=ct[1];return[J+ct*at,ct]},untransform:function(ct){var ct=$(ct,2),J=ct[0],ct=ct[1];return[J-ct*at,ct]}}}function sv(j,z,H,U,it){var at=Oc($(j,1)[0]);return{transform:function(J){var J=$(J,2),ct=J[0];return[ct,J[1]+ct*at]},untransform:function(J){var J=$(J,2),ct=J[0];return[ct,J[1]-ct*at]}}}function Sc(j,z,H,J,K){var at=j<z,K=(at?z-J:K-z)||K-J,J=at?-1:1;return J*K*(H+1)/(H+K/((j-z)*J))+z}function Ec(j,z,H,U,K){var at=j<z,K=(at?z-U:K-z)||K-U;return K/(K*(H+1)/(j-z)-H*(at?-1:1))+z}function xa(j,z,H){return H?new Pr({range:[0,1],domain:[0,z]}).map(j):j}function la(J,z,H,U,it){var at=(J=$(J,3))[0],K=J[1],J=J[2],ct=xa(at,U,J!==void 0&&J);return{transform:function(Ht){var Ht=$(Ht,2),Dt=Ht[0],Ht=Ht[1];return[Sc(Dt,ct,K,0,1),Ht]},untransform:function(Ht){var Ht=$(Ht,2),Dt=Ht[0],Ht=Ht[1];return[Ec(Dt,ct,K,0,1),Ht]}}}function Mc(J,z,H,U,it){var at=(J=$(J,3))[0],K=J[1],J=J[2],ct=xa(at,it,J!==void 0&&J);return{transform:function(ut){return ut=$(ut,2),[ut[0],Sc(ut[1],ct,K,0,1)]},untransform:function(ut){return ut=$(ut,2),[ut[0],Ec(ut[1],ct,K,0,1)]}}}function El(ut,z,H,U,it){var at=(ut=$(ut,5))[0],K=ut[1],J=ut[2],ct=ut[3],ut=ut[4],Dt=xa(at,U,ut=ut!==void 0&&ut),Ht=xa(K,it,ut);return{transform:function(Jt){var Jt=$(Jt,2),Ft=Jt[0],Jt=Jt[1];return[Sc(Ft,Dt,J,0,1),Sc(Jt,Ht,ct,0,1)]},untransform:function(Jt){var Jt=$(Jt,2),Ft=Jt[0],Jt=Jt[1];return[Ec(Ft,Dt,J,0,1),Ec(Jt,Ht,ct,0,1)]}}}function $d(ut,z,H,U,it){var at=(ut=$(ut,5))[0],K=ut[1],J=ut[2],ct=ut[3],ut=(ut=ut[4])!==void 0&&ut,Dt=new Pr({range:[0,U]}),Ht=new Pr({range:[0,it]}),ie=ut?at:Dt.map(at),Ft=ut?K:Ht.map(K);return{transform:function(Nt){var Nt=$(Nt,2),Gt=Nt[0],Nt=Nt[1],he=Dt.map(Gt)-ie,ne=Ht.map(Nt)-Ft,pe=Math.sqrt(he*he+ne*ne);return J<pe?[Gt,Nt]:(Gt=Sc(pe,0,ct,0,J),Nt=Math.atan2(ne,he),pe=ie+Gt*Math.cos(Nt),ne=Ft+Gt*Math.sin(Nt),[Dt.invert(pe),Ht.invert(ne)])},untransform:function(Nt){var Nt=$(Nt,2),Gt=Nt[0],Nt=Nt[1],he=Dt.map(Gt)-ie,ne=Ht.map(Nt)-Ft,pe=Math.sqrt(he*he+ne*ne);return J<pe?[Gt,Nt]:(Gt=Ec(pe,0,ct,0,J),Nt=Math.atan2(ne,he),pe=ie+Gt*Math.cos(Nt),ne=Ft+Gt*Math.sin(Nt),[Dt.invert(pe),Ht.invert(ne)])}}}function cv(j,z,H,U,it,at,K){var J=new Pr({range:[z,z+it]}),ct=new Pr({range:[H,H+at]}),ut=new Pr({range:[U,U+K]});return{transform:function(Ft){var Ft=$(Ft,3),Ht=Ft[0],ie=Ft[1],Ft=Ft[2];return[J.map(Ht),ct.map(ie),ut.map(Ft)]},untransform:function(Ft){var Ft=$(Ft,3),Ht=Ft[0],ie=Ft[1],Ft=Ft[2];return[J.invert(Ht),ct.invert(ie),ut.invert(Ft)]}}}function lv(Dt,z,H,U,it,at,K){var J,ct=(Dt=$(Dt,3))[0],ut=Dt[1],Dt=Dt[2];return J=xe(),ct=[ct,ut,Dt],J[0]=1,J[1]=0,J[2]=0,J[3]=0,J[4]=0,J[5]=1,J[6]=0,J[7]=0,J[8]=0,J[9]=0,J[10]=1,J[11]=0,J[12]=ct[0],J[13]=ct[1],J[14]=ct[2],J[15]=1,J}function er(j,z,H,U,it,at,K){return{transform:function(ct){var ct=$(ct,3),ut=ct[0];return[ct[1],ut,ct[2]]},untransform:function(ct){var ct=$(ct,3),ut=ct[0];return[ct[1],ut,ct[2]]}}}function Zd(Dt,z,H,U,it,at,K){var J,ct=(Dt=$(Dt,3))[0],ut=Dt[1],Dt=Dt[2];return J=xe(),ct=[ct,ut,Dt],J[0]=ct[0],J[1]=0,J[2]=0,J[3]=0,J[4]=0,J[5]=ct[1],J[6]=0,J[7]=0,J[8]=0,J[9]=0,J[10]=ct[2],J[11]=0,J[12]=0,J[13]=0,J[14]=0,J[15]=1,J}pi.prototype.update=function(j){this.options=ee({},this.options,j),this.recoordinate()},pi.prototype.clone=function(){return new pi(this.options)},pi.prototype.getOptions=function(){return this.options},pi.prototype.clear=function(){this.update({transformations:[]})},pi.prototype.getSize=function(){var j=this.options;return[j.width,j.height]},pi.prototype.getCenter=function(){var j=this.options,z=j.x,H=j.y;return[(2*z+j.width)/2,(2*H+j.height)/2]},pi.prototype.transform=function(){for(var j=[],z=0;z<arguments.length;z++)j[z]=arguments[z];var H=this.options.transformations;return this.update({transformations:fe(fe([],$(H),!1),[fe([],$(j),!1)],!1)}),this},pi.prototype.map=function(j){return this.output(j)},pi.prototype.invert=function(j){return this.input(j)},pi.prototype.recoordinate=function(){this.output=this.compose(),this.input=this.compose(!0)},pi.prototype.compose=function(j){function z(Ut,ve){var He;J.push((ve=ve===void 0?!0:ve)?(He=Ut,function(Si){for(var Ei=[],vi=0;vi<Si.length-1;vi+=2){var Mi=[Si[vi],Si[vi+1]],Mi=He(Mi);Ei.push.apply(Ei,fe([],$(Mi),!1))}return Ei}):Ut)}var H,U,it=(j=j===void 0?!1:j)?fe([],$(this.options.transformations),!1).reverse():this.options.transformations,at=j?function(Ut){return Ut.untransform}:function(Ut){return Ut.transform},K=[],J=[];try{for(var ct=oe(it),ut=ct.next();!ut.done;ut=ct.next()){var Dt,Ht,ie,Ft,Jt,Gt,Nt=$(ut.value),he=Nt[0],ne=Nt.slice(1),pe=this.transformers[he];pe&&(Ht=(Dt=this.options).x,ie=Dt.y,Ft=Dt.width,Jt=Dt.height,Ue(Gt=pe(fe([],$(ne),!1),Ht,ie,Ft,Jt))?K.push(Gt):(K.length&&(z(this.createMatrixTransform(K,j)),K.splice(0,K.length)),z(at(Gt)||Xt,he!=="parallel")))}}catch(Ut){H={error:Ut}}finally{try{ut&&!ut.done&&(U=ct.return)&&U.call(ct)}finally{if(H)throw H.error}}return K.length&&z(this.createMatrixTransform(K,j)),_n.apply(void 0,fe([],$(J),!1))},pi.prototype.createMatrixTransform=function(j,z){var H,U,it,at,K,J,ct,ut,Dt,Ht,ie,Ft,Jt=bt();return z&&j.reverse(),j.forEach(function(Gt){return Tt(Jt,Jt,Gt)}),z&&(z=j=Jt,(Ft=new St(9))[0]=z[0],Ft[1]=z[1],Ft[2]=z[2],Ft[3]=z[3],Ft[4]=z[4],Ft[5]=z[5],Ft[6]=z[6],Ft[7]=z[7],Ft[8]=z[8],Ft=(z=Ft)[0],H=z[1],U=z[2],it=z[3],at=z[4],K=z[5],J=z[6],ct=z[7],ut=(z=z[8])*at-K*ct,ie=Ft*ut+H*(Dt=-z*it+K*J)+U*(Ht=ct*it-at*J))&&(j[0]=ut*(ie=1/ie),j[1]=(-z*H+U*ct)*ie,j[2]=(K*H-U*at)*ie,j[3]=Dt*ie,j[4]=(z*Ft-U*J)*ie,j[5]=(-K*Ft+U*it)*ie,j[6]=Ht*ie,j[7]=(-ct*Ft+H*J)*ie,j[8]=(at*Ft-H*it)*ie),function(ve){var Nt,he,ne,pe,Ut,ve=[ve[0],ve[1],1];return ne=Jt,pe=(he=Nt=ve)[0],Ut=he[1],he=he[2],Nt[0]=pe*ne[0]+Ut*ne[3]+he*ne[6],Nt[1]=pe*ne[1]+Ut*ne[4]+he*ne[7],Nt[2]=pe*ne[2]+Ut*ne[5]+he*ne[8],[ve[0],ve[1]]}},qa=pi;function pi(j){this.options={x:0,y:0,width:300,height:150,transformations:[]},this.transformers={cartesian:Gr,translate:gn,custom:Na,matrix:Ol,polar:Bd,transpose:rv,scale:Sl,"shear.x":ov,"shear.y":sv,reflect:iv,"reflect.x":zd,"reflect.y":Wd,rotate:Gd,helix:av,parallel:Uo,fisheye:El,"fisheye.x":la,"fisheye.y":Mc,"fisheye.circular":$d},this.update(j)}Oi.prototype.update=function(j){this.options=ee({},this.options,j),this.recoordinate()},Oi.prototype.clone=function(){return new Oi(this.options)},Oi.prototype.getOptions=function(){return this.options},Oi.prototype.clear=function(){this.update({transformations:[]})},Oi.prototype.getSize=function(){var j=this.options;return[j.width,j.height,j.depth]},Oi.prototype.getCenter=function(){var j=this.options,z=j.x,H=j.y,U=j.z;return[(2*z+j.width)/2,(2*H+j.height)/2,(2*U+j.depth)/2]},Oi.prototype.transform=function(){for(var j=[],z=0;z<arguments.length;z++)j[z]=arguments[z];var H=this.options.transformations;return this.update({transformations:fe(fe([],$(H),!1),[fe([],$(j),!1)],!1)}),this},Oi.prototype.map=function(j){return this.output(j)},Oi.prototype.invert=function(j){return this.input(j)},Oi.prototype.recoordinate=function(){this.output=this.compose(),this.input=this.compose(!0)},Oi.prototype.compose=function(j){function z(He,Si){var Ei;J.push((Si=Si===void 0?!0:Si)?(Ei=He,function(vi){for(var Mi=[],Gi=0;Gi<vi.length-1;Gi+=3){var nr=[vi[Gi],vi[Gi+1],vi[Gi+2]],nr=Ei(nr);Mi.push.apply(Mi,fe([],$(nr),!1))}return Mi}):He)}var H,U,it=(j=j===void 0?!1:j)?fe([],$(this.options.transformations),!1).reverse():this.options.transformations,at=j?function(He){return He.untransform}:function(He){return He.transform},K=[],J=[];try{for(var ct=oe(it),ut=ct.next();!ut.done;ut=ct.next()){var Dt,Ht,ie,Ft,Jt,Gt,Nt,he,ne=$(ut.value),pe=ne[0],Ut=ne.slice(1),ve=this.transformers[pe];ve&&(Ht=(Dt=this.options).x,ie=Dt.y,Ft=Dt.z,Jt=Dt.width,Gt=Dt.height,Nt=Dt.depth,Ue(he=ve(fe([],$(Ut),!1),Ht,ie,Ft,Jt,Gt,Nt))?K.push(he):(K.length&&(z(this.createMatrixTransform(K,j)),K.splice(0,K.length)),z(at(he)||Xt,!0)))}}catch(He){H={error:He}}finally{try{ut&&!ut.done&&(U=ct.return)&&U.call(ct)}finally{if(H)throw H.error}}return K.length&&z(this.createMatrixTransform(K,j)),_n.apply(void 0,fe([],$(J),!1))},Oi.prototype.createMatrixTransform=function(j,z){var H,U,it,at,K,J,ct,ut,Dt,Ht,ie,Ft,Jt,Gt,Nt,he,ne,pe,Ut,ve,He,Si,Ei,vi,Mi,Gi,nr,wn,kc=xe();return z&&j.reverse(),j.forEach(function(Yd){return _e(kc,kc,Yd)}),z&&(z=j=kc,(wn=new St(16))[0]=z[0],wn[1]=z[1],wn[2]=z[2],wn[3]=z[3],wn[4]=z[4],wn[5]=z[5],wn[6]=z[6],wn[7]=z[7],wn[8]=z[8],wn[9]=z[9],wn[10]=z[10],wn[11]=z[11],wn[12]=z[12],wn[13]=z[13],wn[14]=z[14],wn[15]=z[15],wn=(z=wn)[0],H=z[1],U=z[2],it=z[3],at=z[4],K=z[5],J=z[6],ct=z[7],ut=z[8],Dt=z[9],Ht=z[10],ie=z[11],Ft=z[12],Jt=z[13],Gt=z[14],z=z[15],nr=(Nt=wn*K-H*at)*(Gi=Ht*z-ie*Gt)-(he=wn*J-U*at)*(Mi=Dt*z-ie*Jt)+(ne=wn*ct-it*at)*(vi=Dt*Gt-Ht*Jt)+(pe=H*J-U*K)*(Ei=ut*z-ie*Ft)-(Ut=H*ct-it*K)*(Si=ut*Gt-Ht*Ft)+(ve=U*ct-it*J)*(He=ut*Jt-Dt*Ft))&&(j[0]=(K*Gi-J*Mi+ct*vi)*(nr=1/nr),j[1]=(U*Mi-H*Gi-it*vi)*nr,j[2]=(Jt*ve-Gt*Ut+z*pe)*nr,j[3]=(Ht*Ut-Dt*ve-ie*pe)*nr,j[4]=(J*Ei-at*Gi-ct*Si)*nr,j[5]=(wn*Gi-U*Ei+it*Si)*nr,j[6]=(Gt*ne-Ft*ve-z*he)*nr,j[7]=(ut*ve-Ht*ne+ie*he)*nr,j[8]=(at*Mi-K*Ei+ct*He)*nr,j[9]=(H*Ei-wn*Mi-it*He)*nr,j[10]=(Ft*Ut-Jt*ne+z*Nt)*nr,j[11]=(Dt*ne-ut*Ut-ie*Nt)*nr,j[12]=(K*Si-at*vi-J*He)*nr,j[13]=(wn*vi-H*Si+U*He)*nr,j[14]=(Jt*he-Ft*pe-Gt*Nt)*nr,j[15]=(ut*pe-Dt*he+Ht*Nt)*nr),function(Ka){var Ac,_a,Cr,Cs,Ls,Rs,Ka=[Ka[0],Ka[1],Ka[2],1];return Cr=kc,Cs=(_a=Ac=Ka)[0],Ls=_a[1],Rs=_a[2],_a=_a[3],Ac[0]=Cr[0]*Cs+Cr[4]*Ls+Cr[8]*Rs+Cr[12]*_a,Ac[1]=Cr[1]*Cs+Cr[5]*Ls+Cr[9]*Rs+Cr[13]*_a,Ac[2]=Cr[2]*Cs+Cr[6]*Ls+Cr[10]*Rs+Cr[14]*_a,Ac[3]=Cr[3]*Cs+Cr[7]*Ls+Cr[11]*Rs+Cr[15]*_a,[Ka[0],Ka[1],Ka[2]]}},wi=Oi;function Oi(j){this.options={x:0,y:0,z:0,width:300,height:150,depth:150,transformations:[]},this.transformers={cartesian3D:cv,translate3D:lv,scale3D:Zd,transpose3D:er},this.update(j)}pt.Coordinate=qa,pt.Coordinate3D=wi,Object.defineProperty(pt,"__esModule",{value:!0})})},15746:function(Ae,Be,pt){"use strict";var oe=pt(21584);Be.Z=oe.Z},71230:function(Ae,Be,pt){"use strict";var oe=pt(17621);Be.Z=oe.Z},8874:function(Ae){"use strict";Ae.exports={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]}},19818:function(Ae,Be,pt){var oe=pt(8874),$=pt(86851),fe=Object.hasOwnProperty,Ye=Object.create(null);for(var ae in oe)fe.call(oe,ae)&&(Ye[oe[ae]]=ae);var Rt=Ae.exports={to:{},get:{}};Rt.get=function(ft){var re=ft.substring(0,3).toLowerCase(),Wt,ee;switch(re){case"hsl":Wt=Rt.get.hsl(ft),ee="hsl";break;case"hwb":Wt=Rt.get.hwb(ft),ee="hwb";break;default:Wt=Rt.get.rgb(ft),ee="rgb";break}return Wt?{model:ee,value:Wt}:null},Rt.get.rgb=function(ft){if(!ft)return null;var re=/^#([a-f0-9]{3,4})$/i,Wt=/^#([a-f0-9]{6})([a-f0-9]{2})?$/i,ee=/^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/,Xt=/^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/,kt=/^(\w+)$/,St=[0,0,0,1],bt,Tt,xe;if(bt=ft.match(Wt)){for(xe=bt[2],bt=bt[1],Tt=0;Tt<3;Tt++){var _e=Tt*2;St[Tt]=parseInt(bt.slice(_e,_e+2),16)}xe&&(St[3]=parseInt(xe,16)/255)}else if(bt=ft.match(re)){for(bt=bt[1],xe=bt[3],Tt=0;Tt<3;Tt++)St[Tt]=parseInt(bt[Tt]+bt[Tt],16);xe&&(St[3]=parseInt(xe+xe,16)/255)}else if(bt=ft.match(ee)){for(Tt=0;Tt<3;Tt++)St[Tt]=parseInt(bt[Tt+1],0);bt[4]&&(bt[5]?St[3]=parseFloat(bt[4])*.01:St[3]=parseFloat(bt[4]))}else if(bt=ft.match(Xt)){for(Tt=0;Tt<3;Tt++)St[Tt]=Math.round(parseFloat(bt[Tt+1])*2.55);bt[4]&&(bt[5]?St[3]=parseFloat(bt[4])*.01:St[3]=parseFloat(bt[4]))}else return(bt=ft.match(kt))?bt[1]==="transparent"?[0,0,0,0]:fe.call(oe,bt[1])?(St=oe[bt[1]],St[3]=1,St):null:null;for(Tt=0;Tt<3;Tt++)St[Tt]=qt(St[Tt],0,255);return St[3]=qt(St[3],0,1),St},Rt.get.hsl=function(ft){if(!ft)return null;var re=/^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/,Wt=ft.match(re);if(Wt){var ee=parseFloat(Wt[4]),Xt=(parseFloat(Wt[1])%360+360)%360,kt=qt(parseFloat(Wt[2]),0,100),St=qt(parseFloat(Wt[3]),0,100),bt=qt(isNaN(ee)?1:ee,0,1);return[Xt,kt,St,bt]}return null},Rt.get.hwb=function(ft){if(!ft)return null;var re=/^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/,Wt=ft.match(re);if(Wt){var ee=parseFloat(Wt[4]),Xt=(parseFloat(Wt[1])%360+360)%360,kt=qt(parseFloat(Wt[2]),0,100),St=qt(parseFloat(Wt[3]),0,100),bt=qt(isNaN(ee)?1:ee,0,1);return[Xt,kt,St,bt]}return null},Rt.to.hex=function(){var ft=$(arguments);return"#"+Yt(ft[0])+Yt(ft[1])+Yt(ft[2])+(ft[3]<1?Yt(Math.round(ft[3]*255)):"")},Rt.to.rgb=function(){var ft=$(arguments);return ft.length<4||ft[3]===1?"rgb("+Math.round(ft[0])+", "+Math.round(ft[1])+", "+Math.round(ft[2])+")":"rgba("+Math.round(ft[0])+", "+Math.round(ft[1])+", "+Math.round(ft[2])+", "+ft[3]+")"},Rt.to.rgb.percent=function(){var ft=$(arguments),re=Math.round(ft[0]/255*100),Wt=Math.round(ft[1]/255*100),ee=Math.round(ft[2]/255*100);return ft.length<4||ft[3]===1?"rgb("+re+"%, "+Wt+"%, "+ee+"%)":"rgba("+re+"%, "+Wt+"%, "+ee+"%, "+ft[3]+")"},Rt.to.hsl=function(){var ft=$(arguments);return ft.length<4||ft[3]===1?"hsl("+ft[0]+", "+ft[1]+"%, "+ft[2]+"%)":"hsla("+ft[0]+", "+ft[1]+"%, "+ft[2]+"%, "+ft[3]+")"},Rt.to.hwb=function(){var ft=$(arguments),re="";return ft.length>=4&&ft[3]!==1&&(re=", "+ft[3]),"hwb("+ft[0]+", "+ft[1]+"%, "+ft[2]+"%"+re+")"},Rt.to.keyword=function(ft){return Ye[ft.slice(0,3)]};function qt(ft,re,Wt){return Math.min(Math.max(re,ft),Wt)}function Yt(ft){var re=Math.round(ft).toString(16).toUpperCase();return re.length<2?"0"+re:re}},26729:function(Ae){"use strict";var Be=Object.prototype.hasOwnProperty,pt="~";function oe(){}Object.create&&(oe.prototype=Object.create(null),new oe().__proto__||(pt=!1));function $(Rt,qt,Yt){this.fn=Rt,this.context=qt,this.once=Yt||!1}function fe(Rt,qt,Yt,ft,re){if(typeof Yt!="function")throw new TypeError("The listener must be a function");var Wt=new $(Yt,ft||Rt,re),ee=pt?pt+qt:qt;return Rt._events[ee]?Rt._events[ee].fn?Rt._events[ee]=[Rt._events[ee],Wt]:Rt._events[ee].push(Wt):(Rt._events[ee]=Wt,Rt._eventsCount++),Rt}function Ye(Rt,qt){--Rt._eventsCount===0?Rt._events=new oe:delete Rt._events[qt]}function ae(){this._events=new oe,this._eventsCount=0}ae.prototype.eventNames=function(){var qt=[],Yt,ft;if(this._eventsCount===0)return qt;for(ft in Yt=this._events)Be.call(Yt,ft)&&qt.push(pt?ft.slice(1):ft);return Object.getOwnPropertySymbols?qt.concat(Object.getOwnPropertySymbols(Yt)):qt},ae.prototype.listeners=function(qt){var Yt=pt?pt+qt:qt,ft=this._events[Yt];if(!ft)return[];if(ft.fn)return[ft.fn];for(var re=0,Wt=ft.length,ee=new Array(Wt);re<Wt;re++)ee[re]=ft[re].fn;return ee},ae.prototype.listenerCount=function(qt){var Yt=pt?pt+qt:qt,ft=this._events[Yt];return ft?ft.fn?1:ft.length:0},ae.prototype.emit=function(qt,Yt,ft,re,Wt,ee){var Xt=pt?pt+qt:qt;if(!this._events[Xt])return!1;var kt=this._events[Xt],St=arguments.length,bt,Tt;if(kt.fn){switch(kt.once&&this.removeListener(qt,kt.fn,void 0,!0),St){case 1:return kt.fn.call(kt.context),!0;case 2:return kt.fn.call(kt.context,Yt),!0;case 3:return kt.fn.call(kt.context,Yt,ft),!0;case 4:return kt.fn.call(kt.context,Yt,ft,re),!0;case 5:return kt.fn.call(kt.context,Yt,ft,re,Wt),!0;case 6:return kt.fn.call(kt.context,Yt,ft,re,Wt,ee),!0}for(Tt=1,bt=new Array(St-1);Tt<St;Tt++)bt[Tt-1]=arguments[Tt];kt.fn.apply(kt.context,bt)}else{var xe=kt.length,_e;for(Tt=0;Tt<xe;Tt++)switch(kt[Tt].once&&this.removeListener(qt,kt[Tt].fn,void 0,!0),St){case 1:kt[Tt].fn.call(kt[Tt].context);break;case 2:kt[Tt].fn.call(kt[Tt].context,Yt);break;case 3:kt[Tt].fn.call(kt[Tt].context,Yt,ft);break;case 4:kt[Tt].fn.call(kt[Tt].context,Yt,ft,re);break;default:if(!bt)for(_e=1,bt=new Array(St-1);_e<St;_e++)bt[_e-1]=arguments[_e];kt[Tt].fn.apply(kt[Tt].context,bt)}}return!0},ae.prototype.on=function(qt,Yt,ft){return fe(this,qt,Yt,ft,!1)},ae.prototype.once=function(qt,Yt,ft){return fe(this,qt,Yt,ft,!0)},ae.prototype.removeListener=function(qt,Yt,ft,re){var Wt=pt?pt+qt:qt;if(!this._events[Wt])return this;if(!Yt)return Ye(this,Wt),this;var ee=this._events[Wt];if(ee.fn)ee.fn===Yt&&(!re||ee.once)&&(!ft||ee.context===ft)&&Ye(this,Wt);else{for(var Xt=0,kt=[],St=ee.length;Xt<St;Xt++)(ee[Xt].fn!==Yt||re&&!ee[Xt].once||ft&&ee[Xt].context!==ft)&&kt.push(ee[Xt]);kt.length?this._events[Wt]=kt.length===1?kt[0]:kt:Ye(this,Wt)}return this},ae.prototype.removeAllListeners=function(qt){var Yt;return qt?(Yt=pt?pt+qt:qt,this._events[Yt]&&Ye(this,Yt)):(this._events=new oe,this._eventsCount=0),this},ae.prototype.off=ae.prototype.removeListener,ae.prototype.addListener=ae.prototype.on,ae.prefixed=pt,ae.EventEmitter=ae,Ae.exports=ae},69916:function(Ae,Be){(function(pt,oe){oe(Be)})(this,function(pt){"use strict";function oe(Xt,kt,St,bt){bt=bt||{};var Tt=bt.maxIterations||100,xe=bt.tolerance||1e-10,_e=Xt(kt),_n=Xt(St),Ue=St-kt;if(_e*_n>0)throw"Initial bisect points must have opposite signs";if(_e===0)return kt;if(_n===0)return St;for(var pn=0;pn<Tt;++pn){Ue/=2;var gn=kt+Ue,rn=Xt(gn);if(rn*_e>=0&&(kt=gn),Math.abs(Ue)<xe||rn===0)return gn}return kt+Ue}function $(Xt){for(var kt=new Array(Xt),St=0;St<Xt;++St)kt[St]=0;return kt}function fe(Xt,kt){return $(Xt).map(function(){return $(kt)})}function Ye(Xt,kt){for(var St=0,bt=0;bt<Xt.length;++bt)St+=Xt[bt]*kt[bt];return St}function ae(Xt){return Math.sqrt(Ye(Xt,Xt))}function Rt(Xt,kt,St){for(var bt=0;bt<kt.length;++bt)Xt[bt]=kt[bt]*St}function qt(Xt,kt,St,bt,Tt){for(var xe=0;xe<Xt.length;++xe)Xt[xe]=kt*St[xe]+bt*Tt[xe]}function Yt(Xt,kt,St){St=St||{};var bt=St.maxIterations||kt.length*200,Tt=St.nonZeroDelta||1.05,xe=St.zeroDelta||.001,_e=St.minErrorDelta||1e-6,_n=St.minErrorDelta||1e-5,Ue=St.rho!==void 0?St.rho:1,pn=St.chi!==void 0?St.chi:2,gn=St.psi!==void 0?St.psi:-.5,rn=St.sigma!==void 0?St.sigma:.5,Yn,Jn=kt.length,Ce=new Array(Jn+1);Ce[0]=kt,Ce[0].fx=Xt(kt),Ce[0].id=0;for(var Se=0;Se<Jn;++Se){var zr=kt.slice();zr[Se]=zr[Se]?zr[Se]*Tt:xe,Ce[Se+1]=zr,Ce[Se+1].fx=Xt(zr),Ce[Se+1].id=Se+1}function di(Or){for(var yn=0;yn<Or.length;yn++)Ce[Jn][yn]=Or[yn];Ce[Jn].fx=Or.fx}for(var Fi=function(Or,yn){return Or.fx-yn.fx},hi=kt.slice(),tr=kt.slice(),rt=kt.slice(),aa=kt.slice(),Bi=0;Bi<bt;++Bi){if(Ce.sort(Fi),St.history){var Wr=Ce.map(function(Or){var yn=Or.slice();return yn.fx=Or.fx,yn.id=Or.id,yn});Wr.sort(function(Or,yn){return Or.id-yn.id}),St.history.push({x:Ce[0].slice(),fx:Ce[0].fx,simplex:Wr})}for(Yn=0,Se=0;Se<Jn;++Se)Yn=Math.max(Yn,Math.abs(Ce[0][Se]-Ce[1][Se]));if(Math.abs(Ce[0].fx-Ce[Jn].fx)<_e&&Yn<_n)break;for(Se=0;Se<Jn;++Se){hi[Se]=0;for(var ya=0;ya<Jn;++ya)hi[Se]+=Ce[ya][Se];hi[Se]/=Jn}var oa=Ce[Jn];if(qt(tr,1+Ue,hi,-Ue,oa),tr.fx=Xt(tr),tr.fx<Ce[0].fx)qt(aa,1+pn,hi,-pn,oa),aa.fx=Xt(aa),aa.fx<tr.fx?di(aa):di(tr);else if(tr.fx>=Ce[Jn-1].fx){var ks=!1;if(tr.fx>oa.fx?(qt(rt,1+gn,hi,-gn,oa),rt.fx=Xt(rt),rt.fx<oa.fx?di(rt):ks=!0):(qt(rt,1-gn*Ue,hi,gn*Ue,oa),rt.fx=Xt(rt),rt.fx<tr.fx?di(rt):ks=!0),ks){if(rn>=1)break;for(Se=1;Se<Ce.length;++Se)qt(Ce[Se],1-rn,Ce[0],rn,Ce[Se]),Ce[Se].fx=Xt(Ce[Se])}}else di(tr)}return Ce.sort(Fi),{fx:Ce[0].fx,x:Ce[0]}}function ft(Xt,kt,St,bt,Tt,xe,_e){var _n=St.fx,Ue=Ye(St.fxprime,kt),pn=_n,gn=_n,rn=Ue,Yn=0;Tt=Tt||1,xe=xe||1e-6,_e=_e||.1;function Jn(Se,zr,di){for(var Fi=0;Fi<16;++Fi)if(Tt=(Se+zr)/2,qt(bt.x,1,St.x,Tt,kt),pn=bt.fx=Xt(bt.x,bt.fxprime),rn=Ye(bt.fxprime,kt),pn>_n+xe*Tt*Ue||pn>=di)zr=Tt;else{if(Math.abs(rn)<=-_e*Ue)return Tt;rn*(zr-Se)>=0&&(zr=Se),Se=Tt,di=pn}return 0}for(var Ce=0;Ce<10;++Ce){if(qt(bt.x,1,St.x,Tt,kt),pn=bt.fx=Xt(bt.x,bt.fxprime),rn=Ye(bt.fxprime,kt),pn>_n+xe*Tt*Ue||Ce&&pn>=gn)return Jn(Yn,Tt,gn);if(Math.abs(rn)<=-_e*Ue)return Tt;if(rn>=0)return Jn(Tt,Yn,pn);gn=pn,Yn=Tt,Tt*=2}return Tt}function re(Xt,kt,St){var bt={x:kt.slice(),fx:0,fxprime:kt.slice()},Tt={x:kt.slice(),fx:0,fxprime:kt.slice()},xe=kt.slice(),_e,_n,Ue=1,pn;St=St||{},pn=St.maxIterations||kt.length*20,bt.fx=Xt(bt.x,bt.fxprime),_e=bt.fxprime.slice(),Rt(_e,bt.fxprime,-1);for(var gn=0;gn<pn;++gn){if(Ue=ft(Xt,_e,bt,Tt,Ue),St.history&&St.history.push({x:bt.x.slice(),fx:bt.fx,fxprime:bt.fxprime.slice(),alpha:Ue}),!Ue)Rt(_e,bt.fxprime,-1);else{qt(xe,1,Tt.fxprime,-1,bt.fxprime);var rn=Ye(bt.fxprime,bt.fxprime),Yn=Math.max(0,Ye(xe,Tt.fxprime)/rn);qt(_e,Yn,_e,-1,Tt.fxprime),_n=bt,bt=Tt,Tt=_n}if(ae(bt.fxprime)<=1e-5)break}return St.history&&St.history.push({x:bt.x.slice(),fx:bt.fx,fxprime:bt.fxprime.slice(),alpha:Ue}),bt}function Wt(Xt,kt,St){St=St||{};for(var bt=St.maxIterations||kt.length*100,Tt=St.learnRate||.001,xe={x:kt.slice(),fx:0,fxprime:kt.slice()},_e=0;_e<bt&&(xe.fx=Xt(xe.x,xe.fxprime),St.history&&St.history.push({x:xe.x.slice(),fx:xe.fx,fxprime:xe.fxprime.slice()}),qt(xe.x,1,xe.x,-Tt,xe.fxprime),!(ae(xe.fxprime)<=1e-5));++_e);return xe}function ee(Xt,kt,St){St=St||{};var bt={x:kt.slice(),fx:0,fxprime:kt.slice()},Tt={x:kt.slice(),fx:0,fxprime:kt.slice()},xe=St.maxIterations||kt.length*100,_e=St.learnRate||1,_n=kt.slice(),Ue=St.c1||.001,pn=St.c2||.1,gn,rn=[];if(St.history){var Yn=Xt;Xt=function(Ce,Se){return rn.push(Ce.slice()),Yn(Ce,Se)}}bt.fx=Xt(bt.x,bt.fxprime);for(var Jn=0;Jn<xe&&(Rt(_n,bt.fxprime,-1),_e=ft(Xt,_n,bt,Tt,_e,Ue,pn),St.history&&(St.history.push({x:bt.x.slice(),fx:bt.fx,fxprime:bt.fxprime.slice(),functionCalls:rn,learnRate:_e,alpha:_e}),rn=[]),gn=bt,bt=Tt,Tt=gn,!(_e===0||ae(bt.fxprime)<1e-5));++Jn);return bt}pt.bisect=oe,pt.nelderMead=Yt,pt.conjugateGradient=re,pt.gradientDescent=Wt,pt.gradientDescentLineSearch=ee,pt.zeros=$,pt.zerosM=fe,pt.norm2=ae,pt.weightedSum=qt,pt.scale=Rt})},96486:function(Ae,Be,pt){Ae=pt.nmd(Ae);var oe;(function(){var $,fe="4.17.21",Ye=200,ae="Unsupported core-js use. Try https://npms.io/search?q=ponyfill.",Rt="Expected a function",qt="Invalid `variable` option passed into `_.template`",Yt="__lodash_hash_undefined__",ft=500,re="__lodash_placeholder__",Wt=1,ee=2,Xt=4,kt=1,St=2,bt=1,Tt=2,xe=4,_e=8,_n=16,Ue=32,pn=64,gn=128,rn=256,Yn=512,Jn=30,Ce="...",Se=800,zr=16,di=1,Fi=2,hi=3,tr=1/0,rt=9007199254740991,aa=17976931348623157e292,Bi=NaN,Wr=4294967295,ya=Wr-1,oa=Wr>>>1,ks=[["ary",gn],["bind",bt],["bindKey",Tt],["curry",_e],["curryRight",_n],["flip",Yn],["partial",Ue],["partialRight",pn],["rearg",rn]],Or="[object Arguments]",yn="[object Array]",Xa="[object AsyncFunction]",Ua="[object Boolean]",As="[object Date]",Ts="[object DOMException]",Xo="[object Error]",zi="[object Function]",ma="[object GeneratorFunction]",_i="[object Map]",ba="[object Number]",Gu="[object Null]",Wi="[object Object]",bc="[object Promise]",wl="[object Proxy]",Ee="[object RegExp]",xt="[object Set]",Ot="[object String]",ln="[object Symbol]",De="[object Undefined]",Me="[object WeakMap]",Te="[object WeakSet]",Ps="[object ArrayBuffer]",Lo="[object DataView]",un="[object Float32Array]",Hn="[object Float64Array]",Pr="[object Int8Array]",xc="[object Int16Array]",_c="[object Int32Array]",wc="[object Uint8Array]",qa="[object Uint8ClampedArray]",me="[object Uint16Array]",wi="[object Uint32Array]",sa=/\b__p \+= '';/g,sn=/\b(__p \+=) '' \+/g,ca=/(__e\(.*?\)|\b__t\)) \+\n'';/g,Gr=/&(?:amp|lt|gt|quot|#39);/g,Na=/[&<>"']/g,Ol=RegExp(Gr.source),Bd=RegExp(Na.source),rv=/<%-([\s\S]+?)%>/g,iv=/<%([\s\S]+?)%>/g,zd=/<%=([\s\S]+?)%>/g,Wd=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,Gd=/^\w*$/,av=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,Uo=/[\\^$.*+?()[\]{}|]/g,Sl=RegExp(Uo.source),Oc=/^\s+/,ov=/\s/,sv=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,Sc=/\{\n\/\* \[wrapped with (.+)\] \*/,Ec=/,? & /,xa=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,la=/[()=,{}\[\]\/\s]/,Mc=/\\(\\)?/g,El=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,$d=/\w*$/,cv=/^[-+]0x[0-9a-f]+$/i,lv=/^0b[01]+$/i,er=/^\[object .+?Constructor\]$/,Zd=/^0o[0-7]+$/i,pi=/^(?:0|[1-9]\d*)$/,Oi=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,j=/($^)/,z=/['\n\r\u2028\u2029\\]/g,H="\\ud800-\\udfff",U="\\u0300-\\u036f",it="\\ufe20-\\ufe2f",at="\\u20d0-\\u20ff",K=U+it+at,J="\\u2700-\\u27bf",ct="a-z\\xdf-\\xf6\\xf8-\\xff",ut="\\xac\\xb1\\xd7\\xf7",Dt="\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf",Ht="\\u2000-\\u206f",ie=" \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",Ft="A-Z\\xc0-\\xd6\\xd8-\\xde",Jt="\\ufe0e\\ufe0f",Gt=ut+Dt+Ht+ie,Nt="['\u2019]",he="["+H+"]",ne="["+Gt+"]",pe="["+K+"]",Ut="\\d+",ve="["+J+"]",He="["+ct+"]",Si="[^"+H+Gt+Ut+J+ct+Ft+"]",Ei="\\ud83c[\\udffb-\\udfff]",vi="(?:"+pe+"|"+Ei+")",Mi="[^"+H+"]",Gi="(?:\\ud83c[\\udde6-\\uddff]){2}",nr="[\\ud800-\\udbff][\\udc00-\\udfff]",wn="["+Ft+"]",kc="\\u200d",Yd="(?:"+He+"|"+Si+")",Ac="(?:"+wn+"|"+Si+")",_a="(?:"+Nt+"(?:d|ll|m|re|s|t|ve))?",Cr="(?:"+Nt+"(?:D|LL|M|RE|S|T|VE))?",Cs=vi+"?",Ls="["+Jt+"]?",Rs="(?:"+kc+"(?:"+[Mi,Gi,nr].join("|")+")"+Ls+Cs+")*",Ka="\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",iM="\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])",uv=Ls+Cs+Rs,aM="(?:"+[ve,Gi,nr].join("|")+")"+uv,Ro="(?:"+[Mi+pe+"?",pe,Gi,nr,he].join("|")+")",oM=RegExp(Nt,"g"),sM=RegExp(pe,"g"),fv=RegExp(Ei+"(?="+Ei+")|"+Ro+uv,"g"),xb=RegExp([wn+"?"+He+"+"+_a+"(?="+[ne,wn,"$"].join("|")+")",Ac+"+"+Cr+"(?="+[ne,wn+Yd,"$"].join("|")+")",wn+"?"+Yd+"+"+_a,wn+"+"+Cr,iM,Ka,Ut,aM].join("|"),"g"),_b=RegExp("["+kc+H+K+Jt+"]"),cM=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,lM=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],uM=-1,cr={};cr[un]=cr[Hn]=cr[Pr]=cr[xc]=cr[_c]=cr[wc]=cr[qa]=cr[me]=cr[wi]=!0,cr[Or]=cr[yn]=cr[Ps]=cr[Ua]=cr[Lo]=cr[As]=cr[Xo]=cr[zi]=cr[_i]=cr[ba]=cr[Wi]=cr[Ee]=cr[xt]=cr[Ot]=cr[Me]=!1;var rr={};rr[Or]=rr[yn]=rr[Ps]=rr[Lo]=rr[Ua]=rr[As]=rr[un]=rr[Hn]=rr[Pr]=rr[xc]=rr[_c]=rr[_i]=rr[ba]=rr[Wi]=rr[Ee]=rr[xt]=rr[Ot]=rr[ln]=rr[wc]=rr[qa]=rr[me]=rr[wi]=!0,rr[Xo]=rr[zi]=rr[Me]=!1;var fM={\u00C0:"A",\u00C1:"A",\u00C2:"A",\u00C3:"A",\u00C4:"A",\u00C5:"A",\u00E0:"a",\u00E1:"a",\u00E2:"a",\u00E3:"a",\u00E4:"a",\u00E5:"a",\u00C7:"C",\u00E7:"c",\u00D0:"D",\u00F0:"d",\u00C8:"E",\u00C9:"E",\u00CA:"E",\u00CB:"E",\u00E8:"e",\u00E9:"e",\u00EA:"e",\u00EB:"e",\u00CC:"I",\u00CD:"I",\u00CE:"I",\u00CF:"I",\u00EC:"i",\u00ED:"i",\u00EE:"i",\u00EF:"i",\u00D1:"N",\u00F1:"n",\u00D2:"O",\u00D3:"O",\u00D4:"O",\u00D5:"O",\u00D6:"O",\u00D8:"O",\u00F2:"o",\u00F3:"o",\u00F4:"o",\u00F5:"o",\u00F6:"o",\u00F8:"o",\u00D9:"U",\u00DA:"U",\u00DB:"U",\u00DC:"U",\u00F9:"u",\u00FA:"u",\u00FB:"u",\u00FC:"u",\u00DD:"Y",\u00FD:"y",\u00FF:"y",\u00C6:"Ae",\u00E6:"ae",\u00DE:"Th",\u00FE:"th",\u00DF:"ss",\u0100:"A",\u0102:"A",\u0104:"A",\u0101:"a",\u0103:"a",\u0105:"a",\u0106:"C",\u0108:"C",\u010A:"C",\u010C:"C",\u0107:"c",\u0109:"c",\u010B:"c",\u010D:"c",\u010E:"D",\u0110:"D",\u010F:"d",\u0111:"d",\u0112:"E",\u0114:"E",\u0116:"E",\u0118:"E",\u011A:"E",\u0113:"e",\u0115:"e",\u0117:"e",\u0119:"e",\u011B:"e",\u011C:"G",\u011E:"G",\u0120:"G",\u0122:"G",\u011D:"g",\u011F:"g",\u0121:"g",\u0123:"g",\u0124:"H",\u0126:"H",\u0125:"h",\u0127:"h",\u0128:"I",\u012A:"I",\u012C:"I",\u012E:"I",\u0130:"I",\u0129:"i",\u012B:"i",\u012D:"i",\u012F:"i",\u0131:"i",\u0134:"J",\u0135:"j",\u0136:"K",\u0137:"k",\u0138:"k",\u0139:"L",\u013B:"L",\u013D:"L",\u013F:"L",\u0141:"L",\u013A:"l",\u013C:"l",\u013E:"l",\u0140:"l",\u0142:"l",\u0143:"N",\u0145:"N",\u0147:"N",\u014A:"N",\u0144:"n",\u0146:"n",\u0148:"n",\u014B:"n",\u014C:"O",\u014E:"O",\u0150:"O",\u014D:"o",\u014F:"o",\u0151:"o",\u0154:"R",\u0156:"R",\u0158:"R",\u0155:"r",\u0157:"r",\u0159:"r",\u015A:"S",\u015C:"S",\u015E:"S",\u0160:"S",\u015B:"s",\u015D:"s",\u015F:"s",\u0161:"s",\u0162:"T",\u0164:"T",\u0166:"T",\u0163:"t",\u0165:"t",\u0167:"t",\u0168:"U",\u016A:"U",\u016C:"U",\u016E:"U",\u0170:"U",\u0172:"U",\u0169:"u",\u016B:"u",\u016D:"u",\u016F:"u",\u0171:"u",\u0173:"u",\u0174:"W",\u0175:"w",\u0176:"Y",\u0177:"y",\u0178:"Y",\u0179:"Z",\u017B:"Z",\u017D:"Z",\u017A:"z",\u017C:"z",\u017E:"z",\u0132:"IJ",\u0133:"ij",\u0152:"Oe",\u0153:"oe",\u0149:"'n",\u017F:"s"},dM={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"},hM={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"',"&#39;":"'"},Wn={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},dv=parseFloat,Tc=parseInt,Hd=typeof pt.g=="object"&&pt.g&&pt.g.Object===Object&&pt.g,Vd=typeof self=="object"&&self&&self.Object===Object&&self,lr=Hd||Vd||Function("return this")(),Xd=Be&&!Be.nodeType&&Be,$i=Xd&&!0&&Ae&&!Ae.nodeType&&Ae,hv=$i&&$i.exports===Xd,$u=hv&&Hd.process,Gn=function(){try{var ot=$i&&$i.require&&$i.require("util").types;return ot||$u&&$u.binding&&$u.binding("util")}catch(_t){}}(),Ns=Gn&&Gn.isArrayBuffer,Ud=Gn&&Gn.isDate,pv=Gn&&Gn.isMap,qd=Gn&&Gn.isRegExp,Kd=Gn&&Gn.isSet,vv=Gn&&Gn.isTypedArray;function Lr(ot,_t,vt){switch(vt.length){case 0:return ot.call(_t);case 1:return ot.call(_t,vt[0]);case 2:return ot.call(_t,vt[0],vt[1]);case 3:return ot.call(_t,vt[0],vt[1],vt[2])}return ot.apply(_t,vt)}function Is(ot,_t,vt,se){for(var ze=-1,Sn=ot==null?0:ot.length;++ze<Sn;){var ei=ot[ze];_t(se,ei,vt(ei),ot)}return se}function ua(ot,_t){for(var vt=-1,se=ot==null?0:ot.length;++vt<se&&_t(ot[vt],vt,ot)!==!1;);return ot}function gv(ot,_t){for(var vt=ot==null?0:ot.length;vt--&&_t(ot[vt],vt,ot)!==!1;);return ot}function Qd(ot,_t){for(var vt=-1,se=ot==null?0:ot.length;++vt<se;)if(!_t(ot[vt],vt,ot))return!1;return!0}function Qa(ot,_t){for(var vt=-1,se=ot==null?0:ot.length,ze=0,Sn=[];++vt<se;){var ei=ot[vt];_t(ei,vt,ot)&&(Sn[ze++]=ei)}return Sn}function Ml(ot,_t){var vt=ot==null?0:ot.length;return!!vt&&Cc(ot,_t,0)>-1}function Jd(ot,_t,vt){for(var se=-1,ze=ot==null?0:ot.length;++se<ze;)if(vt(_t,ot[se]))return!0;return!1}function $n(ot,_t){for(var vt=-1,se=ot==null?0:ot.length,ze=Array(se);++vt<se;)ze[vt]=_t(ot[vt],vt,ot);return ze}function fa(ot,_t){for(var vt=-1,se=_t.length,ze=ot.length;++vt<se;)ot[ze+vt]=_t[vt];return ot}function Pc(ot,_t,vt,se){var ze=-1,Sn=ot==null?0:ot.length;for(se&&Sn&&(vt=ot[++ze]);++ze<Sn;)vt=_t(vt,ot[ze],ze,ot);return vt}function wb(ot,_t,vt,se){var ze=ot==null?0:ot.length;for(se&&ze&&(vt=ot[--ze]);ze--;)vt=_t(vt,ot[ze],ze,ot);return vt}function Ds(ot,_t){for(var vt=-1,se=ot==null?0:ot.length;++vt<se;)if(_t(ot[vt],vt,ot))return!0;return!1}var th=Yu("length");function Ob(ot){return ot.split("")}function yv(ot){return ot.match(xa)||[]}function mv(ot,_t,vt){var se;return vt(ot,function(ze,Sn,ei){if(_t(ze,Sn,ei))return se=Sn,!1}),se}function Zu(ot,_t,vt,se){for(var ze=ot.length,Sn=vt+(se?1:-1);se?Sn--:++Sn<ze;)if(_t(ot[Sn],Sn,ot))return Sn;return-1}function Cc(ot,_t,vt){return _t===_t?xM(ot,_t,vt):Zu(ot,eh,vt)}function bv(ot,_t,vt,se){for(var ze=vt-1,Sn=ot.length;++ze<Sn;)if(se(ot[ze],_t))return ze;return-1}function eh(ot){return ot!==ot}function nh(ot,_t){var vt=ot==null?0:ot.length;return vt?ih(ot,_t)/vt:Bi}function Yu(ot){return function(_t){return _t==null?$:_t[ot]}}function rh(ot){return function(_t){return ot==null?$:ot[_t]}}function xv(ot,_t,vt,se,ze){return ze(ot,function(Sn,ei,je){vt=se?(se=!1,Sn):_t(vt,Sn,ei,je)}),vt}function Sb(ot,_t){var vt=ot.length;for(ot.sort(_t);vt--;)ot[vt]=ot[vt].value;return ot}function ih(ot,_t){for(var vt,se=-1,ze=ot.length;++se<ze;){var Sn=_t(ot[se]);Sn!==$&&(vt=vt===$?Sn:vt+Sn)}return vt}function Hu(ot,_t){for(var vt=-1,se=Array(ot);++vt<ot;)se[vt]=_t(vt);return se}function Eb(ot,_t){return $n(_t,function(vt){return[vt,ot[vt]]})}function _v(ot){return ot&&ot.slice(0,Tb(ot)+1).replace(Oc,"")}function ki(ot){return function(_t){return ot(_t)}}function ah(ot,_t){return $n(_t,function(vt){return ot[vt]})}function Lc(ot,_t){return ot.has(_t)}function wv(ot,_t){for(var vt=-1,se=ot.length;++vt<se&&Cc(_t,ot[vt],0)>-1;);return vt}function oh(ot,_t){for(var vt=ot.length;vt--&&Cc(_t,ot[vt],0)>-1;);return vt}function Mb(ot,_t){for(var vt=ot.length,se=0;vt--;)ot[vt]===_t&&++se;return se}var pM=rh(fM),vM=rh(dM);function kb(ot){return"\\"+Wn[ot]}function gM(ot,_t){return ot==null?$:ot[_t]}function kl(ot){return _b.test(ot)}function yM(ot){return cM.test(ot)}function mM(ot){for(var _t,vt=[];!(_t=ot.next()).done;)vt.push(_t.value);return vt}function Ov(ot){var _t=-1,vt=Array(ot.size);return ot.forEach(function(se,ze){vt[++_t]=[ze,se]}),vt}function Ab(ot,_t){return function(vt){return ot(_t(vt))}}function js(ot,_t){for(var vt=-1,se=ot.length,ze=0,Sn=[];++vt<se;){var ei=ot[vt];(ei===_t||ei===re)&&(ot[vt]=re,Sn[ze++]=vt)}return Sn}function sh(ot){var _t=-1,vt=Array(ot.size);return ot.forEach(function(se){vt[++_t]=se}),vt}function bM(ot){var _t=-1,vt=Array(ot.size);return ot.forEach(function(se){vt[++_t]=[se,se]}),vt}function xM(ot,_t,vt){for(var se=vt-1,ze=ot.length;++se<ze;)if(ot[se]===_t)return se;return-1}function _M(ot,_t,vt){for(var se=vt+1;se--;)if(ot[se]===_t)return se;return se}function Al(ot){return kl(ot)?OM(ot):th(ot)}function Ja(ot){return kl(ot)?SM(ot):Ob(ot)}function Tb(ot){for(var _t=ot.length;_t--&&ov.test(ot.charAt(_t)););return _t}var wM=rh(hM);function OM(ot){for(var _t=fv.lastIndex=0;fv.test(ot);)++_t;return _t}function SM(ot){return ot.match(fv)||[]}function EM(ot){return ot.match(xb)||[]}var MM=function ot(_t){_t=_t==null?lr:ch.defaults(lr.Object(),_t,ch.pick(lr,lM));var vt=_t.Array,se=_t.Date,ze=_t.Error,Sn=_t.Function,ei=_t.Math,je=_t.Object,Sv=_t.RegExp,qo=_t.String,Ia=_t.TypeError,lh=vt.prototype,Ko=Sn.prototype,Tl=je.prototype,uh=_t["__core-js_shared__"],fh=Ko.toString,Fn=Tl.hasOwnProperty,Pb=0,Ev=function(){var p=/[^.]+$/.exec(uh&&uh.keys&&uh.keys.IE_PROTO||"");return p?"Symbol(src)_1."+p:""}(),dh=Tl.toString,hh=fh.call(je),kM=lr._,ph=Sv("^"+fh.call(Fn).replace(Uo,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),vh=hv?_t.Buffer:$,Qo=_t.Symbol,Fs=_t.Uint8Array,Cb=vh?vh.allocUnsafe:$,gh=Ab(je.getPrototypeOf,je),Mv=je.create,Pl=Tl.propertyIsEnumerable,Cl=lh.splice,Lb=Qo?Qo.isConcatSpreadable:$,Rc=Qo?Qo.iterator:$,Bs=Qo?Qo.toStringTag:$,Vu=function(){try{var p=ao(je,"defineProperty");return p({},"",{}),p}catch(m){}}(),AM=_t.clearTimeout!==lr.clearTimeout&&_t.clearTimeout,TM=se&&se.now!==lr.Date.now&&se.now,PM=_t.setTimeout!==lr.setTimeout&&_t.setTimeout,yh=ei.ceil,mh=ei.floor,Nc=je.getOwnPropertySymbols,CM=vh?vh.isBuffer:$,Rb=_t.isFinite,LM=lh.join,RM=Ab(je.keys,je),ni=ei.max,ri=ei.min,NM=se.now,IM=_t.parseInt,kv=ei.random,Nb=lh.reverse,Av=ao(_t,"DataView"),Xu=ao(_t,"Map"),Tv=ao(_t,"Promise"),Ll=ao(_t,"Set"),Uu=ao(_t,"WeakMap"),qu=ao(je,"create"),bh=Uu&&new Uu,Rl={},DM=Hs(Av),jM=Hs(Xu),FM=Hs(Tv),BM=Hs(Ll),zM=Hs(Uu),xh=Qo?Qo.prototype:$,Ku=xh?xh.valueOf:$,Ib=xh?xh.toString:$;function Z(p){if(_r(p)&&!We(p)&&!(p instanceof fn)){if(p instanceof Da)return p;if(Fn.call(p,"__wrapped__"))return Sf(p)}return new Da(p)}var Ic=function(){function p(){}return function(m){if(!mr(m))return{};if(Mv)return Mv(m);p.prototype=m;var S=new p;return p.prototype=$,S}}();function Qu(){}function Da(p,m){this.__wrapped__=p,this.__actions__=[],this.__chain__=!!m,this.__index__=0,this.__values__=$}Z.templateSettings={escape:rv,evaluate:iv,interpolate:zd,variable:"",imports:{_:Z}},Z.prototype=Qu.prototype,Z.prototype.constructor=Z,Da.prototype=Ic(Qu.prototype),Da.prototype.constructor=Da;function fn(p){this.__wrapped__=p,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=Wr,this.__views__=[]}function WM(){var p=new fn(this.__wrapped__);return p.__actions__=Vi(this.__actions__),p.__dir__=this.__dir__,p.__filtered__=this.__filtered__,p.__iteratees__=Vi(this.__iteratees__),p.__takeCount__=this.__takeCount__,p.__views__=Vi(this.__views__),p}function GM(){if(this.__filtered__){var p=new fn(this);p.__dir__=-1,p.__filtered__=!0}else p=this.clone(),p.__dir__*=-1;return p}function $M(){var p=this.__wrapped__.value(),m=this.__dir__,S=We(p),T=m<0,B=S?p.length:0,Y=ok(0,B,this.__views__),q=Y.start,et=Y.end,st=et-q,Et=T?et:q-1,Mt=this.__iteratees__,Pt=Mt.length,Vt=0,de=ri(st,this.__takeCount__);if(!S||!T&&B==st&&de==st)return qv(p,this.__actions__);var ke=[];t:for(;st--&&Vt<de;){Et+=m;for(var Xe=-1,we=p[Et];++Xe<Pt;){var tn=Mt[Xe],dn=tn.iteratee,Hr=tn.type,mi=dn(we);if(Hr==Fi)we=mi;else if(!mi){if(Hr==di)continue t;break t}}ke[Vt++]=we}return ke}fn.prototype=Ic(Qu.prototype),fn.prototype.constructor=fn;function Dc(p){var m=-1,S=p==null?0:p.length;for(this.clear();++m<S;){var T=p[m];this.set(T[0],T[1])}}function ZM(){this.__data__=qu?qu(null):{},this.size=0}function YM(p){var m=this.has(p)&&delete this.__data__[p];return this.size-=m?1:0,m}function HM(p){var m=this.__data__;if(qu){var S=m[p];return S===Yt?$:S}return Fn.call(m,p)?m[p]:$}function VM(p){var m=this.__data__;return qu?m[p]!==$:Fn.call(m,p)}function XM(p,m){var S=this.__data__;return this.size+=this.has(p)?0:1,S[p]=qu&&m===$?Yt:m,this}Dc.prototype.clear=ZM,Dc.prototype.delete=YM,Dc.prototype.get=HM,Dc.prototype.has=VM,Dc.prototype.set=XM;function No(p){var m=-1,S=p==null?0:p.length;for(this.clear();++m<S;){var T=p[m];this.set(T[0],T[1])}}function UM(){this.__data__=[],this.size=0}function qM(p){var m=this.__data__,S=Ju(m,p);if(S<0)return!1;var T=m.length-1;return S==T?m.pop():Cl.call(m,S,1),--this.size,!0}function KM(p){var m=this.__data__,S=Ju(m,p);return S<0?$:m[S][1]}function QM(p){return Ju(this.__data__,p)>-1}function JM(p,m){var S=this.__data__,T=Ju(S,p);return T<0?(++this.size,S.push([p,m])):S[T][1]=m,this}No.prototype.clear=UM,No.prototype.delete=qM,No.prototype.get=KM,No.prototype.has=QM,No.prototype.set=JM;function Jo(p){var m=-1,S=p==null?0:p.length;for(this.clear();++m<S;){var T=p[m];this.set(T[0],T[1])}}function tk(){this.size=0,this.__data__={hash:new Dc,map:new(Xu||No),string:new Dc}}function ek(p){var m=jh(this,p).delete(p);return this.size-=m?1:0,m}function nk(p){return jh(this,p).get(p)}function Vn(p){return jh(this,p).has(p)}function Zi(p,m){var S=jh(this,p),T=S.size;return S.set(p,m),this.size+=S.size==T?0:1,this}Jo.prototype.clear=tk,Jo.prototype.delete=ek,Jo.prototype.get=nk,Jo.prototype.has=Vn,Jo.prototype.set=Zi;function ge(p){var m=-1,S=p==null?0:p.length;for(this.__data__=new Jo;++m<S;)this.add(p[m])}function ir(p){return this.__data__.set(p,Yt),this}function Db(p){return this.__data__.has(p)}ge.prototype.add=ge.prototype.push=ir,ge.prototype.has=Db;function mn(p){var m=this.__data__=new No(p);this.size=m.size}function _h(){this.__data__=new No,this.size=0}function ar(p){var m=this.__data__,S=m.delete(p);return this.size=m.size,S}function At(p){return this.__data__.get(p)}function $r(p){return this.__data__.has(p)}function jb(p,m){var S=this.__data__;if(S instanceof No){var T=S.__data__;if(!Xu||T.length<Ye-1)return T.push([p,m]),this.size=++S.size,this;S=this.__data__=new Jo(T)}return S.set(p,m),this.size=S.size,this}mn.prototype.clear=_h,mn.prototype.delete=ar,mn.prototype.get=At,mn.prototype.has=$r,mn.prototype.set=jb;function Pv(p,m){var S=We(p),T=!S&&qs(p),B=!S&&!T&&ss(p),Y=!S&&!T&&!B&&Ks(p),q=S||T||B||Y,et=q?Hu(p.length,qo):[],st=et.length;for(var Et in p)(m||Fn.call(p,Et))&&!(q&&(Et=="length"||B&&(Et=="offset"||Et=="parent")||Y&&(Et=="buffer"||Et=="byteLength"||Et=="byteOffset")||Do(Et,st)))&&et.push(Et);return et}function Cv(p){var m=p.length;return m?p[$s(0,m-1)]:$}function Fb(p,m){return Fo(Vi(p),zs(m,0,p.length))}function Bb(p){return Fo(Vi(p))}function wh(p,m,S){(S!==$&&!Aa(p[m],S)||S===$&&!(m in p))&&gi(p,m,S)}function Nl(p,m,S){var T=p[m];(!(Fn.call(p,m)&&Aa(T,S))||S===$&&!(m in p))&&gi(p,m,S)}function Ju(p,m){for(var S=p.length;S--;)if(Aa(p[S][0],m))return S;return-1}function zb(p,m,S,T){return ts(p,function(B,Y,q){m(T,B,S(B),q)}),T}function tf(p,m){return p&&no(m,Yr(m),p)}function Wb(p,m){return p&&no(m,Ki(m),p)}function gi(p,m,S){m=="__proto__"&&Vu?Vu(p,m,{configurable:!0,enumerable:!0,value:S,writable:!0}):p[m]=S}function V(p,m){for(var S=-1,T=m.length,B=vt(T),Y=p==null;++S<T;)B[S]=Y?$:ip(p,m[S]);return B}function zs(p,m,S){return p===p&&(S!==$&&(p=p<=S?p:S),m!==$&&(p=p>=m?p:m)),p}function wa(p,m,S,T,B,Y){var q,et=m&Wt,st=m&ee,Et=m&Xt;if(S&&(q=B?S(p,T,B,Y):S(p)),q!==$)return q;if(!mr(p))return p;var Mt=We(p);if(Mt){if(q=px(p),!et)return Vi(p,q)}else{var Pt=Ai(p),Vt=Pt==zi||Pt==ma;if(ss(p))return Jv(p,et);if(Pt==Wi||Pt==Or||Vt&&!B){if(q=st||Vt?{}:Of(p),!et)return st?sx(p,Wb(q,p)):ox(p,tf(q,p))}else{if(!rr[Pt])return B?p:{};q=vx(p,Pt,et)}}Y||(Y=new mn);var de=Y.get(p);if(de)return de;Y.set(p,q),Ug(p)?p.forEach(function(we){q.add(wa(we,m,S,we,p,Y))}):nu(p)&&p.forEach(function(we,tn){q.set(tn,wa(we,m,S,tn,p,Y))});var ke=Et?st?xf:bf:st?Ki:Yr,Xe=Mt?$:ke(p);return ua(Xe||p,function(we,tn){Xe&&(tn=we,we=p[tn]),Nl(q,tn,wa(we,m,S,tn,p,Y))}),q}function te(p){var m=Yr(p);return function(S){return jc(S,p,m)}}function jc(p,m,S){var T=S.length;if(p==null)return!T;for(p=je(p);T--;){var B=S[T],Y=m[B],q=p[B];if(q===$&&!(B in p)||!Y(q))return!1}return!0}function Lv(p,m,S){if(typeof p!="function")throw new Ia(Rt);return Hl(function(){p.apply($,S)},m)}function Il(p,m,S,T){var B=-1,Y=Ml,q=!0,et=p.length,st=[],Et=m.length;if(!et)return st;S&&(m=$n(m,ki(S))),T?(Y=Jd,q=!1):m.length>=Ye&&(Y=Lc,q=!1,m=new ge(m));t:for(;++B<et;){var Mt=p[B],Pt=S==null?Mt:S(Mt);if(Mt=T||Mt!==0?Mt:0,q&&Pt===Pt){for(var Vt=Et;Vt--;)if(m[Vt]===Pt)continue t;st.push(Mt)}else Y(m,Pt,T)||st.push(Mt)}return st}var ts=eg(to),Rv=eg(Sh,!0);function Gb(p,m){var S=!0;return ts(p,function(T,B,Y){return S=!!m(T,B,Y),S}),S}function Fc(p,m,S){for(var T=-1,B=p.length;++T<B;){var Y=p[T],q=m(Y);if(q!=null&&(et===$?q===q&&!da(q):S(q,et)))var et=q,st=Y}return st}function $b(p,m,S,T){var B=p.length;for(S=Ve(S),S<0&&(S=-S>B?0:B+S),T=T===$||T>B?B:Ve(T),T<0&&(T+=B),T=S>T?0:Jg(T);S<T;)p[S++]=m;return p}function Nv(p,m){var S=[];return ts(p,function(T,B,Y){m(T,B,Y)&&S.push(T)}),S}function Rr(p,m,S,T,B){var Y=-1,q=p.length;for(S||(S=gx),B||(B=[]);++Y<q;){var et=p[Y];m>0&&S(et)?m>1?Rr(et,m-1,S,T,B):fa(B,et):T||(B[B.length]=et)}return B}var Oh=ng(),Iv=ng(!0);function to(p,m){return p&&Oh(p,m,Yr)}function Sh(p,m){return p&&Iv(p,m,Yr)}function ef(p,m){return Qa(m,function(S){return Wa(p[S])})}function Ws(p,m){m=rs(m,p);for(var S=0,T=m.length;p!=null&&S<T;)p=p[Ti(m[S++])];return S&&S==T?p:$}function Zb(p,m,S){var T=m(p);return We(p)?T:fa(T,S(p))}function Zr(p){return p==null?p===$?De:Gu:Bs&&Bs in je(p)?ak(p):$c(p)}function nf(p,m){return p>m}function Dv(p,m){return p!=null&&Fn.call(p,m)}function jv(p,m){return p!=null&&m in je(p)}function Fv(p,m,S){return p>=ri(m,S)&&p<ni(m,S)}function rf(p,m,S){for(var T=S?Jd:Ml,B=p[0].length,Y=p.length,q=Y,et=vt(Y),st=1/0,Et=[];q--;){var Mt=p[q];q&&m&&(Mt=$n(Mt,ki(m))),st=ri(Mt.length,st),et[q]=!S&&(m||B>=120&&Mt.length>=120)?new ge(q&&Mt):$}Mt=p[0];var Pt=-1,Vt=et[0];t:for(;++Pt<B&&Et.length<st;){var de=Mt[Pt],ke=m?m(de):de;if(de=S||de!==0?de:0,!(Vt?Lc(Vt,ke):T(Et,ke,S))){for(q=Y;--q;){var Xe=et[q];if(!(Xe?Lc(Xe,ke):T(p[q],ke,S)))continue t}Vt&&Vt.push(ke),Et.push(de)}}return Et}function Yb(p,m,S,T){return to(p,function(B,Y,q){m(T,S(B),Y,q)}),T}function Dl(p,m,S){m=rs(m,p),p=hg(p,m);var T=p==null?p:p[Ti(Xi(m))];return T==null?$:Lr(T,p,S)}function Gs(p){return _r(p)&&Zr(p)==Or}function Hb(p){return _r(p)&&Zr(p)==Ps}function Vb(p){return _r(p)&&Zr(p)==As}function es(p,m,S,T,B){return p===m?!0:p==null||m==null||!_r(p)&&!_r(m)?p!==p&&m!==m:Xb(p,m,S,T,es,B)}function Xb(p,m,S,T,B,Y){var q=We(p),et=We(m),st=q?yn:Ai(p),Et=et?yn:Ai(m);st=st==Or?Wi:st,Et=Et==Or?Wi:Et;var Mt=st==Wi,Pt=Et==Wi,Vt=st==Et;if(Vt&&ss(p)){if(!ss(m))return!1;q=!0,Mt=!1}if(Vt&&!Mt)return Y||(Y=new mn),q||Ks(p)?dx(p,m,S,T,B,Y):ik(p,m,st,S,T,B,Y);if(!(S&kt)){var de=Mt&&Fn.call(p,"__wrapped__"),ke=Pt&&Fn.call(m,"__wrapped__");if(de||ke){var Xe=de?p.value():p,we=ke?m.value():m;return Y||(Y=new mn),B(Xe,we,S,T,Y)}}return Vt?(Y||(Y=new mn),cg(p,m,S,T,B,Y)):!1}function Ub(p){return _r(p)&&Ai(p)==_i}function Eh(p,m,S,T){var B=S.length,Y=B,q=!T;if(p==null)return!Y;for(p=je(p);B--;){var et=S[B];if(q&&et[2]?et[1]!==p[et[0]]:!(et[0]in p))return!1}for(;++B<Y;){et=S[B];var st=et[0],Et=p[st],Mt=et[1];if(q&&et[2]){if(Et===$&&!(st in p))return!1}else{var Pt=new mn;if(T)var Vt=T(Et,Mt,st,p,m,Pt);if(!(Vt===$?es(Mt,Et,kt|St,T,Pt):Vt))return!1}}return!0}function Bv(p){if(!mr(p)||yx(p))return!1;var m=Wa(p)?ph:er;return m.test(Hs(p))}function qb(p){return _r(p)&&Zr(p)==Ee}function Kb(p){return _r(p)&&Ai(p)==xt}function Qb(p){return _r(p)&&jf(p.length)&&!!cr[Zr(p)]}function jl(p){return typeof p=="function"?p:p==null?yi:typeof p=="object"?We(p)?Gv(p[0],p[1]):Wv(p):yy(p)}function eo(p){if(!$l(p))return RM(p);var m=[];for(var S in je(p))Fn.call(p,S)&&S!="constructor"&&m.push(S);return m}function Mh(p){if(!mr(p))return Bh(p);var m=$l(p),S=[];for(var T in p)T=="constructor"&&(m||!Fn.call(p,T))||S.push(T);return S}function af(p,m){return p<m}function zv(p,m){var S=-1,T=Ci(p)?vt(p.length):[];return ts(p,function(B,Y,q){T[++S]=m(B,Y,q)}),T}function Wv(p){var m=lg(p);return m.length==1&&m[0][2]?Zl(m[0][0],m[0][1]):function(S){return S===p||Eh(S,p,m)}}function Gv(p,m){return oo(p)&&dt(m)?Zl(Ti(p),m):function(S){var T=ip(S,p);return T===$&&T===m?ap(S,p):es(m,T,kt|St)}}function Fl(p,m,S,T,B){p!==m&&Oh(m,function(Y,q){if(B||(B=new mn),mr(Y))Jb(p,m,q,S,Fl,T,B);else{var et=T?T(Yl(p,q),Y,q+"",p,m,B):$;et===$&&(et=Y),wh(p,q,et)}},Ki)}function Jb(p,m,S,T,B,Y,q){var et=Yl(p,S),st=Yl(m,S),Et=q.get(st);if(Et){wh(p,S,Et);return}var Mt=Y?Y(et,st,S+"",p,m,q):$,Pt=Mt===$;if(Pt){var Vt=We(st),de=!Vt&&ss(st),ke=!Vt&&!de&&Ks(st);Mt=st,Vt||de||ke?We(et)?Mt=et:bn(et)?Mt=Vi(et):de?(Pt=!1,Mt=Jv(st,!0)):ke?(Pt=!1,Mt=Ch(st,!0)):Mt=[]:cs(st)||qs(st)?(Mt=et,qs(et)?Mt=ur(et):(!mr(et)||Wa(et))&&(Mt=Of(st))):Pt=!1}Pt&&(q.set(st,Mt),B(Mt,st,T,Y,q),q.delete(st)),wh(p,S,Mt)}function $v(p,m){var S=p.length;if(S)return m+=m<0?S:0,Do(m,S)?p[m]:$}function kh(p,m,S){m.length?m=$n(m,function(Y){return We(Y)?function(q){return Ws(q,Y.length===1?Y[0]:Y)}:Y}):m=[yi];var T=-1;m=$n(m,ki(Pe()));var B=zv(p,function(Y,q,et){var st=$n(m,function(Et){return Et(Y)});return{criteria:st,index:++T,value:Y}});return Sb(B,function(Y,q){return df(Y,q,S)})}function tx(p,m){return Nr(p,m,function(S,T){return ap(p,T)})}function Nr(p,m,S){for(var T=-1,B=m.length,Y={};++T<B;){var q=m[T],et=Ws(p,q);S(et,q)&&Zs(Y,rs(q,p),et)}return Y}function of(p){return function(m){return Ws(m,p)}}function Bc(p,m,S,T){var B=T?bv:Cc,Y=-1,q=m.length,et=p;for(p===m&&(m=Vi(m)),S&&(et=$n(p,ki(S)));++Y<q;)for(var st=0,Et=m[Y],Mt=S?S(Et):Et;(st=B(et,Mt,st,T))>-1;)et!==p&&Cl.call(et,st,1),Cl.call(p,st,1);return p}function Zv(p,m){for(var S=p?m.length:0,T=S-1;S--;){var B=m[S];if(S==T||B!==Y){var Y=B;Do(B)?Cl.call(p,B,1):Ah(p,B)}}return p}function $s(p,m){return p+mh(kv()*(m-p+1))}function ex(p,m,S,T){for(var B=-1,Y=ni(yh((m-p)/(S||1)),0),q=vt(Y);Y--;)q[T?Y:++B]=p,p+=S;return q}function sf(p,m){var S="";if(!p||m<1||m>rt)return S;do m%2&&(S+=p),m=mh(m/2),m&&(p+=p);while(m);return S}function Je(p,m){return as(dg(p,m,yi),p+"")}function nx(p){return Cv(qc(p))}function cf(p,m){var S=qc(p);return Fo(S,zs(m,0,S.length))}function Zs(p,m,S,T){if(!mr(p))return p;m=rs(m,p);for(var B=-1,Y=m.length,q=Y-1,et=p;et!=null&&++B<Y;){var st=Ti(m[B]),Et=S;if(st==="__proto__"||st==="constructor"||st==="prototype")return p;if(B!=q){var Mt=et[st];Et=T?T(Mt,st,et):$,Et===$&&(Et=mr(Mt)?Mt:Do(m[B+1])?[]:{})}Nl(et,st,Et),et=et[st]}return p}var Yv=bh?function(p,m){return bh.set(p,m),p}:yi,Hv=Vu?function(p,m){return Vu(p,"toString",{configurable:!0,enumerable:!1,value:ou(m),writable:!0})}:yi;function rx(p){return Fo(qc(p))}function Yi(p,m,S){var T=-1,B=p.length;m<0&&(m=-m>B?0:B+m),S=S>B?B:S,S<0&&(S+=B),B=m>S?0:S-m>>>0,m>>>=0;for(var Y=vt(B);++T<B;)Y[T]=p[T+m];return Y}function ix(p,m){var S;return ts(p,function(T,B,Y){return S=m(T,B,Y),!S}),!!S}function Bl(p,m,S){var T=0,B=p==null?T:p.length;if(typeof m=="number"&&m===m&&B<=oa){for(;T<B;){var Y=T+B>>>1,q=p[Y];q!==null&&!da(q)&&(S?q<=m:q<m)?T=Y+1:B=Y}return B}return lf(p,m,yi,S)}function lf(p,m,S,T){var B=0,Y=p==null?0:p.length;if(Y===0)return 0;m=S(m);for(var q=m!==m,et=m===null,st=da(m),Et=m===$;B<Y;){var Mt=mh((B+Y)/2),Pt=S(p[Mt]),Vt=Pt!==$,de=Pt===null,ke=Pt===Pt,Xe=da(Pt);if(q)var we=T||ke;else Et?we=ke&&(T||Vt):et?we=ke&&Vt&&(T||!de):st?we=ke&&Vt&&!de&&(T||!Xe):de||Xe?we=!1:we=T?Pt<=m:Pt<m;we?B=Mt+1:Y=Mt}return ri(Y,ya)}function Vv(p,m){for(var S=-1,T=p.length,B=0,Y=[];++S<T;){var q=p[S],et=m?m(q):q;if(!S||!Aa(et,st)){var st=et;Y[B++]=q===0?0:q}}return Y}function Xv(p){return typeof p=="number"?p:da(p)?Bi:+p}function Hi(p){if(typeof p=="string")return p;if(We(p))return $n(p,Hi)+"";if(da(p))return Ib?Ib.call(p):"";var m=p+"";return m=="0"&&1/p==-tr?"-0":m}function ns(p,m,S){var T=-1,B=Ml,Y=p.length,q=!0,et=[],st=et;if(S)q=!1,B=Jd;else if(Y>=Ye){var Et=m?null:ux(p);if(Et)return sh(Et);q=!1,B=Lc,st=new ge}else st=m?[]:et;t:for(;++T<Y;){var Mt=p[T],Pt=m?m(Mt):Mt;if(Mt=S||Mt!==0?Mt:0,q&&Pt===Pt){for(var Vt=st.length;Vt--;)if(st[Vt]===Pt)continue t;m&&st.push(Pt),et.push(Mt)}else B(st,Pt,S)||(st!==et&&st.push(Pt),et.push(Mt))}return et}function Ah(p,m){return m=rs(m,p),p=hg(p,m),p==null||delete p[Ti(Xi(m))]}function Uv(p,m,S,T){return Zs(p,m,S(Ws(p,m)),T)}function uf(p,m,S,T){for(var B=p.length,Y=T?B:-1;(T?Y--:++Y<B)&&m(p[Y],Y,p););return S?Yi(p,T?0:Y,T?Y+1:B):Yi(p,T?Y+1:0,T?B:Y)}function qv(p,m){var S=p;return S instanceof fn&&(S=S.value()),Pc(m,function(T,B){return B.func.apply(B.thisArg,fa([T],B.args))},S)}function En(p,m,S){var T=p.length;if(T<2)return T?ns(p[0]):[];for(var B=-1,Y=vt(T);++B<T;)for(var q=p[B],et=-1;++et<T;)et!=B&&(Y[B]=Il(Y[B]||q,p[et],m,S));return ns(Rr(Y,1),m,S)}function Kv(p,m,S){for(var T=-1,B=p.length,Y=m.length,q={};++T<B;){var et=T<Y?m[T]:$;S(q,p[T],et)}return q}function Th(p){return bn(p)?p:[]}function ff(p){return typeof p=="function"?p:yi}function rs(p,m){return We(p)?p:oo(p,m)?[p]:kn(Ge(p))}var Qv=Je;function Xn(p,m,S){var T=p.length;return S=S===$?T:S,!m&&S>=T?p:Yi(p,m,S)}var zl=AM||function(p){return lr.clearTimeout(p)};function Jv(p,m){if(m)return p.slice();var S=p.length,T=Cb?Cb(S):new p.constructor(S);return p.copy(T),T}function Kt(p){var m=new p.constructor(p.byteLength);return new Fs(m).set(new Fs(p)),m}function tg(p,m){var S=m?Kt(p.buffer):p.buffer;return new p.constructor(S,p.byteOffset,p.byteLength)}function ax(p){var m=new p.constructor(p.source,$d.exec(p));return m.lastIndex=p.lastIndex,m}function Ph(p){return Ku?je(Ku.call(p)):{}}function Ch(p,m){var S=m?Kt(p.buffer):p.buffer;return new p.constructor(S,p.byteOffset,p.length)}function li(p,m){if(p!==m){var S=p!==$,T=p===null,B=p===p,Y=da(p),q=m!==$,et=m===null,st=m===m,Et=da(m);if(!et&&!Et&&!Y&&p>m||Y&&q&&st&&!et&&!Et||T&&q&&st||!S&&st||!B)return 1;if(!T&&!Y&&!Et&&p<m||Et&&S&&B&&!T&&!Y||et&&S&&B||!q&&B||!st)return-1}return 0}function df(p,m,S){for(var T=-1,B=p.criteria,Y=m.criteria,q=B.length,et=S.length;++T<q;){var st=li(B[T],Y[T]);if(st){if(T>=et)return st;var Et=S[T];return st*(Et=="desc"?-1:1)}}return p.index-m.index}function Lh(p,m,S,T){for(var B=-1,Y=p.length,q=S.length,et=-1,st=m.length,Et=ni(Y-q,0),Mt=vt(st+Et),Pt=!T;++et<st;)Mt[et]=m[et];for(;++B<q;)(Pt||B<Y)&&(Mt[S[B]]=p[B]);for(;Et--;)Mt[et++]=p[B++];return Mt}function Rh(p,m,S,T){for(var B=-1,Y=p.length,q=-1,et=S.length,st=-1,Et=m.length,Mt=ni(Y-et,0),Pt=vt(Mt+Et),Vt=!T;++B<Mt;)Pt[B]=p[B];for(var de=B;++st<Et;)Pt[de+st]=m[st];for(;++q<et;)(Vt||B<Y)&&(Pt[de+S[q]]=p[B++]);return Pt}function Vi(p,m){var S=-1,T=p.length;for(m||(m=vt(T));++S<T;)m[S]=p[S];return m}function no(p,m,S,T){var B=!S;S||(S={});for(var Y=-1,q=m.length;++Y<q;){var et=m[Y],st=T?T(S[et],p[et],et,S,p):$;st===$&&(st=p[et]),B?gi(S,et,st):Nl(S,et,st)}return S}function ox(p,m){return no(p,ug(p),m)}function sx(p,m){return no(p,hx(p),m)}function hf(p,m){return function(S,T){var B=We(S)?Is:zb,Y=m?m():{};return B(S,p,Pe(T,2),Y)}}function zc(p){return Je(function(m,S){var T=-1,B=S.length,Y=B>1?S[B-1]:$,q=B>2?S[2]:$;for(Y=p.length>3&&typeof Y=="function"?(B--,Y):$,q&&Mn(S[0],S[1],q)&&(Y=B<3?$:Y,B=1),m=je(m);++T<B;){var et=S[T];et&&p(m,et,T,Y)}return m})}function eg(p,m){return function(S,T){if(S==null)return S;if(!Ci(S))return p(S,T);for(var B=S.length,Y=m?B:-1,q=je(S);(m?Y--:++Y<B)&&T(q[Y],Y,q)!==!1;);return S}}function ng(p){return function(m,S,T){for(var B=-1,Y=je(m),q=T(m),et=q.length;et--;){var st=q[p?et:++B];if(S(Y[st],st,Y)===!1)break}return m}}function rg(p,m,S){var T=m&bt,B=pf(p);function Y(){var q=this&&this!==lr&&this instanceof Y?B:p;return q.apply(T?S:this,arguments)}return Y}function Nh(p){return function(m){m=Ge(m);var S=kl(m)?Ja(m):$,T=S?S[0]:m.charAt(0),B=S?Xn(S,1).join(""):m.slice(1);return T[p]()+B}}function Wc(p){return function(m){return Pc($f(ly(m).replace(oM,"")),p,"")}}function pf(p){return function(){var m=arguments;switch(m.length){case 0:return new p;case 1:return new p(m[0]);case 2:return new p(m[0],m[1]);case 3:return new p(m[0],m[1],m[2]);case 4:return new p(m[0],m[1],m[2],m[3]);case 5:return new p(m[0],m[1],m[2],m[3],m[4]);case 6:return new p(m[0],m[1],m[2],m[3],m[4],m[5]);case 7:return new p(m[0],m[1],m[2],m[3],m[4],m[5],m[6])}var S=Ic(p.prototype),T=p.apply(S,m);return mr(T)?T:S}}function rk(p,m,S){var T=pf(p);function B(){for(var Y=arguments.length,q=vt(Y),et=Y,st=Gc(B);et--;)q[et]=arguments[et];var Et=Y<3&&q[0]!==st&&q[Y-1]!==st?[]:js(q,st);if(Y-=Et.length,Y<S)return Dh(p,m,vf,B.placeholder,$,q,Et,$,$,S-Y);var Mt=this&&this!==lr&&this instanceof B?T:p;return Lr(Mt,this,q)}return B}function ig(p){return function(m,S,T){var B=je(m);if(!Ci(m)){var Y=Pe(S,3);m=Yr(m),S=function(et){return Y(B[et],et,B)}}var q=p(m,S,T);return q>-1?B[Y?m[q]:q]:$}}function Ih(p){return io(function(m){var S=m.length,T=S,B=Da.prototype.thru;for(p&&m.reverse();T--;){var Y=m[T];if(typeof Y!="function")throw new Ia(Rt);if(B&&!q&&wf(Y)=="wrapper")var q=new Da([],!0)}for(T=q?T:S;++T<S;){Y=m[T];var et=wf(Y),st=et=="wrapper"?_f(Y):$;st&&jo(st[0])&&st[1]==(gn|_e|Ue|rn)&&!st[4].length&&st[9]==1?q=q[wf(st[0])].apply(q,st[3]):q=Y.length==1&&jo(Y)?q[et]():q.thru(Y)}return function(){var Et=arguments,Mt=Et[0];if(q&&Et.length==1&&We(Mt))return q.plant(Mt).value();for(var Pt=0,Vt=S?m[Pt].apply(this,Et):Mt;++Pt<S;)Vt=m[Pt].call(this,Vt);return Vt}})}function vf(p,m,S,T,B,Y,q,et,st,Et){var Mt=m&gn,Pt=m&bt,Vt=m&Tt,de=m&(_e|_n),ke=m&Yn,Xe=Vt?$:pf(p);function we(){for(var tn=arguments.length,dn=vt(tn),Hr=tn;Hr--;)dn[Hr]=arguments[Hr];if(de)var mi=Gc(we),ha=Mb(dn,mi);if(T&&(dn=Lh(dn,T,B,de)),Y&&(dn=Rh(dn,Y,q,de)),tn-=ha,de&&tn<Et){var Sr=js(dn,mi);return Dh(p,m,vf,we.placeholder,S,dn,Sr,et,st,Et-tn)}var Ga=Pt?S:this,Bo=Vt?Ga[p]:p;return tn=dn.length,et?dn=pg(dn,et):ke&&tn>1&&dn.reverse(),Mt&&st<tn&&(dn.length=st),this&&this!==lr&&this instanceof we&&(Bo=Xe||pf(Bo)),Bo.apply(Ga,dn)}return we}function cx(p,m){return function(S,T){return Yb(S,p,m(T),{})}}function Wl(p,m){return function(S,T){var B;if(S===$&&T===$)return m;if(S!==$&&(B=S),T!==$){if(B===$)return T;typeof S=="string"||typeof T=="string"?(S=Hi(S),T=Hi(T)):(S=Xv(S),T=Xv(T)),B=p(S,T)}return B}}function Oa(p){return io(function(m){return m=$n(m,ki(Pe())),Je(function(S){var T=this;return p(m,function(B){return Lr(B,T,S)})})})}function gf(p,m){m=m===$?" ":Hi(m);var S=m.length;if(S<2)return S?sf(m,p):m;var T=sf(m,yh(p/Al(m)));return kl(m)?Xn(Ja(T),0,p).join(""):T.slice(0,p)}function ag(p,m,S,T){var B=m&bt,Y=pf(p);function q(){for(var et=-1,st=arguments.length,Et=-1,Mt=T.length,Pt=vt(Mt+st),Vt=this&&this!==lr&&this instanceof q?Y:p;++Et<Mt;)Pt[Et]=T[Et];for(;st--;)Pt[Et++]=arguments[++et];return Lr(Vt,B?S:this,Pt)}return q}function lx(p){return function(m,S,T){return T&&typeof T!="number"&&Mn(m,S,T)&&(S=T=$),m=uo(m),S===$?(S=m,m=0):S=uo(S),T=T===$?m<S?1:-1:uo(T),ex(m,S,T,p)}}function ro(p){return function(m,S){return typeof m=="string"&&typeof S=="string"||(m=Ta(m),S=Ta(S)),p(m,S)}}function Dh(p,m,S,T,B,Y,q,et,st,Et){var Mt=m&_e,Pt=Mt?q:$,Vt=Mt?$:q,de=Mt?Y:$,ke=Mt?$:Y;m|=Mt?Ue:pn,m&=~(Mt?pn:Ue),m&xe||(m&=~(bt|Tt));var Xe=[p,m,B,de,Pt,ke,Vt,et,st,Et],we=S.apply($,Xe);return jo(p)&&xr(we,Xe),we.placeholder=T,vg(we,p,m)}function yf(p){var m=ei[p];return function(S,T){if(S=Ta(S),T=T==null?0:ri(Ve(T),292),T&&Rb(S)){var B=(Ge(S)+"e").split("e"),Y=m(B[0]+"e"+(+B[1]+T));return B=(Ge(Y)+"e").split("e"),+(B[0]+"e"+(+B[1]-T))}return m(S)}}var ux=Ll&&1/sh(new Ll([,-0]))[1]==tr?function(p){return new Ll(p)}:fp;function mf(p){return function(m){var S=Ai(m);return S==_i?Ov(m):S==xt?bM(m):Eb(m,p(m))}}function Io(p,m,S,T,B,Y,q,et){var st=m&Tt;if(!st&&typeof p!="function")throw new Ia(Rt);var Et=T?T.length:0;if(Et||(m&=~(Ue|pn),T=B=$),q=q===$?q:ni(Ve(q),0),et=et===$?et:Ve(et),Et-=B?B.length:0,m&pn){var Mt=T,Pt=B;T=B=$}var Vt=st?$:_f(p),de=[p,m,S,T,B,Mt,Pt,Y,q,et];if(Vt&&mx(de,Vt),p=de[0],m=de[1],S=de[2],T=de[3],B=de[4],et=de[9]=de[9]===$?st?0:p.length:ni(de[9]-Et,0),!et&&m&(_e|_n)&&(m&=~(_e|_n)),!m||m==bt)var ke=rg(p,m,S);else m==_e||m==_n?ke=rk(p,m,et):(m==Ue||m==(bt|Ue))&&!B.length?ke=ag(p,m,S,T):ke=vf.apply($,de);var Xe=Vt?Yv:xr;return vg(Xe(ke,de),p,m)}function fx(p,m,S,T){return p===$||Aa(p,Tl[S])&&!Fn.call(T,S)?m:p}function og(p,m,S,T,B,Y){return mr(p)&&mr(m)&&(Y.set(m,p),Fl(p,m,$,og,Y),Y.delete(m)),p}function sg(p){return cs(p)?$:p}function dx(p,m,S,T,B,Y){var q=S&kt,et=p.length,st=m.length;if(et!=st&&!(q&&st>et))return!1;var Et=Y.get(p),Mt=Y.get(m);if(Et&&Mt)return Et==m&&Mt==p;var Pt=-1,Vt=!0,de=S&St?new ge:$;for(Y.set(p,m),Y.set(m,p);++Pt<et;){var ke=p[Pt],Xe=m[Pt];if(T)var we=q?T(Xe,ke,Pt,m,p,Y):T(ke,Xe,Pt,p,m,Y);if(we!==$){if(we)continue;Vt=!1;break}if(de){if(!Ds(m,function(tn,dn){if(!Lc(de,dn)&&(ke===tn||B(ke,tn,S,T,Y)))return de.push(dn)})){Vt=!1;break}}else if(!(ke===Xe||B(ke,Xe,S,T,Y))){Vt=!1;break}}return Y.delete(p),Y.delete(m),Vt}function ik(p,m,S,T,B,Y,q){switch(S){case Lo:if(p.byteLength!=m.byteLength||p.byteOffset!=m.byteOffset)return!1;p=p.buffer,m=m.buffer;case Ps:return!(p.byteLength!=m.byteLength||!Y(new Fs(p),new Fs(m)));case Ua:case As:case ba:return Aa(+p,+m);case Xo:return p.name==m.name&&p.message==m.message;case Ee:case Ot:return p==m+"";case _i:var et=Ov;case xt:var st=T&kt;if(et||(et=sh),p.size!=m.size&&!st)return!1;var Et=q.get(p);if(Et)return Et==m;T|=St,q.set(p,m);var Mt=dx(et(p),et(m),T,B,Y,q);return q.delete(p),Mt;case ln:if(Ku)return Ku.call(p)==Ku.call(m)}return!1}function cg(p,m,S,T,B,Y){var q=S&kt,et=bf(p),st=et.length,Et=bf(m),Mt=Et.length;if(st!=Mt&&!q)return!1;for(var Pt=st;Pt--;){var Vt=et[Pt];if(!(q?Vt in m:Fn.call(m,Vt)))return!1}var de=Y.get(p),ke=Y.get(m);if(de&&ke)return de==m&&ke==p;var Xe=!0;Y.set(p,m),Y.set(m,p);for(var we=q;++Pt<st;){Vt=et[Pt];var tn=p[Vt],dn=m[Vt];if(T)var Hr=q?T(dn,tn,Vt,m,p,Y):T(tn,dn,Vt,p,m,Y);if(!(Hr===$?tn===dn||B(tn,dn,S,T,Y):Hr)){Xe=!1;break}we||(we=Vt=="constructor")}if(Xe&&!we){var mi=p.constructor,ha=m.constructor;mi!=ha&&"constructor"in p&&"constructor"in m&&!(typeof mi=="function"&&mi instanceof mi&&typeof ha=="function"&&ha instanceof ha)&&(Xe=!1)}return Y.delete(p),Y.delete(m),Xe}function io(p){return as(dg(p,$,yg),p+"")}function bf(p){return Zb(p,Yr,ug)}function xf(p){return Zb(p,Ki,hx)}var _f=bh?function(p){return bh.get(p)}:fp;function wf(p){for(var m=p.name+"",S=Rl[m],T=Fn.call(Rl,m)?S.length:0;T--;){var B=S[T],Y=B.func;if(Y==null||Y==p)return B.name}return m}function Gc(p){var m=Fn.call(Z,"placeholder")?Z:p;return m.placeholder}function Pe(){var p=Z.iteratee||br;return p=p===br?jl:p,arguments.length?p(arguments[0],arguments[1]):p}function jh(p,m){var S=p.__data__;return Ys(m)?S[typeof m=="string"?"string":"hash"]:S.map}function lg(p){for(var m=Yr(p),S=m.length;S--;){var T=m[S],B=p[T];m[S]=[T,B,dt(B)]}return m}function ao(p,m){var S=gM(p,m);return Bv(S)?S:$}function ak(p){var m=Fn.call(p,Bs),S=p[Bs];try{p[Bs]=$;var T=!0}catch(Y){}var B=dh.call(p);return T&&(m?p[Bs]=S:delete p[Bs]),B}var ug=Nc?function(p){return p==null?[]:(p=je(p),Qa(Nc(p),function(m){return Pl.call(p,m)}))}:dp,hx=Nc?function(p){for(var m=[];p;)fa(m,ug(p)),p=gh(p);return m}:dp,Ai=Zr;(Av&&Ai(new Av(new ArrayBuffer(1)))!=Lo||Xu&&Ai(new Xu)!=_i||Tv&&Ai(Tv.resolve())!=bc||Ll&&Ai(new Ll)!=xt||Uu&&Ai(new Uu)!=Me)&&(Ai=function(p){var m=Zr(p),S=m==Wi?p.constructor:$,T=S?Hs(S):"";if(T)switch(T){case DM:return Lo;case jM:return _i;case FM:return bc;case BM:return xt;case zM:return Me}return m});function ok(p,m,S){for(var T=-1,B=S.length;++T<B;){var Y=S[T],q=Y.size;switch(Y.type){case"drop":p+=q;break;case"dropRight":m-=q;break;case"take":m=ri(m,p+q);break;case"takeRight":p=ni(p,m-q);break}}return{start:p,end:m}}function Gl(p){var m=p.match(Sc);return m?m[1].split(Ec):[]}function Fh(p,m,S){m=rs(m,p);for(var T=-1,B=m.length,Y=!1;++T<B;){var q=Ti(m[T]);if(!(Y=p!=null&&S(p,q)))break;p=p[q]}return Y||++T!=B?Y:(B=p==null?0:p.length,!!B&&jf(B)&&Do(q,B)&&(We(p)||qs(p)))}function px(p){var m=p.length,S=new p.constructor(m);return m&&typeof p[0]=="string"&&Fn.call(p,"index")&&(S.index=p.index,S.input=p.input),S}function Of(p){return typeof p.constructor=="function"&&!$l(p)?Ic(gh(p)):{}}function vx(p,m,S){var T=p.constructor;switch(m){case Ps:return Kt(p);case Ua:case As:return new T(+p);case Lo:return tg(p,S);case un:case Hn:case Pr:case xc:case _c:case wc:case qa:case me:case wi:return Ch(p,S);case _i:return new T;case ba:case Ot:return new T(p);case Ee:return ax(p);case xt:return new T;case ln:return Ph(p)}}function sk(p,m){var S=m.length;if(!S)return p;var T=S-1;return m[T]=(S>1?"& ":"")+m[T],m=m.join(S>2?", ":" "),p.replace(sv,`{
/* [wrapped with `+m+`] */
`)}function gx(p){return We(p)||qs(p)||!!(Lb&&p&&p[Lb])}function Do(p,m){var S=typeof p;return m=m==null?rt:m,!!m&&(S=="number"||S!="symbol"&&pi.test(p))&&p>-1&&p%1==0&&p<m}function Mn(p,m,S){if(!mr(S))return!1;var T=typeof m;return(T=="number"?Ci(S)&&Do(m,S.length):T=="string"&&m in S)?Aa(S[m],p):!1}function oo(p,m){if(We(p))return!1;var S=typeof p;return S=="number"||S=="symbol"||S=="boolean"||p==null||da(p)?!0:Gd.test(p)||!Wd.test(p)||m!=null&&p in je(m)}function Ys(p){var m=typeof p;return m=="string"||m=="number"||m=="symbol"||m=="boolean"?p!=="__proto__":p===null}function jo(p){var m=wf(p),S=Z[m];if(typeof S!="function"||!(m in fn.prototype))return!1;if(p===S)return!0;var T=_f(S);return!!T&&p===T[0]}function yx(p){return!!Ev&&Ev in p}var fg=uh?Wa:hp;function $l(p){var m=p&&p.constructor,S=typeof m=="function"&&m.prototype||Tl;return p===S}function dt(p){return p===p&&!mr(p)}function Zl(p,m){return function(S){return S==null?!1:S[p]===m&&(m!==$||p in je(S))}}function is(p){var m=If(p,function(T){return S.size===ft&&S.clear(),T}),S=m.cache;return m}function mx(p,m){var S=p[1],T=m[1],B=S|T,Y=B<(bt|Tt|gn),q=T==gn&&S==_e||T==gn&&S==rn&&p[7].length<=m[8]||T==(gn|rn)&&m[7].length<=m[8]&&S==_e;if(!(Y||q))return p;T&bt&&(p[2]=m[2],B|=S&bt?0:xe);var et=m[3];if(et){var st=p[3];p[3]=st?Lh(st,et,m[4]):et,p[4]=st?js(p[3],re):m[4]}return et=m[5],et&&(st=p[5],p[5]=st?Rh(st,et,m[6]):et,p[6]=st?js(p[5],re):m[6]),et=m[7],et&&(p[7]=et),T&gn&&(p[8]=p[8]==null?m[8]:ri(p[8],m[8])),p[9]==null&&(p[9]=m[9]),p[0]=m[0],p[1]=B,p}function Bh(p){var m=[];if(p!=null)for(var S in je(p))m.push(S);return m}function $c(p){return dh.call(p)}function dg(p,m,S){return m=ni(m===$?p.length-1:m,0),function(){for(var T=arguments,B=-1,Y=ni(T.length-m,0),q=vt(Y);++B<Y;)q[B]=T[m+B];B=-1;for(var et=vt(m+1);++B<m;)et[B]=T[B];return et[m]=S(q),Lr(p,this,et)}}function hg(p,m){return m.length<2?p:Ws(p,Yi(m,0,-1))}function pg(p,m){for(var S=p.length,T=ri(m.length,S),B=Vi(p);T--;){var Y=m[T];p[T]=Do(Y,S)?B[Y]:$}return p}function Yl(p,m){if(!(m==="constructor"&&typeof p[m]=="function")&&m!="__proto__")return p[m]}var xr=ii(Yv),Hl=PM||function(p,m){return lr.setTimeout(p,m)},as=ii(Hv);function vg(p,m,S){var T=m+"";return as(p,sk(T,Zc(Gl(T),S)))}function ii(p){var m=0,S=0;return function(){var T=NM(),B=zr-(T-S);if(S=T,B>0){if(++m>=Se)return arguments[0]}else m=0;return p.apply($,arguments)}}function Fo(p,m){var S=-1,T=p.length,B=T-1;for(m=m===$?T:m;++S<m;){var Y=$s(S,B),q=p[Y];p[Y]=p[S],p[S]=q}return p.length=m,p}var kn=is(function(p){var m=[];return p.charCodeAt(0)===46&&m.push(""),p.replace(av,function(S,T,B,Y){m.push(B?Y.replace(Mc,"$1"):T||S)}),m});function Ti(p){if(typeof p=="string"||da(p))return p;var m=p+"";return m=="0"&&1/p==-tr?"-0":m}function Hs(p){if(p!=null){try{return fh.call(p)}catch(m){}try{return p+""}catch(m){}}return""}function Zc(p,m){return ua(ks,function(S){var T="_."+S[0];m&S[1]&&!Ml(p,T)&&p.push(T)}),p.sort()}function Sf(p){if(p instanceof fn)return p.clone();var m=new Da(p.__wrapped__,p.__chain__);return m.__actions__=Vi(p.__actions__),m.__index__=p.__index__,m.__values__=p.__values__,m}function Pi(p,m,S){(S?Mn(p,m,S):m===$)?m=1:m=ni(Ve(m),0);var T=p==null?0:p.length;if(!T||m<1)return[];for(var B=0,Y=0,q=vt(yh(T/m));B<T;)q[Y++]=Yi(p,B,B+=m);return q}function bx(p){for(var m=-1,S=p==null?0:p.length,T=0,B=[];++m<S;){var Y=p[m];Y&&(B[T++]=Y)}return B}function Cn(){var p=arguments.length;if(!p)return[];for(var m=vt(p-1),S=arguments[0],T=p;T--;)m[T-1]=arguments[T];return fa(We(S)?Vi(S):[S],Rr(m,1))}var xx=Je(function(p,m){return bn(p)?Il(p,Rr(m,1,bn,!0)):[]}),Sa=Je(function(p,m){var S=Xi(m);return bn(S)&&(S=$),bn(p)?Il(p,Rr(m,1,bn,!0),Pe(S,2)):[]}),_x=Je(function(p,m){var S=Xi(m);return bn(S)&&(S=$),bn(p)?Il(p,Rr(m,1,bn,!0),$,S):[]});function ck(p,m,S){var T=p==null?0:p.length;return T?(m=S||m===$?1:Ve(m),Yi(p,m<0?0:m,T)):[]}function lk(p,m,S){var T=p==null?0:p.length;return T?(m=S||m===$?1:Ve(m),m=T-m,Yi(p,0,m<0?0:m)):[]}function wx(p,m){return p&&p.length?uf(p,Pe(m,3),!0,!0):[]}function Ef(p,m){return p&&p.length?uf(p,Pe(m,3),!0):[]}function Ox(p,m,S,T){var B=p==null?0:p.length;return B?(S&&typeof S!="number"&&Mn(p,m,S)&&(S=0,T=B),$b(p,m,S,T)):[]}function gg(p,m,S){var T=p==null?0:p.length;if(!T)return-1;var B=S==null?0:Ve(S);return B<0&&(B=ni(T+B,0)),Zu(p,Pe(m,3),B)}function Mf(p,m,S){var T=p==null?0:p.length;if(!T)return-1;var B=T-1;return S!==$&&(B=Ve(S),B=S<0?ni(T+B,0):ri(B,T-1)),Zu(p,Pe(m,3),B,!0)}function yg(p){var m=p==null?0:p.length;return m?Rr(p,1):[]}function Sx(p){var m=p==null?0:p.length;return m?Rr(p,tr):[]}function mg(p,m){var S=p==null?0:p.length;return S?(m=m===$?1:Ve(m),Rr(p,m)):[]}function so(p){for(var m=-1,S=p==null?0:p.length,T={};++m<S;){var B=p[m];T[B[0]]=B[1]}return T}function Ea(p){return p&&p.length?p[0]:$}function Vl(p,m,S){var T=p==null?0:p.length;if(!T)return-1;var B=S==null?0:Ve(S);return B<0&&(B=ni(T+B,0)),Cc(p,m,B)}function Le(p){var m=p==null?0:p.length;return m?Yi(p,0,-1):[]}var bg=Je(function(p){var m=$n(p,Th);return m.length&&m[0]===p[0]?rf(m):[]}),Ex=Je(function(p){var m=Xi(p),S=$n(p,Th);return m===Xi(S)?m=$:S.pop(),S.length&&S[0]===p[0]?rf(S,Pe(m,2)):[]}),Mx=Je(function(p){var m=Xi(p),S=$n(p,Th);return m=typeof m=="function"?m:$,m&&S.pop(),S.length&&S[0]===p[0]?rf(S,$,m):[]});function kx(p,m){return p==null?"":LM.call(p,m)}function Xi(p){var m=p==null?0:p.length;return m?p[m-1]:$}function Ln(p,m,S){var T=p==null?0:p.length;if(!T)return-1;var B=T;return S!==$&&(B=Ve(S),B=B<0?ni(T+B,0):ri(B,T-1)),m===m?_M(p,m,B):Zu(p,eh,B,!0)}function zh(p,m){return p&&p.length?$v(p,Ve(m)):$}var Ma=Je(Wh);function Wh(p,m){return p&&p.length&&m&&m.length?Bc(p,m):p}function xg(p,m,S){return p&&p.length&&m&&m.length?Bc(p,m,Pe(S,2)):p}function _g(p,m,S){return p&&p.length&&m&&m.length?Bc(p,m,$,S):p}var Ax=io(function(p,m){var S=p==null?0:p.length,T=V(p,m);return Zv(p,$n(m,function(B){return Do(B,S)?+B:B}).sort(li)),T});function kf(p,m){var S=[];if(!(p&&p.length))return S;var T=-1,B=[],Y=p.length;for(m=Pe(m,3);++T<Y;){var q=p[T];m(q,T,p)&&(S.push(q),B.push(T))}return Zv(p,B),S}function Af(p){return p==null?p:Nb.call(p)}function zt(p,m,S){var T=p==null?0:p.length;return T?(S&&typeof S!="number"&&Mn(p,m,S)?(m=0,S=T):(m=m==null?0:Ve(m),S=S===$?T:Ve(S)),Yi(p,m,S)):[]}function Gh(p,m){return Bl(p,m)}function wg(p,m,S){return lf(p,m,Pe(S,2))}function Xl(p,m){var S=p==null?0:p.length;if(S){var T=Bl(p,m);if(T<S&&Aa(p[T],m))return T}return-1}function Ul(p,m){return Bl(p,m,!0)}function Tf(p,m,S){return lf(p,m,Pe(S,2),!0)}function Yc(p,m){var S=p==null?0:p.length;if(S){var T=Bl(p,m,!0)-1;if(Aa(p[T],m))return T}return-1}function ql(p){return p&&p.length?Vv(p):[]}function co(p,m){return p&&p.length?Vv(p,Pe(m,2)):[]}function Tx(p){var m=p==null?0:p.length;return m?Yi(p,1,m):[]}function Px(p,m,S){return p&&p.length?(m=S||m===$?1:Ve(m),Yi(p,0,m<0?0:m)):[]}function Cx(p,m,S){var T=p==null?0:p.length;return T?(m=S||m===$?1:Ve(m),m=T-m,Yi(p,m<0?0:m,T)):[]}function Lx(p,m){return p&&p.length?uf(p,Pe(m,3),!1,!0):[]}function Rx(p,m){return p&&p.length?uf(p,Pe(m,3)):[]}var Nx=Je(function(p){return ns(Rr(p,1,bn,!0))}),Ix=Je(function(p){var m=Xi(p);return bn(m)&&(m=$),ns(Rr(p,1,bn,!0),Pe(m,2))}),Og=Je(function(p){var m=Xi(p);return m=typeof m=="function"?m:$,ns(Rr(p,1,bn,!0),$,m)});function Sg(p){return p&&p.length?ns(p):[]}function Dx(p,m){return p&&p.length?ns(p,Pe(m,2)):[]}function jx(p,m){return m=typeof m=="function"?m:$,p&&p.length?ns(p,$,m):[]}function Pf(p){if(!(p&&p.length))return[];var m=0;return p=Qa(p,function(S){if(bn(S))return m=ni(S.length,m),!0}),Hu(m,function(S){return $n(p,Yu(S))})}function Kl(p,m){if(!(p&&p.length))return[];var S=Pf(p);return m==null?S:$n(S,function(T){return Lr(m,$,T)})}var Eg=Je(function(p,m){return bn(p)?Il(p,m):[]}),Cf=Je(function(p){return En(Qa(p,bn))}),Fx=Je(function(p){var m=Xi(p);return bn(m)&&(m=$),En(Qa(p,bn),Pe(m,2))}),Bx=Je(function(p){var m=Xi(p);return m=typeof m=="function"?m:$,En(Qa(p,bn),$,m)}),Ui=Je(Pf);function Mg(p,m){return Kv(p||[],m||[],Nl)}function zx(p,m){return Kv(p||[],m||[],Zs)}var kg=Je(function(p){var m=p.length,S=m>1?p[m-1]:$;return S=typeof S=="function"?(p.pop(),S):$,Kl(p,S)});function Ql(p){var m=Z(p);return m.__chain__=!0,m}function Vs(p,m){return m(p),p}function lo(p,m){return m(p)}var Ag=io(function(p){var m=p.length,S=m?p[0]:0,T=this.__wrapped__,B=function(Y){return V(Y,p)};return m>1||this.__actions__.length||!(T instanceof fn)||!Do(S)?this.thru(B):(T=T.slice(S,+S+(m?1:0)),T.__actions__.push({func:lo,args:[B],thisArg:$}),new Da(T,this.__chain__).thru(function(Y){return m&&!Y.length&&Y.push($),Y}))});function Tg(){return Ql(this)}function Wx(){return new Da(this.value(),this.__chain__)}function ja(){this.__values__===$&&(this.__values__=Qg(this.value()));var p=this.__index__>=this.__values__.length,m=p?$:this.__values__[this.__index__++];return{done:p,value:m}}function Pg(){return this}function Lf(p){for(var m,S=this;S instanceof Qu;){var T=Sf(S);T.__index__=0,T.__values__=$,m?B.__wrapped__=T:m=T;var B=T;S=S.__wrapped__}return B.__wrapped__=p,m}function $h(){var p=this.__wrapped__;if(p instanceof fn){var m=p;return this.__actions__.length&&(m=new fn(this)),m=m.reverse(),m.__actions__.push({func:lo,args:[Af],thisArg:$}),new Da(m,this.__chain__)}return this.thru(Af)}function Ir(){return qv(this.__wrapped__,this.__actions__)}var Zt=hf(function(p,m,S){Fn.call(p,S)?++p[S]:gi(p,S,1)});function Fa(p,m,S){var T=We(p)?Qd:Gb;return S&&Mn(p,m,S)&&(m=$),T(p,Pe(m,3))}function Gx(p,m){var S=We(p)?Qa:Nv;return S(p,Pe(m,3))}var $x=ig(gg),Zx=ig(Mf);function Hc(p,m){return Rr(Ba(p,m),1)}function Yx(p,m){return Rr(Ba(p,m),tr)}function Hx(p,m,S){return S=S===$?1:Ve(S),Rr(Ba(p,m),S)}function Cg(p,m){var S=We(p)?ua:ts;return S(p,Pe(m,3))}function Lg(p,m){var S=We(p)?gv:Rv;return S(p,Pe(m,3))}var Rg=hf(function(p,m,S){Fn.call(p,S)?p[S].push(m):gi(p,S,[m])});function Zh(p,m,S,T){p=Ci(p)?p:qc(p),S=S&&!T?Ve(S):0;var B=p.length;return S<0&&(S=ni(B+S,0)),Bf(p)?S<=B&&p.indexOf(m,S)>-1:!!B&&Cc(p,m,S)>-1}var Rf=Je(function(p,m,S){var T=-1,B=typeof m=="function",Y=Ci(p)?vt(p.length):[];return ts(p,function(q){Y[++T]=B?Lr(m,q,S):Dl(q,m,S)}),Y}),Vx=hf(function(p,m,S){gi(p,S,m)});function Ba(p,m){var S=We(p)?$n:zv;return S(p,Pe(m,3))}function Nf(p,m,S,T){return p==null?[]:(We(m)||(m=m==null?[]:[m]),S=T?$:S,We(S)||(S=S==null?[]:[S]),kh(p,m,S))}var ka=hf(function(p,m,S){p[S?0:1].push(m)},function(){return[[],[]]});function Xx(p,m,S){var T=We(p)?Pc:xv,B=arguments.length<3;return T(p,Pe(m,4),S,B,ts)}function Yh(p,m,S){var T=We(p)?wb:xv,B=arguments.length<3;return T(p,Pe(m,4),S,B,Rv)}function Rn(p,m){var S=We(p)?Qa:Nv;return S(p,Jl(Pe(m,3)))}function za(p){var m=We(p)?Cv:nx;return m(p)}function Xs(p,m,S){(S?Mn(p,m,S):m===$)?m=1:m=Ve(m);var T=We(p)?Fb:cf;return T(p,m)}function Hh(p){var m=We(p)?Bb:rx;return m(p)}function Ng(p){if(p==null)return 0;if(Ci(p))return Bf(p)?Al(p):p.length;var m=Ai(p);return m==_i||m==xt?p.size:eo(p).length}function Ux(p,m,S){var T=We(p)?Ds:ix;return S&&Mn(p,m,S)&&(m=$),T(p,Pe(m,3))}var qx=Je(function(p,m){if(p==null)return[];var S=m.length;return S>1&&Mn(p,m[0],m[1])?m=[]:S>2&&Mn(m[0],m[1],m[2])&&(m=[m[0]]),kh(p,Rr(m,1),[])}),Vc=TM||function(){return lr.Date.now()};function Kx(p,m){if(typeof m!="function")throw new Ia(Rt);return p=Ve(p),function(){if(--p<1)return m.apply(this,arguments)}}function Vh(p,m,S){return m=S?$:m,m=p&&m==null?p.length:m,Io(p,gn,$,$,$,$,m)}function Xh(p,m){var S;if(typeof m!="function")throw new Ia(Rt);return p=Ve(p),function(){return--p>0&&(S=m.apply(this,arguments)),p<=1&&(m=$),S}}var Uh=Je(function(p,m,S){var T=bt;if(S.length){var B=js(S,Gc(Uh));T|=Ue}return Io(p,T,m,S,B)}),Un=Je(function(p,m,S){var T=bt|Tt;if(S.length){var B=js(S,Gc(Un));T|=Ue}return Io(m,T,p,S,B)});function Ig(p,m,S){m=S?$:m;var T=Io(p,_e,$,$,$,$,$,m);return T.placeholder=Ig.placeholder,T}function Dg(p,m,S){m=S?$:m;var T=Io(p,_n,$,$,$,$,$,m);return T.placeholder=Dg.placeholder,T}function jg(p,m,S){var T,B,Y,q,et,st,Et=0,Mt=!1,Pt=!1,Vt=!0;if(typeof p!="function")throw new Ia(Rt);m=Ta(m)||0,mr(S)&&(Mt=!!S.leading,Pt="maxWait"in S,Y=Pt?ni(Ta(S.maxWait)||0,m):Y,Vt="trailing"in S?!!S.trailing:Vt);function de(Sr){var Ga=T,Bo=B;return T=B=$,Et=Sr,q=p.apply(Bo,Ga),q}function ke(Sr){return Et=Sr,et=Hl(tn,m),Mt?de(Sr):q}function Xe(Sr){var Ga=Sr-st,Bo=Sr-Et,wy=m-Ga;return Pt?ri(wy,Y-Bo):wy}function we(Sr){var Ga=Sr-st,Bo=Sr-Et;return st===$||Ga>=m||Ga<0||Pt&&Bo>=Y}function tn(){var Sr=Vc();if(we(Sr))return dn(Sr);et=Hl(tn,Xe(Sr))}function dn(Sr){return et=$,Vt&&T?de(Sr):(T=B=$,q)}function Hr(){et!==$&&zl(et),Et=0,T=st=B=et=$}function mi(){return et===$?q:dn(Vc())}function ha(){var Sr=Vc(),Ga=we(Sr);if(T=arguments,B=this,st=Sr,Ga){if(et===$)return ke(st);if(Pt)return zl(et),et=Hl(tn,m),de(st)}return et===$&&(et=Hl(tn,m)),q}return ha.cancel=Hr,ha.flush=mi,ha}var Qx=Je(function(p,m){return Lv(p,1,m)}),Jx=Je(function(p,m,S){return Lv(p,Ta(m)||0,S)});function t2(p){return Io(p,Yn)}function If(p,m){if(typeof p!="function"||m!=null&&typeof m!="function")throw new Ia(Rt);var S=function(){var T=arguments,B=m?m.apply(this,T):T[0],Y=S.cache;if(Y.has(B))return Y.get(B);var q=p.apply(this,T);return S.cache=Y.set(B,q)||Y,q};return S.cache=new(If.Cache||Jo),S}If.Cache=Jo;function Jl(p){if(typeof p!="function")throw new Ia(Rt);return function(){var m=arguments;switch(m.length){case 0:return!p.call(this);case 1:return!p.call(this,m[0]);case 2:return!p.call(this,m[0],m[1]);case 3:return!p.call(this,m[0],m[1],m[2])}return!p.apply(this,m)}}function e2(p){return Xh(2,p)}var n2=Qv(function(p,m){m=m.length==1&&We(m[0])?$n(m[0],ki(Pe())):$n(Rr(m,1),ki(Pe()));var S=m.length;return Je(function(T){for(var B=-1,Y=ri(T.length,S);++B<Y;)T[B]=m[B].call(this,T[B]);return Lr(p,this,T)})}),qh=Je(function(p,m){var S=js(m,Gc(qh));return Io(p,Ue,$,m,S)}),Fg=Je(function(p,m){var S=js(m,Gc(Fg));return Io(p,pn,$,m,S)}),r2=io(function(p,m){return Io(p,rn,$,$,$,m)});function i2(p,m){if(typeof p!="function")throw new Ia(Rt);return m=m===$?m:Ve(m),Je(p,m)}function a2(p,m){if(typeof p!="function")throw new Ia(Rt);return m=m==null?0:ni(Ve(m),0),Je(function(S){var T=S[m],B=Xn(S,0,m);return T&&fa(B,T),Lr(p,this,B)})}function uk(p,m,S){var T=!0,B=!0;if(typeof p!="function")throw new Ia(Rt);return mr(S)&&(T="leading"in S?!!S.leading:T,B="trailing"in S?!!S.trailing:B),jg(p,m,{leading:T,maxWait:m,trailing:B})}function Us(p){return Vh(p,1)}function Df(p,m){return qh(ff(m),p)}function os(){if(!arguments.length)return[];var p=arguments[0];return We(p)?p:[p]}function o2(p){return wa(p,Xt)}function tu(p,m){return m=typeof m=="function"?m:$,wa(p,Xt,m)}function Bg(p){return wa(p,Wt|Xt)}function s2(p,m){return m=typeof m=="function"?m:$,wa(p,Wt|Xt,m)}function c2(p,m){return m==null||jc(p,m,Yr(m))}function Aa(p,m){return p===m||p!==p&&m!==m}var Kh=ro(nf),zg=ro(function(p,m){return p>=m}),qs=Gs(function(){return arguments}())?Gs:function(p){return _r(p)&&Fn.call(p,"callee")&&!Pl.call(p,"callee")},We=vt.isArray,qi=Ns?ki(Ns):Hb;function Ci(p){return p!=null&&jf(p.length)&&!Wa(p)}function bn(p){return _r(p)&&Ci(p)}function l2(p){return p===!0||p===!1||_r(p)&&Zr(p)==Ua}var ss=CM||hp,u2=Ud?ki(Ud):Vb;function Wg(p){return _r(p)&&p.nodeType===1&&!cs(p)}function Gg(p){if(p==null)return!0;if(Ci(p)&&(We(p)||typeof p=="string"||typeof p.splice=="function"||ss(p)||Ks(p)||qs(p)))return!p.length;var m=Ai(p);if(m==_i||m==xt)return!p.size;if($l(p))return!eo(p).length;for(var S in p)if(Fn.call(p,S))return!1;return!0}function Qh(p,m){return es(p,m)}function Jh(p,m,S){S=typeof S=="function"?S:$;var T=S?S(p,m):$;return T===$?es(p,m,$,S):!!T}function eu(p){if(!_r(p))return!1;var m=Zr(p);return m==Xo||m==Ts||typeof p.message=="string"&&typeof p.name=="string"&&!cs(p)}function $g(p){return typeof p=="number"&&Rb(p)}function Wa(p){if(!mr(p))return!1;var m=Zr(p);return m==zi||m==ma||m==Xa||m==wl}function Zg(p){return typeof p=="number"&&p==Ve(p)}function jf(p){return typeof p=="number"&&p>-1&&p%1==0&&p<=rt}function mr(p){var m=typeof p;return p!=null&&(m=="object"||m=="function")}function _r(p){return p!=null&&typeof p=="object"}var nu=pv?ki(pv):Ub;function f2(p,m){return p===m||Eh(p,m,lg(m))}function Ff(p,m,S){return S=typeof S=="function"?S:$,Eh(p,m,lg(m),S)}function Yg(p){return tp(p)&&p!=+p}function Hg(p){if(fg(p))throw new ze(ae);return Bv(p)}function Vg(p){return p===null}function d2(p){return p==null}function tp(p){return typeof p=="number"||_r(p)&&Zr(p)==ba}function cs(p){if(!_r(p)||Zr(p)!=Wi)return!1;var m=gh(p);if(m===null)return!0;var S=Fn.call(m,"constructor")&&m.constructor;return typeof S=="function"&&S instanceof S&&fh.call(S)==hh}var ru=qd?ki(qd):qb;function Xg(p){return Zg(p)&&p>=-rt&&p<=rt}var Ug=Kd?ki(Kd):Kb;function Bf(p){return typeof p=="string"||!We(p)&&_r(p)&&Zr(p)==Ot}function da(p){return typeof p=="symbol"||_r(p)&&Zr(p)==ln}var Ks=vv?ki(vv):Qb;function h2(p){return p===$}function p2(p){return _r(p)&&Ai(p)==Me}function qg(p){return _r(p)&&Zr(p)==Te}var fk=ro(af),Kg=ro(function(p,m){return p<=m});function Qg(p){if(!p)return[];if(Ci(p))return Bf(p)?Ja(p):Vi(p);if(Rc&&p[Rc])return mM(p[Rc]());var m=Ai(p),S=m==_i?Ov:m==xt?sh:qc;return S(p)}function uo(p){if(!p)return p===0?p:0;if(p=Ta(p),p===tr||p===-tr){var m=p<0?-1:1;return m*aa}return p===p?p:0}function Ve(p){var m=uo(p),S=m%1;return m===m?S?m-S:m:0}function Jg(p){return p?zs(Ve(p),0,Wr):0}function Ta(p){if(typeof p=="number")return p;if(da(p))return Bi;if(mr(p)){var m=typeof p.valueOf=="function"?p.valueOf():p;p=mr(m)?m+"":m}if(typeof p!="string")return p===0?p:+p;p=_v(p);var S=lv.test(p);return S||Zd.test(p)?Tc(p.slice(2),S?2:8):cv.test(p)?Bi:+p}function ur(p){return no(p,Ki(p))}function Xc(p){return p?zs(Ve(p),-rt,rt):p===0?p:0}function Ge(p){return p==null?"":Hi(p)}var Qs=zc(function(p,m){if($l(m)||Ci(m)){no(m,Yr(m),p);return}for(var S in m)Fn.call(m,S)&&Nl(p,S,m[S])}),Uc=zc(function(p,m){no(m,Ki(m),p)}),iu=zc(function(p,m,S,T){no(m,Ki(m),p,T)}),ty=zc(function(p,m,S,T){no(m,Yr(m),p,T)}),v2=io(V);function g2(p,m){var S=Ic(p);return m==null?S:tf(S,m)}var y2=Je(function(p,m){p=je(p);var S=-1,T=m.length,B=T>2?m[2]:$;for(B&&Mn(m[0],m[1],B)&&(T=1);++S<T;)for(var Y=m[S],q=Ki(Y),et=-1,st=q.length;++et<st;){var Et=q[et],Mt=p[Et];(Mt===$||Aa(Mt,Tl[Et])&&!Fn.call(p,Et))&&(p[Et]=Y[Et])}return p}),m2=Je(function(p){return p.push($,og),Lr(iy,$,p)});function ey(p,m){return mv(p,Pe(m,3),to)}function b2(p,m){return mv(p,Pe(m,3),Sh)}function x2(p,m){return p==null?p:Oh(p,Pe(m,3),Ki)}function ep(p,m){return p==null?p:Iv(p,Pe(m,3),Ki)}function _2(p,m){return p&&to(p,Pe(m,3))}function w2(p,m){return p&&Sh(p,Pe(m,3))}function np(p){return p==null?[]:ef(p,Yr(p))}function rp(p){return p==null?[]:ef(p,Ki(p))}function ip(p,m,S){var T=p==null?$:Ws(p,m);return T===$?S:T}function O2(p,m){return p!=null&&Fh(p,m,Dv)}function ap(p,m){return p!=null&&Fh(p,m,jv)}var ny=cx(function(p,m,S){m!=null&&typeof m.toString!="function"&&(m=dh.call(m)),p[m]=S},ou(yi)),op=cx(function(p,m,S){m!=null&&typeof m.toString!="function"&&(m=dh.call(m)),Fn.call(p,m)?p[m].push(S):p[m]=[S]},Pe),S2=Je(Dl);function Yr(p){return Ci(p)?Pv(p):eo(p)}function Ki(p){return Ci(p)?Pv(p,!0):Mh(p)}function E2(p,m){var S={};return m=Pe(m,3),to(p,function(T,B,Y){gi(S,m(T,B,Y),T)}),S}function ry(p,m){var S={};return m=Pe(m,3),to(p,function(T,B,Y){gi(S,B,m(T,B,Y))}),S}var M2=zc(function(p,m,S){Fl(p,m,S)}),iy=zc(function(p,m,S,T){Fl(p,m,S,T)}),k2=io(function(p,m){var S={};if(p==null)return S;var T=!1;m=$n(m,function(Y){return Y=rs(Y,p),T||(T=Y.length>1),Y}),no(p,xf(p),S),T&&(S=wa(S,Wt|ee|Xt,sg));for(var B=m.length;B--;)Ah(S,m[B]);return S});function A2(p,m){return zf(p,Jl(Pe(m)))}var ay=io(function(p,m){return p==null?{}:tx(p,m)});function zf(p,m){if(p==null)return{};var S=$n(xf(p),function(T){return[T]});return m=Pe(m),Nr(p,S,function(T,B){return m(T,B[0])})}function T2(p,m,S){m=rs(m,p);var T=-1,B=m.length;for(B||(B=1,p=$);++T<B;){var Y=p==null?$:p[Ti(m[T])];Y===$&&(T=B,Y=S),p=Wa(Y)?Y.call(p):Y}return p}function P2(p,m,S){return p==null?p:Zs(p,m,S)}function C2(p,m,S,T){return T=typeof T=="function"?T:$,p==null?p:Zs(p,m,S,T)}var oy=mf(Yr),sy=mf(Ki);function L2(p,m,S){var T=We(p),B=T||ss(p)||Ks(p);if(m=Pe(m,4),S==null){var Y=p&&p.constructor;B?S=T?new Y:[]:mr(p)?S=Wa(Y)?Ic(gh(p)):{}:S={}}return(B?ua:to)(p,function(q,et,st){return m(S,q,et,st)}),S}function R2(p,m){return p==null?!0:Ah(p,m)}function N2(p,m,S){return p==null?p:Uv(p,m,ff(S))}function I2(p,m,S,T){return T=typeof T=="function"?T:$,p==null?p:Uv(p,m,ff(S),T)}function qc(p){return p==null?[]:ah(p,Yr(p))}function D2(p){return p==null?[]:ah(p,Ki(p))}function dk(p,m,S){return S===$&&(S=m,m=$),S!==$&&(S=Ta(S),S=S===S?S:0),m!==$&&(m=Ta(m),m=m===m?m:0),zs(Ta(p),m,S)}function sp(p,m,S){return m=uo(m),S===$?(S=m,m=0):S=uo(S),p=Ta(p),Fv(p,m,S)}function j2(p,m,S){if(S&&typeof S!="boolean"&&Mn(p,m,S)&&(m=S=$),S===$&&(typeof m=="boolean"?(S=m,m=$):typeof p=="boolean"&&(S=p,p=$)),p===$&&m===$?(p=0,m=1):(p=uo(p),m===$?(m=p,p=0):m=uo(m)),p>m){var T=p;p=m,m=T}if(S||p%1||m%1){var B=kv();return ri(p+B*(m-p+dv("1e-"+((B+"").length-1))),m)}return $s(p,m)}var cp=Wc(function(p,m,S){return m=m.toLowerCase(),p+(S?cy(m):m)});function cy(p){return Gf(Ge(p).toLowerCase())}function ly(p){return p=Ge(p),p&&p.replace(Oi,pM).replace(sM,"")}function uy(p,m,S){p=Ge(p),m=Hi(m);var T=p.length;S=S===$?T:zs(Ve(S),0,T);var B=S;return S-=m.length,S>=0&&p.slice(S,B)==m}function fy(p){return p=Ge(p),p&&Bd.test(p)?p.replace(Na,vM):p}function dy(p){return p=Ge(p),p&&Sl.test(p)?p.replace(Uo,"\\$&"):p}var F2=Wc(function(p,m,S){return p+(S?"-":"")+m.toLowerCase()}),hy=Wc(function(p,m,S){return p+(S?" ":"")+m.toLowerCase()}),B2=Nh("toLowerCase");function z2(p,m,S){p=Ge(p),m=Ve(m);var T=m?Al(p):0;if(!m||T>=m)return p;var B=(m-T)/2;return gf(mh(B),S)+p+gf(yh(B),S)}function W2(p,m,S){p=Ge(p),m=Ve(m);var T=m?Al(p):0;return m&&T<m?p+gf(m-T,S):p}function G2(p,m,S){p=Ge(p),m=Ve(m);var T=m?Al(p):0;return m&&T<m?gf(m-T,S)+p:p}function lp(p,m,S){return S||m==null?m=0:m&&(m=+m),IM(Ge(p).replace(Oc,""),m||0)}function Wf(p,m,S){return(S?Mn(p,m,S):m===$)?m=1:m=Ve(m),sf(Ge(p),m)}function Js(){var p=arguments,m=Ge(p[0]);return p.length<3?m:m.replace(p[1],p[2])}var $2=Wc(function(p,m,S){return p+(S?"_":"")+m.toLowerCase()});function Z2(p,m,S){return S&&typeof S!="number"&&Mn(p,m,S)&&(m=S=$),S=S===$?Wr:S>>>0,S?(p=Ge(p),p&&(typeof m=="string"||m!=null&&!ru(m))&&(m=Hi(m),!m&&kl(p))?Xn(Ja(p),0,S):p.split(m,S)):[]}var fo=Wc(function(p,m,S){return p+(S?" ":"")+Gf(m)});function Y2(p,m,S){return p=Ge(p),S=S==null?0:zs(Ve(S),0,p.length),m=Hi(m),p.slice(S,S+m.length)==m}function H2(p,m,S){var T=Z.templateSettings;S&&Mn(p,m,S)&&(m=$),p=Ge(p),m=iu({},m,T,fx);var B=iu({},m.imports,T.imports,fx),Y=Yr(B),q=ah(B,Y),et,st,Et=0,Mt=m.interpolate||j,Pt="__p += '",Vt=Sv((m.escape||j).source+"|"+Mt.source+"|"+(Mt===zd?El:j).source+"|"+(m.evaluate||j).source+"|$","g"),de="//# sourceURL="+(Fn.call(m,"sourceURL")?(m.sourceURL+"").replace(/\s/g," "):"lodash.templateSources["+ ++uM+"]")+`
`;p.replace(Vt,function(we,tn,dn,Hr,mi,ha){return dn||(dn=Hr),Pt+=p.slice(Et,ha).replace(z,kb),tn&&(et=!0,Pt+=`' +
__e(`+tn+`) +
'`),mi&&(st=!0,Pt+=`';
`+mi+`;
__p += '`),dn&&(Pt+=`' +
((__t = (`+dn+`)) == null ? '' : __t) +
'`),Et=ha+we.length,we}),Pt+=`';
`;var ke=Fn.call(m,"variable")&&m.variable;if(!ke)Pt=`with (obj) {
`+Pt+`
}
`;else if(la.test(ke))throw new ze(qt);Pt=(st?Pt.replace(sa,""):Pt).replace(sn,"$1").replace(ca,"$1;"),Pt="function("+(ke||"obj")+`) {
`+(ke?"":`obj || (obj = {});
`)+"var __t, __p = ''"+(et?", __e = _.escape":"")+(st?`, __j = Array.prototype.join;
function print() { __p += __j.call(arguments, '') }
`:`;
`)+Pt+`return __p
}`;var Xe=up(function(){return Sn(Y,de+"return "+Pt).apply($,q)});if(Xe.source=Pt,eu(Xe))throw Xe;return Xe}function au(p){return Ge(p).toLowerCase()}function py(p){return Ge(p).toUpperCase()}function V2(p,m,S){if(p=Ge(p),p&&(S||m===$))return _v(p);if(!p||!(m=Hi(m)))return p;var T=Ja(p),B=Ja(m),Y=wv(T,B),q=oh(T,B)+1;return Xn(T,Y,q).join("")}function X2(p,m,S){if(p=Ge(p),p&&(S||m===$))return p.slice(0,Tb(p)+1);if(!p||!(m=Hi(m)))return p;var T=Ja(p),B=oh(T,Ja(m))+1;return Xn(T,0,B).join("")}function U2(p,m,S){if(p=Ge(p),p&&(S||m===$))return p.replace(Oc,"");if(!p||!(m=Hi(m)))return p;var T=Ja(p),B=wv(T,Ja(m));return Xn(T,B).join("")}function vy(p,m){var S=Jn,T=Ce;if(mr(m)){var B="separator"in m?m.separator:B;S="length"in m?Ve(m.length):S,T="omission"in m?Hi(m.omission):T}p=Ge(p);var Y=p.length;if(kl(p)){var q=Ja(p);Y=q.length}if(S>=Y)return p;var et=S-Al(T);if(et<1)return T;var st=q?Xn(q,0,et).join(""):p.slice(0,et);if(B===$)return st+T;if(q&&(et+=st.length-et),ru(B)){if(p.slice(et).search(B)){var Et,Mt=st;for(B.global||(B=Sv(B.source,Ge($d.exec(B))+"g")),B.lastIndex=0;Et=B.exec(Mt);)var Pt=Et.index;st=st.slice(0,Pt===$?et:Pt)}}else if(p.indexOf(Hi(B),et)!=et){var Vt=st.lastIndexOf(B);Vt>-1&&(st=st.slice(0,Vt))}return st+T}function q2(p){return p=Ge(p),p&&Ol.test(p)?p.replace(Gr,wM):p}var K2=Wc(function(p,m,S){return p+(S?" ":"")+m.toUpperCase()}),Gf=Nh("toUpperCase");function $f(p,m,S){return p=Ge(p),m=S?$:m,m===$?yM(p)?EM(p):yv(p):p.match(m)||[]}var up=Je(function(p,m){try{return Lr(p,$,m)}catch(S){return eu(S)?S:new ze(S)}}),Q2=io(function(p,m){return ua(m,function(S){S=Ti(S),gi(p,S,Uh(p[S],p))}),p});function J2(p){var m=p==null?0:p.length,S=Pe();return p=m?$n(p,function(T){if(typeof T[1]!="function")throw new Ia(Rt);return[S(T[0]),T[1]]}):[],Je(function(T){for(var B=-1;++B<m;){var Y=p[B];if(Lr(Y[0],this,T))return Lr(Y[1],this,T)}})}function Li(p){return te(wa(p,Wt))}function ou(p){return function(){return p}}function t_(p,m){return p==null||p!==p?m:p}var e_=Ih(),n_=Ih(!0);function yi(p){return p}function br(p){return jl(typeof p=="function"?p:wa(p,Wt))}function r_(p){return Wv(wa(p,Wt))}function i_(p,m){return Gv(p,wa(m,Wt))}var a_=Je(function(p,m){return function(S){return Dl(S,p,m)}}),o_=Je(function(p,m){return function(S){return Dl(p,S,m)}});function Zf(p,m,S){var T=Yr(m),B=ef(m,T);S==null&&!(mr(m)&&(B.length||!T.length))&&(S=m,m=p,p=this,B=ef(m,Yr(m)));var Y=!(mr(S)&&"chain"in S)||!!S.chain,q=Wa(p);return ua(B,function(et){var st=m[et];p[et]=st,q&&(p.prototype[et]=function(){var Et=this.__chain__;if(Y||Et){var Mt=p(this.__wrapped__),Pt=Mt.__actions__=Vi(this.__actions__);return Pt.push({func:st,args:arguments,thisArg:p}),Mt.__chain__=Et,Mt}return st.apply(p,fa([this.value()],arguments))})}),p}function gy(){return lr._===this&&(lr._=kM),this}function fp(){}function s_(p){return p=Ve(p),Je(function(m){return $v(m,p)})}var c_=Oa($n),l_=Oa(Qd),u_=Oa(Ds);function yy(p){return oo(p)?Yu(Ti(p)):of(p)}function f_(p){return function(m){return p==null?$:Ws(p,m)}}var d_=lx(),h_=lx(!0);function dp(){return[]}function hp(){return!1}function p_(){return{}}function hk(){return""}function Yf(){return!0}function my(p,m){if(p=Ve(p),p<1||p>rt)return[];var S=Wr,T=ri(p,Wr);m=Pe(m),p-=Wr;for(var B=Hu(T,m);++S<p;)m(S);return B}function pp(p){return We(p)?$n(p,Ti):da(p)?[p]:Vi(kn(Ge(p)))}function vp(p){var m=++Pb;return Ge(p)+m}var Nn=Wl(function(p,m){return p+m},0),by=yf("ceil"),xy=Wl(function(p,m){return p/m},1),fr=yf("floor");function v_(p){return p&&p.length?Fc(p,yi,nf):$}function g_(p,m){return p&&p.length?Fc(p,Pe(m,2),nf):$}function gp(p){return nh(p,yi)}function Kc(p,m){return nh(p,Pe(m,2))}function y_(p){return p&&p.length?Fc(p,yi,af):$}function m_(p,m){return p&&p.length?Fc(p,Pe(m,2),af):$}var b_=Wl(function(p,m){return p*m},1),$e=yf("round"),ho=Wl(function(p,m){return p-m},0);function _y(p){return p&&p.length?ih(p,yi):0}function x_(p,m){return p&&p.length?ih(p,Pe(m,2)):0}return Z.after=Kx,Z.ary=Vh,Z.assign=Qs,Z.assignIn=Uc,Z.assignInWith=iu,Z.assignWith=ty,Z.at=v2,Z.before=Xh,Z.bind=Uh,Z.bindAll=Q2,Z.bindKey=Un,Z.castArray=os,Z.chain=Ql,Z.chunk=Pi,Z.compact=bx,Z.concat=Cn,Z.cond=J2,Z.conforms=Li,Z.constant=ou,Z.countBy=Zt,Z.create=g2,Z.curry=Ig,Z.curryRight=Dg,Z.debounce=jg,Z.defaults=y2,Z.defaultsDeep=m2,Z.defer=Qx,Z.delay=Jx,Z.difference=xx,Z.differenceBy=Sa,Z.differenceWith=_x,Z.drop=ck,Z.dropRight=lk,Z.dropRightWhile=wx,Z.dropWhile=Ef,Z.fill=Ox,Z.filter=Gx,Z.flatMap=Hc,Z.flatMapDeep=Yx,Z.flatMapDepth=Hx,Z.flatten=yg,Z.flattenDeep=Sx,Z.flattenDepth=mg,Z.flip=t2,Z.flow=e_,Z.flowRight=n_,Z.fromPairs=so,Z.functions=np,Z.functionsIn=rp,Z.groupBy=Rg,Z.initial=Le,Z.intersection=bg,Z.intersectionBy=Ex,Z.intersectionWith=Mx,Z.invert=ny,Z.invertBy=op,Z.invokeMap=Rf,Z.iteratee=br,Z.keyBy=Vx,Z.keys=Yr,Z.keysIn=Ki,Z.map=Ba,Z.mapKeys=E2,Z.mapValues=ry,Z.matches=r_,Z.matchesProperty=i_,Z.memoize=If,Z.merge=M2,Z.mergeWith=iy,Z.method=a_,Z.methodOf=o_,Z.mixin=Zf,Z.negate=Jl,Z.nthArg=s_,Z.omit=k2,Z.omitBy=A2,Z.once=e2,Z.orderBy=Nf,Z.over=c_,Z.overArgs=n2,Z.overEvery=l_,Z.overSome=u_,Z.partial=qh,Z.partialRight=Fg,Z.partition=ka,Z.pick=ay,Z.pickBy=zf,Z.property=yy,Z.propertyOf=f_,Z.pull=Ma,Z.pullAll=Wh,Z.pullAllBy=xg,Z.pullAllWith=_g,Z.pullAt=Ax,Z.range=d_,Z.rangeRight=h_,Z.rearg=r2,Z.reject=Rn,Z.remove=kf,Z.rest=i2,Z.reverse=Af,Z.sampleSize=Xs,Z.set=P2,Z.setWith=C2,Z.shuffle=Hh,Z.slice=zt,Z.sortBy=qx,Z.sortedUniq=ql,Z.sortedUniqBy=co,Z.split=Z2,Z.spread=a2,Z.tail=Tx,Z.take=Px,Z.takeRight=Cx,Z.takeRightWhile=Lx,Z.takeWhile=Rx,Z.tap=Vs,Z.throttle=uk,Z.thru=lo,Z.toArray=Qg,Z.toPairs=oy,Z.toPairsIn=sy,Z.toPath=pp,Z.toPlainObject=ur,Z.transform=L2,Z.unary=Us,Z.union=Nx,Z.unionBy=Ix,Z.unionWith=Og,Z.uniq=Sg,Z.uniqBy=Dx,Z.uniqWith=jx,Z.unset=R2,Z.unzip=Pf,Z.unzipWith=Kl,Z.update=N2,Z.updateWith=I2,Z.values=qc,Z.valuesIn=D2,Z.without=Eg,Z.words=$f,Z.wrap=Df,Z.xor=Cf,Z.xorBy=Fx,Z.xorWith=Bx,Z.zip=Ui,Z.zipObject=Mg,Z.zipObjectDeep=zx,Z.zipWith=kg,Z.entries=oy,Z.entriesIn=sy,Z.extend=Uc,Z.extendWith=iu,Zf(Z,Z),Z.add=Nn,Z.attempt=up,Z.camelCase=cp,Z.capitalize=cy,Z.ceil=by,Z.clamp=dk,Z.clone=o2,Z.cloneDeep=Bg,Z.cloneDeepWith=s2,Z.cloneWith=tu,Z.conformsTo=c2,Z.deburr=ly,Z.defaultTo=t_,Z.divide=xy,Z.endsWith=uy,Z.eq=Aa,Z.escape=fy,Z.escapeRegExp=dy,Z.every=Fa,Z.find=$x,Z.findIndex=gg,Z.findKey=ey,Z.findLast=Zx,Z.findLastIndex=Mf,Z.findLastKey=b2,Z.floor=fr,Z.forEach=Cg,Z.forEachRight=Lg,Z.forIn=x2,Z.forInRight=ep,Z.forOwn=_2,Z.forOwnRight=w2,Z.get=ip,Z.gt=Kh,Z.gte=zg,Z.has=O2,Z.hasIn=ap,Z.head=Ea,Z.identity=yi,Z.includes=Zh,Z.indexOf=Vl,Z.inRange=sp,Z.invoke=S2,Z.isArguments=qs,Z.isArray=We,Z.isArrayBuffer=qi,Z.isArrayLike=Ci,Z.isArrayLikeObject=bn,Z.isBoolean=l2,Z.isBuffer=ss,Z.isDate=u2,Z.isElement=Wg,Z.isEmpty=Gg,Z.isEqual=Qh,Z.isEqualWith=Jh,Z.isError=eu,Z.isFinite=$g,Z.isFunction=Wa,Z.isInteger=Zg,Z.isLength=jf,Z.isMap=nu,Z.isMatch=f2,Z.isMatchWith=Ff,Z.isNaN=Yg,Z.isNative=Hg,Z.isNil=d2,Z.isNull=Vg,Z.isNumber=tp,Z.isObject=mr,Z.isObjectLike=_r,Z.isPlainObject=cs,Z.isRegExp=ru,Z.isSafeInteger=Xg,Z.isSet=Ug,Z.isString=Bf,Z.isSymbol=da,Z.isTypedArray=Ks,Z.isUndefined=h2,Z.isWeakMap=p2,Z.isWeakSet=qg,Z.join=kx,Z.kebabCase=F2,Z.last=Xi,Z.lastIndexOf=Ln,Z.lowerCase=hy,Z.lowerFirst=B2,Z.lt=fk,Z.lte=Kg,Z.max=v_,Z.maxBy=g_,Z.mean=gp,Z.meanBy=Kc,Z.min=y_,Z.minBy=m_,Z.stubArray=dp,Z.stubFalse=hp,Z.stubObject=p_,Z.stubString=hk,Z.stubTrue=Yf,Z.multiply=b_,Z.nth=zh,Z.noConflict=gy,Z.noop=fp,Z.now=Vc,Z.pad=z2,Z.padEnd=W2,Z.padStart=G2,Z.parseInt=lp,Z.random=j2,Z.reduce=Xx,Z.reduceRight=Yh,Z.repeat=Wf,Z.replace=Js,Z.result=T2,Z.round=$e,Z.runInContext=ot,Z.sample=za,Z.size=Ng,Z.snakeCase=$2,Z.some=Ux,Z.sortedIndex=Gh,Z.sortedIndexBy=wg,Z.sortedIndexOf=Xl,Z.sortedLastIndex=Ul,Z.sortedLastIndexBy=Tf,Z.sortedLastIndexOf=Yc,Z.startCase=fo,Z.startsWith=Y2,Z.subtract=ho,Z.sum=_y,Z.sumBy=x_,Z.template=H2,Z.times=my,Z.toFinite=uo,Z.toInteger=Ve,Z.toLength=Jg,Z.toLower=au,Z.toNumber=Ta,Z.toSafeInteger=Xc,Z.toString=Ge,Z.toUpper=py,Z.trim=V2,Z.trimEnd=X2,Z.trimStart=U2,Z.truncate=vy,Z.unescape=q2,Z.uniqueId=vp,Z.upperCase=K2,Z.upperFirst=Gf,Z.each=Cg,Z.eachRight=Lg,Z.first=Ea,Zf(Z,function(){var p={};return to(Z,function(m,S){Fn.call(Z.prototype,S)||(p[S]=m)}),p}(),{chain:!1}),Z.VERSION=fe,ua(["bind","bindKey","curry","curryRight","partial","partialRight"],function(p){Z[p].placeholder=Z}),ua(["drop","take"],function(p,m){fn.prototype[p]=function(S){S=S===$?1:ni(Ve(S),0);var T=this.__filtered__&&!m?new fn(this):this.clone();return T.__filtered__?T.__takeCount__=ri(S,T.__takeCount__):T.__views__.push({size:ri(S,Wr),type:p+(T.__dir__<0?"Right":"")}),T},fn.prototype[p+"Right"]=function(S){return this.reverse()[p](S).reverse()}}),ua(["filter","map","takeWhile"],function(p,m){var S=m+1,T=S==di||S==hi;fn.prototype[p]=function(B){var Y=this.clone();return Y.__iteratees__.push({iteratee:Pe(B,3),type:S}),Y.__filtered__=Y.__filtered__||T,Y}}),ua(["head","last"],function(p,m){var S="take"+(m?"Right":"");fn.prototype[p]=function(){return this[S](1).value()[0]}}),ua(["initial","tail"],function(p,m){var S="drop"+(m?"":"Right");fn.prototype[p]=function(){return this.__filtered__?new fn(this):this[S](1)}}),fn.prototype.compact=function(){return this.filter(yi)},fn.prototype.find=function(p){return this.filter(p).head()},fn.prototype.findLast=function(p){return this.reverse().find(p)},fn.prototype.invokeMap=Je(function(p,m){return typeof p=="function"?new fn(this):this.map(function(S){return Dl(S,p,m)})}),fn.prototype.reject=function(p){return this.filter(Jl(Pe(p)))},fn.prototype.slice=function(p,m){p=Ve(p);var S=this;return S.__filtered__&&(p>0||m<0)?new fn(S):(p<0?S=S.takeRight(-p):p&&(S=S.drop(p)),m!==$&&(m=Ve(m),S=m<0?S.dropRight(-m):S.take(m-p)),S)},fn.prototype.takeRightWhile=function(p){return this.reverse().takeWhile(p).reverse()},fn.prototype.toArray=function(){return this.take(Wr)},to(fn.prototype,function(p,m){var S=/^(?:filter|find|map|reject)|While$/.test(m),T=/^(?:head|last)$/.test(m),B=Z[T?"take"+(m=="last"?"Right":""):m],Y=T||/^find/.test(m);B&&(Z.prototype[m]=function(){var q=this.__wrapped__,et=T?[1]:arguments,st=q instanceof fn,Et=et[0],Mt=st||We(q),Pt=function(tn){var dn=B.apply(Z,fa([tn],et));return T&&Vt?dn[0]:dn};Mt&&S&&typeof Et=="function"&&Et.length!=1&&(st=Mt=!1);var Vt=this.__chain__,de=!!this.__actions__.length,ke=Y&&!Vt,Xe=st&&!de;if(!Y&&Mt){q=Xe?q:new fn(this);var we=p.apply(q,et);return we.__actions__.push({func:lo,args:[Pt],thisArg:$}),new Da(we,Vt)}return ke&&Xe?p.apply(this,et):(we=this.thru(Pt),ke?T?we.value()[0]:we.value():we)})}),ua(["pop","push","shift","sort","splice","unshift"],function(p){var m=lh[p],S=/^(?:push|sort|unshift)$/.test(p)?"tap":"thru",T=/^(?:pop|shift)$/.test(p);Z.prototype[p]=function(){var B=arguments;if(T&&!this.__chain__){var Y=this.value();return m.apply(We(Y)?Y:[],B)}return this[S](function(q){return m.apply(We(q)?q:[],B)})}}),to(fn.prototype,function(p,m){var S=Z[m];if(S){var T=S.name+"";Fn.call(Rl,T)||(Rl[T]=[]),Rl[T].push({name:m,func:S})}}),Rl[vf($,Tt).name]=[{name:"wrapper",func:$}],fn.prototype.clone=WM,fn.prototype.reverse=GM,fn.prototype.value=$M,Z.prototype.at=Ag,Z.prototype.chain=Tg,Z.prototype.commit=Wx,Z.prototype.next=ja,Z.prototype.plant=Lf,Z.prototype.reverse=$h,Z.prototype.toJSON=Z.prototype.valueOf=Z.prototype.value=Ir,Z.prototype.first=Z.prototype.head,Rc&&(Z.prototype[Rc]=Pg),Z},ch=MM();lr._=ch,oe=function(){return ch}.call(Be,pt,Be,Ae),oe!==$&&(Ae.exports=oe)}).call(this)},73807:function(Ae){"use strict";var Be=Ae.exports;Ae.exports.isNumber=function(pt){return typeof pt=="number"},Ae.exports.findMin=function(pt){if(pt.length===0)return 1/0;for(var oe=pt[0],$=1;$<pt.length;$++)oe=Math.min(oe,pt[$]);return oe},Ae.exports.findMax=function(pt){if(pt.length===0)return-1/0;for(var oe=pt[0],$=1;$<pt.length;$++)oe=Math.max(oe,pt[$]);return oe},Ae.exports.findMinMulti=function(pt){for(var oe=Be.findMin(pt[0]),$=1;$<pt.length;$++)oe=Math.min(oe,Be.findMin(pt[$]));return oe},Ae.exports.findMaxMulti=function(pt){for(var oe=Be.findMax(pt[0]),$=1;$<pt.length;$++)oe=Math.max(oe,Be.findMax(pt[$]));return oe},Ae.exports.inside=function(pt,oe,$){return pt<=$&&$<=oe}},53843:function(Ae,Be,pt){"use strict";var oe=50,$=2,fe=Math.log(2),Ye=Ae.exports,ae=pt(73807);function Rt(Yt){return 1-Math.abs(Yt)}Ae.exports.getUnifiedMinMax=function(Yt,ft){return Ye.getUnifiedMinMaxMulti([Yt],ft)},Ae.exports.getUnifiedMinMaxMulti=function(Yt,ft){ft=ft||{};var re=!1,Wt=!1,ee=ae.isNumber(ft.width)?ft.width:$,Xt=ae.isNumber(ft.size)?ft.size:oe,kt=ae.isNumber(ft.min)?ft.min:(re=!0,ae.findMinMulti(Yt)),St=ae.isNumber(ft.max)?ft.max:(Wt=!0,ae.findMaxMulti(Yt)),bt=St-kt,Tt=bt/(Xt-1);return re&&(kt=kt-2*ee*Tt),Wt&&(St=St+2*ee*Tt),{min:kt,max:St}},Ae.exports.create=function(Yt,ft){if(ft=ft||{},!Yt||Yt.length===0)return[];var re=ae.isNumber(ft.size)?ft.size:oe,Wt=ae.isNumber(ft.width)?ft.width:$,ee=Ye.getUnifiedMinMax(Yt,{size:re,width:Wt,min:ft.min,max:ft.max}),Xt=ee.min,kt=ee.max,St=kt-Xt,bt=St/(re-1);if(St===0)return[{x:Xt,y:1}];for(var Tt=[],xe=0;xe<re;xe++)Tt.push({x:Xt+xe*bt,y:0});var _e=function(Ce){return Math.floor((Ce-Xt)/bt)},_n=qt(Rt,Wt),Ue=_n[Wt],pn=_n[Wt-1]-_n[Wt-2],gn=0;Yt.forEach(function(Ce){var Se=_e(Ce);if(!(Se+Wt<0||Se-Wt>=Tt.length)){var zr=Math.max(Se-Wt,0),di=Se,Fi=Math.min(Se+Wt,Tt.length-1),hi=zr-(Se-Wt),tr=Se+Wt-Fi,rt=_n[-Wt-1+hi]||0,aa=_n[-Wt-1+tr]||0,Bi=Ue/(Ue-rt-aa);hi>0&&(gn+=Bi*(hi-1)*pn);var Wr=Math.max(0,Se-Wt+1);ae.inside(0,Tt.length-1,Wr)&&(Tt[Wr].y+=Bi*1*pn),ae.inside(0,Tt.length-1,di+1)&&(Tt[di+1].y-=Bi*2*pn),ae.inside(0,Tt.length-1,Fi+1)&&(Tt[Fi+1].y+=Bi*1*pn)}});var rn=gn,Yn=0,Jn=0;return Tt.forEach(function(Ce){Yn+=Ce.y,rn+=Yn,Ce.y=rn,Jn+=rn}),Jn>0&&Tt.forEach(function(Ce){Ce.y/=Jn}),Tt};function qt(Yt,ft){for(var re={},Wt=0,ee=-ft;ee<=ft;ee++)Wt+=Yt(ee/ft),re[ee]=Wt;return re}Ae.exports.getExpectedValueFromPdf=function(Yt){if(!(!Yt||Yt.length===0)){var ft=0;return Yt.forEach(function(re){ft+=re.x*re.y}),ft}},Ae.exports.getXWithLeftTailArea=function(Yt,ft){if(!(!Yt||Yt.length===0)){for(var re=0,Wt=0,ee=0;ee<Yt.length&&(Wt=ee,re+=Yt[ee].y,!(re>=ft));ee++);return Yt[Wt].x}},Ae.exports.getPerplexity=function(Yt){if(!(!Yt||Yt.length===0)){var ft=0;return Yt.forEach(function(re){var Wt=Math.log(re.y);isFinite(Wt)&&(ft+=re.y*Wt)}),ft=-ft/fe,Math.pow(2,ft)}}},86851:function(Ae,Be,pt){"use strict";var oe=pt(89594),$=Array.prototype.concat,fe=Array.prototype.slice,Ye=Ae.exports=function(Rt){for(var qt=[],Yt=0,ft=Rt.length;Yt<ft;Yt++){var re=Rt[Yt];oe(re)?qt=$.call(qt,fe.call(re)):qt.push(re)}return qt};Ye.wrap=function(ae){return function(){return ae(Ye(arguments))}}},89594:function(Ae){Ae.exports=function(pt){return!pt||typeof pt=="string"?!1:pt instanceof Array||Array.isArray(pt)||pt.length>=0&&(pt.splice instanceof Function||Object.getOwnPropertyDescriptor(pt,pt.length-1)&&pt.constructor.name!=="String")}},37762:function(Ae,Be,pt){"use strict";pt.d(Be,{Z:function(){return $}});var oe=pt(40181);function $(fe,Ye){var ae=typeof Symbol!="undefined"&&fe[Symbol.iterator]||fe["@@iterator"];if(!ae){if(Array.isArray(fe)||(ae=(0,oe.Z)(fe))||Ye&&fe&&typeof fe.length=="number"){ae&&(fe=ae);var Rt=0,qt=function(){};return{s:qt,n:function(){return Rt>=fe.length?{done:!0}:{done:!1,value:fe[Rt++]}},e:function(ee){throw ee},f:qt}}throw new TypeError(`Invalid attempt to iterate non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var Yt,ft=!0,re=!1;return{s:function(){ae=ae.call(fe)},n:function(){var ee=ae.next();return ft=ee.done,ee},e:function(ee){re=!0,Yt=ee},f:function(){try{ft||ae.return==null||ae.return()}finally{if(re)throw Yt}}}}}}]);
}());