nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-121649-98b56dfe

package/dist/_libs/plugin-replace.mjs

@@ -0,0 +1,104 @@
+import { t as MagicString } from "./magic-string.mjs";
+import { r as createFilter } from "./plugin-commonjs.mjs";
+
+//#region node_modules/.pnpm/@rollup+plugin-replace@6.0.3_rollup@4.52.5/node_modules/@rollup/plugin-replace/dist/es/index.js
+function escape(str) {
+	return str.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&");
+}
+function ensureFunction(functionOrValue) {
+	if (typeof functionOrValue === "function") return functionOrValue;
+	return function() {
+		return functionOrValue;
+	};
+}
+function longest(a, b) {
+	return b.length - a.length;
+}
+function getReplacements(options) {
+	if (options.values) return Object.assign({}, options.values);
+	var values = Object.assign({}, options);
+	delete values.delimiters;
+	delete values.include;
+	delete values.exclude;
+	delete values.sourcemap;
+	delete values.sourceMap;
+	delete values.objectGuards;
+	delete values.preventAssignment;
+	return values;
+}
+function mapToFunctions(object) {
+	return Object.keys(object).reduce(function(fns, key) {
+		var functions = Object.assign({}, fns);
+		functions[key] = ensureFunction(object[key]);
+		return functions;
+	}, {});
+}
+var objKeyRegEx = /^([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)(\.([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*))+$/;
+function expandTypeofReplacements(replacements) {
+	Object.keys(replacements).forEach(function(key) {
+		var objMatch = key.match(objKeyRegEx);
+		if (!objMatch) return;
+		var dotIndex = objMatch[1].length;
+		do {
+			replacements["typeof " + key.slice(0, dotIndex)] = "\"object\"";
+			dotIndex = key.indexOf(".", dotIndex + 1);
+		} while (dotIndex !== -1);
+	});
+}
+function replace(options) {
+	if (options === void 0) options = {};
+	var filter = createFilter(options.include, options.exclude);
+	var delimiters = options.delimiters;
+	if (delimiters === void 0) delimiters = ["(?<![_$a-zA-Z0-9\\xA0-\\uFFFF])", "(?![_$a-zA-Z0-9\\xA0-\\uFFFF])(?!\\.)"];
+	var preventAssignment = options.preventAssignment;
+	var objectGuards = options.objectGuards;
+	var replacements = getReplacements(options);
+	if (objectGuards) expandTypeofReplacements(replacements);
+	var functionValues = mapToFunctions(replacements);
+	var keys = Object.keys(functionValues).sort(longest).map(escape);
+	var lookbehind = preventAssignment ? "(?<!\\b(?:const|let|var)\\s*)" : "";
+	var lookahead = preventAssignment ? "(?!\\s*=[^=])" : "";
+	var pattern = new RegExp("" + lookbehind + delimiters[0] + "(" + keys.join("|") + ")" + delimiters[1] + lookahead, "g");
+	return {
+		name: "replace",
+		buildStart: function buildStart() {
+			if (![true, false].includes(preventAssignment)) this.warn({ message: "@rollup/plugin-replace: 'preventAssignment' currently defaults to false. It is recommended to set this option to `true`, as the next major version will default this option to `true`." });
+		},
+		renderChunk: function renderChunk(code, chunk) {
+			var id = chunk.fileName;
+			if (!keys.length) return null;
+			if (!filter(id)) return null;
+			return executeReplacement(code, id);
+		},
+		transform: function transform(code, id) {
+			if (!keys.length) return null;
+			if (!filter(id)) return null;
+			return executeReplacement(code, id);
+		}
+	};
+	function executeReplacement(code, id) {
+		var magicString = new MagicString(code);
+		if (!codeHasReplacements(code, id, magicString)) return null;
+		var result = { code: magicString.toString() };
+		if (isSourceMapEnabled()) result.map = magicString.generateMap({ hires: true });
+		return result;
+	}
+	function codeHasReplacements(code, id, magicString) {
+		var result = false;
+		var match;
+		while (match = pattern.exec(code)) {
+			result = true;
+			var start = match.index;
+			var end = start + match[0].length;
+			var replacement = String(functionValues[match[1]](id));
+			magicString.overwrite(start, end, replacement);
+		}
+		return result;
+	}
+	function isSourceMapEnabled() {
+		return options.sourceMap !== false && options.sourcemap !== false;
+	}
+}
+
+//#endregion
+export { replace as t };

package/dist/_libs/pretty-bytes.mjs

@@ -0,0 +1,116 @@
+//#region node_modules/.pnpm/pretty-bytes@7.1.0/node_modules/pretty-bytes/index.js
+const BYTE_UNITS = [
+	"B",
+	"kB",
+	"MB",
+	"GB",
+	"TB",
+	"PB",
+	"EB",
+	"ZB",
+	"YB"
+];
+const BIBYTE_UNITS = [
+	"B",
+	"KiB",
+	"MiB",
+	"GiB",
+	"TiB",
+	"PiB",
+	"EiB",
+	"ZiB",
+	"YiB"
+];
+const BIT_UNITS = [
+	"b",
+	"kbit",
+	"Mbit",
+	"Gbit",
+	"Tbit",
+	"Pbit",
+	"Ebit",
+	"Zbit",
+	"Ybit"
+];
+const BIBIT_UNITS = [
+	"b",
+	"kibit",
+	"Mibit",
+	"Gibit",
+	"Tibit",
+	"Pibit",
+	"Eibit",
+	"Zibit",
+	"Yibit"
+];
+const toLocaleString = (number, locale, options) => {
+	let result = number;
+	if (typeof locale === "string" || Array.isArray(locale)) result = number.toLocaleString(locale, options);
+	else if (locale === true || options !== void 0) result = number.toLocaleString(void 0, options);
+	return result;
+};
+const log10 = (numberOrBigInt) => {
+	if (typeof numberOrBigInt === "number") return Math.log10(numberOrBigInt);
+	const string = numberOrBigInt.toString(10);
+	return string.length + Math.log10(`0.${string.slice(0, 15)}`);
+};
+const log = (numberOrBigInt) => {
+	if (typeof numberOrBigInt === "number") return Math.log(numberOrBigInt);
+	return log10(numberOrBigInt) * Math.log(10);
+};
+const divide = (numberOrBigInt, divisor) => {
+	if (typeof numberOrBigInt === "number") return numberOrBigInt / divisor;
+	const integerPart = numberOrBigInt / BigInt(divisor);
+	const remainder = numberOrBigInt % BigInt(divisor);
+	return Number(integerPart) + Number(remainder) / divisor;
+};
+const applyFixedWidth = (result, fixedWidth) => {
+	if (fixedWidth === void 0) return result;
+	if (typeof fixedWidth !== "number" || !Number.isSafeInteger(fixedWidth) || fixedWidth < 0) throw new TypeError(`Expected fixedWidth to be a non-negative integer, got ${typeof fixedWidth}: ${fixedWidth}`);
+	if (fixedWidth === 0) return result;
+	return result.length < fixedWidth ? result.padStart(fixedWidth, " ") : result;
+};
+const buildLocaleOptions = (options) => {
+	const { minimumFractionDigits, maximumFractionDigits } = options;
+	if (minimumFractionDigits === void 0 && maximumFractionDigits === void 0) return;
+	return {
+		...minimumFractionDigits !== void 0 && { minimumFractionDigits },
+		...maximumFractionDigits !== void 0 && { maximumFractionDigits },
+		roundingMode: "trunc"
+	};
+};
+function prettyBytes(number, options) {
+	if (typeof number !== "bigint" && !Number.isFinite(number)) throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
+	options = {
+		bits: false,
+		binary: false,
+		space: true,
+		nonBreakingSpace: false,
+		...options
+	};
+	const UNITS = options.bits ? options.binary ? BIBIT_UNITS : BIT_UNITS : options.binary ? BIBYTE_UNITS : BYTE_UNITS;
+	const separator = options.space ? options.nonBreakingSpace ? "\xA0" : " " : "";
+	const isZero = typeof number === "number" ? number === 0 : number === 0n;
+	if (options.signed && isZero) return applyFixedWidth(` 0${separator}${UNITS[0]}`, options.fixedWidth);
+	const isNegative = number < 0;
+	const prefix = isNegative ? "-" : options.signed ? "+" : "";
+	if (isNegative) number = -number;
+	const localeOptions = buildLocaleOptions(options);
+	let result;
+	if (number < 1) result = prefix + toLocaleString(number, options.locale, localeOptions) + separator + UNITS[0];
+	else {
+		const exponent = Math.min(Math.floor(options.binary ? log(number) / Math.log(1024) : log10(number) / 3), UNITS.length - 1);
+		number = divide(number, (options.binary ? 1024 : 1e3) ** exponent);
+		if (!localeOptions) {
+			const minPrecision = Math.max(3, Math.floor(number).toString().length);
+			number = number.toPrecision(minPrecision);
+		}
+		const numberString = toLocaleString(Number(number), options.locale, localeOptions);
+		const unit = UNITS[exponent];
+		result = prefix + numberString + separator + unit;
+	}
+	return applyFixedWidth(result, options.fixedWidth);
+}
+
+//#endregion
+export { prettyBytes as t };

package/dist/_libs/range-parser.mjs

@@ -0,0 +1,102 @@
+import { t as __commonJS } from "../_chunks/DXMHy5ca.mjs";
+
+//#region node_modules/.pnpm/range-parser@1.2.1/node_modules/range-parser/index.js
+var require_range_parser = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/range-parser@1.2.1/node_modules/range-parser/index.js": ((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = rangeParser;
+	/**
+	* Parse "Range" header `str` relative to the given file `size`.
+	*
+	* @param {Number} size
+	* @param {String} str
+	* @param {Object} [options]
+	* @return {Array}
+	* @public
+	*/
+	function rangeParser(size, str, options) {
+		if (typeof str !== "string") throw new TypeError("argument str must be a string");
+		var index = str.indexOf("=");
+		if (index === -1) return -2;
+		var arr = str.slice(index + 1).split(",");
+		var ranges = [];
+		ranges.type = str.slice(0, index);
+		for (var i = 0; i < arr.length; i++) {
+			var range = arr[i].split("-");
+			var start = parseInt(range[0], 10);
+			var end = parseInt(range[1], 10);
+			if (isNaN(start)) {
+				start = size - end;
+				end = size - 1;
+			} else if (isNaN(end)) end = size - 1;
+			if (end > size - 1) end = size - 1;
+			if (isNaN(start) || isNaN(end) || start > end || start < 0) continue;
+			ranges.push({
+				start,
+				end
+			});
+		}
+		if (ranges.length < 1) return -1;
+		return options && options.combine ? combineRanges(ranges) : ranges;
+	}
+	/**
+	* Combine overlapping & adjacent ranges.
+	* @private
+	*/
+	function combineRanges(ranges) {
+		var ordered = ranges.map(mapWithIndex).sort(sortByRangeStart);
+		for (var j = 0, i = 1; i < ordered.length; i++) {
+			var range = ordered[i];
+			var current = ordered[j];
+			if (range.start > current.end + 1) ordered[++j] = range;
+			else if (range.end > current.end) {
+				current.end = range.end;
+				current.index = Math.min(current.index, range.index);
+			}
+		}
+		ordered.length = j + 1;
+		var combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex);
+		combined.type = ranges.type;
+		return combined;
+	}
+	/**
+	* Map function to add index value to ranges.
+	* @private
+	*/
+	function mapWithIndex(range, index) {
+		return {
+			start: range.start,
+			end: range.end,
+			index
+		};
+	}
+	/**
+	* Map function to remove index value from ranges.
+	* @private
+	*/
+	function mapWithoutIndex(range) {
+		return {
+			start: range.start,
+			end: range.end
+		};
+	}
+	/**
+	* Sort function to sort ranges by index.
+	* @private
+	*/
+	function sortByRangeIndex(a, b) {
+		return a.index - b.index;
+	}
+	/**
+	* Sort function to sort ranges by start position.
+	* @private
+	*/
+	function sortByRangeStart(a, b) {
+		return a.start - b.start;
+	}
+}) });
+
+//#endregion
+export { require_range_parser as t };

package/dist/_libs/remapping.mjs

@@ -0,0 +1,117 @@
+import { a as toDecodedMap, c as decodedMappings, i as setSourceContent, l as traceSegment, n as maybeAddSegment, o as toEncodedMap, r as setIgnore, s as TraceMap, t as GenMapping } from "./gen-mapping.mjs";
+
+//#region node_modules/.pnpm/@jridgewell+remapping@2.3.5/node_modules/@jridgewell/remapping/dist/remapping.mjs
+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);
+}
+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;
+	return MapSource(map, resolvedSources.map((sourceFile, i) => {
+		const ctx = {
+			importer,
+			depth,
+			source: sourceFile || "",
+			content: void 0,
+			ignore: void 0
+		};
+		const sourceMap = loader(ctx.source, ctx);
+		const { source, content, ignore } = ctx;
+		if (sourceMap) return build(new TraceMap(sourceMap, source), loader, source, depth);
+		return OriginalSource(source, content !== void 0 ? content : sourcesContent ? sourcesContent[i] : null, ignore !== void 0 ? ignore : ignoreList ? ignoreList.includes(i) : false);
+	}));
+}
+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);
+	}
+};
+function remapping(input, loader, options) {
+	const opts = typeof options === "object" ? options : {
+		excludeContent: !!options,
+		decodedMappings: false
+	};
+	return new SourceMap(traceMappings(buildSourceMapTree(input, loader)), opts);
+}
+
+//#endregion
+export { remapping as t };