{"version":3,"sources":["webpack://_N_E/./node_modules/@next/polyfill-module/dist/polyfill-module.js","webpack://_N_E/./node_modules/core-js/modules/web.dom-collections.iterator.js","webpack://_N_E/./node_modules/core-js/internals/object-get-prototype-of.js","webpack://_N_E/./node_modules/core-js/internals/correct-prototype-getter.js","webpack://_N_E/./node_modules/core-js/modules/es.array.iterator.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/inherits.js","webpack://_N_E/./node_modules/core-js/internals/internal-metadata.js","webpack://_N_E/../../client/next.js","webpack://_N_E/./node_modules/raf/polyfill.js","webpack://_N_E/../../client/head-manager.ts","webpack://_N_E/../../../next-server/lib/head-manager-context.ts","webpack://_N_E/../../client/index.tsx","webpack://_N_E/./node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack://_N_E/./node_modules/core-js/modules/es.string.iterator.js","webpack://_N_E/./node_modules/abortcontroller-polyfill/dist/polyfill-patch-fetch.js","webpack://_N_E/./node_modules/core-js/internals/add-to-unscopables.js","webpack://_N_E/./node_modules/core-js/modules/es.map.js","webpack://_N_E/./node_modules/intersection-observer/intersection-observer.js","webpack://_N_E/./node_modules/core-js/es/map/index.js","webpack://_N_E/./node_modules/core-js/modules/es.set.js","webpack://_N_E/./node_modules/child-replace-with-polyfill/index.js","webpack://_N_E/./node_modules/core-js/internals/collection-strong.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack://_N_E/../../client/performance-relayer.ts","webpack://_N_E/./node_modules/performance-now/lib/performance-now.js","webpack://_N_E/./node_modules/core-js/internals/collection.js","webpack://_N_E/./node_modules/core-js/internals/define-iterator.js","webpack://_N_E/./client/polyfills.js","webpack://_N_E/./node_modules/core-js/es/set/index.js","webpack://_N_E/./node_modules/core-js/internals/create-iterator-constructor.js","webpack://_N_E/./node_modules/next/dist/compiled/web-vitals/web-vitals.es5.umd.min.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/extends.js","webpack://_N_E/./node_modules/core-js/internals/iterators-core.js","webpack://_N_E/./node_modules/core-js/internals/freezing.js","webpack://_N_E/./node_modules/raf/index.js","webpack://_N_E/../../../next-server/lib/runtime-config.ts","webpack://_N_E/../../client/page-loader.ts"],"names":["String","prototype","trimStart","trimLeft","trimEnd","trimRight","Symbol","Object","defineProperty","configurable","get","t","exec","this","toString","Array","flat","r","concat","apply","some","isArray","flatMap","map","Promise","finally","then","constructor","o","resolve","global","DOMIterables","ArrayIteratorMethods","createNonEnumerableProperty","wellKnownSymbol","ITERATOR","TO_STRING_TAG","ArrayValues","values","COLLECTION_NAME","Collection","CollectionPrototype","error","METHOD_NAME","has","toObject","sharedKey","CORRECT_PROTOTYPE_GETTER","IE_PROTO","ObjectPrototype","module","exports","getPrototypeOf","O","fails","F","toIndexedObject","addToUnscopables","Iterators","InternalStateModule","defineIterator","setInternalState","set","getInternalState","getterFor","iterated","kind","type","target","index","state","length","undefined","value","done","Arguments","setPrototypeOf","subClass","superClass","TypeError","create","writable","hiddenKeys","isObject","f","uid","FREEZING","METADATA","id","isExtensible","setMetadata","it","objectID","weakData","meta","REQUIRED","fastKey","getWeakData","onFreeze","window","console","polyfill","updatePromise","mountedInstances","updateHead","head","promise","tags","h","components","titleComponent","title","children","document","headEl","headCountEl","headCount","Number","oldTags","i","j","newTags","newTag","k","len","oldTag","updateElements","DOMAttributeNames","acceptCharset","className","htmlFor","httpEquiv","reactElementToDOM","el","props","p","attr","dangerouslySetInnerHTML","HeadManagerContext","React","data","JSON","process","__NEXT_VERSION","looseToArray","err","locales","prefix","__webpack_public_path__","envConfig","serverRuntimeConfig","publicRuntimeConfig","runtimeConfig","asPath","hasBasePath","delBasePath","pageLoader","PageLoader","register","setTimeout","headManager","appElement","router","isFallback","isDynamicRoute","location","hydrateProps","querystring","URLSearchParams","_h","shallow","hash","Component","emitter","appEntrypoint","component","CachedApp","mod","onPerfEntry","uniqueID","Date","Math","entries","perfStartEntry","name","startTime","label","entryType","initialErr","pageEntrypoint","CachedComponent","createRouter","initialProps","App","wrapApp","Boolean","subscription","render","locale","defaultLocale","renderCtx","initial","renderingProps","renderError","doRender","renderErr","renderErrorProps","page","AppTree","appCtx","ctx","pathname","query","loadGetInitialProps","initProps","styleSheets","shouldUseHydrate","ReactDOM","markHydrateComplete","ST","performance","clearMarks","markRenderComplete","navStartEntries","measure","mark","AppContainer","fn","makePublicRouterInstance","wrappedAppProps","appProps","input","lastAppProps","canceled","renderPromise","lastRenderReject","resolvePromise","Error","reject","reactEl","elem","callback","desiredHrefs","Set","s","currentStyleTags","currentHrefs","tag","idx","referenceNode","targetTag","getComputedStyle","noscript","nonce","styleTag","onStart","renderReactElement","Root","Head","_getPrototypeOf","__proto__","self","ReferenceError","charAt","string","point","_classCallCheck","instance","Constructor","_defineProperties","descriptor","enumerable","key","_createClass","protoProps","staticProps","_inherits","_setPrototypeOf","_isNativeReflectConstruct","Reflect","construct","sham","Proxy","call","e","_assertThisInitialized","_possibleConstructorReturn","_createSuper","Derived","hasNativeReflectConstruct","result","Super","NewTarget","arguments","_superPropBase","object","property","hasOwnProperty","_get","receiver","base","desc","getOwnPropertyDescriptor","Emitter","options","listeners","push","stack","l","splice","event","stackToCall","slice","listener","once","removeEventListener","defaultPrevented","AbortSignal","_Emitter","_super","_this","aborted","onabort","AbortController","Event","createEvent","initEvent","createEventObject","bubbles","cancelable","signal","dispatchEvent","polyfillNeeded","__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL","log","Request","abortableFetchDecorator","patchTargets","fetch","_patchTargets","_patchTargets$Request","NativeRequest","NativeAbortController","_patchTargets$__FORCE","init","request","realFetch","isPrototypeOf","abortError","DOMException","cancellation","_","addEventListener","race","toStringTag","_abortableFetch","warn","definePropertyModule","UNSCOPABLES","ArrayPrototype","collection","collectionStrong","IntersectionObserverEntry","intersectionRatio","registry","IntersectionObserver","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","observe","_observationTargets","item","element","nodeType","_registerInstance","entry","_monitorIntersections","_checkForIntersections","unobserve","filter","_unmonitorIntersections","_unregisterInstance","disconnect","takeRecords","records","_queuedEntries","_initThresholds","opt_threshold","threshold","sort","a","isNaN","_parseRootMargin","opt_rootMargin","margins","split","margin","parts","parseFloat","unit","_monitoringIntersections","_monitoringInterval","setInterval","addEvent","_domObserver","MutationObserver","attributes","childList","characterData","subtree","clearInterval","removeEvent","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","top","bottom","left","right","width","height","forEach","targetRect","getBoundingClientRect","rootContainsTarget","_rootContainsTarget","oldEntry","intersectionRect","_computeTargetAndRootIntersection","newEntry","time","now","boundingClientRect","rootBounds","_hasCrossedThreshold","isIntersecting","_callback","display","parent","getParentNode","atRoot","parentRect","parentComputedStyle","root","body","documentElement","overflow","computeRectIntersection","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","indexOf","targetArea","intersectionArea","toFixed","opt_options","timeout","timer","throttle","bind","rootMargin","join","node","opt_useCapture","attachEvent","detatchEvent","rect1","rect2","max","min","child","parentNode","host","path","Map","ReplaceWithPolyfill","currentNode","removeChild","ownerDocument","createTextNode","insertBefore","previousSibling","replaceChild","Element","replaceWith","CharacterData","DocumentType","redefineAll","anInstance","iterate","setSpecies","DESCRIPTORS","internalStateGetterFor","getConstructor","wrapper","CONSTRUCTOR_NAME","IS_MAP","ADDER","C","that","iterable","first","last","size","define","previous","getEntry","next","removed","clear","prev","callbackfn","boundFunction","add","setStrong","ITERATOR_NAME","getInternalCollectionState","getInternalIteratorState","_typeof","assertThisInitialized","isRegistered","onReport","metric","userReportHandler","getCLS","getFID","getFCP","getLCP","getTTFB","getNanoSeconds","hrtime","loadTime","moduleLoadTime","nodeLoadTime","upTime","hr","uptime","getTime","$","isForced","redefine","InternalMetadataModule","checkCorrectnessOfIteration","setToStringTag","inheritIfRequired","common","IS_WEAK","NativeConstructor","NativePrototype","exported","fixMethod","KEY","nativeMethod","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","dummy","forced","createIteratorConstructor","IS_PURE","IteratorsCore","IteratorPrototype","BUGGY_SAFARI_ITERATORS","returnThis","Iterable","NAME","IteratorConstructor","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","keys","proto","createPropertyDescriptor","692","n","floor","random","delta","isFinal","PerformanceObserver","supportedEntryTypes","includes","getEntries","buffered","u","persisted","c","timeStamp","visibilityState","isUnloading","capture","d","passive","hadRecentInput","processingStart","perfMetrics","onFirstInputDelay","getEntriesByType","timing","navigationStart","responseStart","readyState","__webpack_require__","ab","__dirname","_extends","assign","source","PrototypeOfArrayIteratorPrototype","arrayIterator","preventExtensions","vendors","suffix","raf","caf","queue","_now","cp","cancelled","round","handle","cancel","requestAnimationFrame","cancelAnimationFrame","configValue","normalizeRoute","route","buildId","assetPrefix","promisedSsgManifest","promisedDevPagesManifest","routeLoader","getClientBuildManifest","manifest","parseRelativeUrl","getHrefForSlug","dataRoute","addLocale","addBasePath","ssg","isDynamic","interpolatedRoute","interpolateAs","loadRoute","res","href","text","prefetch"],"mappings":"6IAAA,cAAcA,OAAOC,YAAYD,OAAOC,UAAUC,UAAUF,OAAOC,UAAUE,UAAU,YAAYH,OAAOC,YAAYD,OAAOC,UAAUG,QAAQJ,OAAOC,UAAUI,WAAW,gBAAgBC,OAAOL,WAAWM,OAAOC,eAAeF,OAAOL,UAAU,cAAc,CAACQ,cAAa,EAAGC,IAAI,WAAW,IAAIC,EAAE,WAAWC,KAAKC,KAAKC,YAAY,OAAOH,EAAEA,EAAE,QAAG,KAAUI,MAAMd,UAAUe,OAAOD,MAAMd,UAAUe,KAAK,SAASL,EAAEM,GAAG,OAAOA,EAAEJ,KAAKK,OAAOC,MAAM,GAAGN,MAAMF,EAAE,GAAGM,EAAEG,KAAKL,MAAMM,SAASJ,EAAED,KAAKL,EAAE,GAAGM,GAAGF,MAAMd,UAAUqB,QAAQ,SAASX,EAAEM,GAAG,OAAOJ,KAAKU,IAAIZ,EAAEM,GAAGD,SAASQ,QAAQvB,UAAUwB,UAAUD,QAAQvB,UAAUwB,QAAQ,SAASd,GAAG,GAAG,mBAAmBA,EAAE,OAAOE,KAAKa,KAAKf,EAAEA,GAAG,IAAIM,EAAEJ,KAAKc,aAAaH,QAAQ,OAAOX,KAAKa,MAAK,SAASE,GAAG,OAAOX,EAAEY,QAAQlB,KAAKe,MAAK,WAAW,OAAOE,QAAK,SAASA,GAAG,OAAOX,EAAEY,QAAQlB,KAAKe,MAAK,WAAW,MAAME,W,uBCAp0B,IAAIE,EAAS,EAAQ,QACjBC,EAAe,EAAQ,QACvBC,EAAuB,EAAQ,QAC/BC,EAA8B,EAAQ,QACtCC,EAAkB,EAAQ,QAE1BC,EAAWD,EAAgB,YAC3BE,EAAgBF,EAAgB,eAChCG,EAAcL,EAAqBM,OAEvC,IAAK,IAAIC,KAAmBR,EAAc,CACxC,IAAIS,EAAaV,EAAOS,GACpBE,EAAsBD,GAAcA,EAAWvC,UACnD,GAAIwC,EAAqB,CAEvB,GAAIA,EAAoBN,KAAcE,EAAa,IACjDJ,EAA4BQ,EAAqBN,EAAUE,GAC3D,MAAOK,GACPD,EAAoBN,GAAYE,EAKlC,GAHKI,EAAoBL,IACvBH,EAA4BQ,EAAqBL,EAAeG,GAE9DR,EAAaQ,GAAkB,IAAK,IAAII,KAAeX,EAEzD,GAAIS,EAAoBE,KAAiBX,EAAqBW,GAAc,IAC1EV,EAA4BQ,EAAqBE,EAAaX,EAAqBW,IACnF,MAAOD,GACPD,EAAoBE,GAAeX,EAAqBW,O,uBC5BhE,IAAIC,EAAM,EAAQ,QACdC,EAAW,EAAQ,QACnBC,EAAY,EAAQ,QACpBC,EAA2B,EAAQ,QAEnCC,EAAWF,EAAU,YACrBG,EAAkB1C,OAAON,UAI7BiD,EAAOC,QAAUJ,EAA2BxC,OAAO6C,eAAiB,SAAUC,GAE5E,OADAA,EAAIR,EAASQ,GACTT,EAAIS,EAAGL,GAAkBK,EAAEL,GACH,mBAAjBK,EAAE1B,aAA6B0B,aAAaA,EAAE1B,YAChD0B,EAAE1B,YAAY1B,UACdoD,aAAa9C,OAAS0C,EAAkB,O,uBCfnD,IAAIK,EAAQ,EAAQ,QAEpBJ,EAAOC,SAAWG,GAAM,WACtB,SAASC,KAET,OADAA,EAAEtD,UAAU0B,YAAc,KACnBpB,OAAO6C,eAAe,IAAIG,KAASA,EAAEtD,c,oCCJ9C,IAAIuD,EAAkB,EAAQ,QAC1BC,EAAmB,EAAQ,QAC3BC,EAAY,EAAQ,QACpBC,EAAsB,EAAQ,QAC9BC,EAAiB,EAAQ,QAGzBC,EAAmBF,EAAoBG,IACvCC,EAAmBJ,EAAoBK,UAFtB,kBAcrBd,EAAOC,QAAUS,EAAe7C,MAAO,SAAS,SAAUkD,EAAUC,GAClEL,EAAiBhD,KAAM,CACrBsD,KAhBiB,iBAiBjBC,OAAQZ,EAAgBS,GACxBI,MAAO,EACPH,KAAMA,OAIP,WACD,IAAII,EAAQP,EAAiBlD,MACzBuD,EAASE,EAAMF,OACfF,EAAOI,EAAMJ,KACbG,EAAQC,EAAMD,QAClB,OAAKD,GAAUC,GAASD,EAAOG,QAC7BD,EAAMF,YAASI,EACR,CAAEC,WAAOD,EAAWE,MAAM,IAEvB,QAARR,EAAuB,CAAEO,MAAOJ,EAAOK,MAAM,GACrC,UAARR,EAAyB,CAAEO,MAAOL,EAAOC,GAAQK,MAAM,GACpD,CAAED,MAAO,CAACJ,EAAOD,EAAOC,IAASK,MAAM,KAC7C,UAKHhB,EAAUiB,UAAYjB,EAAU3C,MAGhC0C,EAAiB,QACjBA,EAAiB,UACjBA,EAAiB,Y,uBCpDjB,IAAImB,EAAiB,EAAQ,QAiB7B1B,EAAOC,QAfP,SAAmB0B,EAAUC,GAC3B,GAA0B,oBAAfA,GAA4C,OAAfA,EACtC,MAAM,IAAIC,UAAU,sDAGtBF,EAAS5E,UAAYM,OAAOyE,OAAOF,GAAcA,EAAW7E,UAAW,CACrE0B,YAAa,CACX8C,MAAOI,EACPI,UAAU,EACVxE,cAAc,KAGdqE,GAAYF,EAAeC,EAAUC,K,uBCd3C,IAAII,EAAa,EAAQ,QACrBC,EAAW,EAAQ,QACnBvC,EAAM,EAAQ,QACdpC,EAAiB,EAAQ,QAAuC4E,EAChEC,EAAM,EAAQ,QACdC,EAAW,EAAQ,QAEnBC,EAAWF,EAAI,QACfG,EAAK,EAELC,EAAelF,OAAOkF,cAAgB,WACxC,OAAO,GAGLC,EAAc,SAAUC,GAC1BnF,EAAemF,EAAIJ,EAAU,CAAEd,MAAO,CACpCmB,SAAU,OAAQJ,EAClBK,SAAU,OAoCVC,EAAO5C,EAAOC,QAAU,CAC1B4C,UAAU,EACVC,QAlCY,SAAUL,EAAIX,GAE1B,IAAKG,EAASQ,GAAK,MAAoB,iBAANA,EAAiBA,GAAmB,iBAANA,EAAiB,IAAM,KAAOA,EAC7F,IAAK/C,EAAI+C,EAAIJ,GAAW,CAEtB,IAAKE,EAAaE,GAAK,MAAO,IAE9B,IAAKX,EAAQ,MAAO,IAEpBU,EAAYC,GAEZ,OAAOA,EAAGJ,GAAUK,UAwBtBK,YArBgB,SAAUN,EAAIX,GAC9B,IAAKpC,EAAI+C,EAAIJ,GAAW,CAEtB,IAAKE,EAAaE,GAAK,OAAO,EAE9B,IAAKX,EAAQ,OAAO,EAEpBU,EAAYC,GAEZ,OAAOA,EAAGJ,GAAUM,UAatBK,SATa,SAAUP,GAEvB,OADIL,GAAYQ,EAAKC,UAAYN,EAAaE,KAAQ/C,EAAI+C,EAAIJ,IAAWG,EAAYC,GAC9EA,IAUTT,EAAWK,IAAY,G,sCC5DvB,E,SAAA,YAEAY,eAEA,qBAAiBC,QAAjB,Q,qBCJA,EAAQ,QAAMC,Y,4DC8EC,WACb,IAAIC,EAAJ,KAEA,MAAO,CACLC,iBAAkB,IADb,IAELC,WAAaC,YACX,IAAMC,EAAWJ,EAAgB9E,wBAAuB,WACtD,GAAIkF,IAAJ,GAEAJ,OACA,IAAMK,EAAN,GAEAF,WAAcG,YACZ,IAAMC,EAAaF,EAAKC,EAALD,OAAnB,GACAE,UACAF,EAAKC,EAALD,WAGF,IAAMG,EAAiBH,QAAaA,QAAbA,GAAvB,KACII,EAAJ,GACA,KAAoB,KACZ,EAAeD,EAArB,MAAM,SACNC,EACsB,kBAAbC,EAAP,EAEIjG,iBACAiG,OADAjG,IAHNgG,GAOEA,IAAUE,SAAd,QAA8BA,kBAC7B,iDAAqD9C,aA1E9D,SAAwBA,EAAxB,GACE,IAAM+C,EAASD,sCAAf,GACME,EAA+BD,gBAArC,8BAGA,EAYA,IAHA,IAAME,EAAYC,OAAOF,EAAzB,SACMG,EAAN,GAGMC,EAAJ,EAAWC,EAAIL,EADjB,uBAEEI,EAFF,EAGEA,IAAKC,EAAIA,EAHX,uBAKMA,0BAAJ,GACEF,UAGJ,IAAMG,EAAWZ,MAAD,WACba,YACC,IAAK,IAAIC,EAAJ,EAAWC,EAAMN,EAAtB,OAAsCK,EAAtC,EAA+CA,IAAK,CAElD,GADeL,EAAf,GACIO,YAAJ,GAEE,OADAP,eACA,EAGJ,YAIJA,WAAiB3G,YAAD,OAAOA,yBAAvB2G,MACAG,WAAiB9G,YAAD,OAAOuG,iBAAvBO,MACAN,WAAuBC,EAAYE,EAAZF,OAA6BK,EAA9B,QAAtBN,WAkCQW,CAAe3D,EAAMwC,MAArBmB,cA7GV,IAAMC,EAA4C,CAChDC,cADgD,iBAEhDC,UAFgD,QAGhDC,QAHgD,MAIhDC,UAJF,cAOA,SAASC,EAAkB,GAA2C,IAA3C,EAA2C,EAA3C,KAA3B,EAAsE,EAAtE,MACQC,EAAKpB,uBAAX,GACA,IAAK,IAAL,OACE,GAAKqB,iBAAL,IACIC,gBAAJ,4BAAwBA,QAGxB,IAAID,KAAJ,CAEA,IAAME,EAAOT,MAAwBQ,EAArC,cACAF,iBAAsBC,EAAtBD,IAVkE,IAa9D,EAAN,EAAM,WAAN,EAAM,wBAWN,OAVA,EACEA,YAAeI,UAAfJ,GACSrB,IACTqB,cACsB,kBAAbrB,EAAP,EAEIjG,iBACAiG,OADAjG,IAHNsH,IAOF,I,kCC/BF,I,8CAEO,IAAMK,I,EAFb,Y,4BAKKC,sBAHE,I,ytBCDP,UACA,mBACA,eACA,YACA,eACA,YAOA,YACA,YACA,eACA,eAEA,YACA,eACA,eACA,eACA,YAsBMC,EAAuCC,WAC3C5B,yCADF,aAGAd,uBAEuB2C,EAAYC,QAAZD,S,MAEvB,YAAME,oBAAe,IAArB,EAEM,EAFkD,MAGjD,EADD,EACJV,IADI,SAEJW,EAFI,EAEJA,MAFI,wFAUJC,EAGE,EAHFA,OAVF,EAaI,EAbJ,cAaI,EAAJ,GAEMC,GAINC,IAA0B,GAAH,OAAvBA,EAAuB,WAEvBC,YAAoB,CAClBC,oBADkB,GAElBC,oBAAqBC,GAFvBH,KAKA,IAAII,GAAS,IAAb,WAGI,IAAAC,aAAJ,KACED,GAAS,IAAAE,aAATF,IAkDF,IAAMG,EAAa,IAAIC,EAAJ,UAAnB,GACMC,EAAuB,SAAC,GAAD,aAAC,EAAD,mBAC3BF,6BADF,IAEIzD,OAAJ,UAGEA,qBAAqBoC,YAAD,OAAOwB,YAAW,kBAAMD,EAAP,KAArC3D,MAEFA,mBACEA,OAAD,gBAED,IAGA,EACA,EAEO,EACP,EACA,IARM6D,GAAc,IAApB,WACMC,GAAahD,wBAAnB,U,eASA,G,wIAGmB,KACfpG,KAAA,gB,0CAIAA,KAAA,eAOEqJ,UACCC,GACEvB,gBACE,IAAAwB,gBAAeF,EAAf,WAAmCG,SAFvCF,SAGEG,GAAgBA,EAAhBA,SAAwCD,SAL7C,SAQEH,UACEA,eAEElK,OACEuK,SACEA,yBAAmCL,EADrCK,OAEE,IAAIC,gBAAgBH,SAN5BH,YAUE,CAKEO,GALF,EAUEC,SApBJR,M,2CA2BFrJ,KAAA,iB,qCAGa,IACT,EAAJ,SAAI,KAEJ,GADA8J,EAAOA,GAAQA,YAAfA,GACA,CAEA,IAAMtC,EAAKpB,wBAAX,GACA,GAIA8C,YAAW,kBAAM1B,EAAP,mBAAV0B,M,+BAKE,OAAOlJ,KAAKyH,MAAZ,a,GAnEkBK,UAAMiC,WA2EjBC,IAAU,IAAhB,W,+CAEQ,0JAMejB,6BAA5B,SANa,YAOT,UADEkB,EANO,+BAQLA,EAAN,MARW,OAWP,EAAN,EAAQC,UAAF,EAAN,EAAwB5H,QACxB6H,IAEIC,GAAOA,EAAX,kBACEC,EAAc,YAQR,IAKJ,EAba,EAQT,EARS,KAQT,EARS,OAQT,EARS,YAQT,EARS,QAQT,EARS,WAQT,EARS,UAAD,EAQR,EARQ,QAUNC,EAAW,GAAH,OAAMC,WAAN,YACZC,WAAWA,6BADb,MAKIC,GAAWA,EAAf,SACEC,EAAiBD,KAAjBC,WAGFN,kBAAoB,CAClBzF,GAAIA,GADc,EAElBgG,OACAC,UAAWA,GAHO,EAIlBhH,MAAOA,UAJW,EAKlBiH,MACEC,wBAAwBA,EAAxBA,SANJV,gBAaAW,EAAJ,EA/Ca,mDAuDChC,6BALZ,GAlDW,iCAwDP,UANEiC,EAlDK,8BAyDHA,EAAN,MAzDS,QA2DXC,EAAkBD,EAAlBC,UA3DW,2EAuEXF,OAvEW,YA4GTzF,OAAJ,oBA5Ga,kCA6GLA,2BAAN,GA7GW,eAgHb,EAAA+D,UAAS,IAAA6B,cAAA,MAAkC,CACzCC,aADyC,EAEzCpC,aACAqC,IAHyC,EAIzCrB,UAJyC,EAKzCsB,WACAjD,IANyC,EAOzCkB,WAAYgC,QAP6B,GAQzCC,aAAc,qBAAeC,GAAO9L,mBAAwB,CAAE0L,UAC9DK,SACApD,UACAqD,kBAyBAF,GATIG,EAA6B,CACjCP,IADiC,EAEjCQ,SAFiC,EAGjC7B,UAHiC,EAIjCtC,MAJiC,EAKjCW,IALF,IA3Ia,kBAmJb,IAnJa,iCAuJJ,CAAE4B,WAASwB,UAAQG,cAvJf,2D,8DA2JR,G,qEAAA,iFACDE,EAAJ,IADK,gCAEGC,GAAN,GAFG,iEAOGC,GAAN,GAPG,2DAUCC,KAAJ,UAVG,qDAoBGF,IAAY,EAAD,iBAAsB1D,IAAvC,QApBG,0D,sBA2BA,SAAS0D,GAAYG,GAAoC,IACxD,EAAN,EAAM,MAAN,EAAM,IAmCN,OADA1G,iBACOwD,4BAEC,YAA2C,IAA1C,EAA0C,EAAxCmD,KAAH,EAA2C,EAA3C,YAIEC,EAAUd,GAAhB,GACMe,EAAS,CACbrC,UADa,EAEboC,UACA9C,SACAgD,IAAK,CAAEjE,MAAKkE,SAAP,EAAuBC,QAAO3D,SAAQuD,YAE7C,OAAOxL,gBACLsL,QACIA,EADJA,OAEI,IAAAO,qBAAA,EAHC7L,UAIC8L,YAAD,OACLV,IAAS,EAAD,iBAEN3D,MACA2B,UAHM,EAIN2C,cACAjF,MAVJ,W,aAgBN,IACIkF,GAAJ,oBAA8BC,UAAP,QA2BvB,SAASC,KACFC,EAAL,KAEAC,iCAEAA,iFAKAA,uEAEA,GACEA,6DAEFC,MAGF,SAASC,KACP,GAAKH,EAAL,IAEAC,gCACA,IAAMG,EAAkBH,2CAAxB,QAEKG,EAAL,SAIAH,qDAEEG,KAFFH,qBAKAA,mEACA,IACEA,0DACAA,2EAIFC,KACC,6DAA8DG,YAAD,OAC5DJ,0BADD,QAKH,SAASC,KACN,qEAKUI,YAAD,OAAUL,uBALnB,MAQH,SAASM,GAAa,GAE8B,IAFpD,EAEoD,EAFpD,SAGE,OACE,4BACEC,GAAKzL,YAAD,OACFiK,GAAY,CAAEV,IAAF,EAAkBhD,IAA9B0D,WAAmD1D,YAAD,OAChD7C,uCAHN,QAOE,wBAAC,EAAD,wBAAwB3B,OAAO,IAAA2J,0BAA/B,IACE,wBAAC,EAAD,6BAA6B3J,MAA7B,GATN,KAiBF,IAAMyH,GAAWD,YAAD,OACdoC,YAEA,IAAMC,GAAqB,EAAH,iBAEtB1D,UAFsB,EAGtB3B,IAHsB,EAItBiB,WAEF,OACE,gCACE,0BAFJ,MAOF,SAAS0C,GAAS2B,GAAsC,IAClD,EAAJ,EAAI,MAAJ,EAAI,YAAJ,EAAI,QAAJ,EAAI,IACAhB,EACF,YAAagB,OAAQ/J,EAAY+J,EADnC,YAEA3D,EAAYA,GAAa4D,EAAzB5D,UACAtC,EAAQA,GAASkG,EAAjBlG,MAEA,IAAMgG,GAAqB,EAAH,iBAEtB1D,YACA3B,MACAiB,WAGFsE,IAEA,IACA,EADIC,GAAJ,EAEMC,EAAgB,IAAIlN,SAAQ,cAChC,GACEmN,IAEFC,EAAiB,WACfD,OACA9M,KAEF8M,EAAmB,WACjBF,KACAE,OAEA,IAAMjM,EAAa,IAAImM,MAAvB,0BACAnM,eACAoM,SA+GJ,IApQ0BC,EAA5B,EAoQQC,EACJ,4BAAMC,SALR,WACEL,MAKE,4BAAMK,SAtEV,WACE,GAGEnG,IAHF,EASE,CAUA,IATA,IAAMoG,EAAe,IAAIC,IAAI5B,OAAiB6B,YAAD,OAAOA,EAApD,SACMC,EAAmBrG,EACvB/B,0BADF,uBAGMqI,EAAeD,OAClBE,YAAD,OAASA,eADX,kBAKSC,EAAT,EAAkBA,EAAMF,EAAxB,WACMJ,MAAiBI,EAArB,IACED,8BAEAA,+BAKJ,IAAII,EAAgBxI,uBAApB,wBACA,GAIEsG,WAAoB,YAAc,IAAd,EAAc,EAAd,KACZmC,EAAYzI,oDAAlB,EAAkBA,OAGlB,IAIEwI,4BAEEA,EAFFA,aAIAA,QAMNzG,EACE/B,0BADF+B,4BAEWX,YACTA,+BAKFsH,iBAAiB1I,SAAD,KAAhB0I,cAWA,gCACE,0BAJN,KAqBA,OA9HA,WACE,IACGpC,EAKD,SAGF,IAAM8B,EAAmBrG,EACvB/B,0BADF,uBAGMqI,EAAe,IAAIH,IACvBE,OAAsBE,YAAD,OAASA,eADhC,mBAIMK,EAAW3I,uBAAjB,wBACM4I,EAAK,MAAGD,OAAH,EAAGA,eAAd,cAEArC,WAAoB,YAAoB,IAAnB,EAAmB,EAAnB,KAAD,EAAoB,EAApB,KAClB,IAAK+B,MAAL,GAA6B,CAC3B,IAAMQ,EAAW7I,uBAAjB,SACA6I,gCACAA,4BAEA,GACEA,0BAGF7I,6BACA6I,cAAqB7I,wBAArB6I,QAmFNC,GA7Q0BhB,EAgRR,EAhRpB,EAgREiB,GApQMrC,EAAJ,IACEC,iCAIF,IACEH,0BACAD,OAEAC,yBAoQJ,EAGF,SAASwC,GAAK,GAKU,IALV,EAKU,EALV,SAAd,EAKwB,EALxB,SAwBE,OAhBAtH,2BAAsB,kBAAMsG,MAAY,CAAxCtG,IAaAA,qBAAgB,YACd,kBADFA,IAGA,EAKF,SAASuH,GAAK,GAAwC,IAAtD,EAAsD,EAAtD,SAIE,OADAvH,2BAAsB,kBAAMsG,MAAY,CAAxCtG,IACA,O,mBC7xBF,SAASwH,EAAgBvO,GAIvB,OAHAsB,EAAOC,QAAUgN,EAAkB5P,OAAOqE,eAAiBrE,OAAO6C,eAAiB,SAAyBxB,GAC1G,OAAOA,EAAEwO,WAAa7P,OAAO6C,eAAexB,IAEvCuO,EAAgBvO,GAGzBsB,EAAOC,QAAUgN,G,mBCCjBjN,EAAOC,QARP,SAAgCkN,GAC9B,QAAa,IAATA,EACF,MAAM,IAAIC,eAAe,6DAG3B,OAAOD,I,kCCJT,IAAIE,EAAS,EAAQ,QAAiCA,OAClD5M,EAAsB,EAAQ,QAC9BC,EAAiB,EAAQ,QAGzBC,EAAmBF,EAAoBG,IACvCC,EAAmBJ,EAAoBK,UAFrB,mBAMtBJ,EAAe5D,OAAQ,UAAU,SAAUiE,GACzCJ,EAAiBhD,KAAM,CACrBsD,KARkB,kBASlBqM,OAAQxQ,OAAOiE,GACfI,MAAO,OAIR,WACD,IAGIoM,EAHAnM,EAAQP,EAAiBlD,MACzB2P,EAASlM,EAAMkM,OACfnM,EAAQC,EAAMD,MAElB,OAAIA,GAASmM,EAAOjM,OAAe,CAAEE,WAAOD,EAAWE,MAAM,IAC7D+L,EAAQF,EAAOC,EAAQnM,GACvBC,EAAMD,OAASoM,EAAMlM,OACd,CAAEE,MAAOgM,EAAO/L,MAAM,Q,sBC3B/B,yBAC6D,2BAAd,EAE7C,WAAe,aAEf,SAASgM,EAAgBC,EAAUC,GACjC,KAAMD,aAAoBC,GACxB,MAAM,IAAI7L,UAAU,qCAIxB,SAAS8L,EAAkBzM,EAAQkE,GACjC,IAAK,IAAIf,EAAI,EAAGA,EAAIe,EAAM/D,OAAQgD,IAAK,CACrC,IAAIuJ,EAAaxI,EAAMf,GACvBuJ,EAAWC,WAAaD,EAAWC,aAAc,EACjDD,EAAWrQ,cAAe,EACtB,UAAWqQ,IAAYA,EAAW7L,UAAW,GACjD1E,OAAOC,eAAe4D,EAAQ0M,EAAWE,IAAKF,IAIlD,SAASG,EAAaL,EAAaM,EAAYC,GAG7C,OAFID,GAAYL,EAAkBD,EAAY3Q,UAAWiR,GACrDC,GAAaN,EAAkBD,EAAaO,GACzCP,EAGT,SAASQ,EAAUvM,EAAUC,GAC3B,GAA0B,oBAAfA,GAA4C,OAAfA,EACtC,MAAM,IAAIC,UAAU,sDAGtBF,EAAS5E,UAAYM,OAAOyE,OAAOF,GAAcA,EAAW7E,UAAW,CACrE0B,YAAa,CACX8C,MAAOI,EACPI,UAAU,EACVxE,cAAc,KAGdqE,GAAYuM,EAAgBxM,EAAUC,GAG5C,SAASqL,EAAgBvO,GAIvB,OAHAuO,EAAkB5P,OAAOqE,eAAiBrE,OAAO6C,eAAiB,SAAyBxB,GACzF,OAAOA,EAAEwO,WAAa7P,OAAO6C,eAAexB,KAEvBA,GAGzB,SAASyP,EAAgBzP,EAAG2G,GAM1B,OALA8I,EAAkB9Q,OAAOqE,gBAAkB,SAAyBhD,EAAG2G,GAErE,OADA3G,EAAEwO,UAAY7H,EACP3G,IAGcA,EAAG2G,GAG5B,SAAS+I,IACP,GAAuB,qBAAZC,UAA4BA,QAAQC,UAAW,OAAO,EACjE,GAAID,QAAQC,UAAUC,KAAM,OAAO,EACnC,GAAqB,oBAAVC,MAAsB,OAAO,EAExC,IAEE,OADAtG,KAAKnL,UAAUa,SAAS6Q,KAAKJ,QAAQC,UAAUpG,KAAM,IAAI,iBAClD,EACP,MAAOwG,GACP,OAAO,GAIX,SAASC,EAAuBxB,GAC9B,QAAa,IAATA,EACF,MAAM,IAAIC,eAAe,6DAG3B,OAAOD,EAGT,SAASyB,EAA2BzB,EAAMsB,GACxC,OAAIA,GAAyB,kBAATA,GAAqC,oBAATA,EAIzCE,EAAuBxB,GAHrBsB,EAMX,SAASI,EAAaC,GACpB,IAAIC,EAA4BX,IAEhC,OAAO,WACL,IACIY,EADAC,EAAQhC,EAAgB6B,GAG5B,GAAIC,EAA2B,CAC7B,IAAIG,EAAYjC,EAAgBtP,MAAMc,YAEtCuQ,EAASX,QAAQC,UAAUW,EAAOE,UAAWD,QAE7CF,EAASC,EAAMhR,MAAMN,KAAMwR,WAG7B,OAAOP,EAA2BjR,KAAMqR,IAI5C,SAASI,EAAeC,EAAQC,GAC9B,MAAQjS,OAAON,UAAUwS,eAAed,KAAKY,EAAQC,IAEpC,QADfD,EAASpC,EAAgBoC,MAI3B,OAAOA,EAGT,SAASG,EAAKtO,EAAQoO,EAAUG,GAkB9B,OAhBED,EADqB,qBAAZnB,SAA2BA,QAAQ7Q,IACrC6Q,QAAQ7Q,IAER,SAAc0D,EAAQoO,EAAUG,GACrC,IAAIC,EAAON,EAAelO,EAAQoO,GAElC,GAAKI,EAAL,CACA,IAAIC,EAAOtS,OAAOuS,yBAAyBF,EAAMJ,GAEjD,OAAIK,EAAKnS,IACAmS,EAAKnS,IAAIiR,KAAKgB,GAGhBE,EAAKpO,SAIJL,EAAQoO,EAAUG,GAAYvO,GAG5C,IAAI2O,EAAuB,WACzB,SAASA,IACPrC,EAAgB7P,KAAMkS,GAEtBxS,OAAOC,eAAeK,KAAM,YAAa,CACvC4D,MAAO,GACPQ,UAAU,EACVxE,cAAc,IA8DlB,OA1DAwQ,EAAa8B,EAAS,CAAC,CACrB/B,IAAK,mBACLvM,MAAO,SAA0BN,EAAM8K,EAAU+D,GACzC7O,KAAQtD,KAAKoS,YACjBpS,KAAKoS,UAAU9O,GAAQ,IAGzBtD,KAAKoS,UAAU9O,GAAM+O,KAAK,CACxBjE,SAAUA,EACV+D,QAASA,MAGZ,CACDhC,IAAK,sBACLvM,MAAO,SAA6BN,EAAM8K,GACxC,GAAM9K,KAAQtD,KAAKoS,UAMnB,IAFA,IAAIE,EAAQtS,KAAKoS,UAAU9O,GAElBoD,EAAI,EAAG6L,EAAID,EAAM5O,OAAQgD,EAAI6L,EAAG7L,IACvC,GAAI4L,EAAM5L,GAAG0H,WAAaA,EAExB,YADAkE,EAAME,OAAO9L,EAAG,KAKrB,CACDyJ,IAAK,gBACLvM,MAAO,SAAuB6O,GAC5B,GAAMA,EAAMnP,QAAQtD,KAAKoS,UAAzB,CAOA,IAHA,IACIM,EADQ1S,KAAKoS,UAAUK,EAAMnP,MACTqP,QAEfjM,EAAI,EAAG6L,EAAIG,EAAYhP,OAAQgD,EAAI6L,EAAG7L,IAAK,CAClD,IAAIkM,EAAWF,EAAYhM,GAE3B,IACEkM,EAASxE,SAAS0C,KAAK9Q,KAAMyS,GAC7B,MAAO1B,GACPpQ,QAAQK,UAAUH,MAAK,WACrB,MAAMkQ,KAIN6B,EAAST,SAAWS,EAAST,QAAQU,MACvC7S,KAAK8S,oBAAoBL,EAAMnP,KAAMsP,EAASxE,UAIlD,OAAQqE,EAAMM,sBAIXb,EArEkB,GAwEvBc,EAA2B,SAAUC,GACvC1C,EAAUyC,EAAaC,GAEvB,IAAIC,EAAShC,EAAa8B,GAE1B,SAASA,IACP,IAAIG,EA2BJ,OAzBAtD,EAAgB7P,KAAMgT,IAEtBG,EAAQD,EAAOpC,KAAK9Q,OAOToS,WACTF,EAAQpB,KAAKE,EAAuBmC,IAKtCzT,OAAOC,eAAeqR,EAAuBmC,GAAQ,UAAW,CAC9DvP,OAAO,EACPQ,UAAU,EACVxE,cAAc,IAEhBF,OAAOC,eAAeqR,EAAuBmC,GAAQ,UAAW,CAC9DvP,MAAO,KACPQ,UAAU,EACVxE,cAAc,IAETuT,EAuBT,OApBA/C,EAAa4C,EAAa,CAAC,CACzB7C,IAAK,WACLvM,MAAO,WACL,MAAO,yBAER,CACDuM,IAAK,gBACLvM,MAAO,SAAuB6O,GACT,UAAfA,EAAMnP,OACRtD,KAAKoT,SAAU,EAEa,oBAAjBpT,KAAKqT,SACdrT,KAAKqT,QAAQvC,KAAK9Q,KAAMyS,IAI5BZ,EAAKvC,EAAgB0D,EAAY5T,WAAY,gBAAiBY,MAAM8Q,KAAK9Q,KAAMyS,OAI5EO,EAxDsB,CAyD7Bd,GACEoB,EAA+B,WACjC,SAASA,IACPzD,EAAgB7P,KAAMsT,GAItB5T,OAAOC,eAAeK,KAAM,SAAU,CACpC4D,MAAO,IAAIoP,EACX5O,UAAU,EACVxE,cAAc,IAyClB,OArCAwQ,EAAakD,EAAiB,CAAC,CAC7BnD,IAAK,QACLvM,MAAO,WACL,IAAI6O,EAEJ,IACEA,EAAQ,IAAIc,MAAM,SAClB,MAAOxC,GACiB,qBAAb3K,SACJA,SAASoN,aAMZf,EAAQrM,SAASoN,YAAY,UACvBC,UAAU,SAAS,GAAO,IALhChB,EAAQrM,SAASsN,qBACXpQ,KAAO,QAQfmP,EAAQ,CACNnP,KAAM,QACNqQ,SAAS,EACTC,YAAY,GAKlB5T,KAAK6T,OAAOC,cAAcrB,KAE3B,CACDtC,IAAK,WACLvM,MAAO,WACL,MAAO,+BAIJ0P,EAlD0B,GA4DnC,SAASS,EAAevE,GACtB,OAAIA,EAAKwE,0CACPzO,QAAQ0O,IAAI,sFACL,GAUsB,oBAAjBzE,EAAK0E,UAA2B1E,EAAK0E,QAAQ9U,UAAUwS,eAAe,YAAcpC,EAAK8D,gBAiBzG,SAASa,EAAwBC,GAC3B,oBAAsBA,IACxBA,EAAe,CACbC,MAAOD,IAIX,IAAIE,EAAgBF,EAChBC,EAAQC,EAAcD,MACtBE,EAAwBD,EAAcJ,QACtCM,OAA0C,IAA1BD,EAAmCF,EAAMH,QAAUK,EACnEE,EAAwBH,EAAchB,gBACtCoB,EAAwBJ,EAAcN,yCACtCA,OAAqE,IAA1BU,GAA2CA,EAE1F,IAAKX,EAAe,CAClBM,MAAOA,EACPH,QAASM,EACTlB,gBAAiBmB,EACjBT,yCAA0CA,IAE1C,MAAO,CACLK,MAAOA,EACPH,QAASA,GAIb,IAAIA,EAAUM,GAYVN,IAAYA,EAAQ9U,UAAUwS,eAAe,WAAaoC,MAC5DE,EAAU,SAAiBxG,EAAOiH,GAChC,IAAId,EAEAc,GAAQA,EAAKd,SACfA,EAASc,EAAKd,cAOPc,EAAKd,QAGd,IAAIe,EAAU,IAAIJ,EAAc9G,EAAOiH,GAWvC,OATId,GACFnU,OAAOC,eAAeiV,EAAS,SAAU,CACvCxQ,UAAU,EACV8L,YAAY,EACZtQ,cAAc,EACdgE,MAAOiQ,IAIJe,IAGDxV,UAAYoV,EAAcpV,WAGpC,IAAIyV,EAAYR,EAgDhB,MAAO,CACLA,MA/CmB,SAAwB3G,EAAOiH,GAClD,IAAId,EAASK,GAAWA,EAAQ9U,UAAU0V,cAAcpH,GAASA,EAAMmG,OAASc,EAAOA,EAAKd,YAASlQ,EAErG,GAAIkQ,EAAQ,CACV,IAAIkB,EAEJ,IACEA,EAAa,IAAIC,aAAa,UAAW,cACzC,MAAO5M,IAGP2M,EAAa,IAAI/G,MAAM,YACZrD,KAAO,aAIpB,GAAIkJ,EAAOT,QACT,OAAOzS,QAAQsN,OAAO8G,GAIxB,IAAIE,EAAe,IAAItU,SAAQ,SAAUuU,EAAGjH,GAC1C4F,EAAOsB,iBAAiB,SAAS,WAC/B,OAAOlH,EAAO8G,KACb,CACDlC,MAAM,OAeV,OAXI8B,GAAQA,EAAKd,eAORc,EAAKd,OAIPlT,QAAQyU,KAAK,CAACH,EAAcJ,EAAUnH,EAAOiH,KAGtD,OAAOE,EAAUnH,EAAOiH,IAKxBT,QAASA,GA9JS,qBAAXzU,QAA0BA,OAAO4V,cAG1C/B,EAAgBlU,UAAUK,OAAO4V,aAAe,kBAChDrC,EAAY5T,UAAUK,OAAO4V,aAAe,eA8J9C,SAAW7F,GAET,GAAKuE,EAAevE,GAIpB,GAAKA,EAAK6E,MAAV,CAKA,IAAIiB,EAAkBnB,EAAwB3E,GAC1C6E,EAAQiB,EAAgBjB,MACxBH,EAAUoB,EAAgBpB,QAE9B1E,EAAK6E,MAAQA,EACb7E,EAAK0E,QAAUA,EACfxU,OAAOC,eAAe6P,EAAM,kBAAmB,CAC7CpL,UAAU,EACV8L,YAAY,EACZtQ,cAAc,EACdgE,MAAO0P,IAET5T,OAAOC,eAAe6P,EAAM,cAAe,CACzCpL,UAAU,EACV8L,YAAY,EACZtQ,cAAc,EACdgE,MAAOoP,SApBPzN,QAAQgQ,KAAK,qEAPjB,CA6BmB,qBAAT/F,KAAuBA,KAAOvO,KA7fmB,oC,2CCD7D,IAAII,EAAkB,EAAQ,QAC1B8C,EAAS,EAAQ,QACjBqR,EAAuB,EAAQ,QAE/BC,EAAcpU,EAAgB,eAC9BqU,EAAiBxV,MAAMd,eAIQuE,GAA/B+R,EAAeD,IACjBD,EAAqBjR,EAAEmR,EAAgBD,EAAa,CAClD7V,cAAc,EACdgE,MAAOO,EAAO,QAKlB9B,EAAOC,QAAU,SAAU6N,GACzBuF,EAAeD,GAAatF,IAAO,I,kCCjBrC,IAAIwF,EAAa,EAAQ,QACrBC,EAAmB,EAAQ,QAI/BvT,EAAOC,QAAUqT,EAAW,OAAO,SAAUhB,GAC3C,OAAO,WAAiB,OAAOA,EAAK3U,KAAMwR,UAAU9N,OAAS8N,UAAU,QAAK7N,MAC3EiS,I,oBCCF,SAAStQ,EAAQc,GAClB,aAKA,GAAI,yBAA0Bd,GAC1B,8BAA+BA,GAC/B,sBAAuBA,EAAOuQ,0BAA0BzW,UAIpD,mBAAoBkG,EAAOuQ,0BAA0BzW,WACzDM,OAAOC,eAAe2F,EAAOuQ,0BAA0BzW,UACrD,iBAAkB,CAClBS,IAAK,WACH,OAAOG,KAAK8V,kBAAoB,SAVxC,CAwBA,IAAIC,EAAW,GA+EfC,EAAqB5W,UAAU6W,iBAAmB,IAQlDD,EAAqB5W,UAAU8W,cAAgB,KAM/CF,EAAqB5W,UAAU+W,uBAAwB,EAQvDH,EAAqB5W,UAAUgX,QAAU,SAAS7S,GAKhD,IAJ8BvD,KAAKqW,oBAAoB9V,MAAK,SAAS+V,GACnE,OAAOA,EAAKC,SAAWhT,KAGzB,CAIA,IAAMA,GAA6B,GAAnBA,EAAOiT,SACrB,MAAM,IAAIxI,MAAM,6BAGlBhO,KAAKyW,oBACLzW,KAAKqW,oBAAoBhE,KAAK,CAACkE,QAAShT,EAAQmT,MAAO,OACvD1W,KAAK2W,wBACL3W,KAAK4W,2BAQPZ,EAAqB5W,UAAUyX,UAAY,SAAStT,GAClDvD,KAAKqW,oBACDrW,KAAKqW,oBAAoBS,QAAO,SAASR,GAE3C,OAAOA,EAAKC,SAAWhT,KAEpBvD,KAAKqW,oBAAoB3S,SAC5B1D,KAAK+W,0BACL/W,KAAKgX,wBAQThB,EAAqB5W,UAAU6X,WAAa,WAC1CjX,KAAKqW,oBAAsB,GAC3BrW,KAAK+W,0BACL/W,KAAKgX,uBAUPhB,EAAqB5W,UAAU8X,YAAc,WAC3C,IAAIC,EAAUnX,KAAKoX,eAAezE,QAElC,OADA3S,KAAKoX,eAAiB,GACfD,GAaTnB,EAAqB5W,UAAUiY,gBAAkB,SAASC,GACxD,IAAIC,EAAYD,GAAiB,CAAC,GAGlC,OAFKpX,MAAMM,QAAQ+W,KAAYA,EAAY,CAACA,IAErCA,EAAUC,OAAOV,QAAO,SAAShX,EAAG4G,EAAG+Q,GAC5C,GAAgB,iBAAL3X,GAAiB4X,MAAM5X,IAAMA,EAAI,GAAKA,EAAI,EACnD,MAAM,IAAIkO,MAAM,0DAElB,OAAOlO,IAAM2X,EAAE/Q,EAAI,OAgBvBsP,EAAqB5W,UAAUuY,iBAAmB,SAASC,GACzD,IACIC,GADeD,GAAkB,OACVE,MAAM,OAAOpX,KAAI,SAASqX,GACnD,IAAIC,EAAQ,wBAAwBjY,KAAKgY,GACzC,IAAKC,EACH,MAAM,IAAIhK,MAAM,qDAElB,MAAO,CAACpK,MAAOqU,WAAWD,EAAM,IAAKE,KAAMF,EAAM,OAQnD,OAJAH,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GACnCA,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GACnCA,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GAE5BA,GAST7B,EAAqB5W,UAAUuX,sBAAwB,WAChD3W,KAAKmY,2BACRnY,KAAKmY,0BAA2B,EAI5BnY,KAAKkW,cACPlW,KAAKoY,oBAAsBC,YACvBrY,KAAK4W,uBAAwB5W,KAAKkW,gBAGtCoC,EAAShT,EAAQ,SAAUtF,KAAK4W,wBAAwB,GACxD0B,EAASlS,EAAU,SAAUpG,KAAK4W,wBAAwB,GAEtD5W,KAAKmW,uBAAyB,qBAAsB7Q,IACtDtF,KAAKuY,aAAe,IAAIC,iBAAiBxY,KAAK4W,wBAC9C5W,KAAKuY,aAAanC,QAAQhQ,EAAU,CAClCqS,YAAY,EACZC,WAAW,EACXC,eAAe,EACfC,SAAS,QAYnB5C,EAAqB5W,UAAU2X,wBAA0B,WACnD/W,KAAKmY,2BACPnY,KAAKmY,0BAA2B,EAEhCU,cAAc7Y,KAAKoY,qBACnBpY,KAAKoY,oBAAsB,KAE3BU,EAAYxT,EAAQ,SAAUtF,KAAK4W,wBAAwB,GAC3DkC,EAAY1S,EAAU,SAAUpG,KAAK4W,wBAAwB,GAEzD5W,KAAKuY,eACPvY,KAAKuY,aAAatB,aAClBjX,KAAKuY,aAAe,QAY1BvC,EAAqB5W,UAAUwX,uBAAyB,WACtD,IAAImC,EAAc/Y,KAAKgZ,eACnBC,EAAWF,EAAc/Y,KAAKkZ,eAyW3B,CACLC,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GA7WVxZ,KAAKqW,oBAAoBoD,SAAQ,SAASnD,GACxC,IAAI/S,EAAS+S,EAAKC,QACdmD,EAAaC,EAAsBpW,GACnCqW,EAAqB5Z,KAAK6Z,oBAAoBtW,GAC9CuW,EAAWxD,EAAKI,MAChBqD,EAAmBhB,GAAea,GAClC5Z,KAAKga,kCAAkCzW,EAAQ0V,GAE/CgB,EAAW3D,EAAKI,MAAQ,IAAIb,EAA0B,CACxDqE,KAiOG5U,EAAOyH,aAAeA,YAAYoN,KAAOpN,YAAYoN,MAhOxD5W,OAAQA,EACR6W,mBAAoBV,EACpBW,WAAYpB,EACZc,iBAAkBA,IAGfD,EAEMf,GAAea,EAGpB5Z,KAAKsa,qBAAqBR,EAAUG,IACtCja,KAAKoX,eAAe/E,KAAK4H,GAMvBH,GAAYA,EAASS,gBACvBva,KAAKoX,eAAe/E,KAAK4H,GAZ3Bja,KAAKoX,eAAe/E,KAAK4H,KAe1Bja,MAECA,KAAKoX,eAAe1T,QACtB1D,KAAKwa,UAAUxa,KAAKkX,cAAelX,OAiBvCgW,EAAqB5W,UAAU4a,kCAC3B,SAASzW,EAAQ0V,GAGnB,GAA+C,QAA3C3T,EAAOwJ,iBAAiBvL,GAAQkX,QAApC,CAOA,IALA,IACIV,EADaJ,EAAsBpW,GAEnCmX,EAASC,EAAcpX,GACvBqX,GAAS,GAELA,GAAQ,CACd,IAAIC,EAAa,KACbC,EAAyC,GAAnBJ,EAAOlE,SAC7BlR,EAAOwJ,iBAAiB4L,GAAU,GAGtC,GAAmC,QAA/BI,EAAoBL,QAAmB,OAmB3C,GAjBIC,GAAU1a,KAAK+a,MAAQL,GAAUtU,GACnCwU,GAAS,EACTC,EAAa5B,GAMTyB,GAAUtU,EAAS4U,MACnBN,GAAUtU,EAAS6U,iBACa,WAAhCH,EAAoBI,WACtBL,EAAalB,EAAsBe,IAMnCG,KACFd,EAAmBoB,EAAwBN,EAAYd,IAEhC,MAEzBW,EAASC,EAAcD,GAEzB,OAAOX,IAST/D,EAAqB5W,UAAU8Z,aAAe,WAC5C,IAAID,EACJ,GAAIjZ,KAAK+a,KACP9B,EAAWU,EAAsB3Z,KAAK+a,UACjC,CAEL,IAAIK,EAAOhV,EAAS6U,gBAChBD,EAAO5U,EAAS4U,KACpB/B,EAAW,CACTE,IAAK,EACLE,KAAM,EACNC,MAAO8B,EAAKC,aAAeL,EAAKK,YAChC9B,MAAO6B,EAAKC,aAAeL,EAAKK,YAChCjC,OAAQgC,EAAKE,cAAgBN,EAAKM,aAClC9B,OAAQ4B,EAAKE,cAAgBN,EAAKM,cAGtC,OAAOtb,KAAKub,wBAAwBtC,IAUtCjD,EAAqB5W,UAAUmc,wBAA0B,SAASC,GAChE,IAAI3D,EAAU7X,KAAKyb,kBAAkB/a,KAAI,SAASqX,EAAQrR,GACxD,MAAsB,MAAfqR,EAAOG,KAAeH,EAAOnU,MAChCmU,EAAOnU,OAAS8C,EAAI,EAAI8U,EAAKjC,MAAQiC,EAAKhC,QAAU,OAEtDkC,EAAU,CACZvC,IAAKqC,EAAKrC,IAAMtB,EAAQ,GACxByB,MAAOkC,EAAKlC,MAAQzB,EAAQ,GAC5BuB,OAAQoC,EAAKpC,OAASvB,EAAQ,GAC9BwB,KAAMmC,EAAKnC,KAAOxB,EAAQ,IAK5B,OAHA6D,EAAQnC,MAAQmC,EAAQpC,MAAQoC,EAAQrC,KACxCqC,EAAQlC,OAASkC,EAAQtC,OAASsC,EAAQvC,IAEnCuC,GAcT1F,EAAqB5W,UAAUkb,qBAC3B,SAASR,EAAUG,GAIrB,IAAI0B,EAAW7B,GAAYA,EAASS,eAChCT,EAAShE,mBAAqB,GAAK,EACnC8F,EAAW3B,EAASM,eACpBN,EAASnE,mBAAqB,GAAK,EAGvC,GAAI6F,IAAaC,EAEjB,IAAK,IAAIlV,EAAI,EAAGA,EAAI1G,KAAK6b,WAAWnY,OAAQgD,IAAK,CAC/C,IAAI6Q,EAAYvX,KAAK6b,WAAWnV,GAIhC,GAAI6Q,GAAaoE,GAAYpE,GAAaqE,GACtCrE,EAAYoE,IAAapE,EAAYqE,EACvC,OAAO,IAWb5F,EAAqB5W,UAAU4Z,aAAe,WAC5C,OAAQhZ,KAAK+a,MAAQe,EAAa1V,EAAUpG,KAAK+a,OAUnD/E,EAAqB5W,UAAUya,oBAAsB,SAAStW,GAC5D,OAAOuY,EAAa9b,KAAK+a,MAAQ3U,EAAU7C,IAS7CyS,EAAqB5W,UAAUqX,kBAAoB,WAC7CV,EAASgG,QAAQ/b,MAAQ,GAC3B+V,EAAS1D,KAAKrS,OASlBgW,EAAqB5W,UAAU4X,oBAAsB,WACnD,IAAIxT,EAAQuS,EAASgG,QAAQ/b,OACf,GAAVwD,GAAauS,EAASvD,OAAOhP,EAAO,IAqL1C8B,EAAO0Q,qBAAuBA,EAC9B1Q,EAAOuQ,0BAA4BA,EAnqBnC,SAASA,EAA0Ba,GACjC1W,KAAKka,KAAOxD,EAAMwD,KAClBla,KAAKuD,OAASmT,EAAMnT,OACpBvD,KAAKqa,WAAa3D,EAAM2D,WACxBra,KAAKoa,mBAAqB1D,EAAM0D,mBAChCpa,KAAK+Z,iBAAmBrD,EAAMqD,kBA+mBvB,CACLZ,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GApnBVxZ,KAAKua,iBAAmB7D,EAAMqD,iBAG9B,IAAIL,EAAa1Z,KAAKoa,mBAClB4B,EAAatC,EAAWH,MAAQG,EAAWF,OAC3CO,EAAmB/Z,KAAK+Z,iBACxBkC,EAAmBlC,EAAiBR,MAAQQ,EAAiBP,OAM/DxZ,KAAK8V,kBAHHkG,EAGuBxV,QAAQyV,EAAmBD,GAAYE,QAAQ,IAG/Clc,KAAKua,eAAiB,EAAI,EAcvD,SAASvE,EAAqB5H,EAAU+N,GAEtC,IAAIhK,EAAUgK,GAAe,GAE7B,GAAuB,mBAAZ/N,EACT,MAAM,IAAIJ,MAAM,+BAGlB,GAAImE,EAAQ4I,MAAiC,GAAzB5I,EAAQ4I,KAAKvE,SAC/B,MAAM,IAAIxI,MAAM,2BAIlBhO,KAAK4W,uBAmdP,SAAkBtJ,EAAI8O,GACpB,IAAIC,EAAQ,KACZ,OAAO,WACAA,IACHA,EAAQnT,YAAW,WACjBoE,IACA+O,EAAQ,OACPD,KA1duBE,CAC1Btc,KAAK4W,uBAAuB2F,KAAKvc,MAAOA,KAAKiW,kBAGjDjW,KAAKwa,UAAYpM,EACjBpO,KAAKqW,oBAAsB,GAC3BrW,KAAKoX,eAAiB,GACtBpX,KAAKyb,kBAAoBzb,KAAK2X,iBAAiBxF,EAAQqK,YAGvDxc,KAAK6b,WAAa7b,KAAKqX,gBAAgBlF,EAAQoF,WAC/CvX,KAAK+a,KAAO5I,EAAQ4I,MAAQ,KAC5B/a,KAAKwc,WAAaxc,KAAKyb,kBAAkB/a,KAAI,SAASqX,GACpD,OAAOA,EAAOnU,MAAQmU,EAAOG,QAC5BuE,KAAK,KA0dV,SAASnE,EAASoE,EAAMjK,EAAOnF,EAAIqP,GACG,mBAAzBD,EAAKvH,iBACduH,EAAKvH,iBAAiB1C,EAAOnF,EAAIqP,IAAkB,GAEjB,mBAApBD,EAAKE,aACnBF,EAAKE,YAAY,KAAOnK,EAAOnF,GAanC,SAASwL,EAAY4D,EAAMjK,EAAOnF,EAAIqP,GACG,mBAA5BD,EAAK5J,oBACd4J,EAAK5J,oBAAoBL,EAAOnF,EAAIqP,IAAkB,GAEnB,mBAArBD,EAAKG,cACnBH,EAAKG,aAAa,KAAOpK,EAAOnF,GAYpC,SAAS6N,EAAwB2B,EAAOC,GACtC,IAAI5D,EAAM3O,KAAKwS,IAAIF,EAAM3D,IAAK4D,EAAM5D,KAChCC,EAAS5O,KAAKyS,IAAIH,EAAM1D,OAAQ2D,EAAM3D,QACtCC,EAAO7O,KAAKwS,IAAIF,EAAMzD,KAAM0D,EAAM1D,MAClCC,EAAQ9O,KAAKyS,IAAIH,EAAMxD,MAAOyD,EAAMzD,OACpCC,EAAQD,EAAQD,EAChBG,EAASJ,EAASD,EAEtB,OAAQI,GAAS,GAAKC,GAAU,GAAM,CACpCL,IAAKA,EACLC,OAAQA,EACRC,KAAMA,EACNC,MAAOA,EACPC,MAAOA,EACPC,OAAQA,GAUZ,SAASG,EAAsBnS,GAC7B,IAAIgU,EAEJ,IACEA,EAAOhU,EAAGmS,wBACV,MAAOvR,IAKT,OAAKoT,GAGCA,EAAKjC,OAASiC,EAAKhC,SACvBgC,EAAO,CACLrC,IAAKqC,EAAKrC,IACVG,MAAOkC,EAAKlC,MACZF,OAAQoC,EAAKpC,OACbC,KAAMmC,EAAKnC,KACXE,MAAOiC,EAAKlC,MAAQkC,EAAKnC,KACzBG,OAAQgC,EAAKpC,OAASoC,EAAKrC,MAGxBqC,GAUA,CACLrC,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GAWZ,SAASsC,EAAapB,EAAQwC,GAE5B,IADA,IAAIR,EAAOQ,EACJR,GAAM,CACX,GAAIA,GAAQhC,EAAQ,OAAO,EAE3BgC,EAAO/B,EAAc+B,GAEvB,OAAO,EAUT,SAAS/B,EAAc+B,GACrB,IAAIhC,EAASgC,EAAKS,WAElB,OAAIzC,GAA6B,IAAnBA,EAAOlE,UAAkBkE,EAAO0C,KAErC1C,EAAO0C,KAET1C,GApsBT,CA4sBEpV,OAAQc,W,qBCrtBV,EAAQ,QACR,EAAQ,QACR,EAAQ,QACR,EAAQ,QACR,IAAIiX,EAAO,EAAQ,QAEnBhb,EAAOC,QAAU+a,EAAKC,K,kCCLtB,IAAI3H,EAAa,EAAQ,QACrBC,EAAmB,EAAQ,QAI/BvT,EAAOC,QAAUqT,EAAW,OAAO,SAAUhB,GAC3C,OAAO,WAAiB,OAAOA,EAAK3U,KAAMwR,UAAU9N,OAAS8N,UAAU,QAAK7N,MAC3EiS,I,mBCPH,SAAS2H,IAEP,IAEEC,EAFE9C,EAAS1a,KAAKmd,WAChBzW,EAAI8K,UAAU9N,OAEhB,GAAKgX,EAIL,IAHKhU,GAEHgU,EAAO+C,YAAYzd,MACd0G,KAGsB,kBAD3B8W,EAAchM,UAAU9K,IAEtB8W,EAAcxd,KAAK0d,cAAcC,eAAeH,GACvCA,EAAYL,YACrBK,EAAYL,WAAWM,YAAYD,GAGhC9W,EAIAgU,EAAOkD,aAAa5d,KAAK6d,gBAAiBL,GAF7C9C,EAAOoD,aAAaN,EAAaxd,MAMlC+d,QAAQ3e,UAAU4e,cACrBD,QAAQ3e,UAAU4e,YAAcT,GAC7BU,cAAc7e,UAAU4e,cAC3BC,cAAc7e,UAAU4e,YAAcT,GACnCW,aAAa9e,UAAU4e,cAC1BE,aAAa9e,UAAU4e,YAAcT,I,kCC/BvC,IAAI5d,EAAiB,EAAQ,QAAuC4E,EAChEJ,EAAS,EAAQ,QACjBga,EAAc,EAAQ,QACtB5B,EAAO,EAAQ,QACf6B,EAAa,EAAQ,QACrBC,EAAU,EAAQ,QAClBtb,EAAiB,EAAQ,QACzBub,EAAa,EAAQ,QACrBC,EAAc,EAAQ,QACtBpZ,EAAU,EAAQ,QAAkCA,QACpDrC,EAAsB,EAAQ,QAE9BE,EAAmBF,EAAoBG,IACvCub,EAAyB1b,EAAoBK,UAEjDd,EAAOC,QAAU,CACfmc,eAAgB,SAAUC,EAASC,EAAkBC,EAAQC,GAC3D,IAAIC,EAAIJ,GAAQ,SAAUK,EAAMC,GAC9BZ,EAAWW,EAAMD,EAAGH,GACpB3b,EAAiB+b,EAAM,CACrBzb,KAAMqb,EACNnb,MAAOW,EAAO,MACd8a,WAAOtb,EACPub,UAAMvb,EACNwb,KAAM,IAEHZ,IAAaQ,EAAKI,KAAO,QACdxb,GAAZqb,GAAuBX,EAAQW,EAAUD,EAAKF,GAAQE,EAAMH,MAG9D1b,EAAmBsb,EAAuBG,GAE1CS,EAAS,SAAUL,EAAM5O,EAAKvM,GAChC,IAEIyb,EAAU7b,EAFVC,EAAQP,EAAiB6b,GACzBrI,EAAQ4I,EAASP,EAAM5O,GAqBzB,OAlBEuG,EACFA,EAAM9S,MAAQA,GAGdH,EAAMyb,KAAOxI,EAAQ,CACnBlT,MAAOA,EAAQ2B,EAAQgL,GAAK,GAC5BA,IAAKA,EACLvM,MAAOA,EACPyb,SAAUA,EAAW5b,EAAMyb,KAC3BK,UAAM5b,EACN6b,SAAS,GAEN/b,EAAMwb,QAAOxb,EAAMwb,MAAQvI,GAC5B2I,IAAUA,EAASE,KAAO7I,GAC1B6H,EAAa9a,EAAM0b,OAClBJ,EAAKI,OAEI,MAAV3b,IAAeC,EAAMD,MAAMA,GAASkT,IACjCqI,GAGPO,EAAW,SAAUP,EAAM5O,GAC7B,IAGIuG,EAHAjT,EAAQP,EAAiB6b,GAEzBvb,EAAQ2B,EAAQgL,GAEpB,GAAc,MAAV3M,EAAe,OAAOC,EAAMD,MAAMA,GAEtC,IAAKkT,EAAQjT,EAAMwb,MAAOvI,EAAOA,EAAQA,EAAM6I,KAC7C,GAAI7I,EAAMvG,KAAOA,EAAK,OAAOuG,GAiFjC,OA7EAyH,EAAYW,EAAE1f,UAAW,CAGvBqgB,MAAO,WAKL,IAJA,IACIhc,EAAQP,EADDlD,MAEP+H,EAAOtE,EAAMD,MACbkT,EAAQjT,EAAMwb,MACXvI,GACLA,EAAM8I,SAAU,EACZ9I,EAAM2I,WAAU3I,EAAM2I,SAAW3I,EAAM2I,SAASE,UAAO5b,UACpDoE,EAAK2O,EAAMlT,OAClBkT,EAAQA,EAAM6I,KAEhB9b,EAAMwb,MAAQxb,EAAMyb,UAAOvb,EACvB4a,EAAa9a,EAAM0b,KAAO,EAXnBnf,KAYDmf,KAAO,GAInB,OAAU,SAAUhP,GAClB,IACI1M,EAAQP,EADDlD,MAEP0W,EAAQ4I,EAFDtf,KAEgBmQ,GAC3B,GAAIuG,EAAO,CACT,IAAI6I,EAAO7I,EAAM6I,KACbG,EAAOhJ,EAAM2I,gBACV5b,EAAMD,MAAMkT,EAAMlT,OACzBkT,EAAM8I,SAAU,EACZE,IAAMA,EAAKH,KAAOA,GAClBA,IAAMA,EAAKF,SAAWK,GACtBjc,EAAMwb,OAASvI,IAAOjT,EAAMwb,MAAQM,GACpC9b,EAAMyb,MAAQxI,IAAOjT,EAAMyb,KAAOQ,GAClCnB,EAAa9a,EAAM0b,OAZdnf,KAaCmf,OACV,QAASzI,GAIb+C,QAAS,SAAiBkG,GAIxB,IAHA,IAEIjJ,EAFAjT,EAAQP,EAAiBlD,MACzB4f,EAAgBrD,EAAKoD,EAAYnO,UAAU9N,OAAS,EAAI8N,UAAU,QAAK7N,EAAW,GAE/E+S,EAAQA,EAAQA,EAAM6I,KAAO9b,EAAMwb,OAGxC,IAFAW,EAAclJ,EAAM9S,MAAO8S,EAAMvG,IAAKnQ,MAE/B0W,GAASA,EAAM8I,SAAS9I,EAAQA,EAAM2I,UAKjDtd,IAAK,SAAaoO,GAChB,QAASmP,EAAStf,KAAMmQ,MAI5BgO,EAAYW,EAAE1f,UAAWwf,EAAS,CAEhC/e,IAAK,SAAasQ,GAChB,IAAIuG,EAAQ4I,EAAStf,KAAMmQ,GAC3B,OAAOuG,GAASA,EAAM9S,OAGxBX,IAAK,SAAakN,EAAKvM,GACrB,OAAOwb,EAAOpf,KAAc,IAARmQ,EAAY,EAAIA,EAAKvM,KAEzC,CAEFic,IAAK,SAAajc,GAChB,OAAOwb,EAAOpf,KAAM4D,EAAkB,IAAVA,EAAc,EAAIA,EAAOA,MAGrD2a,GAAa5e,EAAemf,EAAE1f,UAAW,OAAQ,CACnDS,IAAK,WACH,OAAOqD,EAAiBlD,MAAMmf,QAG3BL,GAETgB,UAAW,SAAUhB,EAAGH,EAAkBC,GACxC,IAAImB,EAAgBpB,EAAmB,YACnCqB,EAA6BxB,EAAuBG,GACpDsB,EAA2BzB,EAAuBuB,GAGtDhd,EAAe+b,EAAGH,GAAkB,SAAUvb,EAAUC,GACtDL,EAAiBhD,KAAM,CACrBsD,KAAMyc,EACNxc,OAAQH,EACRK,MAAOuc,EAA2B5c,GAClCC,KAAMA,EACN6b,UAAMvb,OAEP,WAKD,IAJA,IAAIF,EAAQwc,EAAyBjgB,MACjCqD,EAAOI,EAAMJ,KACbqT,EAAQjT,EAAMyb,KAEXxI,GAASA,EAAM8I,SAAS9I,EAAQA,EAAM2I,SAE7C,OAAK5b,EAAMF,SAAYE,EAAMyb,KAAOxI,EAAQA,EAAQA,EAAM6I,KAAO9b,EAAMA,MAAMwb,OAMjE,QAAR5b,EAAuB,CAAEO,MAAO8S,EAAMvG,IAAKtM,MAAM,GACzC,UAARR,EAAyB,CAAEO,MAAO8S,EAAM9S,MAAOC,MAAM,GAClD,CAAED,MAAO,CAAC8S,EAAMvG,IAAKuG,EAAM9S,OAAQC,MAAM,IAN9CJ,EAAMF,YAASI,EACR,CAAEC,WAAOD,EAAWE,MAAM,MAMlC+a,EAAS,UAAY,UAAWA,GAAQ,GAG3CN,EAAWK,M,qBCvLf,IAAIuB,EAAU,EAAQ,QAElBC,EAAwB,EAAQ,QAUpC9d,EAAOC,QARP,SAAoCkN,EAAMsB,GACxC,OAAIA,GAA2B,WAAlBoP,EAAQpP,IAAsC,oBAATA,EAI3CqP,EAAsB3Q,GAHpBsB,I,mECNX,IAYA,EAZA,YAWIsP,GADgB5W,SAApB,MACA,GAGA,SAAS6W,EAASC,GAChB,GACEC,K,UA2CYlW,YAEdkW,IAGA,IAGAH,MAEA,IAAAI,QAAA,IACA,IAAAC,QAAA,IACA,IAAAC,QAAA,IACA,IAAAC,QAAA,IACA,IAAAC,SAAA,M,sBCzEF,aACA,WACE,IAAIC,EAAgBC,EAAQC,EAAUC,EAAgBC,EAAcC,EAExC,qBAAhBnU,aAA+C,OAAhBA,aAAyBA,YAAYoN,IAC9E9X,EAAOC,QAAU,WACf,OAAOyK,YAAYoN,OAEQ,qBAAZlS,GAAuC,OAAZA,GAAqBA,EAAQ6Y,QACzEze,EAAOC,QAAU,WACf,OAAQue,IAAmBI,GAAgB,KAE7CH,EAAS7Y,EAAQ6Y,OAMjBE,GALAH,EAAiB,WACf,IAAIM,EAEJ,OAAe,KADfA,EAAKL,KACK,GAAWK,EAAG,OAG1BD,EAA4B,IAAnBjZ,EAAQmZ,SACjBH,EAAeD,EAAiBE,GACvB3W,KAAK4P,KACd9X,EAAOC,QAAU,WACf,OAAOiI,KAAK4P,MAAQ4G,GAEtBA,EAAWxW,KAAK4P,QAEhB9X,EAAOC,QAAU,WACf,OAAO,IAAIiI,MAAO8W,UAAYN,GAEhCA,GAAW,IAAIxW,MAAO8W,aAGvBvQ,KAAK9Q,Q,wDChCR,IAAIshB,EAAI,EAAQ,QACZrgB,EAAS,EAAQ,QACjBsgB,EAAW,EAAQ,QACnBC,EAAW,EAAQ,QACnBC,EAAyB,EAAQ,QACjCpD,EAAU,EAAQ,QAClBD,EAAa,EAAQ,QACrB9Z,EAAW,EAAQ,QACnB7B,EAAQ,EAAQ,QAChBif,EAA8B,EAAQ,QACtCC,EAAiB,EAAQ,QACzBC,EAAoB,EAAQ,QAEhCvf,EAAOC,QAAU,SAAUqc,EAAkBD,EAASmD,GACpD,IAAIjD,GAA8C,IAArCD,EAAiB5C,QAAQ,OAClC+F,GAAgD,IAAtCnD,EAAiB5C,QAAQ,QACnC8C,EAAQD,EAAS,MAAQ,MACzBmD,EAAoB9gB,EAAO0d,GAC3BqD,EAAkBD,GAAqBA,EAAkB3iB,UACzD2Q,EAAcgS,EACdE,EAAW,GAEXC,EAAY,SAAUC,GACxB,IAAIC,EAAeJ,EAAgBG,GACnCX,EAASQ,EAAiBG,EACjB,OAAPA,EAAe,SAAave,GAE1B,OADAwe,EAAatR,KAAK9Q,KAAgB,IAAV4D,EAAc,EAAIA,GACnC5D,MACE,UAAPmiB,EAAkB,SAAUhS,GAC9B,QAAO2R,IAAYxd,EAAS6L,KAAeiS,EAAatR,KAAK9Q,KAAc,IAARmQ,EAAY,EAAIA,IAC1E,OAAPgS,EAAe,SAAahS,GAC9B,OAAO2R,IAAYxd,EAAS6L,QAAOxM,EAAYye,EAAatR,KAAK9Q,KAAc,IAARmQ,EAAY,EAAIA,IAC9E,OAAPgS,EAAe,SAAahS,GAC9B,QAAO2R,IAAYxd,EAAS6L,KAAeiS,EAAatR,KAAK9Q,KAAc,IAARmQ,EAAY,EAAIA,IACjF,SAAaA,EAAKvM,GAEpB,OADAwe,EAAatR,KAAK9Q,KAAc,IAARmQ,EAAY,EAAIA,EAAKvM,GACtC5D,QAMb,GAAIuhB,EAAS5C,EAA8C,mBAArBoD,KAAqCD,GAAWE,EAAgBvI,UAAYhX,GAAM,YACtH,IAAIsf,GAAoBtX,UAAU8U,YAGlCxP,EAAc8R,EAAOpD,eAAeC,EAASC,EAAkBC,EAAQC,GACvE4C,EAAuBvc,UAAW,OAC7B,GAAIqc,EAAS5C,GAAkB,GAAO,CAC3C,IAAI7O,EAAW,IAAIC,EAEfsS,EAAiBvS,EAAS+O,GAAOiD,EAAU,IAAM,EAAG,IAAMhS,EAE1DwS,EAAuB7f,GAAM,WAAcqN,EAAS/N,IAAI,MAGxDwgB,EAAmBb,GAA4B,SAAU1C,GAAY,IAAI+C,EAAkB/C,MAE3FwD,GAAcV,GAAWrf,GAAM,WAIjC,IAFA,IAAIggB,EAAY,IAAIV,EAChBve,EAAQ,EACLA,KAASif,EAAU5D,GAAOrb,EAAOA,GACxC,OAAQif,EAAU1gB,KAAK,MAGpBwgB,KACHxS,EAAc2O,GAAQ,SAAUgE,EAAO1D,GACrCZ,EAAWsE,EAAO3S,EAAa4O,GAC/B,IAAII,EAAO6C,EAAkB,IAAIG,EAAqBW,EAAO3S,GAE7D,YADgBpM,GAAZqb,GAAuBX,EAAQW,EAAUD,EAAKF,GAAQE,EAAMH,GACzDG,MAEG3f,UAAY4iB,EACxBA,EAAgBlhB,YAAciP,IAG5BuS,GAAwBE,KAC1BN,EAAU,UACVA,EAAU,OACVtD,GAAUsD,EAAU,SAGlBM,GAAcH,IAAgBH,EAAUrD,GAGxCiD,GAAWE,EAAgBvC,cAAcuC,EAAgBvC,MAU/D,OAPAwC,EAAStD,GAAoB5O,EAC7BuR,EAAE,CAAErgB,QAAQ,EAAM0hB,OAAQ5S,GAAegS,GAAqBE,GAE9DN,EAAe5R,EAAa4O,GAEvBmD,GAASD,EAAO/B,UAAU/P,EAAa4O,EAAkBC,GAEvD7O,I,kCChGT,IAAIuR,EAAI,EAAQ,QACZsB,EAA4B,EAAQ,QACpCrgB,EAAiB,EAAQ,QACzBwB,EAAiB,EAAQ,QACzB4d,EAAiB,EAAQ,QACzBvgB,EAA8B,EAAQ,QACtCogB,EAAW,EAAQ,QACnBngB,EAAkB,EAAQ,QAC1BwhB,EAAU,EAAQ,QAClBhgB,EAAY,EAAQ,QACpBigB,EAAgB,EAAQ,QAExBC,EAAoBD,EAAcC,kBAClCC,EAAyBF,EAAcE,uBACvC1hB,EAAWD,EAAgB,YAK3B4hB,EAAa,WAAc,OAAOjjB,MAEtCqC,EAAOC,QAAU,SAAU4gB,EAAUC,EAAMC,EAAqB7D,EAAM8D,EAASC,EAAQC,GACrFX,EAA0BQ,EAAqBD,EAAM5D,GAErD,IAkBIiE,EAA0BC,EAAStB,EAlBnCuB,EAAqB,SAAUC,GACjC,GAAIA,IAASN,GAAWO,EAAiB,OAAOA,EAChD,IAAKZ,GAA0BW,KAAQE,EAAmB,OAAOA,EAAkBF,GACnF,OAAQA,GACN,IAbK,OAcL,IAbO,SAcP,IAbQ,UAaM,OAAO,WAAqB,OAAO,IAAIP,EAAoBpjB,KAAM2jB,IAC/E,OAAO,WAAc,OAAO,IAAIP,EAAoBpjB,QAGpDuB,EAAgB4hB,EAAO,YACvBW,GAAwB,EACxBD,EAAoBX,EAAS9jB,UAC7B2kB,EAAiBF,EAAkBviB,IAClCuiB,EAAkB,eAClBR,GAAWQ,EAAkBR,GAC9BO,GAAmBZ,GAA0Be,GAAkBL,EAAmBL,GAClFW,EAA4B,SAARb,GAAkBU,EAAkBpZ,SAA4BsZ,EAiCxF,GA7BIC,IACFR,EAA2BjhB,EAAeyhB,EAAkBlT,KAAK,IAAIoS,IACjEH,IAAsBrjB,OAAON,WAAaokB,EAAyBjE,OAChEsD,GAAWtgB,EAAeihB,KAA8BT,IACvDhf,EACFA,EAAeyf,EAA0BT,GACa,mBAAtCS,EAAyBliB,IACzCF,EAA4BoiB,EAA0BliB,EAAU2hB,IAIpEtB,EAAe6B,EAA0BjiB,GAAe,GAAM,GAC1DshB,IAAShgB,EAAUtB,GAAiB0hB,KAzCjC,UA8CPI,GAAqBU,GA9Cd,WA8CgCA,EAAepZ,OACxDmZ,GAAwB,EACxBF,EAAkB,WAAoB,OAAOG,EAAejT,KAAK9Q,QAI7D6iB,IAAWU,GAAWM,EAAkBviB,KAAcsiB,GAC1DxiB,EAA4ByiB,EAAmBviB,EAAUsiB,GAE3D/gB,EAAUsgB,GAAQS,EAGdP,EAMF,GALAI,EAAU,CACRhiB,OAAQiiB,EA5DD,UA6DPO,KAAMX,EAASM,EAAkBF,EA9D5B,QA+DLjZ,QAASiZ,EA7DD,YA+DNH,EAAQ,IAAKpB,KAAOsB,GAClBT,GAA0Bc,KAA2B3B,KAAO0B,KAC9DrC,EAASqC,EAAmB1B,EAAKsB,EAAQtB,SAEtCb,EAAE,CAAE/d,OAAQ4f,EAAMe,OAAO,EAAMvB,OAAQK,GAA0Bc,GAAyBL,GAGnG,OAAOA,I,kCCxFT,oE,qBCAA,EAAQ,QACR,EAAQ,QACR,EAAQ,QACR,EAAQ,QACR,IAAIpG,EAAO,EAAQ,QAEnBhb,EAAOC,QAAU+a,EAAK/O,K,kCCLtB,IAAIyU,EAAoB,EAAQ,QAA+BA,kBAC3D5e,EAAS,EAAQ,QACjBggB,EAA2B,EAAQ,QACnCxC,EAAiB,EAAQ,QACzB9e,EAAY,EAAQ,QAEpBogB,EAAa,WAAc,OAAOjjB,MAEtCqC,EAAOC,QAAU,SAAU8gB,EAAqBD,EAAM5D,GACpD,IAAIhe,EAAgB4hB,EAAO,YAI3B,OAHAC,EAAoBhkB,UAAY+E,EAAO4e,EAAmB,CAAExD,KAAM4E,EAAyB,EAAG5E,KAC9FoC,EAAeyB,EAAqB7hB,GAAe,GAAO,GAC1DsB,EAAUtB,GAAiB0hB,EACpBG,I,sBCdT,YAAA/gB,EAAA,mBAA0B,IAAIvC,EAAE,CAACskB,IAAI,SAAStkB,EAAEiR,IAAoC,SAASjR,GAAG,aAAa,IAAIiR,EAAEsT,EAAE3d,EAAE,WAAW,MAAM,GAAGrG,OAAOkK,KAAK4P,MAAM,KAAK9Z,OAAOmK,KAAK8Z,MAAM,cAAc9Z,KAAK+Z,UAAU,OAAO9M,EAAE,SAAS3X,GAAmE,MAAM,CAAC6K,KAAK7K,EAAE8D,MAAxE4N,UAAU9N,OAAO,QAAG,IAAS8N,UAAU,GAAGA,UAAU,IAAI,EAAwBgT,MAAM,EAAE/Z,QAAQ,GAAG9F,GAAG+B,IAAI+d,SAAQ,IAAKrkB,EAAE,SAASN,EAAEiR,GAAG,IAAI,GAAG2T,oBAAoBC,oBAAoBC,SAAS9kB,GAAG,CAAC,IAAIukB,EAAE,IAAIK,qBAAoB,SAAS5kB,GAAG,OAAOA,EAAE+kB,aAAankB,IAAIqQ,MAAK,OAAOsT,EAAEjO,QAAQ,CAAC9S,KAAKxD,EAAEglB,UAAS,IAAKT,GAAG,MAAMvkB,MAAMiB,GAAE,EAAGgkB,GAAE,EAAGxW,EAAE,SAASzO,GAAGiB,GAAGjB,EAAEklB,WAAWC,EAAE,WAAW9P,iBAAiB,WAAW5G,GAAG4G,iBAAiB,gBAAe,gBAAezN,EAAE,SAAS5H,GAAG,IAAIiR,EAAES,UAAU9N,OAAO,QAAG,IAAS8N,UAAU,IAAIA,UAAU,GAAGuT,IAAIE,IAAIF,GAAE,GAAI5P,iBAAiB,oBAAmB,SAASpE,GAAG,IAAIsT,EAAEtT,EAAEmU,UAAU,WAAW9e,SAAS+e,iBAAiBrlB,EAAE,CAAColB,UAAUb,EAAEe,YAAYrkB,MAAK,CAACskB,SAAQ,EAAGxS,KAAK9B,KAAKwB,EAAE,SAASzS,EAAEiR,EAAEsT,EAAE3d,GAAG,IAAI+Q,EAAE,OAAO,WAAW4M,GAAGtT,EAAE0T,SAASJ,EAAEpN,aAAalG,EAAEnN,OAAO,IAAI8C,GAAGqK,EAAE0T,SAAS,WAAWre,SAAS+e,mBAAmBpU,EAAEyT,MAAMzT,EAAEnN,OAAO6T,GAAG,IAAI1G,EAAEyT,OAAOzT,EAAE0T,cAAS,IAAShN,KAAK3X,EAAEiR,GAAG0G,EAAE1G,EAAEnN,UAAUW,EAAE,WAAW,YAAO,IAASwM,IAAIA,EAAE,WAAW3K,SAAS+e,gBAAgB,EAAE,IAAIzd,GAAE,SAAS5H,GAAG,IAAIukB,EAAEvkB,EAAEolB,UAAU,OAAOnU,EAAEsT,KAAG,IAAK,CAAC,gBAAgB,OAAOtT,KAAKuU,EAAE,WAAW,OAAOjB,IAAIA,EAAE,IAAI1jB,SAAQ,SAASb,GAAG,MAAM,CAAC,SAAS,UAAU,eAAeY,KAAI,SAASqQ,GAAGoE,iBAAiBpE,EAAEjR,EAAE,CAAC+S,MAAK,EAAG0S,SAAQ,EAAGF,SAAQ,WAAUhB,GAAGvkB,EAAE0gB,OAAO,SAAS1gB,GAAG,IAAIiR,EAAEsT,EAAE7S,UAAU9N,OAAO,QAAG,IAAS8N,UAAU,IAAIA,UAAU,GAAG9K,EAAE+Q,EAAE,MAAM,GAAG1W,EAAE,SAASjB,GAAGA,EAAE0lB,iBAAiB9e,EAAE9C,OAAO9D,EAAE8D,MAAM8C,EAAE+D,QAAQ4H,KAAKvS,GAAGiR,MAAMgU,EAAE3kB,EAAE,eAAeW,GAAGgkB,IAAIhU,EAAEwB,EAAEzS,EAAE4G,EAAEqe,EAAEV,GAAG3c,GAAE,SAAS5H,GAAG,IAAIukB,EAAEvkB,EAAEslB,YAAYL,EAAE7N,cAAcxW,IAAIK,GAAGsjB,IAAI3d,EAAE+d,SAAQ,GAAI1T,SAAQjR,EAAE4gB,OAAO,SAAS5gB,GAAG,IAAIiR,EAAEsT,EAAE5M,EAAE,OAAO/Q,EAAEnC,IAAIxD,EAAEX,EAAE,SAAQ,SAASN,GAAG,2BAA2BA,EAAE6K,MAAM7K,EAAE8K,UAAUlE,EAAEwe,YAAYb,EAAEzgB,MAAM9D,EAAE8K,UAAUyZ,EAAEI,SAAQ,EAAGJ,EAAE5Z,QAAQ4H,KAAKvS,GAAGiR,QAAOhQ,IAAIgQ,EAAEwB,EAAEzS,EAAEukB,EAAEtjB,KAAKjB,EAAE2gB,OAAO,SAAS3gB,GAAG,IAAIiR,EAAE0G,EAAE,OAAO4M,EAAE9f,IAAImC,EAAE,SAAS5G,GAAGA,EAAE8K,UAAUyZ,EAAEa,YAAYnU,EAAEnN,MAAM9D,EAAE2lB,gBAAgB3lB,EAAE8K,UAAUmG,EAAEtG,QAAQ4H,KAAKvS,GAAGiR,EAAE0T,SAAQ,EAAGM,MAAMhkB,EAAEX,EAAE,cAAcsG,GAAGqe,EAAExS,EAAEzS,EAAEiR,EAAEhQ,GAAGA,EAAE2G,GAAE,WAAW3G,EAAEmW,cAAcxW,IAAIgG,GAAG3F,EAAEkW,gBAAc,GAAI3R,OAAOogB,aAAapgB,OAAOogB,YAAYC,mBAAmBrgB,OAAOogB,YAAYC,mBAAkB,SAAS7lB,EAAE4G,GAAGA,EAAEwe,UAAUb,EAAEa,YAAYnU,EAAEnN,MAAM9D,EAAEiR,EAAE0T,SAAQ,EAAG1T,EAAEtG,QAAQ,CAAC,CAACK,UAAU,cAAcH,KAAKjE,EAAEpD,KAAKC,OAAOmD,EAAEnD,OAAOqQ,WAAWlN,EAAEkN,WAAWhJ,UAAUlE,EAAEwe,UAAUO,gBAAgB/e,EAAEwe,UAAUplB,IAAIilB,SAAQjlB,EAAE6gB,OAAO,SAAS7gB,GAAG,IAAIiR,EAAEsT,EAAE7S,UAAU9N,OAAO,QAAG,IAAS8N,UAAU,IAAIA,UAAU,GAAG9K,EAAE+Q,EAAE,OAAO1W,EAAEwD,IAAIwgB,EAAE,SAASjlB,GAAG,IAAIukB,EAAEvkB,EAAE8K,UAAUyZ,EAAEtjB,EAAEmkB,WAAWxe,EAAE9C,MAAMygB,EAAE3d,EAAE+D,QAAQ4H,KAAKvS,IAAI4G,EAAE+d,SAAQ,EAAG1T,KAAKxC,EAAEnO,EAAE,2BAA2B2kB,GAAG,GAAGxW,EAAE,CAACwC,EAAEwB,EAAEzS,EAAE4G,EAAE6H,EAAE8V,GAAG,IAAIY,EAAE,WAAWve,EAAE+d,UAAUlW,EAAE2I,cAAcxW,IAAIqkB,GAAGre,EAAE+d,SAAQ,EAAG1T,MAAMuU,IAAIzkB,KAAKokB,GAAGvd,EAAEud,GAAE,KAAMnlB,EAAE8gB,QAAQ,SAAS9gB,GAAG,IAAIiR,EAAEsT,EAAE5M,EAAE,QAAQ1G,EAAE,WAAW,IAAI,IAAIA,EAAEhE,YAAY6Y,iBAAiB,cAAc,IAAI,WAAW,IAAI9lB,EAAEiN,YAAY8Y,OAAO9U,EAAE,CAACjG,UAAU,aAAaF,UAAU,GAAG,IAAI,IAAIyZ,KAAKvkB,EAAE,oBAAoBukB,GAAG,WAAWA,IAAItT,EAAEsT,GAAG7Z,KAAKwS,IAAIld,EAAEukB,GAAGvkB,EAAEgmB,gBAAgB,IAAI,OAAO/U,EAAhL,GAAqLsT,EAAEzgB,MAAMygB,EAAEG,MAAMzT,EAAEgV,cAAc1B,EAAE5Z,QAAQ,CAACsG,GAAGsT,EAAEI,SAAQ,EAAG3kB,EAAEukB,GAAG,MAAMvkB,MAAM,aAAasG,SAAS4f,WAAW9c,WAAW6H,EAAE,GAAGoE,iBAAiB,WAAWpE,IAAIrR,OAAOC,eAAeG,EAAE,aAAa,CAAC8D,OAAM,IAA5tGygB,CAAEtT,KAAuuGA,EAAE,GAAG,SAASkV,EAAoB5B,GAAG,GAAGtT,EAAEsT,GAAI,OAAOtT,EAAEsT,GAAG/hB,QAAQ,IAAIoE,EAAEqK,EAAEsT,GAAG,CAAC/hB,QAAQ,IAAQmV,GAAE,EAAK,IAAI3X,EAAEukB,GAAGvT,KAAKpK,EAAEpE,QAAQoE,EAAEA,EAAEpE,QAAQ2jB,GAAqBxO,GAAE,EAAM,QAAWA,UAAS1G,EAAEsT,GAAG,OAAO3d,EAAEpE,QAA6C,OAArC2jB,EAAoBC,GAAGC,EAAU,IAAWF,EAAoB,KAAhkH,K,mCCAA,SAASG,IAeP,OAdA/jB,EAAOC,QAAU8jB,EAAW1mB,OAAO2mB,QAAU,SAAU9iB,GACrD,IAAK,IAAImD,EAAI,EAAGA,EAAI8K,UAAU9N,OAAQgD,IAAK,CACzC,IAAI4f,EAAS9U,UAAU9K,GAEvB,IAAK,IAAIyJ,KAAOmW,EACV5mB,OAAON,UAAUwS,eAAed,KAAKwV,EAAQnW,KAC/C5M,EAAO4M,GAAOmW,EAAOnW,IAK3B,OAAO5M,GAGF6iB,EAAS9lB,MAAMN,KAAMwR,WAG9BnP,EAAOC,QAAU8jB,G,kCCjBjB,IAaIrD,EAAmBwD,EAAmCC,EAbtDjkB,EAAiB,EAAQ,QACzBnB,EAA8B,EAAQ,QACtCW,EAAM,EAAQ,QACdV,EAAkB,EAAQ,QAC1BwhB,EAAU,EAAQ,QAElBvhB,EAAWD,EAAgB,YAC3B2hB,GAAyB,EAQzB,GAAGiB,OAGC,SAFNuC,EAAgB,GAAGvC,SAIjBsC,EAAoChkB,EAAeA,EAAeikB,OACxB9mB,OAAON,YAAW2jB,EAAoBwD,GAHlDvD,GAAyB,QAOlCrf,GAArBof,IAAgCA,EAAoB,IAGnDF,GAAY9gB,EAAIghB,EAAmBzhB,IACtCF,EAA4B2hB,EAAmBzhB,GApBhC,WAAc,OAAOtB,QAuBtCqC,EAAOC,QAAU,CACfygB,kBAAmBA,EACnBC,uBAAwBA,I,qBCnC1B,IAAIvgB,EAAQ,EAAQ,QAEpBJ,EAAOC,SAAWG,GAAM,WACtB,OAAO/C,OAAOkF,aAAalF,OAAO+mB,kBAAkB,S,sBCHtD,YAOA,IAPA,MAAU,EAAQ,QACd1L,EAAyB,qBAAXzV,OAAyBrE,EAASqE,OAChDohB,EAAU,CAAC,MAAO,UAClBC,EAAS,iBACTC,EAAM7L,EAAK,UAAY4L,GACvBE,EAAM9L,EAAK,SAAW4L,IAAW5L,EAAK,gBAAkB4L,GAEpDjgB,EAAI,GAAIkgB,GAAOlgB,EAAIggB,EAAQhjB,OAAQgD,IACzCkgB,EAAM7L,EAAK2L,EAAQhgB,GAAK,UAAYigB,GACpCE,EAAM9L,EAAK2L,EAAQhgB,GAAK,SAAWigB,IAC5B5L,EAAK2L,EAAQhgB,GAAK,gBAAkBigB,GAI7C,IAAIC,IAAQC,EAAK,CACf,IAAI3H,EAAO,EACPva,EAAK,EACLmiB,EAAQ,GAGZF,EAAM,SAASxY,GACb,GAAoB,IAAjB0Y,EAAMpjB,OAAc,CACrB,IAAIqjB,EAAO5M,IACPoF,EAAO/U,KAAKwS,IAAI,EALJ,oBAKwB+J,EAAO7H,IAC/CA,EAAOK,EAAOwH,EACd7d,YAAW,WACT,IAAI8d,EAAKF,EAAMnU,MAAM,GAIrBmU,EAAMpjB,OAAS,EACf,IAAI,IAAIgD,EAAI,EAAGA,EAAIsgB,EAAGtjB,OAAQgD,IAC5B,IAAIsgB,EAAGtgB,GAAGugB,UACR,IACED,EAAGtgB,GAAG0H,SAAS8Q,GACf,MAAMnO,GACN7H,YAAW,WAAa,MAAM6H,IAAK,MAIxCvG,KAAK0c,MAAM3H,IAOhB,OALAuH,EAAMzU,KAAK,CACT8U,SAAUxiB,EACVyJ,SAAUA,EACV6Y,WAAW,IAENtiB,GAGTkiB,EAAM,SAASM,GACb,IAAI,IAAIzgB,EAAI,EAAGA,EAAIogB,EAAMpjB,OAAQgD,IAC5BogB,EAAMpgB,GAAGygB,SAAWA,IACrBL,EAAMpgB,GAAGugB,WAAY,IAM7B5kB,EAAOC,QAAU,SAASgL,GAIxB,OAAOsZ,EAAI9V,KAAKiK,EAAMzN,IAExBjL,EAAOC,QAAQ8kB,OAAS,WACtBP,EAAIvmB,MAAMya,EAAMvJ,YAElBnP,EAAOC,QAAQkD,SAAW,SAASkM,GAC5BA,IACHA,EAASqJ,GAEXrJ,EAAO2V,sBAAwBT,EAC/BlV,EAAO4V,qBAAuBT,K,wDCzEhC,M,4BAMO,SAAmBU,GACxB5e,K,2BALa,WACb,W,uHCDF,gBAKA,eACA,YACA,YACA,eAKA,SAAS6e,EAAeC,GACtB,SAAIA,KACF,MAAM,IAAIzZ,MAAM,4CAAV,OAAN,EAAM,MAGR,YAAIyZ,EAAsBA,EACnBA,gBAAP,I,IAUmBze,E,WAQnBlI,WAAW,KAAuC,eAP1C4mB,aAO0C,OAN1CC,iBAM0C,OAJ1CC,yBAI0C,OAH1CC,8BAG0C,OAF3CC,iBAE2C,EAChD9nB,KAAA,aAAmB,aAAnB,GAEAA,KAAA,UACAA,KAAA,cAGAA,KAAA,oBAA2B,IAAIW,SAASK,YACjCsE,OAAL,eACEtE,EAASsE,OAATtE,gBAEEsE,OAAD,kBAAoC,WACnCtE,EAASsE,OAATtE,oB,gDAQJ,OAAO,IAAA+mB,0BAAA,MAA+BC,YAAD,OAAcA,EAAnD,iB,kCA2BO,SAKT,cACkD,IAAAC,kBAAlD,GAAM,EADN,EACQ3b,SAAF,EADN,EACM,QADN,EACM,OACA,GAA2B,IAAA2b,kBAAjC,GAAQ3b,SACFmb,EAAQD,EAAd,GAEMU,EAAkB7K,YACtB,IAAM8K,GAAY,cAAsB,IAAAC,WAAA,EAAtB,GAAlB,SACA,OAAO,IAAAC,aAAA,sBACU,EAAKX,SADf,OACyBS,GADzB,OACqCG,EAAM,GADlD,KAKIC,GAAqB,IAAAhf,gBAA3B,GACMif,EAAoBD,GACtB,IAAAE,eAAA,OAD+B,OAAnC,GAIA,OAAOF,EACHC,GAAqBN,EADT,GAEZA,EAFJ,K,6BAQI,GAAiC,IAE/BT,EAAQD,GADqB,IAAAS,kBAAnC,GAAQ3b,UAER,OAAOtM,KAAK4nB,oBAAL,MAAgCrZ,YAAD,OACpCA,MADF,Q,+BAKM,GACN,OAAOvO,KAAK8nB,YAAYY,UAAUjB,GAAO5mB,MAAM8nB,YAC7C,GAAI,cAAJ,EACE,MAAO,CACLzc,KAAMyc,EADD,UAELve,IAAKue,EAFA,QAGLjc,YAAaic,cAAgB5nB,YAAD,MAAQ,CAClC6nB,KAAM7nB,EAD4B,KAElC8nB,KAAM9nB,EALV,aASF,MAAM4nB,EAAN,W,+BAII,GACN,OAAO3oB,KAAK8nB,YAAYgB,SAAxB,O","file":"static/chunks/main-6a9346742e3d020f02f6.js","sourcesContent":["\"trimStart\"in String.prototype||(String.prototype.trimStart=String.prototype.trimLeft),\"trimEnd\"in String.prototype||(String.prototype.trimEnd=String.prototype.trimRight),\"description\"in Symbol.prototype||Object.defineProperty(Symbol.prototype,\"description\",{configurable:!0,get:function(){var t=/\\((.*)\\)/.exec(this.toString());return t?t[1]:void 0}}),Array.prototype.flat||(Array.prototype.flat=function(t,r){return r=this.concat.apply([],this),t>1&&r.some(Array.isArray)?r.flat(t-1):r},Array.prototype.flatMap=function(t,r){return this.map(t,r).flat()}),Promise.prototype.finally||(Promise.prototype.finally=function(t){if(\"function\"!=typeof t)return this.then(t,t);var r=this.constructor||Promise;return this.then(function(o){return r.resolve(t()).then(function(){return o})},function(o){return r.resolve(t()).then(function(){throw o})})});\n","var global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nfor (var COLLECTION_NAME in DOMIterables) {\n  var Collection = global[COLLECTION_NAME];\n  var CollectionPrototype = Collection && Collection.prototype;\n  if (CollectionPrototype) {\n    // some Chrome versions have non-configurable methods on DOMTokenList\n    if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n      createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n    } catch (error) {\n      CollectionPrototype[ITERATOR] = ArrayValues;\n    }\n    if (!CollectionPrototype[TO_STRING_TAG]) {\n      createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);\n    }\n    if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n      // some Chrome versions have non-configurable methods on DOMTokenList\n      if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n        createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n      } catch (error) {\n        CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n      }\n    }\n  }\n}\n","var has = require('../internals/has');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.github.io/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n  O = toObject(O);\n  if (has(O, IE_PROTO)) return O[IE_PROTO];\n  if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectPrototype : null;\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.github.io/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n  setInternalState(this, {\n    type: ARRAY_ITERATOR,\n    target: toIndexedObject(iterated), // target\n    index: 0,                          // next index\n    kind: kind                         // kind\n  });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n  var state = getInternalState(this);\n  var target = state.target;\n  var kind = state.kind;\n  var index = state.index++;\n  if (!target || index >= target.length) {\n    state.target = undefined;\n    return { value: undefined, done: true };\n  }\n  if (kind == 'keys') return { value: index, done: false };\n  if (kind == 'values') return { value: target[index], done: false };\n  return { value: [index, target[index]], done: false };\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","var setPrototypeOf = require(\"./setPrototypeOf\");\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits;","var hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar has = require('../internals/has');\nvar defineProperty = require('../internals/object-define-property').f;\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar isExtensible = Object.isExtensible || function () {\n  return true;\n};\n\nvar setMetadata = function (it) {\n  defineProperty(it, METADATA, { value: {\n    objectID: 'O' + ++id, // object ID\n    weakData: {}          // weak collections IDs\n  } });\n};\n\nvar fastKey = function (it, create) {\n  // return a primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!has(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMetadata(it);\n  // return object ID\n  } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n  if (!has(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMetadata(it);\n  // return the store of weak collections IDs\n  } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it);\n  return it;\n};\n\nvar meta = module.exports = {\n  REQUIRED: false,\n  fastKey: fastKey,\n  getWeakData: getWeakData,\n  onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","import initNext, * as next from './'\n\nwindow.next = next\n\ninitNext().catch(console.error)\n","require('./').polyfill()\n","const DOMAttributeNames: Record<string, string> = {\n  acceptCharset: 'accept-charset',\n  className: 'class',\n  htmlFor: 'for',\n  httpEquiv: 'http-equiv',\n}\n\nfunction reactElementToDOM({ type, props }: JSX.Element): HTMLElement {\n  const el = document.createElement(type)\n  for (const p in props) {\n    if (!props.hasOwnProperty(p)) continue\n    if (p === 'children' || p === 'dangerouslySetInnerHTML') continue\n\n    // we don't render undefined props to the DOM\n    if (props[p] === undefined) continue\n\n    const attr = DOMAttributeNames[p] || p.toLowerCase()\n    el.setAttribute(attr, props[p])\n  }\n\n  const { children, dangerouslySetInnerHTML } = props\n  if (dangerouslySetInnerHTML) {\n    el.innerHTML = dangerouslySetInnerHTML.__html || ''\n  } else if (children) {\n    el.textContent =\n      typeof children === 'string'\n        ? children\n        : Array.isArray(children)\n        ? children.join('')\n        : ''\n  }\n  return el\n}\n\nfunction updateElements(type: string, components: JSX.Element[]) {\n  const headEl = document.getElementsByTagName('head')[0]\n  const headCountEl: HTMLMetaElement = headEl.querySelector(\n    'meta[name=next-head-count]'\n  ) as HTMLMetaElement\n  if (process.env.NODE_ENV !== 'production') {\n    if (!headCountEl) {\n      console.error(\n        'Warning: next-head-count is missing. https://err.sh/next.js/next-head-count-missing'\n      )\n      return\n    }\n  }\n\n  const headCount = Number(headCountEl.content)\n  const oldTags: Element[] = []\n\n  for (\n    let i = 0, j = headCountEl.previousElementSibling;\n    i < headCount;\n    i++, j = j!.previousElementSibling\n  ) {\n    if (j!.tagName.toLowerCase() === type) {\n      oldTags.push(j!)\n    }\n  }\n  const newTags = (components.map(reactElementToDOM) as HTMLElement[]).filter(\n    (newTag) => {\n      for (let k = 0, len = oldTags.length; k < len; k++) {\n        const oldTag = oldTags[k]\n        if (oldTag.isEqualNode(newTag)) {\n          oldTags.splice(k, 1)\n          return false\n        }\n      }\n      return true\n    }\n  )\n\n  oldTags.forEach((t) => t.parentNode!.removeChild(t))\n  newTags.forEach((t) => headEl.insertBefore(t, headCountEl))\n  headCountEl.content = (headCount - oldTags.length + newTags.length).toString()\n}\n\nexport default function initHeadManager() {\n  let updatePromise: Promise<void> | null = null\n\n  return {\n    mountedInstances: new Set(),\n    updateHead: (head: JSX.Element[]) => {\n      const promise = (updatePromise = Promise.resolve().then(() => {\n        if (promise !== updatePromise) return\n\n        updatePromise = null\n        const tags: Record<string, JSX.Element[]> = {}\n\n        head.forEach((h) => {\n          const components = tags[h.type] || []\n          components.push(h)\n          tags[h.type] = components\n        })\n\n        const titleComponent = tags.title ? tags.title[0] : null\n        let title = ''\n        if (titleComponent) {\n          const { children } = titleComponent.props\n          title =\n            typeof children === 'string'\n              ? children\n              : Array.isArray(children)\n              ? children.join('')\n              : ''\n        }\n        if (title !== document.title) document.title = title\n        ;['meta', 'base', 'link', 'style', 'script'].forEach((type) => {\n          updateElements(type, tags[type] || [])\n        })\n      }))\n    },\n  }\n}\n","import React from 'react'\n\nexport const HeadManagerContext: React.Context<{\n  updateHead?: (state: any) => void\n  mountedInstances?: any\n}> = React.createContext({})\n\nif (process.env.NODE_ENV !== 'production') {\n  HeadManagerContext.displayName = 'HeadManagerContext'\n}\n","/* global location */\nimport '@next/polyfill-module'\nimport React from 'react'\nimport ReactDOM from 'react-dom'\nimport { HeadManagerContext } from '../next-server/lib/head-manager-context'\nimport mitt from '../next-server/lib/mitt'\nimport { RouterContext } from '../next-server/lib/router-context'\nimport type Router from '../next-server/lib/router/router'\nimport type {\n  AppComponent,\n  AppProps,\n  PrivateRouteInfo,\n} from '../next-server/lib/router/router'\nimport { delBasePath, hasBasePath } from '../next-server/lib/router/router'\nimport { isDynamicRoute } from '../next-server/lib/router/utils/is-dynamic'\nimport * as querystring from '../next-server/lib/router/utils/querystring'\nimport * as envConfig from '../next-server/lib/runtime-config'\nimport type { NEXT_DATA } from '../next-server/lib/utils'\nimport { getURL, loadGetInitialProps, ST } from '../next-server/lib/utils'\nimport initHeadManager from './head-manager'\nimport PageLoader, { StyleSheetTuple } from './page-loader'\nimport measureWebVitals from './performance-relayer'\nimport { createRouter, makePublicRouterInstance } from './router'\n\n/// <reference types=\"react-dom/experimental\" />\n\ndeclare let __webpack_public_path__: string\n\ndeclare global {\n  interface Window {\n    /* test fns */\n    __NEXT_HYDRATED?: boolean\n    __NEXT_HYDRATED_CB?: () => void\n\n    /* prod */\n    __NEXT_PRELOADREADY?: (ids?: string[]) => void\n    __NEXT_DATA__: NEXT_DATA\n    __NEXT_P: any[]\n  }\n}\n\ntype RenderRouteInfo = PrivateRouteInfo & { App: AppComponent }\ntype RenderErrorProps = Omit<RenderRouteInfo, 'Component' | 'styleSheets'>\n\nconst data: typeof window['__NEXT_DATA__'] = JSON.parse(\n  document.getElementById('__NEXT_DATA__')!.textContent!\n)\nwindow.__NEXT_DATA__ = data\n\nexport const version = process.env.__NEXT_VERSION\n\nconst looseToArray = <T extends {}>(input: any): T[] => [].slice.call(input)\n\nconst {\n  props: hydrateProps,\n  err: hydrateErr,\n  page,\n  query,\n  buildId,\n  assetPrefix,\n  runtimeConfig,\n  dynamicIds,\n  isFallback,\n  locales,\n} = data\n\nlet { locale, defaultLocale } = data\n\nconst prefix = assetPrefix || ''\n\n// With dynamic assetPrefix it's no longer possible to set assetPrefix at the build time\n// So, this is how we do it in the client side at runtime\n__webpack_public_path__ = `${prefix}/_next/` //eslint-disable-line\n// Initialize next/config with the environment configuration\nenvConfig.setConfig({\n  serverRuntimeConfig: {},\n  publicRuntimeConfig: runtimeConfig || {},\n})\n\nlet asPath = getURL()\n\n// make sure not to attempt stripping basePath for 404s\nif (hasBasePath(asPath)) {\n  asPath = delBasePath(asPath)\n}\n\nif (process.env.__NEXT_I18N_SUPPORT) {\n  const {\n    normalizeLocalePath,\n  } = require('../next-server/lib/i18n/normalize-locale-path') as typeof import('../next-server/lib/i18n/normalize-locale-path')\n\n  const {\n    detectDomainLocale,\n  } = require('../next-server/lib/i18n/detect-domain-locale') as typeof import('../next-server/lib/i18n/detect-domain-locale')\n\n  const {\n    parseRelativeUrl,\n  } = require('../next-server/lib/router/utils/parse-relative-url') as typeof import('../next-server/lib/router/utils/parse-relative-url')\n\n  const {\n    formatUrl,\n  } = require('../next-server/lib/router/utils/format-url') as typeof import('../next-server/lib/router/utils/format-url')\n\n  if (locales) {\n    const parsedAs = parseRelativeUrl(asPath)\n    const localePathResult = normalizeLocalePath(parsedAs.pathname, locales)\n\n    if (localePathResult.detectedLocale) {\n      parsedAs.pathname = localePathResult.pathname\n      asPath = formatUrl(parsedAs)\n    } else {\n      // derive the default locale if it wasn't detected in the asPath\n      // since we don't prerender static pages with all possible default\n      // locales\n      defaultLocale = locale\n    }\n\n    // attempt detecting default locale based on hostname\n    const detectedDomain = detectDomainLocale(\n      process.env.__NEXT_I18N_DOMAINS as any,\n      window.location.hostname\n    )\n\n    // TODO: investigate if defaultLocale needs to be populated after\n    // hydration to prevent mismatched renders\n    if (detectedDomain) {\n      defaultLocale = detectedDomain.defaultLocale\n    }\n  }\n}\n\ntype RegisterFn = (input: [string, () => void]) => void\n\nconst pageLoader = new PageLoader(buildId, prefix)\nconst register: RegisterFn = ([r, f]) =>\n  pageLoader.routeLoader.onEntrypoint(r, f)\nif (window.__NEXT_P) {\n  // Defer page registration for another tick. This will increase the overall\n  // latency in hydrating the page, but reduce the total blocking time.\n  window.__NEXT_P.map((p) => setTimeout(() => register(p), 0))\n}\nwindow.__NEXT_P = []\n;(window.__NEXT_P as any).push = register\n\nconst headManager = initHeadManager()\nconst appElement = document.getElementById('__next')\n\nlet lastAppProps: AppProps\nlet lastRenderReject: (() => void) | null\nlet webpackHMR: any\nexport let router: Router\nlet CachedComponent: React.ComponentType\nlet CachedApp: AppComponent, onPerfEntry: (metric: any) => void\n\nclass Container extends React.Component<{\n  fn: (err: Error, info?: any) => void\n}> {\n  componentDidCatch(componentErr: Error, info: any) {\n    this.props.fn(componentErr, info)\n  }\n\n  componentDidMount() {\n    this.scrollToHash()\n\n    // We need to replace the router state if:\n    // - the page was (auto) exported and has a query string or search (hash)\n    // - it was auto exported and is a dynamic route (to provide params)\n    // - if it is a client-side skeleton (fallback render)\n    if (\n      router.isSsr &&\n      (isFallback ||\n        (data.nextExport &&\n          (isDynamicRoute(router.pathname) || location.search)) ||\n        (hydrateProps && hydrateProps.__N_SSG && location.search))\n    ) {\n      // update query on mount for exported pages\n      router.replace(\n        router.pathname +\n          '?' +\n          String(\n            querystring.assign(\n              querystring.urlQueryToSearchParams(router.query),\n              new URLSearchParams(location.search)\n            )\n          ),\n        asPath,\n        {\n          // @ts-ignore\n          // WARNING: `_h` is an internal option for handing Next.js\n          // client-side hydration. Your app should _never_ use this property.\n          // It may change at any time without notice.\n          _h: 1,\n          // Fallback pages must trigger the data fetch, so the transition is\n          // not shallow.\n          // Other pages (strictly updating query) happens shallowly, as data\n          // requirements would already be present.\n          shallow: !isFallback,\n        }\n      )\n    }\n  }\n\n  componentDidUpdate() {\n    this.scrollToHash()\n  }\n\n  scrollToHash() {\n    let { hash } = location\n    hash = hash && hash.substring(1)\n    if (!hash) return\n\n    const el = document.getElementById(hash)\n    if (!el) return\n\n    // If we call scrollIntoView() in here without a setTimeout\n    // it won't scroll properly.\n    setTimeout(() => el.scrollIntoView(), 0)\n  }\n\n  render() {\n    if (process.env.NODE_ENV === 'production') {\n      return this.props.children\n    } else {\n      const { ReactDevOverlay } = require('@next/react-dev-overlay/lib/client')\n      return <ReactDevOverlay>{this.props.children}</ReactDevOverlay>\n    }\n  }\n}\n\nexport const emitter = mitt()\n\nexport default async (opts: { webpackHMR?: any } = {}) => {\n  // This makes sure this specific lines are removed in production\n  if (process.env.NODE_ENV === 'development') {\n    webpackHMR = opts.webpackHMR\n  }\n\n  const appEntrypoint = await pageLoader.routeLoader.whenEntrypoint('/_app')\n  if ('error' in appEntrypoint) {\n    throw appEntrypoint.error\n  }\n\n  const { component: app, exports: mod } = appEntrypoint\n  CachedApp = app as AppComponent\n\n  if (mod && mod.reportWebVitals) {\n    onPerfEntry = ({\n      id,\n      name,\n      startTime,\n      value,\n      duration,\n      entryType,\n      entries,\n    }) => {\n      // Combines timestamp with random number for unique ID\n      const uniqueID = `${Date.now()}-${\n        Math.floor(Math.random() * (9e12 - 1)) + 1e12\n      }`\n      let perfStartEntry\n\n      if (entries && entries.length) {\n        perfStartEntry = entries[0].startTime\n      }\n\n      mod.reportWebVitals({\n        id: id || uniqueID,\n        name,\n        startTime: startTime || perfStartEntry,\n        value: value == null ? duration : value,\n        label:\n          entryType === 'mark' || entryType === 'measure'\n            ? 'custom'\n            : 'web-vital',\n      })\n    }\n  }\n\n  let initialErr = hydrateErr\n\n  try {\n    const pageEntrypoint =\n      // The dev server fails to serve script assets when there's a hydration\n      // error, so we need to skip waiting for the entrypoint.\n      process.env.NODE_ENV === 'development' && hydrateErr\n        ? { error: hydrateErr }\n        : await pageLoader.routeLoader.whenEntrypoint(page)\n    if ('error' in pageEntrypoint) {\n      throw pageEntrypoint.error\n    }\n    CachedComponent = pageEntrypoint.component\n\n    if (process.env.NODE_ENV !== 'production') {\n      const { isValidElementType } = require('react-is')\n      if (!isValidElementType(CachedComponent)) {\n        throw new Error(\n          `The default export is not a React Component in page: \"${page}\"`\n        )\n      }\n    }\n  } catch (error) {\n    // This catches errors like throwing in the top level of a module\n    initialErr = error\n  }\n\n  if (process.env.NODE_ENV === 'development') {\n    const { getNodeError } = require('@next/react-dev-overlay/lib/client')\n    // Server-side runtime errors need to be re-thrown on the client-side so\n    // that the overlay is rendered.\n    if (initialErr) {\n      if (initialErr === hydrateErr) {\n        setTimeout(() => {\n          let error\n          try {\n            // Generate a new error object. We `throw` it because some browsers\n            // will set the `stack` when thrown, and we want to ensure ours is\n            // not overridden when we re-throw it below.\n            throw new Error(initialErr!.message)\n          } catch (e) {\n            error = e\n          }\n\n          error.name = initialErr!.name\n          error.stack = initialErr!.stack\n\n          const node = getNodeError(error)\n          throw node\n        })\n      }\n      // We replaced the server-side error with a client-side error, and should\n      // no longer rewrite the stack trace to a Node error.\n      else {\n        setTimeout(() => {\n          throw initialErr\n        })\n      }\n    }\n  }\n\n  if (window.__NEXT_PRELOADREADY) {\n    await window.__NEXT_PRELOADREADY(dynamicIds)\n  }\n\n  router = createRouter(page, query, asPath, {\n    initialProps: hydrateProps,\n    pageLoader,\n    App: CachedApp,\n    Component: CachedComponent,\n    wrapApp,\n    err: initialErr,\n    isFallback: Boolean(isFallback),\n    subscription: (info, App) => render(Object.assign({}, info, { App })),\n    locale,\n    locales,\n    defaultLocale,\n  })\n\n  // call init-client middleware\n  if (process.env.__NEXT_PLUGINS) {\n    // @ts-ignore\n    // eslint-disable-next-line\n    import('next-plugin-loader?middleware=on-init-client!')\n      .then((initClientModule) => {\n        return initClientModule.default({ router })\n      })\n      .catch((initClientErr) => {\n        console.error('Error calling client-init for plugins', initClientErr)\n      })\n  }\n\n  const renderCtx: RenderRouteInfo = {\n    App: CachedApp,\n    initial: true,\n    Component: CachedComponent,\n    props: hydrateProps,\n    err: initialErr,\n  }\n\n  if (process.env.NODE_ENV === 'production') {\n    render(renderCtx)\n    return emitter\n  } else {\n    return { emitter, render, renderCtx }\n  }\n}\n\nexport async function render(renderingProps: RenderRouteInfo) {\n  if (renderingProps.err) {\n    await renderError(renderingProps)\n    return\n  }\n\n  try {\n    await doRender(renderingProps)\n  } catch (renderErr) {\n    // bubble up cancelation errors\n    if (renderErr.cancelled) {\n      throw renderErr\n    }\n\n    if (process.env.NODE_ENV === 'development') {\n      // Ensure this error is displayed in the overlay in development\n      setTimeout(() => {\n        throw renderErr\n      })\n    }\n    await renderError({ ...renderingProps, err: renderErr })\n  }\n}\n\n// This method handles all runtime and debug errors.\n// 404 and 500 errors are special kind of errors\n// and they are still handle via the main render method.\nexport function renderError(renderErrorProps: RenderErrorProps) {\n  const { App, err } = renderErrorProps\n\n  // In development runtime errors are caught by our overlay\n  // In production we catch runtime errors using componentDidCatch which will trigger renderError\n  if (process.env.NODE_ENV !== 'production') {\n    // A Next.js rendering runtime error is always unrecoverable\n    // FIXME: let's make this recoverable (error in GIP client-transition)\n    webpackHMR.onUnrecoverableError()\n\n    // We need to render an empty <App> so that the `<ReactDevOverlay>` can\n    // render itself.\n    return doRender({\n      App: () => null,\n      props: {},\n      Component: () => null,\n      styleSheets: [],\n    })\n  }\n  if (process.env.__NEXT_PLUGINS) {\n    // @ts-ignore\n    // eslint-disable-next-line\n    import('next-plugin-loader?middleware=on-error-client!')\n      .then((onClientErrorModule) => {\n        return onClientErrorModule.default({ err })\n      })\n      .catch((onClientErrorErr) => {\n        console.error(\n          'error calling on-error-client for plugins',\n          onClientErrorErr\n        )\n      })\n  }\n\n  // Make sure we log the error to the console, otherwise users can't track down issues.\n  console.error(err)\n  return pageLoader\n    .loadPage('/_error')\n    .then(({ page: ErrorComponent, styleSheets }) => {\n      // In production we do a normal render with the `ErrorComponent` as component.\n      // If we've gotten here upon initial render, we can use the props from the server.\n      // Otherwise, we need to call `getInitialProps` on `App` before mounting.\n      const AppTree = wrapApp(App)\n      const appCtx = {\n        Component: ErrorComponent,\n        AppTree,\n        router,\n        ctx: { err, pathname: page, query, asPath, AppTree },\n      }\n      return Promise.resolve(\n        renderErrorProps.props\n          ? renderErrorProps.props\n          : loadGetInitialProps(App, appCtx)\n      ).then((initProps) =>\n        doRender({\n          ...renderErrorProps,\n          err,\n          Component: ErrorComponent,\n          styleSheets,\n          props: initProps,\n        })\n      )\n    })\n}\n\nlet reactRoot: any = null\nlet shouldUseHydrate = typeof ReactDOM.hydrate === 'function'\nfunction renderReactElement(reactEl: JSX.Element, domEl: HTMLElement) {\n  if (process.env.__NEXT_REACT_MODE !== 'legacy') {\n    if (!reactRoot) {\n      const opts = { hydrate: true }\n      reactRoot =\n        process.env.__NEXT_REACT_MODE === 'concurrent'\n          ? (ReactDOM as any).unstable_createRoot(domEl, opts)\n          : (ReactDOM as any).unstable_createBlockingRoot(domEl, opts)\n    }\n    reactRoot.render(reactEl)\n  } else {\n    // mark start of hydrate/render\n    if (ST) {\n      performance.mark('beforeRender')\n    }\n\n    // The check for `.hydrate` is there to support React alternatives like preact\n    if (shouldUseHydrate) {\n      ReactDOM.hydrate(reactEl, domEl, markHydrateComplete)\n      shouldUseHydrate = false\n    } else {\n      ReactDOM.render(reactEl, domEl, markRenderComplete)\n    }\n  }\n}\n\nfunction markHydrateComplete() {\n  if (!ST) return\n\n  performance.mark('afterHydrate') // mark end of hydration\n\n  performance.measure(\n    'Next.js-before-hydration',\n    'navigationStart',\n    'beforeRender'\n  )\n  performance.measure('Next.js-hydration', 'beforeRender', 'afterHydrate')\n\n  if (onPerfEntry) {\n    performance.getEntriesByName('Next.js-hydration').forEach(onPerfEntry)\n  }\n  clearMarks()\n}\n\nfunction markRenderComplete() {\n  if (!ST) return\n\n  performance.mark('afterRender') // mark end of render\n  const navStartEntries = performance.getEntriesByName('routeChange', 'mark')\n\n  if (!navStartEntries.length) {\n    return\n  }\n\n  performance.measure(\n    'Next.js-route-change-to-render',\n    navStartEntries[0].name,\n    'beforeRender'\n  )\n  performance.measure('Next.js-render', 'beforeRender', 'afterRender')\n  if (onPerfEntry) {\n    performance.getEntriesByName('Next.js-render').forEach(onPerfEntry)\n    performance\n      .getEntriesByName('Next.js-route-change-to-render')\n      .forEach(onPerfEntry)\n  }\n  clearMarks()\n  ;['Next.js-route-change-to-render', 'Next.js-render'].forEach((measure) =>\n    performance.clearMeasures(measure)\n  )\n}\n\nfunction clearMarks() {\n  ;[\n    'beforeRender',\n    'afterHydrate',\n    'afterRender',\n    'routeChange',\n  ].forEach((mark) => performance.clearMarks(mark))\n}\n\nfunction AppContainer({\n  children,\n}: React.PropsWithChildren<{}>): React.ReactElement {\n  return (\n    <Container\n      fn={(error) =>\n        renderError({ App: CachedApp, err: error }).catch((err) =>\n          console.error('Error rendering page: ', err)\n        )\n      }\n    >\n      <RouterContext.Provider value={makePublicRouterInstance(router)}>\n        <HeadManagerContext.Provider value={headManager}>\n          {children}\n        </HeadManagerContext.Provider>\n      </RouterContext.Provider>\n    </Container>\n  )\n}\n\nconst wrapApp = (App: AppComponent) => (\n  wrappedAppProps: Record<string, any>\n) => {\n  const appProps: AppProps = {\n    ...wrappedAppProps,\n    Component: CachedComponent,\n    err: hydrateErr,\n    router,\n  }\n  return (\n    <AppContainer>\n      <App {...appProps} />\n    </AppContainer>\n  )\n}\n\nfunction doRender(input: RenderRouteInfo): Promise<any> {\n  let { App, Component, props, err } = input\n  let styleSheets: StyleSheetTuple[] | undefined =\n    'initial' in input ? undefined : input.styleSheets\n  Component = Component || lastAppProps.Component\n  props = props || lastAppProps.props\n\n  const appProps: AppProps = {\n    ...props,\n    Component,\n    err,\n    router,\n  }\n  // lastAppProps has to be set before ReactDom.render to account for ReactDom throwing an error.\n  lastAppProps = appProps\n\n  let canceled = false\n  let resolvePromise: () => void\n  const renderPromise = new Promise((resolve, reject) => {\n    if (lastRenderReject) {\n      lastRenderReject()\n    }\n    resolvePromise = () => {\n      lastRenderReject = null\n      resolve()\n    }\n    lastRenderReject = () => {\n      canceled = true\n      lastRenderReject = null\n\n      const error: any = new Error('Cancel rendering route')\n      error.cancelled = true\n      reject(error)\n    }\n  })\n\n  // This function has a return type to ensure it doesn't start returning a\n  // Promise. It should remain synchronous.\n  function onStart(): boolean {\n    if (\n      !styleSheets ||\n      // We use `style-loader` in development, so we don't need to do anything\n      // unless we're in production:\n      process.env.NODE_ENV !== 'production'\n    ) {\n      return false\n    }\n\n    const currentStyleTags = looseToArray<HTMLStyleElement>(\n      document.querySelectorAll('style[data-n-href]')\n    )\n    const currentHrefs = new Set(\n      currentStyleTags.map((tag) => tag.getAttribute('data-n-href'))\n    )\n\n    const noscript = document.querySelector('noscript[data-n-css]')\n    const nonce = noscript?.getAttribute('data-n-css')\n\n    styleSheets.forEach(({ href, text }) => {\n      if (!currentHrefs.has(href)) {\n        const styleTag = document.createElement('style')\n        styleTag.setAttribute('data-n-href', href)\n        styleTag.setAttribute('media', 'x')\n\n        if (nonce) {\n          styleTag.setAttribute('nonce', nonce)\n        }\n\n        document.head.appendChild(styleTag)\n        styleTag.appendChild(document.createTextNode(text))\n      }\n    })\n    return true\n  }\n\n  function onHeadCommit() {\n    if (\n      // We use `style-loader` in development, so we don't need to do anything\n      // unless we're in production:\n      process.env.NODE_ENV === 'production' &&\n      // We can skip this during hydration. Running it wont cause any harm, but\n      // we may as well save the CPU cycles:\n      styleSheets &&\n      // Ensure this render was not canceled\n      !canceled\n    ) {\n      const desiredHrefs = new Set(styleSheets.map((s) => s.href))\n      const currentStyleTags = looseToArray<HTMLStyleElement>(\n        document.querySelectorAll('style[data-n-href]')\n      )\n      const currentHrefs = currentStyleTags.map(\n        (tag) => tag.getAttribute('data-n-href')!\n      )\n\n      // Toggle `<style>` tags on or off depending on if they're needed:\n      for (let idx = 0; idx < currentHrefs.length; ++idx) {\n        if (desiredHrefs.has(currentHrefs[idx])) {\n          currentStyleTags[idx].removeAttribute('media')\n        } else {\n          currentStyleTags[idx].setAttribute('media', 'x')\n        }\n      }\n\n      // Reorder styles into intended order:\n      let referenceNode = document.querySelector('noscript[data-n-css]')\n      if (\n        // This should be an invariant:\n        referenceNode\n      ) {\n        styleSheets.forEach(({ href }) => {\n          const targetTag = document.querySelector(\n            `style[data-n-href=\"${href}\"]`\n          )\n          if (\n            // This should be an invariant:\n            targetTag\n          ) {\n            referenceNode!.parentNode!.insertBefore(\n              targetTag,\n              referenceNode!.nextSibling\n            )\n            referenceNode = targetTag\n          }\n        })\n      }\n\n      // Finally, clean up server rendered stylesheets:\n      looseToArray<HTMLLinkElement>(\n        document.querySelectorAll('link[data-n-p]')\n      ).forEach((el) => {\n        el.parentNode!.removeChild(el)\n      })\n\n      // Force browser to recompute layout, which should prevent a flash of\n      // unstyled content:\n      getComputedStyle(document.body, 'height')\n    }\n  }\n\n  function onRootCommit() {\n    resolvePromise()\n  }\n\n  const elem = (\n    <Root callback={onRootCommit}>\n      <Head callback={onHeadCommit} />\n      <AppContainer>\n        <App {...appProps} />\n      </AppContainer>\n    </Root>\n  )\n\n  onStart()\n\n  // We catch runtime errors using componentDidCatch which will trigger renderError\n  renderReactElement(\n    process.env.__NEXT_STRICT_MODE ? (\n      <React.StrictMode>{elem}</React.StrictMode>\n    ) : (\n      elem\n    ),\n    appElement!\n  )\n\n  return renderPromise\n}\n\nfunction Root({\n  callback,\n  children,\n}: React.PropsWithChildren<{\n  callback: () => void\n}>): React.ReactElement {\n  // We use `useLayoutEffect` to guarantee the callback is executed\n  // as soon as React flushes the update.\n  React.useLayoutEffect(() => callback(), [callback])\n  if (process.env.__NEXT_TEST_MODE) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      window.__NEXT_HYDRATED = true\n\n      if (window.__NEXT_HYDRATED_CB) {\n        window.__NEXT_HYDRATED_CB()\n      }\n    }, [])\n  }\n  // We should ask to measure the Web Vitals after rendering completes so we\n  // don't cause any hydration delay:\n  React.useEffect(() => {\n    measureWebVitals(onPerfEntry)\n  }, [])\n  return children as React.ReactElement\n}\n\n// Dummy component that we render as a child of Root so that we can\n// toggle the correct styles before the page is rendered.\nfunction Head({ callback }: { callback: () => void }) {\n  // We use `useLayoutEffect` to guarantee the callback is executed\n  // as soon as React flushes the update.\n  React.useLayoutEffect(() => callback(), [callback])\n  return null\n}\n","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nmodule.exports = _getPrototypeOf;","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized;","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n  setInternalState(this, {\n    type: STRING_ITERATOR,\n    string: String(iterated),\n    index: 0\n  });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n  var state = getInternalState(this);\n  var string = state.string;\n  var index = state.index;\n  var point;\n  if (index >= string.length) return { value: undefined, done: true };\n  point = charAt(string, index);\n  state.index += point.length;\n  return { value: point, done: false };\n});\n","(function (factory) {\n  typeof define === 'function' && define.amd ? define(factory) :\n  factory();\n}((function () { 'use strict';\n\n  function _classCallCheck(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n      throw new TypeError(\"Cannot call a class as a function\");\n    }\n  }\n\n  function _defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  function _createClass(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n  }\n\n  function _inherits(subClass, superClass) {\n    if (typeof superClass !== \"function\" && superClass !== null) {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n\n    subClass.prototype = Object.create(superClass && superClass.prototype, {\n      constructor: {\n        value: subClass,\n        writable: true,\n        configurable: true\n      }\n    });\n    if (superClass) _setPrototypeOf(subClass, superClass);\n  }\n\n  function _getPrototypeOf(o) {\n    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n      return o.__proto__ || Object.getPrototypeOf(o);\n    };\n    return _getPrototypeOf(o);\n  }\n\n  function _setPrototypeOf(o, p) {\n    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n      o.__proto__ = p;\n      return o;\n    };\n\n    return _setPrototypeOf(o, p);\n  }\n\n  function _isNativeReflectConstruct() {\n    if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n    if (Reflect.construct.sham) return false;\n    if (typeof Proxy === \"function\") return true;\n\n    try {\n      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  function _assertThisInitialized(self) {\n    if (self === void 0) {\n      throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n    }\n\n    return self;\n  }\n\n  function _possibleConstructorReturn(self, call) {\n    if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n      return call;\n    }\n\n    return _assertThisInitialized(self);\n  }\n\n  function _createSuper(Derived) {\n    var hasNativeReflectConstruct = _isNativeReflectConstruct();\n\n    return function _createSuperInternal() {\n      var Super = _getPrototypeOf(Derived),\n          result;\n\n      if (hasNativeReflectConstruct) {\n        var NewTarget = _getPrototypeOf(this).constructor;\n\n        result = Reflect.construct(Super, arguments, NewTarget);\n      } else {\n        result = Super.apply(this, arguments);\n      }\n\n      return _possibleConstructorReturn(this, result);\n    };\n  }\n\n  function _superPropBase(object, property) {\n    while (!Object.prototype.hasOwnProperty.call(object, property)) {\n      object = _getPrototypeOf(object);\n      if (object === null) break;\n    }\n\n    return object;\n  }\n\n  function _get(target, property, receiver) {\n    if (typeof Reflect !== \"undefined\" && Reflect.get) {\n      _get = Reflect.get;\n    } else {\n      _get = function _get(target, property, receiver) {\n        var base = _superPropBase(target, property);\n\n        if (!base) return;\n        var desc = Object.getOwnPropertyDescriptor(base, property);\n\n        if (desc.get) {\n          return desc.get.call(receiver);\n        }\n\n        return desc.value;\n      };\n    }\n\n    return _get(target, property, receiver || target);\n  }\n\n  var Emitter = /*#__PURE__*/function () {\n    function Emitter() {\n      _classCallCheck(this, Emitter);\n\n      Object.defineProperty(this, 'listeners', {\n        value: {},\n        writable: true,\n        configurable: true\n      });\n    }\n\n    _createClass(Emitter, [{\n      key: \"addEventListener\",\n      value: function addEventListener(type, callback, options) {\n        if (!(type in this.listeners)) {\n          this.listeners[type] = [];\n        }\n\n        this.listeners[type].push({\n          callback: callback,\n          options: options\n        });\n      }\n    }, {\n      key: \"removeEventListener\",\n      value: function removeEventListener(type, callback) {\n        if (!(type in this.listeners)) {\n          return;\n        }\n\n        var stack = this.listeners[type];\n\n        for (var i = 0, l = stack.length; i < l; i++) {\n          if (stack[i].callback === callback) {\n            stack.splice(i, 1);\n            return;\n          }\n        }\n      }\n    }, {\n      key: \"dispatchEvent\",\n      value: function dispatchEvent(event) {\n        if (!(event.type in this.listeners)) {\n          return;\n        }\n\n        var stack = this.listeners[event.type];\n        var stackToCall = stack.slice();\n\n        for (var i = 0, l = stackToCall.length; i < l; i++) {\n          var listener = stackToCall[i];\n\n          try {\n            listener.callback.call(this, event);\n          } catch (e) {\n            Promise.resolve().then(function () {\n              throw e;\n            });\n          }\n\n          if (listener.options && listener.options.once) {\n            this.removeEventListener(event.type, listener.callback);\n          }\n        }\n\n        return !event.defaultPrevented;\n      }\n    }]);\n\n    return Emitter;\n  }();\n\n  var AbortSignal = /*#__PURE__*/function (_Emitter) {\n    _inherits(AbortSignal, _Emitter);\n\n    var _super = _createSuper(AbortSignal);\n\n    function AbortSignal() {\n      var _this;\n\n      _classCallCheck(this, AbortSignal);\n\n      _this = _super.call(this); // Some versions of babel does not transpile super() correctly for IE <= 10, if the parent\n      // constructor has failed to run, then \"this.listeners\" will still be undefined and then we call\n      // the parent constructor directly instead as a workaround. For general details, see babel bug:\n      // https://github.com/babel/babel/issues/3041\n      // This hack was added as a fix for the issue described here:\n      // https://github.com/Financial-Times/polyfill-library/pull/59#issuecomment-477558042\n\n      if (!_this.listeners) {\n        Emitter.call(_assertThisInitialized(_this));\n      } // Compared to assignment, Object.defineProperty makes properties non-enumerable by default and\n      // we want Object.keys(new AbortController().signal) to be [] for compat with the native impl\n\n\n      Object.defineProperty(_assertThisInitialized(_this), 'aborted', {\n        value: false,\n        writable: true,\n        configurable: true\n      });\n      Object.defineProperty(_assertThisInitialized(_this), 'onabort', {\n        value: null,\n        writable: true,\n        configurable: true\n      });\n      return _this;\n    }\n\n    _createClass(AbortSignal, [{\n      key: \"toString\",\n      value: function toString() {\n        return '[object AbortSignal]';\n      }\n    }, {\n      key: \"dispatchEvent\",\n      value: function dispatchEvent(event) {\n        if (event.type === 'abort') {\n          this.aborted = true;\n\n          if (typeof this.onabort === 'function') {\n            this.onabort.call(this, event);\n          }\n        }\n\n        _get(_getPrototypeOf(AbortSignal.prototype), \"dispatchEvent\", this).call(this, event);\n      }\n    }]);\n\n    return AbortSignal;\n  }(Emitter);\n  var AbortController = /*#__PURE__*/function () {\n    function AbortController() {\n      _classCallCheck(this, AbortController);\n\n      // Compared to assignment, Object.defineProperty makes properties non-enumerable by default and\n      // we want Object.keys(new AbortController()) to be [] for compat with the native impl\n      Object.defineProperty(this, 'signal', {\n        value: new AbortSignal(),\n        writable: true,\n        configurable: true\n      });\n    }\n\n    _createClass(AbortController, [{\n      key: \"abort\",\n      value: function abort() {\n        var event;\n\n        try {\n          event = new Event('abort');\n        } catch (e) {\n          if (typeof document !== 'undefined') {\n            if (!document.createEvent) {\n              // For Internet Explorer 8:\n              event = document.createEventObject();\n              event.type = 'abort';\n            } else {\n              // For Internet Explorer 11:\n              event = document.createEvent('Event');\n              event.initEvent('abort', false, false);\n            }\n          } else {\n            // Fallback where document isn't available:\n            event = {\n              type: 'abort',\n              bubbles: false,\n              cancelable: false\n            };\n          }\n        }\n\n        this.signal.dispatchEvent(event);\n      }\n    }, {\n      key: \"toString\",\n      value: function toString() {\n        return '[object AbortController]';\n      }\n    }]);\n\n    return AbortController;\n  }();\n\n  if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n    // These are necessary to make sure that we get correct output for:\n    // Object.prototype.toString.call(new AbortController())\n    AbortController.prototype[Symbol.toStringTag] = 'AbortController';\n    AbortSignal.prototype[Symbol.toStringTag] = 'AbortSignal';\n  }\n\n  function polyfillNeeded(self) {\n    if (self.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL) {\n      console.log('__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL=true is set, will force install polyfill');\n      return true;\n    } // Note that the \"unfetch\" minimal fetch polyfill defines fetch() without\n    // defining window.Request, and this polyfill need to work on top of unfetch\n    // so the below feature detection needs the !self.AbortController part.\n    // The Request.prototype check is also needed because Safari versions 11.1.2\n    // up to and including 12.1.x has a window.AbortController present but still\n    // does NOT correctly implement abortable fetch:\n    // https://bugs.webkit.org/show_bug.cgi?id=174980#c2\n\n\n    return typeof self.Request === 'function' && !self.Request.prototype.hasOwnProperty('signal') || !self.AbortController;\n  }\n\n  /**\n   * Note: the \"fetch.Request\" default value is available for fetch imported from\n   * the \"node-fetch\" package and not in browsers. This is OK since browsers\n   * will be importing umd-polyfill.js from that path \"self\" is passed the\n   * decorator so the default value will not be used (because browsers that define\n   * fetch also has Request). One quirky setup where self.fetch exists but\n   * self.Request does not is when the \"unfetch\" minimal fetch polyfill is used\n   * on top of IE11; for this case the browser will try to use the fetch.Request\n   * default value which in turn will be undefined but then then \"if (Request)\"\n   * will ensure that you get a patched fetch but still no Request (as expected).\n   * @param {fetch, Request = fetch.Request}\n   * @returns {fetch: abortableFetch, Request: AbortableRequest}\n   */\n\n  function abortableFetchDecorator(patchTargets) {\n    if ('function' === typeof patchTargets) {\n      patchTargets = {\n        fetch: patchTargets\n      };\n    }\n\n    var _patchTargets = patchTargets,\n        fetch = _patchTargets.fetch,\n        _patchTargets$Request = _patchTargets.Request,\n        NativeRequest = _patchTargets$Request === void 0 ? fetch.Request : _patchTargets$Request,\n        NativeAbortController = _patchTargets.AbortController,\n        _patchTargets$__FORCE = _patchTargets.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL,\n        __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL = _patchTargets$__FORCE === void 0 ? false : _patchTargets$__FORCE;\n\n    if (!polyfillNeeded({\n      fetch: fetch,\n      Request: NativeRequest,\n      AbortController: NativeAbortController,\n      __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL: __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL\n    })) {\n      return {\n        fetch: fetch,\n        Request: Request\n      };\n    }\n\n    var Request = NativeRequest; // Note that the \"unfetch\" minimal fetch polyfill defines fetch() without\n    // defining window.Request, and this polyfill need to work on top of unfetch\n    // hence we only patch it if it's available. Also we don't patch it if signal\n    // is already available on the Request prototype because in this case support\n    // is present and the patching below can cause a crash since it assigns to\n    // request.signal which is technically a read-only property. This latter error\n    // happens when you run the main5.js node-fetch example in the repo\n    // \"abortcontroller-polyfill-examples\". The exact error is:\n    //   request.signal = init.signal;\n    //   ^\n    // TypeError: Cannot set property signal of #<Request> which has only a getter\n\n    if (Request && !Request.prototype.hasOwnProperty('signal') || __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL) {\n      Request = function Request(input, init) {\n        var signal;\n\n        if (init && init.signal) {\n          signal = init.signal; // Never pass init.signal to the native Request implementation when the polyfill has\n          // been installed because if we're running on top of a browser with a\n          // working native AbortController (i.e. the polyfill was installed due to\n          // __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL being set), then passing our\n          // fake AbortSignal to the native fetch will trigger:\n          // TypeError: Failed to construct 'Request': member signal is not of type AbortSignal.\n\n          delete init.signal;\n        }\n\n        var request = new NativeRequest(input, init);\n\n        if (signal) {\n          Object.defineProperty(request, 'signal', {\n            writable: false,\n            enumerable: false,\n            configurable: true,\n            value: signal\n          });\n        }\n\n        return request;\n      };\n\n      Request.prototype = NativeRequest.prototype;\n    }\n\n    var realFetch = fetch;\n\n    var abortableFetch = function abortableFetch(input, init) {\n      var signal = Request && Request.prototype.isPrototypeOf(input) ? input.signal : init ? init.signal : undefined;\n\n      if (signal) {\n        var abortError;\n\n        try {\n          abortError = new DOMException('Aborted', 'AbortError');\n        } catch (err) {\n          // IE 11 does not support calling the DOMException constructor, use a\n          // regular error object on it instead.\n          abortError = new Error('Aborted');\n          abortError.name = 'AbortError';\n        } // Return early if already aborted, thus avoiding making an HTTP request\n\n\n        if (signal.aborted) {\n          return Promise.reject(abortError);\n        } // Turn an event into a promise, reject it once `abort` is dispatched\n\n\n        var cancellation = new Promise(function (_, reject) {\n          signal.addEventListener('abort', function () {\n            return reject(abortError);\n          }, {\n            once: true\n          });\n        });\n\n        if (init && init.signal) {\n          // Never pass .signal to the native implementation when the polyfill has\n          // been installed because if we're running on top of a browser with a\n          // working native AbortController (i.e. the polyfill was installed due to\n          // __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL being set), then passing our\n          // fake AbortSignal to the native fetch will trigger:\n          // TypeError: Failed to execute 'fetch' on 'Window': member signal is not of type AbortSignal.\n          delete init.signal;\n        } // Return the fastest promise (don't need to wait for request to finish)\n\n\n        return Promise.race([cancellation, realFetch(input, init)]);\n      }\n\n      return realFetch(input, init);\n    };\n\n    return {\n      fetch: abortableFetch,\n      Request: Request\n    };\n  }\n\n  (function (self) {\n\n    if (!polyfillNeeded(self)) {\n      return;\n    }\n\n    if (!self.fetch) {\n      console.warn('fetch() is not available, cannot install abortcontroller-polyfill');\n      return;\n    }\n\n    var _abortableFetch = abortableFetchDecorator(self),\n        fetch = _abortableFetch.fetch,\n        Request = _abortableFetch.Request;\n\n    self.fetch = fetch;\n    self.Request = Request;\n    Object.defineProperty(self, 'AbortController', {\n      writable: true,\n      enumerable: false,\n      configurable: true,\n      value: AbortController\n    });\n    Object.defineProperty(self, 'AbortSignal', {\n      writable: true,\n      enumerable: false,\n      configurable: true,\n      value: AbortSignal\n    });\n  })(typeof self !== 'undefined' ? self : global);\n\n})));\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.github.io/ecma262/#sec-map-objects\nmodule.exports = collection('Map', function (init) {\n  return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n\n(function(window, document) {\n'use strict';\n\n\n// Exits early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observing a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = entry.rootBounds;\n  this.boundingClientRect = entry.boundingClientRect;\n  this.intersectionRect = entry.intersectionRect || getEmptyRect();\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    // Round the intersection ratio to avoid floating point math issues:\n    // https://github.com/w3c/IntersectionObserver/issues/324\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (options.root && options.root.nodeType != 1) {\n    throw new Error('root must be an Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections();\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n\n    return item.element != target;\n  });\n  if (!this._observationTargets.length) {\n    this._unmonitorIntersections();\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibility state is visible.\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function() {\n  if (!this._monitoringIntersections) {\n    this._monitoringIntersections = true;\n\n    // If a poll interval is set, use polling instead of listening to\n    // resize and scroll events or DOM mutations.\n    if (this.POLL_INTERVAL) {\n      this._monitoringInterval = setInterval(\n          this._checkForIntersections, this.POLL_INTERVAL);\n    }\n    else {\n      addEvent(window, 'resize', this._checkForIntersections, true);\n      addEvent(document, 'scroll', this._checkForIntersections, true);\n\n      if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in window) {\n        this._domObserver = new MutationObserver(this._checkForIntersections);\n        this._domObserver.observe(document, {\n          attributes: true,\n          childList: true,\n          characterData: true,\n          subtree: true\n        });\n      }\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function() {\n  if (this._monitoringIntersections) {\n    this._monitoringIntersections = false;\n\n    clearInterval(this._monitoringInterval);\n    this._monitoringInterval = null;\n\n    removeEvent(window, 'resize', this._checkForIntersections, true);\n    removeEvent(document, 'scroll', this._checkForIntersections, true);\n\n    if (this._domObserver) {\n      this._domObserver.disconnect();\n      this._domObserver = null;\n    }\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, rootRect);\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootRect,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, rootRect) {\n\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var targetRect = getBoundingClientRect(target);\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return;\n\n    if (parent == this.root || parent == document) {\n      atRoot = true;\n      parentRect = rootRect;\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      if (parent != document.body &&\n          parent != document.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n\n      if (!intersectionRect) break;\n    }\n    parent = getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {Object} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var html = document.documentElement;\n    var body = document.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {Object} rect The rect object to expand.\n * @return {Object} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  return containsDeep(this.root || document, target);\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its execution, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detatchEvent == 'function') {\n    node.detatchEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object} The intersection rect or undefined if no intersection\n *     is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  };\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {Object} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {Object} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n/**\n * Checks to see if a parent element contains a child element (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n  return parent;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}(window, document));\n","require('../../modules/es.map');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nrequire('../../modules/web.dom-collections.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Map;\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Set` constructor\n// https://tc39.github.io/ecma262/#sec-set-objects\nmodule.exports = collection('Set', function (init) {\n  return function Set() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","// From https://developer.mozilla.org/en-US/docs/Web/API/ChildNode/replaceWith\nfunction ReplaceWithPolyfill() {\n  \"use-strict\"; // For safari, and IE > 10\n  var parent = this.parentNode,\n    i = arguments.length,\n    currentNode;\n  if (!parent) return;\n  if (!i)\n    // if there are no arguments\n    parent.removeChild(this);\n  while (i--) {\n    // i-- decrements i and returns the value of i before the decrement\n    currentNode = arguments[i];\n    if (typeof currentNode !== \"object\") {\n      currentNode = this.ownerDocument.createTextNode(currentNode);\n    } else if (currentNode.parentNode) {\n      currentNode.parentNode.removeChild(currentNode);\n    }\n    // the value of \"i\" below is after the decrement\n    if (!i)\n      // if currentNode is the first argument (currentNode === arguments[0])\n      parent.replaceChild(currentNode, this);\n    // if currentNode isn't the first\n    else parent.insertBefore(this.previousSibling, currentNode);\n  }\n}\n\nif (!Element.prototype.replaceWith)\n  Element.prototype.replaceWith = ReplaceWithPolyfill;\nif (!CharacterData.prototype.replaceWith)\n  CharacterData.prototype.replaceWith = ReplaceWithPolyfill;\nif (!DocumentType.prototype.replaceWith)\n  DocumentType.prototype.replaceWith = ReplaceWithPolyfill;\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar create = require('../internals/object-create');\nvar redefineAll = require('../internals/redefine-all');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/define-iterator');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n    var C = wrapper(function (that, iterable) {\n      anInstance(that, C, CONSTRUCTOR_NAME);\n      setInternalState(that, {\n        type: CONSTRUCTOR_NAME,\n        index: create(null),\n        first: undefined,\n        last: undefined,\n        size: 0\n      });\n      if (!DESCRIPTORS) that.size = 0;\n      if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP);\n    });\n\n    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n    var define = function (that, key, value) {\n      var state = getInternalState(that);\n      var entry = getEntry(that, key);\n      var previous, index;\n      // change existing entry\n      if (entry) {\n        entry.value = value;\n      // create new entry\n      } else {\n        state.last = entry = {\n          index: index = fastKey(key, true),\n          key: key,\n          value: value,\n          previous: previous = state.last,\n          next: undefined,\n          removed: false\n        };\n        if (!state.first) state.first = entry;\n        if (previous) previous.next = entry;\n        if (DESCRIPTORS) state.size++;\n        else that.size++;\n        // add to index\n        if (index !== 'F') state.index[index] = entry;\n      } return that;\n    };\n\n    var getEntry = function (that, key) {\n      var state = getInternalState(that);\n      // fast case\n      var index = fastKey(key);\n      var entry;\n      if (index !== 'F') return state.index[index];\n      // frozen object case\n      for (entry = state.first; entry; entry = entry.next) {\n        if (entry.key == key) return entry;\n      }\n    };\n\n    redefineAll(C.prototype, {\n      // 23.1.3.1 Map.prototype.clear()\n      // 23.2.3.2 Set.prototype.clear()\n      clear: function clear() {\n        var that = this;\n        var state = getInternalState(that);\n        var data = state.index;\n        var entry = state.first;\n        while (entry) {\n          entry.removed = true;\n          if (entry.previous) entry.previous = entry.previous.next = undefined;\n          delete data[entry.index];\n          entry = entry.next;\n        }\n        state.first = state.last = undefined;\n        if (DESCRIPTORS) state.size = 0;\n        else that.size = 0;\n      },\n      // 23.1.3.3 Map.prototype.delete(key)\n      // 23.2.3.4 Set.prototype.delete(value)\n      'delete': function (key) {\n        var that = this;\n        var state = getInternalState(that);\n        var entry = getEntry(that, key);\n        if (entry) {\n          var next = entry.next;\n          var prev = entry.previous;\n          delete state.index[entry.index];\n          entry.removed = true;\n          if (prev) prev.next = next;\n          if (next) next.previous = prev;\n          if (state.first == entry) state.first = next;\n          if (state.last == entry) state.last = prev;\n          if (DESCRIPTORS) state.size--;\n          else that.size--;\n        } return !!entry;\n      },\n      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)\n      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)\n      forEach: function forEach(callbackfn /* , that = undefined */) {\n        var state = getInternalState(this);\n        var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);\n        var entry;\n        while (entry = entry ? entry.next : state.first) {\n          boundFunction(entry.value, entry.key, this);\n          // revert to the last existing entry\n          while (entry && entry.removed) entry = entry.previous;\n        }\n      },\n      // 23.1.3.7 Map.prototype.has(key)\n      // 23.2.3.7 Set.prototype.has(value)\n      has: function has(key) {\n        return !!getEntry(this, key);\n      }\n    });\n\n    redefineAll(C.prototype, IS_MAP ? {\n      // 23.1.3.6 Map.prototype.get(key)\n      get: function get(key) {\n        var entry = getEntry(this, key);\n        return entry && entry.value;\n      },\n      // 23.1.3.9 Map.prototype.set(key, value)\n      set: function set(key, value) {\n        return define(this, key === 0 ? 0 : key, value);\n      }\n    } : {\n      // 23.2.3.1 Set.prototype.add(value)\n      add: function add(value) {\n        return define(this, value = value === 0 ? 0 : value, value);\n      }\n    });\n    if (DESCRIPTORS) defineProperty(C.prototype, 'size', {\n      get: function () {\n        return getInternalState(this).size;\n      }\n    });\n    return C;\n  },\n  setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) {\n    var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n    var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n    var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n    // add .keys, .values, .entries, [@@iterator]\n    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11\n    defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) {\n      setInternalState(this, {\n        type: ITERATOR_NAME,\n        target: iterated,\n        state: getInternalCollectionState(iterated),\n        kind: kind,\n        last: undefined\n      });\n    }, function () {\n      var state = getInternalIteratorState(this);\n      var kind = state.kind;\n      var entry = state.last;\n      // revert to the last existing entry\n      while (entry && entry.removed) entry = entry.previous;\n      // get next entry\n      if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n        // or finish the iteration\n        state.target = undefined;\n        return { value: undefined, done: true };\n      }\n      // return step by kind\n      if (kind == 'keys') return { value: entry.key, done: false };\n      if (kind == 'values') return { value: entry.value, done: false };\n      return { value: [entry.key, entry.value], done: false };\n    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n    // add [@@species], 23.1.2.2, 23.2.2.2\n    setSpecies(CONSTRUCTOR_NAME);\n  }\n};\n","var _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nvar assertThisInitialized = require(\"./assertThisInitialized\");\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}\n\nmodule.exports = _possibleConstructorReturn;","import {\n  getCLS,\n  getFCP,\n  getFID,\n  getLCP,\n  getTTFB,\n  Metric,\n  ReportHandler,\n} from 'next/dist/compiled/web-vitals'\n\nconst initialHref = location.href\nlet isRegistered = false\nlet userReportHandler: ReportHandler | undefined\n\nfunction onReport(metric: Metric) {\n  if (userReportHandler) {\n    userReportHandler(metric)\n  }\n\n  // This code is not shipped, executed, or present in the client-side\n  // JavaScript bundle unless explicitly enabled in your application.\n  //\n  // When this feature is enabled, we'll make it very clear by printing a\n  // message during the build (`next build`).\n  if (\n    process.env.NODE_ENV === 'production' &&\n    // This field is empty unless you explicitly configure it:\n    process.env.__NEXT_ANALYTICS_ID\n  ) {\n    const body: Record<string, string> = {\n      dsn: process.env.__NEXT_ANALYTICS_ID,\n      id: metric.id,\n      page: window.__NEXT_DATA__.page,\n      href: initialHref,\n      event_name: metric.name,\n      value: metric.value.toString(),\n      speed:\n        'connection' in navigator &&\n        navigator['connection'] &&\n        'effectiveType' in navigator['connection']\n          ? (navigator['connection']['effectiveType'] as string)\n          : '',\n    }\n\n    const blob = new Blob([new URLSearchParams(body).toString()], {\n      // This content type is necessary for `sendBeacon`:\n      type: 'application/x-www-form-urlencoded',\n    })\n    const vitalsUrl = 'https://vitals.vercel-insights.com/v1/vitals'\n    ;(navigator.sendBeacon && navigator.sendBeacon(vitalsUrl, blob)) ||\n      fetch(vitalsUrl, {\n        body: blob,\n        method: 'POST',\n        credentials: 'omit',\n        keepalive: true,\n      })\n  }\n}\n\nexport default (onPerfEntry?: ReportHandler) => {\n  // Update function if it changes:\n  userReportHandler = onPerfEntry\n\n  // Only register listeners once:\n  if (isRegistered) {\n    return\n  }\n  isRegistered = true\n\n  getCLS(onReport)\n  getFID(onReport)\n  getFCP(onReport)\n  getLCP(onReport)\n  getTTFB(onReport)\n}\n","// Generated by CoffeeScript 1.12.2\n(function() {\n  var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;\n\n  if ((typeof performance !== \"undefined\" && performance !== null) && performance.now) {\n    module.exports = function() {\n      return performance.now();\n    };\n  } else if ((typeof process !== \"undefined\" && process !== null) && process.hrtime) {\n    module.exports = function() {\n      return (getNanoSeconds() - nodeLoadTime) / 1e6;\n    };\n    hrtime = process.hrtime;\n    getNanoSeconds = function() {\n      var hr;\n      hr = hrtime();\n      return hr[0] * 1e9 + hr[1];\n    };\n    moduleLoadTime = getNanoSeconds();\n    upTime = process.uptime() * 1e9;\n    nodeLoadTime = moduleLoadTime - upTime;\n  } else if (Date.now) {\n    module.exports = function() {\n      return Date.now() - loadTime;\n    };\n    loadTime = Date.now();\n  } else {\n    module.exports = function() {\n      return new Date().getTime() - loadTime;\n    };\n    loadTime = new Date().getTime();\n  }\n\n}).call(this);\n\n//# sourceMappingURL=performance-now.js.map\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar isForced = require('../internals/is-forced');\nvar redefine = require('../internals/redefine');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n  var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n  var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n  var ADDER = IS_MAP ? 'set' : 'add';\n  var NativeConstructor = global[CONSTRUCTOR_NAME];\n  var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n  var Constructor = NativeConstructor;\n  var exported = {};\n\n  var fixMethod = function (KEY) {\n    var nativeMethod = NativePrototype[KEY];\n    redefine(NativePrototype, KEY,\n      KEY == 'add' ? function add(value) {\n        nativeMethod.call(this, value === 0 ? 0 : value);\n        return this;\n      } : KEY == 'delete' ? function (key) {\n        return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);\n      } : KEY == 'get' ? function get(key) {\n        return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key);\n      } : KEY == 'has' ? function has(key) {\n        return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);\n      } : function set(key, value) {\n        nativeMethod.call(this, key === 0 ? 0 : key, value);\n        return this;\n      }\n    );\n  };\n\n  // eslint-disable-next-line max-len\n  if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n    new NativeConstructor().entries().next();\n  })))) {\n    // create collection constructor\n    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n    InternalMetadataModule.REQUIRED = true;\n  } else if (isForced(CONSTRUCTOR_NAME, true)) {\n    var instance = new Constructor();\n    // early implementations not supports chaining\n    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n    // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n    // most early implementations doesn't supports iterables, most modern - not close it correctly\n    // eslint-disable-next-line no-new\n    var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n    // for early implementations -0 and +0 not the same\n    var BUGGY_ZERO = !IS_WEAK && fails(function () {\n      // V8 ~ Chromium 42- fails only with 5+ elements\n      var $instance = new NativeConstructor();\n      var index = 5;\n      while (index--) $instance[ADDER](index, index);\n      return !$instance.has(-0);\n    });\n\n    if (!ACCEPT_ITERABLES) {\n      Constructor = wrapper(function (dummy, iterable) {\n        anInstance(dummy, Constructor, CONSTRUCTOR_NAME);\n        var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n        if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP);\n        return that;\n      });\n      Constructor.prototype = NativePrototype;\n      NativePrototype.constructor = Constructor;\n    }\n\n    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n      fixMethod('delete');\n      fixMethod('has');\n      IS_MAP && fixMethod('get');\n    }\n\n    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n    // weak collections should not contains .clear method\n    if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n  }\n\n  exported[CONSTRUCTOR_NAME] = Constructor;\n  $({ global: true, forced: Constructor != NativeConstructor }, exported);\n\n  setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n  return Constructor;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n  createIteratorConstructor(IteratorConstructor, NAME, next);\n\n  var getIterationMethod = function (KIND) {\n    if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];\n    switch (KIND) {\n      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n    } return function () { return new IteratorConstructor(this); };\n  };\n\n  var TO_STRING_TAG = NAME + ' Iterator';\n  var INCORRECT_VALUES_NAME = false;\n  var IterablePrototype = Iterable.prototype;\n  var nativeIterator = IterablePrototype[ITERATOR]\n    || IterablePrototype['@@iterator']\n    || DEFAULT && IterablePrototype[DEFAULT];\n  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n  var CurrentIteratorPrototype, methods, KEY;\n\n  // fix native\n  if (anyNativeIterator) {\n    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n    if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n        if (setPrototypeOf) {\n          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n        } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {\n          createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);\n        }\n      }\n      // Set @@toStringTag to native iterators\n      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n      if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n    }\n  }\n\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n    INCORRECT_VALUES_NAME = true;\n    defaultIterator = function values() { return nativeIterator.call(this); };\n  }\n\n  // define iterator\n  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n    createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);\n  }\n  Iterators[NAME] = defaultIterator;\n\n  // export additional methods\n  if (DEFAULT) {\n    methods = {\n      values: getIterationMethod(VALUES),\n      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n      entries: getIterationMethod(ENTRIES)\n    };\n    if (FORCED) for (KEY in methods) {\n      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n        redefine(IterablePrototype, KEY, methods[KEY]);\n      }\n    } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n  }\n\n  return methods;\n};\n","import 'intersection-observer'\nimport 'raf/polyfill'\n// import 'core-js/features/array/from'\n// import 'core-js'\n// import 'core-js/features/set'\n// import 'core-js/features/map'\nimport 'core-js/es/set'\nimport 'core-js/es/map'\nimport 'child-replace-with-polyfill'\nimport 'abortcontroller-polyfill/dist/polyfill-patch-fetch'\n// import 'core-js/features/promise'\n","require('../../modules/es.set');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nrequire('../../modules/web.dom-collections.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Set;\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next) {\n  var TO_STRING_TAG = NAME + ' Iterator';\n  IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });\n  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n  Iterators[TO_STRING_TAG] = returnThis;\n  return IteratorConstructor;\n};\n","module.exports=function(){var t={692:function(t,e){!function(t,n){true?n(e):0}(this,function(t){\"use strict\";var e,n,i=function(){return\"\".concat(Date.now(),\"-\").concat(Math.floor(8999999999999*Math.random())+1e12)},a=function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:-1;return{name:t,value:e,delta:0,entries:[],id:i(),isFinal:!1}},r=function(t,e){try{if(PerformanceObserver.supportedEntryTypes.includes(t)){var n=new PerformanceObserver(function(t){return t.getEntries().map(e)});return n.observe({type:t,buffered:!0}),n}}catch(t){}},o=!1,u=!1,s=function(t){o=!t.persisted},c=function(){addEventListener(\"pagehide\",s),addEventListener(\"beforeunload\",function(){})},p=function(t){var e=arguments.length>1&&void 0!==arguments[1]&&arguments[1];u||(c(),u=!0),addEventListener(\"visibilitychange\",function(e){var n=e.timeStamp;\"hidden\"===document.visibilityState&&t({timeStamp:n,isUnloading:o})},{capture:!0,once:e})},l=function(t,e,n,i){var a;return function(){n&&e.isFinal&&n.disconnect(),e.value>=0&&(i||e.isFinal||\"hidden\"===document.visibilityState)&&(e.delta=e.value-(a||0),(e.delta||e.isFinal||void 0===a)&&(t(e),a=e.value))}},f=function(){return void 0===e&&(e=\"hidden\"===document.visibilityState?0:1/0,p(function(t){var n=t.timeStamp;return e=n},!0)),{get timeStamp(){return e}}},d=function(){return n||(n=new Promise(function(t){return[\"scroll\",\"keydown\",\"pointerdown\"].map(function(e){addEventListener(e,t,{once:!0,passive:!0,capture:!0})})})),n};t.getCLS=function(t){var e,n=arguments.length>1&&void 0!==arguments[1]&&arguments[1],i=a(\"CLS\",0),o=function(t){t.hadRecentInput||(i.value+=t.value,i.entries.push(t),e())},u=r(\"layout-shift\",o);u&&(e=l(t,i,u,n),p(function(t){var n=t.isUnloading;u.takeRecords().map(o),n&&(i.isFinal=!0),e()}))},t.getFCP=function(t){var e,n=a(\"FCP\"),i=f(),o=r(\"paint\",function(t){\"first-contentful-paint\"===t.name&&t.startTime<i.timeStamp&&(n.value=t.startTime,n.isFinal=!0,n.entries.push(t),e())});o&&(e=l(t,n,o))},t.getFID=function(t){var e=a(\"FID\"),n=f(),i=function(t){t.startTime<n.timeStamp&&(e.value=t.processingStart-t.startTime,e.entries.push(t),e.isFinal=!0,u())},o=r(\"first-input\",i),u=l(t,e,o);o?p(function(){o.takeRecords().map(i),o.disconnect()},!0):window.perfMetrics&&window.perfMetrics.onFirstInputDelay&&window.perfMetrics.onFirstInputDelay(function(t,i){i.timeStamp<n.timeStamp&&(e.value=t,e.isFinal=!0,e.entries=[{entryType:\"first-input\",name:i.type,target:i.target,cancelable:i.cancelable,startTime:i.timeStamp,processingStart:i.timeStamp+t}],u())})},t.getLCP=function(t){var e,n=arguments.length>1&&void 0!==arguments[1]&&arguments[1],i=a(\"LCP\"),o=f(),u=function(t){var n=t.startTime;n<o.timeStamp?(i.value=n,i.entries.push(t)):i.isFinal=!0,e()},s=r(\"largest-contentful-paint\",u);if(s){e=l(t,i,s,n);var c=function(){i.isFinal||(s.takeRecords().map(u),i.isFinal=!0,e())};d().then(c),p(c,!0)}},t.getTTFB=function(t){var e,n=a(\"TTFB\");e=function(){try{var e=performance.getEntriesByType(\"navigation\")[0]||function(){var t=performance.timing,e={entryType:\"navigation\",startTime:0};for(var n in t)\"navigationStart\"!==n&&\"toJSON\"!==n&&(e[n]=Math.max(t[n]-t.navigationStart,0));return e}();n.value=n.delta=e.responseStart,n.entries=[e],n.isFinal=!0,t(n)}catch(t){}},\"complete\"===document.readyState?setTimeout(e,0):addEventListener(\"pageshow\",e)},Object.defineProperty(t,\"__esModule\",{value:!0})})}};var e={};function __webpack_require__(n){if(e[n]){return e[n].exports}var i=e[n]={exports:{}};var a=true;try{t[n].call(i.exports,i,i.exports,__webpack_require__);a=false}finally{if(a)delete e[n]}return i.exports}__webpack_require__.ab=__dirname+\"/\";return __webpack_require__(692)}();","function _extends() {\n  module.exports = _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nmodule.exports = _extends;","'use strict';\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\nvar returnThis = function () { return this; };\n\n// `%IteratorPrototype%` object\n// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\nif ([].keys) {\n  arrayIterator = [].keys();\n  // Safari 8 has buggy iterators w/o `next`\n  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n  else {\n    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n  }\n}\n\nif (IteratorPrototype == undefined) IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nif (!IS_PURE && !has(IteratorPrototype, ITERATOR)) {\n  createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);\n}\n\nmodule.exports = {\n  IteratorPrototype: IteratorPrototype,\n  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  return Object.isExtensible(Object.preventExtensions({}));\n});\n","var now = require('performance-now')\n  , root = typeof window === 'undefined' ? global : window\n  , vendors = ['moz', 'webkit']\n  , suffix = 'AnimationFrame'\n  , raf = root['request' + suffix]\n  , caf = root['cancel' + suffix] || root['cancelRequest' + suffix]\n\nfor(var i = 0; !raf && i < vendors.length; i++) {\n  raf = root[vendors[i] + 'Request' + suffix]\n  caf = root[vendors[i] + 'Cancel' + suffix]\n      || root[vendors[i] + 'CancelRequest' + suffix]\n}\n\n// Some versions of FF have rAF but not cAF\nif(!raf || !caf) {\n  var last = 0\n    , id = 0\n    , queue = []\n    , frameDuration = 1000 / 60\n\n  raf = function(callback) {\n    if(queue.length === 0) {\n      var _now = now()\n        , next = Math.max(0, frameDuration - (_now - last))\n      last = next + _now\n      setTimeout(function() {\n        var cp = queue.slice(0)\n        // Clear queue here to prevent\n        // callbacks from appending listeners\n        // to the current frame's queue\n        queue.length = 0\n        for(var i = 0; i < cp.length; i++) {\n          if(!cp[i].cancelled) {\n            try{\n              cp[i].callback(last)\n            } catch(e) {\n              setTimeout(function() { throw e }, 0)\n            }\n          }\n        }\n      }, Math.round(next))\n    }\n    queue.push({\n      handle: ++id,\n      callback: callback,\n      cancelled: false\n    })\n    return id\n  }\n\n  caf = function(handle) {\n    for(var i = 0; i < queue.length; i++) {\n      if(queue[i].handle === handle) {\n        queue[i].cancelled = true\n      }\n    }\n  }\n}\n\nmodule.exports = function(fn) {\n  // Wrap in a new function to prevent\n  // `cancel` potentially being assigned\n  // to the native rAF function\n  return raf.call(root, fn)\n}\nmodule.exports.cancel = function() {\n  caf.apply(root, arguments)\n}\nmodule.exports.polyfill = function(object) {\n  if (!object) {\n    object = root;\n  }\n  object.requestAnimationFrame = raf\n  object.cancelAnimationFrame = caf\n}\n","let runtimeConfig: any\n\nexport default () => {\n  return runtimeConfig\n}\n\nexport function setConfig(configValue: any): void {\n  runtimeConfig = configValue\n}\n","import { ComponentType } from 'react'\nimport type { ClientSsgManifest } from '../build'\nimport {\n  addBasePath,\n  addLocale,\n  interpolateAs,\n} from '../next-server/lib/router/router'\nimport getAssetPathFromRoute from '../next-server/lib/router/utils/get-asset-path-from-route'\nimport { isDynamicRoute } from '../next-server/lib/router/utils/is-dynamic'\nimport { parseRelativeUrl } from '../next-server/lib/router/utils/parse-relative-url'\nimport createRouteLoader, {\n  getClientBuildManifest,\n  RouteLoader,\n} from './route-loader'\n\nfunction normalizeRoute(route: string) {\n  if (route[0] !== '/') {\n    throw new Error(`Route name should start with a \"/\", got \"${route}\"`)\n  }\n\n  if (route === '/') return route\n  return route.replace(/\\/$/, '')\n}\n\nexport type StyleSheetTuple = { href: string; text: string }\nexport type GoodPageCache = {\n  page: ComponentType\n  mod: any\n  styleSheets: StyleSheetTuple[]\n}\n\nexport default class PageLoader {\n  private buildId: string\n  private assetPrefix: string\n\n  private promisedSsgManifest?: Promise<ClientSsgManifest>\n  private promisedDevPagesManifest?: Promise<any>\n  public routeLoader: RouteLoader\n\n  constructor(buildId: string, assetPrefix: string) {\n    this.routeLoader = createRouteLoader(assetPrefix)\n\n    this.buildId = buildId\n    this.assetPrefix = assetPrefix\n\n    /** @type {Promise<Set<string>>} */\n    this.promisedSsgManifest = new Promise((resolve) => {\n      if ((window as any).__SSG_MANIFEST) {\n        resolve((window as any).__SSG_MANIFEST)\n      } else {\n        ;(window as any).__SSG_MANIFEST_CB = () => {\n          resolve((window as any).__SSG_MANIFEST)\n        }\n      }\n    })\n  }\n\n  getPageList() {\n    if (process.env.NODE_ENV === 'production') {\n      return getClientBuildManifest().then((manifest) => manifest.sortedPages)\n    } else {\n      if ((window as any).__DEV_PAGES_MANIFEST) {\n        return (window as any).__DEV_PAGES_MANIFEST.pages\n      } else {\n        if (!this.promisedDevPagesManifest) {\n          this.promisedDevPagesManifest = fetch(\n            `${this.assetPrefix}/_next/static/development/_devPagesManifest.json`\n          )\n            .then((res) => res.json())\n            .then((manifest) => {\n              ;(window as any).__DEV_PAGES_MANIFEST = manifest\n              return manifest.pages\n            })\n            .catch((err) => {\n              console.log(`Failed to fetch devPagesManifest`, err)\n            })\n        }\n        return this.promisedDevPagesManifest\n      }\n    }\n  }\n\n  /**\n   * @param {string} href the route href (file-system path)\n   * @param {string} asPath the URL as shown in browser (virtual path); used for dynamic routes\n   */\n  getDataHref(\n    href: string,\n    asPath: string,\n    ssg: boolean,\n    locale?: string | false\n  ) {\n    const { pathname: hrefPathname, query, search } = parseRelativeUrl(href)\n    const { pathname: asPathname } = parseRelativeUrl(asPath)\n    const route = normalizeRoute(hrefPathname)\n\n    const getHrefForSlug = (path: string) => {\n      const dataRoute = getAssetPathFromRoute(addLocale(path, locale), '.json')\n      return addBasePath(\n        `/_next/data/${this.buildId}${dataRoute}${ssg ? '' : search}`\n      )\n    }\n\n    const isDynamic: boolean = isDynamicRoute(route)\n    const interpolatedRoute = isDynamic\n      ? interpolateAs(hrefPathname, asPathname, query).result\n      : ''\n\n    return isDynamic\n      ? interpolatedRoute && getHrefForSlug(interpolatedRoute)\n      : getHrefForSlug(route)\n  }\n\n  /**\n   * @param {string} href the route href (file-system path)\n   */\n  _isSsg(href: string): Promise<boolean> {\n    const { pathname: hrefPathname } = parseRelativeUrl(href)\n    const route = normalizeRoute(hrefPathname)\n    return this.promisedSsgManifest!.then((s: ClientSsgManifest) =>\n      s.has(route)\n    )\n  }\n\n  loadPage(route: string): Promise<GoodPageCache> {\n    return this.routeLoader.loadRoute(route).then((res) => {\n      if ('component' in res) {\n        return {\n          page: res.component,\n          mod: res.exports,\n          styleSheets: res.styles.map((o) => ({\n            href: o.href,\n            text: o.content,\n          })),\n        }\n      }\n      throw res.error\n    })\n  }\n\n  prefetch(route: string): Promise<void> {\n    return this.routeLoader.prefetch(route)\n  }\n}\n"],"sourceRoot":""}