@react-router/dev 0.0.0-experimental-7c6c0664d → 0.0.0-experimental-9f7fdccd4

package/dist/cli/index.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-7c6c0664d
+ * @react-router/dev v0.0.0-experimental-9f7fdccd4
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,13 +8,1407 @@
  *
  * @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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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 run = require('./run.js');
+// 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);
+  }
+}
+var init_invariant = __esm({
+  "invariant.ts"() {
+    "use strict";
+  }
+});
+
+// vite/babel.ts
+var import_parser, t, traverse, generate;
+var init_babel = __esm({
+  "vite/babel.ts"() {
+    "use strict";
+    import_parser = require("@babel/parser");
+    t = __toESM(require("@babel/types"));
+    traverse = require("@babel/traverse").default;
+    generate = require("@babel/generator").default;
+  }
+});
+
+// vite/node-adapter.ts
+var import_node_events, import_node_stream, import_set_cookie_parser, import_node;
+var init_node_adapter = __esm({
+  "vite/node-adapter.ts"() {
+    "use strict";
+    import_node_events = require("events");
+    import_node_stream = require("stream");
+    import_set_cookie_parser = require("set-cookie-parser");
+    import_node = require("@react-router/node");
+    init_invariant();
+  }
+});
+
+// vite/import-vite-esm-sync.ts
+async function preloadViteEsm() {
+  vite = await import("vite");
+}
+function importViteEsmSync() {
+  invariant(vite, "importViteEsmSync() called before preloadViteEsm()");
+  return vite;
+}
+var vite;
+var init_import_vite_esm_sync = __esm({
+  "vite/import-vite-esm-sync.ts"() {
+    "use strict";
+    init_invariant();
+  }
+});
+
+// vite/resolve-file-url.ts
+var path;
+var init_resolve_file_url = __esm({
+  "vite/resolve-file-url.ts"() {
+    "use strict";
+    path = __toESM(require("path"));
+    init_import_vite_esm_sync();
+  }
+});
+
+// vite/styles.ts
+var path2, import_react_router, cssFileRegExp, cssModulesRegExp;
+var init_styles = __esm({
+  "vite/styles.ts"() {
+    "use strict";
+    path2 = __toESM(require("path"));
+    import_react_router = require("react-router");
+    init_resolve_file_url();
+    cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+    cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
+  }
+});
+
+// vite/vmod.ts
+var id;
+var init_vmod = __esm({
+  "vite/vmod.ts"() {
+    "use strict";
+    id = (name) => `virtual:react-router/${name}`;
+  }
+});
+
+// vite/combine-urls.ts
+var init_combine_urls = __esm({
+  "vite/combine-urls.ts"() {
+    "use strict";
+  }
+});
+
+// vite/remove-exports.ts
+var import_babel_dead_code_elimination;
+var init_remove_exports = __esm({
+  "vite/remove-exports.ts"() {
+    "use strict";
+    import_babel_dead_code_elimination = require("babel-dead-code-elimination");
+    init_babel();
+  }
+});
+
+// config/routes.ts
+function configRoutesToRouteManifest(routes2, 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 routes2) {
+    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, "");
+}
+var import_node_path, v, import_pick, routeConfigEntrySchema, resolvedRouteConfigSchema;
+var init_routes = __esm({
+  "config/routes.ts"() {
+    "use strict";
+    import_node_path = require("path");
+    v = __toESM(require("valibot"));
+    import_pick = __toESM(require("lodash/pick"));
+    init_invariant();
+    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)))
+      })
+    );
+    resolvedRouteConfigSchema = v.array(routeConfigEntrySchema);
+  }
+});
+
+// cli/detectPackageManager.ts
+var init_detectPackageManager = __esm({
+  "cli/detectPackageManager.ts"() {
+    "use strict";
+  }
+});
+
+// vite/config.ts
+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;
+}
+var import_node_child_process, import_node_path2, import_fs_extra, import_picocolors, import_pick2, import_omit, import_package_json, branchRouteProperties, configRouteToBranchRoute, entryExts;
+var init_config = __esm({
+  "vite/config.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+    import_node_path2 = __toESM(require("path"));
+    import_fs_extra = __toESM(require("fs-extra"));
+    import_picocolors = __toESM(require("picocolors"));
+    import_pick2 = __toESM(require("lodash/pick"));
+    import_omit = __toESM(require("lodash/omit"));
+    import_package_json = __toESM(require("@npmcli/package-json"));
+    init_routes();
+    init_detectPackageManager();
+    init_import_vite_esm_sync();
+    branchRouteProperties = [
+      "id",
+      "path",
+      "file",
+      "index"
+    ];
+    configRouteToBranchRoute = (configRoute) => (0, import_pick2.default)(configRoute, branchRouteProperties);
+    entryExts = [".js", ".jsx", ".ts", ".tsx"];
+  }
+});
+
+// vite/with-props.ts
+var import_dedent, vmodId;
+var init_with_props = __esm({
+  "vite/with-props.ts"() {
+    "use strict";
+    import_dedent = __toESM(require("dedent"));
+    init_babel();
+    init_vmod();
+    vmodId = id("with-props");
+  }
+});
+
+// vite/vite-node.ts
+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 };
+}
+var import_server, import_client, import_source_map;
+var init_vite_node = __esm({
+  "vite/vite-node.ts"() {
+    "use strict";
+    import_server = require("vite-node/server");
+    import_client = require("vite-node/client");
+    import_source_map = require("vite-node/source-map");
+    init_import_vite_esm_sync();
+  }
+});
+
+// vite/plugin.ts
+async function resolveViteConfig({
+  configFile,
+  mode,
+  root
+}) {
+  let vite2 = await import("vite");
+  let viteConfig = await vite2.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(import_picocolors2.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(
+      import_picocolors2.default.red("React Router Vite plugin not found in Vite config")
+    );
+    process.exit(1);
+  }
+  return ctx;
+}
+function findConfig(dir, basename2, extensions) {
+  for (let ext of extensions) {
+    let name = basename2 + ext;
+    let file = path4.join(dir, name);
+    if (fse2.existsSync(file)) return file;
+  }
+  return void 0;
+}
+var import_node_crypto, path4, url, fse2, babel, import_react_router2, import_es_module_lexer, import_jsesc, import_picocolors2, serverBuildId, serverManifestId, browserManifestId, hmrRuntimeId, injectHmrRuntimeId, getServerBuildDirectory, defaultEntriesDir, defaultEntries, REACT_REFRESH_HEADER, REACT_REFRESH_FOOTER;
+var init_plugin = __esm({
+  "vite/plugin.ts"() {
+    "use strict";
+    import_node_crypto = require("crypto");
+    path4 = __toESM(require("path"));
+    url = __toESM(require("url"));
+    fse2 = __toESM(require("fs-extra"));
+    babel = __toESM(require("@babel/core"));
+    import_react_router2 = require("react-router");
+    import_es_module_lexer = require("es-module-lexer");
+    import_jsesc = __toESM(require("jsesc"));
+    import_picocolors2 = __toESM(require("picocolors"));
+    init_invariant();
+    init_babel();
+    init_node_adapter();
+    init_styles();
+    init_vmod();
+    init_resolve_file_url();
+    init_combine_urls();
+    init_remove_exports();
+    init_import_vite_esm_sync();
+    init_config();
+    init_with_props();
+    init_vite_node();
+    serverBuildId = id("server-build");
+    serverManifestId = id("server-manifest");
+    browserManifestId = id("browser-manifest");
+    hmrRuntimeId = id("hmr-runtime");
+    injectHmrRuntimeId = id("inject-hmr-runtime");
+    getServerBuildDirectory = (ctx) => path4.join(
+      ctx.reactRouterConfig.buildDirectory,
+      "server",
+      ...ctx.serverBundleBuildConfig ? [ctx.serverBundleBuildConfig.serverBundleId] : []
+    );
+    defaultEntriesDir = path4.resolve(
+      path4.dirname(require.resolve("@react-router/dev/package.json")),
+      "dist",
+      "config",
+      "defaults"
+    );
+    defaultEntries = fse2.readdirSync(defaultEntriesDir).map((filename2) => path4.join(defaultEntriesDir, filename2));
+    invariant(defaultEntries.length > 0, "No default entries found");
+    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();
+    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();
+  }
+});
+
+// vite/profiler.ts
+var import_node_fs, import_node_path3, import_picocolors3, getSession, start, profileCount, stop;
+var init_profiler = __esm({
+  "vite/profiler.ts"() {
+    "use strict";
+    import_node_fs = __toESM(require("fs"));
+    import_node_path3 = __toESM(require("path"));
+    import_picocolors3 = __toESM(require("picocolors"));
+    getSession = () => global.__reactRouter_profile_session;
+    start = async (callback) => {
+      let inspector = await import("inspector").then((r) => r.default);
+      let session = global.__reactRouter_profile_session = new inspector.Session();
+      session.connect();
+      session.post("Profiler.enable", () => {
+        session.post("Profiler.start", callback);
+      });
+    };
+    profileCount = 0;
+    stop = (log2) => {
+      let session = getSession();
+      if (!session) return;
+      return new Promise((res, rej) => {
+        session.post("Profiler.stop", (err, { profile }) => {
+          if (err) return rej(err);
+          let outPath = import_node_path3.default.resolve(`./react-router-${profileCount++}.cpuprofile`);
+          import_node_fs.default.writeFileSync(outPath, JSON.stringify(profile));
+          log2(
+            import_picocolors3.default.yellow(
+              `CPU profile written to ${import_picocolors3.default.white(import_picocolors3.default.dim(outPath))}`
+            )
+          );
+          global.__reactRouter_profile_session = void 0;
+          res();
+        });
+      });
+    };
+  }
+});
+
+// vite/build.ts
+var build_exports = {};
+__export(build_exports, {
+  build: () => build
+});
+function getAddressableRoutes(routes2) {
+  let nonAddressableIds = /* @__PURE__ */ new Set();
+  for (let id2 in routes2) {
+    let route = routes2[id2];
+    if (route.index) {
+      invariant(
+        route.parentId,
+        `Expected index route "${route.id}" to have "parentId" set`
+      );
+      nonAddressableIds.add(route.parentId);
+    }
+    if (typeof route.path !== "string" && !route.index) {
+      nonAddressableIds.add(id2);
+    }
+  }
+  return Object.values(routes2).filter(
+    (route) => !nonAddressableIds.has(route.id)
+  );
+}
+function getRouteBranch(routes2, routeId) {
+  let branch = [];
+  let currentRouteId = routeId;
+  while (currentRouteId) {
+    let route = routes2[currentRouteId];
+    invariant(route, `Missing route for ${currentRouteId}`);
+    branch.push(route);
+    currentRouteId = route.parentId;
+  }
+  return branch.reverse();
+}
+async function getServerBuilds(ctx) {
+  let { rootDirectory } = ctx;
+  const { routes: routes2, serverBuildFile, serverBundles, appDirectory } = ctx.reactRouterConfig;
+  let serverBuildDirectory = getServerBuildDirectory(ctx);
+  if (!serverBundles) {
+    return {
+      serverBuilds: [{ ssr: true }],
+      buildManifest: { routes: routes2 }
+    };
+  }
+  let { normalizePath } = await import("vite");
+  let resolvedAppDirectory = import_node_path4.default.resolve(rootDirectory, appDirectory);
+  let rootRelativeRoutes = Object.fromEntries(
+    Object.entries(routes2).map(([id2, route]) => {
+      let filePath = import_node_path4.default.join(resolvedAppDirectory, route.file);
+      let rootRelativeFilePath = normalizePath(
+        import_node_path4.default.relative(rootDirectory, filePath)
+      );
+      return [id2, { ...route, file: rootRelativeFilePath }];
+    })
+  );
+  let buildManifest = {
+    serverBundles: {},
+    routeIdToServerBundleId: {},
+    routes: rootRelativeRoutes
+  };
+  let serverBundleBuildConfigById = /* @__PURE__ */ new Map();
+  await Promise.all(
+    getAddressableRoutes(routes2).map(async (route) => {
+      let branch = getRouteBranch(routes2, route.id);
+      let serverBundleId = await serverBundles({
+        branch: branch.map(
+          (route2) => configRouteToBranchRoute({
+            ...route2,
+            // Ensure absolute paths are passed to the serverBundles function
+            file: import_node_path4.default.join(resolvedAppDirectory, route2.file)
+          })
+        )
+      });
+      if (typeof serverBundleId !== "string") {
+        throw new Error(`The "serverBundles" function must return a string`);
+      }
+      if (!/^[a-zA-Z0-9-_]+$/.test(serverBundleId)) {
+        throw new Error(
+          `The "serverBundles" function must only return strings containing alphanumeric characters, hyphens and underscores.`
+        );
+      }
+      buildManifest.routeIdToServerBundleId[route.id] = serverBundleId;
+      let relativeServerBundleDirectory = import_node_path4.default.relative(
+        rootDirectory,
+        import_node_path4.default.join(serverBuildDirectory, serverBundleId)
+      );
+      let serverBuildConfig = serverBundleBuildConfigById.get(serverBundleId);
+      if (!serverBuildConfig) {
+        buildManifest.serverBundles[serverBundleId] = {
+          id: serverBundleId,
+          file: normalizePath(
+            import_node_path4.default.join(relativeServerBundleDirectory, serverBuildFile)
+          )
+        };
+        serverBuildConfig = {
+          routes: {},
+          serverBundleId
+        };
+        serverBundleBuildConfigById.set(serverBundleId, serverBuildConfig);
+      }
+      for (let route2 of branch) {
+        serverBuildConfig.routes[route2.id] = route2;
+      }
+    })
+  );
+  let serverBuilds = Array.from(serverBundleBuildConfigById.values()).map(
+    (serverBundleBuildConfig) => {
+      let serverBuild = {
+        ssr: true,
+        serverBundleBuildConfig
+      };
+      return serverBuild;
+    }
+  );
+  return {
+    serverBuilds,
+    buildManifest
+  };
+}
+async function cleanBuildDirectory(viteConfig, ctx) {
+  let buildDirectory = ctx.reactRouterConfig.buildDirectory;
+  let isWithinRoot = () => {
+    let relativePath = import_node_path4.default.relative(ctx.rootDirectory, buildDirectory);
+    return !relativePath.startsWith("..") && !import_node_path4.default.isAbsolute(relativePath);
+  };
+  if (viteConfig.build.emptyOutDir ?? isWithinRoot()) {
+    await import_fs_extra2.default.remove(buildDirectory);
+  }
+}
+function getViteManifestPaths(ctx, serverBuilds) {
+  let buildRelative = (pathname) => import_node_path4.default.resolve(ctx.reactRouterConfig.buildDirectory, pathname);
+  let viteManifestPaths = [
+    "client/.vite/manifest.json",
+    ...serverBuilds.map(({ serverBundleBuildConfig }) => {
+      let serverBundleId = serverBundleBuildConfig?.serverBundleId;
+      let serverBundlePath = serverBundleId ? serverBundleId + "/" : "";
+      return `server/${serverBundlePath}.vite/manifest.json`;
+    })
+  ].map((srcPath) => buildRelative(srcPath));
+  return viteManifestPaths;
+}
+async function build(root, {
+  assetsInlineLimit,
+  clearScreen,
+  config: configFile,
+  emptyOutDir,
+  force,
+  logLevel,
+  minify,
+  mode,
+  sourcemapClient,
+  sourcemapServer
+}) {
+  await preloadViteEsm();
+  let viteConfig = await resolveViteConfig({ configFile, mode, root });
+  const ctx = await extractPluginContext(viteConfig);
+  if (!ctx) {
+    console.error(
+      import_picocolors6.default.red("React Router Vite plugin not found in Vite config")
+    );
+    process.exit(1);
+  }
+  let { reactRouterConfig } = ctx;
+  let vite2 = await import("vite");
+  async function viteBuild({
+    ssr,
+    serverBundleBuildConfig
+  }) {
+    await vite2.build({
+      root,
+      mode,
+      configFile,
+      build: {
+        assetsInlineLimit,
+        emptyOutDir,
+        minify,
+        ssr,
+        sourcemap: ssr ? sourcemapServer : sourcemapClient
+      },
+      optimizeDeps: { force },
+      clearScreen,
+      logLevel,
+      ...serverBundleBuildConfig ? { __reactRouterServerBundleBuildConfig: serverBundleBuildConfig } : {}
+    });
+  }
+  await cleanBuildDirectory(viteConfig, ctx);
+  await viteBuild({ ssr: false });
+  let { serverBuilds, buildManifest } = await getServerBuilds(ctx);
+  await Promise.all(serverBuilds.map(viteBuild));
+  let viteManifestPaths = getViteManifestPaths(ctx, serverBuilds);
+  await Promise.all(
+    viteManifestPaths.map(async (viteManifestPath) => {
+      let manifestExists = await import_fs_extra2.default.pathExists(viteManifestPath);
+      if (!manifestExists) return;
+      if (!ctx.viteManifestEnabled) {
+        await import_fs_extra2.default.remove(viteManifestPath);
+      }
+      let viteDir = import_node_path4.default.dirname(viteManifestPath);
+      let viteDirFiles = await import_fs_extra2.default.readdir(viteDir);
+      if (viteDirFiles.length === 0) {
+        await import_fs_extra2.default.remove(viteDir);
+      }
+    })
+  );
+  await reactRouterConfig.buildEnd?.({
+    buildManifest,
+    reactRouterConfig,
+    viteConfig
+  });
+}
+var import_node_path4, import_fs_extra2, import_picocolors6;
+var init_build = __esm({
+  "vite/build.ts"() {
+    "use strict";
+    import_node_path4 = __toESM(require("path"));
+    import_fs_extra2 = __toESM(require("fs-extra"));
+    import_picocolors6 = __toESM(require("picocolors"));
+    init_plugin();
+    init_config();
+    init_invariant();
+    init_import_vite_esm_sync();
+  }
+});
+
+// vite/dev.ts
+var dev_exports = {};
+__export(dev_exports, {
+  dev: () => dev
+});
+async function dev(root, {
+  clearScreen,
+  config: configFile,
+  cors,
+  force,
+  host,
+  logLevel,
+  mode,
+  open,
+  port,
+  strictPort
+}) {
+  await preloadViteEsm();
+  let vite2 = await import("vite");
+  let server = await vite2.createServer({
+    root,
+    mode,
+    configFile,
+    server: { open, cors, host, port, strictPort },
+    optimizeDeps: { force },
+    clearScreen,
+    logLevel
+  });
+  if (!server.config.plugins.find((plugin2) => plugin2.name === "react-router")) {
+    console.error(
+      import_picocolors7.default.red("React Router Vite plugin not found in Vite config")
+    );
+    process.exit(1);
+  }
+  await server.listen();
+  server.printUrls();
+  let customShortcuts = [
+    {
+      key: "p",
+      description: "start/stop the profiler",
+      async action(server2) {
+        if (getSession()) {
+          await stop(server2.config.logger.info);
+        } else {
+          await start(() => {
+            server2.config.logger.info("Profiler started");
+          });
+        }
+      }
+    }
+  ];
+  server.bindCLIShortcuts({ print: true, customShortcuts });
+}
+var import_picocolors7;
+var init_dev = __esm({
+  "vite/dev.ts"() {
+    "use strict";
+    import_picocolors7 = __toESM(require("picocolors"));
+    init_import_vite_esm_sync();
+    init_profiler();
+  }
+});
+
+// cli/run.ts
+var import_arg = __toESM(require("arg"));
+var import_semver = __toESM(require("semver"));
+var import_picocolors9 = __toESM(require("picocolors"));
+
+// cli/commands.ts
+var path7 = __toESM(require("path"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_package_json2 = __toESM(require("@npmcli/package-json"));
+var import_exit_hook = __toESM(require("exit-hook"));
+var import_picocolors8 = __toESM(require("picocolors"));
+
+// config/format.ts
+function formatRoutes(routeManifest, format) {
+  switch (format) {
+    case "json":
+      return formatRoutesAsJson(routeManifest);
+    case "jsx":
+      return formatRoutesAsJsx(routeManifest);
+  }
+}
+function formatRoutesAsJson(routeManifest) {
+  function handleRoutesRecursive(parentId) {
+    let routes2 = Object.values(routeManifest).filter(
+      (route) => route.parentId === parentId
+    );
+    let children = [];
+    for (let route of routes2) {
+      children.push({
+        id: route.id,
+        index: route.index,
+        path: route.path,
+        caseSensitive: route.caseSensitive,
+        file: route.file,
+        children: handleRoutesRecursive(route.id)
+      });
+    }
+    if (children.length > 0) {
+      return children;
+    }
+    return void 0;
+  }
+  return JSON.stringify(handleRoutesRecursive() || null, null, 2);
+}
+function formatRoutesAsJsx(routeManifest) {
+  let output = "<Routes>";
+  function handleRoutesRecursive(parentId, level = 1) {
+    let routes2 = Object.values(routeManifest).filter(
+      (route) => route.parentId === parentId
+    );
+    let indent = Array(level * 2).fill(" ").join("");
+    for (let route of routes2) {
+      output += "\n" + indent;
+      output += `<Route${route.path ? ` path=${JSON.stringify(route.path)}` : ""}${route.index ? " index" : ""}${route.file ? ` file=${JSON.stringify(route.file)}` : ""}>`;
+      if (handleRoutesRecursive(route.id, level + 1)) {
+        output += "\n" + indent;
+        output += "</Route>";
+      } else {
+        output = output.slice(0, -1) + " />";
+      }
+    }
+    return routes2.length > 0;
+  }
+  handleRoutesRecursive();
+  output += "\n</Routes>";
+  return output;
+}
+
+// cli/commands.ts
+init_plugin();
 
-run.run().then(() => {
-  process.exit(0);
-}, error => {
-  if (error) console.error(error);
-  process.exit(1);
+// cli/useJavascript.ts
+var babel2 = __toESM(require("@babel/core"));
+var import_plugin_syntax_jsx = __toESM(require("@babel/plugin-syntax-jsx"));
+var import_preset_typescript = __toESM(require("@babel/preset-typescript"));
+var import_prettier = __toESM(require("prettier"));
+function transpile(tsx, options = {}) {
+  let mjs = babel2.transformSync(tsx, {
+    compact: false,
+    cwd: options.cwd,
+    filename: options.filename,
+    plugins: [import_plugin_syntax_jsx.default],
+    presets: [[import_preset_typescript.default, { jsx: "preserve" }]],
+    retainLines: true
+  });
+  if (!mjs || !mjs.code) throw new Error("Could not parse TypeScript");
+  return import_prettier.default.format(mjs.code, { parser: "babel" });
+}
+
+// cli/commands.ts
+init_profiler();
+
+// typegen.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_dedent2 = __toESM(require("dedent"));
+var Path = __toESM(require("pathe"));
+var Pathe = __toESM(require("pathe/utils"));
+var import_picocolors5 = __toESM(require("picocolors"));
+
+// logger.ts
+var import_picocolors4 = __toESM(require("picocolors"));
+var DATE_TIME_FORMAT = new Intl.DateTimeFormat([], {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  hour12: false
 });
+var log = (level) => (body, options = {}) => {
+  const dest = level === "error" ? process.stderr : process.stdout;
+  let message = getPrefix(level, options) + " " + body;
+  if (options.durationMs) {
+    const duration = options.durationMs < 1e3 ? `${Math.round(options.durationMs)}ms` : `${(options.durationMs / 1e3).toFixed(2)}s`;
+    message += " " + import_picocolors4.default.dim(duration);
+  }
+  dest.write(message + "\n");
+};
+function getPrefix(level, options) {
+  const timestamp = `${DATE_TIME_FORMAT.format(/* @__PURE__ */ new Date())}`;
+  const prefix = [];
+  if (level === "error" || level === "warn") {
+    prefix.push(import_picocolors4.default.bold(timestamp));
+    prefix.push(`[${level.toUpperCase()}]`);
+  } else {
+    prefix.push(timestamp);
+  }
+  if (options.label) {
+    prefix.push(`[${options.label}]`);
+  }
+  if (level === "error") return import_picocolors4.default.red(prefix.join(" "));
+  if (level === "warn") return import_picocolors4.default.yellow(prefix.join(" "));
+  if (prefix.length === 1) return import_picocolors4.default.dim(prefix[0]);
+  return import_picocolors4.default.dim(prefix[0]) + " " + import_picocolors4.default.blue(prefix.splice(1).join(" "));
+}
+var info = log("info");
+var warn = log("warn");
+var error = log("error");
+
+// typegen.ts
+init_routes();
+init_vite_node();
+init_config();
+init_plugin();
+function getDirectory(ctx) {
+  return Path.join(ctx.rootDirectory, ".react-router/types");
+}
+async function watch(rootDirectory, options = {}) {
+  const watchStart = performance.now();
+  const vitePluginCtx = await loadPluginContext({
+    root: rootDirectory,
+    configFile: options.configFile
+  });
+  const routeConfigFile = findEntry(
+    vitePluginCtx.reactRouterConfig.appDirectory,
+    "routes"
+  );
+  if (!routeConfigFile) {
+    warn(
+      `Could not find route config within ${import_picocolors5.default.blue(
+        Path.relative(
+          vitePluginCtx.rootDirectory,
+          vitePluginCtx.reactRouterConfig.appDirectory
+        )
+      )}`
+    );
+    process.exit(1);
+  }
+  const routeConfigPath = Path.join(
+    vitePluginCtx.reactRouterConfig.appDirectory,
+    routeConfigFile
+  );
+  const routesViteNodeContext = await createContext({
+    root: rootDirectory
+  });
+  async function getRoutes() {
+    const routes2 = {};
+    const rootRouteFile = findEntry(
+      vitePluginCtx.reactRouterConfig.appDirectory,
+      "root"
+    );
+    if (rootRouteFile) {
+      routes2.root = { path: "", id: "root", file: rootRouteFile };
+    } else {
+      warn(`Could not find \`root\` route`);
+    }
+    routesViteNodeContext.devServer.moduleGraph.invalidateAll();
+    routesViteNodeContext.runner.moduleCache.clear();
+    const routeConfig = (await routesViteNodeContext.runner.executeFile(routeConfigPath)).routes;
+    return {
+      ...routes2,
+      ...configRoutesToRouteManifest(await routeConfig)
+    };
+  }
+  const ctx = {
+    rootDirectory,
+    appDirectory: vitePluginCtx.reactRouterConfig.appDirectory,
+    routes: await getRoutes()
+  };
+  await writeAll(ctx);
+  info("generated initial types", {
+    durationMs: performance.now() - watchStart
+  });
+  const watcher = import_chokidar.default.watch(ctx.appDirectory, { ignoreInitial: true });
+  watcher.on("all", async (event, path8) => {
+    const eventStart = performance.now();
+    path8 = Path.normalize(path8);
+    ctx.routes = await getRoutes();
+    const routeConfigChanged = Boolean(
+      routesViteNodeContext.devServer.moduleGraph.getModuleById(path8)
+    );
+    if (routeConfigChanged) {
+      await writeAll(ctx);
+      info("changed route config", {
+        durationMs: performance.now() - eventStart
+      });
+      return;
+    }
+    const route = Object.values(ctx.routes).find(
+      (route2) => path8 === Path.join(ctx.appDirectory, route2.file)
+    );
+    if (route && (event === "add" || event === "unlink")) {
+      await writeAll(ctx);
+      info(
+        `${event === "add" ? "added" : "removed"} route ${import_picocolors5.default.blue(route.file)}`,
+        { durationMs: performance.now() - eventStart }
+      );
+      return;
+    }
+  });
+}
+async function writeAll(ctx) {
+  import_node_fs2.default.rmSync(getDirectory(ctx), { recursive: true, force: true });
+  Object.values(ctx.routes).forEach((route) => {
+    if (!import_node_fs2.default.existsSync(Path.join(ctx.appDirectory, route.file))) return;
+    const typesPath = Path.join(
+      getDirectory(ctx),
+      Path.relative(ctx.rootDirectory, ctx.appDirectory),
+      Path.dirname(route.file),
+      "+types." + Pathe.filename(route.file) + ".d.ts"
+    );
+    const content = getModule(ctx.routes, route);
+    import_node_fs2.default.mkdirSync(Path.dirname(typesPath), { recursive: true });
+    import_node_fs2.default.writeFileSync(typesPath, content);
+  });
+}
+function getModule(routes2, route) {
+  return import_dedent2.default`
+    // React Router generated types for route:
+    // ${route.file}
+
+    import * as T from "react-router/types"
+
+    export type Params = {${formattedParamsProperties(routes2, route)}}
+
+    type RouteModule = typeof import("./${Pathe.filename(route.file)}")
+
+    export namespace Route {
+      export type LoaderData = T.CreateLoaderData<RouteModule>
+      export type ActionData = T.CreateActionData<RouteModule>
+
+      export type LoaderArgs = T.CreateServerLoaderArgs<Params>
+      export type ClientLoaderArgs = T.CreateClientLoaderArgs<Params, RouteModule>
+      export type ActionArgs = T.CreateServerActionArgs<Params>
+      export type ClientActionArgs = T.CreateClientActionArgs<Params, RouteModule>
+
+      export type HydrateFallbackProps = T.CreateHydrateFallbackProps<Params>
+      export type ComponentProps = T.CreateComponentProps<Params, LoaderData, ActionData>
+      export type ErrorBoundaryProps = T.CreateErrorBoundaryProps<Params, LoaderData, ActionData>
+    }
+  `;
+}
+function formattedParamsProperties(routes2, route) {
+  const urlpath = routeLineage(routes2, route).map((route2) => route2.path).join("/");
+  const params = parseParams(urlpath);
+  const indent = "  ".repeat(3);
+  const properties = Object.entries(params).map(([name, values]) => {
+    if (values.length === 1) {
+      const isOptional = values[0];
+      return indent + (isOptional ? `${name}?: string` : `${name}: string`);
+    }
+    const items = values.map(
+      (isOptional) => isOptional ? "string | undefined" : "string"
+    );
+    return indent + `${name}: [${items.join(", ")}]`;
+  });
+  const body = properties.length === 0 ? "" : "\n" + properties.join("\n") + "\n";
+  return body;
+}
+function routeLineage(routes2, route) {
+  const result = [];
+  while (route) {
+    result.push(route);
+    if (!route.parentId) break;
+    route = routes2[route.parentId];
+  }
+  result.reverse();
+  return result;
+}
+function parseParams(urlpath) {
+  const result = {};
+  let segments = urlpath.split("/");
+  segments.filter((s) => s.startsWith(":")).forEach((param) => {
+    param = param.slice(1);
+    let isOptional = param.endsWith("?");
+    if (isOptional) {
+      param = param.slice(0, -1);
+    }
+    result[param] ??= [];
+    result[param].push(isOptional);
+    return;
+  });
+  return result;
+}
+
+// cli/commands.ts
+async function routes(reactRouterRoot, flags = {}) {
+  let ctx = await loadPluginContext({
+    root: reactRouterRoot,
+    configFile: flags.config
+  });
+  if (!ctx) {
+    console.error(
+      import_picocolors8.default.red("React Router Vite plugin not found in Vite config")
+    );
+    process.exit(1);
+  }
+  let format = flags.json ? "json" : "jsx";
+  console.log(formatRoutes(ctx.reactRouterConfig.routes, format));
+}
+async function build2(root, options = {}) {
+  if (!root) {
+    root = process.env.REACT_ROUTER_ROOT || process.cwd();
+  }
+  let { build: build3 } = await Promise.resolve().then(() => (init_build(), build_exports));
+  if (options.profile) {
+    await start();
+  }
+  try {
+    await build3(root, options);
+  } finally {
+    await stop(console.info);
+  }
+}
+async function dev2(root, options = {}) {
+  let { dev: dev3 } = await Promise.resolve().then(() => (init_dev(), dev_exports));
+  if (options.profile) {
+    await start();
+  }
+  (0, import_exit_hook.default)(() => stop(console.info));
+  await dev3(root, options);
+  await new Promise(() => {
+  });
+}
+var clientEntries = ["entry.client.tsx", "entry.client.js", "entry.client.jsx"];
+var serverEntries = ["entry.server.tsx", "entry.server.js", "entry.server.jsx"];
+var entries = ["entry.client", "entry.server"];
+var conjunctionListFormat = new Intl.ListFormat("en", {
+  style: "long",
+  type: "conjunction"
+});
+async function generateEntry(entry, reactRouterRoot, flags = {}) {
+  let ctx = await loadPluginContext({
+    root: reactRouterRoot,
+    configFile: flags.config
+  });
+  let rootDirectory = ctx.rootDirectory;
+  let appDirectory = ctx.reactRouterConfig.appDirectory;
+  if (!entry) {
+    await generateEntry("entry.client", reactRouterRoot, flags);
+    await generateEntry("entry.server", reactRouterRoot, flags);
+    return;
+  }
+  if (!entries.includes(entry)) {
+    let entriesArray = Array.from(entries);
+    let list = conjunctionListFormat.format(entriesArray);
+    console.error(
+      import_picocolors8.default.red(`Invalid entry file. Valid entry files are ${list}`)
+    );
+    return;
+  }
+  let pkgJson = await import_package_json2.default.load(rootDirectory);
+  let deps = pkgJson.content.dependencies ?? {};
+  if (!deps["@react-router/node"]) {
+    console.error(import_picocolors8.default.red(`No default server entry detected.`));
+    return;
+  }
+  let defaultsDirectory = path7.resolve(
+    path7.dirname(require.resolve("@react-router/dev/package.json")),
+    "dist",
+    "config",
+    "defaults"
+  );
+  let defaultEntryClient = path7.resolve(defaultsDirectory, "entry.client.tsx");
+  let defaultEntryServer = path7.resolve(
+    defaultsDirectory,
+    `entry.server.node.tsx`
+  );
+  let isServerEntry = entry === "entry.server";
+  let contents = isServerEntry ? await createServerEntry(rootDirectory, appDirectory, defaultEntryServer) : await createClientEntry(rootDirectory, appDirectory, defaultEntryClient);
+  let useTypeScript = flags.typescript ?? true;
+  let outputExtension = useTypeScript ? "tsx" : "jsx";
+  let outputEntry = `${entry}.${outputExtension}`;
+  let outputFile2 = path7.resolve(appDirectory, outputEntry);
+  if (!useTypeScript) {
+    let javascript = transpile(contents, {
+      cwd: rootDirectory,
+      filename: isServerEntry ? defaultEntryServer : defaultEntryClient
+    });
+    await import_fs_extra3.default.writeFile(outputFile2, javascript, "utf-8");
+  } else {
+    await import_fs_extra3.default.writeFile(outputFile2, contents, "utf-8");
+  }
+  console.log(
+    import_picocolors8.default.blue(
+      `Entry file ${entry} created at ${path7.relative(
+        rootDirectory,
+        outputFile2
+      )}.`
+    )
+  );
+}
+async function checkForEntry(rootDirectory, appDirectory, entries2) {
+  for (let entry of entries2) {
+    let entryPath = path7.resolve(appDirectory, entry);
+    let exists = await import_fs_extra3.default.pathExists(entryPath);
+    if (exists) {
+      let relative6 = path7.relative(rootDirectory, entryPath);
+      console.error(import_picocolors8.default.red(`Entry file ${relative6} already exists.`));
+      return process.exit(1);
+    }
+  }
+}
+async function createServerEntry(rootDirectory, appDirectory, inputFile) {
+  await checkForEntry(rootDirectory, appDirectory, serverEntries);
+  let contents = await import_fs_extra3.default.readFile(inputFile, "utf-8");
+  return contents;
+}
+async function createClientEntry(rootDirectory, appDirectory, inputFile) {
+  await checkForEntry(rootDirectory, appDirectory, clientEntries);
+  let contents = await import_fs_extra3.default.readFile(inputFile, "utf-8");
+  return contents;
+}
+async function typegen(root, flags) {
+  root ??= process.cwd();
+  if (flags.watch) {
+    await watch(root, { configFile: flags.config });
+    await new Promise(() => {
+    });
+    return;
+  }
+  let ctx = await loadPluginContext({ root, configFile: flags.config });
+  await writeAll({
+    rootDirectory: root,
+    appDirectory: ctx.reactRouterConfig.appDirectory,
+    routes: ctx.reactRouterConfig.routes
+  });
+}
+
+// cli/run.ts
+var helpText = `
+${import_picocolors9.default.blueBright("react-router")}
+
+  ${import_picocolors9.default.underline("Usage")}:
+    $ react-router build [${import_picocolors9.default.yellowBright("projectDir")}]
+    $ react-router dev [${import_picocolors9.default.yellowBright("projectDir")}]
+    $ react-router routes [${import_picocolors9.default.yellowBright("projectDir")}]
+
+  ${import_picocolors9.default.underline("Options")}:
+    --help, -h          Print this help message and exit
+    --version, -v       Print the CLI version and exit
+    --no-color          Disable ANSI colors in console output
+  \`build\` Options:
+    --assetsInlineLimit Static asset base64 inline threshold in bytes (default: 4096) (number)
+    --clearScreen       Allow/disable clear screen when logging (boolean)
+    --config, -c        Use specified config file (string)
+    --emptyOutDir       Force empty outDir when it's outside of root (boolean)
+    --logLevel, -l      Info | warn | error | silent (string)
+    --minify            Enable/disable minification, or specify minifier to use (default: "esbuild") (boolean | "terser" | "esbuild")
+    --mode, -m          Set env mode (string)
+    --profile           Start built-in Node.js inspector
+    --sourcemapClient   Output source maps for client build (default: false) (boolean | "inline" | "hidden")
+    --sourcemapServer   Output source maps for server build (default: false) (boolean | "inline" | "hidden")
+  \`dev\` Options:
+    --clearScreen       Allow/disable clear screen when logging (boolean)
+    --config, -c        Use specified config file (string)
+    --cors              Enable CORS (boolean)
+    --force             Force the optimizer to ignore the cache and re-bundle (boolean)
+    --host              Specify hostname (string)
+    --logLevel, -l      Info | warn | error | silent (string)
+    --mode, -m          Set env mode (string)
+    --open              Open browser on startup (boolean | string)
+    --port              Specify port (number)
+    --profile           Start built-in Node.js inspector
+    --strictPort        Exit if specified port is already in use (boolean)
+  \`routes\` Options:
+    --config, -c        Use specified Vite config file (string)
+    --json              Print the routes as JSON
+  \`reveal\` Options:
+    --config, -c        Use specified Vite config file (string)
+    --no-typescript     Generate plain JavaScript files
+  \`typegen\` Options:
+    --config, -c        Use specified Vite config file (string)
+    --watch             Automatically regenerate types whenever route config (\`routes.ts\`) or route modules change
+
+  ${import_picocolors9.default.underline("Build your project")}:
+
+    $ react-router build
+
+  ${import_picocolors9.default.underline("Run your project locally in development")}:
+
+    $ react-router dev
+
+  ${import_picocolors9.default.underline("Show all routes in your app")}:
+
+    $ react-router routes
+    $ react-router routes my-app
+    $ react-router routes --json
+    $ react-router routes --config vite.react-router.config.ts
+
+  ${import_picocolors9.default.underline("Reveal the used entry point")}:
+
+    $ react-router reveal entry.client
+    $ react-router reveal entry.server
+    $ react-router reveal entry.client --no-typescript
+    $ react-router reveal entry.server --no-typescript
+    $ react-router reveal entry.server --config vite.react-router.config.ts
+
+  ${import_picocolors9.default.underline("Generate types for route modules")}:
+
+   $ react-router typegen
+   $ react-router typegen --watch
+   $ react-router typegen --config vite.react-router.config.ts
+`;
+async function run(argv = process.argv.slice(2)) {
+  let versions = process.versions;
+  let MINIMUM_NODE_VERSION = 20;
+  if (versions && versions.node && import_semver.default.major(versions.node) < MINIMUM_NODE_VERSION) {
+    throw new Error(
+      `\uFE0F\u{1F6A8} Oops, Node v${versions.node} detected. react-router requires a Node version greater than ${MINIMUM_NODE_VERSION}.`
+    );
+  }
+  let isBooleanFlag = (arg2) => {
+    let index = argv.indexOf(arg2);
+    let nextArg = argv[index + 1];
+    return !nextArg || nextArg.startsWith("-");
+  };
+  let args = (0, import_arg.default)(
+    {
+      "--force": Boolean,
+      "--help": Boolean,
+      "-h": "--help",
+      "--json": Boolean,
+      "--token": String,
+      "--typescript": Boolean,
+      "--no-typescript": Boolean,
+      "--version": Boolean,
+      "-v": "--version",
+      "--port": Number,
+      "-p": "--port",
+      "--config": String,
+      "-c": "--config",
+      "--assetsInlineLimit": Number,
+      "--clearScreen": Boolean,
+      "--cors": Boolean,
+      "--emptyOutDir": Boolean,
+      "--host": isBooleanFlag("--host") ? Boolean : String,
+      "--logLevel": String,
+      "-l": "--logLevel",
+      "--minify": String,
+      "--mode": String,
+      "-m": "--mode",
+      "--open": isBooleanFlag("--open") ? Boolean : String,
+      "--strictPort": Boolean,
+      "--profile": Boolean,
+      "--sourcemapClient": isBooleanFlag("--sourcemapClient") ? Boolean : String,
+      "--sourcemapServer": isBooleanFlag("--sourcemapServer") ? Boolean : String,
+      "--watch": Boolean
+    },
+    {
+      argv
+    }
+  );
+  let input = args._;
+  let flags = Object.entries(args).reduce((acc, [key, value]) => {
+    key = key.replace(/^--/, "");
+    acc[key] = value;
+    return acc;
+  }, {});
+  if (flags.help) {
+    console.log(helpText);
+    return;
+  }
+  if (flags.version) {
+    let version = require("../package.json").version;
+    console.log(version);
+    return;
+  }
+  flags.interactive = flags.interactive ?? require.main === module;
+  if (args["--no-typescript"]) {
+    flags.typescript = false;
+  }
+  let command = input[0];
+  switch (command) {
+    case "routes":
+      await routes(input[1], flags);
+      break;
+    case "build":
+      await build2(input[1], flags);
+      break;
+    case "reveal": {
+      await generateEntry(input[1], input[2], flags);
+      break;
+    }
+    case "dev":
+      await dev2(input[1], flags);
+      break;
+    case "typegen":
+      await typegen(input[1], flags);
+      break;
+    default:
+      await dev2(input[0], flags);
+  }
+}
+
+// cli/index.ts
+run().then(
+  () => {
+    process.exit(0);
+  },
+  (error2) => {
+    if (error2) console.error(error2);
+    process.exit(1);
+  }
+);