@react-router/dev 7.0.0-pre.2 → 7.0.0-pre.4

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v7.0.0-pre.2
+ * @react-router/dev v7.0.0-pre.4
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,12 +8,2401 @@
  *
  * @license MIT
  */
-'use strict';
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, '__esModule', { value: true });
+// vite.ts
+var vite_exports = {};
+__export(vite_exports, {
+  reactRouter: () => reactRouterVitePlugin
+});
+module.exports = __toCommonJS(vite_exports);
 
-var plugin = require('./vite/plugin.js');
+// vite/plugin.ts
+var import_node_crypto = require("crypto");
+var path4 = __toESM(require("path"));
+var url2 = __toESM(require("url"));
+var fse2 = __toESM(require("fs-extra"));
+var babel = __toESM(require("@babel/core"));
+var import_react_router2 = require("react-router");
+var import_es_module_lexer = require("es-module-lexer");
+var import_jsesc = __toESM(require("jsesc"));
+var import_picocolors2 = __toESM(require("picocolors"));
 
+// invariant.ts
+function invariant(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    console.error(
+      "The following error is a bug in React Router; please open an issue! https://github.com/remix-run/react-router/issues/new/choose"
+    );
+    throw new Error(message);
+  }
+}
 
+// vite/babel.ts
+var import_parser = require("@babel/parser");
+var t = __toESM(require("@babel/types"));
+var traverse = require("@babel/traverse").default;
+var generate = require("@babel/generator").default;
 
-exports.reactRouter = plugin.reactRouterVitePlugin;
+// vite/node-adapter.ts
+var import_node_events = require("events");
+var import_node_stream = require("stream");
+var import_set_cookie_parser = require("set-cookie-parser");
+var import_node = require("@react-router/node");
+function fromNodeHeaders(nodeHeaders) {
+  let headers = new Headers();
+  for (let [key, values] of Object.entries(nodeHeaders)) {
+    if (values) {
+      if (Array.isArray(values)) {
+        for (let value of values) {
+          headers.append(key, value);
+        }
+      } else {
+        headers.set(key, values);
+      }
+    }
+  }
+  return headers;
+}
+function fromNodeRequest(nodeReq, nodeRes) {
+  let origin = nodeReq.headers.origin && "null" !== nodeReq.headers.origin ? nodeReq.headers.origin : `http://${nodeReq.headers.host}`;
+  invariant(
+    nodeReq.originalUrl,
+    "Expected `nodeReq.originalUrl` to be defined"
+  );
+  let url3 = new URL(nodeReq.originalUrl, origin);
+  let controller = new AbortController();
+  let init = {
+    method: nodeReq.method,
+    headers: fromNodeHeaders(nodeReq.headers),
+    signal: controller.signal
+  };
+  nodeRes.on("finish", () => controller = null);
+  nodeRes.on("close", () => controller?.abort());
+  if (nodeReq.method !== "GET" && nodeReq.method !== "HEAD") {
+    init.body = (0, import_node.createReadableStreamFromReadable)(nodeReq);
+    init.duplex = "half";
+  }
+  return new Request(url3.href, init);
+}
+async function toNodeRequest(res, nodeRes) {
+  nodeRes.statusCode = res.status;
+  nodeRes.statusMessage = res.statusText;
+  let cookiesStrings = [];
+  for (let [name, value] of res.headers) {
+    if (name === "set-cookie") {
+      cookiesStrings.push(...(0, import_set_cookie_parser.splitCookiesString)(value));
+    } else nodeRes.setHeader(name, value);
+  }
+  if (cookiesStrings.length) {
+    nodeRes.setHeader("set-cookie", cookiesStrings);
+  }
+  if (res.body) {
+    let responseBody = res.body;
+    let readable = import_node_stream.Readable.from(responseBody);
+    readable.pipe(nodeRes);
+    await (0, import_node_events.once)(readable, "end");
+  } else {
+    nodeRes.end();
+  }
+}
+
+// vite/styles.ts
+var path2 = __toESM(require("path"));
+var import_react_router = require("react-router");
+
+// vite/resolve-file-url.ts
+var path = __toESM(require("path"));
+
+// vite/import-vite-esm-sync.ts
+var vite;
+async function preloadViteEsm() {
+  vite = await import("vite");
+}
+function importViteEsmSync() {
+  invariant(vite, "importViteEsmSync() called before preloadViteEsm()");
+  return vite;
+}
+
+// vite/resolve-file-url.ts
+var resolveFileUrl = ({ rootDirectory }, filePath) => {
+  let vite2 = importViteEsmSync();
+  let relativePath = path.relative(rootDirectory, filePath);
+  let isWithinRoot = !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+  if (!isWithinRoot) {
+    return path.posix.join("/@fs", vite2.normalizePath(filePath));
+  }
+  return "/" + vite2.normalizePath(relativePath);
+};
+
+// vite/styles.ts
+var cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+var cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
+var isCssFile = (file) => cssFileRegExp.test(file);
+var isCssModulesFile = (file) => cssModulesRegExp.test(file);
+var cssUrlParamsWithoutSideEffects = ["url", "inline", "raw", "inline-css"];
+var isCssUrlWithoutSideEffects = (url3) => {
+  let queryString = url3.split("?")[1];
+  if (!queryString) {
+    return false;
+  }
+  let params = new URLSearchParams(queryString);
+  for (let paramWithoutSideEffects of cssUrlParamsWithoutSideEffects) {
+    if (
+      // Parameter is blank and not explicitly set, i.e. "?url", not "?url="
+      params.get(paramWithoutSideEffects) === "" && !url3.includes(`?${paramWithoutSideEffects}=`) && !url3.includes(`&${paramWithoutSideEffects}=`)
+    ) {
+      return true;
+    }
+  }
+  return false;
+};
+var getStylesForFiles = async ({
+  viteDevServer,
+  rootDirectory,
+  cssModulesManifest,
+  files
+}) => {
+  let styles = {};
+  let deps = /* @__PURE__ */ new Set();
+  try {
+    for (let file of files) {
+      let normalizedPath = path2.resolve(rootDirectory, file).replace(/\\/g, "/");
+      let node = await viteDevServer.moduleGraph.getModuleById(normalizedPath);
+      if (!node) {
+        try {
+          await viteDevServer.transformRequest(
+            resolveFileUrl({ rootDirectory }, normalizedPath)
+          );
+        } catch (err) {
+          console.error(err);
+        }
+        node = await viteDevServer.moduleGraph.getModuleById(normalizedPath);
+      }
+      if (!node) {
+        console.log(`Could not resolve module for file: ${file}`);
+        continue;
+      }
+      await findDeps(viteDevServer, node, deps);
+    }
+  } catch (err) {
+    console.error(err);
+  }
+  for (let dep of deps) {
+    if (dep.file && isCssFile(dep.file) && !isCssUrlWithoutSideEffects(dep.url)) {
+      try {
+        let css = isCssModulesFile(dep.file) ? cssModulesManifest[dep.file] : (await viteDevServer.ssrLoadModule(dep.url)).default;
+        if (css === void 0) {
+          throw new Error();
+        }
+        styles[dep.url] = css;
+      } catch {
+        console.warn(`Could not load ${dep.file}`);
+      }
+    }
+  }
+  return Object.entries(styles).map(([fileName, css], i) => [
+    `
+/* ${fileName.replace(/\/\*/g, "/\\*").replace(/\*\//g, "*\\/")} */`,
+    css
+  ]).flat().join("\n") || void 0;
+};
+var findDeps = async (vite2, node, deps) => {
+  let branches = [];
+  async function addFromNode(node2) {
+    if (!deps.has(node2)) {
+      deps.add(node2);
+      await findDeps(vite2, node2, deps);
+    }
+  }
+  async function addFromUrl(url3) {
+    let node2 = await vite2.moduleGraph.getModuleByUrl(url3);
+    if (node2) {
+      await addFromNode(node2);
+    }
+  }
+  if (node.ssrTransformResult) {
+    if (node.ssrTransformResult.deps) {
+      node.ssrTransformResult.deps.forEach(
+        (url3) => branches.push(addFromUrl(url3))
+      );
+    }
+  } else {
+    node.importedModules.forEach((node2) => branches.push(addFromNode(node2)));
+  }
+  await Promise.all(branches);
+};
+var groupRoutesByParentId = (manifest) => {
+  let routes = {};
+  Object.values(manifest).forEach((route) => {
+    if (route) {
+      let parentId = route.parentId || "";
+      if (!routes[parentId]) {
+        routes[parentId] = [];
+      }
+      routes[parentId].push(route);
+    }
+  });
+  return routes;
+};
+var createRoutes = (manifest, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) => {
+  return (routesByParentId[parentId] || []).map((route) => ({
+    ...route,
+    children: createRoutes(manifest, route.id, routesByParentId)
+  }));
+};
+var getStylesForUrl = async ({
+  viteDevServer,
+  rootDirectory,
+  reactRouterConfig,
+  entryClientFilePath,
+  cssModulesManifest,
+  build,
+  url: url3
+}) => {
+  if (url3 === void 0 || url3.includes("?_data=")) {
+    return void 0;
+  }
+  let routes = createRoutes(build.routes);
+  let appPath = path2.relative(process.cwd(), reactRouterConfig.appDirectory);
+  let documentRouteFiles = (0, import_react_router.matchRoutes)(routes, url3, build.basename)?.map(
+    (match) => path2.resolve(appPath, reactRouterConfig.routes[match.route.id].file)
+  ) ?? [];
+  let styles = await getStylesForFiles({
+    viteDevServer,
+    rootDirectory,
+    cssModulesManifest,
+    files: [
+      // Always include the client entry file when crawling the module graph for CSS
+      path2.relative(rootDirectory, entryClientFilePath),
+      // Then include any styles from the matched routes
+      ...documentRouteFiles
+    ]
+  });
+  return styles;
+};
+
+// vite/vmod.ts
+var id = (name) => `virtual:react-router/${name}`;
+var resolve2 = (id2) => `\0${id2}`;
+var url = (id2) => `/@id/__x00__${id2}`;
+
+// vite/combine-urls.ts
+function combineURLs(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+}
+
+// vite/remove-exports.ts
+var import_babel_dead_code_elimination = require("babel-dead-code-elimination");
+var removeExports = (ast, exportsToRemove) => {
+  let previouslyReferencedIdentifiers = (0, import_babel_dead_code_elimination.findReferencedIdentifiers)(ast);
+  let exportsFiltered = false;
+  let markedForRemoval = /* @__PURE__ */ new Set();
+  traverse(ast, {
+    ExportDeclaration(path5) {
+      if (path5.node.type === "ExportNamedDeclaration") {
+        if (path5.node.specifiers.length) {
+          path5.node.specifiers = path5.node.specifiers.filter((specifier) => {
+            if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier") {
+              if (exportsToRemove.includes(specifier.exported.name)) {
+                exportsFiltered = true;
+                return false;
+              }
+            }
+            return true;
+          });
+          if (path5.node.specifiers.length === 0) {
+            markedForRemoval.add(path5);
+          }
+        }
+        if (path5.node.declaration?.type === "VariableDeclaration") {
+          let declaration = path5.node.declaration;
+          declaration.declarations = declaration.declarations.filter(
+            (declaration2) => {
+              if (declaration2.id.type === "Identifier" && exportsToRemove.includes(declaration2.id.name)) {
+                exportsFiltered = true;
+                return false;
+              }
+              if (declaration2.id.type === "ArrayPattern" || declaration2.id.type === "ObjectPattern") {
+                validateDestructuredExports(declaration2.id, exportsToRemove);
+              }
+              return true;
+            }
+          );
+          if (declaration.declarations.length === 0) {
+            markedForRemoval.add(path5);
+          }
+        }
+        if (path5.node.declaration?.type === "FunctionDeclaration") {
+          let id2 = path5.node.declaration.id;
+          if (id2 && exportsToRemove.includes(id2.name)) {
+            markedForRemoval.add(path5);
+          }
+        }
+        if (path5.node.declaration?.type === "ClassDeclaration") {
+          let id2 = path5.node.declaration.id;
+          if (id2 && exportsToRemove.includes(id2.name)) {
+            markedForRemoval.add(path5);
+          }
+        }
+      }
+      if (path5.node.type === "ExportDefaultDeclaration" && exportsToRemove.includes("default")) {
+        markedForRemoval.add(path5);
+      }
+    }
+  });
+  if (markedForRemoval.size > 0 || exportsFiltered) {
+    for (let path5 of markedForRemoval) {
+      path5.remove();
+    }
+    (0, import_babel_dead_code_elimination.deadCodeElimination)(ast, previouslyReferencedIdentifiers);
+  }
+};
+function validateDestructuredExports(id2, exportsToRemove) {
+  if (id2.type === "ArrayPattern") {
+    for (let element of id2.elements) {
+      if (!element) {
+        continue;
+      }
+      if (element.type === "Identifier" && exportsToRemove.includes(element.name)) {
+        throw invalidDestructureError(element.name);
+      }
+      if (element.type === "RestElement" && element.argument.type === "Identifier" && exportsToRemove.includes(element.argument.name)) {
+        throw invalidDestructureError(element.argument.name);
+      }
+      if (element.type === "ArrayPattern" || element.type === "ObjectPattern") {
+        validateDestructuredExports(element, exportsToRemove);
+      }
+    }
+  }
+  if (id2.type === "ObjectPattern") {
+    for (let property of id2.properties) {
+      if (!property) {
+        continue;
+      }
+      if (property.type === "ObjectProperty" && property.key.type === "Identifier") {
+        if (property.value.type === "Identifier" && exportsToRemove.includes(property.value.name)) {
+          throw invalidDestructureError(property.value.name);
+        }
+        if (property.value.type === "ArrayPattern" || property.value.type === "ObjectPattern") {
+          validateDestructuredExports(property.value, exportsToRemove);
+        }
+      }
+      if (property.type === "RestElement" && property.argument.type === "Identifier" && exportsToRemove.includes(property.argument.name)) {
+        throw invalidDestructureError(property.argument.name);
+      }
+    }
+  }
+}
+function invalidDestructureError(name) {
+  return new Error(`Cannot remove destructured export "${name}"`);
+}
+
+// vite/config.ts
+var import_node_child_process = require("child_process");
+var import_node_path2 = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_picocolors = __toESM(require("picocolors"));
+var import_pick2 = __toESM(require("lodash/pick"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_package_json = __toESM(require("@npmcli/package-json"));
+
+// config/routes.ts
+var import_node_path = require("path");
+var v = __toESM(require("valibot"));
+var import_pick = __toESM(require("lodash/pick"));
+function setAppDirectory(directory) {
+  globalThis.__reactRouterAppDirectory = directory;
+}
+var routeConfigEntrySchema = v.pipe(
+  v.custom((value) => {
+    return !(typeof value === "object" && value !== null && "then" in value && "catch" in value);
+  }, "Invalid type: Expected object but received a promise. Did you forget to await?"),
+  v.object({
+    id: v.optional(v.string()),
+    path: v.optional(v.string()),
+    index: v.optional(v.boolean()),
+    caseSensitive: v.optional(v.boolean()),
+    file: v.string(),
+    children: v.optional(v.array(v.lazy(() => routeConfigEntrySchema)))
+  })
+);
+var resolvedRouteConfigSchema = v.array(routeConfigEntrySchema);
+function validateRouteConfig({
+  routeConfigFile,
+  routeConfig
+}) {
+  if (!routeConfig) {
+    return {
+      valid: false,
+      message: `No "routes" export defined in "${routeConfigFile}.`
+    };
+  }
+  if (!Array.isArray(routeConfig)) {
+    return {
+      valid: false,
+      message: `Route config in "${routeConfigFile}" must be an array.`
+    };
+  }
+  let { issues } = v.safeParse(resolvedRouteConfigSchema, routeConfig);
+  if (issues?.length) {
+    let { root, nested } = v.flatten(issues);
+    return {
+      valid: false,
+      message: [
+        `Route config in "${routeConfigFile}" is invalid.`,
+        root ? `${root}` : [],
+        nested ? Object.entries(nested).map(
+          ([path5, message]) => `Path: routes.${path5}
+${message}`
+        ) : []
+      ].flat().join("\n\n")
+    };
+  }
+  return { valid: true };
+}
+function configRoutesToRouteManifest(routes, rootId = "root") {
+  let routeManifest = {};
+  function walk(route, parentId) {
+    let id2 = route.id || createRouteId(route.file);
+    let manifestItem = {
+      id: id2,
+      parentId,
+      file: route.file,
+      path: route.path,
+      index: route.index,
+      caseSensitive: route.caseSensitive
+    };
+    if (routeManifest.hasOwnProperty(id2)) {
+      throw new Error(
+        `Unable to define routes with duplicate route id: "${id2}"`
+      );
+    }
+    routeManifest[id2] = manifestItem;
+    if (route.children) {
+      for (let child of route.children) {
+        walk(child, id2);
+      }
+    }
+  }
+  for (let route of routes) {
+    walk(route, rootId);
+  }
+  return routeManifest;
+}
+function createRouteId(file) {
+  return normalizeSlashes(stripFileExtension(file));
+}
+function normalizeSlashes(file) {
+  return file.split(import_node_path.win32.sep).join("/");
+}
+function stripFileExtension(file) {
+  return file.replace(/\.[a-z0-9]+$/i, "");
+}
+
+// cli/detectPackageManager.ts
+var detectPackageManager = () => {
+  let { npm_config_user_agent } = process.env;
+  if (!npm_config_user_agent) return void 0;
+  try {
+    let pkgManager = npm_config_user_agent.split("/")[0];
+    if (pkgManager === "npm") return "npm";
+    if (pkgManager === "pnpm") return "pnpm";
+    if (pkgManager === "yarn") return "yarn";
+    if (pkgManager === "bun") return "bun";
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+
+// vite/config.ts
+var excludedConfigPresetKeys = ["presets"];
+var mergeReactRouterConfig = (...configs) => {
+  let reducer = (configA, configB) => {
+    let mergeRequired = (key) => configA[key] !== void 0 && configB[key] !== void 0;
+    return {
+      ...configA,
+      ...configB,
+      ...mergeRequired("buildEnd") ? {
+        buildEnd: async (...args) => {
+          await Promise.all([
+            configA.buildEnd?.(...args),
+            configB.buildEnd?.(...args)
+          ]);
+        }
+      } : {},
+      ...mergeRequired("future") ? {
+        future: {
+          ...configA.future,
+          ...configB.future
+        }
+      } : {},
+      ...mergeRequired("presets") ? {
+        presets: [...configA.presets ?? [], ...configB.presets ?? []]
+      } : {}
+    };
+  };
+  return configs.reduce(reducer, {});
+};
+var deepFreeze = (o) => {
+  Object.freeze(o);
+  let oIsFunction = typeof o === "function";
+  let hasOwnProp = Object.prototype.hasOwnProperty;
+  Object.getOwnPropertyNames(o).forEach(function(prop) {
+    if (hasOwnProp.call(o, prop) && (oIsFunction ? prop !== "caller" && prop !== "callee" && prop !== "arguments" : true) && o[prop] !== null && (typeof o[prop] === "object" || typeof o[prop] === "function") && !Object.isFrozen(o[prop])) {
+      deepFreeze(o[prop]);
+    }
+  });
+  return o;
+};
+function resolvePublicPath(viteUserConfig) {
+  return viteUserConfig.base ?? "/";
+}
+var isFirstLoad = true;
+var lastValidRoutes = {};
+async function resolveReactRouterConfig({
+  rootDirectory,
+  reactRouterUserConfig,
+  routeConfigChanged,
+  viteUserConfig,
+  viteCommand,
+  routesViteNodeContext
+}) {
+  let vite2 = importViteEsmSync();
+  let logger = vite2.createLogger(viteUserConfig.logLevel, {
+    prefix: "[react-router]"
+  });
+  let presets = (await Promise.all(
+    (reactRouterUserConfig.presets ?? []).map(async (preset) => {
+      if (!preset.name) {
+        throw new Error(
+          "React Router presets must have a `name` property defined."
+        );
+      }
+      if (!preset.reactRouterConfig) {
+        return null;
+      }
+      let configPreset = (0, import_omit.default)(
+        await preset.reactRouterConfig({ reactRouterUserConfig }),
+        excludedConfigPresetKeys
+      );
+      return configPreset;
+    })
+  )).filter(function isNotNull(value) {
+    return value !== null;
+  });
+  let defaults = {
+    basename: "/",
+    buildDirectory: "build",
+    serverBuildFile: "index.js",
+    serverModuleFormat: "esm",
+    ssr: true
+  };
+  let {
+    appDirectory: userAppDirectory,
+    basename: basename2,
+    buildDirectory: userBuildDirectory,
+    buildEnd,
+    prerender,
+    serverBuildFile,
+    serverBundles,
+    serverModuleFormat,
+    ssr
+  } = {
+    ...defaults,
+    // Default values should be completely overridden by user/preset config, not merged
+    ...mergeReactRouterConfig(...presets, reactRouterUserConfig)
+  };
+  if (!ssr && serverBundles) {
+    console.warn(
+      import_picocolors.default.yellow(
+        import_picocolors.default.bold("\u26A0\uFE0F  SPA Mode: ") + "the `serverBundles` config is invalid with `ssr:false` and will be ignored`"
+      )
+    );
+    serverBundles = void 0;
+  }
+  let isValidPrerenderConfig = prerender == null || typeof prerender === "boolean" || Array.isArray(prerender) || typeof prerender === "function";
+  if (!isValidPrerenderConfig) {
+    logger.error(
+      import_picocolors.default.red(
+        "The `prerender` config must be a boolean, an array of string paths, or a function returning a boolean or array of string paths"
+      )
+    );
+    process.exit(1);
+  }
+  let appDirectory = import_node_path2.default.resolve(rootDirectory, userAppDirectory || "app");
+  let buildDirectory = import_node_path2.default.resolve(rootDirectory, userBuildDirectory);
+  let publicPath = resolvePublicPath(viteUserConfig);
+  if (basename2 !== "/" && viteCommand === "serve" && !viteUserConfig.server?.middlewareMode && !basename2.startsWith(publicPath)) {
+    logger.error(
+      import_picocolors.default.red(
+        "When using the React Router `basename` and the Vite `base` config, the `basename` config must begin with `base` for the default Vite dev server."
+      )
+    );
+    process.exit(1);
+  }
+  let rootRouteFile = findEntry(appDirectory, "root");
+  if (!rootRouteFile) {
+    let rootRouteDisplayPath = import_node_path2.default.relative(
+      rootDirectory,
+      import_node_path2.default.join(appDirectory, "root.tsx")
+    );
+    logger.error(
+      import_picocolors.default.red(
+        `Could not find a root route module in the app directory as "${rootRouteDisplayPath}"`
+      )
+    );
+    process.exit(1);
+  }
+  let routes = {
+    root: { path: "", id: "root", file: rootRouteFile }
+  };
+  let routeConfigFile = findEntry(appDirectory, "routes");
+  class FriendlyError extends Error {
+  }
+  try {
+    if (!routeConfigFile) {
+      let routeConfigDisplayPath = vite2.normalizePath(
+        import_node_path2.default.relative(rootDirectory, import_node_path2.default.join(appDirectory, "routes.ts"))
+      );
+      throw new FriendlyError(
+        `Route config file not found at "${routeConfigDisplayPath}".`
+      );
+    }
+    setAppDirectory(appDirectory);
+    let routeConfigExport = (await routesViteNodeContext.runner.executeFile(
+      import_node_path2.default.join(appDirectory, routeConfigFile)
+    )).routes;
+    let routeConfig = await routeConfigExport;
+    let result = validateRouteConfig({
+      routeConfigFile,
+      routeConfig
+    });
+    if (!result.valid) {
+      throw new FriendlyError(result.message);
+    }
+    routes = { ...routes, ...configRoutesToRouteManifest(routeConfig) };
+    lastValidRoutes = routes;
+    if (routeConfigChanged) {
+      logger.info(import_picocolors.default.green("Route config changed."), {
+        clear: true,
+        timestamp: true
+      });
+    }
+  } catch (error) {
+    logger.error(
+      error instanceof FriendlyError ? import_picocolors.default.red(error.message) : [
+        import_picocolors.default.red(`Route config in "${routeConfigFile}" is invalid.`),
+        "",
+        error.loc?.file && error.loc?.column && error.frame ? [
+          import_node_path2.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
+          error.frame.trim?.()
+        ] : error.stack
+      ].flat().join("\n") + "\n",
+      {
+        error,
+        clear: !isFirstLoad,
+        timestamp: !isFirstLoad
+      }
+    );
+    if (isFirstLoad) {
+      process.exit(1);
+    }
+    routes = lastValidRoutes;
+  }
+  let future = {};
+  let reactRouterConfig = deepFreeze({
+    appDirectory,
+    basename: basename2,
+    buildDirectory,
+    buildEnd,
+    future,
+    prerender,
+    routes,
+    serverBuildFile,
+    serverBundles,
+    serverModuleFormat,
+    ssr
+  });
+  for (let preset of reactRouterUserConfig.presets ?? []) {
+    await preset.reactRouterConfigResolved?.({ reactRouterConfig });
+  }
+  isFirstLoad = false;
+  return reactRouterConfig;
+}
+async function resolveEntryFiles({
+  rootDirectory,
+  reactRouterConfig
+}) {
+  let { appDirectory } = reactRouterConfig;
+  let defaultsDirectory = import_node_path2.default.resolve(
+    import_node_path2.default.dirname(require.resolve("@react-router/dev/package.json")),
+    "dist",
+    "config",
+    "defaults"
+  );
+  let userEntryClientFile = findEntry(appDirectory, "entry.client");
+  let userEntryServerFile = findEntry(appDirectory, "entry.server");
+  let entryServerFile;
+  let entryClientFile = userEntryClientFile || "entry.client.tsx";
+  let pkgJson = await import_package_json.default.load(rootDirectory);
+  let deps = pkgJson.content.dependencies ?? {};
+  if (userEntryServerFile) {
+    entryServerFile = userEntryServerFile;
+  } else {
+    if (!deps["@react-router/node"]) {
+      throw new Error(
+        `Could not determine server runtime. Please install @react-router/node, or provide a custom entry.server.tsx/jsx file in your app directory.`
+      );
+    }
+    if (!deps["isbot"]) {
+      console.log(
+        "adding `isbot@5` to your package.json, you should commit this change"
+      );
+      pkgJson.update({
+        dependencies: {
+          ...pkgJson.content.dependencies,
+          isbot: "^5"
+        }
+      });
+      await pkgJson.save();
+      let packageManager = detectPackageManager() ?? "npm";
+      (0, import_node_child_process.execSync)(`${packageManager} install`, {
+        cwd: rootDirectory,
+        stdio: "inherit"
+      });
+    }
+    entryServerFile = `entry.server.node.tsx`;
+  }
+  let entryClientFilePath = userEntryClientFile ? import_node_path2.default.resolve(reactRouterConfig.appDirectory, userEntryClientFile) : import_node_path2.default.resolve(defaultsDirectory, entryClientFile);
+  let entryServerFilePath = userEntryServerFile ? import_node_path2.default.resolve(reactRouterConfig.appDirectory, userEntryServerFile) : import_node_path2.default.resolve(defaultsDirectory, entryServerFile);
+  return { entryClientFilePath, entryServerFilePath };
+}
+var entryExts = [".js", ".jsx", ".ts", ".tsx"];
+function findEntry(dir, basename2) {
+  for (let ext of entryExts) {
+    let file = import_node_path2.default.resolve(dir, basename2 + ext);
+    if (import_fs_extra.default.existsSync(file)) return import_node_path2.default.relative(dir, file);
+  }
+  return void 0;
+}
+
+// vite/with-props.ts
+var import_dedent = __toESM(require("dedent"));
+var vmodId = id("with-props");
+var NAMED_COMPONENT_EXPORTS = ["HydrateFallback", "ErrorBoundary"];
+var plugin = {
+  name: "react-router-with-props",
+  enforce: "pre",
+  resolveId(id2) {
+    if (id2 === vmodId) return resolve2(vmodId);
+  },
+  async load(id2) {
+    if (id2 !== resolve2(vmodId)) return;
+    return import_dedent.default`
+      import { createElement as h } from "react";
+      import { useActionData, useLoaderData, useParams } from "react-router";
+
+      export function withComponentProps(Component) {
+        return function Wrapped() {
+          const props = {
+            params: useParams(),
+            loaderData: useLoaderData(),
+            actionData: useActionData(),
+          };
+          return h(Component, props);
+        };
+      }
+
+      export function withHydrateFallbackProps(HydrateFallback) {
+        return function Wrapped() {
+          const props = {
+            params: useParams(),
+          };
+          return h(HydrateFallback, props);
+        };
+      }
+
+      export function withErrorBoundaryProps(ErrorBoundary) {
+        return function Wrapped() {
+          const props = {
+            params: useParams(),
+            loaderData: useLoaderData(),
+            actionData: useActionData(),
+          };
+          return h(ErrorBoundary, props);
+        };
+      }
+    `;
+  }
+};
+var transform = (ast) => {
+  const hocs = [];
+  function getHocUid(path5, hocName) {
+    const uid = path5.scope.generateUidIdentifier(hocName);
+    hocs.push([hocName, uid]);
+    return uid;
+  }
+  traverse(ast, {
+    ExportDeclaration(path5) {
+      if (path5.isExportDefaultDeclaration()) {
+        const declaration = path5.get("declaration");
+        const expr = declaration.isExpression() ? declaration.node : declaration.isFunctionDeclaration() ? toFunctionExpression(declaration.node) : void 0;
+        if (expr) {
+          const uid = getHocUid(path5, "withComponentProps");
+          declaration.replaceWith(t.callExpression(uid, [expr]));
+        }
+        return;
+      }
+      if (path5.isExportNamedDeclaration()) {
+        const decl = path5.get("declaration");
+        if (decl.isVariableDeclaration()) {
+          decl.get("declarations").forEach((varDeclarator) => {
+            const id2 = varDeclarator.get("id");
+            const init = varDeclarator.get("init");
+            const expr = init.node;
+            if (!expr) return;
+            if (!id2.isIdentifier()) return;
+            const { name } = id2.node;
+            if (!NAMED_COMPONENT_EXPORTS.includes(name)) return;
+            const uid = getHocUid(path5, `with${name}Props`);
+            init.replaceWith(t.callExpression(uid, [expr]));
+          });
+          return;
+        }
+        if (decl.isFunctionDeclaration()) {
+          const { id: id2 } = decl.node;
+          if (!id2) return;
+          const { name } = id2;
+          if (!NAMED_COMPONENT_EXPORTS.includes(name)) return;
+          const uid = getHocUid(path5, `with${name}Props`);
+          decl.replaceWith(
+            t.variableDeclaration("const", [
+              t.variableDeclarator(
+                t.identifier(name),
+                t.callExpression(uid, [toFunctionExpression(decl.node)])
+              )
+            ])
+          );
+        }
+      }
+    }
+  });
+  if (hocs.length > 0) {
+    ast.program.body.unshift(
+      t.importDeclaration(
+        hocs.map(
+          ([name, identifier]) => t.importSpecifier(identifier, t.identifier(name))
+        ),
+        t.stringLiteral(vmodId)
+      )
+    );
+  }
+};
+function toFunctionExpression(decl) {
+  return t.functionExpression(
+    decl.id,
+    decl.params,
+    decl.body,
+    decl.generator,
+    decl.async
+  );
+}
+
+// vite/vite-node.ts
+var import_server = require("vite-node/server");
+var import_client = require("vite-node/client");
+var import_source_map = require("vite-node/source-map");
+async function createContext(viteConfig = {}) {
+  await preloadViteEsm();
+  const vite2 = importViteEsmSync();
+  const devServer = await vite2.createServer(
+    vite2.mergeConfig(
+      {
+        server: {
+          preTransformRequests: false,
+          hmr: false
+        },
+        optimizeDeps: {
+          noDiscovery: true
+        },
+        configFile: false,
+        envFile: false,
+        plugins: []
+      },
+      viteConfig
+    )
+  );
+  await devServer.pluginContainer.buildStart({});
+  const server = new import_server.ViteNodeServer(devServer);
+  (0, import_source_map.installSourcemapsSupport)({
+    getSourceMap: (source) => server.getSourceMap(source)
+  });
+  const runner = new import_client.ViteNodeRunner({
+    root: devServer.config.root,
+    base: devServer.config.base,
+    fetchModule(id2) {
+      return server.fetchModule(id2);
+    },
+    resolveId(id2, importer) {
+      return server.resolveId(id2, importer);
+    }
+  });
+  return { devServer, server, runner };
+}
+
+// vite/plugin.ts
+var SERVER_ONLY_ROUTE_EXPORTS = ["loader", "action", "headers"];
+var CLIENT_ROUTE_EXPORTS = [
+  "clientAction",
+  "clientLoader",
+  "default",
+  "ErrorBoundary",
+  "handle",
+  "HydrateFallback",
+  "Layout",
+  "links",
+  "meta",
+  "shouldRevalidate"
+];
+var ROUTE_ENTRY_QUERY_STRING = "?route-entry=1";
+var isRouteEntry = (id2) => {
+  return id2.endsWith(ROUTE_ENTRY_QUERY_STRING);
+};
+var serverBuildId = id("server-build");
+var serverManifestId = id("server-manifest");
+var browserManifestId = id("browser-manifest");
+var hmrRuntimeId = id("hmr-runtime");
+var injectHmrRuntimeId = id("inject-hmr-runtime");
+var resolveRelativeRouteFilePath = (route, reactRouterConfig) => {
+  let vite2 = importViteEsmSync();
+  let file = route.file;
+  let fullPath = path4.resolve(reactRouterConfig.appDirectory, file);
+  return vite2.normalizePath(fullPath);
+};
+var vmods = [serverBuildId, serverManifestId, browserManifestId];
+var invalidateVirtualModules = (viteDevServer) => {
+  vmods.forEach((vmod) => {
+    let mod = viteDevServer.moduleGraph.getModuleById(
+      resolve2(vmod)
+    );
+    if (mod) {
+      viteDevServer.moduleGraph.invalidateModule(mod);
+    }
+  });
+};
+var getHash = (source, maxLength) => {
+  let hash = (0, import_node_crypto.createHash)("sha256").update(source).digest("hex");
+  return typeof maxLength === "number" ? hash.slice(0, maxLength) : hash;
+};
+var resolveChunk = (ctx, viteManifest, absoluteFilePath) => {
+  let vite2 = importViteEsmSync();
+  let rootRelativeFilePath = vite2.normalizePath(
+    path4.relative(ctx.rootDirectory, absoluteFilePath)
+  );
+  let entryChunk = viteManifest[rootRelativeFilePath + ROUTE_ENTRY_QUERY_STRING] ?? viteManifest[rootRelativeFilePath];
+  if (!entryChunk) {
+    let knownManifestKeys = Object.keys(viteManifest).map((key) => '"' + key + '"').join(", ");
+    throw new Error(
+      `No manifest entry found for "${rootRelativeFilePath}". Known manifest keys: ${knownManifestKeys}`
+    );
+  }
+  return entryChunk;
+};
+var getReactRouterManifestBuildAssets = (ctx, viteManifest, entryFilePath, prependedAssetFilePaths = []) => {
+  let entryChunk = resolveChunk(ctx, viteManifest, entryFilePath);
+  let prependedAssetChunks = prependedAssetFilePaths.map(
+    (filePath) => resolveChunk(ctx, viteManifest, filePath)
+  );
+  let chunks = resolveDependantChunks(viteManifest, [
+    ...prependedAssetChunks,
+    entryChunk
+  ]);
+  return {
+    module: `${ctx.publicPath}${entryChunk.file}`,
+    imports: dedupe(chunks.flatMap((e) => e.imports ?? [])).map((imported) => {
+      return `${ctx.publicPath}${viteManifest[imported].file}`;
+    }) ?? [],
+    css: dedupe(chunks.flatMap((e) => e.css ?? [])).map((href) => {
+      return `${ctx.publicPath}${href}`;
+    }) ?? []
+  };
+};
+function resolveDependantChunks(viteManifest, entryChunks) {
+  let chunks = /* @__PURE__ */ new Set();
+  function walk(chunk) {
+    if (chunks.has(chunk)) {
+      return;
+    }
+    chunks.add(chunk);
+    if (chunk.imports) {
+      for (let importKey of chunk.imports) {
+        walk(viteManifest[importKey]);
+      }
+    }
+  }
+  for (let entryChunk of entryChunks) {
+    walk(entryChunk);
+  }
+  return Array.from(chunks);
+}
+function dedupe(array2) {
+  return [...new Set(array2)];
+}
+var writeFileSafe = async (file, contents) => {
+  await fse2.ensureDir(path4.dirname(file));
+  await fse2.writeFile(file, contents);
+};
+var getRouteManifestModuleExports = async (viteChildCompiler, ctx) => {
+  let entries = await Promise.all(
+    Object.entries(ctx.reactRouterConfig.routes).map(async ([key, route]) => {
+      let sourceExports = await getRouteModuleExports(
+        viteChildCompiler,
+        ctx,
+        route.file
+      );
+      return [key, sourceExports];
+    })
+  );
+  return Object.fromEntries(entries);
+};
+var getRouteModuleExports = async (viteChildCompiler, ctx, routeFile, readRouteFile) => {
+  if (!viteChildCompiler) {
+    throw new Error("Vite child compiler not found");
+  }
+  let ssr = true;
+  let { pluginContainer, moduleGraph } = viteChildCompiler;
+  let routePath = path4.resolve(ctx.reactRouterConfig.appDirectory, routeFile);
+  let url3 = resolveFileUrl(ctx, routePath);
+  let resolveId = async () => {
+    let result = await pluginContainer.resolveId(url3, void 0, { ssr });
+    if (!result) throw new Error(`Could not resolve module ID for ${url3}`);
+    return result.id;
+  };
+  let [id2, code] = await Promise.all([
+    resolveId(),
+    readRouteFile?.() ?? fse2.readFile(routePath, "utf-8"),
+    // pluginContainer.transform(...) fails if we don't do this first:
+    moduleGraph.ensureEntryFromUrl(url3, ssr)
+  ]);
+  let transformed = await pluginContainer.transform(code, id2, { ssr });
+  let [, exports2] = (0, import_es_module_lexer.parse)(transformed.code);
+  let exportNames = exports2.map((e) => e.n);
+  return exportNames;
+};
+var getServerBundleBuildConfig = (viteUserConfig) => {
+  if (!("__reactRouterServerBundleBuildConfig" in viteUserConfig) || !viteUserConfig.__reactRouterServerBundleBuildConfig) {
+    return null;
+  }
+  return viteUserConfig.__reactRouterServerBundleBuildConfig;
+};
+var getServerBuildDirectory = (ctx) => path4.join(
+  ctx.reactRouterConfig.buildDirectory,
+  "server",
+  ...ctx.serverBundleBuildConfig ? [ctx.serverBundleBuildConfig.serverBundleId] : []
+);
+var getClientBuildDirectory = (reactRouterConfig) => path4.join(reactRouterConfig.buildDirectory, "client");
+var defaultEntriesDir = path4.resolve(
+  path4.dirname(require.resolve("@react-router/dev/package.json")),
+  "dist",
+  "config",
+  "defaults"
+);
+var defaultEntries = fse2.readdirSync(defaultEntriesDir).map((filename) => path4.join(defaultEntriesDir, filename));
+invariant(defaultEntries.length > 0, "No default entries found");
+var reactRouterDevLoadContext = () => ({});
+var deepFreeze2 = (o) => {
+  Object.freeze(o);
+  let oIsFunction = typeof o === "function";
+  let hasOwnProp = Object.prototype.hasOwnProperty;
+  Object.getOwnPropertyNames(o).forEach(function(prop) {
+    if (hasOwnProp.call(o, prop) && (oIsFunction ? prop !== "caller" && prop !== "callee" && prop !== "arguments" : true) && o[prop] !== null && (typeof o[prop] === "object" || typeof o[prop] === "function") && !Object.isFrozen(o[prop])) {
+      deepFreeze2(o[prop]);
+    }
+  });
+  return o;
+};
+var reactRouterVitePlugin = (_config) => {
+  let reactRouterUserConfig = _config ?? {};
+  reactRouterUserConfig = deepFreeze2(reactRouterUserConfig);
+  let viteCommand;
+  let viteUserConfig;
+  let viteConfigEnv;
+  let viteConfig;
+  let cssModulesManifest = {};
+  let viteChildCompiler = null;
+  let routesViteNodeContext = null;
+  let ssrExternals = isInReactRouterMonorepo() ? [
+    // This is only needed within this repo because these packages
+    // are linked to a directory outside of node_modules so Vite
+    // treats them as internal code by default.
+    "react-router",
+    "react-router-dom",
+    "@react-router/architect",
+    "@react-router/cloudflare",
+    "@react-router/dev",
+    "@react-router/express",
+    "@react-router/node",
+    "@react-router/serve"
+  ] : void 0;
+  let ctx;
+  let updatePluginContext = async ({
+    routeConfigChanged = false
+  } = {}) => {
+    let rootDirectory = viteUserConfig.root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
+    invariant(routesViteNodeContext);
+    let reactRouterConfig = await resolveReactRouterConfig({
+      rootDirectory,
+      reactRouterUserConfig,
+      routeConfigChanged,
+      viteUserConfig,
+      viteCommand,
+      routesViteNodeContext
+    });
+    let { entryClientFilePath, entryServerFilePath } = await resolveEntryFiles({
+      rootDirectory,
+      reactRouterConfig
+    });
+    let publicPath = resolvePublicPath(viteUserConfig);
+    let viteManifestEnabled = viteUserConfig.build?.manifest === true;
+    let ssrBuildCtx = viteConfigEnv.isSsrBuild && viteCommand === "build" ? {
+      isSsrBuild: true,
+      getReactRouterServerManifest: async () => (await generateReactRouterManifestsForBuild()).reactRouterServerManifest,
+      serverBundleBuildConfig: getServerBundleBuildConfig(viteUserConfig)
+    } : { isSsrBuild: false };
+    ctx = {
+      reactRouterConfig,
+      rootDirectory,
+      entryClientFilePath,
+      entryServerFilePath,
+      publicPath,
+      viteManifestEnabled,
+      ...ssrBuildCtx
+    };
+  };
+  let pluginIndex = (pluginName) => {
+    invariant(viteConfig);
+    return viteConfig.plugins.findIndex((plugin2) => plugin2.name === pluginName);
+  };
+  let getServerEntry = async () => {
+    invariant(viteConfig, "viteconfig required to generate the server entry");
+    let routes = ctx.serverBundleBuildConfig ? (
+      // For server bundle builds, the server build should only import the
+      // routes for this bundle rather than importing all routes
+      ctx.serverBundleBuildConfig.routes
+    ) : (
+      // Otherwise, all routes are imported as usual
+      ctx.reactRouterConfig.routes
+    );
+    return `
+    import * as entryServer from ${JSON.stringify(
+      resolveFileUrl(ctx, ctx.entryServerFilePath)
+    )};
+    ${Object.keys(routes).map((key, index) => {
+      let route = routes[key];
+      return `import * as route${index} from ${JSON.stringify(
+        resolveFileUrl(
+          ctx,
+          resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
+        ) + ROUTE_ENTRY_QUERY_STRING
+      )};`;
+    }).join("\n")}
+      export { default as assets } from ${JSON.stringify(serverManifestId)};
+      export const assetsBuildDirectory = ${JSON.stringify(
+      path4.relative(
+        ctx.rootDirectory,
+        getClientBuildDirectory(ctx.reactRouterConfig)
+      )
+    )};
+      export const basename = ${JSON.stringify(ctx.reactRouterConfig.basename)};
+      export const future = ${JSON.stringify(ctx.reactRouterConfig.future)};
+      export const isSpaMode = ${!ctx.reactRouterConfig.ssr && ctx.reactRouterConfig.prerender == null};
+      export const publicPath = ${JSON.stringify(ctx.publicPath)};
+      export const entry = { module: entryServer };
+      export const routes = {
+        ${Object.keys(routes).map((key, index) => {
+      let route = routes[key];
+      return `${JSON.stringify(key)}: {
+          id: ${JSON.stringify(route.id)},
+          parentId: ${JSON.stringify(route.parentId)},
+          path: ${JSON.stringify(route.path)},
+          index: ${JSON.stringify(route.index)},
+          caseSensitive: ${JSON.stringify(route.caseSensitive)},
+          module: route${index}
+        }`;
+    }).join(",\n  ")}
+      };`;
+  };
+  let loadViteManifest = async (directory) => {
+    let manifestContents = await fse2.readFile(
+      path4.resolve(directory, ".vite", "manifest.json"),
+      "utf-8"
+    );
+    return JSON.parse(manifestContents);
+  };
+  let hasDependency = (name) => {
+    try {
+      return Boolean(require.resolve(name, { paths: [ctx.rootDirectory] }));
+    } catch (err) {
+      return false;
+    }
+  };
+  let getViteManifestAssetPaths = (viteManifest) => {
+    let cssUrlPaths = Object.values(viteManifest).filter((chunk) => chunk.file.endsWith(".css")).map((chunk) => chunk.file);
+    let chunkAssetPaths = Object.values(viteManifest).flatMap(
+      (chunk) => chunk.assets ?? []
+    );
+    return /* @__PURE__ */ new Set([...cssUrlPaths, ...chunkAssetPaths]);
+  };
+  let generateReactRouterManifestsForBuild = async () => {
+    invariant(viteConfig);
+    let viteManifest = await loadViteManifest(
+      getClientBuildDirectory(ctx.reactRouterConfig)
+    );
+    let entry = getReactRouterManifestBuildAssets(
+      ctx,
+      viteManifest,
+      ctx.entryClientFilePath
+    );
+    let browserRoutes = {};
+    let serverRoutes = {};
+    let routeManifestExports = await getRouteManifestModuleExports(
+      viteChildCompiler,
+      ctx
+    );
+    for (let [key, route] of Object.entries(ctx.reactRouterConfig.routes)) {
+      let routeFilePath = path4.join(
+        ctx.reactRouterConfig.appDirectory,
+        route.file
+      );
+      let sourceExports = routeManifestExports[key];
+      let isRootRoute = route.parentId === void 0;
+      let routeManifestEntry = {
+        id: route.id,
+        parentId: route.parentId,
+        path: route.path,
+        index: route.index,
+        caseSensitive: route.caseSensitive,
+        hasAction: sourceExports.includes("action"),
+        hasLoader: sourceExports.includes("loader"),
+        hasClientAction: sourceExports.includes("clientAction"),
+        hasClientLoader: sourceExports.includes("clientLoader"),
+        hasErrorBoundary: sourceExports.includes("ErrorBoundary"),
+        ...getReactRouterManifestBuildAssets(
+          ctx,
+          viteManifest,
+          routeFilePath,
+          // If this is the root route, we also need to include assets from the
+          // client entry file as this is a common way for consumers to import
+          // global reset styles, etc.
+          isRootRoute ? [ctx.entryClientFilePath] : []
+        )
+      };
+      browserRoutes[key] = routeManifestEntry;
+      let serverBundleRoutes = ctx.serverBundleBuildConfig?.routes;
+      if (!serverBundleRoutes || serverBundleRoutes[key]) {
+        serverRoutes[key] = routeManifestEntry;
+      }
+    }
+    let fingerprintedValues = { entry, routes: browserRoutes };
+    let version = getHash(JSON.stringify(fingerprintedValues), 8);
+    let manifestPath = path4.posix.join(
+      viteConfig.build.assetsDir,
+      `manifest-${version}.js`
+    );
+    let url3 = `${ctx.publicPath}${manifestPath}`;
+    let nonFingerprintedValues = { url: url3, version };
+    let reactRouterBrowserManifest = {
+      ...fingerprintedValues,
+      ...nonFingerprintedValues
+    };
+    await writeFileSafe(
+      path4.join(getClientBuildDirectory(ctx.reactRouterConfig), manifestPath),
+      `window.__reactRouterManifest=${JSON.stringify(
+        reactRouterBrowserManifest
+      )};`
+    );
+    let reactRouterServerManifest = {
+      ...reactRouterBrowserManifest,
+      routes: serverRoutes
+    };
+    return {
+      reactRouterBrowserManifest,
+      reactRouterServerManifest
+    };
+  };
+  let getReactRouterManifestForDev = async () => {
+    let routes = {};
+    let routeManifestExports = await getRouteManifestModuleExports(
+      viteChildCompiler,
+      ctx
+    );
+    for (let [key, route] of Object.entries(ctx.reactRouterConfig.routes)) {
+      let sourceExports = routeManifestExports[key];
+      routes[key] = {
+        id: route.id,
+        parentId: route.parentId,
+        path: route.path,
+        index: route.index,
+        caseSensitive: route.caseSensitive,
+        module: combineURLs(
+          ctx.publicPath,
+          `${resolveFileUrl(
+            ctx,
+            resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
+          )}${ROUTE_ENTRY_QUERY_STRING}`
+        ),
+        hasAction: sourceExports.includes("action"),
+        hasLoader: sourceExports.includes("loader"),
+        hasClientAction: sourceExports.includes("clientAction"),
+        hasClientLoader: sourceExports.includes("clientLoader"),
+        hasErrorBoundary: sourceExports.includes("ErrorBoundary"),
+        imports: []
+      };
+    }
+    return {
+      version: String(Math.random()),
+      url: combineURLs(ctx.publicPath, url(browserManifestId)),
+      hmr: {
+        runtime: combineURLs(
+          ctx.publicPath,
+          url(injectHmrRuntimeId)
+        )
+      },
+      entry: {
+        module: combineURLs(
+          ctx.publicPath,
+          resolveFileUrl(ctx, ctx.entryClientFilePath)
+        ),
+        imports: []
+      },
+      routes
+    };
+  };
+  return [
+    {
+      name: "react-router",
+      config: async (_viteUserConfig, _viteConfigEnv) => {
+        await preloadViteEsm();
+        let vite2 = importViteEsmSync();
+        viteUserConfig = _viteUserConfig;
+        viteConfigEnv = _viteConfigEnv;
+        viteCommand = viteConfigEnv.command;
+        routesViteNodeContext = await createContext({
+          root: viteUserConfig.root,
+          mode: viteConfigEnv.mode,
+          server: {
+            watch: viteCommand === "build" ? null : void 0
+          },
+          ssr: {
+            external: ssrExternals
+          }
+        });
+        await updatePluginContext();
+        Object.assign(
+          process.env,
+          vite2.loadEnv(
+            viteConfigEnv.mode,
+            ctx.rootDirectory,
+            // We override default prefix of "VITE_" with a blank string since
+            // we're targeting the server, so we want to load all environment
+            // variables, not just those explicitly marked for the client
+            ""
+          )
+        );
+        let baseRollupOptions = {
+          // Silence Rollup "use client" warnings
+          // Adapted from https://github.com/vitejs/vite-plugin-react/pull/144
+          onwarn(warning, defaultHandler) {
+            if (warning.code === "MODULE_LEVEL_DIRECTIVE" && warning.message.includes("use client")) {
+              return;
+            }
+            if (viteUserConfig.build?.rollupOptions?.onwarn) {
+              viteUserConfig.build.rollupOptions.onwarn(
+                warning,
+                defaultHandler
+              );
+            } else {
+              defaultHandler(warning);
+            }
+          }
+        };
+        return {
+          __reactRouterPluginContext: ctx,
+          appType: viteCommand === "serve" && viteConfigEnv.mode === "production" && ctx.reactRouterConfig.ssr === false ? "spa" : "custom",
+          ssr: {
+            external: ssrExternals
+          },
+          optimizeDeps: {
+            include: [
+              // Pre-bundle React dependencies to avoid React duplicates,
+              // even if React dependencies are not direct dependencies.
+              // https://react.dev/warnings/invalid-hook-call-warning#duplicate-react
+              "react",
+              "react/jsx-runtime",
+              "react/jsx-dev-runtime",
+              "react-dom",
+              "react-dom/client",
+              // Pre-bundle router dependencies to avoid router duplicates.
+              // Mismatching routers cause `Error: You must render this element inside a <Remix> element`.
+              "react-router",
+              "react-router/dom",
+              // Check to avoid "Failed to resolve dependency: react-router-dom, present in 'optimizeDeps.include'"
+              ...hasDependency("react-router-dom") ? ["react-router-dom"] : []
+            ]
+          },
+          esbuild: {
+            jsx: "automatic",
+            jsxDev: viteCommand !== "build"
+          },
+          resolve: {
+            dedupe: [
+              // https://react.dev/warnings/invalid-hook-call-warning#duplicate-react
+              "react",
+              "react-dom",
+              // see description for `optimizeDeps.include`
+              "react-router",
+              "react-router/dom",
+              "react-router-dom"
+            ]
+          },
+          base: viteUserConfig.base,
+          // When consumer provides an allow list for files that can be read by
+          // the server, ensure that the default entry files are included.
+          // If we don't do this and a default entry file is used, the server
+          // will throw an error that the file is not allowed to be read.
+          // https://vitejs.dev/config/server-options#server-fs-allow
+          server: viteUserConfig.server?.fs?.allow ? { fs: { allow: defaultEntries } } : void 0,
+          // Vite config options for building
+          ...viteCommand === "build" ? {
+            build: {
+              cssMinify: viteUserConfig.build?.cssMinify ?? true,
+              ...!viteConfigEnv.isSsrBuild ? {
+                manifest: true,
+                outDir: getClientBuildDirectory(ctx.reactRouterConfig),
+                rollupOptions: {
+                  ...baseRollupOptions,
+                  preserveEntrySignatures: "exports-only",
+                  input: [
+                    ctx.entryClientFilePath,
+                    ...Object.values(ctx.reactRouterConfig.routes).map(
+                      (route) => `${path4.resolve(
+                        ctx.reactRouterConfig.appDirectory,
+                        route.file
+                      )}${ROUTE_ENTRY_QUERY_STRING}`
+                    )
+                  ]
+                }
+              } : {
+                // We move SSR-only assets to client assets. Note that the
+                // SSR build can also emit code-split JS files (e.g. by
+                // dynamic import) under the same assets directory
+                // regardless of "ssrEmitAssets" option, so we also need to
+                // keep these JS files have to be kept as-is.
+                ssrEmitAssets: true,
+                copyPublicDir: false,
+                // Assets in the public directory are only used by the client
+                manifest: true,
+                // We need the manifest to detect SSR-only assets
+                outDir: getServerBuildDirectory(ctx),
+                rollupOptions: {
+                  ...baseRollupOptions,
+                  preserveEntrySignatures: "exports-only",
+                  input: viteUserConfig.build?.rollupOptions?.input ?? serverBuildId,
+                  output: {
+                    entryFileNames: ctx.reactRouterConfig.serverBuildFile,
+                    format: ctx.reactRouterConfig.serverModuleFormat
+                  }
+                }
+              }
+            }
+          } : void 0,
+          // Vite config options for SPA preview mode
+          ...viteCommand === "serve" && ctx.reactRouterConfig.ssr === false ? {
+            build: {
+              manifest: true,
+              outDir: getClientBuildDirectory(ctx.reactRouterConfig)
+            }
+          } : void 0
+        };
+      },
+      async configResolved(resolvedViteConfig) {
+        await import_es_module_lexer.init;
+        viteConfig = resolvedViteConfig;
+        invariant(viteConfig);
+        if (!viteConfig.configFile) {
+          throw new Error(
+            "The React Router Vite plugin requires the use of a Vite config file"
+          );
+        }
+        let vite2 = importViteEsmSync();
+        let childCompilerConfigFile = await vite2.loadConfigFromFile(
+          {
+            command: viteConfig.command,
+            mode: viteConfig.mode,
+            isSsrBuild: ctx.isSsrBuild
+          },
+          viteConfig.configFile
+        );
+        invariant(
+          childCompilerConfigFile,
+          "Vite config file was unable to be resolved for React Router child compiler"
+        );
+        let rollupPrePlugins = [
+          { pluginName: "@mdx-js/rollup", displayName: "@mdx-js/rollup" }
+        ];
+        for (let prePlugin of rollupPrePlugins) {
+          let prePluginIndex = pluginIndex(prePlugin.pluginName);
+          if (prePluginIndex >= 0 && prePluginIndex > pluginIndex("react-router")) {
+            throw new Error(
+              `The "${prePlugin.displayName}" plugin should be placed before the React Router plugin in your Vite config file`
+            );
+          }
+        }
+        viteChildCompiler = await vite2.createServer({
+          ...viteUserConfig,
+          mode: viteConfig.mode,
+          server: {
+            watch: viteConfig.command === "build" ? null : void 0,
+            preTransformRequests: false,
+            hmr: false
+          },
+          configFile: false,
+          envFile: false,
+          plugins: [
+            ...(childCompilerConfigFile.config.plugins ?? []).flat().filter(
+              (plugin2) => typeof plugin2 === "object" && plugin2 !== null && "name" in plugin2 && plugin2.name !== "react-router" && plugin2.name !== "react-router-route-exports" && plugin2.name !== "react-router-hmr-updates"
+            )
+          ]
+        });
+        await viteChildCompiler.pluginContainer.buildStart({});
+      },
+      async transform(code, id2) {
+        if (isCssModulesFile(id2)) {
+          cssModulesManifest[id2] = code;
+        }
+      },
+      buildStart() {
+        invariant(viteConfig);
+        if (viteCommand === "build" && viteConfig.mode === "production" && !viteConfig.build.ssr && viteConfig.build.sourcemap) {
+          viteConfig.logger.warn(
+            import_picocolors2.default.yellow(
+              "\n" + import_picocolors2.default.bold("  \u26A0\uFE0F  Source maps are enabled in production\n") + [
+                "This makes your server code publicly",
+                "visible in the browser. This is highly",
+                "discouraged! If you insist, ensure that",
+                "you are using environment variables for",
+                "secrets and not hard-coding them in",
+                "your source code."
+              ].map((line) => "     " + line).join("\n") + "\n"
+            )
+          );
+        }
+      },
+      async configureServer(viteDevServer) {
+        (0, import_react_router2.unstable_setDevServerHooks)({
+          // Give the request handler access to the critical CSS in dev to avoid a
+          // flash of unstyled content since Vite injects CSS file contents via JS
+          getCriticalCss: async (build, url3) => {
+            return getStylesForUrl({
+              rootDirectory: ctx.rootDirectory,
+              entryClientFilePath: ctx.entryClientFilePath,
+              reactRouterConfig: ctx.reactRouterConfig,
+              viteDevServer,
+              cssModulesManifest,
+              build,
+              url: url3
+            });
+          },
+          // If an error is caught within the request handler, let Vite fix the
+          // stack trace so it maps back to the actual source code
+          processRequestError: (error) => {
+            if (error instanceof Error) {
+              viteDevServer.ssrFixStacktrace(error);
+            }
+          }
+        });
+        viteDevServer.watcher.on("all", async (eventName, rawFilepath) => {
+          let { normalizePath } = importViteEsmSync();
+          let filepath = normalizePath(rawFilepath);
+          let appFileAddedOrRemoved = (eventName === "add" || eventName === "unlink") && filepath.startsWith(
+            normalizePath(ctx.reactRouterConfig.appDirectory)
+          );
+          invariant(viteConfig?.configFile);
+          let viteConfigChanged = eventName === "change" && filepath === normalizePath(viteConfig.configFile);
+          let routeConfigChanged = Boolean(
+            routesViteNodeContext?.devServer?.moduleGraph.getModuleById(
+              filepath
+            )
+          );
+          if (routeConfigChanged || appFileAddedOrRemoved) {
+            routesViteNodeContext?.devServer?.moduleGraph.invalidateAll();
+            routesViteNodeContext?.runner?.moduleCache.clear();
+          }
+          if (appFileAddedOrRemoved || viteConfigChanged || routeConfigChanged) {
+            let lastReactRouterConfig = ctx.reactRouterConfig;
+            await updatePluginContext({ routeConfigChanged });
+            if (!isEqualJson(lastReactRouterConfig, ctx.reactRouterConfig)) {
+              invalidateVirtualModules(viteDevServer);
+            }
+          }
+        });
+        return () => {
+          if (!viteDevServer.config.server.middlewareMode) {
+            viteDevServer.middlewares.use(async (req, res, next) => {
+              try {
+                let build = await viteDevServer.ssrLoadModule(
+                  serverBuildId
+                );
+                let handler = (0, import_react_router2.createRequestHandler)(build, "development");
+                let nodeHandler = async (nodeReq, nodeRes) => {
+                  let req2 = fromNodeRequest(nodeReq, nodeRes);
+                  let res2 = await handler(
+                    req2,
+                    await reactRouterDevLoadContext(req2)
+                  );
+                  await toNodeRequest(res2, nodeRes);
+                };
+                await nodeHandler(req, res);
+              } catch (error) {
+                next(error);
+              }
+            });
+          }
+        };
+      },
+      writeBundle: {
+        // After the SSR build is finished, we inspect the Vite manifest for
+        // the SSR build and move server-only assets to client assets directory
+        async handler() {
+          if (!ctx.isSsrBuild) {
+            return;
+          }
+          invariant(viteConfig);
+          let clientBuildDirectory = getClientBuildDirectory(
+            ctx.reactRouterConfig
+          );
+          let serverBuildDirectory = getServerBuildDirectory(ctx);
+          let ssrViteManifest = await loadViteManifest(serverBuildDirectory);
+          let ssrAssetPaths = getViteManifestAssetPaths(ssrViteManifest);
+          let movedAssetPaths = [];
+          for (let ssrAssetPath of ssrAssetPaths) {
+            let src = path4.join(serverBuildDirectory, ssrAssetPath);
+            let dest = path4.join(clientBuildDirectory, ssrAssetPath);
+            if (!fse2.existsSync(dest)) {
+              await fse2.move(src, dest);
+              movedAssetPaths.push(dest);
+            } else {
+              await fse2.remove(src);
+            }
+          }
+          let ssrCssPaths = Object.values(ssrViteManifest).flatMap(
+            (chunk) => chunk.css ?? []
+          );
+          await Promise.all(
+            ssrCssPaths.map(
+              (cssPath) => fse2.remove(path4.join(serverBuildDirectory, cssPath))
+            )
+          );
+          if (movedAssetPaths.length) {
+            viteConfig.logger.info(
+              [
+                "",
+                `${import_picocolors2.default.green("\u2713")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from React Router server build to client assets.`,
+                ...movedAssetPaths.map(
+                  (movedAssetPath) => import_picocolors2.default.dim(path4.relative(ctx.rootDirectory, movedAssetPath))
+                ),
+                ""
+              ].join("\n")
+            );
+          }
+          if (ctx.reactRouterConfig.prerender != null && ctx.reactRouterConfig.prerender !== false) {
+            await handlePrerender(
+              viteConfig,
+              ctx.reactRouterConfig,
+              serverBuildDirectory,
+              clientBuildDirectory
+            );
+          } else if (!ctx.reactRouterConfig.ssr) {
+            await handleSpaMode(
+              viteConfig,
+              ctx.reactRouterConfig,
+              serverBuildDirectory,
+              clientBuildDirectory
+            );
+          }
+          if (!ctx.reactRouterConfig.ssr) {
+            viteConfig.logger.info(
+              [
+                "Removing the server build in",
+                import_picocolors2.default.green(serverBuildDirectory),
+                "due to ssr:false"
+              ].join(" ")
+            );
+            fse2.removeSync(serverBuildDirectory);
+          }
+        }
+      },
+      async buildEnd() {
+        await viteChildCompiler?.close();
+        await routesViteNodeContext?.devServer?.close();
+      }
+    },
+    {
+      name: "react-router-route-entry",
+      enforce: "pre",
+      async transform(_code, id2, options) {
+        if (!isRouteEntry(id2)) return;
+        let routeModuleId = id2.replace(ROUTE_ENTRY_QUERY_STRING, "");
+        let routeFileName = path4.basename(routeModuleId);
+        let sourceExports = await getRouteModuleExports(
+          viteChildCompiler,
+          ctx,
+          routeModuleId
+        );
+        let reexports = sourceExports.filter(
+          (exportName) => options?.ssr && SERVER_ONLY_ROUTE_EXPORTS.includes(exportName) || CLIENT_ROUTE_EXPORTS.includes(exportName)
+        ).join(", ");
+        return `export { ${reexports} } from "./${routeFileName}";`;
+      }
+    },
+    {
+      name: "react-router-virtual-modules",
+      enforce: "pre",
+      resolveId(id2) {
+        if (vmods.includes(id2)) return resolve2(id2);
+      },
+      async load(id2) {
+        switch (id2) {
+          case resolve2(serverBuildId): {
+            return await getServerEntry();
+          }
+          case resolve2(serverManifestId): {
+            let reactRouterManifest = ctx.isSsrBuild ? await ctx.getReactRouterServerManifest() : await getReactRouterManifestForDev();
+            return `export default ${(0, import_jsesc.default)(reactRouterManifest, {
+              es6: true
+            })};`;
+          }
+          case resolve2(browserManifestId): {
+            if (viteCommand === "build") {
+              throw new Error("This module only exists in development");
+            }
+            let reactRouterManifest = await getReactRouterManifestForDev();
+            let reactRouterManifestString = (0, import_jsesc.default)(reactRouterManifest, {
+              es6: true
+            });
+            return `window.__reactRouterManifest=${reactRouterManifestString};`;
+          }
+        }
+      }
+    },
+    {
+      name: "react-router-dot-server",
+      enforce: "pre",
+      async resolveId(id2, importer, options) {
+        let isOptimizeDeps = viteCommand === "serve" && options?.scan === true;
+        if (isOptimizeDeps || options?.ssr) return;
+        let isResolving = options?.custom?.["react-router-dot-server"] ?? false;
+        if (isResolving) return;
+        options.custom = { ...options.custom, "react-router-dot-server": true };
+        let resolved = await this.resolve(id2, importer, options);
+        if (!resolved) return;
+        let serverFileRE = /\.server(\.[cm]?[jt]sx?)?$/;
+        let serverDirRE = /\/\.server\//;
+        let isDotServer = serverFileRE.test(resolved.id) || serverDirRE.test(resolved.id);
+        if (!isDotServer) return;
+        if (!importer) return;
+        if (viteCommand !== "build" && importer.endsWith(".html")) {
+          return;
+        }
+        let vite2 = importViteEsmSync();
+        let importerShort = vite2.normalizePath(
+          path4.relative(ctx.rootDirectory, importer)
+        );
+        let isRoute = getRoute(ctx.reactRouterConfig, importer);
+        if (isRoute) {
+          let serverOnlyExports = SERVER_ONLY_ROUTE_EXPORTS.map(
+            (xport) => `\`${xport}\``
+          ).join(", ");
+          throw Error(
+            [
+              import_picocolors2.default.red(`Server-only module referenced by client`),
+              "",
+              `    '${id2}' imported by route '${importerShort}'`,
+              "",
+              `  React Router automatically removes server-code from these exports:`,
+              `    ${serverOnlyExports}`,
+              "",
+              `  But other route exports in '${importerShort}' depend on '${id2}'.`,
+              "",
+              "  See https://remix.run/docs/en/main/guides/vite#splitting-up-client-and-server-code",
+              ""
+            ].join("\n")
+          );
+        }
+        throw Error(
+          [
+            import_picocolors2.default.red(`Server-only module referenced by client`),
+            "",
+            `    '${id2}' imported by '${importerShort}'`,
+            "",
+            "  See https://remix.run/docs/en/main/guides/vite#splitting-up-client-and-server-code",
+            ""
+          ].join("\n")
+        );
+      }
+    },
+    {
+      name: "react-router-dot-client",
+      async transform(code, id2, options) {
+        if (!options?.ssr) return;
+        let clientFileRE = /\.client(\.[cm]?[jt]sx?)?$/;
+        let clientDirRE = /\/\.client\//;
+        if (clientFileRE.test(id2) || clientDirRE.test(id2)) {
+          let exports2 = (0, import_es_module_lexer.parse)(code)[1];
+          return {
+            code: exports2.map(
+              ({ n: name }) => name === "default" ? "export default undefined;" : `export const ${name} = undefined;`
+            ).join("\n"),
+            map: null
+          };
+        }
+      }
+    },
+    plugin,
+    {
+      name: "react-router-route-exports",
+      async transform(code, id2, options) {
+        let route = getRoute(ctx.reactRouterConfig, id2);
+        if (!route) return;
+        if (!options?.ssr && !ctx.reactRouterConfig.ssr) {
+          let serverOnlyExports = (0, import_es_module_lexer.parse)(code)[1].map((exp) => exp.n).filter((exp) => SERVER_ONLY_ROUTE_EXPORTS.includes(exp));
+          if (serverOnlyExports.length > 0) {
+            let str = serverOnlyExports.map((e) => `\`${e}\``).join(", ");
+            let message = `SPA Mode: ${serverOnlyExports.length} invalid route export(s) in \`${route.file}\`: ${str}. See https://remix.run/guides/spa-mode for more information.`;
+            throw Error(message);
+          }
+          if (route.id !== "root") {
+            let hasHydrateFallback = (0, import_es_module_lexer.parse)(code)[1].map((exp) => exp.n).some((exp) => exp === "HydrateFallback");
+            if (hasHydrateFallback) {
+              let message = `SPA Mode: Invalid \`HydrateFallback\` export found in \`${route.file}\`. \`HydrateFallback\` is only permitted on the root route in SPA Mode. See https://remix.run/guides/spa-mode for more information.`;
+              throw Error(message);
+            }
+          }
+        }
+        let [filepath] = id2.split("?");
+        let ast = (0, import_parser.parse)(code, { sourceType: "module" });
+        if (!options?.ssr) {
+          removeExports(ast, SERVER_ONLY_ROUTE_EXPORTS);
+        }
+        transform(ast);
+        return generate(ast, {
+          sourceMaps: true,
+          filename: id2,
+          sourceFileName: filepath
+        });
+      }
+    },
+    {
+      name: "react-router-inject-hmr-runtime",
+      enforce: "pre",
+      resolveId(id2) {
+        if (id2 === injectHmrRuntimeId)
+          return resolve2(injectHmrRuntimeId);
+      },
+      async load(id2) {
+        if (id2 !== resolve2(injectHmrRuntimeId)) return;
+        return [
+          `import RefreshRuntime from "${hmrRuntimeId}"`,
+          "RefreshRuntime.injectIntoGlobalHook(window)",
+          "window.$RefreshReg$ = () => {}",
+          "window.$RefreshSig$ = () => (type) => type",
+          "window.__vite_plugin_react_preamble_installed__ = true"
+        ].join("\n");
+      }
+    },
+    {
+      name: "react-router-hmr-runtime",
+      enforce: "pre",
+      resolveId(id2) {
+        if (id2 === hmrRuntimeId) return resolve2(hmrRuntimeId);
+      },
+      async load(id2) {
+        if (id2 !== resolve2(hmrRuntimeId)) return;
+        let reactRefreshDir = path4.dirname(
+          require.resolve("react-refresh/package.json")
+        );
+        let reactRefreshRuntimePath = path4.join(
+          reactRefreshDir,
+          "cjs/react-refresh-runtime.development.js"
+        );
+        return [
+          "const exports = {}",
+          await fse2.readFile(reactRefreshRuntimePath, "utf8"),
+          await fse2.readFile(
+            require.resolve("./static/refresh-utils.cjs"),
+            "utf8"
+          ),
+          "export default exports"
+        ].join("\n");
+      }
+    },
+    {
+      name: "react-router-react-refresh-babel",
+      async transform(code, id2, options) {
+        if (viteCommand !== "serve") return;
+        if (id2.includes("/node_modules/")) return;
+        let [filepath] = id2.split("?");
+        let extensionsRE = /\.(jsx?|tsx?|mdx?)$/;
+        if (!extensionsRE.test(filepath)) return;
+        let devRuntime = "react/jsx-dev-runtime";
+        let ssr = options?.ssr === true;
+        let isJSX = filepath.endsWith("x");
+        let useFastRefresh = !ssr && (isJSX || code.includes(devRuntime));
+        if (!useFastRefresh) return;
+        if (isRouteEntry(id2)) {
+          return { code: addRefreshWrapper(ctx.reactRouterConfig, code, id2) };
+        }
+        let result = await babel.transformAsync(code, {
+          babelrc: false,
+          configFile: false,
+          filename: id2,
+          sourceFileName: filepath,
+          parserOpts: {
+            sourceType: "module",
+            allowAwaitOutsideFunction: true
+          },
+          plugins: [[require("react-refresh/babel"), { skipEnvCheck: true }]],
+          sourceMaps: true
+        });
+        if (result === null) return;
+        code = result.code;
+        let refreshContentRE = /\$Refresh(?:Reg|Sig)\$\(/;
+        if (refreshContentRE.test(code)) {
+          code = addRefreshWrapper(ctx.reactRouterConfig, code, id2);
+        }
+        return { code, map: result.map };
+      }
+    },
+    {
+      name: "react-router-hmr-updates",
+      async handleHotUpdate({ server, file, modules, read }) {
+        let route = getRoute(ctx.reactRouterConfig, file);
+        let hmrEventData = { route: null };
+        if (route) {
+          let serverManifest = (await server.ssrLoadModule(serverManifestId)).default;
+          let oldRouteMetadata = serverManifest.routes[route.id];
+          let newRouteMetadata = await getRouteMetadata(
+            ctx,
+            viteChildCompiler,
+            route,
+            read
+          );
+          hmrEventData.route = newRouteMetadata;
+          if (!oldRouteMetadata || [
+            "hasLoader",
+            "hasClientLoader",
+            "hasAction",
+            "hasClientAction",
+            "hasErrorBoundary"
+          ].some((key) => oldRouteMetadata[key] !== newRouteMetadata[key])) {
+            invalidateVirtualModules(server);
+          }
+        }
+        server.hot.send({
+          type: "custom",
+          event: "react-router:hmr",
+          data: hmrEventData
+        });
+        return modules;
+      }
+    }
+  ];
+};
+function isInReactRouterMonorepo() {
+  let serverRuntimePath = path4.dirname(
+    require.resolve("@react-router/node/package.json")
+  );
+  let serverRuntimeParentDir = path4.basename(
+    path4.resolve(serverRuntimePath, "..")
+  );
+  return serverRuntimeParentDir === "packages";
+}
+function isEqualJson(v1, v2) {
+  return JSON.stringify(v1) === JSON.stringify(v2);
+}
+function addRefreshWrapper(reactRouterConfig, code, id2) {
+  let route = getRoute(reactRouterConfig, id2);
+  let acceptExports = route || isRouteEntry(id2) ? [
+    "clientAction",
+    "clientLoader",
+    "handle",
+    "meta",
+    "links",
+    "shouldRevalidate"
+  ] : [];
+  return "\n\n" + withCommentBoundaries(
+    "REACT REFRESH HEADER",
+    REACT_REFRESH_HEADER.replaceAll("__SOURCE__", JSON.stringify(id2))
+  ) + "\n\n" + withCommentBoundaries("REACT REFRESH BODY", code) + "\n\n" + withCommentBoundaries(
+    "REACT REFRESH FOOTER",
+    REACT_REFRESH_FOOTER.replaceAll("__SOURCE__", JSON.stringify(id2)).replaceAll("__ACCEPT_EXPORTS__", JSON.stringify(acceptExports)).replaceAll("__ROUTE_ID__", JSON.stringify(route?.id))
+  ) + "\n";
+}
+function withCommentBoundaries(label, text) {
+  let begin = `// [BEGIN] ${label} `;
+  begin += "-".repeat(80 - begin.length);
+  let end = `// [END] ${label} `;
+  end += "-".repeat(80 - end.length);
+  return `${begin}
+${text}
+${end}`;
+}
+var REACT_REFRESH_HEADER = `
+import RefreshRuntime from "${hmrRuntimeId}";
+
+const inWebWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;
+let prevRefreshReg;
+let prevRefreshSig;
+
+if (import.meta.hot && !inWebWorker) {
+  if (!window.__vite_plugin_react_preamble_installed__) {
+    throw new Error(
+      "React Router Vite plugin can't detect preamble. Something is wrong."
+    );
+  }
+
+  prevRefreshReg = window.$RefreshReg$;
+  prevRefreshSig = window.$RefreshSig$;
+  window.$RefreshReg$ = (type, id) => {
+    RefreshRuntime.register(type, __SOURCE__ + " " + id)
+  };
+  window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+}`.trim();
+var REACT_REFRESH_FOOTER = `
+if (import.meta.hot && !inWebWorker) {
+  window.$RefreshReg$ = prevRefreshReg;
+  window.$RefreshSig$ = prevRefreshSig;
+  RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
+    RefreshRuntime.registerExportsForReactRefresh(__SOURCE__, currentExports);
+    import.meta.hot.accept((nextExports) => {
+      if (!nextExports) return;
+      __ROUTE_ID__ && window.__reactRouterRouteModuleUpdates.set(__ROUTE_ID__, nextExports);
+      const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate(currentExports, nextExports, __ACCEPT_EXPORTS__);
+      if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
+    });
+  });
+}`.trim();
+function getRoute(pluginConfig, file) {
+  let vite2 = importViteEsmSync();
+  let routePath = vite2.normalizePath(
+    path4.relative(pluginConfig.appDirectory, file)
+  );
+  let route = Object.values(pluginConfig.routes).find(
+    (r) => vite2.normalizePath(r.file) === routePath
+  );
+  return route;
+}
+async function getRouteMetadata(ctx, viteChildCompiler, route, readRouteFile) {
+  let sourceExports = await getRouteModuleExports(
+    viteChildCompiler,
+    ctx,
+    route.file,
+    readRouteFile
+  );
+  let info = {
+    id: route.id,
+    parentId: route.parentId,
+    path: route.path,
+    index: route.index,
+    caseSensitive: route.caseSensitive,
+    url: combineURLs(
+      ctx.publicPath,
+      "/" + path4.relative(
+        ctx.rootDirectory,
+        resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
+      )
+    ),
+    module: combineURLs(
+      ctx.publicPath,
+      `${resolveFileUrl(
+        ctx,
+        resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
+      )}?import`
+    ),
+    // Ensure the Vite dev server responds with a JS module
+    hasAction: sourceExports.includes("action"),
+    hasClientAction: sourceExports.includes("clientAction"),
+    hasLoader: sourceExports.includes("loader"),
+    hasClientLoader: sourceExports.includes("clientLoader"),
+    hasErrorBoundary: sourceExports.includes("ErrorBoundary"),
+    imports: []
+  };
+  return info;
+}
+async function getPrerenderBuildAndHandler(viteConfig, reactRouterConfig, serverBuildDirectory) {
+  let serverBuildPath = path4.join(
+    serverBuildDirectory,
+    reactRouterConfig.serverBuildFile
+  );
+  let build = await import(url2.pathToFileURL(serverBuildPath).toString());
+  let { createRequestHandler: createHandler } = await import("react-router");
+  return {
+    build,
+    handler: createHandler(build, viteConfig.mode)
+  };
+}
+async function handleSpaMode(viteConfig, reactRouterConfig, serverBuildDirectory, clientBuildDirectory) {
+  let { handler } = await getPrerenderBuildAndHandler(
+    viteConfig,
+    reactRouterConfig,
+    serverBuildDirectory
+  );
+  let request = new Request(`http://localhost${reactRouterConfig.basename}`);
+  let response = await handler(request);
+  let html = await response.text();
+  validatePrerenderedResponse(response, html, "SPA Mode", "/");
+  validatePrerenderedHtml(html, "SPA Mode");
+  await fse2.writeFile(path4.join(clientBuildDirectory, "index.html"), html);
+  viteConfig.logger.info(
+    "SPA Mode: index.html has been written to your " + import_picocolors2.default.bold(path4.relative(process.cwd(), clientBuildDirectory)) + " directory"
+  );
+}
+async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirectory, clientBuildDirectory) {
+  let { build, handler } = await getPrerenderBuildAndHandler(
+    viteConfig,
+    reactRouterConfig,
+    serverBuildDirectory
+  );
+  let routes = createPrerenderRoutes(build.routes);
+  let routesToPrerender;
+  if (typeof reactRouterConfig.prerender === "boolean") {
+    invariant(reactRouterConfig.prerender, "Expected prerender:true");
+    routesToPrerender = determineStaticPrerenderRoutes(
+      routes,
+      viteConfig,
+      true
+    );
+  } else if (typeof reactRouterConfig.prerender === "function") {
+    routesToPrerender = await reactRouterConfig.prerender({
+      getStaticPaths: () => determineStaticPrerenderRoutes(routes, viteConfig, false)
+    });
+  } else {
+    routesToPrerender = reactRouterConfig.prerender || ["/"];
+  }
+  let headers = {
+    // Header that can be used in the loader to know if you're running at
+    // build time or runtime
+    "X-React-Router-Prerender": "yes"
+  };
+  for (let path5 of routesToPrerender) {
+    let matches = (0, import_react_router2.matchRoutes)(routes, path5);
+    let hasLoaders = matches?.some((m) => m.route.loader);
+    let data;
+    if (hasLoaders) {
+      data = await prerenderData(
+        handler,
+        path5,
+        clientBuildDirectory,
+        reactRouterConfig,
+        viteConfig,
+        { headers }
+      );
+    }
+    let leafRoute = matches ? matches[matches.length - 1].route : null;
+    let manifestRoute = leafRoute ? build.routes[leafRoute.id]?.module : null;
+    let isResourceRoute = manifestRoute && !manifestRoute.default && !manifestRoute.ErrorBoundary && manifestRoute.loader;
+    if (isResourceRoute) {
+      await prerenderResourceRoute(
+        handler,
+        path5,
+        clientBuildDirectory,
+        reactRouterConfig,
+        viteConfig,
+        { headers }
+      );
+    } else {
+      await prerenderRoute(
+        handler,
+        path5,
+        clientBuildDirectory,
+        reactRouterConfig,
+        viteConfig,
+        data ? { headers: { ...headers, "X-React-Router-Prerender-Data": data } } : { headers }
+      );
+    }
+  }
+  await prerenderManifest(
+    build,
+    clientBuildDirectory,
+    reactRouterConfig,
+    viteConfig
+  );
+}
+function determineStaticPrerenderRoutes(routes, viteConfig, isBooleanUsage = false) {
+  let paths = ["/"];
+  let paramRoutes = [];
+  function recurse(subtree, prefix = "") {
+    for (let route of subtree) {
+      let newPath = [prefix, route.path].join("/").replace(/\/\/+/g, "/");
+      if (route.path) {
+        let segments = route.path.split("/");
+        if (segments.some((s) => s.startsWith(":") || s === "*")) {
+          paramRoutes.push(route.path);
+        } else {
+          paths.push(newPath);
+        }
+      }
+      if (route.children) {
+        recurse(route.children, newPath);
+      }
+    }
+  }
+  recurse(routes);
+  if (isBooleanUsage && paramRoutes.length > 0) {
+    viteConfig.logger.warn(
+      [
+        "\u26A0\uFE0F Paths with dynamic/splat params cannot be prerendered when using `prerender: true`.",
+        "You may want to use the `prerender()` API to prerender the following paths:",
+        ...paramRoutes.map((p) => "  - " + p)
+      ].join("\n")
+    );
+  }
+  return paths.map((p) => p.replace(/\/\/+/g, "/").replace(/(.+)\/$/, "$1"));
+}
+async function prerenderData(handler, prerenderPath, clientBuildDirectory, reactRouterConfig, viteConfig, requestInit) {
+  let normalizedPath = `${reactRouterConfig.basename}${prerenderPath === "/" ? "/_root.data" : `${prerenderPath.replace(/\/$/, "")}.data`}`.replace(/\/\/+/g, "/");
+  let request = new Request(`http://localhost${normalizedPath}`, requestInit);
+  let response = await handler(request);
+  let data = await response.text();
+  validatePrerenderedResponse(response, data, "Prerender", normalizedPath);
+  let outdir = path4.relative(process.cwd(), clientBuildDirectory);
+  let outfile = path4.join(outdir, ...normalizedPath.split("/"));
+  await fse2.ensureDir(path4.dirname(outfile));
+  await fse2.outputFile(outfile, data);
+  viteConfig.logger.info(`Prerender: Generated ${import_picocolors2.default.bold(outfile)}`);
+  return data;
+}
+async function prerenderRoute(handler, prerenderPath, clientBuildDirectory, reactRouterConfig, viteConfig, requestInit) {
+  let normalizedPath = `${reactRouterConfig.basename}${prerenderPath}/`.replace(
+    /\/\/+/g,
+    "/"
+  );
+  let request = new Request(`http://localhost${normalizedPath}`, requestInit);
+  let response = await handler(request);
+  let html = await response.text();
+  validatePrerenderedResponse(response, html, "Prerender", normalizedPath);
+  if (!reactRouterConfig.ssr) {
+    validatePrerenderedHtml(html, "Prerender");
+  }
+  let outdir = path4.relative(process.cwd(), clientBuildDirectory);
+  let outfile = path4.join(outdir, ...normalizedPath.split("/"), "index.html");
+  await fse2.ensureDir(path4.dirname(outfile));
+  await fse2.outputFile(outfile, html);
+  viteConfig.logger.info(`Prerender: Generated ${import_picocolors2.default.bold(outfile)}`);
+}
+async function prerenderResourceRoute(handler, prerenderPath, clientBuildDirectory, reactRouterConfig, viteConfig, requestInit) {
+  let normalizedPath = `${reactRouterConfig.basename}${prerenderPath}/`.replace(/\/\/+/g, "/").replace(/\/$/g, "");
+  let request = new Request(`http://localhost${normalizedPath}`, requestInit);
+  let response = await handler(request);
+  let text = await response.text();
+  validatePrerenderedResponse(response, text, "Prerender", normalizedPath);
+  let outdir = path4.relative(process.cwd(), clientBuildDirectory);
+  let outfile = path4.join(outdir, ...normalizedPath.split("/"));
+  await fse2.ensureDir(path4.dirname(outfile));
+  await fse2.outputFile(outfile, text);
+  viteConfig.logger.info(`Prerender: Generated ${import_picocolors2.default.bold(outfile)}`);
+}
+async function prerenderManifest(build, clientBuildDirectory, reactRouterConfig, viteConfig) {
+  let normalizedPath = `${reactRouterConfig.basename}/__manifest`.replace(
+    /\/\/+/g,
+    "/"
+  );
+  let outdir = path4.relative(process.cwd(), clientBuildDirectory);
+  let outfile = path4.join(outdir, ...normalizedPath.split("/"));
+  await fse2.ensureDir(path4.dirname(outfile));
+  let manifestData = JSON.stringify(build.assets.routes);
+  await fse2.outputFile(outfile, manifestData);
+  viteConfig.logger.info(`Prerender: Generated ${import_picocolors2.default.bold(outfile)}`);
+}
+function validatePrerenderedResponse(response, html, prefix, path5) {
+  if (response.status !== 200) {
+    throw new Error(
+      `${prefix}: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${path5}\` path.
+${html}`
+    );
+  }
+}
+function validatePrerenderedHtml(html, prefix) {
+  if (!html.includes("window.__reactRouterContext =") || !html.includes("window.__reactRouterRouteModules =")) {
+    throw new Error(
+      `${prefix}: Did you forget to include <Scripts/> in your root route? Your pre-rendered HTML files cannot hydrate without \`<Scripts />\`.`
+    );
+  }
+}
+function groupRoutesByParentId2(manifest) {
+  let routes = {};
+  Object.values(manifest).forEach((route) => {
+    if (route) {
+      let parentId = route.parentId || "";
+      if (!routes[parentId]) {
+        routes[parentId] = [];
+      }
+      routes[parentId].push(route);
+    }
+  });
+  return routes;
+}
+function createPrerenderRoutes(manifest, parentId = "", routesByParentId = groupRoutesByParentId2(manifest)) {
+  return (routesByParentId[parentId] || []).map((route) => {
+    let commonRoute = {
+      // Always include root due to default boundaries
+      hasErrorBoundary: route.id === "root" || route.module.ErrorBoundary != null,
+      id: route.id,
+      path: route.path,
+      loader: route.module.loader ? () => null : void 0,
+      action: void 0,
+      handle: route.module.handle
+    };
+    return route.index ? {
+      index: true,
+      ...commonRoute
+    } : {
+      caseSensitive: route.caseSensitive,
+      children: createPrerenderRoutes(manifest, route.id, routesByParentId),
+      ...commonRoute
+    };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reactRouter
+});