nitro-nightly 3.0.0-beta-28969273.f7aa9de6 → 4.0.0-20251010-091516-7cafddba

package/dist/rollup/index.mjs

@@ -1,1673 +0,0 @@
-import { builtinModules, createRequire } from 'node:module';
-import { pathToFileURL } from 'node:url';
-import alias from '@rollup/plugin-alias';
-import commonjs from '@rollup/plugin-commonjs';
-import inject from '@rollup/plugin-inject';
-import json from '@rollup/plugin-json';
-import { nodeResolve } from '@rollup/plugin-node-resolve';
-import { defu } from 'defu';
-import { isValidNodeImport, normalizeid, parseNodeModulePath, lookupNodeModuleSubpath, resolvePath, sanitizeFilePath } from 'mlly';
-import { runtimeDir, runtimeDependencies } from 'nitro/runtime/meta';
-import { hash } from 'ohash';
-import { resolve, dirname, extname, relative, normalize, isAbsolute, join } from 'pathe';
-import { visualizer } from 'rollup-plugin-visualizer';
-import { isWindows } from 'std-env';
-import * as unenv from 'unenv';
-import unimportPlugin from 'unimport/unplugin';
-import { rollup } from 'unwasm/plugin';
-import { connectors } from 'db0';
-import { camelCase } from 'scule';
-import { createFilter } from '@rollup/pluginutils';
-import { transform } from 'esbuild';
-import { existsSync, promises } from 'node:fs';
-import { platform } from 'node:os';
-import { nodeFileTrace } from '@vercel/nft';
-import { isDirectory } from 'nitro/kit';
-import { readPackageJSON, writePackageJSON } from 'pkg-types';
-import semver from 'semver';
-import { readFile } from 'node:fs/promises';
-import * as _etag from 'etag';
-import _etag__default from 'etag';
-import { globby } from 'globby';
-import mime from 'mime';
-import { withTrailingSlash } from 'ufo';
-import _replace from '@rollup/plugin-replace';
-import { normalizeKey, builtinDrivers } from 'unstorage';
-import { genImport, genSafeVariableName } from 'knitwork';
-
-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 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 externals(opts) {
-  const trackedExternals = /* @__PURE__ */ new Set();
-  const _resolveCache = /* @__PURE__ */ new Map();
-  const _resolve = async (id) => {
-    if (id.startsWith("\0")) {
-      return id;
-    }
-    let resolved = _resolveCache.get(id);
-    if (resolved) {
-      return resolved;
-    }
-    resolved = await resolvePath(id, {
-      conditions: opts.exportConditions,
-      url: opts.moduleDirectories
-    });
-    _resolveCache.set(id, resolved);
-    return resolved;
-  };
-  const inlineMatchers = (opts.inline || []).map((p) => normalizeMatcher(p)).sort((a, b) => (b.score || 0) - (a.score || 0));
-  const externalMatchers = (opts.external || []).map((p) => normalizeMatcher(p)).sort((a, b) => (b.score || 0) - (a.score || 0));
-  const isExplicitInline = (id, importer) => {
-    if (id.startsWith("\0")) {
-      return true;
-    }
-    const inlineMatch = inlineMatchers.find((m) => m(id, importer));
-    const externalMatch = externalMatchers.find((m) => m(id, importer));
-    if (inlineMatch && (!externalMatch || externalMatch && (inlineMatch.score || 0) > (externalMatch.score || 0))) {
-      return true;
-    }
-  };
-  return {
-    name: "node-externals",
-    async resolveId(originalId, importer, options) {
-      if (!originalId || originalId.startsWith("\0") || originalId.includes("?") || originalId.startsWith("#")) {
-        return null;
-      }
-      if (originalId.startsWith(".")) {
-        return null;
-      }
-      const id = normalize(originalId);
-      if (isExplicitInline(id, importer)) {
-        return null;
-      }
-      const resolved = await this.resolve(originalId, importer, options) || {
-        id
-      };
-      if (isExplicitInline(resolved.id, importer)) {
-        return null;
-      }
-      if (!isAbsolute(resolved.id) || !existsSync(resolved.id) || await isDirectory(resolved.id)) {
-        resolved.id = await _resolve(resolved.id).catch(() => resolved.id);
-      }
-      if (!await isValidNodeImport(resolved.id).catch(() => false)) {
-        return null;
-      }
-      if (opts.trace === false) {
-        return {
-          ...resolved,
-          id: isAbsolute(resolved.id) ? normalizeid(resolved.id) : resolved.id,
-          external: true
-        };
-      }
-      const { name: pkgName } = parseNodeModulePath(resolved.id);
-      if (!pkgName) {
-        return null;
-      }
-      if (pkgName !== originalId) {
-        if (!isAbsolute(originalId)) {
-          const fullPath = await _resolve(originalId);
-          trackedExternals.add(fullPath);
-          return {
-            id: originalId,
-            external: true
-          };
-        }
-        const packageEntry = await _resolve(pkgName).catch(() => null);
-        if (packageEntry !== id) {
-          const guessedSubpath = await lookupNodeModuleSubpath(id).catch(() => null);
-          const resolvedGuess = guessedSubpath && await _resolve(join(pkgName, guessedSubpath)).catch(() => null);
-          if (resolvedGuess === id) {
-            trackedExternals.add(resolvedGuess);
-            return {
-              id: join(pkgName, guessedSubpath),
-              external: true
-            };
-          }
-          return null;
-        }
-      }
-      trackedExternals.add(resolved.id);
-      return {
-        id: pkgName,
-        external: true
-      };
-    },
-    async buildEnd() {
-      if (opts.trace === false) {
-        return;
-      }
-      for (const pkgName of opts.traceInclude || []) {
-        const path = await this.resolve(pkgName);
-        if (path?.id) {
-          trackedExternals.add(path.id.replace(/\?.+/, ""));
-        }
-      }
-      const _fileTrace = await nodeFileTrace([...trackedExternals], {
-        // https://github.com/unjs/nitro/pull/1562
-        conditions: (opts.exportConditions || []).filter(
-          (c) => !["require", "import", "default"].includes(c)
-        ),
-        ...opts.traceOptions
-      });
-      const _resolveTracedPath = (p) => promises.realpath(resolve(opts.traceOptions?.base || ".", p));
-      const tracedFiles = Object.fromEntries(
-        await Promise.all(
-          [..._fileTrace.reasons.entries()].map(async ([_path, reasons]) => {
-            if (reasons.ignored) {
-              return;
-            }
-            const path = await _resolveTracedPath(_path);
-            if (!path.includes("node_modules")) {
-              return;
-            }
-            if (!await isFile(path)) {
-              return;
-            }
-            const {
-              dir: baseDir,
-              name: pkgName,
-              subpath
-            } = parseNodeModulePath(path);
-            if (!baseDir || !pkgName) {
-              return;
-            }
-            const pkgPath = join(baseDir, pkgName);
-            const parents = await Promise.all(
-              [...reasons.parents].map((p) => _resolveTracedPath(p))
-            );
-            const tracedFile = {
-              path,
-              parents,
-              subpath,
-              pkgName,
-              pkgPath
-            };
-            return [path, tracedFile];
-          })
-        ).then((r) => r.filter(Boolean))
-      );
-      const tracedPackages = {};
-      for (const tracedFile of Object.values(tracedFiles)) {
-        const pkgName = tracedFile.pkgName;
-        let tracedPackage = tracedPackages[pkgName];
-        let pkgJSON = await readPackageJSON(tracedFile.pkgPath, {
-          cache: true
-        }).catch(
-          () => {
-          }
-          // TODO: Only catch ENOENT
-        );
-        if (!pkgJSON) {
-          pkgJSON = { name: pkgName, version: "0.0.0" };
-        }
-        if (!tracedPackage) {
-          tracedPackage = {
-            name: pkgName,
-            versions: {}
-          };
-          tracedPackages[pkgName] = tracedPackage;
-        }
-        let tracedPackageVersion = tracedPackage.versions[pkgJSON.version || "0.0.0"];
-        if (!tracedPackageVersion) {
-          tracedPackageVersion = {
-            path: tracedFile.pkgPath,
-            files: [],
-            pkgJSON
-          };
-          tracedPackage.versions[pkgJSON.version || "0.0.0"] = tracedPackageVersion;
-        }
-        tracedPackageVersion.files.push(tracedFile.path);
-        tracedFile.pkgName = pkgName;
-        if (pkgJSON.version) {
-          tracedFile.pkgVersion = pkgJSON.version;
-        }
-      }
-      const usedAliases = {};
-      const writePackage = async (name, version, _pkgPath) => {
-        const pkg = tracedPackages[name];
-        const pkgPath = _pkgPath || pkg.name;
-        for (const src of pkg.versions[version].files) {
-          const { subpath } = parseNodeModulePath(src);
-          if (!subpath) {
-            continue;
-          }
-          const dst = join(opts.outDir, "node_modules", pkgPath, subpath);
-          await promises.mkdir(dirname(dst), { recursive: true });
-          await promises.copyFile(src, dst);
-        }
-        const pkgJSON = pkg.versions[version].pkgJSON;
-        applyProductionCondition(pkgJSON.exports);
-        const pkgJSONPath = join(
-          opts.outDir,
-          "node_modules",
-          pkgPath,
-          "package.json"
-        );
-        await promises.mkdir(dirname(pkgJSONPath), { recursive: true });
-        await promises.writeFile(
-          pkgJSONPath,
-          JSON.stringify(pkgJSON, null, 2),
-          "utf8"
-        );
-        if (opts.traceAlias && pkgPath in opts.traceAlias) {
-          usedAliases[opts.traceAlias[pkgPath]] = version;
-          await linkPackage(pkgPath, opts.traceAlias[pkgPath]);
-        }
-      };
-      const isWindows = platform() === "win32";
-      const linkPackage = async (from, to) => {
-        const src = join(opts.outDir, "node_modules", from);
-        const dst = join(opts.outDir, "node_modules", to);
-        const dstStat = await promises.lstat(dst).catch(() => null);
-        const exists = dstStat?.isSymbolicLink();
-        if (exists) {
-          return;
-        }
-        await promises.mkdir(dirname(dst), { recursive: true });
-        await promises.symlink(
-          relative(dirname(dst), src),
-          dst,
-          isWindows ? "junction" : "dir"
-        ).catch((error) => {
-          console.error("Cannot link", from, "to", to, error);
-        });
-      };
-      const findPackageParents = (pkg, version) => {
-        const versionFiles = pkg.versions[version].files.map(
-          (path) => tracedFiles[path]
-        );
-        const parentPkgs = [
-          ...new Set(
-            versionFiles.flatMap(
-              (file) => file.parents.map((parentPath) => {
-                const parentFile = tracedFiles[parentPath];
-                if (parentFile.pkgName === pkg.name) {
-                  return null;
-                }
-                return `${parentFile.pkgName}@${parentFile.pkgVersion}`;
-              }).filter(Boolean)
-            )
-          )
-        ];
-        return parentPkgs;
-      };
-      const multiVersionPkgs = {};
-      const singleVersionPackages = [];
-      for (const tracedPackage of Object.values(tracedPackages)) {
-        const versions = Object.keys(tracedPackage.versions);
-        if (versions.length === 1) {
-          singleVersionPackages.push(tracedPackage.name);
-          continue;
-        }
-        multiVersionPkgs[tracedPackage.name] = {};
-        for (const version of versions) {
-          multiVersionPkgs[tracedPackage.name][version] = findPackageParents(
-            tracedPackage,
-            version
-          );
-        }
-      }
-      await Promise.all(
-        singleVersionPackages.map((pkgName) => {
-          const pkg = tracedPackages[pkgName];
-          const version = Object.keys(pkg.versions)[0];
-          return writePackage(pkgName, version);
-        })
-      );
-      for (const [pkgName, pkgVersions] of Object.entries(multiVersionPkgs)) {
-        const versionEntries = Object.entries(pkgVersions).sort(
-          ([v1, p1], [v2, p2]) => {
-            if (p1.length === 0) {
-              return -1;
-            }
-            if (p2.length === 0) {
-              return 1;
-            }
-            return compareVersions(v1, v2);
-          }
-        );
-        for (const [version, parentPkgs] of versionEntries) {
-          await writePackage(pkgName, version, `.nitro/${pkgName}@${version}`);
-          await linkPackage(`.nitro/${pkgName}@${version}`, `${pkgName}`);
-          for (const parentPkg of parentPkgs) {
-            const parentPkgName = parentPkg.replace(/@[^@]+$/, "");
-            await (multiVersionPkgs[parentPkgName] ? linkPackage(
-              `.nitro/${pkgName}@${version}`,
-              `.nitro/${parentPkg}/node_modules/${pkgName}`
-            ) : linkPackage(
-              `.nitro/${pkgName}@${version}`,
-              `${parentPkgName}/node_modules/${pkgName}`
-            ));
-          }
-        }
-      }
-      const userPkg = await readPackageJSON(
-        opts.rootDir || process.cwd()
-      ).catch(() => ({}));
-      await writePackageJSON(resolve(opts.outDir, "package.json"), {
-        name: (userPkg.name || "server") + "-prod",
-        version: userPkg.version || "0.0.0",
-        type: "module",
-        private: true,
-        dependencies: Object.fromEntries(
-          [
-            ...Object.values(tracedPackages).map((pkg) => [
-              pkg.name,
-              Object.keys(pkg.versions)[0]
-            ]),
-            ...Object.entries(usedAliases)
-          ].sort(([a], [b]) => a.localeCompare(b))
-        )
-      });
-    }
-  };
-}
-function compareVersions(v1 = "0.0.0", v2 = "0.0.0") {
-  try {
-    return semver.lt(v1, v2, { loose: true }) ? 1 : -1;
-  } catch {
-    return v1.localeCompare(v2);
-  }
-}
-function applyProductionCondition(exports) {
-  if (!exports || typeof exports === "string" || Array.isArray(exports)) {
-    return;
-  }
-  if ("production" in exports) {
-    if (typeof exports.production === "string") {
-      exports.default = exports.production;
-    } else {
-      Object.assign(exports, exports.production);
-    }
-  }
-  for (const key in exports) {
-    applyProductionCondition(exports[key]);
-  }
-}
-async function isFile(file) {
-  try {
-    const stat = await promises.stat(file);
-    return stat.isFile();
-  } catch (error) {
-    if (error?.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-function normalizeMatcher(input) {
-  if (typeof input === "function") {
-    input.score = input.score ?? 1e4;
-    return input;
-  }
-  if (input instanceof RegExp) {
-    const matcher = (id) => input.test(id);
-    matcher.score = input.toString().length;
-    Object.defineProperty(matcher, "name", { value: `match(${input})` });
-    return matcher;
-  }
-  if (typeof input === "string") {
-    const pattern = normalize(input);
-    const matcher = (id) => {
-      const idWithoutNodeModules = id.split("node_modules/").pop();
-      return id.startsWith(pattern) || idWithoutNodeModules?.startsWith(pattern);
-    };
-    matcher.score = input.length;
-    if (!isAbsolute(input) && input[0] !== ".") {
-      matcher.score += 1e3;
-    }
-    Object.defineProperty(matcher, "name", { value: `match(${pattern})` });
-    return matcher;
-  }
-  throw new Error(`Invalid matcher or pattern: ${input}`);
-}
-
-function handlers(nitro) {
-  const getHandlers = () => {
-    const handlers2 = [
-      ...nitro.scannedHandlers,
-      ...nitro.options.handlers
-    ];
-    const envConditions = new Set(
-      [
-        nitro.options.dev ? "dev" : "prod",
-        nitro.options.preset,
-        nitro.options.preset === "nitro-prerender" ? "prerender" : void 0
-      ].filter(Boolean)
-    );
-    return handlers2.filter((h) => {
-      const envs = (Array.isArray(h.env) ? h.env : [h.env]).filter(
-        Boolean
-      );
-      return envs.length === 0 || envs.some((env) => envConditions.has(env));
-    });
-  };
-  return virtual(
-    {
-      "#nitro-internal-virtual/server-handlers": () => {
-        const handlers2 = getHandlers();
-        if (nitro.options.serveStatic) {
-          handlers2.unshift({
-            middleware: true,
-            handler: join(runtimeDir, "internal/static")
-          });
-        }
-        if (nitro.options.renderer) {
-          handlers2.push({
-            route: "/**",
-            lazy: true,
-            handler: nitro.options.renderer
-          });
-        }
-        extendMiddlewareWithRuleOverlaps(handlers2, nitro.options.routeRules);
-        const imports = unique(
-          handlers2.filter((h) => !h.lazy).map((h) => h.handler)
-        );
-        const lazyImports = unique(
-          handlers2.filter((h) => h.lazy).map((h) => h.handler)
-        );
-        const code = (
-          /* js */
-          `
-${imports.map((handler) => `import ${getImportId(handler)} from '${handler}';`).join("\n")}
-
-${lazyImports.map(
-            (handler) => `const ${getImportId(handler, true)} = () => import('${handler}');`
-          ).join("\n")}
-
-export const handlers = [
-${handlers2.map(
-            (h) => `  { route: '${h.route || ""}', handler: ${getImportId(
-              h.handler,
-              h.lazy
-            )}, lazy: ${!!h.lazy}, middleware: ${!!h.middleware}, method: ${JSON.stringify(
-              h.method?.toLowerCase()
-            )} }`
-          ).join(",\n")}
-];
-  `.trim()
-        );
-        return code;
-      },
-      "#nitro-internal-virtual/server-handlers-meta": () => {
-        const handlers2 = getHandlers();
-        return (
-          /* js */
-          `
-  ${handlers2.map(
-            (h) => `import ${getImportId(h.handler)}Meta from "${h.handler}?meta";`
-          ).join("\n")}
-export const handlersMeta = [
-  ${handlers2.map(
-            (h) => (
-              /* js */
-              `{ route: ${JSON.stringify(h.route)}, method: ${JSON.stringify(
-                h.method?.toLowerCase()
-              )}, meta: ${getImportId(h.handler)}Meta }`
-            )
-          ).join(",\n")}
-  ];
-        `
-        );
-      }
-    },
-    nitro.vfs
-  );
-}
-function unique(arr) {
-  return [...new Set(arr)];
-}
-function getImportId(p, lazy) {
-  return (lazy ? "_lazy_" : "_") + hash(p).slice(0, 6);
-}
-const WILDCARD_PATH_RE = /\/\*\*.*$/;
-function extendMiddlewareWithRuleOverlaps(handlers2, routeRules) {
-  const rules = Object.entries(routeRules);
-  for (const [path, rule] of rules) {
-    if (!rule.cache) {
-      const isNested = rules.some(
-        ([p, r]) => r.cache && WILDCARD_PATH_RE.test(p) && path.startsWith(p.replace(WILDCARD_PATH_RE, ""))
-      );
-      if (!isNested) {
-        continue;
-      }
-    }
-    for (const [index, handler] of handlers2.entries()) {
-      if (!handler.route || handler.middleware) {
-        continue;
-      }
-      if (handler.route === path) {
-        break;
-      }
-      if (!WILDCARD_PATH_RE.test(handler.route)) {
-        continue;
-      }
-      if (!path.startsWith(handler.route.replace(WILDCARD_PATH_RE, ""))) {
-        continue;
-      }
-      handlers2.splice(index, 0, {
-        ...handler,
-        route: path
-      });
-      break;
-    }
-  }
-}
-
-const virtualPrefix = "\0nitro-handler-meta:";
-const esbuildLoaders = {
-  ".ts": "ts",
-  ".js": "js",
-  ".tsx": "tsx",
-  ".jsx": "jsx"
-};
-function handlersMeta(nitro) {
-  return {
-    name: "nitro:handlers-meta",
-    async resolveId(id) {
-      if (id.startsWith("\0")) {
-        return;
-      }
-      if (id.endsWith(`?meta`)) {
-        const resolved = await this.resolve(id.replace(`?meta`, ``));
-        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) {
-        console.warn(
-          `[nitro] [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;
-    }
-  }
-}
-
-const ImportMetaRe = /import\.meta|globalThis._importMeta_/;
-function importMeta(nitro) {
-  return {
-    name: "import-meta",
-    renderChunk(code, chunk) {
-      const isEntry = chunk.isEntry;
-      if (!isEntry && (!ImportMetaRe.test(code) || code.includes("ROLLUP_NO_REPLACE"))) {
-        return;
-      }
-      const url = nitro.options.node && isEntry && !code.includes("ROLLUP_NO_REPLACE") ? "_import_meta_url_" : '"file:///_entry.js"';
-      const envImport = nitro.options.node ? "import process from 'node:process';" : "";
-      const env = nitro.options.node ? "process.env" : "{}";
-      const ref = "globalThis._importMeta_";
-      const stub = `{url:${url},env:${env}}`;
-      const stubInit = isEntry ? `${ref}=${stub};` : `${ref}=${ref}||${stub};`;
-      return {
-        code: envImport + stubInit + 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 globby("**", {
-          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 = _etag__default(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 'pathe'
-import assets from '#nitro-internal-virtual/public-assets-data'
-export function readAsset (id) {
-  const serverDir = dirname(fileURLToPath(import.meta.url))
-  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
-  );
-}
-
-const HELPER_ID = "\0raw-helpers";
-function raw(opts = {}) {
-  const extensions = /* @__PURE__ */ new Set([
-    ".md",
-    ".mdx",
-    ".txt",
-    ".css",
-    ".htm",
-    ".html",
-    ...opts.extensions || []
-  ]);
-  return {
-    name: "raw",
-    async resolveId(id, importer) {
-      if (id === HELPER_ID) {
-        return id;
-      }
-      if (id[0] === "\0") {
-        return;
-      }
-      let isRawId = id.startsWith("raw:");
-      if (isRawId) {
-        id = id.slice(4);
-      } else if (extensions.has(extname(id))) {
-        isRawId = true;
-      }
-      if (!isRawId) {
-        return;
-      }
-      const resolvedId = (await this.resolve(id, importer, { skipSelf: true }))?.id;
-      if (!resolvedId || resolvedId.startsWith("\0")) {
-        return resolvedId;
-      }
-      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
-      };
-    }
-  };
-}
-function isBinary(id) {
-  const idMime = mime.getType(id) || "";
-  if (idMime.startsWith("text/")) {
-    return false;
-  }
-  if (/application\/(json|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;
-}
-  `;
-}
-
-const NO_REPLACE_RE = /ROLLUP_NO_REPLACE/;
-function replace(options) {
-  const _plugin = _replace(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 createEtag = _etag.default || _etag;
-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 globby("**/*.*", {
-            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 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);
-      }
-    }
-  };
-}
-
-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": `
-import { createStorage } from 'unstorage'
-import { assets } from '#nitro-internal-virtual/server-assets'
-
-${driverImports.map((i) => genImport(i, genSafeVariableName(i))).join("\n")}
-
-export 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 : ""}
-`
-    },
-    nitro.vfs
-  );
-}
-
-const TIMING = "globalThis.__timing__";
-const iife = (code) => `(function() { ${code.trim()} })();`.replace(/\n/g, "");
-const HELPER = iife(`
-const start = () => Date.now();
-const end = s => Date.now() - s;
-const _s = {};
-const metrics = [];
-const logStart = id => { _s[id] = Date.now(); };
-const logEnd = id => { const t = end(_s[id]); delete _s[id]; metrics.push([id, t]); if (t > 0) { console.debug('>', id + ' (' + t + 'ms)'); } };
-${TIMING} = { start, end, metrics, logStart, logEnd };
-`);
-const HELPERIMPORT = "import './timing.js';";
-function timing(_opts = {}) {
-  return {
-    name: "timing",
-    generateBundle() {
-      this.emitFile({
-        type: "asset",
-        fileName: "timing.js",
-        source: HELPER
-      });
-    },
-    renderChunk(code, chunk) {
-      let name = chunk.fileName || "";
-      name = name.replace(extname(name), "");
-      const logName = name === "index" ? "Nitro Start" : "Load " + name;
-      return {
-        code: (chunk.isEntry ? HELPERIMPORT : "") + `${TIMING}.logStart('${logName}');` + code + `;${TIMING}.logEnd('${logName}');`,
-        map: null
-      };
-    }
-  };
-}
-
-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 getRollupConfig = (nitro) => {
-  const extensions = [
-    ".ts",
-    ".mjs",
-    ".js",
-    ".json",
-    ".node",
-    ".tsx",
-    ".jsx"
-  ];
-  const nodePreset = nitro.options.node === false ? unenv.nodeless : unenv.node;
-  const builtinPreset = {
-    alias: {
-      // General
-      ...nitro.options.dev ? {} : {
-        debug: "unenv/runtime/npm/debug",
-        "consola/core": "consola/core",
-        consola: "unenv/runtime/npm/consola"
-      },
-      ...nitro.options.alias
-    }
-  };
-  const env = unenv.env(nodePreset, builtinPreset, nitro.options.unenv);
-  const buildServerDir = join(nitro.options.buildDir, "dist/server");
-  const presetsDir = resolve(runtimeDir, "../presets");
-  const chunkNamePrefixes = [
-    [nitro.options.buildDir, "build"],
-    [buildServerDir, "app"],
-    [runtimeDir, "nitro"],
-    [presetsDir, "nitro"],
-    ["\0raw:", "raw"],
-    ["\0nitro-wasm:", "wasm"],
-    ["\0", "virtual"]
-  ];
-  function getChunkGroup(id) {
-    if (id.startsWith(runtimeDir) || id.startsWith(presetsDir)) {
-      return "nitro";
-    }
-  }
-  function getChunkName(id) {
-    for (const [dir, name] of chunkNamePrefixes) {
-      if (id.startsWith(dir)) {
-        return `chunks/${name}/[name].mjs`;
-      }
-    }
-    const routeHandler = nitro.options.handlers.find((h) => id.startsWith(h.handler)) || nitro.scannedHandlers.find((h) => id.startsWith(h.handler));
-    if (routeHandler?.route) {
-      const path = routeHandler.route.replace(/:([^/]+)/g, "_$1").replace(/\/[^/]+$/g, "") || "/";
-      return `chunks/routes${path}/[name].mjs`;
-    }
-    const taskHandler = Object.entries(nitro.options.tasks).find(
-      ([_, task]) => task.handler === id
-    );
-    if (taskHandler) {
-      return `chunks/tasks/[name].mjs`;
-    }
-    return `chunks/_/[name].mjs`;
-  }
-  const rollupConfig = defu(nitro.options.rollupConfig, {
-    input: nitro.options.entry,
-    output: {
-      dir: nitro.options.output.serverDir,
-      entryFileNames: "index.mjs",
-      chunkFileNames(chunk) {
-        const lastModule = normalize(chunk.moduleIds.at(-1) || "");
-        return getChunkName(lastModule);
-      },
-      manualChunks(id) {
-        return getChunkGroup(id);
-      },
-      inlineDynamicImports: nitro.options.inlineDynamicImports,
-      format: "esm",
-      exports: "auto",
-      intro: "",
-      outro: "",
-      generatedCode: {
-        constBindings: true
-      },
-      sanitizeFileName: sanitizeFilePath,
-      sourcemap: nitro.options.sourceMap,
-      sourcemapExcludeSources: true,
-      sourcemapIgnoreList(relativePath, sourcemapPath) {
-        return relativePath.includes("node_modules");
-      }
-    },
-    external: env.external,
-    plugins: [],
-    onwarn(warning, rollupWarn) {
-      if (!["CIRCULAR_DEPENDENCY", "EVAL"].includes(warning.code || "") && !warning.message.includes("Unsupported source map comment")) {
-        rollupWarn(warning);
-      }
-    },
-    treeshake: {
-      moduleSideEffects(id) {
-        const normalizedId = normalize(id);
-        const idWithoutNodeModules = normalizedId.split("node_modules/").pop();
-        if (!idWithoutNodeModules) {
-          return false;
-        }
-        if (normalizedId.startsWith(runtimeDir) || idWithoutNodeModules.startsWith(runtimeDir)) {
-          return true;
-        }
-        return nitro.options.moduleSideEffects.some(
-          (m) => normalizedId.startsWith(m) || idWithoutNodeModules.startsWith(m)
-        );
-      }
-    }
-  });
-  if (rollupConfig.output.inlineDynamicImports) {
-    delete rollupConfig.output.manualChunks;
-  }
-  if (nitro.options.timing) {
-    rollupConfig.plugins.push(timing());
-  }
-  if (nitro.options.imports) {
-    rollupConfig.plugins.push(
-      unimportPlugin.rollup(nitro.options.imports)
-    );
-  }
-  rollupConfig.plugins.push(raw());
-  if (nitro.options.experimental.wasm) {
-    rollupConfig.plugins.push(rollup(nitro.options.wasm || {}));
-  }
-  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,
-    // @ts-expect-error
-    "versions.nitro": "",
-    "versions?.nitro": "",
-    // Internal
-    _asyncContext: nitro.options.experimental.asyncContext,
-    _websocket: nitro.options.experimental.websocket,
-    _tasks: nitro.options.experimental.tasks
-  };
-  rollupConfig.plugins.push(importMeta(nitro));
-  rollupConfig.plugins.push(
-    replace({
-      preventAssignment: true,
-      values: {
-        "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(
-          [".", ";", ")", "[", "]", "}", " "].map((d) => [
-            `import.meta${d}`,
-            `globalThis._importMeta_${d}`
-          ])
-        ),
-        ...Object.fromEntries(
-          [";", "(", "{", "}", " ", "	", "\n"].map((d) => [
-            `${d}global.`,
-            `${d}globalThis.`
-          ])
-        ),
-        ...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
-      }
-    })
-  );
-  rollupConfig.plugins.push(
-    esbuild({
-      target: "es2019",
-      sourceMap: nitro.options.sourceMap,
-      ...nitro.options.esbuild?.options
-    })
-  );
-  rollupConfig.plugins.push(serverAssets(nitro));
-  rollupConfig.plugins.push(publicAssets(nitro));
-  rollupConfig.plugins.push(storage(nitro));
-  rollupConfig.plugins.push(database(nitro));
-  rollupConfig.plugins.push(handlers(nitro));
-  if (nitro.options.experimental.openAPI) {
-    rollupConfig.plugins.push(handlersMeta());
-  }
-  rollupConfig.plugins.push(
-    virtual(
-      {
-        "#nitro-internal-pollyfills": env.polyfill.map((p) => `import '${p}';`).join("\n")
-      },
-      nitro.vfs
-    )
-  );
-  rollupConfig.plugins.push(virtual(nitro.options.virtual, nitro.vfs));
-  const nitroPlugins = [...new Set(nitro.options.plugins)];
-  rollupConfig.plugins.push(
-    virtual(
-      {
-        "#nitro-internal-virtual/plugins": `
-${nitroPlugins.map((plugin) => `import _${hash(plugin)} from '${plugin}';`).join("\n")}
-
-export const plugins = [
-  ${nitroPlugins.map((plugin) => `_${hash(plugin)}`).join(",\n")}
-]
-    `
-      },
-      nitro.vfs
-    )
-  );
-  let buildDir = nitro.options.buildDir;
-  if (isWindows && nitro.options.externals?.trace === false && nitro.options.dev) {
-    buildDir = pathToFileURL(buildDir).href;
-  }
-  rollupConfig.plugins.push(
-    alias({
-      entries: resolveAliases({
-        "#build": buildDir,
-        "#nitro-internal-virtual/error-handler": nitro.options.errorHandler,
-        "#internal/nitro": runtimeDir,
-        "nitropack/runtime": runtimeDir,
-        "nitro/runtime": runtimeDir,
-        "~": nitro.options.srcDir,
-        "@/": nitro.options.srcDir,
-        "~~": nitro.options.rootDir,
-        "@@/": nitro.options.rootDir,
-        ...env.alias
-      })
-    })
-  );
-  if (nitro.options.noExternals) {
-    rollupConfig.plugins.push({
-      name: "no-externals",
-      async resolveId(id, from, options) {
-        if (nitro.options.node && (id.startsWith("node:") || builtinModules.includes(id))) {
-          return { id, external: true };
-        }
-        const resolved = await this.resolve(id, from, options);
-        if (!resolved) {
-          const _resolved = await resolvePath(id, {
-            url: nitro.options.nodeModulesDirs,
-            conditions: [
-              "default",
-              nitro.options.dev ? "development" : "production",
-              "node",
-              "import",
-              "require"
-            ]
-          }).catch(() => null);
-          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(
-              from
-            )} and externals are not allowed!`
-          );
-        }
-      }
-    });
-  } else {
-    rollupConfig.plugins.push(
-      externals(
-        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
-        })
-      )
-    );
-  }
-  rollupConfig.plugins.push(
-    nodeResolve({
-      extensions,
-      preferBuiltins: !!nitro.options.node,
-      rootDir: nitro.options.rootDir,
-      modulePaths: nitro.options.nodeModulesDirs,
-      // 'module' is intentionally not supported because of externals
-      mainFields: ["main"],
-      exportConditions: nitro.options.exportConditions
-    })
-  );
-  rollupConfig.plugins.push(
-    commonjs({
-      esmExternals: (id) => !id.startsWith("unenv/"),
-      requireReturnsDefault: "auto",
-      ...nitro.options.commonJS
-    })
-  );
-  rollupConfig.plugins.push(json());
-  rollupConfig.plugins.push(inject(env.inject));
-  if (nitro.options.minify) {
-    const _terser = createRequire(import.meta.url)("@rollup/plugin-terser");
-    const terser = _terser.default || _terser;
-    rollupConfig.plugins.push(
-      terser({
-        mangle: {
-          keep_fnames: true,
-          keep_classnames: true
-        },
-        format: {
-          comments: false
-        }
-      })
-    );
-  }
-  if (nitro.options.sourceMap && !nitro.options.dev && nitro.options.experimental.sourcemapMinify !== false) {
-    rollupConfig.plugins.push(sourcemapMininify());
-  }
-  if (nitro.options.analyze) {
-    rollupConfig.plugins.push(
-      visualizer({
-        ...nitro.options.analyze,
-        filename: (nitro.options.analyze.filename || "stats.html").replace(
-          "{name}",
-          "nitro"
-        ),
-        title: "Nitro Server bundle stats"
-      })
-    );
-  }
-  return rollupConfig;
-};
-
-export { getRollupConfig };