@qwik.dev/router 2.0.0-beta.36 → 2.0.0-beta.38

package/lib/adapters/cloudflare-pages/vite/index.mjs

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { join, relative } from 'node:path';
 import { n as normalizePathSlash } from '../../../chunks/fs.mjs';
+import { e as ensureSlash } from '../../../chunks/pathname.mjs';
 import { viteAdapter } from '../../shared/vite/index.mjs';
 
 function cloudflarePagesAdapter(opts = {}) {
@@ -38,14 +39,11 @@ function cloudflarePagesAdapter(opts = {}) {
         publicDir: false
       };
     },
-    async generate({ clientOutDir, serverOutDir, basePathname, assetsDir }) {
+    async generate({ clientOutDir, serverOutDir, basePathname }) {
       const routesJsonPath = join(clientOutDir, "_routes.json");
       const hasRoutesJson = fs.existsSync(routesJsonPath);
       if (!hasRoutesJson && opts.functionRoutes !== false) {
-        let pathName = assetsDir ? join(basePathname, assetsDir) : basePathname;
-        if (!pathName.endsWith("/")) {
-          pathName += "/";
-        }
+        const pathName = ensureSlash(basePathname);
         const routesJson = {
           version: 1,
           include: [

package/lib/adapters/shared/vite/index.d.ts

@@ -1,6 +1,6 @@
-import type { Plugin as Plugin_2 } from 'vite';
+import { Plugin as Plugin_2 } from 'vite';
 import type { SsgRenderOptions } from 'packages/qwik-router/src/ssg';
-import type { UserConfig } from 'vite';
+import { UserConfig } from 'vite';
 
 /** @public */
 export declare interface AdapterSSGOptions extends Omit<SsgRenderOptions, 'outDir' | 'origin'> {
@@ -75,7 +75,7 @@ export declare interface ServerAdapterOptions {
 }
 
 /** @public */
-export declare function viteAdapter(opts: ViteAdapterPluginOptions): Plugin_2<any>[];
+export declare function viteAdapter(opts: ViteAdapterPluginOptions): Plugin_2<never>[];
 
 /** @public */
 declare interface ViteAdapterPluginOptions {
@@ -93,7 +93,6 @@ declare interface ViteAdapterPluginOptions {
         serverOutDir: string;
         basePathname: string;
         routes: BuiltRoute[];
-        assetsDir?: string;
         warn: (message: string) => void;
         error: (message: string) => void;
     }) => Promise<void>;

package/lib/adapters/shared/vite/index.mjs

@@ -1,71 +1,21 @@
+import { spawn } from 'node:child_process';
+import { readFile, unlink, rm } from 'node:fs/promises';
 import { join, resolve, dirname, basename } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import fs from 'node:fs';
-import { g as getErrorHtml } from '../../../chunks/error-handler.mjs';
+import { L as LOADER_REGEX } from '../../../chunks/request-path.mjs';
+import { e as ensureSlash } from '../../../chunks/pathname.mjs';
 
-const SSG_WORKER_IMPORT_PREFIX = "@qwik-router-ssg-worker/";
-function ssgWorkerImportPlugin() {
-  return {
-    name: "qwik-router-ssg-worker-imports",
-    enforce: "pre",
-    async resolveId(id, importer) {
-      if (!id.startsWith(SSG_WORKER_IMPORT_PREFIX)) {
-        return null;
-      }
-      const subpath = id.slice(SSG_WORKER_IMPORT_PREFIX.length);
-      const sourceId = fileURLToPath(new URL(`../../${subpath}`, import.meta.url));
-      const resolved = await this.resolve(sourceId, importer, {
-        skipSelf: true
-      });
-      return `${(resolved ?? {
-        id: sourceId
-      }).id}?ssg-worker`;
-    }
-  };
-}
-
-function normalizeTrailingSlash(pathname) {
-  if (!pathname.endsWith("/")) {
-    return pathname + "/";
-  }
-  return pathname;
-}
-function createNotFoundPathsCode(basePathname, notFounds) {
-  notFounds.sort((a, b) => {
-    if (a[0].length > b[0].length) {
-      return -1;
-    }
-    if (a[0].length < b[0].length) {
-      return 1;
-    }
-    if (a[0] < b[0]) {
-      return -1;
-    }
-    if (a[0] > b[0]) {
-      return 1;
-    }
-    return 0;
-  });
-  if (!notFounds.some((r) => r[0] === basePathname)) {
-    const html = getErrorHtml(404, "Resource Not Found");
-    notFounds.push([
-      basePathname,
-      html
-    ]);
-  }
-  return JSON.stringify(notFounds, null, 2).slice(1, -1);
-}
 function createStaticPathsCode(staticPaths) {
   return JSON.stringify(Array.from(new Set(staticPaths)).sort()).slice(1, -1);
 }
-const injectStatics = async (staticPathsCode, notFoundPathsCode, outDir) => {
+const injectStatics = async (staticPathsCode, outDir) => {
   const promises = /* @__PURE__ */ new Set();
   const doReplace = async (path) => {
     const code = await fs.promises.readFile(path, "utf-8");
     let replaced = false;
-    const newCode = code.replace(/(['"])__QWIK_ROUTER_(STATIC_PATHS|NOT_FOUND)_ARRAY__\1/g, (_, _quote, type) => {
+    const newCode = code.replace(/(['"])__QWIK_ROUTER_STATIC_PATHS_ARRAY__\1/g, () => {
       replaced = true;
-      return type === "STATIC_PATHS" ? staticPathsCode : notFoundPathsCode;
+      return staticPathsCode;
     });
     if (replaced) {
       await fs.promises.writeFile(path, newCode);
@@ -91,37 +41,37 @@ const injectStatics = async (staticPathsCode, notFoundPathsCode, outDir) => {
 };
 async function postBuild(clientOutDir, serverOutDir, pathName, userStaticPaths, cleanStatic) {
   if (pathName && !pathName.endsWith("/")) {
-    pathName += "/";
+    pathName = ensureSlash(pathName);
   }
+  const pathNameBase = pathName || "/";
   const ignorePathnames = /* @__PURE__ */ new Set([
-    pathName + "/" + (globalThis.__QWIK_BUILD_DIR__ || "build") + "/",
-    pathName + "/" + (globalThis.__QWIK_ASSETS_DIR__ || "assets") + "/"
+    pathNameBase + (globalThis.__QWIK_BUILD_DIR__ || "build") + "/",
+    pathNameBase + (globalThis.__QWIK_ASSETS_DIR__ || "assets") + "/"
   ]);
-  const staticPaths = new Set(userStaticPaths.map(normalizeTrailingSlash));
-  const notFounds = [];
+  const staticPaths = new Set(userStaticPaths.map(ensureSlash));
   const loadItem = async (fsDir, fsName, pathname) => {
-    pathname = normalizeTrailingSlash(pathname);
+    pathname = ensureSlash(pathname);
     if (ignorePathnames.has(pathname)) {
       return;
     }
     const fsPath = join(fsDir, fsName);
-    if (fsName === "index.html" || fsName === "q-data.json") {
+    if (fsName === "index.html") {
       if (!staticPaths.has(pathname) && cleanStatic) {
         await fs.promises.unlink(fsPath);
       }
       return;
     }
-    if (fsName === "404.html") {
-      const notFoundHtml = await fs.promises.readFile(fsPath, "utf-8");
-      notFounds.push([
-        pathname,
-        notFoundHtml
-      ]);
+    if (LOADER_REGEX.test("/" + fsName)) {
+      if (staticPaths.has(pathname)) {
+        staticPaths.add(pathname + fsName);
+      } else if (cleanStatic) {
+        await fs.promises.unlink(fsPath);
+      }
       return;
     }
     const stat = await fs.promises.stat(fsPath);
     if (stat.isDirectory()) {
-      await loadDir(fsPath, pathname + fsName + "/");
+      await loadDir(fsPath, ensureSlash(pathname + fsName));
     } else if (stat.isFile()) {
       staticPaths.add(pathname + fsName);
     }
@@ -133,19 +83,21 @@ async function postBuild(clientOutDir, serverOutDir, pathName, userStaticPaths,
   if (fs.existsSync(clientOutDir)) {
     await loadDir(clientOutDir, pathName);
   }
-  const notFoundPathsCode = createNotFoundPathsCode(pathName, notFounds);
   const staticPathsCode = createStaticPathsCode(staticPaths);
-  await injectStatics(staticPathsCode, notFoundPathsCode, serverOutDir);
+  await injectStatics(staticPathsCode, serverOutDir);
 }
 
 const QWIK_SSG_ENTRY_ID = "@qwik-ssg-entry";
 const QWIK_SSG_ENTRY_RESOLVED = "\0@qwik-ssg-entry";
+const QWIK_SSG_WORKER_ENTRY_ID = "@qwik-ssg-worker-entry";
+const QWIK_SSG_WORKER_ENTRY_RESOLVED = "\0@qwik-ssg-worker-entry";
 function viteAdapter(opts) {
   let qwikRouterPlugin = null;
   let qwikVitePlugin = null;
-  let serverOutDir = null;
   let viteCommand;
+  let buildAppRan = false;
   const outputEntries = [];
+  const ssgOutDirFor = (root) => join(resolve(root), "node_modules", ".cache", `qwik-router-ssg-${process.pid}`);
   const plugin = {
     name: `vite-plugin-qwik-router-ssg-${opts.name}`,
     enforce: "post",
@@ -158,30 +110,78 @@ function viteAdapter(opts) {
         "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "production"),
         ...config.define
       };
+      config.builder ??= {};
+      if (opts.ssg !== null) {
+        config.environments = {
+          ...config.environments,
+          // Same server externalization as `ssr` (via the router/qwik `configEnvironment` hooks);
+          // only the build graph and outDir differ. run-ssg externalizes node_modules deps and
+          // resolves them at render time, so native/CJS packages (e.g. a database client) are not
+          // force-bundled.
+          ssg: {
+            consumer: "server",
+            build: {
+              ssr: true,
+              outDir: ssgOutDirFor(config.root ?? process.cwd()),
+              emptyOutDir: true,
+              // Throwaway output, executed once and deleted — skip minify/sourcemap work.
+              minify: false,
+              sourcemap: false
+            }
+          }
+        };
+      }
       return config;
     },
+    configEnvironment(name, environmentOptions) {
+      if (name === "ssg") {
+        environmentOptions.build = {
+          ...environmentOptions.build,
+          rollupOptions: {
+            ...environmentOptions.build?.rollupOptions,
+            input: {}
+          }
+        };
+      }
+    },
     configResolved(config) {
       viteCommand = config.command;
       qwikRouterPlugin = config.plugins.find((p) => p.name === "vite-plugin-qwik-router");
       if (!qwikRouterPlugin) {
         throw new Error("Missing vite-plugin-qwik-router");
       }
+      qwikRouterPlugin.api?._setSsgRoutes?.(opts.ssg?.include, opts.ssg?.exclude);
       qwikVitePlugin = config.plugins.find((p) => p.name === "vite-plugin-qwik");
       if (!qwikVitePlugin) {
         throw new Error("Missing vite-plugin-qwik");
       }
-      serverOutDir = config.build.outDir;
     },
     resolveId(id) {
       if (id === QWIK_SSG_ENTRY_ID) {
         return QWIK_SSG_ENTRY_RESOLVED;
       }
+      if (id === QWIK_SSG_WORKER_ENTRY_ID) {
+        return QWIK_SSG_WORKER_ENTRY_RESOLVED;
+      }
     },
     load(id) {
+      if (id === QWIK_SSG_WORKER_ENTRY_RESOLVED) {
+        const { srcDir } = qwikVitePlugin.api.getOptions();
+        return [
+          `import render from '${srcDir}/entry.ssr';`,
+          `import qwikRouterConfig from '@qwik-router-config';`,
+          `import { startWorker } from '@qwik.dev/router/ssg';`,
+          // Fire-and-forget (no top-level await): avoids a Rollup inlined-dynamic-import init-order
+          // bug on the SSR target. See rollup/rollup#4166.
+          `startWorker({ render, qwikRouterConfig }).catch((err) => {`,
+          `  console.error(err);`,
+          `  process.exit(1);`,
+          `});`
+        ].join("\n");
+      }
       if (id !== QWIK_SSG_ENTRY_RESOLVED) {
         return;
       }
-      const { srcDir } = qwikVitePlugin.api.getOptions();
       const clientPublicOutDir = qwikVitePlugin.api.getClientPublicOutDir();
       const basePathname = qwikRouterPlugin.api.getBasePathname();
       const rootDir = qwikVitePlugin.api.getRootDir() ?? void 0;
@@ -215,47 +215,43 @@ function viteAdapter(opts) {
         }
       }
       return [
-        `import { isMainThread } from 'node:worker_threads';`,
-        `import render from '${srcDir}/entry.ssr';`,
         `import qwikRouterConfig from '@qwik-router-config';`,
-        `import { runSsg, startWorker } from '@qwik.dev/router/ssg';`,
+        `import { runSsg } from '@qwik.dev/router/ssg';`,
         ``,
         `const ssgOpts = ${JSON.stringify(ssgOpts)};`,
         ``,
         `// Parse --quiet / --debug CLI flags`,
-        `const args = isMainThread ? process.argv.slice(2) : [];`,
+        `const args = process.argv.slice(2);`,
         `if (args.includes('--quiet')) ssgOpts.log = 'quiet';`,
         `if (args.includes('--debug')) ssgOpts.log = 'debug';`,
         ``,
-        // Fire-and-forget instead of top-level await. On the worker/edge SSR target Vite
-        // inlines dynamic imports, and Rollup then reads the inlined `./system` namespace
-        // before it is initialized across a top-level await. See rollup/rollup#4166.
-        // runSsg/startWorker keep the process alive (worker handles) and call process.exit.
-        `const ssgRun = isMainThread`,
-        `  ? runSsg({`,
-        `      render,`,
-        `      qwikRouterConfig,`,
-        `      workerFilePath: new URL(import.meta.url).href,`,
-        `      ...ssgOpts,`,
-        `    })`,
-        `  : startWorker({ render, qwikRouterConfig });`,
-        `ssgRun.catch((err) => {`,
+        // Fire-and-forget; see rollup/rollup#4166 above. The worker entry is a sibling file.
+        `runSsg({`,
+        `  qwikRouterConfig,`,
+        `  workerFilePath: new URL('./run-ssg-worker.js', import.meta.url).href,`,
+        `  ...ssgOpts,`,
+        `}).catch((err) => {`,
         `  console.error(err);`,
         `  process.exit(1);`,
         `});`
       ].join("\n");
     },
     buildStart() {
-      if (this.environment.config.consumer === "server" && opts.ssg !== null && viteCommand === "build" && serverOutDir) {
+      if (this.environment.name === "ssg" && viteCommand === "build") {
         this.emitFile({
           id: QWIK_SSG_ENTRY_ID,
           type: "chunk",
           fileName: "run-ssg.js"
         });
+        this.emitFile({
+          id: QWIK_SSG_WORKER_ENTRY_ID,
+          type: "chunk",
+          fileName: "run-ssg-worker.js"
+        });
       }
     },
     generateBundle(_, bundles) {
-      if (this.environment.config.consumer === "server") {
+      if (this.environment.name === "ssr") {
         outputEntries.length = 0;
         for (const fileName in bundles) {
           const chunk = bundles[fileName];
@@ -263,77 +259,93 @@ function viteAdapter(opts) {
             outputEntries.push(fileName);
           }
         }
+        if (opts.ssg !== null && viteCommand === "build" && !buildAppRan) {
+          this.warn("Qwik Router SSG was skipped: the `ssr` environment was built directly instead of through the Vite app builder, so no pages were prerendered. Build with the Qwik CLI or `createBuilder(config).buildApp()` (a plain `vite build` does this automatically).");
+        }
       }
     },
-    closeBundle: {
-      sequential: true,
-      async handler() {
-        if (this.environment.config.consumer === "server" && serverOutDir && qwikRouterPlugin?.api && qwikVitePlugin?.api) {
-          const staticPaths = opts.staticPaths || [];
-          const routes = qwikRouterPlugin.api.getRoutes();
-          const basePathname = qwikRouterPlugin.api.getBasePathname();
-          const clientOutDir = qwikVitePlugin.api.getClientOutDir();
-          const clientPublicOutDir = qwikVitePlugin.api.getClientPublicOutDir();
-          const assetsDir = qwikVitePlugin.api.getAssetsDir();
-          if (opts.ssg !== null && clientOutDir && clientPublicOutDir) {
-            const runSsgPath = join(serverOutDir, "run-ssg.js");
-            const { spawn } = await import('node:child_process');
-            const ssgExitCode = await new Promise((resolve2, reject) => {
-              const child = spawn(process.execPath, [
-                runSsgPath
-              ], {
-                stdio: [
-                  "ignore",
-                  "inherit",
-                  "inherit"
-                ],
-                env: {
-                  ...process.env,
-                  NODE_ENV: process.env.NODE_ENV || "production"
-                }
-              });
-              child.on("close", resolve2);
-              child.on("error", reject);
-            });
-            if (ssgExitCode !== 0) {
-              const err = new Error(`Error while running SSG from "${opts.name}" adapter. At least one path failed to render.`);
-              err.stack = void 0;
-              this.error(err);
-            }
-            const fs = await import('node:fs');
-            const staticPathsFile = join(clientPublicOutDir, "_static-paths.json");
-            try {
-              const content = await fs.promises.readFile(staticPathsFile, "utf-8");
-              staticPaths.push(...JSON.parse(content));
-              await fs.promises.unlink(staticPathsFile);
-            } catch {
+    // Build the deployed server (`ssr`) and the separate `ssg` graph (run-ssg) — two graphs, so
+    // prerendered route code never reaches the `ssr` bundle — then render the pages and post-build.
+    // (The client builds in its own `vite build`.)
+    async buildApp(builder) {
+      buildAppRan = true;
+      const ssr = builder.environments.ssr;
+      if (ssr) {
+        await builder.build(ssr);
+      }
+      const serverOutDir = ssr?.config.build.outDir;
+      if (!serverOutDir || !qwikRouterPlugin?.api || !qwikVitePlugin?.api) {
+        return;
+      }
+      const log = builder.config.logger;
+      const staticPaths = opts.staticPaths || [];
+      const routes = qwikRouterPlugin.api.getRoutes();
+      const basePathname = qwikRouterPlugin.api.getBasePathname();
+      const clientOutDir = qwikVitePlugin.api.getClientOutDir();
+      const clientPublicOutDir = qwikVitePlugin.api.getClientPublicOutDir();
+      const ssgEnv = builder.environments.ssg;
+      const ssgOutDir = ssgOutDirFor(builder.config.root);
+      if (ssgEnv && clientOutDir && clientPublicOutDir) {
+        await builder.build(ssgEnv);
+        const runSsgPath = join(ssgOutDir, "run-ssg.js");
+        const ssgExitCode = await new Promise((res, reject) => {
+          const child = spawn(process.execPath, [
+            runSsgPath
+          ], {
+            stdio: [
+              "ignore",
+              "inherit",
+              "inherit"
+            ],
+            env: {
+              ...process.env,
+              NODE_ENV: process.env.NODE_ENV || "production"
             }
+          });
+          child.on("close", res);
+          child.on("error", reject);
+        });
+        if (ssgExitCode !== 0) {
+          throw new Error(`Error while running SSG from "${opts.name}" adapter. At least one path failed to render.`);
+        }
+        const staticPathsFile = join(clientPublicOutDir, "_static-paths.json");
+        try {
+          staticPaths.push(...JSON.parse(await readFile(staticPathsFile, "utf-8")));
+          await unlink(staticPathsFile);
+        } catch {
+        }
+        if (process.env.QWIK_ROUTER_KEEP_SSG_BUILD) {
+          log.warn(`SSG build kept at ${ssgOutDir}`);
+        } else {
+          await rm(ssgOutDir, {
+            recursive: true,
+            force: true
+          });
+        }
+      }
+      await postBuild(clientPublicOutDir, serverOutDir, basePathname, staticPaths, !!opts.cleanStaticGenerated);
+      if (typeof opts.generate === "function") {
+        await opts.generate({
+          outputEntries,
+          serverOutDir,
+          clientOutDir,
+          clientPublicOutDir,
+          basePathname,
+          routes,
+          warn: (message) => log.warn(message),
+          error: (message) => {
+            throw new Error(message);
           }
-          await postBuild(clientPublicOutDir, serverOutDir, assetsDir ? join(basePathname, assetsDir) : basePathname, staticPaths, !!opts.cleanStaticGenerated);
-          if (typeof opts.generate === "function") {
-            await opts.generate({
-              outputEntries,
-              serverOutDir,
-              clientOutDir,
-              clientPublicOutDir,
-              basePathname,
-              routes,
-              assetsDir,
-              warn: (message) => this.warn(message),
-              error: (message) => this.error(message)
-            });
-          }
-          this.warn(`
+        });
+      }
+      log.warn(`
 ==============================================
 Note: Make sure that you are serving the built files with proper cache headers.
 See https://qwik.dev/docs/deployments/#cache-headers for more information.
 ==============================================`);
-        }
-      }
     }
   };
   return [
-    ssgWorkerImportPlugin(),
     plugin
   ];
 }

package/lib/chunks/dev-preloaded-route-loader.mjs

@@ -0,0 +1,3 @@
+const devPreloadedRouteLoaders = globalThis[/* @__PURE__ */ Symbol.for("devPreloadedRouteLoaders")] ??= /* @__PURE__ */ new WeakMap();
+
+export { devPreloadedRouteLoaders as d };

package/lib/chunks/format.mjs

@@ -0,0 +1,31 @@
+function toTitleCase(str) {
+  return str.replace(/\w\S*/g, (txt) => {
+    return txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase();
+  });
+}
+function addError(ctx, e) {
+  ctx.diagnostics.push({
+    type: "error",
+    message: e ? String(e.stack || e) : "Error"
+  });
+}
+function addWarning(ctx, message) {
+  ctx.diagnostics.push({
+    type: "warn",
+    message: String(message)
+  });
+}
+function msToString(ms) {
+  if (ms < 1) {
+    return ms.toFixed(2) + " ms";
+  }
+  if (ms < 1e3) {
+    return ms.toFixed(1) + " ms";
+  }
+  if (ms < 6e4) {
+    return (ms / 1e3).toFixed(1) + " s";
+  }
+  return (ms / 6e4).toFixed(1) + " m";
+}
+
+export { addError as a, addWarning as b, msToString as m, toTitleCase as t };

package/lib/chunks/fs.mjs

@@ -1,5 +1,6 @@
 import { normalize, basename, dirname, relative } from 'node:path';
-import { t as toTitleCase, n as normalizePathname } from './pathname.mjs';
+import { t as toTitleCase } from './format.mjs';
+import { n as normalizePathname, e as ensureSlash } from './pathname.mjs';
 
 function parseRouteIndexName(extlessName) {
   let layoutName = "";
@@ -56,11 +57,8 @@ function normalizePath(path) {
 function getMenuPathname(opts, filePath) {
   let pathname = normalizePath(relative(opts.routesDir, filePath));
   pathname = `/` + normalizePath(dirname(pathname));
-  let result = normalizePathname(pathname, opts.basePathname);
-  if (!result.endsWith("/")) {
-    result += "/";
-  }
-  return result;
+  const result = normalizePathname(pathname, opts.basePathname);
+  return ensureSlash(result);
 }
 function createFileId(routesDir, fsPath, explicitFileType) {
   const ids = [];
@@ -125,8 +123,12 @@ function isServiceWorkerName(extlessName) {
 function isEntryName(extlessName) {
   return extlessName === "entry";
 }
+function errorBoundaryName(extlessName) {
+  const match = /^(error|404)(?:|!|@.+)$/.exec(extlessName);
+  return match ? match[1] : void 0;
+}
 function isErrorName(extlessName) {
-  return extlessName === "error" || extlessName === "404";
+  return errorBoundaryName(extlessName) !== void 0;
 }
 function isGroupedLayoutName(dirName, warn = true) {
   return dirName.startsWith("(") && dirName.endsWith(")");
@@ -141,4 +143,4 @@ function getPathnameFromDirPath(opts, dirPath) {
   return pathname;
 }
 
-export { isErrorName as a, isLayoutModule as b, isEntryName as c, isMenuFileName as d, isServiceWorkerName as e, isPageModuleExt as f, getExtension as g, isModuleExt as h, isIndexModule as i, isMarkdownExt as j, normalizePath as k, getPathnameFromDirPath as l, getMenuPathname as m, normalizePathSlash as n, createFileId as o, parseRouteIndexName as p, isPluginModule as q, removeExtension as r, isPageExt as s };
+export { isErrorName as a, isPageModuleExt as b, isModuleExt as c, isMarkdownExt as d, isLayoutModule as e, isEntryName as f, getExtension as g, isMenuFileName as h, isIndexModule as i, isServiceWorkerName as j, normalizePath as k, getPathnameFromDirPath as l, getMenuPathname as m, normalizePathSlash as n, createFileId as o, parseRouteIndexName as p, errorBoundaryName as q, removeExtension as r, isPluginModule as s, isPageExt as t };