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

package/dist/vite/plugin.js

@@ -1,1301 +0,0 @@
-/**
- * @react-router/dev v7.0.0-pre.2
- *
- * 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
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var node_crypto = require('node:crypto');
-var path = require('node:path');
-var url = require('node:url');
-var fse = require('fs-extra');
-var babel$1 = require('@babel/core');
-var reactRouter = require('react-router');
-var esModuleLexer = require('es-module-lexer');
-var jsesc = require('jsesc');
-var colors = require('picocolors');
-var invariant = require('../invariant.js');
-var babel = require('./babel.js');
-var nodeAdapter = require('./node-adapter.js');
-var styles = require('./styles.js');
-var vmod = require('./vmod.js');
-var resolveFileUrl = require('./resolve-file-url.js');
-var combineUrls = require('./combine-urls.js');
-var removeExports = require('./remove-exports.js');
-var importViteEsmSync = require('./import-vite-esm-sync.js');
-var config = require('./config.js');
-var withProps = require('./with-props.js');
-var viteNode = require('./vite-node.js');
-var parser = require('@babel/parser');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var url__namespace = /*#__PURE__*/_interopNamespace(url);
-var fse__namespace = /*#__PURE__*/_interopNamespace(fse);
-var babel__default = /*#__PURE__*/_interopDefaultLegacy(babel$1);
-var jsesc__default = /*#__PURE__*/_interopDefaultLegacy(jsesc);
-var colors__default = /*#__PURE__*/_interopDefaultLegacy(colors);
-
-async function resolveViteConfig({
-  configFile,
-  mode,
-  root
-}) {
-  let vite = await import('vite');
-  let viteConfig = await vite.resolveConfig({
-    mode,
-    configFile,
-    root
-  }, "build",
-  // command
-  "production",
-  // default mode
-  "production" // default NODE_ENV
-  );
-  if (typeof viteConfig.build.manifest === "string") {
-    throw new Error("Custom Vite manifest paths are not supported");
-  }
-  return viteConfig;
-}
-async function extractPluginContext(viteConfig) {
-  return viteConfig["__reactRouterPluginContext"];
-}
-async function loadPluginContext({
-  configFile,
-  root
-}) {
-  if (!root) {
-    root = process.env.REACT_ROUTER_ROOT || process.cwd();
-  }
-  configFile = configFile ?? findConfig(root, "vite.config", [".ts", ".cts", ".mts", ".js", ".cjs", ".mjs"]);
-  if (!configFile) {
-    console.error(colors__default["default"].red("Vite config file not found"));
-    process.exit(1);
-  }
-  let viteConfig = await resolveViteConfig({
-    configFile,
-    root
-  });
-  let ctx = await extractPluginContext(viteConfig);
-  if (!ctx) {
-    console.error(colors__default["default"].red("React Router Vite plugin not found in Vite config"));
-    process.exit(1);
-  }
-  return ctx;
-}
-const SERVER_ONLY_ROUTE_EXPORTS = ["loader", "action", "headers"];
-const CLIENT_ROUTE_EXPORTS = ["clientAction", "clientLoader", "default", "ErrorBoundary", "handle", "HydrateFallback", "Layout", "links", "meta", "shouldRevalidate"];
-// Each route gets its own virtual module marked with an entry query string
-const ROUTE_ENTRY_QUERY_STRING = "?route-entry=1";
-const isRouteEntry = id => {
-  return id.endsWith(ROUTE_ENTRY_QUERY_STRING);
-};
-let serverBuildId = vmod.id("server-build");
-let serverManifestId = vmod.id("server-manifest");
-let browserManifestId = vmod.id("browser-manifest");
-let hmrRuntimeId = vmod.id("hmr-runtime");
-let injectHmrRuntimeId = vmod.id("inject-hmr-runtime");
-const resolveRelativeRouteFilePath = (route, reactRouterConfig) => {
-  let vite = importViteEsmSync.importViteEsmSync();
-  let file = route.file;
-  let fullPath = path__namespace.resolve(reactRouterConfig.appDirectory, file);
-  return vite.normalizePath(fullPath);
-};
-let vmods = [serverBuildId, serverManifestId, browserManifestId];
-const invalidateVirtualModules = viteDevServer => {
-  vmods.forEach(vmod$1 => {
-    let mod = viteDevServer.moduleGraph.getModuleById(vmod.resolve(vmod$1));
-    if (mod) {
-      viteDevServer.moduleGraph.invalidateModule(mod);
-    }
-  });
-};
-const getHash = (source, maxLength) => {
-  let hash = node_crypto.createHash("sha256").update(source).digest("hex");
-  return typeof maxLength === "number" ? hash.slice(0, maxLength) : hash;
-};
-const resolveChunk = (ctx, viteManifest, absoluteFilePath) => {
-  let vite = importViteEsmSync.importViteEsmSync();
-  let rootRelativeFilePath = vite.normalizePath(path__namespace.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;
-};
-const getReactRouterManifestBuildAssets = (ctx, viteManifest, entryFilePath, prependedAssetFilePaths = []) => {
-  let entryChunk = resolveChunk(ctx, viteManifest, entryFilePath);
-  // This is here to support prepending client entry assets to the root route
-  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 = 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(array) {
-  return [...new Set(array)];
-}
-const writeFileSafe = async (file, contents) => {
-  await fse__namespace.ensureDir(path__namespace.dirname(file));
-  await fse__namespace.writeFile(file, contents);
-};
-const 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);
-};
-const getRouteModuleExports = async (viteChildCompiler, ctx, routeFile, readRouteFile) => {
-  if (!viteChildCompiler) {
-    throw new Error("Vite child compiler not found");
-  }
-  // We transform the route module code with the Vite child compiler so that we
-  // can parse the exports from non-JS files like MDX. This ensures that we can
-  // understand the exports from anything that Vite can compile to JS, not just
-  // the route file formats that the Remix compiler historically supported.
-  let ssr = true;
-  let {
-    pluginContainer,
-    moduleGraph
-  } = viteChildCompiler;
-  let routePath = path__namespace.resolve(ctx.reactRouterConfig.appDirectory, routeFile);
-  let url = resolveFileUrl.resolveFileUrl(ctx, routePath);
-  let resolveId = async () => {
-    let result = await pluginContainer.resolveId(url, undefined, {
-      ssr
-    });
-    if (!result) throw new Error(`Could not resolve module ID for ${url}`);
-    return result.id;
-  };
-  let [id, code] = await Promise.all([resolveId(), (readRouteFile === null || readRouteFile === void 0 ? void 0 : readRouteFile()) ?? fse__namespace.readFile(routePath, "utf-8"),
-  // pluginContainer.transform(...) fails if we don't do this first:
-  moduleGraph.ensureEntryFromUrl(url, ssr)]);
-  let transformed = await pluginContainer.transform(code, id, {
-    ssr
-  });
-  let [, exports] = esModuleLexer.parse(transformed.code);
-  let exportNames = exports.map(e => e.n);
-  return exportNames;
-};
-const getServerBundleBuildConfig = viteUserConfig => {
-  if (!("__reactRouterServerBundleBuildConfig" in viteUserConfig) || !viteUserConfig.__reactRouterServerBundleBuildConfig) {
-    return null;
-  }
-  return viteUserConfig.__reactRouterServerBundleBuildConfig;
-};
-let getServerBuildDirectory = ctx => path__namespace.join(ctx.reactRouterConfig.buildDirectory, "server", ...(ctx.serverBundleBuildConfig ? [ctx.serverBundleBuildConfig.serverBundleId] : []));
-let getClientBuildDirectory = reactRouterConfig => path__namespace.join(reactRouterConfig.buildDirectory, "client");
-let defaultEntriesDir = path__namespace.resolve(__dirname, "..", "config", "defaults");
-let defaultEntries = fse__namespace.readdirSync(defaultEntriesDir).map(filename => path__namespace.join(defaultEntriesDir, filename));
-invariant(defaultEntries.length > 0, "No default entries found");
-let reactRouterDevLoadContext = () => ({});
-// Inlined from https://github.com/jsdf/deep-freeze
-let 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;
-};
-/**
- * React Router [Vite plugin.](https://vitejs.dev/guide/using-plugins.html)
- */
-const reactRouterVitePlugin = _config => {
-  let reactRouterUserConfig = _config ?? {};
-  // Prevent mutations to the user config
-  reactRouterUserConfig = deepFreeze(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"] : undefined;
-  // This is initialized by `updatePluginContext` during Vite's `config`
-  // hook, so most of the code can assume this defined without null check.
-  // During dev, `updatePluginContext` is called again on every config file
-  // change or route file addition/removal.
-  let ctx;
-  /** Mutates `ctx` as a side-effect */
-  let updatePluginContext = async ({
-    routeConfigChanged = false
-  } = {}) => {
-    var _viteUserConfig$build;
-    let rootDirectory = viteUserConfig.root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
-    invariant(routesViteNodeContext);
-    let reactRouterConfig = await config.resolveReactRouterConfig({
-      rootDirectory,
-      reactRouterUserConfig,
-      routeConfigChanged,
-      viteUserConfig,
-      viteCommand,
-      routesViteNodeContext
-    });
-    let {
-      entryClientFilePath,
-      entryServerFilePath
-    } = await config.resolveEntryFiles({
-      rootDirectory,
-      reactRouterConfig
-    });
-    let publicPath = config.resolvePublicPath(viteUserConfig);
-    let viteManifestEnabled = ((_viteUserConfig$build = viteUserConfig.build) === null || _viteUserConfig$build === void 0 ? void 0 : _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(plugin => plugin.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.resolveFileUrl(ctx, ctx.entryServerFilePath))};
-    ${Object.keys(routes).map((key, index) => {
-      let route = routes[key];
-      return `import * as route${index} from ${JSON.stringify(resolveFileUrl.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(path__namespace.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 fse__namespace.readFile(path__namespace.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 => {
-    // Get .css?url imports and CSS entry points
-    let cssUrlPaths = Object.values(viteManifest).filter(chunk => chunk.file.endsWith(".css")).map(chunk => chunk.file);
-    // Get bundled CSS files and generic asset types
-    let chunkAssetPaths = Object.values(viteManifest).flatMap(chunk => chunk.assets ?? []);
-    return 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)) {
-      var _ctx$serverBundleBuil;
-      let routeFilePath = path__namespace.join(ctx.reactRouterConfig.appDirectory, route.file);
-      let sourceExports = routeManifestExports[key];
-      let isRootRoute = route.parentId === undefined;
-      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$serverBundleBuil = ctx.serverBundleBuildConfig) === null || _ctx$serverBundleBuil === void 0 ? void 0 : _ctx$serverBundleBuil.routes;
-      if (!serverBundleRoutes || serverBundleRoutes[key]) {
-        serverRoutes[key] = routeManifestEntry;
-      }
-    }
-    let fingerprintedValues = {
-      entry,
-      routes: browserRoutes
-    };
-    let version = getHash(JSON.stringify(fingerprintedValues), 8);
-    let manifestPath = path__namespace.posix.join(viteConfig.build.assetsDir, `manifest-${version}.js`);
-    let url = `${ctx.publicPath}${manifestPath}`;
-    let nonFingerprintedValues = {
-      url,
-      version
-    };
-    let reactRouterBrowserManifest = {
-      ...fingerprintedValues,
-      ...nonFingerprintedValues
-    };
-    // Write the browser manifest to disk as part of the build process
-    await writeFileSafe(path__namespace.join(getClientBuildDirectory(ctx.reactRouterConfig), manifestPath), `window.__reactRouterManifest=${JSON.stringify(reactRouterBrowserManifest)};`);
-    // The server manifest is the same as the browser manifest, except for
-    // server bundle builds which only includes routes for the current bundle,
-    // otherwise the server and client have the same routes
-    let reactRouterServerManifest = {
-      ...reactRouterBrowserManifest,
-      routes: serverRoutes
-    };
-    return {
-      reactRouterBrowserManifest,
-      reactRouterServerManifest
-    };
-  };
-  // In dev, the server and browser manifests are the same
-  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.combineURLs(ctx.publicPath, `${resolveFileUrl.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.combineURLs(ctx.publicPath, vmod.url(browserManifestId)),
-      hmr: {
-        runtime: combineUrls.combineURLs(ctx.publicPath, vmod.url(injectHmrRuntimeId))
-      },
-      entry: {
-        module: combineUrls.combineURLs(ctx.publicPath, resolveFileUrl.resolveFileUrl(ctx, ctx.entryClientFilePath)),
-        imports: []
-      },
-      routes
-    };
-  };
-  return [{
-    name: "react-router",
-    config: async (_viteUserConfig, _viteConfigEnv) => {
-      var _viteUserConfig$serve, _viteUserConfig$serve2, _viteUserConfig$build4, _viteUserConfig$build5, _viteUserConfig$build6;
-      // Preload Vite's ESM build up-front as soon as we're in an async context
-      await importViteEsmSync.preloadViteEsm();
-      // Ensure sync import of Vite works after async preload
-      let vite = importViteEsmSync.importViteEsmSync();
-      viteUserConfig = _viteUserConfig;
-      viteConfigEnv = _viteConfigEnv;
-      viteCommand = viteConfigEnv.command;
-      routesViteNodeContext = await viteNode.createContext({
-        root: viteUserConfig.root,
-        mode: viteConfigEnv.mode,
-        server: {
-          watch: viteCommand === "build" ? null : undefined
-        },
-        ssr: {
-          external: ssrExternals
-        }
-      });
-      await updatePluginContext();
-      Object.assign(process.env, vite.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) {
-          var _viteUserConfig$build2, _viteUserConfig$build3;
-          if (warning.code === "MODULE_LEVEL_DIRECTIVE" && warning.message.includes("use client")) {
-            return;
-          }
-          if ((_viteUserConfig$build2 = viteUserConfig.build) !== null && _viteUserConfig$build2 !== void 0 && (_viteUserConfig$build3 = _viteUserConfig$build2.rollupOptions) !== null && _viteUserConfig$build3 !== void 0 && _viteUserConfig$build3.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",
-          // 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"]
-        },
-        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$serve = viteUserConfig.server) !== null && _viteUserConfig$serve !== void 0 && (_viteUserConfig$serve2 = _viteUserConfig$serve.fs) !== null && _viteUserConfig$serve2 !== void 0 && _viteUserConfig$serve2.allow ? {
-          fs: {
-            allow: defaultEntries
-          }
-        } : undefined,
-        // Vite config options for building
-        ...(viteCommand === "build" ? {
-          build: {
-            cssMinify: ((_viteUserConfig$build4 = viteUserConfig.build) === null || _viteUserConfig$build4 === void 0 ? void 0 : _viteUserConfig$build4.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 => `${path__namespace.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$build5 = viteUserConfig.build) === null || _viteUserConfig$build5 === void 0 ? void 0 : (_viteUserConfig$build6 = _viteUserConfig$build5.rollupOptions) === null || _viteUserConfig$build6 === void 0 ? void 0 : _viteUserConfig$build6.input) ?? serverBuildId,
-                output: {
-                  entryFileNames: ctx.reactRouterConfig.serverBuildFile,
-                  format: ctx.reactRouterConfig.serverModuleFormat
-                }
-              }
-            })
-          }
-        } : undefined),
-        // Vite config options for SPA preview mode
-        ...(viteCommand === "serve" && ctx.reactRouterConfig.ssr === false ? {
-          build: {
-            manifest: true,
-            outDir: getClientBuildDirectory(ctx.reactRouterConfig)
-          }
-        } : undefined)
-      };
-    },
-    async configResolved(resolvedViteConfig) {
-      await esModuleLexer.init;
-      viteConfig = resolvedViteConfig;
-      invariant(viteConfig);
-      // We load the same Vite config file again for the child compiler so
-      // that both parent and child compiler's plugins have independent state.
-      // If we re-used the `viteUserConfig.plugins` array for the child
-      // compiler, it could lead to mutating shared state between plugin
-      // instances in unexpected ways, e.g. during `vite build` the
-      // `configResolved` plugin hook would be called with `command = "build"`
-      // by parent and then `command = "serve"` by child, which some plugins
-      // may respond to by updating state referenced by the parent.
-      if (!viteConfig.configFile) {
-        throw new Error("The React Router Vite plugin requires the use of a Vite config file");
-      }
-      let vite = importViteEsmSync.importViteEsmSync();
-      let childCompilerConfigFile = await vite.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");
-      // Validate that commonly used Rollup plugins that need to run before
-      // ours are in the correct order. This is because Rollup plugins can't
-      // set `enforce: "pre"` like Vite plugins can. Explicitly validating
-      // this provides a much nicer developer experience.
-      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 vite.createServer({
-        ...viteUserConfig,
-        mode: viteConfig.mode,
-        server: {
-          watch: viteConfig.command === "build" ? null : undefined,
-          preTransformRequests: false,
-          hmr: false
-        },
-        configFile: false,
-        envFile: false,
-        plugins: [...(childCompilerConfigFile.config.plugins ?? []).flat()
-        // Exclude this plugin from the child compiler to prevent an
-        // infinite loop (plugin creates a child compiler with the same
-        // plugin that creates another child compiler, repeat ad
-        // infinitum), and to prevent the manifest from being written to
-        // disk from the child compiler. This is important in the
-        // production build because the child compiler is a Vite dev
-        // server and will generate incorrect manifests.
-        .filter(plugin => typeof plugin === "object" && plugin !== null && "name" in plugin && plugin.name !== "react-router" && plugin.name !== "react-router-route-exports" && plugin.name !== "react-router-hmr-updates")]
-      });
-      await viteChildCompiler.pluginContainer.buildStart({});
-    },
-    async transform(code, id) {
-      if (styles.isCssModulesFile(id)) {
-        cssModulesManifest[id] = code;
-      }
-    },
-    buildStart() {
-      invariant(viteConfig);
-      if (viteCommand === "build" && viteConfig.mode === "production" && !viteConfig.build.ssr && viteConfig.build.sourcemap) {
-        viteConfig.logger.warn(colors__default["default"].yellow("\n" + colors__default["default"].bold("  ⚠️  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) {
-      reactRouter.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, url) => {
-          return styles.getStylesForUrl({
-            rootDirectory: ctx.rootDirectory,
-            entryClientFilePath: ctx.entryClientFilePath,
-            reactRouterConfig: ctx.reactRouterConfig,
-            viteDevServer,
-            cssModulesManifest,
-            build,
-            url
-          });
-        },
-        // 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);
-          }
-        }
-      });
-      // Invalidate virtual modules and update cached plugin config via file watcher
-      viteDevServer.watcher.on("all", async (eventName, rawFilepath) => {
-        var _viteConfig, _routesViteNodeContex, _routesViteNodeContex2;
-        let {
-          normalizePath
-        } = importViteEsmSync.importViteEsmSync();
-        let filepath = normalizePath(rawFilepath);
-        let appFileAddedOrRemoved = (eventName === "add" || eventName === "unlink") && filepath.startsWith(normalizePath(ctx.reactRouterConfig.appDirectory));
-        invariant((_viteConfig = viteConfig) === null || _viteConfig === void 0 ? void 0 : _viteConfig.configFile);
-        let viteConfigChanged = eventName === "change" && filepath === normalizePath(viteConfig.configFile);
-        let routeConfigChanged = Boolean((_routesViteNodeContex = routesViteNodeContext) === null || _routesViteNodeContex === void 0 ? void 0 : (_routesViteNodeContex2 = _routesViteNodeContex.devServer) === null || _routesViteNodeContex2 === void 0 ? void 0 : _routesViteNodeContex2.moduleGraph.getModuleById(filepath));
-        if (routeConfigChanged || appFileAddedOrRemoved) {
-          var _routesViteNodeContex3, _routesViteNodeContex4, _routesViteNodeContex5, _routesViteNodeContex6;
-          (_routesViteNodeContex3 = routesViteNodeContext) === null || _routesViteNodeContex3 === void 0 ? void 0 : (_routesViteNodeContex4 = _routesViteNodeContex3.devServer) === null || _routesViteNodeContex4 === void 0 ? void 0 : _routesViteNodeContex4.moduleGraph.invalidateAll();
-          (_routesViteNodeContex5 = routesViteNodeContext) === null || _routesViteNodeContex5 === void 0 ? void 0 : (_routesViteNodeContex6 = _routesViteNodeContex5.runner) === null || _routesViteNodeContex6 === void 0 ? void 0 : _routesViteNodeContex6.moduleCache.clear();
-        }
-        if (appFileAddedOrRemoved || viteConfigChanged || routeConfigChanged) {
-          let lastReactRouterConfig = ctx.reactRouterConfig;
-          await updatePluginContext({
-            routeConfigChanged
-          });
-          if (!isEqualJson(lastReactRouterConfig, ctx.reactRouterConfig)) {
-            invalidateVirtualModules(viteDevServer);
-          }
-        }
-      });
-      return () => {
-        // Let user servers handle SSR requests in middleware mode,
-        // otherwise the Vite plugin will handle the request
-        if (!viteDevServer.config.server.middlewareMode) {
-          viteDevServer.middlewares.use(async (req, res, next) => {
-            try {
-              let build = await viteDevServer.ssrLoadModule(serverBuildId);
-              let handler = reactRouter.createRequestHandler(build, "development");
-              let nodeHandler = async (nodeReq, nodeRes) => {
-                let req = nodeAdapter.fromNodeRequest(nodeReq, nodeRes);
-                let res = await handler(req, await reactRouterDevLoadContext(req));
-                await nodeAdapter.toNodeRequest(res, 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);
-        // We only move assets that aren't in the client build, otherwise we
-        // remove them. These assets only exist because we explicitly set
-        // `ssrEmitAssets: true` in the SSR Vite config. These assets
-        // typically wouldn't exist by default, which is why we assume it's
-        // safe to remove them. We're aiming for a clean build output so that
-        // unnecessary assets don't get deployed alongside the server code.
-        let movedAssetPaths = [];
-        for (let ssrAssetPath of ssrAssetPaths) {
-          let src = path__namespace.join(serverBuildDirectory, ssrAssetPath);
-          let dest = path__namespace.join(clientBuildDirectory, ssrAssetPath);
-          if (!fse__namespace.existsSync(dest)) {
-            await fse__namespace.move(src, dest);
-            movedAssetPaths.push(dest);
-          } else {
-            await fse__namespace.remove(src);
-          }
-        }
-        // We assume CSS assets from the SSR build are unnecessary and remove
-        // them for the same reasons as above.
-        let ssrCssPaths = Object.values(ssrViteManifest).flatMap(chunk => chunk.css ?? []);
-        await Promise.all(ssrCssPaths.map(cssPath => fse__namespace.remove(path__namespace.join(serverBuildDirectory, cssPath))));
-        if (movedAssetPaths.length) {
-          viteConfig.logger.info(["", `${colors__default["default"].green("✓")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from React Router server build to client assets.`, ...movedAssetPaths.map(movedAssetPath => colors__default["default"].dim(path__namespace.relative(ctx.rootDirectory, movedAssetPath))), ""].join("\n"));
-        }
-        if (ctx.reactRouterConfig.prerender != null && ctx.reactRouterConfig.prerender !== false) {
-          // If we have prerender routes, that takes precedence over SPA mode
-          // which is ssr:false and only the rot route being rendered
-          await handlePrerender(viteConfig, ctx.reactRouterConfig, serverBuildDirectory, clientBuildDirectory);
-        } else if (!ctx.reactRouterConfig.ssr) {
-          await handleSpaMode(viteConfig, ctx.reactRouterConfig, serverBuildDirectory, clientBuildDirectory);
-        }
-        // For both SPA mode and prerendering, we can remove the server builds
-        // if ssr:false is set
-        if (!ctx.reactRouterConfig.ssr) {
-          // Cleanup - we no longer need the server build assets
-          viteConfig.logger.info(["Removing the server build in", colors__default["default"].green(serverBuildDirectory), "due to ssr:false"].join(" "));
-          fse__namespace.removeSync(serverBuildDirectory);
-        }
-      }
-    },
-    async buildEnd() {
-      var _viteChildCompiler, _routesViteNodeContex7, _routesViteNodeContex8;
-      await ((_viteChildCompiler = viteChildCompiler) === null || _viteChildCompiler === void 0 ? void 0 : _viteChildCompiler.close());
-      await ((_routesViteNodeContex7 = routesViteNodeContext) === null || _routesViteNodeContex7 === void 0 ? void 0 : (_routesViteNodeContex8 = _routesViteNodeContex7.devServer) === null || _routesViteNodeContex8 === void 0 ? void 0 : _routesViteNodeContex8.close());
-    }
-  }, {
-    name: "react-router-route-entry",
-    enforce: "pre",
-    async transform(_code, id, options) {
-      if (!isRouteEntry(id)) return;
-      let routeModuleId = id.replace(ROUTE_ENTRY_QUERY_STRING, "");
-      let routeFileName = path__namespace.basename(routeModuleId);
-      let sourceExports = await getRouteModuleExports(viteChildCompiler, ctx, routeModuleId);
-      let reexports = sourceExports.filter(exportName => (options === null || options === void 0 ? void 0 : 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(id) {
-      if (vmods.includes(id)) return vmod.resolve(id);
-    },
-    async load(id) {
-      switch (id) {
-        case vmod.resolve(serverBuildId):
-          {
-            return await getServerEntry();
-          }
-        case vmod.resolve(serverManifestId):
-          {
-            let reactRouterManifest = ctx.isSsrBuild ? await ctx.getReactRouterServerManifest() : await getReactRouterManifestForDev();
-            return `export default ${jsesc__default["default"](reactRouterManifest, {
-              es6: true
-            })};`;
-          }
-        case vmod.resolve(browserManifestId):
-          {
-            if (viteCommand === "build") {
-              throw new Error("This module only exists in development");
-            }
-            let reactRouterManifest = await getReactRouterManifestForDev();
-            let reactRouterManifestString = jsesc__default["default"](reactRouterManifest, {
-              es6: true
-            });
-            return `window.__reactRouterManifest=${reactRouterManifestString};`;
-          }
-      }
-    }
-  }, {
-    name: "react-router-dot-server",
-    enforce: "pre",
-    async resolveId(id, importer, options) {
-      var _options$custom;
-      // https://vitejs.dev/config/dep-optimization-options
-      let isOptimizeDeps = viteCommand === "serve" && (options === null || options === void 0 ? void 0 : options.scan) === true;
-      if (isOptimizeDeps || options !== null && options !== void 0 && options.ssr) return;
-      let isResolving = (options === null || options === void 0 ? void 0 : (_options$custom = options.custom) === null || _options$custom === void 0 ? void 0 : _options$custom["react-router-dot-server"]) ?? false;
-      if (isResolving) return;
-      options.custom = {
-        ...options.custom,
-        "react-router-dot-server": true
-      };
-      let resolved = await this.resolve(id, 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")) {
-        // Vite has a special `index.html` importer for `resolveId` within `transformRequest`
-        // https://github.com/vitejs/vite/blob/5684fcd8d27110d098b3e1c19d851f44251588f1/packages/vite/src/node/server/transformRequest.ts#L158
-        // https://github.com/vitejs/vite/blob/5684fcd8d27110d098b3e1c19d851f44251588f1/packages/vite/src/node/server/pluginContainer.ts#L668
-        return;
-      }
-      let vite = importViteEsmSync.importViteEsmSync();
-      let importerShort = vite.normalizePath(path__namespace.relative(ctx.rootDirectory, importer));
-      let isRoute = getRoute(ctx.reactRouterConfig, importer);
-      if (isRoute) {
-        let serverOnlyExports = SERVER_ONLY_ROUTE_EXPORTS.map(xport => `\`${xport}\``).join(", ");
-        throw Error([colors__default["default"].red(`Server-only module referenced by client`), "", `    '${id}' imported by route '${importerShort}'`, "", `  React Router automatically removes server-code from these exports:`, `    ${serverOnlyExports}`, "", `  But other route exports in '${importerShort}' depend on '${id}'.`, "", "  See https://remix.run/docs/en/main/guides/vite#splitting-up-client-and-server-code", ""].join("\n"));
-      }
-      throw Error([colors__default["default"].red(`Server-only module referenced by client`), "", `    '${id}' 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, id, options) {
-      if (!(options !== null && options !== void 0 && options.ssr)) return;
-      let clientFileRE = /\.client(\.[cm]?[jt]sx?)?$/;
-      let clientDirRE = /\/\.client\//;
-      if (clientFileRE.test(id) || clientDirRE.test(id)) {
-        let exports = esModuleLexer.parse(code)[1];
-        return {
-          code: exports.map(({
-            n: name
-          }) => name === "default" ? "export default undefined;" : `export const ${name} = undefined;`).join("\n"),
-          map: null
-        };
-      }
-    }
-  }, withProps.plugin, {
-    name: "react-router-route-exports",
-    async transform(code, id, options) {
-      let route = getRoute(ctx.reactRouterConfig, id);
-      if (!route) return;
-      if (!(options !== null && options !== void 0 && options.ssr) && !ctx.reactRouterConfig.ssr) {
-        let serverOnlyExports = esModuleLexer.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 = esModuleLexer.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] = id.split("?");
-      let ast = parser.parse(code, {
-        sourceType: "module"
-      });
-      if (!(options !== null && options !== void 0 && options.ssr)) {
-        removeExports.removeExports(ast, SERVER_ONLY_ROUTE_EXPORTS);
-      }
-      withProps.transform(ast);
-      return babel.generate(ast, {
-        sourceMaps: true,
-        filename: id,
-        sourceFileName: filepath
-      });
-    }
-  }, {
-    name: "react-router-inject-hmr-runtime",
-    enforce: "pre",
-    resolveId(id) {
-      if (id === injectHmrRuntimeId) return vmod.resolve(injectHmrRuntimeId);
-    },
-    async load(id) {
-      if (id !== vmod.resolve(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(id) {
-      if (id === hmrRuntimeId) return vmod.resolve(hmrRuntimeId);
-    },
-    async load(id) {
-      if (id !== vmod.resolve(hmrRuntimeId)) return;
-      let reactRefreshDir = path__namespace.dirname(require.resolve("react-refresh/package.json"));
-      let reactRefreshRuntimePath = path__namespace.join(reactRefreshDir, "cjs/react-refresh-runtime.development.js");
-      return ["const exports = {}", await fse__namespace.readFile(reactRefreshRuntimePath, "utf8"), await fse__namespace.readFile(require.resolve("./static/refresh-utils.cjs"), "utf8"), "export default exports"].join("\n");
-    }
-  }, {
-    name: "react-router-react-refresh-babel",
-    async transform(code, id, options) {
-      if (viteCommand !== "serve") return;
-      if (id.includes("/node_modules/")) return;
-      let [filepath] = id.split("?");
-      let extensionsRE = /\.(jsx?|tsx?|mdx?)$/;
-      if (!extensionsRE.test(filepath)) return;
-      let devRuntime = "react/jsx-dev-runtime";
-      let ssr = (options === null || options === void 0 ? void 0 : options.ssr) === true;
-      let isJSX = filepath.endsWith("x");
-      let useFastRefresh = !ssr && (isJSX || code.includes(devRuntime));
-      if (!useFastRefresh) return;
-      if (isRouteEntry(id)) {
-        return {
-          code: addRefreshWrapper(ctx.reactRouterConfig, code, id)
-        };
-      }
-      let result = await babel__default["default"].transformAsync(code, {
-        babelrc: false,
-        configFile: false,
-        filename: id,
-        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, id);
-      }
-      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) {
-        // invalidate manifest on route exports change
-        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 findConfig(dir, basename, extensions) {
-  for (let ext of extensions) {
-    let name = basename + ext;
-    let file = path__namespace.join(dir, name);
-    if (fse__namespace.existsSync(file)) return file;
-  }
-  return undefined;
-}
-function isInReactRouterMonorepo() {
-  // We use '@react-router/node' for this check since it's a
-  // dependency of this package and guaranteed to be in node_modules
-  let serverRuntimePath = path__namespace.dirname(require.resolve("@react-router/node/package.json"));
-  let serverRuntimeParentDir = path__namespace.basename(path__namespace.resolve(serverRuntimePath, ".."));
-  return serverRuntimeParentDir === "packages";
-}
-function isEqualJson(v1, v2) {
-  return JSON.stringify(v1) === JSON.stringify(v2);
-}
-function addRefreshWrapper(reactRouterConfig, code, id) {
-  let route = getRoute(reactRouterConfig, id);
-  let acceptExports = route || isRouteEntry(id) ? ["clientAction", "clientLoader", "handle", "meta", "links", "shouldRevalidate"] : [];
-  return "\n\n" + withCommentBoundaries("REACT REFRESH HEADER", REACT_REFRESH_HEADER.replaceAll("__SOURCE__", JSON.stringify(id))) + "\n\n" + withCommentBoundaries("REACT REFRESH BODY", code) + "\n\n" + withCommentBoundaries("REACT REFRESH FOOTER", REACT_REFRESH_FOOTER.replaceAll("__SOURCE__", JSON.stringify(id)).replaceAll("__ACCEPT_EXPORTS__", JSON.stringify(acceptExports)).replaceAll("__ROUTE_ID__", JSON.stringify(route === null || route === void 0 ? void 0 : 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}\n${text}\n${end}`;
-}
-const 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();
-const 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 vite = importViteEsmSync.importViteEsmSync();
-  let routePath = vite.normalizePath(path__namespace.relative(pluginConfig.appDirectory, file));
-  let route = Object.values(pluginConfig.routes).find(r => vite.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.combineURLs(ctx.publicPath, "/" + path__namespace.relative(ctx.rootDirectory, resolveRelativeRouteFilePath(route, ctx.reactRouterConfig))),
-    module: combineUrls.combineURLs(ctx.publicPath, `${resolveFileUrl.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 = path__namespace.join(serverBuildDirectory, reactRouterConfig.serverBuildFile);
-  let build = await import(url__namespace.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");
-  // Write out the index.html file for the SPA
-  await fse__namespace.writeFile(path__namespace.join(clientBuildDirectory, "index.html"), html);
-  viteConfig.logger.info("SPA Mode: index.html has been written to your " + colors__default["default"].bold(path__namespace.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 path of routesToPrerender) {
-    var _matchRoutes;
-    let hasLoaders = (_matchRoutes = reactRouter.matchRoutes(routes, path)) === null || _matchRoutes === void 0 ? void 0 : _matchRoutes.some(m => m.route.loader);
-    let data;
-    if (hasLoaders) {
-      data = await prerenderData(handler, path, clientBuildDirectory, reactRouterConfig, viteConfig, {
-        headers
-      });
-    }
-    await prerenderRoute(handler, path, 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) {
-  // Always start with the root/index route included
-  let paths = ["/"];
-  let paramRoutes = [];
-  // Then recursively add any new path defined by the tree
-  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(["⚠️ 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"));
-  }
-  // Clean double slashes and remove trailing slashes
-  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);
-  // Write out the .data file
-  let outdir = path__namespace.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path__namespace.join(outdir, ...normalizedPath.split("/"));
-  await fse__namespace.ensureDir(path__namespace.dirname(outfile));
-  await fse__namespace.outputFile(outfile, data);
-  viteConfig.logger.info(`Prerender: Generated ${colors__default["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");
-  }
-  // Write out the HTML file
-  let outdir = path__namespace.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path__namespace.join(outdir, ...normalizedPath.split("/"), "index.html");
-  await fse__namespace.ensureDir(path__namespace.dirname(outfile));
-  await fse__namespace.outputFile(outfile, html);
-  viteConfig.logger.info(`Prerender: Generated ${colors__default["default"].bold(outfile)}`);
-}
-async function prerenderManifest(build, clientBuildDirectory, reactRouterConfig, viteConfig) {
-  let normalizedPath = `${reactRouterConfig.basename}/__manifest`.replace(/\/\/+/g, "/");
-  let outdir = path__namespace.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path__namespace.join(outdir, ...normalizedPath.split("/"));
-  await fse__namespace.ensureDir(path__namespace.dirname(outfile));
-  let manifestData = JSON.stringify(build.assets.routes);
-  await fse__namespace.outputFile(outfile, manifestData);
-  viteConfig.logger.info(`Prerender: Generated ${colors__default["default"].bold(outfile)}`);
-}
-function validatePrerenderedResponse(response, html, prefix, path) {
-  if (response.status !== 200) {
-    throw new Error(`${prefix}: Received a ${response.status} status code from ` + `\`entry.server.tsx\` while prerendering the \`${path}\` ` + `path.\n${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 />`.");
-  }
-}
-// Note: Duplicated from react-router/lib/server-runtime
-function groupRoutesByParentId(manifest) {
-  let routes = {};
-  Object.values(manifest).forEach(route => {
-    if (route) {
-      let parentId = route.parentId || "";
-      if (!routes[parentId]) {
-        routes[parentId] = [];
-      }
-      routes[parentId].push(route);
-    }
-  });
-  return routes;
-}
-// Note: Duplicated from react-router/lib/server-runtime
-function createPrerenderRoutes(manifest, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) {
-  return (routesByParentId[parentId] || []).map(route => {
-    let commonRoute = {
-      // Always include root due to default boundaries
-      hasErrorBoundary: route.id === "root" || route.module.ErrorBoundary != null,
-      id: route.id,
-      path: route.path,
-      loader: route.module.loader ? () => null : undefined,
-      action: undefined,
-      handle: route.module.handle
-    };
-    return route.index ? {
-      index: true,
-      ...commonRoute
-    } : {
-      caseSensitive: route.caseSensitive,
-      children: createPrerenderRoutes(manifest, route.id, routesByParentId),
-      ...commonRoute
-    };
-  });
-}
-
-exports.extractPluginContext = extractPluginContext;
-exports.getServerBuildDirectory = getServerBuildDirectory;
-exports.loadPluginContext = loadPluginContext;
-exports.reactRouterVitePlugin = reactRouterVitePlugin;
-exports.resolveViteConfig = resolveViteConfig;