{"version":3,"sources":["webpack://@lemon8/webapp-seo/../lib/context.ts","webpack://@lemon8/webapp-seo/../lib/hooks.tsx","webpack://@lemon8/webapp-seo/../lib/components.tsx","webpack://@lemon8/webapp-seo/../index.ts","webpack://@lemon8/webapp-seo/./node_modules/.pnpm/jotai@2.3.1_@types+react@18.2.60_react@18.2.0/node_modules/jotai/index.js","webpack://@lemon8/webapp-seo/./node_modules/.pnpm/jotai@2.3.1_@types+react@18.2.60_react@18.2.0/node_modules/jotai/react.js","webpack://@lemon8/webapp-seo/./node_modules/.pnpm/jotai@2.3.1_@types+react@18.2.60_react@18.2.0/node_modules/jotai/react/utils.js","webpack://@lemon8/webapp-seo/./node_modules/.pnpm/jotai@2.3.1_@types+react@18.2.60_react@18.2.0/node_modules/jotai/utils.js","webpack://@lemon8/webapp-seo/./node_modules/.pnpm/jotai@2.3.1_@types+react@18.2.60_react@18.2.0/node_modules/jotai/vanilla.js","webpack://@lemon8/webapp-seo/./node_modules/.pnpm/jotai@2.3.1_@types+react@18.2.60_react@18.2.0/node_modules/jotai/vanilla/utils.js","webpack://@lemon8/webapp-seo/./node_modules/.pnpm/react-i18next@11.18.6_i18next@21.10.0_react-dom@18.2.0_react@18.2.0/node_modules/react-i18next/dist/es/unescape.js","webpack://@lemon8/webapp-seo/./node_modules/.pnpm/react-i18next@11.18.6_i18next@21.10.0_react-dom@18.2.0_react@18.2.0/node_modules/react-i18next/dist/es/context.js"],"names":["DataRouterContext","React","DataRouterStateContext","AwaitContext","NavigationContext","LocationContext","RouteContext","outlet","matches","isDataRoute","RouteErrorContext","useHref","to","_temp","relative","useInRouterContext","invariant","basename","navigator","hash","pathname","search","useResolvedPath","joinedPathname","joinPaths","createHref","useLocation","location","useNavigationType","useContext","navigationType","useMatch","pattern","useMemo","matchPath","navigateEffectWarning","useIsomorphicLayoutEffect","cb","static","useNavigate","useNavigateStable","useNavigateUnstable","dataRouterContext","locationPathname","routePathnamesJson","JSON","stringify","getPathContributingMatches","map","match","pathnameBase","activeRef","current","options","go","path","resolveTo","parse","replace","push","state","OutletContext","useOutletContext","useOutlet","context","Provider","value","useParams","routeMatch","length","params","_temp2","useRoutes","routes","locationArg","useRoutesImpl","dataRouterState","parentMatches","parentParams","parentPathname","parentPathnameBase","parentRoute","route","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","parsePath","startsWith","remainingPathname","slice","matchRoutes","renderedMatches","_renderMatches","Object","assign","encodeLocation","_extends","key","NavigationType","DefaultErrorComponent","error","useRouteError","message","isRouteErrorResponse","status","statusText","Error","stack","lightgrey","preStyles","padding","backgroundColor","codeStyles","devInfo","style","fontStyle","defaultErrorElement","RenderErrorBoundary","constructor","props","revalidation","getDerivedStateFromError","getDerivedStateFromProps","componentDidCatch","errorInfo","console","render","routeContext","children","component","RenderedRoute","_ref","staticContext","errorElement","ErrorBoundary","_deepestRenderedBoundaryId","id","_dataRouterState2","_dataRouterState","errors","errorIndex","findIndex","m","Math","min","reduceRight","index","concat","getChildren","Component","element","DataRouterHook","DataRouterStateHook","getDataRouterConsoleError","hookName","useDataRouterContext","ctx","useDataRouterState","useRouteContext","useCurrentRouteId","thisRoute","useRouteId","UseRouteId","useNavigation","UseNavigation","navigation","useRevalidator","UseRevalidator","revalidate","router","useMatches","loaderData","UseMatches","data","handle","useLoaderData","UseLoaderData","routeId","useRouteLoaderData","UseRouteLoaderData","useActionData","UseActionData","values","actionData","_state$errors","UseRouteError","useAsyncValue","_data","useAsyncError","_error","blockerId","useBlocker","shouldBlock","UseBlocker","blockerKey","setBlockerKey","useState","blockerFunction","useCallback","arg","currentLocation","nextLocation","historyAction","stripBasename","useEffect","String","deleteBlocker","getBlocker","blockers","has","get","IDLE_BLOCKER","UseNavigateStable","navigate","fromRouteId","alreadyWarned","warningOnce","cond","START_TRANSITION","startTransitionImpl","RouterProvider","fallbackElement","future","setStateImpl","v7_startTransition","setState","newState","subscribe","n","opts","preventScrollReset","Router","initialized","DataRoutes","_ref2","undefined","MemoryRouter","_ref3","initialEntries","initialIndex","historyRef","useRef","createMemoryHistory","v5Compat","history","action","useLayoutEffect","listen","createElement","Navigate","_ref4","jsonPath","Outlet","Route","_props","_ref5","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","Routes","_ref6","createRoutesFromChildren","Await","_ref7","resolve","AwaitErrorBoundary","ResolveAwait","AwaitRenderStatus","neverSettledPromise","Promise","promise","pending","success","defineProperty","renderError","reject","catch","_tracked","then","AbortedDeferredError","_ref8","toRender","parentPath","Children","forEach","isValidElement","treePath","type","Fragment","apply","join","caseSensitive","loader","hasErrorBoundary","shouldRevalidate","lazy","renderMatches","mapRouteProperties","updates","createMemoryRouter","createRouter","v7_prependBasename","hydrationData","initialize","vanilla","react","k","exports","ReactExports","StoreContext","useStore","store","storeRef","isPromiseLike","x","use","v","e","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","callback","set","_unsupportedIterableToArray","o","minLen","_arrayLikeToArray","arr","len","i","arr2","_createForOfIteratorHelperLoose","allowArrayLike","it","hydratedMap","useHydrateAtoms","hydratedSet","getHydratedSet","_iterator","_step","_step$value","utils$1","keyCount","read","write","config","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","settled","mountDependencies","setAtomError","readAtomState","force","s","isSync","getter","_aState","controller","setSelf","writeAtom","_controller","readAtom","addAtom","mounted","mountAtom","canUnmountAtom","delAtom","unmountAtom","recomputeDependents","dependencyMap","dirtyMap","loop1","dependent","loop2","dirtyCount","_dependencyMap$get","isChanged","writeAtomState","setter","r","_len3","_key3","flushed","flushPending","_len2","_key2","result","_len4","_key4","initialDependent","_getAtomState","_","aMounted","onUnmount","_len5","_key5","_mountedMap$get","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","name","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","unstable_options","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","matchHtmlEntity","htmlEntities","unescapeHtmlEntity","text","ownKeys","object","enumerableOnly","keys","symbols","sym","_objectSpread","target","source","defaultOptions","i18nInstance","I18nContext","setDefaults","getDefaults","ReportNamespaces","namespaces","_this","ns","setI18n","instance","getI18n","initReactI18next","composeInitialProps","ForComponent","i18nInitialProps","getInitialProps","componentsInitialProps","i18n","ret","initialI18nStore","l"],"mappings":"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","file":"50-c8d1f63459c4d70487c5.js","sourcesContent":["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 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 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(config);\n    };\n    config.write = function (get, set, arg) {\n      return set(config, typeof arg === 'function' ? arg(get(config)) : 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 'v' in a && 'v' in b && Object.is(a.v, b.v);\n};\nvar isEqualAtomError = function isEqualAtomError(a, b) {\n  return 'e' in a && 'e' in b && Object.is(a.e, b.e);\n};\nvar hasPromiseAtomValue = function hasPromiseAtomValue(a) {\n  return '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 (prevAtomState && hasPromiseAtomValue(prevAtomState)) {\n      var _next = 'v' in atomState ? atomState.v instanceof Promise ? atomState.v : Promise.resolve(atomState.v) : Promise.reject(atomState.e);\n      cancelPromise(prevAtomState.v, _next);\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 (prevAtomState && isEqualAtomValue(prevAtomState, nextAtomState) && prevAtomState.d === nextAtomState.d) {\n      return prevAtomState;\n    }\n    if (prevAtomState && 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 promise = new Promise(function (resolve, reject) {\n        var settled = false;\n        valueOrPromise.then(function (v) {\n          if (!settled) {\n            settled = true;\n            var prevAtomState = getAtomState(atom);\n            var nextAtomState = setAtomValue(atom, promise, nextDependencies);\n            resolvePromise(promise, v);\n            resolve(v);\n            if ((prevAtomState == null ? void 0 : prevAtomState.d) !== nextAtomState.d) {\n              mountDependencies(atom, nextAtomState, prevAtomState == null ? void 0 : prevAtomState.d);\n            }\n          }\n        }, function (e) {\n          if (!settled) {\n            settled = true;\n            var prevAtomState = getAtomState(atom);\n            var nextAtomState = setAtomValue(atom, promise, nextDependencies);\n            rejectPromise(promise, e);\n            reject(e);\n            if ((prevAtomState == null ? void 0 : prevAtomState.d) !== nextAtomState.d) {\n              mountDependencies(atom, nextAtomState, prevAtomState == null ? void 0 : prevAtomState.d);\n            }\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 ? void 0 : 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 (prevAtomState && 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        return a === atom || readAtomState(a) === 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 loop1 = function loop1(a) {\n      var mounted = mountedMap.get(a);\n      mounted == null ? void 0 : mounted.t.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      var mounted = mountedMap.get(a);\n      mounted == null ? void 0 : mounted.t.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 = !prevAtomState || !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 (!prevAtomState || !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) {\n    var _getAtomState;\n    (_getAtomState = getAtomState(atom)) == null ? void 0 : _getAtomState.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);\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 onUnmount = atom.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    return mounted;\n  };\n  var unmountAtom = function unmountAtom(atom) {\n    var _mountedMap$get;\n    var onUnmount = (_mountedMap$get = mountedMap.get(atom)) == null ? void 0 : _mountedMap$get.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 ? void 0 : 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          if (atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {\n            mountDependencies(atom, atomState, prevAtomState == null ? void 0 : prevAtomState.d);\n          }\n          var mounted = mountedMap.get(atom);\n          if (mounted && !(prevAtomState && !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();\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(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          set(arrAtom, [].concat(arr.slice(0, index), [nextItem], arr.slice(index + 1)));\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') {\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, unstable_options) {\n  if (storage === void 0) {\n    storage = defaultStorage;\n  }\n  var getOnInit = unstable_options == null ? void 0 : unstable_options.unstable_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 ? void 0 : resolve(result);\n      setResult == null ? void 0 : 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        };\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 ('v' in state) {\n        return state.v;\n      }\n      return state.f;\n    }, anAtom.write);\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","var matchHtmlEntity = /&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34|nbsp|#160|copy|#169|reg|#174|hellip|#8230|#x2F|#47);/g;\nvar htmlEntities = {\n  '&amp;': '&',\n  '&#38;': '&',\n  '&lt;': '<',\n  '&#60;': '<',\n  '&gt;': '>',\n  '&#62;': '>',\n  '&apos;': \"'\",\n  '&#39;': \"'\",\n  '&quot;': '\"',\n  '&#34;': '\"',\n  '&nbsp;': ' ',\n  '&#160;': ' ',\n  '&copy;': '©',\n  '&#169;': '©',\n  '&reg;': '®',\n  '&#174;': '®',\n  '&hellip;': '…',\n  '&#8230;': '…',\n  '&#x2F;': '/',\n  '&#47;': '/'\n};\n\nvar unescapeHtmlEntity = function unescapeHtmlEntity(m) {\n  return htmlEntities[m];\n};\n\nexport var unescape = function unescape(text) {\n  return text.replace(matchHtmlEntity, unescapeHtmlEntity);\n};","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport { createContext } from 'react';\nimport { unescape } from './unescape';\nvar defaultOptions = {\n  bindI18n: 'languageChanged',\n  bindI18nStore: '',\n  transEmptyNodeValue: '',\n  transSupportBasicHtmlNodes: true,\n  transWrapTextNodes: '',\n  transKeepBasicHtmlNodesFor: ['br', 'strong', 'i', 'p'],\n  useSuspense: true,\n  unescape: unescape\n};\nvar i18nInstance;\nexport var I18nContext = createContext();\nexport function setDefaults() {\n  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  defaultOptions = _objectSpread(_objectSpread({}, defaultOptions), options);\n}\nexport function getDefaults() {\n  return defaultOptions;\n}\nexport var ReportNamespaces = function () {\n  function ReportNamespaces() {\n    _classCallCheck(this, ReportNamespaces);\n\n    this.usedNamespaces = {};\n  }\n\n  _createClass(ReportNamespaces, [{\n    key: \"addUsedNamespaces\",\n    value: function addUsedNamespaces(namespaces) {\n      var _this = this;\n\n      namespaces.forEach(function (ns) {\n        if (!_this.usedNamespaces[ns]) _this.usedNamespaces[ns] = true;\n      });\n    }\n  }, {\n    key: \"getUsedNamespaces\",\n    value: function getUsedNamespaces() {\n      return Object.keys(this.usedNamespaces);\n    }\n  }]);\n\n  return ReportNamespaces;\n}();\nexport function setI18n(instance) {\n  i18nInstance = instance;\n}\nexport function getI18n() {\n  return i18nInstance;\n}\nexport var initReactI18next = {\n  type: '3rdParty',\n  init: function init(instance) {\n    setDefaults(instance.options.react);\n    setI18n(instance);\n  }\n};\nexport function composeInitialProps(ForComponent) {\n  return function (ctx) {\n    return new Promise(function (resolve) {\n      var i18nInitialProps = getInitialProps();\n\n      if (ForComponent.getInitialProps) {\n        ForComponent.getInitialProps(ctx).then(function (componentsInitialProps) {\n          resolve(_objectSpread(_objectSpread({}, componentsInitialProps), i18nInitialProps));\n        });\n      } else {\n        resolve(i18nInitialProps);\n      }\n    });\n  };\n}\nexport function getInitialProps() {\n  var i18n = getI18n();\n  var namespaces = i18n.reportNamespaces ? i18n.reportNamespaces.getUsedNamespaces() : [];\n  var ret = {};\n  var initialI18nStore = {};\n  i18n.languages.forEach(function (l) {\n    initialI18nStore[l] = {};\n    namespaces.forEach(function (ns) {\n      initialI18nStore[l][ns] = i18n.getResourceBundle(l, ns) || {};\n    });\n  });\n  ret.initialI18nStore = initialI18nStore;\n  ret.initialLanguage = i18n.language;\n  return ret;\n}"],"sourceRoot":""}