nitro-nightly 3.1.0-20251028-090722-437659e4 → 3.1.0-20251028-131831-fe9fd554

package/dist/_build/plugins.mjs

@@ -1,1041 +0,0 @@
-import { r as replace$1 } from '../_deps/@rollup/plugin-replace.mjs';
-import { pathToFileURL } from 'node:url';
-import { builtinModules } from 'node:module';
-import { hash } from 'ohash';
-import { defu } from 'defu';
-import { r as resolveModulePath } from '../_deps/exsolve.mjs';
-import { runtimeDir, runtimeDependencies } from 'nitro/runtime/meta';
-import { u as unplugin } from '../_deps/unimport.mjs';
-import { r as rollup } from '../_deps/unwasm.mjs';
-import { connectors } from 'db0';
-import { camelCase } from 'scule';
-import { a as resolve, d as dirname, e as extname, r as relative, j as join, i as isAbsolute } from '../_deps/pathe.mjs';
-import { readFile } from 'node:fs/promises';
-import { transform } from 'esbuild';
-import { promises } from 'node:fs';
-import { c as createEtag } from '../_deps/etag.mjs';
-import { g as glob } from '../_deps/tinyglobby.mjs';
-import { m as mime } from '../_deps/mime.mjs';
-import { withTrailingSlash } from 'ufo';
-import { normalizeKey, builtinDrivers } from 'unstorage';
-import { g as genImport, a as genSafeVariableName } from '../_deps/knitwork.mjs';
-import { rollupNodeFileTrace } from 'nf3';
-import { hasTemplateSyntax, compileTemplateToString, RENDER_CONTEXT_KEYS } from 'rendu';
-import { c as createFilter } from '../_deps/unplugin-utils.mjs';
-
-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);
-      }
-    }
-  };
-}
-
-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 "nitro/deps/h3";
-
-export const hasRouteRules = ${nitro.routing.routeRules.hasRoutes() ? "true" : "false"};
-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 hasRoutes = ${nitro.routing.routes.hasRoutes() ? "true" : "false"};
-export const findRoute = ${nitro.routing.routes.compileToString({ serialize: serializeHandler })}
-
-export const hasRoutedMiddleware = ${nitro.routing.routedMiddleware.hasRoutes() ? "true" : "false"};
-export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({ serialize: serializeHandler, matchAll: true })};
-
-export const hasGlobalMiddleware = ${nitro.routing.globalMiddleware.length > 0 || nitro.options.serverEntry ? "true" : "false"};
-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 "nitro/deps/h3";
-              export const rendererTemplate = () => new HTTPResponse(${JSON.stringify(html)}, { headers: { "content-type": "text/html; charset=utf-8" } });
-            `
-            );
-          }
-        }
-      }
-    },
-    nitro.vfs
-  );
-}
-
-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(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({
-      name: "no-externals",
-      async resolveId(id, importer, resolveOpts) {
-        if (resolveOpts.custom?.skipNoExternals) {
-          return;
-        }
-        id = base.aliases[id] || id;
-        if (base.env.external.includes(id) || nitro.options.node && (id.startsWith("node:") || builtinModules.includes(id))) {
-          return { id, external: true };
-        }
-        const resolved = await this.resolve(id, importer, resolveOpts);
-        if (!resolved) {
-          const _resolved = resolveModulePath(id, {
-            try: true,
-            from: importer && isAbsolute(importer) ? [pathToFileURL(importer), ...nitro.options.nodeModulesDirs] : nitro.options.nodeModulesDirs,
-            suffixes: ["", "/index"],
-            extensions: [".mjs", ".cjs", ".js", ".mts", ".cts", ".ts", ".json"],
-            conditions: [
-              "default",
-              nitro.options.dev ? "development" : "production",
-              "node",
-              "import",
-              "require"
-            ]
-          });
-          if (_resolved) {
-            return { id: _resolved, external: false };
-          }
-        }
-        if (!resolved || resolved.external && !id.endsWith(".wasm")) {
-          throw new Error(
-            `Cannot resolve ${JSON.stringify(id)} from ${JSON.stringify(
-              importer
-            )} and externals are not allowed!`
-          );
-        }
-      }
-    });
-  } else if (!nitro.options.dev) {
-    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",
-            "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;
-}
-
-const defaultLoaders = {
-  ".ts": "ts",
-  ".js": "js",
-  ".tsx": "tsx",
-  ".jsx": "jsx"
-};
-function esbuild(options) {
-  const {
-    include,
-    exclude,
-    sourceMap,
-    loaders: loadersConfig,
-    minify,
-    ...transformOptions
-  } = options;
-  const loaders = { ...defaultLoaders };
-  if (loadersConfig) {
-    for (const key of Object.keys(loadersConfig)) {
-      const value = loadersConfig[key];
-      if (typeof value === "string") {
-        loaders[key] = value;
-      } else if (value === false) {
-        delete loaders[key];
-      }
-    }
-  }
-  const extensions = Object.keys(loaders);
-  const INCLUDE_REGEXP = new RegExp(
-    `\\.(${extensions.map((ext) => ext.slice(1)).join("|")})$`
-  );
-  const EXCLUDE_REGEXP = /node_modules/;
-  const filter = createFilter(
-    include || INCLUDE_REGEXP,
-    exclude || EXCLUDE_REGEXP
-  );
-  return {
-    name: "esbuild",
-    async transform(code, id) {
-      if (!filter(id)) {
-        return null;
-      }
-      const ext = extname(id);
-      const loader = loaders[ext];
-      if (!loader) {
-        return null;
-      }
-      const result = await transform(code, {
-        sourcemap: sourceMap === "hidden" ? "external" : sourceMap,
-        ...transformOptions,
-        loader,
-        sourcefile: id
-      });
-      printWarnings(id, result, this);
-      return result.code && {
-        code: result.code,
-        map: result.map || null
-      };
-    },
-    async renderChunk(code) {
-      if (minify) {
-        const result = await transform(code, {
-          loader: "js",
-          minify: true,
-          target: transformOptions.target
-        });
-        if (result.code) {
-          return {
-            code: result.code,
-            map: result.map || null
-          };
-        }
-      }
-      return null;
-    }
-  };
-}
-function printWarnings(id, result, plugin) {
-  if (result.warnings) {
-    for (const warning of result.warnings) {
-      let message = "[esbuild]";
-      if (warning.location) {
-        message += ` (${relative(process.cwd(), id)}:${warning.location.line}:${warning.location.column})`;
-      }
-      message += ` ${warning.text}`;
-      plugin.warn(message);
-    }
-  }
-}
-
-function sourcemapMininify() {
-  return {
-    name: "nitro:sourcemap-minify",
-    generateBundle(_options, bundle) {
-      for (const [key, asset] of Object.entries(bundle)) {
-        if (!key.endsWith(".map") || !("source" in asset) || typeof asset.source !== "string") {
-          continue;
-        }
-        const sourcemap = JSON.parse(asset.source);
-        if (!(sourcemap.sources || []).some((s) => s.includes("node_modules"))) {
-          continue;
-        }
-        sourcemap.mappings = "";
-        asset.source = JSON.stringify(sourcemap);
-      }
-    }
-  };
-}
-
-const HELPER_ID = "\0raw-helpers";
-function raw(opts = {}) {
-  const extensions = /* @__PURE__ */ new Set([
-    ".md",
-    ".mdx",
-    ".txt",
-    ".css",
-    ".htm",
-    ".html",
-    ".sql",
-    ...opts.extensions || []
-  ]);
-  return {
-    name: "raw",
-    async resolveId(id, importer, resolveOpts) {
-      if (id === HELPER_ID) {
-        return id;
-      }
-      if (id[0] === "\0") {
-        return;
-      }
-      const withRawSpecifier = id.startsWith("raw:");
-      if (withRawSpecifier) {
-        id = id.slice(4);
-      }
-      if (!withRawSpecifier && !extensions.has(extname(id))) {
-        return;
-      }
-      const resolvedId = (await this.resolve(id, importer, resolveOpts))?.id;
-      if (!resolvedId || resolvedId.startsWith("\0")) {
-        return resolvedId;
-      }
-      if (!withRawSpecifier && !extensions.has(extname(resolvedId))) {
-        return;
-      }
-      return { id: "\0raw:" + resolvedId };
-    },
-    load(id) {
-      if (id === HELPER_ID) {
-        return getHelpers();
-      }
-      if (id.startsWith("\0raw:")) {
-        return promises.readFile(id.slice(5), isBinary(id) ? "binary" : "utf8");
-      }
-    },
-    transform(code, id) {
-      if (!id.startsWith("\0raw:")) {
-        return;
-      }
-      if (isBinary(id)) {
-        const serialized = Buffer.from(code, "binary").toString("base64");
-        return {
-          code: `// ROLLUP_NO_REPLACE 
- import {base64ToUint8Array } from "${HELPER_ID}" 
- export default base64ToUint8Array("${serialized}")`,
-          map: null
-        };
-      }
-      return {
-        code: `// ROLLUP_NO_REPLACE 
- export default ${JSON.stringify(code)}`,
-        map: null,
-        moduleType: "js"
-      };
-    }
-  };
-}
-function isBinary(id) {
-  const idMime = mime.getType(id) || "";
-  if (idMime.startsWith("text/")) {
-    return false;
-  }
-  if (/application\/(json|sql|xml|yaml)/.test(idMime)) {
-    return false;
-  }
-  return true;
-}
-function getHelpers() {
-  const js = String.raw;
-  return js`
-export function base64ToUint8Array(str) {
-  const data = atob(str);
-  const size = data.length;
-  const bytes = new Uint8Array(size);
-  for (let i = 0; i < size; i++) {
-    bytes[i] = data.charCodeAt(i);
-  }
-  return bytes;
-}
-  `;
-}
-
-export { raw as a, baseBuildPlugins as b, esbuild as e, replace as r, sourcemapMininify as s };