nitro-nightly 3.1.0-20251028-000737-b443005f → 3.1.0-20251028-090722-437659e4

package/dist/_build/plugins.mjs

@@ -0,0 +1,1041 @@
+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 };