@epic-web/workshop-app 5.0.3 → 5.1.1

package/node_modules/@remix-run/react/dist/esm/single-fetch.js

@@ -1,309 +0,0 @@
-/**
- * @remix-run/react v2.10.0
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-import * as React from 'react';
-import { UNSAFE_ErrorResponseImpl, redirect } from '@remix-run/router';
-import { UNSAFE_SingleFetchRedirectSymbol } from '@remix-run/server-runtime';
-import { decode } from 'turbo-stream';
-import { createRequestInit } from './data.js';
-import { escapeHtml } from './markup.js';
-import invariant from './invariant.js';
-
-// clientLoader
-
-let defineClientLoader = clientLoader => clientLoader;
-
-// clientAction
-
-let defineClientAction = clientAction => clientAction;
-// StreamTransfer recursively renders down chunks of the `serverHandoffStream`
-// into the client-side `streamController`
-function StreamTransfer({
-  context,
-  identifier,
-  reader,
-  textDecoder,
-  nonce
-}) {
-  // If the user didn't render the <Scripts> component then we don't have to
-  // bother streaming anything in
-  if (!context.renderMeta || !context.renderMeta.didRenderScripts) {
-    return null;
-  }
-  if (!context.renderMeta.streamCache) {
-    context.renderMeta.streamCache = {};
-  }
-  let {
-    streamCache
-  } = context.renderMeta;
-  let promise = streamCache[identifier];
-  if (!promise) {
-    promise = streamCache[identifier] = reader.read().then(result => {
-      streamCache[identifier].result = {
-        done: result.done,
-        value: textDecoder.decode(result.value, {
-          stream: true
-        })
-      };
-    }).catch(e => {
-      streamCache[identifier].error = e;
-    });
-  }
-  if (promise.error) {
-    throw promise.error;
-  }
-  if (promise.result === undefined) {
-    throw promise;
-  }
-  let {
-    done,
-    value
-  } = promise.result;
-  let scriptTag = value ? /*#__PURE__*/React.createElement("script", {
-    nonce: nonce,
-    dangerouslySetInnerHTML: {
-      __html: `window.__remixContext.streamController.enqueue(${escapeHtml(JSON.stringify(value))});`
-    }
-  }) : null;
-  if (done) {
-    return /*#__PURE__*/React.createElement(React.Fragment, null, scriptTag, /*#__PURE__*/React.createElement("script", {
-      nonce: nonce,
-      dangerouslySetInnerHTML: {
-        __html: `window.__remixContext.streamController.close();`
-      }
-    }));
-  } else {
-    return /*#__PURE__*/React.createElement(React.Fragment, null, scriptTag, /*#__PURE__*/React.createElement(React.Suspense, null, /*#__PURE__*/React.createElement(StreamTransfer, {
-      context: context,
-      identifier: identifier + 1,
-      reader: reader,
-      textDecoder: textDecoder,
-      nonce: nonce
-    })));
-  }
-}
-function getSingleFetchDataStrategy(manifest, routeModules) {
-  return async ({
-    request,
-    matches
-  }) => request.method !== "GET" ? singleFetchActionStrategy(request, matches) : singleFetchLoaderStrategy(manifest, routeModules, request, matches);
-}
-
-// Actions are simple since they're singular calls to the server
-function singleFetchActionStrategy(request, matches) {
-  return Promise.all(matches.map(async m => {
-    let actionStatus;
-    let result = await m.resolve(async handler => {
-      let result = await handler(async () => {
-        let url = singleFetchUrl(request.url);
-        let init = await createRequestInit(request);
-        let {
-          data,
-          status
-        } = await fetchAndDecode(url, init);
-        actionStatus = status;
-        return unwrapSingleFetchResult(data, m.route.id);
-      });
-      return {
-        type: "data",
-        result,
-        status: actionStatus
-      };
-    });
-    return {
-      ...result,
-      // Proxy along the action HTTP response status for thrown errors
-      status: actionStatus
-    };
-  }));
-}
-
-// Loaders are trickier since we only want to hit the server once, so we
-// create a singular promise for all server-loader routes to latch onto.
-function singleFetchLoaderStrategy(manifest, routeModules, request, matches) {
-  let singleFetchPromise;
-  return Promise.all(matches.map(async m => m.resolve(async handler => {
-    let result;
-    let url = stripIndexParam(singleFetchUrl(request.url));
-
-    // When a route has a client loader, it calls it's singular server loader
-    if (manifest.routes[m.route.id].hasClientLoader) {
-      result = await handler(async () => {
-        url.searchParams.set("_routes", m.route.id);
-        let {
-          data
-        } = await fetchAndDecode(url);
-        return unwrapSingleFetchResults(data, m.route.id);
-      });
-    } else {
-      result = await handler(async () => {
-        // Otherwise we let multiple routes hook onto the same promise
-        if (!singleFetchPromise) {
-          url = addRevalidationParam(manifest, routeModules, matches.map(m => m.route), matches.filter(m => m.shouldLoad).map(m => m.route), url);
-          singleFetchPromise = fetchAndDecode(url).then(({
-            data
-          }) => data);
-        }
-        let results = await singleFetchPromise;
-        return unwrapSingleFetchResults(results, m.route.id);
-      });
-    }
-    return {
-      type: "data",
-      result
-    };
-  })));
-}
-function stripIndexParam(url) {
-  let indexValues = url.searchParams.getAll("index");
-  url.searchParams.delete("index");
-  let indexValuesToKeep = [];
-  for (let indexValue of indexValues) {
-    if (indexValue) {
-      indexValuesToKeep.push(indexValue);
-    }
-  }
-  for (let toKeep of indexValuesToKeep) {
-    url.searchParams.append("index", toKeep);
-  }
-  return url;
-}
-
-// Determine which routes we want to load so we can add a `?_routes` search param
-// for fine-grained revalidation if necessary. There's some nuance to this decision:
-//
-//  - The presence of `shouldRevalidate` and `clientLoader` functions are the only
-//    way to trigger fine-grained single fetch loader calls.  without either of
-//    these on the route matches we just always ask for the full `.data` request.
-//  - If any routes have a `shouldRevalidate` or `clientLoader` then we do a
-//    comparison of the routes we matched and the routes we're aiming to load
-//  - If they don't match up, then we add the `_routes` param or fine-grained
-//    loading
-//  - This is used by the single fetch implementation above and by the
-//    `<PrefetchPageLinksImpl>` component so we can prefetch routes using the
-//    same logic
-function addRevalidationParam(manifest, routeModules, matchedRoutes, loadRoutes, url) {
-  let genRouteIds = arr => arr.filter(id => manifest.routes[id].hasLoader).join(",");
-
-  // Look at the `routeModules` for `shouldRevalidate` here instead of the manifest
-  // since HDR adds a wrapper for `shouldRevalidate` even if the route didn't have one
-  // initially.
-  // TODO: We probably can get rid of that wrapper once we're strictly on on
-  // single-fetch in v3 and just leverage a needsRevalidation data structure here
-  // to determine what to fetch
-  let needsParam = matchedRoutes.some(r => {
-    var _routeModules$r$id, _manifest$routes$r$id;
-    return ((_routeModules$r$id = routeModules[r.id]) === null || _routeModules$r$id === void 0 ? void 0 : _routeModules$r$id.shouldRevalidate) || ((_manifest$routes$r$id = manifest.routes[r.id]) === null || _manifest$routes$r$id === void 0 ? void 0 : _manifest$routes$r$id.hasClientLoader);
-  });
-  if (!needsParam) {
-    return url;
-  }
-  let matchedIds = genRouteIds(matchedRoutes.map(r => r.id));
-  let loadIds = genRouteIds(loadRoutes.filter(r => {
-    var _manifest$routes$r$id2;
-    return !((_manifest$routes$r$id2 = manifest.routes[r.id]) !== null && _manifest$routes$r$id2 !== void 0 && _manifest$routes$r$id2.hasClientLoader);
-  }).map(r => r.id));
-  if (matchedIds !== loadIds) {
-    url.searchParams.set("_routes", loadIds);
-  }
-  return url;
-}
-function singleFetchUrl(reqUrl) {
-  let url = typeof reqUrl === "string" ? new URL(reqUrl, window.location.origin) : reqUrl;
-  url.pathname = `${url.pathname === "/" ? "_root" : url.pathname}.data`;
-  return url;
-}
-async function fetchAndDecode(url, init) {
-  let res = await fetch(url, init);
-  // Don't do a hard check against the header here.  We'll get `text/x-turbo`
-  // when we have a running server, but if folks want to prerender `.data` files
-  // and serve them from a CDN we should let them come back with whatever
-  // Content-Type their CDN provides and not force them to make sure `.data`
-  // files are served as `text/x-turbo`.  We'll throw if we can't decode anyway.
-  invariant(res.body, "No response body to decode");
-  try {
-    let decoded = await decodeViaTurboStream(res.body, window);
-    return {
-      status: res.status,
-      data: decoded.value
-    };
-  } catch (e) {
-    console.error(e);
-    throw new Error(`Unable to decode turbo-stream response from URL: ${url.toString()}`);
-  }
-}
-
-// Note: If you change this function please change the corresponding
-// encodeViaTurboStream function in server-runtime
-function decodeViaTurboStream(body, global) {
-  return decode(body, {
-    plugins: [(type, ...rest) => {
-      // Decode Errors back into Error instances using the right type and with
-      // the right (potentially undefined) stacktrace
-      if (type === "SanitizedError") {
-        let [name, message, stack] = rest;
-        let Constructor = Error;
-        // @ts-expect-error
-        if (name && name in global && typeof global[name] === "function") {
-          // @ts-expect-error
-          Constructor = global[name];
-        }
-        let error = new Constructor(message);
-        error.stack = stack;
-        return {
-          value: error
-        };
-      }
-      if (type === "ErrorResponse") {
-        let [data, status, statusText] = rest;
-        return {
-          value: new UNSAFE_ErrorResponseImpl(status, statusText, data)
-        };
-      }
-      if (type === "SingleFetchRedirect") {
-        return {
-          value: {
-            [UNSAFE_SingleFetchRedirectSymbol]: rest[0]
-          }
-        };
-      }
-    }]
-  });
-}
-function unwrapSingleFetchResults(results, routeId) {
-  let redirect = results[UNSAFE_SingleFetchRedirectSymbol];
-  if (redirect) {
-    return unwrapSingleFetchResult(redirect, routeId);
-  }
-  return results[routeId] !== undefined ? unwrapSingleFetchResult(results[routeId], routeId) : null;
-}
-function unwrapSingleFetchResult(result, routeId) {
-  if ("error" in result) {
-    throw result.error;
-  } else if ("redirect" in result) {
-    let headers = {};
-    if (result.revalidate) {
-      headers["X-Remix-Revalidate"] = "yes";
-    }
-    if (result.reload) {
-      headers["X-Remix-Reload-Document"] = "yes";
-    }
-    return redirect(result.redirect, {
-      status: result.status,
-      headers
-    });
-  } else if ("data" in result) {
-    return result.data;
-  } else {
-    throw new Error(`No response found for routeId "${routeId}"`);
-  }
-}
-
-export { StreamTransfer, addRevalidationParam, decodeViaTurboStream, defineClientAction, defineClientLoader, getSingleFetchDataStrategy, singleFetchUrl };

package/node_modules/@remix-run/react/dist/fallback.d.ts

@@ -1,2 +0,0 @@
-import * as React from "react";
-export declare function RemixRootDefaultHydrateFallback(): React.JSX.Element;

package/node_modules/@remix-run/react/dist/fallback.js

@@ -1,59 +0,0 @@
-/**
- * @remix-run/react v2.10.0
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var React = require('react');
-var errorBoundaries = require('./errorBoundaries.js');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var React__namespace = /*#__PURE__*/_interopNamespace(React);
-
-// If the user sets `clientLoader.hydrate=true` somewhere but does not
-// provide a `HydrateFallback` at any level of the tree, then we need to at
-// least include `<Scripts>` in the SSR so we can hydrate the app and call the
-// `clientLoader` functions
-function RemixRootDefaultHydrateFallback() {
-  return /*#__PURE__*/React__namespace.createElement(errorBoundaries.BoundaryShell, {
-    title: "Loading...",
-    renderScripts: true
-  }, /*#__PURE__*/React__namespace.createElement("script", {
-    dangerouslySetInnerHTML: {
-      __html: `
-              console.log(
-                "💿 Hey developer 👋. You can provide a way better UX than this " +
-                "when your app is running \`clientLoader\` functions on hydration. " +
-                "Check out https://remix.run/route/hydrate-fallback for more information."
-              );
-            `
-    }
-  }));
-}
-
-exports.RemixRootDefaultHydrateFallback = RemixRootDefaultHydrateFallback;

package/node_modules/@remix-run/react/dist/fog-of-war.d.ts

@@ -1,37 +0,0 @@
-import type { Router } from "@remix-run/router";
-import type { unstable_PatchRoutesOnMissFunction } from "react-router";
-import type { AssetsManifest, FutureConfig } from "./entry";
-import type { RouteModules } from "./routeModules";
-declare global {
-    interface Navigator {
-        connection?: {
-            saveData: boolean;
-        };
-    }
-}
-type FogOfWarInfo = {
-    nextPaths: Set<string>;
-    knownGoodPaths: Set<string>;
-    known404Paths: Set<string>;
-};
-export declare function isFogOfWarEnabled(future: FutureConfig, isSpaMode: boolean): boolean;
-export declare function getPartialManifest(manifest: AssetsManifest, router: Router): {
-    routes: {};
-    entry: {
-        imports: string[];
-        module: string;
-    };
-    url: string;
-    version: string;
-    hmr?: {
-        timestamp?: number | undefined;
-        runtime: string;
-    } | undefined;
-};
-export declare function initFogOfWar(manifest: AssetsManifest, routeModules: RouteModules, future: FutureConfig, isSpaMode: boolean, basename: string | undefined): {
-    enabled: boolean;
-    patchRoutesOnMiss?: unstable_PatchRoutesOnMissFunction;
-};
-export declare function useFogOFWarDiscovery(router: Router, manifest: AssetsManifest, routeModules: RouteModules, future: FutureConfig, isSpaMode: boolean): void;
-export declare function fetchAndApplyManifestPatches(paths: string[], _fogOfWar: FogOfWarInfo, manifest: AssetsManifest, routeModules: RouteModules, future: FutureConfig, isSpaMode: boolean, basename: string | undefined, patchRoutes: Router["patchRoutes"]): Promise<void>;
-export {};

package/node_modules/@remix-run/react/dist/fog-of-war.js

@@ -1,254 +0,0 @@
-/**
- * @remix-run/react v2.10.0
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var router = require('@remix-run/router');
-var React = require('react');
-var routes = require('./routes.js');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var React__namespace = /*#__PURE__*/_interopNamespace(React);
-
-// 7.5k to come in under the ~8k limit for most browsers
-// https://stackoverflow.com/a/417184
-const URL_LIMIT = 7680;
-let fogOfWar = null;
-function isFogOfWarEnabled(future, isSpaMode) {
-  return future.unstable_fogOfWar === true && !isSpaMode;
-}
-function getPartialManifest(manifest, router$1) {
-  // Start with our matches for this pathname
-  let routeIds = new Set(router$1.state.matches.map(m => m.route.id));
-  let segments = router$1.state.location.pathname.split("/").filter(Boolean);
-  let paths = ["/"];
-
-  // We've already matched to the last segment
-  segments.pop();
-
-  // Traverse each path for our parents and match in case they have pathless/index
-  // children we need to include in the initial manifest
-  while (segments.length > 0) {
-    paths.push(`/${segments.join("/")}`);
-    segments.pop();
-  }
-  paths.forEach(path => {
-    let matches = router.matchRoutes(router$1.routes, path, router$1.basename);
-    if (matches) {
-      matches.forEach(m => routeIds.add(m.route.id));
-    }
-  });
-  let initialRoutes = [...routeIds].reduce((acc, id) => Object.assign(acc, {
-    [id]: manifest.routes[id]
-  }), {});
-  return {
-    ...manifest,
-    routes: initialRoutes
-  };
-}
-function initFogOfWar(manifest, routeModules, future, isSpaMode, basename) {
-  if (!isFogOfWarEnabled(future, isSpaMode)) {
-    return {
-      enabled: false
-    };
-  }
-  fogOfWar = {
-    nextPaths: new Set(),
-    knownGoodPaths: new Set(),
-    known404Paths: new Set()
-  };
-  return {
-    enabled: true,
-    patchRoutesOnMiss: async ({
-      path,
-      patch
-    }) => {
-      if (fogOfWar.known404Paths.has(path) || fogOfWar.knownGoodPaths.has(path)) {
-        return;
-      }
-      await fetchAndApplyManifestPatches([path], fogOfWar, manifest, routeModules, future, isSpaMode, basename, patch);
-    }
-  };
-}
-function useFogOFWarDiscovery(router, manifest, routeModules, future, isSpaMode) {
-  React__namespace.useEffect(() => {
-    var _navigator$connection;
-    // Don't prefetch if not enabled or if the user has `saveData` enabled
-    if (!isFogOfWarEnabled(future, isSpaMode) || ((_navigator$connection = navigator.connection) === null || _navigator$connection === void 0 ? void 0 : _navigator$connection.saveData) === true) {
-      return;
-    }
-
-    // Register a link href for patching
-    function registerPath(path) {
-      if (!path) {
-        return;
-      }
-      let url = new URL(path, window.location.origin);
-      let {
-        knownGoodPaths,
-        known404Paths,
-        nextPaths
-      } = fogOfWar;
-      if (knownGoodPaths.has(url.pathname) || known404Paths.has(url.pathname)) {
-        return;
-      }
-      nextPaths.add(url.pathname);
-    }
-
-    // Fetch patches for all currently rendered links
-    async function fetchPatches() {
-      let lazyPaths = getFogOfWarPaths(fogOfWar);
-      if (lazyPaths.length === 0) {
-        return;
-      }
-      try {
-        await fetchAndApplyManifestPatches(lazyPaths, fogOfWar, manifest, routeModules, future, isSpaMode, router.basename, router.patchRoutes);
-      } catch (e) {
-        console.error("Failed to fetch manifest patches", e);
-      }
-    }
-
-    // Register and fetch patches for all initially-rendered links
-    document.body.querySelectorAll("a[data-discover]").forEach(a => registerPath(a.getAttribute("href")));
-    fetchPatches();
-
-    // Setup a MutationObserver to fetch all subsequently rendered links
-    let debouncedFetchPatches = debounce(fetchPatches, 100);
-    function isElement(node) {
-      return node.nodeType === Node.ELEMENT_NODE;
-    }
-    let observer = new MutationObserver(records => {
-      let links = new Set();
-      records.forEach(r => {
-        [r.target, ...r.addedNodes].forEach(node => {
-          if (!isElement(node)) return;
-          if (node.tagName === "A" && node.getAttribute("data-discover")) {
-            links.add(node);
-          } else if (node.tagName !== "A") {
-            node.querySelectorAll("a[data-discover]").forEach(el => links.add(el));
-          }
-        });
-      });
-      links.forEach(link => registerPath(link.getAttribute("href")));
-      debouncedFetchPatches();
-    });
-    observer.observe(document.documentElement, {
-      subtree: true,
-      childList: true,
-      attributes: true,
-      attributeFilter: ["data-discover", "href"]
-    });
-    return () => observer.disconnect();
-  }, [future, isSpaMode, manifest, routeModules, router]);
-}
-function getFogOfWarPaths(fogOfWar, router) {
-  let {
-    knownGoodPaths,
-    known404Paths,
-    nextPaths
-  } = fogOfWar;
-  return Array.from(nextPaths.keys()).filter(path => {
-    if (knownGoodPaths.has(path)) {
-      nextPaths.delete(path);
-      return false;
-    }
-    if (known404Paths.has(path)) {
-      nextPaths.delete(path);
-      return false;
-    }
-    return true;
-  });
-}
-async function fetchAndApplyManifestPatches(paths, _fogOfWar, manifest, routeModules, future, isSpaMode, basename, patchRoutes) {
-  let {
-    nextPaths,
-    knownGoodPaths,
-    known404Paths
-  } = _fogOfWar;
-  let manifestPath = `${basename ?? "/"}/__manifest`.replace(/\/+/g, "/");
-  let url = new URL(manifestPath, window.location.origin);
-  url.searchParams.set("version", manifest.version);
-  paths.forEach(path => url.searchParams.append("p", path));
-
-  // If the URL is nearing the ~8k limit on GET requests, skip this optimization
-  // step and just let discovery happen on link click.  We also wipe out the
-  // nextPaths Set here so we can start filling it with fresh links
-  if (url.toString().length > URL_LIMIT) {
-    nextPaths.clear();
-    return;
-  }
-  let res = await fetch(url);
-  if (!res.ok) {
-    throw new Error(`${res.status} ${res.statusText}`);
-  } else if (res.status >= 400) {
-    throw new Error(await res.text());
-  }
-  let data = await res.json();
-
-  // Capture this before we apply the patches to the manifest
-  let knownRoutes = new Set(Object.keys(manifest.routes));
-
-  // Patch routes we don't know about yet into the manifest
-  let patches = Object.values(data.patches).reduce((acc, route) => !knownRoutes.has(route.id) ? Object.assign(acc, {
-    [route.id]: route
-  }) : acc, {});
-  Object.assign(manifest.routes, patches);
-
-  // Track legit 404s so we don't try to fetch them again
-  data.notFoundPaths.forEach(p => known404Paths.add(p));
-
-  // Track matched paths so we don't have to fetch them again
-  paths.forEach(p => knownGoodPaths.add(p));
-
-  // Identify all parentIds for which we have new children to add and patch
-  // in their new children
-  let parentIds = new Set();
-  Object.values(patches).forEach(patch => {
-    if (!patch.parentId || !patches[patch.parentId]) {
-      parentIds.add(patch.parentId);
-    }
-  });
-  parentIds.forEach(parentId => patchRoutes(parentId || null, routes.createClientRoutes(patches, routeModules, null, future, isSpaMode, parentId)));
-}
-
-// Thanks Josh!
-// https://www.joshwcomeau.com/snippets/javascript/debounce/
-function debounce(callback, wait) {
-  let timeoutId;
-  return (...args) => {
-    window.clearTimeout(timeoutId);
-    timeoutId = window.setTimeout(() => callback(...args), wait);
-  };
-}
-
-exports.fetchAndApplyManifestPatches = fetchAndApplyManifestPatches;
-exports.getPartialManifest = getPartialManifest;
-exports.initFogOfWar = initFogOfWar;
-exports.isFogOfWarEnabled = isFogOfWarEnabled;
-exports.useFogOFWarDiscovery = useFogOFWarDiscovery;

package/node_modules/@remix-run/react/dist/index.d.ts

@@ -1,16 +0,0 @@
-export type { ErrorResponse, Fetcher, FetcherWithComponents, FormEncType, FormMethod, FormProps, Location, NavigateFunction, Navigation, Params, Path, ShouldRevalidateFunction, ShouldRevalidateFunctionArgs, SubmitFunction, SubmitOptions, Blocker, BlockerFunction, } from "react-router-dom";
-export { createPath, createRoutesFromChildren, createRoutesFromElements, createSearchParams, generatePath, matchPath, matchRoutes, parsePath, renderMatches, resolvePath, Form, Navigate, NavigationType, Outlet, Route, Routes, useAsyncError, useAsyncValue, isRouteErrorResponse, useBeforeUnload, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLocation, useMatch, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRoutes, useSearchParams, useSubmit, useBlocker, unstable_usePrompt, unstable_useViewTransitionState, } from "react-router-dom";
-export { defer, json, redirect, redirectDocument, } from "@remix-run/server-runtime";
-export type { RemixBrowserProps } from "./browser";
-export { RemixBrowser } from "./browser";
-export type { AwaitProps, RemixNavLinkProps as NavLinkProps, RemixLinkProps as LinkProps, UIMatch, } from "./components";
-export { Await, Meta, Links, Scripts, Link, NavLink, PrefetchPageLinks, LiveReload, useFetcher, useLoaderData, useRouteLoaderData, useActionData, useMatches, RemixContext as UNSAFE_RemixContext, } from "./components";
-export type { HtmlLinkDescriptor } from "./links";
-export type { ClientActionFunction, ClientActionFunctionArgs, ClientLoaderFunction, ClientLoaderFunctionArgs, MetaArgs, MetaMatch as UNSAFE_MetaMatch, MetaDescriptor, MetaFunction, RouteModules as UNSAFE_RouteModules, } from "./routeModules";
-export { ScrollRestoration } from "./scroll-restoration";
-export type { RemixServerProps } from "./server";
-export { RemixServer } from "./server";
-export type { ClientAction as unstable_ClientAction, ClientLoader as unstable_ClientLoader, } from "./single-fetch";
-export { defineClientAction as unstable_defineClientAction, defineClientLoader as unstable_defineClientLoader, } from "./single-fetch";
-export type { FutureConfig as UNSAFE_FutureConfig, AssetsManifest as UNSAFE_AssetsManifest, RemixContextObject as UNSAFE_RemixContextObject, } from "./entry";
-export type { EntryRoute as UNSAFE_EntryRoute, RouteManifest as UNSAFE_RouteManifest, } from "./routes";