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

package/dist/_build/vite2.mjs

@@ -0,0 +1,149 @@
+import { n as nitro } from './vite.mjs';
+import { a } from '../_chunks/_deps/std-env.mjs';
+import './prepare.mjs';
+import 'consola';
+import 'hookable';
+import '../_chunks/_deps/c12.mjs';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:url';
+import 'node:os';
+import '../_chunks/_deps/exsolve.mjs';
+import 'node:path';
+import 'node:assert';
+import 'node:process';
+import 'node:v8';
+import 'node:util';
+import 'jiti';
+import '../_chunks/_deps/rc9.mjs';
+import 'destr';
+import 'defu';
+import '../_chunks/_deps/pkg-types.mjs';
+import '../_chunks/_deps/mlly.mjs';
+import '../_chunks/_deps/acorn.mjs';
+import 'node:module';
+import 'ufo';
+import '../_chunks/_deps/pathe.mjs';
+import '../_chunks/_deps/confbox.mjs';
+import '../_chunks/_deps/dotenv.mjs';
+import 'fs';
+import 'os';
+import 'crypto';
+import 'path';
+import '../_chunks/_deps/commondir.mjs';
+import '../_chunks/_deps/perfect-debounce.mjs';
+import '../_chunks/_deps/compatx.mjs';
+import '../_chunks/_deps/klona.mjs';
+import 'nitro/runtime/meta';
+import '../_chunks/_deps/escape-string-regexp.mjs';
+import '../_chunks/_deps/tinyglobby.mjs';
+import 'url';
+import '../_chunks/_deps/fdir.mjs';
+import 'module';
+import '../_chunks/_deps/picomatch.mjs';
+import 'ofetch';
+import 'unstorage';
+import '../_chunks/_deps/rou3.mjs';
+import 'ohash';
+import '../_chunks/_deps/unimport.mjs';
+import 'scule';
+import '../_chunks/_deps/magic-string.mjs';
+import '../_chunks/_deps/@jridgewell/sourcemap-codec.mjs';
+import '../_chunks/_deps/unplugin.mjs';
+import 'node:buffer';
+import '../_chunks/_deps/@jridgewell/remapping.mjs';
+import '../_chunks/_deps/@jridgewell/trace-mapping.mjs';
+import '../_chunks/_deps/@jridgewell/resolve-uri.mjs';
+import '../_chunks/_deps/@jridgewell/gen-mapping.mjs';
+import 'node:querystring';
+import '../_chunks/_deps/webpack-virtual-modules.mjs';
+import 'constants';
+import '../_chunks/_deps/unplugin-utils.mjs';
+import '../_chunks/_deps/local-pkg.mjs';
+import '../_chunks/_deps/quansync.mjs';
+import '../_chunks/_deps/estree-walker.mjs';
+import '../_chunks/_deps/strip-literal.mjs';
+import '../_chunks/_deps/js-tokens.mjs';
+import 'consola/utils';
+import '../_chunks/_deps/dot-prop.mjs';
+import 'node:zlib';
+import '../_chunks/_deps/mime.mjs';
+import 'node:worker_threads';
+import 'h3';
+import 'undici';
+import 'nitro/meta';
+import 'srvx/node';
+import '../_chunks/app.mjs';
+import '../_chunks/_deps/serve-static.mjs';
+import '../_chunks/_deps/encodeurl.mjs';
+import '../_chunks/_deps/escape-html.mjs';
+import '../_chunks/_deps/parseurl.mjs';
+import '../_chunks/_deps/send.mjs';
+import '../_chunks/_deps/http-errors.mjs';
+import '../_chunks/_deps/depd.mjs';
+import '../_chunks/_deps/setprototypeof.mjs';
+import '../_chunks/_deps/statuses.mjs';
+import '../_chunks/_deps/inherits.mjs';
+import '../_chunks/_deps/toidentifier.mjs';
+import '../_chunks/_deps/debug.mjs';
+import 'tty';
+import 'util';
+import '../_chunks/_deps/ms.mjs';
+import '../_chunks/_deps/supports-color.mjs';
+import '../_chunks/_deps/etag.mjs';
+import '../_chunks/_deps/fresh.mjs';
+import '../_chunks/_deps/mime-types.mjs';
+import '../_chunks/_deps/mime-db.mjs';
+import '../_chunks/_deps/on-finished.mjs';
+import '../_chunks/_deps/ee-first.mjs';
+import '../_chunks/_deps/range-parser.mjs';
+import 'stream';
+import '../_chunks/_deps/httpxy.mjs';
+import 'node:http';
+import 'node:https';
+import 'node:events';
+import 'youch-core';
+import 'youch';
+import 'source-map';
+import 'srvx';
+import '../_chunks/_deps/@rollup/plugin-alias.mjs';
+import '../_chunks/_deps/@rollup/plugin-inject.mjs';
+import '../_chunks/_deps/@rollup/pluginutils.mjs';
+import './info.mjs';
+import '../_chunks/_deps/@rollup/plugin-replace.mjs';
+import 'unenv';
+import '../_chunks/_deps/unwasm.mjs';
+import 'node:crypto';
+import '../_chunks/_deps/knitwork.mjs';
+import 'db0';
+import 'esbuild';
+import 'nf3';
+import 'rendu';
+import '../_chunks/_presets/_types.mjs';
+import 'vite';
+import '../_chunks/_deps/chokidar.mjs';
+import 'fs/promises';
+import 'events';
+import '../_chunks/_deps/readdirp.mjs';
+import 'node:stream';
+import 'get-port-please';
+import 'node:child_process';
+import '../_chunks/_deps/@pi0/vite-plugin-fullstack.mjs';
+import 'node:assert/strict';
+
+async function viteBuild(nitro$1) {
+  if (nitro$1.options.dev) {
+    throw new Error(
+      "Nitro vite builder is not supported in development mode. Please use `vite dev` instead."
+    );
+  }
+  const { createBuilder } = await import('vite');
+  const builder = await createBuilder({
+    base: nitro$1.options.rootDir,
+    plugins: [await nitro({ _nitro: nitro$1 })],
+    logLevel: a ? "warn" : void 0
+  });
+  await builder.buildApp();
+}
+
+export { viteBuild };

package/dist/_chunks/_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/_chunks/_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 };