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

package/dist/_chunks/index3.mjs

@@ -0,0 +1,1058 @@
+import { i as createNitro, k as addRoute, l as scanUnprefixedPublicAssets, m as compressPublicAssets, n as mime, w as writeFile, o as findAllRoutes, q as createRouter, t as genObjectKey, u as resolveNitroPath, v as toExports, r as resolveModulePath, x as parseNodeModulePath, y as lookupNodeModuleSubpath, z as isDirectory } from './index.mjs';
+import { pathToFileURL } from 'node:url';
+import { colors } from 'consola/utils';
+import { defu } from 'defu';
+import { parseURL, withTrailingSlash, withBase, joinURL, withoutBase } from 'ufo';
+import { a as relative, r as resolve, j as join, c as normalizeWindowsPath, i as isAbsolute, d as dirname } from './pathe.M-eThtNZ.mjs';
+import './server.mjs';
+import { existsSync, promises } from 'node:fs';
+import { runtimeDir } from 'nitro/runtime/meta';
+import 'scule';
+
+async function build(nitro) {
+  switch (nitro.options.builder) {
+    case "rollup": {
+      const { rollupBuild } = await import('./build3.mjs');
+      return rollupBuild(nitro);
+    }
+    case "rolldown": {
+      const { rolldownBuild } = await import('./build2.mjs');
+      return rolldownBuild(nitro);
+    }
+    case "vite": {
+      const { viteBuild } = await import('./build.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();
+}
+
+var D=new Set(["area","base","br","col","embed","hr","img","input","keygen","link","meta","param","source","track","wbr"]),x=new Set(["script","style"]),o=/(?:<(\/?)([a-zA-Z][a-zA-Z0-9\:-]*)(?:\s([^>]*?))?((?:\s*\/)?)>|(<\!\-\-)([\s\S]*?)(\-\->)|(<\!)([\s\S]*?)(>))/gm,b=/[\@\.a-z0-9_\:\-]/i;function I(e){let t={};if(e){let i="none",r,n="",a,l;for(let c=0;c<e.length;c++){let d=e[c];i==="none"?b.test(d)?(r&&(t[r]=n,r=void 0,n=""),a=c,i="key"):d==="="&&r&&(i="value"):i==="key"?b.test(d)||(r=e.substring(a,c),d==="="?i="value":i="none"):d===l&&c>0&&e[c-1]!=="\\"?l&&(n=e.substring(a,c),l=void 0,i="none"):(d==='"'||d==="'")&&!l&&(a=c+1,l=d);}i==="key"&&a!=null&&a<e.length&&(r=e.substring(a,e.length)),r&&(t[r]=n);}return t}function P(e){let t=typeof e=="string"?e:e.value,i,r,n,a,l,c,d,m,s,u=[];o.lastIndex=0,r=i={type:0,children:[]};let g=0;function h(){a=t.substring(g,o.lastIndex-n[0].length),a&&r.children.push({type:2,value:a,parent:r});}for(;n=o.exec(t);){if(c=n[5]||n[8],d=n[6]||n[9],m=n[7]||n[10],x.has(r.name)&&n[2]!==r.name){l=o.lastIndex-n[0].length,r.children.length>0&&(r.children[0].value+=n[0]);continue}else if(c==="<!--"){if(l=o.lastIndex-n[0].length,x.has(r.name))continue;s={type:3,value:d,parent:r,loc:[{start:l,end:l+c.length},{start:o.lastIndex-m.length,end:o.lastIndex}]},u.push(s),s.parent.children.push(s);}else if(c==="<!")l=o.lastIndex-n[0].length,s={type:4,value:d,parent:r,loc:[{start:l,end:l+c.length},{start:o.lastIndex-m.length,end:o.lastIndex}]},u.push(s),s.parent.children.push(s);else if(n[1]!=="/")if(h(),x.has(r.name)){g=o.lastIndex,h();continue}else s={type:1,name:n[2]+"",attributes:I(n[3]),parent:r,children:[],loc:[{start:o.lastIndex-n[0].length,end:o.lastIndex}]},u.push(s),s.parent.children.push(s),n[4]&&n[4].indexOf("/")>-1||D.has(s.name)?(s.loc[1]=s.loc[0],s.isSelfClosingTag=true):r=s;else h(),n[2]+""===r.name?(s=r,r=s.parent,s.loc.push({start:o.lastIndex-n[0].length,end:o.lastIndex}),a=t.substring(s.loc[0].end,s.loc[1].start),s.children.length===0&&s.children.push({type:2,value:a,parent:r})):n[2]+""===u[u.length-1].name&&u[u.length-1].isSelfClosingTag===true&&(s=u[u.length-1],s.loc.push({start:o.lastIndex-n[0].length,end:o.lastIndex}));g=o.lastIndex;}return a=t.slice(g),r.children.push({type:2,value:a,parent:r}),i}var T=class{constructor(t){this.callback=t;}async visit(t,i,r){if(await this.callback(t,i,r),Array.isArray(t.children)){let n=[];for(let a=0;a<t.children.length;a++){let l=t.children[a];n.push(this.visit(l,t,a));}await Promise.all(n);}}};function z(e,t){return new T(t).visit(e)}
+
+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);
+  }
+}
+
+const pathSeparators = /* @__PURE__ */ new Set(["/", "\\", void 0]);
+const normalizedAliasSymbol = Symbol.for("pathe:normalizedAlias");
+function normalizeAliases(_aliases) {
+  if (_aliases[normalizedAliasSymbol]) {
+    return _aliases;
+  }
+  const aliases = Object.fromEntries(
+    Object.entries(_aliases).sort(([a], [b]) => _compareAliases(a, b))
+  );
+  for (const key in aliases) {
+    for (const alias in aliases) {
+      if (alias === key || key.startsWith(alias)) {
+        continue;
+      }
+      if (aliases[key]?.startsWith(alias) && pathSeparators.has(aliases[key][alias.length])) {
+        aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
+      }
+    }
+  }
+  Object.defineProperty(aliases, normalizedAliasSymbol, {
+    value: true,
+    enumerable: false
+  });
+  return aliases;
+}
+function resolveAlias(path, aliases) {
+  const _path = normalizeWindowsPath(path);
+  aliases = normalizeAliases(aliases);
+  for (const [alias, to] of Object.entries(aliases)) {
+    if (!_path.startsWith(alias)) {
+      continue;
+    }
+    const _alias = hasTrailingSlash(alias) ? alias.slice(0, -1) : alias;
+    if (hasTrailingSlash(_path[_alias.length])) {
+      return join(to, _path.slice(alias.length));
+    }
+  }
+  return _path;
+}
+function _compareAliases(a, b) {
+  return b.split("/").length - a.split("/").length;
+}
+function hasTrailingSlash(path = "/") {
+  const lastChar = path[path.length - 1];
+  return lastChar === "/" || lastChar === "\\";
+}
+
+function getType(val) {
+  const type = typeof val;
+  if (type === "undefined" || val === null) {
+    return void 0;
+  }
+  if (Array.isArray(val)) {
+    return "array";
+  }
+  return type;
+}
+function isObject(val) {
+  return val !== null && !Array.isArray(val) && typeof val === "object";
+}
+function nonEmpty(arr) {
+  return arr.filter(Boolean);
+}
+function unique(arr) {
+  return [...new Set(arr)];
+}
+function joinPath(a, b = "", sep = ".") {
+  return a ? a + sep + b : b;
+}
+function setValue(obj, path, val) {
+  const keys = path.split(".");
+  const _key = keys.pop();
+  for (const key of keys) {
+    if (!obj || typeof obj !== "object") {
+      return;
+    }
+    if (!(key in obj)) {
+      obj[key] = {};
+    }
+    obj = obj[key];
+  }
+  if (_key) {
+    if (!obj || typeof obj !== "object") {
+      return;
+    }
+    obj[_key] = val;
+  }
+}
+function getValue(obj, path) {
+  for (const key of path.split(".")) {
+    if (!obj || typeof obj !== "object" || !(key in obj)) {
+      return;
+    }
+    obj = obj[key];
+  }
+  return obj;
+}
+function normalizeTypes(val) {
+  const arr = unique(val.filter(Boolean));
+  if (arr.length === 0 || arr.includes("any")) {
+    return;
+  }
+  return arr.length > 1 ? arr : arr[0];
+}
+
+async function resolveSchema(obj, defaults, options = {}) {
+  const schema = await _resolveSchema(obj, "", {
+    root: obj,
+    defaults,
+    resolveCache: {},
+    ignoreDefaults: !!options.ignoreDefaults
+  });
+  return schema;
+}
+async function _resolveSchema(input, id, ctx) {
+  if (id in ctx.resolveCache) {
+    return ctx.resolveCache[id];
+  }
+  const schemaId = "#" + id.replace(/\./g, "/");
+  if (!isObject(input)) {
+    const safeInput = Array.isArray(input) ? [...input] : input;
+    const schema2 = {
+      type: getType(input),
+      id: schemaId,
+      default: ctx.ignoreDefaults ? void 0 : safeInput
+    };
+    normalizeSchema(schema2, { ignoreDefaults: ctx.ignoreDefaults });
+    ctx.resolveCache[id] = schema2;
+    if (ctx.defaults && getValue(ctx.defaults, id) === void 0) {
+      setValue(ctx.defaults, id, schema2.default);
+    }
+    return schema2;
+  }
+  const node = { ...input };
+  const schema = ctx.resolveCache[id] = {
+    ...node.$schema,
+    id: schemaId
+  };
+  for (const key in node) {
+    if (key === "$resolve" || key === "$schema" || key === "$default") {
+      continue;
+    }
+    schema.properties = schema.properties || {};
+    if (!schema.properties[key]) {
+      const child = schema.properties[key] = await _resolveSchema(
+        node[key],
+        joinPath(id, key),
+        ctx
+      );
+      if (Array.isArray(child.tags) && child.tags.includes("@required")) {
+        schema.required = schema.required || [];
+        if (!schema.required.includes(key)) {
+          schema.required.push(key);
+        }
+      }
+    }
+  }
+  if (!ctx.ignoreDefaults) {
+    if (ctx.defaults) {
+      schema.default = getValue(ctx.defaults, id);
+    }
+    if (schema.default === void 0 && "$default" in node) {
+      schema.default = node.$default;
+    }
+    if (typeof node.$resolve === "function") {
+      schema.default = await node.$resolve(schema.default, async (key) => {
+        return (await _resolveSchema(getValue(ctx.root, key), key, ctx)).default;
+      });
+    }
+  }
+  if (ctx.defaults) {
+    setValue(ctx.defaults, id, schema.default);
+  }
+  if (!schema.type) {
+    schema.type = getType(schema.default) || (schema.properties ? "object" : "any");
+  }
+  normalizeSchema(schema, { ignoreDefaults: ctx.ignoreDefaults });
+  if (ctx.defaults && getValue(ctx.defaults, id) === void 0) {
+    setValue(ctx.defaults, id, schema.default);
+  }
+  return schema;
+}
+function normalizeSchema(schema, options) {
+  if (schema.type === "array" && !("items" in schema)) {
+    schema.items = {
+      type: nonEmpty(unique(schema.default.map((i) => getType(i))))
+    };
+    if (schema.items.type) {
+      if (schema.items.type.length === 0) {
+        schema.items.type = "any";
+      } else if (schema.items.type.length === 1) {
+        schema.items.type = schema.items.type[0];
+      }
+    }
+  }
+  if (!options.ignoreDefaults && schema.default === void 0 && ("properties" in schema || schema.type === "object" || schema.type === "any")) {
+    const propsWithDefaults = Object.entries(schema.properties || {}).filter(([, prop]) => "default" in prop).map(([key, value]) => [key, value.default]);
+    schema.default = Object.fromEntries(propsWithDefaults);
+  }
+}
+
+const GenerateTypesDefaults = {
+  interfaceName: "Untyped",
+  addExport: true,
+  addDefaults: true,
+  allowExtraKeys: void 0,
+  partial: false,
+  indentation: 0
+};
+const TYPE_MAP = {
+  array: "any[]",
+  bigint: "bigint",
+  boolean: "boolean",
+  number: "number",
+  object: "",
+  // Will be precisely defined
+  any: "any",
+  string: "string",
+  symbol: "Symbol",
+  function: "Function"
+};
+const SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "items",
+  "default",
+  "resolve",
+  "properties",
+  "title",
+  "description",
+  "$schema",
+  "type",
+  "tsType",
+  "markdownType",
+  "tags",
+  "args",
+  "id",
+  "returns"
+]);
+const DECLARATION_RE = /typeof import\(["'](?<source>[^)]+)["']\)(\.(?<type>\w+)|\[["'](?<type1>\w+)["']])/g;
+function extractTypeImports(declarations) {
+  const typeImports = {};
+  const aliases = /* @__PURE__ */ new Set();
+  const imports = [];
+  for (const match of declarations.matchAll(DECLARATION_RE)) {
+    const { source, type1, type = type1 } = match.groups || {};
+    typeImports[source] = typeImports[source] || /* @__PURE__ */ new Set();
+    typeImports[source].add(type);
+  }
+  for (const source in typeImports) {
+    const sourceImports = [];
+    for (const type of typeImports[source]) {
+      let count = 0;
+      let alias = type;
+      while (aliases.has(alias)) {
+        alias = `${type}${count++}`;
+      }
+      aliases.add(alias);
+      sourceImports.push(alias === type ? type : `${type} as ${alias}`);
+      declarations = declarations.replace(
+        new RegExp(
+          `typeof import\\(['"]${source}['"]\\)(\\.${type}|\\[['"]${type}['"]\\])`,
+          "g"
+        ),
+        alias
+      );
+    }
+    imports.push(
+      `import type { ${sourceImports.join(", ")} } from '${source}'`
+    );
+  }
+  return [...imports, declarations].join("\n");
+}
+function generateTypes(schema, opts = {}) {
+  opts = { ...GenerateTypesDefaults, ...opts };
+  const baseIden = " ".repeat(opts.indentation || 0);
+  const interfaceCode = `interface ${opts.interfaceName} {
+` + _genTypes(schema, baseIden + " ", opts).map((l) => l.trim().length > 0 ? l : "").join("\n") + `
+${baseIden}}`;
+  if (!opts.addExport) {
+    return baseIden + interfaceCode;
+  }
+  return extractTypeImports(baseIden + `export ${interfaceCode}`);
+}
+function _genTypes(schema, spaces, opts) {
+  const buff = [];
+  if (!schema) {
+    return buff;
+  }
+  for (const key in schema.properties) {
+    const val = schema.properties[key];
+    buff.push(...generateJSDoc(val, opts));
+    if (val.tsType) {
+      buff.push(
+        `${genObjectKey(key)}${isRequired(schema, key, opts) ? "" : "?"}: ${val.tsType},
+`
+      );
+    } else if (val.type === "object") {
+      buff.push(
+        `${genObjectKey(key)}${isRequired(schema, key, opts) ? "" : "?"}: {`,
+        ..._genTypes(val, spaces, opts),
+        "},\n"
+      );
+    } else {
+      let type;
+      if (val.type === "array") {
+        type = `Array<${getTsType(val.items || [], opts)}>`;
+      } else if (val.type === "function") {
+        type = genFunctionType(val, opts);
+      } else {
+        type = getTsType(val, opts);
+      }
+      buff.push(
+        `${genObjectKey(key)}${isRequired(schema, key, opts) ? "" : "?"}: ${type},
+`
+      );
+    }
+  }
+  if (buff.length > 0) {
+    const last = buff.pop() || "";
+    buff.push(last.slice(0, Math.max(0, last.length - 1)));
+  }
+  if (opts.allowExtraKeys === true || buff.length === 0 && opts.allowExtraKeys !== false) {
+    buff.push("[key: string]: any");
+  }
+  return buff.flatMap((l) => l.split("\n")).map((l) => spaces + l);
+}
+function getTsType(type, opts) {
+  if (Array.isArray(type)) {
+    return [normalizeTypes(type.map((t) => getTsType(t, opts)))].flat().join("|") || "any";
+  }
+  if (!type) {
+    return "any";
+  }
+  if (type.tsType) {
+    return type.tsType;
+  }
+  if (!type.type) {
+    return "any";
+  }
+  if (Array.isArray(type.type)) {
+    return type.type.map((t) => {
+      if (t === "object" && type.type.length > 1) {
+        return `{
+` + _genTypes(type, " ", opts).join("\n") + `
+}`;
+      }
+      return TYPE_MAP[t];
+    }).join("|");
+  }
+  if (type.type === "array") {
+    return `Array<${getTsType(type.items || [], opts)}>`;
+  }
+  if (type.type === "object") {
+    return `{
+` + _genTypes(type, " ", opts).join("\n") + `
+}`;
+  }
+  return TYPE_MAP[type.type] || type.type;
+}
+function genFunctionType(schema, opts) {
+  return `(${genFunctionArgs(schema.args, opts)}) => ${getTsType(
+    schema.returns || [],
+    opts
+  )}`;
+}
+function genFunctionArgs(args, opts) {
+  return args?.map((arg) => {
+    let argStr = arg.name;
+    if (arg.optional || arg.default) {
+      argStr += "?";
+    }
+    if (arg.type || arg.tsType) {
+      argStr += `: ${getTsType(arg, opts)}`;
+    }
+    return argStr;
+  }).join(", ") || "";
+}
+function generateJSDoc(schema, opts) {
+  opts.defaultDescription = opts.defaultDescription || opts.defaultDescrption;
+  let buff = [];
+  if (schema.title) {
+    buff.push(schema.title, "");
+  }
+  if (schema.description) {
+    buff.push(schema.description, "");
+  } else if (opts.defaultDescription && schema.type !== "object") {
+    buff.push(opts.defaultDescription, "");
+  }
+  if (opts.addDefaults && schema.type !== "object" && schema.type !== "any" && !(Array.isArray(schema.default) && schema.default.length === 0)) {
+    const stringified = JSON.stringify(schema.default);
+    if (stringified) {
+      buff.push(`@default ${stringified.replace(/\*\//g, String.raw`*\/`)}`);
+    }
+  }
+  for (const key in schema) {
+    if (!SCHEMA_KEYS.has(key)) {
+      buff.push("", `@${key} ${schema[key]}`);
+    }
+  }
+  if (Array.isArray(schema.tags)) {
+    for (const tag of schema.tags) {
+      if (tag !== "@untyped") {
+        buff.push("", tag);
+      }
+    }
+  }
+  buff = buff.flatMap((i) => i.split("\n"));
+  if (buff.length > 0) {
+    return buff.length === 1 ? ["/** " + buff[0] + " */"] : ["/**", ...buff.map((i) => ` * ${i}`), "*/"];
+  }
+  return [];
+}
+function isRequired(schema, key, opts) {
+  if (Array.isArray(schema.required) && schema.required.includes(key)) {
+    return true;
+  }
+  return !opts.partial;
+}
+
+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) {
+      if (resolvedImportPathMap.has(i.from)) {
+        continue;
+      }
+      let path = resolveAlias(i.from, nitro.options.alias);
+      if (!isAbsolute(path)) {
+        const resolvedPath = resolveModulePath(i.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(i.from, path);
+    }
+    autoImportedTypes = [
+      nitro.options.imports && nitro.options.imports.autoImport !== false ? (await nitro.unimport.generateTypeDeclarations({
+        exportHelper: false,
+        resolvePath: (i) => resolvedImportPathMap.get(i.from) ?? i.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 };