nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_build/prepare.mjs

@@ -0,0 +1,1511 @@
+import consola, { consola as consola$1 } from 'consola';
+import { Hookable, createDebugger } from 'hookable';
+import { w as watchConfig, l as loadConfig } from '../_chunks/_deps/c12.mjs';
+import { r as resolveCompatibilityDatesFromEnv, a as resolveCompatibilityDates } from '../_chunks/_deps/compatx.mjs';
+import { k as klona, a as klona$1 } from '../_chunks/_deps/klona.mjs';
+import { runtimeDir, pkgDir } from 'nitro/runtime/meta';
+import { d, a } from '../_chunks/_deps/std-env.mjs';
+import { r as resolve, j as join, a as relative, d as dirname, n as normalize } from '../_chunks/_deps/pathe.mjs';
+import { existsSync, promises } from 'node:fs';
+import defu$1, { defu } from 'defu';
+import { withLeadingSlash, withoutTrailingSlash, withTrailingSlash, withBase } from 'ufo';
+import { e as escapeStringRegexp } from '../_chunks/_deps/escape-string-regexp.mjs';
+import { g as resolveModuleExportNames } from '../_chunks/_deps/mlly.mjs';
+import { f as findWorkspaceDir } from '../_chunks/_deps/pkg-types.mjs';
+import { r as resolveModulePath } from '../_chunks/_deps/exsolve.mjs';
+import { createJiti } from 'jiti';
+import { g as glob } from '../_chunks/_deps/tinyglobby.mjs';
+import fsp, { stat, mkdir, writeFile as writeFile$1, readFile } from 'node:fs/promises';
+import { ofetch } from 'ofetch';
+import { createStorage as createStorage$1, builtinDrivers } from 'unstorage';
+import { c as createRouter, a as addRoute, b as compileRouterToString, d as findRoute, f as findAllRoutes } from '../_chunks/_deps/rou3.mjs';
+import { hash } from 'ohash';
+import { c as createUnimport } from '../_chunks/_deps/unimport.mjs';
+import { colors } from 'consola/utils';
+import { g as getProperty } from '../_chunks/_deps/dot-prop.mjs';
+import zlib from 'node:zlib';
+import { m as mime } from '../_chunks/_deps/mime.mjs';
+
+const NitroDefaults = {
+  // General
+  compatibilityDate: "latest",
+  debug: d,
+  logLevel: a ? 1 : 3,
+  runtimeConfig: { app: {}, nitro: {} },
+  // Dirs
+  scanDirs: [],
+  buildDir: ".nitro",
+  output: {
+    dir: "{{ rootDir }}/.output",
+    serverDir: "{{ output.dir }}/server",
+    publicDir: "{{ output.dir }}/public"
+  },
+  // Features
+  experimental: {},
+  future: {},
+  storage: {},
+  devStorage: {},
+  bundledStorage: [],
+  publicAssets: [],
+  serverAssets: [],
+  plugins: [],
+  tasks: {},
+  scheduledTasks: {},
+  imports: false,
+  virtual: {},
+  compressPublicAssets: false,
+  ignore: [],
+  // Dev
+  dev: false,
+  devServer: { watch: [] },
+  watchOptions: { ignoreInitial: true },
+  devProxy: {},
+  // Logging
+  logging: {
+    compressedSizes: true,
+    buildSuccess: true
+  },
+  // Routing
+  baseURL: process.env.NITRO_APP_BASE_URL || "/",
+  handlers: [],
+  devHandlers: [],
+  errorHandler: void 0,
+  routeRules: {},
+  prerender: {
+    autoSubfolderIndex: true,
+    concurrency: 1,
+    interval: 0,
+    retry: 3,
+    retryDelay: 500,
+    failOnError: false,
+    crawlLinks: false,
+    ignore: [],
+    routes: []
+  },
+  // Rollup
+  builder: void 0,
+  moduleSideEffects: ["unenv/polyfill/", resolve(runtimeDir, "polyfill/")],
+  replace: {},
+  node: true,
+  sourceMap: true,
+  esbuild: {
+    options: {
+      jsxFactory: "h",
+      jsxFragment: "Fragment"
+    }
+  },
+  // Advanced
+  typescript: {
+    strict: true,
+    generateRuntimeConfigTypes: false,
+    generateTsConfig: false,
+    tsconfigPath: "types/tsconfig.json",
+    internalPaths: false,
+    tsConfig: {}
+  },
+  nodeModulesDirs: [],
+  hooks: {},
+  commands: {},
+  // Framework
+  framework: {
+    name: "nitro",
+    version: ""
+  }
+};
+
+async function resolveAssetsOptions(options) {
+  for (const publicAsset of options.publicAssets) {
+    publicAsset.dir = resolve(options.srcDir, publicAsset.dir);
+    publicAsset.baseURL = withLeadingSlash(
+      withoutTrailingSlash(publicAsset.baseURL || "/")
+    );
+  }
+  for (const dir of options.scanDirs) {
+    const publicDir = resolve(dir, "public");
+    if (!existsSync(publicDir)) {
+      continue;
+    }
+    if (options.publicAssets.some((asset) => asset.dir === publicDir)) {
+      continue;
+    }
+    options.publicAssets.push({ dir: publicDir });
+  }
+  for (const serverAsset of options.serverAssets) {
+    serverAsset.dir = resolve(options.srcDir, serverAsset.dir);
+  }
+  options.serverAssets.push({
+    baseName: "server",
+    dir: resolve(options.srcDir, "assets")
+  });
+  for (const asset of options.publicAssets) {
+    asset.baseURL = asset.baseURL || "/";
+    const isTopLevel = asset.baseURL === "/";
+    asset.fallthrough = asset.fallthrough ?? isTopLevel;
+    const routeRule = options.routeRules[asset.baseURL + "/**"];
+    asset.maxAge = routeRule?.cache?.maxAge ?? asset.maxAge ?? 0;
+    if (asset.maxAge && !asset.fallthrough) {
+      options.routeRules[asset.baseURL + "/**"] = defu(routeRule, {
+        headers: {
+          "cache-control": `public, max-age=${asset.maxAge}, immutable`
+        }
+      });
+    }
+  }
+}
+
+async function resolveCompatibilityOptions(options) {
+  options.compatibilityDate = resolveCompatibilityDatesFromEnv(
+    options.compatibilityDate
+  );
+}
+
+async function resolveDatabaseOptions(options) {
+  if (options.experimental.database && options.imports) {
+    options.imports.presets.push({
+      from: "nitro/runtime/internal/database",
+      imports: ["useDatabase"]
+    });
+    if (options.dev && !options.database && !options.devDatabase) {
+      options.devDatabase = {
+        default: {
+          connector: "sqlite",
+          options: {
+            cwd: options.rootDir
+          }
+        }
+      };
+    } else if (options.node && !options.database) {
+      options.database = {
+        default: {
+          connector: "sqlite",
+          options: {}
+        }
+      };
+    }
+  }
+}
+
+async function resolveExportConditionsOptions(options) {
+  options.exportConditions = _resolveExportConditions(
+    options.exportConditions || [],
+    { dev: options.dev, node: options.node, wasm: options.experimental.wasm }
+  );
+}
+function _resolveExportConditions(conditions, opts) {
+  const resolvedConditions = [];
+  resolvedConditions.push(opts.dev ? "development" : "production");
+  resolvedConditions.push(...conditions);
+  if (opts.node) {
+    resolvedConditions.push("node");
+  } else {
+    resolvedConditions.push(
+      "wintercg",
+      "worker",
+      "web",
+      "browser",
+      "workerd",
+      "edge-light",
+      "netlify",
+      "edge-routine",
+      "deno"
+    );
+  }
+  if (opts.wasm) {
+    resolvedConditions.push("wasm", "unwasm");
+  }
+  resolvedConditions.push("import", "default");
+  if ("Bun" in globalThis) {
+    resolvedConditions.push("bun");
+  } else if ("Deno" in globalThis) {
+    resolvedConditions.push("deno");
+  }
+  return resolvedConditions.filter(
+    (c, i) => resolvedConditions.indexOf(c) === i
+  );
+}
+
+async function resolveImportsOptions(options) {
+  if (options.imports === false) {
+    return;
+  }
+  options.imports.presets ??= [];
+  options.imports.presets.push(...getNitroImportsPreset());
+  const h3Exports = await resolveModuleExportNames("h3", {
+    url: import.meta.url
+  });
+  options.imports.presets ??= [];
+  options.imports.presets.push({
+    from: "h3",
+    imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
+  });
+  options.imports.dirs ??= [];
+  options.imports.dirs.push(
+    ...options.scanDirs.map((dir) => join(dir, "utils/**/*"))
+  );
+  if (Array.isArray(options.imports.exclude) && options.imports.exclude.length === 0) {
+    options.imports.exclude.push(/[/\\]\.git[/\\]/);
+    options.imports.exclude.push(options.buildDir);
+    const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
+    options.imports.exclude.push(
+      scanDirsInNodeModules.length > 0 ? new RegExp(
+        `node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeStringRegexp(dir)).join("|")})`
+      ) : /[/\\]node_modules[/\\]/
+    );
+  }
+}
+function getNitroImportsPreset() {
+  return [
+    {
+      from: "nitro/runtime/internal/app",
+      imports: ["useNitroApp"]
+    },
+    {
+      from: "nitro/runtime/internal/runtime-config",
+      imports: ["useRuntimeConfig"]
+    },
+    {
+      from: "nitro/runtime/internal/plugin",
+      imports: ["defineNitroPlugin", "nitroPlugin"]
+    },
+    {
+      from: "nitro/runtime/internal/cache",
+      imports: [
+        "defineCachedFunction",
+        "defineCachedEventHandler",
+        "defineCachedHandler",
+        "cachedFunction",
+        "cachedEventHandler"
+      ]
+    },
+    {
+      from: "nitro/runtime/internal/storage",
+      imports: ["useStorage"]
+    },
+    {
+      from: "nitro/runtime/internal/renderer",
+      imports: ["defineRenderHandler"]
+    },
+    {
+      from: "nitro/runtime/internal/meta",
+      imports: ["defineRouteMeta"]
+    },
+    {
+      from: "nitro/runtime/internal/route-rules",
+      imports: ["getRouteRules"]
+    },
+    {
+      from: "nitro/runtime/internal/context",
+      imports: ["useRequest"]
+    },
+    {
+      from: "nitro/runtime/internal/task",
+      imports: ["defineTask", "runTask"]
+    },
+    {
+      from: "nitro/runtime/internal/error/utils",
+      imports: ["defineNitroErrorHandler"]
+    },
+    {
+      from: "nitro/deps/ofetch",
+      imports: ["$fetch"]
+    }
+  ];
+}
+
+async function resolveOpenAPIOptions(options) {
+  if (!options.experimental.openAPI) {
+    return;
+  }
+  if (!options.dev && !options.openAPI?.production) {
+    return;
+  }
+  const shouldPrerender = !options.dev && options.openAPI?.production === "prerender";
+  const handlersEnv = shouldPrerender ? "prerender" : "";
+  const prerenderRoutes = [];
+  const jsonRoute = options.openAPI?.route || "/_openapi.json";
+  prerenderRoutes.push(jsonRoute);
+  options.handlers.push({
+    route: jsonRoute,
+    env: handlersEnv,
+    handler: join(runtimeDir, "internal/routes/openapi")
+  });
+  if (options.openAPI?.ui?.scalar !== false) {
+    const scalarRoute = options.openAPI?.ui?.scalar?.route || "/_scalar";
+    prerenderRoutes.push(scalarRoute);
+    options.handlers.push({
+      route: options.openAPI?.ui?.scalar?.route || "/_scalar",
+      env: handlersEnv,
+      handler: join(runtimeDir, "internal/routes/scalar")
+    });
+  }
+  if (options.openAPI?.ui?.swagger !== false) {
+    const swaggerRoute = options.openAPI?.ui?.swagger?.route || "/_swagger";
+    prerenderRoutes.push(swaggerRoute);
+    options.handlers.push({
+      route: swaggerRoute,
+      env: handlersEnv,
+      handler: join(runtimeDir, "internal/routes/swagger")
+    });
+  }
+  if (shouldPrerender) {
+    options.prerender ??= {};
+    options.prerender.routes ??= [];
+    options.prerender.routes.push(...prerenderRoutes);
+  }
+}
+
+function prettyPath(p, highlight = true) {
+  p = relative(process.cwd(), p);
+  return highlight ? colors.cyan(p) : p;
+}
+function resolveNitroPath(path, nitroOptions, base) {
+  if (typeof path !== "string") {
+    throw new TypeError("Invalid path: " + path);
+  }
+  path = _compilePathTemplate(path)(nitroOptions);
+  for (const base2 in nitroOptions.alias) {
+    if (path.startsWith(base2)) {
+      path = nitroOptions.alias[base2] + path.slice(base2.length);
+    }
+  }
+  return resolve(base || nitroOptions.srcDir, path);
+}
+function _compilePathTemplate(contents) {
+  return (params) => contents.replace(/{{ ?([\w.]+) ?}}/g, (_, match) => {
+    const val = getProperty(params, match);
+    if (!val) {
+      consola.warn(
+        `cannot resolve template param '${match}' in ${contents.slice(0, 20)}`
+      );
+    }
+    return val || `${match}`;
+  });
+}
+async function writeFile(file, contents, log = false) {
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile$1(
+    file,
+    contents,
+    typeof contents === "string" ? "utf8" : void 0
+  );
+  if (log) {
+    consola.info("Generated", prettyPath(file));
+  }
+}
+async function isDirectory(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+const RESOLVE_EXTENSIONS = [".ts", ".js", ".mts", ".mjs", ".tsx", ".jsx"];
+async function resolvePathOptions(options) {
+  options.rootDir = resolve(options.rootDir || ".") + "/";
+  options.workspaceDir ||= await findWorkspaceDir(options.rootDir).catch(() => options.rootDir) + "/";
+  for (const key of ["srcDir", "buildDir"]) {
+    options[key] = resolve(options.rootDir, options[key] || ".");
+  }
+  options.alias ??= {};
+  if (!options.static && !options.entry) {
+    throw new Error(
+      `Nitro entry is missing! Is "${options.preset}" preset correct?`
+    );
+  }
+  if (options.entry) {
+    options.entry = resolveNitroPath(options.entry, options);
+  }
+  options.output.dir = resolveNitroPath(
+    options.output.dir || NitroDefaults.output.dir,
+    options,
+    options.rootDir
+  ) + "/";
+  options.output.publicDir = resolveNitroPath(
+    options.output.publicDir || NitroDefaults.output.publicDir,
+    options,
+    options.rootDir
+  ) + "/";
+  options.output.serverDir = resolveNitroPath(
+    options.output.serverDir || NitroDefaults.output.serverDir,
+    options,
+    options.rootDir
+  ) + "/";
+  options.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, "dist/node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, ".."));
+  options.nodeModulesDirs = [
+    ...new Set(
+      // Adding trailing slash to optimize resolve performance (path is explicitly a dir)
+      options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir) + "/")
+    )
+  ];
+  options.plugins = options.plugins.map((p) => resolveNitroPath(p, options));
+  options.scanDirs.unshift(options.srcDir);
+  options.scanDirs = options.scanDirs.map(
+    (dir) => resolve(options.srcDir, dir)
+  );
+  options.scanDirs = [...new Set(options.scanDirs.map((dir) => dir + "/"))];
+  if (options.serverEntry) {
+    options.serverEntry = resolveModulePath(
+      resolveNitroPath(options.serverEntry, options),
+      {
+        from: options.scanDirs,
+        extensions: RESOLVE_EXTENSIONS
+      }
+    );
+  } else {
+    const defaultServerEntry = resolveModulePath("./server", {
+      from: options.scanDirs,
+      extensions: RESOLVE_EXTENSIONS,
+      try: true
+    });
+    if (defaultServerEntry) {
+      options.serverEntry = defaultServerEntry;
+      consola.info(
+        `Using \`${prettyPath(defaultServerEntry)}\` as server entry.`
+      );
+    }
+  }
+  if (options.renderer?.entry) {
+    options.renderer.entry = resolveModulePath(
+      resolveNitroPath(options.renderer?.entry, options),
+      {
+        from: options.scanDirs,
+        extensions: RESOLVE_EXTENSIONS
+      }
+    );
+  }
+  if (options.renderer?.template) {
+    options.renderer.template = resolveModulePath(
+      resolveNitroPath(options.renderer?.template, options),
+      {
+        from: options.scanDirs,
+        extensions: [".html"]
+      }
+    );
+  } else if (!options.renderer?.entry) {
+    const defaultIndex = resolveModulePath("./index.html", {
+      from: options.scanDirs,
+      extensions: [".html"],
+      try: true
+    });
+    if (defaultIndex) {
+      options.renderer ??= {};
+      options.renderer.template = defaultIndex;
+      consola.info(
+        `Using \`${prettyPath(defaultIndex)}\` as renderer template.`
+      );
+    }
+  }
+  if (options.renderer?.template && !options.renderer?.entry) {
+    options.renderer ??= {};
+    options.renderer.entry = join(
+      runtimeDir,
+      "internal/routes/renderer-template" + (options.dev ? ".dev" : "")
+    );
+  }
+}
+
+async function resolveRouteRulesOptions(options) {
+  options.routeRules = defu(options.routeRules, options.routes || {});
+  options.routeRules = normalizeRouteRules(options);
+}
+function normalizeRouteRules(config) {
+  const normalizedRules = {};
+  for (let path in config.routeRules) {
+    const routeConfig = config.routeRules[path];
+    path = withLeadingSlash(path);
+    const routeRules = {
+      ...routeConfig,
+      redirect: void 0,
+      proxy: void 0
+    };
+    if (routeConfig.redirect) {
+      routeRules.redirect = {
+        // @ts-ignore
+        to: "/",
+        status: 307,
+        ...typeof routeConfig.redirect === "string" ? { to: routeConfig.redirect } : routeConfig.redirect
+      };
+      if (path.endsWith("/**")) {
+        routeRules.redirect._redirectStripBase = path.slice(0, -3);
+      }
+    }
+    if (routeConfig.proxy) {
+      routeRules.proxy = typeof routeConfig.proxy === "string" ? { to: routeConfig.proxy } : routeConfig.proxy;
+      if (path.endsWith("/**")) {
+        routeRules.proxy._proxyStripBase = path.slice(0, -3);
+      }
+    }
+    if (routeConfig.cors) {
+      routeRules.headers = {
+        "access-control-allow-origin": "*",
+        "access-control-allow-methods": "*",
+        "access-control-allow-headers": "*",
+        "access-control-max-age": "0",
+        ...routeRules.headers
+      };
+    }
+    if (routeConfig.swr) {
+      routeRules.cache = routeRules.cache || {};
+      routeRules.cache.swr = true;
+      if (typeof routeConfig.swr === "number") {
+        routeRules.cache.maxAge = routeConfig.swr;
+      }
+    }
+    if (routeConfig.cache === false) {
+      routeRules.cache = false;
+    }
+    normalizedRules[path] = routeRules;
+  }
+  return normalizedRules;
+}
+
+async function resolveRuntimeConfigOptions(options) {
+  options.runtimeConfig = normalizeRuntimeConfig(options);
+}
+function normalizeRuntimeConfig(config) {
+  provideFallbackValues(config.runtimeConfig || {});
+  const runtimeConfig = defu$1(
+    config.runtimeConfig,
+    {
+      app: {
+        baseURL: config.baseURL
+      },
+      nitro: {
+        envExpansion: config.experimental?.envExpansion,
+        openAPI: config.openAPI
+      }
+    }
+  );
+  runtimeConfig.nitro.routeRules = config.routeRules;
+  checkSerializableRuntimeConfig(runtimeConfig);
+  return runtimeConfig;
+}
+function provideFallbackValues(obj) {
+  for (const key in obj) {
+    if (obj[key] === void 0 || obj[key] === null) {
+      obj[key] = "";
+    } else if (typeof obj[key] === "object") {
+      provideFallbackValues(obj[key]);
+    }
+  }
+}
+function checkSerializableRuntimeConfig(obj, path = []) {
+  if (isPrimitiveValue(obj)) {
+    return;
+  }
+  for (const key in obj) {
+    const value = obj[key];
+    if (value === null || value === void 0 || isPrimitiveValue(value)) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const [index, item] of value.entries())
+        checkSerializableRuntimeConfig(item, [...path, `${key}[${index}]`]);
+    } else if (typeof value === "object" && value.constructor === Object && (!value.constructor?.name || value.constructor.name === "Object")) {
+      checkSerializableRuntimeConfig(value, [...path, key]);
+    } else {
+      console.warn(
+        `Runtime config option \`${[...path, key].join(".")}\` may not be able to be serialized.`
+      );
+    }
+  }
+}
+function isPrimitiveValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+
+async function resolveStorageOptions(options) {
+  const fsMounts = {
+    root: resolve(options.rootDir),
+    src: resolve(options.srcDir),
+    build: resolve(options.buildDir),
+    cache: resolve(options.buildDir, "cache")
+  };
+  for (const p in fsMounts) {
+    options.devStorage[p] = options.devStorage[p] || {
+      driver: "fs",
+      readOnly: p === "root" || p === "src",
+      base: fsMounts[p]
+    };
+  }
+  if (options.dev && options.storage.data === void 0 && options.devStorage.data === void 0) {
+    options.devStorage.data = {
+      driver: "fs",
+      base: resolve(options.rootDir, ".data/kv")
+    };
+  } else if (options.node && options.storage.data === void 0) {
+    options.storage.data = {
+      driver: "fsLite",
+      base: "./.data/kv"
+    };
+  }
+}
+
+async function resolveURLOptions(options) {
+  options.baseURL = withLeadingSlash(withTrailingSlash(options.baseURL));
+}
+
+async function resolveErrorOptions(options) {
+  if (!options.errorHandler) {
+    options.errorHandler = [];
+  } else if (!Array.isArray(options.errorHandler)) {
+    options.errorHandler = [options.errorHandler];
+  }
+  options.errorHandler.push(
+    join(runtimeDir, `internal/error/${options.dev ? "dev" : "prod"}`)
+  );
+}
+
+const common = {
+  meta: {
+    name: "nitro-common",
+    url: import.meta.url
+  },
+  alias: {
+    "buffer/": "node:buffer",
+    "buffer/index": "node:buffer",
+    "buffer/index.js": "node:buffer",
+    "string_decoder/": "node:string_decoder",
+    "process/": "node:process"
+  }
+};
+const nodeless = {
+  meta: {
+    name: "nitro-nodeless",
+    url: import.meta.url
+  },
+  inject: {
+    global: "unenv/polyfill/globalthis",
+    process: "node:process",
+    Buffer: ["node:buffer", "Buffer"],
+    clearImmediate: ["node:timers", "clearImmediate"],
+    setImmediate: ["node:timers", "setImmediate"],
+    performance: "unenv/polyfill/performance",
+    PerformanceObserver: ["node:perf_hooks", "PerformanceObserver"],
+    BroadcastChannel: ["node:worker_threads", "BroadcastChannel"]
+  },
+  polyfill: [
+    "unenv/polyfill/globalthis-global",
+    "unenv/polyfill/process",
+    "unenv/polyfill/buffer",
+    "unenv/polyfill/timers"
+  ]
+};
+async function resolveUnenv(options) {
+  options.unenv ??= [];
+  if (!Array.isArray(options.unenv)) {
+    options.unenv = [options.unenv];
+  }
+  options.unenv = options.unenv.filter(Boolean);
+  if (!options.node) {
+    options.unenv.unshift(nodeless);
+  }
+  options.unenv.unshift(common);
+}
+
+async function resolveBuilder(options) {
+  if (!options.builder) {
+    options.builder = process.env.NITRO_BUILDER || "rollup";
+  }
+  if (options.builder === "rolldown") {
+    try {
+      await import('rolldown');
+    } catch {
+      throw new Error(
+        `Builder "rolldown" is not available. Make sure to install "rolldown" package.`
+      );
+    }
+  } else if (options.builder === "vite") {
+    try {
+      await import('vite');
+    } catch {
+      throw new Error(
+        `Builder "vite" is not available. Make sure to install "vite" package.`
+      );
+    }
+  }
+  if (!["rollup", "rolldown", "vite"].includes(options.builder)) {
+    throw new Error(`Builder "${options.builder}" is not supported.`);
+  }
+}
+
+const configResolvers = [
+  resolveCompatibilityOptions,
+  resolvePathOptions,
+  resolveImportsOptions,
+  resolveRouteRulesOptions,
+  resolveDatabaseOptions,
+  resolveExportConditionsOptions,
+  resolveRuntimeConfigOptions,
+  resolveOpenAPIOptions,
+  resolveURLOptions,
+  resolveAssetsOptions,
+  resolveStorageOptions,
+  resolveErrorOptions,
+  resolveUnenv,
+  resolveBuilder
+];
+async function loadOptions(configOverrides = {}, opts = {}) {
+  const options = await _loadUserConfig(configOverrides, opts);
+  for (const resolver of configResolvers) {
+    await resolver(options);
+  }
+  return options;
+}
+async function _loadUserConfig(configOverrides = {}, opts = {}) {
+  configOverrides = klona(configOverrides);
+  globalThis.defineNitroConfig = globalThis.defineNitroConfig || ((c) => c);
+  let compatibilityDate = configOverrides.compatibilityDate || opts.compatibilityDate || (process.env.NITRO_COMPATIBILITY_DATE || process.env.SERVER_COMPATIBILITY_DATE || process.env.COMPATIBILITY_DATE);
+  const { resolvePreset } = await import('../_chunks/_presets/index.mjs');
+  let preset = configOverrides.preset || process.env.NITRO_PRESET || process.env.SERVER_PRESET;
+  const _dotenv = opts.dotenv ?? (configOverrides.dev && { fileName: [".env", ".env.local"] });
+  const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
+    name: "nitro",
+    cwd: configOverrides.rootDir,
+    dotenv: _dotenv,
+    extend: { extendKey: ["extends", "preset"] },
+    defaults: NitroDefaults,
+    jitiOptions: {
+      alias: {
+        nitropack: "nitro/config",
+        "nitro/config": "nitro/config"
+      }
+    },
+    async overrides({ rawConfigs }) {
+      const getConf = (key) => configOverrides[key] ?? rawConfigs.main?.[key] ?? rawConfigs.rc?.[key] ?? rawConfigs.packageJson?.[key];
+      if (!compatibilityDate) {
+        compatibilityDate = getConf("compatibilityDate");
+      }
+      const framework = getConf("framework");
+      const isCustomFramework = framework?.name && framework.name !== "nitro";
+      if (!preset) {
+        preset = getConf("preset");
+      }
+      if (configOverrides.dev) {
+        preset = preset && preset !== "nitro-dev" ? await resolvePreset(preset, {
+          static: getConf("static"),
+          dev: true,
+          compatibilityDate: compatibilityDate || "latest"
+        }).then((p) => p?._meta?.name || "nitro-dev").catch(() => "nitro-dev") : "nitro-dev";
+      } else if (!preset) {
+        preset = await resolvePreset("", {
+          static: getConf("static"),
+          dev: false,
+          compatibilityDate: compatibilityDate || "latest"
+        }).then((p) => p?._meta?.name);
+      }
+      return {
+        ...configOverrides,
+        preset,
+        typescript: {
+          generateRuntimeConfigTypes: !isCustomFramework,
+          ...getConf("typescript"),
+          ...configOverrides.typescript
+        }
+      };
+    },
+    async resolve(id) {
+      const preset2 = await resolvePreset(id, {
+        static: configOverrides.static,
+        compatibilityDate: compatibilityDate || "latest",
+        dev: configOverrides.dev
+      });
+      if (preset2) {
+        return {
+          config: klona(preset2)
+        };
+      }
+    },
+    ...opts.c12
+  });
+  const options = klona(loadedConfig.config);
+  options._config = configOverrides;
+  options._c12 = loadedConfig;
+  const _presetName = (loadedConfig.layers || []).find((l) => l.config?._meta?.name)?.config?._meta?.name || preset;
+  options.preset = _presetName;
+  options.compatibilityDate = resolveCompatibilityDates(
+    compatibilityDate,
+    options.compatibilityDate
+  );
+  if (options.dev && options.preset !== "nitro-dev") {
+    consola.info(`Using \`${options.preset}\` emulation in development mode.`);
+  }
+  return options;
+}
+
+async function updateNitroConfig(nitro, config) {
+  nitro.options.routeRules = normalizeRouteRules(
+    config.routeRules ? config : nitro.options
+  );
+  nitro.options.runtimeConfig = normalizeRuntimeConfig(
+    config.runtimeConfig ? config : nitro.options
+  );
+  await nitro.hooks.callHook("rollup:reload");
+  consola.success("Nitro config hot reloaded!");
+}
+
+async function installModules(nitro) {
+  const _modules = [...nitro.options.modules || []];
+  const modules = await Promise.all(
+    _modules.map((mod) => _resolveNitroModule(mod, nitro.options))
+  );
+  const _installedURLs = /* @__PURE__ */ new Set();
+  for (const mod of modules) {
+    if (mod._url) {
+      if (_installedURLs.has(mod._url)) {
+        continue;
+      }
+      _installedURLs.add(mod._url);
+    }
+    await mod.setup(nitro);
+  }
+}
+async function _resolveNitroModule(mod, nitroOptions) {
+  let _url;
+  if (typeof mod === "string") {
+    globalThis.defineNitroModule = // @ts-ignore
+    globalThis.defineNitroModule || ((mod2) => mod2);
+    const jiti = createJiti(nitroOptions.rootDir, {
+      alias: nitroOptions.alias
+    });
+    const _modPath = jiti.esmResolve(mod);
+    _url = _modPath;
+    mod = await jiti.import(_modPath, { default: true });
+  }
+  if (typeof mod === "function") {
+    mod = { setup: mod };
+  }
+  if (!mod.setup) {
+    mod.setup = () => {
+    };
+  }
+  return {
+    _url,
+    ...mod
+  };
+}
+
+const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+const suffixRegex = /(\.(?<method>connect|delete|get|head|options|patch|post|put|trace))?(\.(?<env>dev|prod|prerender))?$/;
+async function scanAndSyncOptions(nitro) {
+  const scannedPlugins = await scanPlugins(nitro);
+  for (const plugin of scannedPlugins) {
+    if (!nitro.options.plugins.includes(plugin)) {
+      nitro.options.plugins.push(plugin);
+    }
+  }
+  if (nitro.options.experimental.tasks) {
+    const scannedTasks = await scanTasks(nitro);
+    for (const scannedTask of scannedTasks) {
+      if (scannedTask.name in nitro.options.tasks) {
+        if (!nitro.options.tasks[scannedTask.name].handler) {
+          nitro.options.tasks[scannedTask.name].handler = scannedTask.handler;
+        }
+      } else {
+        nitro.options.tasks[scannedTask.name] = {
+          handler: scannedTask.handler,
+          description: ""
+        };
+      }
+    }
+  }
+  const scannedModules = await scanModules(nitro);
+  nitro.options.modules = nitro.options.modules || [];
+  for (const modPath of scannedModules) {
+    if (!nitro.options.modules.includes(modPath)) {
+      nitro.options.modules.push(modPath);
+    }
+  }
+}
+async function scanHandlers(nitro) {
+  const middleware = await scanMiddleware(nitro);
+  const handlers = await Promise.all([
+    scanServerRoutes(
+      nitro,
+      nitro.options.apiDir || "api",
+      nitro.options.apiBaseURL || "/api"
+    ),
+    scanServerRoutes(nitro, nitro.options.routesDir || "routes")
+  ]).then((r) => r.flat());
+  nitro.scannedHandlers = [
+    ...middleware,
+    ...handlers.filter((h, index, array) => {
+      return array.findIndex(
+        (h2) => h.route === h2.route && h.method === h2.method && h.env === h2.env
+      ) === index;
+    })
+  ];
+  return handlers;
+}
+async function scanMiddleware(nitro) {
+  const files = await scanFiles(nitro, "middleware");
+  return files.map((file) => {
+    return {
+      route: "/**",
+      middleware: true,
+      handler: file.fullPath
+    };
+  });
+}
+async function scanServerRoutes(nitro, dir, prefix = "/") {
+  const files = await scanFiles(nitro, dir);
+  return files.map((file) => {
+    let route = file.path.replace(/\.[A-Za-z]+$/, "").replace(/\(([^(/\\]+)\)[/\\]/g, "").replace(/\[\.{3}]/g, "**").replace(/\[\.{3}(\w+)]/g, "**:$1").replace(/\[([^/\]]+)]/g, ":$1");
+    route = withLeadingSlash(withoutTrailingSlash(withBase(route, prefix)));
+    const suffixMatch = route.match(suffixRegex);
+    let method;
+    let env;
+    if (suffixMatch?.index && suffixMatch?.index >= 0) {
+      route = route.slice(0, suffixMatch.index);
+      method = suffixMatch.groups?.method;
+      env = suffixMatch.groups?.env;
+    }
+    route = route.replace(/\/index$/, "") || "/";
+    return {
+      handler: file.fullPath,
+      lazy: true,
+      middleware: false,
+      route,
+      method,
+      env
+    };
+  });
+}
+async function scanPlugins(nitro) {
+  const files = await scanFiles(nitro, "plugins");
+  return files.map((f) => f.fullPath);
+}
+async function scanTasks(nitro) {
+  const files = await scanFiles(nitro, "tasks");
+  return files.map((f) => {
+    const name = f.path.replace(/\/index$/, "").replace(/\.[A-Za-z]+$/, "").replace(/\//g, ":");
+    return { name, handler: f.fullPath };
+  });
+}
+async function scanModules(nitro) {
+  const files = await scanFiles(nitro, "modules");
+  return files.map((f) => f.fullPath);
+}
+async function scanFiles(nitro, name) {
+  const files = await Promise.all(
+    nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name))
+  ).then((r) => r.flat());
+  return files;
+}
+async function scanDir(nitro, dir, name) {
+  const fileNames = await glob(join(name, GLOB_SCAN_PATTERN), {
+    cwd: dir,
+    dot: true,
+    ignore: nitro.options.ignore,
+    absolute: true
+  }).catch((error) => {
+    if (error?.code === "ENOTDIR") {
+      nitro.logger.warn(
+        `Ignoring \`${join(dir, name)}\`. It must be a directory.`
+      );
+      return [];
+    }
+    throw error;
+  });
+  return fileNames.map((fullPath) => {
+    return {
+      fullPath,
+      path: relative(join(dir, name), fullPath)
+    };
+  }).sort((a, b) => a.path.localeCompare(b.path));
+}
+
+async function runTask(taskEvent, opts) {
+  const ctx = await _getTasksContext(opts);
+  const result = await ctx.devFetch(`/_nitro/tasks/${taskEvent.name}`, {
+    method: "POST",
+    body: taskEvent
+  });
+  return result;
+}
+async function listTasks(opts) {
+  const ctx = await _getTasksContext(opts);
+  const res = await ctx.devFetch("/_nitro/tasks");
+  return res.tasks;
+}
+function addNitroTasksVirtualFile(nitro) {
+  nitro.options.virtual["#nitro-internal-virtual/tasks"] = () => {
+    const _scheduledTasks = Object.entries(nitro.options.scheduledTasks || {}).map(([cron, _tasks]) => {
+      const tasks = (Array.isArray(_tasks) ? _tasks : [_tasks]).filter(
+        (name) => {
+          if (!nitro.options.tasks[name]) {
+            nitro.logger.warn(`Scheduled task \`${name}\` is not defined!`);
+            return false;
+          }
+          return true;
+        }
+      );
+      return { cron, tasks };
+    }).filter((e) => e.tasks.length > 0);
+    const scheduledTasks = _scheduledTasks.length > 0 ? _scheduledTasks : false;
+    return (
+      /* js */
+      `
+export const scheduledTasks = ${JSON.stringify(scheduledTasks)};
+
+export const tasks = {
+  ${Object.entries(nitro.options.tasks).map(
+        ([name, task]) => `"${name}": {
+          meta: {
+            description: ${JSON.stringify(task.description)},
+          },
+          resolve: ${task.handler ? `() => import("${normalize(
+          task.handler
+        )}").then(r => r.default || r)` : "undefined"},
+        }`
+      ).join(",\n")}
+};`
+    );
+  };
+}
+const _devHint = `(is dev server running?)`;
+async function _getTasksContext(opts) {
+  const cwd = resolve(process.cwd(), opts?.cwd || ".");
+  const outDir = resolve(cwd, opts?.buildDir || ".nitro");
+  const buildInfoPath = resolve(outDir, "nitro.json");
+  if (!existsSync(buildInfoPath)) {
+    throw new Error(`Missing info file: \`${buildInfoPath}\` ${_devHint}`);
+  }
+  const buildInfo = JSON.parse(
+    await readFile(buildInfoPath, "utf8")
+  );
+  if (!buildInfo.dev?.pid || !buildInfo.dev?.workerAddress) {
+    throw new Error(
+      `Missing dev server info in: \`${buildInfoPath}\` ${_devHint}`
+    );
+  }
+  if (!_pidIsRunning(buildInfo.dev.pid)) {
+    throw new Error(`Dev server is not running (pid: ${buildInfo.dev.pid})`);
+  }
+  const devFetch = ofetch.create({
+    baseURL: `http://${buildInfo.dev.workerAddress.host || "localhost"}:${buildInfo.dev.workerAddress.port || "3000"}`,
+    // @ts-expect-error
+    socketPath: buildInfo.dev.workerAddress.socketPath
+  });
+  return {
+    buildInfo,
+    devFetch
+  };
+}
+function _pidIsRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function createStorage(nitro) {
+  const storage = createStorage$1();
+  const mounts = klona$1({
+    ...nitro.options.storage,
+    ...nitro.options.devStorage
+  });
+  for (const [path, opts] of Object.entries(mounts)) {
+    if (opts.driver) {
+      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
+      storage.mount(path, driver(opts));
+    } else {
+      nitro.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
+    }
+  }
+  return storage;
+}
+async function snapshotStorage(nitro) {
+  const data = {};
+  const allKeys = [
+    ...new Set(
+      await Promise.all(
+        nitro.options.bundledStorage.map((base) => nitro.storage.getKeys(base))
+      ).then((r) => r.flat())
+    )
+  ];
+  await Promise.all(
+    allKeys.map(async (key) => {
+      data[key] = await nitro.storage.getItem(key);
+    })
+  );
+  return data;
+}
+
+const isGlobalMiddleware = (h) => !h.method && (!h.route || h.route === "/**");
+function initNitroRouting(nitro) {
+  const envConditions = new Set(
+    [
+      nitro.options.dev ? "dev" : "prod",
+      nitro.options.preset,
+      nitro.options.preset === "nitro-prerender" ? "prerender" : void 0
+    ].filter(Boolean)
+  );
+  const matchesEnv = (h) => {
+    const hEnv = Array.isArray(h.env) ? h.env : [h.env];
+    const envs = hEnv.filter(Boolean);
+    return envs.length === 0 || envs.some((env) => envConditions.has(env));
+  };
+  const routes = new Router();
+  const routeRules = new Router(
+    true
+    /* matchAll */
+  );
+  const globalMiddleware = [];
+  const routedMiddleware = new Router(
+    true
+    /* matchAll */
+  );
+  const warns = /* @__PURE__ */ new Set();
+  const sync = () => {
+    routeRules._update(
+      Object.entries(nitro.options.routeRules).map(([route, data]) => ({
+        route,
+        method: "",
+        data: {
+          ...data,
+          _route: route
+        }
+      }))
+    );
+    const _routes = [
+      ...nitro.scannedHandlers,
+      ...nitro.options.handlers
+    ].filter((h) => h && !h.middleware && matchesEnv(h));
+    if (nitro.options.renderer?.entry) {
+      const existingWildcard = _routes.findIndex(
+        (h) => /^\/\*\*(:.+)?$/.test(h.route) && (!h.method || h.method === "GET")
+      );
+      if (existingWildcard !== -1) {
+        const h = _routes[existingWildcard];
+        const warn = `The renderer will override \`${relative(".", h.handler)}\` (route: \`${h.route}\`). Use a more specific route or different HTTP method.`;
+        if (!warns.has(warn)) {
+          warns.add(warn);
+          nitro.logger.warn(warn);
+        }
+        _routes.splice(existingWildcard, 1);
+      }
+      _routes.push({
+        route: "/**",
+        lazy: true,
+        handler: nitro.options.renderer?.entry
+      });
+    }
+    routes._update(
+      _routes.map((h) => ({
+        ...h,
+        method: h.method || "",
+        data: handlerWithImportHash(h)
+      }))
+    );
+    const _middleware = [
+      ...nitro.scannedHandlers,
+      ...nitro.options.handlers
+    ].filter((h) => h && h.middleware && matchesEnv(h));
+    if (nitro.options.serveStatic) {
+      _middleware.unshift({
+        route: "/**",
+        middleware: true,
+        handler: join(runtimeDir, "internal/static")
+      });
+    }
+    globalMiddleware.splice(
+      0,
+      globalMiddleware.length,
+      ..._middleware.filter((h) => isGlobalMiddleware(h)).map((m) => handlerWithImportHash(m))
+    );
+    routedMiddleware._update(
+      _middleware.filter((h) => !isGlobalMiddleware(h)).map((h) => ({
+        ...h,
+        method: h.method || "",
+        data: handlerWithImportHash(h)
+      }))
+    );
+  };
+  nitro.routing = Object.freeze({
+    sync,
+    routes,
+    routeRules,
+    globalMiddleware,
+    routedMiddleware
+  });
+}
+function handlerWithImportHash(h) {
+  const id = (h.lazy ? "_lazy_" : "_") + hash(h.handler).replace(/-/g, "").slice(0, 6);
+  return { ...h, _importHash: id };
+}
+class Router {
+  #routes;
+  #router;
+  #compiled;
+  constructor(matchAll) {
+    this._update([]);
+  }
+  get routes() {
+    return this.#routes;
+  }
+  _update(routes) {
+    this.#routes = routes;
+    this.#router = createRouter();
+    this.#compiled = void 0;
+    for (const route of routes) {
+      addRoute(this.#router, route.method, route.route, route.data);
+    }
+  }
+  hasRoutes() {
+    return this.#routes.length > 0;
+  }
+  compileToString(opts) {
+    return this.#compiled || (this.#compiled = compileRouterToString(this.#router, void 0, opts));
+  }
+  match(method, path) {
+    return findRoute(this.#router, method, path)?.data;
+  }
+  matchAll(method, path) {
+    return findAllRoutes(this.#router, method, path).map(
+      (route) => route.data
+    );
+  }
+}
+
+async function createNitro(config = {}, opts = {}) {
+  const options = await loadOptions(config, opts);
+  const nitro = {
+    options,
+    hooks: new Hookable(),
+    vfs: {},
+    routing: {},
+    logger: consola$1.withTag("nitro"),
+    scannedHandlers: [],
+    close: () => Promise.resolve(nitro.hooks.callHook("close")),
+    storage: void 0,
+    async updateConfig(config2) {
+      updateNitroConfig(nitro, config2);
+    }
+  };
+  initNitroRouting(nitro);
+  await scanAndSyncOptions(nitro);
+  nitro.storage = await createStorage(nitro);
+  nitro.hooks.hook("close", async () => {
+    await nitro.storage.dispose();
+  });
+  if (nitro.options.debug) {
+    createDebugger(nitro.hooks, { tag: "nitro" });
+  }
+  if (nitro.options.logLevel !== void 0) {
+    nitro.logger.level = nitro.options.logLevel;
+  }
+  nitro.hooks.addHooks(nitro.options.hooks);
+  addNitroTasksVirtualFile(nitro);
+  await installModules(nitro);
+  if (nitro.options.imports) {
+    nitro.unimport = createUnimport(nitro.options.imports);
+    await nitro.unimport.init();
+    nitro.options.virtual["#imports"] = () => nitro.unimport?.toExports() || "";
+    nitro.options.virtual["#nitro"] = 'export * from "#imports"';
+  }
+  await scanHandlers(nitro);
+  nitro.routing.sync();
+  return nitro;
+}
+
+async function compressPublicAssets(nitro) {
+  const publicFiles = await glob("**", {
+    cwd: nitro.options.output.publicDir,
+    absolute: false,
+    dot: true,
+    ignore: ["**/*.gz", "**/*.br"]
+  });
+  await Promise.all(
+    publicFiles.map(async (fileName) => {
+      const filePath = resolve(nitro.options.output.publicDir, fileName);
+      if (existsSync(filePath + ".gz") || existsSync(filePath + ".br")) {
+        return;
+      }
+      const mimeType = mime.getType(fileName) || "text/plain";
+      const fileContents = await fsp.readFile(filePath);
+      if (fileContents.length < 1024 || fileName.endsWith(".map") || !isCompressibleMime(mimeType)) {
+        return;
+      }
+      const { gzip, brotli } = nitro.options.compressPublicAssets || {};
+      const encodings = [
+        gzip !== false && "gzip",
+        brotli !== false && "br"
+      ].filter(Boolean);
+      await Promise.all(
+        encodings.map(async (encoding) => {
+          const suffix = "." + (encoding === "gzip" ? "gz" : "br");
+          const compressedPath = filePath + suffix;
+          if (existsSync(compressedPath)) {
+            return;
+          }
+          const gzipOptions = { level: zlib.constants.Z_BEST_COMPRESSION };
+          const brotliOptions = {
+            [zlib.constants.BROTLI_PARAM_MODE]: isTextMime(mimeType) ? zlib.constants.BROTLI_MODE_TEXT : zlib.constants.BROTLI_MODE_GENERIC,
+            [zlib.constants.BROTLI_PARAM_QUALITY]: zlib.constants.BROTLI_MAX_QUALITY,
+            [zlib.constants.BROTLI_PARAM_SIZE_HINT]: fileContents.length
+          };
+          const compressedBuff = await new Promise(
+            (resolve2, reject) => {
+              const cb = (error, result) => error ? reject(error) : resolve2(result);
+              if (encoding === "gzip") {
+                zlib.gzip(fileContents, gzipOptions, cb);
+              } else {
+                zlib.brotliCompress(fileContents, brotliOptions, cb);
+              }
+            }
+          );
+          await fsp.writeFile(compressedPath, compressedBuff);
+        })
+      );
+    })
+  );
+}
+function isTextMime(mimeType) {
+  return /text|javascript|json|xml/.test(mimeType);
+}
+const COMPRESSIBLE_MIMES_RE = /* @__PURE__ */ new Set([
+  "application/dash+xml",
+  "application/eot",
+  "application/font",
+  "application/font-sfnt",
+  "application/javascript",
+  "application/json",
+  "application/opentype",
+  "application/otf",
+  "application/pdf",
+  "application/pkcs7-mime",
+  "application/protobuf",
+  "application/rss+xml",
+  "application/truetype",
+  "application/ttf",
+  "application/vnd.apple.mpegurl",
+  "application/vnd.mapbox-vector-tile",
+  "application/vnd.ms-fontobject",
+  "application/wasm",
+  "application/xhtml+xml",
+  "application/xml",
+  "application/x-font-opentype",
+  "application/x-font-truetype",
+  "application/x-font-ttf",
+  "application/x-httpd-cgi",
+  "application/x-javascript",
+  "application/x-mpegurl",
+  "application/x-opentype",
+  "application/x-otf",
+  "application/x-perl",
+  "application/x-ttf",
+  "font/eot",
+  "font/opentype",
+  "font/otf",
+  "font/ttf",
+  "image/svg+xml",
+  "text/css",
+  "text/csv",
+  "text/html",
+  "text/javascript",
+  "text/js",
+  "text/plain",
+  "text/richtext",
+  "text/tab-separated-values",
+  "text/xml",
+  "text/x-component",
+  "text/x-java-source",
+  "text/x-script",
+  "vnd.apple.mpegurl"
+]);
+function isCompressibleMime(mimeType) {
+  return COMPRESSIBLE_MIMES_RE.has(mimeType);
+}
+
+const NEGATION_RE = /^(!?)(.*)$/;
+const PARENT_DIR_GLOB_RE = /!?\.\.\//;
+async function scanUnprefixedPublicAssets(nitro) {
+  const scannedPaths = [];
+  for (const asset of nitro.options.publicAssets) {
+    if (asset.baseURL && asset.baseURL !== "/" && !asset.fallthrough) {
+      continue;
+    }
+    if (!await isDirectory(asset.dir)) {
+      continue;
+    }
+    const includePatterns = getIncludePatterns(nitro, asset.dir);
+    const publicAssets = await glob(includePatterns, {
+      cwd: asset.dir,
+      absolute: false,
+      dot: true
+    });
+    scannedPaths.push(
+      ...publicAssets.map((file) => join(asset.baseURL || "/", file))
+    );
+  }
+  return scannedPaths;
+}
+async function copyPublicAssets(nitro) {
+  if (nitro.options.noPublicDir) {
+    return;
+  }
+  for (const asset of nitro.options.publicAssets) {
+    const srcDir = asset.dir;
+    const dstDir = join(nitro.options.output.publicDir, asset.baseURL);
+    if (await isDirectory(srcDir)) {
+      const includePatterns = getIncludePatterns(nitro, srcDir);
+      const publicAssets = await glob(includePatterns, {
+        cwd: srcDir,
+        absolute: false,
+        dot: true
+      });
+      await Promise.all(
+        publicAssets.map(async (file) => {
+          const src = join(srcDir, file);
+          const dst = join(dstDir, file);
+          if (!existsSync(dst)) {
+            await promises.cp(src, dst);
+          }
+        })
+      );
+    }
+  }
+  if (nitro.options.compressPublicAssets) {
+    await compressPublicAssets(nitro);
+  }
+  nitro.logger.success(
+    "Generated public " + prettyPath(nitro.options.output.publicDir)
+  );
+}
+function getIncludePatterns(nitro, srcDir) {
+  return [
+    "**",
+    ...nitro.options.ignore.map((p) => {
+      const [_, negation, pattern] = p.match(NEGATION_RE) || [];
+      return (
+        // Convert ignore to include patterns
+        (negation ? "" : "!") + // Make non-glob patterns relative to publicAssetDir
+        (pattern.startsWith("*") ? pattern : relative(srcDir, resolve(nitro.options.srcDir, pattern)))
+      );
+    })
+  ].filter((p) => !PARENT_DIR_GLOB_RE.test(p));
+}
+
+async function prepare(nitro) {
+  await prepareDir(nitro.options.output.dir);
+  if (!nitro.options.noPublicDir) {
+    await prepareDir(nitro.options.output.publicDir);
+  }
+  if (!nitro.options.static) {
+    await prepareDir(nitro.options.output.serverDir);
+  }
+}
+async function prepareDir(dir) {
+  await fsp.rm(dir, { recursive: true, force: true });
+  await fsp.mkdir(dir, { recursive: true });
+}
+
+export { snapshotStorage as a, scanUnprefixedPublicAssets as b, createNitro as c, compressPublicAssets as d, copyPublicAssets as e, runTask as f, listTasks as g, prettyPath as h, isDirectory as i, loadOptions as l, prepare as p, resolveNitroPath as r, scanHandlers as s, writeFile as w };