nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_chunks/_deps/knitwork.mjs

@@ -0,0 +1,172 @@
+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

@@ -0,0 +1,163 @@
+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 };