nitro-nightly 3.0.1-20260120-020848-6786d069 → 3.0.1-20260120-133849-ca1a9dee

package/dist/_libs/{c12+dotenv+rc9.mjs → rc9+c12+dotenv.mjs}

@@ -1,7 +1,5 @@
-import { n as __require, r as __toESM, t as __commonJSMin } from "../_chunks/nitro.mjs";
-import { a as join$1, n as dirname$1, o as normalize$1, r as extname$1, t as basename$1, u as resolve$1 } from "./pathe.mjs";
-import { l as resolveModulePath, o as readPackageJSON, r as findWorkspaceDir } from "./confbox+exsolve+pkg-types.mjs";
-import { t as debounce } from "./perfect-debounce.mjs";
+import { i as __toESM, n as __exportAll, r as __require, t as __commonJSMin } from "../_common.mjs";
+import { $ as resolveModulePath, Y as readPackageJSON, at as join$1, ct as resolve$1, nt as dirname$1, ot as normalize$1, q as findWorkspaceDir, rt as extname$1, tt as basename$1 } from "../_build/common.mjs";
 import { existsSync, promises, readFileSync, statSync } from "node:fs";
 import { readFile, rm } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
@@ -481,8 +479,103 @@ function readUser(options) {
 	return read(options);
 }
 
+//#endregion
+//#region node_modules/.pnpm/perfect-debounce@2.0.0/node_modules/perfect-debounce/dist/index.mjs
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve$2) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve$2(leadingValue);
+			} else resolveList.push(resolve$2);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+
 //#endregion
 //#region node_modules/.pnpm/c12@3.3.3_magicast@0.5.1/node_modules/c12/dist/index.mjs
+var dist_exports = /* @__PURE__ */ __exportAll({
+	SUPPORTED_EXTENSIONS: () => SUPPORTED_EXTENSIONS,
+	loadConfig: () => loadConfig,
+	loadDotenv: () => loadDotenv,
+	setupDotenv: () => setupDotenv,
+	watchConfig: () => watchConfig
+});
 var import_main = /* @__PURE__ */ __toESM(require_main(), 1);
 /**
 * Load and interpolate environment variables into `process.env`.
@@ -560,11 +653,11 @@ function getDotEnvVars(targetEnvironment) {
 }
 const _normalize = (p) => p?.replace(/\\/g, "/");
 const ASYNC_LOADERS = {
-	".yaml": () => import("./_.mjs").then((r) => r.parseYAML),
-	".yml": () => import("./_.mjs").then((r) => r.parseYAML),
-	".jsonc": () => import("./confbox4.mjs").then((r) => r.parseJSONC),
-	".json5": () => import("./confbox2.mjs").then((r) => r.parseJSON5),
-	".toml": () => import("./_2.mjs").then((r) => r.parseTOML)
+	".yaml": () => import("./confbox.mjs").then((n) => n.a).then((r) => r.parseYAML),
+	".yml": () => import("./confbox.mjs").then((n) => n.a).then((r) => r.parseYAML),
+	".jsonc": () => import("./confbox.mjs").then((n) => n.t).then((r) => r.parseJSONC),
+	".json5": () => import("./confbox.mjs").then((n) => n.o).then((r) => r.parseJSON5),
+	".toml": () => import("./confbox.mjs").then((n) => n.r).then((r) => r.parseTOML)
 };
 const SUPPORTED_EXTENSIONS = Object.freeze([
 	".js",
@@ -750,7 +843,7 @@ async function resolveConfig(source, options, sourceOptions = {}) {
 	const customProviderKeys = Object.keys(sourceOptions.giget?.providers || {}).map((key) => `${key}:`);
 	const gigetPrefixes = customProviderKeys.length > 0 ? [...new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES;
 	if (options.giget !== false && gigetPrefixes.some((prefix) => source.startsWith(prefix))) {
-		const { downloadTemplate } = await import("./giget+node-fetch-native.mjs");
+		const { downloadTemplate } = await import("./nypm+giget+tinyexec.mjs").then((n) => n.t);
 		const { digest } = await import("ohash");
 		const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + digest(source).slice(0, 10).replace(/[-_]/g, "");
 		let cloneDir;
@@ -831,7 +924,7 @@ async function watchConfig(options) {
 		options.rcFile && resolve$1(l.cwd, typeof options.rcFile === "string" ? options.rcFile : `.${configName}rc`),
 		options.packageJson && resolve$1(l.cwd, "package.json")
 	]).filter(Boolean))];
-	const watch$1 = await import("./_6.mjs").then((r) => r.watch || r.default || r);
+	const watch$1 = await import("./readdirp+chokidar.mjs").then((n) => n.t).then((r) => r.watch || r.default || r);
 	const { diff } = await import("ohash/utils");
 	const _fswatcher = watch$1(watchingFiles, {
 		ignoreInitial: true,
@@ -876,4 +969,4 @@ async function watchConfig(options) {
 }
 
 //#endregion
-export { watchConfig as a, setupDotenv as i, loadConfig as n, loadDotenv as r, SUPPORTED_EXTENSIONS as t };
+export { debounce as i, loadConfig as n, watchConfig as r, dist_exports as t };

package/dist/_libs/{chokidar+readdirp.mjs → readdirp+chokidar.mjs}

@@ -1,3 +1,4 @@
+import { n as __exportAll } from "../_common.mjs";
 import { Stats, stat, unwatchFile, watch, watchFile } from "node:fs";
 import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
 import { type } from "node:os";
@@ -957,6 +958,12 @@ var NodeFsHandler = class {
 //#endregion
 //#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 /*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+var chokidar_exports = /* @__PURE__ */ __exportAll({
+	FSWatcher: () => FSWatcher,
+	WatchHelper: () => WatchHelper,
+	default: () => chokidar_default,
+	watch: () => watch$1
+});
 const SLASH = "/";
 const SLASH_SLASH = "//";
 const ONE_DOT = ".";
@@ -1601,4 +1608,4 @@ var chokidar_default = {
 };
 
 //#endregion
-export { watch$1 as i, WatchHelper as n, chokidar_default as r, FSWatcher as t };
+export { watch$1 as n, chokidar_exports 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 "./resolve-uri+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 };