@mcp-use/inspector 0.9.0-canary.4 → 0.9.0-canary.6

package/dist/client/assets/index-DctLeaKS.js

@@ -1,2817 +0,0 @@
-import { c as createServerRoutes, s as shouldHydrateRouteLoader, b as createStaticRouter, r as reactExports, F as FrameworkContext, R as RemixErrorBoundary, S as StaticRouterProvider, d as StreamTransfer, u as useRouteError, e as re, E as ErrorResponseImpl, m as matchRoutes, f as RouterContextProvider, g as convertRoutesToDataRoutes, h as createMemoryRouter, i as RouterProvider, j as RSCRouterContext, k as SINGLE_FETCH_REDIRECT_STATUS, l as isRouteErrorResponse, w as warnOnce, n as createStaticHandler, o as instrumentHandler, q as withErrorBoundaryProps, t as withHydrateFallbackProps, v as withComponentProps, O as Outlet, x as React, y as decodeViaTurboStream, z as SingleFetchRedirectSymbol, A as redirectDocument, B as replace, C as redirect, D as stripBasename, G as getManifestPath, H as isRedirectResponse, I as isDataWithResponseInit, J as isRedirectStatusCode, K as isResponse, L as getStaticContextFromError, N as NO_BODY_STATUS_CODES, M as encode, P as escapeHtml, Q as invariant$1, T as useFogOFWarDiscovery, U as reactDomExports, V as createClientRoutes, W as createRouter, X as getPatchRoutesOnNavigationFunction, Y as getTurboStreamSingleFetchDataStrategy, Z as mapRouteProperties, $ as hydrationRouteProperties, a0 as createBrowserHistory, a1 as createClientRoutesWithHMRRevalidationOptOut } from "./index-DEA0KU_h.js";
-import { a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at, au, av, aw, ax, ay, az, aA, aB, aC, aD, aE, aF, aG, aH, aI, aJ, aK, aL, aM, aN, aO, aP, aQ, aR, aS, aT, aU, aV, aW, aX, aY, aZ, a_, a$, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf } from "./index-DEA0KU_h.js";
-var dist = {};
-var hasRequiredDist;
-function requireDist() {
-  if (hasRequiredDist) return dist;
-  hasRequiredDist = 1;
-  Object.defineProperty(dist, "__esModule", { value: true });
-  dist.parse = parse;
-  dist.serialize = serialize;
-  const cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
-  const cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
-  const domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
-  const pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
-  const __toString = Object.prototype.toString;
-  const NullObject = /* @__PURE__ */ (() => {
-    const C = function() {
-    };
-    C.prototype = /* @__PURE__ */ Object.create(null);
-    return C;
-  })();
-  function parse(str, options) {
-    const obj = new NullObject();
-    const len = str.length;
-    if (len < 2)
-      return obj;
-    const dec = options?.decode || decode;
-    let index = 0;
-    do {
-      const eqIdx = str.indexOf("=", index);
-      if (eqIdx === -1)
-        break;
-      const colonIdx = str.indexOf(";", index);
-      const endIdx = colonIdx === -1 ? len : colonIdx;
-      if (eqIdx > endIdx) {
-        index = str.lastIndexOf(";", eqIdx - 1) + 1;
-        continue;
-      }
-      const keyStartIdx = startIndex(str, index, eqIdx);
-      const keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
-      const key = str.slice(keyStartIdx, keyEndIdx);
-      if (obj[key] === void 0) {
-        let valStartIdx = startIndex(str, eqIdx + 1, endIdx);
-        let valEndIdx = endIndex(str, endIdx, valStartIdx);
-        const value = dec(str.slice(valStartIdx, valEndIdx));
-        obj[key] = value;
-      }
-      index = endIdx + 1;
-    } while (index < len);
-    return obj;
-  }
-  function startIndex(str, index, max) {
-    do {
-      const code = str.charCodeAt(index);
-      if (code !== 32 && code !== 9)
-        return index;
-    } while (++index < max);
-    return max;
-  }
-  function endIndex(str, index, min) {
-    while (index > min) {
-      const code = str.charCodeAt(--index);
-      if (code !== 32 && code !== 9)
-        return index + 1;
-    }
-    return min;
-  }
-  function serialize(name, val, options) {
-    const enc = options?.encode || encodeURIComponent;
-    if (!cookieNameRegExp.test(name)) {
-      throw new TypeError(`argument name is invalid: ${name}`);
-    }
-    const value = enc(val);
-    if (!cookieValueRegExp.test(value)) {
-      throw new TypeError(`argument val is invalid: ${val}`);
-    }
-    let str = name + "=" + value;
-    if (!options)
-      return str;
-    if (options.maxAge !== void 0) {
-      if (!Number.isInteger(options.maxAge)) {
-        throw new TypeError(`option maxAge is invalid: ${options.maxAge}`);
-      }
-      str += "; Max-Age=" + options.maxAge;
-    }
-    if (options.domain) {
-      if (!domainValueRegExp.test(options.domain)) {
-        throw new TypeError(`option domain is invalid: ${options.domain}`);
-      }
-      str += "; Domain=" + options.domain;
-    }
-    if (options.path) {
-      if (!pathValueRegExp.test(options.path)) {
-        throw new TypeError(`option path is invalid: ${options.path}`);
-      }
-      str += "; Path=" + options.path;
-    }
-    if (options.expires) {
-      if (!isDate(options.expires) || !Number.isFinite(options.expires.valueOf())) {
-        throw new TypeError(`option expires is invalid: ${options.expires}`);
-      }
-      str += "; Expires=" + options.expires.toUTCString();
-    }
-    if (options.httpOnly) {
-      str += "; HttpOnly";
-    }
-    if (options.secure) {
-      str += "; Secure";
-    }
-    if (options.partitioned) {
-      str += "; Partitioned";
-    }
-    if (options.priority) {
-      const priority = typeof options.priority === "string" ? options.priority.toLowerCase() : void 0;
-      switch (priority) {
-        case "low":
-          str += "; Priority=Low";
-          break;
-        case "medium":
-          str += "; Priority=Medium";
-          break;
-        case "high":
-          str += "; Priority=High";
-          break;
-        default:
-          throw new TypeError(`option priority is invalid: ${options.priority}`);
-      }
-    }
-    if (options.sameSite) {
-      const sameSite = typeof options.sameSite === "string" ? options.sameSite.toLowerCase() : options.sameSite;
-      switch (sameSite) {
-        case true:
-        case "strict":
-          str += "; SameSite=Strict";
-          break;
-        case "lax":
-          str += "; SameSite=Lax";
-          break;
-        case "none":
-          str += "; SameSite=None";
-          break;
-        default:
-          throw new TypeError(`option sameSite is invalid: ${options.sameSite}`);
-      }
-    }
-    return str;
-  }
-  function decode(str) {
-    if (str.indexOf("%") === -1)
-      return str;
-    try {
-      return decodeURIComponent(str);
-    } catch (e) {
-      return str;
-    }
-  }
-  function isDate(val) {
-    return __toString.call(val) === "[object Date]";
-  }
-  return dist;
-}
-var distExports = requireDist();
-var setCookie = { exports: {} };
-var hasRequiredSetCookie;
-function requireSetCookie() {
-  if (hasRequiredSetCookie) return setCookie.exports;
-  hasRequiredSetCookie = 1;
-  var defaultParseOptions = {
-    decodeValues: true,
-    map: false,
-    silent: false
-  };
-  function isForbiddenKey(key) {
-    return typeof key !== "string" || key in {};
-  }
-  function createNullObj() {
-    return /* @__PURE__ */ Object.create(null);
-  }
-  function isNonEmptyString(str) {
-    return typeof str === "string" && !!str.trim();
-  }
-  function parseString(setCookieValue, options) {
-    var parts = setCookieValue.split(";").filter(isNonEmptyString);
-    var nameValuePairStr = parts.shift();
-    var parsed = parseNameValuePair(nameValuePairStr);
-    var name = parsed.name;
-    var value = parsed.value;
-    options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-    if (isForbiddenKey(name)) {
-      return null;
-    }
-    try {
-      value = options.decodeValues ? decodeURIComponent(value) : value;
-    } catch (e) {
-      console.error(
-        "set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.",
-        e
-      );
-    }
-    var cookie = createNullObj();
-    cookie.name = name;
-    cookie.value = value;
-    parts.forEach(function(part) {
-      var sides = part.split("=");
-      var key = sides.shift().trimLeft().toLowerCase();
-      if (isForbiddenKey(key)) {
-        return;
-      }
-      var value2 = sides.join("=");
-      if (key === "expires") {
-        cookie.expires = new Date(value2);
-      } else if (key === "max-age") {
-        var n = parseInt(value2, 10);
-        if (!Number.isNaN(n)) cookie.maxAge = n;
-      } else if (key === "secure") {
-        cookie.secure = true;
-      } else if (key === "httponly") {
-        cookie.httpOnly = true;
-      } else if (key === "samesite") {
-        cookie.sameSite = value2;
-      } else if (key === "partitioned") {
-        cookie.partitioned = true;
-      } else if (key) {
-        cookie[key] = value2;
-      }
-    });
-    return cookie;
-  }
-  function parseNameValuePair(nameValuePairStr) {
-    var name = "";
-    var value = "";
-    var nameValueArr = nameValuePairStr.split("=");
-    if (nameValueArr.length > 1) {
-      name = nameValueArr.shift();
-      value = nameValueArr.join("=");
-    } else {
-      value = nameValuePairStr;
-    }
-    return { name, value };
-  }
-  function parse(input, options) {
-    options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-    if (!input) {
-      if (!options.map) {
-        return [];
-      } else {
-        return createNullObj();
-      }
-    }
-    if (input.headers) {
-      if (typeof input.headers.getSetCookie === "function") {
-        input = input.headers.getSetCookie();
-      } else if (input.headers["set-cookie"]) {
-        input = input.headers["set-cookie"];
-      } else {
-        var sch = input.headers[Object.keys(input.headers).find(function(key) {
-          return key.toLowerCase() === "set-cookie";
-        })];
-        if (!sch && input.headers.cookie && !options.silent) {
-          console.warn(
-            "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
-          );
-        }
-        input = sch;
-      }
-    }
-    if (!Array.isArray(input)) {
-      input = [input];
-    }
-    if (!options.map) {
-      return input.filter(isNonEmptyString).map(function(str) {
-        return parseString(str, options);
-      }).filter(Boolean);
-    } else {
-      var cookies = createNullObj();
-      return input.filter(isNonEmptyString).reduce(function(cookies2, str) {
-        var cookie = parseString(str, options);
-        if (cookie && !isForbiddenKey(cookie.name)) {
-          cookies2[cookie.name] = cookie;
-        }
-        return cookies2;
-      }, cookies);
-    }
-  }
-  function splitCookiesString(cookiesString) {
-    if (Array.isArray(cookiesString)) {
-      return cookiesString;
-    }
-    if (typeof cookiesString !== "string") {
-      return [];
-    }
-    var cookiesStrings = [];
-    var pos = 0;
-    var start;
-    var ch;
-    var lastComma;
-    var nextStart;
-    var cookiesSeparatorFound;
-    function skipWhitespace() {
-      while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
-        pos += 1;
-      }
-      return pos < cookiesString.length;
-    }
-    function notSpecialChar() {
-      ch = cookiesString.charAt(pos);
-      return ch !== "=" && ch !== ";" && ch !== ",";
-    }
-    while (pos < cookiesString.length) {
-      start = pos;
-      cookiesSeparatorFound = false;
-      while (skipWhitespace()) {
-        ch = cookiesString.charAt(pos);
-        if (ch === ",") {
-          lastComma = pos;
-          pos += 1;
-          skipWhitespace();
-          nextStart = pos;
-          while (pos < cookiesString.length && notSpecialChar()) {
-            pos += 1;
-          }
-          if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
-            cookiesSeparatorFound = true;
-            pos = nextStart;
-            cookiesStrings.push(cookiesString.substring(start, lastComma));
-            start = pos;
-          } else {
-            pos = lastComma + 1;
-          }
-        } else {
-          pos += 1;
-        }
-      }
-      if (!cookiesSeparatorFound || pos >= cookiesString.length) {
-        cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
-      }
-    }
-    return cookiesStrings;
-  }
-  setCookie.exports = parse;
-  setCookie.exports.parse = parse;
-  setCookie.exports.parseString = parseString;
-  setCookie.exports.splitCookiesString = splitCookiesString;
-  return setCookie.exports;
-}
-var setCookieExports = /* @__PURE__ */ requireSetCookie();
-var define_process_env_default = {};
-function ServerRouter({
-  context,
-  url,
-  nonce
-}) {
-  if (typeof url === "string") {
-    url = new URL(url);
-  }
-  let { manifest, routeModules, criticalCss, serverHandoffString } = context;
-  let routes = createServerRoutes(
-    manifest.routes,
-    routeModules,
-    context.future,
-    context.isSpaMode
-  );
-  context.staticHandlerContext.loaderData = {
-    ...context.staticHandlerContext.loaderData
-  };
-  for (let match of context.staticHandlerContext.matches) {
-    let routeId = match.route.id;
-    let route = routeModules[routeId];
-    let manifestRoute = context.manifest.routes[routeId];
-    if (route && manifestRoute && shouldHydrateRouteLoader(
-      routeId,
-      route.clientLoader,
-      manifestRoute.hasLoader,
-      context.isSpaMode
-    ) && (route.HydrateFallback || !manifestRoute.hasLoader)) {
-      delete context.staticHandlerContext.loaderData[routeId];
-    }
-  }
-  let router2 = createStaticRouter(routes, context.staticHandlerContext);
-  return /* @__PURE__ */ reactExports.createElement(reactExports.Fragment, null, /* @__PURE__ */ reactExports.createElement(
-    FrameworkContext.Provider,
-    {
-      value: {
-        manifest,
-        routeModules,
-        criticalCss,
-        serverHandoffString,
-        future: context.future,
-        ssr: context.ssr,
-        isSpaMode: context.isSpaMode,
-        routeDiscovery: context.routeDiscovery,
-        serializeError: context.serializeError,
-        renderMeta: context.renderMeta
-      }
-    },
-    /* @__PURE__ */ reactExports.createElement(RemixErrorBoundary, { location: router2.state.location }, /* @__PURE__ */ reactExports.createElement(
-      StaticRouterProvider,
-      {
-        router: router2,
-        context: context.staticHandlerContext,
-        hydrate: false
-      }
-    ))
-  ), context.serverHandoffStream ? /* @__PURE__ */ reactExports.createElement(reactExports.Suspense, null, /* @__PURE__ */ reactExports.createElement(
-    StreamTransfer,
-    {
-      context,
-      identifier: 0,
-      reader: context.serverHandoffStream.getReader(),
-      textDecoder: new TextDecoder(),
-      nonce
-    }
-  )) : null);
-}
-function createRoutesStub(routes, _context) {
-  return function RoutesTestStub({
-    initialEntries,
-    initialIndex,
-    hydrationData,
-    future
-  }) {
-    let routerRef = reactExports.useRef();
-    let frameworkContextRef = reactExports.useRef();
-    if (routerRef.current == null) {
-      frameworkContextRef.current = {
-        future: {
-          unstable_subResourceIntegrity: future?.unstable_subResourceIntegrity === true,
-          v8_middleware: future?.v8_middleware === true
-        },
-        manifest: {
-          routes: {},
-          entry: { imports: [], module: "" },
-          url: "",
-          version: ""
-        },
-        routeModules: {},
-        ssr: false,
-        isSpaMode: false,
-        routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" }
-      };
-      let patched = processRoutes(
-        // @ts-expect-error `StubRouteObject` is stricter about `loader`/`action`
-        // types compared to `AgnosticRouteObject`
-        convertRoutesToDataRoutes(routes, (r) => r),
-        _context !== void 0 ? _context : future?.v8_middleware ? new RouterContextProvider() : {},
-        frameworkContextRef.current.manifest,
-        frameworkContextRef.current.routeModules
-      );
-      routerRef.current = createMemoryRouter(patched, {
-        initialEntries,
-        initialIndex,
-        hydrationData
-      });
-    }
-    return /* @__PURE__ */ reactExports.createElement(FrameworkContext.Provider, { value: frameworkContextRef.current }, /* @__PURE__ */ reactExports.createElement(RouterProvider, { router: routerRef.current }));
-  };
-}
-function processRoutes(routes, context, manifest, routeModules, parentId) {
-  return routes.map((route) => {
-    if (!route.id) {
-      throw new Error(
-        "Expected a route.id in react-router processRoutes() function"
-      );
-    }
-    let newRoute = {
-      id: route.id,
-      path: route.path,
-      index: route.index,
-      Component: route.Component ? withComponentProps(route.Component) : void 0,
-      HydrateFallback: route.HydrateFallback ? withHydrateFallbackProps(route.HydrateFallback) : void 0,
-      ErrorBoundary: route.ErrorBoundary ? withErrorBoundaryProps(route.ErrorBoundary) : void 0,
-      action: route.action ? (args) => route.action({ ...args, context }) : void 0,
-      loader: route.loader ? (args) => route.loader({ ...args, context }) : void 0,
-      middleware: route.middleware ? route.middleware.map(
-        (mw) => (...args) => mw(
-          { ...args[0], context },
-          args[1]
-        )
-      ) : void 0,
-      handle: route.handle,
-      shouldRevalidate: route.shouldRevalidate
-    };
-    let entryRoute = {
-      id: route.id,
-      path: route.path,
-      index: route.index,
-      parentId,
-      hasAction: route.action != null,
-      hasLoader: route.loader != null,
-      // When testing routes, you should be stubbing loader/action/middleware,
-      // not trying to re-implement the full loader/clientLoader/SSR/hydration
-      // flow. That is better tested via E2E tests.
-      hasClientAction: false,
-      hasClientLoader: false,
-      hasClientMiddleware: false,
-      hasErrorBoundary: route.ErrorBoundary != null,
-      // any need for these?
-      module: "build/stub-path-to-module.js",
-      clientActionModule: void 0,
-      clientLoaderModule: void 0,
-      clientMiddlewareModule: void 0,
-      hydrateFallbackModule: void 0
-    };
-    manifest.routes[newRoute.id] = entryRoute;
-    routeModules[route.id] = {
-      default: newRoute.Component || Outlet,
-      ErrorBoundary: newRoute.ErrorBoundary || void 0,
-      handle: route.handle,
-      links: route.links,
-      meta: route.meta,
-      shouldRevalidate: route.shouldRevalidate
-    };
-    if (route.children) {
-      newRoute.children = processRoutes(
-        route.children,
-        context,
-        manifest,
-        routeModules,
-        newRoute.id
-      );
-    }
-    return newRoute;
-  });
-}
-var encoder = /* @__PURE__ */ new TextEncoder();
-var sign = async (value, secret) => {
-  let data2 = encoder.encode(value);
-  let key = await createKey(secret, ["sign"]);
-  let signature = await crypto.subtle.sign("HMAC", key, data2);
-  let hash = btoa(String.fromCharCode(...new Uint8Array(signature))).replace(
-    /=+$/,
-    ""
-  );
-  return value + "." + hash;
-};
-var unsign = async (cookie, secret) => {
-  let index = cookie.lastIndexOf(".");
-  let value = cookie.slice(0, index);
-  let hash = cookie.slice(index + 1);
-  let data2 = encoder.encode(value);
-  let key = await createKey(secret, ["verify"]);
-  try {
-    let signature = byteStringToUint8Array(atob(hash));
-    let valid = await crypto.subtle.verify("HMAC", key, signature, data2);
-    return valid ? value : false;
-  } catch (error) {
-    return false;
-  }
-};
-var createKey = async (secret, usages) => crypto.subtle.importKey(
-  "raw",
-  encoder.encode(secret),
-  { name: "HMAC", hash: "SHA-256" },
-  false,
-  usages
-);
-function byteStringToUint8Array(byteString) {
-  let array = new Uint8Array(byteString.length);
-  for (let i = 0; i < byteString.length; i++) {
-    array[i] = byteString.charCodeAt(i);
-  }
-  return array;
-}
-var createCookie = (name, cookieOptions = {}) => {
-  let { secrets = [], ...options } = {
-    path: "/",
-    sameSite: "lax",
-    ...cookieOptions
-  };
-  warnOnceAboutExpiresCookie(name, options.expires);
-  return {
-    get name() {
-      return name;
-    },
-    get isSigned() {
-      return secrets.length > 0;
-    },
-    get expires() {
-      return typeof options.maxAge !== "undefined" ? new Date(Date.now() + options.maxAge * 1e3) : options.expires;
-    },
-    async parse(cookieHeader, parseOptions) {
-      if (!cookieHeader) return null;
-      let cookies = distExports.parse(cookieHeader, { ...options, ...parseOptions });
-      if (name in cookies) {
-        let value = cookies[name];
-        if (typeof value === "string" && value !== "") {
-          let decoded = await decodeCookieValue(value, secrets);
-          return decoded;
-        } else {
-          return "";
-        }
-      } else {
-        return null;
-      }
-    },
-    async serialize(value, serializeOptions) {
-      return distExports.serialize(
-        name,
-        value === "" ? "" : await encodeCookieValue(value, secrets),
-        {
-          ...options,
-          ...serializeOptions
-        }
-      );
-    }
-  };
-};
-var isCookie = (object) => {
-  return object != null && typeof object.name === "string" && typeof object.isSigned === "boolean" && typeof object.parse === "function" && typeof object.serialize === "function";
-};
-async function encodeCookieValue(value, secrets) {
-  let encoded = encodeData(value);
-  if (secrets.length > 0) {
-    encoded = await sign(encoded, secrets[0]);
-  }
-  return encoded;
-}
-async function decodeCookieValue(value, secrets) {
-  if (secrets.length > 0) {
-    for (let secret of secrets) {
-      let unsignedValue = await unsign(value, secret);
-      if (unsignedValue !== false) {
-        return decodeData(unsignedValue);
-      }
-    }
-    return null;
-  }
-  return decodeData(value);
-}
-function encodeData(value) {
-  return btoa(myUnescape(encodeURIComponent(JSON.stringify(value))));
-}
-function decodeData(value) {
-  try {
-    return JSON.parse(decodeURIComponent(myEscape(atob(value))));
-  } catch (error) {
-    return {};
-  }
-}
-function myEscape(value) {
-  let str = value.toString();
-  let result = "";
-  let index = 0;
-  let chr, code;
-  while (index < str.length) {
-    chr = str.charAt(index++);
-    if (/[\w*+\-./@]/.exec(chr)) {
-      result += chr;
-    } else {
-      code = chr.charCodeAt(0);
-      if (code < 256) {
-        result += "%" + hex(code, 2);
-      } else {
-        result += "%u" + hex(code, 4).toUpperCase();
-      }
-    }
-  }
-  return result;
-}
-function hex(code, length) {
-  let result = code.toString(16);
-  while (result.length < length) result = "0" + result;
-  return result;
-}
-function myUnescape(value) {
-  let str = value.toString();
-  let result = "";
-  let index = 0;
-  let chr, part;
-  while (index < str.length) {
-    chr = str.charAt(index++);
-    if (chr === "%") {
-      if (str.charAt(index) === "u") {
-        part = str.slice(index + 1, index + 5);
-        if (/^[\da-f]{4}$/i.exec(part)) {
-          result += String.fromCharCode(parseInt(part, 16));
-          index += 5;
-          continue;
-        }
-      } else {
-        part = str.slice(index, index + 2);
-        if (/^[\da-f]{2}$/i.exec(part)) {
-          result += String.fromCharCode(parseInt(part, 16));
-          index += 2;
-          continue;
-        }
-      }
-    }
-    result += chr;
-  }
-  return result;
-}
-function warnOnceAboutExpiresCookie(name, expires) {
-  warnOnce(
-    !expires,
-    `The "${name}" cookie has an "expires" property set. This will cause the expires value to not be updated when the session is committed. Instead, you should set the expires value when serializing the cookie. You can use \`commitSession(session, { expires })\` if using a session storage object, or \`cookie.serialize("value", { expires })\` if you're using the cookie directly.`
-  );
-}
-function createEntryRouteModules(manifest) {
-  return Object.keys(manifest).reduce((memo, routeId) => {
-    let route = manifest[routeId];
-    if (route) {
-      memo[routeId] = route.module;
-    }
-    return memo;
-  }, {});
-}
-var ServerMode = /* @__PURE__ */ ((ServerMode2) => {
-  ServerMode2["Development"] = "development";
-  ServerMode2["Production"] = "production";
-  ServerMode2["Test"] = "test";
-  return ServerMode2;
-})(ServerMode || {});
-function isServerMode(value) {
-  return value === "development" || value === "production" || value === "test";
-}
-function sanitizeError(error, serverMode) {
-  if (error instanceof Error && serverMode !== "development") {
-    let sanitized = new Error("Unexpected Server Error");
-    sanitized.stack = void 0;
-    return sanitized;
-  }
-  return error;
-}
-function sanitizeErrors(errors, serverMode) {
-  return Object.entries(errors).reduce((acc, [routeId, error]) => {
-    return Object.assign(acc, { [routeId]: sanitizeError(error, serverMode) });
-  }, {});
-}
-function serializeError(error, serverMode) {
-  let sanitized = sanitizeError(error, serverMode);
-  return {
-    message: sanitized.message,
-    stack: sanitized.stack
-  };
-}
-function serializeErrors(errors, serverMode) {
-  if (!errors) return null;
-  let entries = Object.entries(errors);
-  let serialized = {};
-  for (let [key, val] of entries) {
-    if (isRouteErrorResponse(val)) {
-      serialized[key] = { ...val, __type: "RouteErrorResponse" };
-    } else if (val instanceof Error) {
-      let sanitized = sanitizeError(val, serverMode);
-      serialized[key] = {
-        message: sanitized.message,
-        stack: sanitized.stack,
-        __type: "Error",
-        // If this is a subclass (i.e., ReferenceError), send up the type so we
-        // can re-create the same type during hydration.  This will only apply
-        // in dev mode since all production errors are sanitized to normal
-        // Error instances
-        ...sanitized.name !== "Error" ? {
-          __subType: sanitized.name
-        } : {}
-      };
-    } else {
-      serialized[key] = val;
-    }
-  }
-  return serialized;
-}
-function matchServerRoutes(routes, pathname, basename) {
-  let matches = matchRoutes(
-    routes,
-    pathname,
-    basename
-  );
-  if (!matches) return null;
-  return matches.map((match) => ({
-    params: match.params,
-    pathname: match.pathname,
-    route: match.route
-  }));
-}
-async function callRouteHandler(handler, args) {
-  let result = await handler({
-    request: stripRoutesParam(stripIndexParam(args.request)),
-    params: args.params,
-    context: args.context,
-    unstable_pattern: args.unstable_pattern
-  });
-  if (isDataWithResponseInit(result) && result.init && result.init.status && isRedirectStatusCode(result.init.status)) {
-    throw new Response(null, result.init);
-  }
-  return result;
-}
-function stripIndexParam(request) {
-  let url = new URL(request.url);
-  let indexValues = url.searchParams.getAll("index");
-  url.searchParams.delete("index");
-  let indexValuesToKeep = [];
-  for (let indexValue of indexValues) {
-    if (indexValue) {
-      indexValuesToKeep.push(indexValue);
-    }
-  }
-  for (let toKeep of indexValuesToKeep) {
-    url.searchParams.append("index", toKeep);
-  }
-  let init = {
-    method: request.method,
-    body: request.body,
-    headers: request.headers,
-    signal: request.signal
-  };
-  if (init.body) {
-    init.duplex = "half";
-  }
-  return new Request(url.href, init);
-}
-function stripRoutesParam(request) {
-  let url = new URL(request.url);
-  url.searchParams.delete("_routes");
-  let init = {
-    method: request.method,
-    body: request.body,
-    headers: request.headers,
-    signal: request.signal
-  };
-  if (init.body) {
-    init.duplex = "half";
-  }
-  return new Request(url.href, init);
-}
-function invariant(value, message) {
-  if (value === false || value === null || typeof value === "undefined") {
-    console.error(
-      "The following error is a bug in React Router; please open an issue! https://github.com/remix-run/react-router/issues/new/choose"
-    );
-    throw new Error(message);
-  }
-}
-var globalDevServerHooksKey = "__reactRouterDevServerHooks";
-function setDevServerHooks(devServerHooks) {
-  globalThis[globalDevServerHooksKey] = devServerHooks;
-}
-function getDevServerHooks() {
-  return globalThis[globalDevServerHooksKey];
-}
-function getBuildTimeHeader(request, headerName) {
-  if (typeof process !== "undefined") {
-    try {
-      if (define_process_env_default?.IS_RR_BUILD_REQUEST === "yes") {
-        return request.headers.get(headerName);
-      }
-    } catch (e) {
-    }
-  }
-  return null;
-}
-function groupRoutesByParentId(manifest) {
-  let routes = {};
-  Object.values(manifest).forEach((route) => {
-    if (route) {
-      let parentId = route.parentId || "";
-      if (!routes[parentId]) {
-        routes[parentId] = [];
-      }
-      routes[parentId].push(route);
-    }
-  });
-  return routes;
-}
-function createRoutes(manifest, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) {
-  return (routesByParentId[parentId] || []).map((route) => ({
-    ...route,
-    children: createRoutes(manifest, route.id, routesByParentId)
-  }));
-}
-function createStaticHandlerDataRoutes(manifest, future, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) {
-  return (routesByParentId[parentId] || []).map((route) => {
-    let commonRoute = {
-      // Always include root due to default boundaries
-      hasErrorBoundary: route.id === "root" || route.module.ErrorBoundary != null,
-      id: route.id,
-      path: route.path,
-      middleware: route.module.middleware,
-      // Need to use RR's version in the param typed here to permit the optional
-      // context even though we know it'll always be provided in remix
-      loader: route.module.loader ? async (args) => {
-        let preRenderedData = getBuildTimeHeader(
-          args.request,
-          "X-React-Router-Prerender-Data"
-        );
-        if (preRenderedData != null) {
-          let encoded = preRenderedData ? decodeURI(preRenderedData) : preRenderedData;
-          invariant(encoded, "Missing prerendered data for route");
-          let uint8array = new TextEncoder().encode(encoded);
-          let stream = new ReadableStream({
-            start(controller) {
-              controller.enqueue(uint8array);
-              controller.close();
-            }
-          });
-          let decoded = await decodeViaTurboStream(stream, globalThis);
-          let data2 = decoded.value;
-          if (data2 && SingleFetchRedirectSymbol in data2) {
-            let result = data2[SingleFetchRedirectSymbol];
-            let init = { status: result.status };
-            if (result.reload) {
-              throw redirectDocument(result.redirect, init);
-            } else if (result.replace) {
-              throw replace(result.redirect, init);
-            } else {
-              throw redirect(result.redirect, init);
-            }
-          } else {
-            invariant(
-              data2 && route.id in data2,
-              "Unable to decode prerendered data"
-            );
-            let result = data2[route.id];
-            invariant(
-              "data" in result,
-              "Unable to process prerendered data"
-            );
-            return result.data;
-          }
-        }
-        let val = await callRouteHandler(route.module.loader, args);
-        return val;
-      } : void 0,
-      action: route.module.action ? (args) => callRouteHandler(route.module.action, args) : void 0,
-      handle: route.module.handle
-    };
-    return route.index ? {
-      index: true,
-      ...commonRoute
-    } : {
-      caseSensitive: route.caseSensitive,
-      children: createStaticHandlerDataRoutes(
-        manifest,
-        future,
-        route.id,
-        routesByParentId
-      ),
-      ...commonRoute
-    };
-  });
-}
-function createServerHandoffString(serverHandoff) {
-  return escapeHtml(JSON.stringify(serverHandoff));
-}
-function getDocumentHeaders(context, build) {
-  return getDocumentHeadersImpl(context, (m) => {
-    let route = build.routes[m.route.id];
-    invariant(route, `Route with id "${m.route.id}" not found in build`);
-    return route.module.headers;
-  });
-}
-function getDocumentHeadersImpl(context, getRouteHeadersFn, _defaultHeaders) {
-  let boundaryIdx = context.errors ? context.matches.findIndex((m) => context.errors[m.route.id]) : -1;
-  let matches = boundaryIdx >= 0 ? context.matches.slice(0, boundaryIdx + 1) : context.matches;
-  let errorHeaders;
-  if (boundaryIdx >= 0) {
-    let { actionHeaders, actionData, loaderHeaders, loaderData } = context;
-    context.matches.slice(boundaryIdx).some((match) => {
-      let id = match.route.id;
-      if (actionHeaders[id] && (!actionData || !actionData.hasOwnProperty(id))) {
-        errorHeaders = actionHeaders[id];
-      } else if (loaderHeaders[id] && !loaderData.hasOwnProperty(id)) {
-        errorHeaders = loaderHeaders[id];
-      }
-      return errorHeaders != null;
-    });
-  }
-  const defaultHeaders = new Headers(_defaultHeaders);
-  return matches.reduce((parentHeaders, match, idx) => {
-    let { id } = match.route;
-    let loaderHeaders = context.loaderHeaders[id] || new Headers();
-    let actionHeaders = context.actionHeaders[id] || new Headers();
-    let includeErrorHeaders = errorHeaders != null && idx === matches.length - 1;
-    let includeErrorCookies = includeErrorHeaders && errorHeaders !== loaderHeaders && errorHeaders !== actionHeaders;
-    let headersFn = getRouteHeadersFn(match);
-    if (headersFn == null) {
-      let headers2 = new Headers(parentHeaders);
-      if (includeErrorCookies) {
-        prependCookies(errorHeaders, headers2);
-      }
-      prependCookies(actionHeaders, headers2);
-      prependCookies(loaderHeaders, headers2);
-      return headers2;
-    }
-    let headers = new Headers(
-      typeof headersFn === "function" ? headersFn({
-        loaderHeaders,
-        parentHeaders,
-        actionHeaders,
-        errorHeaders: includeErrorHeaders ? errorHeaders : void 0
-      }) : headersFn
-    );
-    if (includeErrorCookies) {
-      prependCookies(errorHeaders, headers);
-    }
-    prependCookies(actionHeaders, headers);
-    prependCookies(loaderHeaders, headers);
-    prependCookies(parentHeaders, headers);
-    return headers;
-  }, new Headers(defaultHeaders));
-}
-function prependCookies(parentHeaders, childHeaders) {
-  let parentSetCookieString = parentHeaders.get("Set-Cookie");
-  if (parentSetCookieString) {
-    let cookies = setCookieExports.splitCookiesString(parentSetCookieString);
-    let childCookies = new Set(childHeaders.getSetCookie());
-    cookies.forEach((cookie) => {
-      if (!childCookies.has(cookie)) {
-        childHeaders.append("Set-Cookie", cookie);
-      }
-    });
-  }
-}
-var SERVER_NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([
-  ...NO_BODY_STATUS_CODES,
-  304
-]);
-async function singleFetchAction(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
-  try {
-    let handlerRequest = new Request(handlerUrl, {
-      method: request.method,
-      body: request.body,
-      headers: request.headers,
-      signal: request.signal,
-      ...request.body ? { duplex: "half" } : void 0
-    });
-    let result = await staticHandler.query(handlerRequest, {
-      requestContext: loadContext,
-      skipLoaderErrorBubbling: true,
-      skipRevalidation: true,
-      generateMiddlewareResponse: build.future.v8_middleware ? async (query) => {
-        try {
-          let innerResult = await query(handlerRequest);
-          return handleQueryResult(innerResult);
-        } catch (error) {
-          return handleQueryError(error);
-        }
-      } : void 0
-    });
-    return handleQueryResult(result);
-  } catch (error) {
-    return handleQueryError(error);
-  }
-  function handleQueryResult(result) {
-    return isResponse(result) ? result : staticContextToResponse(result);
-  }
-  function handleQueryError(error) {
-    handleError(error);
-    return generateSingleFetchResponse(request, build, serverMode, {
-      result: { error },
-      headers: new Headers(),
-      status: 500
-    });
-  }
-  function staticContextToResponse(context) {
-    let headers = getDocumentHeaders(context, build);
-    if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
-      return new Response(null, { status: context.statusCode, headers });
-    }
-    if (context.errors) {
-      Object.values(context.errors).forEach((err) => {
-        if (!isRouteErrorResponse(err) || err.error) {
-          handleError(err);
-        }
-      });
-      context.errors = sanitizeErrors(context.errors, serverMode);
-    }
-    let singleFetchResult;
-    if (context.errors) {
-      singleFetchResult = { error: Object.values(context.errors)[0] };
-    } else {
-      singleFetchResult = {
-        data: Object.values(context.actionData || {})[0]
-      };
-    }
-    return generateSingleFetchResponse(request, build, serverMode, {
-      result: singleFetchResult,
-      headers,
-      status: context.statusCode
-    });
-  }
-}
-async function singleFetchLoaders(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
-  let routesParam = new URL(request.url).searchParams.get("_routes");
-  let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
-  try {
-    let handlerRequest = new Request(handlerUrl, {
-      headers: request.headers,
-      signal: request.signal
-    });
-    let result = await staticHandler.query(handlerRequest, {
-      requestContext: loadContext,
-      filterMatchesToLoad: (m) => !loadRouteIds || loadRouteIds.has(m.route.id),
-      skipLoaderErrorBubbling: true,
-      generateMiddlewareResponse: build.future.v8_middleware ? async (query) => {
-        try {
-          let innerResult = await query(handlerRequest);
-          return handleQueryResult(innerResult);
-        } catch (error) {
-          return handleQueryError(error);
-        }
-      } : void 0
-    });
-    return handleQueryResult(result);
-  } catch (error) {
-    return handleQueryError(error);
-  }
-  function handleQueryResult(result) {
-    return isResponse(result) ? result : staticContextToResponse(result);
-  }
-  function handleQueryError(error) {
-    handleError(error);
-    return generateSingleFetchResponse(request, build, serverMode, {
-      result: { error },
-      headers: new Headers(),
-      status: 500
-    });
-  }
-  function staticContextToResponse(context) {
-    let headers = getDocumentHeaders(context, build);
-    if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
-      return new Response(null, { status: context.statusCode, headers });
-    }
-    if (context.errors) {
-      Object.values(context.errors).forEach((err) => {
-        if (!isRouteErrorResponse(err) || err.error) {
-          handleError(err);
-        }
-      });
-      context.errors = sanitizeErrors(context.errors, serverMode);
-    }
-    let results = {};
-    let loadedMatches = new Set(
-      context.matches.filter(
-        (m) => loadRouteIds ? loadRouteIds.has(m.route.id) : m.route.loader != null
-      ).map((m) => m.route.id)
-    );
-    if (context.errors) {
-      for (let [id, error] of Object.entries(context.errors)) {
-        results[id] = { error };
-      }
-    }
-    for (let [id, data2] of Object.entries(context.loaderData)) {
-      if (!(id in results) && loadedMatches.has(id)) {
-        results[id] = { data: data2 };
-      }
-    }
-    return generateSingleFetchResponse(request, build, serverMode, {
-      result: results,
-      headers,
-      status: context.statusCode
-    });
-  }
-}
-function generateSingleFetchResponse(request, build, serverMode, {
-  result,
-  headers,
-  status
-}) {
-  let resultHeaders = new Headers(headers);
-  resultHeaders.set("X-Remix-Response", "yes");
-  if (SERVER_NO_BODY_STATUS_CODES.has(status)) {
-    return new Response(null, { status, headers: resultHeaders });
-  }
-  resultHeaders.set("Content-Type", "text/x-script");
-  resultHeaders.delete("Content-Length");
-  return new Response(
-    encodeViaTurboStream(
-      result,
-      request.signal,
-      build.entry.module.streamTimeout,
-      serverMode
-    ),
-    {
-      status: status || 200,
-      headers: resultHeaders
-    }
-  );
-}
-function generateSingleFetchRedirectResponse(redirectResponse, request, build, serverMode) {
-  let redirect2 = getSingleFetchRedirect(
-    redirectResponse.status,
-    redirectResponse.headers,
-    build.basename
-  );
-  let headers = new Headers(redirectResponse.headers);
-  headers.delete("Location");
-  headers.set("Content-Type", "text/x-script");
-  return generateSingleFetchResponse(request, build, serverMode, {
-    result: request.method === "GET" ? { [SingleFetchRedirectSymbol]: redirect2 } : redirect2,
-    headers,
-    status: SINGLE_FETCH_REDIRECT_STATUS
-  });
-}
-function getSingleFetchRedirect(status, headers, basename) {
-  let redirect2 = headers.get("Location");
-  if (basename) {
-    redirect2 = stripBasename(redirect2, basename) || redirect2;
-  }
-  return {
-    redirect: redirect2,
-    status,
-    revalidate: (
-      // Technically X-Remix-Revalidate isn't needed here - that was an implementation
-      // detail of ?_data requests as our way to tell the front end to revalidate when
-      // we didn't have a response body to include that information in.
-      // With single fetch, we tell the front end via this revalidate boolean field.
-      // However, we're respecting it for now because it may be something folks have
-      // used in their own responses
-      // TODO(v3): Consider removing or making this official public API
-      headers.has("X-Remix-Revalidate") || headers.has("Set-Cookie")
-    ),
-    reload: headers.has("X-Remix-Reload-Document"),
-    replace: headers.has("X-Remix-Replace")
-  };
-}
-function encodeViaTurboStream(data2, requestSignal, streamTimeout, serverMode) {
-  let controller = new AbortController();
-  let timeoutId = setTimeout(
-    () => controller.abort(new Error("Server Timeout")),
-    typeof streamTimeout === "number" ? streamTimeout : 4950
-  );
-  requestSignal.addEventListener("abort", () => clearTimeout(timeoutId));
-  return encode(data2, {
-    signal: controller.signal,
-    plugins: [
-      (value) => {
-        if (value instanceof Error) {
-          let { name, message, stack } = serverMode === "production" ? sanitizeError(value, serverMode) : value;
-          return ["SanitizedError", name, message, stack];
-        }
-        if (value instanceof ErrorResponseImpl) {
-          let { data: data3, status, statusText } = value;
-          return ["ErrorResponse", data3, status, statusText];
-        }
-        if (value && typeof value === "object" && SingleFetchRedirectSymbol in value) {
-          return ["SingleFetchRedirect", value[SingleFetchRedirectSymbol]];
-        }
-      }
-    ],
-    postPlugins: [
-      (value) => {
-        if (!value) return;
-        if (typeof value !== "object") return;
-        return [
-          "SingleFetchClassInstance",
-          Object.fromEntries(Object.entries(value))
-        ];
-      },
-      () => ["SingleFetchFallback"]
-    ]
-  });
-}
-function derive(build, mode) {
-  let routes = createRoutes(build.routes);
-  let dataRoutes = createStaticHandlerDataRoutes(build.routes, build.future);
-  let serverMode = isServerMode(mode) ? mode : "production";
-  let staticHandler = createStaticHandler(dataRoutes, {
-    basename: build.basename,
-    unstable_instrumentations: build.entry.module.unstable_instrumentations
-  });
-  let errorHandler = build.entry.module.handleError || ((error, { request }) => {
-    if (serverMode !== "test" && !request.signal.aborted) {
-      console.error(
-        // @ts-expect-error This is "private" from users but intended for internal use
-        isRouteErrorResponse(error) && error.error ? error.error : error
-      );
-    }
-  });
-  let requestHandler = async (request, initialContext) => {
-    let params = {};
-    let loadContext;
-    let handleError = (error) => {
-      if (mode === "development") {
-        getDevServerHooks()?.processRequestError?.(error);
-      }
-      errorHandler(error, {
-        context: loadContext,
-        params,
-        request
-      });
-    };
-    if (build.future.v8_middleware) {
-      if (initialContext && !(initialContext instanceof RouterContextProvider)) {
-        let error = new Error(
-          "Invalid `context` value provided to `handleRequest`. When middleware is enabled you must return an instance of `RouterContextProvider` from your `getLoadContext` function."
-        );
-        handleError(error);
-        return returnLastResortErrorResponse(error, serverMode);
-      }
-      loadContext = initialContext || new RouterContextProvider();
-    } else {
-      loadContext = initialContext || {};
-    }
-    let url = new URL(request.url);
-    let normalizedBasename = build.basename || "/";
-    let normalizedPath = url.pathname;
-    if (stripBasename(normalizedPath, normalizedBasename) === "/_root.data") {
-      normalizedPath = normalizedBasename;
-    } else if (normalizedPath.endsWith(".data")) {
-      normalizedPath = normalizedPath.replace(/\.data$/, "");
-    }
-    if (stripBasename(normalizedPath, normalizedBasename) !== "/" && normalizedPath.endsWith("/")) {
-      normalizedPath = normalizedPath.slice(0, -1);
-    }
-    let isSpaMode = getBuildTimeHeader(request, "X-React-Router-SPA-Mode") === "yes";
-    if (!build.ssr) {
-      let decodedPath = decodeURI(normalizedPath);
-      if (normalizedBasename !== "/") {
-        let strippedPath = stripBasename(decodedPath, normalizedBasename);
-        if (strippedPath == null) {
-          errorHandler(
-            new ErrorResponseImpl(
-              404,
-              "Not Found",
-              `Refusing to prerender the \`${decodedPath}\` path because it does not start with the basename \`${normalizedBasename}\``
-            ),
-            {
-              context: loadContext,
-              params,
-              request
-            }
-          );
-          return new Response("Not Found", {
-            status: 404,
-            statusText: "Not Found"
-          });
-        }
-        decodedPath = strippedPath;
-      }
-      if (build.prerender.length === 0) {
-        isSpaMode = true;
-      } else if (!build.prerender.includes(decodedPath) && !build.prerender.includes(decodedPath + "/")) {
-        if (url.pathname.endsWith(".data")) {
-          errorHandler(
-            new ErrorResponseImpl(
-              404,
-              "Not Found",
-              `Refusing to SSR the path \`${decodedPath}\` because \`ssr:false\` is set and the path is not included in the \`prerender\` config, so in production the path will be a 404.`
-            ),
-            {
-              context: loadContext,
-              params,
-              request
-            }
-          );
-          return new Response("Not Found", {
-            status: 404,
-            statusText: "Not Found"
-          });
-        } else {
-          isSpaMode = true;
-        }
-      }
-    }
-    let manifestUrl = getManifestPath(
-      build.routeDiscovery.manifestPath,
-      normalizedBasename
-    );
-    if (url.pathname === manifestUrl) {
-      try {
-        let res = await handleManifestRequest(build, routes, url);
-        return res;
-      } catch (e) {
-        handleError(e);
-        return new Response("Unknown Server Error", { status: 500 });
-      }
-    }
-    let matches = matchServerRoutes(routes, normalizedPath, build.basename);
-    if (matches && matches.length > 0) {
-      Object.assign(params, matches[0].params);
-    }
-    let response;
-    if (url.pathname.endsWith(".data")) {
-      let handlerUrl = new URL(request.url);
-      handlerUrl.pathname = normalizedPath;
-      let singleFetchMatches = matchServerRoutes(
-        routes,
-        handlerUrl.pathname,
-        build.basename
-      );
-      response = await handleSingleFetchRequest(
-        serverMode,
-        build,
-        staticHandler,
-        request,
-        handlerUrl,
-        loadContext,
-        handleError
-      );
-      if (isRedirectResponse(response)) {
-        response = generateSingleFetchRedirectResponse(
-          response,
-          request,
-          build,
-          serverMode
-        );
-      }
-      if (build.entry.module.handleDataRequest) {
-        response = await build.entry.module.handleDataRequest(response, {
-          context: loadContext,
-          params: singleFetchMatches ? singleFetchMatches[0].params : {},
-          request
-        });
-        if (isRedirectResponse(response)) {
-          response = generateSingleFetchRedirectResponse(
-            response,
-            request,
-            build,
-            serverMode
-          );
-        }
-      }
-    } else if (!isSpaMode && matches && matches[matches.length - 1].route.module.default == null && matches[matches.length - 1].route.module.ErrorBoundary == null) {
-      response = await handleResourceRequest(
-        serverMode,
-        build,
-        staticHandler,
-        matches.slice(-1)[0].route.id,
-        request,
-        loadContext,
-        handleError
-      );
-    } else {
-      let { pathname } = url;
-      let criticalCss = void 0;
-      if (build.unstable_getCriticalCss) {
-        criticalCss = await build.unstable_getCriticalCss({ pathname });
-      } else if (mode === "development" && getDevServerHooks()?.getCriticalCss) {
-        criticalCss = await getDevServerHooks()?.getCriticalCss?.(pathname);
-      }
-      response = await handleDocumentRequest(
-        serverMode,
-        build,
-        staticHandler,
-        request,
-        loadContext,
-        handleError,
-        isSpaMode,
-        criticalCss
-      );
-    }
-    if (request.method === "HEAD") {
-      return new Response(null, {
-        headers: response.headers,
-        status: response.status,
-        statusText: response.statusText
-      });
-    }
-    return response;
-  };
-  if (build.entry.module.unstable_instrumentations) {
-    requestHandler = instrumentHandler(
-      requestHandler,
-      build.entry.module.unstable_instrumentations.map((i) => i.handler).filter(Boolean)
-    );
-  }
-  return {
-    routes,
-    dataRoutes,
-    serverMode,
-    staticHandler,
-    errorHandler,
-    requestHandler
-  };
-}
-var createRequestHandler = (build, mode) => {
-  let _build;
-  let routes;
-  let serverMode;
-  let staticHandler;
-  let errorHandler;
-  let _requestHandler;
-  return async function requestHandler(request, initialContext) {
-    _build = typeof build === "function" ? await build() : build;
-    if (typeof build === "function") {
-      let derived = derive(_build, mode);
-      routes = derived.routes;
-      serverMode = derived.serverMode;
-      staticHandler = derived.staticHandler;
-      errorHandler = derived.errorHandler;
-      _requestHandler = derived.requestHandler;
-    } else if (!routes || !serverMode || !staticHandler || !errorHandler || !_requestHandler) {
-      let derived = derive(_build, mode);
-      routes = derived.routes;
-      serverMode = derived.serverMode;
-      staticHandler = derived.staticHandler;
-      errorHandler = derived.errorHandler;
-      _requestHandler = derived.requestHandler;
-    }
-    return _requestHandler(request, initialContext);
-  };
-};
-async function handleManifestRequest(build, routes, url) {
-  if (build.assets.version !== url.searchParams.get("version")) {
-    return new Response(null, {
-      status: 204,
-      headers: {
-        "X-Remix-Reload-Document": "true"
-      }
-    });
-  }
-  let patches = {};
-  if (url.searchParams.has("paths")) {
-    let paths = /* @__PURE__ */ new Set();
-    let pathParam = url.searchParams.get("paths") || "";
-    let requestedPaths = pathParam.split(",").filter(Boolean);
-    requestedPaths.forEach((path) => {
-      if (!path.startsWith("/")) {
-        path = `/${path}`;
-      }
-      let segments = path.split("/").slice(1);
-      segments.forEach((_, i) => {
-        let partialPath = segments.slice(0, i + 1).join("/");
-        paths.add(`/${partialPath}`);
-      });
-    });
-    for (let path of paths) {
-      let matches = matchServerRoutes(routes, path, build.basename);
-      if (matches) {
-        for (let match of matches) {
-          let routeId = match.route.id;
-          let route = build.assets.routes[routeId];
-          if (route) {
-            patches[routeId] = route;
-          }
-        }
-      }
-    }
-    return Response.json(patches, {
-      headers: {
-        "Cache-Control": "public, max-age=31536000, immutable"
-      }
-    });
-  }
-  return new Response("Invalid Request", { status: 400 });
-}
-async function handleSingleFetchRequest(serverMode, build, staticHandler, request, handlerUrl, loadContext, handleError) {
-  let response = request.method !== "GET" ? await singleFetchAction(
-    build,
-    serverMode,
-    staticHandler,
-    request,
-    handlerUrl,
-    loadContext,
-    handleError
-  ) : await singleFetchLoaders(
-    build,
-    serverMode,
-    staticHandler,
-    request,
-    handlerUrl,
-    loadContext,
-    handleError
-  );
-  return response;
-}
-async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, isSpaMode, criticalCss) {
-  try {
-    let result = await staticHandler.query(request, {
-      requestContext: loadContext,
-      generateMiddlewareResponse: build.future.v8_middleware ? async (query) => {
-        try {
-          let innerResult = await query(request);
-          if (!isResponse(innerResult)) {
-            innerResult = await renderHtml(innerResult, isSpaMode);
-          }
-          return innerResult;
-        } catch (error) {
-          handleError(error);
-          return new Response(null, { status: 500 });
-        }
-      } : void 0
-    });
-    if (!isResponse(result)) {
-      result = await renderHtml(result, isSpaMode);
-    }
-    return result;
-  } catch (error) {
-    handleError(error);
-    return new Response(null, { status: 500 });
-  }
-  async function renderHtml(context, isSpaMode2) {
-    let headers = getDocumentHeaders(context, build);
-    if (SERVER_NO_BODY_STATUS_CODES.has(context.statusCode)) {
-      return new Response(null, { status: context.statusCode, headers });
-    }
-    if (context.errors) {
-      Object.values(context.errors).forEach((err) => {
-        if (!isRouteErrorResponse(err) || err.error) {
-          handleError(err);
-        }
-      });
-      context.errors = sanitizeErrors(context.errors, serverMode);
-    }
-    let state = {
-      loaderData: context.loaderData,
-      actionData: context.actionData,
-      errors: serializeErrors(context.errors, serverMode)
-    };
-    let baseServerHandoff = {
-      basename: build.basename,
-      future: build.future,
-      routeDiscovery: build.routeDiscovery,
-      ssr: build.ssr,
-      isSpaMode: isSpaMode2
-    };
-    let entryContext = {
-      manifest: build.assets,
-      routeModules: createEntryRouteModules(build.routes),
-      staticHandlerContext: context,
-      criticalCss,
-      serverHandoffString: createServerHandoffString({
-        ...baseServerHandoff,
-        criticalCss
-      }),
-      serverHandoffStream: encodeViaTurboStream(
-        state,
-        request.signal,
-        build.entry.module.streamTimeout,
-        serverMode
-      ),
-      renderMeta: {},
-      future: build.future,
-      ssr: build.ssr,
-      routeDiscovery: build.routeDiscovery,
-      isSpaMode: isSpaMode2,
-      serializeError: (err) => serializeError(err, serverMode)
-    };
-    let handleDocumentRequestFunction = build.entry.module.default;
-    try {
-      return await handleDocumentRequestFunction(
-        request,
-        context.statusCode,
-        headers,
-        entryContext,
-        loadContext
-      );
-    } catch (error) {
-      handleError(error);
-      let errorForSecondRender = error;
-      if (isResponse(error)) {
-        try {
-          let data2 = await unwrapResponse(error);
-          errorForSecondRender = new ErrorResponseImpl(
-            error.status,
-            error.statusText,
-            data2
-          );
-        } catch (e) {
-        }
-      }
-      context = getStaticContextFromError(
-        staticHandler.dataRoutes,
-        context,
-        errorForSecondRender
-      );
-      if (context.errors) {
-        context.errors = sanitizeErrors(context.errors, serverMode);
-      }
-      let state2 = {
-        loaderData: context.loaderData,
-        actionData: context.actionData,
-        errors: serializeErrors(context.errors, serverMode)
-      };
-      entryContext = {
-        ...entryContext,
-        staticHandlerContext: context,
-        serverHandoffString: createServerHandoffString(baseServerHandoff),
-        serverHandoffStream: encodeViaTurboStream(
-          state2,
-          request.signal,
-          build.entry.module.streamTimeout,
-          serverMode
-        ),
-        renderMeta: {}
-      };
-      try {
-        return await handleDocumentRequestFunction(
-          request,
-          context.statusCode,
-          headers,
-          entryContext,
-          loadContext
-        );
-      } catch (error2) {
-        handleError(error2);
-        return returnLastResortErrorResponse(error2, serverMode);
-      }
-    }
-  }
-}
-async function handleResourceRequest(serverMode, build, staticHandler, routeId, request, loadContext, handleError) {
-  try {
-    let result = await staticHandler.queryRoute(request, {
-      routeId,
-      requestContext: loadContext,
-      generateMiddlewareResponse: build.future.v8_middleware ? async (queryRoute) => {
-        try {
-          let innerResult = await queryRoute(request);
-          return handleQueryRouteResult(innerResult);
-        } catch (error) {
-          return handleQueryRouteError(error);
-        }
-      } : void 0
-    });
-    return handleQueryRouteResult(result);
-  } catch (error) {
-    return handleQueryRouteError(error);
-  }
-  function handleQueryRouteResult(result) {
-    if (isResponse(result)) {
-      return result;
-    }
-    if (typeof result === "string") {
-      return new Response(result);
-    }
-    return Response.json(result);
-  }
-  function handleQueryRouteError(error) {
-    if (isResponse(error)) {
-      return error;
-    }
-    if (isRouteErrorResponse(error)) {
-      handleError(error);
-      return errorResponseToJson(error, serverMode);
-    }
-    if (error instanceof Error && error.message === "Expected a response from queryRoute") {
-      let newError = new Error(
-        "Expected a Response to be returned from resource route handler"
-      );
-      handleError(newError);
-      return returnLastResortErrorResponse(newError, serverMode);
-    }
-    handleError(error);
-    return returnLastResortErrorResponse(error, serverMode);
-  }
-}
-function errorResponseToJson(errorResponse, serverMode) {
-  return Response.json(
-    serializeError(
-      // @ts-expect-error This is "private" from users but intended for internal use
-      errorResponse.error || new Error("Unexpected Server Error"),
-      serverMode
-    ),
-    {
-      status: errorResponse.status,
-      statusText: errorResponse.statusText
-    }
-  );
-}
-function returnLastResortErrorResponse(error, serverMode) {
-  let message = "Unexpected Server Error";
-  if (serverMode !== "production") {
-    message += `
-
-${String(error)}`;
-  }
-  return new Response(message, {
-    status: 500,
-    headers: {
-      "Content-Type": "text/plain"
-    }
-  });
-}
-function unwrapResponse(response) {
-  let contentType = response.headers.get("Content-Type");
-  return contentType && /\bapplication\/json\b/.test(contentType) ? response.body == null ? null : response.json() : response.text();
-}
-function flash(name) {
-  return `__flash_${name}__`;
-}
-var createSession = (initialData = {}, id = "") => {
-  let map = new Map(Object.entries(initialData));
-  return {
-    get id() {
-      return id;
-    },
-    get data() {
-      return Object.fromEntries(map);
-    },
-    has(name) {
-      return map.has(name) || map.has(flash(name));
-    },
-    get(name) {
-      if (map.has(name)) return map.get(name);
-      let flashName = flash(name);
-      if (map.has(flashName)) {
-        let value = map.get(flashName);
-        map.delete(flashName);
-        return value;
-      }
-      return void 0;
-    },
-    set(name, value) {
-      map.set(name, value);
-    },
-    flash(name, value) {
-      map.set(flash(name), value);
-    },
-    unset(name) {
-      map.delete(name);
-    }
-  };
-};
-var isSession = (object) => {
-  return object != null && typeof object.id === "string" && typeof object.data !== "undefined" && typeof object.has === "function" && typeof object.get === "function" && typeof object.set === "function" && typeof object.flash === "function" && typeof object.unset === "function";
-};
-function createSessionStorage({
-  cookie: cookieArg,
-  createData,
-  readData,
-  updateData,
-  deleteData
-}) {
-  let cookie = isCookie(cookieArg) ? cookieArg : createCookie(cookieArg?.name || "__session", cookieArg);
-  warnOnceAboutSigningSessionCookie(cookie);
-  return {
-    async getSession(cookieHeader, options) {
-      let id = cookieHeader && await cookie.parse(cookieHeader, options);
-      let data2 = id && await readData(id);
-      return createSession(data2 || {}, id || "");
-    },
-    async commitSession(session, options) {
-      let { id, data: data2 } = session;
-      let expires = options?.maxAge != null ? new Date(Date.now() + options.maxAge * 1e3) : options?.expires != null ? options.expires : cookie.expires;
-      if (id) {
-        await updateData(id, data2, expires);
-      } else {
-        id = await createData(data2, expires);
-      }
-      return cookie.serialize(id, options);
-    },
-    async destroySession(session, options) {
-      await deleteData(session.id);
-      return cookie.serialize("", {
-        ...options,
-        maxAge: void 0,
-        expires: /* @__PURE__ */ new Date(0)
-      });
-    }
-  };
-}
-function warnOnceAboutSigningSessionCookie(cookie) {
-  warnOnce(
-    cookie.isSigned,
-    `The "${cookie.name}" cookie is not signed, but session cookies should be signed to prevent tampering on the client before they are sent back to the server. See https://reactrouter.com/explanation/sessions-and-cookies#signing-cookies for more information.`
-  );
-}
-function createCookieSessionStorage({ cookie: cookieArg } = {}) {
-  let cookie = isCookie(cookieArg) ? cookieArg : createCookie(cookieArg?.name || "__session", cookieArg);
-  warnOnceAboutSigningSessionCookie(cookie);
-  return {
-    async getSession(cookieHeader, options) {
-      return createSession(
-        cookieHeader && await cookie.parse(cookieHeader, options) || {}
-      );
-    },
-    async commitSession(session, options) {
-      let serializedCookie = await cookie.serialize(session.data, options);
-      if (serializedCookie.length > 4096) {
-        throw new Error(
-          "Cookie length will exceed browser maximum. Length: " + serializedCookie.length
-        );
-      }
-      return serializedCookie;
-    },
-    async destroySession(_session, options) {
-      return cookie.serialize("", {
-        ...options,
-        maxAge: void 0,
-        expires: /* @__PURE__ */ new Date(0)
-      });
-    }
-  };
-}
-function createMemorySessionStorage({ cookie } = {}) {
-  let map = /* @__PURE__ */ new Map();
-  return createSessionStorage({
-    cookie,
-    async createData(data2, expires) {
-      let id = Math.random().toString(36).substring(2, 10);
-      map.set(id, { data: data2, expires });
-      return id;
-    },
-    async readData(id) {
-      if (map.has(id)) {
-        let { data: data2, expires } = map.get(id);
-        if (!expires || expires > /* @__PURE__ */ new Date()) {
-          return data2;
-        }
-        if (expires) map.delete(id);
-      }
-      return null;
-    },
-    async updateData(id, data2, expires) {
-      map.set(id, { data: data2, expires });
-    },
-    async deleteData(id) {
-      map.delete(id);
-    }
-  });
-}
-function href(path, ...args) {
-  let params = args[0];
-  let result = path.replace(/\/*\*?$/, "").replace(
-    /\/:([\w-]+)(\?)?/g,
-    // same regex as in .\router\utils.ts: compilePath().
-    (_, param, questionMark) => {
-      const isRequired = questionMark === void 0;
-      const value = params ? params[param] : void 0;
-      if (isRequired && value === void 0) {
-        throw new Error(
-          `Path '${path}' requires param '${param}' but it was not provided`
-        );
-      }
-      return value === void 0 ? "" : "/" + value;
-    }
-  );
-  if (path.endsWith("*")) {
-    const value = params ? params["*"] : void 0;
-    if (value !== void 0) {
-      result += "/" + value;
-    }
-  }
-  return result || "/";
-}
-var encoder2 = new TextEncoder();
-var trailer = "</body></html>";
-function injectRSCPayload(rscStream) {
-  let decoder = new TextDecoder();
-  let resolveFlightDataPromise;
-  let flightDataPromise = new Promise(
-    (resolve) => resolveFlightDataPromise = resolve
-  );
-  let startedRSC = false;
-  let buffered = [];
-  let timeout = null;
-  function flushBufferedChunks(controller) {
-    for (let chunk of buffered) {
-      let buf = decoder.decode(chunk, { stream: true });
-      if (buf.endsWith(trailer)) {
-        buf = buf.slice(0, -trailer.length);
-      }
-      controller.enqueue(encoder2.encode(buf));
-    }
-    buffered.length = 0;
-    timeout = null;
-  }
-  return new TransformStream({
-    transform(chunk, controller) {
-      buffered.push(chunk);
-      if (timeout) {
-        return;
-      }
-      timeout = setTimeout(async () => {
-        flushBufferedChunks(controller);
-        if (!startedRSC) {
-          startedRSC = true;
-          writeRSCStream(rscStream, controller).catch((err) => controller.error(err)).then(resolveFlightDataPromise);
-        }
-      }, 0);
-    },
-    async flush(controller) {
-      await flightDataPromise;
-      if (timeout) {
-        clearTimeout(timeout);
-        flushBufferedChunks(controller);
-      }
-      controller.enqueue(encoder2.encode("</body></html>"));
-    }
-  });
-}
-async function writeRSCStream(rscStream, controller) {
-  let decoder = new TextDecoder("utf-8", { fatal: true });
-  const reader = rscStream.getReader();
-  try {
-    let read;
-    while ((read = await reader.read()) && !read.done) {
-      const chunk = read.value;
-      try {
-        writeChunk(
-          JSON.stringify(decoder.decode(chunk, { stream: true })),
-          controller
-        );
-      } catch (err) {
-        let base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
-        writeChunk(
-          `Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`,
-          controller
-        );
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  let remaining = decoder.decode();
-  if (remaining.length) {
-    writeChunk(JSON.stringify(remaining), controller);
-  }
-}
-function writeChunk(chunk, controller) {
-  controller.enqueue(
-    encoder2.encode(
-      `<script>${escapeScript(
-        `(self.__FLIGHT_DATA||=[]).push(${chunk})`
-      )}<\/script>`
-    )
-  );
-}
-function escapeScript(script) {
-  return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
-}
-var RSCRouterGlobalErrorBoundary = class extends re.Component {
-  constructor(props) {
-    super(props);
-    this.state = { error: null, location: props.location };
-  }
-  static getDerivedStateFromError(error) {
-    return { error };
-  }
-  static getDerivedStateFromProps(props, state) {
-    if (state.location !== props.location) {
-      return { error: null, location: props.location };
-    }
-    return { error: state.error, location: state.location };
-  }
-  render() {
-    if (this.state.error) {
-      return /* @__PURE__ */ re.createElement(
-        RSCDefaultRootErrorBoundaryImpl,
-        {
-          error: this.state.error,
-          renderAppShell: true
-        }
-      );
-    } else {
-      return this.props.children;
-    }
-  }
-};
-function ErrorWrapper({
-  renderAppShell,
-  title,
-  children
-}) {
-  if (!renderAppShell) {
-    return children;
-  }
-  return /* @__PURE__ */ re.createElement("html", { lang: "en" }, /* @__PURE__ */ re.createElement("head", null, /* @__PURE__ */ re.createElement("meta", { charSet: "utf-8" }), /* @__PURE__ */ re.createElement(
-    "meta",
-    {
-      name: "viewport",
-      content: "width=device-width,initial-scale=1,viewport-fit=cover"
-    }
-  ), /* @__PURE__ */ re.createElement("title", null, title)), /* @__PURE__ */ re.createElement("body", null, /* @__PURE__ */ re.createElement("main", { style: { fontFamily: "system-ui, sans-serif", padding: "2rem" } }, children)));
-}
-function RSCDefaultRootErrorBoundaryImpl({
-  error,
-  renderAppShell
-}) {
-  console.error(error);
-  let heyDeveloper = /* @__PURE__ */ re.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__ */ re.createElement(
-      ErrorWrapper,
-      {
-        renderAppShell,
-        title: "Unhandled Thrown Response!"
-      },
-      /* @__PURE__ */ re.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__ */ re.createElement(ErrorWrapper, { renderAppShell, title: "Application Error!" }, /* @__PURE__ */ re.createElement("h1", { style: { fontSize: "24px" } }, "Application Error"), /* @__PURE__ */ re.createElement(
-    "pre",
-    {
-      style: {
-        padding: "2rem",
-        background: "hsla(10, 50%, 50%, 0.1)",
-        color: "red",
-        overflow: "auto"
-      }
-    },
-    errorInstance.stack
-  ), heyDeveloper);
-}
-function RSCDefaultRootErrorBoundary({
-  hasRootLayout
-}) {
-  let error = useRouteError();
-  if (hasRootLayout === void 0) {
-    throw new Error("Missing 'hasRootLayout' prop");
-  }
-  return /* @__PURE__ */ re.createElement(
-    RSCDefaultRootErrorBoundaryImpl,
-    {
-      renderAppShell: !hasRootLayout,
-      error
-    }
-  );
-}
-function createRSCRouteModules(payload) {
-  const routeModules = {};
-  for (const match of payload.matches) {
-    populateRSCRouteModules(routeModules, match);
-  }
-  return routeModules;
-}
-function populateRSCRouteModules(routeModules, matches) {
-  matches = Array.isArray(matches) ? matches : [matches];
-  for (const match of matches) {
-    routeModules[match.id] = {
-      links: match.links,
-      meta: match.meta,
-      default: noopComponent
-    };
-  }
-}
-var noopComponent = () => null;
-var REACT_USE = "use";
-var useImpl = React[REACT_USE];
-function useSafe(promise) {
-  if (useImpl) {
-    return useImpl(promise);
-  }
-  throw new Error("React Router v7 requires React 19+ for RSC features.");
-}
-async function routeRSCServerRequest({
-  request,
-  fetchServer,
-  createFromReadableStream,
-  renderHTML,
-  hydrate = true
-}) {
-  const url = new URL(request.url);
-  const isDataRequest = isReactServerRequest(url);
-  const respondWithRSCPayload = isDataRequest || isManifestRequest(url) || request.headers.has("rsc-action-id");
-  const serverResponse = await fetchServer(request);
-  if (respondWithRSCPayload || serverResponse.headers.get("React-Router-Resource") === "true") {
-    return serverResponse;
-  }
-  if (!serverResponse.body) {
-    throw new Error("Missing body in server response");
-  }
-  const detectRedirectResponse = serverResponse.clone();
-  let serverResponseB = null;
-  if (hydrate) {
-    serverResponseB = serverResponse.clone();
-  }
-  const body = serverResponse.body;
-  let buffer;
-  let streamControllers = [];
-  const createStream = () => {
-    if (!buffer) {
-      buffer = [];
-      return body.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            buffer.push(chunk);
-            controller.enqueue(chunk);
-            streamControllers.forEach((c) => c.enqueue(chunk));
-          },
-          flush() {
-            streamControllers.forEach((c) => c.close());
-            streamControllers = [];
-          }
-        })
-      );
-    }
-    return new ReadableStream({
-      start(controller) {
-        buffer.forEach((chunk) => controller.enqueue(chunk));
-        streamControllers.push(controller);
-      }
-    });
-  };
-  let deepestRenderedBoundaryId = null;
-  const getPayload = () => {
-    const payloadPromise = Promise.resolve(
-      createFromReadableStream(createStream())
-    );
-    return Object.defineProperties(payloadPromise, {
-      _deepestRenderedBoundaryId: {
-        get() {
-          return deepestRenderedBoundaryId;
-        },
-        set(boundaryId) {
-          deepestRenderedBoundaryId = boundaryId;
-        }
-      },
-      formState: {
-        get() {
-          return payloadPromise.then(
-            (payload) => payload.type === "render" ? payload.formState : void 0
-          );
-        }
-      }
-    });
-  };
-  try {
-    if (!detectRedirectResponse.body) {
-      throw new Error("Failed to clone server response");
-    }
-    const payload = await createFromReadableStream(
-      detectRedirectResponse.body
-    );
-    if (serverResponse.status === SINGLE_FETCH_REDIRECT_STATUS && payload.type === "redirect") {
-      const headers2 = new Headers(serverResponse.headers);
-      headers2.delete("Content-Encoding");
-      headers2.delete("Content-Length");
-      headers2.delete("Content-Type");
-      headers2.delete("X-Remix-Response");
-      headers2.set("Location", payload.location);
-      return new Response(serverResponseB?.body || "", {
-        headers: headers2,
-        status: payload.status,
-        statusText: serverResponse.statusText
-      });
-    }
-    const html = await renderHTML(getPayload);
-    const headers = new Headers(serverResponse.headers);
-    headers.set("Content-Type", "text/html; charset=utf-8");
-    if (!hydrate) {
-      return new Response(html, {
-        status: serverResponse.status,
-        headers
-      });
-    }
-    if (!serverResponseB?.body) {
-      throw new Error("Failed to clone server response");
-    }
-    const body2 = html.pipeThrough(injectRSCPayload(serverResponseB.body));
-    return new Response(body2, {
-      status: serverResponse.status,
-      headers
-    });
-  } catch (reason) {
-    if (reason instanceof Response) {
-      return reason;
-    }
-    try {
-      const status = isRouteErrorResponse(reason) ? reason.status : 500;
-      const html = await renderHTML(() => {
-        const decoded = Promise.resolve(
-          createFromReadableStream(createStream())
-        );
-        const payloadPromise = decoded.then(
-          (payload) => Object.assign(payload, {
-            status,
-            errors: deepestRenderedBoundaryId ? {
-              [deepestRenderedBoundaryId]: reason
-            } : {}
-          })
-        );
-        return Object.defineProperties(payloadPromise, {
-          _deepestRenderedBoundaryId: {
-            get() {
-              return deepestRenderedBoundaryId;
-            },
-            set(boundaryId) {
-              deepestRenderedBoundaryId = boundaryId;
-            }
-          },
-          formState: {
-            get() {
-              return payloadPromise.then(
-                (payload) => payload.type === "render" ? payload.formState : void 0
-              );
-            }
-          }
-        });
-      });
-      const headers = new Headers(serverResponse.headers);
-      headers.set("Content-Type", "text/html");
-      if (!hydrate) {
-        return new Response(html, {
-          status,
-          headers
-        });
-      }
-      if (!serverResponseB?.body) {
-        throw new Error("Failed to clone server response");
-      }
-      const body2 = html.pipeThrough(injectRSCPayload(serverResponseB.body));
-      return new Response(body2, {
-        status,
-        headers
-      });
-    } catch {
-    }
-    throw reason;
-  }
-}
-function RSCStaticRouter({ getPayload }) {
-  const decoded = getPayload();
-  const payload = useSafe(decoded);
-  if (payload.type === "redirect") {
-    throw new Response(null, {
-      status: payload.status,
-      headers: {
-        Location: payload.location
-      }
-    });
-  }
-  if (payload.type !== "render") return null;
-  let patchedLoaderData = { ...payload.loaderData };
-  for (const match of payload.matches) {
-    if (shouldHydrateRouteLoader(
-      match.id,
-      match.clientLoader,
-      match.hasLoader,
-      false
-    ) && (match.hydrateFallbackElement || !match.hasLoader)) {
-      delete patchedLoaderData[match.id];
-    }
-  }
-  const context = {
-    get _deepestRenderedBoundaryId() {
-      return decoded._deepestRenderedBoundaryId ?? null;
-    },
-    set _deepestRenderedBoundaryId(boundaryId) {
-      decoded._deepestRenderedBoundaryId = boundaryId;
-    },
-    actionData: payload.actionData,
-    actionHeaders: {},
-    basename: payload.basename,
-    errors: payload.errors,
-    loaderData: patchedLoaderData,
-    loaderHeaders: {},
-    location: payload.location,
-    statusCode: 200,
-    matches: payload.matches.map((match) => ({
-      params: match.params,
-      pathname: match.pathname,
-      pathnameBase: match.pathnameBase,
-      route: {
-        id: match.id,
-        action: match.hasAction || !!match.clientAction,
-        handle: match.handle,
-        hasErrorBoundary: match.hasErrorBoundary,
-        loader: match.hasLoader || !!match.clientLoader,
-        index: match.index,
-        path: match.path,
-        shouldRevalidate: match.shouldRevalidate
-      }
-    }))
-  };
-  const router2 = createStaticRouter(
-    payload.matches.reduceRight((previous, match) => {
-      const route = {
-        id: match.id,
-        action: match.hasAction || !!match.clientAction,
-        element: match.element,
-        errorElement: match.errorElement,
-        handle: match.handle,
-        hasErrorBoundary: !!match.errorElement,
-        hydrateFallbackElement: match.hydrateFallbackElement,
-        index: match.index,
-        loader: match.hasLoader || !!match.clientLoader,
-        path: match.path,
-        shouldRevalidate: match.shouldRevalidate
-      };
-      if (previous.length > 0) {
-        route.children = previous;
-      }
-      return [route];
-    }, []),
-    context
-  );
-  const frameworkContext = {
-    future: {
-      // These flags have no runtime impact so can always be false.  If we add
-      // flags that drive runtime behavior they'll need to be proxied through.
-      v8_middleware: false,
-      unstable_subResourceIntegrity: false
-    },
-    isSpaMode: false,
-    ssr: true,
-    criticalCss: "",
-    manifest: {
-      routes: {},
-      version: "1",
-      url: "",
-      entry: {
-        module: "",
-        imports: []
-      }
-    },
-    routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" },
-    routeModules: createRSCRouteModules(payload)
-  };
-  return /* @__PURE__ */ reactExports.createElement(RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ reactExports.createElement(RSCRouterGlobalErrorBoundary, { location: payload.location }, /* @__PURE__ */ reactExports.createElement(FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ reactExports.createElement(
-    StaticRouterProvider,
-    {
-      context,
-      router: router2,
-      hydrate: false,
-      nonce: payload.nonce
-    }
-  ))));
-}
-function isReactServerRequest(url) {
-  return url.pathname.endsWith(".rsc");
-}
-function isManifestRequest(url) {
-  return url.pathname.endsWith(".manifest");
-}
-function deserializeErrors(errors) {
-  if (!errors) return null;
-  let entries = Object.entries(errors);
-  let serialized = {};
-  for (let [key, val] of entries) {
-    if (val && val.__type === "RouteErrorResponse") {
-      serialized[key] = new ErrorResponseImpl(
-        val.status,
-        val.statusText,
-        val.data,
-        val.internal === true
-      );
-    } else if (val && val.__type === "Error") {
-      if (val.__subType) {
-        let ErrorConstructor = window[val.__subType];
-        if (typeof ErrorConstructor === "function") {
-          try {
-            let error = new ErrorConstructor(val.message);
-            error.stack = val.stack;
-            serialized[key] = error;
-          } catch (e) {
-          }
-        }
-      }
-      if (serialized[key] == null) {
-        let error = new Error(val.message);
-        error.stack = val.stack;
-        serialized[key] = error;
-      }
-    } else {
-      serialized[key] = val;
-    }
-  }
-  return serialized;
-}
-function getHydrationData({
-  state,
-  routes,
-  getRouteInfo,
-  location,
-  basename,
-  isSpaMode
-}) {
-  let hydrationData = {
-    ...state,
-    loaderData: { ...state.loaderData }
-  };
-  let initialMatches = matchRoutes(routes, location, basename);
-  if (initialMatches) {
-    for (let match of initialMatches) {
-      let routeId = match.route.id;
-      let routeInfo = getRouteInfo(routeId);
-      if (shouldHydrateRouteLoader(
-        routeId,
-        routeInfo.clientLoader,
-        routeInfo.hasLoader,
-        isSpaMode
-      ) && (routeInfo.hasHydrateFallback || !routeInfo.hasLoader)) {
-        delete hydrationData.loaderData[routeId];
-      } else if (!routeInfo.hasLoader) {
-        hydrationData.loaderData[routeId] = null;
-      }
-    }
-  }
-  return hydrationData;
-}
-function RouterProvider2(props) {
-  return /* @__PURE__ */ reactExports.createElement(RouterProvider, { flushSync: reactDomExports.flushSync, ...props });
-}
-var ssrInfo = null;
-var router = null;
-function initSsrInfo() {
-  if (!ssrInfo && window.__reactRouterContext && window.__reactRouterManifest && window.__reactRouterRouteModules) {
-    if (window.__reactRouterManifest.sri === true) {
-      const importMap = document.querySelector("script[rr-importmap]");
-      if (importMap?.textContent) {
-        try {
-          window.__reactRouterManifest.sri = JSON.parse(
-            importMap.textContent
-          ).integrity;
-        } catch (err) {
-          console.error("Failed to parse import map", err);
-        }
-      }
-    }
-    ssrInfo = {
-      context: window.__reactRouterContext,
-      manifest: window.__reactRouterManifest,
-      routeModules: window.__reactRouterRouteModules,
-      stateDecodingPromise: void 0,
-      router: void 0,
-      routerInitialized: false
-    };
-  }
-}
-function createHydratedRouter({
-  getContext,
-  unstable_instrumentations
-}) {
-  initSsrInfo();
-  if (!ssrInfo) {
-    throw new Error(
-      "You must be using the SSR features of React Router in order to skip passing a `router` prop to `<RouterProvider>`"
-    );
-  }
-  let localSsrInfo = ssrInfo;
-  if (!ssrInfo.stateDecodingPromise) {
-    let stream = ssrInfo.context.stream;
-    invariant$1(stream, "No stream found for single fetch decoding");
-    ssrInfo.context.stream = void 0;
-    ssrInfo.stateDecodingPromise = decodeViaTurboStream(stream, window).then((value) => {
-      ssrInfo.context.state = value.value;
-      localSsrInfo.stateDecodingPromise.value = true;
-    }).catch((e) => {
-      localSsrInfo.stateDecodingPromise.error = e;
-    });
-  }
-  if (ssrInfo.stateDecodingPromise.error) {
-    throw ssrInfo.stateDecodingPromise.error;
-  }
-  if (!ssrInfo.stateDecodingPromise.value) {
-    throw ssrInfo.stateDecodingPromise;
-  }
-  let routes = createClientRoutes(
-    ssrInfo.manifest.routes,
-    ssrInfo.routeModules,
-    ssrInfo.context.state,
-    ssrInfo.context.ssr,
-    ssrInfo.context.isSpaMode
-  );
-  let hydrationData = void 0;
-  if (ssrInfo.context.isSpaMode) {
-    let { loaderData } = ssrInfo.context.state;
-    if (ssrInfo.manifest.routes.root?.hasLoader && loaderData && "root" in loaderData) {
-      hydrationData = {
-        loaderData: {
-          root: loaderData.root
-        }
-      };
-    }
-  } else {
-    hydrationData = getHydrationData({
-      state: ssrInfo.context.state,
-      routes,
-      getRouteInfo: (routeId) => ({
-        clientLoader: ssrInfo.routeModules[routeId]?.clientLoader,
-        hasLoader: ssrInfo.manifest.routes[routeId]?.hasLoader === true,
-        hasHydrateFallback: ssrInfo.routeModules[routeId]?.HydrateFallback != null
-      }),
-      location: window.location,
-      basename: window.__reactRouterContext?.basename,
-      isSpaMode: ssrInfo.context.isSpaMode
-    });
-    if (hydrationData && hydrationData.errors) {
-      hydrationData.errors = deserializeErrors(hydrationData.errors);
-    }
-  }
-  let router2 = createRouter({
-    routes,
-    history: createBrowserHistory(),
-    basename: ssrInfo.context.basename,
-    getContext,
-    hydrationData,
-    hydrationRouteProperties,
-    unstable_instrumentations,
-    mapRouteProperties,
-    future: {
-      middleware: ssrInfo.context.future.v8_middleware
-    },
-    dataStrategy: getTurboStreamSingleFetchDataStrategy(
-      () => router2,
-      ssrInfo.manifest,
-      ssrInfo.routeModules,
-      ssrInfo.context.ssr,
-      ssrInfo.context.basename
-    ),
-    patchRoutesOnNavigation: getPatchRoutesOnNavigationFunction(
-      ssrInfo.manifest,
-      ssrInfo.routeModules,
-      ssrInfo.context.ssr,
-      ssrInfo.context.routeDiscovery,
-      ssrInfo.context.isSpaMode,
-      ssrInfo.context.basename
-    )
-  });
-  ssrInfo.router = router2;
-  if (router2.state.initialized) {
-    ssrInfo.routerInitialized = true;
-    router2.initialize();
-  }
-  router2.createRoutesForHMR = /* spacer so ts-ignore does not affect the right hand of the assignment */
-  createClientRoutesWithHMRRevalidationOptOut;
-  window.__reactRouterDataRouter = router2;
-  return router2;
-}
-function HydratedRouter(props) {
-  if (!router) {
-    router = createHydratedRouter({
-      getContext: props.getContext,
-      unstable_instrumentations: props.unstable_instrumentations
-    });
-  }
-  let [criticalCss, setCriticalCss] = reactExports.useState(
-    void 0
-  );
-  reactExports.useEffect(() => {
-  }, []);
-  reactExports.useEffect(() => {
-  }, [criticalCss]);
-  let [location2, setLocation] = reactExports.useState(router.state.location);
-  reactExports.useLayoutEffect(() => {
-    if (ssrInfo && ssrInfo.router && !ssrInfo.routerInitialized) {
-      ssrInfo.routerInitialized = true;
-      ssrInfo.router.initialize();
-    }
-  }, []);
-  reactExports.useLayoutEffect(() => {
-    if (ssrInfo && ssrInfo.router) {
-      return ssrInfo.router.subscribe((newState) => {
-        if (newState.location !== location2) {
-          setLocation(newState.location);
-        }
-      });
-    }
-  }, [location2]);
-  invariant$1(ssrInfo, "ssrInfo unavailable for HydratedRouter");
-  useFogOFWarDiscovery(
-    router,
-    ssrInfo.manifest,
-    ssrInfo.routeModules,
-    ssrInfo.context.ssr,
-    ssrInfo.context.routeDiscovery,
-    ssrInfo.context.isSpaMode
-  );
-  return (
-    // This fragment is important to ensure we match the <ServerRouter> JSX
-    // structure so that useId values hydrate correctly
-    /* @__PURE__ */ reactExports.createElement(reactExports.Fragment, null, /* @__PURE__ */ reactExports.createElement(
-      FrameworkContext.Provider,
-      {
-        value: {
-          manifest: ssrInfo.manifest,
-          routeModules: ssrInfo.routeModules,
-          future: ssrInfo.context.future,
-          criticalCss,
-          ssr: ssrInfo.context.ssr,
-          isSpaMode: ssrInfo.context.isSpaMode,
-          routeDiscovery: ssrInfo.context.routeDiscovery
-        }
-      },
-      /* @__PURE__ */ reactExports.createElement(RemixErrorBoundary, { location: location2 }, /* @__PURE__ */ reactExports.createElement(
-        RouterProvider2,
-        {
-          router,
-          unstable_onError: props.unstable_onError
-        }
-      ))
-    ), /* @__PURE__ */ reactExports.createElement(reactExports.Fragment, null))
-  );
-}
-export {
-  a2 as Await,
-  a3 as BrowserRouter,
-  a4 as Form,
-  a5 as HashRouter,
-  HydratedRouter,
-  a6 as IDLE_BLOCKER,
-  a7 as IDLE_FETCHER,
-  a8 as IDLE_NAVIGATION,
-  a9 as Link,
-  aa as Links,
-  ab as MemoryRouter,
-  ac as Meta,
-  ad as NavLink,
-  ae as Navigate,
-  af as NavigationType,
-  Outlet,
-  ag as PrefetchPageLinks,
-  ah as Route,
-  ai as Router,
-  RouterContextProvider,
-  RouterProvider2 as RouterProvider,
-  aj as Routes,
-  ak as Scripts,
-  al as ScrollRestoration,
-  ServerRouter,
-  am as StaticRouter,
-  StaticRouterProvider,
-  an as UNSAFE_AwaitContextProvider,
-  ao as UNSAFE_DataRouterContext,
-  ap as UNSAFE_DataRouterStateContext,
-  ErrorResponseImpl as UNSAFE_ErrorResponseImpl,
-  aq as UNSAFE_FetchersContext,
-  FrameworkContext as UNSAFE_FrameworkContext,
-  ar as UNSAFE_LocationContext,
-  as as UNSAFE_NavigationContext,
-  RSCDefaultRootErrorBoundary as UNSAFE_RSCDefaultRootErrorBoundary,
-  RemixErrorBoundary as UNSAFE_RemixErrorBoundary,
-  at as UNSAFE_RouteContext,
-  ServerMode as UNSAFE_ServerMode,
-  SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol,
-  au as UNSAFE_ViewTransitionContext,
-  av as UNSAFE_WithComponentProps,
-  aw as UNSAFE_WithErrorBoundaryProps,
-  ax as UNSAFE_WithHydrateFallbackProps,
-  createBrowserHistory as UNSAFE_createBrowserHistory,
-  createClientRoutes as UNSAFE_createClientRoutes,
-  createClientRoutesWithHMRRevalidationOptOut as UNSAFE_createClientRoutesWithHMRRevalidationOptOut,
-  createRouter as UNSAFE_createRouter,
-  decodeViaTurboStream as UNSAFE_decodeViaTurboStream,
-  deserializeErrors as UNSAFE_deserializeErrors,
-  getHydrationData as UNSAFE_getHydrationData,
-  getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction,
-  getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy,
-  hydrationRouteProperties as UNSAFE_hydrationRouteProperties,
-  invariant$1 as UNSAFE_invariant,
-  mapRouteProperties as UNSAFE_mapRouteProperties,
-  shouldHydrateRouteLoader as UNSAFE_shouldHydrateRouteLoader,
-  useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery,
-  ay as UNSAFE_useScrollRestoration,
-  withComponentProps as UNSAFE_withComponentProps,
-  withErrorBoundaryProps as UNSAFE_withErrorBoundaryProps,
-  withHydrateFallbackProps as UNSAFE_withHydrateFallbackProps,
-  az as createBrowserRouter,
-  aA as createContext,
-  createCookie,
-  createCookieSessionStorage,
-  aB as createHashRouter,
-  createMemoryRouter,
-  createMemorySessionStorage,
-  aC as createPath,
-  createRequestHandler,
-  aD as createRoutesFromChildren,
-  aE as createRoutesFromElements,
-  createRoutesStub,
-  aF as createSearchParams,
-  createSession,
-  createSessionStorage,
-  aG as createStaticHandler,
-  createStaticRouter,
-  aH as data,
-  aI as generatePath,
-  href,
-  isCookie,
-  isRouteErrorResponse,
-  isSession,
-  aJ as matchPath,
-  matchRoutes,
-  aK as parsePath,
-  redirect,
-  redirectDocument,
-  aL as renderMatches,
-  replace,
-  aM as resolvePath,
-  aN as unstable_HistoryRouter,
-  RSCStaticRouter as unstable_RSCStaticRouter,
-  routeRSCServerRequest as unstable_routeRSCServerRequest,
-  setDevServerHooks as unstable_setDevServerHooks,
-  aO as unstable_usePrompt,
-  aP as unstable_useRoute,
-  aQ as useActionData,
-  aR as useAsyncError,
-  aS as useAsyncValue,
-  aT as useBeforeUnload,
-  aU as useBlocker,
-  aV as useFetcher,
-  aW as useFetchers,
-  aX as useFormAction,
-  aY as useHref,
-  aZ as useInRouterContext,
-  a_ as useLinkClickHandler,
-  a$ as useLoaderData,
-  b0 as useLocation,
-  b1 as useMatch,
-  b2 as useMatches,
-  b3 as useNavigate,
-  b4 as useNavigation,
-  b5 as useNavigationType,
-  b6 as useOutlet,
-  b7 as useOutletContext,
-  b8 as useParams,
-  b9 as useResolvedPath,
-  ba as useRevalidator,
-  useRouteError,
-  bb as useRouteLoaderData,
-  bc as useRoutes,
-  bd as useSearchParams,
-  be as useSubmit,
-  bf as useViewTransitionState
-};