UNPKG

react-router/dist/development/chunk-RMD3H4O3.mjs

Version:
80.1 kBJavaScriptView Raw
1/**
* react-router v7.15.0
*
* Copyright (c) Remix Software Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE.md file in the root directory of this source tree.
*
* @license MIT
*/
11import {
ENABLE_DEV_WARNINGS,
ErrorResponseImpl,
FrameworkContext,
NO_BODY_STATUS_CODES,
Outlet,
RSCRouterContext,
RemixErrorBoundary,
RouterContextProvider,
RouterProvider,
SINGLE_FETCH_REDIRECT_STATUS,
SingleFetchRedirectSymbol,
StaticRouterProvider,
StreamTransfer,
URL_LIMIT,
convertRoutesToDataRoutes,
createMemoryRouter,
createServerRoutes,
createStaticHandler,
createStaticRouter,
decodeRedirectErrorDigest,
decodeRouteErrorResponseDigest,
decodeViaTurboStream,
encode,
escapeHtml,
getManifestPath,
getStaticContextFromError,
instrumentHandler,
isDataWithResponseInit,
isRedirectResponse,
isRedirectStatusCode,
isResponse,
isRouteErrorResponse,
matchRoutes,
matchRoutesImpl,
redirect,
redirectDocument,
replace,
shouldHydrateRouteLoader,
stripBasename,
useRouteError,
warnOnce,
withComponentProps,
withErrorBoundaryProps,
withHydrateFallbackProps
56} from "./chunk-5KNZJZUH.mjs";
57
58// lib/dom/ssr/server.tsx
59import * as React from "react";
60function ServerRouter({
context,
url,
nonce
64}) {
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 router = createStaticRouter(routes, context.staticHandlerContext, {
  branches: context.branches
});
return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.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__ */ React.createElement(RemixErrorBoundary, { location: router.state.location }, /* @__PURE__ */ React.createElement(
    StaticRouterProvider,
    {
      router,
      context: context.staticHandlerContext,
      hydrate: false
    }
  ))
), context.serverHandoffStream ? /* @__PURE__ */ React.createElement(React.Suspense, null, /* @__PURE__ */ React.createElement(
  StreamTransfer,
  {
    context,
    identifier: 0,
    reader: context.serverHandoffStream.getReader(),
    textDecoder: new TextDecoder(),
    nonce
  }
)) : null);
128}
129
130// lib/dom/ssr/routes-test-stub.tsx
131import * as React2 from "react";
132function createRoutesStub(routes, _context) {
return function RoutesTestStub({
  initialEntries,
  initialIndex,
  hydrationData,
  future
}) {
  let routerRef = React2.useRef();
  let frameworkContextRef = React2.useRef();
  if (routerRef.current == null) {
    frameworkContextRef.current = {
      future: {
        v8_passThroughRequests: future?.v8_passThroughRequests === true,
        v8_middleware: future?.v8_middleware === true,
        unstable_trailingSlashAwareDataRequests: future?.unstable_trailingSlashAwareDataRequests === 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 `RouteObject`
      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__ */ React2.createElement(FrameworkContext.Provider, { value: frameworkContextRef.current }, /* @__PURE__ */ React2.createElement(RouterProvider, { router: routerRef.current }));
};
175}
176function 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;
});
242}
243
244// lib/server-runtime/cookies.ts
245import { parse, serialize } from "cookie";
246
247// lib/server-runtime/crypto.ts
248var encoder = /* @__PURE__ */ new TextEncoder();
249var 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;
258};
259var 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;
}
272};
273var createKey = async (secret, usages) => crypto.subtle.importKey(
"raw",
encoder.encode(secret),
{ name: "HMAC", hash: "SHA-256" },
false,
usages
279);
280function byteStringToUint8Array(byteString) {
let array = new Uint8Array(byteString.length);
for (let i = 0; i < byteString.length; i++) {
  array[i] = byteString.charCodeAt(i);
}
return array;
286}
287
288// lib/server-runtime/cookies.ts
289var 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 = 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 serialize(
      name,
      value === "" ? "" : await encodeCookieValue(value, secrets),
      {
        ...options,
        ...serializeOptions
      }
    );
  }
};
332};
333var isCookie = (object) => {
return object != null && typeof object.name === "string" && typeof object.isSigned === "boolean" && typeof object.parse === "function" && typeof object.serialize === "function";
335};
336async function encodeCookieValue(value, secrets) {
let encoded = encodeData(value);
if (secrets.length > 0) {
  encoded = await sign(encoded, secrets[0]);
}
return encoded;
342}
343async 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);
354}
355function encodeData(value) {
return btoa(myUnescape(encodeURIComponent(JSON.stringify(value))));
357}
358function decodeData(value) {
try {
  return JSON.parse(decodeURIComponent(myEscape(atob(value))));
} catch (error) {
  return {};
}
364}
365function 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;
384}
385function hex(code, length) {
let result = code.toString(16);
while (result.length < length) result = "0" + result;
return result;
389}
390function 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;
417}
418function 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.`
);
423}
424
425// lib/server-runtime/entry.ts
426function createEntryRouteModules(manifest) {
return Object.keys(manifest).reduce((memo, routeId) => {
  let route = manifest[routeId];
  if (route) {
    memo[routeId] = route.module;
  }
  return memo;
}, {});
434}
435
436// lib/server-runtime/mode.ts
437var ServerMode = /* @__PURE__ */ ((ServerMode2) => {
ServerMode2["Development"] = "development";
ServerMode2["Production"] = "production";
ServerMode2["Test"] = "test";
return ServerMode2;
442})(ServerMode || {});
443function isServerMode(value) {
return value === "development" /* Development */ || value === "production" /* Production */ || value === "test" /* Test */;
445}
446
447// lib/server-runtime/errors.ts
448function sanitizeError(error, serverMode) {
if (error instanceof Error && serverMode !== "development" /* Development */) {
  let sanitized = new Error("Unexpected Server Error");
  sanitized.stack = void 0;
  return sanitized;
}
return error;
455}
456function sanitizeErrors(errors, serverMode) {
return Object.entries(errors).reduce((acc, [routeId, error]) => {
  return Object.assign(acc, { [routeId]: sanitizeError(error, serverMode) });
}, {});
460}
461function serializeError(error, serverMode) {
let sanitized = sanitizeError(error, serverMode);
return {
  message: sanitized.message,
  stack: sanitized.stack
};
467}
468function 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;
494}
495
496// lib/server-runtime/invariant.ts
497function 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);
}
504}
505
506// lib/server-runtime/routeMatching.ts
507function matchServerRoutes(manifest, dataRoutes, branches, pathname, basename) {
let matches = matchRoutesImpl(
  dataRoutes,
  pathname,
  basename ?? "/",
  false,
  branches
);
if (!matches) return null;
return matches.map((match) => {
  let route = manifest[match.route.id];
  invariant(
    route,
    `Route with id "${match.route.id}" not found in manifest.`
  );
  return {
    params: match.params,
    pathname: match.pathname,
    route
  };
});
528}
529
530// lib/server-runtime/data.ts
531async function callRouteHandler(handler, args, future) {
let result = await handler({
  request: future.v8_passThroughRequests ? args.request : stripRoutesParam(stripIndexParam(args.request)),
  url: args.url,
  params: args.params,
  context: args.context,
  pattern: args.pattern
});
if (isDataWithResponseInit(result) && result.init && result.init.status && isRedirectStatusCode(result.init.status)) {
  throw new Response(null, result.init);
}
return result;
543}
544function 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);
567}
568function 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);
581}
582
583// lib/server-runtime/dev.ts
584var globalDevServerHooksKey = "__reactRouterDevServerHooks";
585function setDevServerHooks(devServerHooks) {
globalThis[globalDevServerHooksKey] = devServerHooks;
587}
588function getDevServerHooks() {
return globalThis[globalDevServerHooksKey];
590}
591function getBuildTimeHeader(request, headerName) {
if (typeof process !== "undefined") {
  try {
    if (process.env.hasOwnProperty("IS_RR_BUILD_REQUEST") && process.env.IS_RR_BUILD_REQUEST === "yes") {
      return request.headers.get(headerName);
    }
  } catch (e) {
  }
}
return null;
601}
602
603// lib/server-runtime/routes.ts
604function 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;
616}
617function 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, global);
        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,
        future
      );
      return val;
    } : void 0,
    action: route.module.action ? (args) => callRouteHandler(route.module.action, args, future) : void 0,
    handle: route.module.handle
  };
  return route.index ? {
    index: true,
    ...commonRoute
  } : {
    caseSensitive: route.caseSensitive,
    children: createStaticHandlerDataRoutes(
      manifest,
      future,
      route.id,
      routesByParentId
    ),
    ...commonRoute
  };
});
691}
692
693// lib/server-runtime/serverHandoff.ts
694function createServerHandoffString(serverHandoff) {
return escapeHtml(JSON.stringify(serverHandoff));
696}
697
698// lib/server-runtime/headers.ts
699import { splitCookiesString } from "set-cookie-parser";
700function 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;
});
706}
707function 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));
756}
757function prependCookies(parentHeaders, childHeaders) {
let parentSetCookieString = parentHeaders.get("Set-Cookie");
if (parentSetCookieString) {
  let cookies = splitCookiesString(parentSetCookieString);
  let childCookies = new Set(childHeaders.getSetCookie());
  cookies.forEach((cookie) => {
    if (!childCookies.has(cookie)) {
      childHeaders.append("Set-Cookie", cookie);
    }
  });
}
768}
769
770// lib/actions.ts
771function throwIfPotentialCSRFAttack(headers, allowedActionOrigins) {
let originHeader = headers.get("origin");
let originDomain = null;
try {
  originDomain = typeof originHeader === "string" && originHeader !== "null" ? new URL(originHeader).host : originHeader;
} catch {
  throw new Error(
    `\`origin\` header is not a valid URL. Aborting the action.`
  );
}
let host = parseHostHeader(headers);
if (originDomain && (!host || originDomain !== host.value)) {
  if (!isAllowedOrigin(originDomain, allowedActionOrigins)) {
    if (host) {
      throw new Error(
        `${host.type} header does not match \`origin\` header from a forwarded action request. Aborting the action.`
      );
    } else {
      throw new Error(
        "`x-forwarded-host` or `host` headers are not provided. One of these is needed to compare the `origin` header from a forwarded action request. Aborting the action."
      );
    }
  }
}
795}
796function matchWildcardDomain(domain, pattern) {
const domainParts = domain.split(".");
const patternParts = pattern.split(".");
if (patternParts.length < 1) {
  return false;
}
if (domainParts.length < patternParts.length) {
  return false;
}
while (patternParts.length) {
  const patternPart = patternParts.pop();
  const domainPart = domainParts.pop();
  switch (patternPart) {
    case "": {
      return false;
    }
    case "*": {
      if (domainPart) {
        continue;
      } else {
        return false;
      }
    }
    case "**": {
      if (patternParts.length > 0) {
        return false;
      }
      return domainPart !== void 0;
    }
    case void 0:
    default: {
      if (domainPart !== patternPart) {
        return false;
      }
    }
  }
}
return domainParts.length === 0;
834}
835function isAllowedOrigin(originDomain, allowedActionOrigins = []) {
return allowedActionOrigins.some(
  (allowedOrigin) => allowedOrigin && (allowedOrigin === originDomain || matchWildcardDomain(originDomain, allowedOrigin))
);
839}
840function parseHostHeader(headers) {
let forwardedHostHeader = headers.get("x-forwarded-host");
let forwardedHostValue = forwardedHostHeader?.split(",")[0]?.trim();
let hostHeader = headers.get("host");
return forwardedHostValue ? {
  type: "x-forwarded-host",
  value: forwardedHostValue
} : hostHeader ? {
  type: "host",
  value: hostHeader
} : void 0;
851}
852
853// lib/server-runtime/urls.ts
854function getNormalizedPath(request, basename, future) {
basename = basename || "/";
let url = new URL(request.url);
let pathname = url.pathname;
if (future?.unstable_trailingSlashAwareDataRequests) {
  if (pathname.endsWith("/_.data")) {
    pathname = pathname.replace(/_\.data$/, "");
  } else {
    pathname = pathname.replace(/\.data$/, "");
  }
} else {
  if (stripBasename(pathname, basename) === "/_root.data") {
    pathname = basename;
  } else if (pathname.endsWith(".data")) {
    pathname = pathname.replace(/\.data$/, "");
  }
  if (stripBasename(pathname, basename) !== "/" && pathname.endsWith("/")) {
    pathname = pathname.slice(0, -1);
  }
}
let searchParams = new URLSearchParams(url.search);
searchParams.delete("_routes");
let search = searchParams.toString();
if (search) {
  search = `?${search}`;
}
return {
  pathname,
  search,
  // No hashes on the server
  hash: ""
};
886}
887
888// lib/server-runtime/single-fetch.ts
889var SERVER_NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([
...NO_BODY_STATUS_CODES,
304
892]);
893async function singleFetchAction(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
try {
  try {
    throwIfPotentialCSRFAttack(
      request.headers,
      Array.isArray(build.allowedActionOrigins) ? build.allowedActionOrigins : []
    );
  } catch (e) {
    return handleQueryError(new Error("Bad Request"), 400);
  }
  let handlerRequest = build.future.v8_passThroughRequests ? request : 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,
    normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
  });
  return handleQueryResult(result);
} catch (error) {
  return handleQueryError(error);
}
function handleQueryResult(result) {
  return isResponse(result) ? result : staticContextToResponse(result);
}
function handleQueryError(error, status = 500) {
  handleError(error);
  return generateSingleFetchResponse(request, build, serverMode, {
    result: { error },
    headers: new Headers(),
    status
  });
}
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
  });
}
966}
967async 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 = build.future.v8_passThroughRequests ? request : 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,
    normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
  });
  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
  });
}
1039}
1040function generateSingleFetchResponse(request, build, serverMode, {
result,
headers,
status
1044}) {
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
  }
);
1064}
1065function 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
});
1079}
1080function 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")
};
1101}
1102function encodeViaTurboStream(data2, requestSignal, streamTimeout, serverMode) {
let controller = new AbortController();
let timeoutId = setTimeout(
  () => {
    controller.abort(new Error("Server Timeout"));
    cleanupCallbacks();
  },
  typeof streamTimeout === "number" ? streamTimeout : 4950
);
let abortControllerOnRequestAbort = () => {
  controller.abort(requestSignal.reason);
  cleanupCallbacks();
};
requestSignal.addEventListener("abort", abortControllerOnRequestAbort);
let cleanupCallbacks = () => {
  clearTimeout(timeoutId);
  requestSignal.removeEventListener("abort", abortControllerOnRequestAbort);
};
return encode(data2, {
  signal: controller.signal,
  onComplete: cleanupCallbacks,
  plugins: [
    (value) => {
      if (value instanceof Error) {
        let { name, message, stack } = serverMode === "production" /* 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"]
  ]
});
1150}
1151
1152// lib/server-runtime/server.ts
1153function derive(build, mode) {
let dataRoutes = createStaticHandlerDataRoutes(build.routes, build.future);
let serverMode = isServerMode(mode) ? mode : "production" /* Production */;
let staticHandler = createStaticHandler(dataRoutes, {
  basename: build.basename,
  instrumentations: build.entry.module.instrumentations,
  future: build.future
});
let errorHandler = build.entry.module.handleError || ((error, { request }) => {
  if (serverMode !== "test" /* 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" /* 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 requestUrl = new URL(request.url);
  let normalizedPathname = getNormalizedPath(
    request,
    build.basename,
    build.future
  ).pathname;
  let isSpaMode = getBuildTimeHeader(request, "X-React-Router-SPA-Mode") === "yes";
  if (!build.ssr) {
    let decodedPath = decodeURI(normalizedPathname);
    if (build.basename && build.basename !== "/") {
      let strippedPath = stripBasename(decodedPath, build.basename);
      if (strippedPath == null) {
        errorHandler(
          new ErrorResponseImpl(
            404,
            "Not Found",
            `Refusing to prerender the \`${decodedPath}\` path because it does not start with the basename \`${build.basename}\``
          ),
          {
            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 (requestUrl.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,
    build.basename
  );
  if (requestUrl.pathname === manifestUrl) {
    try {
      let res = await handleManifestRequest(
        build,
        staticHandler.dataRoutes,
        staticHandler._internalRouteBranches,
        requestUrl
      );
      return res;
    } catch (e) {
      handleError(e);
      return new Response("Unknown Server Error", { status: 500 });
    }
  }
  let matches = matchServerRoutes(
    build.routes,
    staticHandler.dataRoutes,
    staticHandler._internalRouteBranches,
    normalizedPathname,
    build.basename
  );
  if (matches && matches.length > 0) {
    Object.assign(params, matches[0].params);
  }
  let response;
  if (requestUrl.pathname.endsWith(".data")) {
    response = await handleSingleFetchRequest(
      serverMode,
      build,
      staticHandler,
      request,
      normalizedPathname,
      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: matches ? matches[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 } = requestUrl;
    let criticalCss = void 0;
    if (build.unstable_getCriticalCss) {
      criticalCss = await build.unstable_getCriticalCss({ pathname });
    } else if (mode === "development" /* 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.instrumentations) {
  requestHandler = instrumentHandler(
    requestHandler,
    build.entry.module.instrumentations.map((i) => i.handler).filter(Boolean)
  );
}
return {
  serverMode,
  staticHandler,
  errorHandler,
  requestHandler
};
1362}
1363var createRequestHandler = (build, mode) => {
let _build;
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);
    serverMode = derived.serverMode;
    staticHandler = derived.staticHandler;
    errorHandler = derived.errorHandler;
    _requestHandler = derived.requestHandler;
  } else if (!serverMode || !staticHandler || !errorHandler || !_requestHandler) {
    let derived = derive(_build, mode);
    serverMode = derived.serverMode;
    staticHandler = derived.staticHandler;
    errorHandler = derived.errorHandler;
    _requestHandler = derived.requestHandler;
  }
  return _requestHandler(request, initialContext);
};
1386};
1387async function handleManifestRequest(build, dataRoutes, branches, url) {
if (build.assets.version !== url.searchParams.get("version")) {
  return new Response(null, {
    status: 204,
    headers: {
      "X-Remix-Reload-Document": "true"
    }
  });
}
if (url.toString().length > URL_LIMIT) {
  return new Response(null, {
    statusText: "Bad Request",
    status: 400
  });
}
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(
      build.routes,
      dataRoutes,
      branches,
      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 });
1442}
1443async function handleSingleFetchRequest(serverMode, build, staticHandler, request, normalizedPath, loadContext, handleError) {
let handlerUrl = new URL(request.url);
handlerUrl.pathname = normalizedPath;
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;
1464}
1465async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, isSpaMode, criticalCss) {
try {
  if (request.method === "POST") {
    try {
      throwIfPotentialCSRFAttack(
        request.headers,
        Array.isArray(build.allowedActionOrigins) ? build.allowedActionOrigins : []
      );
    } catch (e) {
      handleError(e);
      return new Response("Bad Request", { status: 400 });
    }
  }
  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,
    normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
  });
  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,
    branches: staticHandler._internalRouteBranches,
    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);
    }
  }
}
1612}
1613async 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,
    normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
  });
  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);
}
1659}
1660function 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
  }
);
1672}
1673function returnLastResortErrorResponse(error, serverMode) {
let message = "Unexpected Server Error";
if (serverMode !== "production" /* Production */) {
  message += `
1677
1678${String(error)}`;
}
return new Response(message, {
  status: 500,
  headers: {
    "Content-Type": "text/plain"
  }
});
1686}
1687function unwrapResponse(response) {
let contentType = response.headers.get("Content-Type");
return contentType && /\bapplication\/json\b/.test(contentType) ? response.body == null ? null : response.json() : response.text();
1690}
1691
1692// lib/server-runtime/sessions.ts
1693function flash(name) {
return `__flash_${name}__`;
1695}
1696var 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);
  }
};
1728};
1729var 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";
1731};
1732function createSessionStorage({
cookie: cookieArg,
createData,
readData,
updateData,
deleteData
1738}) {
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)
    });
  }
};
1766}
1767function 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.`
);
1772}
1773
1774// lib/server-runtime/sessions/cookieStorage.ts
1775function 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)
    });
  }
};
1801}
1802
1803// lib/server-runtime/sessions/memoryStorage.ts
1804function 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);
  }
});
1830}
1831
1832// lib/href.ts
1833function href(path, ...args) {
let params = args[0];
let result = trimTrailingSplat(path).replace(
  /\/:([\w-]+)(\?)?/g,
  // same regex as in .\router\utils.ts: compilePath().
  (_, param, questionMark) => {
    const isRequired = questionMark === void 0;
    const value = params?.[param];
    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?.["*"];
  if (value !== void 0) {
    result += "/" + value;
  }
}
return result || "/";
1856}
1857function trimTrailingSplat(path) {
let i = path.length - 1;
let char = path[i];
if (char !== "*" && char !== "/") return path;
i--;
for (; i >= 0; i--) {
  if (path[i] !== "/") break;
}
return path.slice(0, i + 1);
1866}
1867
1868// lib/rsc/server.ssr.tsx
1869import * as React4 from "react";
1870
1871// lib/rsc/html-stream/server.ts
1872var encoder2 = new TextEncoder();
1873var trailer = "</body></html>";
1874function 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>"));
  }
});
1917}
1918async 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);
}
1945}
1946function writeChunk(chunk, controller) {
controller.enqueue(
  encoder2.encode(
    `<script>${escapeScript(
      `(self.__FLIGHT_DATA||=[]).push(${chunk})`
    )}</script>`
  )
);
1954}
1955function escapeScript(script) {
return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
1957}
1958
1959// lib/rsc/errorBoundaries.tsx
1960import React3 from "react";
1961var RSCRouterGlobalErrorBoundary = class extends React3.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__ */ React3.createElement(
      RSCDefaultRootErrorBoundaryImpl,
      {
        error: this.state.error,
        renderAppShell: true
      }
    );
  } else {
    return this.props.children;
  }
}
1988};
1989function ErrorWrapper({
renderAppShell,
title,
children
1993}) {
if (!renderAppShell) {
  return children;
}
return /* @__PURE__ */ React3.createElement("html", { lang: "en" }, /* @__PURE__ */ React3.createElement("head", null, /* @__PURE__ */ React3.createElement("meta", { charSet: "utf-8" }), /* @__PURE__ */ React3.createElement(
  "meta",
  {
    name: "viewport",
    content: "width=device-width,initial-scale=1,viewport-fit=cover"
  }
), /* @__PURE__ */ React3.createElement("title", null, title)), /* @__PURE__ */ React3.createElement("body", null, /* @__PURE__ */ React3.createElement("main", { style: { fontFamily: "system-ui, sans-serif", padding: "2rem" } }, children)));
2004}
2005function RSCDefaultRootErrorBoundaryImpl({
error,
renderAppShell
2008}) {
console.error(error);
let heyDeveloper = /* @__PURE__ */ React3.createElement(
  "script",
  {
    dangerouslySetInnerHTML: {
      __html: `
      console.log(
        "\u{1F4BF} Hey developer \u{1F44B}. 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__ */ React3.createElement(
    ErrorWrapper,
    {
      renderAppShell,
      title: "Unhandled Thrown Response!"
    },
    /* @__PURE__ */ React3.createElement("h1", { style: { fontSize: "24px" } }, error.status, " ", error.statusText),
    ENABLE_DEV_WARNINGS ? heyDeveloper : null
  );
}
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__ */ React3.createElement(ErrorWrapper, { renderAppShell, title: "Application Error!" }, /* @__PURE__ */ React3.createElement("h1", { style: { fontSize: "24px" } }, "Application Error"), /* @__PURE__ */ React3.createElement(
  "pre",
  {
    style: {
      padding: "2rem",
      background: "hsla(10, 50%, 50%, 0.1)",
      color: "red",
      overflow: "auto"
    }
  },
  errorInstance.stack
), heyDeveloper);
2052}
2053function RSCDefaultRootErrorBoundary({
hasRootLayout
2055}) {
let error = useRouteError();
if (hasRootLayout === void 0) {
  throw new Error("Missing 'hasRootLayout' prop");
}
return /* @__PURE__ */ React3.createElement(
  RSCDefaultRootErrorBoundaryImpl,
  {
    renderAppShell: !hasRootLayout,
    error
  }
);
2067}
2068
2069// lib/rsc/route-modules.ts
2070function createRSCRouteModules(payload) {
const routeModules = {};
for (const match of payload.matches) {
  populateRSCRouteModules(routeModules, match);
}
return routeModules;
2076}
2077function 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
  };
}
2086}
2087var noopComponent = () => null;
2088
2089// lib/rsc/server.ssr.tsx
2090var defaultManifestPath = "/__manifest";
2091var REACT_USE = "use";
2092var useImpl = React4[REACT_USE];
2093function useSafe(promise) {
if (useImpl) {
  return useImpl(promise);
}
throw new Error("React Router v7 requires React 19+ for RSC features.");
2098}
2099async function routeRSCServerRequest({
request,
serverResponse,
createFromReadableStream,
renderHTML,
hydrate = true
2105}) {
const url = new URL(request.url);
const isDataRequest = isReactServerRequest(url);
const respondWithRSCPayload = isDataRequest || isManifestRequest(url) || request.headers.has("rsc-action-id");
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
        );
      }
    }
  });
};
let renderRedirect;
let renderError;
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
    });
  }
  let reactHeaders = new Headers();
  let status = serverResponse.status;
  let statusText = serverResponse.statusText;
  let html = await renderHTML(getPayload, {
    onError(error) {
      if (typeof error === "object" && error && "digest" in error && typeof error.digest === "string") {
        renderRedirect = decodeRedirectErrorDigest(error.digest);
        if (renderRedirect) {
          return error.digest;
        }
        let routeErrorResponse = decodeRouteErrorResponseDigest(error.digest);
        if (routeErrorResponse) {
          renderError = routeErrorResponse;
          status = routeErrorResponse.status;
          statusText = routeErrorResponse.statusText;
          return error.digest;
        }
      }
    },
    onHeaders(headers2) {
      for (const [key, value] of headers2) {
        reactHeaders.append(key, value);
      }
    }
  });
  const headers = new Headers(reactHeaders);
  for (const [key, value] of serverResponse.headers) {
    headers.append(key, value);
  }
  headers.set("Content-Type", "text/html; charset=utf-8");
  if (renderRedirect) {
    headers.set("Location", renderRedirect.location);
    return new Response(html, {
      status: renderRedirect.status,
      headers
    });
  }
  const redirectTransform = new TransformStream({
    flush(controller) {
      if (renderRedirect) {
        controller.enqueue(
          new TextEncoder().encode(
            `<meta http-equiv="refresh" content="0;url=${escapeHtml(renderRedirect.location)}"/>`
          )
        );
      }
    }
  });
  if (!hydrate) {
    return new Response(html.pipeThrough(redirectTransform), {
      status,
      statusText,
      headers
    });
  }
  if (!serverResponseB?.body) {
    throw new Error("Failed to clone server response");
  }
  const body2 = html.pipeThrough(injectRSCPayload(serverResponseB.body)).pipeThrough(redirectTransform);
  return new Response(body2, {
    status,
    statusText,
    headers
  });
} catch (reason) {
  if (reason instanceof Response) {
    return reason;
  }
  if (renderRedirect) {
    return new Response(`Redirect: ${renderRedirect.location}`, {
      status: renderRedirect.status,
      headers: {
        Location: renderRedirect.location
      }
    });
  }
  try {
    reason = renderError ?? reason;
    let [status, statusText] = isRouteErrorResponse(reason) ? [reason.status, reason.statusText] : [500, ""];
    let retryRedirect;
    let reactHeaders = new Headers();
    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
              );
            }
          }
        });
      },
      {
        onError(error) {
          if (typeof error === "object" && error && "digest" in error && typeof error.digest === "string") {
            retryRedirect = decodeRedirectErrorDigest(error.digest);
            if (retryRedirect) {
              return error.digest;
            }
            let routeErrorResponse = decodeRouteErrorResponseDigest(
              error.digest
            );
            if (routeErrorResponse) {
              status = routeErrorResponse.status;
              statusText = routeErrorResponse.statusText;
              return error.digest;
            }
          }
        },
        onHeaders(headers2) {
          for (const [key, value] of headers2) {
            reactHeaders.append(key, value);
          }
        }
      }
    );
    const headers = new Headers(reactHeaders);
    for (const [key, value] of serverResponse.headers) {
      headers.append(key, value);
    }
    headers.set("Content-Type", "text/html; charset=utf-8");
    if (retryRedirect) {
      headers.set("Location", retryRedirect.location);
      return new Response(html, {
        status: retryRedirect.status,
        headers
      });
    }
    const retryRedirectTransform = new TransformStream({
      flush(controller) {
        if (retryRedirect) {
          controller.enqueue(
            new TextEncoder().encode(
              `<meta http-equiv="refresh" content="0;url=${escapeHtml(retryRedirect.location)}"/>`
            )
          );
        }
      }
    });
    if (!hydrate) {
      return new Response(html.pipeThrough(retryRedirectTransform), {
        status,
        statusText,
        headers
      });
    }
    if (!serverResponseB?.body) {
      throw new Error("Failed to clone server response");
    }
    const body2 = html.pipeThrough(injectRSCPayload(serverResponseB.body)).pipeThrough(retryRedirectTransform);
    return new Response(body2, {
      status,
      statusText,
      headers
    });
  } catch {
  }
  throw reason;
}
2371}
2372function 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 router = 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_trailingSlashAwareDataRequests: true,
    // always on for RSC
    v8_passThroughRequests: true
    // always on for RSC
  },
  isSpaMode: false,
  ssr: true,
  criticalCss: "",
  manifest: {
    routes: {},
    version: "1",
    url: "",
    entry: {
      module: "",
      imports: []
    }
  },
  routeDiscovery: payload.routeDiscovery.mode === "initial" ? { mode: "initial", manifestPath: defaultManifestPath } : {
    mode: "lazy",
    manifestPath: payload.routeDiscovery.manifestPath || defaultManifestPath
  },
  routeModules: createRSCRouteModules(payload)
};
return /* @__PURE__ */ React4.createElement(RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React4.createElement(RSCRouterGlobalErrorBoundary, { location: payload.location }, /* @__PURE__ */ React4.createElement(FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React4.createElement(
  StaticRouterProvider,
  {
    context,
    router,
    hydrate: false,
    nonce: payload.nonce
  }
))));
2485}
2486function isReactServerRequest(url) {
return url.pathname.endsWith(".rsc");
2488}
2489function isManifestRequest(url) {
return url.pathname.endsWith(".manifest");
2491}
2492
2493// lib/dom/ssr/errors.ts
2494function 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;
2528}
2529
2530// lib/dom/ssr/hydration.tsx
2531function getHydrationData({
state,
routes,
getRouteInfo,
location,
basename,
isSpaMode
2538}) {
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;
2561}
2562
2563export {
ServerRouter,
createRoutesStub,
createCookie,
isCookie,
ServerMode,
setDevServerHooks,
createRequestHandler,
createSession,
isSession,
createSessionStorage,
createCookieSessionStorage,
createMemorySessionStorage,
href,
RSCRouterGlobalErrorBoundary,
RSCDefaultRootErrorBoundary,
populateRSCRouteModules,
routeRSCServerRequest,
RSCStaticRouter,
deserializeErrors,
getHydrationData
2584};
1	`/**`
2	`* react-router v7.15.0`
3	`*`
4	`* Copyright (c) Remix Software Inc.`
5	`*`
6	`* This source code is licensed under the MIT license found in the`
7	`* LICENSE.md file in the root directory of this source tree.`
8	`*`
9	`* @license MIT`
10	`*/`
11	`import {`
12	`ENABLE_DEV_WARNINGS,`
13	`ErrorResponseImpl,`
14	`FrameworkContext,`
15	`NO_BODY_STATUS_CODES,`
16	`Outlet,`
17	`RSCRouterContext,`
18	`RemixErrorBoundary,`
19	`RouterContextProvider,`
20	`RouterProvider,`
21	`SINGLE_FETCH_REDIRECT_STATUS,`
22	`SingleFetchRedirectSymbol,`
23	`StaticRouterProvider,`
24	`StreamTransfer,`
25	`URL_LIMIT,`
26	`convertRoutesToDataRoutes,`
27	`createMemoryRouter,`
28	`createServerRoutes,`
29	`createStaticHandler,`
30	`createStaticRouter,`
31	`decodeRedirectErrorDigest,`
32	`decodeRouteErrorResponseDigest,`
33	`decodeViaTurboStream,`
34	`encode,`
35	`escapeHtml,`
36	`getManifestPath,`
37	`getStaticContextFromError,`
38	`instrumentHandler,`
39	`isDataWithResponseInit,`
40	`isRedirectResponse,`