{"version":3,"sources":["webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/atom/ab-test.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/atom/crawler.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/atom/csp-scripts.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/atom/i18n-text.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/atom/index.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/atom/locale.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/atom/render-config.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/atom/root-traffic.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/atom/user-agent.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/atom/web-user.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/i18n/europe.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/i18n/index.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/i18n/language.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/i18n/region.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/format/index.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/format/num-formatter.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/format/time-ago-formatter.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/format/time-formatter.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/index.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/no-operation.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/pending-queue.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/unreachable.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/view-observer/index.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/view-observer/observer.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/view-observer/preset.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/view-observer/use-view-observer.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/@lemon8+web-app-shared@1.2.3_@types+react@18.2.78/node_modules/@lemon8/web-app-shared/dist/esm/util/xss/index.js","webpack://@lemon8/web-sharing/../dom.ts","webpack://@lemon8/web-sharing/../index.tsx","webpack://@lemon8/web-sharing/../lib/context.ts","webpack://@lemon8/web-sharing/../lib/hooks.tsx","webpack://@lemon8/web-sharing/../lib/components.tsx","webpack://@lemon8/web-sharing/../index.ts","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/jotai@2.6.1_@types+react@18.2.78_react@18.2.0/node_modules/jotai/index.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/jotai@2.6.1_@types+react@18.2.78_react@18.2.0/node_modules/jotai/react.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/jotai@2.6.1_@types+react@18.2.78_react@18.2.0/node_modules/jotai/react/utils.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/jotai@2.6.1_@types+react@18.2.78_react@18.2.0/node_modules/jotai/utils.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/jotai@2.6.1_@types+react@18.2.78_react@18.2.0/node_modules/jotai/vanilla.js","webpack://@lemon8/web-sharing/../common/temp/split__lemon8_web_sharing/node_modules/.pnpm/jotai@2.6.1_@types+react@18.2.78_react@18.2.0/node_modules/jotai/vanilla/utils.js"],"names":["exports","jotai_1","CrawlerType","GoogleCrawlerSubType","__createBinding","o","m","k","k2","desc","__exportStar","p","isEuropeRegion","region","region_1","Language","language","l","r","Region","IDCRegion","getRegionIDC","i18n_1","NUM_INTERVAL_MAP","formatNum","num","_config","val","config","decimal","unitDigit","oneDecimal","s","formatNumByRegion","t","type","units","__importDefault","mod","dayjs_1","ONE_SECOND","ONE_MINUTE","ONE_HOUR","ONE_DAY","ONE_WEEK","EIGHT_DAY","formatTimeAgo","time","now","after","seconds","minutes","hours","days","weeks","timeDayjs","dateToLocalISO","timeStamp","timeZone","off","absoff","NoOperation","PendingQueue","task","Unreachable","reason","ViewObserver","options","element","callback","entries","containerHeight","entry","node","elementHeight","isVisible","timeout","visible","scene","instance","buildThreshold","steps","_x","i","react_1","observer_1","preset_1","useViewObserver","props","deps","onView","inputRef","ref","tracked","setTracked","observer","filter_xss_1","filterXSS","html","buildInnerHtml","defaultMethod","defaultEncType","isHtmlElement","object","tagName","isButtonElement","toLowerCase","isFormElement","isInputElement","isModifiedEvent","event","metaKey","altKey","ctrlKey","shiftKey","shouldProcessLinkClick","target","button","createSearchParams","init","URLSearchParams","Array","isArray","Object","keys","reduce","memo","key","value","concat","map","v","getSearchParamsForLocation","locationSearch","defaultSearchParams","searchParams","has","getAll","forEach","append","_formDataSupportsSubmitter","isFormDataSubmitterSupported","FormData","document","createElement","e","supportedFormEncTypes","Set","getFormEncType","encType","getFormSubmissionInfo","basename","method","action","formData","body","attr","getAttribute","stripBasename","form","Error","name","prefix","undefined","createBrowserRouter","routes","opts","createRouter","future","_extends","v7_prependBasename","history","createBrowserHistory","window","hydrationData","parseHydrationData","mapRouteProperties","initialize","createHashRouter","createHashHistory","_window","state","__staticRouterHydrationData","errors","deserializeErrors","serialized","__type","ErrorResponse","status","statusText","data","internal","error","message","stack","START_TRANSITION","startTransitionImpl","React","BrowserRouter","_ref","children","historyRef","current","v5Compat","setStateImpl","location","v7_startTransition","setState","newState","listen","Router","navigationType","navigator","HashRouter","_ref2","HistoryRouter","_ref3","isBrowser","ABSOLUTE_URL_REGEX","Link","_ref4","onClick","relative","reloadDocument","replace","to","preventScrollReset","rest","_objectWithoutPropertiesLoose","_excluded","NavigationContext","absoluteHref","isExternal","test","currentUrl","URL","href","targetUrl","startsWith","protocol","path","pathname","origin","search","hash","useHref","internalOnClick","useLinkClickHandler","handleClick","defaultPrevented","NavLink","_ref5","ariaCurrentProp","caseSensitive","className","classNameProp","end","style","styleProp","_excluded2","useResolvedPath","useLocation","routerState","DataRouterStateContext","toPathname","encodeLocation","locationPathname","nextLocationPathname","navigation","isActive","charAt","length","isPending","ariaCurrent","filter","Boolean","join","Form","submit","useSubmit","FormImpl","_ref6","forwardedRef","onSubmit","_excluded3","formMethod","formAction","useFormAction","submitHandler","preventDefault","submitter","nativeEvent","submitMethod","currentTarget","ScrollRestoration","_ref7","getKey","storageKey","useScrollRestoration","DataRouterHook","DataRouterStateHook","getDataRouterConsoleError","hookName","useDataRouterContext","ctx","DataRouterContext","invariant","useDataRouterState","_temp","replaceProp","navigate","useNavigate","createPath","useSearchParams","defaultInit","defaultSearchParamsRef","hasSetSearchParamsRef","setSearchParams","nextInit","navigateOptions","newSearchParams","validateClientSideSubmission","router","UseSubmit","currentRouteId","useRouteId","formEncType","fromRouteId","useSubmitFetcher","fetcherKey","fetcherRouteId","UseSubmitFetcher","fetch","_temp2","routeContext","RouteContext","match","matches","slice","route","index","params","delete","toString","joinPaths","createFetcherForm","routeId","fetcherId","useFetcher","_route$matches","UseFetcher","id","String","load","fetcher","getFetcher","fetcherWithComponents","console","warn","deleteFetcher","useFetchers","UseFetchers","fetchers","values","SCROLL_RESTORATION_STORAGE_KEY","savedScrollPositions","_temp3","UseScrollRestoration","restoreScrollPosition","useMatches","useNavigation","scrollRestoration","usePageHide","scrollY","sessionStorage","setItem","JSON","stringify","sessionPositions","getItem","parse","getKeyWithoutBasename","disableScrollRestoration","enableScrollRestoration","scrollTo","el","getElementById","scrollIntoView","useBeforeUnload","capture","addEventListener","removeEventListener","usePrompt","_ref8","when","blocker","useBlocker","reset","confirm","setTimeout","proceed","AwaitContext","LocationContext","outlet","isDataRoute","RouteErrorContext","useInRouterContext","joinedPathname","createHref","useNavigationType","useMatch","pattern","matchPath","navigateEffectWarning","useIsomorphicLayoutEffect","cb","static","useNavigateStable","useNavigateUnstable","dataRouterContext","routePathnamesJson","getPathContributingMatches","pathnameBase","activeRef","go","resolveTo","push","OutletContext","useOutletContext","useOutlet","context","Provider","useParams","routeMatch","useRoutes","locationArg","useRoutesImpl","dataRouterState","parentMatches","parentParams","parentPathname","parentPathnameBase","parentRoute","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","parsePath","remainingPathname","matchRoutes","renderedMatches","_renderMatches","assign","NavigationType","DefaultErrorComponent","useRouteError","isRouteErrorResponse","lightgrey","preStyles","padding","backgroundColor","codeStyles","devInfo","fontStyle","defaultErrorElement","RenderErrorBoundary","constructor","revalidation","getDerivedStateFromError","getDerivedStateFromProps","componentDidCatch","errorInfo","render","component","RenderedRoute","staticContext","errorElement","ErrorBoundary","_deepestRenderedBoundaryId","_dataRouterState2","_dataRouterState","errorIndex","findIndex","Math","min","reduceRight","getChildren","Component","useRouteContext","useCurrentRouteId","thisRoute","UseRouteId","UseNavigation","useRevalidator","UseRevalidator","revalidate","loaderData","UseMatches","handle","useLoaderData","UseLoaderData","useRouteLoaderData","UseRouteLoaderData","useActionData","UseActionData","actionData","_state$errors","UseRouteError","useAsyncValue","_data","useAsyncError","_error","blockerId","shouldBlock","UseBlocker","blockerKey","setBlockerKey","blockerFunction","arg","currentLocation","nextLocation","historyAction","deleteBlocker","getBlocker","blockers","get","IDLE_BLOCKER","UseNavigateStable","alreadyWarned","warningOnce","cond","RouterProvider","fallbackElement","subscribe","n","initialized","DataRoutes","MemoryRouter","initialEntries","initialIndex","createMemoryHistory","Navigate","jsonPath","Outlet","Route","_props","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","Routes","createRoutesFromChildren","Await","resolve","AwaitErrorBoundary","ResolveAwait","AwaitRenderStatus","neverSettledPromise","Promise","promise","pending","success","defineProperty","renderError","reject","catch","_tracked","then","AbortedDeferredError","toRender","parentPath","treePath","apply","loader","hasErrorBoundary","shouldRevalidate","lazy","renderMatches","updates","createMemoryRouter","vanilla","react","ReactExports","StoreContext","useStore","store","storeRef","isPromiseLike","x","use","useAtomValue","atom","_useReducer","prev","nextValue","_useReducer$","valueFromReducer","storeFromReducer","atomFromReducer","rerender","delay","unsub","useSetAtom","setAtom","_len","args","_key","useAtom","react$1","utils","useResetAtom","anAtom","resetAtom","useReducerAtom","reducer","_useAtom","dispatch","useAtomCallback","set","_unsupportedIterableToArray","minLen","_arrayLikeToArray","arr","len","arr2","_createForOfIteratorHelperLoose","allowArrayLike","it","hydratedMap","useHydrateAtoms","hydratedSet","getHydratedSet","_iterator","_step","_step$value","utils$1","keyCount","read","write","hasInitialValue","isActuallyWritableAtom","cancelPromiseMap","registerCancelPromise","cancel","cancelPromise","next","resolvePromise","rejectPromise","isEqualAtomValue","a","b","isEqualAtomError","hasPromiseAtomValue","isEqualPromiseAtomValue","returnAtomValue","atomState","createStore","atomStateMap","mountedMap","pendingMap","storeListenersRev2","mountedAtoms","getAtomState","setAtomState","prevAtomState","_next","updateDependencies","nextAtomState","nextDependencies","dependencies","changed","aState","setAtomValue","setAtomValueOrPromise","valueOrPromise","abortPromise","continuePromise","updatePromiseDependencies","mountDependencies","settled","setAtomError","readAtomState","force","isSync","getter","_aState","controller","setSelf","writeAtom","_controller","readAtom","addAtom","mounted","mountAtom","canUnmountAtom","delAtom","unmountAtom","recomputeDependents","dependencyMap","dirtyMap","getDependents","_mountedMap$get","dependents","_","pendingAtom","_getAtomState","loop1","dependent","loop2","dirtyCount","_dependencyMap$get","isChanged","writeAtomState","setter","_len3","_key3","flushed","flushPending","_len2","_key2","result","_len4","_key4","initialDependent","onMountQueue","_getAtomState2","queue","aMounted","onMount","onUnmount","_len5","_key5","f","_mountedMap$get2","prevDependencies","depSet","listener","subscribeAtom","listeners","defaultStore","getDefaultStore","RESET","atomWithReset","initialValue","update","atomWithReducer","atomFamily","initializeAtom","areEqual","shouldRemove","atoms","createAtom","param","item","newAtom","_iterator2","_step2","_step2$value","fn","_iterator3","_step3","_step3$value","getCached$2","c","cache1$4","memo3","create","dep1","dep2","dep3","cache2","cache3","selectAtom","selector","equalityFn","EMPTY","selectValue","prevSlice","derivedAtom","cache1$3","memo1$1","deepFreeze","obj","propNames","freezeAtom","frozenAtom","_get","freezeAtomCreator","origRead","getCached$1","cache1$2","memo2$1","cacheKeyForEmptyKeyExtractor","isWritable","isFunction","splitAtom","arrAtom","keyExtractor","mappingCache","getMapping","mapping","prevMapping","atomList","keyList","cachedAtom","mappingAtom","currArr","prevItem","nextItem","splittedAtom","_index","_arr","index1","index2","_arr2","atomWithDefault","getDefault","overwrittenAtom","overwritten","prevValue","createJSONStorage","getStringStorage","lastStr","lastValue","storage","_getStringStorage$get","_getStringStorage","str","_unused","newValue","_getStringStorage2","_getStringStorage3","storageEventCallback","_newValue","_unused2","defaultStorage","atomWithStorage","getOnInit","baseAtom","resolvedValue","atomWithObservable","getObservable","returnResultData","observableResultAtom","_observable$Symbol$ob","_observable","observable","itself","makePending","initialResult","setResult","lastResult","subscription","timer","isNotMounted","start","d","resultAtom","observableAtom","_get2","cache1$1","memo1","LOADING","loadable","loadableCache","refreshAtom","cached","getCached","cache1","memo2","defaultFallback","unwrap","fallback","promiseErrorCache","promiseResultCache","promiseAndValueAtom"],"mappings":"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","file":"946-1ef3c021395efd548306.js","sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.$ABTest = void 0;\nconst jotai_1 = require(\"jotai\");\nexports.$ABTest = (0, jotai_1.atom)({\n    versions: '',\n    parameters: {},\n});\nexports.$ABTest.debugLabel = '$ABTest';\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.$Crawler = exports.GoogleCrawlerSubType = exports.CrawlerType = void 0;\nconst jotai_1 = require(\"jotai\");\nvar CrawlerType;\n(function (CrawlerType) {\n    CrawlerType[\"Google\"] = \"google\";\n})(CrawlerType = exports.CrawlerType || (exports.CrawlerType = {}));\nvar GoogleCrawlerSubType;\n(function (GoogleCrawlerSubType) {\n    GoogleCrawlerSubType[\"GoogleAPIs\"] = \"google_apis\";\n    GoogleCrawlerSubType[\"AdsBot\"] = \"ads_bot\";\n    GoogleCrawlerSubType[\"AdSense\"] = \"mediapartners\";\n    GoogleCrawlerSubType[\"Image\"] = \"image\";\n    GoogleCrawlerSubType[\"News\"] = \"news\";\n    GoogleCrawlerSubType[\"Video\"] = \"video\";\n    GoogleCrawlerSubType[\"GoogleBot\"] = \"googlebot\";\n    GoogleCrawlerSubType[\"GoogleBot$Mobile\"] = \"googlebot(mobile)\";\n    GoogleCrawlerSubType[\"FeedFetcher\"] = \"feed_fetcher\";\n    GoogleCrawlerSubType[\"ReadAloud\"] = \"read_aloud\";\n    GoogleCrawlerSubType[\"Favicon\"] = \"favicon\";\n    GoogleCrawlerSubType[\"Storebot\"] = \"store_bot\";\n    GoogleCrawlerSubType[\"SiteVerification\"] = \"site_verification\";\n})(GoogleCrawlerSubType = exports.GoogleCrawlerSubType || (exports.GoogleCrawlerSubType = {}));\nexports.$Crawler = (0, jotai_1.atom)({});\nexports.$Crawler.debugLabel = '$Crawler';\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.$CSPScripts = void 0;\nconst jotai_1 = require(\"jotai\");\nexports.$CSPScripts = (0, jotai_1.atom)({\n    'tea-precollect': '',\n    'slardar-precollect': '',\n    'remix-route-modules': '',\n    'remix-server-handoff': '',\n});\nexports.$CSPScripts.debugLabel = '$CSPScripts';\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.$I18nText = void 0;\nconst jotai_1 = require(\"jotai\");\nexports.$I18nText = (0, jotai_1.atom)({});\nexports.$I18nText.debugLabel = '$I18nText';\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./ab-test\"), exports);\n__exportStar(require(\"./crawler\"), exports);\n__exportStar(require(\"./i18n-text\"), exports);\n__exportStar(require(\"./locale\"), exports);\n__exportStar(require(\"./render-config\"), exports);\n__exportStar(require(\"./root-traffic\"), exports);\n__exportStar(require(\"./user-agent\"), exports);\n__exportStar(require(\"./web-user\"), exports);\n__exportStar(require(\"./csp-scripts\"), exports);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.$Locale = void 0;\nconst jotai_1 = require(\"jotai\");\nexports.$Locale = (0, jotai_1.atom)({});\nexports.$Locale.debugLabel = '$Locale';\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.$RenderConfig = void 0;\nconst jotai_1 = require(\"jotai\");\nexports.$RenderConfig = (0, jotai_1.atom)({\n    enableStreamingSSR: false,\n    disableInlineScripts: false,\n});\nexports.$RenderConfig.debugLabel = '$RenderConfig';\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.$RootTraffic = void 0;\nconst jotai_1 = require(\"jotai\");\nexports.$RootTraffic = (0, jotai_1.atom)({});\nexports.$RootTraffic.debugLabel = '$RootTraffic';\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.$UserAgent = void 0;\nconst jotai_1 = require(\"jotai\");\nexports.$UserAgent = (0, jotai_1.atom)({\n    isMobile: false,\n    isBot: false,\n    isiOS: false,\n    isSafari: false,\n    isInApp: false,\n    isMacOS: false,\n});\nexports.$UserAgent.debugLabel = '$UserAgent';\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.$WebUser = void 0;\nconst jotai_1 = require(\"jotai\");\nexports.$WebUser = (0, jotai_1.atom)({\n    webId: '',\n});\nexports.$WebUser.debugLabel = '$WebUser';\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isEuropeRegion = exports.EURO_COUNTRY_SET = exports.EURO_COUNTRY_LIST = void 0;\nexports.EURO_COUNTRY_LIST = [\n    'at',\n    'be',\n    'bg',\n    'hr',\n    'ch',\n    'cy',\n    'cz',\n    'de',\n    'dk',\n    'ee',\n    'el',\n    'fi',\n    'fr',\n    'gb',\n    'gr',\n    'hu',\n    'ie',\n    'it',\n    'lv',\n    'lt',\n    'lu',\n    'mt',\n    'nl',\n    'pl',\n    'pt',\n    'ro',\n    'sk',\n    'si',\n    'es',\n    'se',\n    'no',\n    'is',\n    'li',\n];\nexports.EURO_COUNTRY_SET = new Set(exports.EURO_COUNTRY_LIST);\nconst isEuropeRegion = (region) => exports.EURO_COUNTRY_SET.has(region);\nexports.isEuropeRegion = isEuropeRegion;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./region\"), exports);\n__exportStar(require(\"./language\"), exports);\n__exportStar(require(\"./europe\"), exports);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.RegionHrefLangMap = exports.RegionFallbackLanguageMap = exports.SupportedLanguageMetas = exports.SupportedLanguages = exports.LanguageDisplayNameMap = exports.Language = void 0;\nconst region_1 = require(\"./region\");\nvar Language;\n(function (Language) {\n    Language[\"en\"] = \"en\";\n    Language[\"id\"] = \"id\";\n    Language[\"ja\"] = \"ja\";\n    Language[\"ms\"] = \"ms\";\n    Language[\"th\"] = \"th\";\n    Language[\"vi\"] = \"vi\";\n    Language[\"fil\"] = \"fil\";\n})(Language = exports.Language || (exports.Language = {}));\nexports.LanguageDisplayNameMap = {\n    en: 'English',\n    id: 'Bahasa Indonesia',\n    ja: '日本語',\n    ms: 'Bahasa Melayu',\n    th: 'ไทย',\n    vi: 'Tiếng Việt',\n    fil: 'Pilipino',\n};\nexports.SupportedLanguages = [\n    Language.en,\n    Language.id,\n    Language.ja,\n    Language.ms,\n    Language.th,\n    Language.vi,\n];\nexports.SupportedLanguageMetas = exports.SupportedLanguages.map((language) => ({\n    language,\n    displayName: exports.LanguageDisplayNameMap[language],\n})).sort((l, r) => (l.displayName > r.displayName ? 1 : -1));\nexports.RegionFallbackLanguageMap = {\n    [region_1.Region.jp]: Language.ja,\n    [region_1.Region.th]: Language.th,\n    [region_1.Region.my]: Language.ms,\n    [region_1.Region.id]: Language.id,\n    [region_1.Region.vn]: Language.vi,\n    [region_1.Region.us]: Language.en,\n    [region_1.Region.gb]: Language.en,\n    [region_1.Region.sg]: Language.en,\n    [region_1.Region.ph]: Language.en,\n};\nexports.RegionHrefLangMap = {\n    [region_1.Region.jp]: 'ja-jp',\n    [region_1.Region.th]: 'th-th',\n    [region_1.Region.my]: 'ms-my',\n    [region_1.Region.id]: 'id-id',\n    [region_1.Region.vn]: 'vi-vn',\n    [region_1.Region.us]: 'en-us',\n    [region_1.Region.gb]: 'en-gb',\n    [region_1.Region.sg]: 'en-sg',\n    [region_1.Region.ph]: 'en-ph',\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getRegionIDC = exports.IDCRegion = exports.RegionDisplayMap = exports.Region = void 0;\n/**\n * ISO 639-1 Language Code\n */\nvar Region;\n(function (Region) {\n    Region[\"jp\"] = \"jp\";\n    Region[\"th\"] = \"th\";\n    Region[\"my\"] = \"my\";\n    Region[\"id\"] = \"id\";\n    Region[\"ph\"] = \"ph\";\n    Region[\"vn\"] = \"vn\";\n    Region[\"us\"] = \"us\";\n    Region[\"gb\"] = \"gb\";\n    Region[\"sg\"] = \"sg\";\n})(Region = exports.Region || (exports.Region = {}));\nexports.RegionDisplayMap = {\n    [Region.jp]: '日本',\n    [Region.th]: 'ไทย',\n    [Region.my]: 'Malaysia',\n    [Region.id]: 'Indonesia',\n    [Region.vn]: 'Việt Nam',\n    [Region.us]: 'US',\n    [Region.gb]: 'UK',\n    [Region.sg]: 'Singapore',\n    [Region.ph]: 'Philippines',\n};\nvar IDCRegion;\n(function (IDCRegion) {\n    IDCRegion[\"SG\"] = \"sg\";\n    IDCRegion[\"VA\"] = \"va\";\n})(IDCRegion = exports.IDCRegion || (exports.IDCRegion = {}));\nconst getRegionIDC = (region) => {\n    return [Region.jp, Region.us, Region.gb].includes(region) ? IDCRegion.VA : IDCRegion.SG;\n};\nexports.getRegionIDC = getRegionIDC;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./num-formatter\"), exports);\n__exportStar(require(\"./time-ago-formatter\"), exports);\n__exportStar(require(\"./time-formatter\"), exports);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.formatNumByRegion = exports.formatNum = void 0;\nconst i18n_1 = require(\"../../i18n\");\nconst NUM_INTERVAL_MAP = {\n    w: [i18n_1.Region.jp],\n    k: [i18n_1.Region.id, i18n_1.Region.my, i18n_1.Region.ph, i18n_1.Region.sg, i18n_1.Region.th, i18n_1.Region.vn, i18n_1.Region.gb, i18n_1.Region.us],\n};\nfunction formatNum(num, _config = {}) {\n    let val = `${num}`;\n    const config = {\n        decimal: 1,\n        units: ['万', '億'],\n        needDiv: true,\n        ..._config,\n    };\n    const { decimal } = config;\n    if (config.type === 'KMB') {\n        if (num >= 1e10) {\n            val = `${(num / 1e9).toFixed(0)}B`;\n        }\n        else if (num >= 1e9) {\n            val = `${(num / 1e9).toFixed(decimal).replace(/\\.0*$/, '')}B`;\n        }\n        else if (num >= 1e7) {\n            val = `${(num / 1e6).toFixed(0)}M`;\n        }\n        else if (num >= 1e6) {\n            val = `${(num / 1e6).toFixed(decimal).replace(/\\.0*$/, '')}M`;\n        }\n        else if (num >= 1e4) {\n            val = `${(num / 1e3).toFixed(0)}K`;\n        }\n        else if (num >= 1e3) {\n            val = `${(num / 1e3).toFixed(decimal).replace(/\\.0*$/, '')}K`;\n        }\n        else {\n            val = `${num}`;\n        }\n    }\n    else if (config.type === 'KM') {\n        if (num >= 10e6) {\n            const unitDigit = (num / 1e6).toString().split('.')[0];\n            const oneDecimal = ((num - Number(unitDigit) * 1e6) / 1e5).toString().split('.')[0];\n            if (Number(oneDecimal) >= 1) {\n                val = `${String(unitDigit)}.${String(oneDecimal)}${config.units[0]}`;\n            }\n            else {\n                val = `${String(unitDigit)}${config.units[1]}`;\n            }\n        }\n        else if (num >= 1e4) {\n            const unitDigit = (num / 1e3).toString().split('.')[0];\n            const oneDecimal = ((num - Number(unitDigit) * 1e3) / 1e2).toString().split('.')[0];\n            if (Number(oneDecimal) >= 1) {\n                val = `${String(unitDigit)}.${String(oneDecimal)}${config.units[0]}`;\n            }\n            else {\n                val = `${String(unitDigit)}${config.units[0]}`;\n            }\n        }\n        else {\n            val = `${num}`;\n        }\n    }\n    else if (config.type === 'WY') {\n        if (num >= 1e10) {\n            val = ~~(num / 1e8) + config.units[1];\n        }\n        else if (num >= 1e8) {\n            val = (num / 1e8).toFixed(decimal).replace(/\\.0*$/, '') + config.units[1];\n        }\n        else if (num >= 1e6) {\n            val = ~~(num / 1e4) + config.units[0];\n        }\n        else if (num >= 1e4) {\n            val = (num / 1e4).toFixed(decimal).replace(/\\.0*$/, '') + config.units[0];\n        }\n        else {\n            val = `${num}`;\n        }\n    }\n    else if (config.type === 'W') {\n        if (num >= 1e4) {\n            const unitDigit = (num / 1e4).toString().split('.')[0];\n            const oneDecimal = ((num - Number(unitDigit) * 1e4) / 1e3).toString().split('.')[0];\n            if (Number(oneDecimal) >= 1) {\n                val = `${String(unitDigit)}.${String(oneDecimal)}${config.units[0]}`;\n            }\n            else {\n                val = `${String(unitDigit)}${config.units[0]}`;\n            }\n        }\n        else {\n            val = `${num}`;\n        }\n    }\n    else if (config.upperLimit && num >= config.upperLimit) {\n        val = config.upperText;\n    }\n    if (config.needDiv) {\n        val = val.replace(/\\d+/, function (s) {\n            return s.replace(/(\\d)(?=(\\d{3})+$)/g, '$1,');\n        });\n    }\n    if (config.tmpl) {\n        return config.tmpl.replace('%s', val);\n    }\n    return val;\n}\nexports.formatNum = formatNum;\nfunction formatNumByRegion(num, region, t) {\n    if (NUM_INTERVAL_MAP.w.includes(region)) {\n        const type = 'W';\n        const units = [t('common_ten_thousand')];\n        return formatNum(num, { type, units, needDiv: false });\n    }\n    if (NUM_INTERVAL_MAP.k.includes(region)) {\n        const type = 'KM';\n        const units = [t('common_thousand'), t('common_million')];\n        return formatNum(num, { type, units, needDiv: false });\n    }\n    return '';\n}\nexports.formatNumByRegion = formatNumByRegion;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.formatTimeAgo = void 0;\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst ONE_SECOND = 1000;\nconst ONE_MINUTE = 60 * ONE_SECOND;\nconst ONE_HOUR = 60 * ONE_MINUTE;\nconst ONE_DAY = 24 * ONE_HOUR;\nconst ONE_WEEK = 7 * ONE_DAY;\nconst EIGHT_DAY = 8 * ONE_DAY;\n/**\n * time: seconds\n */\nconst formatTimeAgo = (time, t) => {\n    const now = Date.now();\n    const after = now - time * 1000;\n    if (after < ONE_MINUTE) {\n        const seconds = Math.floor(after / ONE_SECOND);\n        return t('seconds_ago_plural', { num: seconds }).replace('%d', `${seconds}`);\n    }\n    if (after < ONE_HOUR) {\n        const minutes = Math.floor(after / ONE_MINUTE);\n        return t('minutes_ago_plural', { num: minutes }).replace('%d', `${minutes}`);\n    }\n    if (after < ONE_DAY) {\n        const hours = Math.floor(after / ONE_HOUR);\n        return t('hours_ago_plural', { num: hours }).replace('%d', `${hours}`);\n    }\n    if (after < ONE_WEEK) {\n        const days = Math.floor(after / ONE_DAY);\n        return t('days_ago_plural', { num: days }).replace('%d', `${days}`);\n    }\n    if (after < EIGHT_DAY) {\n        const weeks = Math.floor(after / ONE_WEEK);\n        return t('weeks_ago_plural', { num: weeks }).replace('%d', `${weeks}`);\n    }\n    const timeDayjs = (0, dayjs_1.default)(time * 1000);\n    if ((0, dayjs_1.default)(now).year() === timeDayjs.year()) {\n        return timeDayjs.format('M/D');\n    }\n    return timeDayjs.format('YYYY/M/D');\n};\nexports.formatTimeAgo = formatTimeAgo;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.dateToLocalISO = void 0;\nconst dateToLocalISO = function (timeStamp, timeZone) {\n    // off为当地时区相对UTC的偏移量，日本为9，中国为8\n    const off = -timeZone * 60;\n    const absoff = Math.abs(off);\n    return `${new Date(timeStamp * 1000 - off * 60 * 1000).toISOString().substr(0, 23) +\n        (off > 0 ? '-' : '+') +\n        (absoff / 60).toFixed(0).padStart(2, '0')}:${(absoff % 60).toString().padStart(2, '0')}`;\n};\nexports.dateToLocalISO = dateToLocalISO;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./unreachable\"), exports);\n__exportStar(require(\"./no-operation\"), exports);\n__exportStar(require(\"./format\"), exports);\n__exportStar(require(\"./xss\"), exports);\n__exportStar(require(\"./view-observer\"), exports);\n__exportStar(require(\"./pending-queue\"), exports);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.NoOperation = void 0;\nconst NoOperation = () => void 0;\nexports.NoOperation = NoOperation;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PendingQueue = void 0;\nclass PendingQueue {\n    constructor() {\n        this._tasks = [];\n        this._doInterval = () => {\n            if (this._tasks.length) {\n                this._tasks.forEach((task) => task());\n                this._tasks = [];\n            }\n        };\n        setInterval(this._doInterval, 500);\n    }\n    push(task) {\n        this._tasks.push(task);\n    }\n}\nexports.PendingQueue = PendingQueue;\nPendingQueue.instance = new PendingQueue();\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Unreachable = void 0;\nconst Unreachable = (reason = 'unreachable code here') => {\n    throw new Error(reason);\n};\nexports.Unreachable = Unreachable;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./observer\"), exports);\n__exportStar(require(\"./preset\"), exports);\n__exportStar(require(\"./use-view-observer\"), exports);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ViewObserver = void 0;\nclass ViewObserver {\n    constructor(options) {\n        this.observe = (element, callback) => {\n            this.elements.set(element, {\n                callback,\n                visible: false,\n                entry: element,\n            });\n            this.observer.observe(element);\n        };\n        this.unobserve = (element) => {\n            if (!this.elements.get(element)) {\n                return;\n            }\n            this.observer.unobserve(element);\n            this.elements.delete(element);\n        };\n        /**\n         * callback for Intersection Observer\n         *\n         * Loop through all the observed elements and check if visible\n         *\n         * @param  {Array} [entries] array of [IntersectionObserverEntry],\n         */\n        this._watchElements = (entries = []) => {\n            /**\n             * If rootBounds does not exist, it will default to the height and width of the viewport\n             */\n            const containerHeight = window.innerHeight || document.documentElement.clientHeight;\n            entries\n                .filter((entry) => entry.isIntersecting)\n                .forEach((entry) => {\n                const node = entry.target;\n                const element = this.elements.get(node);\n                const bounds = entry.boundingClientRect || node.getBoundingClientRect();\n                const elementHeight = bounds.height;\n                const isVisible = entry.intersectionRatio >= this.options.targetVisibleIntersectionThreshold ||\n                    (entry.intersectionRatio * elementHeight) / containerHeight >=\n                        this.options.containerVisibleIntersectionThreshold;\n                // Element is still visible since last check\n                if (isVisible && element && element.timeoutSet) {\n                    return;\n                }\n                // If the element is visible\n                if (isVisible && element) {\n                    // Set the visibility state to true but wait until the timeout finishes\n                    // to fire the event\n                    element.timeoutSet = true;\n                    // Start timer\n                    this.timeouts.set(node, setTimeout(() => {\n                        // Fire the event\n                        this._onVisibilityChange(node, true);\n                    }, this.options.minTimeVisible));\n                }\n                else {\n                    const timeout = this.timeouts.get(node);\n                    // Fire event\n                    this._onVisibilityChange(node, false);\n                    // Element is no longer visible, delete timeout\n                    clearTimeout(timeout);\n                    this.timeouts.delete(node);\n                    if (element) {\n                        element.timeoutSet = false;\n                    }\n                }\n            });\n        };\n        /**\n         * callback for orientationchange or other event which may cause element visible change\n         *\n         * Fire onChange event listeners for all visible elements\n         */\n        this._reportVisibilityStates = () => {\n            this.elements.forEach(({ visible }, element) => {\n                if (visible) {\n                    this._onVisibilityChange(element, visible);\n                }\n            });\n        };\n        this.options = options;\n        this.elements = new Map();\n        this.timeouts = new Map();\n        this.observer = new IntersectionObserver(this._watchElements, {\n            root: this.options.root,\n            rootMargin: this.options.rootMargin,\n            threshold: this.options.threshold,\n        });\n        this._addEventListeners();\n    }\n    destroy() {\n        this.elements.clear();\n        this.timeouts.clear();\n        if (typeof this.observer.disconnect === 'function') {\n            this.observer.disconnect();\n        }\n        this._removeEventListeners();\n    }\n    /**\n     * Handle DOM element visibility state change\n     * @param  {Element} element - the DOM node\n     * @param  {Boolean} visible - the visibility state of the entry\n     */\n    _onVisibilityChange(element, visible) {\n        const entry = this.elements.get(element);\n        if (!entry) {\n            return;\n        }\n        // Set the new visibility state\n        entry.visible = visible;\n        const { callback } = entry;\n        callback(visible);\n    }\n    _addEventListeners() {\n        window.addEventListener('focus', this._reportVisibilityStates);\n        window.addEventListener('orientationchange', this._reportVisibilityStates);\n    }\n    _removeEventListeners() {\n        window.removeEventListener('focus', this._reportVisibilityStates);\n        window.removeEventListener('orientationchange', this._reportVisibilityStates);\n    }\n}\nexports.ViewObserver = ViewObserver;\nViewObserver.Factory = {\n    instances: new Map(),\n    get: (options) => {\n        const { scene } = options;\n        let instance = ViewObserver.Factory.instances.get(scene);\n        if (!instance) {\n            instance = new ViewObserver(options);\n            ViewObserver.Factory.instances.set(scene, instance);\n        }\n        return instance;\n    },\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ViewObserverPreset = exports.buildThreshold = void 0;\n/**\n * Build an array of threshold values ranging from 0 to 1\n * @param {Number} steps - number of steps between 0 and 1.0\n * @returns {Number[]} returns array of floats\n */\nconst buildThreshold = (steps = 1) => {\n    const threshold = Array.from({ length: steps }, (_x, i) => i / steps);\n    // Returns an array like [0, ...n, 1]\n    return [...threshold, 1];\n};\nexports.buildThreshold = buildThreshold;\nexports.ViewObserverPreset = {\n    default: {\n        scene: 'default',\n        root: null,\n        rootMargin: '',\n        threshold: (0, exports.buildThreshold)(10),\n        targetVisibleIntersectionThreshold: 0.8,\n        containerVisibleIntersectionThreshold: 0.5,\n        minTimeVisible: 250,\n    },\n    'viewport-asap': {\n        scene: 'viewport-asap',\n        root: null,\n        rootMargin: '',\n        threshold: (0, exports.buildThreshold)(1),\n        targetVisibleIntersectionThreshold: 0,\n        containerVisibleIntersectionThreshold: 0,\n        minTimeVisible: 0,\n    },\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.useViewObserver = void 0;\nconst react_1 = require(\"react\");\nconst observer_1 = require(\"./observer\");\nconst preset_1 = require(\"./preset\");\nconst useViewObserver = (props, deps = []) => {\n    const { onView, ref: inputRef, options } = props;\n    const ref = inputRef || (0, react_1.useRef)(null);\n    const [tracked, setTracked] = (0, react_1.useState)(false);\n    (0, react_1.useEffect)(() => {\n        const element = ref.current;\n        if (!element || tracked) {\n            return;\n        }\n        const observer = observer_1.ViewObserver.Factory.get(options || preset_1.ViewObserverPreset.default);\n        observer.observe(element, (visible) => {\n            if (visible) {\n                onView();\n                setTracked(true);\n                observer.unobserve(element);\n            }\n        });\n        return () => {\n            observer.unobserve(element);\n        };\n    }, [ref, tracked, onView, ...deps]);\n    return ref;\n};\nexports.useViewObserver = useViewObserver;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.buildInnerHtml = exports.filterXSS = void 0;\nconst filter_xss_1 = require(\"@ies/filter-xss\");\nconst filterXSS = (html) => (0, filter_xss_1._filterXSS)(html);\nexports.filterXSS = filterXSS;\nconst buildInnerHtml = (html) => {\n    return {\n        __html: (0, exports.filterXSS)(html),\n    };\n};\nexports.buildInnerHtml = buildInnerHtml;\n","import type {\n  FormEncType,\n  HTMLFormMethod,\n  RelativeRoutingType,\n} from \"@remix-run/router\";\nimport { stripBasename, UNSAFE_warning as warning } from \"@remix-run/router\";\n\nexport const defaultMethod: HTMLFormMethod = \"get\";\nconst defaultEncType: FormEncType = \"application/x-www-form-urlencoded\";\n\nexport function isHtmlElement(object: any): object is HTMLElement {\n  return object != null && typeof object.tagName === \"string\";\n}\n\nexport function isButtonElement(object: any): object is HTMLButtonElement {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"button\";\n}\n\nexport function isFormElement(object: any): object is HTMLFormElement {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"form\";\n}\n\nexport function isInputElement(object: any): object is HTMLInputElement {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"input\";\n}\n\ntype LimitedMouseEvent = Pick<\n  MouseEvent,\n  \"button\" | \"metaKey\" | \"altKey\" | \"ctrlKey\" | \"shiftKey\"\n>;\n\nfunction isModifiedEvent(event: LimitedMouseEvent) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nexport function shouldProcessLinkClick(\n  event: LimitedMouseEvent,\n  target?: string\n) {\n  return (\n    event.button === 0 && // Ignore everything but left clicks\n    (!target || target === \"_self\") && // Let browser handle \"target=_blank\" etc.\n    !isModifiedEvent(event) // Ignore clicks with modifier keys\n  );\n}\n\nexport type ParamKeyValuePair = [string, string];\n\nexport type URLSearchParamsInit =\n  | string\n  | ParamKeyValuePair[]\n  | Record<string, string | string[]>\n  | URLSearchParams;\n\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n *   let searchParams = new URLSearchParams([\n *     ['sort', 'name'],\n *     ['sort', 'price']\n *   ]);\n *\n * you can do:\n *\n *   let searchParams = createSearchParams({\n *     sort: ['name', 'price']\n *   });\n */\nexport function createSearchParams(\n  init: URLSearchParamsInit = \"\"\n): URLSearchParams {\n  return new URLSearchParams(\n    typeof init === \"string\" ||\n    Array.isArray(init) ||\n    init instanceof URLSearchParams\n      ? init\n      : Object.keys(init).reduce((memo, key) => {\n          let value = init[key];\n          return memo.concat(\n            Array.isArray(value) ? value.map((v) => [key, v]) : [[key, value]]\n          );\n        }, [] as ParamKeyValuePair[])\n  );\n}\n\nexport function getSearchParamsForLocation(\n  locationSearch: string,\n  defaultSearchParams: URLSearchParams | null\n) {\n  let searchParams = createSearchParams(locationSearch);\n\n  if (defaultSearchParams) {\n    for (let key of defaultSearchParams.keys()) {\n      if (!searchParams.has(key)) {\n        defaultSearchParams.getAll(key).forEach((value) => {\n          searchParams.append(key, value);\n        });\n      }\n    }\n  }\n\n  return searchParams;\n}\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n  [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\nexport type SubmitTarget =\n  | HTMLFormElement\n  | HTMLButtonElement\n  | HTMLInputElement\n  | FormData\n  | URLSearchParams\n  | JsonValue\n  | null;\n\n// One-time check for submitter support\nlet _formDataSupportsSubmitter: boolean | null = null;\n\nfunction isFormDataSubmitterSupported() {\n  if (_formDataSupportsSubmitter === null) {\n    try {\n      new FormData(\n        document.createElement(\"form\"),\n        // @ts-expect-error if FormData supports the submitter parameter, this will throw\n        0\n      );\n      _formDataSupportsSubmitter = false;\n    } catch (e) {\n      _formDataSupportsSubmitter = true;\n    }\n  }\n  return _formDataSupportsSubmitter;\n}\n\nexport interface SubmitOptions {\n  /**\n   * The HTTP method used to submit the form. Overrides `<form method>`.\n   * Defaults to \"GET\".\n   */\n  method?: HTMLFormMethod;\n\n  /**\n   * The action URL path used to submit the form. Overrides `<form action>`.\n   * Defaults to the path of the current route.\n   */\n  action?: string;\n\n  /**\n   * The encoding used to submit the form. Overrides `<form encType>`.\n   * Defaults to \"application/x-www-form-urlencoded\".\n   */\n  encType?: FormEncType;\n\n  /**\n   * Set `true` to replace the current entry in the browser's history stack\n   * instead of creating a new one (i.e. stay on \"the same page\"). Defaults\n   * to `false`.\n   */\n  replace?: boolean;\n\n  /**\n   * Determines whether the form action is relative to the route hierarchy or\n   * the pathname.  Use this if you want to opt out of navigating the route\n   * hierarchy and want to instead route based on /-delimited URL segments\n   */\n  relative?: RelativeRoutingType;\n\n  /**\n   * In browser-based environments, prevent resetting scroll after this\n   * navigation when using the <ScrollRestoration> component\n   */\n  preventScrollReset?: boolean;\n}\n\nconst supportedFormEncTypes: Set<FormEncType> = new Set([\n  \"application/x-www-form-urlencoded\",\n  \"multipart/form-data\",\n  \"text/plain\",\n]);\n\nfunction getFormEncType(encType: string | null) {\n  if (encType != null && !supportedFormEncTypes.has(encType as FormEncType)) {\n    warning(\n      false,\n      `\"${encType}\" is not a valid \\`encType\\` for \\`<Form>\\`/\\`<fetcher.Form>\\` ` +\n        `and will default to \"${defaultEncType}\"`\n    );\n\n    return null;\n  }\n  return encType;\n}\n\nexport function getFormSubmissionInfo(\n  target: SubmitTarget,\n  basename: string\n): {\n  action: string | null;\n  method: string;\n  encType: string;\n  formData: FormData | undefined;\n  body: any;\n} {\n  let method: string;\n  let action: string | null;\n  let encType: string;\n  let formData: FormData | undefined;\n  let body: any;\n\n  if (isFormElement(target)) {\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"enctype\")) || defaultEncType;\n\n    formData = new FormData(target);\n  } else if (\n    isButtonElement(target) ||\n    (isInputElement(target) &&\n      (target.type === \"submit\" || target.type === \"image\"))\n  ) {\n    let form = target.form;\n\n    if (form == null) {\n      throw new Error(\n        `Cannot submit a <button> or <input type=\"submit\"> without a <form>`\n      );\n    }\n\n    // <button>/<input type=\"submit\"> may override attributes of <form>\n\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"formaction\") || form.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n\n    method =\n      target.getAttribute(\"formmethod\") ||\n      form.getAttribute(\"method\") ||\n      defaultMethod;\n    encType =\n      getFormEncType(target.getAttribute(\"formenctype\")) ||\n      getFormEncType(form.getAttribute(\"enctype\")) ||\n      defaultEncType;\n\n    // Build a FormData object populated from a form and submitter\n    formData = new FormData(form, target);\n\n    // If this browser doesn't support the `FormData(el, submitter)` format,\n    // then tack on the submitter value at the end.  This is a lightweight\n    // solution that is not 100% spec compliant.  For complete support in older\n    // browsers, consider using the `formdata-submitter-polyfill` package\n    if (!isFormDataSubmitterSupported()) {\n      let { name, type, value } = target;\n      if (type === \"image\") {\n        let prefix = name ? `${name}.` : \"\";\n        formData.append(`${prefix}x`, \"0\");\n        formData.append(`${prefix}y`, \"0\");\n      } else if (name) {\n        formData.append(name, value);\n      }\n    }\n  } else if (isHtmlElement(target)) {\n    throw new Error(\n      `Cannot submit element that is not <form>, <button>, or ` +\n        `<input type=\"submit|image\">`\n    );\n  } else {\n    method = defaultMethod;\n    action = null;\n    encType = defaultEncType;\n    body = target;\n  }\n\n  // Send body for <Form encType=\"text/plain\" so we encode it into text\n  if (formData && encType === \"text/plain\") {\n    body = formData;\n    formData = undefined;\n  }\n\n  return { action, method: method.toLowerCase(), encType, formData, body };\n}\n","/**\n * NOTE: If you refactor this to split up the modules into separate files,\n * you'll need to update the rollup config for react-router-dom-v5-compat.\n */\nimport * as React from \"react\";\nimport type {\n  FutureConfig,\n  Location,\n  NavigateOptions,\n  NavigationType,\n  RelativeRoutingType,\n  RouteObject,\n  To,\n} from \"react-router\";\nimport {\n  Router,\n  createPath,\n  useHref,\n  useLocation,\n  useMatches,\n  useNavigate,\n  useNavigation,\n  useResolvedPath,\n  unstable_useBlocker as useBlocker,\n  UNSAFE_DataRouterContext as DataRouterContext,\n  UNSAFE_DataRouterStateContext as DataRouterStateContext,\n  UNSAFE_NavigationContext as NavigationContext,\n  UNSAFE_RouteContext as RouteContext,\n  UNSAFE_mapRouteProperties as mapRouteProperties,\n  UNSAFE_useRouteId as useRouteId,\n} from \"react-router\";\nimport type {\n  BrowserHistory,\n  Fetcher,\n  FormEncType,\n  FormMethod,\n  FutureConfig as RouterFutureConfig,\n  GetScrollRestorationKeyFunction,\n  HashHistory,\n  History,\n  HTMLFormMethod,\n  HydrationState,\n  Router as RemixRouter,\n  V7_FormMethod,\n} from \"@remix-run/router\";\nimport {\n  createRouter,\n  createBrowserHistory,\n  createHashHistory,\n  joinPaths,\n  stripBasename,\n  ErrorResponse,\n  UNSAFE_invariant as invariant,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n  SubmitOptions,\n  ParamKeyValuePair,\n  URLSearchParamsInit,\n  SubmitTarget,\n} from \"./dom\";\nimport {\n  createSearchParams,\n  defaultMethod,\n  getFormSubmissionInfo,\n  getSearchParamsForLocation,\n  shouldProcessLinkClick,\n} from \"./dom\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Re-exports\n////////////////////////////////////////////////////////////////////////////////\n\nexport type {\n  FormEncType,\n  FormMethod,\n  GetScrollRestorationKeyFunction,\n  ParamKeyValuePair,\n  SubmitOptions,\n  URLSearchParamsInit,\n  V7_FormMethod,\n};\nexport { createSearchParams };\n\n// Note: Keep in sync with react-router exports!\nexport type {\n  ActionFunction,\n  ActionFunctionArgs,\n  AwaitProps,\n  unstable_Blocker,\n  unstable_BlockerFunction,\n  DataRouteMatch,\n  DataRouteObject,\n  Fetcher,\n  Hash,\n  IndexRouteObject,\n  IndexRouteProps,\n  JsonFunction,\n  LazyRouteFunction,\n  LayoutRouteProps,\n  LoaderFunction,\n  LoaderFunctionArgs,\n  Location,\n  MemoryRouterProps,\n  NavigateFunction,\n  NavigateOptions,\n  NavigateProps,\n  Navigation,\n  Navigator,\n  NonIndexRouteObject,\n  OutletProps,\n  Params,\n  ParamParseKey,\n  Path,\n  PathMatch,\n  Pathname,\n  PathPattern,\n  PathRouteProps,\n  RedirectFunction,\n  RelativeRoutingType,\n  RouteMatch,\n  RouteObject,\n  RouteProps,\n  RouterProps,\n  RouterProviderProps,\n  RoutesProps,\n  Search,\n  ShouldRevalidateFunction,\n  To,\n} from \"react-router\";\nexport {\n  AbortedDeferredError,\n  Await,\n  MemoryRouter,\n  Navigate,\n  NavigationType,\n  Outlet,\n  Route,\n  Router,\n  RouterProvider,\n  Routes,\n  createMemoryRouter,\n  createPath,\n  createRoutesFromChildren,\n  createRoutesFromElements,\n  defer,\n  isRouteErrorResponse,\n  generatePath,\n  json,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  redirect,\n  renderMatches,\n  resolvePath,\n  useActionData,\n  useAsyncError,\n  useAsyncValue,\n  unstable_useBlocker,\n  useHref,\n  useInRouterContext,\n  useLoaderData,\n  useLocation,\n  useMatch,\n  useMatches,\n  useNavigate,\n  useNavigation,\n  useNavigationType,\n  useOutlet,\n  useOutletContext,\n  useParams,\n  useResolvedPath,\n  useRevalidator,\n  useRouteError,\n  useRouteLoaderData,\n  useRoutes,\n} from \"react-router\";\n\n///////////////////////////////////////////////////////////////////////////////\n// DANGER! PLEASE READ ME!\n// We provide these exports as an escape hatch in the event that you need any\n// routing data that we don't provide an explicit API for. With that said, we\n// want to cover your use case if we can, so if you feel the need to use these\n// we want to hear from you. Let us know what you're building and we'll do our\n// best to make sure we can support you!\n//\n// We consider these exports an implementation detail and do not guarantee\n// against any breaking changes, regardless of the semver release. Use with\n// extreme caution and only if you understand the consequences. Godspeed.\n///////////////////////////////////////////////////////////////////////////////\n\n/** @internal */\nexport {\n  UNSAFE_DataRouterContext,\n  UNSAFE_DataRouterStateContext,\n  UNSAFE_NavigationContext,\n  UNSAFE_LocationContext,\n  UNSAFE_RouteContext,\n  UNSAFE_useRouteId,\n} from \"react-router\";\n//#endregion\n\ndeclare global {\n  var __staticRouterHydrationData: HydrationState | undefined;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Routers\n////////////////////////////////////////////////////////////////////////////////\n\ninterface DOMRouterOpts {\n  basename?: string;\n  future?: Partial<Omit<RouterFutureConfig, \"v7_prependBasename\">>;\n  hydrationData?: HydrationState;\n  window?: Window;\n}\n\nexport function createBrowserRouter(\n  routes: RouteObject[],\n  opts?: DOMRouterOpts\n): RemixRouter {\n  return createRouter({\n    basename: opts?.basename,\n    future: {\n      ...opts?.future,\n      v7_prependBasename: true,\n    },\n    history: createBrowserHistory({ window: opts?.window }),\n    hydrationData: opts?.hydrationData || parseHydrationData(),\n    routes,\n    mapRouteProperties,\n  }).initialize();\n}\n\nexport function createHashRouter(\n  routes: RouteObject[],\n  opts?: DOMRouterOpts\n): RemixRouter {\n  return createRouter({\n    basename: opts?.basename,\n    future: {\n      ...opts?.future,\n      v7_prependBasename: true,\n    },\n    history: createHashHistory({ window: opts?.window }),\n    hydrationData: opts?.hydrationData || parseHydrationData(),\n    routes,\n    mapRouteProperties,\n  }).initialize();\n}\n\nfunction parseHydrationData(): HydrationState | undefined {\n  let state = window?.__staticRouterHydrationData;\n  if (state && state.errors) {\n    state = {\n      ...state,\n      errors: deserializeErrors(state.errors),\n    };\n  }\n  return state;\n}\n\nfunction deserializeErrors(\n  errors: RemixRouter[\"state\"][\"errors\"]\n): RemixRouter[\"state\"][\"errors\"] {\n  if (!errors) return null;\n  let entries = Object.entries(errors);\n  let serialized: RemixRouter[\"state\"][\"errors\"] = {};\n  for (let [key, val] of entries) {\n    // Hey you!  If you change this, please change the corresponding logic in\n    // serializeErrors in react-router-dom/server.tsx :)\n    if (val && val.__type === \"RouteErrorResponse\") {\n      serialized[key] = new ErrorResponse(\n        val.status,\n        val.statusText,\n        val.data,\n        val.internal === true\n      );\n    } else if (val && val.__type === \"Error\") {\n      let error = new Error(val.message);\n      // Wipe away the client-side stack trace.  Nothing to fill it in with\n      // because we don't serialize SSR stack traces for security reasons\n      error.stack = \"\";\n      serialized[key] = error;\n    } else {\n      serialized[key] = val;\n    }\n  }\n  return serialized;\n}\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Components\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\nexport interface BrowserRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  future?: FutureConfig;\n  window?: Window;\n}\n\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\nexport function BrowserRouter({\n  basename,\n  children,\n  future,\n  window,\n}: BrowserRouterProps) {\n  let historyRef = React.useRef<BrowserHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({ window, v5Compat: true });\n  }\n\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface HashRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  future?: FutureConfig;\n  window?: Window;\n}\n\n/**\n * A `<Router>` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\nexport function HashRouter({\n  basename,\n  children,\n  future,\n  window,\n}: HashRouterProps) {\n  let historyRef = React.useRef<HashHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({ window, v5Compat: true });\n  }\n\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface HistoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  future?: FutureConfig;\n  history: History;\n}\n\n/**\n * A `<Router>` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\nfunction HistoryRouter({\n  basename,\n  children,\n  future,\n  history,\n}: HistoryRouterProps) {\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nif (__DEV__) {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\n\nexport { HistoryRouter as unstable_HistoryRouter };\n\nexport interface LinkProps\n  extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, \"href\"> {\n  reloadDocument?: boolean;\n  replace?: boolean;\n  state?: any;\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  to: To;\n}\n\nconst isBrowser =\n  typeof window !== \"undefined\" &&\n  typeof window.document !== \"undefined\" &&\n  typeof window.document.createElement !== \"undefined\";\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\n/**\n * The public API for rendering a history-aware <a>.\n */\nexport const Link = React.forwardRef<HTMLAnchorElement, LinkProps>(\n  function LinkWithRef(\n    {\n      onClick,\n      relative,\n      reloadDocument,\n      replace,\n      state,\n      target,\n      to,\n      preventScrollReset,\n      ...rest\n    },\n    ref\n  ) {\n    let { basename } = React.useContext(NavigationContext);\n\n    // Rendered into <a href> for absolute URLs\n    let absoluteHref;\n    let isExternal = false;\n\n    if (typeof to === \"string\" && ABSOLUTE_URL_REGEX.test(to)) {\n      // Render the absolute href server- and client-side\n      absoluteHref = to;\n\n      // Only check for external origins client-side\n      if (isBrowser) {\n        try {\n          let currentUrl = new URL(window.location.href);\n          let targetUrl = to.startsWith(\"//\")\n            ? new URL(currentUrl.protocol + to)\n            : new URL(to);\n          let path = stripBasename(targetUrl.pathname, basename);\n\n          if (targetUrl.origin === currentUrl.origin && path != null) {\n            // Strip the protocol/origin/basename for same-origin absolute URLs\n            to = path + targetUrl.search + targetUrl.hash;\n          } else {\n            isExternal = true;\n          }\n        } catch (e) {\n          // We can't do external URL detection without a valid URL\n          warning(\n            false,\n            `<Link to=\"${to}\"> contains an invalid URL which will probably break ` +\n              `when clicked - please update to a valid URL path.`\n          );\n        }\n      }\n    }\n\n    // Rendered into <a href> for relative URLs\n    let href = useHref(to, { relative });\n\n    let internalOnClick = useLinkClickHandler(to, {\n      replace,\n      state,\n      target,\n      preventScrollReset,\n      relative,\n    });\n    function handleClick(\n      event: React.MouseEvent<HTMLAnchorElement, MouseEvent>\n    ) {\n      if (onClick) onClick(event);\n      if (!event.defaultPrevented) {\n        internalOnClick(event);\n      }\n    }\n\n    return (\n      // eslint-disable-next-line jsx-a11y/anchor-has-content\n      <a\n        {...rest}\n        href={absoluteHref || href}\n        onClick={isExternal || reloadDocument ? onClick : handleClick}\n        ref={ref}\n        target={target}\n      />\n    );\n  }\n);\n\nif (__DEV__) {\n  Link.displayName = \"Link\";\n}\n\nexport interface NavLinkProps\n  extends Omit<LinkProps, \"className\" | \"style\" | \"children\"> {\n  children?:\n    | React.ReactNode\n    | ((props: { isActive: boolean; isPending: boolean }) => React.ReactNode);\n  caseSensitive?: boolean;\n  className?:\n    | string\n    | ((props: {\n        isActive: boolean;\n        isPending: boolean;\n      }) => string | undefined);\n  end?: boolean;\n  style?:\n    | React.CSSProperties\n    | ((props: {\n        isActive: boolean;\n        isPending: boolean;\n      }) => React.CSSProperties | undefined);\n}\n\n/**\n * A <Link> wrapper that knows if it's \"active\" or not.\n */\nexport const NavLink = React.forwardRef<HTMLAnchorElement, NavLinkProps>(\n  function NavLinkWithRef(\n    {\n      \"aria-current\": ariaCurrentProp = \"page\",\n      caseSensitive = false,\n      className: classNameProp = \"\",\n      end = false,\n      style: styleProp,\n      to,\n      children,\n      ...rest\n    },\n    ref\n  ) {\n    let path = useResolvedPath(to, { relative: rest.relative });\n    let location = useLocation();\n    let routerState = React.useContext(DataRouterStateContext);\n    let { navigator } = React.useContext(NavigationContext);\n\n    let toPathname = navigator.encodeLocation\n      ? navigator.encodeLocation(path).pathname\n      : path.pathname;\n    let locationPathname = location.pathname;\n    let nextLocationPathname =\n      routerState && routerState.navigation && routerState.navigation.location\n        ? routerState.navigation.location.pathname\n        : null;\n\n    if (!caseSensitive) {\n      locationPathname = locationPathname.toLowerCase();\n      nextLocationPathname = nextLocationPathname\n        ? nextLocationPathname.toLowerCase()\n        : null;\n      toPathname = toPathname.toLowerCase();\n    }\n\n    let isActive =\n      locationPathname === toPathname ||\n      (!end &&\n        locationPathname.startsWith(toPathname) &&\n        locationPathname.charAt(toPathname.length) === \"/\");\n\n    let isPending =\n      nextLocationPathname != null &&\n      (nextLocationPathname === toPathname ||\n        (!end &&\n          nextLocationPathname.startsWith(toPathname) &&\n          nextLocationPathname.charAt(toPathname.length) === \"/\"));\n\n    let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n\n    let className: string | undefined;\n    if (typeof classNameProp === \"function\") {\n      className = classNameProp({ isActive, isPending });\n    } else {\n      // If the className prop is not a function, we use a default `active`\n      // class for <NavLink />s that are active. In v5 `active` was the default\n      // value for `activeClassName`, but we are removing that API and can still\n      // use the old default behavior for a cleaner upgrade path and keep the\n      // simple styling rules working as they currently do.\n      className = [\n        classNameProp,\n        isActive ? \"active\" : null,\n        isPending ? \"pending\" : null,\n      ]\n        .filter(Boolean)\n        .join(\" \");\n    }\n\n    let style =\n      typeof styleProp === \"function\"\n        ? styleProp({ isActive, isPending })\n        : styleProp;\n\n    return (\n      <Link\n        {...rest}\n        aria-current={ariaCurrent}\n        className={className}\n        ref={ref}\n        style={style}\n        to={to}\n      >\n        {typeof children === \"function\"\n          ? children({ isActive, isPending })\n          : children}\n      </Link>\n    );\n  }\n);\n\nif (__DEV__) {\n  NavLink.displayName = \"NavLink\";\n}\n\nexport interface FormProps extends React.FormHTMLAttributes<HTMLFormElement> {\n  /**\n   * The HTTP verb to use when the form is submit. Supports \"get\", \"post\",\n   * \"put\", \"delete\", \"patch\".\n   */\n  method?: HTMLFormMethod;\n\n  /**\n   * `<form encType>` - enhancing beyond the normal string type and limiting\n   * to the built-in browser supported values\n   */\n  encType?:\n    | \"application/x-www-form-urlencoded\"\n    | \"multipart/form-data\"\n    | \"text/plain\";\n\n  /**\n   * Normal `<form action>` but supports React Router's relative paths.\n   */\n  action?: string;\n\n  /**\n   * Forces a full document navigation instead of a fetch.\n   */\n  reloadDocument?: boolean;\n\n  /**\n   * Replaces the current entry in the browser history stack when the form\n   * navigates. Use this if you don't want the user to be able to click \"back\"\n   * to the page with the form on it.\n   */\n  replace?: boolean;\n\n  /**\n   * Determines whether the form action is relative to the route hierarchy or\n   * the pathname.  Use this if you want to opt out of navigating the route\n   * hierarchy and want to instead route based on /-delimited URL segments\n   */\n  relative?: RelativeRoutingType;\n\n  /**\n   * Prevent the scroll position from resetting to the top of the viewport on\n   * completion of the navigation when using the <ScrollRestoration> component\n   */\n  preventScrollReset?: boolean;\n\n  /**\n   * A function to call when the form is submitted. If you call\n   * `event.preventDefault()` then this form will not do anything.\n   */\n  onSubmit?: React.FormEventHandler<HTMLFormElement>;\n}\n\n/**\n * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except\n * that the interaction with the server is with `fetch` instead of new document\n * requests, allowing components to add nicer UX to the page as the form is\n * submitted and returns with data.\n */\nexport const Form = React.forwardRef<HTMLFormElement, FormProps>(\n  (props, ref) => {\n    let submit = useSubmit();\n    return <FormImpl {...props} submit={submit} ref={ref} />;\n  }\n);\n\nif (__DEV__) {\n  Form.displayName = \"Form\";\n}\n\ntype HTMLSubmitEvent = React.BaseSyntheticEvent<\n  SubmitEvent,\n  Event,\n  HTMLFormElement\n>;\n\ntype HTMLFormSubmitter = HTMLButtonElement | HTMLInputElement;\n\ninterface FormImplProps extends FormProps {\n  submit: SubmitFunction | FetcherSubmitFunction;\n}\n\nconst FormImpl = React.forwardRef<HTMLFormElement, FormImplProps>(\n  (\n    {\n      reloadDocument,\n      replace,\n      method = defaultMethod,\n      action,\n      onSubmit,\n      submit,\n      relative,\n      preventScrollReset,\n      ...props\n    },\n    forwardedRef\n  ) => {\n    let formMethod: HTMLFormMethod =\n      method.toLowerCase() === \"get\" ? \"get\" : \"post\";\n    let formAction = useFormAction(action, { relative });\n    let submitHandler: React.FormEventHandler<HTMLFormElement> = (event) => {\n      onSubmit && onSubmit(event);\n      if (event.defaultPrevented) return;\n      event.preventDefault();\n\n      let submitter = (event as unknown as HTMLSubmitEvent).nativeEvent\n        .submitter as HTMLFormSubmitter | null;\n\n      let submitMethod =\n        (submitter?.getAttribute(\"formmethod\") as HTMLFormMethod | undefined) ||\n        method;\n\n      submit(submitter || event.currentTarget, {\n        method: submitMethod,\n        replace,\n        relative,\n        preventScrollReset,\n      });\n    };\n\n    return (\n      <form\n        ref={forwardedRef}\n        method={formMethod}\n        action={formAction}\n        onSubmit={reloadDocument ? onSubmit : submitHandler}\n        {...props}\n      />\n    );\n  }\n);\n\nif (__DEV__) {\n  FormImpl.displayName = \"FormImpl\";\n}\n\nexport interface ScrollRestorationProps {\n  getKey?: GetScrollRestorationKeyFunction;\n  storageKey?: string;\n}\n\n/**\n * This component will emulate the browser's scroll restoration on location\n * changes.\n */\nexport function ScrollRestoration({\n  getKey,\n  storageKey,\n}: ScrollRestorationProps) {\n  useScrollRestoration({ getKey, storageKey });\n  return null;\n}\n\nif (__DEV__) {\n  ScrollRestoration.displayName = \"ScrollRestoration\";\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hooks\n////////////////////////////////////////////////////////////////////////////////\n\nenum DataRouterHook {\n  UseScrollRestoration = \"useScrollRestoration\",\n  UseSubmit = \"useSubmit\",\n  UseSubmitFetcher = \"useSubmitFetcher\",\n  UseFetcher = \"useFetcher\",\n}\n\nenum DataRouterStateHook {\n  UseFetchers = \"useFetchers\",\n  UseScrollRestoration = \"useScrollRestoration\",\n}\n\nfunction getDataRouterConsoleError(\n  hookName: DataRouterHook | DataRouterStateHook\n) {\n  return `${hookName} must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.`;\n}\n\nfunction useDataRouterContext(hookName: DataRouterHook) {\n  let ctx = React.useContext(DataRouterContext);\n  invariant(ctx, getDataRouterConsoleError(hookName));\n  return ctx;\n}\n\nfunction useDataRouterState(hookName: DataRouterStateHook) {\n  let state = React.useContext(DataRouterStateContext);\n  invariant(state, getDataRouterConsoleError(hookName));\n  return state;\n}\n\n/**\n * Handles the click behavior for router `<Link>` components. This is useful if\n * you need to create custom `<Link>` components with the same click behavior we\n * use in our exported `<Link>`.\n */\nexport function useLinkClickHandler<E extends Element = HTMLAnchorElement>(\n  to: To,\n  {\n    target,\n    replace: replaceProp,\n    state,\n    preventScrollReset,\n    relative,\n  }: {\n    target?: React.HTMLAttributeAnchorTarget;\n    replace?: boolean;\n    state?: any;\n    preventScrollReset?: boolean;\n    relative?: RelativeRoutingType;\n  } = {}\n): (event: React.MouseEvent<E, MouseEvent>) => void {\n  let navigate = useNavigate();\n  let location = useLocation();\n  let path = useResolvedPath(to, { relative });\n\n  return React.useCallback(\n    (event: React.MouseEvent<E, MouseEvent>) => {\n      if (shouldProcessLinkClick(event, target)) {\n        event.preventDefault();\n\n        // If the URL hasn't changed, a regular <a> will do a replace instead of\n        // a push, so do the same here unless the replace prop is explicitly set\n        let replace =\n          replaceProp !== undefined\n            ? replaceProp\n            : createPath(location) === createPath(path);\n\n        navigate(to, { replace, state, preventScrollReset, relative });\n      }\n    },\n    [\n      location,\n      navigate,\n      path,\n      replaceProp,\n      state,\n      target,\n      to,\n      preventScrollReset,\n      relative,\n    ]\n  );\n}\n\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\nexport function useSearchParams(\n  defaultInit?: URLSearchParamsInit\n): [URLSearchParams, SetURLSearchParams] {\n  warning(\n    typeof URLSearchParams !== \"undefined\",\n    `You cannot use the \\`useSearchParams\\` hook in a browser that does not ` +\n      `support the URLSearchParams API. If you need to support Internet ` +\n      `Explorer 11, we recommend you load a polyfill such as ` +\n      `https://github.com/ungap/url-search-params\\n\\n` +\n      `If you're unsure how to load polyfills, we recommend you check out ` +\n      `https://polyfill.io/v3/ which provides some recommendations about how ` +\n      `to load polyfills only for users that need them, instead of for every ` +\n      `user.`\n  );\n\n  let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n  let hasSetSearchParamsRef = React.useRef(false);\n\n  let location = useLocation();\n  let searchParams = React.useMemo(\n    () =>\n      // Only merge in the defaults if we haven't yet called setSearchParams.\n      // Once we call that we want those to take precedence, otherwise you can't\n      // remove a param with setSearchParams({}) if it has an initial value\n      getSearchParamsForLocation(\n        location.search,\n        hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current\n      ),\n    [location.search]\n  );\n\n  let navigate = useNavigate();\n  let setSearchParams = React.useCallback<SetURLSearchParams>(\n    (nextInit, navigateOptions) => {\n      const newSearchParams = createSearchParams(\n        typeof nextInit === \"function\" ? nextInit(searchParams) : nextInit\n      );\n      hasSetSearchParamsRef.current = true;\n      navigate(\"?\" + newSearchParams, navigateOptions);\n    },\n    [navigate, searchParams]\n  );\n\n  return [searchParams, setSearchParams];\n}\n\nexport type SetURLSearchParams = (\n  nextInit?:\n    | URLSearchParamsInit\n    | ((prev: URLSearchParams) => URLSearchParamsInit),\n  navigateOpts?: NavigateOptions\n) => void;\n\n/**\n * Submits a HTML `<form>` to the server without reloading the page.\n */\nexport interface SubmitFunction {\n  (\n    /**\n     * Specifies the `<form>` to be submitted to the server, a specific\n     * `<button>` or `<input type=\"submit\">` to use to submit the form, or some\n     * arbitrary data to submit.\n     *\n     * Note: When using a `<button>` its `name` and `value` will also be\n     * included in the form data that is submitted.\n     */\n    target: SubmitTarget,\n\n    /**\n     * Options that override the `<form>`'s own attributes. Required when\n     * submitting arbitrary data without a backing `<form>`.\n     */\n    options?: SubmitOptions\n  ): void;\n}\n\n/**\n * Submits a fetcher `<form>` to the server without reloading the page.\n */\nexport interface FetcherSubmitFunction {\n  (\n    target: SubmitTarget,\n    // Fetchers cannot replace because they are not navigation events\n    options?: Omit<SubmitOptions, \"replace\">\n  ): void;\n}\n\nfunction validateClientSideSubmission() {\n  if (typeof document === \"undefined\") {\n    throw new Error(\n      \"You are calling submit during the server render. \" +\n        \"Try calling submit within a `useEffect` or callback instead.\"\n    );\n  }\n}\n\n/**\n * Returns a function that may be used to programmatically submit a form (or\n * some arbitrary data) to the server.\n */\nexport function useSubmit(): SubmitFunction {\n  let { router } = useDataRouterContext(DataRouterHook.UseSubmit);\n  let { basename } = React.useContext(NavigationContext);\n  let currentRouteId = useRouteId();\n\n  return React.useCallback<SubmitFunction>(\n    (target, options = {}) => {\n      validateClientSideSubmission();\n\n      let { action, method, encType, formData, body } = getFormSubmissionInfo(\n        target,\n        basename\n      );\n\n      router.navigate(options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || (method as HTMLFormMethod),\n        formEncType: options.encType || (encType as FormEncType),\n        replace: options.replace,\n        fromRouteId: currentRouteId,\n      });\n    },\n    [router, basename, currentRouteId]\n  );\n}\n\n/**\n * Returns the implementation for fetcher.submit\n */\nfunction useSubmitFetcher(\n  fetcherKey: string,\n  fetcherRouteId: string\n): FetcherSubmitFunction {\n  let { router } = useDataRouterContext(DataRouterHook.UseSubmitFetcher);\n  let { basename } = React.useContext(NavigationContext);\n\n  return React.useCallback<FetcherSubmitFunction>(\n    (target, options = {}) => {\n      validateClientSideSubmission();\n\n      let { action, method, encType, formData, body } = getFormSubmissionInfo(\n        target,\n        basename\n      );\n\n      invariant(\n        fetcherRouteId != null,\n        \"No routeId available for useFetcher()\"\n      );\n      router.fetch(fetcherKey, fetcherRouteId, options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || (method as HTMLFormMethod),\n        formEncType: options.encType || (encType as FormEncType),\n      });\n    },\n    [router, basename, fetcherKey, fetcherRouteId]\n  );\n}\n\n// v7: Eventually we should deprecate this entirely in favor of using the\n// router method directly?\nexport function useFormAction(\n  action?: string,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): string {\n  let { basename } = React.useContext(NavigationContext);\n  let routeContext = React.useContext(RouteContext);\n  invariant(routeContext, \"useFormAction must be used inside a RouteContext\");\n\n  let [match] = routeContext.matches.slice(-1);\n  // Shallow clone path so we can modify it below, otherwise we modify the\n  // object referenced by useMemo inside useResolvedPath\n  let path = { ...useResolvedPath(action ? action : \".\", { relative }) };\n\n  // Previously we set the default action to \".\". The problem with this is that\n  // `useResolvedPath(\".\")` excludes search params and the hash of the resolved\n  // URL. This is the intended behavior of when \".\" is specifically provided as\n  // the form action, but inconsistent w/ browsers when the action is omitted.\n  // https://github.com/remix-run/remix/issues/927\n  let location = useLocation();\n  if (action == null) {\n    // Safe to write to these directly here since if action was undefined, we\n    // would have called useResolvedPath(\".\") which will never include a search\n    // or hash\n    path.search = location.search;\n    path.hash = location.hash;\n\n    // When grabbing search params from the URL, remove the automatically\n    // inserted ?index param so we match the useResolvedPath search behavior\n    // which would not include ?index\n    if (match.route.index) {\n      let params = new URLSearchParams(path.search);\n      params.delete(\"index\");\n      path.search = params.toString() ? `?${params.toString()}` : \"\";\n    }\n  }\n\n  if ((!action || action === \".\") && match.route.index) {\n    path.search = path.search\n      ? path.search.replace(/^\\?/, \"?index&\")\n      : \"?index\";\n  }\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the form action.  If this is a root navigation, then just use\n  // the raw basename which allows the basename to have full control over the\n  // presence of a trailing slash on root actions\n  if (basename !== \"/\") {\n    path.pathname =\n      path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\nfunction createFetcherForm(fetcherKey: string, routeId: string) {\n  let FetcherForm = React.forwardRef<HTMLFormElement, FormProps>(\n    (props, ref) => {\n      let submit = useSubmitFetcher(fetcherKey, routeId);\n      return <FormImpl {...props} ref={ref} submit={submit} />;\n    }\n  );\n  if (__DEV__) {\n    FetcherForm.displayName = \"fetcher.Form\";\n  }\n  return FetcherForm;\n}\n\nlet fetcherId = 0;\n\nexport type FetcherWithComponents<TData> = Fetcher<TData> & {\n  Form: ReturnType<typeof createFetcherForm>;\n  submit: FetcherSubmitFunction;\n  load: (href: string) => void;\n};\n\n/**\n * Interacts with route loaders and actions without causing a navigation. Great\n * for any interaction that stays on the same page.\n */\nexport function useFetcher<TData = any>(): FetcherWithComponents<TData> {\n  let { router } = useDataRouterContext(DataRouterHook.UseFetcher);\n\n  let route = React.useContext(RouteContext);\n  invariant(route, `useFetcher must be used inside a RouteContext`);\n\n  let routeId = route.matches[route.matches.length - 1]?.route.id;\n  invariant(\n    routeId != null,\n    `useFetcher can only be used on routes that contain a unique \"id\"`\n  );\n\n  let [fetcherKey] = React.useState(() => String(++fetcherId));\n  let [Form] = React.useState(() => {\n    invariant(routeId, `No routeId available for fetcher.Form()`);\n    return createFetcherForm(fetcherKey, routeId);\n  });\n  let [load] = React.useState(() => (href: string) => {\n    invariant(router, \"No router available for fetcher.load()\");\n    invariant(routeId, \"No routeId available for fetcher.load()\");\n    router.fetch(fetcherKey, routeId, href);\n  });\n  let submit = useSubmitFetcher(fetcherKey, routeId);\n\n  let fetcher = router.getFetcher<TData>(fetcherKey);\n\n  let fetcherWithComponents = React.useMemo(\n    () => ({\n      Form,\n      submit,\n      load,\n      ...fetcher,\n    }),\n    [fetcher, Form, submit, load]\n  );\n\n  React.useEffect(() => {\n    // Is this busted when the React team gets real weird and calls effects\n    // twice on mount?  We really just need to garbage collect here when this\n    // fetcher is no longer around.\n    return () => {\n      if (!router) {\n        console.warn(`No router available to clean up from useFetcher()`);\n        return;\n      }\n      router.deleteFetcher(fetcherKey);\n    };\n  }, [router, fetcherKey]);\n\n  return fetcherWithComponents;\n}\n\n/**\n * Provides all fetchers currently on the page. Useful for layouts and parent\n * routes that need to provide pending/optimistic UI regarding the fetch.\n */\nexport function useFetchers(): Fetcher[] {\n  let state = useDataRouterState(DataRouterStateHook.UseFetchers);\n  return [...state.fetchers.values()];\n}\n\nconst SCROLL_RESTORATION_STORAGE_KEY = \"react-router-scroll-positions\";\nlet savedScrollPositions: Record<string, number> = {};\n\n/**\n * When rendered inside a RouterProvider, will restore scroll positions on navigations\n */\nfunction useScrollRestoration({\n  getKey,\n  storageKey,\n}: {\n  getKey?: GetScrollRestorationKeyFunction;\n  storageKey?: string;\n} = {}) {\n  let { router } = useDataRouterContext(DataRouterHook.UseScrollRestoration);\n  let { restoreScrollPosition, preventScrollReset } = useDataRouterState(\n    DataRouterStateHook.UseScrollRestoration\n  );\n  let { basename } = React.useContext(NavigationContext);\n  let location = useLocation();\n  let matches = useMatches();\n  let navigation = useNavigation();\n\n  // Trigger manual scroll restoration while we're active\n  React.useEffect(() => {\n    window.history.scrollRestoration = \"manual\";\n    return () => {\n      window.history.scrollRestoration = \"auto\";\n    };\n  }, []);\n\n  // Save positions on pagehide\n  usePageHide(\n    React.useCallback(() => {\n      if (navigation.state === \"idle\") {\n        let key = (getKey ? getKey(location, matches) : null) || location.key;\n        savedScrollPositions[key] = window.scrollY;\n      }\n      sessionStorage.setItem(\n        storageKey || SCROLL_RESTORATION_STORAGE_KEY,\n        JSON.stringify(savedScrollPositions)\n      );\n      window.history.scrollRestoration = \"auto\";\n    }, [storageKey, getKey, navigation.state, location, matches])\n  );\n\n  // Read in any saved scroll locations\n  if (typeof document !== \"undefined\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      try {\n        let sessionPositions = sessionStorage.getItem(\n          storageKey || SCROLL_RESTORATION_STORAGE_KEY\n        );\n        if (sessionPositions) {\n          savedScrollPositions = JSON.parse(sessionPositions);\n        }\n      } catch (e) {\n        // no-op, use default empty object\n      }\n    }, [storageKey]);\n\n    // Enable scroll restoration in the router\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      let getKeyWithoutBasename: GetScrollRestorationKeyFunction | undefined =\n        getKey && basename !== \"/\"\n          ? (location, matches) =>\n              getKey(\n                // Strip the basename to match useLocation()\n                {\n                  ...location,\n                  pathname:\n                    stripBasename(location.pathname, basename) ||\n                    location.pathname,\n                },\n                matches\n              )\n          : getKey;\n      let disableScrollRestoration = router?.enableScrollRestoration(\n        savedScrollPositions,\n        () => window.scrollY,\n        getKeyWithoutBasename\n      );\n      return () => disableScrollRestoration && disableScrollRestoration();\n    }, [router, basename, getKey]);\n\n    // Restore scrolling when state.restoreScrollPosition changes\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      // Explicit false means don't do anything (used for submissions)\n      if (restoreScrollPosition === false) {\n        return;\n      }\n\n      // been here before, scroll to it\n      if (typeof restoreScrollPosition === \"number\") {\n        window.scrollTo(0, restoreScrollPosition);\n        return;\n      }\n\n      // try to scroll to the hash\n      if (location.hash) {\n        let el = document.getElementById(location.hash.slice(1));\n        if (el) {\n          el.scrollIntoView();\n          return;\n        }\n      }\n\n      // Don't reset if this navigation opted out\n      if (preventScrollReset === true) {\n        return;\n      }\n\n      // otherwise go to the top on new locations\n      window.scrollTo(0, 0);\n    }, [location, restoreScrollPosition, preventScrollReset]);\n  }\n}\n\nexport { useScrollRestoration as UNSAFE_useScrollRestoration };\n\n/**\n * Setup a callback to be fired on the window's `beforeunload` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nexport function useBeforeUnload(\n  callback: (event: BeforeUnloadEvent) => any,\n  options?: { capture?: boolean }\n): void {\n  let { capture } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? { capture } : undefined;\n    window.addEventListener(\"beforeunload\", callback, opts);\n    return () => {\n      window.removeEventListener(\"beforeunload\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n\n/**\n * Setup a callback to be fired on the window's `pagehide` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.  This event is better supported than beforeunload across browsers.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction usePageHide(\n  callback: (event: PageTransitionEvent) => any,\n  options?: { capture?: boolean }\n): void {\n  let { capture } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? { capture } : undefined;\n    window.addEventListener(\"pagehide\", callback, opts);\n    return () => {\n      window.removeEventListener(\"pagehide\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n\n/**\n * Wrapper around useBlocker to show a window.confirm prompt to users instead\n * of building a custom UI with useBlocker.\n *\n * Warning: This has *a lot of rough edges* and behaves very differently (and\n * very incorrectly in some cases) across browsers if user click addition\n * back/forward navigations while the confirm is open.  Use at your own risk.\n */\nfunction usePrompt({ when, message }: { when: boolean; message: string }) {\n  let blocker = useBlocker(when);\n\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\" && !when) {\n      blocker.reset();\n    }\n  }, [blocker, when]);\n\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\") {\n      let proceed = window.confirm(message);\n      if (proceed) {\n        setTimeout(blocker.proceed, 0);\n      } else {\n        blocker.reset();\n      }\n    }\n  }, [blocker, message]);\n}\n\nexport { usePrompt as unstable_usePrompt };\n\n//#endregion\n","import * as React from \"react\";\nimport type {\n  AgnosticRouteMatch,\n  AgnosticIndexRouteObject,\n  AgnosticNonIndexRouteObject,\n  History,\n  Location,\n  RelativeRoutingType,\n  Router,\n  StaticHandlerContext,\n  To,\n  TrackedPromise,\n  LazyRouteFunction,\n} from \"@remix-run/router\";\nimport type { Action as NavigationType } from \"@remix-run/router\";\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nexport interface IndexRouteObject {\n  caseSensitive?: AgnosticIndexRouteObject[\"caseSensitive\"];\n  path?: AgnosticIndexRouteObject[\"path\"];\n  id?: AgnosticIndexRouteObject[\"id\"];\n  loader?: AgnosticIndexRouteObject[\"loader\"];\n  action?: AgnosticIndexRouteObject[\"action\"];\n  hasErrorBoundary?: AgnosticIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: AgnosticIndexRouteObject[\"shouldRevalidate\"];\n  handle?: AgnosticIndexRouteObject[\"handle\"];\n  index: true;\n  children?: undefined;\n  element?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n  lazy?: LazyRouteFunction<IndexRouteObject>;\n}\n\nexport interface NonIndexRouteObject {\n  caseSensitive?: AgnosticNonIndexRouteObject[\"caseSensitive\"];\n  path?: AgnosticNonIndexRouteObject[\"path\"];\n  id?: AgnosticNonIndexRouteObject[\"id\"];\n  loader?: AgnosticNonIndexRouteObject[\"loader\"];\n  action?: AgnosticNonIndexRouteObject[\"action\"];\n  hasErrorBoundary?: AgnosticNonIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: AgnosticNonIndexRouteObject[\"shouldRevalidate\"];\n  handle?: AgnosticNonIndexRouteObject[\"handle\"];\n  index?: false;\n  children?: RouteObject[];\n  element?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n  lazy?: LazyRouteFunction<NonIndexRouteObject>;\n}\n\nexport type RouteObject = IndexRouteObject | NonIndexRouteObject;\n\nexport type DataRouteObject = RouteObject & {\n  children?: DataRouteObject[];\n  id: string;\n};\n\nexport interface RouteMatch<\n  ParamKey extends string = string,\n  RouteObjectType extends RouteObject = RouteObject\n> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {}\n\nexport interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {}\n\nexport interface DataRouterContextObject extends NavigationContextObject {\n  router: Router;\n  staticContext?: StaticHandlerContext;\n}\n\nexport const DataRouterContext =\n  React.createContext<DataRouterContextObject | null>(null);\nif (__DEV__) {\n  DataRouterContext.displayName = \"DataRouter\";\n}\n\nexport const DataRouterStateContext = React.createContext<\n  Router[\"state\"] | null\n>(null);\nif (__DEV__) {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\n\nexport const AwaitContext = React.createContext<TrackedPromise | null>(null);\nif (__DEV__) {\n  AwaitContext.displayName = \"Await\";\n}\n\nexport interface NavigateOptions {\n  replace?: boolean;\n  state?: any;\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level <Router> API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport interface Navigator {\n  createHref: History[\"createHref\"];\n  // Optional for backwards-compat with Router/HistoryRouter usage (edge case)\n  encodeLocation?: History[\"encodeLocation\"];\n  go: History[\"go\"];\n  push(to: To, state?: any, opts?: NavigateOptions): void;\n  replace(to: To, state?: any, opts?: NavigateOptions): void;\n}\n\ninterface NavigationContextObject {\n  basename: string;\n  navigator: Navigator;\n  static: boolean;\n}\n\nexport const NavigationContext = React.createContext<NavigationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n  location: Location;\n  navigationType: NavigationType;\n}\n\nexport const LocationContext = React.createContext<LocationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  LocationContext.displayName = \"Location\";\n}\n\nexport interface RouteContextObject {\n  outlet: React.ReactElement | null;\n  matches: RouteMatch[];\n  isDataRoute: boolean;\n}\n\nexport const RouteContext = React.createContext<RouteContextObject>({\n  outlet: null,\n  matches: [],\n  isDataRoute: false,\n});\n\nif (__DEV__) {\n  RouteContext.displayName = \"Route\";\n}\n\nexport const RouteErrorContext = React.createContext<any>(null);\n\nif (__DEV__) {\n  RouteErrorContext.displayName = \"RouteError\";\n}\n","import * as React from \"react\";\nimport type {\n  Blocker,\n  BlockerFunction,\n  Location,\n  ParamParseKey,\n  Params,\n  Path,\n  PathMatch,\n  PathPattern,\n  RelativeRoutingType,\n  Router as RemixRouter,\n  RevalidationState,\n  To,\n} from \"@remix-run/router\";\nimport {\n  Action as NavigationType,\n  UNSAFE_invariant as invariant,\n  isRouteErrorResponse,\n  joinPaths,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  resolveTo,\n  stripBasename,\n  IDLE_BLOCKER,\n  UNSAFE_getPathContributingMatches as getPathContributingMatches,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n  NavigateOptions,\n  RouteContextObject,\n  RouteMatch,\n  RouteObject,\n  DataRouteMatch,\n} from \"./context\";\nimport {\n  DataRouterContext,\n  DataRouterStateContext,\n  LocationContext,\n  NavigationContext,\n  RouteContext,\n  RouteErrorContext,\n  AwaitContext,\n} from \"./context\";\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/hooks/use-href\n */\nexport function useHref(\n  to: To,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): string {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useHref() may be used only in the context of a <Router> component.`\n  );\n\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { hash, pathname, search } = useResolvedPath(to, { relative });\n\n  let joinedPathname = pathname;\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the href.  If this is a root navigation, then just use the raw\n  // basename which allows the basename to have full control over the presence\n  // of a trailing slash on root links\n  if (basename !== \"/\") {\n    joinedPathname =\n      pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a <Router>.\n *\n * @see https://reactrouter.com/hooks/use-in-router-context\n */\nexport function useInRouterContext(): boolean {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/hooks/use-location\n */\nexport function useLocation(): Location {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useLocation() may be used only in the context of a <Router> component.`\n  );\n\n  return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/hooks/use-navigation-type\n */\nexport function useNavigationType(): NavigationType {\n  return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * <NavLink>.\n *\n * @see https://reactrouter.com/hooks/use-match\n */\nexport function useMatch<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useMatch() may be used only in the context of a <Router> component.`\n  );\n\n  let { pathname } = useLocation();\n  return React.useMemo(\n    () => matchPath<ParamKey, Path>(pattern, pathname),\n    [pathname, pattern]\n  );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n  (to: To, options?: NavigateOptions): void;\n  (delta: number): void;\n}\n\nconst navigateEffectWarning =\n  `You should call navigate() in a React.useEffect(), not when ` +\n  `your component is first rendered.`;\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(\n  cb: Parameters<typeof React.useLayoutEffect>[0]\n) {\n  let isStatic = React.useContext(NavigationContext).static;\n  if (!isStatic) {\n    // We should be able to get rid of this once react 18.3 is released\n    // See: https://github.com/facebook/react/pull/26395\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(cb);\n  }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by <Link>s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/hooks/use-navigate\n */\nexport function useNavigate(): NavigateFunction {\n  let { isDataRoute } = React.useContext(RouteContext);\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\n\nfunction useNavigateUnstable(): NavigateFunction {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useNavigate() may be used only in the context of a <Router> component.`\n  );\n\n  let dataRouterContext = React.useContext(DataRouterContext);\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    getPathContributingMatches(matches).map((match) => match.pathnameBase)\n  );\n\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(activeRef.current, navigateEffectWarning);\n\n      // Short circuit here since if this happens on first render the navigate\n      // is useless because we haven't wired up our history listener yet\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        navigator.go(to);\n        return;\n      }\n\n      let path = resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname,\n        options.relative === \"path\"\n      );\n\n      // If we're operating within a basename, prepend it to the pathname prior\n      // to handing off to history (but only if we're not in a data router,\n      // otherwise it'll prepend the basename inside of the router).\n      // If this is a root navigation, then we navigate to the raw basename\n      // which allows the basename to have full control over the presence of a\n      // trailing slash on root links\n      if (dataRouterContext == null && basename !== \"/\") {\n        path.pathname =\n          path.pathname === \"/\"\n            ? basename\n            : joinPaths([basename, path.pathname]);\n      }\n\n      (!!options.replace ? navigator.replace : navigator.push)(\n        path,\n        options.state,\n        options\n      );\n    },\n    [\n      basename,\n      navigator,\n      routePathnamesJson,\n      locationPathname,\n      dataRouterContext,\n    ]\n  );\n\n  return navigate;\n}\n\nconst OutletContext = React.createContext<unknown>(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/hooks/use-outlet-context\n */\nexport function useOutletContext<Context = unknown>(): Context {\n  return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by <Outlet> to render child routes.\n *\n * @see https://reactrouter.com/hooks/use-outlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return (\n      <OutletContext.Provider value={context}>{outlet}</OutletContext.Provider>\n    );\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/hooks/use-params\n */\nexport function useParams<\n  ParamsOrKey extends string | Record<string, string | undefined> = string\n>(): Readonly<\n  [ParamsOrKey] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>\n> {\n  let { matches } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/hooks/use-resolved-path\n */\nexport function useResolvedPath(\n  to: To,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): Path {\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    getPathContributingMatches(matches).map((match) => match.pathnameBase)\n  );\n\n  return React.useMemo(\n    () =>\n      resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname,\n        relative === \"path\"\n      ),\n    [to, routePathnamesJson, locationPathname, relative]\n  );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an <Outlet> to render their child route's\n * element.\n *\n * @see https://reactrouter.com/hooks/use-routes\n */\nexport function useRoutes(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string\n): React.ReactElement | null {\n  return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nexport function useRoutesImpl(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string,\n  dataRouterState?: RemixRouter[\"state\"]\n): React.ReactElement | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useRoutes() may be used only in the context of a <Router> component.`\n  );\n\n  let { navigator } = React.useContext(NavigationContext);\n  let { matches: parentMatches } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n\n  if (__DEV__) {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = (parentRoute && parentRoute.path) || \"\";\n    warningOnce(\n      parentPathname,\n      !parentRoute || parentPath.endsWith(\"*\"),\n      `You rendered descendant <Routes> (or called \\`useRoutes()\\`) at ` +\n        `\"${parentPathname}\" (under <Route path=\"${parentPath}\">) but the ` +\n        `parent route path has no trailing \"*\". This means if you navigate ` +\n        `deeper, the parent won't match anymore and therefore the child ` +\n        `routes will never render.\\n\\n` +\n        `Please change the parent <Route path=\"${parentPath}\"> to <Route ` +\n        `path=\"${parentPath === \"/\" ? \"*\" : `${parentPath}/*`}\">.`\n    );\n  }\n\n  let locationFromContext = useLocation();\n\n  let location;\n  if (locationArg) {\n    let parsedLocationArg =\n      typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n    invariant(\n      parentPathnameBase === \"/\" ||\n        parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n      `When overriding the location using \\`<Routes location>\\` or \\`useRoutes(routes, location)\\`, ` +\n        `the location pathname must begin with the portion of the URL pathname that was ` +\n        `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n        `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n    );\n\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\n  let pathname = location.pathname || \"/\";\n  let remainingPathname =\n    parentPathnameBase === \"/\"\n      ? pathname\n      : pathname.slice(parentPathnameBase.length) || \"/\";\n\n  let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n  if (__DEV__) {\n    warning(\n      parentRoute || matches != null,\n      `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n    );\n\n    warning(\n      matches == null ||\n        matches[matches.length - 1].route.element !== undefined ||\n        matches[matches.length - 1].route.Component !== undefined,\n      `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" ` +\n        `does not have an element or Component. This means it will render an <Outlet /> with a ` +\n        `null value by default resulting in an \"empty\" page.`\n    );\n  }\n\n  let renderedMatches = _renderMatches(\n    matches &&\n      matches.map((match) =>\n        Object.assign({}, match, {\n          params: Object.assign({}, parentParams, match.params),\n          pathname: joinPaths([\n            parentPathnameBase,\n            // Re-encode pathnames that were decoded inside matchRoutes\n            navigator.encodeLocation\n              ? navigator.encodeLocation(match.pathname).pathname\n              : match.pathname,\n          ]),\n          pathnameBase:\n            match.pathnameBase === \"/\"\n              ? parentPathnameBase\n              : joinPaths([\n                  parentPathnameBase,\n                  // Re-encode pathnames that were decoded inside matchRoutes\n                  navigator.encodeLocation\n                    ? navigator.encodeLocation(match.pathnameBase).pathname\n                    : match.pathnameBase,\n                ]),\n        })\n      ),\n    parentMatches,\n    dataRouterState\n  );\n\n  // When a user passes in a `locationArg`, the associated routes need to\n  // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n  // to use the scoped location instead of the global location.\n  if (locationArg && renderedMatches) {\n    return (\n      <LocationContext.Provider\n        value={{\n          location: {\n            pathname: \"/\",\n            search: \"\",\n            hash: \"\",\n            state: null,\n            key: \"default\",\n            ...location,\n          },\n          navigationType: NavigationType.Pop,\n        }}\n      >\n        {renderedMatches}\n      </LocationContext.Provider>\n    );\n  }\n\n  return renderedMatches;\n}\n\nfunction DefaultErrorComponent() {\n  let error = useRouteError();\n  let message = isRouteErrorResponse(error)\n    ? `${error.status} ${error.statusText}`\n    : error instanceof Error\n    ? error.message\n    : JSON.stringify(error);\n  let stack = error instanceof Error ? error.stack : null;\n  let lightgrey = \"rgba(200,200,200, 0.5)\";\n  let preStyles = { padding: \"0.5rem\", backgroundColor: lightgrey };\n  let codeStyles = { padding: \"2px 4px\", backgroundColor: lightgrey };\n\n  let devInfo = null;\n  if (__DEV__) {\n    console.error(\n      \"Error handled by React Router default ErrorBoundary:\",\n      error\n    );\n\n    devInfo = (\n      <>\n        <p>💿 Hey developer 👋</p>\n        <p>\n          You can provide a way better UX than this when your app throws errors\n          by providing your own <code style={codeStyles}>ErrorBoundary</code> or{\" \"}\n          <code style={codeStyles}>errorElement</code> prop on your route.\n        </p>\n      </>\n    );\n  }\n\n  return (\n    <>\n      <h2>Unexpected Application Error!</h2>\n      <h3 style={{ fontStyle: \"italic\" }}>{message}</h3>\n      {stack ? <pre style={preStyles}>{stack}</pre> : null}\n      {devInfo}\n    </>\n  );\n}\n\nconst defaultErrorElement = <DefaultErrorComponent />;\n\ntype RenderErrorBoundaryProps = React.PropsWithChildren<{\n  location: Location;\n  revalidation: RevalidationState;\n  error: any;\n  component: React.ReactNode;\n  routeContext: RouteContextObject;\n}>;\n\ntype RenderErrorBoundaryState = {\n  location: Location;\n  revalidation: RevalidationState;\n  error: any;\n};\n\nexport class RenderErrorBoundary extends React.Component<\n  RenderErrorBoundaryProps,\n  RenderErrorBoundaryState\n> {\n  constructor(props: RenderErrorBoundaryProps) {\n    super(props);\n    this.state = {\n      location: props.location,\n      revalidation: props.revalidation,\n      error: props.error,\n    };\n  }\n\n  static getDerivedStateFromError(error: any) {\n    return { error: error };\n  }\n\n  static getDerivedStateFromProps(\n    props: RenderErrorBoundaryProps,\n    state: RenderErrorBoundaryState\n  ) {\n    // When we get into an error state, the user will likely click \"back\" to the\n    // previous page that didn't have an error. Because this wraps the entire\n    // application, that will have no effect--the error page continues to display.\n    // This gives us a mechanism to recover from the error when the location changes.\n    //\n    // Whether we're in an error state or not, we update the location in state\n    // so that when we are in an error state, it gets reset when a new location\n    // comes in and the user recovers from the error.\n    if (\n      state.location !== props.location ||\n      (state.revalidation !== \"idle\" && props.revalidation === \"idle\")\n    ) {\n      return {\n        error: props.error,\n        location: props.location,\n        revalidation: props.revalidation,\n      };\n    }\n\n    // If we're not changing locations, preserve the location but still surface\n    // any new errors that may come through. We retain the existing error, we do\n    // this because the error provided from the app state may be cleared without\n    // the location changing.\n    return {\n      error: props.error || state.error,\n      location: state.location,\n      revalidation: props.revalidation || state.revalidation,\n    };\n  }\n\n  componentDidCatch(error: any, errorInfo: any) {\n    console.error(\n      \"React Router caught the following error during render\",\n      error,\n      errorInfo\n    );\n  }\n\n  render() {\n    return this.state.error ? (\n      <RouteContext.Provider value={this.props.routeContext}>\n        <RouteErrorContext.Provider\n          value={this.state.error}\n          children={this.props.component}\n        />\n      </RouteContext.Provider>\n    ) : (\n      this.props.children\n    );\n  }\n}\n\ninterface RenderedRouteProps {\n  routeContext: RouteContextObject;\n  match: RouteMatch<string, RouteObject>;\n  children: React.ReactNode | null;\n}\n\nfunction RenderedRoute({ routeContext, match, children }: RenderedRouteProps) {\n  let dataRouterContext = React.useContext(DataRouterContext);\n\n  // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n  if (\n    dataRouterContext &&\n    dataRouterContext.static &&\n    dataRouterContext.staticContext &&\n    (match.route.errorElement || match.route.ErrorBoundary)\n  ) {\n    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n  }\n\n  return (\n    <RouteContext.Provider value={routeContext}>\n      {children}\n    </RouteContext.Provider>\n  );\n}\n\nexport function _renderMatches(\n  matches: RouteMatch[] | null,\n  parentMatches: RouteMatch[] = [],\n  dataRouterState: RemixRouter[\"state\"] | null = null\n): React.ReactElement | null {\n  if (matches == null) {\n    if (dataRouterState?.errors) {\n      // Don't bail if we have data router errors so we can render them in the\n      // boundary.  Use the pre-matched (or shimmed) matches\n      matches = dataRouterState.matches as DataRouteMatch[];\n    } else {\n      return null;\n    }\n  }\n\n  let renderedMatches = matches;\n\n  // If we have data errors, trim matches to the highest error boundary\n  let errors = dataRouterState?.errors;\n  if (errors != null) {\n    let errorIndex = renderedMatches.findIndex(\n      (m) => m.route.id && errors?.[m.route.id]\n    );\n    invariant(\n      errorIndex >= 0,\n      `Could not find a matching route for errors on route IDs: ${Object.keys(\n        errors\n      ).join(\",\")}`\n    );\n    renderedMatches = renderedMatches.slice(\n      0,\n      Math.min(renderedMatches.length, errorIndex + 1)\n    );\n  }\n\n  return renderedMatches.reduceRight((outlet, match, index) => {\n    let error = match.route.id ? errors?.[match.route.id] : null;\n    // Only data routers handle errors\n    let errorElement: React.ReactNode | null = null;\n    if (dataRouterState) {\n      errorElement = match.route.errorElement || defaultErrorElement;\n    }\n    let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n    let getChildren = () => {\n      let children: React.ReactNode;\n      if (error) {\n        children = errorElement;\n      } else if (match.route.Component) {\n        // Note: This is a de-optimized path since React won't re-use the\n        // ReactElement since it's identity changes with each new\n        // React.createElement call.  We keep this so folks can use\n        // `<Route Component={...}>` in `<Routes>` but generally `Component`\n        // usage is only advised in `RouterProvider` when we can convert it to\n        // `element` ahead of time.\n        children = <match.route.Component />;\n      } else if (match.route.element) {\n        children = match.route.element;\n      } else {\n        children = outlet;\n      }\n      return (\n        <RenderedRoute\n          match={match}\n          routeContext={{\n            outlet,\n            matches,\n            isDataRoute: dataRouterState != null,\n          }}\n          children={children}\n        />\n      );\n    };\n    // Only wrap in an error boundary within data router usages when we have an\n    // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to\n    // an ancestor ErrorBoundary/errorElement\n    return dataRouterState &&\n      (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? (\n      <RenderErrorBoundary\n        location={dataRouterState.location}\n        revalidation={dataRouterState.revalidation}\n        component={errorElement}\n        error={error}\n        children={getChildren()}\n        routeContext={{ outlet: null, matches, isDataRoute: true }}\n      />\n    ) : (\n      getChildren()\n    );\n  }, null as React.ReactElement | null);\n}\n\nenum DataRouterHook {\n  UseBlocker = \"useBlocker\",\n  UseRevalidator = \"useRevalidator\",\n  UseNavigateStable = \"useNavigate\",\n}\n\nenum DataRouterStateHook {\n  UseBlocker = \"useBlocker\",\n  UseLoaderData = \"useLoaderData\",\n  UseActionData = \"useActionData\",\n  UseRouteError = \"useRouteError\",\n  UseNavigation = \"useNavigation\",\n  UseRouteLoaderData = \"useRouteLoaderData\",\n  UseMatches = \"useMatches\",\n  UseRevalidator = \"useRevalidator\",\n  UseNavigateStable = \"useNavigate\",\n  UseRouteId = \"useRouteId\",\n}\n\nfunction getDataRouterConsoleError(\n  hookName: DataRouterHook | DataRouterStateHook\n) {\n  return `${hookName} must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.`;\n}\n\nfunction useDataRouterContext(hookName: DataRouterHook) {\n  let ctx = React.useContext(DataRouterContext);\n  invariant(ctx, getDataRouterConsoleError(hookName));\n  return ctx;\n}\n\nfunction useDataRouterState(hookName: DataRouterStateHook) {\n  let state = React.useContext(DataRouterStateContext);\n  invariant(state, getDataRouterConsoleError(hookName));\n  return state;\n}\n\nfunction useRouteContext(hookName: DataRouterStateHook) {\n  let route = React.useContext(RouteContext);\n  invariant(route, getDataRouterConsoleError(hookName));\n  return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName: DataRouterStateHook) {\n  let route = useRouteContext(hookName);\n  let thisRoute = route.matches[route.matches.length - 1];\n  invariant(\n    thisRoute.route.id,\n    `${hookName} can only be used on routes that contain a unique \"id\"`\n  );\n  return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nexport function useRouteId() {\n  return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nexport function useNavigation() {\n  let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n  return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nexport function useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return {\n    revalidate: dataRouterContext.router.revalidate,\n    state: state.revalidation,\n  };\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nexport function useMatches() {\n  let { matches, loaderData } = useDataRouterState(\n    DataRouterStateHook.UseMatches\n  );\n  return React.useMemo(\n    () =>\n      matches.map((match) => {\n        let { pathname, params } = match;\n        // Note: This structure matches that created by createUseMatchesMatch\n        // in the @remix-run/router , so if you change this please also change\n        // that :)  Eventually we'll DRY this up\n        return {\n          id: match.route.id,\n          pathname,\n          params,\n          data: loaderData[match.route.id] as unknown,\n          handle: match.route.handle as unknown,\n        };\n      }),\n    [matches, loaderData]\n  );\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nexport function useLoaderData(): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n\n  if (state.errors && state.errors[routeId] != null) {\n    console.error(\n      `You cannot \\`useLoaderData\\` in an errorElement (routeId: ${routeId})`\n    );\n    return undefined;\n  }\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nexport function useRouteLoaderData(routeId: string): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nexport function useActionData(): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseActionData);\n\n  let route = React.useContext(RouteContext);\n  invariant(route, `useActionData must be used inside a RouteContext`);\n\n  return Object.values(state?.actionData || {})[0];\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error.  This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nexport function useRouteError(): unknown {\n  let error = React.useContext(RouteErrorContext);\n  let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n  // If this was a render error, we put it in a RouteError context inside\n  // of RenderErrorBoundary\n  if (error) {\n    return error;\n  }\n\n  // Otherwise look for errors from our data router state\n  return state.errors?.[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor <Await /> value\n */\nexport function useAsyncValue(): unknown {\n  let value = React.useContext(AwaitContext);\n  return value?._data;\n}\n\n/**\n * Returns the error from the nearest ancestor <Await /> value\n */\nexport function useAsyncError(): unknown {\n  let value = React.useContext(AwaitContext);\n  return value?._error;\n}\n\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation.  Mostly used to avoid\n * using half-filled form data.  This does not handle hard-reloads or\n * cross-origin navigations.\n */\nexport function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker {\n  let { router, basename } = useDataRouterContext(DataRouterHook.UseBlocker);\n  let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n\n  let [blockerKey, setBlockerKey] = React.useState(\"\");\n  let blockerFunction = React.useCallback<BlockerFunction>(\n    (arg) => {\n      if (typeof shouldBlock !== \"function\") {\n        return !!shouldBlock;\n      }\n      if (basename === \"/\") {\n        return shouldBlock(arg);\n      }\n\n      // If they provided us a function and we've got an active basename, strip\n      // it from the locations we expose to the user to match the behavior of\n      // useLocation\n      let { currentLocation, nextLocation, historyAction } = arg;\n      return shouldBlock({\n        currentLocation: {\n          ...currentLocation,\n          pathname:\n            stripBasename(currentLocation.pathname, basename) ||\n            currentLocation.pathname,\n        },\n        nextLocation: {\n          ...nextLocation,\n          pathname:\n            stripBasename(nextLocation.pathname, basename) ||\n            nextLocation.pathname,\n        },\n        historyAction,\n      });\n    },\n    [basename, shouldBlock]\n  );\n\n  // This effect is in charge of blocker key assignment and deletion (which is\n  // tightly coupled to the key)\n  React.useEffect(() => {\n    let key = String(++blockerId);\n    setBlockerKey(key);\n    return () => router.deleteBlocker(key);\n  }, [router]);\n\n  // This effect handles assigning the blockerFunction.  This is to handle\n  // unstable blocker function identities, and happens only after the prior\n  // effect so we don't get an orphaned blockerFunction in the router with a\n  // key of \"\".  Until then we just have the IDLE_BLOCKER.\n  React.useEffect(() => {\n    if (blockerKey !== \"\") {\n      router.getBlocker(blockerKey, blockerFunction);\n    }\n  }, [router, blockerKey, blockerFunction]);\n\n  // Prefer the blocker from `state` not `router.state` since DataRouterContext\n  // is memoized so this ensures we update on blocker state updates\n  return blockerKey && state.blockers.has(blockerKey)\n    ? state.blockers.get(blockerKey)!\n    : IDLE_BLOCKER;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable(): NavigateFunction {\n  let { router } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n  let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(activeRef.current, navigateEffectWarning);\n\n      // Short circuit here since if this happens on first render the navigate\n      // is useless because we haven't wired up our router subscriber yet\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        router.navigate(to);\n      } else {\n        router.navigate(to, { fromRouteId: id, ...options });\n      }\n    },\n    [router, id]\n  );\n\n  return navigate;\n}\n\nconst alreadyWarned: Record<string, boolean> = {};\n\nfunction warningOnce(key: string, cond: boolean, message: string) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    warning(false, message);\n  }\n}\n","import * as React from \"react\";\nimport type {\n  TrackedPromise,\n  InitialEntry,\n  Location,\n  MemoryHistory,\n  Router as RemixRouter,\n  To,\n  LazyRouteFunction,\n  RelativeRoutingType,\n  RouterState,\n} from \"@remix-run/router\";\nimport {\n  Action as NavigationType,\n  AbortedDeferredError,\n  createMemoryHistory,\n  UNSAFE_invariant as invariant,\n  parsePath,\n  resolveTo,\n  stripBasename,\n  UNSAFE_warning as warning,\n  UNSAFE_getPathContributingMatches as getPathContributingMatches,\n} from \"@remix-run/router\";\n\nimport type {\n  DataRouteObject,\n  IndexRouteObject,\n  RouteMatch,\n  RouteObject,\n  Navigator,\n  NonIndexRouteObject,\n} from \"./context\";\nimport {\n  LocationContext,\n  NavigationContext,\n  DataRouterContext,\n  DataRouterStateContext,\n  AwaitContext,\n  RouteContext,\n} from \"./context\";\nimport {\n  useAsyncValue,\n  useInRouterContext,\n  useNavigate,\n  useOutlet,\n  useRoutes,\n  _renderMatches,\n  useRoutesImpl,\n  useLocation,\n} from \"./hooks\";\n\nexport interface FutureConfig {\n  v7_startTransition: boolean;\n}\n\nexport interface RouterProviderProps {\n  fallbackElement?: React.ReactNode;\n  router: RemixRouter;\n  future?: FutureConfig;\n}\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nexport function RouterProvider({\n  fallbackElement,\n  router,\n  future,\n}: RouterProviderProps): React.ReactElement {\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  let [state, setStateImpl] = React.useState(router.state);\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: RouterState) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n\n  let navigator = React.useMemo((): Navigator => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: (n) => router.navigate(n),\n      push: (to, state, opts) =>\n        router.navigate(to, {\n          state,\n          preventScrollReset: opts?.preventScrollReset,\n        }),\n      replace: (to, state, opts) =>\n        router.navigate(to, {\n          replace: true,\n          state,\n          preventScrollReset: opts?.preventScrollReset,\n        }),\n    };\n  }, [router]);\n\n  let basename = router.basename || \"/\";\n\n  let dataRouterContext = React.useMemo(\n    () => ({\n      router,\n      navigator,\n      static: false,\n      basename,\n    }),\n    [router, navigator, basename]\n  );\n\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return (\n    <>\n      <DataRouterContext.Provider value={dataRouterContext}>\n        <DataRouterStateContext.Provider value={state}>\n          <Router\n            basename={basename}\n            location={state.location}\n            navigationType={state.historyAction}\n            navigator={navigator}\n          >\n            {state.initialized ? (\n              <DataRoutes routes={router.routes} state={state} />\n            ) : (\n              fallbackElement\n            )}\n          </Router>\n        </DataRouterStateContext.Provider>\n      </DataRouterContext.Provider>\n      {null}\n    </>\n  );\n}\n\nfunction DataRoutes({\n  routes,\n  state,\n}: {\n  routes: DataRouteObject[];\n  state: RouterState;\n}): React.ReactElement | null {\n  return useRoutesImpl(routes, undefined, state);\n}\n\nexport interface MemoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n  future?: FutureConfig;\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/router-components/memory-router\n */\nexport function MemoryRouter({\n  basename,\n  children,\n  initialEntries,\n  initialIndex,\n  future,\n}: MemoryRouterProps): React.ReactElement {\n  let historyRef = React.useRef<MemoryHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true,\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface NavigateProps {\n  to: To;\n  replace?: boolean;\n  state?: any;\n  relative?: RelativeRoutingType;\n}\n\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/components/navigate\n */\nexport function Navigate({\n  to,\n  replace,\n  state,\n  relative,\n}: NavigateProps): null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of\n    // the router loaded. We can help them understand how to avoid that.\n    `<Navigate> may be used only in the context of a <Router> component.`\n  );\n\n  warning(\n    !React.useContext(NavigationContext).static,\n    `<Navigate> must not be used on the initial render in a <StaticRouter>. ` +\n      `This is a no-op, but you should modify your code so the <Navigate> is ` +\n      `only ever rendered in response to some user interaction or state change.`\n  );\n\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n  let navigate = useNavigate();\n\n  // Resolve the path outside of the effect so that when effects run twice in\n  // StrictMode they navigate to the same place\n  let path = resolveTo(\n    to,\n    getPathContributingMatches(matches).map((match) => match.pathnameBase),\n    locationPathname,\n    relative === \"path\"\n  );\n  let jsonPath = JSON.stringify(path);\n\n  React.useEffect(\n    () => navigate(JSON.parse(jsonPath), { replace, state, relative }),\n    [navigate, jsonPath, relative, replace, state]\n  );\n\n  return null;\n}\n\nexport interface OutletProps {\n  context?: unknown;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/components/outlet\n */\nexport function Outlet(props: OutletProps): React.ReactElement | null {\n  return useOutlet(props.context);\n}\n\nexport interface PathRouteProps {\n  caseSensitive?: NonIndexRouteObject[\"caseSensitive\"];\n  path?: NonIndexRouteObject[\"path\"];\n  id?: NonIndexRouteObject[\"id\"];\n  lazy?: LazyRouteFunction<NonIndexRouteObject>;\n  loader?: NonIndexRouteObject[\"loader\"];\n  action?: NonIndexRouteObject[\"action\"];\n  hasErrorBoundary?: NonIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: NonIndexRouteObject[\"shouldRevalidate\"];\n  handle?: NonIndexRouteObject[\"handle\"];\n  index?: false;\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n}\n\nexport interface LayoutRouteProps extends PathRouteProps {}\n\nexport interface IndexRouteProps {\n  caseSensitive?: IndexRouteObject[\"caseSensitive\"];\n  path?: IndexRouteObject[\"path\"];\n  id?: IndexRouteObject[\"id\"];\n  lazy?: LazyRouteFunction<IndexRouteObject>;\n  loader?: IndexRouteObject[\"loader\"];\n  action?: IndexRouteObject[\"action\"];\n  hasErrorBoundary?: IndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: IndexRouteObject[\"shouldRevalidate\"];\n  handle?: IndexRouteObject[\"handle\"];\n  index: true;\n  children?: undefined;\n  element?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n}\n\nexport type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/components/route\n */\nexport function Route(_props: RouteProps): React.ReactElement | null {\n  invariant(\n    false,\n    `A <Route> is only ever to be used as the child of <Routes> element, ` +\n      `never rendered directly. Please wrap your <Route> in a <Routes>.`\n  );\n}\n\nexport interface RouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  location: Partial<Location> | string;\n  navigationType?: NavigationType;\n  navigator: Navigator;\n  static?: boolean;\n}\n\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a <Router> directly. Instead, you'll render a\n * router that is more specific to your environment such as a <BrowserRouter>\n * in web browsers or a <StaticRouter> for server rendering.\n *\n * @see https://reactrouter.com/router-components/router\n */\nexport function Router({\n  basename: basenameProp = \"/\",\n  children = null,\n  location: locationProp,\n  navigationType = NavigationType.Pop,\n  navigator,\n  static: staticProp = false,\n}: RouterProps): React.ReactElement | null {\n  invariant(\n    !useInRouterContext(),\n    `You cannot render a <Router> inside another <Router>.` +\n      ` You should never have more than one in your app.`\n  );\n\n  // Preserve trailing slashes on basename, so we can let the user control\n  // the enforcement of trailing slashes throughout the app\n  let basename = basenameProp.replace(/^\\/*/, \"/\");\n  let navigationContext = React.useMemo(\n    () => ({ basename, navigator, static: staticProp }),\n    [basename, navigator, staticProp]\n  );\n\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\",\n  } = locationProp;\n\n  let locationContext = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      location: {\n        pathname: trailingPathname,\n        search,\n        hash,\n        state,\n        key,\n      },\n      navigationType,\n    };\n  }, [basename, pathname, search, hash, state, key, navigationType]);\n\n  warning(\n    locationContext != null,\n    `<Router basename=\"${basename}\"> is not able to match the URL ` +\n      `\"${pathname}${search}${hash}\" because it does not start with the ` +\n      `basename, so the <Router> won't render anything.`\n  );\n\n  if (locationContext == null) {\n    return null;\n  }\n\n  return (\n    <NavigationContext.Provider value={navigationContext}>\n      <LocationContext.Provider children={children} value={locationContext} />\n    </NavigationContext.Provider>\n  );\n}\n\nexport interface RoutesProps {\n  children?: React.ReactNode;\n  location?: Partial<Location> | string;\n}\n\n/**\n * A container for a nested tree of <Route> elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/components/routes\n */\nexport function Routes({\n  children,\n  location,\n}: RoutesProps): React.ReactElement | null {\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n\nexport interface AwaitResolveRenderFunction {\n  (data: Awaited<any>): React.ReactNode;\n}\n\nexport interface AwaitProps {\n  children: React.ReactNode | AwaitResolveRenderFunction;\n  errorElement?: React.ReactNode;\n  resolve: TrackedPromise | any;\n}\n\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nexport function Await({ children, errorElement, resolve }: AwaitProps) {\n  return (\n    <AwaitErrorBoundary resolve={resolve} errorElement={errorElement}>\n      <ResolveAwait>{children}</ResolveAwait>\n    </AwaitErrorBoundary>\n  );\n}\n\ntype AwaitErrorBoundaryProps = React.PropsWithChildren<{\n  errorElement?: React.ReactNode;\n  resolve: TrackedPromise | any;\n}>;\n\ntype AwaitErrorBoundaryState = {\n  error: any;\n};\n\nenum AwaitRenderStatus {\n  pending,\n  success,\n  error,\n}\n\nconst neverSettledPromise = new Promise(() => {});\n\nclass AwaitErrorBoundary extends React.Component<\n  AwaitErrorBoundaryProps,\n  AwaitErrorBoundaryState\n> {\n  constructor(props: AwaitErrorBoundaryProps) {\n    super(props);\n    this.state = { error: null };\n  }\n\n  static getDerivedStateFromError(error: any) {\n    return { error };\n  }\n\n  componentDidCatch(error: any, errorInfo: any) {\n    console.error(\n      \"<Await> caught the following error during render\",\n      error,\n      errorInfo\n    );\n  }\n\n  render() {\n    let { children, errorElement, resolve } = this.props;\n\n    let promise: TrackedPromise | null = null;\n    let status: AwaitRenderStatus = AwaitRenderStatus.pending;\n\n    if (!(resolve instanceof Promise)) {\n      // Didn't get a promise - provide as a resolved promise\n      status = AwaitRenderStatus.success;\n      promise = Promise.resolve();\n      Object.defineProperty(promise, \"_tracked\", { get: () => true });\n      Object.defineProperty(promise, \"_data\", { get: () => resolve });\n    } else if (this.state.error) {\n      // Caught a render error, provide it as a rejected promise\n      status = AwaitRenderStatus.error;\n      let renderError = this.state.error;\n      promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings\n      Object.defineProperty(promise, \"_tracked\", { get: () => true });\n      Object.defineProperty(promise, \"_error\", { get: () => renderError });\n    } else if ((resolve as TrackedPromise)._tracked) {\n      // Already tracked promise - check contents\n      promise = resolve;\n      status =\n        promise._error !== undefined\n          ? AwaitRenderStatus.error\n          : promise._data !== undefined\n          ? AwaitRenderStatus.success\n          : AwaitRenderStatus.pending;\n    } else {\n      // Raw (untracked) promise - track it\n      status = AwaitRenderStatus.pending;\n      Object.defineProperty(resolve, \"_tracked\", { get: () => true });\n      promise = resolve.then(\n        (data: any) =>\n          Object.defineProperty(resolve, \"_data\", { get: () => data }),\n        (error: any) =>\n          Object.defineProperty(resolve, \"_error\", { get: () => error })\n      );\n    }\n\n    if (\n      status === AwaitRenderStatus.error &&\n      promise._error instanceof AbortedDeferredError\n    ) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\n\n    if (status === AwaitRenderStatus.error) {\n      // Render via our errorElement\n      return <AwaitContext.Provider value={promise} children={errorElement} />;\n    }\n\n    if (status === AwaitRenderStatus.success) {\n      // Render children with resolved value\n      return <AwaitContext.Provider value={promise} children={children} />;\n    }\n\n    // Throw to the suspense boundary\n    throw promise;\n  }\n}\n\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on <Await>\n */\nfunction ResolveAwait({\n  children,\n}: {\n  children: React.ReactNode | AwaitResolveRenderFunction;\n}) {\n  let data = useAsyncValue();\n  let toRender = typeof children === \"function\" ? children(data) : children;\n  return <>{toRender}</>;\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/utils/create-routes-from-children\n */\nexport function createRoutesFromChildren(\n  children: React.ReactNode,\n  parentPath: number[] = []\n): RouteObject[] {\n  let routes: RouteObject[] = [];\n\n  React.Children.forEach(children, (element, index) => {\n    if (!React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n\n    let treePath = [...parentPath, index];\n\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(\n        routes,\n        createRoutesFromChildren(element.props.children, treePath)\n      );\n      return;\n    }\n\n    invariant(\n      element.type === Route,\n      `[${\n        typeof element.type === \"string\" ? element.type : element.type.name\n      }] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`\n    );\n\n    invariant(\n      !element.props.index || !element.props.children,\n      \"An index route cannot have child routes.\"\n    );\n\n    let route: RouteObject = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      Component: element.props.Component,\n      index: element.props.index,\n      path: element.props.path,\n      loader: element.props.loader,\n      action: element.props.action,\n      errorElement: element.props.errorElement,\n      ErrorBoundary: element.props.ErrorBoundary,\n      hasErrorBoundary:\n        element.props.ErrorBoundary != null ||\n        element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle,\n      lazy: element.props.lazy,\n    };\n\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(\n        element.props.children,\n        treePath\n      );\n    }\n\n    routes.push(route);\n  });\n\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nexport function renderMatches(\n  matches: RouteMatch[] | null\n): React.ReactElement | null {\n  return _renderMatches(matches);\n}\n","import * as React from \"react\";\nimport type {\n  ActionFunction,\n  ActionFunctionArgs,\n  Blocker,\n  BlockerFunction,\n  Fetcher,\n  HydrationState,\n  JsonFunction,\n  LoaderFunction,\n  LoaderFunctionArgs,\n  Location,\n  Navigation,\n  Params,\n  ParamParseKey,\n  Path,\n  PathMatch,\n  PathPattern,\n  RedirectFunction,\n  RelativeRoutingType,\n  Router as RemixRouter,\n  ShouldRevalidateFunction,\n  To,\n  InitialEntry,\n  LazyRouteFunction,\n  FutureConfig as RouterFutureConfig,\n} from \"@remix-run/router\";\nimport {\n  AbortedDeferredError,\n  Action as NavigationType,\n  createMemoryHistory,\n  createPath,\n  createRouter,\n  defer,\n  generatePath,\n  isRouteErrorResponse,\n  json,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  redirect,\n  resolvePath,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n  AwaitProps,\n  MemoryRouterProps,\n  NavigateProps,\n  OutletProps,\n  RouteProps,\n  PathRouteProps,\n  LayoutRouteProps,\n  IndexRouteProps,\n  RouterProps,\n  RoutesProps,\n  RouterProviderProps,\n  FutureConfig,\n} from \"./lib/components\";\nimport {\n  createRoutesFromChildren,\n  renderMatches,\n  Await,\n  MemoryRouter,\n  Navigate,\n  Outlet,\n  Route,\n  Router,\n  RouterProvider,\n  Routes,\n} from \"./lib/components\";\nimport type {\n  DataRouteMatch,\n  DataRouteObject,\n  IndexRouteObject,\n  Navigator,\n  NavigateOptions,\n  NonIndexRouteObject,\n  RouteMatch,\n  RouteObject,\n} from \"./lib/context\";\nimport {\n  DataRouterContext,\n  DataRouterStateContext,\n  LocationContext,\n  NavigationContext,\n  RouteContext,\n} from \"./lib/context\";\nimport type { NavigateFunction } from \"./lib/hooks\";\nimport {\n  useBlocker,\n  useHref,\n  useInRouterContext,\n  useLocation,\n  useMatch,\n  useNavigationType,\n  useNavigate,\n  useOutlet,\n  useOutletContext,\n  useParams,\n  useResolvedPath,\n  useRoutes,\n  useActionData,\n  useAsyncError,\n  useAsyncValue,\n  useRouteId,\n  useLoaderData,\n  useMatches,\n  useNavigation,\n  useRevalidator,\n  useRouteError,\n  useRouteLoaderData,\n  useRoutesImpl,\n} from \"./lib/hooks\";\n\n// Exported for backwards compatibility, but not being used internally anymore\ntype Hash = string;\ntype Pathname = string;\ntype Search = string;\n\n// Expose react-router public API\nexport type {\n  ActionFunction,\n  ActionFunctionArgs,\n  AwaitProps,\n  Blocker as unstable_Blocker,\n  BlockerFunction as unstable_BlockerFunction,\n  DataRouteMatch,\n  DataRouteObject,\n  Fetcher,\n  FutureConfig,\n  Hash,\n  IndexRouteObject,\n  IndexRouteProps,\n  JsonFunction,\n  LazyRouteFunction,\n  LayoutRouteProps,\n  LoaderFunction,\n  LoaderFunctionArgs,\n  Location,\n  MemoryRouterProps,\n  NavigateFunction,\n  NavigateOptions,\n  NavigateProps,\n  Navigation,\n  Navigator,\n  NonIndexRouteObject,\n  OutletProps,\n  Params,\n  ParamParseKey,\n  Path,\n  PathMatch,\n  Pathname,\n  PathPattern,\n  PathRouteProps,\n  RedirectFunction,\n  RelativeRoutingType,\n  RouteMatch,\n  RouteObject,\n  RouteProps,\n  RouterProps,\n  RouterProviderProps,\n  RoutesProps,\n  Search,\n  ShouldRevalidateFunction,\n  To,\n};\nexport {\n  AbortedDeferredError,\n  Await,\n  MemoryRouter,\n  Navigate,\n  NavigationType,\n  Outlet,\n  Route,\n  Router,\n  RouterProvider,\n  Routes,\n  createPath,\n  createRoutesFromChildren,\n  createRoutesFromChildren as createRoutesFromElements,\n  defer,\n  isRouteErrorResponse,\n  generatePath,\n  json,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  redirect,\n  renderMatches,\n  resolvePath,\n  useActionData,\n  useAsyncError,\n  useAsyncValue,\n  useBlocker as unstable_useBlocker,\n  useHref,\n  useInRouterContext,\n  useLoaderData,\n  useLocation,\n  useMatch,\n  useMatches,\n  useNavigate,\n  useNavigation,\n  useNavigationType,\n  useOutlet,\n  useOutletContext,\n  useParams,\n  useResolvedPath,\n  useRevalidator,\n  useRouteError,\n  useRouteLoaderData,\n  useRoutes,\n};\n\nfunction mapRouteProperties(route: RouteObject) {\n  let updates: Partial<RouteObject> & { hasErrorBoundary: boolean } = {\n    // Note: this check also occurs in createRoutesFromChildren so update\n    // there if you change this -- please and thank you!\n    hasErrorBoundary: route.ErrorBoundary != null || route.errorElement != null,\n  };\n\n  if (route.Component) {\n    if (__DEV__) {\n      if (route.element) {\n        warning(\n          false,\n          \"You should not include both `Component` and `element` on your route - \" +\n            \"`Component` will be used.\"\n        );\n      }\n    }\n    Object.assign(updates, {\n      element: React.createElement(route.Component),\n      Component: undefined,\n    });\n  }\n\n  if (route.ErrorBoundary) {\n    if (__DEV__) {\n      if (route.errorElement) {\n        warning(\n          false,\n          \"You should not include both `ErrorBoundary` and `errorElement` on your route - \" +\n            \"`ErrorBoundary` will be used.\"\n        );\n      }\n    }\n    Object.assign(updates, {\n      errorElement: React.createElement(route.ErrorBoundary),\n      ErrorBoundary: undefined,\n    });\n  }\n\n  return updates;\n}\n\nexport function createMemoryRouter(\n  routes: RouteObject[],\n  opts?: {\n    basename?: string;\n    future?: Partial<Omit<RouterFutureConfig, \"v7_prependBasename\">>;\n    hydrationData?: HydrationState;\n    initialEntries?: InitialEntry[];\n    initialIndex?: number;\n  }\n): RemixRouter {\n  return createRouter({\n    basename: opts?.basename,\n    future: {\n      ...opts?.future,\n      v7_prependBasename: true,\n    },\n    history: createMemoryHistory({\n      initialEntries: opts?.initialEntries,\n      initialIndex: opts?.initialIndex,\n    }),\n    hydrationData: opts?.hydrationData,\n    routes,\n    mapRouteProperties,\n  }).initialize();\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// DANGER! PLEASE READ ME!\n// We provide these exports as an escape hatch in the event that you need any\n// routing data that we don't provide an explicit API for. With that said, we\n// want to cover your use case if we can, so if you feel the need to use these\n// we want to hear from you. Let us know what you're building and we'll do our\n// best to make sure we can support you!\n//\n// We consider these exports an implementation detail and do not guarantee\n// against any breaking changes, regardless of the semver release. Use with\n// extreme caution and only if you understand the consequences. Godspeed.\n///////////////////////////////////////////////////////////////////////////////\n\n/** @internal */\nexport {\n  NavigationContext as UNSAFE_NavigationContext,\n  LocationContext as UNSAFE_LocationContext,\n  RouteContext as UNSAFE_RouteContext,\n  DataRouterContext as UNSAFE_DataRouterContext,\n  DataRouterStateContext as UNSAFE_DataRouterStateContext,\n  mapRouteProperties as UNSAFE_mapRouteProperties,\n  useRouteId as UNSAFE_useRouteId,\n  useRoutesImpl as UNSAFE_useRoutesImpl,\n};\n","'use strict';\n\nvar vanilla = require('jotai/vanilla');\nvar react = require('jotai/react');\n\n\n\nObject.keys(vanilla).forEach(function (k) {\n\tif (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {\n\t\tenumerable: true,\n\t\tget: function () { return vanilla[k]; }\n\t});\n});\nObject.keys(react).forEach(function (k) {\n\tif (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {\n\t\tenumerable: true,\n\t\tget: function () { return react[k]; }\n\t});\n});\n","'use client';\n'use strict';\n\nvar ReactExports = require('react');\nvar vanilla = require('jotai/vanilla');\n\nvar StoreContext = ReactExports.createContext(undefined);\nvar useStore = function useStore(options) {\n  var store = ReactExports.useContext(StoreContext);\n  return (options == null ? void 0 : options.store) || store || vanilla.getDefaultStore();\n};\nvar Provider = function Provider(_ref) {\n  var children = _ref.children,\n    store = _ref.store;\n  var storeRef = ReactExports.useRef();\n  if (!store && !storeRef.current) {\n    storeRef.current = vanilla.createStore();\n  }\n  return ReactExports.createElement(StoreContext.Provider, {\n    value: store || storeRef.current\n  }, children);\n};\n\nvar isPromiseLike = function isPromiseLike(x) {\n  return typeof (x == null ? void 0 : x.then) === 'function';\n};\nvar use = ReactExports.use || function (promise) {\n  if (promise.status === 'pending') {\n    throw promise;\n  } else if (promise.status === 'fulfilled') {\n    return promise.value;\n  } else if (promise.status === 'rejected') {\n    throw promise.reason;\n  } else {\n    promise.status = 'pending';\n    promise.then(function (v) {\n      promise.status = 'fulfilled';\n      promise.value = v;\n    }, function (e) {\n      promise.status = 'rejected';\n      promise.reason = e;\n    });\n    throw promise;\n  }\n};\nfunction useAtomValue(atom, options) {\n  var store = useStore(options);\n  var _useReducer = ReactExports.useReducer(function (prev) {\n      var nextValue = store.get(atom);\n      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {\n        return prev;\n      }\n      return [nextValue, store, atom];\n    }, undefined, function () {\n      return [store.get(atom), store, atom];\n    }),\n    _useReducer$ = _useReducer[0],\n    valueFromReducer = _useReducer$[0],\n    storeFromReducer = _useReducer$[1],\n    atomFromReducer = _useReducer$[2],\n    rerender = _useReducer[1];\n  var value = valueFromReducer;\n  if (storeFromReducer !== store || atomFromReducer !== atom) {\n    rerender();\n    value = store.get(atom);\n  }\n  var delay = options == null ? void 0 : options.delay;\n  ReactExports.useEffect(function () {\n    var unsub = store.sub(atom, function () {\n      if (typeof delay === 'number') {\n        setTimeout(rerender, delay);\n        return;\n      }\n      rerender();\n    });\n    rerender();\n    return unsub;\n  }, [store, atom, delay]);\n  ReactExports.useDebugValue(value);\n  return isPromiseLike(value) ? use(value) : value;\n}\n\nfunction useSetAtom(atom, options) {\n  var store = useStore(options);\n  var setAtom = ReactExports.useCallback(function () {\n    if (process.env.NODE_ENV !== 'production' && !('write' in atom)) {\n      throw new Error('not writable atom');\n    }\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return store.set.apply(store, [atom].concat(args));\n  }, [store, atom]);\n  return setAtom;\n}\n\nfunction useAtom(atom, options) {\n  return [useAtomValue(atom, options), useSetAtom(atom, options)];\n}\n\nexports.Provider = Provider;\nexports.useAtom = useAtom;\nexports.useAtomValue = useAtomValue;\nexports.useSetAtom = useSetAtom;\nexports.useStore = useStore;\n","'use client';\n'use strict';\n\nvar react$1 = require('react');\nvar react = require('jotai/react');\nvar utils = require('jotai/vanilla/utils');\nvar vanilla = require('jotai/vanilla');\n\nfunction useResetAtom(anAtom, options) {\n  var setAtom = react.useSetAtom(anAtom, options);\n  var resetAtom = react$1.useCallback(function () {\n    return setAtom(utils.RESET);\n  }, [setAtom]);\n  return resetAtom;\n}\n\nfunction useReducerAtom(anAtom, reducer, options) {\n  var _useAtom = react.useAtom(anAtom, options),\n    state = _useAtom[0],\n    setState = _useAtom[1];\n  var dispatch = react$1.useCallback(function (action) {\n    setState(function (prev) {\n      return reducer(prev, action);\n    });\n  }, [setState, reducer]);\n  return [state, dispatch];\n}\n\nfunction useAtomCallback(callback, options) {\n  var anAtom = react$1.useMemo(function () {\n    return vanilla.atom(null, function (get, set) {\n      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n        args[_key - 2] = arguments[_key];\n      }\n      return callback.apply(void 0, [get, set].concat(args));\n    });\n  }, [callback]);\n  return react.useSetAtom(anAtom, options);\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nvar hydratedMap = new WeakMap();\nfunction useHydrateAtoms(values, options) {\n  var store = react.useStore(options);\n  var hydratedSet = getHydratedSet(store);\n  for (var _iterator = _createForOfIteratorHelperLoose(values), _step; !(_step = _iterator()).done;) {\n    var _step$value = _step.value,\n      atom = _step$value[0],\n      value = _step$value[1];\n    if (!hydratedSet.has(atom) || options != null && options.dangerouslyForceHydrate) {\n      hydratedSet.add(atom);\n      store.set(atom, value);\n    }\n  }\n}\nvar getHydratedSet = function getHydratedSet(store) {\n  var hydratedSet = hydratedMap.get(store);\n  if (!hydratedSet) {\n    hydratedSet = new WeakSet();\n    hydratedMap.set(store, hydratedSet);\n  }\n  return hydratedSet;\n};\n\nexports.useAtomCallback = useAtomCallback;\nexports.useHydrateAtoms = useHydrateAtoms;\nexports.useReducerAtom = useReducerAtom;\nexports.useResetAtom = useResetAtom;\n","'use strict';\n\nvar utils = require('jotai/vanilla/utils');\nvar utils$1 = require('jotai/react/utils');\n\n\n\nObject.keys(utils).forEach(function (k) {\n\tif (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {\n\t\tenumerable: true,\n\t\tget: function () { return utils[k]; }\n\t});\n});\nObject.keys(utils$1).forEach(function (k) {\n\tif (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {\n\t\tenumerable: true,\n\t\tget: function () { return utils$1[k]; }\n\t});\n});\n","'use strict';\n\nvar keyCount = 0;\nfunction atom(read, write) {\n  var key = \"atom\" + ++keyCount;\n  var config = {\n    toString: function toString() {\n      return key;\n    }\n  };\n  if (typeof read === 'function') {\n    config.read = read;\n  } else {\n    config.init = read;\n    config.read = function (get) {\n      return get(this);\n    };\n    config.write = function (get, set, arg) {\n      return set(this, typeof arg === 'function' ? arg(get(this)) : arg);\n    };\n  }\n  if (write) {\n    config.write = write;\n  }\n  return config;\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nvar hasInitialValue = function hasInitialValue(atom) {\n  return 'init' in atom;\n};\nvar isActuallyWritableAtom = function isActuallyWritableAtom(atom) {\n  return !!atom.write;\n};\nvar cancelPromiseMap = new WeakMap();\nvar registerCancelPromise = function registerCancelPromise(promise, cancel) {\n  cancelPromiseMap.set(promise, cancel);\n  promise.catch(function () {}).finally(function () {\n    return cancelPromiseMap.delete(promise);\n  });\n};\nvar cancelPromise = function cancelPromise(promise, next) {\n  var cancel = cancelPromiseMap.get(promise);\n  if (cancel) {\n    cancelPromiseMap.delete(promise);\n    cancel(next);\n  }\n};\nvar resolvePromise = function resolvePromise(promise, value) {\n  promise.status = 'fulfilled';\n  promise.value = value;\n};\nvar rejectPromise = function rejectPromise(promise, e) {\n  promise.status = 'rejected';\n  promise.reason = e;\n};\nvar isPromiseLike = function isPromiseLike(x) {\n  return typeof (x == null ? void 0 : x.then) === 'function';\n};\nvar isEqualAtomValue = function isEqualAtomValue(a, b) {\n  return !!a && 'v' in a && 'v' in b && Object.is(a.v, b.v);\n};\nvar isEqualAtomError = function isEqualAtomError(a, b) {\n  return !!a && 'e' in a && 'e' in b && Object.is(a.e, b.e);\n};\nvar hasPromiseAtomValue = function hasPromiseAtomValue(a) {\n  return !!a && 'v' in a && a.v instanceof Promise;\n};\nvar isEqualPromiseAtomValue = function isEqualPromiseAtomValue(a, b) {\n  return 'v' in a && 'v' in b && a.v.orig && a.v.orig === b.v.orig;\n};\nvar returnAtomValue = function returnAtomValue(atomState) {\n  if ('e' in atomState) {\n    throw atomState.e;\n  }\n  return atomState.v;\n};\nvar createStore = function createStore() {\n  var atomStateMap = new WeakMap();\n  var mountedMap = new WeakMap();\n  var pendingMap = new Map();\n  var storeListenersRev2;\n  var mountedAtoms;\n  if (process.env.NODE_ENV !== 'production') {\n    storeListenersRev2 = new Set();\n    mountedAtoms = new Set();\n  }\n  var getAtomState = function getAtomState(atom) {\n    return atomStateMap.get(atom);\n  };\n  var setAtomState = function setAtomState(atom, atomState) {\n    if (process.env.NODE_ENV !== 'production') {\n      Object.freeze(atomState);\n    }\n    var prevAtomState = atomStateMap.get(atom);\n    atomStateMap.set(atom, atomState);\n    if (!pendingMap.has(atom)) {\n      pendingMap.set(atom, prevAtomState);\n    }\n    if (hasPromiseAtomValue(prevAtomState)) {\n      var _next = 'v' in atomState ? atomState.v instanceof Promise ? atomState.v : Promise.resolve(atomState.v) : Promise.reject(atomState.e);\n      if (prevAtomState.v !== _next) {\n        cancelPromise(prevAtomState.v, _next);\n      }\n    }\n  };\n  var updateDependencies = function updateDependencies(atom, nextAtomState, nextDependencies) {\n    var dependencies = new Map();\n    var changed = false;\n    nextDependencies.forEach(function (aState, a) {\n      if (!aState && a === atom) {\n        aState = nextAtomState;\n      }\n      if (aState) {\n        dependencies.set(a, aState);\n        if (nextAtomState.d.get(a) !== aState) {\n          changed = true;\n        }\n      } else if (process.env.NODE_ENV !== 'production') {\n        console.warn('[Bug] atom state not found');\n      }\n    });\n    if (changed || nextAtomState.d.size !== dependencies.size) {\n      nextAtomState.d = dependencies;\n    }\n  };\n  var setAtomValue = function setAtomValue(atom, value, nextDependencies) {\n    var prevAtomState = getAtomState(atom);\n    var nextAtomState = {\n      d: (prevAtomState == null ? void 0 : prevAtomState.d) || new Map(),\n      v: value\n    };\n    if (nextDependencies) {\n      updateDependencies(atom, nextAtomState, nextDependencies);\n    }\n    if (isEqualAtomValue(prevAtomState, nextAtomState) && prevAtomState.d === nextAtomState.d) {\n      return prevAtomState;\n    }\n    if (hasPromiseAtomValue(prevAtomState) && hasPromiseAtomValue(nextAtomState) && isEqualPromiseAtomValue(prevAtomState, nextAtomState)) {\n      if (prevAtomState.d === nextAtomState.d) {\n        return prevAtomState;\n      } else {\n        nextAtomState.v = prevAtomState.v;\n      }\n    }\n    setAtomState(atom, nextAtomState);\n    return nextAtomState;\n  };\n  var setAtomValueOrPromise = function setAtomValueOrPromise(atom, valueOrPromise, nextDependencies, abortPromise) {\n    if (isPromiseLike(valueOrPromise)) {\n      var continuePromise;\n      var updatePromiseDependencies = function updatePromiseDependencies() {\n        var prevAtomState = getAtomState(atom);\n        if (!hasPromiseAtomValue(prevAtomState) || prevAtomState.v !== promise) {\n          return;\n        }\n        var nextAtomState = setAtomValue(atom, promise, nextDependencies);\n        if (mountedMap.has(atom) && prevAtomState.d !== nextAtomState.d) {\n          mountDependencies(atom, nextAtomState, prevAtomState.d);\n        }\n      };\n      var promise = new Promise(function (resolve, reject) {\n        var settled = false;\n        valueOrPromise.then(function (v) {\n          if (!settled) {\n            settled = true;\n            resolvePromise(promise, v);\n            resolve(v);\n            updatePromiseDependencies();\n          }\n        }, function (e) {\n          if (!settled) {\n            settled = true;\n            rejectPromise(promise, e);\n            reject(e);\n            updatePromiseDependencies();\n          }\n        });\n        continuePromise = function continuePromise(next) {\n          if (!settled) {\n            settled = true;\n            next.then(function (v) {\n              return resolvePromise(promise, v);\n            }, function (e) {\n              return rejectPromise(promise, e);\n            });\n            resolve(next);\n          }\n        };\n      });\n      promise.orig = valueOrPromise;\n      promise.status = 'pending';\n      registerCancelPromise(promise, function (next) {\n        if (next) {\n          continuePromise(next);\n        }\n        abortPromise == null || abortPromise();\n      });\n      return setAtomValue(atom, promise, nextDependencies);\n    }\n    return setAtomValue(atom, valueOrPromise, nextDependencies);\n  };\n  var setAtomError = function setAtomError(atom, error, nextDependencies) {\n    var prevAtomState = getAtomState(atom);\n    var nextAtomState = {\n      d: (prevAtomState == null ? void 0 : prevAtomState.d) || new Map(),\n      e: error\n    };\n    if (nextDependencies) {\n      updateDependencies(atom, nextAtomState, nextDependencies);\n    }\n    if (isEqualAtomError(prevAtomState, nextAtomState) && prevAtomState.d === nextAtomState.d) {\n      return prevAtomState;\n    }\n    setAtomState(atom, nextAtomState);\n    return nextAtomState;\n  };\n  var readAtomState = function readAtomState(atom, force) {\n    var atomState = getAtomState(atom);\n    if (!force && atomState) {\n      if (mountedMap.has(atom)) {\n        return atomState;\n      }\n      if (Array.from(atomState.d).every(function (_ref) {\n        var a = _ref[0],\n          s = _ref[1];\n        if (a === atom) {\n          return true;\n        }\n        var aState = readAtomState(a);\n        return aState === s || isEqualAtomValue(aState, s);\n      })) {\n        return atomState;\n      }\n    }\n    var nextDependencies = new Map();\n    var isSync = true;\n    var getter = function getter(a) {\n      if (a === atom) {\n        var _aState = getAtomState(a);\n        if (_aState) {\n          nextDependencies.set(a, _aState);\n          return returnAtomValue(_aState);\n        }\n        if (hasInitialValue(a)) {\n          nextDependencies.set(a, undefined);\n          return a.init;\n        }\n        throw new Error('no atom init');\n      }\n      var aState = readAtomState(a);\n      nextDependencies.set(a, aState);\n      return returnAtomValue(aState);\n    };\n    var controller;\n    var setSelf;\n    var options = {\n      get signal() {\n        if (!controller) {\n          controller = new AbortController();\n        }\n        return controller.signal;\n      },\n      get setSelf() {\n        if (process.env.NODE_ENV !== 'production' && !isActuallyWritableAtom(atom)) {\n          console.warn('setSelf function cannot be used with read-only atom');\n        }\n        if (!setSelf && isActuallyWritableAtom(atom)) {\n          setSelf = function setSelf() {\n            if (process.env.NODE_ENV !== 'production' && isSync) {\n              console.warn('setSelf function cannot be called in sync');\n            }\n            if (!isSync) {\n              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n                args[_key] = arguments[_key];\n              }\n              return writeAtom.apply(void 0, [atom].concat(args));\n            }\n          };\n        }\n        return setSelf;\n      }\n    };\n    try {\n      var valueOrPromise = atom.read(getter, options);\n      return setAtomValueOrPromise(atom, valueOrPromise, nextDependencies, function () {\n        var _controller;\n        return (_controller = controller) == null ? void 0 : _controller.abort();\n      });\n    } catch (error) {\n      return setAtomError(atom, error, nextDependencies);\n    } finally {\n      isSync = false;\n    }\n  };\n  var readAtom = function readAtom(atom) {\n    return returnAtomValue(readAtomState(atom));\n  };\n  var addAtom = function addAtom(atom) {\n    var mounted = mountedMap.get(atom);\n    if (!mounted) {\n      mounted = mountAtom(atom);\n    }\n    return mounted;\n  };\n  var canUnmountAtom = function canUnmountAtom(atom, mounted) {\n    return !mounted.l.size && (!mounted.t.size || mounted.t.size === 1 && mounted.t.has(atom));\n  };\n  var delAtom = function delAtom(atom) {\n    var mounted = mountedMap.get(atom);\n    if (mounted && canUnmountAtom(atom, mounted)) {\n      unmountAtom(atom);\n    }\n  };\n  var recomputeDependents = function recomputeDependents(atom) {\n    var dependencyMap = new Map();\n    var dirtyMap = new WeakMap();\n    var getDependents = function getDependents(a) {\n      var _mountedMap$get;\n      var dependents = new Set((_mountedMap$get = mountedMap.get(a)) == null ? void 0 : _mountedMap$get.t);\n      pendingMap.forEach(function (_, pendingAtom) {\n        var _getAtomState;\n        if ((_getAtomState = getAtomState(pendingAtom)) != null && _getAtomState.d.has(a)) {\n          dependents.add(pendingAtom);\n        }\n      });\n      return dependents;\n    };\n    var loop1 = function loop1(a) {\n      getDependents(a).forEach(function (dependent) {\n        if (dependent !== a) {\n          dependencyMap.set(dependent, (dependencyMap.get(dependent) || new Set()).add(a));\n          dirtyMap.set(dependent, (dirtyMap.get(dependent) || 0) + 1);\n          loop1(dependent);\n        }\n      });\n    };\n    loop1(atom);\n    var loop2 = function loop2(a) {\n      getDependents(a).forEach(function (dependent) {\n        if (dependent !== a) {\n          var dirtyCount = dirtyMap.get(dependent);\n          if (dirtyCount) {\n            dirtyMap.set(dependent, --dirtyCount);\n          }\n          if (!dirtyCount) {\n            var _dependencyMap$get;\n            var isChanged = !!((_dependencyMap$get = dependencyMap.get(dependent)) != null && _dependencyMap$get.size);\n            if (isChanged) {\n              var prevAtomState = getAtomState(dependent);\n              var nextAtomState = readAtomState(dependent, true);\n              isChanged = !isEqualAtomValue(prevAtomState, nextAtomState);\n            }\n            if (!isChanged) {\n              dependencyMap.forEach(function (s) {\n                return s.delete(dependent);\n              });\n            }\n          }\n          loop2(dependent);\n        }\n      });\n    };\n    loop2(atom);\n  };\n  var writeAtomState = function writeAtomState(atom) {\n    var isSync = true;\n    var getter = function getter(a) {\n      return returnAtomValue(readAtomState(a));\n    };\n    var setter = function setter(a) {\n      var r;\n      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {\n        args[_key3 - 1] = arguments[_key3];\n      }\n      if (a === atom) {\n        if (!hasInitialValue(a)) {\n          throw new Error('atom not writable');\n        }\n        var prevAtomState = getAtomState(a);\n        var nextAtomState = setAtomValueOrPromise(a, args[0]);\n        if (!isEqualAtomValue(prevAtomState, nextAtomState)) {\n          recomputeDependents(a);\n        }\n      } else {\n        r = writeAtomState.apply(void 0, [a].concat(args));\n      }\n      if (!isSync) {\n        var flushed = flushPending();\n        if (process.env.NODE_ENV !== 'production') {\n          storeListenersRev2.forEach(function (l) {\n            return l({\n              type: 'async-write',\n              flushed: flushed\n            });\n          });\n        }\n      }\n      return r;\n    };\n    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n      args[_key2 - 1] = arguments[_key2];\n    }\n    var result = atom.write.apply(atom, [getter, setter].concat(args));\n    isSync = false;\n    return result;\n  };\n  var writeAtom = function writeAtom(atom) {\n    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n      args[_key4 - 1] = arguments[_key4];\n    }\n    var result = writeAtomState.apply(void 0, [atom].concat(args));\n    var flushed = flushPending();\n    if (process.env.NODE_ENV !== 'production') {\n      storeListenersRev2.forEach(function (l) {\n        return l({\n          type: 'write',\n          flushed: flushed\n        });\n      });\n    }\n    return result;\n  };\n  var mountAtom = function mountAtom(atom, initialDependent, onMountQueue) {\n    var _getAtomState2;\n    var queue = onMountQueue || [];\n    (_getAtomState2 = getAtomState(atom)) == null || _getAtomState2.d.forEach(function (_, a) {\n      var aMounted = mountedMap.get(a);\n      if (aMounted) {\n        aMounted.t.add(atom);\n      } else {\n        if (a !== atom) {\n          mountAtom(a, atom, queue);\n        }\n      }\n    });\n    readAtomState(atom);\n    var mounted = {\n      t: new Set(initialDependent && [initialDependent]),\n      l: new Set()\n    };\n    mountedMap.set(atom, mounted);\n    if (process.env.NODE_ENV !== 'production') {\n      mountedAtoms.add(atom);\n    }\n    if (isActuallyWritableAtom(atom) && atom.onMount) {\n      var onMount = atom.onMount;\n      queue.push(function () {\n        var onUnmount = onMount(function () {\n          for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {\n            args[_key5] = arguments[_key5];\n          }\n          return writeAtom.apply(void 0, [atom].concat(args));\n        });\n        if (onUnmount) {\n          mounted.u = onUnmount;\n        }\n      });\n    }\n    if (!onMountQueue) {\n      queue.forEach(function (f) {\n        return f();\n      });\n    }\n    return mounted;\n  };\n  var unmountAtom = function unmountAtom(atom) {\n    var _mountedMap$get2;\n    var onUnmount = (_mountedMap$get2 = mountedMap.get(atom)) == null ? void 0 : _mountedMap$get2.u;\n    if (onUnmount) {\n      onUnmount();\n    }\n    mountedMap.delete(atom);\n    if (process.env.NODE_ENV !== 'production') {\n      mountedAtoms.delete(atom);\n    }\n    var atomState = getAtomState(atom);\n    if (atomState) {\n      if (hasPromiseAtomValue(atomState)) {\n        cancelPromise(atomState.v);\n      }\n      atomState.d.forEach(function (_, a) {\n        if (a !== atom) {\n          var mounted = mountedMap.get(a);\n          if (mounted) {\n            mounted.t.delete(atom);\n            if (canUnmountAtom(a, mounted)) {\n              unmountAtom(a);\n            }\n          }\n        }\n      });\n    } else if (process.env.NODE_ENV !== 'production') {\n      console.warn('[Bug] could not find atom state to unmount', atom);\n    }\n  };\n  var mountDependencies = function mountDependencies(atom, atomState, prevDependencies) {\n    var depSet = new Set(atomState.d.keys());\n    prevDependencies == null || prevDependencies.forEach(function (_, a) {\n      if (depSet.has(a)) {\n        depSet.delete(a);\n        return;\n      }\n      var mounted = mountedMap.get(a);\n      if (mounted) {\n        mounted.t.delete(atom);\n        if (canUnmountAtom(a, mounted)) {\n          unmountAtom(a);\n        }\n      }\n    });\n    depSet.forEach(function (a) {\n      var mounted = mountedMap.get(a);\n      if (mounted) {\n        mounted.t.add(atom);\n      } else if (mountedMap.has(atom)) {\n        mountAtom(a, atom);\n      }\n    });\n  };\n  var flushPending = function flushPending() {\n    var flushed;\n    if (process.env.NODE_ENV !== 'production') {\n      flushed = new Set();\n    }\n    while (pendingMap.size) {\n      var pending = Array.from(pendingMap);\n      pendingMap.clear();\n      pending.forEach(function (_ref2) {\n        var atom = _ref2[0],\n          prevAtomState = _ref2[1];\n        var atomState = getAtomState(atom);\n        if (atomState) {\n          var mounted = mountedMap.get(atom);\n          if (mounted && atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {\n            mountDependencies(atom, atomState, prevAtomState == null ? void 0 : prevAtomState.d);\n          }\n          if (mounted && !(!hasPromiseAtomValue(prevAtomState) && (isEqualAtomValue(prevAtomState, atomState) || isEqualAtomError(prevAtomState, atomState)))) {\n            mounted.l.forEach(function (listener) {\n              return listener();\n            });\n            if (process.env.NODE_ENV !== 'production') {\n              flushed.add(atom);\n            }\n          }\n        } else if (process.env.NODE_ENV !== 'production') {\n          console.warn('[Bug] no atom state to flush');\n        }\n      });\n    }\n    if (process.env.NODE_ENV !== 'production') {\n      return flushed;\n    }\n  };\n  var subscribeAtom = function subscribeAtom(atom, listener) {\n    var mounted = addAtom(atom);\n    var flushed = flushPending();\n    var listeners = mounted.l;\n    listeners.add(listener);\n    if (process.env.NODE_ENV !== 'production') {\n      storeListenersRev2.forEach(function (l) {\n        return l({\n          type: 'sub',\n          flushed: flushed\n        });\n      });\n    }\n    return function () {\n      listeners.delete(listener);\n      delAtom(atom);\n      if (process.env.NODE_ENV !== 'production') {\n        storeListenersRev2.forEach(function (l) {\n          return l({\n            type: 'unsub'\n          });\n        });\n      }\n    };\n  };\n  if (process.env.NODE_ENV !== 'production') {\n    return {\n      get: readAtom,\n      set: writeAtom,\n      sub: subscribeAtom,\n      dev_subscribe_store: function dev_subscribe_store(l, rev) {\n        if (rev !== 2) {\n          throw new Error('The current StoreListener revision is 2.');\n        }\n        storeListenersRev2.add(l);\n        return function () {\n          storeListenersRev2.delete(l);\n        };\n      },\n      dev_get_mounted_atoms: function dev_get_mounted_atoms() {\n        return mountedAtoms.values();\n      },\n      dev_get_atom_state: function dev_get_atom_state(a) {\n        return atomStateMap.get(a);\n      },\n      dev_get_mounted: function dev_get_mounted(a) {\n        return mountedMap.get(a);\n      },\n      dev_restore_atoms: function dev_restore_atoms(values) {\n        for (var _iterator = _createForOfIteratorHelperLoose(values), _step; !(_step = _iterator()).done;) {\n          var _step$value = _step.value,\n            atom = _step$value[0],\n            valueOrPromise = _step$value[1];\n          if (hasInitialValue(atom)) {\n            setAtomValueOrPromise(atom, valueOrPromise);\n            recomputeDependents(atom);\n          }\n        }\n        var flushed = flushPending();\n        storeListenersRev2.forEach(function (l) {\n          return l({\n            type: 'restore',\n            flushed: flushed\n          });\n        });\n      }\n    };\n  }\n  return {\n    get: readAtom,\n    set: writeAtom,\n    sub: subscribeAtom\n  };\n};\nvar defaultStore;\nif (process.env.NODE_ENV !== 'production') {\n  if (typeof globalThis.__NUMBER_OF_JOTAI_INSTANCES__ === 'number') {\n    ++globalThis.__NUMBER_OF_JOTAI_INSTANCES__;\n  } else {\n    globalThis.__NUMBER_OF_JOTAI_INSTANCES__ = 1;\n  }\n}\nvar getDefaultStore = function getDefaultStore() {\n  if (!defaultStore) {\n    if (process.env.NODE_ENV !== 'production' && globalThis.__NUMBER_OF_JOTAI_INSTANCES__ !== 1) {\n      console.warn('Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044');\n    }\n    defaultStore = createStore();\n  }\n  return defaultStore;\n};\n\nexports.atom = atom;\nexports.createStore = createStore;\nexports.getDefaultStore = getDefaultStore;\n","'use strict';\n\nvar vanilla = require('jotai/vanilla');\n\nvar RESET = Symbol(process.env.NODE_ENV !== 'production' ? 'RESET' : '');\n\nfunction atomWithReset(initialValue) {\n  var anAtom = vanilla.atom(initialValue, function (get, set, update) {\n    var nextValue = typeof update === 'function' ? update(get(anAtom)) : update;\n    set(anAtom, nextValue === RESET ? initialValue : nextValue);\n  });\n  return anAtom;\n}\n\nfunction atomWithReducer(initialValue, reducer) {\n  var anAtom = vanilla.atom(initialValue, function (get, set, action) {\n    return set(anAtom, reducer(get(anAtom), action));\n  });\n  return anAtom;\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction atomFamily(initializeAtom, areEqual) {\n  var shouldRemove = null;\n  var atoms = new Map();\n  var createAtom = function createAtom(param) {\n    var item;\n    if (areEqual === undefined) {\n      item = atoms.get(param);\n    } else {\n      for (var _iterator = _createForOfIteratorHelperLoose(atoms), _step; !(_step = _iterator()).done;) {\n        var _step$value = _step.value,\n          key = _step$value[0],\n          value = _step$value[1];\n        if (areEqual(key, param)) {\n          item = value;\n          break;\n        }\n      }\n    }\n    if (item !== undefined) {\n      if (shouldRemove != null && shouldRemove(item[1], param)) {\n        createAtom.remove(param);\n      } else {\n        return item[0];\n      }\n    }\n    var newAtom = initializeAtom(param);\n    atoms.set(param, [newAtom, Date.now()]);\n    return newAtom;\n  };\n  createAtom.remove = function (param) {\n    if (areEqual === undefined) {\n      atoms.delete(param);\n    } else {\n      for (var _iterator2 = _createForOfIteratorHelperLoose(atoms), _step2; !(_step2 = _iterator2()).done;) {\n        var _step2$value = _step2.value,\n          key = _step2$value[0];\n        if (areEqual(key, param)) {\n          atoms.delete(key);\n          break;\n        }\n      }\n    }\n  };\n  createAtom.setShouldRemove = function (fn) {\n    shouldRemove = fn;\n    if (!shouldRemove) return;\n    for (var _iterator3 = _createForOfIteratorHelperLoose(atoms), _step3; !(_step3 = _iterator3()).done;) {\n      var _step3$value = _step3.value,\n        key = _step3$value[0],\n        value = _step3$value[1];\n      if (shouldRemove(value[1], key)) {\n        atoms.delete(key);\n      }\n    }\n  };\n  return createAtom;\n}\n\nvar getCached$2 = function getCached(c, m, k) {\n  return (m.has(k) ? m : m.set(k, c())).get(k);\n};\nvar cache1$4 = new WeakMap();\nvar memo3 = function memo3(create, dep1, dep2, dep3) {\n  var cache2 = getCached$2(function () {\n    return new WeakMap();\n  }, cache1$4, dep1);\n  var cache3 = getCached$2(function () {\n    return new WeakMap();\n  }, cache2, dep2);\n  return getCached$2(create, cache3, dep3);\n};\nfunction selectAtom(anAtom, selector, equalityFn) {\n  if (equalityFn === void 0) {\n    equalityFn = Object.is;\n  }\n  return memo3(function () {\n    var EMPTY = Symbol();\n    var selectValue = function selectValue(_ref) {\n      var value = _ref[0],\n        prevSlice = _ref[1];\n      if (prevSlice === EMPTY) {\n        return selector(value);\n      }\n      var slice = selector(value, prevSlice);\n      return equalityFn(prevSlice, slice) ? prevSlice : slice;\n    };\n    var derivedAtom = vanilla.atom(function (get) {\n      var prev = get(derivedAtom);\n      var value = get(anAtom);\n      if (value instanceof Promise || prev instanceof Promise) {\n        return Promise.all([value, prev]).then(selectValue);\n      }\n      return selectValue([value, prev]);\n    });\n    derivedAtom.init = EMPTY;\n    return derivedAtom;\n  }, anAtom, selector, equalityFn);\n}\n\nvar cache1$3 = new WeakMap();\nvar memo1$1 = function memo1(create, dep1) {\n  return (cache1$3.has(dep1) ? cache1$3 : cache1$3.set(dep1, create())).get(dep1);\n};\nvar deepFreeze = function deepFreeze(obj) {\n  if (typeof obj !== 'object' || obj === null) return;\n  Object.freeze(obj);\n  var propNames = Object.getOwnPropertyNames(obj);\n  for (var _iterator = _createForOfIteratorHelperLoose(propNames), _step; !(_step = _iterator()).done;) {\n    var name = _step.value;\n    var value = obj[name];\n    deepFreeze(value);\n  }\n  return obj;\n};\nfunction freezeAtom(anAtom) {\n  return memo1$1(function () {\n    var frozenAtom = vanilla.atom(function (get) {\n      return deepFreeze(get(anAtom));\n    }, function (_get, set, arg) {\n      return set(anAtom, arg);\n    });\n    return frozenAtom;\n  }, anAtom);\n}\nfunction freezeAtomCreator(createAtom) {\n  return function () {\n    var anAtom = createAtom.apply(void 0, arguments);\n    var origRead = anAtom.read;\n    anAtom.read = function (get, options) {\n      return deepFreeze(origRead.call(this, get, options));\n    };\n    return anAtom;\n  };\n}\n\nvar getCached$1 = function getCached(c, m, k) {\n  return (m.has(k) ? m : m.set(k, c())).get(k);\n};\nvar cache1$2 = new WeakMap();\nvar memo2$1 = function memo2(create, dep1, dep2) {\n  var cache2 = getCached$1(function () {\n    return new WeakMap();\n  }, cache1$2, dep1);\n  return getCached$1(create, cache2, dep2);\n};\nvar cacheKeyForEmptyKeyExtractor = {};\nvar isWritable = function isWritable(atom) {\n  return !!atom.write;\n};\nvar isFunction = function isFunction(x) {\n  return typeof x === 'function';\n};\nfunction splitAtom(arrAtom, keyExtractor) {\n  return memo2$1(function () {\n    var mappingCache = new WeakMap();\n    var getMapping = function getMapping(arr, prev) {\n      var mapping = mappingCache.get(arr);\n      if (mapping) {\n        return mapping;\n      }\n      var prevMapping = prev && mappingCache.get(prev);\n      var atomList = [];\n      var keyList = [];\n      arr.forEach(function (item, index) {\n        var key = keyExtractor ? keyExtractor(item) : index;\n        keyList[index] = key;\n        var cachedAtom = prevMapping && prevMapping.atomList[prevMapping.keyList.indexOf(key)];\n        if (cachedAtom) {\n          atomList[index] = cachedAtom;\n          return;\n        }\n        var read = function read(get) {\n          var prev = get(mappingAtom);\n          var currArr = get(arrAtom);\n          var mapping = getMapping(currArr, prev == null ? void 0 : prev.arr);\n          var index = mapping.keyList.indexOf(key);\n          if (index < 0 || index >= currArr.length) {\n            var prevItem = arr[getMapping(arr).keyList.indexOf(key)];\n            if (prevItem) {\n              return prevItem;\n            }\n            throw new Error('splitAtom: index out of bounds for read');\n          }\n          return currArr[index];\n        };\n        var write = function write(get, set, update) {\n          var prev = get(mappingAtom);\n          var arr = get(arrAtom);\n          var mapping = getMapping(arr, prev == null ? void 0 : prev.arr);\n          var index = mapping.keyList.indexOf(key);\n          if (index < 0 || index >= arr.length) {\n            throw new Error('splitAtom: index out of bounds for write');\n          }\n          var nextItem = isFunction(update) ? update(arr[index]) : update;\n          if (!Object.is(arr[index], nextItem)) {\n            set(arrAtom, [].concat(arr.slice(0, index), [nextItem], arr.slice(index + 1)));\n          }\n        };\n        atomList[index] = isWritable(arrAtom) ? vanilla.atom(read, write) : vanilla.atom(read);\n      });\n      if (prevMapping && prevMapping.keyList.length === keyList.length && prevMapping.keyList.every(function (x, i) {\n        return x === keyList[i];\n      })) {\n        mapping = prevMapping;\n      } else {\n        mapping = {\n          arr: arr,\n          atomList: atomList,\n          keyList: keyList\n        };\n      }\n      mappingCache.set(arr, mapping);\n      return mapping;\n    };\n    var mappingAtom = vanilla.atom(function (get) {\n      var prev = get(mappingAtom);\n      var arr = get(arrAtom);\n      var mapping = getMapping(arr, prev == null ? void 0 : prev.arr);\n      return mapping;\n    });\n    if (process.env.NODE_ENV !== 'production') {\n      mappingAtom.debugPrivate = true;\n    }\n    mappingAtom.init = undefined;\n    var splittedAtom = isWritable(arrAtom) ? vanilla.atom(function (get) {\n      return get(mappingAtom).atomList;\n    }, function (get, set, action) {\n      switch (action.type) {\n        case 'remove':\n          {\n            var index = get(splittedAtom).indexOf(action.atom);\n            if (index >= 0) {\n              var arr = get(arrAtom);\n              set(arrAtom, [].concat(arr.slice(0, index), arr.slice(index + 1)));\n            }\n            break;\n          }\n        case 'insert':\n          {\n            var _index = action.before ? get(splittedAtom).indexOf(action.before) : get(splittedAtom).length;\n            if (_index >= 0) {\n              var _arr = get(arrAtom);\n              set(arrAtom, [].concat(_arr.slice(0, _index), [action.value], _arr.slice(_index)));\n            }\n            break;\n          }\n        case 'move':\n          {\n            var index1 = get(splittedAtom).indexOf(action.atom);\n            var index2 = action.before ? get(splittedAtom).indexOf(action.before) : get(splittedAtom).length;\n            if (index1 >= 0 && index2 >= 0) {\n              var _arr2 = get(arrAtom);\n              if (index1 < index2) {\n                set(arrAtom, [].concat(_arr2.slice(0, index1), _arr2.slice(index1 + 1, index2), [_arr2[index1]], _arr2.slice(index2)));\n              } else {\n                set(arrAtom, [].concat(_arr2.slice(0, index2), [_arr2[index1]], _arr2.slice(index2, index1), _arr2.slice(index1 + 1)));\n              }\n            }\n            break;\n          }\n      }\n    }) : vanilla.atom(function (get) {\n      return get(mappingAtom).atomList;\n    });\n    return splittedAtom;\n  }, arrAtom, keyExtractor || cacheKeyForEmptyKeyExtractor);\n}\n\nfunction atomWithDefault(getDefault) {\n  var EMPTY = Symbol();\n  var overwrittenAtom = vanilla.atom(EMPTY);\n  if (process.env.NODE_ENV !== 'production') {\n    overwrittenAtom.debugPrivate = true;\n  }\n  var anAtom = vanilla.atom(function (get, options) {\n    var overwritten = get(overwrittenAtom);\n    if (overwritten !== EMPTY) {\n      return overwritten;\n    }\n    return getDefault(get, options);\n  }, function (get, set, update) {\n    if (update === RESET) {\n      set(overwrittenAtom, EMPTY);\n    } else if (typeof update === 'function') {\n      var prevValue = get(anAtom);\n      set(overwrittenAtom, update(prevValue));\n    } else {\n      set(overwrittenAtom, update);\n    }\n  });\n  return anAtom;\n}\n\nvar isPromiseLike = function isPromiseLike(x) {\n  return typeof (x == null ? void 0 : x.then) === 'function';\n};\nfunction createJSONStorage(getStringStorage) {\n  var lastStr;\n  var lastValue;\n  var storage = {\n    getItem: function getItem(key, initialValue) {\n      var _getStringStorage$get, _getStringStorage;\n      var parse = function parse(str) {\n        str = str || '';\n        if (lastStr !== str) {\n          try {\n            lastValue = JSON.parse(str);\n          } catch (_unused) {\n            return initialValue;\n          }\n          lastStr = str;\n        }\n        return lastValue;\n      };\n      var str = (_getStringStorage$get = (_getStringStorage = getStringStorage()) == null ? void 0 : _getStringStorage.getItem(key)) != null ? _getStringStorage$get : null;\n      if (isPromiseLike(str)) {\n        return str.then(parse);\n      }\n      return parse(str);\n    },\n    setItem: function setItem(key, newValue) {\n      var _getStringStorage2;\n      return (_getStringStorage2 = getStringStorage()) == null ? void 0 : _getStringStorage2.setItem(key, JSON.stringify(newValue));\n    },\n    removeItem: function removeItem(key) {\n      var _getStringStorage3;\n      return (_getStringStorage3 = getStringStorage()) == null ? void 0 : _getStringStorage3.removeItem(key);\n    }\n  };\n  if (typeof window !== 'undefined' && typeof window.addEventListener === 'function' && window.Storage) {\n    storage.subscribe = function (key, callback, initialValue) {\n      if (!(getStringStorage() instanceof window.Storage)) {\n        return function () {};\n      }\n      var storageEventCallback = function storageEventCallback(e) {\n        if (e.storageArea === getStringStorage() && e.key === key) {\n          var _newValue;\n          try {\n            _newValue = JSON.parse(e.newValue || '');\n          } catch (_unused2) {\n            _newValue = initialValue;\n          }\n          callback(_newValue);\n        }\n      };\n      window.addEventListener('storage', storageEventCallback);\n      return function () {\n        window.removeEventListener('storage', storageEventCallback);\n      };\n    };\n  }\n  return storage;\n}\nvar defaultStorage = createJSONStorage(function () {\n  return typeof window !== 'undefined' ? window.localStorage : undefined;\n});\nfunction atomWithStorage(key, initialValue, storage, options) {\n  if (storage === void 0) {\n    storage = defaultStorage;\n  }\n  var getOnInit = options == null ? void 0 : options.getOnInit;\n  var baseAtom = vanilla.atom(getOnInit ? storage.getItem(key, initialValue) : initialValue);\n  if (process.env.NODE_ENV !== 'production') {\n    baseAtom.debugPrivate = true;\n  }\n  baseAtom.onMount = function (setAtom) {\n    if (!getOnInit) {\n      setAtom(storage.getItem(key, initialValue));\n    }\n    var unsub;\n    if (storage.subscribe) {\n      unsub = storage.subscribe(key, setAtom, initialValue);\n    }\n    return unsub;\n  };\n  var anAtom = vanilla.atom(function (get) {\n    return get(baseAtom);\n  }, function (get, set, update) {\n    var nextValue = typeof update === 'function' ? update(get(baseAtom)) : update;\n    if (nextValue === RESET) {\n      set(baseAtom, initialValue);\n      return storage.removeItem(key);\n    }\n    if (nextValue instanceof Promise) {\n      return nextValue.then(function (resolvedValue) {\n        set(baseAtom, resolvedValue);\n        return storage.setItem(key, resolvedValue);\n      });\n    }\n    set(baseAtom, nextValue);\n    return storage.setItem(key, nextValue);\n  });\n  return anAtom;\n}\n\nfunction atomWithObservable(getObservable, options) {\n  var returnResultData = function returnResultData(result) {\n    if ('e' in result) {\n      throw result.e;\n    }\n    return result.d;\n  };\n  var observableResultAtom = vanilla.atom(function (get) {\n    var _observable$Symbol$ob, _observable;\n    var observable = getObservable(get);\n    var itself = (_observable$Symbol$ob = (_observable = observable)[Symbol.observable]) == null ? void 0 : _observable$Symbol$ob.call(_observable);\n    if (itself) {\n      observable = itself;\n    }\n    var resolve;\n    var makePending = function makePending() {\n      return new Promise(function (r) {\n        resolve = r;\n      });\n    };\n    var initialResult = options && 'initialValue' in options ? {\n      d: typeof options.initialValue === 'function' ? options.initialValue() : options.initialValue\n    } : makePending();\n    var setResult;\n    var lastResult;\n    var listener = function listener(result) {\n      lastResult = result;\n      resolve == null || resolve(result);\n      setResult == null || setResult(result);\n    };\n    var subscription;\n    var timer;\n    var isNotMounted = function isNotMounted() {\n      return !setResult;\n    };\n    var start = function start() {\n      if (subscription) {\n        clearTimeout(timer);\n        subscription.unsubscribe();\n      }\n      subscription = observable.subscribe({\n        next: function next(d) {\n          return listener({\n            d: d\n          });\n        },\n        error: function error(e) {\n          return listener({\n            e: e\n          });\n        },\n        complete: function complete() {}\n      });\n      if (isNotMounted() && options != null && options.unstable_timeout) {\n        timer = setTimeout(function () {\n          if (subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n          }\n        }, options.unstable_timeout);\n      }\n    };\n    start();\n    var resultAtom = vanilla.atom(lastResult || initialResult);\n    if (process.env.NODE_ENV !== 'production') {\n      resultAtom.debugPrivate = true;\n    }\n    resultAtom.onMount = function (update) {\n      setResult = update;\n      if (lastResult) {\n        update(lastResult);\n      }\n      if (subscription) {\n        clearTimeout(timer);\n      } else {\n        start();\n      }\n      return function () {\n        setResult = undefined;\n        if (subscription) {\n          subscription.unsubscribe();\n          subscription = undefined;\n        }\n      };\n    };\n    return [resultAtom, observable, makePending, start, isNotMounted];\n  });\n  if (process.env.NODE_ENV !== 'production') {\n    observableResultAtom.debugPrivate = true;\n  }\n  var observableAtom = vanilla.atom(function (get) {\n    var _get = get(observableResultAtom),\n      resultAtom = _get[0];\n    var result = get(resultAtom);\n    if (result instanceof Promise) {\n      return result.then(returnResultData);\n    }\n    return returnResultData(result);\n  }, function (get, set, data) {\n    var _get2 = get(observableResultAtom),\n      resultAtom = _get2[0],\n      observable = _get2[1],\n      makePending = _get2[2],\n      start = _get2[3],\n      isNotMounted = _get2[4];\n    if ('next' in observable) {\n      if (isNotMounted()) {\n        set(resultAtom, makePending());\n        start();\n      }\n      observable.next(data);\n    } else {\n      throw new Error('observable is not subject');\n    }\n  });\n  return observableAtom;\n}\n\nvar cache1$1 = new WeakMap();\nvar memo1 = function memo1(create, dep1) {\n  return (cache1$1.has(dep1) ? cache1$1 : cache1$1.set(dep1, create())).get(dep1);\n};\nvar LOADING = {\n  state: 'loading'\n};\nfunction loadable(anAtom) {\n  return memo1(function () {\n    var loadableCache = new WeakMap();\n    var refreshAtom = vanilla.atom(0);\n    if (process.env.NODE_ENV !== 'production') {\n      refreshAtom.debugPrivate = true;\n    }\n    var derivedAtom = vanilla.atom(function (get, _ref) {\n      var setSelf = _ref.setSelf;\n      get(refreshAtom);\n      var value;\n      try {\n        value = get(anAtom);\n      } catch (error) {\n        return {\n          state: 'hasError',\n          error: error\n        };\n      }\n      if (!(value instanceof Promise)) {\n        return {\n          state: 'hasData',\n          data: value\n        };\n      }\n      var promise = value;\n      var cached = loadableCache.get(promise);\n      if (cached) {\n        return cached;\n      }\n      loadableCache.set(promise, LOADING);\n      promise.then(function (data) {\n        loadableCache.set(promise, {\n          state: 'hasData',\n          data: data\n        });\n      }, function (error) {\n        loadableCache.set(promise, {\n          state: 'hasError',\n          error: error\n        });\n      }).finally(setSelf);\n      return LOADING;\n    }, function (_get, set) {\n      set(refreshAtom, function (c) {\n        return c + 1;\n      });\n    });\n    if (process.env.NODE_ENV !== 'production') {\n      derivedAtom.debugPrivate = true;\n    }\n    return vanilla.atom(function (get) {\n      return get(derivedAtom);\n    });\n  }, anAtom);\n}\n\nvar getCached = function getCached(c, m, k) {\n  return (m.has(k) ? m : m.set(k, c())).get(k);\n};\nvar cache1 = new WeakMap();\nvar memo2 = function memo2(create, dep1, dep2) {\n  var cache2 = getCached(function () {\n    return new WeakMap();\n  }, cache1, dep1);\n  return getCached(create, cache2, dep2);\n};\nvar defaultFallback = function defaultFallback() {\n  return undefined;\n};\nfunction unwrap(anAtom, fallback) {\n  if (fallback === void 0) {\n    fallback = defaultFallback;\n  }\n  return memo2(function () {\n    var promiseErrorCache = new WeakMap();\n    var promiseResultCache = new WeakMap();\n    var refreshAtom = vanilla.atom(0);\n    if (process.env.NODE_ENV !== 'production') {\n      refreshAtom.debugPrivate = true;\n    }\n    var promiseAndValueAtom = vanilla.atom(function (get, _ref) {\n      var setSelf = _ref.setSelf;\n      get(refreshAtom);\n      var prev = get(promiseAndValueAtom);\n      var promise = get(anAtom);\n      if (!(promise instanceof Promise)) {\n        return {\n          v: promise\n        };\n      }\n      if (promise === (prev == null ? void 0 : prev.p)) {\n        if (promiseErrorCache.has(promise)) {\n          throw promiseErrorCache.get(promise);\n        }\n        if (promiseResultCache.has(promise)) {\n          return {\n            p: promise,\n            v: promiseResultCache.get(promise)\n          };\n        }\n      }\n      if (promise !== (prev == null ? void 0 : prev.p)) {\n        promise.then(function (v) {\n          return promiseResultCache.set(promise, v);\n        }, function (e) {\n          return promiseErrorCache.set(promise, e);\n        }).finally(setSelf);\n      }\n      if (prev && 'v' in prev) {\n        return {\n          p: promise,\n          f: fallback(prev.v),\n          v: prev.v\n        };\n      }\n      return {\n        p: promise,\n        f: fallback()\n      };\n    }, function (_get, set) {\n      set(refreshAtom, function (c) {\n        return c + 1;\n      });\n    });\n    promiseAndValueAtom.init = undefined;\n    if (process.env.NODE_ENV !== 'production') {\n      promiseAndValueAtom.debugPrivate = true;\n    }\n    return vanilla.atom(function (get) {\n      var state = get(promiseAndValueAtom);\n      if ('f' in state) {\n        return state.f;\n      }\n      return state.v;\n    }, function (_get, set) {\n      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n        args[_key - 2] = arguments[_key];\n      }\n      return set.apply(void 0, [anAtom].concat(args));\n    });\n  }, anAtom, fallback);\n}\n\nexports.RESET = RESET;\nexports.atomFamily = atomFamily;\nexports.atomWithDefault = atomWithDefault;\nexports.atomWithObservable = atomWithObservable;\nexports.atomWithReducer = atomWithReducer;\nexports.atomWithReset = atomWithReset;\nexports.atomWithStorage = atomWithStorage;\nexports.createJSONStorage = createJSONStorage;\nexports.freezeAtom = freezeAtom;\nexports.freezeAtomCreator = freezeAtomCreator;\nexports.loadable = loadable;\nexports.selectAtom = selectAtom;\nexports.splitAtom = splitAtom;\nexports.unwrap = unwrap;\n"],"sourceRoot":""}