@qwik.dev/router 2.0.0-beta.2 → 2.0.0-beta.21

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

@@ -1,16 +1,15 @@
-// packages/qwik-router/src/adapters/shared/vite/index.ts
-import fs2 from "node:fs";
-import { basename, dirname, join as join2, resolve } from "node:path";
+import { join, resolve, dirname, basename } from 'node:path';
+import fs from 'node:fs';
+import { g as getErrorHtml } from '../../../chunks/error-handler.mjs';
 
-// packages/qwik-router/src/adapters/shared/vite/post-build.ts
-import { getErrorHtml } from "../../../middleware/request-handler/index.mjs";
-import fs from "node:fs";
-import { join } from "node:path";
-async function postBuild(clientOutDir, pathName, userStaticPaths, format, cleanStatic) {
+async function postBuild(clientOutDir, serverOutDir, pathName, userStaticPaths, cleanStatic) {
   if (pathName && !pathName.endsWith("/")) {
     pathName += "/";
   }
-  const ignorePathnames = /* @__PURE__ */ new Set([pathName + "build/", pathName + "assets/"]);
+  const ignorePathnames = /* @__PURE__ */ new Set([
+    pathName + "/" + (globalThis.__QWIK_BUILD_DIR__ || "build") + "/",
+    pathName + "/" + (globalThis.__QWIK_ASSETS_DIR__ || "assets") + "/"
+  ]);
   const staticPaths = new Set(userStaticPaths.map(normalizeTrailingSlash));
   const notFounds = [];
   const loadItem = async (fsDir, fsName, pathname) => {
@@ -44,12 +43,9 @@ async function postBuild(clientOutDir, pathName, userStaticPaths, format, cleanS
   if (fs.existsSync(clientOutDir)) {
     await loadDir(clientOutDir, pathName);
   }
-  const notFoundPathsCode = createNotFoundPathsModule(pathName, notFounds, format);
-  const staticPathsCode = createStaticPathsModule(pathName, staticPaths, format);
-  return {
-    notFoundPathsCode,
-    staticPathsCode
-  };
+  const notFoundPathsCode = createNotFoundPathsCode(pathName, notFounds);
+  const staticPathsCode = createStaticPathsCode(staticPaths);
+  await injectStatics(staticPathsCode, notFoundPathsCode, serverOutDir);
 }
 function normalizeTrailingSlash(pathname) {
   if (!pathname.endsWith("/")) {
@@ -57,7 +53,7 @@ function normalizeTrailingSlash(pathname) {
   }
   return pathname;
 }
-function createNotFoundPathsModule(basePathname, notFounds, format) {
+function createNotFoundPathsCode(basePathname, notFounds) {
   notFounds.sort((a, b) => {
     if (a[0].length > b[0].length) {
       return -1;
@@ -77,66 +73,44 @@ function createNotFoundPathsModule(basePathname, notFounds, format) {
     const html = getErrorHtml(404, "Resource Not Found");
     notFounds.push([basePathname, html]);
   }
-  const c = [];
-  c.push(`const notFounds = ${JSON.stringify(notFounds, null, 2)};`);
-  c.push(`function getNotFound(p) {`);
-  c.push(`  for (const r of notFounds) {`);
-  c.push(`    if (p.startsWith(r[0])) {`);
-  c.push(`      return r[1];`);
-  c.push(`    }`);
-  c.push(`  }`);
-  c.push(`  return "Resource Not Found";`);
-  c.push(`}`);
-  if (format === "cjs") {
-    c.push("exports.getNotFound = getNotFound;");
-  } else {
-    c.push("export { getNotFound };");
-  }
-  return c.join("\n");
+  return JSON.stringify(notFounds, null, 2).slice(1, -1);
 }
-function createStaticPathsModule(basePathname, staticPaths, format) {
-  const assetsPath = basePathname + "assets/";
-  const baseBuildPath = basePathname + "build/";
-  const c = [];
-  c.push(
-    `const staticPaths = new Set(${JSON.stringify(
-      Array.from(new Set(staticPaths)).sort()
-    )});`
-  );
-  c.push(`function isStaticPath(method, url) {`);
-  c.push(`  if (method.toUpperCase() !== 'GET') {`);
-  c.push(`    return false;`);
-  c.push(`  }`);
-  c.push(`  const p = url.pathname;`);
-  c.push(`  if (p.startsWith(${JSON.stringify(baseBuildPath)})) {`);
-  c.push(`    return true;`);
-  c.push(`  }`);
-  c.push(`  if (p.startsWith(${JSON.stringify(assetsPath)})) {`);
-  c.push(`    return true;`);
-  c.push(`  }`);
-  c.push(`  if (staticPaths.has(p)) {`);
-  c.push(`    return true;`);
-  c.push(`  }`);
-  c.push(`  if (p.endsWith('/q-data.json')) {`);
-  c.push(`    const pWithoutQdata = p.replace(/\\/q-data.json$/, '');`);
-  c.push(`    if (staticPaths.has(pWithoutQdata + '/')) {`);
-  c.push(`      return true;`);
-  c.push(`    }`);
-  c.push(`    if (staticPaths.has(pWithoutQdata)) {`);
-  c.push(`      return true;`);
-  c.push(`    }`);
-  c.push(`  }`);
-  c.push(`  return false;`);
-  c.push(`}`);
-  if (format === "cjs") {
-    c.push("exports.isStaticPath = isStaticPath;");
-  } else {
-    c.push("export { isStaticPath };");
-  }
-  return c.join("\n");
+function createStaticPathsCode(staticPaths) {
+  return JSON.stringify(Array.from(new Set(staticPaths)).sort()).slice(1, -1);
 }
+const injectStatics = async (staticPathsCode, notFoundPathsCode, 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) => {
+        replaced = true;
+        return type === "STATIC_PATHS" ? staticPathsCode : notFoundPathsCode;
+      }
+    );
+    if (replaced) {
+      await fs.promises.writeFile(path, newCode);
+    }
+  };
+  const walk = async (dir) => {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        await walk(join(dir, entry.name));
+      } else if (entry.name.endsWith("js")) {
+        const p = doReplace(join(dir, entry.name)).finally(() => {
+          promises.delete(p);
+        });
+        promises.add(p);
+      }
+    }
+  };
+  await walk(outDir);
+  await Promise.all(promises);
+};
 
-// packages/qwik-router/src/adapters/shared/vite/index.ts
 function viteAdapter(opts) {
   let qwikRouterPlugin = null;
   let qwikVitePlugin = null;
@@ -144,10 +118,10 @@ function viteAdapter(opts) {
   let renderModulePath = null;
   let qwikRouterConfigModulePath = null;
   let isSsrBuild = false;
-  let format = "esm";
+  let viteCommand;
   const outputEntries = [];
   const plugin = {
-    name: `vite-plugin-qwik-router-${opts.name}`,
+    name: `vite-plugin-qwik-router-ssg-${opts.name}`,
     enforce: "post",
     apply: "build",
     config(config) {
@@ -161,8 +135,8 @@ function viteAdapter(opts) {
       return config;
     },
     configResolved(config) {
-      var _a, _b, _c, _d;
       isSsrBuild = !!config.build.ssr;
+      viteCommand = config.command;
       if (isSsrBuild) {
         qwikRouterPlugin = config.plugins.find(
           (p) => p.name === "vite-plugin-qwik-router"
@@ -177,18 +151,32 @@ function viteAdapter(opts) {
           throw new Error("Missing vite-plugin-qwik");
         }
         serverOutDir = config.build.outDir;
-        if (((_a = config.build) == null ? void 0 : _a.ssr) !== true) {
+        if (config.build?.ssr !== true) {
           throw new Error(
             `"build.ssr" must be set to "true" in order to use the "${opts.name}" adapter.`
           );
         }
-        if (!((_c = (_b = config.build) == null ? void 0 : _b.rollupOptions) == null ? void 0 : _c.input)) {
+        if (!config.build?.rollupOptions?.input) {
           throw new Error(
             `"build.rollupOptions.input" must be set in order to use the "${opts.name}" adapter.`
           );
         }
-        if (((_d = config.ssr) == null ? void 0 : _d.format) === "cjs") {
-          format = "cjs";
+      }
+    },
+    buildStart() {
+      if (isSsrBuild && opts.ssg !== null) {
+        const { srcDir } = qwikVitePlugin.api.getOptions();
+        if (viteCommand === "build" && serverOutDir && srcDir) {
+          this.emitFile({
+            id: "@qwik-router-config",
+            type: "chunk",
+            fileName: "@qwik-router-config.js"
+          });
+          this.emitFile({
+            id: `${srcDir}/entry.ssr`,
+            type: "chunk",
+            fileName: "entry.ssr.js"
+          });
         }
       }
     },
@@ -200,29 +188,18 @@ function viteAdapter(opts) {
           if (chunk.type === "chunk" && chunk.isEntry) {
             outputEntries.push(fileName);
             if (chunk.name === "entry.ssr") {
-              renderModulePath = join2(serverOutDir, fileName);
+              renderModulePath = join(serverOutDir, fileName);
             } else if (chunk.name === "@qwik-router-config") {
-              qwikRouterConfigModulePath = join2(serverOutDir, fileName);
+              qwikRouterConfigModulePath = join(serverOutDir, fileName);
             }
           }
         }
-        if (!renderModulePath) {
-          throw new Error(
-            'Unable to find "entry.ssr" entry point. Did you forget to add it to "build.rollupOptions.input"?'
-          );
-        }
-        if (!qwikRouterConfigModulePath) {
-          throw new Error(
-            'Unable to find "@qwik-router-config" entry point. Did you forget to add it to "build.rollupOptions.input"?'
-          );
-        }
       }
     },
     closeBundle: {
       sequential: true,
       async handler() {
-        var _a;
-        if (isSsrBuild && opts.ssg !== null && serverOutDir && (qwikRouterPlugin == null ? void 0 : qwikRouterPlugin.api) && (qwikVitePlugin == null ? void 0 : qwikVitePlugin.api)) {
+        if (isSsrBuild && serverOutDir && qwikRouterPlugin?.api && qwikVitePlugin?.api) {
           const staticPaths = opts.staticPaths || [];
           const routes = qwikRouterPlugin.api.getRoutes();
           const basePathname = qwikRouterPlugin.api.getBasePathname();
@@ -230,8 +207,8 @@ function viteAdapter(opts) {
           const clientPublicOutDir = qwikVitePlugin.api.getClientPublicOutDir();
           const assetsDir = qwikVitePlugin.api.getAssetsDir();
           const rootDir = qwikVitePlugin.api.getRootDir() ?? void 0;
-          if (renderModulePath && qwikRouterConfigModulePath && clientOutDir && clientPublicOutDir) {
-            let ssgOrigin = ((_a = opts.ssg) == null ? void 0 : _a.origin) ?? opts.origin;
+          if (opts.ssg !== null && renderModulePath && qwikRouterConfigModulePath && clientOutDir && clientPublicOutDir) {
+            let ssgOrigin = opts.ssg?.origin ?? opts.origin;
             if (!ssgOrigin) {
               ssgOrigin = `https://yoursite.qwik.dev`;
             }
@@ -243,13 +220,13 @@ function viteAdapter(opts) {
             }
             try {
               ssgOrigin = new URL(ssgOrigin).origin;
-            } catch (e) {
+            } catch {
               this.warn(
                 `Invalid "origin" option: "${ssgOrigin}". Using default origin: "https://yoursite.qwik.dev"`
               );
               ssgOrigin = `https://yoursite.qwik.dev`;
             }
-            const staticGenerate = await import("../../../static/index.mjs");
+            const staticGenerate = await import('../../../ssg/index.mjs');
             const generateOpts = {
               maxWorkers: opts.maxWorkers,
               basePathname,
@@ -269,40 +246,41 @@ function viteAdapter(opts) {
               this.error(err);
             }
             staticPaths.push(...staticGenerateResult.staticPaths);
-            const { staticPathsCode, notFoundPathsCode } = await postBuild(
+          }
+          await postBuild(
+            clientPublicOutDir,
+            serverOutDir,
+            assetsDir ? join(basePathname, assetsDir) : basePathname,
+            staticPaths,
+            !!opts.cleanStaticGenerated
+          );
+          if (typeof opts.generate === "function") {
+            await opts.generate({
+              outputEntries,
+              serverOutDir,
+              clientOutDir,
               clientPublicOutDir,
-              assetsDir ? join2(basePathname, assetsDir) : basePathname,
-              staticPaths,
-              format,
-              !!opts.cleanStaticGenerated
-            );
-            await Promise.all([
-              fs2.promises.writeFile(join2(serverOutDir, RESOLVED_STATIC_PATHS_ID), staticPathsCode),
-              fs2.promises.writeFile(
-                join2(serverOutDir, RESOLVED_NOT_FOUND_PATHS_ID),
-                notFoundPathsCode
-              )
-            ]);
-            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(
-              `
+              basePathname,
+              routes,
+              assetsDir,
+              warn: (message) => this.warn(message),
+              error: (message) => this.error(message)
+            });
+          }
+          this.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.
 ==============================================`
-            );
+          );
+          if (opts.ssg !== null) {
+            setTimeout(() => {
+              console.warn(
+                "SSG seems to be hanging after completion, forcing process to exit. Everything is likely fine."
+              );
+              process.exit(0);
+            }, 5e3).unref();
           }
         }
       }
@@ -324,15 +302,5 @@ function getParentDir(startDir, dirName) {
   }
   throw new Error(`Unable to find "${dirName}" directory from "${startDir}"`);
 }
-var STATIC_PATHS_ID = "@qwik-router-static-paths";
-var RESOLVED_STATIC_PATHS_ID = `${STATIC_PATHS_ID}.js`;
-var NOT_FOUND_PATHS_ID = "@qwik-router-not-found-paths";
-var RESOLVED_NOT_FOUND_PATHS_ID = `${NOT_FOUND_PATHS_ID}.js`;
-export {
-  NOT_FOUND_PATHS_ID,
-  RESOLVED_NOT_FOUND_PATHS_ID,
-  RESOLVED_STATIC_PATHS_ID,
-  STATIC_PATHS_ID,
-  getParentDir,
-  viteAdapter
-};
+
+export { getParentDir, viteAdapter };

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

@@ -0,0 +1,13 @@
+import type { SsgRenderOptions } from '../../../ssg';
+
+/** @public */
+export declare function ssgAdapter(opts: SsgAdapterOptions): any;
+
+/** @public */
+export declare interface SsgAdapterOptions extends Omit<SsgRenderOptions, 'outDir'> {
+}
+
+/** @public @deprecated Use `ssgAdapter` instead. */
+export declare const staticAdapter: typeof ssgAdapter;
+
+export { }

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

@@ -0,0 +1,18 @@
+import { viteAdapter } from '../../shared/vite/index.mjs';
+import 'node:path';
+import 'node:fs';
+import '../../../chunks/error-handler.mjs';
+
+function ssgAdapter(opts) {
+  return viteAdapter({
+    name: "static-site-generation",
+    origin: opts.origin,
+    ssg: {
+      include: ["/*"],
+      ...opts
+    }
+  });
+}
+const staticAdapter = ssgAdapter;
+
+export { ssgAdapter, staticAdapter };

package/lib/adapters/vercel-edge/vite/index.d.ts

@@ -1,7 +1,7 @@
 import { ServerAdapterOptions } from '../../shared/vite';
-import type { StaticGenerateRenderOptions } from '@qwik.dev/router/static';
+import type { SsgRenderOptions } from 'packages/qwik-router/src/ssg';
 
-export { StaticGenerateRenderOptions }
+export { SsgRenderOptions }
 
 /** @public */
 export declare function vercelEdgeAdapter(opts?: VercelEdgeAdapterOptions): any;
@@ -35,7 +35,7 @@ export declare interface VercelEdgeAdapterOptions extends ServerAdapterOptions {
      */
     staticPaths?: string[];
     /**
-     * Define the `target` property in the `ssr` object in the `vite.config.mts` file.
+     * Define the `target` property in the `ssr` object in the `vite.config.ts` file.
      *
      * Defaults to `webworker`.
      */

package/lib/adapters/vercel-edge/vite/index.mjs

@@ -1,18 +1,17 @@
-// packages/qwik-router/src/adapters/vercel-edge/vite/index.ts
-import fs from "node:fs";
-import { dirname, join } from "node:path";
-import { getParentDir, viteAdapter } from "../../shared/vite/index.mjs";
+import fs from 'node:fs';
+import { join, dirname } from 'node:path';
+import { viteAdapter, getParentDir } from '../../shared/vite/index.mjs';
+import '../../../chunks/error-handler.mjs';
+
 function vercelEdgeAdapter(opts = {}) {
-  var _a;
   return viteAdapter({
     name: "vercel-edge",
-    origin: ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.VERCEL_URL) || "https://yoursitename.vercel.app",
+    origin: process?.env?.VERCEL_URL || "https://yoursitename.vercel.app",
     ssg: opts.ssg,
     staticPaths: opts.staticPaths,
     cleanStaticGenerated: true,
     config(config) {
-      var _a2;
-      const outDir = ((_a2 = config.build) == null ? void 0 : _a2.outDir) || join(".vercel", "output", "functions", "_qwik-router.func");
+      const outDir = config.build?.outDir || join(".vercel", "output", "functions", "_qwik-router.func");
       return {
         resolve: {
           conditions: opts.target === "node" ? ["node", "import", "module", "browser", "default"] : ["edge-light", "webworker", "worker", "browser", "module", "main"]
@@ -78,6 +77,5 @@ function vercelEdgeAdapter(opts = {}) {
     }
   });
 }
-export {
-  vercelEdgeAdapter
-};
+
+export { vercelEdgeAdapter };

package/lib/chunks/error-handler.mjs

@@ -0,0 +1,57 @@
+function getErrorHtml(status, e) {
+  let message = "Server Error";
+  if (e != null) {
+    if (typeof e.message === "string") {
+      message = e.message;
+    } else {
+      message = String(e);
+    }
+  }
+  return `<html>` + minimalHtmlResponse(status, message) + `</html>`;
+}
+function minimalHtmlResponse(status, message) {
+  if (typeof status !== "number") {
+    status = 500;
+  }
+  if (typeof message === "string") {
+    message = escapeHtml(message);
+  } else {
+    message = "";
+  }
+  const width = typeof message === "string" ? "600px" : "300px";
+  const color = status >= 500 ? COLOR_500 : COLOR_400;
+  return `
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="Status" content="${status}">
+  <title>${status} ${message}</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <style>
+    body { color: ${color}; background-color: #fafafa; padding: 30px; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Roboto, sans-serif; }
+    p { max-width: ${width}; margin: 60px auto 30px auto; background: white; border-radius: 4px; box-shadow: 0px 0px 50px -20px ${color}; overflow: hidden; }
+    strong { display: inline-block; padding: 15px; background: ${color}; color: white; }
+    span { display: inline-block; padding: 15px; }
+  </style>
+</head>
+<body><p><strong>${status}</strong> <span>${message}</span></p></body>
+`;
+}
+const ESCAPE_HTML = /[&<>]/g;
+const escapeHtml = (s) => {
+  return s.replace(ESCAPE_HTML, (c) => {
+    switch (c) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      default:
+        return "";
+    }
+  });
+};
+const COLOR_400 = "#006ce9";
+const COLOR_500 = "#713fc2";
+
+export { getErrorHtml as g, minimalHtmlResponse as m };

package/lib/chunks/format-error.mjs

@@ -0,0 +1,137 @@
+import { l as normalizePath } from './fs.mjs';
+import fs from 'node:fs';
+
+const findLocation = (e) => {
+  const stack = e.stack;
+  if (typeof stack === "string") {
+    const lines = stack.split("\n").filter((l) => !l.includes("/node_modules/") && !l.includes("(node:"));
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].replace("file:///", "/");
+      if (/^\s+at/.test(line)) {
+        const start = line.indexOf("/");
+        const end = line.lastIndexOf(")", start);
+        if (start > 0) {
+          const path = line.slice(start, end);
+          const parts = path.split(":");
+          const nu0 = safeParseInt(parts[parts.length - 1]);
+          const nu1 = safeParseInt(parts[parts.length - 2]);
+          if (typeof nu0 === "number" && typeof nu1 === "number") {
+            parts.length -= 2;
+            return {
+              file: parts.join(":"),
+              line: nu1,
+              column: nu0
+            };
+          } else if (typeof nu0 === "number") {
+            parts.length -= 1;
+            return {
+              file: parts.join(":"),
+              line: nu0,
+              column: void 0
+            };
+          } else {
+            return {
+              file: parts.join(":"),
+              line: void 0,
+              column: void 0
+            };
+          }
+        }
+      }
+    }
+  }
+  return void 0;
+};
+const safeParseInt = (nu) => {
+  try {
+    return parseInt(nu, 10);
+  } catch {
+    return void 0;
+  }
+};
+const splitRE = /\r?\n/;
+const range = 2;
+function posToNumber(source, pos) {
+  if (typeof pos === "number") {
+    return pos;
+  }
+  if (pos.lo != null) {
+    return pos.lo;
+  }
+  const lines = source.split(splitRE);
+  const { line, column } = pos;
+  let start = 0;
+  for (let i = 0; i < line - 1 && i < lines.length; i++) {
+    start += lines[i].length + 1;
+  }
+  return start + column;
+}
+function generateCodeFrame(source, start = 0, end) {
+  start = posToNumber(source, start);
+  end = end || start;
+  const lines = source.split(splitRE);
+  let count = 0;
+  const res = [];
+  for (let i = 0; i < lines.length; i++) {
+    count += lines[i].length + 1;
+    if (count >= start) {
+      for (let j = i - range; j <= i + range || end > count; j++) {
+        if (j < 0 || j >= lines.length) {
+          continue;
+        }
+        const line = j + 1;
+        res.push(`${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`);
+        const lineLength = lines[j].length;
+        if (j === i) {
+          const pad = Math.max(start - (count - lineLength) + 1, 0);
+          const length = Math.max(1, end > count ? lineLength - pad : end - start);
+          res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
+        } else if (j > i) {
+          if (end > count) {
+            const length = Math.max(Math.min(end - count, lineLength), 1);
+            res.push(`   |  ` + "^".repeat(length));
+          }
+          count += lineLength + 1;
+        }
+      }
+      break;
+    }
+  }
+  return res.join("\n");
+}
+function parseId(originalId) {
+  const [pathId, query] = originalId.split("?");
+  const queryStr = query || "";
+  return {
+    originalId,
+    pathId,
+    query: queryStr ? `?${query}` : "",
+    params: new URLSearchParams(queryStr)
+  };
+}
+
+function formatError(e) {
+  if (e instanceof Error) {
+    const err = e;
+    let loc = err.loc;
+    if (!err.frame && !err.plugin) {
+      if (!loc) {
+        loc = findLocation(err);
+      }
+      if (loc) {
+        err.loc = loc;
+        if (loc.file) {
+          err.id = normalizePath(err.loc.file);
+          try {
+            const code = fs.readFileSync(err.loc.file, "utf-8");
+            err.frame = generateCodeFrame(code, err.loc);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  return e;
+}
+
+export { formatError as f, parseId as p };