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

package/dist/_libs/knitwork.mjs

@@ -1,124 +0,0 @@
-//#region node_modules/.pnpm/knitwork@1.3.0/node_modules/knitwork/dist/index.mjs
-function genString(input, options = {}) {
-	const str = JSON.stringify(input);
-	if (!options.singleQuotes) return str;
-	return `'${escapeString(str).slice(1, -1)}'`;
-}
-const NEEDS_ESCAPE_RE = /[\n\r'\\\u2028\u2029]/;
-const QUOTE_NEWLINE_RE = /([\n\r'\u2028\u2029])/g;
-const BACKSLASH_RE = /\\/g;
-function escapeString(id) {
-	if (!NEEDS_ESCAPE_RE.test(id)) return id;
-	return id.replace(BACKSLASH_RE, "\\\\").replace(QUOTE_NEWLINE_RE, "\\$1");
-}
-function genSafeVariableName(name) {
-	if (reservedNames.has(name)) return `_${name}`;
-	return name.replace(/^\d/, (r) => `_${r}`).replace(/\W/g, (r) => "_" + r.charCodeAt(0));
-}
-const reservedNames = /* @__PURE__ */ new Set([
-	"Infinity",
-	"NaN",
-	"arguments",
-	"await",
-	"break",
-	"case",
-	"catch",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"finally",
-	"for",
-	"function",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"interface",
-	"let",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"static",
-	"super",
-	"switch",
-	"this",
-	"throw",
-	"true",
-	"try",
-	"typeof",
-	"undefined",
-	"var",
-	"void",
-	"while",
-	"with",
-	"yield"
-]);
-const VALID_IDENTIFIER_RE = /^[$_]?([A-Z_a-z]\w*|\d)$/;
-function _genStatement(type, specifier, names, options = {}) {
-	const specifierString = genString(specifier, options);
-	if (!names) return `${type} ${specifierString};`;
-	const nameArray = Array.isArray(names);
-	const namesString = (nameArray ? names : [names]).map((index) => {
-		if (typeof index === "string") return { name: index };
-		if (index.name === index.as) index = { name: index.name };
-		return index;
-	}).map((index) => index.as ? `${index.name} as ${index.as}` : index.name).join(", ");
-	if (nameArray) return `${type} { ${namesString} } from ${genString(specifier, options)}${_genImportAttributes(type, options)};`;
-	return `${type} ${namesString} from ${genString(specifier, options)}${_genImportAttributes(type, options)};`;
-}
-function _genImportAttributes(type, options) {
-	if (type === "import type" || type === "export type") return "";
-	if (typeof options.attributes?.type === "string") return ` with { type: ${genString(options.attributes.type)} }`;
-	if (typeof options.assert?.type === "string") return ` assert { type: ${genString(options.assert.type)} }`;
-	return "";
-}
-function genImport(specifier, imports, options = {}) {
-	return _genStatement("import", specifier, imports, options);
-}
-function wrapInDelimiters(lines, indent = "", delimiters = "{}", withComma = true) {
-	if (lines.length === 0) return delimiters;
-	const [start, end] = delimiters;
-	return `${start}
-` + lines.join(withComma ? ",\n" : "\n") + `
-${indent}${end}`;
-}
-function genObjectKey(key) {
-	return VALID_IDENTIFIER_RE.test(key) ? key : genString(key);
-}
-function genObjectFromRaw(object, indent = "", options = {}) {
-	return genObjectFromRawEntries(Object.entries(object), indent, options);
-}
-function genArrayFromRaw(array, indent = "", options = {}) {
-	const newIdent = indent + "  ";
-	return wrapInDelimiters(array.map((index) => `${newIdent}${genRawValue(index, newIdent, options)}`), indent, "[]");
-}
-function genObjectFromRawEntries(array, indent = "", options = {}) {
-	const newIdent = indent + "  ";
-	return wrapInDelimiters(array.map(([key, value]) => `${newIdent}${genObjectKey(key)}: ${genRawValue(value, newIdent, options)}`), indent, "{}");
-}
-function genRawValue(value, indent = "", options = {}) {
-	if (value === void 0) return "undefined";
-	if (value === null) return "null";
-	if (Array.isArray(value)) return genArrayFromRaw(value, indent, options);
-	if (value && typeof value === "object") return genObjectFromRaw(value, indent, options);
-	if (options.preserveTypes && typeof value !== "function") return JSON.stringify(value);
-	return value.toString();
-}
-
-//#endregion
-export { genString as a, genSafeVariableName as i, genObjectFromRaw as n, genObjectKey as r, genImport as t };

package/dist/_libs/local-pkg.mjs

@@ -1,125 +0,0 @@
-import { d as resolvePathSync } from "./mlly.mjs";
-import { t as quansync } from "./quansync.mjs";
-import { createRequire } from "node:module";
-import fs from "node:fs";
-import fsp from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import path, { dirname, join, win32 } from "node:path";
-import process$1 from "node:process";
-
-//#region node_modules/.pnpm/local-pkg@1.1.2/node_modules/local-pkg/dist/index.mjs
-const toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-async function findUp$1(name, { cwd: cwd$1 = process$1.cwd(), type = "file", stopAt } = {}) {
-	let directory = path.resolve(toPath(cwd$1) ?? "");
-	const { root } = path.parse(directory);
-	stopAt = path.resolve(directory, toPath(stopAt ?? root));
-	const isAbsoluteName = path.isAbsolute(name);
-	while (directory) {
-		const filePath = isAbsoluteName ? name : path.join(directory, name);
-		try {
-			const stats = await fsp.stat(filePath);
-			if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) return filePath;
-		} catch {}
-		if (directory === stopAt || directory === root) break;
-		directory = path.dirname(directory);
-	}
-}
-function findUpSync(name, { cwd: cwd$1 = process$1.cwd(), type = "file", stopAt } = {}) {
-	let directory = path.resolve(toPath(cwd$1) ?? "");
-	const { root } = path.parse(directory);
-	stopAt = path.resolve(directory, toPath(stopAt) ?? root);
-	const isAbsoluteName = path.isAbsolute(name);
-	while (directory) {
-		const filePath = isAbsoluteName ? name : path.join(directory, name);
-		try {
-			const stats = fs.statSync(filePath, { throwIfNoEntry: false });
-			if (type === "file" && stats?.isFile() || type === "directory" && stats?.isDirectory()) return filePath;
-		} catch {}
-		if (directory === stopAt || directory === root) break;
-		directory = path.dirname(directory);
-	}
-}
-function _resolve(path$1, options = {}) {
-	if (options.platform === "auto" || !options.platform) options.platform = process$1.platform === "win32" ? "win32" : "posix";
-	if (process$1.versions.pnp) {
-		const paths = options.paths || [];
-		if (paths.length === 0) paths.push(process$1.cwd());
-		const targetRequire = createRequire(import.meta.url);
-		try {
-			return targetRequire.resolve(path$1, { paths });
-		} catch {}
-	}
-	const modulePath = resolvePathSync(path$1, { url: options.paths });
-	if (options.platform === "win32") return win32.normalize(modulePath);
-	return modulePath;
-}
-function resolveModule(name, options = {}) {
-	try {
-		return _resolve(name, options);
-	} catch {
-		return;
-	}
-}
-function getPackageJsonPath(name, options = {}) {
-	const entry = resolvePackage(name, options);
-	if (!entry) return;
-	return searchPackageJSON(entry);
-}
-const readFile$1 = quansync({
-	async: (id) => fs.promises.readFile(id, "utf8"),
-	sync: (id) => fs.readFileSync(id, "utf8")
-});
-const getPackageInfo = quansync(function* (name, options = {}) {
-	const packageJsonPath = getPackageJsonPath(name, options);
-	if (!packageJsonPath) return;
-	const packageJson = JSON.parse(yield readFile$1(packageJsonPath));
-	return {
-		name,
-		version: packageJson.version,
-		rootPath: dirname(packageJsonPath),
-		packageJsonPath,
-		packageJson
-	};
-});
-const getPackageInfoSync = getPackageInfo.sync;
-function resolvePackage(name, options = {}) {
-	try {
-		return _resolve(`${name}/package.json`, options);
-	} catch {}
-	try {
-		return _resolve(name, options);
-	} catch (e) {
-		if (e.code !== "MODULE_NOT_FOUND" && e.code !== "ERR_MODULE_NOT_FOUND") console.error(e);
-		return false;
-	}
-}
-function searchPackageJSON(dir) {
-	let packageJsonPath;
-	while (true) {
-		if (!dir) return;
-		const newDir = dirname(dir);
-		if (newDir === dir) return;
-		dir = newDir;
-		packageJsonPath = join(dir, "package.json");
-		if (fs.existsSync(packageJsonPath)) break;
-	}
-	return packageJsonPath;
-}
-const findUp = quansync({
-	sync: findUpSync,
-	async: findUp$1
-});
-const loadPackageJSON = quansync(function* (cwd$1 = process$1.cwd()) {
-	const path$1 = yield findUp("package.json", { cwd: cwd$1 });
-	if (!path$1 || !fs.existsSync(path$1)) return null;
-	return JSON.parse(yield readFile$1(path$1));
-});
-const loadPackageJSONSync = loadPackageJSON.sync;
-const isPackageListed = quansync(function* (name, cwd$1) {
-	const pkg = (yield loadPackageJSON(cwd$1)) || {};
-	return name in (pkg.dependencies || {}) || name in (pkg.devDependencies || {});
-});
-const isPackageListedSync = isPackageListed.sync;
-
-//#endregion
-export { resolveModule as t };