pncat
Version:
A unified cli tool that enhances package managers catalogs feature.
1,767 lines (1,745 loc) • 178 kB
JavaScript
import { r as __require, t as __commonJSMin } from "./chunk-6qLfnLNH.mjs";
import { a as require_valid, i as require_clean, n as require_valid$1, r as require_satisfies, t as require_semver } from "./semver-Df1PSY8l.mjs";
import { i as require_lib$13, n as require_lib$12, r as require_commonjs$1, t as require_npa } from "./npa-fnjp9MqV.mjs";
import { a as require_lib$14, i as require_commonjs$3, n as require_commonjs$2, t as require_promise_retry } from "./promise-retry-BEdb5rpr.mjs";
//#region node_modules/.pnpm/walk-up-path@4.0.0/node_modules/walk-up-path/dist/commonjs/index.js
var require_commonjs = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.walkUp = void 0;
const path_1 = __require("path");
const walkUp$1 = function* (path$5) {
for (path$5 = (0, path_1.resolve)(path$5); path$5;) {
yield path$5;
const pp = (0, path_1.dirname)(path$5);
if (pp === path$5) break;
else path$5 = pp;
}
};
exports.walkUp = walkUp$1;
}));
//#endregion
//#region node_modules/.pnpm/ini@6.0.0/node_modules/ini/lib/ini.js
var require_ini$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const { hasOwnProperty: hasOwnProperty$2 } = Object.prototype;
const encode$1 = (obj, opt = {}) => {
if (typeof opt === "string") opt = { section: opt };
opt.align = opt.align === true;
opt.newline = opt.newline === true;
opt.sort = opt.sort === true;
opt.whitespace = opt.whitespace === true || opt.align === true;
/* istanbul ignore next */
opt.platform = opt.platform || typeof process !== "undefined" && process.platform;
opt.bracketedArray = opt.bracketedArray !== false;
/* istanbul ignore next */
const eol = opt.platform === "win32" ? "\r\n" : "\n";
const separator = opt.whitespace ? " = " : "=";
const children = [];
const keys = opt.sort ? Object.keys(obj).sort() : Object.keys(obj);
let padToChars = 0;
if (opt.align) padToChars = safe$1(keys.filter((k) => obj[k] === null || Array.isArray(obj[k]) || typeof obj[k] !== "object").map((k) => Array.isArray(obj[k]) ? `${k}[]` : k).concat([""]).reduce((a, b) => safe$1(a).length >= safe$1(b).length ? a : b)).length;
let out = "";
const arraySuffix = opt.bracketedArray ? "[]" : "";
for (const k of keys) {
const val = obj[k];
if (val && Array.isArray(val)) for (const item of val) out += safe$1(`${k}${arraySuffix}`).padEnd(padToChars, " ") + separator + safe$1(item) + eol;
else if (val && typeof val === "object") children.push(k);
else out += safe$1(k).padEnd(padToChars, " ") + separator + safe$1(val) + eol;
}
if (opt.section && out.length) out = "[" + safe$1(opt.section) + "]" + (opt.newline ? eol + eol : eol) + out;
for (const k of children) {
const nk = splitSections$1(k, ".").join("\\.");
const section = (opt.section ? opt.section + "." : "") + nk;
const child = encode$1(obj[k], {
...opt,
section
});
if (out.length && child.length) out += eol;
out += child;
}
return out;
};
function splitSections$1(str, separator) {
var lastMatchIndex = 0;
var lastSeparatorIndex = 0;
var nextIndex = 0;
var sections = [];
do {
nextIndex = str.indexOf(separator, lastMatchIndex);
if (nextIndex !== -1) {
lastMatchIndex = nextIndex + separator.length;
if (nextIndex > 0 && str[nextIndex - 1] === "\\") continue;
sections.push(str.slice(lastSeparatorIndex, nextIndex));
lastSeparatorIndex = nextIndex + separator.length;
}
} while (nextIndex !== -1);
sections.push(str.slice(lastSeparatorIndex));
return sections;
}
const decode$1 = (str, opt = {}) => {
opt.bracketedArray = opt.bracketedArray !== false;
const out = Object.create(null);
let p = out;
let section = null;
const re = /^\[([^\]]*)\]\s*$|^([^=]+)(=(.*))?$/i;
const lines = str.split(/[\r\n]+/g);
const duplicates = {};
for (const line of lines) {
if (!line || line.match(/^\s*[;#]/) || line.match(/^\s*$/)) continue;
const match = line.match(re);
if (!match) continue;
if (match[1] !== void 0) {
section = unsafe$1(match[1]);
if (section === "__proto__") {
p = Object.create(null);
continue;
}
p = out[section] = out[section] || Object.create(null);
continue;
}
const keyRaw = unsafe$1(match[2]);
let isArray;
if (opt.bracketedArray) isArray = keyRaw.length > 2 && keyRaw.slice(-2) === "[]";
else {
duplicates[keyRaw] = (duplicates?.[keyRaw] || 0) + 1;
isArray = duplicates[keyRaw] > 1;
}
const key = isArray && keyRaw.endsWith("[]") ? keyRaw.slice(0, -2) : keyRaw;
if (key === "__proto__") continue;
const valueRaw = match[3] ? unsafe$1(match[4]) : true;
const value = valueRaw === "true" || valueRaw === "false" || valueRaw === "null" ? JSON.parse(valueRaw) : valueRaw;
if (isArray) {
if (!hasOwnProperty$2.call(p, key)) p[key] = [];
else if (!Array.isArray(p[key])) p[key] = [p[key]];
}
if (Array.isArray(p[key])) p[key].push(value);
else p[key] = value;
}
const remove = [];
for (const k of Object.keys(out)) {
if (!hasOwnProperty$2.call(out, k) || typeof out[k] !== "object" || Array.isArray(out[k])) continue;
const parts = splitSections$1(k, ".");
p = out;
const l = parts.pop();
const nl = l.replace(/\\\./g, ".");
for (const part of parts) {
if (part === "__proto__") continue;
if (!hasOwnProperty$2.call(p, part) || typeof p[part] !== "object") p[part] = Object.create(null);
p = p[part];
}
if (p === out && nl === l) continue;
p[nl] = out[k];
remove.push(k);
}
for (const del of remove) delete out[del];
return out;
};
const isQuoted$1 = (val) => {
return val.startsWith("\"") && val.endsWith("\"") || val.startsWith("'") && val.endsWith("'");
};
const safe$1 = (val) => {
if (typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted$1(val) || val !== val.trim()) return JSON.stringify(val);
return val.split(";").join("\\;").split("#").join("\\#");
};
const unsafe$1 = (val) => {
val = (val || "").trim();
if (isQuoted$1(val)) {
if (val.charAt(0) === "'") val = val.slice(1, -1);
try {
val = JSON.parse(val);
} catch {}
} else {
let esc = false;
let unesc = "";
for (let i = 0, l = val.length; i < l; i++) {
const c = val.charAt(i);
if (esc) {
if ("\\;#".indexOf(c) !== -1) unesc += c;
else unesc += "\\" + c;
esc = false;
} else if (";#".indexOf(c) !== -1) break;
else if (c === "\\") esc = true;
else unesc += c;
}
if (esc) unesc += "\\";
return unesc.trim();
}
return val;
};
module.exports = {
parse: decode$1,
decode: decode$1,
stringify: encode$1,
encode: encode$1,
safe: safe$1,
unsafe: unsafe$1
};
}));
//#endregion
//#region node_modules/.pnpm/abbrev@4.0.0/node_modules/abbrev/lib/index.js
var require_lib$11 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = abbrev$1;
function abbrev$1(...args) {
let list = args;
if (args.length === 1 && (Array.isArray(args[0]) || typeof args[0] === "string")) list = [].concat(args[0]);
for (let i = 0, l = list.length; i < l; i++) list[i] = typeof list[i] === "string" ? list[i] : String(list[i]);
list = list.sort(lexSort);
const abbrevs = {};
let prev = "";
for (let ii = 0, ll = list.length; ii < ll; ii++) {
const current = list[ii];
const next = list[ii + 1] || "";
let nextMatches = true;
let prevMatches = true;
if (current === next) continue;
let j = 0;
const cl = current.length;
for (; j < cl; j++) {
const curChar = current.charAt(j);
nextMatches = nextMatches && curChar === next.charAt(j);
prevMatches = prevMatches && curChar === prev.charAt(j);
if (!nextMatches && !prevMatches) {
j++;
break;
}
}
prev = current;
if (j === cl) {
abbrevs[current] = current;
continue;
}
for (let a = current.slice(0, j); j <= cl; j++) {
abbrevs[a] = current;
a += current.charAt(j);
}
}
return abbrevs;
}
function lexSort(a, b) {
return a === b ? 0 : a > b ? 1 : -1;
}
}));
//#endregion
//#region node_modules/.pnpm/nopt@9.0.0/node_modules/nopt/lib/debug.js
var require_debug = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/* istanbul ignore next */
module.exports = process.env.DEBUG_NOPT || process.env.NOPT_DEBUG ? (...a) => console.error(...a) : () => {};
}));
//#endregion
//#region node_modules/.pnpm/nopt@9.0.0/node_modules/nopt/lib/type-defs.js
var require_type_defs$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const url = __require("url");
const path$4 = __require("path");
const Stream = __require("stream").Stream;
const os$3 = __require("os");
const debug$1 = require_debug();
function validateString(data, k, val) {
data[k] = String(val);
}
function validatePath$1(data, k, val) {
if (val === true) return false;
if (val === null) return true;
val = String(val);
const homePattern = process.platform === "win32" ? /^~(\/|\\)/ : /^~\//;
const home = os$3.homedir();
if (home && val.match(homePattern)) data[k] = path$4.resolve(home, val.slice(2));
else data[k] = path$4.resolve(val);
return true;
}
function validateNumber(data, k, val) {
debug$1("validate Number %j %j %j", k, val, isNaN(val));
if (isNaN(val)) return false;
data[k] = +val;
}
function validateDate(data, k, val) {
const s = Date.parse(val);
debug$1("validate Date %j %j %j", k, val, s);
if (isNaN(s)) return false;
data[k] = new Date(val);
}
function validateBoolean(data, k, val) {
if (typeof val === "string") if (!isNaN(val)) val = !!+val;
else if (val === "null" || val === "false") val = false;
else val = true;
else val = !!val;
data[k] = val;
}
function validateUrl(data, k, val) {
val = url.parse(String(val));
if (!val.host) return false;
data[k] = val.href;
}
function validateStream(data, k, val) {
if (!(val instanceof Stream)) return false;
data[k] = val;
}
module.exports = {
String: {
type: String,
validate: validateString
},
Boolean: {
type: Boolean,
validate: validateBoolean
},
url: {
type: url,
validate: validateUrl
},
Number: {
type: Number,
validate: validateNumber
},
path: {
type: path$4,
validate: validatePath$1
},
Stream: {
type: Stream,
validate: validateStream
},
Date: {
type: Date,
validate: validateDate
},
Array: { type: Array }
};
}));
//#endregion
//#region node_modules/.pnpm/nopt@9.0.0/node_modules/nopt/lib/nopt-lib.js
var require_nopt_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const abbrev = require_lib$11();
const debug = require_debug();
const defaultTypeDefs$1 = require_type_defs$1();
const hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
const getType = (k, { types, dynamicTypes }) => {
let hasType = hasOwn(types, k);
let type = types[k];
if (!hasType && typeof dynamicTypes === "function") {
const matchedType = dynamicTypes(k);
if (matchedType !== void 0) {
type = matchedType;
hasType = true;
}
}
return [hasType, type];
};
const isTypeDef = (type, def) => def && type === def;
const hasTypeDef = (type, def) => def && type.indexOf(def) !== -1;
const doesNotHaveTypeDef = (type, def) => def && !hasTypeDef(type, def);
function nopt$3(args, { types, shorthands, typeDefs: typeDefs$3, invalidHandler, unknownHandler, abbrevHandler, typeDefault, dynamicTypes } = {}) {
debug(types, shorthands, args, typeDefs$3);
const data = {};
const argv = {
remain: [],
cooked: args,
original: args.slice(0)
};
parse$7(args, data, argv.remain, {
typeDefs: typeDefs$3,
types,
dynamicTypes,
shorthands,
unknownHandler,
abbrevHandler
});
clean$2(data, {
types,
dynamicTypes,
typeDefs: typeDefs$3,
invalidHandler,
typeDefault
});
data.argv = argv;
Object.defineProperty(data.argv, "toString", {
value: function() {
return this.original.map(JSON.stringify).join(" ");
},
enumerable: false
});
return data;
}
function clean$2(data, { types = {}, typeDefs: typeDefs$3 = {}, dynamicTypes, invalidHandler, typeDefault } = {}) {
const StringType = typeDefs$3.String?.type;
const NumberType = typeDefs$3.Number?.type;
const ArrayType = typeDefs$3.Array?.type;
const BooleanType = typeDefs$3.Boolean?.type;
const DateType = typeDefs$3.Date?.type;
const hasTypeDefault = typeof typeDefault !== "undefined";
if (!hasTypeDefault) {
typeDefault = [
false,
true,
null
];
if (StringType) typeDefault.push(StringType);
if (ArrayType) typeDefault.push(ArrayType);
}
const remove = {};
Object.keys(data).forEach((k) => {
if (k === "argv") return;
let val = data[k];
debug("val=%j", val);
const isArray = Array.isArray(val);
let [hasType, rawType] = getType(k, {
types,
dynamicTypes
});
let type = rawType;
if (!isArray) val = [val];
if (!type) type = typeDefault;
if (isTypeDef(type, ArrayType)) type = typeDefault.concat(ArrayType);
if (!Array.isArray(type)) type = [type];
debug("val=%j", val);
debug("types=", type);
val = val.map((v) => {
if (typeof v === "string") {
debug("string %j", v);
v = v.trim();
if (v === "null" && ~type.indexOf(null) || v === "true" && (~type.indexOf(true) || hasTypeDef(type, BooleanType)) || v === "false" && (~type.indexOf(false) || hasTypeDef(type, BooleanType))) {
v = JSON.parse(v);
debug("jsonable %j", v);
} else if (hasTypeDef(type, NumberType) && !isNaN(v)) {
debug("convert to number", v);
v = +v;
} else if (hasTypeDef(type, DateType) && !isNaN(Date.parse(v))) {
debug("convert to date", v);
v = new Date(v);
}
}
if (!hasType) {
if (!hasTypeDefault) return v;
rawType = typeDefault;
}
if (v === false && ~type.indexOf(null) && !(~type.indexOf(false) || hasTypeDef(type, BooleanType))) v = null;
const d = {};
d[k] = v;
debug("prevalidated val", d, v, rawType);
if (!validate$1(d, k, v, rawType, { typeDefs: typeDefs$3 })) {
if (invalidHandler) invalidHandler(k, v, rawType, data);
else if (invalidHandler !== false) debug("invalid: " + k + "=" + v, rawType);
return remove;
}
debug("validated v", d, v, rawType);
return d[k];
}).filter((v) => v !== remove);
if (!val.length && doesNotHaveTypeDef(type, ArrayType)) {
debug("VAL HAS NO LENGTH, DELETE IT", val, k, type.indexOf(ArrayType));
delete data[k];
} else if (isArray) {
debug(isArray, data[k], val);
data[k] = val;
} else data[k] = val[0];
debug("k=%s val=%j", k, val, data[k]);
});
}
function validate$1(data, k, val, type, { typeDefs: typeDefs$3 } = {}) {
const ArrayType = typeDefs$3?.Array?.type;
if (Array.isArray(type)) {
for (let i = 0, l = type.length; i < l; i++) {
if (isTypeDef(type[i], ArrayType)) continue;
if (validate$1(data, k, val, type[i], { typeDefs: typeDefs$3 })) return true;
}
delete data[k];
return false;
}
if (isTypeDef(type, ArrayType)) return true;
if (type !== type) {
debug("Poison NaN", k, val, type);
delete data[k];
return false;
}
if (val === type) {
debug("Explicitly allowed %j", val);
data[k] = val;
return true;
}
let ok = false;
const types = Object.keys(typeDefs$3);
for (let i = 0, l = types.length; i < l; i++) {
debug("test type %j %j %j", k, val, types[i]);
const t = typeDefs$3[types[i]];
if (t && (type && type.name && t.type && t.type.name ? type.name === t.type.name : type === t.type)) {
const d = {};
ok = t.validate(d, k, val) !== false;
val = d[k];
if (ok) {
data[k] = val;
break;
}
}
}
debug("OK? %j (%j %j %j)", ok, k, val, types[types.length - 1]);
if (!ok) delete data[k];
return ok;
}
function parse$7(args, data, remain, { types = {}, typeDefs: typeDefs$3 = {}, shorthands = {}, dynamicTypes, unknownHandler, abbrevHandler } = {}) {
const StringType = typeDefs$3.String?.type;
const NumberType = typeDefs$3.Number?.type;
const ArrayType = typeDefs$3.Array?.type;
const BooleanType = typeDefs$3.Boolean?.type;
debug("parse", args, data, remain);
const abbrevs = abbrev(Object.keys(types));
debug("abbrevs=%j", abbrevs);
const shortAbbr = abbrev(Object.keys(shorthands));
for (let i = 0; i < args.length; i++) {
let arg = args[i];
debug("arg", arg);
if (arg.match(/^-{2,}$/)) {
remain.push.apply(remain, args.slice(i + 1));
args[i] = "--";
break;
}
let hadEq = false;
if (arg.charAt(0) === "-" && arg.length > 1) {
const at = arg.indexOf("=");
if (at > -1) {
hadEq = true;
const v = arg.slice(at + 1);
arg = arg.slice(0, at);
args.splice(i, 1, arg, v);
}
const shRes = resolveShort(arg, shortAbbr, abbrevs, {
shorthands,
abbrevHandler
});
debug("arg=%j shRes=%j", arg, shRes);
if (shRes) {
args.splice.apply(args, [i, 1].concat(shRes));
if (arg !== shRes[0]) {
i--;
continue;
}
}
arg = arg.replace(/^-+/, "");
let no = null;
while (arg.toLowerCase().indexOf("no-") === 0) {
no = !no;
arg = arg.slice(3);
}
if (abbrevs[arg] && abbrevs[arg] !== arg) {
if (abbrevHandler) abbrevHandler(arg, abbrevs[arg]);
else if (abbrevHandler !== false) debug(`abbrev: ${arg} -> ${abbrevs[arg]}`);
arg = abbrevs[arg];
}
let [hasType, argType] = getType(arg, {
types,
dynamicTypes
});
let isTypeArray = Array.isArray(argType);
if (isTypeArray && argType.length === 1) {
isTypeArray = false;
argType = argType[0];
}
let isArray = isTypeDef(argType, ArrayType) || isTypeArray && hasTypeDef(argType, ArrayType);
if (!hasType && hasOwn(data, arg)) {
if (!Array.isArray(data[arg])) data[arg] = [data[arg]];
isArray = true;
}
let val;
let la = args[i + 1];
const isBool = typeof no === "boolean" || isTypeDef(argType, BooleanType) || isTypeArray && hasTypeDef(argType, BooleanType) || typeof argType === "undefined" && !hadEq || la === "false" && (argType === null || isTypeArray && ~argType.indexOf(null));
if (typeof argType === "undefined") {
const hangingLa = !hadEq && la && !la?.startsWith("-") && !["true", "false"].includes(la);
if (unknownHandler) if (hangingLa) unknownHandler(arg, la);
else unknownHandler(arg);
else if (unknownHandler !== false) {
debug(`unknown: ${arg}`);
if (hangingLa) debug(`unknown: ${la} parsed as normal opt`);
}
}
if (isBool) {
val = !no;
if (la === "true" || la === "false") {
val = JSON.parse(la);
la = null;
if (no) val = !val;
i++;
}
if (isTypeArray && la) {
if (~argType.indexOf(la)) {
val = la;
i++;
} else if (la === "null" && ~argType.indexOf(null)) {
val = null;
i++;
} else if (!la.match(/^-{2,}[^-]/) && !isNaN(la) && hasTypeDef(argType, NumberType)) {
val = +la;
i++;
} else if (!la.match(/^-[^-]/) && hasTypeDef(argType, StringType)) {
val = la;
i++;
}
}
if (isArray) (data[arg] = data[arg] || []).push(val);
else data[arg] = val;
continue;
}
if (isTypeDef(argType, StringType)) {
if (la === void 0) la = "";
else if (la.match(/^-{1,2}[^-]+/)) {
la = "";
i--;
}
}
if (la && la.match(/^-{2,}$/)) {
la = void 0;
i--;
}
val = la === void 0 ? true : la;
if (isArray) (data[arg] = data[arg] || []).push(val);
else data[arg] = val;
i++;
continue;
}
remain.push(arg);
}
}
const SINGLES = Symbol("singles");
const singleCharacters = (arg, shorthands) => {
let singles = shorthands[SINGLES];
if (!singles) {
singles = Object.keys(shorthands).filter((s) => s.length === 1).reduce((l, r) => {
l[r] = true;
return l;
}, {});
shorthands[SINGLES] = singles;
debug("shorthand singles", singles);
}
const chrs = arg.split("").filter((c) => singles[c]);
return chrs.join("") === arg ? chrs : null;
};
function resolveShort(arg, ...rest) {
const { abbrevHandler, types = {}, shorthands = {} } = rest.length ? rest.pop() : {};
const shortAbbr = rest[0] ?? abbrev(Object.keys(shorthands));
const abbrevs = rest[1] ?? abbrev(Object.keys(types));
arg = arg.replace(/^-+/, "");
if (abbrevs[arg] === arg) return null;
if (shorthands[arg]) {
if (shorthands[arg] && !Array.isArray(shorthands[arg])) shorthands[arg] = shorthands[arg].split(/\s+/);
return shorthands[arg];
}
const chrs = singleCharacters(arg, shorthands);
if (chrs) return chrs.map((c) => shorthands[c]).reduce((l, r) => l.concat(r), []);
if (abbrevs[arg] && !shorthands[arg]) return null;
if (shortAbbr[arg]) {
if (abbrevHandler) abbrevHandler(arg, shortAbbr[arg]);
else if (abbrevHandler !== false) debug(`abbrev: ${arg} -> ${shortAbbr[arg]}`);
arg = shortAbbr[arg];
}
if (shorthands[arg] && !Array.isArray(shorthands[arg])) shorthands[arg] = shorthands[arg].split(/\s+/);
return shorthands[arg];
}
module.exports = {
nopt: nopt$3,
clean: clean$2,
parse: parse$7,
validate: validate$1,
resolveShort,
typeDefs: defaultTypeDefs$1
};
}));
//#endregion
//#region node_modules/.pnpm/nopt@9.0.0/node_modules/nopt/lib/nopt.js
var require_nopt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const lib = require_nopt_lib();
const defaultTypeDefs = require_type_defs$1();
module.exports = exports = nopt$2;
exports.clean = clean$1;
exports.typeDefs = defaultTypeDefs;
exports.lib = lib;
function nopt$2(types, shorthands, args = process.argv, slice = 2) {
return lib.nopt(args.slice(slice), {
types: types || {},
shorthands: shorthands || {},
typeDefs: exports.typeDefs,
invalidHandler: exports.invalidHandler,
unknownHandler: exports.unknownHandler,
abbrevHandler: exports.abbrevHandler
});
}
function clean$1(data, types, typeDefs$3 = exports.typeDefs) {
return lib.clean(data, {
types: types || {},
typeDefs: typeDefs$3,
invalidHandler: exports.invalidHandler,
unknownHandler: exports.unknownHandler,
abbrevHandler: exports.abbrevHandler
});
}
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+config@10.4.4/node_modules/@npmcli/config/lib/umask.js
var require_umask = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const parse$6 = (val) => {
// istanbul ignore else
if (typeof val === "string") if (/^0o?[0-7]+$/.test(val)) return parseInt(val.replace(/^0o?/, ""), 8);
else if (/^[1-9][0-9]*$/.test(val)) return parseInt(val, 10);
else throw new Error(`invalid umask value: ${val}`);
else {
if (typeof val !== "number") throw new Error(`invalid umask value: ${val}`);
val = Math.floor(val);
if (val < 0 || val > 511) throw new Error(`invalid umask value: ${val}`);
return val;
}
};
const validate = (data, k, val) => {
try {
data[k] = parse$6(val);
return true;
} catch (er) {
return false;
}
};
module.exports = {
parse: parse$6,
validate
};
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+config@10.4.4/node_modules/@npmcli/config/lib/type-defs.js
var require_type_defs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const nopt$1 = require_nopt();
const { validate: validateUmask } = require_umask();
var Umask = class {};
var Semver = class {};
const semverValid = require_valid();
const validateSemver = (data, k, val) => {
const valid$2 = semverValid(val);
if (!valid$2) return false;
data[k] = valid$2;
};
const noptValidatePath = nopt$1.typeDefs.path.validate;
const validatePath = (data, k, val) => {
if (typeof val !== "string") return false;
return noptValidatePath(data, k, val);
};
module.exports = {
...nopt$1.typeDefs,
semver: {
type: Semver,
validate: validateSemver,
description: "full valid SemVer string"
},
Umask: {
type: Umask,
validate: validateUmask,
description: "octal number in range 0o000..0o777 (0..511)"
},
url: {
...nopt$1.typeDefs.url,
description: "full url with \"http://\""
},
path: {
...nopt$1.typeDefs.path,
validate: validatePath,
description: "valid filesystem path"
},
Number: {
...nopt$1.typeDefs.Number,
description: "numeric value"
},
Boolean: {
...nopt$1.typeDefs.Boolean,
description: "boolean value (true or false)"
},
Date: {
...nopt$1.typeDefs.Date,
description: "valid Date string"
}
};
nopt$1.typeDefs = module.exports;
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+config@10.4.4/node_modules/@npmcli/config/lib/nerf-dart.js
var require_nerf_dart = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const { URL: URL$1 } = __require("node:url");
/**
* Maps a URL to an identifier.
*
* Name courtesy schiffertronix media LLC, a New Jersey corporation
*
* @param {String} uri The URL to be nerfed.
*
* @returns {String} A nerfed URL.
*/
module.exports = (url$1) => {
const parsed = new URL$1(url$1);
const rel = new URL$1(".", `${parsed.protocol}//${parsed.host}${parsed.pathname}`);
return `//${rel.host}${rel.pathname}`;
};
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+config@10.4.4/node_modules/@npmcli/config/lib/env-replace.js
var require_env_replace = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const envExpr = /(?<!\\)(\\*)\$\{([^${}?]+)(\?)?\}/g;
module.exports = (f, env) => f.replace(envExpr, (orig, esc, name, modifier) => {
const fallback = modifier === "?" ? "" : `$\{${name}}`;
const val = env[name] !== void 0 ? env[name] : fallback;
if (esc.length % 2) return orig.slice((esc.length + 1) / 2);
return esc.slice(esc.length / 2) + val;
});
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+config@10.4.4/node_modules/@npmcli/config/lib/parse-field.js
var require_parse_field = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const typeDefs$2 = require_type_defs();
const envReplace$1 = require_env_replace();
const { resolve: resolve$2 } = __require("node:path");
const { parse: umaskParse } = require_umask();
const parseField$1 = (f, key, opts, listElement = false) => {
if (typeof f !== "string" && !Array.isArray(f)) return f;
const { platform, types, home, env } = opts;
const typeList = new Set([].concat(types[key]));
const isPath = typeList.has(typeDefs$2.path.type);
const isBool = typeList.has(typeDefs$2.Boolean.type);
const isString = isPath || typeList.has(typeDefs$2.String.type);
const isUmask = typeList.has(typeDefs$2.Umask.type);
const isNumber = typeList.has(typeDefs$2.Number.type);
const isList = !listElement && typeList.has(Array);
const isDate = typeList.has(typeDefs$2.Date.type);
if (Array.isArray(f)) return !isList ? f : f.map((field) => parseField$1(field, key, opts, true));
f = f.trim();
if (isList) return parseField$1(f.split("\n\n"), key, opts);
if (isBool && !isString && f === "") return true;
if (!isString && !isPath && !isNumber) switch (f) {
case "true": return true;
case "false": return false;
case "null": return null;
case "undefined": return;
}
f = envReplace$1(f, env);
if (isDate) return new Date(f);
if (isPath) if ((platform === "win32" ? /^~(\/|\\)/ : /^~\//).test(f) && home) f = resolve$2(home, f.slice(2));
else f = resolve$2(f);
if (isUmask) try {
return umaskParse(f);
} catch (er) {
return f;
}
if (isNumber && !isNaN(f)) f = +f;
return f;
};
module.exports = parseField$1;
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+config@10.4.4/node_modules/@npmcli/config/lib/set-envs.js
var require_set_envs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const envKey = (key, val) => {
return !/^[/@_]/.test(key) && typeof envVal(val) === "string" && `npm_config_${key.replace(/-/g, "_").toLowerCase()}`;
};
const envVal = (val) => Array.isArray(val) ? val.map((v) => envVal(v)).join("\n\n") : val === null || val === void 0 || val === false ? "" : typeof val === "object" ? null : String(val);
const sameConfigValue = (def, val) => !Array.isArray(val) || !Array.isArray(def) ? def === val : sameArrayValue(def, val);
const sameArrayValue = (def, val) => {
if (def.length !== val.length) return false;
for (let i = 0; i < def.length; i++)
/* istanbul ignore next - there are no array configs where the default
* is not an empty array, so this loop is a no-op, but it's the correct
* thing to do if we ever DO add a config like that. */
if (def[i] !== val[i]) return false;
return true;
};
const setEnv = (env, rawKey, rawVal) => {
const val = envVal(rawVal);
const key = envKey(rawKey, val);
if (key && val !== null) env[key] = val;
};
const setEnvs$1 = (config) => {
const { env, defaults, definitions, list: [cliConf, envConf] } = config;
env.INIT_CWD = process.cwd();
const cliSet = new Set(Object.keys(cliConf));
const envSet = new Set(Object.keys(envConf));
for (const key in cliConf) {
const { deprecated, envExport = true } = definitions[key] || {};
if (deprecated || envExport === false) continue;
if (sameConfigValue(defaults[key], cliConf[key])) {
if (!sameConfigValue(envConf[key], cliConf[key])) setEnv(env, key, cliConf[key]);
} else if (!(envSet.has(key) && !cliSet.has(key))) setEnv(env, key, cliConf[key]);
}
env.HOME = config.home;
env.npm_config_global_prefix = config.globalPrefix;
env.npm_config_local_prefix = config.localPrefix;
if (cliConf.editor) env.EDITOR = cliConf.editor;
if (cliConf["node-options"]) env.NODE_OPTIONS = cliConf["node-options"];
env.npm_config_node_gyp = cliConf["node-gyp"];
env.npm_config_npm_version = cliConf["npm-version"] || "unknown";
env.npm_execpath = config.npmBin;
env.NODE = env.npm_node_execpath = config.execPath;
};
module.exports = setEnvs$1;
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+config@10.4.4/node_modules/@npmcli/config/lib/errors.js
var require_errors$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var ErrInvalidAuth = class extends Error {
constructor(problems) {
let message = "Invalid auth configuration found: ";
message += problems.map((problem) => {
// istanbul ignore else
if (problem.action === "delete") return `\`${problem.key}\` is not allowed in ${problem.where} config`;
else if (problem.action === "rename") return `\`${problem.from}\` must be renamed to \`${problem.to}\` in ${problem.where} config`;
}).join(", ");
message += "\nPlease run `npm config fix` to repair your configuration.`";
super(message);
this.code = "ERR_INVALID_AUTH";
this.problems = problems;
}
};
module.exports = { ErrInvalidAuth };
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+config@10.4.4/node_modules/@npmcli/config/lib/type-description.js
var require_type_description = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const typeDefs$1 = require_type_defs();
const typeDescription = (t) => {
if (!t || typeof t !== "function" && typeof t !== "object") return t;
if (Array.isArray(t)) return t.map((t$1) => typeDescription(t$1));
for (const { type, description } of Object.values(typeDefs$1)) if (type === t) return description || type;
return t;
};
module.exports = (t) => [].concat(typeDescription(t)).filter((t$1) => t$1 !== void 0);
}));
//#endregion
//#region node_modules/.pnpm/json-parse-even-better-errors@4.0.0/node_modules/json-parse-even-better-errors/lib/index.js
var require_lib$10 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const INDENT = Symbol.for("indent");
const NEWLINE = Symbol.for("newline");
const DEFAULT_NEWLINE = "\n";
const DEFAULT_INDENT = " ";
const BOM = /^\uFEFF/;
const FORMAT = /^\s*[{[]((?:\r?\n)+)([\s\t]*)/;
const EMPTY = /^(?:\{\}|\[\])((?:\r?\n)+)?$/;
const UNEXPECTED_TOKEN = /^Unexpected token '?(.)'?(,)? /i;
const hexify = (char) => {
const h = char.charCodeAt(0).toString(16).toUpperCase();
return `0x${h.length % 2 ? "0" : ""}${h}`;
};
const stripBOM = (txt) => String(txt).replace(BOM, "");
const makeParsedError = (msg, parsing, position = 0) => ({
message: `${msg} while parsing ${parsing}`,
position
});
const parseError = (e, txt, context = 20) => {
let msg = e.message;
if (!txt) return makeParsedError(msg, "empty string");
const badTokenMatch = msg.match(UNEXPECTED_TOKEN);
const badIndexMatch = msg.match(/ position\s+(\d+)/i);
if (badTokenMatch) msg = msg.replace(UNEXPECTED_TOKEN, `Unexpected token ${JSON.stringify(badTokenMatch[1])} (${hexify(badTokenMatch[1])})$2 `);
let errIdx;
if (badIndexMatch) errIdx = +badIndexMatch[1];
else if (msg.match(/^Unexpected end of JSON.*/i)) errIdx = txt.length - 1;
if (errIdx == null) return makeParsedError(msg, `'${txt.slice(0, context * 2)}'`);
const start = errIdx <= context ? 0 : errIdx - context;
const end = errIdx + context >= txt.length ? txt.length : errIdx + context;
const slice = `${start ? "..." : ""}${txt.slice(start, end)}${end === txt.length ? "" : "..."}`;
return makeParsedError(msg, `${txt === slice ? "" : "near "}${JSON.stringify(slice)}`, errIdx);
};
var JSONParseError = class extends SyntaxError {
constructor(er, txt, context, caller) {
const metadata = parseError(er, txt, context);
super(metadata.message);
Object.assign(this, metadata);
this.code = "EJSONPARSE";
this.systemError = er;
Error.captureStackTrace(this, caller || this.constructor);
}
get name() {
return this.constructor.name;
}
set name(n) {}
get [Symbol.toStringTag]() {
return this.constructor.name;
}
};
const parseJson = (txt, reviver) => {
const result = JSON.parse(txt, reviver);
if (result && typeof result === "object") {
const match = txt.match(EMPTY) || txt.match(FORMAT) || [
null,
"",
""
];
result[NEWLINE] = match[1] ?? DEFAULT_NEWLINE;
result[INDENT] = match[2] ?? DEFAULT_INDENT;
}
return result;
};
const parseJsonError = (raw, reviver, context) => {
const txt = stripBOM(raw);
try {
return parseJson(txt, reviver);
} catch (e) {
if (typeof raw !== "string" && !Buffer.isBuffer(raw)) {
const msg = Array.isArray(raw) && raw.length === 0 ? "an empty array" : String(raw);
throw Object.assign(/* @__PURE__ */ new TypeError(`Cannot parse ${msg}`), {
code: "EJSONPARSE",
systemError: e
});
}
throw new JSONParseError(e, txt, context, parseJsonError);
}
};
module.exports = parseJsonError;
parseJsonError.JSONParseError = JSONParseError;
parseJsonError.noExceptions = (raw, reviver) => {
try {
return parseJson(stripBOM(raw), reviver);
} catch {}
};
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+package-json@7.0.1/node_modules/@npmcli/package-json/lib/update-dependencies.js
var require_update_dependencies = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const depTypes = new Set([
"dependencies",
"optionalDependencies",
"devDependencies",
"peerDependencies"
]);
const orderDeps = (content) => {
for (const type of depTypes) if (content && content[type]) content[type] = Object.keys(content[type]).sort((a, b) => a.localeCompare(b, "en")).reduce((res, key) => {
res[key] = content[type][key];
return res;
}, {});
return content;
};
const updateDependencies = ({ content, originalContent }) => {
const pkg = orderDeps({ ...content });
if (pkg.dependencies) {
if (pkg.optionalDependencies) for (const name of Object.keys(pkg.optionalDependencies)) delete pkg.dependencies[name];
}
const result = { ...originalContent };
for (const type of depTypes) {
if (pkg[type]) result[type] = pkg[type];
if (pkg[type] && typeof pkg === "object" && Object.keys(pkg[type]).length === 0) delete result[type];
}
const { dependencies: origProd, peerDependencies: origPeer } = originalContent || {};
const { peerDependencies: newPeer } = result;
if (origProd && origPeer && newPeer) {
for (const name of Object.keys(origPeer)) if (origProd[name] !== void 0 && newPeer[name] !== void 0) {
result.dependencies = result.dependencies || {};
result.dependencies[name] = newPeer[name];
}
}
return result;
};
updateDependencies.knownKeys = depTypes;
module.exports = updateDependencies;
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+package-json@7.0.1/node_modules/@npmcli/package-json/lib/update-scripts.js
var require_update_scripts = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const updateScripts$1 = ({ content, originalContent = {} }) => {
const newScripts = content.scripts;
if (!newScripts) return originalContent;
const hasInvalidScripts = () => Object.entries(newScripts).some(([key, value]) => typeof key !== "string" || typeof value !== "string");
if (hasInvalidScripts()) throw Object.assign(/* @__PURE__ */ new TypeError("package.json scripts should be a key-value pair of strings."), { code: "ESCRIPTSINVALID" });
return {
...originalContent,
scripts: { ...newScripts }
};
};
module.exports = updateScripts$1;
}));
//#endregion
//#region node_modules/.pnpm/@npmcli+package-json@7.0.1/node_modules/@npmcli/package-json/lib/update-workspaces.js
var require_update_workspaces = /* @__PURE__ */ __commonJSMin(((exports, module) => {
const updateWorkspaces$1 = ({ content, originalContent = {} }) => {
const newWorkspaces = content.workspaces;
if (!newWorkspaces) return originalContent;
const hasInvalidWorkspaces = () => newWorkspaces.some((w) => !(typeof w === "string"));
if (!newWorkspaces.length || hasInvalidWorkspaces()) throw Object.assign(/* @__PURE__ */ new TypeError("workspaces should be an array of strings."), { code: "EWORKSPACESINVALID" });
return {
...originalContent,
workspaces: [...newWorkspaces]
};
};
module.exports = updateWorkspaces$1;
}));
//#endregion
//#region node_modules/.pnpm/spdx-license-ids@3.0.21/node_modules/spdx-license-ids/index.json
var require_spdx_license_ids = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = [
"0BSD",
"3D-Slicer-1.0",
"AAL",
"ADSL",
"AFL-1.1",
"AFL-1.2",
"AFL-2.0",
"AFL-2.1",
"AFL-3.0",
"AGPL-1.0-only",
"AGPL-1.0-or-later",
"AGPL-3.0-only",
"AGPL-3.0-or-later",
"AMD-newlib",
"AMDPLPA",
"AML",
"AML-glslang",
"AMPAS",
"ANTLR-PD",
"ANTLR-PD-fallback",
"APAFML",
"APL-1.0",
"APSL-1.0",
"APSL-1.1",
"APSL-1.2",
"APSL-2.0",
"ASWF-Digital-Assets-1.0",
"ASWF-Digital-Assets-1.1",
"Abstyles",
"AdaCore-doc",
"Adobe-2006",
"Adobe-Display-PostScript",
"Adobe-Glyph",
"Adobe-Utopia",
"Afmparse",
"Aladdin",
"Apache-1.0",
"Apache-1.1",
"Apache-2.0",
"App-s2p",
"Arphic-1999",
"Artistic-1.0",
"Artistic-1.0-Perl",
"Artistic-1.0-cl8",
"Artistic-2.0",
"BSD-1-Clause",
"BSD-2-Clause",
"BSD-2-Clause-Darwin",
"BSD-2-Clause-Patent",
"BSD-2-Clause-Views",
"BSD-2-Clause-first-lines",
"BSD-3-Clause",
"BSD-3-Clause-Attribution",
"BSD-3-Clause-Clear",
"BSD-3-Clause-HP",
"BSD-3-Clause-LBNL",
"BSD-3-Clause-Modification",
"BSD-3-Clause-No-Military-License",
"BSD-3-Clause-No-Nuclear-License",
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause-No-Nuclear-Warranty",
"BSD-3-Clause-Open-MPI",
"BSD-3-Clause-Sun",
"BSD-3-Clause-acpica",
"BSD-3-Clause-flex",
"BSD-4-Clause",
"BSD-4-Clause-Shortened",
"BSD-4-Clause-UC",
"BSD-4.3RENO",
"BSD-4.3TAHOE",
"BSD-Advertising-Acknowledgement",
"BSD-Attribution-HPND-disclaimer",
"BSD-Inferno-Nettverk",
"BSD-Protection",
"BSD-Source-Code",
"BSD-Source-beginning-file",
"BSD-Systemics",
"BSD-Systemics-W3Works",
"BSL-1.0",
"BUSL-1.1",
"Baekmuk",
"Bahyph",
"Barr",
"Beerware",
"BitTorrent-1.0",
"BitTorrent-1.1",
"Bitstream-Charter",
"Bitstream-Vera",
"BlueOak-1.0.0",
"Boehm-GC",
"Boehm-GC-without-fee",
"Borceux",
"Brian-Gladman-2-Clause",
"Brian-Gladman-3-Clause",
"C-UDA-1.0",
"CAL-1.0",
"CAL-1.0-Combined-Work-Exception",
"CATOSL-1.1",
"CC-BY-1.0",
"CC-BY-2.0",
"CC-BY-2.5",
"CC-BY-2.5-AU",
"CC-BY-3.0",
"CC-BY-3.0-AT",
"CC-BY-3.0-AU",
"CC-BY-3.0-DE",
"CC-BY-3.0-IGO",
"CC-BY-3.0-NL",
"CC-BY-3.0-US",
"CC-BY-4.0",
"CC-BY-NC-1.0",
"CC-BY-NC-2.0",
"CC-BY-NC-2.5",
"CC-BY-NC-3.0",
"CC-BY-NC-3.0-DE",
"CC-BY-NC-4.0",
"CC-BY-NC-ND-1.0",
"CC-BY-NC-ND-2.0",
"CC-BY-NC-ND-2.5",
"CC-BY-NC-ND-3.0",
"CC-BY-NC-ND-3.0-DE",
"CC-BY-NC-ND-3.0-IGO",
"CC-BY-NC-ND-4.0",
"CC-BY-NC-SA-1.0",
"CC-BY-NC-SA-2.0",
"CC-BY-NC-SA-2.0-DE",
"CC-BY-NC-SA-2.0-FR",
"CC-BY-NC-SA-2.0-UK",
"CC-BY-NC-SA-2.5",
"CC-BY-NC-SA-3.0",
"CC-BY-NC-SA-3.0-DE",
"CC-BY-NC-SA-3.0-IGO",
"CC-BY-NC-SA-4.0",
"CC-BY-ND-1.0",
"CC-BY-ND-2.0",
"CC-BY-ND-2.5",
"CC-BY-ND-3.0",
"CC-BY-ND-3.0-DE",
"CC-BY-ND-4.0",
"CC-BY-SA-1.0",
"CC-BY-SA-2.0",
"CC-BY-SA-2.0-UK",
"CC-BY-SA-2.1-JP",
"CC-BY-SA-2.5",
"CC-BY-SA-3.0",
"CC-BY-SA-3.0-AT",
"CC-BY-SA-3.0-DE",
"CC-BY-SA-3.0-IGO",
"CC-BY-SA-4.0",
"CC-PDDC",
"CC-PDM-1.0",
"CC-SA-1.0",
"CC0-1.0",
"CDDL-1.0",
"CDDL-1.1",
"CDL-1.0",
"CDLA-Permissive-1.0",
"CDLA-Permissive-2.0",
"CDLA-Sharing-1.0",
"CECILL-1.0",
"CECILL-1.1",
"CECILL-2.0",
"CECILL-2.1",
"CECILL-B",
"CECILL-C",
"CERN-OHL-1.1",
"CERN-OHL-1.2",
"CERN-OHL-P-2.0",
"CERN-OHL-S-2.0",
"CERN-OHL-W-2.0",
"CFITSIO",
"CMU-Mach",
"CMU-Mach-nodoc",
"CNRI-Jython",
"CNRI-Python",
"CNRI-Python-GPL-Compatible",
"COIL-1.0",
"CPAL-1.0",
"CPL-1.0",
"CPOL-1.02",
"CUA-OPL-1.0",
"Caldera",
"Caldera-no-preamble",
"Catharon",
"ClArtistic",
"Clips",
"Community-Spec-1.0",
"Condor-1.1",
"Cornell-Lossless-JPEG",
"Cronyx",
"Crossword",
"CrystalStacker",
"Cube",
"D-FSL-1.0",
"DEC-3-Clause",
"DL-DE-BY-2.0",
"DL-DE-ZERO-2.0",
"DOC",
"DRL-1.0",
"DRL-1.1",
"DSDP",
"DocBook-Schema",
"DocBook-Stylesheet",
"DocBook-XML",
"Dotseqn",
"ECL-1.0",
"ECL-2.0",
"EFL-1.0",
"EFL-2.0",
"EPICS",
"EPL-1.0",
"EPL-2.0",
"EUDatagrid",
"EUPL-1.0",
"EUPL-1.1",
"EUPL-1.2",
"Elastic-2.0",
"Entessa",
"ErlPL-1.1",
"Eurosym",
"FBM",
"FDK-AAC",
"FSFAP",
"FSFAP-no-warranty-disclaimer",
"FSFUL",
"FSFULLR",
"FSFULLRWD",
"FTL",
"Fair",
"Ferguson-Twofish",
"Frameworx-1.0",
"FreeBSD-DOC",
"FreeImage",
"Furuseth",
"GCR-docs",
"GD",
"GFDL-1.1-invariants-only",
"GFDL-1.1-invariants-or-later",
"GFDL-1.1-no-invariants-only",
"GFDL-1.1-no-invariants-or-later",
"GFDL-1.1-only",
"GFDL-1.1-or-later",
"GFDL-1.2-invariants-only",
"GFDL-1.2-invariants-or-later",
"GFDL-1.2-no-invariants-only",
"GFDL-1.2-no-invariants-or-later",
"GFDL-1.2-only",
"GFDL-1.2-or-later",
"GFDL-1.3-invariants-only",
"GFDL-1.3-invariants-or-later",
"GFDL-1.3-no-invariants-only",
"GFDL-1.3-no-invariants-or-later",
"GFDL-1.3-only",
"GFDL-1.3-or-later",
"GL2PS",
"GLWTPL",
"GPL-1.0-only",
"GPL-1.0-or-later",
"GPL-2.0-only",
"GPL-2.0-or-later",
"GPL-3.0-only",
"GPL-3.0-or-later",
"Giftware",
"Glide",
"Glulxe",
"Graphics-Gems",
"Gutmann",
"HIDAPI",
"HP-1986",
"HP-1989",
"HPND",
"HPND-DEC",
"HPND-Fenneberg-Livingston",
"HPND-INRIA-IMAG",
"HPND-Intel",
"HPND-Kevlin-Henney",
"HPND-MIT-disclaimer",
"HPND-Markus-Kuhn",
"HPND-Netrek",
"HPND-Pbmplus",
"HPND-UC",
"HPND-UC-export-US",
"HPND-doc",
"HPND-doc-sell",
"HPND-export-US",
"HPND-export-US-acknowledgement",
"HPND-export-US-modify",
"HPND-export2-US",
"HPND-merchantability-variant",
"HPND-sell-MIT-disclaimer-xserver",
"HPND-sell-regexpr",
"HPND-sell-variant",
"HPND-sell-variant-MIT-disclaimer",
"HPND-sell-variant-MIT-disclaimer-rev",
"HTMLTIDY",
"HaskellReport",
"Hippocratic-2.1",
"IBM-pibs",
"ICU",
"IEC-Code-Components-EULA",
"IJG",
"IJG-short",
"IPA",
"IPL-1.0",
"ISC",
"ISC-Veillard",
"ImageMagick",
"Imlib2",
"Info-ZIP",
"Inner-Net-2.0",
"InnoSetup",
"Intel",
"Intel-ACPI",
"Interbase-1.0",
"JPL-image",
"JPNIC",
"JSON",
"Jam",
"JasPer-2.0",
"Kastrup",
"Kazlib",
"Knuth-CTAN",
"LAL-1.2",
"LAL-1.3",
"LGPL-2.0-only",
"LGPL-2.0-or-later",
"LGPL-2.1-only",
"LGPL-2.1-or-later",
"LGPL-3.0-only",
"LGPL-3.0-or-later",
"LGPLLR",
"LOOP",
"LPD-document",
"LPL-1.0",
"LPL-1.02",
"LPPL-1.0",
"LPPL-1.1",
"LPPL-1.2",
"LPPL-1.3a",
"LPPL-1.3c",
"LZMA-SDK-9.11-to-9.20",
"LZMA-SDK-9.22",
"Latex2e",
"Latex2e-translated-notice",
"Leptonica",
"LiLiQ-P-1.1",
"LiLiQ-R-1.1",
"LiLiQ-Rplus-1.1",
"Libpng",
"Linux-OpenIB",
"Linux-man-pages-1-para",
"Linux-man-pages-copyleft",
"Linux-man-pages-copyleft-2-para",
"Linux-man-pages-copyleft-var",
"Lucida-Bitmap-Fonts",
"MIPS",
"MIT",
"MIT-0",
"MIT-CMU",
"MIT-Click",
"MIT-Festival",
"MIT-Khronos-old",
"MIT-Modern-Variant",
"MIT-Wu",
"MIT-advertising",
"MIT-enna",
"MIT-feh",
"MIT-open-group",
"MIT-testregex",
"MITNFA",
"MMIXware",
"MPEG-SSG",
"MPL-1.0",
"MPL-1.1",
"MPL-2.0",
"MPL-2.0-no-copyleft-exception",
"MS-LPL",
"MS-PL",
"MS-RL",
"MTLL",
"Mackerras-3-Clause",
"Mackerras-3-Clause-acknowledgment",
"MakeIndex",
"Martin-Birgmeier",
"McPhee-slideshow",
"Minpack",
"MirOS",
"Motosoto",
"MulanPSL-1.0",
"MulanPSL-2.0",
"Multics",
"Mup",
"NAIST-2003",
"NASA-1.3",
"NBPL-1.0",
"NCBI-PD",
"NCGL-UK-2.0",
"NCL",
"NCSA",
"NGPL",
"NICTA-1.0",
"NIST-PD",
"NIST-PD-fallback",
"NIST-Software",
"NLOD-1.0",
"NLOD-2.0",
"NLPL",
"NOSL",
"NPL-1.0",
"NPL-1.1",
"NPOSL-3.0",
"NRL",
"NTP",
"NTP-0",
"Naumen",
"NetCDF",
"Newsletr",
"Nokia",
"Noweb",
"O-UDA-1.0",
"OAR",
"OCCT-PL",
"OCLC-2.0",
"ODC-By-1.0",
"ODbL-1.0",
"OFFIS",
"OFL-1.0",
"OFL-1.0-RFN",
"OFL-1.0-no-RFN",
"OFL-1.1",
"OFL-1.1-RFN",
"OFL-1.1-no-RFN",
"OGC-1.0",
"OGDL-Taiwan-1.0",
"OGL-Canada-2.0",
"OGL-UK-1.0",
"OGL-UK-2.0",
"OGL-UK-3.0",
"OGTSL",
"OLDAP-1.1",
"OLDAP-1.2",
"OLDAP-1.3",
"OLDAP-1.4",
"OLDAP-2.0",
"OLDAP-2.0.1",
"OLDAP-2.1",
"OLDAP-2.2",
"OLDAP-2.2.1",
"OLDAP-2.2.2",
"OLDAP-2.3",
"OLDAP-2.4",
"OLDAP-2.5",
"OLDAP-2.6",
"OLDAP-2.7",
"OLDAP-2.8",
"OLFL-1.3",
"OML",
"OPL-1.0",
"OPL-UK-3.0",
"OPUBL-1.0",
"OSET-PL-2.1",
"OSL-1.0",
"OSL-1.1",
"OSL-2.0",
"OSL-2.1",
"OSL-3.0",
"OpenPBS-2.3",
"OpenSSL",
"OpenSSL-standalone",
"OpenVision",
"PADL",
"PDDL-1.0",
"PHP-3.0",
"PHP-3.01",
"PPL",
"PSF-2.0",
"Parity-6.0.0",
"Parity-7.0.0",
"Pixar",
"Plexus",
"PolyForm-Noncommercial-1.0.0",
"PolyForm-Small-Business-1.0.0",
"PostgreSQL",
"Python-2.0",
"Python-2.0.1",
"QPL-1.0",
"QPL-1.0-INRIA-2004",
"Qhull",
"RHeCos-1.1",
"RPL-1.1",
"RPL-1.5",
"RPSL-1.0",
"RSA-MD",
"RSCPL",
"Rdisc",
"Ruby",
"Ruby-pty",
"SAX-PD",
"SAX-PD-2.0",
"SCEA",
"SGI-B-1.0",
"SGI-B-1.1",
"SGI-B-2.0",
"SGI-OpenGL",
"SGP4",
"SHL-0.5",
"SHL-0.51",
"SISSL",
"SISSL-1.2",
"SL",
"SMAIL-GPL",
"SMLNJ",
"SMPPL",
"SNIA",
"SPL-1.0",
"SSH-OpenSSH",
"SSH-short",
"SSLeay-standalone",
"SSPL-1.0",
"SWL",
"Saxpath",
"SchemeReport",
"Sendmail",
"Sendmail-8.23",
"Sendmail-Open-Source-1.1",
"SimPL-2.0",
"Sleepycat",
"Soundex",
"Spencer-86",
"Spencer-94",
"Spencer-99",
"SugarCRM-1.1.3",
"Sun-PPP",
"Sun-PPP-2000",
"SunPro",
"Symlinks",
"TAPR-OHL-1.0",
"TCL",
"TCP-wrappers",
"TGPPL-1.0",
"TMate",
"TORQUE-1.1",
"TOSL",
"TPDL",
"TPL-1.0",
"TTWL",
"TTYP0",
"TU-Berlin-1.0",
"TU-Berlin-2.0",
"TermReadKey",
"ThirdEye",
"TrustedQSL",
"UCAR",
"UCL-1.0",
"UMich-Merit",
"UPL-1.0",
"URT-RLE",
"Ubuntu-font-1.0",
"Unicode-3.0",
"Unicode-DFS-2015",
"Unicode-DFS-2016",
"Unicode-TOU",
"UnixCrypt",
"Unlicense",
"VOSTROM",
"VSL-1.0",
"Vim",
"W3C",
"W3C-19980720",
"W3C-20150513",
"WTFPL",
"Watcom-1.0",
"Widget-Workshop",
"Wsuipa",
"X11",
"X11-distribute-modifications-variant",
"X11-swapped",
"XFree86-1.1",
"XSkat",
"Xdebug-1.03",
"Xerox",
"Xfig",
"Xnet",
"YPL-1.0",
"YPL-1.1",
"ZPL-1.1",
"ZPL-2.0",
"ZPL-2.1",
"Zed",
"Zeeff",
"Zend-2.0",
"Zimbra-1.3",
"Zimbra-1.4",
"Zlib",
"any-OSI",
"any-OSI-perl-modules",
"bcrypt-Solar-Designer",
"blessing",
"bzip2-1.0.6",
"check-cvs",
"checkmk",
"copyleft-next-0.3.0",
"copyleft-next-0.3.1",
"curl",
"cve-tou",
"diffmark",
"dtoa",
"dvipdfm",
"eGenix",
"etalab-2.0",
"fwlw",
"gSOAP-1.3b",
"generic-xts",
"gnuplot",
"gtkbook",
"hdparm",
"iMatix",
"libpng-2.0",
"libselinux-1.0",
"libtiff",
"libutil-David-Nugent",
"lsof",
"magaz",
"mailprio",
"metamail",
"mpi-permissive",
"mpich2",
"mplus",
"pkgconf",
"pnmstitch",
"psfrag",
"psutils",
"python-ldap",
"radvd",
"snprintf",
"softSurfer",
"ssh-keyscan",
"swrule",
"threeparttable",
"ulem",
"w3m",
"wwl",
"xinetd",
"xkeyboard-config-Zinoviev",
"xlock",
"xpp",
"xzoom",
"zlib-acknowledgement"
];
}));
//#endregion
//#region node_modules/.pnpm/spdx-license-ids@3.0.21/node_modules/spdx-license-ids/deprecated.json
var require_deprecated = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = [
"AGPL-1.0",
"AGPL-3.0",
"BSD-2-Clause-FreeBSD",
"BSD-2-Clause-NetBSD",
"GFDL-1.1",
"GFDL-1.2",
"GFDL-1.3",
"GPL-1.0",
"GPL-2.0",
"GPL-2.0-with-GCC-exception",
"GPL-2.0-with-autoconf-exception",
"GPL-2.0-with-bison-exception",
"GPL-2.0-with-classpath-exception",
"GPL-2.0-with-font-exception",
"GPL-3.0",
"GPL-3.0-with-GCC-exception",
"GPL-3.0-with-autoconf-exception",
"LGPL-2.0",
"LGPL-2.1",
"LGPL-3.0",
"Net-SNMP",
"Nunit",
"StandardML-NJ",
"bzip2-1.0.5",
"eCos-2.0",
"wxWindows"
];
}));
//#endregion
//#region node_modules/.pnpm/spdx-exceptions@2.5.0/node_modules/spdx-exceptions/in