UNPKG

react-router/dist/development/index-react-server.mjs

Version:
120 kBJavaScriptView Raw
1import { AsyncLocalStorage } from 'node:async_hooks';
2import * as React2 from 'react';
3import { splitCookiesString } from 'set-cookie-parser';
4import { UNSAFE_AwaitContextProvider, UNSAFE_WithComponentProps, Outlet as Outlet$1, UNSAFE_WithErrorBoundaryProps, UNSAFE_WithHydrateFallbackProps } from 'react-router/internal/react-server-client';
5export { BrowserRouter, Form, HashRouter, Link, Links, MemoryRouter, Meta, NavLink, Navigate, Outlet, Route, Router, RouterProvider, Routes, ScrollRestoration, StaticRouter, StaticRouterProvider, unstable_HistoryRouter } from 'react-router/internal/react-server-client';
6import { serialize, parse } from 'cookie';
7
8/**
* react-router v7.14.1
*
* 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
*/
18var __typeError = (msg) => {
throw TypeError(msg);
20};
21var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
22var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
23var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
24
25// lib/router/history.ts
26function invariant(value, message) {
if (value === false || value === null || typeof value === "undefined") {
  throw new Error(message);
}
30}
31function warning(cond, message) {
if (!cond) {
  if (typeof console !== "undefined") console.warn(message);
  try {
    throw new Error(message);
  } catch (e) {
  }
}
39}
40function createKey() {
return Math.random().toString(36).substring(2, 10);
42}
43function createLocation(current, to, state = null, key, unstable_mask) {
let location = {
  pathname: typeof current === "string" ? current : current.pathname,
  search: "",
  hash: "",
  ...typeof to === "string" ? parsePath(to) : to,
  state,
  // TODO: This could be cleaned up.  push/replace should probably just take
  // full Locations now and avoid the need to run through this flow at all
  // But that's a pretty big refactor to the current test suite so going to
  // keep as is for the time being and just let any incoming keys take precedence
  key: to && to.key || key || createKey(),
  unstable_mask
};
return location;
58}
59function createPath({
pathname = "/",
search = "",
hash = ""
63}) {
if (search && search !== "?")
  pathname += search.charAt(0) === "?" ? search : "?" + search;
if (hash && hash !== "#")
  pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
return pathname;
69}
70function parsePath(path) {
let parsedPath = {};
if (path) {
  let hashIndex = path.indexOf("#");
  if (hashIndex >= 0) {
    parsedPath.hash = path.substring(hashIndex);
    path = path.substring(0, hashIndex);
  }
  let searchIndex = path.indexOf("?");
  if (searchIndex >= 0) {
    parsedPath.search = path.substring(searchIndex);
    path = path.substring(0, searchIndex);
  }
  if (path) {
    parsedPath.pathname = path;
  }
}
return parsedPath;
88}
89
90// lib/router/instrumentation.ts
91var UninstrumentedSymbol = Symbol("Uninstrumented");
92function getRouteInstrumentationUpdates(fns, route) {
let aggregated = {
  lazy: [],
  "lazy.loader": [],
  "lazy.action": [],
  "lazy.middleware": [],
  middleware: [],
  loader: [],
  action: []
};
fns.forEach(
  (fn) => fn({
    id: route.id,
    index: route.index,
    path: route.path,
    instrument(i) {
      let keys = Object.keys(aggregated);
      for (let key of keys) {
        if (i[key]) {
          aggregated[key].push(i[key]);
        }
      }
    }
  })
);
let updates = {};
if (typeof route.lazy === "function" && aggregated.lazy.length > 0) {
  let instrumented = wrapImpl(aggregated.lazy, route.lazy, () => void 0);
  if (instrumented) {
    updates.lazy = instrumented;
  }
}
if (typeof route.lazy === "object") {
  let lazyObject = route.lazy;
  ["middleware", "loader", "action"].forEach((key) => {
    let lazyFn = lazyObject[key];
    let instrumentations = aggregated[`lazy.${key}`];
    if (typeof lazyFn === "function" && instrumentations.length > 0) {
      let instrumented = wrapImpl(instrumentations, lazyFn, () => void 0);
      if (instrumented) {
        updates.lazy = Object.assign(updates.lazy || {}, {
          [key]: instrumented
        });
      }
    }
  });
}
["loader", "action"].forEach((key) => {
  let handler = route[key];
  if (typeof handler === "function" && aggregated[key].length > 0) {
    let original = handler[UninstrumentedSymbol] ?? handler;
    let instrumented = wrapImpl(
      aggregated[key],
      original,
      (...args) => getHandlerInfo(args[0])
    );
    if (instrumented) {
      if (key === "loader" && original.hydrate === true) {
        instrumented.hydrate = true;
      }
      instrumented[UninstrumentedSymbol] = original;
      updates[key] = instrumented;
    }
  }
});
if (route.middleware && route.middleware.length > 0 && aggregated.middleware.length > 0) {
  updates.middleware = route.middleware.map((middleware) => {
    let original = middleware[UninstrumentedSymbol] ?? middleware;
    let instrumented = wrapImpl(
      aggregated.middleware,
      original,
      (...args) => getHandlerInfo(args[0])
    );
    if (instrumented) {
      instrumented[UninstrumentedSymbol] = original;
      return instrumented;
    }
    return middleware;
  });
}
return updates;
173}
174function wrapImpl(impls, handler, getInfo) {
if (impls.length === 0) {
  return null;
}
return async (...args) => {
  let result = await recurseRight(
    impls,
    getInfo(...args),
    () => handler(...args),
    impls.length - 1
  );
  if (result.type === "error") {
    throw result.value;
  }
  return result.value;
};
190}
191async function recurseRight(impls, info, handler, index) {
let impl = impls[index];
let result;
if (!impl) {
  try {
    let value = await handler();
    result = { type: "success", value };
  } catch (e) {
    result = { type: "error", value: e };
  }
} else {
  let handlerPromise = void 0;
  let callHandler = async () => {
    if (handlerPromise) {
      console.error("You cannot call instrumented handlers more than once");
    } else {
      handlerPromise = recurseRight(impls, info, handler, index - 1);
    }
    result = await handlerPromise;
    invariant(result, "Expected a result");
    if (result.type === "error" && result.value instanceof Error) {
      return { status: "error", error: result.value };
    }
    return { status: "success", error: void 0 };
  };
  try {
    await impl(callHandler, info);
  } catch (e) {
    console.error("An instrumentation function threw an error:", e);
  }
  if (!handlerPromise) {
    await callHandler();
  }
  await handlerPromise;
}
if (result) {
  return result;
}
return {
  type: "error",
  value: new Error("No result assigned in instrumentation chain.")
};
233}
234function getHandlerInfo(args) {
let { request, context, params, unstable_pattern } = args;
return {
  request: getReadonlyRequest(request),
  params: { ...params },
  unstable_pattern,
  context: getReadonlyContext(context)
};
242}
243function getReadonlyRequest(request) {
return {
  method: request.method,
  url: request.url,
  headers: {
    get: (...args) => request.headers.get(...args)
  }
};
251}
252function getReadonlyContext(context) {
if (isPlainObject(context)) {
  let frozen = { ...context };
  Object.freeze(frozen);
  return frozen;
} else {
  return {
    get: (ctx) => context.get(ctx)
  };
}
262}
263var objectProtoNames = Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
264function isPlainObject(thing) {
if (thing === null || typeof thing !== "object") {
  return false;
}
const proto = Object.getPrototypeOf(thing);
return proto === Object.prototype || proto === null || Object.getOwnPropertyNames(proto).sort().join("\0") === objectProtoNames;
270}
271
272// lib/router/utils.ts
273function createContext(defaultValue) {
return { defaultValue };
275}
276var _map;
277var RouterContextProvider = class {
/**
 * Create a new `RouterContextProvider` instance
 * @param init An optional initial context map to populate the provider with
 */
constructor(init) {
  __privateAdd(this, _map, /* @__PURE__ */ new Map());
  if (init) {
    for (let [context, value] of init) {
      this.set(context, value);
    }
  }
}
/**
 * Access a value from the context. If no value has been set for the context,
 * it will return the context's `defaultValue` if provided, or throw an error
 * if no `defaultValue` was set.
 * @param context The context to get the value for
 * @returns The value for the context, or the context's `defaultValue` if no
 * value was set
 */
get(context) {
  if (__privateGet(this, _map).has(context)) {
    return __privateGet(this, _map).get(context);
  }
  if (context.defaultValue !== void 0) {
    return context.defaultValue;
  }
  throw new Error("No value found for context");
}
/**
 * Set a value for the context. If the context already has a value set, this
 * will overwrite it.
 *
 * @param context The context to set the value for
 * @param value The value to set for the context
 * @returns {void}
 */
set(context, value) {
  __privateGet(this, _map).set(context, value);
}
318};
319_map = new WeakMap();
320var unsupportedLazyRouteObjectKeys = /* @__PURE__ */ new Set([
"lazy",
"caseSensitive",
"path",
"id",
"index",
"children"
327]);
328function isUnsupportedLazyRouteObjectKey(key) {
return unsupportedLazyRouteObjectKeys.has(
  key
);
332}
333var unsupportedLazyRouteFunctionKeys = /* @__PURE__ */ new Set([
"lazy",
"caseSensitive",
"path",
"id",
"index",
"middleware",
"children"
341]);
342function isUnsupportedLazyRouteFunctionKey(key) {
return unsupportedLazyRouteFunctionKeys.has(
  key
);
346}
347function isIndexRoute(route) {
return route.index === true;
349}
350function convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath = [], manifest = {}, allowInPlaceMutations = false) {
return routes.map((route, index) => {
  let treePath = [...parentPath, String(index)];
  let id = typeof route.id === "string" ? route.id : treePath.join("-");
  invariant(
    route.index !== true || !route.children,
    `Cannot specify children on an index route`
  );
  invariant(
    allowInPlaceMutations || !manifest[id],
    `Found a route id collision on id "${id}".  Route id's must be globally unique within Data Router usages`
  );
  if (isIndexRoute(route)) {
    let indexRoute = {
      ...route,
      id
    };
    manifest[id] = mergeRouteUpdates(
      indexRoute,
      mapRouteProperties(indexRoute)
    );
    return indexRoute;
  } else {
    let pathOrLayoutRoute = {
      ...route,
      id,
      children: void 0
    };
    manifest[id] = mergeRouteUpdates(
      pathOrLayoutRoute,
      mapRouteProperties(pathOrLayoutRoute)
    );
    if (route.children) {
      pathOrLayoutRoute.children = convertRoutesToDataRoutes(
        route.children,
        mapRouteProperties,
        treePath,
        manifest,
        allowInPlaceMutations
      );
    }
    return pathOrLayoutRoute;
  }
});
394}
395function mergeRouteUpdates(route, updates) {
return Object.assign(route, {
  ...updates,
  ...typeof updates.lazy === "object" && updates.lazy != null ? {
    lazy: {
      ...route.lazy,
      ...updates.lazy
    }
  } : {}
});
405}
406function matchRoutes(routes, locationArg, basename = "/") {
return matchRoutesImpl(routes, locationArg, basename, false);
408}
409function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
let pathname = stripBasename(location.pathname || "/", basename);
if (pathname == null) {
  return null;
}
let branches = flattenRoutes(routes);
rankRouteBranches(branches);
let matches = null;
for (let i = 0; matches == null && i < branches.length; ++i) {
  let decoded = decodePath(pathname);
  matches = matchRouteBranch(
    branches[i],
    decoded,
    allowPartial
  );
}
return matches;
427}
428function convertRouteMatchToUiMatch(match, loaderData) {
let { route, pathname, params } = match;
return {
  id: route.id,
  pathname,
  params,
  data: loaderData[route.id],
  loaderData: loaderData[route.id],
  handle: route.handle
};
438}
439function flattenRoutes(routes, branches = [], parentsMeta = [], parentPath = "", _hasParentOptionalSegments = false) {
let flattenRoute = (route, index, hasParentOptionalSegments = _hasParentOptionalSegments, relativePath) => {
  let meta = {
    relativePath: relativePath === void 0 ? route.path || "" : relativePath,
    caseSensitive: route.caseSensitive === true,
    childrenIndex: index,
    route
  };
  if (meta.relativePath.startsWith("/")) {
    if (!meta.relativePath.startsWith(parentPath) && hasParentOptionalSegments) {
      return;
    }
    invariant(
      meta.relativePath.startsWith(parentPath),
      `Absolute route path "${meta.relativePath}" nested under path "${parentPath}" is not valid. An absolute child route path must start with the combined path of all its parent routes.`
    );
    meta.relativePath = meta.relativePath.slice(parentPath.length);
  }
  let path = joinPaths([parentPath, meta.relativePath]);
  let routesMeta = parentsMeta.concat(meta);
  if (route.children && route.children.length > 0) {
    invariant(
      // Our types know better, but runtime JS may not!
      // @ts-expect-error
      route.index !== true,
      `Index routes must not have child routes. Please remove all child routes from route path "${path}".`
    );
    flattenRoutes(
      route.children,
      branches,
      routesMeta,
      path,
      hasParentOptionalSegments
    );
  }
  if (route.path == null && !route.index) {
    return;
  }
  branches.push({
    path,
    score: computeScore(path, route.index),
    routesMeta
  });
};
routes.forEach((route, index) => {
  if (route.path === "" || !route.path?.includes("?")) {
    flattenRoute(route, index);
  } else {
    for (let exploded of explodeOptionalSegments(route.path)) {
      flattenRoute(route, index, true, exploded);
    }
  }
});
return branches;
493}
494function explodeOptionalSegments(path) {
let segments = path.split("/");
if (segments.length === 0) return [];
let [first, ...rest] = segments;
let isOptional = first.endsWith("?");
let required = first.replace(/\?$/, "");
if (rest.length === 0) {
  return isOptional ? [required, ""] : [required];
}
let restExploded = explodeOptionalSegments(rest.join("/"));
let result = [];
result.push(
  ...restExploded.map(
    (subpath) => subpath === "" ? required : [required, subpath].join("/")
  )
);
if (isOptional) {
  result.push(...restExploded);
}
return result.map(
  (exploded) => path.startsWith("/") && exploded === "" ? "/" : exploded
);
516}
517function rankRouteBranches(branches) {
branches.sort(
  (a, b) => a.score !== b.score ? b.score - a.score : compareIndexes(
    a.routesMeta.map((meta) => meta.childrenIndex),
    b.routesMeta.map((meta) => meta.childrenIndex)
  )
);
524}
525var paramRe = /^:[\w-]+$/;
526var dynamicSegmentValue = 3;
527var indexRouteValue = 2;
528var emptySegmentValue = 1;
529var staticSegmentValue = 10;
530var splatPenalty = -2;
531var isSplat = (s) => s === "*";
532function computeScore(path, index) {
let segments = path.split("/");
let initialScore = segments.length;
if (segments.some(isSplat)) {
  initialScore += splatPenalty;
}
if (index) {
  initialScore += indexRouteValue;
}
return segments.filter((s) => !isSplat(s)).reduce(
  (score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue),
  initialScore
);
545}
546function compareIndexes(a, b) {
let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
return siblings ? (
  // If two routes are siblings, we should try to match the earlier sibling
  // first. This allows people to have fine-grained control over the matching
  // behavior by simply putting routes with identical paths in the order they
  // want them tried.
  a[a.length - 1] - b[b.length - 1]
) : (
  // Otherwise, it doesn't really make sense to rank non-siblings by index,
  // so they sort equally.
  0
);
559}
560function matchRouteBranch(branch, pathname, allowPartial = false) {
let { routesMeta } = branch;
let matchedParams = {};
let matchedPathname = "/";
let matches = [];
for (let i = 0; i < routesMeta.length; ++i) {
  let meta = routesMeta[i];
  let end = i === routesMeta.length - 1;
  let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
  let match = matchPath(
    { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },
    remainingPathname
  );
  let route = meta.route;
  if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {
    match = matchPath(
      {
        path: meta.relativePath,
        caseSensitive: meta.caseSensitive,
        end: false
      },
      remainingPathname
    );
  }
  if (!match) {
    return null;
  }
  Object.assign(matchedParams, match.params);
  matches.push({
    // TODO: Can this as be avoided?
    params: matchedParams,
    pathname: joinPaths([matchedPathname, match.pathname]),
    pathnameBase: normalizePathname(
      joinPaths([matchedPathname, match.pathnameBase])
    ),
    route
  });
  if (match.pathnameBase !== "/") {
    matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
  }
}
return matches;
602}
603function matchPath(pattern, pathname) {
if (typeof pattern === "string") {
  pattern = { path: pattern, caseSensitive: false, end: true };
}
let [matcher, compiledParams] = compilePath(
  pattern.path,
  pattern.caseSensitive,
  pattern.end
);
let match = pathname.match(matcher);
if (!match) return null;
let matchedPathname = match[0];
let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
let captureGroups = match.slice(1);
let params = compiledParams.reduce(
  (memo, { paramName, isOptional }, index) => {
    if (paramName === "*") {
      let splatValue = captureGroups[index] || "";
      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
    }
    const value = captureGroups[index];
    if (isOptional && !value) {
      memo[paramName] = void 0;
    } else {
      memo[paramName] = (value || "").replace(/%2F/g, "/");
    }
    return memo;
  },
  {}
);
return {
  params,
  pathname: matchedPathname,
  pathnameBase,
  pattern
};
639}
640function compilePath(path, caseSensitive = false, end = true) {
warning(
  path === "*" || !path.endsWith("*") || path.endsWith("/*"),
  `Route path "${path}" will be treated as if it were "${path.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${path.replace(/\*$/, "/*")}".`
);
let params = [];
let regexpSource = "^" + path.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(
  /\/:([\w-]+)(\?)?/g,
  (match, paramName, isOptional, index, str) => {
    params.push({ paramName, isOptional: isOptional != null });
    if (isOptional) {
      let nextChar = str.charAt(index + match.length);
      if (nextChar && nextChar !== "/") {
        return "/([^\\/]*)";
      }
      return "(?:/([^\\/]*))?";
    }
    return "/([^\\/]+)";
  }
).replace(/\/([\w-]+)\?(\/|$)/g, "(/$1)?$2");
if (path.endsWith("*")) {
  params.push({ paramName: "*" });
  regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
} else if (end) {
  regexpSource += "\\/*$";
} else if (path !== "" && path !== "/") {
  regexpSource += "(?:(?=\\/|$))";
} else ;
let matcher = new RegExp(regexpSource, caseSensitive ? void 0 : "i");
return [matcher, params];
670}
671function decodePath(value) {
try {
  return value.split("/").map((v) => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
} catch (error) {
  warning(
    false,
    `The URL path "${value}" could not be decoded because it is a malformed URL segment. This is probably due to a bad percent encoding (${error}).`
  );
  return value;
}
681}
682function stripBasename(pathname, basename) {
if (basename === "/") return pathname;
if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
  return null;
}
let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
let nextChar = pathname.charAt(startIndex);
if (nextChar && nextChar !== "/") {
  return null;
}
return pathname.slice(startIndex) || "/";
693}
694function prependBasename({
basename,
pathname
697}) {
return pathname === "/" ? basename : joinPaths([basename, pathname]);
699}
700var ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
701var isAbsoluteUrl = (url) => ABSOLUTE_URL_REGEX.test(url);
702function resolvePath(to, fromPathname = "/") {
let {
  pathname: toPathname,
  search = "",
  hash = ""
} = typeof to === "string" ? parsePath(to) : to;
let pathname;
if (toPathname) {
  toPathname = removeDoubleSlashes(toPathname);
  if (toPathname.startsWith("/")) {
    pathname = resolvePathname(toPathname.substring(1), "/");
  } else {
    pathname = resolvePathname(toPathname, fromPathname);
  }
} else {
  pathname = fromPathname;
}
return {
  pathname,
  search: normalizeSearch(search),
  hash: normalizeHash(hash)
};
724}
725function resolvePathname(relativePath, fromPathname) {
let segments = removeTrailingSlash(fromPathname).split("/");
let relativeSegments = relativePath.split("/");
relativeSegments.forEach((segment) => {
  if (segment === "..") {
    if (segments.length > 1) segments.pop();
  } else if (segment !== ".") {
    segments.push(segment);
  }
});
return segments.length > 1 ? segments.join("/") : "/";
736}
737function getInvalidPathError(char, field, dest, path) {
return `Cannot include a '${char}' character in a manually specified \`to.${field}\` field [${JSON.stringify(
  path
)}].  Please separate it out to the \`to.${dest}\` field. Alternatively you may provide the full path as a string in <Link to="..."> and the router will parse it for you.`;
741}
742function getPathContributingMatches(matches) {
return matches.filter(
  (match, index) => index === 0 || match.route.path && match.route.path.length > 0
);
746}
747function getResolveToMatches(matches) {
let pathMatches = getPathContributingMatches(matches);
return pathMatches.map(
  (match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase
);
752}
753function resolveTo(toArg, routePathnames, locationPathname, isPathRelative = false) {
let to;
if (typeof toArg === "string") {
  to = parsePath(toArg);
} else {
  to = { ...toArg };
  invariant(
    !to.pathname || !to.pathname.includes("?"),
    getInvalidPathError("?", "pathname", "search", to)
  );
  invariant(
    !to.pathname || !to.pathname.includes("#"),
    getInvalidPathError("#", "pathname", "hash", to)
  );
  invariant(
    !to.search || !to.search.includes("#"),
    getInvalidPathError("#", "search", "hash", to)
  );
}
let isEmptyPath = toArg === "" || to.pathname === "";
let toPathname = isEmptyPath ? "/" : to.pathname;
let from;
if (toPathname == null) {
  from = locationPathname;
} else {
  let routePathnameIndex = routePathnames.length - 1;
  if (!isPathRelative && toPathname.startsWith("..")) {
    let toSegments = toPathname.split("/");
    while (toSegments[0] === "..") {
      toSegments.shift();
      routePathnameIndex -= 1;
    }
    to.pathname = toSegments.join("/");
  }
  from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
}
let path = resolvePath(to, from);
let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
  path.pathname += "/";
}
return path;
796}
797var removeDoubleSlashes = (path) => path.replace(/\/\/+/g, "/");
798var joinPaths = (paths) => removeDoubleSlashes(paths.join("/"));
799var removeTrailingSlash = (path) => path.replace(/\/+$/, "");
800var normalizePathname = (pathname) => removeTrailingSlash(pathname).replace(/^\/*/, "/");
801var normalizeSearch = (search) => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
802var normalizeHash = (hash) => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
803var DataWithResponseInit = class {
constructor(data2, init) {
  this.type = "DataWithResponseInit";
  this.data = data2;
  this.init = init || null;
}
809};
810function data(data2, init) {
return new DataWithResponseInit(
  data2,
  typeof init === "number" ? { status: init } : init
);
815}
816var redirect = (url, init = 302) => {
let responseInit = init;
if (typeof responseInit === "number") {
  responseInit = { status: responseInit };
} else if (typeof responseInit.status === "undefined") {
  responseInit.status = 302;
}
let headers = new Headers(responseInit.headers);
headers.set("Location", url);
return new Response(null, { ...responseInit, headers });
826};
827var redirectDocument = (url, init) => {
let response = redirect(url, init);
response.headers.set("X-Remix-Reload-Document", "true");
return response;
831};
832var replace = (url, init) => {
let response = redirect(url, init);
response.headers.set("X-Remix-Replace", "true");
return response;
836};
837var ErrorResponseImpl = class {
constructor(status, statusText, data2, internal = false) {
  this.status = status;
  this.statusText = statusText || "";
  this.internal = internal;
  if (data2 instanceof Error) {
    this.data = data2.toString();
    this.error = data2;
  } else {
    this.data = data2;
  }
}
849};
850function isRouteErrorResponse(error) {
return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
852}
853function getRoutePattern(matches) {
let parts = matches.map((m) => m.route.path).filter(Boolean);
return joinPaths(parts) || "/";
856}
857
858// lib/router/router.ts
859var validMutationMethodsArr = [
"POST",
"PUT",
"PATCH",
"DELETE"
864];
865var validMutationMethods = new Set(
validMutationMethodsArr
867);
868var validRequestMethodsArr = [
"GET",
...validMutationMethodsArr
871];
872var validRequestMethods = new Set(validRequestMethodsArr);
873var redirectStatusCodes = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
874var defaultMapRouteProperties = (route) => ({
hasErrorBoundary: Boolean(route.hasErrorBoundary)
876});
877var ResetLoaderDataSymbol = Symbol("ResetLoaderData");
878function createStaticHandler(routes, opts) {
invariant(
  routes.length > 0,
  "You must provide a non-empty routes array to createStaticHandler"
);
let manifest = {};
let basename = (opts ? opts.basename : null) || "/";
let _mapRouteProperties = opts?.mapRouteProperties || defaultMapRouteProperties;
let mapRouteProperties = _mapRouteProperties;
({
  // unused in static handler
  ...opts?.future
});
if (opts?.unstable_instrumentations) {
  let instrumentations = opts.unstable_instrumentations;
  mapRouteProperties = (route) => {
    return {
      ..._mapRouteProperties(route),
      ...getRouteInstrumentationUpdates(
        instrumentations.map((i) => i.route).filter(Boolean),
        route
      )
    };
  };
}
let dataRoutes = convertRoutesToDataRoutes(
  routes,
  mapRouteProperties,
  void 0,
  manifest
);
async function query(request, {
  requestContext,
  filterMatchesToLoad,
  skipLoaderErrorBubbling,
  skipRevalidation,
  dataStrategy,
  generateMiddlewareResponse,
  unstable_normalizePath
} = {}) {
  let normalizePath = unstable_normalizePath || defaultNormalizePath;
  let method = request.method;
  let location = createLocation("", normalizePath(request), null, "default");
  let matches = matchRoutes(dataRoutes, location, basename);
  requestContext = requestContext != null ? requestContext : new RouterContextProvider();
  if (!isValidMethod(method) && method !== "HEAD") {
    let error = getInternalRouterError(405, { method });
    let { matches: methodNotAllowedMatches, route } = getShortCircuitMatches(dataRoutes);
    let staticContext = {
      basename,
      location,
      matches: methodNotAllowedMatches,
      loaderData: {},
      actionData: null,
      errors: {
        [route.id]: error
      },
      statusCode: error.status,
      loaderHeaders: {},
      actionHeaders: {}
    };
    return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
  } else if (!matches) {
    let error = getInternalRouterError(404, { pathname: location.pathname });
    let { matches: notFoundMatches, route } = getShortCircuitMatches(dataRoutes);
    let staticContext = {
      basename,
      location,
      matches: notFoundMatches,
      loaderData: {},
      actionData: null,
      errors: {
        [route.id]: error
      },
      statusCode: error.status,
      loaderHeaders: {},
      actionHeaders: {}
    };
    return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
  }
  if (generateMiddlewareResponse) {
    invariant(
      requestContext instanceof RouterContextProvider,
      "When using middleware in `staticHandler.query()`, any provided `requestContext` must be an instance of `RouterContextProvider`"
    );
    try {
      await loadLazyMiddlewareForMatches(
        matches,
        manifest,
        mapRouteProperties
      );
      let renderedStaticContext;
      let response = await runServerMiddlewarePipeline(
        {
          request,
          unstable_url: createDataFunctionUrl(request, location),
          unstable_pattern: getRoutePattern(matches),
          matches,
          params: matches[0].params,
          // If we're calling middleware then it must be enabled so we can cast
          // this to the proper type knowing it's not an `AppLoadContext`
          context: requestContext
        },
        async () => {
          let res = await generateMiddlewareResponse(
            async (revalidationRequest, opts2 = {}) => {
              let result2 = await queryImpl(
                revalidationRequest,
                location,
                matches,
                requestContext,
                dataStrategy || null,
                skipLoaderErrorBubbling === true,
                null,
                "filterMatchesToLoad" in opts2 ? opts2.filterMatchesToLoad ?? null : filterMatchesToLoad ?? null,
                skipRevalidation === true
              );
              if (isResponse(result2)) {
                return result2;
              }
              renderedStaticContext = { location, basename, ...result2 };
              return renderedStaticContext;
            }
          );
          return res;
        },
        async (error, routeId) => {
          if (isRedirectResponse(error)) {
            return error;
          }
          if (isResponse(error)) {
            try {
              error = new ErrorResponseImpl(
                error.status,
                error.statusText,
                await parseResponseBody(error)
              );
            } catch (e) {
              error = e;
            }
          }
          if (isDataWithResponseInit(error)) {
            error = dataWithResponseInitToErrorResponse(error);
          }
          if (renderedStaticContext) {
            if (routeId in renderedStaticContext.loaderData) {
              renderedStaticContext.loaderData[routeId] = void 0;
            }
            let staticContext = getStaticContextFromError(
              dataRoutes,
              renderedStaticContext,
              error,
              skipLoaderErrorBubbling ? routeId : findNearestBoundary(matches, routeId).route.id
            );
            return generateMiddlewareResponse(
              () => Promise.resolve(staticContext)
            );
          } else {
            let boundaryRouteId = skipLoaderErrorBubbling ? routeId : findNearestBoundary(
              matches,
              matches.find(
                (m) => m.route.id === routeId || m.route.loader
              )?.route.id || routeId
            ).route.id;
            let staticContext = {
              matches,
              location,
              basename,
              loaderData: {},
              actionData: null,
              errors: {
                [boundaryRouteId]: error
              },
              statusCode: isRouteErrorResponse(error) ? error.status : 500,
              actionHeaders: {},
              loaderHeaders: {}
            };
            return generateMiddlewareResponse(
              () => Promise.resolve(staticContext)
            );
          }
        }
      );
      invariant(isResponse(response), "Expected a response in query()");
      return response;
    } catch (e) {
      if (isResponse(e)) {
        return e;
      }
      throw e;
    }
  }
  let result = await queryImpl(
    request,
    location,
    matches,
    requestContext,
    dataStrategy || null,
    skipLoaderErrorBubbling === true,
    null,
    filterMatchesToLoad || null,
    skipRevalidation === true
  );
  if (isResponse(result)) {
    return result;
  }
  return { location, basename, ...result };
}
async function queryRoute(request, {
  routeId,
  requestContext,
  dataStrategy,
  generateMiddlewareResponse,
  unstable_normalizePath
} = {}) {
  let normalizePath = unstable_normalizePath || defaultNormalizePath;
  let method = request.method;
  let location = createLocation("", normalizePath(request), null, "default");
  let matches = matchRoutes(dataRoutes, location, basename);
  requestContext = requestContext != null ? requestContext : new RouterContextProvider();
  if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") {
    throw getInternalRouterError(405, { method });
  } else if (!matches) {
    throw getInternalRouterError(404, { pathname: location.pathname });
  }
  let match = routeId ? matches.find((m) => m.route.id === routeId) : getTargetMatch(matches, location);
  if (routeId && !match) {
    throw getInternalRouterError(403, {
      pathname: location.pathname,
      routeId
    });
  } else if (!match) {
    throw getInternalRouterError(404, { pathname: location.pathname });
  }
  if (generateMiddlewareResponse) {
    invariant(
      requestContext instanceof RouterContextProvider,
      "When using middleware in `staticHandler.queryRoute()`, any provided `requestContext` must be an instance of `RouterContextProvider`"
    );
    await loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties);
    let response = await runServerMiddlewarePipeline(
      {
        request,
        unstable_url: createDataFunctionUrl(request, location),
        unstable_pattern: getRoutePattern(matches),
        matches,
        params: matches[0].params,
        // If we're calling middleware then it must be enabled so we can cast
        // this to the proper type knowing it's not an `AppLoadContext`
        context: requestContext
      },
      async () => {
        let res = await generateMiddlewareResponse(
          async (innerRequest) => {
            let result2 = await queryImpl(
              innerRequest,
              location,
              matches,
              requestContext,
              dataStrategy || null,
              false,
              match,
              null,
              false
            );
            let processed = handleQueryResult(result2);
            return isResponse(processed) ? processed : typeof processed === "string" ? new Response(processed) : Response.json(processed);
          }
        );
        return res;
      },
      (error) => {
        if (isDataWithResponseInit(error)) {
          return Promise.resolve(dataWithResponseInitToResponse(error));
        }
        if (isResponse(error)) {
          return Promise.resolve(error);
        }
        throw error;
      }
    );
    return response;
  }
  let result = await queryImpl(
    request,
    location,
    matches,
    requestContext,
    dataStrategy || null,
    false,
    match,
    null,
    false
  );
  return handleQueryResult(result);
  function handleQueryResult(result2) {
    if (isResponse(result2)) {
      return result2;
    }
    let error = result2.errors ? Object.values(result2.errors)[0] : void 0;
    if (error !== void 0) {
      throw error;
    }
    if (result2.actionData) {
      return Object.values(result2.actionData)[0];
    }
    if (result2.loaderData) {
      return Object.values(result2.loaderData)[0];
    }
    return void 0;
  }
}
async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, skipRevalidation) {
  invariant(
    request.signal,
    "query()/queryRoute() requests must contain an AbortController signal"
  );
  try {
    if (isMutationMethod(request.method)) {
      let result2 = await submit(
        request,
        location,
        matches,
        routeMatch || getTargetMatch(matches, location),
        requestContext,
        dataStrategy,
        skipLoaderErrorBubbling,
        routeMatch != null,
        filterMatchesToLoad,
        skipRevalidation
      );
      return result2;
    }
    let result = await loadRouteData(
      request,
      location,
      matches,
      requestContext,
      dataStrategy,
      skipLoaderErrorBubbling,
      routeMatch,
      filterMatchesToLoad
    );
    return isResponse(result) ? result : {
      ...result,
      actionData: null,
      actionHeaders: {}
    };
  } catch (e) {
    if (isDataStrategyResult(e) && isResponse(e.result)) {
      if (e.type === "error" /* error */) {
        throw e.result;
      }
      return e.result;
    }
    if (isRedirectResponse(e)) {
      return e;
    }
    throw e;
  }
}
async function submit(request, location, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest, filterMatchesToLoad, skipRevalidation) {
  let result;
  if (!actionMatch.route.action && !actionMatch.route.lazy) {
    let error = getInternalRouterError(405, {
      method: request.method,
      pathname: new URL(request.url).pathname,
      routeId: actionMatch.route.id
    });
    if (isRouteRequest) {
      throw error;
    }
    result = {
      type: "error" /* error */,
      error
    };
  } else {
    let dsMatches = getTargetedDataStrategyMatches(
      mapRouteProperties,
      manifest,
      request,
      location,
      matches,
      actionMatch,
      [],
      requestContext
    );
    let results = await callDataStrategy(
      request,
      location,
      dsMatches,
      isRouteRequest,
      requestContext,
      dataStrategy
    );
    result = results[actionMatch.route.id];
    if (request.signal.aborted) {
      throwStaticHandlerAbortedError(request, isRouteRequest);
    }
  }
  if (isRedirectResult(result)) {
    throw new Response(null, {
      status: result.response.status,
      headers: {
        Location: result.response.headers.get("Location")
      }
    });
  }
  if (isRouteRequest) {
    if (isErrorResult(result)) {
      throw result.error;
    }
    return {
      matches: [actionMatch],
      loaderData: {},
      actionData: { [actionMatch.route.id]: result.data },
      errors: null,
      // Note: statusCode + headers are unused here since queryRoute will
      // return the raw Response or value
      statusCode: 200,
      loaderHeaders: {},
      actionHeaders: {}
    };
  }
  if (skipRevalidation) {
    if (isErrorResult(result)) {
      let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
      return {
        statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
        actionData: null,
        actionHeaders: {
          ...result.headers ? { [actionMatch.route.id]: result.headers } : {}
        },
        matches,
        loaderData: {},
        errors: {
          [boundaryMatch.route.id]: result.error
        },
        loaderHeaders: {}
      };
    } else {
      return {
        actionData: {
          [actionMatch.route.id]: result.data
        },
        actionHeaders: result.headers ? { [actionMatch.route.id]: result.headers } : {},
        matches,
        loaderData: {},
        errors: null,
        statusCode: result.statusCode || 200,
        loaderHeaders: {}
      };
    }
  }
  let loaderRequest = new Request(request.url, {
    headers: request.headers,
    redirect: request.redirect,
    signal: request.signal
  });
  if (isErrorResult(result)) {
    let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
    let handlerContext2 = await loadRouteData(
      loaderRequest,
      location,
      matches,
      requestContext,
      dataStrategy,
      skipLoaderErrorBubbling,
      null,
      filterMatchesToLoad,
      [boundaryMatch.route.id, result]
    );
    return {
      ...handlerContext2,
      statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
      actionData: null,
      actionHeaders: {
        ...result.headers ? { [actionMatch.route.id]: result.headers } : {}
      }
    };
  }
  let handlerContext = await loadRouteData(
    loaderRequest,
    location,
    matches,
    requestContext,
    dataStrategy,
    skipLoaderErrorBubbling,
    null,
    filterMatchesToLoad
  );
  return {
    ...handlerContext,
    actionData: {
      [actionMatch.route.id]: result.data
    },
    // action status codes take precedence over loader status codes
    ...result.statusCode ? { statusCode: result.statusCode } : {},
    actionHeaders: result.headers ? { [actionMatch.route.id]: result.headers } : {}
  };
}
async function loadRouteData(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, pendingActionResult) {
  let isRouteRequest = routeMatch != null;
  if (isRouteRequest && !routeMatch?.route.loader && !routeMatch?.route.lazy) {
    throw getInternalRouterError(400, {
      method: request.method,
      pathname: new URL(request.url).pathname,
      routeId: routeMatch?.route.id
    });
  }
  let dsMatches;
  if (routeMatch) {
    dsMatches = getTargetedDataStrategyMatches(
      mapRouteProperties,
      manifest,
      request,
      location,
      matches,
      routeMatch,
      [],
      requestContext
    );
  } else {
    let maxIdx = pendingActionResult && isErrorResult(pendingActionResult[1]) ? (
      // Up to but not including the boundary
      matches.findIndex((m) => m.route.id === pendingActionResult[0]) - 1
    ) : void 0;
    let pattern = getRoutePattern(matches);
    dsMatches = matches.map((match, index) => {
      if (maxIdx != null && index > maxIdx) {
        return getDataStrategyMatch(
          mapRouteProperties,
          manifest,
          request,
          location,
          pattern,
          match,
          [],
          requestContext,
          false
        );
      }
      return getDataStrategyMatch(
        mapRouteProperties,
        manifest,
        request,
        location,
        pattern,
        match,
        [],
        requestContext,
        (match.route.loader || match.route.lazy) != null && (!filterMatchesToLoad || filterMatchesToLoad(match))
      );
    });
  }
  if (!dataStrategy && !dsMatches.some((m) => m.shouldLoad)) {
    return {
      matches,
      loaderData: {},
      errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
        [pendingActionResult[0]]: pendingActionResult[1].error
      } : null,
      statusCode: 200,
      loaderHeaders: {}
    };
  }
  let results = await callDataStrategy(
    request,
    location,
    dsMatches,
    isRouteRequest,
    requestContext,
    dataStrategy
  );
  if (request.signal.aborted) {
    throwStaticHandlerAbortedError(request, isRouteRequest);
  }
  let handlerContext = processRouteLoaderData(
    matches,
    results,
    pendingActionResult,
    true,
    skipLoaderErrorBubbling
  );
  return {
    ...handlerContext,
    matches
  };
}
async function callDataStrategy(request, location, matches, isRouteRequest, requestContext, dataStrategy) {
  let results = await callDataStrategyImpl(
    dataStrategy || defaultDataStrategy,
    request,
    location,
    matches,
    null,
    requestContext);
  let dataResults = {};
  await Promise.all(
    matches.map(async (match) => {
      if (!(match.route.id in results)) {
        return;
      }
      let result = results[match.route.id];
      if (isRedirectDataStrategyResult(result)) {
        let response = result.result;
        throw normalizeRelativeRoutingRedirectResponse(
          response,
          request,
          match.route.id,
          matches,
          basename
        );
      }
      if (isRouteRequest) {
        if (isResponse(result.result)) {
          throw result;
        } else if (isDataWithResponseInit(result.result)) {
          throw dataWithResponseInitToResponse(result.result);
        }
      }
      dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);
    })
  );
  return dataResults;
}
return {
  dataRoutes,
  query,
  queryRoute
};
1509}
1510function getStaticContextFromError(routes, handlerContext, error, boundaryId) {
let errorBoundaryId = boundaryId || handlerContext._deepestRenderedBoundaryId || routes[0].id;
return {
  ...handlerContext,
  statusCode: isRouteErrorResponse(error) ? error.status : 500,
  errors: {
    [errorBoundaryId]: error
  }
};
1519}
1520function throwStaticHandlerAbortedError(request, isRouteRequest) {
if (request.signal.reason !== void 0) {
  throw request.signal.reason;
}
let method = isRouteRequest ? "queryRoute" : "query";
throw new Error(
  `${method}() call aborted without an \`AbortSignal.reason\`: ${request.method} ${request.url}`
);
1528}
1529function defaultNormalizePath(request) {
let url = new URL(request.url);
return {
  pathname: url.pathname,
  search: url.search,
  hash: url.hash
};
1536}
1537function normalizeTo(location, matches, basename, to, fromRouteId, relative) {
let contextualMatches;
let activeRouteMatch;
{
  contextualMatches = matches;
  activeRouteMatch = matches[matches.length - 1];
}
let path = resolveTo(
  to ? to : ".",
  getResolveToMatches(contextualMatches),
  stripBasename(location.pathname, basename) || location.pathname,
  relative === "path"
);
if (to == null) {
  path.search = location.search;
  path.hash = location.hash;
}
if ((to == null || to === "" || to === ".") && activeRouteMatch) {
  let nakedIndex = hasNakedIndexQuery(path.search);
  if (activeRouteMatch.route.index && !nakedIndex) {
    path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
  } else if (!activeRouteMatch.route.index && nakedIndex) {
    let params = new URLSearchParams(path.search);
    let indexValues = params.getAll("index");
    params.delete("index");
    indexValues.filter((v) => v).forEach((v) => params.append("index", v));
    let qs = params.toString();
    path.search = qs ? `?${qs}` : "";
  }
}
if (basename !== "/") {
  path.pathname = prependBasename({ basename, pathname: path.pathname });
}
return createPath(path);
1571}
1572function shouldRevalidateLoader(loaderMatch, arg) {
if (loaderMatch.route.shouldRevalidate) {
  let routeChoice = loaderMatch.route.shouldRevalidate(arg);
  if (typeof routeChoice === "boolean") {
    return routeChoice;
  }
}
return arg.defaultShouldRevalidate;
1580}
1581var lazyRoutePropertyCache = /* @__PURE__ */ new WeakMap();
1582var loadLazyRouteProperty = ({
key,
route,
manifest,
mapRouteProperties
1587}) => {
let routeToUpdate = manifest[route.id];
invariant(routeToUpdate, "No route found in manifest");
if (!routeToUpdate.lazy || typeof routeToUpdate.lazy !== "object") {
  return;
}
let lazyFn = routeToUpdate.lazy[key];
if (!lazyFn) {
  return;
}
let cache2 = lazyRoutePropertyCache.get(routeToUpdate);
if (!cache2) {
  cache2 = {};
  lazyRoutePropertyCache.set(routeToUpdate, cache2);
}
let cachedPromise = cache2[key];
if (cachedPromise) {
  return cachedPromise;
}
let propertyPromise = (async () => {
  let isUnsupported = isUnsupportedLazyRouteObjectKey(key);
  let staticRouteValue = routeToUpdate[key];
  let isStaticallyDefined = staticRouteValue !== void 0 && key !== "hasErrorBoundary";
  if (isUnsupported) {
    warning(
      !isUnsupported,
      "Route property " + key + " is not a supported lazy route property. This property will be ignored."
    );
    cache2[key] = Promise.resolve();
  } else if (isStaticallyDefined) {
    warning(
      false,
      `Route "${routeToUpdate.id}" has a static property "${key}" defined. The lazy property will be ignored.`
    );
  } else {
    let value = await lazyFn();
    if (value != null) {
      Object.assign(routeToUpdate, { [key]: value });
      Object.assign(routeToUpdate, mapRouteProperties(routeToUpdate));
    }
  }
  if (typeof routeToUpdate.lazy === "object") {
    routeToUpdate.lazy[key] = void 0;
    if (Object.values(routeToUpdate.lazy).every((value) => value === void 0)) {
      routeToUpdate.lazy = void 0;
    }
  }
})();
cache2[key] = propertyPromise;
return propertyPromise;
1637};
1638var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
1639function loadLazyRoute(route, type, manifest, mapRouteProperties, lazyRoutePropertiesToSkip) {
let routeToUpdate = manifest[route.id];
invariant(routeToUpdate, "No route found in manifest");
if (!route.lazy) {
  return {
    lazyRoutePromise: void 0,
    lazyHandlerPromise: void 0
  };
}
if (typeof route.lazy === "function") {
  let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
  if (cachedPromise) {
    return {
      lazyRoutePromise: cachedPromise,
      lazyHandlerPromise: cachedPromise
    };
  }
  let lazyRoutePromise2 = (async () => {
    invariant(
      typeof route.lazy === "function",
      "No lazy route function found"
    );
    let lazyRoute = await route.lazy();
    let routeUpdates = {};
    for (let lazyRouteProperty in lazyRoute) {
      let lazyValue = lazyRoute[lazyRouteProperty];
      if (lazyValue === void 0) {
        continue;
      }
      let isUnsupported = isUnsupportedLazyRouteFunctionKey(lazyRouteProperty);
      let staticRouteValue = routeToUpdate[lazyRouteProperty];
      let isStaticallyDefined = staticRouteValue !== void 0 && // This property isn't static since it should always be updated based
      // on the route updates
      lazyRouteProperty !== "hasErrorBoundary";
      if (isUnsupported) {
        warning(
          !isUnsupported,
          "Route property " + lazyRouteProperty + " is not a supported property to be returned from a lazy route function. This property will be ignored."
        );
      } else if (isStaticallyDefined) {
        warning(
          !isStaticallyDefined,
          `Route "${routeToUpdate.id}" has a static property "${lazyRouteProperty}" defined but its lazy function is also returning a value for this property. The lazy route property "${lazyRouteProperty}" will be ignored.`
        );
      } else {
        routeUpdates[lazyRouteProperty] = lazyValue;
      }
    }
    Object.assign(routeToUpdate, routeUpdates);
    Object.assign(routeToUpdate, {
      // To keep things framework agnostic, we use the provided `mapRouteProperties`
      // function to set the framework-aware properties (`element`/`hasErrorBoundary`)
      // since the logic will differ between frameworks.
      ...mapRouteProperties(routeToUpdate),
      lazy: void 0
    });
  })();
  lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
  lazyRoutePromise2.catch(() => {
  });
  return {
    lazyRoutePromise: lazyRoutePromise2,
    lazyHandlerPromise: lazyRoutePromise2
  };
}
let lazyKeys = Object.keys(route.lazy);
let lazyPropertyPromises = [];
let lazyHandlerPromise = void 0;
for (let key of lazyKeys) {
  if (lazyRoutePropertiesToSkip && lazyRoutePropertiesToSkip.includes(key)) {
    continue;
  }
  let promise = loadLazyRouteProperty({
    key,
    route,
    manifest,
    mapRouteProperties
  });
  if (promise) {
    lazyPropertyPromises.push(promise);
    if (key === type) {
      lazyHandlerPromise = promise;
    }
  }
}
let lazyRoutePromise = lazyPropertyPromises.length > 0 ? Promise.all(lazyPropertyPromises).then(() => {
}) : void 0;
lazyRoutePromise?.catch(() => {
});
lazyHandlerPromise?.catch(() => {
});
return {
  lazyRoutePromise,
  lazyHandlerPromise
};
1734}
1735function isNonNullable(value) {
return value !== void 0;
1737}
1738function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties) {
let promises = matches.map(({ route }) => {
  if (typeof route.lazy !== "object" || !route.lazy.middleware) {
    return void 0;
  }
  return loadLazyRouteProperty({
    key: "middleware",
    route,
    manifest,
    mapRouteProperties
  });
}).filter(isNonNullable);
return promises.length > 0 ? Promise.all(promises) : void 0;
1751}
1752async function defaultDataStrategy(args) {
let matchesToLoad = args.matches.filter((m) => m.shouldLoad);
let keyedResults = {};
let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));
results.forEach((result, i) => {
  keyedResults[matchesToLoad[i].route.id] = result;
});
return keyedResults;
1760}
1761function runServerMiddlewarePipeline(args, handler, errorHandler) {
return runMiddlewarePipeline(
  args,
  handler,
  processResult,
  isResponse,
  errorHandler
);
function processResult(result) {
  return isDataWithResponseInit(result) ? dataWithResponseInitToResponse(result) : result;
}
1772}
1773async function runMiddlewarePipeline(args, handler, processResult, isResult, errorHandler) {
let { matches, ...dataFnArgs } = args;
let tuples = matches.flatMap(
  (m) => m.route.middleware ? m.route.middleware.map((fn) => [m.route.id, fn]) : []
);
let result = await callRouteMiddleware(
  dataFnArgs,
  tuples,
  handler,
  processResult,
  isResult,
  errorHandler
);
return result;
1787}
1788async function callRouteMiddleware(args, middlewares, handler, processResult, isResult, errorHandler, idx = 0) {
let { request } = args;
if (request.signal.aborted) {
  throw request.signal.reason ?? new Error(`Request aborted: ${request.method} ${request.url}`);
}
let tuple = middlewares[idx];
if (!tuple) {
  let result = await handler();
  return result;
}
let [routeId, middleware] = tuple;
let nextResult;
let next = async () => {
  if (nextResult) {
    throw new Error("You may only call `next()` once per middleware");
  }
  try {
    let result = await callRouteMiddleware(
      args,
      middlewares,
      handler,
      processResult,
      isResult,
      errorHandler,
      idx + 1
    );
    nextResult = { value: result };
    return nextResult.value;
  } catch (error) {
    nextResult = { value: await errorHandler(error, routeId, nextResult) };
    return nextResult.value;
  }
};
try {
  let value = await middleware(args, next);
  let result = value != null ? processResult(value) : void 0;
  if (isResult(result)) {
    return result;
  } else if (nextResult) {
    return result ?? nextResult.value;
  } else {
    nextResult = { value: await next() };
    return nextResult.value;
  }
} catch (error) {
  let response = await errorHandler(error, routeId, nextResult);
  return response;
}
1836}
1837function getDataStrategyMatchLazyPromises(mapRouteProperties, manifest, request, match, lazyRoutePropertiesToSkip) {
let lazyMiddlewarePromise = loadLazyRouteProperty({
  key: "middleware",
  route: match.route,
  manifest,
  mapRouteProperties
});
let lazyRoutePromises = loadLazyRoute(
  match.route,
  isMutationMethod(request.method) ? "action" : "loader",
  manifest,
  mapRouteProperties,
  lazyRoutePropertiesToSkip
);
return {
  middleware: lazyMiddlewarePromise,
  route: lazyRoutePromises.lazyRoutePromise,
  handler: lazyRoutePromises.lazyHandlerPromise
};
1856}
1857function getDataStrategyMatch(mapRouteProperties, manifest, request, path, unstable_pattern, match, lazyRoutePropertiesToSkip, scopedContext, shouldLoad, shouldRevalidateArgs = null, callSiteDefaultShouldRevalidate) {
let isUsingNewApi = false;
let _lazyPromises = getDataStrategyMatchLazyPromises(
  mapRouteProperties,
  manifest,
  request,
  match,
  lazyRoutePropertiesToSkip
);
return {
  ...match,
  _lazyPromises,
  shouldLoad,
  shouldRevalidateArgs,
  shouldCallHandler(defaultShouldRevalidate) {
    isUsingNewApi = true;
    if (!shouldRevalidateArgs) {
      return shouldLoad;
    }
    if (typeof defaultShouldRevalidate === "boolean") {
      return shouldRevalidateLoader(match, {
        ...shouldRevalidateArgs,
        defaultShouldRevalidate
      });
    }
    return shouldRevalidateLoader(match, shouldRevalidateArgs);
  },
  resolve(handlerOverride) {
    let { lazy, loader, middleware } = match.route;
    let callHandler = isUsingNewApi || shouldLoad || handlerOverride && !isMutationMethod(request.method) && (lazy || loader);
    let isMiddlewareOnlyRoute = middleware && middleware.length > 0 && !loader && !lazy;
    if (callHandler && (isMutationMethod(request.method) || !isMiddlewareOnlyRoute)) {
      return callLoaderOrAction({
        request,
        path,
        unstable_pattern,
        match,
        lazyHandlerPromise: _lazyPromises?.handler,
        lazyRoutePromise: _lazyPromises?.route,
        handlerOverride,
        scopedContext
      });
    }
    return Promise.resolve({ type: "data" /* data */, result: void 0 });
  }
};
1903}
1904function getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, path, matches, targetMatch, lazyRoutePropertiesToSkip, scopedContext, shouldRevalidateArgs = null) {
return matches.map((match) => {
  if (match.route.id !== targetMatch.route.id) {
    return {
      ...match,
      shouldLoad: false,
      shouldRevalidateArgs,
      shouldCallHandler: () => false,
      _lazyPromises: getDataStrategyMatchLazyPromises(
        mapRouteProperties,
        manifest,
        request,
        match,
        lazyRoutePropertiesToSkip
      ),
      resolve: () => Promise.resolve({ type: "data", result: void 0 })
    };
  }
  return getDataStrategyMatch(
    mapRouteProperties,
    manifest,
    request,
    path,
    getRoutePattern(matches),
    match,
    lazyRoutePropertiesToSkip,
    scopedContext,
    true,
    shouldRevalidateArgs
  );
});
1935}
1936async function callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, scopedContext, isStaticHandler) {
if (matches.some((m) => m._lazyPromises?.middleware)) {
  await Promise.all(matches.map((m) => m._lazyPromises?.middleware));
}
let dataStrategyArgs = {
  request,
  unstable_url: createDataFunctionUrl(request, path),
  unstable_pattern: getRoutePattern(matches),
  params: matches[0].params,
  context: scopedContext,
  matches
};
let runClientMiddleware = () => {
  throw new Error(
    "You cannot call `runClientMiddleware()` from a static handler `dataStrategy`. Middleware is run outside of `dataStrategy` during SSR in order to bubble up the Response.  You can enable middleware via the `respond` API in `query`/`queryRoute`"
  );
} ;
let results = await dataStrategyImpl({
  ...dataStrategyArgs,
  fetcherKey,
  runClientMiddleware
});
try {
  await Promise.all(
    matches.flatMap((m) => [
      m._lazyPromises?.handler,
      m._lazyPromises?.route
    ])
  );
} catch (e) {
}
return results;
1968}
1969async function callLoaderOrAction({
request,
path,
unstable_pattern,
match,
lazyHandlerPromise,
lazyRoutePromise,
handlerOverride,
scopedContext
1978}) {
let result;
let onReject;
let isAction = isMutationMethod(request.method);
let type = isAction ? "action" : "loader";
let runHandler = (handler) => {
  let reject;
  let abortPromise = new Promise((_, r) => reject = r);
  onReject = () => reject();
  request.signal.addEventListener("abort", onReject);
  let actualHandler = (ctx) => {
    if (typeof handler !== "function") {
      return Promise.reject(
        new Error(
          `You cannot call the handler for a route which defines a boolean "${type}" [routeId: ${match.route.id}]`
        )
      );
    }
    return handler(
      {
        request,
        unstable_url: createDataFunctionUrl(request, path),
        unstable_pattern,
        params: match.params,
        context: scopedContext
      },
      ...ctx !== void 0 ? [ctx] : []
    );
  };
  let handlerPromise = (async () => {
    try {
      let val = await (handlerOverride ? handlerOverride((ctx) => actualHandler(ctx)) : actualHandler());
      return { type: "data", result: val };
    } catch (e) {
      return { type: "error", result: e };
    }
  })();
  return Promise.race([handlerPromise, abortPromise]);
};
try {
  let handler = isAction ? match.route.action : match.route.loader;
  if (lazyHandlerPromise || lazyRoutePromise) {
    if (handler) {
      let handlerError;
      let [value] = await Promise.all([
        // If the handler throws, don't let it immediately bubble out,
        // since we need to let the lazy() execution finish so we know if this
        // route has a boundary that can handle the error
        runHandler(handler).catch((e) => {
          handlerError = e;
        }),
        // Ensure all lazy route promises are resolved before continuing
        lazyHandlerPromise,
        lazyRoutePromise
      ]);
      if (handlerError !== void 0) {
        throw handlerError;
      }
      result = value;
    } else {
      await lazyHandlerPromise;
      let handler2 = isAction ? match.route.action : match.route.loader;
      if (handler2) {
        [result] = await Promise.all([runHandler(handler2), lazyRoutePromise]);
      } else if (type === "action") {
        let url = new URL(request.url);
        let pathname = url.pathname + url.search;
        throw getInternalRouterError(405, {
          method: request.method,
          pathname,
          routeId: match.route.id
        });
      } else {
        return { type: "data" /* data */, result: void 0 };
      }
    }
  } else if (!handler) {
    let url = new URL(request.url);
    let pathname = url.pathname + url.search;
    throw getInternalRouterError(404, {
      pathname
    });
  } else {
    result = await runHandler(handler);
  }
} catch (e) {
  return { type: "error" /* error */, result: e };
} finally {
  if (onReject) {
    request.signal.removeEventListener("abort", onReject);
  }
}
return result;
2071}
2072async function parseResponseBody(response) {
let contentType = response.headers.get("Content-Type");
if (contentType && /\bapplication\/json\b/.test(contentType)) {
  return response.body == null ? null : response.json();
}
return response.text();
2078}
2079async function convertDataStrategyResultToDataResult(dataStrategyResult) {
let { result, type } = dataStrategyResult;
if (isResponse(result)) {
  let data2;
  try {
    data2 = await parseResponseBody(result);
  } catch (e) {
    return { type: "error" /* error */, error: e };
  }
  if (type === "error" /* error */) {
    return {
      type: "error" /* error */,
      error: new ErrorResponseImpl(result.status, result.statusText, data2),
      statusCode: result.status,
      headers: result.headers
    };
  }
  return {
    type: "data" /* data */,
    data: data2,
    statusCode: result.status,
    headers: result.headers
  };
}
if (type === "error" /* error */) {
  if (isDataWithResponseInit(result)) {
    if (result.data instanceof Error) {
      return {
        type: "error" /* error */,
        error: result.data,
        statusCode: result.init?.status,
        headers: result.init?.headers ? new Headers(result.init.headers) : void 0
      };
    }
    return {
      type: "error" /* error */,
      error: dataWithResponseInitToErrorResponse(result),
      statusCode: isRouteErrorResponse(result) ? result.status : void 0,
      headers: result.init?.headers ? new Headers(result.init.headers) : void 0
    };
  }
  return {
    type: "error" /* error */,
    error: result,
    statusCode: isRouteErrorResponse(result) ? result.status : void 0
  };
}
if (isDataWithResponseInit(result)) {
  return {
    type: "data" /* data */,
    data: result.data,
    statusCode: result.init?.status,
    headers: result.init?.headers ? new Headers(result.init.headers) : void 0
  };
}
return { type: "data" /* data */, data: result };
2135}
2136function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename) {
let location = response.headers.get("Location");
invariant(
  location,
  "Redirects returned/thrown from loaders/actions must have a Location header"
);
if (!isAbsoluteUrl(location)) {
  let trimmedMatches = matches.slice(
    0,
    matches.findIndex((m) => m.route.id === routeId) + 1
  );
  location = normalizeTo(
    new URL(request.url),
    trimmedMatches,
    basename,
    location
  );
  response.headers.set("Location", location);
}
return response;
2156}
2157function createDataFunctionUrl(request, path) {
let url = new URL(request.url);
let parsed = typeof path === "string" ? parsePath(path) : path;
url.pathname = parsed.pathname || "/";
if (parsed.search) {
  let searchParams = new URLSearchParams(parsed.search);
  let indexValues = searchParams.getAll("index");
  searchParams.delete("index");
  for (let value of indexValues.filter(Boolean)) {
    searchParams.append("index", value);
  }
  url.search = searchParams.size ? `?${searchParams.toString()}` : "";
} else {
  url.search = "";
}
url.hash = parsed.hash || "";
return url;
2174}
2175function processRouteLoaderData(matches, results, pendingActionResult, isStaticHandler = false, skipLoaderErrorBubbling = false) {
let loaderData = {};
let errors = null;
let statusCode;
let foundError = false;
let loaderHeaders = {};
let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : void 0;
matches.forEach((match) => {
  if (!(match.route.id in results)) {
    return;
  }
  let id = match.route.id;
  let result = results[id];
  invariant(
    !isRedirectResult(result),
    "Cannot handle redirect results in processLoaderData"
  );
  if (isErrorResult(result)) {
    let error = result.error;
    if (pendingError !== void 0) {
      error = pendingError;
      pendingError = void 0;
    }
    errors = errors || {};
    if (skipLoaderErrorBubbling) {
      errors[id] = error;
    } else {
      let boundaryMatch = findNearestBoundary(matches, id);
      if (errors[boundaryMatch.route.id] == null) {
        errors[boundaryMatch.route.id] = error;
      }
    }
    if (!isStaticHandler) {
      loaderData[id] = ResetLoaderDataSymbol;
    }
    if (!foundError) {
      foundError = true;
      statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;
    }
    if (result.headers) {
      loaderHeaders[id] = result.headers;
    }
  } else {
    loaderData[id] = result.data;
    if (result.statusCode && result.statusCode !== 200 && !foundError) {
      statusCode = result.statusCode;
    }
    if (result.headers) {
      loaderHeaders[id] = result.headers;
    }
  }
});
if (pendingError !== void 0 && pendingActionResult) {
  errors = { [pendingActionResult[0]]: pendingError };
  if (pendingActionResult[2]) {
    loaderData[pendingActionResult[2]] = void 0;
  }
}
return {
  loaderData,
  errors,
  statusCode: statusCode || 200,
  loaderHeaders
};
2239}
2240function findNearestBoundary(matches, routeId) {
let eligibleMatches = routeId ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1) : [...matches];
return eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) || matches[0];
2243}
2244function getShortCircuitMatches(routes) {
let route = routes.length === 1 ? routes[0] : routes.find((r) => r.index || !r.path || r.path === "/") || {
  id: `__shim-error-route__`
};
return {
  matches: [
    {
      params: {},
      pathname: "",
      pathnameBase: "",
      route
    }
  ],
  route
};
2259}
2260function getInternalRouterError(status, {
pathname,
routeId,
method,
type,
message
2266} = {}) {
let statusText = "Unknown Server Error";
let errorMessage = "Unknown @remix-run/router error";
if (status === 400) {
  statusText = "Bad Request";
  if (method && pathname && routeId) {
    errorMessage = `You made a ${method} request to "${pathname}" but did not provide a \`loader\` for route "${routeId}", so there is no way to handle the request.`;
  } else if (type === "invalid-body") {
    errorMessage = "Unable to encode submission body";
  }
} else if (status === 403) {
  statusText = "Forbidden";
  errorMessage = `Route "${routeId}" does not match URL "${pathname}"`;
} else if (status === 404) {
  statusText = "Not Found";
  errorMessage = `No route matches URL "${pathname}"`;
} else if (status === 405) {
  statusText = "Method Not Allowed";
  if (method && pathname && routeId) {
    errorMessage = `You made a ${method.toUpperCase()} request to "${pathname}" but did not provide an \`action\` for route "${routeId}", so there is no way to handle the request.`;
  } else if (method) {
    errorMessage = `Invalid request method "${method.toUpperCase()}"`;
  }
}
return new ErrorResponseImpl(
  status || 500,
  statusText,
  new Error(errorMessage),
  true
);
2296}
2297function dataWithResponseInitToResponse(data2) {
return Response.json(data2.data, data2.init ?? void 0);
2299}
2300function dataWithResponseInitToErrorResponse(data2) {
return new ErrorResponseImpl(
  data2.init?.status ?? 500,
  data2.init?.statusText ?? "Internal Server Error",
  data2.data
);
2306}
2307function isDataStrategyResult(result) {
return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === "data" /* data */ || result.type === "error" /* error */);
2309}
2310function isRedirectDataStrategyResult(result) {
return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
2312}
2313function isErrorResult(result) {
return result.type === "error" /* error */;
2315}
2316function isRedirectResult(result) {
return (result && result.type) === "redirect" /* redirect */;
2318}
2319function isDataWithResponseInit(value) {
return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
2321}
2322function isResponse(value) {
return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
2324}
2325function isRedirectStatusCode(statusCode) {
return redirectStatusCodes.has(statusCode);
2327}
2328function isRedirectResponse(result) {
return isResponse(result) && isRedirectStatusCode(result.status) && result.headers.has("Location");
2330}
2331function isValidMethod(method) {
return validRequestMethods.has(method.toUpperCase());
2333}
2334function isMutationMethod(method) {
return validMutationMethods.has(method.toUpperCase());
2336}
2337function hasNakedIndexQuery(search) {
return new URLSearchParams(search).getAll("index").some((v) => v === "");
2339}
2340function getTargetMatch(matches, location) {
let search = typeof location === "string" ? parsePath(location).search : location.search;
if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || "")) {
  return matches[matches.length - 1];
}
let pathMatches = getPathContributingMatches(matches);
return pathMatches[pathMatches.length - 1];
2347}
2348
2349// lib/server-runtime/invariant.ts
2350function 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);
}
2357}
2358
2359// lib/server-runtime/headers.ts
2360function 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));
2409}
2410function 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);
    }
  });
}
2421}
2422var SINGLE_FETCH_REDIRECT_STATUS = 202;
2423
2424// lib/actions.ts
2425function 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."
      );
    }
  }
}
2449}
2450function 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;
2488}
2489function isAllowedOrigin(originDomain, allowedActionOrigins = []) {
return allowedActionOrigins.some(
  (allowedOrigin) => allowedOrigin && (allowedOrigin === originDomain || matchWildcardDomain(originDomain, allowedOrigin))
);
2493}
2494function 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;
2505}
2506
2507// lib/errors.ts
2508var ERROR_DIGEST_BASE = "REACT_ROUTER_ERROR";
2509var ERROR_DIGEST_REDIRECT = "REDIRECT";
2510var ERROR_DIGEST_ROUTE_ERROR_RESPONSE = "ROUTE_ERROR_RESPONSE";
2511function createRedirectErrorDigest(response) {
return `${ERROR_DIGEST_BASE}:${ERROR_DIGEST_REDIRECT}:${JSON.stringify({
  status: response.status,
  statusText: response.statusText,
  location: response.headers.get("Location"),
  reloadDocument: response.headers.get("X-Remix-Reload-Document") === "true",
  replace: response.headers.get("X-Remix-Replace") === "true"
})}`;
2519}
2520function createRouteErrorResponseDigest(response) {
let status = 500;
let statusText = "";
let data2;
if (isDataWithResponseInit(response)) {
  status = response.init?.status ?? status;
  statusText = response.init?.statusText ?? statusText;
  data2 = response.data;
} else {
  status = response.status;
  statusText = response.statusText;
  data2 = void 0;
}
return `${ERROR_DIGEST_BASE}:${ERROR_DIGEST_ROUTE_ERROR_RESPONSE}:${JSON.stringify(
  {
    status,
    statusText,
    data: data2
  }
)}`;
2540}
2541
2542// lib/server-runtime/urls.ts
2543function getNormalizedPath(request, basename, future) {
basename = basename || "/";
let url = new URL(request.url);
let pathname = url.pathname;
{
  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: ""
};
2569}
2570
2571// lib/rsc/server.rsc.ts
2572var Outlet = Outlet$1;
2573var WithComponentProps = UNSAFE_WithComponentProps;
2574var WithErrorBoundaryProps = UNSAFE_WithErrorBoundaryProps;
2575var WithHydrateFallbackProps = UNSAFE_WithHydrateFallbackProps;
2576var globalVar = typeof globalThis !== "undefined" ? globalThis : global;
2577var ServerStorage = globalVar.___reactRouterServerStorage___ ?? (globalVar.___reactRouterServerStorage___ = new AsyncLocalStorage());
2578function getRequest() {
const ctx = ServerStorage.getStore();
if (!ctx)
  throw new Error(
    "getRequest must be called from within a React Server render context"
  );
return ctx.request;
2585}
2586var redirect2 = (...args) => {
const response = redirect(...args);
const ctx = ServerStorage.getStore();
if (ctx && ctx.runningAction) {
  ctx.redirect = response;
}
return response;
2593};
2594var redirectDocument2 = (...args) => {
const response = redirectDocument(...args);
const ctx = ServerStorage.getStore();
if (ctx && ctx.runningAction) {
  ctx.redirect = response;
}
return response;
2601};
2602var replace2 = (...args) => {
const response = replace(...args);
const ctx = ServerStorage.getStore();
if (ctx && ctx.runningAction) {
  ctx.redirect = response;
}
return response;
2609};
2610var cachedResolvePromise = (
// @ts-expect-error - on 18 types, requires 19.
React2.cache(async (resolve) => {
  return Promise.allSettled([resolve]).then((r) => r[0]);
})
2615);
2616var Await = async ({
children,
resolve,
errorElement
2620}) => {
let promise = cachedResolvePromise(resolve);
let resolved = await promise;
if (resolved.status === "rejected" && !errorElement) {
  throw resolved.reason;
}
if (resolved.status === "rejected") {
  return React2.createElement(UNSAFE_AwaitContextProvider, {
    children: React2.createElement(React2.Fragment, null, errorElement),
    value: { _tracked: true, _error: resolved.reason }
  });
}
const toRender = typeof children === "function" ? children(resolved.value) : children;
return React2.createElement(UNSAFE_AwaitContextProvider, {
  children: toRender,
  value: { _tracked: true, _data: resolved.value }
});
2637};
2638async function matchRSCServerRequest({
allowedActionOrigins,
createTemporaryReferenceSet,
basename,
decodeReply,
requestContext,
routeDiscovery,
loadServerAction,
decodeAction,
decodeFormState,
onError,
request,
routes,
generateResponse
2652}) {
let url = new URL(request.url);
basename = basename || "/";
let normalizedPath = url.pathname;
if (url.pathname.endsWith("/_.rsc")) {
  normalizedPath = url.pathname.replace(/_\.rsc$/, "");
} else if (url.pathname.endsWith(".rsc")) {
  normalizedPath = url.pathname.replace(/\.rsc$/, "");
}
if (stripBasename(normalizedPath, basename) !== "/" && normalizedPath.endsWith("/")) {
  normalizedPath = normalizedPath.slice(0, -1);
}
url.pathname = normalizedPath;
basename = basename.length > normalizedPath.length ? normalizedPath : basename;
let routerRequest = new Request(url.toString(), {
  method: request.method,
  headers: request.headers,
  body: request.body,
  signal: request.signal,
  duplex: request.body ? "half" : void 0
});
const temporaryReferences = createTemporaryReferenceSet();
const requestUrl = new URL(request.url);
if (isManifestRequest(requestUrl)) {
  let response2 = await generateManifestResponse(
    routes,
    basename,
    request,
    generateResponse,
    temporaryReferences,
    routeDiscovery
  );
  return response2;
}
let isDataRequest = isReactServerRequest(requestUrl);
let matches = matchRoutes(routes, url.pathname, basename);
if (matches) {
  await Promise.all(matches.map((m) => explodeLazyRoute(m.route)));
}
const leafMatch = matches?.[matches.length - 1];
if (!isDataRequest && leafMatch && !leafMatch.route.Component && !leafMatch.route.ErrorBoundary) {
  return generateResourceResponse(
    routerRequest,
    routes,
    basename,
    leafMatch.route.id,
    requestContext,
    onError
  );
}
let response = await generateRenderResponse(
  routerRequest,
  routes,
  basename,
  isDataRequest,
  decodeReply,
  requestContext,
  loadServerAction,
  decodeAction,
  decodeFormState,
  onError,
  generateResponse,
  temporaryReferences,
  allowedActionOrigins,
  routeDiscovery
);
response.headers.set("X-Remix-Response", "yes");
return response;
2720}
2721async function generateManifestResponse(routes, basename, request, generateResponse, temporaryReferences, routeDiscovery) {
if (routeDiscovery?.mode === "initial") {
  let payload2 = {
    type: "manifest",
    patches: getAllRoutePatches(routes)
  };
  return generateResponse(
    {
      statusCode: 200,
      headers: new Headers({
        "Content-Type": "text/x-component",
        Vary: "Content-Type"
      }),
      payload: payload2
    },
    { temporaryReferences, onError: defaultOnError }
  );
}
let url = new URL(request.url);
let pathParam = url.searchParams.get("paths");
let pathnames = pathParam ? pathParam.split(",").filter(Boolean) : [url.pathname.replace(/\.manifest$/, "")];
let routeIds = /* @__PURE__ */ new Set();
let matchedRoutes = pathnames.flatMap((pathname) => {
  let pathnameMatches = matchRoutes(routes, pathname, basename);
  return pathnameMatches?.map((m, i) => ({
    ...m.route,
    parentId: pathnameMatches[i - 1]?.route.id
  })) ?? [];
}).filter((route) => {
  if (!routeIds.has(route.id)) {
    routeIds.add(route.id);
    return true;
  }
  return false;
});
let payload = {
  type: "manifest",
  patches: Promise.all([
    ...matchedRoutes.map((route) => getManifestRoute(route)),
    getAdditionalRoutePatches(
      pathnames,
      routes,
      basename,
      Array.from(routeIds)
    )
  ]).then((r) => r.flat(1))
};
return generateResponse(
  {
    statusCode: 200,
    headers: new Headers({
      "Content-Type": "text/x-component"
    }),
    payload
  },
  { temporaryReferences, onError: defaultOnError }
);
2778}
2779function prependBasenameToRedirectResponse(response, basename = "/") {
if (basename === "/") {
  return response;
}
let redirect3 = response.headers.get("Location");
if (!redirect3 || isAbsoluteUrl(redirect3)) {
  return response;
}
response.headers.set(
  "Location",
  prependBasename({ basename, pathname: redirect3 })
);
return response;
2792}
2793async function processServerAction(request, basename, decodeReply, loadServerAction, decodeAction, decodeFormState, onError, temporaryReferences) {
const getRevalidationRequest = () => new Request(request.url, {
  method: "GET",
  headers: request.headers,
  signal: request.signal
});
const isFormRequest = canDecodeWithFormData(
  request.headers.get("Content-Type")
);
const actionId = request.headers.get("rsc-action-id");
if (actionId) {
  if (!decodeReply || !loadServerAction) {
    throw new Error(
      "Cannot handle enhanced server action without decodeReply and loadServerAction functions"
    );
  }
  const reply = isFormRequest ? await request.formData() : await request.text();
  const actionArgs = await decodeReply(reply, { temporaryReferences });
  const action = await loadServerAction(actionId);
  const serverAction = action.bind(null, ...actionArgs);
  let actionResult = Promise.resolve(serverAction());
  try {
    await actionResult;
  } catch (error) {
    if (isResponse(error)) {
      return error;
    }
    onError?.(error);
  }
  let maybeFormData = actionArgs.length === 1 ? actionArgs[0] : actionArgs[1];
  let formData = maybeFormData && typeof maybeFormData === "object" && maybeFormData instanceof FormData ? maybeFormData : null;
  let skipRevalidation = formData?.has("$SKIP_REVALIDATION") ?? false;
  return {
    actionResult,
    revalidationRequest: getRevalidationRequest(),
    skipRevalidation
  };
} else if (isFormRequest) {
  const formData = await request.clone().formData();
  if (Array.from(formData.keys()).some((k) => k.startsWith("$ACTION_"))) {
    if (!decodeAction) {
      throw new Error(
        "Cannot handle form actions without a decodeAction function"
      );
    }
    const action = await decodeAction(formData);
    let formState = void 0;
    try {
      let result = await action();
      if (isRedirectResponse(result)) {
        result = prependBasenameToRedirectResponse(result, basename);
      }
      formState = decodeFormState?.(result, formData);
    } catch (error) {
      if (isRedirectResponse(error)) {
        return prependBasenameToRedirectResponse(error, basename);
      }
      if (isResponse(error)) {
        return error;
      }
      onError?.(error);
    }
    return {
      formState,
      revalidationRequest: getRevalidationRequest(),
      skipRevalidation: false
    };
  }
}
2862}
2863async function generateResourceResponse(request, routes, basename, routeId, requestContext, onError) {
try {
  const staticHandler = createStaticHandler(routes, {
    basename
  });
  let response = await staticHandler.queryRoute(request, {
    routeId,
    requestContext,
    async generateMiddlewareResponse(queryRoute) {
      try {
        let response2 = await queryRoute(request);
        return generateResourceResponse2(response2);
      } catch (error) {
        return generateErrorResponse(error);
      }
    },
    unstable_normalizePath: (r) => getNormalizedPath(r, basename, null)
  });
  return response;
} catch (error) {
  return generateErrorResponse(error);
}
function generateErrorResponse(error) {
  let response;
  if (isResponse(error)) {
    response = error;
  } else if (isRouteErrorResponse(error)) {
    onError?.(error);
    const errorMessage = typeof error.data === "string" ? error.data : error.statusText;
    response = new Response(errorMessage, {
      status: error.status,
      statusText: error.statusText
    });
  } else {
    onError?.(error);
    response = new Response("Internal Server Error", { status: 500 });
  }
  return generateResourceResponse2(response);
}
function generateResourceResponse2(response) {
  const headers = new Headers(response.headers);
  headers.set("React-Router-Resource", "true");
  return new Response(response.body, {
    status: response.status,
    statusText: response.statusText,
    headers
  });
}
2911}
2912async function generateRenderResponse(request, routes, basename, isDataRequest, decodeReply, requestContext, loadServerAction, decodeAction, decodeFormState, onError, generateResponse, temporaryReferences, allowedActionOrigins, routeDiscovery) {
let statusCode = 200;
let url = new URL(request.url);
let isSubmission = isMutationMethod(request.method);
let routeIdsToLoad = !isSubmission && url.searchParams.has("_routes") ? url.searchParams.get("_routes").split(",") : null;
const staticHandler = createStaticHandler(routes, {
  basename,
  mapRouteProperties: (r) => ({
    hasErrorBoundary: r.ErrorBoundary != null
  })
});
let actionResult;
const ctx = {
  request,
  runningAction: false
};
const result = await ServerStorage.run(
  ctx,
  () => staticHandler.query(request, {
    requestContext,
    skipLoaderErrorBubbling: isDataRequest,
    skipRevalidation: isSubmission,
    ...routeIdsToLoad ? { filterMatchesToLoad: (m) => routeIdsToLoad.includes(m.route.id) } : {},
    unstable_normalizePath: (r) => getNormalizedPath(r, basename),
    async generateMiddlewareResponse(query) {
      let formState;
      let skipRevalidation = false;
      let potentialCSRFAttackError;
      if (request.method === "POST") {
        try {
          throwIfPotentialCSRFAttack(request.headers, allowedActionOrigins);
          ctx.runningAction = true;
          let result2 = await processServerAction(
            request,
            basename,
            decodeReply,
            loadServerAction,
            decodeAction,
            decodeFormState,
            onError,
            temporaryReferences
          ).finally(() => {
            ctx.runningAction = false;
          });
          if (isResponse(result2)) {
            return generateRedirectResponse(
              result2,
              actionResult,
              basename,
              isDataRequest,
              generateResponse,
              temporaryReferences,
              ctx.redirect?.headers
            );
          }
          skipRevalidation = result2?.skipRevalidation ?? false;
          actionResult = result2?.actionResult;
          formState = result2?.formState;
          request = result2?.revalidationRequest ?? request;
          if (ctx.redirect) {
            return generateRedirectResponse(
              ctx.redirect,
              actionResult,
              basename,
              isDataRequest,
              generateResponse,
              temporaryReferences,
              void 0
            );
          }
        } catch (error) {
          potentialCSRFAttackError = error;
        }
      }
      let staticContext = await query(
        request,
        skipRevalidation || !!potentialCSRFAttackError ? {
          filterMatchesToLoad: () => false
        } : void 0
      );
      if (isResponse(staticContext)) {
        return generateRedirectResponse(
          staticContext,
          actionResult,
          basename,
          isDataRequest,
          generateResponse,
          temporaryReferences,
          ctx.redirect?.headers
        );
      }
      if (potentialCSRFAttackError) {
        staticContext.errors ?? (staticContext.errors = {});
        staticContext.errors[staticContext.matches[0].route.id] = potentialCSRFAttackError;
        staticContext.statusCode = 400;
      }
      return generateStaticContextResponse(
        routes,
        basename,
        generateResponse,
        statusCode,
        routeIdsToLoad,
        isDataRequest,
        isSubmission,
        actionResult,
        formState,
        staticContext,
        temporaryReferences,
        skipRevalidation,
        ctx.redirect?.headers,
        routeDiscovery
      );
    }
  })
);
if (isRedirectResponse(result)) {
  return generateRedirectResponse(
    result,
    actionResult,
    basename,
    isDataRequest,
    generateResponse,
    temporaryReferences,
    ctx.redirect?.headers
  );
}
invariant2(isResponse(result), "Expected a response from query");
return result;
3040}
3041function generateRedirectResponse(response, actionResult, basename, isDataRequest, generateResponse, temporaryReferences, sideEffectRedirectHeaders) {
let redirect3 = response.headers.get("Location");
if (isDataRequest && basename) {
  redirect3 = stripBasename(redirect3, basename) || redirect3;
}
let payload = {
  type: "redirect",
  location: redirect3,
  reload: response.headers.get("X-Remix-Reload-Document") === "true",
  replace: response.headers.get("X-Remix-Replace") === "true",
  status: response.status,
  actionResult
};
let headers = new Headers(sideEffectRedirectHeaders);
for (const [key, value] of response.headers.entries()) {
  headers.append(key, value);
}
headers.delete("Location");
headers.delete("X-Remix-Reload-Document");
headers.delete("X-Remix-Replace");
headers.delete("Content-Length");
headers.set("Content-Type", "text/x-component");
return generateResponse(
  {
    statusCode: SINGLE_FETCH_REDIRECT_STATUS,
    headers,
    payload
  },
  { temporaryReferences, onError: defaultOnError }
);
3071}
3072async function generateStaticContextResponse(routes, basename, generateResponse, statusCode, routeIdsToLoad, isDataRequest, isSubmission, actionResult, formState, staticContext, temporaryReferences, skipRevalidation, sideEffectRedirectHeaders, routeDiscovery) {
statusCode = staticContext.statusCode ?? statusCode;
if (staticContext.errors) {
  staticContext.errors = Object.fromEntries(
    Object.entries(staticContext.errors).map(([key, error]) => [
      key,
      isRouteErrorResponse(error) ? Object.fromEntries(Object.entries(error)) : error
    ])
  );
}
staticContext.matches.forEach((m) => {
  const routeHasNoLoaderData = staticContext.loaderData[m.route.id] === void 0;
  const routeHasError = Boolean(
    staticContext.errors && m.route.id in staticContext.errors
  );
  if (routeHasNoLoaderData && !routeHasError) {
    staticContext.loaderData[m.route.id] = null;
  }
});
let headers = getDocumentHeadersImpl(
  staticContext,
  (match) => match.route.headers,
  sideEffectRedirectHeaders
);
headers.delete("Content-Length");
const baseRenderPayload = {
  type: "render",
  basename: staticContext.basename,
  routeDiscovery: routeDiscovery ?? { mode: "lazy" },
  actionData: staticContext.actionData,
  errors: staticContext.errors,
  loaderData: staticContext.loaderData,
  location: staticContext.location,
  formState
};
const renderPayloadPromise = () => getRenderPayload(
  baseRenderPayload,
  routes,
  basename,
  routeIdsToLoad,
  isDataRequest,
  staticContext,
  routeDiscovery
);
let payload;
if (actionResult) {
  payload = {
    type: "action",
    actionResult,
    rerender: skipRevalidation ? void 0 : renderPayloadPromise()
  };
} else if (isSubmission && isDataRequest) {
  payload = {
    ...baseRenderPayload,
    matches: [],
    patches: Promise.resolve([])
  };
} else {
  payload = await renderPayloadPromise();
}
return generateResponse(
  {
    statusCode,
    headers,
    payload
  },
  { temporaryReferences, onError: defaultOnError }
);
3140}
3141async function getRenderPayload(baseRenderPayload, routes, basename, routeIdsToLoad, isDataRequest, staticContext, routeDiscovery) {
let deepestRenderedRouteIdx = staticContext.matches.length - 1;
let parentIds = {};
staticContext.matches.forEach((m, i) => {
  if (i > 0) {
    parentIds[m.route.id] = staticContext.matches[i - 1].route.id;
  }
  if (staticContext.errors && m.route.id in staticContext.errors && deepestRenderedRouteIdx > i) {
    deepestRenderedRouteIdx = i;
  }
});
let matchesPromise = Promise.all(
  staticContext.matches.map((match, i) => {
    let isBelowErrorBoundary = i > deepestRenderedRouteIdx;
    let parentId = parentIds[match.route.id];
    return getRSCRouteMatch({
      staticContext,
      match,
      routeIdsToLoad,
      isBelowErrorBoundary,
      parentId
    });
  })
);
let patches = routeDiscovery?.mode === "initial" && !isDataRequest ? getAllRoutePatches(routes).then(
  (patches2) => patches2.filter(
    (patch) => !staticContext.matches.some((m) => m.route.id === patch.id)
  )
) : getAdditionalRoutePatches(
  [staticContext.location.pathname],
  routes,
  basename,
  staticContext.matches.map((m) => m.route.id)
);
return {
  ...baseRenderPayload,
  matches: await matchesPromise,
  patches
};
3180}
3181async function getRSCRouteMatch({
staticContext,
match,
isBelowErrorBoundary,
routeIdsToLoad,
parentId
3187}) {
const route = match.route;
await explodeLazyRoute(route);
const Layout = route.Layout || React2.Fragment;
const Component = route.Component;
const ErrorBoundary = route.ErrorBoundary;
const HydrateFallback = route.HydrateFallback;
const loaderData = staticContext.loaderData[route.id];
const actionData = staticContext.actionData?.[route.id];
const params = match.params;
let element = void 0;
let shouldLoadRoute = !routeIdsToLoad || routeIdsToLoad.includes(route.id);
if (Component && shouldLoadRoute) {
  element = !isBelowErrorBoundary ? React2.createElement(
    Layout,
    null,
    isClientReference(Component) ? React2.createElement(WithComponentProps, {
      children: React2.createElement(Component)
    }) : React2.createElement(Component, {
      loaderData,
      actionData,
      params,
      matches: staticContext.matches.map(
        (match2) => convertRouteMatchToUiMatch(match2, staticContext.loaderData)
      )
    })
  ) : React2.createElement(Outlet);
}
let error = void 0;
if (ErrorBoundary && staticContext.errors) {
  error = staticContext.errors[route.id];
}
const errorElement = ErrorBoundary ? React2.createElement(
  Layout,
  null,
  isClientReference(ErrorBoundary) ? React2.createElement(WithErrorBoundaryProps, {
    children: React2.createElement(ErrorBoundary)
  }) : React2.createElement(ErrorBoundary, {
    loaderData,
    actionData,
    params,
    error
  })
) : void 0;
const hydrateFallbackElement = HydrateFallback ? React2.createElement(
  Layout,
  null,
  isClientReference(HydrateFallback) ? React2.createElement(WithHydrateFallbackProps, {
    children: React2.createElement(HydrateFallback)
  }) : React2.createElement(HydrateFallback, {
    loaderData,
    actionData,
    params
  })
) : void 0;
const hmrRoute = route;
return {
  clientAction: route.clientAction,
  clientLoader: route.clientLoader,
  element,
  errorElement,
  handle: route.handle,
  hasAction: !!route.action,
  hasComponent: !!Component,
  hasErrorBoundary: !!ErrorBoundary,
  hasLoader: !!route.loader,
  hydrateFallbackElement,
  id: route.id,
  index: "index" in route ? route.index : void 0,
  links: route.links,
  meta: route.meta,
  params,
  parentId,
  path: route.path,
  pathname: match.pathname,
  pathnameBase: match.pathnameBase,
  shouldRevalidate: route.shouldRevalidate,
  // Add an unused client-only export (if present) so HMR can support
  // switching between server-first and client-only routes during development
  ...hmrRoute.__ensureClientRouteModuleForHMR ? {
    __ensureClientRouteModuleForHMR: hmrRoute.__ensureClientRouteModuleForHMR
  } : {}
};
3270}
3271async function getManifestRoute(route) {
await explodeLazyRoute(route);
const Layout = route.Layout || React2.Fragment;
const errorElement = route.ErrorBoundary ? React2.createElement(
  Layout,
  null,
  React2.createElement(route.ErrorBoundary)
) : void 0;
return {
  clientAction: route.clientAction,
  clientLoader: route.clientLoader,
  handle: route.handle,
  hasAction: !!route.action,
  hasComponent: !!route.Component,
  hasErrorBoundary: !!route.ErrorBoundary,
  errorElement,
  hasLoader: !!route.loader,
  id: route.id,
  parentId: route.parentId,
  path: route.path,
  index: "index" in route ? route.index : void 0,
  links: route.links,
  meta: route.meta
};
3295}
3296async function explodeLazyRoute(route) {
if ("lazy" in route && route.lazy) {
  let {
    default: lazyDefaultExport,
    Component: lazyComponentExport,
    ...lazyProperties
  } = await route.lazy();
  let Component = lazyComponentExport || lazyDefaultExport;
  if (Component && !route.Component) {
    route.Component = Component;
  }
  for (let [k, v] of Object.entries(lazyProperties)) {
    if (k !== "id" && k !== "path" && k !== "index" && k !== "children" && route[k] == null) {
      route[k] = v;
    }
  }
  route.lazy = void 0;
}
3314}
3315async function getAllRoutePatches(routes, basename) {
let patches = [];
async function traverse(route, parentId) {
  let manifestRoute = await getManifestRoute({ ...route, parentId });
  patches.push(manifestRoute);
  if ("children" in route && route.children?.length) {
    for (let child of route.children) {
      await traverse(child, route.id);
    }
  }
}
for (let route of routes) {
  await traverse(route, void 0);
}
return patches.filter((p) => !!p.parentId);
3330}
3331async function getAdditionalRoutePatches(pathnames, routes, basename, matchedRouteIds) {
let patchRouteMatches = /* @__PURE__ */ new Map();
let matchedPaths = /* @__PURE__ */ new Set();
for (const pathname of pathnames) {
  let segments = pathname.split("/").filter(Boolean);
  let paths = ["/"];
  segments.pop();
  while (segments.length > 0) {
    paths.push(`/${segments.join("/")}`);
    segments.pop();
  }
  paths.forEach((path) => {
    if (matchedPaths.has(path)) {
      return;
    }
    matchedPaths.add(path);
    let matches = matchRoutes(routes, path, basename) || [];
    matches.forEach((m, i) => {
      if (patchRouteMatches.get(m.route.id)) {
        return;
      }
      patchRouteMatches.set(m.route.id, {
        ...m.route,
        parentId: matches[i - 1]?.route.id
      });
    });
  });
}
let patches = await Promise.all(
  [...patchRouteMatches.values()].filter((route) => !matchedRouteIds.some((id) => id === route.id)).map((route) => getManifestRoute(route))
);
return patches;
3363}
3364function isReactServerRequest(url) {
return url.pathname.endsWith(".rsc");
3366}
3367function isManifestRequest(url) {
return url.pathname.endsWith(".manifest");
3369}
3370function defaultOnError(error) {
if (isRedirectResponse(error)) {
  return createRedirectErrorDigest(error);
}
if (isResponse(error) || isDataWithResponseInit(error)) {
  return createRouteErrorResponseDigest(error);
}
3377}
3378function isClientReference(x) {
try {
  return x.$$typeof === Symbol.for("react.client.reference");
} catch {
  return false;
}
3384}
3385function canDecodeWithFormData(contentType) {
if (!contentType) return false;
return contentType.match(/\bapplication\/x-www-form-urlencoded\b/) || contentType.match(/\bmultipart\/form-data\b/);
3388}
3389
3390// lib/href.ts
3391function 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 || "/";
3414}
3415function 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);
3424}
3425
3426// lib/server-runtime/crypto.ts
3427var encoder = /* @__PURE__ */ new TextEncoder();
3428var sign = async (value, secret) => {
let data2 = encoder.encode(value);
let key = await createKey2(secret, ["sign"]);
let signature = await crypto.subtle.sign("HMAC", key, data2);
let hash = btoa(String.fromCharCode(...new Uint8Array(signature))).replace(
  /=+$/,
  ""
);
return value + "." + hash;
3437};
3438var 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 createKey2(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;
}
3451};
3452var createKey2 = async (secret, usages) => crypto.subtle.importKey(
"raw",
encoder.encode(secret),
{ name: "HMAC", hash: "SHA-256" },
false,
usages
3458);
3459function byteStringToUint8Array(byteString) {
let array = new Uint8Array(byteString.length);
for (let i = 0; i < byteString.length; i++) {
  array[i] = byteString.charCodeAt(i);
}
return array;
3465}
3466
3467// lib/server-runtime/warnings.ts
3468var alreadyWarned = {};
3469function warnOnce(condition, message) {
if (!condition && !alreadyWarned[message]) {
  alreadyWarned[message] = true;
  console.warn(message);
}
3474}
3475
3476// lib/server-runtime/cookies.ts
3477var 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
      }
    );
  }
};
3520};
3521var isCookie = (object) => {
return object != null && typeof object.name === "string" && typeof object.isSigned === "boolean" && typeof object.parse === "function" && typeof object.serialize === "function";
3523};
3524async function encodeCookieValue(value, secrets) {
let encoded = encodeData(value);
if (secrets.length > 0) {
  encoded = await sign(encoded, secrets[0]);
}
return encoded;
3530}
3531async 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);
3542}
3543function encodeData(value) {
return btoa(myUnescape(encodeURIComponent(JSON.stringify(value))));
3545}
3546function decodeData(value) {
try {
  return JSON.parse(decodeURIComponent(myEscape(atob(value))));
} catch (error) {
  return {};
}
3552}
3553function 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;
3572}
3573function hex(code, length) {
let result = code.toString(16);
while (result.length < length) result = "0" + result;
return result;
3577}
3578function 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;
3605}
3606function 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.`
);
3611}
3612
3613// lib/server-runtime/sessions.ts
3614function flash(name) {
return `__flash_${name}__`;
3616}
3617var 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);
  }
};
3649};
3650var 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";
3652};
3653function createSessionStorage({
cookie: cookieArg,
createData,
readData,
updateData,
deleteData
3659}) {
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)
    });
  }
};
3687}
3688function 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.`
);
3693}
3694
3695// lib/server-runtime/sessions/cookieStorage.ts
3696function 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)
    });
  }
};
3722}
3723
3724// lib/server-runtime/sessions/memoryStorage.ts
3725function 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);
  }
});
3751}
3752
3753export { Await, RouterContextProvider, createContext, createCookie, createCookieSessionStorage, createMemorySessionStorage, createSession, createSessionStorage, createStaticHandler, data, href, isCookie, isRouteErrorResponse, isSession, matchRoutes, redirect2 as redirect, redirectDocument2 as redirectDocument, replace2 as replace, getRequest as unstable_getRequest, matchRSCServerRequest as unstable_matchRSCServerRequest };
1	`import { AsyncLocalStorage } from 'node:async_hooks';`
2	`import * as React2 from 'react';`
3	`import { splitCookiesString } from 'set-cookie-parser';`
4	`import { UNSAFE_AwaitContextProvider, UNSAFE_WithComponentProps, Outlet as Outlet$1, UNSAFE_WithErrorBoundaryProps, UNSAFE_WithHydrateFallbackProps } from 'react-router/internal/react-server-client';`
5	`export { BrowserRouter, Form, HashRouter, Link, Links, MemoryRouter, Meta, NavLink, Navigate, Outlet, Route, Router, RouterProvider, Routes, ScrollRestoration, StaticRouter, StaticRouterProvider, unstable_HistoryRouter } from 'react-router/internal/react-server-client';`
6	`import { serialize, parse } from 'cookie';`
7
8	`/**`
9	`* react-router v7.14.1`
10	`*`
11	`* Copyright (c) Remix Software Inc.`
12	`*`
13	`* This source code is licensed under the MIT license found in the`
14	`* LICENSE.md file in the root directory of this source tree.`
15	`*`
16	`* @license MIT`
17	`*/`
18	`var __typeError = (msg) => {`
19	`throw TypeError(msg);`
20	`};`
21	`var __accessCheck = (obj, member, msg) => member.has(obj) \|\| __typeError("Cannot " + msg);`
22	`var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));`
23	`var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);`
24
25	`// lib/router/history.ts`
26	`function invariant(value, message) {`
27	`if (value === false \|\| value === null \|\| typeof value === "undefined") {`
28	`throw new Error(message);`
29	`}`
30	`}`
31	`function warning(cond, message) {`
32	`if (!cond) {`
33	`if (typeof console !== "undefined") console.warn(message);`
34	`try {`
35	`throw new Error(message);`
36	`} catch (e) {`
37	`}`
38	`}`
39	`}`
40	`function createKey() {`