nitro-nightly 3.1.0-20251028-004953-57503e42 → 3.1.0-20251028-090722-437659e4

package/dist/{cli → _cli}/build.mjs

@@ -1,11 +1,10 @@
 import nodeCrypto from 'node:crypto';
-import { d as defineCommand } from './index.mjs';
+import { d as defineCommand } from '../_deps/citty.mjs';
 import { createNitro, prepare, copyPublicAssets, prerender, build as build$1 } from 'nitro';
 import { c as commonArgs } from './common.mjs';
-import { r as resolve } from '../_chunks/pathe.M-eThtNZ.mjs';
+import { a as resolve } from '../_deps/pathe.mjs';
 import 'consola';
 import 'consola/utils';
-import 'nitro/meta';
 
 if (!globalThis.crypto) {
   globalThis.crypto = nodeCrypto;

package/dist/_cli/dev.mjs

@@ -0,0 +1,205 @@
+import { d as defineCommand } from '../_deps/citty.mjs';
+import { consola } from 'consola';
+import { createNitro, prepare, build } from 'nitro';
+import { c as commonArgs } from './common.mjs';
+import { N as NitroDevServer } from '../_build/vite.mjs';
+import { a as resolve } from '../_deps/pathe.mjs';
+import 'consola/utils';
+import 'node:url';
+import 'defu';
+import '../_deps/mime.mjs';
+import '../_build/assets.mjs';
+import 'node:fs';
+import '../_deps/tinyglobby.mjs';
+import 'fs';
+import 'path';
+import 'url';
+import '../_deps/fdir.mjs';
+import 'module';
+import '../_deps/picomatch.mjs';
+import '../_deps/commondir.mjs';
+import 'node:fs/promises';
+import '../_deps/dot-prop.mjs';
+import 'node:zlib';
+import '../_deps/rou3.mjs';
+import 'ufo';
+import '../_build/build.mjs';
+import '../_build/rolldown.mjs';
+import '../_deps/mlly.mjs';
+import '../_deps/acorn.mjs';
+import 'node:module';
+import '../_deps/pkg-types.mjs';
+import '../_deps/confbox.mjs';
+import '../_deps/exsolve.mjs';
+import 'node:path';
+import 'node:assert';
+import 'node:process';
+import 'node:v8';
+import 'node:util';
+import 'nitro/runtime/meta';
+import '../_build/config.mjs';
+import 'unenv';
+import '../_build/plugins.mjs';
+import '../_deps/@rollup/plugin-replace.mjs';
+import '../_deps/magic-string.mjs';
+import '../_deps/@jridgewell/sourcemap-codec.mjs';
+import '../_deps/@rollup/pluginutils.mjs';
+import '../_deps/estree-walker.mjs';
+import 'ohash';
+import '../_deps/unimport.mjs';
+import 'scule';
+import 'node:os';
+import '../_deps/unplugin.mjs';
+import 'node:buffer';
+import '../_deps/@jridgewell/remapping.mjs';
+import '../_deps/@jridgewell/trace-mapping.mjs';
+import '../_deps/@jridgewell/resolve-uri.mjs';
+import '../_deps/@jridgewell/gen-mapping.mjs';
+import 'node:querystring';
+import '../_deps/webpack-virtual-modules.mjs';
+import 'constants';
+import '../_deps/unplugin-utils.mjs';
+import '../_deps/local-pkg.mjs';
+import '../_deps/quansync.mjs';
+import '../_deps/strip-literal.mjs';
+import '../_deps/js-tokens.mjs';
+import '../_deps/unwasm.mjs';
+import 'node:crypto';
+import '../_deps/knitwork.mjs';
+import 'db0';
+import 'esbuild';
+import '../_deps/etag.mjs';
+import 'crypto';
+import 'unstorage';
+import 'nf3';
+import 'rendu';
+import '../_deps/chokidar.mjs';
+import 'fs/promises';
+import 'events';
+import '../_deps/readdirp.mjs';
+import 'node:stream';
+import 'os';
+import '../_deps/perfect-debounce.mjs';
+import '../_build/types.mjs';
+import '../_deps/untyped.mjs';
+import '../_deps/compatx.mjs';
+import '../_deps/gzip-size.mjs';
+import 'stream';
+import '../_deps/pretty-bytes.mjs';
+import 'std-env';
+import '../_build/snapshot.mjs';
+import 'klona';
+import '../_build/info.mjs';
+import 'nitro/meta';
+import '../_presets/_types.mjs';
+import '../_deps/ultrahtml.mjs';
+import 'h3';
+import 'srvx/node';
+import '../_build/prepare.mjs';
+import 'hookable';
+import '../_deps/c12.mjs';
+import 'jiti';
+import '../_deps/rc9.mjs';
+import 'destr';
+import '../_deps/dotenv.mjs';
+import 'klona/full';
+import '../_deps/escape-string-regexp.mjs';
+import 'ofetch';
+import 'node:worker_threads';
+import 'undici';
+import '../_deps/serve-static.mjs';
+import '../_deps/encodeurl.mjs';
+import '../_deps/escape-html.mjs';
+import '../_deps/parseurl.mjs';
+import '../_deps/send.mjs';
+import '../_deps/http-errors.mjs';
+import '../_deps/depd.mjs';
+import '../_deps/setprototypeof.mjs';
+import '../_deps/statuses.mjs';
+import '../_deps/inherits.mjs';
+import '../_deps/toidentifier.mjs';
+import '../_deps/debug.mjs';
+import 'tty';
+import 'util';
+import '../_deps/ms.mjs';
+import '../_deps/supports-color.mjs';
+import '../_deps/fresh.mjs';
+import '../_deps/mime-types.mjs';
+import '../_deps/mime-db.mjs';
+import '../_deps/on-finished.mjs';
+import '../_deps/ee-first.mjs';
+import '../_deps/range-parser.mjs';
+import '../_deps/httpxy.mjs';
+import 'node:http';
+import 'node:https';
+import 'node:events';
+import 'youch-core';
+import 'youch';
+import 'source-map';
+import 'srvx';
+import '../_deps/@rollup/plugin-alias.mjs';
+import '../_deps/@rollup/plugin-inject.mjs';
+import 'vite';
+import 'get-port-please';
+import 'node:child_process';
+import '../_deps/@pi0/vite-plugin-fullstack.mjs';
+import 'node:assert/strict';
+
+const hmrKeyRe = /^runtimeConfig\.|routeRules\./;
+const dev = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Start the development server"
+  },
+  args: {
+    ...commonArgs,
+    port: { type: "string", description: "specify port" },
+    host: { type: "string", description: "specify hostname " }
+  },
+  async run({ args }) {
+    const rootDir = resolve(args.dir || args._dir || ".");
+    let nitro;
+    const reload = async () => {
+      if (nitro) {
+        consola.info("Restarting dev server...");
+        if ("unwatch" in nitro.options._c12) {
+          await nitro.options._c12.unwatch();
+        }
+        await nitro.close();
+      }
+      nitro = await createNitro(
+        {
+          rootDir,
+          dev: true,
+          _cli: { command: "dev" }
+        },
+        {
+          watch: true,
+          c12: {
+            async onUpdate({ getDiff, newConfig }) {
+              const diff = getDiff();
+              if (diff.length === 0) {
+                return;
+              }
+              consola.info(
+                "Nitro config updated:\n" + diff.map((entry) => `  ${entry.toString()}`).join("\n")
+              );
+              await (diff.every((e) => hmrKeyRe.test(e.key)) ? nitro.updateConfig(newConfig.config || {}) : reload());
+            }
+          }
+        }
+      );
+      nitro.hooks.hookOnce("restart", reload);
+      const server = new NitroDevServer(nitro);
+      await server.listen({
+        port: args.port,
+        hostname: args.host
+      });
+      await prepare(nitro);
+      await build(nitro);
+    };
+    await reload();
+  }
+});
+
+export { dev as default };

package/dist/{cli/index2.mjs → _cli/index.mjs}

@@ -1,7 +1,6 @@
-import { d as defineCommand } from './index.mjs';
+import { d as defineCommand } from '../_deps/citty.mjs';
 import 'consola';
 import 'consola/utils';
-import 'nitro/meta';
 
 const index = defineCommand({
   meta: {

package/dist/{cli → _cli}/list.mjs

@@ -1,9 +1,8 @@
-import { d as defineCommand } from './index.mjs';
+import { d as defineCommand } from '../_deps/citty.mjs';
 import { consola } from 'consola';
 import { loadOptions, listTasks } from 'nitro';
-import { r as resolve } from '../_chunks/pathe.M-eThtNZ.mjs';
+import { a as resolve } from '../_deps/pathe.mjs';
 import 'consola/utils';
-import 'nitro/meta';
 
 const list = defineCommand({
   meta: {

package/dist/{cli → _cli}/prepare.mjs

@@ -1,10 +1,9 @@
-import { d as defineCommand } from './index.mjs';
+import { d as defineCommand } from '../_deps/citty.mjs';
 import { createNitro, writeTypes } from 'nitro';
 import { c as commonArgs } from './common.mjs';
-import { r as resolve } from '../_chunks/pathe.M-eThtNZ.mjs';
+import { a as resolve } from '../_deps/pathe.mjs';
 import 'consola';
 import 'consola/utils';
-import 'nitro/meta';
 
 const prepare = defineCommand({
   meta: {

package/dist/{cli → _cli}/run.mjs

@@ -1,10 +1,9 @@
-import { d as defineCommand } from './index.mjs';
+import { d as defineCommand } from '../_deps/citty.mjs';
 import { consola } from 'consola';
 import destr from 'destr';
 import { loadOptions, runTask } from 'nitro';
-import { r as resolve } from '../_chunks/pathe.M-eThtNZ.mjs';
+import { a as resolve } from '../_deps/pathe.mjs';
 import 'consola/utils';
-import 'nitro/meta';
 
 const run = defineCommand({
   meta: {

package/dist/_deps/@jridgewell/gen-mapping.mjs

@@ -0,0 +1,189 @@
+import { e as encode } from './sourcemap-codec.mjs';
+
+// src/set-array.ts
+var SetArray = class {
+  constructor() {
+    this._indexes = { __proto__: null };
+    this.array = [];
+  }
+};
+function cast(set) {
+  return set;
+}
+function get(setarr, key) {
+  return cast(setarr)._indexes[key];
+}
+function put(setarr, key) {
+  const index = get(setarr, key);
+  if (index !== void 0) return index;
+  const { array, _indexes: indexes } = cast(setarr);
+  const length = array.push(key);
+  return indexes[key] = length - 1;
+}
+function remove(setarr, key) {
+  const index = get(setarr, key);
+  if (index === void 0) return;
+  const { array, _indexes: indexes } = cast(setarr);
+  for (let i = index + 1; i < array.length; i++) {
+    const k = array[i];
+    array[i - 1] = k;
+    indexes[k]--;
+  }
+  indexes[key] = void 0;
+  array.pop();
+}
+
+// src/sourcemap-segment.ts
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+
+// src/gen-mapping.ts
+var NO_NAME = -1;
+var GenMapping = class {
+  constructor({ file, sourceRoot } = {}) {
+    this._names = new SetArray();
+    this._sources = new SetArray();
+    this._sourcesContent = [];
+    this._mappings = [];
+    this.file = file;
+    this.sourceRoot = sourceRoot;
+    this._ignoreList = new SetArray();
+  }
+};
+function cast2(map) {
+  return map;
+}
+var maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
+  return addSegmentInternal(
+    true,
+    map,
+    genLine,
+    genColumn,
+    source,
+    sourceLine,
+    sourceColumn,
+    name);
+};
+function setSourceContent(map, source, content) {
+  const {
+    _sources: sources,
+    _sourcesContent: sourcesContent
+    // _originalScopes: originalScopes,
+  } = cast2(map);
+  const index = put(sources, source);
+  sourcesContent[index] = content;
+}
+function setIgnore(map, source, ignore = true) {
+  const {
+    _sources: sources,
+    _sourcesContent: sourcesContent,
+    _ignoreList: ignoreList
+    // _originalScopes: originalScopes,
+  } = cast2(map);
+  const index = put(sources, source);
+  if (index === sourcesContent.length) sourcesContent[index] = null;
+  if (ignore) put(ignoreList, index);
+  else remove(ignoreList, index);
+}
+function toDecodedMap(map) {
+  const {
+    _mappings: mappings,
+    _sources: sources,
+    _sourcesContent: sourcesContent,
+    _names: names,
+    _ignoreList: ignoreList
+    // _originalScopes: originalScopes,
+    // _generatedRanges: generatedRanges,
+  } = cast2(map);
+  removeEmptyFinalLines(mappings);
+  return {
+    version: 3,
+    file: map.file || void 0,
+    names: names.array,
+    sourceRoot: map.sourceRoot || void 0,
+    sources: sources.array,
+    sourcesContent,
+    mappings,
+    // originalScopes,
+    // generatedRanges,
+    ignoreList: ignoreList.array
+  };
+}
+function toEncodedMap(map) {
+  const decoded = toDecodedMap(map);
+  return Object.assign({}, decoded, {
+    // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)),
+    // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]),
+    mappings: encode(decoded.mappings)
+  });
+}
+function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+  const {
+    _mappings: mappings,
+    _sources: sources,
+    _sourcesContent: sourcesContent,
+    _names: names
+    // _originalScopes: originalScopes,
+  } = cast2(map);
+  const line = getIndex(mappings, genLine);
+  const index = getColumnIndex(line, genColumn);
+  if (!source) {
+    if (skipSourceless(line, index)) return;
+    return insert(line, index, [genColumn]);
+  }
+  const sourcesIndex = put(sources, source);
+  const namesIndex = name ? put(names, name) : NO_NAME;
+  if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = null;
+  if (skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+    return;
+  }
+  return insert(
+    line,
+    index,
+    name ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn]
+  );
+}
+function getIndex(arr, index) {
+  for (let i = arr.length; i <= index; i++) {
+    arr[i] = [];
+  }
+  return arr[index];
+}
+function getColumnIndex(line, genColumn) {
+  let index = line.length;
+  for (let i = index - 1; i >= 0; index = i--) {
+    const current = line[i];
+    if (genColumn >= current[COLUMN]) break;
+  }
+  return index;
+}
+function insert(array, index, value) {
+  for (let i = array.length; i > index; i--) {
+    array[i] = array[i - 1];
+  }
+  array[index] = value;
+}
+function removeEmptyFinalLines(mappings) {
+  const { length } = mappings;
+  let len = length;
+  for (let i = len - 1; i >= 0; len = i, i--) {
+    if (mappings[i].length > 0) break;
+  }
+  if (len < length) mappings.length = len;
+}
+function skipSourceless(line, index) {
+  if (index === 0) return true;
+  const prev = line[index - 1];
+  return prev.length === 1;
+}
+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+  if (index === 0) return false;
+  const prev = line[index - 1];
+  if (prev.length === 1) return false;
+  return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME);
+}
+
+export { GenMapping as G, toEncodedMap as a, setIgnore as b, maybeAddSegment as m, setSourceContent as s, toDecodedMap as t };

package/dist/_deps/@jridgewell/remapping.mjs

@@ -0,0 +1,137 @@
+import { T as TraceMap, d as decodedMappings, t as traceSegment } from './trace-mapping.mjs';
+import { t as toDecodedMap, a as toEncodedMap, G as GenMapping, m as maybeAddSegment, s as setSourceContent, b as setIgnore } from './gen-mapping.mjs';
+
+// src/build-source-map-tree.ts
+var SOURCELESS_MAPPING = /* @__PURE__ */ SegmentObject("", -1, -1, "", null, false);
+var EMPTY_SOURCES = [];
+function SegmentObject(source, line, column, name, content, ignore) {
+  return { source, line, column, name, content, ignore };
+}
+function Source(map, sources, source, content, ignore) {
+  return {
+    map,
+    sources,
+    source,
+    content,
+    ignore
+  };
+}
+function MapSource(map, sources) {
+  return Source(map, sources, "", null, false);
+}
+function OriginalSource(source, content, ignore) {
+  return Source(null, EMPTY_SOURCES, source, content, ignore);
+}
+function traceMappings(tree) {
+  const gen = new GenMapping({ file: tree.map.file });
+  const { sources: rootSources, map } = tree;
+  const rootNames = map.names;
+  const rootMappings = decodedMappings(map);
+  for (let i = 0; i < rootMappings.length; i++) {
+    const segments = rootMappings[i];
+    for (let j = 0; j < segments.length; j++) {
+      const segment = segments[j];
+      const genCol = segment[0];
+      let traced = SOURCELESS_MAPPING;
+      if (segment.length !== 1) {
+        const source2 = rootSources[segment[1]];
+        traced = originalPositionFor(
+          source2,
+          segment[2],
+          segment[3],
+          segment.length === 5 ? rootNames[segment[4]] : ""
+        );
+        if (traced == null) continue;
+      }
+      const { column, line, name, content, source, ignore } = traced;
+      maybeAddSegment(gen, i, genCol, source, line, column, name);
+      if (source && content != null) setSourceContent(gen, source, content);
+      if (ignore) setIgnore(gen, source, true);
+    }
+  }
+  return gen;
+}
+function originalPositionFor(source, line, column, name) {
+  if (!source.map) {
+    return SegmentObject(source.source, line, column, name, source.content, source.ignore);
+  }
+  const segment = traceSegment(source.map, line, column);
+  if (segment == null) return null;
+  if (segment.length === 1) return SOURCELESS_MAPPING;
+  return originalPositionFor(
+    source.sources[segment[1]],
+    segment[2],
+    segment[3],
+    segment.length === 5 ? source.map.names[segment[4]] : name
+  );
+}
+
+// src/build-source-map-tree.ts
+function asArray(value) {
+  if (Array.isArray(value)) return value;
+  return [value];
+}
+function buildSourceMapTree(input, loader) {
+  const maps = asArray(input).map((m) => new TraceMap(m, ""));
+  const map = maps.pop();
+  for (let i = 0; i < maps.length; i++) {
+    if (maps[i].sources.length > 1) {
+      throw new Error(
+        `Transformation map ${i} must have exactly one source file.
+Did you specify these with the most recent transformation maps first?`
+      );
+    }
+  }
+  let tree = build(map, loader, "", 0);
+  for (let i = maps.length - 1; i >= 0; i--) {
+    tree = MapSource(maps[i], [tree]);
+  }
+  return tree;
+}
+function build(map, loader, importer, importerDepth) {
+  const { resolvedSources, sourcesContent, ignoreList } = map;
+  const depth = importerDepth + 1;
+  const children = resolvedSources.map((sourceFile, i) => {
+    const ctx = {
+      importer,
+      depth,
+      source: sourceFile || "",
+      content: void 0,
+      ignore: void 0
+    };
+    const sourceMap = loader(ctx.source, ctx);
+    const { source} = ctx;
+    if (sourceMap) return build(new TraceMap(sourceMap, source), loader, source, depth);
+    const sourceContent = sourcesContent ? sourcesContent[i] : null;
+    const ignored = ignoreList ? ignoreList.includes(i) : false;
+    return OriginalSource(source, sourceContent, ignored);
+  });
+  return MapSource(map, children);
+}
+var SourceMap = class {
+  constructor(map, options) {
+    const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map);
+    this.version = out.version;
+    this.file = out.file;
+    this.mappings = out.mappings;
+    this.names = out.names;
+    this.ignoreList = out.ignoreList;
+    this.sourceRoot = out.sourceRoot;
+    this.sources = out.sources;
+    if (!options.excludeContent) {
+      this.sourcesContent = out.sourcesContent;
+    }
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+};
+
+// src/remapping.ts
+function remapping(input, loader, options) {
+  const opts = { excludeContent: true, decodedMappings: false };
+  const tree = buildSourceMapTree(input, loader);
+  return new SourceMap(traceMappings(tree), opts);
+}
+
+export { remapping as r };