nitro-nightly 3.1.0-20251028-110430-e607b753 → 3.1.0-20251028-131831-fe9fd554

package/dist/_chunks/index.mjs

@@ -0,0 +1,648 @@
+import { c as createNitro, b as scanUnprefixedPublicAssets, d as compressPublicAssets, w as writeFile, r as resolveNitroPath, i as isDirectory } from '../_build/prepare.mjs';
+import { pathToFileURL } from 'node:url';
+import { colors } from 'consola/utils';
+import { defu } from 'defu';
+import { m as mime } from './_deps/mime.mjs';
+import { a as addRoute, f as findAllRoutes, c as createRouter } from './_deps/rou3.mjs';
+import { parseURL, withTrailingSlash, withBase, joinURL, withoutBase } from 'ufo';
+import { z, P } from './_deps/ultrahtml.mjs';
+import { a as relative, r as resolve, j as join, c as resolveAlias, i as isAbsolute, d as dirname } from './_deps/pathe.mjs';
+import './server.mjs';
+import { existsSync, promises } from 'node:fs';
+import { i as parseNodeModulePath, l as lookupNodeModuleSubpath } from './_deps/mlly.mjs';
+import { r as resolveModulePath } from './_deps/exsolve.mjs';
+import { runtimeDir } from 'nitro/runtime/meta';
+import { g as generateTypes, r as resolveSchema } from './_deps/untyped.mjs';
+import { t as toExports } from './_deps/unimport.mjs';
+
+async function build(nitro) {
+  switch (nitro.options.builder) {
+    case "rollup": {
+      const { rollupBuild } = await import('../_build/build2.mjs');
+      return rollupBuild(nitro);
+    }
+    case "rolldown": {
+      const { rolldownBuild } = await import('../_build/build.mjs');
+      return rolldownBuild(nitro);
+    }
+    case "vite": {
+      const { viteBuild } = await import('../_build/vite2.mjs');
+      return viteBuild(nitro);
+    }
+    default: {
+      throw new Error(`Unknown builder: ${nitro.options.builder}`);
+    }
+  }
+}
+
+async function runParallel(inputs, cb, opts) {
+  const tasks = /* @__PURE__ */ new Set();
+  function queueNext() {
+    const route = inputs.values().next().value;
+    if (!route) {
+      return;
+    }
+    inputs.delete(route);
+    const task = (opts.interval ? new Promise((resolve) => setTimeout(resolve, opts.interval)) : Promise.resolve()).then(() => cb(route)).catch((error) => {
+      console.error(error);
+    });
+    tasks.add(task);
+    return task.then(() => {
+      tasks.delete(task);
+      if (inputs.size > 0) {
+        return refillQueue();
+      }
+    });
+  }
+  function refillQueue() {
+    const workers = Math.min(opts.concurrency - tasks.size, inputs.size);
+    return Promise.all(Array.from({ length: workers }, () => queueNext()));
+  }
+  await refillQueue();
+}
+
+const allowedExtensions = /* @__PURE__ */ new Set(["", ".json"]);
+const linkParents$1 = /* @__PURE__ */ new Map();
+const HTML_ENTITIES = {
+  "&lt;": "<",
+  "&gt;": ">",
+  "&amp;": "&",
+  "&apos;": "'",
+  "&quot;": '"'
+};
+function escapeHtml(text) {
+  return text.replace(
+    /&(lt|gt|amp|apos|quot);/g,
+    (ch) => HTML_ENTITIES[ch] || ch
+  );
+}
+async function extractLinks(html, from, res, crawlLinks) {
+  const links = [];
+  const _links = [];
+  if (crawlLinks) {
+    await z(P(html), (node) => {
+      if (!node.attributes?.href) {
+        return;
+      }
+      const link = escapeHtml(node.attributes.href);
+      if (!decodeURIComponent(link).startsWith("#") && allowedExtensions.has(getExtension(link))) {
+        _links.push(link);
+      }
+    });
+  }
+  const header = res.headers.get("x-nitro-prerender") || "";
+  _links.push(...header.split(",").map((i) => decodeURIComponent(i.trim())));
+  for (const link of _links.filter(Boolean)) {
+    const _link = parseURL(link);
+    if (_link.protocol || _link.host) {
+      continue;
+    }
+    if (!_link.pathname.startsWith("/")) {
+      const fromURL = new URL(from, "http://localhost");
+      _link.pathname = new URL(_link.pathname, fromURL).pathname;
+    }
+    links.push(_link.pathname + _link.search);
+  }
+  for (const link of links) {
+    const _parents = linkParents$1.get(link);
+    if (_parents) {
+      _parents.add(from);
+    } else {
+      linkParents$1.set(link, /* @__PURE__ */ new Set([from]));
+    }
+  }
+  return links;
+}
+const EXT_REGEX = /\.[\da-z]+$/;
+function getExtension(link) {
+  const pathname = parseURL(link).pathname;
+  return (pathname.match(EXT_REGEX) || [])[0] || "";
+}
+function formatPrerenderRoute(route) {
+  let str = `  \u251C\u2500 ${route.route} (${route.generateTimeMS}ms)`;
+  if (route.error) {
+    const parents = linkParents$1.get(route.route);
+    const errorColor = colors[route.error.status === 404 ? "yellow" : "red"];
+    const errorLead = parents?.size ? "\u251C\u2500\u2500" : "\u2514\u2500\u2500";
+    str += `
+  \u2502 ${errorLead} ${errorColor(route.error.message)}`;
+    if (parents?.size) {
+      str += `
+${[...parents.values()].map((link) => `  \u2502 \u2514\u2500\u2500 Linked from ${link}`).join("\n")}`;
+    }
+  }
+  if (route.skip) {
+    str += colors.gray(" (skipped)");
+  }
+  return colors.gray(str);
+}
+function matchesIgnorePattern(path, pattern) {
+  if (typeof pattern === "string") {
+    return path.startsWith(pattern);
+  }
+  if (typeof pattern === "function") {
+    return pattern(path) === true;
+  }
+  if (pattern instanceof RegExp) {
+    return pattern.test(path);
+  }
+  return false;
+}
+
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+const linkParents = /* @__PURE__ */ new Map();
+async function prerender(nitro) {
+  if (nitro.options.noPublicDir) {
+    nitro.logger.warn(
+      "Skipping prerender since `noPublicDir` option is enabled."
+    );
+    return;
+  }
+  if (nitro.options.builder === "vite") {
+    nitro.logger.warn(
+      "Skipping prerender since not supported with vite builder yet..."
+    );
+    return;
+  }
+  const routes = new Set(nitro.options.prerender.routes);
+  const prerenderRulePaths = Object.entries(nitro.options.routeRules).filter(([path2, options]) => options.prerender && !path2.includes("*")).map((e) => e[0]);
+  for (const route of prerenderRulePaths) {
+    routes.add(route);
+  }
+  await nitro.hooks.callHook("prerender:routes", routes);
+  if (routes.size === 0) {
+    if (nitro.options.prerender.crawlLinks) {
+      routes.add("/");
+    } else {
+      return;
+    }
+  }
+  nitro.logger.info("Initializing prerenderer");
+  nitro._prerenderedRoutes = [];
+  nitro._prerenderMeta = nitro._prerenderMeta || {};
+  const prerendererConfig = {
+    ...nitro.options._config,
+    static: false,
+    rootDir: nitro.options.rootDir,
+    logLevel: 0,
+    preset: "nitro-prerender"
+  };
+  await nitro.hooks.callHook("prerender:config", prerendererConfig);
+  const nitroRenderer = await createNitro(prerendererConfig);
+  const prerenderStartTime = Date.now();
+  await nitro.hooks.callHook("prerender:init", nitroRenderer);
+  let path = relative(nitro.options.output.dir, nitro.options.output.publicDir);
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
+  }
+  nitroRenderer.options.commands.preview = `npx serve ${path}`;
+  nitroRenderer.options.output.dir = nitro.options.output.dir;
+  await build(nitroRenderer);
+  const serverFilename = typeof nitroRenderer.options.rollupConfig?.output?.entryFileNames === "string" ? nitroRenderer.options.rollupConfig.output.entryFileNames : "index.mjs";
+  const serverEntrypoint = resolve(
+    nitroRenderer.options.output.serverDir,
+    serverFilename
+  );
+  const { closePrerenderer, appFetch } = await import(pathToFileURL(serverEntrypoint).href);
+  const routeRules = createRouter();
+  for (const [route, rules] of Object.entries(nitro.options.routeRules)) {
+    addRoute(routeRules, void 0, route, rules);
+  }
+  const _getRouteRules = (path2) => defu(
+    {},
+    ...findAllRoutes(routeRules, void 0, path2).map((r) => r.data).reverse()
+  );
+  const generatedRoutes = /* @__PURE__ */ new Set();
+  const failedRoutes = /* @__PURE__ */ new Set();
+  const skippedRoutes = /* @__PURE__ */ new Set();
+  const displayedLengthWarns = /* @__PURE__ */ new Set();
+  const publicAssetBases = nitro.options.publicAssets.filter(
+    (a) => !!a.baseURL && a.baseURL !== "/" && !a.fallthrough
+  ).map((a) => withTrailingSlash(a.baseURL));
+  const scannedPublicAssets = nitro.options.prerender.ignoreUnprefixedPublicAssets ? new Set(await scanUnprefixedPublicAssets(nitro)) : /* @__PURE__ */ new Set();
+  const canPrerender = (route = "/") => {
+    if (generatedRoutes.has(route) || skippedRoutes.has(route)) {
+      return false;
+    }
+    for (const pattern of nitro.options.prerender.ignore) {
+      if (matchesIgnorePattern(route, pattern)) {
+        return false;
+      }
+    }
+    if (publicAssetBases.some((base) => route.startsWith(base))) {
+      return false;
+    }
+    if (scannedPublicAssets.has(route)) {
+      return false;
+    }
+    if (_getRouteRules(route).prerender === false) {
+      return false;
+    }
+    return true;
+  };
+  const canWriteToDisk = (route) => {
+    if (route.route.includes("?")) {
+      return false;
+    }
+    const FS_MAX_SEGMENT = 255;
+    const FS_MAX_PATH = 1024;
+    const FS_MAX_PATH_PUBLIC_HTML = FS_MAX_PATH - (nitro.options.output.publicDir.length + 10);
+    if ((route.route.length >= FS_MAX_PATH_PUBLIC_HTML || route.route.split("/").some((s) => s.length > FS_MAX_SEGMENT)) && !displayedLengthWarns.has(route)) {
+      displayedLengthWarns.add(route);
+      const _route = route.route.slice(0, 60) + "...";
+      if (route.route.length >= FS_MAX_PATH_PUBLIC_HTML) {
+        nitro.logger.warn(
+          `Prerendering long route "${_route}" (${route.route.length}) can cause filesystem issues since it exceeds ${FS_MAX_PATH_PUBLIC_HTML}-character limit when writing to \`${nitro.options.output.publicDir}\`.`
+        );
+      } else {
+        nitro.logger.warn(
+          `Skipping prerender of the route "${_route}" since it exceeds the ${FS_MAX_SEGMENT}-character limit in one of the path segments and can cause filesystem issues.`
+        );
+        return false;
+      }
+    }
+    return true;
+  };
+  const generateRoute = async (route) => {
+    const start = Date.now();
+    route = decodeURI(route);
+    if (!canPrerender(route)) {
+      skippedRoutes.add(route);
+      return;
+    }
+    generatedRoutes.add(route);
+    const _route = { route };
+    const encodedRoute = encodeURI(route);
+    const res = await appFetch(withBase(encodedRoute, nitro.options.baseURL), {
+      headers: [["x-nitro-prerender", encodedRoute]]
+      // TODO
+      // retry: nitro.options.prerender.retry,
+      // retryDelay: nitro.options.prerender.retryDelay,
+    });
+    let dataBuff = Buffer.from(await res.arrayBuffer());
+    Object.defineProperty(_route, "contents", {
+      get: () => {
+        return dataBuff ? dataBuff.toString("utf8") : void 0;
+      },
+      set(value) {
+        if (dataBuff) {
+          dataBuff = Buffer.from(value);
+        }
+      }
+    });
+    Object.defineProperty(_route, "data", {
+      get: () => {
+        return dataBuff ? dataBuff.buffer : void 0;
+      },
+      set(value) {
+        if (dataBuff) {
+          dataBuff = Buffer.from(value);
+        }
+      }
+    });
+    const redirectCodes = [301, 302, 303, 304, 307, 308];
+    if (![200, ...redirectCodes].includes(res.status)) {
+      _route.error = new Error(`[${res.status}] ${res.statusText}`);
+      _route.error.status = res.status;
+      _route.error.statusText = res.statusText;
+    }
+    _route.generateTimeMS = Date.now() - start;
+    const contentType = res.headers.get("content-type") || "";
+    const isImplicitHTML = !route.endsWith(".html") && contentType.includes("html") && !JsonSigRx.test(dataBuff.subarray(0, 32).toString("utf8"));
+    const routeWithIndex = route.endsWith("/") ? route + "index" : route;
+    const htmlPath = route.endsWith("/") || nitro.options.prerender.autoSubfolderIndex ? joinURL(route, "index.html") : route + ".html";
+    _route.fileName = withoutBase(
+      isImplicitHTML ? htmlPath : routeWithIndex,
+      nitro.options.baseURL
+    );
+    const inferredContentType = mime.getType(_route.fileName) || "text/plain";
+    _route.contentType = contentType || inferredContentType;
+    await nitro.hooks.callHook("prerender:generate", _route, nitro);
+    if (_route.contentType !== inferredContentType) {
+      nitro._prerenderMeta[_route.fileName] ||= {};
+      nitro._prerenderMeta[_route.fileName].contentType = _route.contentType;
+    }
+    if (_route.error) {
+      failedRoutes.add(_route);
+    }
+    if (_route.skip || _route.error) {
+      await nitro.hooks.callHook("prerender:route", _route);
+      nitro.logger.log(formatPrerenderRoute(_route));
+      dataBuff = void 0;
+      return _route;
+    }
+    if (canWriteToDisk(_route)) {
+      const filePath = join(nitro.options.output.publicDir, _route.fileName);
+      await writeFile(filePath, dataBuff);
+      nitro._prerenderedRoutes.push(_route);
+    } else {
+      _route.skip = true;
+    }
+    if (!_route.error && (isImplicitHTML || route.endsWith(".html"))) {
+      const extractedLinks = await extractLinks(
+        dataBuff.toString("utf8"),
+        route,
+        res,
+        nitro.options.prerender.crawlLinks
+      );
+      for (const _link of extractedLinks) {
+        if (canPrerender(_link)) {
+          routes.add(_link);
+        }
+      }
+    }
+    await nitro.hooks.callHook("prerender:route", _route);
+    nitro.logger.log(formatPrerenderRoute(_route));
+    dataBuff = void 0;
+    return _route;
+  };
+  nitro.logger.info(
+    nitro.options.prerender.crawlLinks ? `Prerendering ${routes.size} initial routes with crawler` : `Prerendering ${routes.size} routes`
+  );
+  await runParallel(routes, generateRoute, {
+    concurrency: nitro.options.prerender.concurrency,
+    interval: nitro.options.prerender.interval
+  });
+  await closePrerenderer();
+  await nitro.hooks.callHook("prerender:done", {
+    prerenderedRoutes: nitro._prerenderedRoutes,
+    failedRoutes: [...failedRoutes]
+  });
+  if (nitro.options.prerender.failOnError && failedRoutes.size > 0) {
+    nitro.logger.log("\nErrors prerendering:");
+    for (const route of failedRoutes) {
+      const parents = linkParents.get(route.route);
+      parents?.size ? `
+${[...parents.values()].map((link) => colors.gray(`  \u2502 \u2514\u2500\u2500 Linked from ${link}`)).join("\n")}` : "";
+      nitro.logger.log(formatPrerenderRoute(route));
+    }
+    nitro.logger.log("");
+    throw new Error("Exiting due to prerender errors.");
+  }
+  const prerenderTimeInMs = Date.now() - prerenderStartTime;
+  nitro.logger.info(
+    `Prerendered ${nitro._prerenderedRoutes.length} routes in ${prerenderTimeInMs / 1e3} seconds`
+  );
+  if (nitro.options.compressPublicAssets) {
+    await compressPublicAssets(nitro);
+  }
+}
+
+async function writeTypes(nitro) {
+  const types = {
+    routes: {}
+  };
+  const typesDir = resolve(nitro.options.buildDir, "types");
+  const middleware = [...nitro.scannedHandlers, ...nitro.options.handlers];
+  for (const mw of middleware) {
+    if (typeof mw.handler !== "string" || !mw.route) {
+      continue;
+    }
+    const relativePath = relative(
+      typesDir,
+      resolveNitroPath(mw.handler, nitro.options)
+    ).replace(/\.(js|mjs|cjs|ts|mts|cts|tsx|jsx)$/, "");
+    const method = mw.method || "default";
+    types.routes[mw.route] ??= {};
+    types.routes[mw.route][method] ??= [];
+    types.routes[mw.route][method].push(
+      `Simplify<Serialize<Awaited<ReturnType<typeof import('${relativePath}').default>>>>`
+    );
+  }
+  let autoImportedTypes = [];
+  let autoImportExports = "";
+  if (nitro.unimport) {
+    await nitro.unimport.init();
+    const allImports = await nitro.unimport.getImports();
+    autoImportExports = toExports(allImports).replace(
+      /#internal\/nitro/g,
+      relative(typesDir, runtimeDir)
+    );
+    const resolvedImportPathMap = /* @__PURE__ */ new Map();
+    for (const i of allImports) {
+      const from = i.typeFrom || i.from;
+      if (resolvedImportPathMap.has(from)) {
+        continue;
+      }
+      let path = resolveAlias(from, nitro.options.alias);
+      if (!isAbsolute(path)) {
+        const resolvedPath = resolveModulePath(from, {
+          try: true,
+          from: nitro.options.nodeModulesDirs,
+          conditions: ["type", "node", "import"],
+          suffixes: ["", "/index"],
+          extensions: [".mjs", ".cjs", ".js", ".mts", ".cts", ".ts"]
+        });
+        if (resolvedPath) {
+          const { dir, name } = parseNodeModulePath(resolvedPath);
+          if (!dir || !name) {
+            path = resolvedPath;
+          } else {
+            const subpath = await lookupNodeModuleSubpath(resolvedPath);
+            path = join(dir, name, subpath || "");
+          }
+        }
+      }
+      if (existsSync(path) && !await isDirectory(path)) {
+        path = path.replace(/\.[a-z]+$/, "");
+      }
+      if (isAbsolute(path)) {
+        path = relative(typesDir, path);
+      }
+      resolvedImportPathMap.set(from, path);
+    }
+    autoImportedTypes = [
+      nitro.options.imports && nitro.options.imports.autoImport !== false ? (await nitro.unimport.generateTypeDeclarations({
+        exportHelper: false,
+        resolvePath: (i) => {
+          const from = i.typeFrom || i.from;
+          return resolvedImportPathMap.get(from) ?? from;
+        }
+      })).trim() : ""
+    ];
+  }
+  const generateRoutes = () => [
+    "// Generated by nitro",
+    'import type { Serialize, Simplify } from "nitro/types";',
+    'declare module "nitro/types" {',
+    "  type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T",
+    "  interface InternalApi {",
+    ...Object.entries(types.routes).map(
+      ([path, methods]) => [
+        `    '${path}': {`,
+        ...Object.entries(methods).map(
+          ([method, types2]) => `      '${method}': ${types2.join(" | ")}`
+        ),
+        "    }"
+      ].join("\n")
+    ),
+    "  }",
+    "}",
+    // Makes this a module for augmentation purposes
+    "export {}"
+  ];
+  const config = [
+    "// Generated by nitro",
+    /* ts */
+    `declare module "nitro/types" {`,
+    nitro.options.typescript.generateRuntimeConfigTypes ? generateTypes(
+      await resolveSchema(
+        Object.fromEntries(
+          Object.entries(nitro.options.runtimeConfig).filter(
+            ([key]) => !["app", "nitro"].includes(key)
+          )
+        )
+      ),
+      {
+        interfaceName: "NitroRuntimeConfig",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 2
+      }
+    ) : "",
+    `}`,
+    // Makes this a module for augmentation purposes
+    "export {}"
+  ];
+  const declarations = [
+    // local nitropack augmentations
+    '/// <reference path="./nitro-routes.d.ts" />',
+    '/// <reference path="./nitro-config.d.ts" />',
+    // global server auto-imports
+    '/// <reference path="./nitro-imports.d.ts" />'
+  ];
+  const buildFiles = [];
+  buildFiles.push({
+    path: join(typesDir, "nitro-routes.d.ts"),
+    contents: () => generateRoutes().join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "nitro-config.d.ts"),
+    contents: config.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "nitro-imports.d.ts"),
+    contents: [...autoImportedTypes, autoImportExports || "export {}"].join(
+      "\n"
+    )
+  });
+  buildFiles.push({
+    path: join(typesDir, "nitro.d.ts"),
+    contents: declarations.join("\n")
+  });
+  if (nitro.options.typescript.generateTsConfig) {
+    const tsConfigPath = resolve(
+      nitro.options.buildDir,
+      nitro.options.typescript.tsconfigPath
+    );
+    const tsconfigDir = dirname(tsConfigPath);
+    const tsConfig = defu(nitro.options.typescript.tsConfig, {
+      compilerOptions: {
+        /* Base options: */
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+        skipLibCheck: true,
+        target: "ESNext",
+        allowJs: true,
+        resolveJsonModule: true,
+        moduleDetection: "force",
+        isolatedModules: true,
+        verbatimModuleSyntax: true,
+        allowImportingTsExtensions: true,
+        /* Strictness */
+        strict: nitro.options.typescript.strict,
+        noUncheckedIndexedAccess: true,
+        noImplicitOverride: true,
+        forceConsistentCasingInFileNames: true,
+        /* If NOT transpiling with TypeScript: */
+        module: "Preserve",
+        jsx: "preserve",
+        jsxFactory: "h",
+        jsxFragmentFactory: "Fragment",
+        paths: {
+          "#imports": [
+            relativeWithDot(tsconfigDir, join(typesDir, "nitro-imports"))
+          ],
+          ...nitro.options.typescript.internalPaths ? {
+            "nitro/runtime": [
+              relativeWithDot(tsconfigDir, join(runtimeDir, "index"))
+            ],
+            "#internal/nitro": [
+              relativeWithDot(tsconfigDir, join(runtimeDir, "index"))
+            ],
+            "nitro/runtime/*": [
+              relativeWithDot(tsconfigDir, join(runtimeDir, "*"))
+            ],
+            "#internal/nitro/*": [
+              relativeWithDot(tsconfigDir, join(runtimeDir, "*"))
+            ]
+          } : {}
+        }
+      },
+      include: [
+        relativeWithDot(tsconfigDir, join(typesDir, "nitro.d.ts")).replace(
+          /^(?=[^.])/,
+          "./"
+        ),
+        join(relativeWithDot(tsconfigDir, nitro.options.rootDir), "**/*"),
+        ...nitro.options.srcDir === nitro.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, nitro.options.srcDir), "**/*")]
+      ]
+    });
+    for (const alias in tsConfig.compilerOptions.paths) {
+      const paths = await Promise.all(
+        tsConfig.compilerOptions.paths[alias].map(async (path) => {
+          if (!isAbsolute(path)) {
+            return path;
+          }
+          const stats = await promises.stat(path).catch(
+            () => null
+            /* file does not exist */
+          );
+          return relativeWithDot(
+            tsconfigDir,
+            stats?.isFile() ? path.replace(/(?<=\w)\.\w+$/g, "") : path
+          );
+        })
+      );
+      tsConfig.compilerOptions.paths[alias] = [...new Set(paths)];
+    }
+    tsConfig.include = [
+      ...new Set(
+        tsConfig.include.map(
+          (p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p
+        )
+      )
+    ];
+    if (tsConfig.exclude) {
+      tsConfig.exclude = [
+        ...new Set(
+          tsConfig.exclude.map(
+            (p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p
+          )
+        )
+      ];
+    }
+    types.tsConfig = tsConfig;
+    buildFiles.push({
+      path: tsConfigPath,
+      contents: () => JSON.stringify(tsConfig, null, 2)
+    });
+  }
+  await nitro.hooks.callHook("types:extend", types);
+  await Promise.all(
+    buildFiles.map(async (file) => {
+      await writeFile(
+        resolve(nitro.options.buildDir, file.path),
+        typeof file.contents === "string" ? file.contents : file.contents()
+      );
+    })
+  );
+}
+const RELATIVE_RE = /^\.{1,2}\//;
+function relativeWithDot(from, to) {
+  const rel = relative(from, to);
+  return RELATIVE_RE.test(rel) ? rel : "./" + rel;
+}
+
+export { build as b, prerender as p, runParallel as r, writeTypes as w };