nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-122334-09c1a7a8

package/dist/_build/info.mjs

@@ -1,1002 +0,0 @@
-import { r as replace$1 } from '../_chunks/_deps/@rollup/plugin-replace.mjs';
-import { defineEnv } from 'unenv';
-import { runtimeDir, runtimeDependencies } from 'nitro/runtime/meta';
-import { j as join, r as resolve, d as dirname, e as extname, a as relative } from '../_chunks/_deps/pathe.mjs';
-import { hash } from 'ohash';
-import { defu } from 'defu';
-import { u as unplugin } from '../_chunks/_deps/unimport.mjs';
-import { r as rollup } from '../_chunks/_deps/unwasm.mjs';
-import { connectors } from 'db0';
-import { camelCase } from 'scule';
-import { readFile, mkdir, unlink, symlink } from 'node:fs/promises';
-import { transform } from 'esbuild';
-import { promises } from 'node:fs';
-import { c as createEtag } from '../_chunks/_deps/etag.mjs';
-import { g as glob } from '../_chunks/_deps/tinyglobby.mjs';
-import { m as mime } from '../_chunks/_deps/mime.mjs';
-import { withTrailingSlash } from 'ufo';
-import { normalizeKey, builtinDrivers } from 'unstorage';
-import { b as genImport, a as genSafeVariableName } from '../_chunks/_deps/knitwork.mjs';
-import { rollupNodeFileTrace } from 'nf3';
-import { hasTemplateSyntax, compileTemplateToString, RENDER_CONTEXT_KEYS } from 'rendu';
-import { version } from 'nitro/meta';
-import { p as presetsWithConfig } from '../_chunks/_presets/_types.mjs';
-import { w as writeFile } from './prepare.mjs';
-import { dirname as dirname$1 } from 'node:path';
-
-const NO_REPLACE_RE = /ROLLUP_NO_REPLACE|\\0raw:/;
-function replace(options) {
-  const _plugin = replace$1(options);
-  return {
-    ..._plugin,
-    // https://github.com/rollup/plugins/blob/master/packages/replace/src/index.js#L94
-    renderChunk(code, chunk, options2) {
-      if (!NO_REPLACE_RE.test(code)) {
-        return _plugin.renderChunk.call(this, code, chunk, options2);
-      }
-    }
-  };
-}
-
-function baseBuildConfig(nitro) {
-  const buildServerDir = join(nitro.options.buildDir, "dist/server");
-  const presetsDir = resolve(runtimeDir, "../presets");
-  const extensions = [".ts", ".mjs", ".js", ".json", ".node", ".tsx", ".jsx"];
-  const isNodeless = nitro.options.node === false;
-  let NODE_ENV = nitro.options.dev ? "development" : "production";
-  if (nitro.options.preset === "nitro-prerender") {
-    NODE_ENV = "prerender";
-  }
-  const buildEnvVars = {
-    NODE_ENV,
-    prerender: nitro.options.preset === "nitro-prerender",
-    server: true,
-    client: false,
-    dev: String(nitro.options.dev),
-    DEBUG: nitro.options.dev
-  };
-  const staticFlags = {
-    dev: nitro.options.dev,
-    preset: nitro.options.preset,
-    prerender: nitro.options.preset === "nitro-prerender",
-    server: true,
-    client: false,
-    nitro: true,
-    baseURL: nitro.options.baseURL,
-    // @ts-expect-error
-    "versions.nitro": "",
-    "versions?.nitro": "",
-    // Internal
-    _asyncContext: nitro.options.experimental.asyncContext,
-    _websocket: nitro.options.experimental.websocket,
-    _tasks: nitro.options.experimental.tasks
-  };
-  const replaceDelimiters = [
-    String.raw`\b`,
-    String.raw`(?![\w.$])`
-  ];
-  const replacements = {
-    "typeof window": '"undefined"',
-    _import_meta_url_: "import.meta.url",
-    "globalThis.process.": "process.",
-    "process.env.RUNTIME_CONFIG": () => JSON.stringify(nitro.options.runtimeConfig, null, 2),
-    ...Object.fromEntries(
-      Object.entries(buildEnvVars).map(([key, val]) => [
-        `process.env.${key}`,
-        JSON.stringify(val)
-      ])
-    ),
-    ...Object.fromEntries(
-      Object.entries(buildEnvVars).map(([key, val]) => [
-        `import.meta.env.${key}`,
-        JSON.stringify(val)
-      ])
-    ),
-    ...Object.fromEntries(
-      Object.entries(staticFlags).map(([key, val]) => [
-        `process.${key}`,
-        JSON.stringify(val)
-      ])
-    ),
-    ...Object.fromEntries(
-      Object.entries(staticFlags).map(([key, val]) => [
-        `import.meta.${key}`,
-        JSON.stringify(val)
-      ])
-    ),
-    ...nitro.options.replace
-  };
-  const { env } = defineEnv({
-    nodeCompat: isNodeless,
-    npmShims: true,
-    resolve: true,
-    presets: nitro.options.unenv,
-    overrides: {
-      alias: nitro.options.alias
-    }
-  });
-  const aliases = resolveAliases({
-    "#internal/nitro": runtimeDir,
-    "nitro/runtime": runtimeDir,
-    "nitropack/runtime": runtimeDir,
-    // Backwards compatibility
-    ...env.alias
-  });
-  return {
-    buildServerDir,
-    presetsDir,
-    extensions,
-    isNodeless,
-    buildEnvVars,
-    staticFlags,
-    replaceDelimiters,
-    replacements,
-    env,
-    aliases
-  };
-}
-function resolveAliases(_aliases) {
-  const aliases = Object.fromEntries(
-    Object.entries(_aliases).sort(
-      ([a], [b]) => b.split("/").length - a.split("/").length || b.length - a.length
-    )
-  );
-  for (const key in aliases) {
-    for (const alias in aliases) {
-      if (!["~", "@", "#"].includes(alias[0])) {
-        continue;
-      }
-      if (alias === "@" && !aliases[key].startsWith("@/")) {
-        continue;
-      }
-      if (aliases[key].startsWith(alias)) {
-        aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
-      }
-    }
-  }
-  return aliases;
-}
-
-const PREFIX = "\0virtual:";
-function virtual(modules, cache = {}) {
-  const _modules = /* @__PURE__ */ new Map();
-  for (const [id, mod] of Object.entries(modules)) {
-    cache[id] = mod;
-    _modules.set(id, mod);
-    _modules.set(resolve(id), mod);
-  }
-  return {
-    name: "virtual",
-    resolveId(id, importer) {
-      if (id in modules) {
-        return PREFIX + id;
-      }
-      if (importer) {
-        const importerNoPrefix = importer.startsWith(PREFIX) ? importer.slice(PREFIX.length) : importer;
-        const resolved = resolve(dirname(importerNoPrefix), id);
-        if (_modules.has(resolved)) {
-          return PREFIX + resolved;
-        }
-      }
-      return null;
-    },
-    async load(id) {
-      if (!id.startsWith(PREFIX)) {
-        return null;
-      }
-      const idNoPrefix = id.slice(PREFIX.length);
-      if (!_modules.has(idNoPrefix)) {
-        return null;
-      }
-      let m = _modules.get(idNoPrefix);
-      if (typeof m === "function") {
-        m = await m();
-      }
-      if (!m) {
-        return null;
-      }
-      cache[id.replace(PREFIX, "")] = m;
-      return {
-        code: m,
-        map: null
-      };
-    }
-  };
-}
-
-function database(nitro) {
-  if (!nitro.options.experimental.database) {
-    return virtual(
-      {
-        "#nitro-internal-virtual/database": () => {
-          return (
-            /* js */
-            `export const connectionConfigs = {};`
-          );
-        }
-      },
-      nitro.vfs
-    );
-  }
-  const dbConfigs = nitro.options.dev && nitro.options.devDatabase || nitro.options.database;
-  const connectorsNames = [
-    ...new Set(
-      Object.values(dbConfigs || {}).map((config) => config?.connector)
-    )
-  ].filter(Boolean);
-  for (const name of connectorsNames) {
-    if (!connectors[name]) {
-      throw new Error(`Database connector "${name}" is invalid.`);
-    }
-  }
-  return virtual(
-    {
-      "#nitro-internal-virtual/database": () => {
-        return `
-${connectorsNames.map(
-          (name) => `import ${camelCase(name)}Connector from "${connectors[name]}";`
-        ).join("\n")}
-
-export const connectionConfigs = {
-  ${Object.entries(dbConfigs || {}).map(
-          ([name, { connector, options }]) => `${name}: {
-          connector: ${camelCase(connector)}Connector,
-          options: ${JSON.stringify(options)}
-        }`
-        ).join(",\n")}
-};
-        `;
-      }
-    },
-    nitro.vfs
-  );
-}
-
-const RuntimeRouteRules = [
-  "headers",
-  "redirect",
-  "proxy",
-  "cache"
-];
-function routing(nitro) {
-  return virtual(
-    {
-      // --- routing (routes, routeRules and middleware) ---
-      "#nitro-internal-virtual/routing": () => {
-        const allHandlers = uniqueBy(
-          [
-            ...Object.values(nitro.routing.routes.routes).map((h) => h.data),
-            ...Object.values(nitro.routing.routedMiddleware.routes).map(
-              (h) => h.data
-            ),
-            ...nitro.routing.globalMiddleware
-          ],
-          "_importHash"
-        );
-        const h3Imports = [
-          allHandlers.some((h) => !h.lazy) && "toEventHandler",
-          nitro.options.serverEntry && "toMiddleware",
-          allHandlers.some((h) => h.lazy) && "defineLazyEventHandler"
-        ].filter(Boolean);
-        return (
-          /* js */
-          `
-import * as __routeRules__ from "nitro/runtime/internal/route-rules";
-${nitro.options.serverEntry ? `import __serverEntry__ from ${JSON.stringify(nitro.options.serverEntry)};` : ""}
-import {${h3Imports.join(", ")}} from "h3";
-
-export const findRouteRules = ${nitro.routing.routeRules.compileToString({ serialize: serializeRouteRule, matchAll: true })}
-
-${allHandlers.filter((h) => !h.lazy).map((h) => (
-            /* js */
-            `import ${h._importHash} from "${h.handler}";`
-          )).join("\n")}
-
-${allHandlers.filter((h) => h.lazy).map(
-            (h) => (
-              /* js */
-              `const ${h._importHash} = defineLazyEventHandler(() => import("${h.handler}"));`
-            )
-          ).join("\n")}
-
-export const findRoute = ${nitro.routing.routes.compileToString({ serialize: serializeHandler })}
-
-export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({ serialize: serializeHandler, matchAll: true })};
-
-export const globalMiddleware = [
-  ${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `toEventHandler(${h._importHash})`).join(",")}
-  ${nitro.options.serverEntry ? `,toMiddleware(__serverEntry__)` : ""}
-].filter(Boolean);
-  `
-        );
-      },
-      // --- routing-meta ---
-      "#nitro-internal-virtual/routing-meta": () => {
-        const routeHandlers = uniqueBy(
-          Object.values(nitro.routing.routes.routes).map((h) => h.data),
-          "_importHash"
-        );
-        return (
-          /* js */
-          `
-  ${routeHandlers.map(
-            (h) => (
-              /* js */
-              `import ${h._importHash}Meta from "${h.handler}?meta";`
-            )
-          ).join("\n")}
-export const handlersMeta = [
-  ${routeHandlers.map(
-            (h) => (
-              /* js */
-              `{ route: ${JSON.stringify(h.route)}, method: ${JSON.stringify(
-                h.method?.toLowerCase()
-              )}, meta: ${h._importHash}Meta }`
-            )
-          ).join(",\n")}
-  ];
-        `.trim()
-        );
-      }
-    },
-    nitro.vfs
-  );
-}
-function uniqueBy(arr, key) {
-  return [...new Map(arr.map((item) => [item[key], item])).values()];
-}
-function serializeHandler(h) {
-  return `{${[
-    `route:${JSON.stringify(h.route)}`,
-    h.method && `method:${JSON.stringify(h.method)}`,
-    h.meta && `meta:${JSON.stringify(h.meta)}`,
-    `handler:${h.lazy ? h._importHash : `toEventHandler(${h._importHash})`}`
-  ].filter(Boolean).join(",")}}`;
-}
-function serializeRouteRule(h) {
-  return `[${Object.entries(h).filter(([name, options]) => options !== void 0 && name[0] !== "_").map(([name, options]) => {
-    return `{${[
-      `name:${JSON.stringify(name)}`,
-      `route:${JSON.stringify(h._route)}`,
-      h._method && `method:${JSON.stringify(h._method)}`,
-      RuntimeRouteRules.includes(name) && `handler:__routeRules__.${name}`,
-      `options:${JSON.stringify(options)}`
-    ].filter(Boolean).join(",")}}`;
-  }).join(",")}]`;
-}
-
-const virtualPrefix = "\0nitro-handler-meta:";
-const esbuildLoaders = {
-  ".ts": "ts",
-  ".js": "js",
-  ".tsx": "tsx",
-  ".jsx": "jsx"
-};
-function routeMeta(nitro) {
-  return {
-    name: "nitro:route-meta",
-    async resolveId(id, importer, resolveOpts) {
-      if (id.startsWith("\0")) {
-        return;
-      }
-      if (id.endsWith(`?meta`)) {
-        const resolved = await this.resolve(
-          id.replace(`?meta`, ``),
-          importer,
-          resolveOpts
-        );
-        if (!resolved) {
-          return;
-        }
-        return virtualPrefix + resolved.id;
-      }
-    },
-    load(id) {
-      if (id.startsWith(virtualPrefix)) {
-        const fullPath = id.slice(virtualPrefix.length);
-        return readFile(fullPath, { encoding: "utf8" });
-      }
-    },
-    async transform(code, id) {
-      if (!id.startsWith(virtualPrefix)) {
-        return;
-      }
-      let meta = null;
-      try {
-        const ext = extname(id);
-        const jsCode = await transform(code, {
-          loader: esbuildLoaders[ext]
-        }).then((r) => r.code);
-        const ast = this.parse(jsCode);
-        for (const node of ast.body) {
-          if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" && node.expression.callee.name === "defineRouteMeta" && node.expression.arguments.length === 1) {
-            meta = astToObject(node.expression.arguments[0]);
-            break;
-          }
-        }
-      } catch (error) {
-        nitro.logger.warn(
-          `[handlers-meta] Cannot extra route meta for: ${id}: ${error}`
-        );
-      }
-      return {
-        code: `export default ${JSON.stringify(meta)};`,
-        map: null
-      };
-    }
-  };
-}
-function astToObject(node) {
-  switch (node.type) {
-    case "ObjectExpression": {
-      const obj = {};
-      for (const prop of node.properties) {
-        if (prop.type === "Property") {
-          const key = prop.key.name ?? prop.key.value;
-          obj[key] = astToObject(prop.value);
-        }
-      }
-      return obj;
-    }
-    case "ArrayExpression": {
-      return node.elements.map((el) => astToObject(el)).filter(Boolean);
-    }
-    case "Literal": {
-      return node.value;
-    }
-  }
-}
-
-function serverMain(nitro) {
-  return {
-    name: "nitro:server-main",
-    renderChunk(code, chunk) {
-      if (chunk.isEntry) {
-        return {
-          code: `globalThis.__nitro_main__ = import.meta.url; ${code}`,
-          map: null
-        };
-      }
-    }
-  };
-}
-
-const readAssetHandler = {
-  true: "node",
-  node: "node",
-  false: "null",
-  deno: "deno",
-  inline: "inline"
-};
-function publicAssets(nitro) {
-  return virtual(
-    {
-      // #nitro-internal-virtual/public-assets-data
-      "#nitro-internal-virtual/public-assets-data": async () => {
-        const assets = {};
-        const files = await glob("**", {
-          cwd: nitro.options.output.publicDir,
-          absolute: false,
-          dot: true
-        });
-        for (const id of files) {
-          let mimeType = mime.getType(id.replace(/\.(gz|br)$/, "")) || "text/plain";
-          if (mimeType.startsWith("text")) {
-            mimeType += "; charset=utf-8";
-          }
-          const fullPath = resolve(nitro.options.output.publicDir, id);
-          const assetData = await promises.readFile(fullPath);
-          const etag = createEtag(assetData);
-          const stat = await promises.stat(fullPath);
-          const assetId = "/" + decodeURIComponent(id);
-          let encoding;
-          if (id.endsWith(".gz")) {
-            encoding = "gzip";
-          } else if (id.endsWith(".br")) {
-            encoding = "br";
-          }
-          assets[assetId] = {
-            type: nitro._prerenderMeta?.[assetId]?.contentType || mimeType,
-            encoding,
-            etag,
-            mtime: stat.mtime.toJSON(),
-            size: stat.size,
-            path: relative(nitro.options.output.serverDir, fullPath),
-            data: nitro.options.serveStatic === "inline" ? assetData.toString("base64") : void 0
-          };
-        }
-        return `export default ${JSON.stringify(assets, null, 2)};`;
-      },
-      // #nitro-internal-virtual/public-assets-node
-      "#nitro-internal-virtual/public-assets-node": () => {
-        return `
-import { promises as fsp } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { resolve, dirname } from 'node:path'
-import assets from '#nitro-internal-virtual/public-assets-data'
-export function readAsset (id) {
-  const serverDir = dirname(fileURLToPath(globalThis.__nitro_main__))
-  return fsp.readFile(resolve(serverDir, assets[id].path))
-}`;
-      },
-      // #nitro-internal-virtual/public-assets-deno
-      "#nitro-internal-virtual/public-assets-deno": () => {
-        return `
-import assets from '#nitro-internal-virtual/public-assets-data'
-export function readAsset (id) {
-  // https://deno.com/deploy/docs/serve-static-assets
-  const path = '.' + decodeURIComponent(new URL(\`../public\${id}\`, 'file://').pathname)
-  return Deno.readFile(path);
-}`;
-      },
-      // #nitro-internal-virtual/public-assets-null
-      "#nitro-internal-virtual/public-assets-null": () => {
-        return `
-    export function readAsset (id) {
-        return Promise.resolve(null);
-    }`;
-      },
-      // #nitro-internal-virtual/public-assets-inline
-      "#nitro-internal-virtual/public-assets-inline": () => {
-        return `
-  import assets from '#nitro-internal-virtual/public-assets-data'
-  export function readAsset (id) {
-    if (!assets[id]) { return undefined }
-    if (assets[id]._data) { return assets[id]._data }
-    if (!assets[id].data) { return assets[id].data }
-    assets[id]._data = Uint8Array.from(atob(assets[id].data), (c) => c.charCodeAt(0))
-    return assets[id]._data
-}`;
-      },
-      // #nitro-internal-virtual/public-assets
-      "#nitro-internal-virtual/public-assets": () => {
-        const publicAssetBases = Object.fromEntries(
-          nitro.options.publicAssets.filter((dir) => !dir.fallthrough && dir.baseURL !== "/").map((dir) => [
-            withTrailingSlash(dir.baseURL),
-            { maxAge: dir.maxAge }
-          ])
-        );
-        const handlerName = readAssetHandler[nitro.options.serveStatic] || "null";
-        const readAssetImport = `#nitro-internal-virtual/public-assets-${handlerName}`;
-        return `
-import assets from '#nitro-internal-virtual/public-assets-data'
-export { readAsset } from "${readAssetImport}"
-export const publicAssetBases = ${JSON.stringify(publicAssetBases)}
-
-export function isPublicAssetURL(id = '') {
-  if (assets[id]) {
-    return true
-  }
-  for (const base in publicAssetBases) {
-    if (id.startsWith(base)) { return true }
-  }
-  return false
-}
-
-export function getPublicAssetMeta(id = '') {
-  for (const base in publicAssetBases) {
-    if (id.startsWith(base)) { return publicAssetBases[base] }
-  }
-  return {}
-}
-
-export function getAsset (id) {
-  return assets[id]
-}
-`;
-      }
-    },
-    nitro.vfs
-  );
-}
-
-function serverAssets(nitro) {
-  if (nitro.options.dev || nitro.options.preset === "nitro-prerender") {
-    return virtual(
-      { "#nitro-internal-virtual/server-assets": getAssetsDev(nitro) },
-      nitro.vfs
-    );
-  }
-  return virtual(
-    {
-      "#nitro-internal-virtual/server-assets": async () => {
-        const assets = {};
-        for (const asset of nitro.options.serverAssets) {
-          const files = await glob(asset.pattern || "**/*", {
-            cwd: asset.dir,
-            absolute: false,
-            ignore: asset.ignore
-          });
-          for (const _id of files) {
-            const fsPath = resolve(asset.dir, _id);
-            const id = asset.baseName + "/" + _id;
-            assets[id] = { fsPath, meta: {} };
-            let type = mime.getType(id) || "text/plain";
-            if (type.startsWith("text")) {
-              type += "; charset=utf-8";
-            }
-            const etag = createEtag(await promises.readFile(fsPath));
-            const mtime = await promises.stat(fsPath).then((s) => s.mtime.toJSON());
-            assets[id].meta = { type, etag, mtime };
-          }
-        }
-        return getAssetProd(assets);
-      }
-    },
-    nitro.vfs
-  );
-}
-function getAssetsDev(nitro) {
-  return `
-import { createStorage } from 'unstorage'
-import fsDriver from 'unstorage/drivers/fs'
-
-const serverAssets = ${JSON.stringify(nitro.options.serverAssets)}
-
-export const assets = createStorage()
-
-for (const asset of serverAssets) {
-  assets.mount(asset.baseName, fsDriver({ base: asset.dir, ignore: (asset?.ignore || []) }))
-}`;
-}
-function getAssetProd(assets) {
-  return `
-const _assets = {
-${Object.entries(assets).map(
-    ([id, asset]) => `  [${JSON.stringify(
-      normalizeKey(id)
-    )}]: {
-    import: () => import(${JSON.stringify(
-      "raw:" + asset.fsPath
-    )}).then(r => r.default || r),
-    meta: ${JSON.stringify(
-      asset.meta
-    )}
-  }`
-  ).join(",\n")}
-}
-
-const normalizeKey = ${normalizeKey.toString()}
-
-export const assets = {
-  getKeys() {
-    return Promise.resolve(Object.keys(_assets))
-  },
-  hasItem (id) {
-    id = normalizeKey(id)
-    return Promise.resolve(id in _assets)
-  },
-  getItem (id) {
-    id = normalizeKey(id)
-    return Promise.resolve(_assets[id] ? _assets[id].import() : null)
-  },
-  getMeta (id) {
-    id = normalizeKey(id)
-    return Promise.resolve(_assets[id] ? _assets[id].meta : {})
-  }
-}
-`;
-}
-
-function storage(nitro) {
-  const mounts = [];
-  const isDevOrPrerender = nitro.options.dev || nitro.options.preset === "nitro-prerender";
-  const storageMounts = isDevOrPrerender ? { ...nitro.options.storage, ...nitro.options.devStorage } : nitro.options.storage;
-  for (const path in storageMounts) {
-    const mount = storageMounts[path];
-    mounts.push({
-      path,
-      driver: builtinDrivers[mount.driver] || mount.driver,
-      opts: mount
-    });
-  }
-  const driverImports = [...new Set(mounts.map((m) => m.driver))];
-  const bundledStorageCode = `
-import { prefixStorage } from 'unstorage'
-import overlay from 'unstorage/drivers/overlay'
-import memory from 'unstorage/drivers/memory'
-
-const bundledStorage = ${JSON.stringify(nitro.options.bundledStorage)}
-for (const base of bundledStorage) {
-  storage.mount(base, overlay({
-    layers: [
-      memory(),
-      // TODO
-      // prefixStorage(storage, base),
-      prefixStorage(storage, 'assets:nitro:bundled:' + base)
-    ]
-  }))
-}`;
-  return virtual(
-    {
-      "#nitro-internal-virtual/storage": (
-        /* js */
-        `
-import { createStorage } from 'unstorage'
-import { assets } from '#nitro-internal-virtual/server-assets'
-
-${driverImports.map((i) => genImport(i, genSafeVariableName(i))).join("\n")}
-
-export function initStorage() {
-  const storage = createStorage({})
-  storage.mount('/assets', assets)
-  ${mounts.map(
-          (m) => `storage.mount('${m.path}', ${genSafeVariableName(
-            m.driver
-          )}(${JSON.stringify(m.opts)}))`
-        ).join("\n")}
-
-  ${!isDevOrPrerender && nitro.options.bundledStorage.length > 0 ? bundledStorageCode : ""}
-  return storage
-}
-`
-      )
-    },
-    nitro.vfs
-  );
-}
-
-function errorHandler(nitro) {
-  return virtual(
-    {
-      "#nitro-internal-virtual/error-handler": () => {
-        const errorHandlers = Array.isArray(nitro.options.errorHandler) ? nitro.options.errorHandler : [nitro.options.errorHandler];
-        const builtinHandler = join(
-          runtimeDir,
-          `internal/error/${nitro.options.dev ? "dev" : "prod"}`
-        );
-        return (
-          /* js */
-          `
-${errorHandlers.map((h, i) => `import errorHandler$${i} from "${h}";`).join("\n")}
-
-const errorHandlers = [${errorHandlers.map((_, i) => `errorHandler$${i}`).join(", ")}];
-
-import { defaultHandler } from "${builtinHandler}";
-
-export default async function(error, event) {
-  for (const handler of errorHandlers) {
-    try {
-      const response = await handler(error, event, { defaultHandler });
-      if (response) {
-        return response;
-      }
-    } catch(error) {
-      // Handler itself thrown, log and continue
-      console.error(error);
-    }
-  }
-  // H3 will handle fallback
-}
-`
-        );
-      }
-    },
-    nitro.vfs
-  );
-}
-
-function rendererTemplate(nitro) {
-  return virtual(
-    {
-      "#nitro-internal-virtual/renderer-template": async () => {
-        if (typeof nitro.options.renderer?.template !== "string") {
-          return `export const rendererTemplate = () => '<!-- renderer.template is not set -->'; export const rendererTemplateFile = undefined;`;
-        }
-        if (nitro.options.dev) {
-          return `import { readFile } from 'node:fs/promises';export const rendererTemplate = () => readFile(${JSON.stringify(nitro.options.renderer?.template)}, "utf8"); export const rendererTemplateFile = ${JSON.stringify(
-            nitro.options.renderer?.template
-          )};`;
-        } else {
-          const html = await readFile(nitro.options.renderer?.template, "utf8");
-          if (hasTemplateSyntax(html)) {
-            const template = compileTemplateToString(html, {
-              contextKeys: [...RENDER_CONTEXT_KEYS]
-            });
-            return (
-              /* js */
-              `
-            import { renderToResponse } from 'rendu'
-            const template = ${template};
-            export const rendererTemplate = (request) => renderToResponse(template, { request })
-            `
-            );
-          } else {
-            return (
-              /* js */
-              `
-              import { HTTPResponse } from "h3";
-              export const rendererTemplate = () => new HTTPResponse(${JSON.stringify(html)}, { headers: { "content-type": "text/html; charset=utf-8" } });
-            `
-            );
-          }
-        }
-      }
-    },
-    nitro.vfs
-  );
-}
-
-function featureFlags(nitro) {
-  return virtual(
-    {
-      "#nitro-internal-virtual/feature-flags": () => {
-        const featureFlags2 = {
-          // Routing
-          hasRoutes: nitro.routing.routes.hasRoutes(),
-          hasRouteRules: nitro.routing.routeRules.hasRoutes(),
-          hasRoutedMiddleware: nitro.routing.routedMiddleware.hasRoutes(),
-          hasGlobalMiddleware: nitro.routing.globalMiddleware.length > 0 || !!nitro.options.serverEntry,
-          // Plugins
-          hasPlugins: nitro.options.plugins.length > 0,
-          hasHooks: nitro.options.features?.runtimeHooks ?? nitro.options.plugins.length > 0
-        };
-        return (
-          /* js */
-          Object.entries(featureFlags2).map(
-            ([key, value]) => (
-              /* js */
-              `export const ${key} = ${Boolean(value)};`
-            )
-          ).join("\n")
-        );
-      }
-    },
-    nitro.vfs
-  );
-}
-
-const subpathMap = {
-  "nitro/h3": "h3",
-  "nitro/deps/h3": "h3",
-  "nitro/deps/ofetch": "ofetch"
-};
-function nitroResolveIds() {
-  return {
-    name: "nitro:resolve-ids",
-    resolveId: {
-      order: "pre",
-      handler(id, importer, rOpts) {
-        if (importer && importer.startsWith("\0virtual:#nitro-internal-virtual")) {
-          return this.resolve(id, runtimeDir, { skipSelf: true });
-        }
-        const mappedId = subpathMap[id];
-        if (mappedId) {
-          return this.resolve(mappedId, runtimeDir, { skipSelf: true });
-        }
-      }
-    }
-  };
-}
-
-function baseBuildPlugins(nitro, base) {
-  const plugins = [];
-  if (nitro.options.imports) {
-    plugins.push(unplugin.rollup(nitro.options.imports));
-  }
-  if (nitro.options.experimental.wasm) {
-    plugins.push(rollup(nitro.options.wasm || {}));
-  }
-  plugins.push(serverMain());
-  const nitroPlugins = [...new Set(nitro.options.plugins)];
-  plugins.push(
-    virtual(
-      {
-        "#nitro-internal-virtual/plugins": (
-          /* js */
-          `
-  ${nitroPlugins.map(
-            (plugin) => `import _${hash(plugin).replace(/-/g, "")} from '${plugin}';`
-          ).join("\n")}
-
-  export const plugins = [
-    ${nitroPlugins.map((plugin) => `_${hash(plugin).replace(/-/g, "")}`).join(",\n")}
-  ]
-      `
-        )
-      },
-      nitro.vfs
-    )
-  );
-  plugins.push(featureFlags(nitro));
-  plugins.push(nitroResolveIds());
-  plugins.push(serverAssets(nitro));
-  plugins.push(publicAssets(nitro));
-  plugins.push(storage(nitro));
-  plugins.push(database(nitro));
-  plugins.push(routing(nitro));
-  if (nitro.options.experimental.openAPI) {
-    plugins.push(routeMeta(nitro));
-  }
-  plugins.push(errorHandler(nitro));
-  plugins.push(
-    virtual(
-      {
-        "#nitro-internal-pollyfills": base.env.polyfill.map((p) => (
-          /* js */
-          `import '${p}';`
-        )).join("\n") || /* js */
-        `/* No polyfills */`
-      },
-      nitro.vfs
-    )
-  );
-  plugins.push(virtual(nitro.options.virtual, nitro.vfs));
-  if (nitro.options.renderer?.template) {
-    plugins.push(rendererTemplate(nitro));
-  }
-  if (!nitro.options.noExternals) {
-    plugins.push(
-      rollupNodeFileTrace(
-        defu(nitro.options.externals, {
-          outDir: nitro.options.output.serverDir,
-          moduleDirectories: nitro.options.nodeModulesDirs,
-          external: [
-            ...nitro.options.dev ? [nitro.options.buildDir] : [],
-            ...nitro.options.nodeModulesDirs
-          ],
-          inline: [
-            "#",
-            "~",
-            "@/",
-            "~~",
-            "@@/",
-            "virtual:",
-            "nitro/runtime",
-            dirname(nitro.options.entry),
-            ...nitro.options.experimental.wasm ? [(id) => id?.endsWith(".wasm")] : [],
-            runtimeDir,
-            nitro.options.srcDir,
-            ...nitro.options.handlers.map((m) => m.handler).filter((i) => typeof i === "string"),
-            ...nitro.options.dev || nitro.options.preset === "nitro-prerender" || nitro.options.experimental.bundleRuntimeDependencies === false ? [] : runtimeDependencies
-          ],
-          traceOptions: {
-            base: "/",
-            processCwd: nitro.options.rootDir,
-            exportsOnly: true
-          },
-          traceAlias: {
-            "h3-nightly": "h3",
-            ...nitro.options.externals?.traceAlias
-          },
-          exportConditions: nitro.options.exportConditions,
-          writePackageJson: true
-        })
-      )
-    );
-  }
-  return plugins;
-}
-
-async function writeBuildInfo(nitro) {
-  const buildInfoPath = resolve(nitro.options.output.dir, "nitro.json");
-  const buildInfo = {
-    date: (/* @__PURE__ */ new Date()).toJSON(),
-    preset: nitro.options.preset,
-    framework: nitro.options.framework,
-    versions: {
-      nitro: version
-    },
-    commands: {
-      preview: nitro.options.commands.preview,
-      deploy: nitro.options.commands.deploy
-    },
-    config: {
-      ...Object.fromEntries(
-        presetsWithConfig.map((key) => [key, nitro.options[key]])
-      )
-    }
-  };
-  await writeFile(buildInfoPath, JSON.stringify(buildInfo, null, 2), true);
-  const lastBuild = resolve(
-    nitro.options.rootDir,
-    "node_modules/.nitro/last-build"
-  );
-  await mkdir(dirname$1(lastBuild), { recursive: true });
-  await unlink(lastBuild).catch(() => {
-  });
-  await symlink(nitro.options.output.dir, lastBuild).catch(console.warn);
-  return buildInfo;
-}
-
-export { baseBuildPlugins as a, baseBuildConfig as b, replace as r, writeBuildInfo as w };