nitro-nightly 3.0.1-20260120-020848-6786d069 → 3.0.1-20260120-133205-cbfce96c

package/dist/_chunks/nitro2.mjs

@@ -1,258 +1,101 @@
-import { n as __require, r as __toESM, t as __commonJSMin } from "./nitro.mjs";
-import { l as relative, n as dirname, u as resolve } from "../_libs/pathe.mjs";
-import { a as readGitConfig, c as resolvePackageJSON, i as parseGitConfig, n as findNearestFile, o as readPackageJSON, r as findWorkspaceDir, s as resolveGitConfig, t as findFile } from "../_libs/confbox+exsolve+pkg-types.mjs";
-import { i as a } from "../_libs/std-env.mjs";
-import { t as glob } from "../_libs/fdir+picomatch+tinyglobby.mjs";
-import { t as runParallel } from "./nitro5.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";
+import { N as glob, at as join, st as relative } from "../_build/common.mjs";
+import { withBase, withLeadingSlash, withoutTrailingSlash } from "ufo";
 
-//#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);
+//#region src/scan.ts
+const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+const suffixRegex = /(\.(?<method>connect|delete|get|head|options|patch|post|put|trace))?(\.(?<env>dev|prod|prerender))?$/;
+async function scanAndSyncOptions(nitro) {
+	const scannedPlugins = await scanPlugins(nitro);
+	for (const plugin of scannedPlugins) if (!nitro.options.plugins.includes(plugin)) nitro.options.plugins.push(plugin);
+	if (nitro.options.experimental.tasks) {
+		const scannedTasks = await scanTasks(nitro);
+		for (const scannedTask of scannedTasks) if (scannedTask.name in nitro.options.tasks) {
+			if (!nitro.options.tasks[scannedTask.name].handler) nitro.options.tasks[scannedTask.name].handler = scannedTask.handler;
+		} else nitro.options.tasks[scannedTask.name] = {
+			handler: scannedTask.handler,
+			description: ""
+		};
 	}
-	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;
+	const scannedModules = await scanModules(nitro);
+	nitro.options.modules = nitro.options.modules || [];
+	for (const modPath of scannedModules) if (!nitro.options.modules.includes(modPath)) nitro.options.modules.push(modPath);
 }
-
-//#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);
+async function scanHandlers(nitro) {
+	const middleware = await scanMiddleware(nitro);
+	const handlers = await Promise.all([scanServerRoutes(nitro, nitro.options.apiDir || "api", nitro.options.apiBaseURL || "/api"), scanServerRoutes(nitro, nitro.options.routesDir || "routes")]).then((r) => r.flat());
+	nitro.scannedHandlers = [...middleware, ...handlers.filter((h, index, array) => {
+		return array.findIndex((h2) => h.route === h2.route && h.method === h2.method && h.env === h2.env) === index;
+	})];
+	return handlers;
+}
+async function scanMiddleware(nitro) {
+	return (await scanFiles(nitro, "middleware")).map((file) => {
+		return {
+			route: "/**",
+			middleware: true,
+			handler: file.fullPath
+		};
+	});
+}
+async function scanServerRoutes(nitro, dir, prefix = "/") {
+	return (await scanFiles(nitro, dir)).map((file) => {
+		let route = file.path.replace(/\.[A-Za-z]+$/, "").replace(/\(([^(/\\]+)\)[/\\]/g, "").replace(/\[\.{3}]/g, "**").replace(/\[\.{3}(\w+)]/g, "**:$1").replace(/\[([^/\]]+)]/g, ":$1");
+		route = withLeadingSlash(withoutTrailingSlash(withBase(route, prefix)));
+		const suffixMatch = route.match(suffixRegex);
+		let method;
+		let env;
+		if (suffixMatch?.index && suffixMatch?.index >= 0) {
+			route = route.slice(0, suffixMatch.index);
+			method = suffixMatch.groups?.method;
+			env = suffixMatch.groups?.env;
 		}
-		const numberString = toLocaleString(Number(number), options.locale, localeOptions);
-		const unit = UNITS[exponent];
-		result = prefix + numberString + separator + unit;
-	}
-	return applyFixedWidth(result, options.fixedWidth);
+		route = route.replace(/\/index$/, "") || "/";
+		return {
+			handler: file.fullPath,
+			lazy: true,
+			middleware: false,
+			route,
+			method,
+			env
+		};
+	});
 }
-
-//#endregion
-//#region src/utils/fs-tree.ts
-async function generateFSTree(dir, options = {}) {
-	if (a) return;
-	const files = await glob("**/*.*", {
-		cwd: dir,
-		ignore: ["*.map"]
+async function scanPlugins(nitro) {
+	return (await scanFiles(nitro, "plugins")).map((f) => f.fullPath);
+}
+async function scanTasks(nitro) {
+	return (await scanFiles(nitro, "tasks")).map((f) => {
+		return {
+			name: f.path.replace(/\/index$/, "").replace(/\.[A-Za-z]+$/, "").replace(/\//g, ":"),
+			handler: f.fullPath
+		};
 	});
-	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;
+}
+async function scanModules(nitro) {
+	return (await scanFiles(nitro, "modules")).map((f) => f.fullPath);
+}
+async function scanFiles(nitro, name) {
+	return await Promise.all(nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name))).then((r) => r.flat());
+}
+async function scanDir(nitro, dir, name) {
+	return (await glob(join(name, GLOB_SCAN_PATTERN), {
+		cwd: dir,
+		dot: true,
+		ignore: nitro.options.ignore,
+		absolute: true
+	}).catch((error) => {
+		if (error?.code === "ENOTDIR") {
+			nitro.logger.warn(`Ignoring \`${join(dir, name)}\`. It must be a directory.`);
+			return [];
 		}
-		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;
+		throw error;
+	})).map((fullPath) => {
+		return {
+			fullPath,
+			path: relative(join(dir, name), fullPath)
+		};
+	}).sort((a, b) => a.path.localeCompare(b.path));
 }
 
 //#endregion
-export { readPackageJSON, generateFSTree as t };
+export { scanHandlers as n, scanAndSyncOptions as t };

package/dist/_chunks/utils.mjs

@@ -0,0 +1,254 @@
+import { i as __toESM, r as __require, t as __commonJSMin } from "../_common.mjs";
+import { N as glob, V as a, ct as resolve, nt as dirname, p as runParallel, st as relative } 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 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 { generateFSTree as t };

package/dist/_common.mjs

@@ -0,0 +1,45 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };