UNPKG

react-router/dist/development/index.js

Version:
77.1 kBJavaScriptView Raw
1"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }/**
* react-router v7.10.0
*
* Copyright (c) Remix Software Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE.md file in the root directory of this source tree.
*
* @license MIT
*/
11"use client";
12
13
14
15
16
17var _chunk26EFLBGXjs = require('./chunk-26EFLBGX.js');
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43var _chunkAWUYHSQUjs = require('./chunk-AWUYHSQU.js');
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148var _chunk54KWOGSJjs = require('./chunk-54KWOGSJ.js');
149
150// lib/dom/ssr/server.tsx
151var _react = require('react'); var React = _interopRequireWildcard(_react); var React2 = _interopRequireWildcard(_react); var React3 = _interopRequireWildcard(_react);
152function ServerRouter({
context,
url,
nonce
156}) {
if (typeof url === "string") {
  url = new URL(url);
}
let { manifest, routeModules, criticalCss, serverHandoffString } = context;
let routes = _chunk54KWOGSJjs.createServerRoutes.call(void 0, 
  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 && _chunk54KWOGSJjs.shouldHydrateRouteLoader.call(void 0, 
    routeId,
    route.clientLoader,
    manifestRoute.hasLoader,
    context.isSpaMode
  ) && (route.HydrateFallback || !manifestRoute.hasLoader)) {
    delete context.staticHandlerContext.loaderData[routeId];
  }
}
let router = _chunkAWUYHSQUjs.createStaticRouter.call(void 0, routes, context.staticHandlerContext);
return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
  _chunk54KWOGSJjs.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(_chunk54KWOGSJjs.RemixErrorBoundary, { location: router.state.location }, /* @__PURE__ */ React.createElement(
    _chunkAWUYHSQUjs.StaticRouterProvider,
    {
      router,
      context: context.staticHandlerContext,
      hydrate: false
    }
  ))
), context.serverHandoffStream ? /* @__PURE__ */ React.createElement(React.Suspense, null, /* @__PURE__ */ React.createElement(
  _chunk54KWOGSJjs.StreamTransfer,
  {
    context,
    identifier: 0,
    reader: context.serverHandoffStream.getReader(),
    textDecoder: new TextDecoder(),
    nonce
  }
)) : null);
218}
219
220// lib/dom/ssr/routes-test-stub.tsx
221
222function 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: {
        unstable_subResourceIntegrity: _optionalChain([future, 'optionalAccess', _2 => _2.unstable_subResourceIntegrity]) === true,
        v8_middleware: _optionalChain([future, 'optionalAccess', _3 => _3.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`
      _chunk54KWOGSJjs.convertRoutesToDataRoutes.call(void 0, routes, (r) => r),
      _context !== void 0 ? _context : _optionalChain([future, 'optionalAccess', _4 => _4.v8_middleware]) ? new (0, _chunk54KWOGSJjs.RouterContextProvider)() : {},
      frameworkContextRef.current.manifest,
      frameworkContextRef.current.routeModules
    );
    routerRef.current = _chunk54KWOGSJjs.createMemoryRouter.call(void 0, patched, {
      initialEntries,
      initialIndex,
      hydrationData
    });
  }
  return /* @__PURE__ */ React2.createElement(_chunk54KWOGSJjs.FrameworkContext.Provider, { value: frameworkContextRef.current }, /* @__PURE__ */ React2.createElement(_chunk54KWOGSJjs.RouterProvider, { router: routerRef.current }));
};
264}
265function 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 ? _chunk54KWOGSJjs.withComponentProps.call(void 0, route.Component) : void 0,
    HydrateFallback: route.HydrateFallback ? _chunk54KWOGSJjs.withHydrateFallbackProps.call(void 0, route.HydrateFallback) : void 0,
    ErrorBoundary: route.ErrorBoundary ? _chunk54KWOGSJjs.withErrorBoundaryProps.call(void 0, 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 || _chunk54KWOGSJjs.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;
});
331}
332
333// lib/server-runtime/cookies.ts
334var _cookie = require('cookie');
335
336// lib/server-runtime/crypto.ts
337var encoder = /* @__PURE__ */ new TextEncoder();
338var 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;
347};
348var 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;
}
361};
362var createKey = async (secret, usages) => crypto.subtle.importKey(
"raw",
encoder.encode(secret),
{ name: "HMAC", hash: "SHA-256" },
false,
usages
368);
369function byteStringToUint8Array(byteString) {
let array = new Uint8Array(byteString.length);
for (let i = 0; i < byteString.length; i++) {
  array[i] = byteString.charCodeAt(i);
}
return array;
375}
376
377// lib/server-runtime/cookies.ts
378var 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 = _cookie.parse.call(void 0, 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 _cookie.serialize.call(void 0, 
      name,
      value === "" ? "" : await encodeCookieValue(value, secrets),
      {
        ...options,
        ...serializeOptions
      }
    );
  }
};
421};
422var isCookie = (object) => {
return object != null && typeof object.name === "string" && typeof object.isSigned === "boolean" && typeof object.parse === "function" && typeof object.serialize === "function";
424};
425async function encodeCookieValue(value, secrets) {
let encoded = encodeData(value);
if (secrets.length > 0) {
  encoded = await sign(encoded, secrets[0]);
}
return encoded;
431}
432async 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);
443}
444function encodeData(value) {
return btoa(myUnescape(encodeURIComponent(JSON.stringify(value))));
446}
447function decodeData(value) {
try {
  return JSON.parse(decodeURIComponent(myEscape(atob(value))));
} catch (error) {
  return {};
}
453}
454function 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;
473}
474function hex(code, length) {
let result = code.toString(16);
while (result.length < length) result = "0" + result;
return result;
478}
479function 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;
506}
507function warnOnceAboutExpiresCookie(name, expires) {
_chunk54KWOGSJjs.warnOnce.call(void 0, 
  !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.`
);
512}
513
514// lib/server-runtime/entry.ts
515function createEntryRouteModules(manifest) {
return Object.keys(manifest).reduce((memo, routeId) => {
  let route = manifest[routeId];
  if (route) {
    memo[routeId] = route.module;
  }
  return memo;
}, {});
523}
524
525// lib/server-runtime/mode.ts
526var ServerMode = /* @__PURE__ */ ((ServerMode2) => {
ServerMode2["Development"] = "development";
ServerMode2["Production"] = "production";
ServerMode2["Test"] = "test";
return ServerMode2;
531})(ServerMode || {});
532function isServerMode(value) {
return value === "development" /* Development */ || value === "production" /* Production */ || value === "test" /* Test */;
534}
535
536// lib/server-runtime/errors.ts
537function 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;
544}
545function sanitizeErrors(errors, serverMode) {
return Object.entries(errors).reduce((acc, [routeId, error]) => {
  return Object.assign(acc, { [routeId]: sanitizeError(error, serverMode) });
}, {});
549}
550function serializeError(error, serverMode) {
let sanitized = sanitizeError(error, serverMode);
return {
  message: sanitized.message,
  stack: sanitized.stack
};
556}
557function serializeErrors(errors, serverMode) {
if (!errors) return null;
let entries = Object.entries(errors);
let serialized = {};
for (let [key, val] of entries) {
  if (_chunk54KWOGSJjs.isRouteErrorResponse.call(void 0, 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;
583}
584
585// lib/server-runtime/routeMatching.ts
586function matchServerRoutes(routes, pathname, basename) {
let matches = _chunk54KWOGSJjs.matchRoutes.call(void 0, 
  routes,
  pathname,
  basename
);
if (!matches) return null;
return matches.map((match) => ({
  params: match.params,
  pathname: match.pathname,
  route: match.route
}));
598}
599
600// lib/server-runtime/data.ts
601async 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 (_chunk54KWOGSJjs.isDataWithResponseInit.call(void 0, result) && result.init && result.init.status && _chunk54KWOGSJjs.isRedirectStatusCode.call(void 0, result.init.status)) {
  throw new Response(null, result.init);
}
return result;
612}
613function 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);
636}
637function 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);
650}
651
652// lib/server-runtime/invariant.ts
653function invariant2(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);
}
660}
661
662// lib/server-runtime/dev.ts
663var globalDevServerHooksKey = "__reactRouterDevServerHooks";
664function setDevServerHooks(devServerHooks) {
globalThis[globalDevServerHooksKey] = devServerHooks;
666}
667function getDevServerHooks() {
return globalThis[globalDevServerHooksKey];
669}
670function getBuildTimeHeader(request, headerName) {
if (typeof process !== "undefined") {
  try {
    if (_optionalChain([process, 'access', _5 => _5.env, 'optionalAccess', _6 => _6.IS_RR_BUILD_REQUEST]) === "yes") {
      return request.headers.get(headerName);
    }
  } catch (e) {
  }
}
return null;
680}
681
682// lib/server-runtime/routes.ts
683function 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;
695}
696function createRoutes(manifest, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) {
return (routesByParentId[parentId] || []).map((route) => ({
  ...route,
  children: createRoutes(manifest, route.id, routesByParentId)
}));
701}
702function 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;
        invariant2(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 _chunk54KWOGSJjs.decodeViaTurboStream.call(void 0, stream, global);
        let data2 = decoded.value;
        if (data2 && _chunk54KWOGSJjs.SingleFetchRedirectSymbol in data2) {
          let result = data2[_chunk54KWOGSJjs.SingleFetchRedirectSymbol];
          let init = { status: result.status };
          if (result.reload) {
            throw _chunk54KWOGSJjs.redirectDocument.call(void 0, result.redirect, init);
          } else if (result.replace) {
            throw _chunk54KWOGSJjs.replace.call(void 0, result.redirect, init);
          } else {
            throw _chunk54KWOGSJjs.redirect.call(void 0, result.redirect, init);
          }
        } else {
          invariant2(
            data2 && route.id in data2,
            "Unable to decode prerendered data"
          );
          let result = data2[route.id];
          invariant2(
            "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
  };
});
772}
773
774// lib/server-runtime/serverHandoff.ts
775function createServerHandoffString(serverHandoff) {
return _chunk54KWOGSJjs.escapeHtml.call(void 0, JSON.stringify(serverHandoff));
777}
778
779// lib/server-runtime/headers.ts
780var _setcookieparser = require('set-cookie-parser');
781function getDocumentHeaders(context, build) {
return getDocumentHeadersImpl(context, (m) => {
  let route = build.routes[m.route.id];
  invariant2(route, `Route with id "${m.route.id}" not found in build`);
  return route.module.headers;
});
787}
788function 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));
837}
838function prependCookies(parentHeaders, childHeaders) {
let parentSetCookieString = parentHeaders.get("Set-Cookie");
if (parentSetCookieString) {
  let cookies = _setcookieparser.splitCookiesString.call(void 0, parentSetCookieString);
  let childCookies = new Set(childHeaders.getSetCookie());
  cookies.forEach((cookie) => {
    if (!childCookies.has(cookie)) {
      childHeaders.append("Set-Cookie", cookie);
    }
  });
}
849}
850
851// lib/server-runtime/single-fetch.ts
852var SERVER_NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([
..._chunk54KWOGSJjs.NO_BODY_STATUS_CODES,
304
855]);
856async 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 _chunk54KWOGSJjs.isResponse.call(void 0, 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 (_chunk54KWOGSJjs.isRedirectStatusCode.call(void 0, context.statusCode) && headers.has("Location")) {
    return new Response(null, { status: context.statusCode, headers });
  }
  if (context.errors) {
    Object.values(context.errors).forEach((err) => {
      if (!_chunk54KWOGSJjs.isRouteErrorResponse.call(void 0, 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
  });
}
920}
921async 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 _chunk54KWOGSJjs.isResponse.call(void 0, 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 (_chunk54KWOGSJjs.isRedirectStatusCode.call(void 0, context.statusCode) && headers.has("Location")) {
    return new Response(null, { status: context.statusCode, headers });
  }
  if (context.errors) {
    Object.values(context.errors).forEach((err) => {
      if (!_chunk54KWOGSJjs.isRouteErrorResponse.call(void 0, 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
  });
}
992}
993function generateSingleFetchResponse(request, build, serverMode, {
result,
headers,
status
997}) {
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
  }
);
1017}
1018function 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" ? { [_chunk54KWOGSJjs.SingleFetchRedirectSymbol]: redirect2 } : redirect2,
  headers,
  status: _chunk54KWOGSJjs.SINGLE_FETCH_REDIRECT_STATUS
});
1032}
1033function getSingleFetchRedirect(status, headers, basename) {
let redirect2 = headers.get("Location");
if (basename) {
  redirect2 = _chunk54KWOGSJjs.stripBasename.call(void 0, 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")
};
1054}
1055function 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 _chunk54KWOGSJjs.encode.call(void 0, data2, {
  signal: controller.signal,
  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 _chunk54KWOGSJjs.ErrorResponseImpl) {
        let { data: data3, status, statusText } = value;
        return ["ErrorResponse", data3, status, statusText];
      }
      if (value && typeof value === "object" && _chunk54KWOGSJjs.SingleFetchRedirectSymbol in value) {
        return ["SingleFetchRedirect", value[_chunk54KWOGSJjs.SingleFetchRedirectSymbol]];
      }
    }
  ],
  postPlugins: [
    (value) => {
      if (!value) return;
      if (typeof value !== "object") return;
      return [
        "SingleFetchClassInstance",
        Object.fromEntries(Object.entries(value))
      ];
    },
    () => ["SingleFetchFallback"]
  ]
});
1091}
1092
1093// lib/server-runtime/server.ts
1094function derive(build, mode) {
let routes = createRoutes(build.routes);
let dataRoutes = createStaticHandlerDataRoutes(build.routes, build.future);
let serverMode = isServerMode(mode) ? mode : "production" /* Production */;
let staticHandler = _chunk54KWOGSJjs.createStaticHandler.call(void 0, dataRoutes, {
  basename: build.basename,
  unstable_instrumentations: build.entry.module.unstable_instrumentations
});
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
      _chunk54KWOGSJjs.isRouteErrorResponse.call(void 0, error) && error.error ? error.error : error
    );
  }
});
let requestHandler = async (request, initialContext) => {
  let params = {};
  let loadContext;
  let handleError = (error) => {
    if (mode === "development" /* Development */) {
      _optionalChain([getDevServerHooks, 'call', _7 => _7(), 'optionalAccess', _8 => _8.processRequestError, 'optionalCall', _9 => _9(error)]);
    }
    errorHandler(error, {
      context: loadContext,
      params,
      request
    });
  };
  if (build.future.v8_middleware) {
    if (initialContext && !(initialContext instanceof _chunk54KWOGSJjs.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 (0, _chunk54KWOGSJjs.RouterContextProvider)();
  } else {
    loadContext = initialContext || {};
  }
  let url = new URL(request.url);
  let normalizedBasename = build.basename || "/";
  let normalizedPath = url.pathname;
  if (_chunk54KWOGSJjs.stripBasename.call(void 0, normalizedPath, normalizedBasename) === "/_root.data") {
    normalizedPath = normalizedBasename;
  } else if (normalizedPath.endsWith(".data")) {
    normalizedPath = normalizedPath.replace(/\.data$/, "");
  }
  if (_chunk54KWOGSJjs.stripBasename.call(void 0, 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 = _chunk54KWOGSJjs.stripBasename.call(void 0, decodedPath, normalizedBasename);
      if (strippedPath == null) {
        errorHandler(
          new (0, _chunk54KWOGSJjs.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 (0, _chunk54KWOGSJjs.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 = _chunk54KWOGSJjs.getManifestPath.call(void 0, 
    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 (_chunk54KWOGSJjs.isRedirectResponse.call(void 0, 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 (_chunk54KWOGSJjs.isRedirectResponse.call(void 0, 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" /* Development */ && _optionalChain([getDevServerHooks, 'call', _10 => _10(), 'optionalAccess', _11 => _11.getCriticalCss])) {
      criticalCss = await _optionalChain([getDevServerHooks, 'call', _12 => _12(), 'optionalAccess', _13 => _13.getCriticalCss, 'optionalCall', _14 => _14(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 = _chunk54KWOGSJjs.instrumentHandler.call(void 0, 
    requestHandler,
    build.entry.module.unstable_instrumentations.map((i) => i.handler).filter(Boolean)
  );
}
return {
  routes,
  dataRoutes,
  serverMode,
  staticHandler,
  errorHandler,
  requestHandler
};
1306}
1307var 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);
};
1333};
1334async 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 });
1377}
1378async 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;
1397}
1398async 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 (!_chunk54KWOGSJjs.isResponse.call(void 0, innerResult)) {
          innerResult = await renderHtml(innerResult, isSpaMode);
        }
        return innerResult;
      } catch (error) {
        handleError(error);
        return new Response(null, { status: 500 });
      }
    } : void 0
  });
  if (!_chunk54KWOGSJjs.isResponse.call(void 0, 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 (!_chunk54KWOGSJjs.isRouteErrorResponse.call(void 0, 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 (_chunk54KWOGSJjs.isResponse.call(void 0, error)) {
      try {
        let data2 = await unwrapResponse(error);
        errorForSecondRender = new (0, _chunk54KWOGSJjs.ErrorResponseImpl)(
          error.status,
          error.statusText,
          data2
        );
      } catch (e) {
      }
    }
    context = _chunk54KWOGSJjs.getStaticContextFromError.call(void 0, 
      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);
    }
  }
}
1532}
1533async 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 (_chunk54KWOGSJjs.isResponse.call(void 0, result)) {
    return result;
  }
  if (typeof result === "string") {
    return new Response(result);
  }
  return Response.json(result);
}
function handleQueryRouteError(error) {
  if (_chunk54KWOGSJjs.isResponse.call(void 0, error)) {
    return error;
  }
  if (_chunk54KWOGSJjs.isRouteErrorResponse.call(void 0, 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);
}
1578}
1579function 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
  }
);
1591}
1592function returnLastResortErrorResponse(error, serverMode) {
let message = "Unexpected Server Error";
if (serverMode !== "production" /* Production */) {
  message += `
1596
1597${String(error)}`;
}
return new Response(message, {
  status: 500,
  headers: {
    "Content-Type": "text/plain"
  }
});
1605}
1606function unwrapResponse(response) {
let contentType = response.headers.get("Content-Type");
return contentType && /\bapplication\/json\b/.test(contentType) ? response.body == null ? null : response.json() : response.text();
1609}
1610
1611// lib/server-runtime/sessions.ts
1612function flash(name) {
return `__flash_${name}__`;
1614}
1615var 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);
  }
};
1647};
1648var 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";
1650};
1651function createSessionStorage({
cookie: cookieArg,
createData,
readData,
updateData,
deleteData
1657}) {
let cookie = isCookie(cookieArg) ? cookieArg : createCookie(_optionalChain([cookieArg, 'optionalAccess', _15 => _15.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 = _optionalChain([options, 'optionalAccess', _16 => _16.maxAge]) != null ? new Date(Date.now() + options.maxAge * 1e3) : _optionalChain([options, 'optionalAccess', _17 => _17.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)
    });
  }
};
1685}
1686function warnOnceAboutSigningSessionCookie(cookie) {
_chunk54KWOGSJjs.warnOnce.call(void 0, 
  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.`
);
1691}
1692
1693// lib/server-runtime/sessions/cookieStorage.ts
1694function createCookieSessionStorage({ cookie: cookieArg } = {}) {
let cookie = isCookie(cookieArg) ? cookieArg : createCookie(_optionalChain([cookieArg, 'optionalAccess', _18 => _18.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)
    });
  }
};
1720}
1721
1722// lib/server-runtime/sessions/memoryStorage.ts
1723function 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);
  }
});
1749}
1750
1751// lib/href.ts
1752function 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 = _optionalChain([params, 'optionalAccess', _19 => _19[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 = _optionalChain([params, 'optionalAccess', _20 => _20["*"]]);
  if (value !== void 0) {
    result += "/" + value;
  }
}
return result || "/";
1775}
1776function 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);
1785}
1786
1787// lib/rsc/server.ssr.tsx
1788
1789
1790// lib/rsc/html-stream/server.ts
1791var encoder2 = new TextEncoder();
1792var trailer = "</body></html>";
1793function 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>"));
  }
});
1836}
1837async 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);
}
1864}
1865function writeChunk(chunk, controller) {
controller.enqueue(
  encoder2.encode(
    `<script>${escapeScript(
      `(self.__FLIGHT_DATA||=[]).push(${chunk})`
    )}</script>`
  )
);
1873}
1874function escapeScript(script) {
return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
1876}
1877
1878// lib/rsc/server.ssr.tsx
1879var REACT_USE = "use";
1880var useImpl = React3[REACT_USE];
1881function useSafe(promise) {
if (useImpl) {
  return useImpl(promise);
}
throw new Error("React Router v7 requires React 19+ for RSC features.");
1886}
1887async function routeRSCServerRequest({
request,
fetchServer,
createFromReadableStream,
renderHTML,
hydrate = true
1893}) {
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 === _chunk54KWOGSJjs.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(_optionalChain([serverResponseB, 'optionalAccess', _21 => _21.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 (!_optionalChain([serverResponseB, 'optionalAccess', _22 => _22.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 = _chunk54KWOGSJjs.isRouteErrorResponse.call(void 0, 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 (!_optionalChain([serverResponseB, 'optionalAccess', _23 => _23.body])) {
      throw new Error("Failed to clone server response");
    }
    const body2 = html.pipeThrough(injectRSCPayload(serverResponseB.body));
    return new Response(body2, {
      status,
      headers
    });
  } catch (e2) {
  }
  throw reason;
}
2052}
2053function 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 (_chunk54KWOGSJjs.shouldHydrateRouteLoader.call(void 0, 
    match.id,
    match.clientLoader,
    match.hasLoader,
    false
  ) && (match.hydrateFallbackElement || !match.hasLoader)) {
    delete patchedLoaderData[match.id];
  }
}
const context = {
  get _deepestRenderedBoundaryId() {
    return _nullishCoalesce(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 = _chunkAWUYHSQUjs.createStaticRouter.call(void 0, 
  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: _chunk26EFLBGXjs.createRSCRouteModules.call(void 0, payload)
};
return /* @__PURE__ */ React3.createElement(_chunk54KWOGSJjs.RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React3.createElement(_chunk26EFLBGXjs.RSCRouterGlobalErrorBoundary, { location: payload.location }, /* @__PURE__ */ React3.createElement(_chunk54KWOGSJjs.FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React3.createElement(
  _chunkAWUYHSQUjs.StaticRouterProvider,
  {
    context,
    router,
    hydrate: false,
    nonce: payload.nonce
  }
))));
2160}
2161function isReactServerRequest(url) {
return url.pathname.endsWith(".rsc");
2163}
2164function isManifestRequest(url) {
return url.pathname.endsWith(".manifest");
2166}
2167
2168// lib/dom/ssr/errors.ts
2169function 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 (0, _chunk54KWOGSJjs.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;
2203}
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332exports.Await = _chunk54KWOGSJjs.Await; exports.BrowserRouter = _chunkAWUYHSQUjs.BrowserRouter; exports.Form = _chunkAWUYHSQUjs.Form; exports.HashRouter = _chunkAWUYHSQUjs.HashRouter; exports.IDLE_BLOCKER = _chunk54KWOGSJjs.IDLE_BLOCKER; exports.IDLE_FETCHER = _chunk54KWOGSJjs.IDLE_FETCHER; exports.IDLE_NAVIGATION = _chunk54KWOGSJjs.IDLE_NAVIGATION; exports.Link = _chunkAWUYHSQUjs.Link; exports.Links = _chunk54KWOGSJjs.Links; exports.MemoryRouter = _chunk54KWOGSJjs.MemoryRouter; exports.Meta = _chunk54KWOGSJjs.Meta; exports.NavLink = _chunkAWUYHSQUjs.NavLink; exports.Navigate = _chunk54KWOGSJjs.Navigate; exports.NavigationType = _chunk54KWOGSJjs.Action; exports.Outlet = _chunk54KWOGSJjs.Outlet; exports.PrefetchPageLinks = _chunk54KWOGSJjs.PrefetchPageLinks; exports.Route = _chunk54KWOGSJjs.Route; exports.Router = _chunk54KWOGSJjs.Router; exports.RouterContextProvider = _chunk54KWOGSJjs.RouterContextProvider; exports.RouterProvider = _chunk54KWOGSJjs.RouterProvider; exports.Routes = _chunk54KWOGSJjs.Routes; exports.Scripts = _chunk54KWOGSJjs.Scripts; exports.ScrollRestoration = _chunkAWUYHSQUjs.ScrollRestoration; exports.ServerRouter = ServerRouter; exports.StaticRouter = _chunkAWUYHSQUjs.StaticRouter; exports.StaticRouterProvider = _chunkAWUYHSQUjs.StaticRouterProvider; exports.UNSAFE_AwaitContextProvider = _chunk54KWOGSJjs.AwaitContextProvider; exports.UNSAFE_DataRouterContext = _chunk54KWOGSJjs.DataRouterContext; exports.UNSAFE_DataRouterStateContext = _chunk54KWOGSJjs.DataRouterStateContext; exports.UNSAFE_ErrorResponseImpl = _chunk54KWOGSJjs.ErrorResponseImpl; exports.UNSAFE_FetchersContext = _chunk54KWOGSJjs.FetchersContext; exports.UNSAFE_FrameworkContext = _chunk54KWOGSJjs.FrameworkContext; exports.UNSAFE_LocationContext = _chunk54KWOGSJjs.LocationContext; exports.UNSAFE_NavigationContext = _chunk54KWOGSJjs.NavigationContext; exports.UNSAFE_RSCDefaultRootErrorBoundary = _chunk26EFLBGXjs.RSCDefaultRootErrorBoundary; exports.UNSAFE_RemixErrorBoundary = _chunk54KWOGSJjs.RemixErrorBoundary; exports.UNSAFE_RouteContext = _chunk54KWOGSJjs.RouteContext; exports.UNSAFE_ServerMode = ServerMode; exports.UNSAFE_SingleFetchRedirectSymbol = _chunk54KWOGSJjs.SingleFetchRedirectSymbol; exports.UNSAFE_ViewTransitionContext = _chunk54KWOGSJjs.ViewTransitionContext; exports.UNSAFE_WithComponentProps = _chunk54KWOGSJjs.WithComponentProps; exports.UNSAFE_WithErrorBoundaryProps = _chunk54KWOGSJjs.WithErrorBoundaryProps; exports.UNSAFE_WithHydrateFallbackProps = _chunk54KWOGSJjs.WithHydrateFallbackProps; exports.UNSAFE_createBrowserHistory = _chunk54KWOGSJjs.createBrowserHistory; exports.UNSAFE_createClientRoutes = _chunk54KWOGSJjs.createClientRoutes; exports.UNSAFE_createClientRoutesWithHMRRevalidationOptOut = _chunk54KWOGSJjs.createClientRoutesWithHMRRevalidationOptOut; exports.UNSAFE_createRouter = _chunk54KWOGSJjs.createRouter; exports.UNSAFE_decodeViaTurboStream = _chunk54KWOGSJjs.decodeViaTurboStream; exports.UNSAFE_deserializeErrors = deserializeErrors; exports.UNSAFE_getHydrationData = _chunk26EFLBGXjs.getHydrationData; exports.UNSAFE_getPatchRoutesOnNavigationFunction = _chunk54KWOGSJjs.getPatchRoutesOnNavigationFunction; exports.UNSAFE_getTurboStreamSingleFetchDataStrategy = _chunk54KWOGSJjs.getTurboStreamSingleFetchDataStrategy; exports.UNSAFE_hydrationRouteProperties = _chunk54KWOGSJjs.hydrationRouteProperties; exports.UNSAFE_invariant = _chunk54KWOGSJjs.invariant; exports.UNSAFE_mapRouteProperties = _chunk54KWOGSJjs.mapRouteProperties; exports.UNSAFE_shouldHydrateRouteLoader = _chunk54KWOGSJjs.shouldHydrateRouteLoader; exports.UNSAFE_useFogOFWarDiscovery = _chunk54KWOGSJjs.useFogOFWarDiscovery; exports.UNSAFE_useScrollRestoration = _chunkAWUYHSQUjs.useScrollRestoration; exports.UNSAFE_withComponentProps = _chunk54KWOGSJjs.withComponentProps; exports.UNSAFE_withErrorBoundaryProps = _chunk54KWOGSJjs.withErrorBoundaryProps; exports.UNSAFE_withHydrateFallbackProps = _chunk54KWOGSJjs.withHydrateFallbackProps; exports.createBrowserRouter = _chunkAWUYHSQUjs.createBrowserRouter; exports.createContext = _chunk54KWOGSJjs.createContext; exports.createCookie = createCookie; exports.createCookieSessionStorage = createCookieSessionStorage; exports.createHashRouter = _chunkAWUYHSQUjs.createHashRouter; exports.createMemoryRouter = _chunk54KWOGSJjs.createMemoryRouter; exports.createMemorySessionStorage = createMemorySessionStorage; exports.createPath = _chunk54KWOGSJjs.createPath; exports.createRequestHandler = createRequestHandler; exports.createRoutesFromChildren = _chunk54KWOGSJjs.createRoutesFromChildren; exports.createRoutesFromElements = _chunk54KWOGSJjs.createRoutesFromElements; exports.createRoutesStub = createRoutesStub; exports.createSearchParams = _chunkAWUYHSQUjs.createSearchParams; exports.createSession = createSession; exports.createSessionStorage = createSessionStorage; exports.createStaticHandler = _chunkAWUYHSQUjs.createStaticHandler; exports.createStaticRouter = _chunkAWUYHSQUjs.createStaticRouter; exports.data = _chunk54KWOGSJjs.data; exports.generatePath = _chunk54KWOGSJjs.generatePath; exports.href = href; exports.isCookie = isCookie; exports.isRouteErrorResponse = _chunk54KWOGSJjs.isRouteErrorResponse; exports.isSession = isSession; exports.matchPath = _chunk54KWOGSJjs.matchPath; exports.matchRoutes = _chunk54KWOGSJjs.matchRoutes; exports.parsePath = _chunk54KWOGSJjs.parsePath; exports.redirect = _chunk54KWOGSJjs.redirect; exports.redirectDocument = _chunk54KWOGSJjs.redirectDocument; exports.renderMatches = _chunk54KWOGSJjs.renderMatches; exports.replace = _chunk54KWOGSJjs.replace; exports.resolvePath = _chunk54KWOGSJjs.resolvePath; exports.unstable_HistoryRouter = _chunkAWUYHSQUjs.HistoryRouter; exports.unstable_RSCStaticRouter = RSCStaticRouter; exports.unstable_routeRSCServerRequest = routeRSCServerRequest; exports.unstable_setDevServerHooks = setDevServerHooks; exports.unstable_usePrompt = _chunkAWUYHSQUjs.usePrompt; exports.unstable_useRoute = _chunk54KWOGSJjs.useRoute; exports.useActionData = _chunk54KWOGSJjs.useActionData; exports.useAsyncError = _chunk54KWOGSJjs.useAsyncError; exports.useAsyncValue = _chunk54KWOGSJjs.useAsyncValue; exports.useBeforeUnload = _chunkAWUYHSQUjs.useBeforeUnload; exports.useBlocker = _chunk54KWOGSJjs.useBlocker; exports.useFetcher = _chunkAWUYHSQUjs.useFetcher; exports.useFetchers = _chunkAWUYHSQUjs.useFetchers; exports.useFormAction = _chunkAWUYHSQUjs.useFormAction; exports.useHref = _chunk54KWOGSJjs.useHref; exports.useInRouterContext = _chunk54KWOGSJjs.useInRouterContext; exports.useLinkClickHandler = _chunkAWUYHSQUjs.useLinkClickHandler; exports.useLoaderData = _chunk54KWOGSJjs.useLoaderData; exports.useLocation = _chunk54KWOGSJjs.useLocation; exports.useMatch = _chunk54KWOGSJjs.useMatch; exports.useMatches = _chunk54KWOGSJjs.useMatches; exports.useNavigate = _chunk54KWOGSJjs.useNavigate; exports.useNavigation = _chunk54KWOGSJjs.useNavigation; exports.useNavigationType = _chunk54KWOGSJjs.useNavigationType; exports.useOutlet = _chunk54KWOGSJjs.useOutlet; exports.useOutletContext = _chunk54KWOGSJjs.useOutletContext; exports.useParams = _chunk54KWOGSJjs.useParams; exports.useResolvedPath = _chunk54KWOGSJjs.useResolvedPath; exports.useRevalidator = _chunk54KWOGSJjs.useRevalidator; exports.useRouteError = _chunk54KWOGSJjs.useRouteError; exports.useRouteLoaderData = _chunk54KWOGSJjs.useRouteLoaderData; exports.useRoutes = _chunk54KWOGSJjs.useRoutes; exports.useSearchParams = _chunkAWUYHSQUjs.useSearchParams; exports.useSubmit = _chunkAWUYHSQUjs.useSubmit; exports.useViewTransitionState = _chunkAWUYHSQUjs.useViewTransitionState;
1	"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' \|\| op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' \|\| op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' \|\| op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }/**
2	`* react-router v7.10.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	`"use client";`
12
13
14
15
16
17	`var _chunk26EFLBGXjs = require('./chunk-26EFLBGX.js');`
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40