nitro-nightly 3.0.1-20260106-122901-e9c3a660 → 3.0.1-20260106-182834-5019d347

package/dist/_libs/node-fetch-native.mjs

@@ -0,0 +1,7 @@
+//#region node_modules/.pnpm/node-fetch-native@1.6.7/node_modules/node-fetch-native/dist/native.mjs
+const e = globalThis.Blob, o = globalThis.File, a = globalThis.FormData, s = globalThis.Headers, t = globalThis.Request, h = globalThis.Response, i = globalThis.AbortController, l = globalThis.fetch || (() => {
+	throw new Error("[node-fetch-native] Failed to fetch: `globalThis.fetch` is not available!");
+});
+
+//#endregion
+export { l as t };

package/dist/_libs/nypm.mjs

@@ -0,0 +1,239 @@
+import { n as __exportAll } from "../_rolldown.mjs";
+import { o as join, s as normalize, u as resolve } from "./pathe.mjs";
+import { s as readPackageJSON } from "./pkg-types.mjs";
+import { t as K } from "./tinyexec.mjs";
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+
+//#region node_modules/.pnpm/nypm@0.6.2/node_modules/nypm/dist/shared/nypm.CLjaS_sz.mjs
+async function findup(cwd, match, options = {}) {
+	const segments = normalize(cwd).split("/");
+	while (segments.length > 0) {
+		const result = await match(segments.join("/") || "/");
+		if (result || !options.includeParentDirs) return result;
+		segments.pop();
+	}
+}
+function cached(fn) {
+	let v;
+	return () => {
+		if (v === void 0) v = fn().then((r) => {
+			v = r;
+			return v;
+		});
+		return v;
+	};
+}
+const hasCorepack = cached(async () => {
+	if (globalThis.process?.versions?.webcontainer) return false;
+	try {
+		const { exitCode } = await K("corepack", ["--version"]);
+		return exitCode === 0;
+	} catch {
+		return false;
+	}
+});
+async function executeCommand(command, args, options = {}) {
+	const xArgs = command === "npm" || command === "bun" || command === "deno" || !await hasCorepack() ? [command, args] : ["corepack", [command, ...args]];
+	const { exitCode, stdout, stderr } = await K(xArgs[0], xArgs[1], { nodeOptions: {
+		cwd: resolve(options.cwd || process.cwd()),
+		env: options.env,
+		stdio: options.silent ? "pipe" : "inherit"
+	} });
+	if (exitCode !== 0) throw new Error(`\`${xArgs.flat().join(" ")}\` failed.${options.silent ? [
+		"",
+		stdout,
+		stderr
+	].join("\n") : ""}`);
+}
+const NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG = "No package manager auto-detected.";
+async function resolveOperationOptions(options = {}) {
+	const cwd = options.cwd || process.cwd();
+	const env = {
+		...process.env,
+		...options.env
+	};
+	const packageManager = (typeof options.packageManager === "string" ? packageManagers.find((pm) => pm.name === options.packageManager) : options.packageManager) || await detectPackageManager(options.cwd || process.cwd());
+	if (!packageManager) throw new Error(NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG);
+	return {
+		cwd,
+		env,
+		silent: options.silent ?? false,
+		packageManager,
+		dev: options.dev ?? false,
+		workspace: options.workspace,
+		global: options.global ?? false,
+		dry: options.dry ?? false
+	};
+}
+function getWorkspaceArgs(options) {
+	if (!options.workspace) return [];
+	const workspacePkg = typeof options.workspace === "string" && options.workspace !== "" ? options.workspace : void 0;
+	if (options.packageManager.name === "pnpm") return workspacePkg ? ["--filter", workspacePkg] : ["--workspace-root"];
+	if (options.packageManager.name === "npm") return workspacePkg ? ["-w", workspacePkg] : ["--workspaces"];
+	if (options.packageManager.name === "yarn") if (!options.packageManager.majorVersion || options.packageManager.majorVersion === "1") return workspacePkg ? ["--cwd", workspacePkg] : ["-W"];
+	else return workspacePkg ? ["workspace", workspacePkg] : [];
+	return [];
+}
+function parsePackageManagerField(packageManager) {
+	const [name, _version] = (packageManager || "").split("@");
+	const [version, buildMeta] = _version?.split("+") || [];
+	if (name && name !== "-" && /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name)) return {
+		name,
+		version,
+		buildMeta
+	};
+	const sanitized = name.replace(/\W+/g, "");
+	return {
+		name: sanitized,
+		version,
+		buildMeta,
+		warnings: [`Abnormal characters found in \`packageManager\` field, sanitizing from \`${name}\` to \`${sanitized}\``]
+	};
+}
+const packageManagers = [
+	{
+		name: "npm",
+		command: "npm",
+		lockFile: "package-lock.json"
+	},
+	{
+		name: "pnpm",
+		command: "pnpm",
+		lockFile: "pnpm-lock.yaml",
+		files: ["pnpm-workspace.yaml"]
+	},
+	{
+		name: "bun",
+		command: "bun",
+		lockFile: ["bun.lockb", "bun.lock"]
+	},
+	{
+		name: "yarn",
+		command: "yarn",
+		lockFile: "yarn.lock",
+		files: [".yarnrc.yml"]
+	},
+	{
+		name: "deno",
+		command: "deno",
+		lockFile: "deno.lock",
+		files: ["deno.json"]
+	}
+];
+async function detectPackageManager(cwd, options = {}) {
+	const detected = await findup(resolve(cwd || "."), async (path) => {
+		if (!options.ignorePackageJSON) {
+			const packageJSONPath = join(path, "package.json");
+			if (existsSync(packageJSONPath)) {
+				const packageJSON = JSON.parse(await readFile(packageJSONPath, "utf8"));
+				if (packageJSON?.packageManager) {
+					const { name, version = "0.0.0", buildMeta, warnings } = parsePackageManagerField(packageJSON.packageManager);
+					if (name) {
+						const majorVersion = version.split(".")[0];
+						const packageManager = packageManagers.find((pm) => pm.name === name && pm.majorVersion === majorVersion) || packageManagers.find((pm) => pm.name === name);
+						return {
+							name,
+							command: name,
+							version,
+							majorVersion,
+							buildMeta,
+							warnings,
+							files: packageManager?.files,
+							lockFile: packageManager?.lockFile
+						};
+					}
+				}
+			}
+			if (existsSync(join(path, "deno.json"))) return packageManagers.find((pm) => pm.name === "deno");
+		}
+		if (!options.ignoreLockFile) {
+			for (const packageManager of packageManagers) if ([packageManager.lockFile, packageManager.files].flat().filter(Boolean).some((file) => existsSync(resolve(path, file)))) return { ...packageManager };
+		}
+	}, { includeParentDirs: options.includeParentDirs ?? true });
+	if (!detected && !options.ignoreArgv) {
+		const scriptArg = process.argv[1];
+		if (scriptArg) {
+			for (const packageManager of packageManagers) if ((/* @__PURE__ */ new RegExp(`[/\\\\]\\.?${packageManager.command}`)).test(scriptArg)) return packageManager;
+		}
+	}
+	return detected;
+}
+async function installDependencies(options = {}) {
+	const resolvedOptions = await resolveOperationOptions(options);
+	const commandArgs = options.frozenLockFile ? {
+		npm: ["ci"],
+		yarn: ["install", "--immutable"],
+		bun: ["install", "--frozen-lockfile"],
+		pnpm: ["install", "--frozen-lockfile"],
+		deno: ["install", "--frozen"]
+	}[resolvedOptions.packageManager.name] : ["install"];
+	if (!resolvedOptions.dry) await executeCommand(resolvedOptions.packageManager.command, commandArgs, {
+		cwd: resolvedOptions.cwd,
+		silent: resolvedOptions.silent
+	});
+	return { exec: {
+		command: resolvedOptions.packageManager.command,
+		args: commandArgs
+	} };
+}
+async function addDependency(name, options = {}) {
+	const resolvedOptions = await resolveOperationOptions(options);
+	const names = Array.isArray(name) ? name : [name];
+	if (resolvedOptions.packageManager.name === "deno") {
+		for (let i = 0; i < names.length; i++) if (!/^(npm|jsr|file):.+$/.test(names[i])) names[i] = `npm:${names[i]}`;
+	}
+	if (names.length === 0) return {};
+	const args = (resolvedOptions.packageManager.name === "yarn" ? [
+		...getWorkspaceArgs(resolvedOptions),
+		resolvedOptions.global && resolvedOptions.packageManager.majorVersion === "1" ? "global" : "",
+		"add",
+		resolvedOptions.dev ? "-D" : "",
+		...names
+	] : [
+		resolvedOptions.packageManager.name === "npm" ? "install" : "add",
+		...getWorkspaceArgs(resolvedOptions),
+		resolvedOptions.dev ? "-D" : "",
+		resolvedOptions.global ? "-g" : "",
+		...names
+	]).filter(Boolean);
+	if (!resolvedOptions.dry) await executeCommand(resolvedOptions.packageManager.command, args, {
+		cwd: resolvedOptions.cwd,
+		silent: resolvedOptions.silent
+	});
+	if (!resolvedOptions.dry && options.installPeerDependencies) {
+		const existingPkg = await readPackageJSON(resolvedOptions.cwd);
+		const peerDeps = [];
+		const peerDevDeps = [];
+		for (const _name of names) {
+			const pkgName = _name.match(/^(.[^@]+)/)?.[0];
+			const pkg = await readPackageJSON(pkgName, { url: resolvedOptions.cwd }).catch(() => ({}));
+			if (!pkg.peerDependencies || pkg.name !== pkgName) continue;
+			for (const [peerDependency, version] of Object.entries(pkg.peerDependencies)) {
+				if (pkg.peerDependenciesMeta?.[peerDependency]?.optional) continue;
+				if (existingPkg.dependencies?.[peerDependency] || existingPkg.devDependencies?.[peerDependency]) continue;
+				(pkg.peerDependenciesMeta?.[peerDependency]?.dev ? peerDevDeps : peerDeps).push(`${peerDependency}@${version}`);
+			}
+		}
+		if (peerDeps.length > 0) await addDependency(peerDeps, { ...resolvedOptions });
+		if (peerDevDeps.length > 0) await addDevDependency(peerDevDeps, { ...resolvedOptions });
+	}
+	return { exec: {
+		command: resolvedOptions.packageManager.command,
+		args
+	} };
+}
+async function addDevDependency(name, options = {}) {
+	return await addDependency(name, {
+		...options,
+		dev: true
+	});
+}
+
+//#endregion
+//#region node_modules/.pnpm/nypm@0.6.2/node_modules/nypm/dist/index.mjs
+var dist_exports = /* @__PURE__ */ __exportAll({ addDevDependency: () => addDevDependency });
+
+//#endregion
+export { installDependencies as a, detectPackageManager as i, addDependency as n, packageManagers as o, addDevDependency as r, dist_exports as t };

package/dist/_libs/path-parse.mjs

@@ -0,0 +1,47 @@
+import { t as __commonJSMin } from "../_rolldown.mjs";
+
+//#region node_modules/.pnpm/path-parse@1.0.7/node_modules/path-parse/index.js
+var require_path_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isWindows = process.platform === "win32";
+	var splitWindowsRe = /^(((?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?[\\\/]?)(?:[^\\\/]*[\\\/])*)((\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))[\\\/]*$/;
+	var win32 = {};
+	function win32SplitPath(filename) {
+		return splitWindowsRe.exec(filename).slice(1);
+	}
+	win32.parse = function(pathString) {
+		if (typeof pathString !== "string") throw new TypeError("Parameter 'pathString' must be a string, not " + typeof pathString);
+		var allParts = win32SplitPath(pathString);
+		if (!allParts || allParts.length !== 5) throw new TypeError("Invalid path '" + pathString + "'");
+		return {
+			root: allParts[1],
+			dir: allParts[0] === allParts[1] ? allParts[0] : allParts[0].slice(0, -1),
+			base: allParts[2],
+			ext: allParts[4],
+			name: allParts[3]
+		};
+	};
+	var splitPathRe = /^((\/?)(?:[^\/]*\/)*)((\.{1,2}|[^\/]+?|)(\.[^.\/]*|))[\/]*$/;
+	var posix = {};
+	function posixSplitPath(filename) {
+		return splitPathRe.exec(filename).slice(1);
+	}
+	posix.parse = function(pathString) {
+		if (typeof pathString !== "string") throw new TypeError("Parameter 'pathString' must be a string, not " + typeof pathString);
+		var allParts = posixSplitPath(pathString);
+		if (!allParts || allParts.length !== 5) throw new TypeError("Invalid path '" + pathString + "'");
+		return {
+			root: allParts[1],
+			dir: allParts[0].slice(0, -1),
+			base: allParts[2],
+			ext: allParts[4],
+			name: allParts[3]
+		};
+	};
+	if (isWindows) module.exports = win32.parse;
+	else module.exports = posix.parse;
+	module.exports.posix = posix.parse;
+	module.exports.win32 = win32.parse;
+}));
+
+//#endregion
+export { require_path_parse as t };

package/dist/_libs/pathe.mjs

@@ -1,5 +1,166 @@
-import { D as normalizeWindowsPath, T as join } from "./c12.mjs";
+//#region node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const relative = function(from, to) {
+	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const basename = function(p, extension) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
+		}
+	}
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+const parse = function(p) {
+	const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
+	const base = basename(p);
+	const extension = extname(base);
+	return {
+		root,
+		dir: dirname(p),
+		base,
+		ext: extension,
+		name: base.slice(0, base.length - extension.length)
+	};
+};
 
+//#endregion
 //#region node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/utils.mjs
 const pathSeparators = /* @__PURE__ */ new Set([
 	"/",
@@ -38,4 +199,4 @@ function hasTrailingSlash(path = "/") {
 }
 
 //#endregion
-export { resolveAlias as t };
+export { isAbsolute as a, parse as c, extname as i, relative as l, basename as n, join as o, dirname as r, normalize as s, resolveAlias as t, resolve as u };

package/dist/_libs/perfect-debounce.mjs

@@ -0,0 +1,89 @@
+//#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) => {
+			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(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	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
+export { debounce as t };