.isFinite(m)||m<0,b=vi(u),w=Ua(u),S=Su(u,u.tooltip.settings.shared);if(h==="Enter"){if(g)return;var k=lf(u,S,"hover",String(d.index));t.dispatch(sf({active:!d.active,activeIndex:d.index,activeCoordinate:k}));return}var A=fH(u),P=A==="left-to-right"?1:-1,C=h==="ArrowRight"?1:-1,N;if(g){var j=ls(u),M=us(u),F=C*P,W=ie=>({active:!1,index:String(ie),dataKey:void 0,graphicalItemId:void 0,coordinate:void 0});if(N=-1,F>0){for(var H=0;H<w.length;H++)if(Nl(W(H),w,j,M)!=null){N=H;break}}else for(var Y=w.length-1;Y>=0;Y--)if(Nl(W(Y),w,j,M)!=null){N=Y;break}if(N<0)return}else{N=m+C*P;var B=(b==null?void 0:b.length)||w.length;if(B===0||N>=B||N<0)return}var pe=lf(u,S,"hover",String(N));t.dispatch(sf({active:!0,activeIndex:N.toString(),activeCoordinate:pe}))}finally{Mo=null,ya=null}};if(!a){s();return}n==="raf"?Mo=requestAnimationFrame(s):typeof n=="number"&&ya===null&&(s(),id=null,ya=setTimeout(()=>{id?s():(ya=null,Mo=null)},n))}});mh.startListening({actionCreator:vI,effect:(e,t)=>{var r=t.getState(),n=r.rootProps.accessibilityLayer!==!1;if(n){var{keyboardInteraction:i}=r.tooltip;if(!i.active&&i.index==null){var a="0",s=Su(r,r.tooltip.settings.shared),u=lf(r,s,"hover",String(a));t.dispatch(sf({active:!0,activeIndex:a,activeCoordinate:u}))}}}});mh.startListening({actionCreator:mI,effect:(e,t)=>{var r=t.getState(),n=r.rootProps.accessibilityLayer!==!1;if(n){var{keyboardInteraction:i}=r.tooltip;i.active&&t.dispatch(sf({active:!1,activeIndex:i.index,activeCoordinate:i.coordinate}))}}});function gI(e){e.persist();var{currentTarget:t}=e;return new Proxy(e,{get:(r,n)=>{if(n==="currentTarget")return t;var i=Reflect.get(r,n);return typeof i=="function"?i.bind(r):i}})}var zr=Ar("externalEvent"),yI=uu(),ad=new Map,bl=new Map,eg=new Map;yI.startListening({actionCreator:zr,effect:(e,t)=>{var{handler:r,reactEvent:n}=e.payload;if(r!=null){var i=n.type,a=gI(n);eg.set(i,{handler:r,reactEvent:a});var s=ad.get(i);s!==void 0&&(cancelAnimationFrame(s),ad.delete(i));var u=t.getState(),{throttleDelay:c,throttledEvents:d}=u.eventSettings,h=d,p=h==="all"||(h==null?void 0:h.includes(i)),m=bl.get(i);m!==void 0&&(typeof c!="number"||!p)&&(clearTimeout(m),bl.delete(i));var g=()=>{var S=eg.get(i);try{if(!S)return;var{handler:k,reactEvent:A}=S,P=t.getState(),C={activeCoordinate:pK(P),activeDataKey:tN(P),activeIndex:Ba(P),activeLabel:eN(P),activeTooltipIndex:Ba(P),isTooltipActive:vK(P)};k&&k(C,A)}finally{ad.delete(i),bl.delete(i),eg.delete(i)}};if(!p){g();return}if(c==="raf"){var b=requestAnimationFrame(g);ad.set(i,b)}else if(typeof c=="number"){if(!bl.has(i)){g();var w=setTimeout(g,c);bl.set(i,w)}}else g()}}});var oJ=L([bs],e=>e.tooltipItemPayloads),sJ=L([oJ,(e,t)=>t,(e,t,r)=>r],(e,t,r)=>{if(t!=null){var n=e.find(a=>a.settings.graphicalItemId===r);if(n!=null){var{getPosition:i}=n;if(i!=null)return i(t)}}}),wI=Ar("touchMove"),bI=uu(),wa=null,Di=null,WE=null,xl=null;bI.startListening({actionCreator:wI,effect:(e,t)=>{var r=e.payload;if(!(r.touches==null||r.touches.length===0)){xl=gI(r);var n=t.getState(),{throttleDelay:i,throttledEvents:a}=n.eventSettings,s=a==="all"||a.includes("touchmove");wa!==null&&(cancelAnimationFrame(wa),wa=null),Di!==null&&(typeof i!="number"||!s)&&(clearTimeout(Di),Di=null),WE=Array.from(r.touches).map(c=>uw({clientX:c.clientX,clientY:c.clientY,currentTarget:r.currentTarget}));var u=()=>{if(xl!=null){var c=t.getState(),d=Su(c,c.tooltip.settings.shared);if(d==="axis"){var h,p=(h=WE)===null||h===void 0?void 0:h[0];if(p==null){wa=null,Di=null;return}var m=lw(c,p);(m==null?void 0:m.activeIndex)!=null&&t.dispatch(BT({activeIndex:m.activeIndex,activeDataKey:void 0,activeCoordinate:m.activeCoordinate}))}else if(d==="item"){var g,b=xl.touches[0];if(document.elementFromPoint==null||b==null)return;var w=document.elementFromPoint(b.clientX,b.clientY);if(!w||!w.getAttribute)return;var S=w.getAttribute(NB),k=(g=w.getAttribute(IB))!==null&&g!==void 0?g:void 0,A=Xa(c).find(N=>N.id===k);if(S==null||A==null||k==null)return;var{dataKey:P}=A,C=sJ(c,S,k);t.dispatch(zT({activeDataKey:P,activeIndex:S,activeCoordinate:C,activeGraphicalItemId:k}))}wa=null,Di=null}};if(!s){u();return}i==="raf"?wa=requestAnimationFrame(u):typeof i=="number"&&Di===null&&(u(),xl=null,Di=setTimeout(()=>{xl?u():(Di=null,wa=null)},i))}}});var xI={throttleDelay:"raf",throttledEvents:["mousemove","touchmove","pointermove","scroll","wheel"]},_I=Xt({name:"eventSettings",initialState:xI,reducers:{setEventSettings:(e,t)=>{t.payload.throttleDelay!=null&&(e.throttleDelay=t.payload.throttleDelay),t.payload.throttledEvents!=null&&(e.throttledEvents=t.payload.throttledEvents)}}}),{setEventSettings:lJ}=_I.actions,uJ=_I.reducer,cJ=WA({brush:eG,cartesianAxis:D7,chartData:h9,errorBars:ZG,eventSettings:uJ,graphicalItems:h7,layout:pB,legend:k5,options:l9,polarAxis:DV,polarOptions:aJ,referenceElements:iG,renderedTicks:xG,rootProps:tJ,tooltip:kH,zIndex:XK}),dJ=function(t){var r=arguments.length>1&&arguments[1]!==void 0?arguments[1]:"Chart";return zU({reducer:cJ,preloadedState:t,middleware:n=>{var i;return n({serializableCheck:!1,immutableCheck:!["commonjs","es6","production"].includes((i="es6")!==null&&i!==void 0?i:"")}).concat([cI.middleware,dI.middleware,mh.middleware,yI.middleware,bI.middleware])},enhancers:n=>{var i=n;return typeof n=="function"&&(i=n()),i.concat(iC({type:"raf"}))},devTools:{serialize:{replacer:eJ},name:"recharts-".concat(r)}})};function fJ(e){var{preloadedState:t,children:r,reduxStoreName:n}=e,i=Jt(),a=x.useRef(null);if(i)return r;a.current==null&&(a.current=dJ(t,n));var s=Uy;return x.createElement(U5,{context:s,store:a.current},r)}function hJ(e){var{layout:t,margin:r}=e,n=at(),i=Jt();return x.useEffect(()=>{i||(n(dB(t)),n(cB(r)))},[n,i,t,r]),null}var pJ=x.memo(hJ,hu);function vJ(e){var t=at();return x.useEffect(()=>{t(rJ(e))},[t,e]),null}var mJ=e=>{var t=at();return x.useEffect(()=>{t(lJ(e))},[t,e]),null},gJ=x.memo(mJ,hu);function qE(e){var{zIndex:t,isPanorama:r}=e,n=x.useRef(null),i=at();return x.useLayoutEffect(()=>(n.current&&i(GK({zIndex:t,element:n.current,isPanorama:r})),()=>{i(YK({zIndex:t,isPanorama:r}))}),[i,t,r]),x.createElement("g",{tabIndex:-1,ref:n,className:"recharts-zIndex-layer_".concat(t)})}function HE(e){var{children:t,isPanorama:r}=e,n=ve(zK);if(!n||n.length===0)return t;var i=n.filter(s=>s<0),a=n.filter(s=>s>0);return x.createElement(x.Fragment,null,i.map(s=>x.createElement(qE,{key:s,zIndex:s,isPanorama:r})),t,a.map(s=>x.createElement(qE,{key:s,zIndex:s,isPanorama:r})))}var yJ=["children"];function wJ(e,t){if(e==null)return{};var r,n,i=bJ(e,t);if(Object.getOwnPropertySymbols){var a=Object.getOwnPropertySymbols(e);for(n=0;n<a.length;n++)r=a[n],t.indexOf(r)===-1&&{}.propertyIsEnumerable.call(e,r)&&(i[r]=e[r])}return i}function bJ(e,t){if(e==null)return{};var r={};for(var n in e)if({}.hasOwnProperty.call(e,n)){if(t.indexOf(n)!==-1)continue;r[n]=e[n]}return r}function vf(){return vf=Object.assign?Object.assign.bind():function(e){for(var t=1;t<arguments.length;t++){var r=arguments[t];for(var n in r)({}).hasOwnProperty.call(r,n)&&(e[n]=r[n])}return e},vf.apply(null,arguments)}var xJ={width:"100%",height:"100%",display:"block"},_J=x.forwardRef((e,t)=>{var r=EC(),n=OC(),i=LC();if(!Rn(r)||!Rn(n))return null;var{children:a,otherAttributes:s,title:u,desc:c}=e,d,h;return s!=null&&(typeof s.tabIndex=="number"?d=s.tabIndex:d=i?0:void 0,typeof s.role=="string"?h=s.role:h=i?"application":void 0),x.createElement(oA,vf({},s,{title:u,desc:c,role:h,tabIndex:d,width:r,height:n,style:xJ,ref:t}),a)}),SJ=e=>{var{children:t}=e,r=ve(Hf);if(!r)return null;var{width:n,height:i,y:a,x:s}=r;return x.createElement(oA,{width:n,height:i,x:s,y:a},t)},KE=x.forwardRef((e,t)=>{var{children:r}=e,n=wJ(e,yJ),i=Jt();return i?x.createElement(SJ,null,x.createElement(HE,{isPanorama:!0},r)):x.createElement(_J,vf({ref:t},n),x.createElement(HE,{isPanorama:!1},r))});function kJ(){var e=at(),[t,r]=x.useState(null),n=ve(TB);return x.useEffect(()=>{if(t!=null){var i=t.getBoundingClientRect(),a=i.width/t.offsetWidth;je(a)&&a!==n&&e(hB(a))}},[t,e,n]),r}function VE(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function PJ(e){for(var t=1;t<arguments.length;t++){var r=arguments[t]!=null?arguments[t]:{};t%2?VE(Object(r),!0).forEach(function(n){EJ(e,n,r[n])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(r)):VE(Object(r)).forEach(function(n){Object.defineProperty(e,n,Object.getOwnPropertyDescriptor(r,n))})}return e}function EJ(e,t,r){return(t=OJ(t))in e?Object.defineProperty(e,t,{value:r,enumerable:!0,configurable:!0,writable:!0}):e[t]=r,e}function OJ(e){var t=AJ(e,"string");return typeof t=="symbol"?t:t+""}function AJ(e,t){if(typeof e!="object"||!e)return e;var r=e[Symbol.toPrimitive];if(r!==void 0){var n=r.call(e,t);if(typeof n!="object")return n;throw new TypeError("@@toPrimitive must return a primitive value.")}return(t==="string"?String:Number)(e)}function Vi(){return Vi=Object.assign?Object.assign.bind():function(e){for(var t=1;t<arguments.length;t++){var r=arguments[t];for(var n in r)({}).hasOwnProperty.call(r,n)&&(e[n]=r[n])}return e},Vi.apply(null,arguments)}var CJ=()=>(_9(),null);function mf(e){if(typeof e=="number")return e;if(typeof e=="string"){var t=parseFloat(e);if(!Number.isNaN(t))return t}return 0}var jJ=x.forwardRef((e,t)=>{var r,n,i=x.useRef(null),[a,s]=x.useState({containerWidth:mf((r=e.style)===null||r===void 0?void 0:r.width),containerHeight:mf((n=e.style)===null||n===void 0?void 0:n.height)}),u=x.useCallback((d,h)=>{s(p=>{var m=Math.round(d),g=Math.round(h);return p.containerWidth===m&&p.containerHeight===g?p:{containerWidth:m,containerHeight:g}})},[]),c=x.useCallback(d=>{if(typeof t=="function"&&t(d),i.current!=null&&(i.current.disconnect(),i.current=null),d!=null&&typeof ResizeObserver<"u"){var{width:h,height:p}=d.getBoundingClientRect();u(h,p);var m=b=>{var w=b[0];if(w!=null){var{width:S,height:k}=w.contentRect;u(S,k)}},g=new ResizeObserver(m);g.observe(d),i.current=g}},[t,u]);return x.useEffect(()=>()=>{var d=i.current;d!=null&&d.disconnect()},[u]),x.createElement(x.Fragment,null,x.createElement(du,{width:a.containerWidth,height:a.containerHeight}),x.createElement("div",Vi({ref:c},e)))}),TJ=x.forwardRef((e,t)=>{var{width:r,height:n}=e,[i,a]=x.useState({containerWidth:mf(r),containerHeight:mf(n)}),s=x.useCallback((c,d)=>{a(h=>{var p=Math.round(c),m=Math.round(d);return h.containerWidth===p&&h.containerHeight===m?h:{containerWidth:p,containerHeight:m}})},[]),u=x.useCallback(c=>{if(typeof t=="function"&&t(c),c!=null){var{width:d,height:h}=c.getBoundingClientRect();s(d,h)}},[t,s]);return x.createElement(x.Fragment,null,x.createElement(du,{width:i.containerWidth,height:i.containerHeight}),x.createElement("div",Vi({ref:u},e)))}),NJ=x.forwardRef((e,t)=>{var{width:r,height:n}=e;return x.createElement(x.Fragment,null,x.createElement(du,{width:r,height:n}),x.createElement("div",Vi({ref:t},e)))}),IJ=x.forwardRef((e,t)=>{var{width:r,height:n}=e;return typeof r=="string"||typeof n=="string"?x.createElement(TJ,Vi({},e,{ref:t})):typeof r=="number"&&typeof n=="number"?x.createElement(NJ,Vi({},e,{width:r,height:n,ref:t})):x.createElement(x.Fragment,null,x.createElement(du,{width:r,height:n}),x.createElement("div",Vi({ref:t},e)))});function RJ(e){return e?jJ:IJ}var DJ=x.forwardRef((e,t)=>{var{children:r,className:n,height:i,onClick:a,onContextMenu:s,onDoubleClick:u,onMouseDown:c,onMouseEnter:d,onMouseLeave:h,onMouseMove:p,onMouseUp:m,onTouchEnd:g,onTouchMove:b,onTouchStart:w,style:S,width:k,responsive:A,dispatchTouchEvents:P=!0}=e,C=x.useRef(null),N=at(),[j,M]=x.useState(null),[F,W]=x.useState(null),H=kJ(),Y=Gy(),B=(Y==null?void 0:Y.width)>0?Y.width:k,pe=(Y==null?void 0:Y.height)>0?Y.height:i,ie=x.useCallback(re=>{H(re),typeof t=="function"&&t(re),M(re),W(re),re!=null&&(C.current=re)},[H,t,M,W]),me=x.useCallback(re=>{N(uI(re)),N(zr({handler:a,reactEvent:re}))},[N,a]),_e=x.useCallback(re=>{N(by(re)),N(zr({handler:d,reactEvent:re}))},[N,d]),he=x.useCallback(re=>{N(UT()),N(zr({handler:h,reactEvent:re}))},[N,h]),K=x.useCallback(re=>{N(by(re)),N(zr({handler:p,reactEvent:re}))},[N,p]),Q=x.useCallback(()=>{N(vI())},[N]),X=x.useCallback(()=>{N(mI())},[N]),D=x.useCallback(re=>{N(pI(re.key))},[N]),q=x.useCallback(re=>{N(zr({handler:s,reactEvent:re}))},[N,s]),ge=x.useCallback(re=>{N(zr({handler:u,reactEvent:re}))},[N,u]),ye=x.useCallback(re=>{N(zr({handler:c,reactEvent:re}))},[N,c]),Pe=x.useCallback(re=>{N(zr({handler:m,reactEvent:re}))},[N,m]),Ee=x.useCallback(re=>{N(zr({handler:w,reactEvent:re}))},[N,w]),Ne=x.useCallback(re=>{P&&N(wI(re)),N(zr({handler:b,reactEvent:re}))},[N,P,b]),ke=x.useCallback(re=>{N(zr({handler:g,reactEvent:re}))},[N,g]),ee=RJ(A);return x.createElement(lN.Provider,{value:j},x.createElement(m3.Provider,{value:F},x.createElement(ee,{width:B??(S==null?void 0:S.width),height:pe??(S==null?void 0:S.height),className:Fe("recharts-wrapper",n),style:PJ({position:"relative",cursor:"default",width:B,height:pe},S),onClick:me,onContextMenu:q,onDoubleClick:ge,onFocus:Q,onBlur:X,onKeyDown:D,onMouseDown:ye,onMouseEnter:_e,onMouseLeave:he,onMouseMove:K,onMouseUp:Pe,onTouchEnd:ke,onTouchMove:Ne,onTouchStart:Ee,ref:ie},x.createElement(CJ,null),r)))}),MJ=["width","height","responsive","children","className","style","compact","title","desc"];function $J(e,t){if(e==null)return{};var r,n,i=LJ(e,t);if(Object.getOwnPropertySymbols){var a=Object.getOwnPropertySymbols(e);for(n=0;n<a.length;n++)r=a[n],t.indexOf(r)===-1&&{}.propertyIsEnumerable.call(e,r)&&(i[r]=e[r])}return i}function LJ(e,t){if(e==null)return{};var r={};for(var n in e)if({}.hasOwnProperty.call(e,n)){if(t.indexOf(n)!==-1)continue;r[n]=e[n]}return r}var zJ=x.forwardRef((e,t)=>{var{width:r,height:n,responsive:i,children:a,className:s,style:u,compact:c,title:d,desc:h}=e,p=$J(e,MJ),m=un(p);return c?x.createElement(x.Fragment,null,x.createElement(du,{width:r,height:n}),x.createElement(KE,{otherAttributes:m,title:d,desc:h},a)):x.createElement(DJ,{className:s,style:u,width:r,height:n,responsive:i??!1,onClick:e.onClick,onMouseLeave:e.onMouseLeave,onMouseEnter:e.onMouseEnter,onMouseMove:e.onMouseMove,onMouseDown:e.onMouseDown,onMouseUp:e.onMouseUp,onContextMenu:e.onContextMenu,onDoubleClick:e.onDoubleClick,onTouchStart:e.onTouchStart,onTouchMove:e.onTouchMove,onTouchEnd:e.onTouchEnd},x.createElement(KE,{otherAttributes:m,title:d,desc:h,ref:t},x.createElement(oG,null,a)))});function xy(){return xy=Object.assign?Object.assign.bind():function(e){for(var t=1;t<arguments.length;t++){var r=arguments[t];for(var n in r)({}).hasOwnProperty.call(r,n)&&(e[n]=r[n])}return e},xy.apply(null,arguments)}function GE(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter(function(i){return Object.getOwnPropertyDescriptor(e,i).enumerable})),r.push.apply(r,n)}return r}function UJ(e){for(var t=1;t<arguments.length;t++){var r=arguments[t]!=null?arguments[t]:{};t%2?GE(Object(r),!0).forEach(function(n){BJ(e,n,r[n])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(r)):GE(Object(r)).forEach(function(n){Object.defineProperty(e,n,Object.getOwnPropertyDescriptor(r,n))})}return e}function BJ(e,t,r){return(t=FJ(t))in e?Object.defineProperty(e,t,{value:r,enumerable:!0,configurable:!0,writable:!0}):e[t]=r,e}function FJ(e){var t=WJ(e,"string");return typeof t=="symbol"?t:t+""}function WJ(e,t){if(typeof e!="object"||!e)return e;var r=e[Symbol.toPrimitive];if(r!==void 0){var n=r.call(e,t);if(typeof n!="object")return n;throw new TypeError("@@toPrimitive must return a primitive value.")}return(t==="string"?String:Number)(e)}var qJ={top:5,right:5,bottom:5,left:5},HJ=UJ({accessibilityLayer:!0,barCategoryGap:"10%",barGap:4,layout:"horizontal",margin:qJ,responsive:!1,reverseStackOrder:!1,stackOffset:"none",syncMethod:"index"},xI),SI=x.forwardRef(function(t,r){var n,i=or(t.categoricalChartProps,HJ),{chartName:a,defaultTooltipEventType:s,validateTooltipEventTypes:u,tooltipPayloadSearcher:c,categoricalChartProps:d}=t,h={chartName:a,defaultTooltipEventType:s,validateTooltipEventTypes:u,tooltipPayloadSearcher:c,eventEmitter:void 0};return x.createElement(fJ,{preloadedState:{options:h},reduxStoreName:(n=d.id)!==null&&n!==void 0?n:a},x.createElement(Z7,{chartData:d.data}),x.createElement(pJ,{layout:i.layout,margin:i.margin}),x.createElement(gJ,{throttleDelay:i.throttleDelay,throttledEvents:i.throttledEvents}),x.createElement(vJ,{baseValue:i.baseValue,accessibilityLayer:i.accessibilityLayer,barCategoryGap:i.barCategoryGap,maxBarSize:i.maxBarSize,stackOffset:i.stackOffset,barGap:i.barGap,barSize:i.barSize,syncId:i.syncId,syncMethod:i.syncMethod,className:i.className,reverseStackOrder:i.reverseStackOrder}),x.createElement(zJ,xy({},i,{ref:r})))}),KJ=["axis"],VJ=x.forwardRef((e,t)=>x.createElement(SI,{chartName:"LineChart",defaultTooltipEventType:"axis",validateTooltipEventTypes:KJ,tooltipPayloadSearcher:uN,categoricalChartProps:e,ref:t})),GJ=["axis","item"],YJ=x.forwardRef((e,t)=>x.createElement(SI,{chartName:"BarChart",defaultTooltipEventType:"axis",validateTooltipEventTypes:GJ,tooltipPayloadSearcher:uN,categoricalChartProps:e,ref:t}));const kI=6048e5,XJ=864e5,PI=6e4,EI=36e5,YE=Symbol.for("constructDateFrom");function $n(e,t){return typeof e=="function"?e(t):e&&typeof e=="object"&&YE in e?e[YE](t):e instanceof Date?new e.constructor(t):new Date(t)}function ar(e,t){return $n(t||e,e)}let JJ={};function gh(){return JJ}function Wa(e,t){var u,c,d,h;const r=gh(),n=(t==null?void 0:t.weekStartsOn)??((c=(u=t==null?void 0:t.locale)==null?void 0:u.options)==null?void 0:c.weekStartsOn)??r.weekStartsOn??((h=(d=r.locale)==null?void 0:d.options)==null?void 0:h.weekStartsOn)??0,i=ar(e,t==null?void 0:t.in),a=i.getDay(),s=(a<n?7:0)+a-n;return i.setDate(i.getDate()-s),i.setHours(0,0,0,0),i}function gf(e,t){return Wa(e,{...t,weekStartsOn:1})}function OI(e,t){const r=ar(e,t==null?void 0:t.in),n=r.getFullYear(),i=$n(r,0);i.setFullYear(n+1,0,4),i.setHours(0,0,0,0);const a=gf(i),s=$n(r,0);s.setFullYear(n,0,4),s.setHours(0,0,0,0);const u=gf(s);return r.getTime()>=a.getTime()?n+1:r.getTime()>=u.getTime()?n:n-1}function XE(e){const t=ar(e),r=new Date(Date.UTC(t.getFullYear(),t.getMonth(),t.getDate(),t.getHours(),t.getMinutes(),t.getSeconds(),t.getMilliseconds()));return r.setUTCFullYear(t.getFullYear()),+e-+r}function cw(e,...t){const r=$n.bind(null,e||t.find(n=>typeof n=="object"));return t.map(r)}function JE(e,t){const r=ar(e,t==null?void 0:t.in);return r.setHours(0,0,0,0),r}function QJ(e,t,r){const[n,i]=cw(r==null?void 0:r.in,e,t),a=JE(n),s=JE(i),u=+a-XE(a),c=+s-XE(s);return Math.round((u-c)/XJ)}function ZJ(e,t){const r=OI(e,t),n=$n(e,0);return n.setFullYear(r,0,4),n.setHours(0,0,0,0),gf(n)}function eQ(e){return e instanceof Date||typeof e=="object"&&Object.prototype.toString.call(e)==="[object Date]"}function tQ(e){return!(!eQ(e)&&typeof e!="number"||isNaN(+ar(e)))}function rQ(e,t){const r=ar(e,t==null?void 0:t.in),n=r.getMonth();return r.setFullYear(r.getFullYear(),n+1,0),r.setHours(23,59,59,999),r}function nQ(e,t){const[r,n]=cw(e,t.start,t.end);return{start:r,end:n}}function iQ(e,t){const{start:r,end:n}=nQ(t==null?void 0:t.in,e);let i=+r>+n;const a=i?+r:+n,s=i?n:r;s.setHours(0,0,0,0);let u=1;const c=[];for(;+s<=a;)c.push($n(r,s)),s.setDate(s.getDate()+u),s.setHours(0,0,0,0);return i?c.reverse():c}function aQ(e,t){const r=ar(e,t==null?void 0:t.in);return r.setDate(1),r.setHours(0,0,0,0),r}function oQ(e,t){const r=ar(e,t==null?void 0:t.in);return r.setFullYear(r.getFullYear(),0,1),r.setHours(0,0,0,0),r}const sQ={lessThanXSeconds:{one:"less than a second",other:"less than {{count}} seconds"},xSeconds:{one:"1 second",other:"{{count}} seconds"},halfAMinute:"half a minute",lessThanXMinutes:{one:"less than a minute",other:"less than {{count}} minutes"},xMinutes:{one:"1 minute",other:"{{count}} minutes"},aboutXHours:{one:"about 1 hour",other:"about {{count}} hours"},xHours:{one:"1 hour",other:"{{count}} hours"},xDays:{one:"1 day",other:"{{count}} days"},aboutXWeeks:{one:"about 1 week",other:"about {{count}} weeks"},xWeeks:{one:"1 week",other:"{{count}} weeks"},aboutXMonths:{one:"about 1 month",other:"about {{count}} months"},xMonths:{one:"1 month",other:"{{count}} months"},aboutXYears:{one:"about 1 year",other:"about {{count}} years"},xYears:{one:"1 year",other:"{{count}} years"},overXYears:{one:"over 1 year",other:"over {{count}} years"},almostXYears:{one:"almost 1 year",other:"almost {{count}} years"}},lQ=(e,t,r)=>{let n;const i=sQ[e];return typeof i=="string"?n=i:t===1?n=i.one:n=i.other.replace("{{count}}",t.toString()),r!=null&&r.addSuffix?r.comparison&&r.comparison>0?"in "+n:n+" ago":n};function Qo(e){return(t={})=>{const r=t.width?String(t.width):e.defaultWidth;return e.formats[r]||e.formats[e.defaultWidth]}}const uQ={full:"EEEE, MMMM do, y",long:"MMMM do, y",medium:"MMM d, y",short:"MM/dd/yyyy"},cQ={full:"h:mm:ss a zzzz",long:"h:mm:ss a z",medium:"h:mm:ss a",short:"h:mm a"},dQ={full:"{{date}} 'at' {{time}}",long:"{{date}} 'at' {{time}}",medium:"{{date}}, {{time}}",short:"{{date}}, {{time}}"},fQ={date:Qo({formats:uQ,defaultWidth:"full"}),time:Qo({formats:cQ,defaultWidth:"full"}),dateTime:Qo({formats:dQ,defaultWidth:"full"})},hQ={lastWeek:"'last' eeee 'at' p",yesterday:"'yesterday at' p",today:"'today at' p",tomorrow:"'tomorrow at' p",nextWeek:"eeee 'at' p",other:"P"},pQ=(e,t,r,n)=>hQ[e];function En(e){return(t,r)=>{const n=r!=null&&r.context?String(r.context):"standalone";let i;if(n==="formatting"&&e.formattingValues){const s=e.defaultFormattingWidth||e.defaultWidth,u=r!=null&&r.width?String(r.width):s;i=e.formattingValues[u]||e.formattingValues[s]}else{const s=e.defaultWidth,u=r!=null&&r.width?String(r.width):e.defaultWidth;i=e.values[u]||e.values[s]}const a=e.argumentCallback?e.argumentCallback(t):t;return i[a]}}const vQ={narrow:["B","A"],abbreviated:["BC","AD"],wide:["Before Christ","Anno Domini"]},mQ={narrow:["1","2","3","4"],abbreviated:["Q1","Q2","Q3","Q4"],wide:["1st quarter","2nd quarter","3rd quarter","4th quarter"]},gQ={narrow:["J","F","M","A","M","J","J","A","S","O","N","D"],abbreviated:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],wide:["January","February","March","April","May","June","July","August","September","October","November","December"]},yQ={narrow:["S","M","T","W","T","F","S"],short:["Su","Mo","Tu","We","Th","Fr","Sa"],abbreviated:["Su
