{"version":3,"sources":["webpack://@lemon8/web-sharing/../dom.ts","webpack://@lemon8/web-sharing/../index.tsx","webpack://@lemon8/web-sharing/../lib/context.ts","webpack://@lemon8/web-sharing/../lib/hooks.tsx","webpack://@lemon8/web-sharing/../lib/components.tsx","webpack://@lemon8/web-sharing/../index.ts"],"names":["defaultMethod","defaultEncType","isHtmlElement","object","tagName","isButtonElement","toLowerCase","isFormElement","isInputElement","isModifiedEvent","event","metaKey","altKey","ctrlKey","shiftKey","shouldProcessLinkClick","target","button","createSearchParams","init","URLSearchParams","Array","isArray","Object","keys","reduce","memo","key","value","concat","map","v","getSearchParamsForLocation","locationSearch","defaultSearchParams","searchParams","has","getAll","forEach","append","_formDataSupportsSubmitter","isFormDataSubmitterSupported","FormData","document","createElement","e","supportedFormEncTypes","Set","getFormEncType","encType","getFormSubmissionInfo","basename","method","action","formData","body","attr","getAttribute","stripBasename","type","form","Error","name","prefix","undefined","createBrowserRouter","routes","opts","createRouter","future","_extends","v7_prependBasename","history","createBrowserHistory","window","hydrationData","parseHydrationData","mapRouteProperties","initialize","createHashRouter","createHashHistory","_window","state","__staticRouterHydrationData","errors","deserializeErrors","entries","serialized","val","__type","ErrorResponse","status","statusText","data","internal","error","message","stack","START_TRANSITION","startTransitionImpl","React","BrowserRouter","_ref","children","historyRef","current","v5Compat","setStateImpl","location","v7_startTransition","setState","newState","listen","Router","navigationType","navigator","HashRouter","_ref2","HistoryRouter","_ref3","isBrowser","ABSOLUTE_URL_REGEX","Link","_ref4","ref","onClick","relative","reloadDocument","replace","to","preventScrollReset","rest","_objectWithoutPropertiesLoose","_excluded","NavigationContext","absoluteHref","isExternal","test","currentUrl","URL","href","targetUrl","startsWith","protocol","path","pathname","origin","search","hash","useHref","internalOnClick","useLinkClickHandler","handleClick","defaultPrevented","NavLink","_ref5","ariaCurrentProp","caseSensitive","className","classNameProp","end","style","styleProp","_excluded2","useResolvedPath","useLocation","routerState","DataRouterStateContext","toPathname","encodeLocation","locationPathname","nextLocationPathname","navigation","isActive","charAt","length","isPending","ariaCurrent","filter","Boolean","join","Form","props","submit","useSubmit","FormImpl","_ref6","forwardedRef","onSubmit","_excluded3","formMethod","formAction","useFormAction","submitHandler","preventDefault","submitter","nativeEvent","submitMethod","currentTarget","ScrollRestoration","_ref7","getKey","storageKey","useScrollRestoration","DataRouterHook","DataRouterStateHook","getDataRouterConsoleError","hookName","useDataRouterContext","ctx","DataRouterContext","invariant","useDataRouterState","_temp","replaceProp","navigate","useNavigate","createPath","useSearchParams","defaultInit","defaultSearchParamsRef","hasSetSearchParamsRef","setSearchParams","nextInit","navigateOptions","newSearchParams","validateClientSideSubmission","router","UseSubmit","currentRouteId","useRouteId","options","formEncType","fromRouteId","useSubmitFetcher","fetcherKey","fetcherRouteId","UseSubmitFetcher","fetch","_temp2","routeContext","RouteContext","match","matches","slice","route","index","params","delete","toString","joinPaths","createFetcherForm","routeId","fetcherId","useFetcher","_route$matches","UseFetcher","id","String","load","fetcher","getFetcher","fetcherWithComponents","console","warn","deleteFetcher","useFetchers","UseFetchers","fetchers","values","SCROLL_RESTORATION_STORAGE_KEY","savedScrollPositions","_temp3","UseScrollRestoration","restoreScrollPosition","useMatches","useNavigation","scrollRestoration","usePageHide","scrollY","sessionStorage","setItem","JSON","stringify","sessionPositions","getItem","parse","getKeyWithoutBasename","disableScrollRestoration","enableScrollRestoration","scrollTo","el","getElementById","scrollIntoView","useBeforeUnload","callback","capture","addEventListener","removeEventListener","usePrompt","_ref8","when","blocker","useBlocker","reset","confirm","setTimeout","proceed","AwaitContext","LocationContext","outlet","isDataRoute","RouteErrorContext","useInRouterContext","joinedPathname","createHref","useNavigationType","useMatch","pattern","matchPath","navigateEffectWarning","useIsomorphicLayoutEffect","cb","static","useNavigateStable","useNavigateUnstable","dataRouterContext","routePathnamesJson","getPathContributingMatches","pathnameBase","activeRef","go","resolveTo","push","OutletContext","useOutletContext","useOutlet","context","Provider","useParams","routeMatch","useRoutes","locationArg","useRoutesImpl","dataRouterState","parentMatches","parentParams","parentPathname","parentPathnameBase","parentRoute","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","parsePath","remainingPathname","matchRoutes","renderedMatches","_renderMatches","assign","NavigationType","DefaultErrorComponent","useRouteError","isRouteErrorResponse","lightgrey","preStyles","padding","backgroundColor","codeStyles","devInfo","fontStyle","defaultErrorElement","RenderErrorBoundary","constructor","revalidation","getDerivedStateFromError","getDerivedStateFromProps","componentDidCatch","errorInfo","render","component","RenderedRoute","staticContext","errorElement","ErrorBoundary","_deepestRenderedBoundaryId","_dataRouterState2","_dataRouterState","errorIndex","findIndex","m","Math","min","reduceRight","getChildren","Component","element","useRouteContext","useCurrentRouteId","thisRoute","UseRouteId","UseNavigation","useRevalidator","UseRevalidator","revalidate","loaderData","UseMatches","handle","useLoaderData","UseLoaderData","useRouteLoaderData","UseRouteLoaderData","useActionData","UseActionData","actionData","_state$errors","UseRouteError","useAsyncValue","_data","useAsyncError","_error","blockerId","shouldBlock","UseBlocker","blockerKey","setBlockerKey","blockerFunction","arg","currentLocation","nextLocation","historyAction","deleteBlocker","getBlocker","blockers","get","IDLE_BLOCKER","UseNavigateStable","alreadyWarned","warningOnce","cond","RouterProvider","fallbackElement","subscribe","n","initialized","DataRoutes","MemoryRouter","initialEntries","initialIndex","createMemoryHistory","Navigate","jsonPath","Outlet","Route","_props","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","Routes","createRoutesFromChildren","Await","resolve","AwaitErrorBoundary","ResolveAwait","AwaitRenderStatus","neverSettledPromise","Promise","promise","pending","success","defineProperty","renderError","reject","catch","_tracked","then","AbortedDeferredError","toRender","parentPath","treePath","apply","loader","hasErrorBoundary","shouldRevalidate","lazy","renderMatches","updates","createMemoryRouter"],"mappings":"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","file":"602-c5f55c4b1d0f3062441c.js","sourcesContent":["import type {\n  FormEncType,\n  HTMLFormMethod,\n  RelativeRoutingType,\n} from \"@remix-run/router\";\nimport { stripBasename, UNSAFE_warning as warning } from \"@remix-run/router\";\n\nexport const defaultMethod: HTMLFormMethod = \"get\";\nconst defaultEncType: FormEncType = \"application/x-www-form-urlencoded\";\n\nexport function isHtmlElement(object: any): object is HTMLElement {\n  return object != null && typeof object.tagName === \"string\";\n}\n\nexport function isButtonElement(object: any): object is HTMLButtonElement {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"button\";\n}\n\nexport function isFormElement(object: any): object is HTMLFormElement {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"form\";\n}\n\nexport function isInputElement(object: any): object is HTMLInputElement {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"input\";\n}\n\ntype LimitedMouseEvent = Pick<\n  MouseEvent,\n  \"button\" | \"metaKey\" | \"altKey\" | \"ctrlKey\" | \"shiftKey\"\n>;\n\nfunction isModifiedEvent(event: LimitedMouseEvent) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nexport function shouldProcessLinkClick(\n  event: LimitedMouseEvent,\n  target?: string\n) {\n  return (\n    event.button === 0 && // Ignore everything but left clicks\n    (!target || target === \"_self\") && // Let browser handle \"target=_blank\" etc.\n    !isModifiedEvent(event) // Ignore clicks with modifier keys\n  );\n}\n\nexport type ParamKeyValuePair = [string, string];\n\nexport type URLSearchParamsInit =\n  | string\n  | ParamKeyValuePair[]\n  | Record<string, string | string[]>\n  | URLSearchParams;\n\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n *   let searchParams = new URLSearchParams([\n *     ['sort', 'name'],\n *     ['sort', 'price']\n *   ]);\n *\n * you can do:\n *\n *   let searchParams = createSearchParams({\n *     sort: ['name', 'price']\n *   });\n */\nexport function createSearchParams(\n  init: URLSearchParamsInit = \"\"\n): URLSearchParams {\n  return new URLSearchParams(\n    typeof init === \"string\" ||\n    Array.isArray(init) ||\n    init instanceof URLSearchParams\n      ? init\n      : Object.keys(init).reduce((memo, key) => {\n          let value = init[key];\n          return memo.concat(\n            Array.isArray(value) ? value.map((v) => [key, v]) : [[key, value]]\n          );\n        }, [] as ParamKeyValuePair[])\n  );\n}\n\nexport function getSearchParamsForLocation(\n  locationSearch: string,\n  defaultSearchParams: URLSearchParams | null\n) {\n  let searchParams = createSearchParams(locationSearch);\n\n  if (defaultSearchParams) {\n    for (let key of defaultSearchParams.keys()) {\n      if (!searchParams.has(key)) {\n        defaultSearchParams.getAll(key).forEach((value) => {\n          searchParams.append(key, value);\n        });\n      }\n    }\n  }\n\n  return searchParams;\n}\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n  [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\nexport type SubmitTarget =\n  | HTMLFormElement\n  | HTMLButtonElement\n  | HTMLInputElement\n  | FormData\n  | URLSearchParams\n  | JsonValue\n  | null;\n\n// One-time check for submitter support\nlet _formDataSupportsSubmitter: boolean | null = null;\n\nfunction isFormDataSubmitterSupported() {\n  if (_formDataSupportsSubmitter === null) {\n    try {\n      new FormData(\n        document.createElement(\"form\"),\n        // @ts-expect-error if FormData supports the submitter parameter, this will throw\n        0\n      );\n      _formDataSupportsSubmitter = false;\n    } catch (e) {\n      _formDataSupportsSubmitter = true;\n    }\n  }\n  return _formDataSupportsSubmitter;\n}\n\nexport interface SubmitOptions {\n  /**\n   * The HTTP method used to submit the form. Overrides `<form method>`.\n   * Defaults to \"GET\".\n   */\n  method?: HTMLFormMethod;\n\n  /**\n   * The action URL path used to submit the form. Overrides `<form action>`.\n   * Defaults to the path of the current route.\n   */\n  action?: string;\n\n  /**\n   * The encoding used to submit the form. Overrides `<form encType>`.\n   * Defaults to \"application/x-www-form-urlencoded\".\n   */\n  encType?: FormEncType;\n\n  /**\n   * Set `true` to replace the current entry in the browser's history stack\n   * instead of creating a new one (i.e. stay on \"the same page\"). Defaults\n   * to `false`.\n   */\n  replace?: boolean;\n\n  /**\n   * Determines whether the form action is relative to the route hierarchy or\n   * the pathname.  Use this if you want to opt out of navigating the route\n   * hierarchy and want to instead route based on /-delimited URL segments\n   */\n  relative?: RelativeRoutingType;\n\n  /**\n   * In browser-based environments, prevent resetting scroll after this\n   * navigation when using the <ScrollRestoration> component\n   */\n  preventScrollReset?: boolean;\n}\n\nconst supportedFormEncTypes: Set<FormEncType> = new Set([\n  \"application/x-www-form-urlencoded\",\n  \"multipart/form-data\",\n  \"text/plain\",\n]);\n\nfunction getFormEncType(encType: string | null) {\n  if (encType != null && !supportedFormEncTypes.has(encType as FormEncType)) {\n    warning(\n      false,\n      `\"${encType}\" is not a valid \\`encType\\` for \\`<Form>\\`/\\`<fetcher.Form>\\` ` +\n        `and will default to \"${defaultEncType}\"`\n    );\n\n    return null;\n  }\n  return encType;\n}\n\nexport function getFormSubmissionInfo(\n  target: SubmitTarget,\n  basename: string\n): {\n  action: string | null;\n  method: string;\n  encType: string;\n  formData: FormData | undefined;\n  body: any;\n} {\n  let method: string;\n  let action: string | null;\n  let encType: string;\n  let formData: FormData | undefined;\n  let body: any;\n\n  if (isFormElement(target)) {\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"enctype\")) || defaultEncType;\n\n    formData = new FormData(target);\n  } else if (\n    isButtonElement(target) ||\n    (isInputElement(target) &&\n      (target.type === \"submit\" || target.type === \"image\"))\n  ) {\n    let form = target.form;\n\n    if (form == null) {\n      throw new Error(\n        `Cannot submit a <button> or <input type=\"submit\"> without a <form>`\n      );\n    }\n\n    // <button>/<input type=\"submit\"> may override attributes of <form>\n\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"formaction\") || form.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n\n    method =\n      target.getAttribute(\"formmethod\") ||\n      form.getAttribute(\"method\") ||\n      defaultMethod;\n    encType =\n      getFormEncType(target.getAttribute(\"formenctype\")) ||\n      getFormEncType(form.getAttribute(\"enctype\")) ||\n      defaultEncType;\n\n    // Build a FormData object populated from a form and submitter\n    formData = new FormData(form, target);\n\n    // If this browser doesn't support the `FormData(el, submitter)` format,\n    // then tack on the submitter value at the end.  This is a lightweight\n    // solution that is not 100% spec compliant.  For complete support in older\n    // browsers, consider using the `formdata-submitter-polyfill` package\n    if (!isFormDataSubmitterSupported()) {\n      let { name, type, value } = target;\n      if (type === \"image\") {\n        let prefix = name ? `${name}.` : \"\";\n        formData.append(`${prefix}x`, \"0\");\n        formData.append(`${prefix}y`, \"0\");\n      } else if (name) {\n        formData.append(name, value);\n      }\n    }\n  } else if (isHtmlElement(target)) {\n    throw new Error(\n      `Cannot submit element that is not <form>, <button>, or ` +\n        `<input type=\"submit|image\">`\n    );\n  } else {\n    method = defaultMethod;\n    action = null;\n    encType = defaultEncType;\n    body = target;\n  }\n\n  // Send body for <Form encType=\"text/plain\" so we encode it into text\n  if (formData && encType === \"text/plain\") {\n    body = formData;\n    formData = undefined;\n  }\n\n  return { action, method: method.toLowerCase(), encType, formData, body };\n}\n","/**\n * NOTE: If you refactor this to split up the modules into separate files,\n * you'll need to update the rollup config for react-router-dom-v5-compat.\n */\nimport * as React from \"react\";\nimport type {\n  FutureConfig,\n  Location,\n  NavigateOptions,\n  NavigationType,\n  RelativeRoutingType,\n  RouteObject,\n  To,\n} from \"react-router\";\nimport {\n  Router,\n  createPath,\n  useHref,\n  useLocation,\n  useMatches,\n  useNavigate,\n  useNavigation,\n  useResolvedPath,\n  unstable_useBlocker as useBlocker,\n  UNSAFE_DataRouterContext as DataRouterContext,\n  UNSAFE_DataRouterStateContext as DataRouterStateContext,\n  UNSAFE_NavigationContext as NavigationContext,\n  UNSAFE_RouteContext as RouteContext,\n  UNSAFE_mapRouteProperties as mapRouteProperties,\n  UNSAFE_useRouteId as useRouteId,\n} from \"react-router\";\nimport type {\n  BrowserHistory,\n  Fetcher,\n  FormEncType,\n  FormMethod,\n  FutureConfig as RouterFutureConfig,\n  GetScrollRestorationKeyFunction,\n  HashHistory,\n  History,\n  HTMLFormMethod,\n  HydrationState,\n  Router as RemixRouter,\n  V7_FormMethod,\n} from \"@remix-run/router\";\nimport {\n  createRouter,\n  createBrowserHistory,\n  createHashHistory,\n  joinPaths,\n  stripBasename,\n  ErrorResponse,\n  UNSAFE_invariant as invariant,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n  SubmitOptions,\n  ParamKeyValuePair,\n  URLSearchParamsInit,\n  SubmitTarget,\n} from \"./dom\";\nimport {\n  createSearchParams,\n  defaultMethod,\n  getFormSubmissionInfo,\n  getSearchParamsForLocation,\n  shouldProcessLinkClick,\n} from \"./dom\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Re-exports\n////////////////////////////////////////////////////////////////////////////////\n\nexport type {\n  FormEncType,\n  FormMethod,\n  GetScrollRestorationKeyFunction,\n  ParamKeyValuePair,\n  SubmitOptions,\n  URLSearchParamsInit,\n  V7_FormMethod,\n};\nexport { createSearchParams };\n\n// Note: Keep in sync with react-router exports!\nexport type {\n  ActionFunction,\n  ActionFunctionArgs,\n  AwaitProps,\n  unstable_Blocker,\n  unstable_BlockerFunction,\n  DataRouteMatch,\n  DataRouteObject,\n  Fetcher,\n  Hash,\n  IndexRouteObject,\n  IndexRouteProps,\n  JsonFunction,\n  LazyRouteFunction,\n  LayoutRouteProps,\n  LoaderFunction,\n  LoaderFunctionArgs,\n  Location,\n  MemoryRouterProps,\n  NavigateFunction,\n  NavigateOptions,\n  NavigateProps,\n  Navigation,\n  Navigator,\n  NonIndexRouteObject,\n  OutletProps,\n  Params,\n  ParamParseKey,\n  Path,\n  PathMatch,\n  Pathname,\n  PathPattern,\n  PathRouteProps,\n  RedirectFunction,\n  RelativeRoutingType,\n  RouteMatch,\n  RouteObject,\n  RouteProps,\n  RouterProps,\n  RouterProviderProps,\n  RoutesProps,\n  Search,\n  ShouldRevalidateFunction,\n  To,\n} from \"react-router\";\nexport {\n  AbortedDeferredError,\n  Await,\n  MemoryRouter,\n  Navigate,\n  NavigationType,\n  Outlet,\n  Route,\n  Router,\n  RouterProvider,\n  Routes,\n  createMemoryRouter,\n  createPath,\n  createRoutesFromChildren,\n  createRoutesFromElements,\n  defer,\n  isRouteErrorResponse,\n  generatePath,\n  json,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  redirect,\n  renderMatches,\n  resolvePath,\n  useActionData,\n  useAsyncError,\n  useAsyncValue,\n  unstable_useBlocker,\n  useHref,\n  useInRouterContext,\n  useLoaderData,\n  useLocation,\n  useMatch,\n  useMatches,\n  useNavigate,\n  useNavigation,\n  useNavigationType,\n  useOutlet,\n  useOutletContext,\n  useParams,\n  useResolvedPath,\n  useRevalidator,\n  useRouteError,\n  useRouteLoaderData,\n  useRoutes,\n} from \"react-router\";\n\n///////////////////////////////////////////////////////////////////////////////\n// DANGER! PLEASE READ ME!\n// We provide these exports as an escape hatch in the event that you need any\n// routing data that we don't provide an explicit API for. With that said, we\n// want to cover your use case if we can, so if you feel the need to use these\n// we want to hear from you. Let us know what you're building and we'll do our\n// best to make sure we can support you!\n//\n// We consider these exports an implementation detail and do not guarantee\n// against any breaking changes, regardless of the semver release. Use with\n// extreme caution and only if you understand the consequences. Godspeed.\n///////////////////////////////////////////////////////////////////////////////\n\n/** @internal */\nexport {\n  UNSAFE_DataRouterContext,\n  UNSAFE_DataRouterStateContext,\n  UNSAFE_NavigationContext,\n  UNSAFE_LocationContext,\n  UNSAFE_RouteContext,\n  UNSAFE_useRouteId,\n} from \"react-router\";\n//#endregion\n\ndeclare global {\n  var __staticRouterHydrationData: HydrationState | undefined;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Routers\n////////////////////////////////////////////////////////////////////////////////\n\ninterface DOMRouterOpts {\n  basename?: string;\n  future?: Partial<Omit<RouterFutureConfig, \"v7_prependBasename\">>;\n  hydrationData?: HydrationState;\n  window?: Window;\n}\n\nexport function createBrowserRouter(\n  routes: RouteObject[],\n  opts?: DOMRouterOpts\n): RemixRouter {\n  return createRouter({\n    basename: opts?.basename,\n    future: {\n      ...opts?.future,\n      v7_prependBasename: true,\n    },\n    history: createBrowserHistory({ window: opts?.window }),\n    hydrationData: opts?.hydrationData || parseHydrationData(),\n    routes,\n    mapRouteProperties,\n  }).initialize();\n}\n\nexport function createHashRouter(\n  routes: RouteObject[],\n  opts?: DOMRouterOpts\n): RemixRouter {\n  return createRouter({\n    basename: opts?.basename,\n    future: {\n      ...opts?.future,\n      v7_prependBasename: true,\n    },\n    history: createHashHistory({ window: opts?.window }),\n    hydrationData: opts?.hydrationData || parseHydrationData(),\n    routes,\n    mapRouteProperties,\n  }).initialize();\n}\n\nfunction parseHydrationData(): HydrationState | undefined {\n  let state = window?.__staticRouterHydrationData;\n  if (state && state.errors) {\n    state = {\n      ...state,\n      errors: deserializeErrors(state.errors),\n    };\n  }\n  return state;\n}\n\nfunction deserializeErrors(\n  errors: RemixRouter[\"state\"][\"errors\"]\n): RemixRouter[\"state\"][\"errors\"] {\n  if (!errors) return null;\n  let entries = Object.entries(errors);\n  let serialized: RemixRouter[\"state\"][\"errors\"] = {};\n  for (let [key, val] of entries) {\n    // Hey you!  If you change this, please change the corresponding logic in\n    // serializeErrors in react-router-dom/server.tsx :)\n    if (val && val.__type === \"RouteErrorResponse\") {\n      serialized[key] = new ErrorResponse(\n        val.status,\n        val.statusText,\n        val.data,\n        val.internal === true\n      );\n    } else if (val && val.__type === \"Error\") {\n      let error = new Error(val.message);\n      // Wipe away the client-side stack trace.  Nothing to fill it in with\n      // because we don't serialize SSR stack traces for security reasons\n      error.stack = \"\";\n      serialized[key] = error;\n    } else {\n      serialized[key] = val;\n    }\n  }\n  return serialized;\n}\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Components\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\nexport interface BrowserRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  future?: FutureConfig;\n  window?: Window;\n}\n\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\nexport function BrowserRouter({\n  basename,\n  children,\n  future,\n  window,\n}: BrowserRouterProps) {\n  let historyRef = React.useRef<BrowserHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({ window, v5Compat: true });\n  }\n\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface HashRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  future?: FutureConfig;\n  window?: Window;\n}\n\n/**\n * A `<Router>` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\nexport function HashRouter({\n  basename,\n  children,\n  future,\n  window,\n}: HashRouterProps) {\n  let historyRef = React.useRef<HashHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({ window, v5Compat: true });\n  }\n\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface HistoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  future?: FutureConfig;\n  history: History;\n}\n\n/**\n * A `<Router>` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\nfunction HistoryRouter({\n  basename,\n  children,\n  future,\n  history,\n}: HistoryRouterProps) {\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nif (__DEV__) {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\n\nexport { HistoryRouter as unstable_HistoryRouter };\n\nexport interface LinkProps\n  extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, \"href\"> {\n  reloadDocument?: boolean;\n  replace?: boolean;\n  state?: any;\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  to: To;\n}\n\nconst isBrowser =\n  typeof window !== \"undefined\" &&\n  typeof window.document !== \"undefined\" &&\n  typeof window.document.createElement !== \"undefined\";\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\n/**\n * The public API for rendering a history-aware <a>.\n */\nexport const Link = React.forwardRef<HTMLAnchorElement, LinkProps>(\n  function LinkWithRef(\n    {\n      onClick,\n      relative,\n      reloadDocument,\n      replace,\n      state,\n      target,\n      to,\n      preventScrollReset,\n      ...rest\n    },\n    ref\n  ) {\n    let { basename } = React.useContext(NavigationContext);\n\n    // Rendered into <a href> for absolute URLs\n    let absoluteHref;\n    let isExternal = false;\n\n    if (typeof to === \"string\" && ABSOLUTE_URL_REGEX.test(to)) {\n      // Render the absolute href server- and client-side\n      absoluteHref = to;\n\n      // Only check for external origins client-side\n      if (isBrowser) {\n        try {\n          let currentUrl = new URL(window.location.href);\n          let targetUrl = to.startsWith(\"//\")\n            ? new URL(currentUrl.protocol + to)\n            : new URL(to);\n          let path = stripBasename(targetUrl.pathname, basename);\n\n          if (targetUrl.origin === currentUrl.origin && path != null) {\n            // Strip the protocol/origin/basename for same-origin absolute URLs\n            to = path + targetUrl.search + targetUrl.hash;\n          } else {\n            isExternal = true;\n          }\n        } catch (e) {\n          // We can't do external URL detection without a valid URL\n          warning(\n            false,\n            `<Link to=\"${to}\"> contains an invalid URL which will probably break ` +\n              `when clicked - please update to a valid URL path.`\n          );\n        }\n      }\n    }\n\n    // Rendered into <a href> for relative URLs\n    let href = useHref(to, { relative });\n\n    let internalOnClick = useLinkClickHandler(to, {\n      replace,\n      state,\n      target,\n      preventScrollReset,\n      relative,\n    });\n    function handleClick(\n      event: React.MouseEvent<HTMLAnchorElement, MouseEvent>\n    ) {\n      if (onClick) onClick(event);\n      if (!event.defaultPrevented) {\n        internalOnClick(event);\n      }\n    }\n\n    return (\n      // eslint-disable-next-line jsx-a11y/anchor-has-content\n      <a\n        {...rest}\n        href={absoluteHref || href}\n        onClick={isExternal || reloadDocument ? onClick : handleClick}\n        ref={ref}\n        target={target}\n      />\n    );\n  }\n);\n\nif (__DEV__) {\n  Link.displayName = \"Link\";\n}\n\nexport interface NavLinkProps\n  extends Omit<LinkProps, \"className\" | \"style\" | \"children\"> {\n  children?:\n    | React.ReactNode\n    | ((props: { isActive: boolean; isPending: boolean }) => React.ReactNode);\n  caseSensitive?: boolean;\n  className?:\n    | string\n    | ((props: {\n        isActive: boolean;\n        isPending: boolean;\n      }) => string | undefined);\n  end?: boolean;\n  style?:\n    | React.CSSProperties\n    | ((props: {\n        isActive: boolean;\n        isPending: boolean;\n      }) => React.CSSProperties | undefined);\n}\n\n/**\n * A <Link> wrapper that knows if it's \"active\" or not.\n */\nexport const NavLink = React.forwardRef<HTMLAnchorElement, NavLinkProps>(\n  function NavLinkWithRef(\n    {\n      \"aria-current\": ariaCurrentProp = \"page\",\n      caseSensitive = false,\n      className: classNameProp = \"\",\n      end = false,\n      style: styleProp,\n      to,\n      children,\n      ...rest\n    },\n    ref\n  ) {\n    let path = useResolvedPath(to, { relative: rest.relative });\n    let location = useLocation();\n    let routerState = React.useContext(DataRouterStateContext);\n    let { navigator } = React.useContext(NavigationContext);\n\n    let toPathname = navigator.encodeLocation\n      ? navigator.encodeLocation(path).pathname\n      : path.pathname;\n    let locationPathname = location.pathname;\n    let nextLocationPathname =\n      routerState && routerState.navigation && routerState.navigation.location\n        ? routerState.navigation.location.pathname\n        : null;\n\n    if (!caseSensitive) {\n      locationPathname = locationPathname.toLowerCase();\n      nextLocationPathname = nextLocationPathname\n        ? nextLocationPathname.toLowerCase()\n        : null;\n      toPathname = toPathname.toLowerCase();\n    }\n\n    let isActive =\n      locationPathname === toPathname ||\n      (!end &&\n        locationPathname.startsWith(toPathname) &&\n        locationPathname.charAt(toPathname.length) === \"/\");\n\n    let isPending =\n      nextLocationPathname != null &&\n      (nextLocationPathname === toPathname ||\n        (!end &&\n          nextLocationPathname.startsWith(toPathname) &&\n          nextLocationPathname.charAt(toPathname.length) === \"/\"));\n\n    let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n\n    let className: string | undefined;\n    if (typeof classNameProp === \"function\") {\n      className = classNameProp({ isActive, isPending });\n    } else {\n      // If the className prop is not a function, we use a default `active`\n      // class for <NavLink />s that are active. In v5 `active` was the default\n      // value for `activeClassName`, but we are removing that API and can still\n      // use the old default behavior for a cleaner upgrade path and keep the\n      // simple styling rules working as they currently do.\n      className = [\n        classNameProp,\n        isActive ? \"active\" : null,\n        isPending ? \"pending\" : null,\n      ]\n        .filter(Boolean)\n        .join(\" \");\n    }\n\n    let style =\n      typeof styleProp === \"function\"\n        ? styleProp({ isActive, isPending })\n        : styleProp;\n\n    return (\n      <Link\n        {...rest}\n        aria-current={ariaCurrent}\n        className={className}\n        ref={ref}\n        style={style}\n        to={to}\n      >\n        {typeof children === \"function\"\n          ? children({ isActive, isPending })\n          : children}\n      </Link>\n    );\n  }\n);\n\nif (__DEV__) {\n  NavLink.displayName = \"NavLink\";\n}\n\nexport interface FormProps extends React.FormHTMLAttributes<HTMLFormElement> {\n  /**\n   * The HTTP verb to use when the form is submit. Supports \"get\", \"post\",\n   * \"put\", \"delete\", \"patch\".\n   */\n  method?: HTMLFormMethod;\n\n  /**\n   * `<form encType>` - enhancing beyond the normal string type and limiting\n   * to the built-in browser supported values\n   */\n  encType?:\n    | \"application/x-www-form-urlencoded\"\n    | \"multipart/form-data\"\n    | \"text/plain\";\n\n  /**\n   * Normal `<form action>` but supports React Router's relative paths.\n   */\n  action?: string;\n\n  /**\n   * Forces a full document navigation instead of a fetch.\n   */\n  reloadDocument?: boolean;\n\n  /**\n   * Replaces the current entry in the browser history stack when the form\n   * navigates. Use this if you don't want the user to be able to click \"back\"\n   * to the page with the form on it.\n   */\n  replace?: boolean;\n\n  /**\n   * Determines whether the form action is relative to the route hierarchy or\n   * the pathname.  Use this if you want to opt out of navigating the route\n   * hierarchy and want to instead route based on /-delimited URL segments\n   */\n  relative?: RelativeRoutingType;\n\n  /**\n   * Prevent the scroll position from resetting to the top of the viewport on\n   * completion of the navigation when using the <ScrollRestoration> component\n   */\n  preventScrollReset?: boolean;\n\n  /**\n   * A function to call when the form is submitted. If you call\n   * `event.preventDefault()` then this form will not do anything.\n   */\n  onSubmit?: React.FormEventHandler<HTMLFormElement>;\n}\n\n/**\n * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except\n * that the interaction with the server is with `fetch` instead of new document\n * requests, allowing components to add nicer UX to the page as the form is\n * submitted and returns with data.\n */\nexport const Form = React.forwardRef<HTMLFormElement, FormProps>(\n  (props, ref) => {\n    let submit = useSubmit();\n    return <FormImpl {...props} submit={submit} ref={ref} />;\n  }\n);\n\nif (__DEV__) {\n  Form.displayName = \"Form\";\n}\n\ntype HTMLSubmitEvent = React.BaseSyntheticEvent<\n  SubmitEvent,\n  Event,\n  HTMLFormElement\n>;\n\ntype HTMLFormSubmitter = HTMLButtonElement | HTMLInputElement;\n\ninterface FormImplProps extends FormProps {\n  submit: SubmitFunction | FetcherSubmitFunction;\n}\n\nconst FormImpl = React.forwardRef<HTMLFormElement, FormImplProps>(\n  (\n    {\n      reloadDocument,\n      replace,\n      method = defaultMethod,\n      action,\n      onSubmit,\n      submit,\n      relative,\n      preventScrollReset,\n      ...props\n    },\n    forwardedRef\n  ) => {\n    let formMethod: HTMLFormMethod =\n      method.toLowerCase() === \"get\" ? \"get\" : \"post\";\n    let formAction = useFormAction(action, { relative });\n    let submitHandler: React.FormEventHandler<HTMLFormElement> = (event) => {\n      onSubmit && onSubmit(event);\n      if (event.defaultPrevented) return;\n      event.preventDefault();\n\n      let submitter = (event as unknown as HTMLSubmitEvent).nativeEvent\n        .submitter as HTMLFormSubmitter | null;\n\n      let submitMethod =\n        (submitter?.getAttribute(\"formmethod\") as HTMLFormMethod | undefined) ||\n        method;\n\n      submit(submitter || event.currentTarget, {\n        method: submitMethod,\n        replace,\n        relative,\n        preventScrollReset,\n      });\n    };\n\n    return (\n      <form\n        ref={forwardedRef}\n        method={formMethod}\n        action={formAction}\n        onSubmit={reloadDocument ? onSubmit : submitHandler}\n        {...props}\n      />\n    );\n  }\n);\n\nif (__DEV__) {\n  FormImpl.displayName = \"FormImpl\";\n}\n\nexport interface ScrollRestorationProps {\n  getKey?: GetScrollRestorationKeyFunction;\n  storageKey?: string;\n}\n\n/**\n * This component will emulate the browser's scroll restoration on location\n * changes.\n */\nexport function ScrollRestoration({\n  getKey,\n  storageKey,\n}: ScrollRestorationProps) {\n  useScrollRestoration({ getKey, storageKey });\n  return null;\n}\n\nif (__DEV__) {\n  ScrollRestoration.displayName = \"ScrollRestoration\";\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hooks\n////////////////////////////////////////////////////////////////////////////////\n\nenum DataRouterHook {\n  UseScrollRestoration = \"useScrollRestoration\",\n  UseSubmit = \"useSubmit\",\n  UseSubmitFetcher = \"useSubmitFetcher\",\n  UseFetcher = \"useFetcher\",\n}\n\nenum DataRouterStateHook {\n  UseFetchers = \"useFetchers\",\n  UseScrollRestoration = \"useScrollRestoration\",\n}\n\nfunction getDataRouterConsoleError(\n  hookName: DataRouterHook | DataRouterStateHook\n) {\n  return `${hookName} must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.`;\n}\n\nfunction useDataRouterContext(hookName: DataRouterHook) {\n  let ctx = React.useContext(DataRouterContext);\n  invariant(ctx, getDataRouterConsoleError(hookName));\n  return ctx;\n}\n\nfunction useDataRouterState(hookName: DataRouterStateHook) {\n  let state = React.useContext(DataRouterStateContext);\n  invariant(state, getDataRouterConsoleError(hookName));\n  return state;\n}\n\n/**\n * Handles the click behavior for router `<Link>` components. This is useful if\n * you need to create custom `<Link>` components with the same click behavior we\n * use in our exported `<Link>`.\n */\nexport function useLinkClickHandler<E extends Element = HTMLAnchorElement>(\n  to: To,\n  {\n    target,\n    replace: replaceProp,\n    state,\n    preventScrollReset,\n    relative,\n  }: {\n    target?: React.HTMLAttributeAnchorTarget;\n    replace?: boolean;\n    state?: any;\n    preventScrollReset?: boolean;\n    relative?: RelativeRoutingType;\n  } = {}\n): (event: React.MouseEvent<E, MouseEvent>) => void {\n  let navigate = useNavigate();\n  let location = useLocation();\n  let path = useResolvedPath(to, { relative });\n\n  return React.useCallback(\n    (event: React.MouseEvent<E, MouseEvent>) => {\n      if (shouldProcessLinkClick(event, target)) {\n        event.preventDefault();\n\n        // If the URL hasn't changed, a regular <a> will do a replace instead of\n        // a push, so do the same here unless the replace prop is explicitly set\n        let replace =\n          replaceProp !== undefined\n            ? replaceProp\n            : createPath(location) === createPath(path);\n\n        navigate(to, { replace, state, preventScrollReset, relative });\n      }\n    },\n    [\n      location,\n      navigate,\n      path,\n      replaceProp,\n      state,\n      target,\n      to,\n      preventScrollReset,\n      relative,\n    ]\n  );\n}\n\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\nexport function useSearchParams(\n  defaultInit?: URLSearchParamsInit\n): [URLSearchParams, SetURLSearchParams] {\n  warning(\n    typeof URLSearchParams !== \"undefined\",\n    `You cannot use the \\`useSearchParams\\` hook in a browser that does not ` +\n      `support the URLSearchParams API. If you need to support Internet ` +\n      `Explorer 11, we recommend you load a polyfill such as ` +\n      `https://github.com/ungap/url-search-params\\n\\n` +\n      `If you're unsure how to load polyfills, we recommend you check out ` +\n      `https://polyfill.io/v3/ which provides some recommendations about how ` +\n      `to load polyfills only for users that need them, instead of for every ` +\n      `user.`\n  );\n\n  let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n  let hasSetSearchParamsRef = React.useRef(false);\n\n  let location = useLocation();\n  let searchParams = React.useMemo(\n    () =>\n      // Only merge in the defaults if we haven't yet called setSearchParams.\n      // Once we call that we want those to take precedence, otherwise you can't\n      // remove a param with setSearchParams({}) if it has an initial value\n      getSearchParamsForLocation(\n        location.search,\n        hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current\n      ),\n    [location.search]\n  );\n\n  let navigate = useNavigate();\n  let setSearchParams = React.useCallback<SetURLSearchParams>(\n    (nextInit, navigateOptions) => {\n      const newSearchParams = createSearchParams(\n        typeof nextInit === \"function\" ? nextInit(searchParams) : nextInit\n      );\n      hasSetSearchParamsRef.current = true;\n      navigate(\"?\" + newSearchParams, navigateOptions);\n    },\n    [navigate, searchParams]\n  );\n\n  return [searchParams, setSearchParams];\n}\n\nexport type SetURLSearchParams = (\n  nextInit?:\n    | URLSearchParamsInit\n    | ((prev: URLSearchParams) => URLSearchParamsInit),\n  navigateOpts?: NavigateOptions\n) => void;\n\n/**\n * Submits a HTML `<form>` to the server without reloading the page.\n */\nexport interface SubmitFunction {\n  (\n    /**\n     * Specifies the `<form>` to be submitted to the server, a specific\n     * `<button>` or `<input type=\"submit\">` to use to submit the form, or some\n     * arbitrary data to submit.\n     *\n     * Note: When using a `<button>` its `name` and `value` will also be\n     * included in the form data that is submitted.\n     */\n    target: SubmitTarget,\n\n    /**\n     * Options that override the `<form>`'s own attributes. Required when\n     * submitting arbitrary data without a backing `<form>`.\n     */\n    options?: SubmitOptions\n  ): void;\n}\n\n/**\n * Submits a fetcher `<form>` to the server without reloading the page.\n */\nexport interface FetcherSubmitFunction {\n  (\n    target: SubmitTarget,\n    // Fetchers cannot replace because they are not navigation events\n    options?: Omit<SubmitOptions, \"replace\">\n  ): void;\n}\n\nfunction validateClientSideSubmission() {\n  if (typeof document === \"undefined\") {\n    throw new Error(\n      \"You are calling submit during the server render. \" +\n        \"Try calling submit within a `useEffect` or callback instead.\"\n    );\n  }\n}\n\n/**\n * Returns a function that may be used to programmatically submit a form (or\n * some arbitrary data) to the server.\n */\nexport function useSubmit(): SubmitFunction {\n  let { router } = useDataRouterContext(DataRouterHook.UseSubmit);\n  let { basename } = React.useContext(NavigationContext);\n  let currentRouteId = useRouteId();\n\n  return React.useCallback<SubmitFunction>(\n    (target, options = {}) => {\n      validateClientSideSubmission();\n\n      let { action, method, encType, formData, body } = getFormSubmissionInfo(\n        target,\n        basename\n      );\n\n      router.navigate(options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || (method as HTMLFormMethod),\n        formEncType: options.encType || (encType as FormEncType),\n        replace: options.replace,\n        fromRouteId: currentRouteId,\n      });\n    },\n    [router, basename, currentRouteId]\n  );\n}\n\n/**\n * Returns the implementation for fetcher.submit\n */\nfunction useSubmitFetcher(\n  fetcherKey: string,\n  fetcherRouteId: string\n): FetcherSubmitFunction {\n  let { router } = useDataRouterContext(DataRouterHook.UseSubmitFetcher);\n  let { basename } = React.useContext(NavigationContext);\n\n  return React.useCallback<FetcherSubmitFunction>(\n    (target, options = {}) => {\n      validateClientSideSubmission();\n\n      let { action, method, encType, formData, body } = getFormSubmissionInfo(\n        target,\n        basename\n      );\n\n      invariant(\n        fetcherRouteId != null,\n        \"No routeId available for useFetcher()\"\n      );\n      router.fetch(fetcherKey, fetcherRouteId, options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || (method as HTMLFormMethod),\n        formEncType: options.encType || (encType as FormEncType),\n      });\n    },\n    [router, basename, fetcherKey, fetcherRouteId]\n  );\n}\n\n// v7: Eventually we should deprecate this entirely in favor of using the\n// router method directly?\nexport function useFormAction(\n  action?: string,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): string {\n  let { basename } = React.useContext(NavigationContext);\n  let routeContext = React.useContext(RouteContext);\n  invariant(routeContext, \"useFormAction must be used inside a RouteContext\");\n\n  let [match] = routeContext.matches.slice(-1);\n  // Shallow clone path so we can modify it below, otherwise we modify the\n  // object referenced by useMemo inside useResolvedPath\n  let path = { ...useResolvedPath(action ? action : \".\", { relative }) };\n\n  // Previously we set the default action to \".\". The problem with this is that\n  // `useResolvedPath(\".\")` excludes search params and the hash of the resolved\n  // URL. This is the intended behavior of when \".\" is specifically provided as\n  // the form action, but inconsistent w/ browsers when the action is omitted.\n  // https://github.com/remix-run/remix/issues/927\n  let location = useLocation();\n  if (action == null) {\n    // Safe to write to these directly here since if action was undefined, we\n    // would have called useResolvedPath(\".\") which will never include a search\n    // or hash\n    path.search = location.search;\n    path.hash = location.hash;\n\n    // When grabbing search params from the URL, remove the automatically\n    // inserted ?index param so we match the useResolvedPath search behavior\n    // which would not include ?index\n    if (match.route.index) {\n      let params = new URLSearchParams(path.search);\n      params.delete(\"index\");\n      path.search = params.toString() ? `?${params.toString()}` : \"\";\n    }\n  }\n\n  if ((!action || action === \".\") && match.route.index) {\n    path.search = path.search\n      ? path.search.replace(/^\\?/, \"?index&\")\n      : \"?index\";\n  }\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the form action.  If this is a root navigation, then just use\n  // the raw basename which allows the basename to have full control over the\n  // presence of a trailing slash on root actions\n  if (basename !== \"/\") {\n    path.pathname =\n      path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\nfunction createFetcherForm(fetcherKey: string, routeId: string) {\n  let FetcherForm = React.forwardRef<HTMLFormElement, FormProps>(\n    (props, ref) => {\n      let submit = useSubmitFetcher(fetcherKey, routeId);\n      return <FormImpl {...props} ref={ref} submit={submit} />;\n    }\n  );\n  if (__DEV__) {\n    FetcherForm.displayName = \"fetcher.Form\";\n  }\n  return FetcherForm;\n}\n\nlet fetcherId = 0;\n\nexport type FetcherWithComponents<TData> = Fetcher<TData> & {\n  Form: ReturnType<typeof createFetcherForm>;\n  submit: FetcherSubmitFunction;\n  load: (href: string) => void;\n};\n\n/**\n * Interacts with route loaders and actions without causing a navigation. Great\n * for any interaction that stays on the same page.\n */\nexport function useFetcher<TData = any>(): FetcherWithComponents<TData> {\n  let { router } = useDataRouterContext(DataRouterHook.UseFetcher);\n\n  let route = React.useContext(RouteContext);\n  invariant(route, `useFetcher must be used inside a RouteContext`);\n\n  let routeId = route.matches[route.matches.length - 1]?.route.id;\n  invariant(\n    routeId != null,\n    `useFetcher can only be used on routes that contain a unique \"id\"`\n  );\n\n  let [fetcherKey] = React.useState(() => String(++fetcherId));\n  let [Form] = React.useState(() => {\n    invariant(routeId, `No routeId available for fetcher.Form()`);\n    return createFetcherForm(fetcherKey, routeId);\n  });\n  let [load] = React.useState(() => (href: string) => {\n    invariant(router, \"No router available for fetcher.load()\");\n    invariant(routeId, \"No routeId available for fetcher.load()\");\n    router.fetch(fetcherKey, routeId, href);\n  });\n  let submit = useSubmitFetcher(fetcherKey, routeId);\n\n  let fetcher = router.getFetcher<TData>(fetcherKey);\n\n  let fetcherWithComponents = React.useMemo(\n    () => ({\n      Form,\n      submit,\n      load,\n      ...fetcher,\n    }),\n    [fetcher, Form, submit, load]\n  );\n\n  React.useEffect(() => {\n    // Is this busted when the React team gets real weird and calls effects\n    // twice on mount?  We really just need to garbage collect here when this\n    // fetcher is no longer around.\n    return () => {\n      if (!router) {\n        console.warn(`No router available to clean up from useFetcher()`);\n        return;\n      }\n      router.deleteFetcher(fetcherKey);\n    };\n  }, [router, fetcherKey]);\n\n  return fetcherWithComponents;\n}\n\n/**\n * Provides all fetchers currently on the page. Useful for layouts and parent\n * routes that need to provide pending/optimistic UI regarding the fetch.\n */\nexport function useFetchers(): Fetcher[] {\n  let state = useDataRouterState(DataRouterStateHook.UseFetchers);\n  return [...state.fetchers.values()];\n}\n\nconst SCROLL_RESTORATION_STORAGE_KEY = \"react-router-scroll-positions\";\nlet savedScrollPositions: Record<string, number> = {};\n\n/**\n * When rendered inside a RouterProvider, will restore scroll positions on navigations\n */\nfunction useScrollRestoration({\n  getKey,\n  storageKey,\n}: {\n  getKey?: GetScrollRestorationKeyFunction;\n  storageKey?: string;\n} = {}) {\n  let { router } = useDataRouterContext(DataRouterHook.UseScrollRestoration);\n  let { restoreScrollPosition, preventScrollReset } = useDataRouterState(\n    DataRouterStateHook.UseScrollRestoration\n  );\n  let { basename } = React.useContext(NavigationContext);\n  let location = useLocation();\n  let matches = useMatches();\n  let navigation = useNavigation();\n\n  // Trigger manual scroll restoration while we're active\n  React.useEffect(() => {\n    window.history.scrollRestoration = \"manual\";\n    return () => {\n      window.history.scrollRestoration = \"auto\";\n    };\n  }, []);\n\n  // Save positions on pagehide\n  usePageHide(\n    React.useCallback(() => {\n      if (navigation.state === \"idle\") {\n        let key = (getKey ? getKey(location, matches) : null) || location.key;\n        savedScrollPositions[key] = window.scrollY;\n      }\n      sessionStorage.setItem(\n        storageKey || SCROLL_RESTORATION_STORAGE_KEY,\n        JSON.stringify(savedScrollPositions)\n      );\n      window.history.scrollRestoration = \"auto\";\n    }, [storageKey, getKey, navigation.state, location, matches])\n  );\n\n  // Read in any saved scroll locations\n  if (typeof document !== \"undefined\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      try {\n        let sessionPositions = sessionStorage.getItem(\n          storageKey || SCROLL_RESTORATION_STORAGE_KEY\n        );\n        if (sessionPositions) {\n          savedScrollPositions = JSON.parse(sessionPositions);\n        }\n      } catch (e) {\n        // no-op, use default empty object\n      }\n    }, [storageKey]);\n\n    // Enable scroll restoration in the router\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      let getKeyWithoutBasename: GetScrollRestorationKeyFunction | undefined =\n        getKey && basename !== \"/\"\n          ? (location, matches) =>\n              getKey(\n                // Strip the basename to match useLocation()\n                {\n                  ...location,\n                  pathname:\n                    stripBasename(location.pathname, basename) ||\n                    location.pathname,\n                },\n                matches\n              )\n          : getKey;\n      let disableScrollRestoration = router?.enableScrollRestoration(\n        savedScrollPositions,\n        () => window.scrollY,\n        getKeyWithoutBasename\n      );\n      return () => disableScrollRestoration && disableScrollRestoration();\n    }, [router, basename, getKey]);\n\n    // Restore scrolling when state.restoreScrollPosition changes\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      // Explicit false means don't do anything (used for submissions)\n      if (restoreScrollPosition === false) {\n        return;\n      }\n\n      // been here before, scroll to it\n      if (typeof restoreScrollPosition === \"number\") {\n        window.scrollTo(0, restoreScrollPosition);\n        return;\n      }\n\n      // try to scroll to the hash\n      if (location.hash) {\n        let el = document.getElementById(location.hash.slice(1));\n        if (el) {\n          el.scrollIntoView();\n          return;\n        }\n      }\n\n      // Don't reset if this navigation opted out\n      if (preventScrollReset === true) {\n        return;\n      }\n\n      // otherwise go to the top on new locations\n      window.scrollTo(0, 0);\n    }, [location, restoreScrollPosition, preventScrollReset]);\n  }\n}\n\nexport { useScrollRestoration as UNSAFE_useScrollRestoration };\n\n/**\n * Setup a callback to be fired on the window's `beforeunload` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nexport function useBeforeUnload(\n  callback: (event: BeforeUnloadEvent) => any,\n  options?: { capture?: boolean }\n): void {\n  let { capture } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? { capture } : undefined;\n    window.addEventListener(\"beforeunload\", callback, opts);\n    return () => {\n      window.removeEventListener(\"beforeunload\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n\n/**\n * Setup a callback to be fired on the window's `pagehide` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.  This event is better supported than beforeunload across browsers.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction usePageHide(\n  callback: (event: PageTransitionEvent) => any,\n  options?: { capture?: boolean }\n): void {\n  let { capture } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? { capture } : undefined;\n    window.addEventListener(\"pagehide\", callback, opts);\n    return () => {\n      window.removeEventListener(\"pagehide\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n\n/**\n * Wrapper around useBlocker to show a window.confirm prompt to users instead\n * of building a custom UI with useBlocker.\n *\n * Warning: This has *a lot of rough edges* and behaves very differently (and\n * very incorrectly in some cases) across browsers if user click addition\n * back/forward navigations while the confirm is open.  Use at your own risk.\n */\nfunction usePrompt({ when, message }: { when: boolean; message: string }) {\n  let blocker = useBlocker(when);\n\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\" && !when) {\n      blocker.reset();\n    }\n  }, [blocker, when]);\n\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\") {\n      let proceed = window.confirm(message);\n      if (proceed) {\n        setTimeout(blocker.proceed, 0);\n      } else {\n        blocker.reset();\n      }\n    }\n  }, [blocker, message]);\n}\n\nexport { usePrompt as unstable_usePrompt };\n\n//#endregion\n","import * as React from \"react\";\nimport type {\n  AgnosticRouteMatch,\n  AgnosticIndexRouteObject,\n  AgnosticNonIndexRouteObject,\n  History,\n  Location,\n  RelativeRoutingType,\n  Router,\n  StaticHandlerContext,\n  To,\n  TrackedPromise,\n  LazyRouteFunction,\n} from \"@remix-run/router\";\nimport type { Action as NavigationType } from \"@remix-run/router\";\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nexport interface IndexRouteObject {\n  caseSensitive?: AgnosticIndexRouteObject[\"caseSensitive\"];\n  path?: AgnosticIndexRouteObject[\"path\"];\n  id?: AgnosticIndexRouteObject[\"id\"];\n  loader?: AgnosticIndexRouteObject[\"loader\"];\n  action?: AgnosticIndexRouteObject[\"action\"];\n  hasErrorBoundary?: AgnosticIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: AgnosticIndexRouteObject[\"shouldRevalidate\"];\n  handle?: AgnosticIndexRouteObject[\"handle\"];\n  index: true;\n  children?: undefined;\n  element?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n  lazy?: LazyRouteFunction<IndexRouteObject>;\n}\n\nexport interface NonIndexRouteObject {\n  caseSensitive?: AgnosticNonIndexRouteObject[\"caseSensitive\"];\n  path?: AgnosticNonIndexRouteObject[\"path\"];\n  id?: AgnosticNonIndexRouteObject[\"id\"];\n  loader?: AgnosticNonIndexRouteObject[\"loader\"];\n  action?: AgnosticNonIndexRouteObject[\"action\"];\n  hasErrorBoundary?: AgnosticNonIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: AgnosticNonIndexRouteObject[\"shouldRevalidate\"];\n  handle?: AgnosticNonIndexRouteObject[\"handle\"];\n  index?: false;\n  children?: RouteObject[];\n  element?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n  lazy?: LazyRouteFunction<NonIndexRouteObject>;\n}\n\nexport type RouteObject = IndexRouteObject | NonIndexRouteObject;\n\nexport type DataRouteObject = RouteObject & {\n  children?: DataRouteObject[];\n  id: string;\n};\n\nexport interface RouteMatch<\n  ParamKey extends string = string,\n  RouteObjectType extends RouteObject = RouteObject\n> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {}\n\nexport interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {}\n\nexport interface DataRouterContextObject extends NavigationContextObject {\n  router: Router;\n  staticContext?: StaticHandlerContext;\n}\n\nexport const DataRouterContext =\n  React.createContext<DataRouterContextObject | null>(null);\nif (__DEV__) {\n  DataRouterContext.displayName = \"DataRouter\";\n}\n\nexport const DataRouterStateContext = React.createContext<\n  Router[\"state\"] | null\n>(null);\nif (__DEV__) {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\n\nexport const AwaitContext = React.createContext<TrackedPromise | null>(null);\nif (__DEV__) {\n  AwaitContext.displayName = \"Await\";\n}\n\nexport interface NavigateOptions {\n  replace?: boolean;\n  state?: any;\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level <Router> API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport interface Navigator {\n  createHref: History[\"createHref\"];\n  // Optional for backwards-compat with Router/HistoryRouter usage (edge case)\n  encodeLocation?: History[\"encodeLocation\"];\n  go: History[\"go\"];\n  push(to: To, state?: any, opts?: NavigateOptions): void;\n  replace(to: To, state?: any, opts?: NavigateOptions): void;\n}\n\ninterface NavigationContextObject {\n  basename: string;\n  navigator: Navigator;\n  static: boolean;\n}\n\nexport const NavigationContext = React.createContext<NavigationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n  location: Location;\n  navigationType: NavigationType;\n}\n\nexport const LocationContext = React.createContext<LocationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  LocationContext.displayName = \"Location\";\n}\n\nexport interface RouteContextObject {\n  outlet: React.ReactElement | null;\n  matches: RouteMatch[];\n  isDataRoute: boolean;\n}\n\nexport const RouteContext = React.createContext<RouteContextObject>({\n  outlet: null,\n  matches: [],\n  isDataRoute: false,\n});\n\nif (__DEV__) {\n  RouteContext.displayName = \"Route\";\n}\n\nexport const RouteErrorContext = React.createContext<any>(null);\n\nif (__DEV__) {\n  RouteErrorContext.displayName = \"RouteError\";\n}\n","import * as React from \"react\";\nimport type {\n  Blocker,\n  BlockerFunction,\n  Location,\n  ParamParseKey,\n  Params,\n  Path,\n  PathMatch,\n  PathPattern,\n  RelativeRoutingType,\n  Router as RemixRouter,\n  RevalidationState,\n  To,\n} from \"@remix-run/router\";\nimport {\n  Action as NavigationType,\n  UNSAFE_invariant as invariant,\n  isRouteErrorResponse,\n  joinPaths,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  resolveTo,\n  stripBasename,\n  IDLE_BLOCKER,\n  UNSAFE_getPathContributingMatches as getPathContributingMatches,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n  NavigateOptions,\n  RouteContextObject,\n  RouteMatch,\n  RouteObject,\n  DataRouteMatch,\n} from \"./context\";\nimport {\n  DataRouterContext,\n  DataRouterStateContext,\n  LocationContext,\n  NavigationContext,\n  RouteContext,\n  RouteErrorContext,\n  AwaitContext,\n} from \"./context\";\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/hooks/use-href\n */\nexport function useHref(\n  to: To,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): string {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useHref() may be used only in the context of a <Router> component.`\n  );\n\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { hash, pathname, search } = useResolvedPath(to, { relative });\n\n  let joinedPathname = pathname;\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the href.  If this is a root navigation, then just use the raw\n  // basename which allows the basename to have full control over the presence\n  // of a trailing slash on root links\n  if (basename !== \"/\") {\n    joinedPathname =\n      pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a <Router>.\n *\n * @see https://reactrouter.com/hooks/use-in-router-context\n */\nexport function useInRouterContext(): boolean {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/hooks/use-location\n */\nexport function useLocation(): Location {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useLocation() may be used only in the context of a <Router> component.`\n  );\n\n  return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/hooks/use-navigation-type\n */\nexport function useNavigationType(): NavigationType {\n  return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * <NavLink>.\n *\n * @see https://reactrouter.com/hooks/use-match\n */\nexport function useMatch<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useMatch() may be used only in the context of a <Router> component.`\n  );\n\n  let { pathname } = useLocation();\n  return React.useMemo(\n    () => matchPath<ParamKey, Path>(pattern, pathname),\n    [pathname, pattern]\n  );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n  (to: To, options?: NavigateOptions): void;\n  (delta: number): void;\n}\n\nconst navigateEffectWarning =\n  `You should call navigate() in a React.useEffect(), not when ` +\n  `your component is first rendered.`;\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(\n  cb: Parameters<typeof React.useLayoutEffect>[0]\n) {\n  let isStatic = React.useContext(NavigationContext).static;\n  if (!isStatic) {\n    // We should be able to get rid of this once react 18.3 is released\n    // See: https://github.com/facebook/react/pull/26395\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(cb);\n  }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by <Link>s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/hooks/use-navigate\n */\nexport function useNavigate(): NavigateFunction {\n  let { isDataRoute } = React.useContext(RouteContext);\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\n\nfunction useNavigateUnstable(): NavigateFunction {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useNavigate() may be used only in the context of a <Router> component.`\n  );\n\n  let dataRouterContext = React.useContext(DataRouterContext);\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    getPathContributingMatches(matches).map((match) => match.pathnameBase)\n  );\n\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(activeRef.current, navigateEffectWarning);\n\n      // Short circuit here since if this happens on first render the navigate\n      // is useless because we haven't wired up our history listener yet\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        navigator.go(to);\n        return;\n      }\n\n      let path = resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname,\n        options.relative === \"path\"\n      );\n\n      // If we're operating within a basename, prepend it to the pathname prior\n      // to handing off to history (but only if we're not in a data router,\n      // otherwise it'll prepend the basename inside of the router).\n      // If this is a root navigation, then we navigate to the raw basename\n      // which allows the basename to have full control over the presence of a\n      // trailing slash on root links\n      if (dataRouterContext == null && basename !== \"/\") {\n        path.pathname =\n          path.pathname === \"/\"\n            ? basename\n            : joinPaths([basename, path.pathname]);\n      }\n\n      (!!options.replace ? navigator.replace : navigator.push)(\n        path,\n        options.state,\n        options\n      );\n    },\n    [\n      basename,\n      navigator,\n      routePathnamesJson,\n      locationPathname,\n      dataRouterContext,\n    ]\n  );\n\n  return navigate;\n}\n\nconst OutletContext = React.createContext<unknown>(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/hooks/use-outlet-context\n */\nexport function useOutletContext<Context = unknown>(): Context {\n  return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by <Outlet> to render child routes.\n *\n * @see https://reactrouter.com/hooks/use-outlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return (\n      <OutletContext.Provider value={context}>{outlet}</OutletContext.Provider>\n    );\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/hooks/use-params\n */\nexport function useParams<\n  ParamsOrKey extends string | Record<string, string | undefined> = string\n>(): Readonly<\n  [ParamsOrKey] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>\n> {\n  let { matches } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/hooks/use-resolved-path\n */\nexport function useResolvedPath(\n  to: To,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): Path {\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    getPathContributingMatches(matches).map((match) => match.pathnameBase)\n  );\n\n  return React.useMemo(\n    () =>\n      resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname,\n        relative === \"path\"\n      ),\n    [to, routePathnamesJson, locationPathname, relative]\n  );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an <Outlet> to render their child route's\n * element.\n *\n * @see https://reactrouter.com/hooks/use-routes\n */\nexport function useRoutes(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string\n): React.ReactElement | null {\n  return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nexport function useRoutesImpl(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string,\n  dataRouterState?: RemixRouter[\"state\"]\n): React.ReactElement | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useRoutes() may be used only in the context of a <Router> component.`\n  );\n\n  let { navigator } = React.useContext(NavigationContext);\n  let { matches: parentMatches } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n\n  if (__DEV__) {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = (parentRoute && parentRoute.path) || \"\";\n    warningOnce(\n      parentPathname,\n      !parentRoute || parentPath.endsWith(\"*\"),\n      `You rendered descendant <Routes> (or called \\`useRoutes()\\`) at ` +\n        `\"${parentPathname}\" (under <Route path=\"${parentPath}\">) but the ` +\n        `parent route path has no trailing \"*\". This means if you navigate ` +\n        `deeper, the parent won't match anymore and therefore the child ` +\n        `routes will never render.\\n\\n` +\n        `Please change the parent <Route path=\"${parentPath}\"> to <Route ` +\n        `path=\"${parentPath === \"/\" ? \"*\" : `${parentPath}/*`}\">.`\n    );\n  }\n\n  let locationFromContext = useLocation();\n\n  let location;\n  if (locationArg) {\n    let parsedLocationArg =\n      typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n    invariant(\n      parentPathnameBase === \"/\" ||\n        parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n      `When overriding the location using \\`<Routes location>\\` or \\`useRoutes(routes, location)\\`, ` +\n        `the location pathname must begin with the portion of the URL pathname that was ` +\n        `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n        `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n    );\n\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\n  let pathname = location.pathname || \"/\";\n  let remainingPathname =\n    parentPathnameBase === \"/\"\n      ? pathname\n      : pathname.slice(parentPathnameBase.length) || \"/\";\n\n  let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n  if (__DEV__) {\n    warning(\n      parentRoute || matches != null,\n      `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n    );\n\n    warning(\n      matches == null ||\n        matches[matches.length - 1].route.element !== undefined ||\n        matches[matches.length - 1].route.Component !== undefined,\n      `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" ` +\n        `does not have an element or Component. This means it will render an <Outlet /> with a ` +\n        `null value by default resulting in an \"empty\" page.`\n    );\n  }\n\n  let renderedMatches = _renderMatches(\n    matches &&\n      matches.map((match) =>\n        Object.assign({}, match, {\n          params: Object.assign({}, parentParams, match.params),\n          pathname: joinPaths([\n            parentPathnameBase,\n            // Re-encode pathnames that were decoded inside matchRoutes\n            navigator.encodeLocation\n              ? navigator.encodeLocation(match.pathname).pathname\n              : match.pathname,\n          ]),\n          pathnameBase:\n            match.pathnameBase === \"/\"\n              ? parentPathnameBase\n              : joinPaths([\n                  parentPathnameBase,\n                  // Re-encode pathnames that were decoded inside matchRoutes\n                  navigator.encodeLocation\n                    ? navigator.encodeLocation(match.pathnameBase).pathname\n                    : match.pathnameBase,\n                ]),\n        })\n      ),\n    parentMatches,\n    dataRouterState\n  );\n\n  // When a user passes in a `locationArg`, the associated routes need to\n  // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n  // to use the scoped location instead of the global location.\n  if (locationArg && renderedMatches) {\n    return (\n      <LocationContext.Provider\n        value={{\n          location: {\n            pathname: \"/\",\n            search: \"\",\n            hash: \"\",\n            state: null,\n            key: \"default\",\n            ...location,\n          },\n          navigationType: NavigationType.Pop,\n        }}\n      >\n        {renderedMatches}\n      </LocationContext.Provider>\n    );\n  }\n\n  return renderedMatches;\n}\n\nfunction DefaultErrorComponent() {\n  let error = useRouteError();\n  let message = isRouteErrorResponse(error)\n    ? `${error.status} ${error.statusText}`\n    : error instanceof Error\n    ? error.message\n    : JSON.stringify(error);\n  let stack = error instanceof Error ? error.stack : null;\n  let lightgrey = \"rgba(200,200,200, 0.5)\";\n  let preStyles = { padding: \"0.5rem\", backgroundColor: lightgrey };\n  let codeStyles = { padding: \"2px 4px\", backgroundColor: lightgrey };\n\n  let devInfo = null;\n  if (__DEV__) {\n    console.error(\n      \"Error handled by React Router default ErrorBoundary:\",\n      error\n    );\n\n    devInfo = (\n      <>\n        <p>💿 Hey developer 👋</p>\n        <p>\n          You can provide a way better UX than this when your app throws errors\n          by providing your own <code style={codeStyles}>ErrorBoundary</code> or{\" \"}\n          <code style={codeStyles}>errorElement</code> prop on your route.\n        </p>\n      </>\n    );\n  }\n\n  return (\n    <>\n      <h2>Unexpected Application Error!</h2>\n      <h3 style={{ fontStyle: \"italic\" }}>{message}</h3>\n      {stack ? <pre style={preStyles}>{stack}</pre> : null}\n      {devInfo}\n    </>\n  );\n}\n\nconst defaultErrorElement = <DefaultErrorComponent />;\n\ntype RenderErrorBoundaryProps = React.PropsWithChildren<{\n  location: Location;\n  revalidation: RevalidationState;\n  error: any;\n  component: React.ReactNode;\n  routeContext: RouteContextObject;\n}>;\n\ntype RenderErrorBoundaryState = {\n  location: Location;\n  revalidation: RevalidationState;\n  error: any;\n};\n\nexport class RenderErrorBoundary extends React.Component<\n  RenderErrorBoundaryProps,\n  RenderErrorBoundaryState\n> {\n  constructor(props: RenderErrorBoundaryProps) {\n    super(props);\n    this.state = {\n      location: props.location,\n      revalidation: props.revalidation,\n      error: props.error,\n    };\n  }\n\n  static getDerivedStateFromError(error: any) {\n    return { error: error };\n  }\n\n  static getDerivedStateFromProps(\n    props: RenderErrorBoundaryProps,\n    state: RenderErrorBoundaryState\n  ) {\n    // When we get into an error state, the user will likely click \"back\" to the\n    // previous page that didn't have an error. Because this wraps the entire\n    // application, that will have no effect--the error page continues to display.\n    // This gives us a mechanism to recover from the error when the location changes.\n    //\n    // Whether we're in an error state or not, we update the location in state\n    // so that when we are in an error state, it gets reset when a new location\n    // comes in and the user recovers from the error.\n    if (\n      state.location !== props.location ||\n      (state.revalidation !== \"idle\" && props.revalidation === \"idle\")\n    ) {\n      return {\n        error: props.error,\n        location: props.location,\n        revalidation: props.revalidation,\n      };\n    }\n\n    // If we're not changing locations, preserve the location but still surface\n    // any new errors that may come through. We retain the existing error, we do\n    // this because the error provided from the app state may be cleared without\n    // the location changing.\n    return {\n      error: props.error || state.error,\n      location: state.location,\n      revalidation: props.revalidation || state.revalidation,\n    };\n  }\n\n  componentDidCatch(error: any, errorInfo: any) {\n    console.error(\n      \"React Router caught the following error during render\",\n      error,\n      errorInfo\n    );\n  }\n\n  render() {\n    return this.state.error ? (\n      <RouteContext.Provider value={this.props.routeContext}>\n        <RouteErrorContext.Provider\n          value={this.state.error}\n          children={this.props.component}\n        />\n      </RouteContext.Provider>\n    ) : (\n      this.props.children\n    );\n  }\n}\n\ninterface RenderedRouteProps {\n  routeContext: RouteContextObject;\n  match: RouteMatch<string, RouteObject>;\n  children: React.ReactNode | null;\n}\n\nfunction RenderedRoute({ routeContext, match, children }: RenderedRouteProps) {\n  let dataRouterContext = React.useContext(DataRouterContext);\n\n  // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n  if (\n    dataRouterContext &&\n    dataRouterContext.static &&\n    dataRouterContext.staticContext &&\n    (match.route.errorElement || match.route.ErrorBoundary)\n  ) {\n    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n  }\n\n  return (\n    <RouteContext.Provider value={routeContext}>\n      {children}\n    </RouteContext.Provider>\n  );\n}\n\nexport function _renderMatches(\n  matches: RouteMatch[] | null,\n  parentMatches: RouteMatch[] = [],\n  dataRouterState: RemixRouter[\"state\"] | null = null\n): React.ReactElement | null {\n  if (matches == null) {\n    if (dataRouterState?.errors) {\n      // Don't bail if we have data router errors so we can render them in the\n      // boundary.  Use the pre-matched (or shimmed) matches\n      matches = dataRouterState.matches as DataRouteMatch[];\n    } else {\n      return null;\n    }\n  }\n\n  let renderedMatches = matches;\n\n  // If we have data errors, trim matches to the highest error boundary\n  let errors = dataRouterState?.errors;\n  if (errors != null) {\n    let errorIndex = renderedMatches.findIndex(\n      (m) => m.route.id && errors?.[m.route.id]\n    );\n    invariant(\n      errorIndex >= 0,\n      `Could not find a matching route for errors on route IDs: ${Object.keys(\n        errors\n      ).join(\",\")}`\n    );\n    renderedMatches = renderedMatches.slice(\n      0,\n      Math.min(renderedMatches.length, errorIndex + 1)\n    );\n  }\n\n  return renderedMatches.reduceRight((outlet, match, index) => {\n    let error = match.route.id ? errors?.[match.route.id] : null;\n    // Only data routers handle errors\n    let errorElement: React.ReactNode | null = null;\n    if (dataRouterState) {\n      errorElement = match.route.errorElement || defaultErrorElement;\n    }\n    let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n    let getChildren = () => {\n      let children: React.ReactNode;\n      if (error) {\n        children = errorElement;\n      } else if (match.route.Component) {\n        // Note: This is a de-optimized path since React won't re-use the\n        // ReactElement since it's identity changes with each new\n        // React.createElement call.  We keep this so folks can use\n        // `<Route Component={...}>` in `<Routes>` but generally `Component`\n        // usage is only advised in `RouterProvider` when we can convert it to\n        // `element` ahead of time.\n        children = <match.route.Component />;\n      } else if (match.route.element) {\n        children = match.route.element;\n      } else {\n        children = outlet;\n      }\n      return (\n        <RenderedRoute\n          match={match}\n          routeContext={{\n            outlet,\n            matches,\n            isDataRoute: dataRouterState != null,\n          }}\n          children={children}\n        />\n      );\n    };\n    // Only wrap in an error boundary within data router usages when we have an\n    // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to\n    // an ancestor ErrorBoundary/errorElement\n    return dataRouterState &&\n      (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? (\n      <RenderErrorBoundary\n        location={dataRouterState.location}\n        revalidation={dataRouterState.revalidation}\n        component={errorElement}\n        error={error}\n        children={getChildren()}\n        routeContext={{ outlet: null, matches, isDataRoute: true }}\n      />\n    ) : (\n      getChildren()\n    );\n  }, null as React.ReactElement | null);\n}\n\nenum DataRouterHook {\n  UseBlocker = \"useBlocker\",\n  UseRevalidator = \"useRevalidator\",\n  UseNavigateStable = \"useNavigate\",\n}\n\nenum DataRouterStateHook {\n  UseBlocker = \"useBlocker\",\n  UseLoaderData = \"useLoaderData\",\n  UseActionData = \"useActionData\",\n  UseRouteError = \"useRouteError\",\n  UseNavigation = \"useNavigation\",\n  UseRouteLoaderData = \"useRouteLoaderData\",\n  UseMatches = \"useMatches\",\n  UseRevalidator = \"useRevalidator\",\n  UseNavigateStable = \"useNavigate\",\n  UseRouteId = \"useRouteId\",\n}\n\nfunction getDataRouterConsoleError(\n  hookName: DataRouterHook | DataRouterStateHook\n) {\n  return `${hookName} must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.`;\n}\n\nfunction useDataRouterContext(hookName: DataRouterHook) {\n  let ctx = React.useContext(DataRouterContext);\n  invariant(ctx, getDataRouterConsoleError(hookName));\n  return ctx;\n}\n\nfunction useDataRouterState(hookName: DataRouterStateHook) {\n  let state = React.useContext(DataRouterStateContext);\n  invariant(state, getDataRouterConsoleError(hookName));\n  return state;\n}\n\nfunction useRouteContext(hookName: DataRouterStateHook) {\n  let route = React.useContext(RouteContext);\n  invariant(route, getDataRouterConsoleError(hookName));\n  return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName: DataRouterStateHook) {\n  let route = useRouteContext(hookName);\n  let thisRoute = route.matches[route.matches.length - 1];\n  invariant(\n    thisRoute.route.id,\n    `${hookName} can only be used on routes that contain a unique \"id\"`\n  );\n  return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nexport function useRouteId() {\n  return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nexport function useNavigation() {\n  let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n  return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nexport function useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return {\n    revalidate: dataRouterContext.router.revalidate,\n    state: state.revalidation,\n  };\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nexport function useMatches() {\n  let { matches, loaderData } = useDataRouterState(\n    DataRouterStateHook.UseMatches\n  );\n  return React.useMemo(\n    () =>\n      matches.map((match) => {\n        let { pathname, params } = match;\n        // Note: This structure matches that created by createUseMatchesMatch\n        // in the @remix-run/router , so if you change this please also change\n        // that :)  Eventually we'll DRY this up\n        return {\n          id: match.route.id,\n          pathname,\n          params,\n          data: loaderData[match.route.id] as unknown,\n          handle: match.route.handle as unknown,\n        };\n      }),\n    [matches, loaderData]\n  );\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nexport function useLoaderData(): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n\n  if (state.errors && state.errors[routeId] != null) {\n    console.error(\n      `You cannot \\`useLoaderData\\` in an errorElement (routeId: ${routeId})`\n    );\n    return undefined;\n  }\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nexport function useRouteLoaderData(routeId: string): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nexport function useActionData(): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseActionData);\n\n  let route = React.useContext(RouteContext);\n  invariant(route, `useActionData must be used inside a RouteContext`);\n\n  return Object.values(state?.actionData || {})[0];\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error.  This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nexport function useRouteError(): unknown {\n  let error = React.useContext(RouteErrorContext);\n  let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n  // If this was a render error, we put it in a RouteError context inside\n  // of RenderErrorBoundary\n  if (error) {\n    return error;\n  }\n\n  // Otherwise look for errors from our data router state\n  return state.errors?.[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor <Await /> value\n */\nexport function useAsyncValue(): unknown {\n  let value = React.useContext(AwaitContext);\n  return value?._data;\n}\n\n/**\n * Returns the error from the nearest ancestor <Await /> value\n */\nexport function useAsyncError(): unknown {\n  let value = React.useContext(AwaitContext);\n  return value?._error;\n}\n\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation.  Mostly used to avoid\n * using half-filled form data.  This does not handle hard-reloads or\n * cross-origin navigations.\n */\nexport function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker {\n  let { router, basename } = useDataRouterContext(DataRouterHook.UseBlocker);\n  let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n\n  let [blockerKey, setBlockerKey] = React.useState(\"\");\n  let blockerFunction = React.useCallback<BlockerFunction>(\n    (arg) => {\n      if (typeof shouldBlock !== \"function\") {\n        return !!shouldBlock;\n      }\n      if (basename === \"/\") {\n        return shouldBlock(arg);\n      }\n\n      // If they provided us a function and we've got an active basename, strip\n      // it from the locations we expose to the user to match the behavior of\n      // useLocation\n      let { currentLocation, nextLocation, historyAction } = arg;\n      return shouldBlock({\n        currentLocation: {\n          ...currentLocation,\n          pathname:\n            stripBasename(currentLocation.pathname, basename) ||\n            currentLocation.pathname,\n        },\n        nextLocation: {\n          ...nextLocation,\n          pathname:\n            stripBasename(nextLocation.pathname, basename) ||\n            nextLocation.pathname,\n        },\n        historyAction,\n      });\n    },\n    [basename, shouldBlock]\n  );\n\n  // This effect is in charge of blocker key assignment and deletion (which is\n  // tightly coupled to the key)\n  React.useEffect(() => {\n    let key = String(++blockerId);\n    setBlockerKey(key);\n    return () => router.deleteBlocker(key);\n  }, [router]);\n\n  // This effect handles assigning the blockerFunction.  This is to handle\n  // unstable blocker function identities, and happens only after the prior\n  // effect so we don't get an orphaned blockerFunction in the router with a\n  // key of \"\".  Until then we just have the IDLE_BLOCKER.\n  React.useEffect(() => {\n    if (blockerKey !== \"\") {\n      router.getBlocker(blockerKey, blockerFunction);\n    }\n  }, [router, blockerKey, blockerFunction]);\n\n  // Prefer the blocker from `state` not `router.state` since DataRouterContext\n  // is memoized so this ensures we update on blocker state updates\n  return blockerKey && state.blockers.has(blockerKey)\n    ? state.blockers.get(blockerKey)!\n    : IDLE_BLOCKER;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable(): NavigateFunction {\n  let { router } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n  let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(activeRef.current, navigateEffectWarning);\n\n      // Short circuit here since if this happens on first render the navigate\n      // is useless because we haven't wired up our router subscriber yet\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        router.navigate(to);\n      } else {\n        router.navigate(to, { fromRouteId: id, ...options });\n      }\n    },\n    [router, id]\n  );\n\n  return navigate;\n}\n\nconst alreadyWarned: Record<string, boolean> = {};\n\nfunction warningOnce(key: string, cond: boolean, message: string) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    warning(false, message);\n  }\n}\n","import * as React from \"react\";\nimport type {\n  TrackedPromise,\n  InitialEntry,\n  Location,\n  MemoryHistory,\n  Router as RemixRouter,\n  To,\n  LazyRouteFunction,\n  RelativeRoutingType,\n  RouterState,\n} from \"@remix-run/router\";\nimport {\n  Action as NavigationType,\n  AbortedDeferredError,\n  createMemoryHistory,\n  UNSAFE_invariant as invariant,\n  parsePath,\n  resolveTo,\n  stripBasename,\n  UNSAFE_warning as warning,\n  UNSAFE_getPathContributingMatches as getPathContributingMatches,\n} from \"@remix-run/router\";\n\nimport type {\n  DataRouteObject,\n  IndexRouteObject,\n  RouteMatch,\n  RouteObject,\n  Navigator,\n  NonIndexRouteObject,\n} from \"./context\";\nimport {\n  LocationContext,\n  NavigationContext,\n  DataRouterContext,\n  DataRouterStateContext,\n  AwaitContext,\n  RouteContext,\n} from \"./context\";\nimport {\n  useAsyncValue,\n  useInRouterContext,\n  useNavigate,\n  useOutlet,\n  useRoutes,\n  _renderMatches,\n  useRoutesImpl,\n  useLocation,\n} from \"./hooks\";\n\nexport interface FutureConfig {\n  v7_startTransition: boolean;\n}\n\nexport interface RouterProviderProps {\n  fallbackElement?: React.ReactNode;\n  router: RemixRouter;\n  future?: FutureConfig;\n}\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nexport function RouterProvider({\n  fallbackElement,\n  router,\n  future,\n}: RouterProviderProps): React.ReactElement {\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  let [state, setStateImpl] = React.useState(router.state);\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: RouterState) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n\n  let navigator = React.useMemo((): Navigator => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: (n) => router.navigate(n),\n      push: (to, state, opts) =>\n        router.navigate(to, {\n          state,\n          preventScrollReset: opts?.preventScrollReset,\n        }),\n      replace: (to, state, opts) =>\n        router.navigate(to, {\n          replace: true,\n          state,\n          preventScrollReset: opts?.preventScrollReset,\n        }),\n    };\n  }, [router]);\n\n  let basename = router.basename || \"/\";\n\n  let dataRouterContext = React.useMemo(\n    () => ({\n      router,\n      navigator,\n      static: false,\n      basename,\n    }),\n    [router, navigator, basename]\n  );\n\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return (\n    <>\n      <DataRouterContext.Provider value={dataRouterContext}>\n        <DataRouterStateContext.Provider value={state}>\n          <Router\n            basename={basename}\n            location={state.location}\n            navigationType={state.historyAction}\n            navigator={navigator}\n          >\n            {state.initialized ? (\n              <DataRoutes routes={router.routes} state={state} />\n            ) : (\n              fallbackElement\n            )}\n          </Router>\n        </DataRouterStateContext.Provider>\n      </DataRouterContext.Provider>\n      {null}\n    </>\n  );\n}\n\nfunction DataRoutes({\n  routes,\n  state,\n}: {\n  routes: DataRouteObject[];\n  state: RouterState;\n}): React.ReactElement | null {\n  return useRoutesImpl(routes, undefined, state);\n}\n\nexport interface MemoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n  future?: FutureConfig;\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/router-components/memory-router\n */\nexport function MemoryRouter({\n  basename,\n  children,\n  initialEntries,\n  initialIndex,\n  future,\n}: MemoryRouterProps): React.ReactElement {\n  let historyRef = React.useRef<MemoryHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true,\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface NavigateProps {\n  to: To;\n  replace?: boolean;\n  state?: any;\n  relative?: RelativeRoutingType;\n}\n\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/components/navigate\n */\nexport function Navigate({\n  to,\n  replace,\n  state,\n  relative,\n}: NavigateProps): null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of\n    // the router loaded. We can help them understand how to avoid that.\n    `<Navigate> may be used only in the context of a <Router> component.`\n  );\n\n  warning(\n    !React.useContext(NavigationContext).static,\n    `<Navigate> must not be used on the initial render in a <StaticRouter>. ` +\n      `This is a no-op, but you should modify your code so the <Navigate> is ` +\n      `only ever rendered in response to some user interaction or state change.`\n  );\n\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n  let navigate = useNavigate();\n\n  // Resolve the path outside of the effect so that when effects run twice in\n  // StrictMode they navigate to the same place\n  let path = resolveTo(\n    to,\n    getPathContributingMatches(matches).map((match) => match.pathnameBase),\n    locationPathname,\n    relative === \"path\"\n  );\n  let jsonPath = JSON.stringify(path);\n\n  React.useEffect(\n    () => navigate(JSON.parse(jsonPath), { replace, state, relative }),\n    [navigate, jsonPath, relative, replace, state]\n  );\n\n  return null;\n}\n\nexport interface OutletProps {\n  context?: unknown;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/components/outlet\n */\nexport function Outlet(props: OutletProps): React.ReactElement | null {\n  return useOutlet(props.context);\n}\n\nexport interface PathRouteProps {\n  caseSensitive?: NonIndexRouteObject[\"caseSensitive\"];\n  path?: NonIndexRouteObject[\"path\"];\n  id?: NonIndexRouteObject[\"id\"];\n  lazy?: LazyRouteFunction<NonIndexRouteObject>;\n  loader?: NonIndexRouteObject[\"loader\"];\n  action?: NonIndexRouteObject[\"action\"];\n  hasErrorBoundary?: NonIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: NonIndexRouteObject[\"shouldRevalidate\"];\n  handle?: NonIndexRouteObject[\"handle\"];\n  index?: false;\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n}\n\nexport interface LayoutRouteProps extends PathRouteProps {}\n\nexport interface IndexRouteProps {\n  caseSensitive?: IndexRouteObject[\"caseSensitive\"];\n  path?: IndexRouteObject[\"path\"];\n  id?: IndexRouteObject[\"id\"];\n  lazy?: LazyRouteFunction<IndexRouteObject>;\n  loader?: IndexRouteObject[\"loader\"];\n  action?: IndexRouteObject[\"action\"];\n  hasErrorBoundary?: IndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: IndexRouteObject[\"shouldRevalidate\"];\n  handle?: IndexRouteObject[\"handle\"];\n  index: true;\n  children?: undefined;\n  element?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n}\n\nexport type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/components/route\n */\nexport function Route(_props: RouteProps): React.ReactElement | null {\n  invariant(\n    false,\n    `A <Route> is only ever to be used as the child of <Routes> element, ` +\n      `never rendered directly. Please wrap your <Route> in a <Routes>.`\n  );\n}\n\nexport interface RouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  location: Partial<Location> | string;\n  navigationType?: NavigationType;\n  navigator: Navigator;\n  static?: boolean;\n}\n\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a <Router> directly. Instead, you'll render a\n * router that is more specific to your environment such as a <BrowserRouter>\n * in web browsers or a <StaticRouter> for server rendering.\n *\n * @see https://reactrouter.com/router-components/router\n */\nexport function Router({\n  basename: basenameProp = \"/\",\n  children = null,\n  location: locationProp,\n  navigationType = NavigationType.Pop,\n  navigator,\n  static: staticProp = false,\n}: RouterProps): React.ReactElement | null {\n  invariant(\n    !useInRouterContext(),\n    `You cannot render a <Router> inside another <Router>.` +\n      ` You should never have more than one in your app.`\n  );\n\n  // Preserve trailing slashes on basename, so we can let the user control\n  // the enforcement of trailing slashes throughout the app\n  let basename = basenameProp.replace(/^\\/*/, \"/\");\n  let navigationContext = React.useMemo(\n    () => ({ basename, navigator, static: staticProp }),\n    [basename, navigator, staticProp]\n  );\n\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\",\n  } = locationProp;\n\n  let locationContext = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      location: {\n        pathname: trailingPathname,\n        search,\n        hash,\n        state,\n        key,\n      },\n      navigationType,\n    };\n  }, [basename, pathname, search, hash, state, key, navigationType]);\n\n  warning(\n    locationContext != null,\n    `<Router basename=\"${basename}\"> is not able to match the URL ` +\n      `\"${pathname}${search}${hash}\" because it does not start with the ` +\n      `basename, so the <Router> won't render anything.`\n  );\n\n  if (locationContext == null) {\n    return null;\n  }\n\n  return (\n    <NavigationContext.Provider value={navigationContext}>\n      <LocationContext.Provider children={children} value={locationContext} />\n    </NavigationContext.Provider>\n  );\n}\n\nexport interface RoutesProps {\n  children?: React.ReactNode;\n  location?: Partial<Location> | string;\n}\n\n/**\n * A container for a nested tree of <Route> elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/components/routes\n */\nexport function Routes({\n  children,\n  location,\n}: RoutesProps): React.ReactElement | null {\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n\nexport interface AwaitResolveRenderFunction {\n  (data: Awaited<any>): React.ReactNode;\n}\n\nexport interface AwaitProps {\n  children: React.ReactNode | AwaitResolveRenderFunction;\n  errorElement?: React.ReactNode;\n  resolve: TrackedPromise | any;\n}\n\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nexport function Await({ children, errorElement, resolve }: AwaitProps) {\n  return (\n    <AwaitErrorBoundary resolve={resolve} errorElement={errorElement}>\n      <ResolveAwait>{children}</ResolveAwait>\n    </AwaitErrorBoundary>\n  );\n}\n\ntype AwaitErrorBoundaryProps = React.PropsWithChildren<{\n  errorElement?: React.ReactNode;\n  resolve: TrackedPromise | any;\n}>;\n\ntype AwaitErrorBoundaryState = {\n  error: any;\n};\n\nenum AwaitRenderStatus {\n  pending,\n  success,\n  error,\n}\n\nconst neverSettledPromise = new Promise(() => {});\n\nclass AwaitErrorBoundary extends React.Component<\n  AwaitErrorBoundaryProps,\n  AwaitErrorBoundaryState\n> {\n  constructor(props: AwaitErrorBoundaryProps) {\n    super(props);\n    this.state = { error: null };\n  }\n\n  static getDerivedStateFromError(error: any) {\n    return { error };\n  }\n\n  componentDidCatch(error: any, errorInfo: any) {\n    console.error(\n      \"<Await> caught the following error during render\",\n      error,\n      errorInfo\n    );\n  }\n\n  render() {\n    let { children, errorElement, resolve } = this.props;\n\n    let promise: TrackedPromise | null = null;\n    let status: AwaitRenderStatus = AwaitRenderStatus.pending;\n\n    if (!(resolve instanceof Promise)) {\n      // Didn't get a promise - provide as a resolved promise\n      status = AwaitRenderStatus.success;\n      promise = Promise.resolve();\n      Object.defineProperty(promise, \"_tracked\", { get: () => true });\n      Object.defineProperty(promise, \"_data\", { get: () => resolve });\n    } else if (this.state.error) {\n      // Caught a render error, provide it as a rejected promise\n      status = AwaitRenderStatus.error;\n      let renderError = this.state.error;\n      promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings\n      Object.defineProperty(promise, \"_tracked\", { get: () => true });\n      Object.defineProperty(promise, \"_error\", { get: () => renderError });\n    } else if ((resolve as TrackedPromise)._tracked) {\n      // Already tracked promise - check contents\n      promise = resolve;\n      status =\n        promise._error !== undefined\n          ? AwaitRenderStatus.error\n          : promise._data !== undefined\n          ? AwaitRenderStatus.success\n          : AwaitRenderStatus.pending;\n    } else {\n      // Raw (untracked) promise - track it\n      status = AwaitRenderStatus.pending;\n      Object.defineProperty(resolve, \"_tracked\", { get: () => true });\n      promise = resolve.then(\n        (data: any) =>\n          Object.defineProperty(resolve, \"_data\", { get: () => data }),\n        (error: any) =>\n          Object.defineProperty(resolve, \"_error\", { get: () => error })\n      );\n    }\n\n    if (\n      status === AwaitRenderStatus.error &&\n      promise._error instanceof AbortedDeferredError\n    ) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\n\n    if (status === AwaitRenderStatus.error) {\n      // Render via our errorElement\n      return <AwaitContext.Provider value={promise} children={errorElement} />;\n    }\n\n    if (status === AwaitRenderStatus.success) {\n      // Render children with resolved value\n      return <AwaitContext.Provider value={promise} children={children} />;\n    }\n\n    // Throw to the suspense boundary\n    throw promise;\n  }\n}\n\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on <Await>\n */\nfunction ResolveAwait({\n  children,\n}: {\n  children: React.ReactNode | AwaitResolveRenderFunction;\n}) {\n  let data = useAsyncValue();\n  let toRender = typeof children === \"function\" ? children(data) : children;\n  return <>{toRender}</>;\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/utils/create-routes-from-children\n */\nexport function createRoutesFromChildren(\n  children: React.ReactNode,\n  parentPath: number[] = []\n): RouteObject[] {\n  let routes: RouteObject[] = [];\n\n  React.Children.forEach(children, (element, index) => {\n    if (!React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n\n    let treePath = [...parentPath, index];\n\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(\n        routes,\n        createRoutesFromChildren(element.props.children, treePath)\n      );\n      return;\n    }\n\n    invariant(\n      element.type === Route,\n      `[${\n        typeof element.type === \"string\" ? element.type : element.type.name\n      }] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`\n    );\n\n    invariant(\n      !element.props.index || !element.props.children,\n      \"An index route cannot have child routes.\"\n    );\n\n    let route: RouteObject = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      Component: element.props.Component,\n      index: element.props.index,\n      path: element.props.path,\n      loader: element.props.loader,\n      action: element.props.action,\n      errorElement: element.props.errorElement,\n      ErrorBoundary: element.props.ErrorBoundary,\n      hasErrorBoundary:\n        element.props.ErrorBoundary != null ||\n        element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle,\n      lazy: element.props.lazy,\n    };\n\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(\n        element.props.children,\n        treePath\n      );\n    }\n\n    routes.push(route);\n  });\n\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nexport function renderMatches(\n  matches: RouteMatch[] | null\n): React.ReactElement | null {\n  return _renderMatches(matches);\n}\n","import * as React from \"react\";\nimport type {\n  ActionFunction,\n  ActionFunctionArgs,\n  Blocker,\n  BlockerFunction,\n  Fetcher,\n  HydrationState,\n  JsonFunction,\n  LoaderFunction,\n  LoaderFunctionArgs,\n  Location,\n  Navigation,\n  Params,\n  ParamParseKey,\n  Path,\n  PathMatch,\n  PathPattern,\n  RedirectFunction,\n  RelativeRoutingType,\n  Router as RemixRouter,\n  ShouldRevalidateFunction,\n  To,\n  InitialEntry,\n  LazyRouteFunction,\n  FutureConfig as RouterFutureConfig,\n} from \"@remix-run/router\";\nimport {\n  AbortedDeferredError,\n  Action as NavigationType,\n  createMemoryHistory,\n  createPath,\n  createRouter,\n  defer,\n  generatePath,\n  isRouteErrorResponse,\n  json,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  redirect,\n  resolvePath,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n  AwaitProps,\n  MemoryRouterProps,\n  NavigateProps,\n  OutletProps,\n  RouteProps,\n  PathRouteProps,\n  LayoutRouteProps,\n  IndexRouteProps,\n  RouterProps,\n  RoutesProps,\n  RouterProviderProps,\n  FutureConfig,\n} from \"./lib/components\";\nimport {\n  createRoutesFromChildren,\n  renderMatches,\n  Await,\n  MemoryRouter,\n  Navigate,\n  Outlet,\n  Route,\n  Router,\n  RouterProvider,\n  Routes,\n} from \"./lib/components\";\nimport type {\n  DataRouteMatch,\n  DataRouteObject,\n  IndexRouteObject,\n  Navigator,\n  NavigateOptions,\n  NonIndexRouteObject,\n  RouteMatch,\n  RouteObject,\n} from \"./lib/context\";\nimport {\n  DataRouterContext,\n  DataRouterStateContext,\n  LocationContext,\n  NavigationContext,\n  RouteContext,\n} from \"./lib/context\";\nimport type { NavigateFunction } from \"./lib/hooks\";\nimport {\n  useBlocker,\n  useHref,\n  useInRouterContext,\n  useLocation,\n  useMatch,\n  useNavigationType,\n  useNavigate,\n  useOutlet,\n  useOutletContext,\n  useParams,\n  useResolvedPath,\n  useRoutes,\n  useActionData,\n  useAsyncError,\n  useAsyncValue,\n  useRouteId,\n  useLoaderData,\n  useMatches,\n  useNavigation,\n  useRevalidator,\n  useRouteError,\n  useRouteLoaderData,\n  useRoutesImpl,\n} from \"./lib/hooks\";\n\n// Exported for backwards compatibility, but not being used internally anymore\ntype Hash = string;\ntype Pathname = string;\ntype Search = string;\n\n// Expose react-router public API\nexport type {\n  ActionFunction,\n  ActionFunctionArgs,\n  AwaitProps,\n  Blocker as unstable_Blocker,\n  BlockerFunction as unstable_BlockerFunction,\n  DataRouteMatch,\n  DataRouteObject,\n  Fetcher,\n  FutureConfig,\n  Hash,\n  IndexRouteObject,\n  IndexRouteProps,\n  JsonFunction,\n  LazyRouteFunction,\n  LayoutRouteProps,\n  LoaderFunction,\n  LoaderFunctionArgs,\n  Location,\n  MemoryRouterProps,\n  NavigateFunction,\n  NavigateOptions,\n  NavigateProps,\n  Navigation,\n  Navigator,\n  NonIndexRouteObject,\n  OutletProps,\n  Params,\n  ParamParseKey,\n  Path,\n  PathMatch,\n  Pathname,\n  PathPattern,\n  PathRouteProps,\n  RedirectFunction,\n  RelativeRoutingType,\n  RouteMatch,\n  RouteObject,\n  RouteProps,\n  RouterProps,\n  RouterProviderProps,\n  RoutesProps,\n  Search,\n  ShouldRevalidateFunction,\n  To,\n};\nexport {\n  AbortedDeferredError,\n  Await,\n  MemoryRouter,\n  Navigate,\n  NavigationType,\n  Outlet,\n  Route,\n  Router,\n  RouterProvider,\n  Routes,\n  createPath,\n  createRoutesFromChildren,\n  createRoutesFromChildren as createRoutesFromElements,\n  defer,\n  isRouteErrorResponse,\n  generatePath,\n  json,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  redirect,\n  renderMatches,\n  resolvePath,\n  useActionData,\n  useAsyncError,\n  useAsyncValue,\n  useBlocker as unstable_useBlocker,\n  useHref,\n  useInRouterContext,\n  useLoaderData,\n  useLocation,\n  useMatch,\n  useMatches,\n  useNavigate,\n  useNavigation,\n  useNavigationType,\n  useOutlet,\n  useOutletContext,\n  useParams,\n  useResolvedPath,\n  useRevalidator,\n  useRouteError,\n  useRouteLoaderData,\n  useRoutes,\n};\n\nfunction mapRouteProperties(route: RouteObject) {\n  let updates: Partial<RouteObject> & { hasErrorBoundary: boolean } = {\n    // Note: this check also occurs in createRoutesFromChildren so update\n    // there if you change this -- please and thank you!\n    hasErrorBoundary: route.ErrorBoundary != null || route.errorElement != null,\n  };\n\n  if (route.Component) {\n    if (__DEV__) {\n      if (route.element) {\n        warning(\n          false,\n          \"You should not include both `Component` and `element` on your route - \" +\n            \"`Component` will be used.\"\n        );\n      }\n    }\n    Object.assign(updates, {\n      element: React.createElement(route.Component),\n      Component: undefined,\n    });\n  }\n\n  if (route.ErrorBoundary) {\n    if (__DEV__) {\n      if (route.errorElement) {\n        warning(\n          false,\n          \"You should not include both `ErrorBoundary` and `errorElement` on your route - \" +\n            \"`ErrorBoundary` will be used.\"\n        );\n      }\n    }\n    Object.assign(updates, {\n      errorElement: React.createElement(route.ErrorBoundary),\n      ErrorBoundary: undefined,\n    });\n  }\n\n  return updates;\n}\n\nexport function createMemoryRouter(\n  routes: RouteObject[],\n  opts?: {\n    basename?: string;\n    future?: Partial<Omit<RouterFutureConfig, \"v7_prependBasename\">>;\n    hydrationData?: HydrationState;\n    initialEntries?: InitialEntry[];\n    initialIndex?: number;\n  }\n): RemixRouter {\n  return createRouter({\n    basename: opts?.basename,\n    future: {\n      ...opts?.future,\n      v7_prependBasename: true,\n    },\n    history: createMemoryHistory({\n      initialEntries: opts?.initialEntries,\n      initialIndex: opts?.initialIndex,\n    }),\n    hydrationData: opts?.hydrationData,\n    routes,\n    mapRouteProperties,\n  }).initialize();\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// DANGER! PLEASE READ ME!\n// We provide these exports as an escape hatch in the event that you need any\n// routing data that we don't provide an explicit API for. With that said, we\n// want to cover your use case if we can, so if you feel the need to use these\n// we want to hear from you. Let us know what you're building and we'll do our\n// best to make sure we can support you!\n//\n// We consider these exports an implementation detail and do not guarantee\n// against any breaking changes, regardless of the semver release. Use with\n// extreme caution and only if you understand the consequences. Godspeed.\n///////////////////////////////////////////////////////////////////////////////\n\n/** @internal */\nexport {\n  NavigationContext as UNSAFE_NavigationContext,\n  LocationContext as UNSAFE_LocationContext,\n  RouteContext as UNSAFE_RouteContext,\n  DataRouterContext as UNSAFE_DataRouterContext,\n  DataRouterStateContext as UNSAFE_DataRouterStateContext,\n  mapRouteProperties as UNSAFE_mapRouteProperties,\n  useRouteId as UNSAFE_useRouteId,\n  useRoutesImpl as UNSAFE_useRoutesImpl,\n};\n"],"sourceRoot":""}