nitro-nightly 3.0.1-20260106-202835-5325b208 → 3.0.1-20260106-205209-b085a480

package/dist/_chunks/utils.mjs

@@ -0,0 +1,278 @@
+import { i as __toESM, r as __require, t as __commonJSMin } from "../_common.mjs";
+import { Ft as resolve, Pt as relative, dt as a, kt as dirname, rt as glob } from "../_build/common.mjs";
+import fs, { promises } from "node:fs";
+import { promisify } from "node:util";
+import { colors } from "consola/utils";
+import zlib from "node:zlib";
+import "node:stream";
+
+//#region src/utils/parallel.ts
+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$1) => setTimeout(resolve$1, 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();
+}
+
+//#endregion
+//#region node_modules/.pnpm/duplexer@0.1.2/node_modules/duplexer/index.js
+var require_duplexer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Stream = __require("stream");
+	var writeMethods = [
+		"write",
+		"end",
+		"destroy"
+	];
+	var readMethods = ["resume", "pause"];
+	var readEvents = ["data", "close"];
+	var slice = Array.prototype.slice;
+	module.exports = duplex;
+	function forEach(arr, fn) {
+		if (arr.forEach) return arr.forEach(fn);
+		for (var i = 0; i < arr.length; i++) fn(arr[i], i);
+	}
+	function duplex(writer, reader) {
+		var stream = new Stream();
+		var ended = false;
+		forEach(writeMethods, proxyWriter);
+		forEach(readMethods, proxyReader);
+		forEach(readEvents, proxyStream);
+		reader.on("end", handleEnd);
+		writer.on("drain", function() {
+			stream.emit("drain");
+		});
+		writer.on("error", reemit);
+		reader.on("error", reemit);
+		stream.writable = writer.writable;
+		stream.readable = reader.readable;
+		return stream;
+		function proxyWriter(methodName) {
+			stream[methodName] = method;
+			function method() {
+				return writer[methodName].apply(writer, arguments);
+			}
+		}
+		function proxyReader(methodName) {
+			stream[methodName] = method;
+			function method() {
+				stream.emit(methodName);
+				var func = reader[methodName];
+				if (func) return func.apply(reader, arguments);
+				reader.emit(methodName);
+			}
+		}
+		function proxyStream(methodName) {
+			reader.on(methodName, reemit$1);
+			function reemit$1() {
+				var args = slice.call(arguments);
+				args.unshift(methodName);
+				stream.emit.apply(stream, args);
+			}
+		}
+		function handleEnd() {
+			if (ended) return;
+			ended = true;
+			var args = slice.call(arguments);
+			args.unshift("end");
+			stream.emit.apply(stream, args);
+		}
+		function reemit(err) {
+			stream.emit("error", err);
+		}
+	}
+}));
+
+//#endregion
+//#region node_modules/.pnpm/gzip-size@7.0.0/node_modules/gzip-size/index.js
+var import_duplexer = /* @__PURE__ */ __toESM(require_duplexer(), 1);
+const getOptions = (options) => ({
+	level: 9,
+	...options
+});
+const gzip = promisify(zlib.gzip);
+async function gzipSize(input, options) {
+	if (!input) return 0;
+	return (await gzip(input, getOptions(options))).length;
+}
+
+//#endregion
+//#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
+//#region src/utils/fs-tree.ts
+async function generateFSTree(dir, options = {}) {
+	if (a) return;
+	const files = await glob("**/*.*", {
+		cwd: dir,
+		ignore: ["*.map"]
+	});
+	const items = [];
+	await runParallel(new Set(files), async (file) => {
+		const path = resolve(dir, file);
+		const src = await promises.readFile(path);
+		const size = src.byteLength;
+		const gzip$1 = options.compressedSizes ? await gzipSize(src) : 0;
+		items.push({
+			file,
+			path,
+			size,
+			gzip: gzip$1
+		});
+	}, { concurrency: 10 });
+	items.sort((a$1, b) => a$1.path.localeCompare(b.path));
+	let totalSize = 0;
+	let totalGzip = 0;
+	let totalNodeModulesSize = 0;
+	let totalNodeModulesGzip = 0;
+	let treeText = "";
+	for (const [index, item] of items.entries()) {
+		let dir$1 = dirname(item.file);
+		if (dir$1 === ".") dir$1 = "";
+		const rpath = relative(process.cwd(), item.path);
+		const treeChar = index === items.length - 1 ? "└─" : "├─";
+		if (item.file.includes("node_modules")) {
+			totalNodeModulesSize += item.size;
+			totalNodeModulesGzip += item.gzip;
+			continue;
+		}
+		treeText += colors.gray(`  ${treeChar} ${rpath} (${prettyBytes(item.size)})`);
+		if (options.compressedSizes) treeText += colors.gray(` (${prettyBytes(item.gzip)} gzip)`);
+		treeText += "\n";
+		totalSize += item.size;
+		totalGzip += item.gzip;
+	}
+	treeText += `${colors.cyan("Σ Total size:")} ${prettyBytes(totalSize + totalNodeModulesSize)}`;
+	if (options.compressedSizes) treeText += ` (${prettyBytes(totalGzip + totalNodeModulesGzip)} gzip)`;
+	treeText += "\n";
+	return treeText;
+}
+
+//#endregion
+export { runParallel as n, generateFSTree as t };

package/dist/_libs/@hiogawa/vite-plugin-fullstack.mjs

@@ -1,7 +1,5 @@
-import { n as __exportAll } from "../../_rolldown.mjs";
-import { t as MagicString } from "../magic-string.mjs";
-import { t as stripLiteral } from "../strip-literal.mjs";
-import { t as exactRegex } from "../@rolldown/pluginutils.mjs";
+import { n as __exportAll } from "../../_common.mjs";
+import { G as stripLiteral, K as MagicString } from "../../_build/common.mjs";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
@@ -10,6 +8,36 @@ import { createHash } from "node:crypto";
 import { isCSSRequest, normalizePath } from "vite";
 import assert$1 from "node:assert/strict";
 
+//#region node_modules/.pnpm/@rolldown+pluginutils@1.0.0-beta.55/node_modules/@rolldown/pluginutils/dist/simple-filters.js
+/**
+* Constructs a RegExp that matches the exact string specified.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*
+* @example
+* ```ts
+* import { exactRegex } from '@rolldown/pluginutils';
+* const plugin = {
+*   name: 'plugin',
+*   resolveId: {
+*     filter: { id: exactRegex('foo') },
+*     handler(id) {} // will only be called for `foo`
+*   }
+* }
+* ```
+*/
+function exactRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}$`, flags);
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+	return str.replace(escapeRegexRE, "\\$&");
+}
+
+//#endregion
 //#region node_modules/.pnpm/@hiogawa+vite-plugin-fullstack@0.0.11_vite@8.0.0-beta.5_@types+node@25.0.3_jiti@2.6.1_tsx@4.21.0_yaml@2.8.2_/node_modules/@hiogawa/vite-plugin-fullstack/dist/plugin-B4MlD0Bd.js
 function parseIdQuery(id) {
 	if (!id.includes("?")) return {

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

@@ -1,5 +1,307 @@
-import { n as encode } from "./sourcemap-codec.mjs";
+import { J as encode, q as decode } from "../../_build/common.mjs";
 
+//#region node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+* Matches the parts of a URL:
+* 1. Scheme, including ":", guaranteed.
+* 2. User/password, including "@", optional.
+* 3. Host, guaranteed.
+* 4. Port, including ":", optional.
+* 5. Path, including "/", optional.
+* 6. Query, including "?", optional.
+* 7. Hash, including "#", optional.
+*/
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+*
+* 1. Host, optional.
+* 2. Path, which may include "/", guaranteed.
+* 3. Query, including "?", optional.
+* 4. Hash, including "#", optional.
+*/
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+	return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+	return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+	return input.startsWith("/");
+}
+function isFileUrl(input) {
+	return input.startsWith("file:");
+}
+function isRelative(input) {
+	return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+	const match = urlRegex.exec(input);
+	return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+	const match = fileRegex.exec(input);
+	const path = match[2];
+	return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+	return {
+		scheme,
+		user,
+		host,
+		port,
+		path,
+		query,
+		hash,
+		type: 7
+	};
+}
+function parseUrl(input) {
+	if (isSchemeRelativeUrl(input)) {
+		const url$1 = parseAbsoluteUrl("http:" + input);
+		url$1.scheme = "";
+		url$1.type = 6;
+		return url$1;
+	}
+	if (isAbsolutePath(input)) {
+		const url$1 = parseAbsoluteUrl("http://foo.com" + input);
+		url$1.scheme = "";
+		url$1.host = "";
+		url$1.type = 5;
+		return url$1;
+	}
+	if (isFileUrl(input)) return parseFileUrl(input);
+	if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+	const url = parseAbsoluteUrl("http://foo.com/" + input);
+	url.scheme = "";
+	url.host = "";
+	url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+	return url;
+}
+function stripPathFilename(path) {
+	if (path.endsWith("/..")) return path;
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+	normalizePath(base, base.type);
+	if (url.path === "/") url.path = base.path;
+	else url.path = stripPathFilename(base.path) + url.path;
+}
+/**
+* The path can have empty directories "//", unneeded parents "foo/..", or current directory
+* "foo/.". We need to normalize to a standard representation.
+*/
+function normalizePath(url, type) {
+	const rel = type <= 4;
+	const pieces = url.path.split("/");
+	let pointer = 1;
+	let positive = 0;
+	let addTrailingSlash = false;
+	for (let i = 1; i < pieces.length; i++) {
+		const piece = pieces[i];
+		if (!piece) {
+			addTrailingSlash = true;
+			continue;
+		}
+		addTrailingSlash = false;
+		if (piece === ".") continue;
+		if (piece === "..") {
+			if (positive) {
+				addTrailingSlash = true;
+				positive--;
+				pointer--;
+			} else if (rel) pieces[pointer++] = piece;
+			continue;
+		}
+		pieces[pointer++] = piece;
+		positive++;
+	}
+	let path = "";
+	for (let i = 1; i < pointer; i++) path += "/" + pieces[i];
+	if (!path || addTrailingSlash && !path.endsWith("/..")) path += "/";
+	url.path = path;
+}
+/**
+* Attempts to resolve `input` URL/path relative to `base`.
+*/
+function resolve(input, base) {
+	if (!input && !base) return "";
+	const url = parseUrl(input);
+	let inputType = url.type;
+	if (base && inputType !== 7) {
+		const baseUrl = parseUrl(base);
+		const baseType = baseUrl.type;
+		switch (inputType) {
+			case 1: url.hash = baseUrl.hash;
+			case 2: url.query = baseUrl.query;
+			case 3:
+			case 4: mergePaths(url, baseUrl);
+			case 5:
+				url.user = baseUrl.user;
+				url.host = baseUrl.host;
+				url.port = baseUrl.port;
+			case 6: url.scheme = baseUrl.scheme;
+		}
+		if (baseType > inputType) inputType = baseType;
+	}
+	normalizePath(url, inputType);
+	const queryHash = url.query + url.hash;
+	switch (inputType) {
+		case 2:
+		case 3: return queryHash;
+		case 4: {
+			const path = url.path.slice(1);
+			if (!path) return queryHash || ".";
+			if (isRelative(base || input) && !isRelative(path)) return "./" + path + queryHash;
+			return path + queryHash;
+		}
+		case 5: return url.path + queryHash;
+		default: return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+	}
+}
+
+//#endregion
+//#region node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path) {
+	if (!path) return "";
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+	const from = stripFilename(mapUrl);
+	const prefix = sourceRoot ? sourceRoot + "/" : "";
+	return (source) => resolve(prefix + (source || ""), from);
+}
+var COLUMN$1 = 0;
+function maybeSort(mappings, owned) {
+	const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+	if (unsortedIndex === mappings.length) return mappings;
+	if (!owned) mappings = mappings.slice();
+	for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) mappings[i] = sortSegments(mappings[i], owned);
+	return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+	for (let i = start; i < mappings.length; i++) if (!isSorted(mappings[i])) return i;
+	return mappings.length;
+}
+function isSorted(line) {
+	for (let j = 1; j < line.length; j++) if (line[j][COLUMN$1] < line[j - 1][COLUMN$1]) return false;
+	return true;
+}
+function sortSegments(line, owned) {
+	if (!owned) line = line.slice();
+	return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[COLUMN$1] - b[COLUMN$1];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN$1] - needle;
+		if (cmp === 0) {
+			found = true;
+			return mid;
+		}
+		if (cmp < 0) low = mid + 1;
+		else high = mid - 1;
+	}
+	found = false;
+	return low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN$1] !== needle) break;
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN$1] !== needle) break;
+	return index;
+}
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found = lastIndex !== -1 && haystack[lastIndex][COLUMN$1] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) low = lastIndex === -1 ? 0 : lastIndex;
+		else high = lastIndex;
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse(map) {
+	return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+	constructor(map, mapUrl) {
+		const isString = typeof map === "string";
+		if (!isString && map._decodedMemo) return map;
+		const parsed = parse(map);
+		const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+		this.version = version;
+		this.file = file;
+		this.names = names || [];
+		this.sourceRoot = sourceRoot;
+		this.sources = sources;
+		this.sourcesContent = sourcesContent;
+		this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+		const resolve$1 = resolver(mapUrl, sourceRoot);
+		this.resolvedSources = sources.map(resolve$1);
+		const { mappings } = parsed;
+		if (typeof mappings === "string") {
+			this._encoded = mappings;
+			this._decoded = void 0;
+		} else if (Array.isArray(mappings)) {
+			this._encoded = void 0;
+			this._decoded = maybeSort(mappings, isString);
+		} else if (parsed.sections) throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+		else throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+		this._decodedMemo = memoizedState();
+		this._bySources = void 0;
+		this._bySourceMemos = void 0;
+	}
+};
+function cast$1(map) {
+	return map;
+}
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast$1(map))._decoded || (_a._decoded = decode(cast$1(map)._encoded));
+}
+function traceSegment(map, line, column) {
+	const decoded = decodedMappings(map);
+	if (line >= decoded.length) return null;
+	const segments = decoded[line];
+	const index = traceSegmentInternal(segments, cast$1(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+	return index === -1 ? null : segments[index];
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch(segments, column, memo, line);
+	if (found) index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+	else if (bias === LEAST_UPPER_BOUND) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+
+//#endregion
 //#region node_modules/.pnpm/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
 var SetArray = class {
 	constructor() {
@@ -143,4 +445,4 @@ function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIn
 }
 
 //#endregion
-export { toDecodedMap as a, setSourceContent as i, maybeAddSegment as n, toEncodedMap as o, setIgnore as r, GenMapping as t };
+export { toDecodedMap as a, decodedMappings as c, setSourceContent as i, traceSegment as l, maybeAddSegment as n, toEncodedMap as o, setIgnore as r, TraceMap as s, GenMapping as t };

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

@@ -1,5 +1,4 @@
-import { n as decodedMappings, r as traceSegment, t as TraceMap } from "./trace-mapping.mjs";
-import { a as toDecodedMap, i as setSourceContent, n as maybeAddSegment, o as toEncodedMap, r as setIgnore, t as GenMapping } from "./gen-mapping.mjs";
+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);