nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-122334-09c1a7a8

package/dist/_chunks/_deps/klona.mjs

@@ -1,137 +0,0 @@
-function set(obj, key, val) {
-	if (typeof val.value === 'object') val.value = klona$1(val.value);
-	if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === '__proto__') {
-		Object.defineProperty(obj, key, val);
-	} else obj[key] = val.value;
-}
-
-function klona$1(x) {
-	if (typeof x !== 'object') return x;
-
-	var i=0, k, list, tmp, str=Object.prototype.toString.call(x);
-
-	if (str === '[object Object]') {
-		tmp = Object.create(x.__proto__ || null);
-	} else if (str === '[object Array]') {
-		tmp = Array(x.length);
-	} else if (str === '[object Set]') {
-		tmp = new Set;
-		x.forEach(function (val) {
-			tmp.add(klona$1(val));
-		});
-	} else if (str === '[object Map]') {
-		tmp = new Map;
-		x.forEach(function (val, key) {
-			tmp.set(klona$1(key), klona$1(val));
-		});
-	} else if (str === '[object Date]') {
-		tmp = new Date(+x);
-	} else if (str === '[object RegExp]') {
-		tmp = new RegExp(x.source, x.flags);
-	} else if (str === '[object DataView]') {
-		tmp = new x.constructor( klona$1(x.buffer) );
-	} else if (str === '[object ArrayBuffer]') {
-		tmp = x.slice(0);
-	} else if (str.slice(-6) === 'Array]') {
-		// ArrayBuffer.isView(x)
-		// ~> `new` bcuz `Buffer.slice` => ref
-		tmp = new x.constructor(x);
-	}
-
-	if (tmp) {
-		for (list=Object.getOwnPropertySymbols(x); i < list.length; i++) {
-			set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
-		}
-
-		for (i=0, list=Object.getOwnPropertyNames(x); i < list.length; i++) {
-			if (Object.hasOwnProperty.call(tmp, k=list[i]) && tmp[k] === x[k]) continue;
-			set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
-		}
-	}
-
-	return tmp || x;
-}
-
-function klona(x) {
-	if (typeof x !== 'object') return x;
-
-	var k, tmp, str=Object.prototype.toString.call(x);
-
-	if (str === '[object Object]') {
-		if (x.constructor !== Object && typeof x.constructor === 'function') {
-			tmp = new x.constructor();
-			for (k in x) {
-				if (x.hasOwnProperty(k) && tmp[k] !== x[k]) {
-					tmp[k] = klona(x[k]);
-				}
-			}
-		} else {
-			tmp = {}; // null
-			for (k in x) {
-				if (k === '__proto__') {
-					Object.defineProperty(tmp, k, {
-						value: klona(x[k]),
-						configurable: true,
-						enumerable: true,
-						writable: true,
-					});
-				} else {
-					tmp[k] = klona(x[k]);
-				}
-			}
-		}
-		return tmp;
-	}
-
-	if (str === '[object Array]') {
-		k = x.length;
-		for (tmp=Array(k); k--;) {
-			tmp[k] = klona(x[k]);
-		}
-		return tmp;
-	}
-
-	if (str === '[object Set]') {
-		tmp = new Set;
-		x.forEach(function (val) {
-			tmp.add(klona(val));
-		});
-		return tmp;
-	}
-
-	if (str === '[object Map]') {
-		tmp = new Map;
-		x.forEach(function (val, key) {
-			tmp.set(klona(key), klona(val));
-		});
-		return tmp;
-	}
-
-	if (str === '[object Date]') {
-		return new Date(+x);
-	}
-
-	if (str === '[object RegExp]') {
-		tmp = new RegExp(x.source, x.flags);
-		tmp.lastIndex = x.lastIndex;
-		return tmp;
-	}
-
-	if (str === '[object DataView]') {
-		return new x.constructor( klona(x.buffer) );
-	}
-
-	if (str === '[object ArrayBuffer]') {
-		return x.slice(0);
-	}
-
-	// ArrayBuffer.isView(x)
-	// ~> `new` bcuz `Buffer.slice` => ref
-	if (str.slice(-6) === 'Array]') {
-		return new x.constructor(x);
-	}
-
-	return x;
-}
-
-export { klona as a, klona$1 as k };

package/dist/_chunks/_deps/knitwork.mjs

@@ -1,172 +0,0 @@
-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"
-]);
-
-function _genStatement(type, specifier, names, options = {}) {
-  const specifierString = genString(specifier, options);
-  if (!names) {
-    return `${type} ${specifierString};`;
-  }
-  const nameArray = Array.isArray(names);
-  const _names = (nameArray ? names : [names]).map((index) => {
-    if (typeof index === "string") {
-      return { name: index };
-    }
-    if (index.name === index.as) {
-      index = { name: index.name };
-    }
-    return index;
-  });
-  const namesString = _names.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 (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}`;
-}
-const VALID_IDENTIFIER_RE = /^[$_]?([A-Z_a-z]\w*|\d)$/;
-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();
-}
-
-export { genSafeVariableName as a, genImport as b, genString as c, genObjectFromRaw as d, genObjectKey as g };

package/dist/_chunks/_deps/local-pkg.mjs

@@ -1,163 +0,0 @@
-import fs from 'node:fs';
-import { createRequire } from 'node:module';
-import path, { win32, dirname, join } from 'node:path';
-import process$1 from 'node:process';
-import fsp from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import { r as resolvePathSync } from './mlly.mjs';
-import { q as quansync } from './quansync.mjs';
-
-const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-
-async function findUp$1(name, {
-	cwd = process$1.cwd(),
-	type = 'file',
-	stopAt,
-} = {}) {
-	let directory = path.resolve(toPath(cwd) ?? '');
-	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); // eslint-disable-line no-await-in-loop
-			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 = process$1.cwd(),
-	type = 'file',
-	stopAt,
-} = {}) {
-	let directory = path.resolve(toPath(cwd) ?? '');
-	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, 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, { paths });
-    } catch {
-    }
-  }
-  const modulePath = resolvePathSync(path, {
-    url: options.paths
-  });
-  if (options.platform === "win32")
-    return win32.normalize(modulePath);
-  return modulePath;
-}
-function resolveModule(name, options = {}) {
-  try {
-    return _resolve(name, options);
-  } catch {
-    return void 0;
-  }
-}
-function getPackageJsonPath(name, options = {}) {
-  const entry = resolvePackage(name, options);
-  if (!entry)
-    return;
-  return searchPackageJSON(entry);
-}
-const readFile = 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(packageJsonPath));
-  return {
-    name,
-    version: packageJson.version,
-    rootPath: dirname(packageJsonPath),
-    packageJsonPath,
-    packageJson
-  };
-});
-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 = process$1.cwd()) {
-  const path = yield findUp("package.json", { cwd });
-  if (!path || !fs.existsSync(path))
-    return null;
-  return JSON.parse(yield readFile(path));
-});
-loadPackageJSON.sync;
-const isPackageListed = quansync(function* (name, cwd) {
-  const pkg = (yield loadPackageJSON(cwd)) || {};
-  return name in (pkg.dependencies || {}) || name in (pkg.devDependencies || {});
-});
-isPackageListed.sync;
-
-export { resolveModule as r };