create-bluecopa-react-app 1.0.10 → 1.0.12

package/templates/latest/dist/assets/client-LFBsfOjG.js

@@ -0,0 +1,2775 @@
+System.register(['./__federation_fn_import-CzfA7kmP.js', './index-D5og7-RT-BA7DwZw1.js', './index-BzNimew1.js', './index-DMFtQdNS.js'], (function (exports, module) {
+  'use strict';
+  var importShared, jsxRuntimeExports, FR, s1, PA, getDefaultExportFromCjs, requireReactDom;
+  return {
+    setters: [module => {
+      importShared = module.importShared;
+    }, module => {
+      jsxRuntimeExports = module.j;
+      FR = module.F;
+      s1 = module.s;
+      PA = module.P;
+    }, module => {
+      getDefaultExportFromCjs = module.g;
+    }, module => {
+      requireReactDom = module.r;
+    }],
+    execute: (async function () {
+
+      exports({
+        A: App,
+        B: BrowserRouter,
+        M: MemoryRouter
+      });
+
+      var PopStateEventType = "popstate";
+      function createMemoryHistory(options = {}) {
+        let { initialEntries = ["/"], initialIndex, v5Compat = false } = options;
+        let entries;
+        entries = initialEntries.map(
+          (entry, index2) => createMemoryLocation(
+            entry,
+            typeof entry === "string" ? null : entry.state,
+            index2 === 0 ? "default" : void 0
+          )
+        );
+        let index = clampIndex(
+          initialIndex == null ? entries.length - 1 : initialIndex
+        );
+        let action = "POP";
+        let listener = null;
+        function clampIndex(n) {
+          return Math.min(Math.max(n, 0), entries.length - 1);
+        }
+        function getCurrentLocation() {
+          return entries[index];
+        }
+        function createMemoryLocation(to, state = null, key) {
+          let location = createLocation(
+            entries ? getCurrentLocation().pathname : "/",
+            to,
+            state,
+            key
+          );
+          warning(
+            location.pathname.charAt(0) === "/",
+            `relative pathnames are not supported in memory history: ${JSON.stringify(
+        to
+      )}`
+          );
+          return location;
+        }
+        function createHref2(to) {
+          return typeof to === "string" ? to : createPath(to);
+        }
+        let history = {
+          get index() {
+            return index;
+          },
+          get action() {
+            return action;
+          },
+          get location() {
+            return getCurrentLocation();
+          },
+          createHref: createHref2,
+          createURL(to) {
+            return new URL(createHref2(to), "http://localhost");
+          },
+          encodeLocation(to) {
+            let path = typeof to === "string" ? parsePath(to) : to;
+            return {
+              pathname: path.pathname || "",
+              search: path.search || "",
+              hash: path.hash || ""
+            };
+          },
+          push(to, state) {
+            action = "PUSH";
+            let nextLocation = createMemoryLocation(to, state);
+            index += 1;
+            entries.splice(index, entries.length, nextLocation);
+            if (v5Compat && listener) {
+              listener({ action, location: nextLocation, delta: 1 });
+            }
+          },
+          replace(to, state) {
+            action = "REPLACE";
+            let nextLocation = createMemoryLocation(to, state);
+            entries[index] = nextLocation;
+            if (v5Compat && listener) {
+              listener({ action, location: nextLocation, delta: 0 });
+            }
+          },
+          go(delta) {
+            action = "POP";
+            let nextIndex = clampIndex(index + delta);
+            let nextLocation = entries[nextIndex];
+            index = nextIndex;
+            if (listener) {
+              listener({ action, location: nextLocation, delta });
+            }
+          },
+          listen(fn) {
+            listener = fn;
+            return () => {
+              listener = null;
+            };
+          }
+        };
+        return history;
+      }
+      function createBrowserHistory(options = {}) {
+        function createBrowserLocation(window2, globalHistory) {
+          let { pathname, search, hash } = window2.location;
+          return createLocation(
+            "",
+            { pathname, search, hash },
+            // state defaults to `null` because `window.history.state` does
+            globalHistory.state && globalHistory.state.usr || null,
+            globalHistory.state && globalHistory.state.key || "default"
+          );
+        }
+        function createBrowserHref(window2, to) {
+          return typeof to === "string" ? to : createPath(to);
+        }
+        return getUrlBasedHistory(
+          createBrowserLocation,
+          createBrowserHref,
+          null,
+          options
+        );
+      }
+      function invariant(value, message) {
+        if (value === false || value === null || typeof value === "undefined") {
+          throw new Error(message);
+        }
+      }
+      function warning(cond, message) {
+        if (!cond) {
+          if (typeof console !== "undefined") console.warn(message);
+          try {
+            throw new Error(message);
+          } catch (e) {
+          }
+        }
+      }
+      function createKey() {
+        return Math.random().toString(36).substring(2, 10);
+      }
+      function getHistoryState(location, index) {
+        return {
+          usr: location.state,
+          key: location.key,
+          idx: index
+        };
+      }
+      function createLocation(current, to, state = null, key) {
+        let location = {
+          pathname: typeof current === "string" ? current : current.pathname,
+          search: "",
+          hash: "",
+          ...typeof to === "string" ? parsePath(to) : to,
+          state,
+          // TODO: This could be cleaned up.  push/replace should probably just take
+          // full Locations now and avoid the need to run through this flow at all
+          // But that's a pretty big refactor to the current test suite so going to
+          // keep as is for the time being and just let any incoming keys take precedence
+          key: to && to.key || key || createKey()
+        };
+        return location;
+      }
+      function createPath({
+        pathname = "/",
+        search = "",
+        hash = ""
+      }) {
+        if (search && search !== "?")
+          pathname += search.charAt(0) === "?" ? search : "?" + search;
+        if (hash && hash !== "#")
+          pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+        return pathname;
+      }
+      function parsePath(path) {
+        let parsedPath = {};
+        if (path) {
+          let hashIndex = path.indexOf("#");
+          if (hashIndex >= 0) {
+            parsedPath.hash = path.substring(hashIndex);
+            path = path.substring(0, hashIndex);
+          }
+          let searchIndex = path.indexOf("?");
+          if (searchIndex >= 0) {
+            parsedPath.search = path.substring(searchIndex);
+            path = path.substring(0, searchIndex);
+          }
+          if (path) {
+            parsedPath.pathname = path;
+          }
+        }
+        return parsedPath;
+      }
+      function getUrlBasedHistory(getLocation, createHref2, validateLocation, options = {}) {
+        let { window: window2 = document.defaultView, v5Compat = false } = options;
+        let globalHistory = window2.history;
+        let action = "POP";
+        let listener = null;
+        let index = getIndex();
+        if (index == null) {
+          index = 0;
+          globalHistory.replaceState({ ...globalHistory.state, idx: index }, "");
+        }
+        function getIndex() {
+          let state = globalHistory.state || { idx: null };
+          return state.idx;
+        }
+        function handlePop() {
+          action = "POP";
+          let nextIndex = getIndex();
+          let delta = nextIndex == null ? null : nextIndex - index;
+          index = nextIndex;
+          if (listener) {
+            listener({ action, location: history.location, delta });
+          }
+        }
+        function push(to, state) {
+          action = "PUSH";
+          let location = createLocation(history.location, to, state);
+          index = getIndex() + 1;
+          let historyState = getHistoryState(location, index);
+          let url = history.createHref(location);
+          try {
+            globalHistory.pushState(historyState, "", url);
+          } catch (error) {
+            if (error instanceof DOMException && error.name === "DataCloneError") {
+              throw error;
+            }
+            window2.location.assign(url);
+          }
+          if (v5Compat && listener) {
+            listener({ action, location: history.location, delta: 1 });
+          }
+        }
+        function replace2(to, state) {
+          action = "REPLACE";
+          let location = createLocation(history.location, to, state);
+          index = getIndex();
+          let historyState = getHistoryState(location, index);
+          let url = history.createHref(location);
+          globalHistory.replaceState(historyState, "", url);
+          if (v5Compat && listener) {
+            listener({ action, location: history.location, delta: 0 });
+          }
+        }
+        function createURL(to) {
+          return createBrowserURLImpl(to);
+        }
+        let history = {
+          get action() {
+            return action;
+          },
+          get location() {
+            return getLocation(window2, globalHistory);
+          },
+          listen(fn) {
+            if (listener) {
+              throw new Error("A history only accepts one active listener");
+            }
+            window2.addEventListener(PopStateEventType, handlePop);
+            listener = fn;
+            return () => {
+              window2.removeEventListener(PopStateEventType, handlePop);
+              listener = null;
+            };
+          },
+          createHref(to) {
+            return createHref2(window2, to);
+          },
+          createURL,
+          encodeLocation(to) {
+            let url = createURL(to);
+            return {
+              pathname: url.pathname,
+              search: url.search,
+              hash: url.hash
+            };
+          },
+          push,
+          replace: replace2,
+          go(n) {
+            return globalHistory.go(n);
+          }
+        };
+        return history;
+      }
+      function createBrowserURLImpl(to, isAbsolute = false) {
+        let base = "http://localhost";
+        if (typeof window !== "undefined") {
+          base = window.location.origin !== "null" ? window.location.origin : window.location.href;
+        }
+        invariant(base, "No window.location.(origin|href) available to create URL");
+        let href = typeof to === "string" ? to : createPath(to);
+        href = href.replace(/ $/, "%20");
+        if (!isAbsolute && href.startsWith("//")) {
+          href = base + href;
+        }
+        return new URL(href, base);
+      }
+      function matchRoutes(routes, locationArg, basename = "/") {
+        return matchRoutesImpl(routes, locationArg, basename, false);
+      }
+      function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
+        let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
+        let pathname = stripBasename(location.pathname || "/", basename);
+        if (pathname == null) {
+          return null;
+        }
+        let branches = flattenRoutes(routes);
+        rankRouteBranches(branches);
+        let matches = null;
+        for (let i = 0; matches == null && i < branches.length; ++i) {
+          let decoded = decodePath(pathname);
+          matches = matchRouteBranch(
+            branches[i],
+            decoded,
+            allowPartial
+          );
+        }
+        return matches;
+      }
+      function flattenRoutes(routes, branches = [], parentsMeta = [], parentPath = "", _hasParentOptionalSegments = false) {
+        let flattenRoute = (route, index, hasParentOptionalSegments = _hasParentOptionalSegments, relativePath) => {
+          let meta = {
+            relativePath: relativePath === void 0 ? route.path || "" : relativePath,
+            caseSensitive: route.caseSensitive === true,
+            childrenIndex: index,
+            route
+          };
+          if (meta.relativePath.startsWith("/")) {
+            if (!meta.relativePath.startsWith(parentPath) && hasParentOptionalSegments) {
+              return;
+            }
+            invariant(
+              meta.relativePath.startsWith(parentPath),
+              `Absolute route path "${meta.relativePath}" nested under path "${parentPath}" is not valid. An absolute child route path must start with the combined path of all its parent routes.`
+            );
+            meta.relativePath = meta.relativePath.slice(parentPath.length);
+          }
+          let path = joinPaths([parentPath, meta.relativePath]);
+          let routesMeta = parentsMeta.concat(meta);
+          if (route.children && route.children.length > 0) {
+            invariant(
+              // Our types know better, but runtime JS may not!
+              // @ts-expect-error
+              route.index !== true,
+              `Index routes must not have child routes. Please remove all child routes from route path "${path}".`
+            );
+            flattenRoutes(
+              route.children,
+              branches,
+              routesMeta,
+              path,
+              hasParentOptionalSegments
+            );
+          }
+          if (route.path == null && !route.index) {
+            return;
+          }
+          branches.push({
+            path,
+            score: computeScore(path, route.index),
+            routesMeta
+          });
+        };
+        routes.forEach((route, index) => {
+          if (route.path === "" || !route.path?.includes("?")) {
+            flattenRoute(route, index);
+          } else {
+            for (let exploded of explodeOptionalSegments(route.path)) {
+              flattenRoute(route, index, true, exploded);
+            }
+          }
+        });
+        return branches;
+      }
+      function explodeOptionalSegments(path) {
+        let segments = path.split("/");
+        if (segments.length === 0) return [];
+        let [first, ...rest] = segments;
+        let isOptional = first.endsWith("?");
+        let required = first.replace(/\?$/, "");
+        if (rest.length === 0) {
+          return isOptional ? [required, ""] : [required];
+        }
+        let restExploded = explodeOptionalSegments(rest.join("/"));
+        let result = [];
+        result.push(
+          ...restExploded.map(
+            (subpath) => subpath === "" ? required : [required, subpath].join("/")
+          )
+        );
+        if (isOptional) {
+          result.push(...restExploded);
+        }
+        return result.map(
+          (exploded) => path.startsWith("/") && exploded === "" ? "/" : exploded
+        );
+      }
+      function rankRouteBranches(branches) {
+        branches.sort(
+          (a, b) => a.score !== b.score ? b.score - a.score : compareIndexes(
+            a.routesMeta.map((meta) => meta.childrenIndex),
+            b.routesMeta.map((meta) => meta.childrenIndex)
+          )
+        );
+      }
+      var paramRe = /^:[\w-]+$/;
+      var dynamicSegmentValue = 3;
+      var indexRouteValue = 2;
+      var emptySegmentValue = 1;
+      var staticSegmentValue = 10;
+      var splatPenalty = -2;
+      var isSplat = (s) => s === "*";
+      function computeScore(path, index) {
+        let segments = path.split("/");
+        let initialScore = segments.length;
+        if (segments.some(isSplat)) {
+          initialScore += splatPenalty;
+        }
+        if (index) {
+          initialScore += indexRouteValue;
+        }
+        return segments.filter((s) => !isSplat(s)).reduce(
+          (score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue),
+          initialScore
+        );
+      }
+      function compareIndexes(a, b) {
+        let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
+        return siblings ? (
+          // If two routes are siblings, we should try to match the earlier sibling
+          // first. This allows people to have fine-grained control over the matching
+          // behavior by simply putting routes with identical paths in the order they
+          // want them tried.
+          a[a.length - 1] - b[b.length - 1]
+        ) : (
+          // Otherwise, it doesn't really make sense to rank non-siblings by index,
+          // so they sort equally.
+          0
+        );
+      }
+      function matchRouteBranch(branch, pathname, allowPartial = false) {
+        let { routesMeta } = branch;
+        let matchedParams = {};
+        let matchedPathname = "/";
+        let matches = [];
+        for (let i = 0; i < routesMeta.length; ++i) {
+          let meta = routesMeta[i];
+          let end = i === routesMeta.length - 1;
+          let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
+          let match = matchPath(
+            { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },
+            remainingPathname
+          );
+          let route = meta.route;
+          if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {
+            match = matchPath(
+              {
+                path: meta.relativePath,
+                caseSensitive: meta.caseSensitive,
+                end: false
+              },
+              remainingPathname
+            );
+          }
+          if (!match) {
+            return null;
+          }
+          Object.assign(matchedParams, match.params);
+          matches.push({
+            // TODO: Can this as be avoided?
+            params: matchedParams,
+            pathname: joinPaths([matchedPathname, match.pathname]),
+            pathnameBase: normalizePathname(
+              joinPaths([matchedPathname, match.pathnameBase])
+            ),
+            route
+          });
+          if (match.pathnameBase !== "/") {
+            matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
+          }
+        }
+        return matches;
+      }
+      function matchPath(pattern, pathname) {
+        if (typeof pattern === "string") {
+          pattern = { path: pattern, caseSensitive: false, end: true };
+        }
+        let [matcher, compiledParams] = compilePath(
+          pattern.path,
+          pattern.caseSensitive,
+          pattern.end
+        );
+        let match = pathname.match(matcher);
+        if (!match) return null;
+        let matchedPathname = match[0];
+        let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
+        let captureGroups = match.slice(1);
+        let params = compiledParams.reduce(
+          (memo2, { paramName, isOptional }, index) => {
+            if (paramName === "*") {
+              let splatValue = captureGroups[index] || "";
+              pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
+            }
+            const value = captureGroups[index];
+            if (isOptional && !value) {
+              memo2[paramName] = void 0;
+            } else {
+              memo2[paramName] = (value || "").replace(/%2F/g, "/");
+            }
+            return memo2;
+          },
+          {}
+        );
+        return {
+          params,
+          pathname: matchedPathname,
+          pathnameBase,
+          pattern
+        };
+      }
+      function compilePath(path, caseSensitive = false, end = true) {
+        warning(
+          path === "*" || !path.endsWith("*") || path.endsWith("/*"),
+          `Route path "${path}" will be treated as if it were "${path.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${path.replace(/\*$/, "/*")}".`
+        );
+        let params = [];
+        let regexpSource = "^" + path.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(
+          /\/:([\w-]+)(\?)?/g,
+          (_, paramName, isOptional) => {
+            params.push({ paramName, isOptional: isOptional != null });
+            return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
+          }
+        ).replace(/\/([\w-]+)\?(\/|$)/g, "(/$1)?$2");
+        if (path.endsWith("*")) {
+          params.push({ paramName: "*" });
+          regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
+        } else if (end) {
+          regexpSource += "\\/*$";
+        } else if (path !== "" && path !== "/") {
+          regexpSource += "(?:(?=\\/|$))";
+        } else ;
+        let matcher = new RegExp(regexpSource, caseSensitive ? void 0 : "i");
+        return [matcher, params];
+      }
+      function decodePath(value) {
+        try {
+          return value.split("/").map((v) => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
+        } catch (error) {
+          warning(
+            false,
+            `The URL path "${value}" could not be decoded because it is a malformed URL segment. This is probably due to a bad percent encoding (${error}).`
+          );
+          return value;
+        }
+      }
+      function stripBasename(pathname, basename) {
+        if (basename === "/") return pathname;
+        if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
+          return null;
+        }
+        let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
+        let nextChar = pathname.charAt(startIndex);
+        if (nextChar && nextChar !== "/") {
+          return null;
+        }
+        return pathname.slice(startIndex) || "/";
+      }
+      function resolvePath(to, fromPathname = "/") {
+        let {
+          pathname: toPathname,
+          search = "",
+          hash = ""
+        } = typeof to === "string" ? parsePath(to) : to;
+        let pathname = toPathname ? toPathname.startsWith("/") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;
+        return {
+          pathname,
+          search: normalizeSearch(search),
+          hash: normalizeHash(hash)
+        };
+      }
+      function resolvePathname(relativePath, fromPathname) {
+        let segments = fromPathname.replace(/\/+$/, "").split("/");
+        let relativeSegments = relativePath.split("/");
+        relativeSegments.forEach((segment) => {
+          if (segment === "..") {
+            if (segments.length > 1) segments.pop();
+          } else if (segment !== ".") {
+            segments.push(segment);
+          }
+        });
+        return segments.length > 1 ? segments.join("/") : "/";
+      }
+      function getInvalidPathError(char, field, dest, path) {
+        return `Cannot include a '${char}' character in a manually specified \`to.${field}\` field [${JSON.stringify(
+    path
+  )}].  Please separate it out to the \`to.${dest}\` field. Alternatively you may provide the full path as a string in <Link to="..."> and the router will parse it for you.`;
+      }
+      function getPathContributingMatches(matches) {
+        return matches.filter(
+          (match, index) => index === 0 || match.route.path && match.route.path.length > 0
+        );
+      }
+      function getResolveToMatches(matches) {
+        let pathMatches = getPathContributingMatches(matches);
+        return pathMatches.map(
+          (match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase
+        );
+      }
+      function resolveTo(toArg, routePathnames, locationPathname, isPathRelative = false) {
+        let to;
+        if (typeof toArg === "string") {
+          to = parsePath(toArg);
+        } else {
+          to = { ...toArg };
+          invariant(
+            !to.pathname || !to.pathname.includes("?"),
+            getInvalidPathError("?", "pathname", "search", to)
+          );
+          invariant(
+            !to.pathname || !to.pathname.includes("#"),
+            getInvalidPathError("#", "pathname", "hash", to)
+          );
+          invariant(
+            !to.search || !to.search.includes("#"),
+            getInvalidPathError("#", "search", "hash", to)
+          );
+        }
+        let isEmptyPath = toArg === "" || to.pathname === "";
+        let toPathname = isEmptyPath ? "/" : to.pathname;
+        let from;
+        if (toPathname == null) {
+          from = locationPathname;
+        } else {
+          let routePathnameIndex = routePathnames.length - 1;
+          if (!isPathRelative && toPathname.startsWith("..")) {
+            let toSegments = toPathname.split("/");
+            while (toSegments[0] === "..") {
+              toSegments.shift();
+              routePathnameIndex -= 1;
+            }
+            to.pathname = toSegments.join("/");
+          }
+          from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+        }
+        let path = resolvePath(to, from);
+        let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
+        let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
+        if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
+          path.pathname += "/";
+        }
+        return path;
+      }
+      var joinPaths = (paths) => paths.join("/").replace(/\/\/+/g, "/");
+      var normalizePathname = (pathname) => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
+      var normalizeSearch = (search) => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
+      var normalizeHash = (hash) => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
+      function isRouteErrorResponse(error) {
+        return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
+      }
+      var validMutationMethodsArr = [
+        "POST",
+        "PUT",
+        "PATCH",
+        "DELETE"
+      ];
+      new Set(
+        validMutationMethodsArr
+      );
+      var validRequestMethodsArr = [
+        "GET",
+        ...validMutationMethodsArr
+      ];
+      new Set(validRequestMethodsArr);
+      const React = await importShared('react');
+
+      var DataRouterContext = React.createContext(null);
+      DataRouterContext.displayName = "DataRouter";
+      var DataRouterStateContext = React.createContext(null);
+      DataRouterStateContext.displayName = "DataRouterState";
+      var RSCRouterContext = React.createContext(false);
+      function useIsRSCRouterContext() {
+        return React.useContext(RSCRouterContext);
+      }
+      var ViewTransitionContext = React.createContext({
+        isTransitioning: false
+      });
+      ViewTransitionContext.displayName = "ViewTransition";
+      var FetchersContext = React.createContext(
+        /* @__PURE__ */ new Map()
+      );
+      FetchersContext.displayName = "Fetchers";
+      var AwaitContext = React.createContext(null);
+      AwaitContext.displayName = "Await";
+      var NavigationContext = React.createContext(
+        null
+      );
+      NavigationContext.displayName = "Navigation";
+      var LocationContext = React.createContext(
+        null
+      );
+      LocationContext.displayName = "Location";
+      var RouteContext = React.createContext({
+        outlet: null,
+        matches: [],
+        isDataRoute: false
+      });
+      RouteContext.displayName = "Route";
+      var RouteErrorContext = React.createContext(null);
+      RouteErrorContext.displayName = "RouteError";
+      const React2 = await importShared('react');
+
+      function useHref(to, { relative } = {}) {
+        invariant(
+          useInRouterContext(),
+          // TODO: This error is probably because they somehow have 2 versions of the
+          // router loaded. We can help them understand how to avoid that.
+          `useHref() may be used only in the context of a <Router> component.`
+        );
+        let { basename, navigator } = React2.useContext(NavigationContext);
+        let { hash, pathname, search } = useResolvedPath(to, { relative });
+        let joinedPathname = pathname;
+        if (basename !== "/") {
+          joinedPathname = pathname === "/" ? basename : joinPaths([basename, pathname]);
+        }
+        return navigator.createHref({ pathname: joinedPathname, search, hash });
+      }
+      function useInRouterContext() {
+        return React2.useContext(LocationContext) != null;
+      }
+      function useLocation() {
+        invariant(
+          useInRouterContext(),
+          // TODO: This error is probably because they somehow have 2 versions of the
+          // router loaded. We can help them understand how to avoid that.
+          `useLocation() may be used only in the context of a <Router> component.`
+        );
+        return React2.useContext(LocationContext).location;
+      }
+      var navigateEffectWarning = `You should call navigate() in a React.useEffect(), not when your component is first rendered.`;
+      function useIsomorphicLayoutEffect(cb) {
+        let isStatic = React2.useContext(NavigationContext).static;
+        if (!isStatic) {
+          React2.useLayoutEffect(cb);
+        }
+      }
+      function useNavigate() {
+        let { isDataRoute } = React2.useContext(RouteContext);
+        return isDataRoute ? useNavigateStable() : useNavigateUnstable();
+      }
+      function useNavigateUnstable() {
+        invariant(
+          useInRouterContext(),
+          // TODO: This error is probably because they somehow have 2 versions of the
+          // router loaded. We can help them understand how to avoid that.
+          `useNavigate() may be used only in the context of a <Router> component.`
+        );
+        let dataRouterContext = React2.useContext(DataRouterContext);
+        let { basename, navigator } = React2.useContext(NavigationContext);
+        let { matches } = React2.useContext(RouteContext);
+        let { pathname: locationPathname } = useLocation();
+        let routePathnamesJson = JSON.stringify(getResolveToMatches(matches));
+        let activeRef = React2.useRef(false);
+        useIsomorphicLayoutEffect(() => {
+          activeRef.current = true;
+        });
+        let navigate = React2.useCallback(
+          (to, options = {}) => {
+            warning(activeRef.current, navigateEffectWarning);
+            if (!activeRef.current) return;
+            if (typeof to === "number") {
+              navigator.go(to);
+              return;
+            }
+            let path = resolveTo(
+              to,
+              JSON.parse(routePathnamesJson),
+              locationPathname,
+              options.relative === "path"
+            );
+            if (dataRouterContext == null && basename !== "/") {
+              path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+            }
+            (!!options.replace ? navigator.replace : navigator.push)(
+              path,
+              options.state,
+              options
+            );
+          },
+          [
+            basename,
+            navigator,
+            routePathnamesJson,
+            locationPathname,
+            dataRouterContext
+          ]
+        );
+        return navigate;
+      }
+      React2.createContext(null);
+      function useResolvedPath(to, { relative } = {}) {
+        let { matches } = React2.useContext(RouteContext);
+        let { pathname: locationPathname } = useLocation();
+        let routePathnamesJson = JSON.stringify(getResolveToMatches(matches));
+        return React2.useMemo(
+          () => resolveTo(
+            to,
+            JSON.parse(routePathnamesJson),
+            locationPathname,
+            relative === "path"
+          ),
+          [to, routePathnamesJson, locationPathname, relative]
+        );
+      }
+      function useRoutes(routes, locationArg) {
+        return useRoutesImpl(routes, locationArg);
+      }
+      function useRoutesImpl(routes, locationArg, dataRouterState, unstable_onError, future) {
+        invariant(
+          useInRouterContext(),
+          // TODO: This error is probably because they somehow have 2 versions of the
+          // router loaded. We can help them understand how to avoid that.
+          `useRoutes() may be used only in the context of a <Router> component.`
+        );
+        let { navigator } = React2.useContext(NavigationContext);
+        let { matches: parentMatches } = React2.useContext(RouteContext);
+        let routeMatch = parentMatches[parentMatches.length - 1];
+        let parentParams = routeMatch ? routeMatch.params : {};
+        let parentPathname = routeMatch ? routeMatch.pathname : "/";
+        let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : "/";
+        let parentRoute = routeMatch && routeMatch.route;
+        {
+          let parentPath = parentRoute && parentRoute.path || "";
+          warningOnce(
+            parentPathname,
+            !parentRoute || parentPath.endsWith("*") || parentPath.endsWith("*?"),
+            `You rendered descendant <Routes> (or called \`useRoutes()\`) at "${parentPathname}" (under <Route path="${parentPath}">) but the parent route path has no trailing "*". This means if you navigate deeper, the parent won't match anymore and therefore the child routes will never render.
+
+Please change the parent <Route path="${parentPath}"> to <Route path="${parentPath === "/" ? "*" : `${parentPath}/*`}">.`
+          );
+        }
+        let locationFromContext = useLocation();
+        let location;
+        if (locationArg) {
+          let parsedLocationArg = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
+          invariant(
+            parentPathnameBase === "/" || parsedLocationArg.pathname?.startsWith(parentPathnameBase),
+            `When overriding the location using \`<Routes location>\` or \`useRoutes(routes, location)\`, the location pathname must begin with the portion of the URL pathname that was matched by all parent routes. The current pathname base is "${parentPathnameBase}" but pathname "${parsedLocationArg.pathname}" was given in the \`location\` prop.`
+          );
+          location = parsedLocationArg;
+        } else {
+          location = locationFromContext;
+        }
+        let pathname = location.pathname || "/";
+        let remainingPathname = pathname;
+        if (parentPathnameBase !== "/") {
+          let parentSegments = parentPathnameBase.replace(/^\//, "").split("/");
+          let segments = pathname.replace(/^\//, "").split("/");
+          remainingPathname = "/" + segments.slice(parentSegments.length).join("/");
+        }
+        let matches = matchRoutes(routes, { pathname: remainingPathname });
+        {
+          warning(
+            parentRoute || matches != null,
+            `No routes matched location "${location.pathname}${location.search}${location.hash}" `
+          );
+          warning(
+            matches == null || matches[matches.length - 1].route.element !== void 0 || matches[matches.length - 1].route.Component !== void 0 || matches[matches.length - 1].route.lazy !== void 0,
+            `Matched leaf route at location "${location.pathname}${location.search}${location.hash}" does not have an element or Component. This means it will render an <Outlet /> with a null value by default resulting in an "empty" page.`
+          );
+        }
+        let renderedMatches = _renderMatches(
+          matches && matches.map(
+            (match) => Object.assign({}, match, {
+              params: Object.assign({}, parentParams, match.params),
+              pathname: joinPaths([
+                parentPathnameBase,
+                // Re-encode pathnames that were decoded inside matchRoutes.
+                // Pre-encode `?` and `#` ahead of `encodeLocation` because it uses
+                // `new URL()` internally and we need to prevent it from treating
+                // them as separators
+                navigator.encodeLocation ? navigator.encodeLocation(
+                  match.pathname.replace(/\?/g, "%3F").replace(/#/g, "%23")
+                ).pathname : match.pathname
+              ]),
+              pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([
+                parentPathnameBase,
+                // Re-encode pathnames that were decoded inside matchRoutes
+                // Pre-encode `?` and `#` ahead of `encodeLocation` because it uses
+                // `new URL()` internally and we need to prevent it from treating
+                // them as separators
+                navigator.encodeLocation ? navigator.encodeLocation(
+                  match.pathnameBase.replace(/\?/g, "%3F").replace(/#/g, "%23")
+                ).pathname : match.pathnameBase
+              ])
+            })
+          ),
+          parentMatches,
+          dataRouterState,
+          unstable_onError,
+          future
+        );
+        if (locationArg && renderedMatches) {
+          return /* @__PURE__ */ React2.createElement(
+            LocationContext.Provider,
+            {
+              value: {
+                location: {
+                  pathname: "/",
+                  search: "",
+                  hash: "",
+                  state: null,
+                  key: "default",
+                  ...location
+                },
+                navigationType: "POP"
+                /* Pop */
+              }
+            },
+            renderedMatches
+          );
+        }
+        return renderedMatches;
+      }
+      function DefaultErrorComponent() {
+        let error = useRouteError();
+        let message = isRouteErrorResponse(error) ? `${error.status} ${error.statusText}` : error instanceof Error ? error.message : JSON.stringify(error);
+        let stack = error instanceof Error ? error.stack : null;
+        let lightgrey = "rgba(200,200,200, 0.5)";
+        let preStyles = { padding: "0.5rem", backgroundColor: lightgrey };
+        let codeStyles = { padding: "2px 4px", backgroundColor: lightgrey };
+        let devInfo = null;
+        {
+          console.error(
+            "Error handled by React Router default ErrorBoundary:",
+            error
+          );
+          devInfo = /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement("p", null, "💿 Hey developer 👋"), /* @__PURE__ */ React2.createElement("p", null, "You can provide a way better UX than this when your app throws errors by providing your own ", /* @__PURE__ */ React2.createElement("code", { style: codeStyles }, "ErrorBoundary"), " or", " ", /* @__PURE__ */ React2.createElement("code", { style: codeStyles }, "errorElement"), " prop on your route."));
+        }
+        return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement("h2", null, "Unexpected Application Error!"), /* @__PURE__ */ React2.createElement("h3", { style: { fontStyle: "italic" } }, message), stack ? /* @__PURE__ */ React2.createElement("pre", { style: preStyles }, stack) : null, devInfo);
+      }
+      var defaultErrorElement = /* @__PURE__ */ React2.createElement(DefaultErrorComponent, null);
+      var RenderErrorBoundary = class extends React2.Component {
+        constructor(props) {
+          super(props);
+          this.state = {
+            location: props.location,
+            revalidation: props.revalidation,
+            error: props.error
+          };
+        }
+        static getDerivedStateFromError(error) {
+          return { error };
+        }
+        static getDerivedStateFromProps(props, state) {
+          if (state.location !== props.location || state.revalidation !== "idle" && props.revalidation === "idle") {
+            return {
+              error: props.error,
+              location: props.location,
+              revalidation: props.revalidation
+            };
+          }
+          return {
+            error: props.error !== void 0 ? props.error : state.error,
+            location: state.location,
+            revalidation: props.revalidation || state.revalidation
+          };
+        }
+        componentDidCatch(error, errorInfo) {
+          if (this.props.unstable_onError) {
+            this.props.unstable_onError(error, errorInfo);
+          } else {
+            console.error(
+              "React Router caught the following error during render",
+              error
+            );
+          }
+        }
+        render() {
+          return this.state.error !== void 0 ? /* @__PURE__ */ React2.createElement(RouteContext.Provider, { value: this.props.routeContext }, /* @__PURE__ */ React2.createElement(
+            RouteErrorContext.Provider,
+            {
+              value: this.state.error,
+              children: this.props.component
+            }
+          )) : this.props.children;
+        }
+      };
+      function RenderedRoute({ routeContext, match, children }) {
+        let dataRouterContext = React2.useContext(DataRouterContext);
+        if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {
+          dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;
+        }
+        return /* @__PURE__ */ React2.createElement(RouteContext.Provider, { value: routeContext }, children);
+      }
+      function _renderMatches(matches, parentMatches = [], dataRouterState = null, unstable_onError = null, future = null) {
+        if (matches == null) {
+          if (!dataRouterState) {
+            return null;
+          }
+          if (dataRouterState.errors) {
+            matches = dataRouterState.matches;
+          } else if (parentMatches.length === 0 && !dataRouterState.initialized && dataRouterState.matches.length > 0) {
+            matches = dataRouterState.matches;
+          } else {
+            return null;
+          }
+        }
+        let renderedMatches = matches;
+        let errors = dataRouterState?.errors;
+        if (errors != null) {
+          let errorIndex = renderedMatches.findIndex(
+            (m) => m.route.id && errors?.[m.route.id] !== void 0
+          );
+          invariant(
+            errorIndex >= 0,
+            `Could not find a matching route for errors on route IDs: ${Object.keys(
+        errors
+      ).join(",")}`
+          );
+          renderedMatches = renderedMatches.slice(
+            0,
+            Math.min(renderedMatches.length, errorIndex + 1)
+          );
+        }
+        let renderFallback = false;
+        let fallbackIndex = -1;
+        if (dataRouterState) {
+          for (let i = 0; i < renderedMatches.length; i++) {
+            let match = renderedMatches[i];
+            if (match.route.HydrateFallback || match.route.hydrateFallbackElement) {
+              fallbackIndex = i;
+            }
+            if (match.route.id) {
+              let { loaderData, errors: errors2 } = dataRouterState;
+              let needsToRunLoader = match.route.loader && !loaderData.hasOwnProperty(match.route.id) && (!errors2 || errors2[match.route.id] === void 0);
+              if (match.route.lazy || needsToRunLoader) {
+                renderFallback = true;
+                if (fallbackIndex >= 0) {
+                  renderedMatches = renderedMatches.slice(0, fallbackIndex + 1);
+                } else {
+                  renderedMatches = [renderedMatches[0]];
+                }
+                break;
+              }
+            }
+          }
+        }
+        return renderedMatches.reduceRight(
+          (outlet, match, index) => {
+            let error;
+            let shouldRenderHydrateFallback = false;
+            let errorElement = null;
+            let hydrateFallbackElement = null;
+            if (dataRouterState) {
+              error = errors && match.route.id ? errors[match.route.id] : void 0;
+              errorElement = match.route.errorElement || defaultErrorElement;
+              if (renderFallback) {
+                if (fallbackIndex < 0 && index === 0) {
+                  warningOnce(
+                    "route-fallback",
+                    false,
+                    "No `HydrateFallback` element provided to render during initial hydration"
+                  );
+                  shouldRenderHydrateFallback = true;
+                  hydrateFallbackElement = null;
+                } else if (fallbackIndex === index) {
+                  shouldRenderHydrateFallback = true;
+                  hydrateFallbackElement = match.route.hydrateFallbackElement || null;
+                }
+              }
+            }
+            let matches2 = parentMatches.concat(renderedMatches.slice(0, index + 1));
+            let getChildren = () => {
+              let children;
+              if (error) {
+                children = errorElement;
+              } else if (shouldRenderHydrateFallback) {
+                children = hydrateFallbackElement;
+              } else if (match.route.Component) {
+                children = /* @__PURE__ */ React2.createElement(match.route.Component, null);
+              } else if (match.route.element) {
+                children = match.route.element;
+              } else {
+                children = outlet;
+              }
+              return /* @__PURE__ */ React2.createElement(
+                RenderedRoute,
+                {
+                  match,
+                  routeContext: {
+                    outlet,
+                    matches: matches2,
+                    isDataRoute: dataRouterState != null
+                  },
+                  children
+                }
+              );
+            };
+            return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /* @__PURE__ */ React2.createElement(
+              RenderErrorBoundary,
+              {
+                location: dataRouterState.location,
+                revalidation: dataRouterState.revalidation,
+                component: errorElement,
+                error,
+                children: getChildren(),
+                routeContext: { outlet: null, matches: matches2, isDataRoute: true },
+                unstable_onError
+              }
+            ) : getChildren();
+          },
+          null
+        );
+      }
+      function getDataRouterConsoleError(hookName) {
+        return `${hookName} must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.`;
+      }
+      function useDataRouterContext(hookName) {
+        let ctx = React2.useContext(DataRouterContext);
+        invariant(ctx, getDataRouterConsoleError(hookName));
+        return ctx;
+      }
+      function useDataRouterState(hookName) {
+        let state = React2.useContext(DataRouterStateContext);
+        invariant(state, getDataRouterConsoleError(hookName));
+        return state;
+      }
+      function useRouteContext(hookName) {
+        let route = React2.useContext(RouteContext);
+        invariant(route, getDataRouterConsoleError(hookName));
+        return route;
+      }
+      function useCurrentRouteId(hookName) {
+        let route = useRouteContext(hookName);
+        let thisRoute = route.matches[route.matches.length - 1];
+        invariant(
+          thisRoute.route.id,
+          `${hookName} can only be used on routes that contain a unique "id"`
+        );
+        return thisRoute.route.id;
+      }
+      function useRouteId() {
+        return useCurrentRouteId(
+          "useRouteId"
+          /* UseRouteId */
+        );
+      }
+      function useRouteError() {
+        let error = React2.useContext(RouteErrorContext);
+        let state = useDataRouterState(
+          "useRouteError"
+          /* UseRouteError */
+        );
+        let routeId = useCurrentRouteId(
+          "useRouteError"
+          /* UseRouteError */
+        );
+        if (error !== void 0) {
+          return error;
+        }
+        return state.errors?.[routeId];
+      }
+      function useNavigateStable() {
+        let { router } = useDataRouterContext(
+          "useNavigate"
+          /* UseNavigateStable */
+        );
+        let id = useCurrentRouteId(
+          "useNavigate"
+          /* UseNavigateStable */
+        );
+        let activeRef = React2.useRef(false);
+        useIsomorphicLayoutEffect(() => {
+          activeRef.current = true;
+        });
+        let navigate = React2.useCallback(
+          async (to, options = {}) => {
+            warning(activeRef.current, navigateEffectWarning);
+            if (!activeRef.current) return;
+            if (typeof to === "number") {
+              router.navigate(to);
+            } else {
+              await router.navigate(to, { fromRouteId: id, ...options });
+            }
+          },
+          [router, id]
+        );
+        return navigate;
+      }
+      var alreadyWarned = {};
+      function warningOnce(key, cond, message) {
+        if (!cond && !alreadyWarned[key]) {
+          alreadyWarned[key] = true;
+          warning(false, message);
+        }
+      }
+      const React3 = await importShared('react');
+
+      var alreadyWarned2 = {};
+      function warnOnce(condition, message) {
+        if (!condition && !alreadyWarned2[message]) {
+          alreadyWarned2[message] = true;
+          console.warn(message);
+        }
+      }
+      React3.memo(DataRoutes);
+      function DataRoutes({
+        routes,
+        future,
+        state,
+        unstable_onError
+      }) {
+        return useRoutesImpl(routes, void 0, state, unstable_onError, future);
+      }
+      function MemoryRouter({
+        basename,
+        children,
+        initialEntries,
+        initialIndex
+      }) {
+        let historyRef = React3.useRef();
+        if (historyRef.current == null) {
+          historyRef.current = createMemoryHistory({
+            initialEntries,
+            initialIndex,
+            v5Compat: true
+          });
+        }
+        let history = historyRef.current;
+        let [state, setStateImpl] = React3.useState({
+          action: history.action,
+          location: history.location
+        });
+        let setState = React3.useCallback(
+          (newState) => {
+            React3.startTransition(() => setStateImpl(newState));
+          },
+          [setStateImpl]
+        );
+        React3.useLayoutEffect(() => history.listen(setState), [history, setState]);
+        return /* @__PURE__ */ React3.createElement(
+          Router,
+          {
+            basename,
+            children,
+            location: state.location,
+            navigationType: state.action,
+            navigator: history
+          }
+        );
+      }
+      function Navigate({
+        to,
+        replace: replace2,
+        state,
+        relative
+      }) {
+        invariant(
+          useInRouterContext(),
+          // TODO: This error is probably because they somehow have 2 versions of
+          // the router loaded. We can help them understand how to avoid that.
+          `<Navigate> may be used only in the context of a <Router> component.`
+        );
+        let { static: isStatic } = React3.useContext(NavigationContext);
+        warning(
+          !isStatic,
+          `<Navigate> must not be used on the initial render in a <StaticRouter>. This is a no-op, but you should modify your code so the <Navigate> is only ever rendered in response to some user interaction or state change.`
+        );
+        let { matches } = React3.useContext(RouteContext);
+        let { pathname: locationPathname } = useLocation();
+        let navigate = useNavigate();
+        let path = resolveTo(
+          to,
+          getResolveToMatches(matches),
+          locationPathname,
+          relative === "path"
+        );
+        let jsonPath = JSON.stringify(path);
+        React3.useEffect(() => {
+          navigate(JSON.parse(jsonPath), { replace: replace2, state, relative });
+        }, [navigate, jsonPath, relative, replace2, state]);
+        return null;
+      }
+      function Route(props) {
+        invariant(
+          false,
+          `A <Route> is only ever to be used as the child of <Routes> element, never rendered directly. Please wrap your <Route> in a <Routes>.`
+        );
+      }
+      function Router({
+        basename: basenameProp = "/",
+        children = null,
+        location: locationProp,
+        navigationType = "POP",
+        navigator,
+        static: staticProp = false
+      }) {
+        invariant(
+          !useInRouterContext(),
+          `You cannot render a <Router> inside another <Router>. You should never have more than one in your app.`
+        );
+        let basename = basenameProp.replace(/^\/*/, "/");
+        let navigationContext = React3.useMemo(
+          () => ({
+            basename,
+            navigator,
+            static: staticProp,
+            future: {}
+          }),
+          [basename, navigator, staticProp]
+        );
+        if (typeof locationProp === "string") {
+          locationProp = parsePath(locationProp);
+        }
+        let {
+          pathname = "/",
+          search = "",
+          hash = "",
+          state = null,
+          key = "default"
+        } = locationProp;
+        let locationContext = React3.useMemo(() => {
+          let trailingPathname = stripBasename(pathname, basename);
+          if (trailingPathname == null) {
+            return null;
+          }
+          return {
+            location: {
+              pathname: trailingPathname,
+              search,
+              hash,
+              state,
+              key
+            },
+            navigationType
+          };
+        }, [basename, pathname, search, hash, state, key, navigationType]);
+        warning(
+          locationContext != null,
+          `<Router basename="${basename}"> is not able to match the URL "${pathname}${search}${hash}" because it does not start with the basename, so the <Router> won't render anything.`
+        );
+        if (locationContext == null) {
+          return null;
+        }
+        return /* @__PURE__ */ React3.createElement(NavigationContext.Provider, { value: navigationContext }, /* @__PURE__ */ React3.createElement(LocationContext.Provider, { children, value: locationContext }));
+      }
+      function Routes({
+        children,
+        location
+      }) {
+        return useRoutes(createRoutesFromChildren(children), location);
+      }
+      (class extends React3.Component {
+        constructor(props) {
+          super(props);
+          this.state = { error: null };
+        }
+        static getDerivedStateFromError(error) {
+          return { error };
+        }
+        componentDidCatch(error, errorInfo) {
+          if (this.props.unstable_onError) {
+            this.props.unstable_onError(error, errorInfo);
+          } else {
+            console.error(
+              "<Await> caught the following error during render",
+              error,
+              errorInfo
+            );
+          }
+        }
+        render() {
+          let { children, errorElement, resolve } = this.props;
+          let promise = null;
+          let status = 0;
+          if (!(resolve instanceof Promise)) {
+            status = 1;
+            promise = Promise.resolve();
+            Object.defineProperty(promise, "_tracked", { get: () => true });
+            Object.defineProperty(promise, "_data", { get: () => resolve });
+          } else if (this.state.error) {
+            status = 2;
+            let renderError = this.state.error;
+            promise = Promise.reject().catch(() => {
+            });
+            Object.defineProperty(promise, "_tracked", { get: () => true });
+            Object.defineProperty(promise, "_error", { get: () => renderError });
+          } else if (resolve._tracked) {
+            promise = resolve;
+            status = "_error" in promise ? 2 : "_data" in promise ? 1 : 0;
+          } else {
+            status = 0;
+            Object.defineProperty(resolve, "_tracked", { get: () => true });
+            promise = resolve.then(
+              (data2) => Object.defineProperty(resolve, "_data", { get: () => data2 }),
+              (error) => {
+                this.props.unstable_onError?.(error);
+                Object.defineProperty(resolve, "_error", { get: () => error });
+              }
+            );
+          }
+          if (status === 2 && !errorElement) {
+            throw promise._error;
+          }
+          if (status === 2) {
+            return /* @__PURE__ */ React3.createElement(AwaitContext.Provider, { value: promise, children: errorElement });
+          }
+          if (status === 1) {
+            return /* @__PURE__ */ React3.createElement(AwaitContext.Provider, { value: promise, children });
+          }
+          throw promise;
+        }
+      });
+      function createRoutesFromChildren(children, parentPath = []) {
+        let routes = [];
+        React3.Children.forEach(children, (element, index) => {
+          if (!React3.isValidElement(element)) {
+            return;
+          }
+          let treePath = [...parentPath, index];
+          if (element.type === React3.Fragment) {
+            routes.push.apply(
+              routes,
+              createRoutesFromChildren(element.props.children, treePath)
+            );
+            return;
+          }
+          invariant(
+            element.type === Route,
+            `[${typeof element.type === "string" ? element.type : element.type.name}] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`
+          );
+          invariant(
+            !element.props.index || !element.props.children,
+            "An index route cannot have child routes."
+          );
+          let route = {
+            id: element.props.id || treePath.join("-"),
+            caseSensitive: element.props.caseSensitive,
+            element: element.props.element,
+            Component: element.props.Component,
+            index: element.props.index,
+            path: element.props.path,
+            middleware: element.props.middleware,
+            loader: element.props.loader,
+            action: element.props.action,
+            hydrateFallbackElement: element.props.hydrateFallbackElement,
+            HydrateFallback: element.props.HydrateFallback,
+            errorElement: element.props.errorElement,
+            ErrorBoundary: element.props.ErrorBoundary,
+            hasErrorBoundary: element.props.hasErrorBoundary === true || element.props.ErrorBoundary != null || element.props.errorElement != null,
+            shouldRevalidate: element.props.shouldRevalidate,
+            handle: element.props.handle,
+            lazy: element.props.lazy
+          };
+          if (element.props.children) {
+            route.children = createRoutesFromChildren(
+              element.props.children,
+              treePath
+            );
+          }
+          routes.push(route);
+        });
+        return routes;
+      }
+      var defaultMethod = "get";
+      var defaultEncType = "application/x-www-form-urlencoded";
+      function isHtmlElement(object) {
+        return object != null && typeof object.tagName === "string";
+      }
+      function isButtonElement(object) {
+        return isHtmlElement(object) && object.tagName.toLowerCase() === "button";
+      }
+      function isFormElement(object) {
+        return isHtmlElement(object) && object.tagName.toLowerCase() === "form";
+      }
+      function isInputElement(object) {
+        return isHtmlElement(object) && object.tagName.toLowerCase() === "input";
+      }
+      function isModifiedEvent(event) {
+        return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
+      }
+      function shouldProcessLinkClick(event, target) {
+        return event.button === 0 && // Ignore everything but left clicks
+        (!target || target === "_self") && // Let browser handle "target=_blank" etc.
+        !isModifiedEvent(event);
+      }
+      var _formDataSupportsSubmitter = null;
+      function isFormDataSubmitterSupported() {
+        if (_formDataSupportsSubmitter === null) {
+          try {
+            new FormData(
+              document.createElement("form"),
+              // @ts-expect-error if FormData supports the submitter parameter, this will throw
+              0
+            );
+            _formDataSupportsSubmitter = false;
+          } catch (e) {
+            _formDataSupportsSubmitter = true;
+          }
+        }
+        return _formDataSupportsSubmitter;
+      }
+      var supportedFormEncTypes = /* @__PURE__ */ new Set([
+        "application/x-www-form-urlencoded",
+        "multipart/form-data",
+        "text/plain"
+      ]);
+      function getFormEncType(encType) {
+        if (encType != null && !supportedFormEncTypes.has(encType)) {
+          warning(
+            false,
+            `"${encType}" is not a valid \`encType\` for \`<Form>\`/\`<fetcher.Form>\` and will default to "${defaultEncType}"`
+          );
+          return null;
+        }
+        return encType;
+      }
+      function getFormSubmissionInfo(target, basename) {
+        let method;
+        let action;
+        let encType;
+        let formData;
+        let body;
+        if (isFormElement(target)) {
+          let attr = target.getAttribute("action");
+          action = attr ? stripBasename(attr, basename) : null;
+          method = target.getAttribute("method") || defaultMethod;
+          encType = getFormEncType(target.getAttribute("enctype")) || defaultEncType;
+          formData = new FormData(target);
+        } else if (isButtonElement(target) || isInputElement(target) && (target.type === "submit" || target.type === "image")) {
+          let form = target.form;
+          if (form == null) {
+            throw new Error(
+              `Cannot submit a <button> or <input type="submit"> without a <form>`
+            );
+          }
+          let attr = target.getAttribute("formaction") || form.getAttribute("action");
+          action = attr ? stripBasename(attr, basename) : null;
+          method = target.getAttribute("formmethod") || form.getAttribute("method") || defaultMethod;
+          encType = getFormEncType(target.getAttribute("formenctype")) || getFormEncType(form.getAttribute("enctype")) || defaultEncType;
+          formData = new FormData(form, target);
+          if (!isFormDataSubmitterSupported()) {
+            let { name, type, value } = target;
+            if (type === "image") {
+              let prefix = name ? `${name}.` : "";
+              formData.append(`${prefix}x`, "0");
+              formData.append(`${prefix}y`, "0");
+            } else if (name) {
+              formData.append(name, value);
+            }
+          }
+        } else if (isHtmlElement(target)) {
+          throw new Error(
+            `Cannot submit element that is not <form>, <button>, or <input type="submit|image">`
+          );
+        } else {
+          method = defaultMethod;
+          action = null;
+          encType = defaultEncType;
+          body = target;
+        }
+        if (formData && encType === "text/plain") {
+          body = formData;
+          formData = void 0;
+        }
+        return { action, method: method.toLowerCase(), encType, formData, body };
+      }
+      await importShared('react');
+      Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
+      function invariant2(value, message) {
+        if (value === false || value === null || typeof value === "undefined") {
+          throw new Error(message);
+        }
+      }
+      function singleFetchUrl(reqUrl, basename, extension) {
+        let url = typeof reqUrl === "string" ? new URL(
+          reqUrl,
+          // This can be called during the SSR flow via PrefetchPageLinksImpl so
+          // don't assume window is available
+          typeof window === "undefined" ? "server://singlefetch/" : window.location.origin
+        ) : reqUrl;
+        if (url.pathname === "/") {
+          url.pathname = `_root.${extension}`;
+        } else if (basename && stripBasename(url.pathname, basename) === "/") {
+          url.pathname = `${basename.replace(/\/$/, "")}/_root.${extension}`;
+        } else {
+          url.pathname = `${url.pathname.replace(/\/$/, "")}.${extension}`;
+        }
+        return url;
+      }
+      const React9 = await importShared('react');
+
+      const React8 = await importShared('react');
+
+      async function loadRouteModule(route, routeModulesCache) {
+        if (route.id in routeModulesCache) {
+          return routeModulesCache[route.id];
+        }
+        try {
+          let routeModule = await module.import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.module
+          );
+          routeModulesCache[route.id] = routeModule;
+          return routeModule;
+        } catch (error) {
+          console.error(
+            `Error loading route module \`${route.module}\`, reloading page...`
+          );
+          console.error(error);
+          if (window.__reactRouterContext && window.__reactRouterContext.isSpaMode && // @ts-expect-error
+          void 0) ;
+          window.location.reload();
+          return new Promise(() => {
+          });
+        }
+      }
+      function isHtmlLinkDescriptor(object) {
+        if (object == null) {
+          return false;
+        }
+        if (object.href == null) {
+          return object.rel === "preload" && typeof object.imageSrcSet === "string" && typeof object.imageSizes === "string";
+        }
+        return typeof object.rel === "string" && typeof object.href === "string";
+      }
+      async function getKeyedPrefetchLinks(matches, manifest, routeModules) {
+        let links = await Promise.all(
+          matches.map(async (match) => {
+            let route = manifest.routes[match.route.id];
+            if (route) {
+              let mod = await loadRouteModule(route, routeModules);
+              return mod.links ? mod.links() : [];
+            }
+            return [];
+          })
+        );
+        return dedupeLinkDescriptors(
+          links.flat(1).filter(isHtmlLinkDescriptor).filter((link) => link.rel === "stylesheet" || link.rel === "preload").map(
+            (link) => link.rel === "stylesheet" ? { ...link, rel: "prefetch", as: "style" } : { ...link, rel: "prefetch" }
+          )
+        );
+      }
+      function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, location, mode) {
+        let isNew = (match, index) => {
+          if (!currentMatches[index]) return true;
+          return match.route.id !== currentMatches[index].route.id;
+        };
+        let matchPathChanged = (match, index) => {
+          return (
+            // param change, /users/123 -> /users/456
+            currentMatches[index].pathname !== match.pathname || // splat param changed, which is not present in match.path
+            // e.g. /files/images/avatar.jpg -> files/finances.xls
+            currentMatches[index].route.path?.endsWith("*") && currentMatches[index].params["*"] !== match.params["*"]
+          );
+        };
+        if (mode === "assets") {
+          return nextMatches.filter(
+            (match, index) => isNew(match, index) || matchPathChanged(match, index)
+          );
+        }
+        if (mode === "data") {
+          return nextMatches.filter((match, index) => {
+            let manifestRoute = manifest.routes[match.route.id];
+            if (!manifestRoute || !manifestRoute.hasLoader) {
+              return false;
+            }
+            if (isNew(match, index) || matchPathChanged(match, index)) {
+              return true;
+            }
+            if (match.route.shouldRevalidate) {
+              let routeChoice = match.route.shouldRevalidate({
+                currentUrl: new URL(
+                  location.pathname + location.search + location.hash,
+                  window.origin
+                ),
+                currentParams: currentMatches[0]?.params || {},
+                nextUrl: new URL(page, window.origin),
+                nextParams: match.params,
+                defaultShouldRevalidate: true
+              });
+              if (typeof routeChoice === "boolean") {
+                return routeChoice;
+              }
+            }
+            return true;
+          });
+        }
+        return [];
+      }
+      function getModuleLinkHrefs(matches, manifest, { includeHydrateFallback } = {}) {
+        return dedupeHrefs(
+          matches.map((match) => {
+            let route = manifest.routes[match.route.id];
+            if (!route) return [];
+            let hrefs = [route.module];
+            if (route.clientActionModule) {
+              hrefs = hrefs.concat(route.clientActionModule);
+            }
+            if (route.clientLoaderModule) {
+              hrefs = hrefs.concat(route.clientLoaderModule);
+            }
+            if (includeHydrateFallback && route.hydrateFallbackModule) {
+              hrefs = hrefs.concat(route.hydrateFallbackModule);
+            }
+            if (route.imports) {
+              hrefs = hrefs.concat(route.imports);
+            }
+            return hrefs;
+          }).flat(1)
+        );
+      }
+      function dedupeHrefs(hrefs) {
+        return [...new Set(hrefs)];
+      }
+      function sortKeys(obj) {
+        let sorted = {};
+        let keys = Object.keys(obj).sort();
+        for (let key of keys) {
+          sorted[key] = obj[key];
+        }
+        return sorted;
+      }
+      function dedupeLinkDescriptors(descriptors, preloads) {
+        let set = /* @__PURE__ */ new Set();
+        new Set(preloads);
+        return descriptors.reduce((deduped, descriptor) => {
+          let key = JSON.stringify(sortKeys(descriptor));
+          if (!set.has(key)) {
+            set.add(key);
+            deduped.push({ key, link: descriptor });
+          }
+          return deduped;
+        }, []);
+      }
+      await importShared('react');
+
+      await importShared('react');
+
+      await importShared('react');
+      function isFogOfWarEnabled(routeDiscovery, ssr) {
+        return routeDiscovery.mode === "lazy" && ssr === true;
+      }
+      function getPartialManifest({ sri, ...manifest }, router) {
+        let routeIds = new Set(router.state.matches.map((m) => m.route.id));
+        let segments = router.state.location.pathname.split("/").filter(Boolean);
+        let paths = ["/"];
+        segments.pop();
+        while (segments.length > 0) {
+          paths.push(`/${segments.join("/")}`);
+          segments.pop();
+        }
+        paths.forEach((path) => {
+          let matches = matchRoutes(router.routes, path, router.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,
+          sri: sri ? true : void 0
+        };
+      }
+      function useDataRouterContext2() {
+        let context = React8.useContext(DataRouterContext);
+        invariant2(
+          context,
+          "You must render this element inside a <DataRouterContext.Provider> element"
+        );
+        return context;
+      }
+      function useDataRouterStateContext() {
+        let context = React8.useContext(DataRouterStateContext);
+        invariant2(
+          context,
+          "You must render this element inside a <DataRouterStateContext.Provider> element"
+        );
+        return context;
+      }
+      var FrameworkContext = React8.createContext(void 0);
+      FrameworkContext.displayName = "FrameworkContext";
+      function useFrameworkContext() {
+        let context = React8.useContext(FrameworkContext);
+        invariant2(
+          context,
+          "You must render this element inside a <HydratedRouter> element"
+        );
+        return context;
+      }
+      function usePrefetchBehavior(prefetch, theirElementProps) {
+        let frameworkContext = React8.useContext(FrameworkContext);
+        let [maybePrefetch, setMaybePrefetch] = React8.useState(false);
+        let [shouldPrefetch, setShouldPrefetch] = React8.useState(false);
+        let { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
+        let ref = React8.useRef(null);
+        React8.useEffect(() => {
+          if (prefetch === "render") {
+            setShouldPrefetch(true);
+          }
+          if (prefetch === "viewport") {
+            let callback = (entries) => {
+              entries.forEach((entry) => {
+                setShouldPrefetch(entry.isIntersecting);
+              });
+            };
+            let observer = new IntersectionObserver(callback, { threshold: 0.5 });
+            if (ref.current) observer.observe(ref.current);
+            return () => {
+              observer.disconnect();
+            };
+          }
+        }, [prefetch]);
+        React8.useEffect(() => {
+          if (maybePrefetch) {
+            let id = setTimeout(() => {
+              setShouldPrefetch(true);
+            }, 100);
+            return () => {
+              clearTimeout(id);
+            };
+          }
+        }, [maybePrefetch]);
+        let setIntent = () => {
+          setMaybePrefetch(true);
+        };
+        let cancelIntent = () => {
+          setMaybePrefetch(false);
+          setShouldPrefetch(false);
+        };
+        if (!frameworkContext) {
+          return [false, ref, {}];
+        }
+        if (prefetch !== "intent") {
+          return [shouldPrefetch, ref, {}];
+        }
+        return [
+          shouldPrefetch,
+          ref,
+          {
+            onFocus: composeEventHandlers(onFocus, setIntent),
+            onBlur: composeEventHandlers(onBlur, cancelIntent),
+            onMouseEnter: composeEventHandlers(onMouseEnter, setIntent),
+            onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
+            onTouchStart: composeEventHandlers(onTouchStart, setIntent)
+          }
+        ];
+      }
+      function composeEventHandlers(theirHandler, ourHandler) {
+        return (event) => {
+          theirHandler && theirHandler(event);
+          if (!event.defaultPrevented) {
+            ourHandler(event);
+          }
+        };
+      }
+      function getActiveMatches(matches, errors, isSpaMode) {
+        if (isSpaMode && !isHydrated) {
+          return [matches[0]];
+        }
+        return matches;
+      }
+      function PrefetchPageLinks({ page, ...linkProps }) {
+        let { router } = useDataRouterContext2();
+        let matches = React8.useMemo(
+          () => matchRoutes(router.routes, page, router.basename),
+          [router.routes, page, router.basename]
+        );
+        if (!matches) {
+          return null;
+        }
+        return /* @__PURE__ */ React8.createElement(PrefetchPageLinksImpl, { page, matches, ...linkProps });
+      }
+      function useKeyedPrefetchLinks(matches) {
+        let { manifest, routeModules } = useFrameworkContext();
+        let [keyedPrefetchLinks, setKeyedPrefetchLinks] = React8.useState([]);
+        React8.useEffect(() => {
+          let interrupted = false;
+          void getKeyedPrefetchLinks(matches, manifest, routeModules).then(
+            (links) => {
+              if (!interrupted) {
+                setKeyedPrefetchLinks(links);
+              }
+            }
+          );
+          return () => {
+            interrupted = true;
+          };
+        }, [matches, manifest, routeModules]);
+        return keyedPrefetchLinks;
+      }
+      function PrefetchPageLinksImpl({
+        page,
+        matches: nextMatches,
+        ...linkProps
+      }) {
+        let location = useLocation();
+        let { manifest, routeModules } = useFrameworkContext();
+        let { basename } = useDataRouterContext2();
+        let { loaderData, matches } = useDataRouterStateContext();
+        let newMatchesForData = React8.useMemo(
+          () => getNewMatchesForLinks(
+            page,
+            nextMatches,
+            matches,
+            manifest,
+            location,
+            "data"
+          ),
+          [page, nextMatches, matches, manifest, location]
+        );
+        let newMatchesForAssets = React8.useMemo(
+          () => getNewMatchesForLinks(
+            page,
+            nextMatches,
+            matches,
+            manifest,
+            location,
+            "assets"
+          ),
+          [page, nextMatches, matches, manifest, location]
+        );
+        let dataHrefs = React8.useMemo(() => {
+          if (page === location.pathname + location.search + location.hash) {
+            return [];
+          }
+          let routesParams = /* @__PURE__ */ new Set();
+          let foundOptOutRoute = false;
+          nextMatches.forEach((m) => {
+            let manifestRoute = manifest.routes[m.route.id];
+            if (!manifestRoute || !manifestRoute.hasLoader) {
+              return;
+            }
+            if (!newMatchesForData.some((m2) => m2.route.id === m.route.id) && m.route.id in loaderData && routeModules[m.route.id]?.shouldRevalidate) {
+              foundOptOutRoute = true;
+            } else if (manifestRoute.hasClientLoader) {
+              foundOptOutRoute = true;
+            } else {
+              routesParams.add(m.route.id);
+            }
+          });
+          if (routesParams.size === 0) {
+            return [];
+          }
+          let url = singleFetchUrl(page, basename, "data");
+          if (foundOptOutRoute && routesParams.size > 0) {
+            url.searchParams.set(
+              "_routes",
+              nextMatches.filter((m) => routesParams.has(m.route.id)).map((m) => m.route.id).join(",")
+            );
+          }
+          return [url.pathname + url.search];
+        }, [
+          basename,
+          loaderData,
+          location,
+          manifest,
+          newMatchesForData,
+          nextMatches,
+          page,
+          routeModules
+        ]);
+        let moduleHrefs = React8.useMemo(
+          () => getModuleLinkHrefs(newMatchesForAssets, manifest),
+          [newMatchesForAssets, manifest]
+        );
+        let keyedPrefetchLinks = useKeyedPrefetchLinks(newMatchesForAssets);
+        return /* @__PURE__ */ React8.createElement(React8.Fragment, null, dataHrefs.map((href) => /* @__PURE__ */ React8.createElement("link", { key: href, rel: "prefetch", as: "fetch", href, ...linkProps })), moduleHrefs.map((href) => /* @__PURE__ */ React8.createElement("link", { key: href, rel: "modulepreload", href, ...linkProps })), keyedPrefetchLinks.map(({ key, link }) => (
+          // these don't spread `linkProps` because they are full link descriptors
+          // already with their own props
+          /* @__PURE__ */ React8.createElement("link", { key, nonce: linkProps.nonce, ...link })
+        )));
+      }
+      var isHydrated = false;
+      function setIsHydrated() {
+        isHydrated = true;
+      }
+      function Scripts(scriptProps) {
+        let {
+          manifest,
+          serverHandoffString,
+          isSpaMode,
+          renderMeta,
+          routeDiscovery,
+          ssr
+        } = useFrameworkContext();
+        let { router, static: isStatic, staticContext } = useDataRouterContext2();
+        let { matches: routerMatches } = useDataRouterStateContext();
+        let isRSCRouterContext = useIsRSCRouterContext();
+        let enableFogOfWar = isFogOfWarEnabled(routeDiscovery, ssr);
+        if (renderMeta) {
+          renderMeta.didRenderScripts = true;
+        }
+        let matches = getActiveMatches(routerMatches, null, isSpaMode);
+        React8.useEffect(() => {
+          setIsHydrated();
+        }, []);
+        let initialScripts = React8.useMemo(() => {
+          if (isRSCRouterContext) {
+            return null;
+          }
+          let streamScript = "window.__reactRouterContext.stream = new ReadableStream({start(controller){window.__reactRouterContext.streamController = controller;}}).pipeThrough(new TextEncoderStream());";
+          let contextScript = staticContext ? `window.__reactRouterContext = ${serverHandoffString};${streamScript}` : " ";
+          let routeModulesScript = !isStatic ? " " : `${manifest.hmr?.runtime ? `import ${JSON.stringify(manifest.hmr.runtime)};` : ""}${!enableFogOfWar ? `import ${JSON.stringify(manifest.url)}` : ""};
+${matches.map((match, routeIndex) => {
+      let routeVarName = `route${routeIndex}`;
+      let manifestEntry = manifest.routes[match.route.id];
+      invariant2(manifestEntry, `Route ${match.route.id} not found in manifest`);
+      let {
+        clientActionModule,
+        clientLoaderModule,
+        clientMiddlewareModule,
+        hydrateFallbackModule,
+        module
+      } = manifestEntry;
+      let chunks = [
+        ...clientActionModule ? [
+          {
+            module: clientActionModule,
+            varName: `${routeVarName}_clientAction`
+          }
+        ] : [],
+        ...clientLoaderModule ? [
+          {
+            module: clientLoaderModule,
+            varName: `${routeVarName}_clientLoader`
+          }
+        ] : [],
+        ...clientMiddlewareModule ? [
+          {
+            module: clientMiddlewareModule,
+            varName: `${routeVarName}_clientMiddleware`
+          }
+        ] : [],
+        ...hydrateFallbackModule ? [
+          {
+            module: hydrateFallbackModule,
+            varName: `${routeVarName}_HydrateFallback`
+          }
+        ] : [],
+        { module, varName: `${routeVarName}_main` }
+      ];
+      if (chunks.length === 1) {
+        return `import * as ${routeVarName} from ${JSON.stringify(module)};`;
+      }
+      let chunkImportsSnippet = chunks.map((chunk) => `import * as ${chunk.varName} from "${chunk.module}";`).join("\n");
+      let mergedChunksSnippet = `const ${routeVarName} = {${chunks.map((chunk) => `...${chunk.varName}`).join(",")}};`;
+      return [chunkImportsSnippet, mergedChunksSnippet].join("\n");
+    }).join("\n")}
+  ${enableFogOfWar ? (
+      // Inline a minimal manifest with the SSR matches
+      `window.__reactRouterManifest = ${JSON.stringify(
+        getPartialManifest(manifest, router),
+        null,
+        2
+      )};`
+    ) : ""}
+  window.__reactRouterRouteModules = {${matches.map((match, index) => `${JSON.stringify(match.route.id)}:route${index}`).join(",")}};
+
+import(${JSON.stringify(manifest.entry.module)});`;
+          return /* @__PURE__ */ React8.createElement(React8.Fragment, null, /* @__PURE__ */ React8.createElement(
+            "script",
+            {
+              ...scriptProps,
+              suppressHydrationWarning: true,
+              dangerouslySetInnerHTML: { __html: contextScript },
+              type: void 0
+            }
+          ), /* @__PURE__ */ React8.createElement(
+            "script",
+            {
+              ...scriptProps,
+              suppressHydrationWarning: true,
+              dangerouslySetInnerHTML: { __html: routeModulesScript },
+              type: "module",
+              async: true
+            }
+          ));
+        }, []);
+        let preloads = isHydrated || isRSCRouterContext ? [] : dedupe(
+          manifest.entry.imports.concat(
+            getModuleLinkHrefs(matches, manifest, {
+              includeHydrateFallback: true
+            })
+          )
+        );
+        let sri = typeof manifest.sri === "object" ? manifest.sri : {};
+        warnOnce(
+          !isRSCRouterContext,
+          "The <Scripts /> element is a no-op when using RSC and can be safely removed."
+        );
+        return isHydrated || isRSCRouterContext ? null : /* @__PURE__ */ React8.createElement(React8.Fragment, null, typeof manifest.sri === "object" ? /* @__PURE__ */ React8.createElement(
+          "script",
+          {
+            "rr-importmap": "",
+            type: "importmap",
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: JSON.stringify({
+                integrity: sri
+              })
+            }
+          }
+        ) : null, !enableFogOfWar ? /* @__PURE__ */ React8.createElement(
+          "link",
+          {
+            rel: "modulepreload",
+            href: manifest.url,
+            crossOrigin: scriptProps.crossOrigin,
+            integrity: sri[manifest.url],
+            suppressHydrationWarning: true
+          }
+        ) : null, /* @__PURE__ */ React8.createElement(
+          "link",
+          {
+            rel: "modulepreload",
+            href: manifest.entry.module,
+            crossOrigin: scriptProps.crossOrigin,
+            integrity: sri[manifest.entry.module],
+            suppressHydrationWarning: true
+          }
+        ), preloads.map((path) => /* @__PURE__ */ React8.createElement(
+          "link",
+          {
+            key: path,
+            rel: "modulepreload",
+            href: path,
+            crossOrigin: scriptProps.crossOrigin,
+            integrity: sri[path],
+            suppressHydrationWarning: true
+          }
+        )), initialScripts);
+      }
+      function dedupe(array) {
+        return [...new Set(array)];
+      }
+      function mergeRefs(...refs) {
+        return (value) => {
+          refs.forEach((ref) => {
+            if (typeof ref === "function") {
+              ref(value);
+            } else if (ref != null) {
+              ref.current = value;
+            }
+          });
+        };
+      }
+      (class extends React9.Component {
+        constructor(props) {
+          super(props);
+          this.state = { error: props.error || null, location: props.location };
+        }
+        static getDerivedStateFromError(error) {
+          return { error };
+        }
+        static getDerivedStateFromProps(props, state) {
+          if (state.location !== props.location) {
+            return { error: props.error || null, location: props.location };
+          }
+          return { error: props.error || state.error, location: state.location };
+        }
+        render() {
+          if (this.state.error) {
+            return /* @__PURE__ */ React9.createElement(
+              RemixRootDefaultErrorBoundary,
+              {
+                error: this.state.error,
+                isOutsideRemixApp: true
+              }
+            );
+          } else {
+            return this.props.children;
+          }
+        }
+      });
+      function RemixRootDefaultErrorBoundary({
+        error,
+        isOutsideRemixApp
+      }) {
+        console.error(error);
+        let heyDeveloper = /* @__PURE__ */ React9.createElement(
+          "script",
+          {
+            dangerouslySetInnerHTML: {
+              __html: `
+        console.log(
+          "💿 Hey developer 👋. You can provide a way better UX than this when your app throws errors. Check out https://reactrouter.com/how-to/error-boundary for more information."
+        );
+      `
+            }
+          }
+        );
+        if (isRouteErrorResponse(error)) {
+          return /* @__PURE__ */ React9.createElement(BoundaryShell, { title: "Unhandled Thrown Response!" }, /* @__PURE__ */ React9.createElement("h1", { style: { fontSize: "24px" } }, error.status, " ", error.statusText), heyDeveloper );
+        }
+        let errorInstance;
+        if (error instanceof Error) {
+          errorInstance = error;
+        } else {
+          let errorString = error == null ? "Unknown Error" : typeof error === "object" && "toString" in error ? error.toString() : JSON.stringify(error);
+          errorInstance = new Error(errorString);
+        }
+        return /* @__PURE__ */ React9.createElement(
+          BoundaryShell,
+          {
+            title: "Application Error!",
+            isOutsideRemixApp
+          },
+          /* @__PURE__ */ React9.createElement("h1", { style: { fontSize: "24px" } }, "Application Error"),
+          /* @__PURE__ */ React9.createElement(
+            "pre",
+            {
+              style: {
+                padding: "2rem",
+                background: "hsla(10, 50%, 50%, 0.1)",
+                color: "red",
+                overflow: "auto"
+              }
+            },
+            errorInstance.stack
+          ),
+          heyDeveloper
+        );
+      }
+      function BoundaryShell({
+        title,
+        renderScripts,
+        isOutsideRemixApp,
+        children
+      }) {
+        let { routeModules } = useFrameworkContext();
+        if (routeModules.root?.Layout && !isOutsideRemixApp) {
+          return children;
+        }
+        return /* @__PURE__ */ React9.createElement("html", { lang: "en" }, /* @__PURE__ */ React9.createElement("head", null, /* @__PURE__ */ React9.createElement("meta", { charSet: "utf-8" }), /* @__PURE__ */ React9.createElement(
+          "meta",
+          {
+            name: "viewport",
+            content: "width=device-width,initial-scale=1,viewport-fit=cover"
+          }
+        ), /* @__PURE__ */ React9.createElement("title", null, title)), /* @__PURE__ */ React9.createElement("body", null, /* @__PURE__ */ React9.createElement("main", { style: { fontFamily: "system-ui, sans-serif", padding: "2rem" } }, children, renderScripts ? /* @__PURE__ */ React9.createElement(Scripts, null) : null)));
+      }
+      const React10 = await importShared('react');
+
+      var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+      try {
+        if (isBrowser) {
+          window.__reactRouterVersion = // @ts-expect-error
+          "7.9.3";
+        }
+      } catch (e) {
+      }
+      function BrowserRouter({
+        basename,
+        children,
+        window: window2
+      }) {
+        let historyRef = React10.useRef();
+        if (historyRef.current == null) {
+          historyRef.current = createBrowserHistory({ window: window2, v5Compat: true });
+        }
+        let history = historyRef.current;
+        let [state, setStateImpl] = React10.useState({
+          action: history.action,
+          location: history.location
+        });
+        let setState = React10.useCallback(
+          (newState) => {
+            React10.startTransition(() => setStateImpl(newState));
+          },
+          [setStateImpl]
+        );
+        React10.useLayoutEffect(() => history.listen(setState), [history, setState]);
+        return /* @__PURE__ */ React10.createElement(
+          Router,
+          {
+            basename,
+            children,
+            location: state.location,
+            navigationType: state.action,
+            navigator: history
+          }
+        );
+      }
+      var ABSOLUTE_URL_REGEX2 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+      var Link = React10.forwardRef(
+        function LinkWithRef({
+          onClick,
+          discover = "render",
+          prefetch = "none",
+          relative,
+          reloadDocument,
+          replace: replace2,
+          state,
+          target,
+          to,
+          preventScrollReset,
+          viewTransition,
+          ...rest
+        }, forwardedRef) {
+          let { basename } = React10.useContext(NavigationContext);
+          let isAbsolute = typeof to === "string" && ABSOLUTE_URL_REGEX2.test(to);
+          let absoluteHref;
+          let isExternal = false;
+          if (typeof to === "string" && isAbsolute) {
+            absoluteHref = to;
+            if (isBrowser) {
+              try {
+                let currentUrl = new URL(window.location.href);
+                let targetUrl = to.startsWith("//") ? new URL(currentUrl.protocol + to) : new URL(to);
+                let path = stripBasename(targetUrl.pathname, basename);
+                if (targetUrl.origin === currentUrl.origin && path != null) {
+                  to = path + targetUrl.search + targetUrl.hash;
+                } else {
+                  isExternal = true;
+                }
+              } catch (e) {
+                warning(
+                  false,
+                  `<Link to="${to}"> contains an invalid URL which will probably break when clicked - please update to a valid URL path.`
+                );
+              }
+            }
+          }
+          let href = useHref(to, { relative });
+          let [shouldPrefetch, prefetchRef, prefetchHandlers] = usePrefetchBehavior(
+            prefetch,
+            rest
+          );
+          let internalOnClick = useLinkClickHandler(to, {
+            replace: replace2,
+            state,
+            target,
+            preventScrollReset,
+            relative,
+            viewTransition
+          });
+          function handleClick(event) {
+            if (onClick) onClick(event);
+            if (!event.defaultPrevented) {
+              internalOnClick(event);
+            }
+          }
+          let link = (
+            // eslint-disable-next-line jsx-a11y/anchor-has-content
+            /* @__PURE__ */ React10.createElement(
+              "a",
+              {
+                ...rest,
+                ...prefetchHandlers,
+                href: absoluteHref || href,
+                onClick: isExternal || reloadDocument ? onClick : handleClick,
+                ref: mergeRefs(forwardedRef, prefetchRef),
+                target,
+                "data-discover": !isAbsolute && discover === "render" ? "true" : void 0
+              }
+            )
+          );
+          return shouldPrefetch && !isAbsolute ? /* @__PURE__ */ React10.createElement(React10.Fragment, null, link, /* @__PURE__ */ React10.createElement(PrefetchPageLinks, { page: href })) : link;
+        }
+      );
+      Link.displayName = "Link";
+      var NavLink = React10.forwardRef(
+        function NavLinkWithRef({
+          "aria-current": ariaCurrentProp = "page",
+          caseSensitive = false,
+          className: classNameProp = "",
+          end = false,
+          style: styleProp,
+          to,
+          viewTransition,
+          children,
+          ...rest
+        }, ref) {
+          let path = useResolvedPath(to, { relative: rest.relative });
+          let location = useLocation();
+          let routerState = React10.useContext(DataRouterStateContext);
+          let { navigator, basename } = React10.useContext(NavigationContext);
+          let isTransitioning = routerState != null && // Conditional usage is OK here because the usage of a data router is static
+          // eslint-disable-next-line react-hooks/rules-of-hooks
+          useViewTransitionState(path) && viewTransition === true;
+          let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;
+          let locationPathname = location.pathname;
+          let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;
+          if (!caseSensitive) {
+            locationPathname = locationPathname.toLowerCase();
+            nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;
+            toPathname = toPathname.toLowerCase();
+          }
+          if (nextLocationPathname && basename) {
+            nextLocationPathname = stripBasename(nextLocationPathname, basename) || nextLocationPathname;
+          }
+          const endSlashPosition = toPathname !== "/" && toPathname.endsWith("/") ? toPathname.length - 1 : toPathname.length;
+          let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(endSlashPosition) === "/";
+          let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === "/");
+          let renderProps = {
+            isActive,
+            isPending,
+            isTransitioning
+          };
+          let ariaCurrent = isActive ? ariaCurrentProp : void 0;
+          let className;
+          if (typeof classNameProp === "function") {
+            className = classNameProp(renderProps);
+          } else {
+            className = [
+              classNameProp,
+              isActive ? "active" : null,
+              isPending ? "pending" : null,
+              isTransitioning ? "transitioning" : null
+            ].filter(Boolean).join(" ");
+          }
+          let style = typeof styleProp === "function" ? styleProp(renderProps) : styleProp;
+          return /* @__PURE__ */ React10.createElement(
+            Link,
+            {
+              ...rest,
+              "aria-current": ariaCurrent,
+              className,
+              ref,
+              style,
+              to,
+              viewTransition
+            },
+            typeof children === "function" ? children(renderProps) : children
+          );
+        }
+      );
+      NavLink.displayName = "NavLink";
+      var Form = React10.forwardRef(
+        ({
+          discover = "render",
+          fetcherKey,
+          navigate,
+          reloadDocument,
+          replace: replace2,
+          state,
+          method = defaultMethod,
+          action,
+          onSubmit,
+          relative,
+          preventScrollReset,
+          viewTransition,
+          ...props
+        }, forwardedRef) => {
+          let submit = useSubmit();
+          let formAction = useFormAction(action, { relative });
+          let formMethod = method.toLowerCase() === "get" ? "get" : "post";
+          let isAbsolute = typeof action === "string" && ABSOLUTE_URL_REGEX2.test(action);
+          let submitHandler = (event) => {
+            onSubmit && onSubmit(event);
+            if (event.defaultPrevented) return;
+            event.preventDefault();
+            let submitter = event.nativeEvent.submitter;
+            let submitMethod = submitter?.getAttribute("formmethod") || method;
+            submit(submitter || event.currentTarget, {
+              fetcherKey,
+              method: submitMethod,
+              navigate,
+              replace: replace2,
+              state,
+              relative,
+              preventScrollReset,
+              viewTransition
+            });
+          };
+          return /* @__PURE__ */ React10.createElement(
+            "form",
+            {
+              ref: forwardedRef,
+              method: formMethod,
+              action: formAction,
+              onSubmit: reloadDocument ? onSubmit : submitHandler,
+              ...props,
+              "data-discover": !isAbsolute && discover === "render" ? "true" : void 0
+            }
+          );
+        }
+      );
+      Form.displayName = "Form";
+      function getDataRouterConsoleError2(hookName) {
+        return `${hookName} must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.`;
+      }
+      function useDataRouterContext3(hookName) {
+        let ctx = React10.useContext(DataRouterContext);
+        invariant(ctx, getDataRouterConsoleError2(hookName));
+        return ctx;
+      }
+      function useLinkClickHandler(to, {
+        target,
+        replace: replaceProp,
+        state,
+        preventScrollReset,
+        relative,
+        viewTransition
+      } = {}) {
+        let navigate = useNavigate();
+        let location = useLocation();
+        let path = useResolvedPath(to, { relative });
+        return React10.useCallback(
+          (event) => {
+            if (shouldProcessLinkClick(event, target)) {
+              event.preventDefault();
+              let replace2 = replaceProp !== void 0 ? replaceProp : createPath(location) === createPath(path);
+              navigate(to, {
+                replace: replace2,
+                state,
+                preventScrollReset,
+                relative,
+                viewTransition
+              });
+            }
+          },
+          [
+            location,
+            navigate,
+            path,
+            replaceProp,
+            state,
+            target,
+            to,
+            preventScrollReset,
+            relative,
+            viewTransition
+          ]
+        );
+      }
+      var fetcherId = 0;
+      var getUniqueFetcherId = () => `__${String(++fetcherId)}__`;
+      function useSubmit() {
+        let { router } = useDataRouterContext3(
+          "useSubmit"
+          /* UseSubmit */
+        );
+        let { basename } = React10.useContext(NavigationContext);
+        let currentRouteId = useRouteId();
+        return React10.useCallback(
+          async (target, options = {}) => {
+            let { action, method, encType, formData, body } = getFormSubmissionInfo(
+              target,
+              basename
+            );
+            if (options.navigate === false) {
+              let key = options.fetcherKey || getUniqueFetcherId();
+              await router.fetch(key, currentRouteId, options.action || action, {
+                preventScrollReset: options.preventScrollReset,
+                formData,
+                body,
+                formMethod: options.method || method,
+                formEncType: options.encType || encType,
+                flushSync: options.flushSync
+              });
+            } else {
+              await router.navigate(options.action || action, {
+                preventScrollReset: options.preventScrollReset,
+                formData,
+                body,
+                formMethod: options.method || method,
+                formEncType: options.encType || encType,
+                replace: options.replace,
+                state: options.state,
+                fromRouteId: currentRouteId,
+                flushSync: options.flushSync,
+                viewTransition: options.viewTransition
+              });
+            }
+          },
+          [router, basename, currentRouteId]
+        );
+      }
+      function useFormAction(action, { relative } = {}) {
+        let { basename } = React10.useContext(NavigationContext);
+        let routeContext = React10.useContext(RouteContext);
+        invariant(routeContext, "useFormAction must be used inside a RouteContext");
+        let [match] = routeContext.matches.slice(-1);
+        let path = { ...useResolvedPath(action ? action : ".", { relative }) };
+        let location = useLocation();
+        if (action == null) {
+          path.search = location.search;
+          let params = new URLSearchParams(path.search);
+          let indexValues = params.getAll("index");
+          let hasNakedIndexParam = indexValues.some((v) => v === "");
+          if (hasNakedIndexParam) {
+            params.delete("index");
+            indexValues.filter((v) => v).forEach((v) => params.append("index", v));
+            let qs = params.toString();
+            path.search = qs ? `?${qs}` : "";
+          }
+        }
+        if ((!action || action === ".") && match.route.index) {
+          path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
+        }
+        if (basename !== "/") {
+          path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+        }
+        return createPath(path);
+      }
+      function useViewTransitionState(to, { relative } = {}) {
+        let vtContext = React10.useContext(ViewTransitionContext);
+        invariant(
+          vtContext != null,
+          "`useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`.  Did you accidentally import `RouterProvider` from `react-router`?"
+        );
+        let { basename } = useDataRouterContext3(
+          "useViewTransitionState"
+          /* useViewTransitionState */
+        );
+        let path = useResolvedPath(to, { relative });
+        if (!vtContext.isTransitioning) {
+          return false;
+        }
+        let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname;
+        let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname;
+        return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;
+      }
+      await importShared('react');
+
+      const scriptRel = 'modulepreload';const assetsURL = function(dep) { return "/"+dep };const seen = {};const __vitePreload = function preload(baseModule, deps, importerUrl) {
+        let promise = Promise.resolve();
+        if (false              && deps && deps.length > 0) {
+          let allSettled2 = function(promises) {
+            return Promise.all(
+              promises.map(
+                (p) => Promise.resolve(p).then(
+                  (value) => ({ status: "fulfilled", value }),
+                  (reason) => ({ status: "rejected", reason })
+                )
+              )
+            );
+          };
+          document.getElementsByTagName("link");
+          const cspNonceMeta = document.querySelector(
+            "meta[property=csp-nonce]"
+          );
+          const cspNonce = cspNonceMeta?.nonce || cspNonceMeta?.getAttribute("nonce");
+          promise = allSettled2(
+            deps.map((dep) => {
+              dep = assetsURL(dep);
+              if (dep in seen) return;
+              seen[dep] = true;
+              const isCss = dep.endsWith(".css");
+              const cssSelector = isCss ? '[rel="stylesheet"]' : "";
+              if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) {
+                return;
+              }
+              const link = document.createElement("link");
+              link.rel = isCss ? "stylesheet" : scriptRel;
+              if (!isCss) {
+                link.as = "script";
+              }
+              link.crossOrigin = "";
+              link.href = dep;
+              if (cspNonce) {
+                link.setAttribute("nonce", cspNonce);
+              }
+              document.head.appendChild(link);
+              if (isCss) {
+                return new Promise((res, rej) => {
+                  link.addEventListener("load", res);
+                  link.addEventListener(
+                    "error",
+                    () => rej(new Error(`Unable to preload CSS for ${dep}`))
+                  );
+                });
+              }
+            })
+          );
+        }
+        function handlePreloadError(err) {
+          const e = new Event("vite:preloadError", {
+            cancelable: true
+          });
+          e.payload = err;
+          window.dispatchEvent(e);
+          if (!e.defaultPrevented) {
+            throw err;
+          }
+        }
+        return promise.then((res) => {
+          for (const item of res || []) {
+            if (item.status !== "rejected") continue;
+            handlePreloadError(item.reason);
+          }
+          return baseModule().catch(handlePreloadError);
+        });
+      };
+
+      const {lazy} = await importShared('react');
+      const Home = lazy(() => __vitePreload(() => module.import('./home-BBY02MnI.js'),false             ?__VITE_PRELOAD__:void 0));
+      function RouteConfig() {
+        return /* @__PURE__ */ jsxRuntimeExports.jsxs(Routes, { children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(Route, { path: "/", element: /* @__PURE__ */ jsxRuntimeExports.jsx(Home, {}) }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(Route, { path: "*", element: /* @__PURE__ */ jsxRuntimeExports.jsx(Navigate, { to: "/", replace: true }) })
+        ] });
+      }
+
+      const {Suspense,useEffect,useState} = await importShared('react');
+      const { QueryClient, QueryClientProvider } = FR;
+      function App(props) {
+        const [queryClient] = useState(() => new QueryClient({
+          defaultOptions: {
+            queries: {
+              staleTime: 60 * 1e3,
+              // 1 minute
+              refetchOnWindowFocus: false
+            }
+          }
+        }));
+        useEffect(() => {
+          let copaUser = {};
+          try {
+            const copaToken = undefined                                        ? atob(undefined                                       ) : "{}";
+            copaUser = JSON.parse(copaToken);
+          } catch (error) {
+            console.warn("Failed to parse VITE_BLUECOPA_API_TOKEN:", error);
+          }
+          s1({
+            apiBaseUrl: props.apiBaseUrl || undefined                                      || "https://develop.bluecopa.com",
+            workspaceId: props.workspaceId || undefined                                           || "",
+            accessToken: props.accessToken || copaUser?.accessToken || "",
+            userId: props.userId || ""
+          });
+        }, []);
+        return /* @__PURE__ */ jsxRuntimeExports.jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsxRuntimeExports.jsxs(Suspense, { fallback: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "p-4 text-sm text-muted-foreground", children: "Loading…" }), children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(RouteConfig, {}),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(PA, { initialIsOpen: false })
+        ] }) });
+      }
+
+      var client = {};
+
+      var hasRequiredClient;
+
+      function requireClient () {
+      	if (hasRequiredClient) return client;
+      	hasRequiredClient = 1;
+      	var m = requireReactDom();
+      	{
+      	  client.createRoot = m.createRoot;
+      	  client.hydrateRoot = m.hydrateRoot;
+      	}
+      	return client;
+      }
+
+      var clientExports = exports("c", requireClient());
+      const ReactDOM = exports("R", /*@__PURE__*/getDefaultExportFromCjs(clientExports));
+
+    })
+  };
+}));