@codeworksh/cli 0.0.1-dev.20260918042316 → 0.0.1-dev.20260922135856

package/lib-HXZBVLKt.mjs

@@ -0,0 +1,846 @@
+import { St as __require, yt as __commonJSMin } from "./error-DTXBm1nO.mjs";
+import { n as require_lib$1, t as require_commonjs } from "./commonjs-CiyyOsS6.mjs";
+import { p as require_lib$2, s as require_ini, t as require_lib$3 } from "./lib-vrwKjvzk.mjs";
+import { n as require_umask, r as require_nopt, t as require_type_defs } from "./type-defs-xvRvQI4T.mjs";
+//#region ../../node_modules/.pnpm/@npmcli+config@11.0.1/node_modules/@npmcli/config/lib/nerf-dart.js
+var require_nerf_dart = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { URL } = __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) => {
+		const parsed = new URL(url);
+		const from = `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
+		const rel = new URL(".", from);
+		return `//${rel.host}${rel.pathname}`;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@npmcli+config@11.0.1/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@11.0.1/node_modules/@npmcli/config/lib/parse-field.js
+var require_parse_field = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const typeDefs = require_type_defs();
+	const envReplace = require_env_replace();
+	const { resolve: resolve$1 } = __require("node:path");
+	const { parse: umaskParse } = require_umask();
+	const parseField = (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.path.type);
+		const isBool = typeList.has(typeDefs.Boolean.type);
+		const isString = isPath || typeList.has(typeDefs.String.type);
+		const isUmask = typeList.has(typeDefs.Umask.type);
+		const isNumber = typeList.has(typeDefs.Number.type);
+		const isList = !listElement && typeList.has(Array);
+		const isDate = typeList.has(typeDefs.Date.type);
+		if (Array.isArray(f)) return !isList ? f : f.map((field) => parseField(field, key, opts, true));
+		f = f.trim();
+		if (isList) return parseField(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(f, env);
+		if (isDate) return new Date(f);
+		if (isPath) {
+			if ((platform === "win32" ? /^~(\/|\\)/ : /^~\//).test(f) && home) f = resolve$1(home, f.slice(2));
+			else f = resolve$1(f);
+		}
+		if (isUmask) try {
+			return umaskParse(f);
+		} catch (er) {
+			return f;
+		}
+		if (isNumber && !isNaN(f)) f = +f;
+		return f;
+	};
+	module.exports = parseField;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@npmcli+config@11.0.1/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 = (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;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@npmcli+config@11.0.1/node_modules/@npmcli/config/lib/errors.js
+var require_errors = /* @__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@11.0.1/node_modules/@npmcli/config/lib/type-description.js
+var require_type_description = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const typeDefs = require_type_defs();
+	const typeDescription = (t) => {
+		if (!t || typeof t !== "function" && typeof t !== "object") return t;
+		if (Array.isArray(t)) return t.map((t) => typeDescription(t));
+		for (const { type, description } of Object.values(typeDefs)) if (type === t) return description || type;
+		return t;
+	};
+	module.exports = (t) => [].concat(typeDescription(t)).filter((t) => t !== void 0);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@npmcli+config@11.0.1/node_modules/@npmcli/config/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { walkUp } = require_commonjs();
+	const ini = require_ini();
+	const nopt = require_nopt();
+	const { log, time } = require_lib$2();
+	const { resolve, dirname, join } = __require("node:path");
+	const { homedir } = __require("node:os");
+	const { readFile, writeFile, chmod, unlink, stat, mkdir } = __require("node:fs/promises");
+	const internalEnv = [
+		"npm-version",
+		"global-prefix",
+		"local-prefix"
+	];
+	const fileExists = (...p) => stat(resolve(...p)).then((st) => st.isFile()).catch(() => false);
+	const dirExists = (...p) => stat(resolve(...p)).then((st) => st.isDirectory()).catch(() => false);
+	const hasOwnProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+	const typeDefs = require_type_defs();
+	const nerfDart = require_nerf_dart();
+	const envReplace = require_env_replace();
+	const parseField = require_parse_field();
+	const setEnvs = require_set_envs();
+	const confFileTypes = /* @__PURE__ */ new Set([
+		"global",
+		"user",
+		"project"
+	]);
+	const confTypes = /* @__PURE__ */ new Set([
+		"default",
+		"builtin",
+		...confFileTypes,
+		"env",
+		"cli"
+	]);
+	var Config = class {
+		#loaded = false;
+		#flatten;
+		#flatOptions = null;
+		#warnings = [];
+		#unknownConfigs = [];
+		static get typeDefs() {
+			return typeDefs;
+		}
+		constructor({ definitions, shorthands, flatten, nerfDarts = [], npmPath, env = process.env, argv = process.argv, platform = process.platform, execPath = process.execPath, cwd = process.cwd(), excludeNpmCwd = false, warn = true }) {
+			this.nerfDarts = nerfDarts;
+			this.definitions = definitions;
+			const { types, defaults, deprecated } = getTypesFromDefinitions(definitions);
+			this.deprecated = deprecated;
+			this.#flatten = flatten;
+			this.types = types;
+			this.shorthands = shorthands;
+			this.defaults = defaults;
+			this.npmPath = npmPath;
+			this.npmBin = join(this.npmPath, "bin/npm-cli.js");
+			this.argv = argv;
+			this.env = env;
+			this.execPath = execPath;
+			this.platform = platform;
+			this.cwd = cwd;
+			this.excludeNpmCwd = excludeNpmCwd;
+			this.globalPrefix = null;
+			this.localPrefix = null;
+			this.localPackage = null;
+			this.home = null;
+			const wheres = [...confTypes];
+			this.data = /* @__PURE__ */ new Map();
+			let parent = null;
+			for (const where of wheres) this.data.set(where, parent = new ConfigData(parent));
+			this.data.set = () => {
+				throw new Error("cannot change internal config data structure");
+			};
+			this.data.delete = () => {
+				throw new Error("cannot change internal config data structure");
+			};
+			this.sources = /* @__PURE__ */ new Map([]);
+			for (const { data } of this.data.values()) this.list.unshift(data);
+			this.#loaded = false;
+			this.warn = warn;
+		}
+		get list() {
+			const list = [];
+			for (const { data } of this.data.values()) list.unshift(data);
+			return list;
+		}
+		get loaded() {
+			return this.#loaded;
+		}
+		get prefix() {
+			return this.#get("global") ? this.globalPrefix : this.localPrefix;
+		}
+		find(key) {
+			if (!this.loaded) throw new Error("call config.load() before reading values");
+			const entries = [...this.data.entries()];
+			for (let i = entries.length - 1; i > -1; i--) {
+				const [where, { data }] = entries[i];
+				if (hasOwnProperty(data, key)) return where;
+			}
+			return null;
+		}
+		get(key, where) {
+			if (!this.loaded) throw new Error("call config.load() before reading values");
+			return this.#get(key, where);
+		}
+		#get(key, where = null) {
+			if (where !== null && !confTypes.has(where)) throw new Error("invalid config location param: " + where);
+			const { data } = this.data.get(where || "cli");
+			return where === null || hasOwnProperty(data, key) ? data[key] : void 0;
+		}
+		set(key, val, where = "cli") {
+			if (!this.loaded) throw new Error("call config.load() before setting values");
+			if (!confTypes.has(where)) throw new Error("invalid config location param: " + where);
+			this.#checkDeprecated(key);
+			const { data, raw } = this.data.get(where);
+			data[key] = val;
+			if ([
+				"global",
+				"user",
+				"project"
+			].includes(where)) raw[key] = val;
+			this.data.get(where)[_valid] = null;
+			this.#flatOptions = null;
+		}
+		get flat() {
+			if (this.#flatOptions) return this.#flatOptions;
+			const timeEnd = time.start("config:load:flatten");
+			this.#flatOptions = {};
+			for (const { data } of this.data.values()) this.#flatten(data, this.#flatOptions);
+			this.#flatOptions.nodeBin = this.execPath;
+			this.#flatOptions.npmBin = this.npmBin;
+			timeEnd();
+			return this.#flatOptions;
+		}
+		delete(key, where = "cli") {
+			if (!this.loaded) throw new Error("call config.load() before deleting values");
+			if (!confTypes.has(where)) throw new Error("invalid config location param: " + where);
+			const { data, raw } = this.data.get(where);
+			delete data[key];
+			if ([
+				"global",
+				"user",
+				"project"
+			].includes(where)) delete raw[key];
+		}
+		async load() {
+			if (this.loaded) throw new Error("attempting to load npm config multiple times");
+			this.loadDefaults();
+			await this.loadBuiltinConfig();
+			this.loadCLI();
+			this.loadEnv();
+			await this.loadProjectConfig();
+			await this.loadUserConfig();
+			await this.loadGlobalConfig();
+			this.#loaded = true;
+			this.globalPrefix = this.get("prefix");
+			this.setEnvs();
+		}
+		loadDefaults() {
+			this.loadGlobalPrefix();
+			this.loadHome();
+			const defaultsObject = {
+				...this.defaults,
+				prefix: this.globalPrefix
+			};
+			try {
+				defaultsObject["npm-version"] = __require(join(this.npmPath, "package.json")).version;
+			} catch {}
+			this.#loadObject(defaultsObject, "default", "default values");
+			const { data } = this.data.get("default");
+			Object.defineProperty(data, "globalconfig", {
+				get: () => resolve(this.#get("prefix"), "etc/npmrc"),
+				set(value) {
+					Object.defineProperty(data, "globalconfig", {
+						value,
+						configurable: true,
+						writable: true,
+						enumerable: true
+					});
+				},
+				configurable: true,
+				enumerable: true
+			});
+			Object.defineProperty(data, "global-ignore-file", {
+				get: () => resolve(this.#get("prefix"), "etc/npmignore"),
+				set(value) {
+					Object.defineProperty(data, "global-ignore-file", {
+						value,
+						configurable: true,
+						writable: true,
+						enumerable: true
+					});
+				},
+				configurable: true,
+				enumerable: true
+			});
+		}
+		loadHome() {
+			this.home = this.env.HOME || homedir();
+		}
+		loadGlobalPrefix() {
+			if (this.globalPrefix) throw new Error("cannot load default global prefix more than once");
+			if (this.env.PREFIX) this.globalPrefix = this.env.PREFIX;
+			else if (this.platform === "win32") this.globalPrefix = dirname(this.execPath);
+			else {
+				this.globalPrefix = dirname(dirname(this.execPath));
+				if (this.env.DESTDIR) this.globalPrefix = join(this.env.DESTDIR, this.globalPrefix);
+			}
+		}
+		loadEnv() {
+			const conf = Object.create(null);
+			for (const [envKey, envVal] of Object.entries(this.env)) {
+				if (!/^npm_config_/i.test(envKey) || envVal === "") continue;
+				let key = envKey.slice(11);
+				if (!key.startsWith("//")) key = key.replace(/(?!^)_/g, "-").toLowerCase();
+				conf[key] = envVal;
+			}
+			this.#loadObject(conf, "env", "environment");
+		}
+		loadCLI() {
+			for (const s of Object.keys(this.shorthands)) if (s.length > 1 && this.argv.includes(`-${s}`)) throw Object.assign(/* @__PURE__ */ new Error(`-${s} is not a valid single-hyphen cli flag. Did you mean --${s}?`), { code: "EUNKNOWNCONFIG" });
+			nopt.invalidHandler = (k, val, type) => this.invalidHandler(k, val, type, "command line options", "cli");
+			nopt.unknownHandler = (k, next) => this.unknownHandler(k, next);
+			nopt.abbrevHandler = this.abbrevHandler;
+			const conf = nopt(this.types, this.shorthands, this.argv);
+			nopt.invalidHandler = null;
+			nopt.unknownHandler = null;
+			this.parsedArgv = conf.argv;
+			delete conf.argv;
+			this.#loadObject(conf, "cli", "command line options");
+		}
+		get valid() {
+			for (const [where, { valid }] of this.data.entries()) if (valid === false || valid === null && !this.validate(where)) return false;
+			return true;
+		}
+		validate(where) {
+			if (!where) {
+				let valid = true;
+				const authProblems = [];
+				for (const entryWhere of this.data.keys()) {
+					if (entryWhere === "default" || entryWhere === "builtin" || entryWhere === "cli") continue;
+					const ret = this.validate(entryWhere);
+					valid = valid && ret;
+					if ([
+						"global",
+						"user",
+						"project"
+					].includes(entryWhere)) {
+						for (const key of ["_authtoken", "-authtoken"]) if (this.get(key, entryWhere)) authProblems.push({
+							action: "delete",
+							key,
+							where: entryWhere
+						});
+						const nerfedReg = nerfDart(this.get("registry"));
+						for (const key of [
+							"_auth",
+							"_authToken",
+							"username",
+							"_password"
+						]) if (this.get(key, entryWhere)) {
+							if (key === "username" && !this.get("_password", entryWhere)) authProblems.push({
+								action: "delete",
+								key,
+								where: entryWhere
+							});
+							else if (key === "_password" && !this.get("username", entryWhere)) authProblems.push({
+								action: "delete",
+								key,
+								where: entryWhere
+							});
+							else authProblems.push({
+								action: "rename",
+								from: key,
+								to: `${nerfedReg}:${key}`,
+								where: entryWhere
+							});
+						}
+						if (this.get("email", entryWhere)) authProblems.push({
+							action: "rename",
+							from: "email",
+							to: `${nerfedReg}:email`,
+							where: entryWhere
+						});
+						for (const key of ["certfile", "keyfile"]) if (this.get(key, entryWhere)) {
+							const pair = key === "certfile" ? "keyfile" : "certfile";
+							if (!this.get(pair, entryWhere)) authProblems.push({
+								action: "delete",
+								key,
+								where: entryWhere
+							});
+							else authProblems.push({
+								action: "rename",
+								from: key,
+								to: `${nerfedReg}:${key}`,
+								where: entryWhere
+							});
+						}
+					}
+				}
+				if (authProblems.length) {
+					const { ErrInvalidAuth } = require_errors();
+					throw new ErrInvalidAuth(authProblems);
+				}
+				return valid;
+			} else {
+				const obj = this.data.get(where);
+				obj[_valid] = true;
+				nopt.invalidHandler = (k, val, type) => this.invalidHandler(k, val, type, obj.source, where);
+				nopt.clean(obj.data, this.types, typeDefs);
+				nopt.invalidHandler = null;
+				return obj[_valid];
+			}
+		}
+		repair(problems) {
+			if (!problems) try {
+				this.validate();
+			} catch (err) {
+				// istanbul ignore next
+				if (err.code !== "ERR_INVALID_AUTH") throw err;
+				problems = err.problems;
+			} finally {
+				if (!problems) problems = [];
+			}
+			for (const problem of problems)
+ // istanbul ignore else
+			if (problem.action === "delete") this.delete(problem.key, problem.where);
+			else if (problem.action === "rename") {
+				if (this.find(problem.to) !== null) this.delete(problem.from, problem.where);
+				else {
+					const raw = this.data.get(problem.where).raw?.[problem.from];
+					const calculated = this.get(problem.from, problem.where);
+					this.set(problem.to, raw || calculated, problem.where);
+					this.delete(problem.from, problem.where);
+				}
+			}
+		}
+		isDefault(key) {
+			const [defaultType, ...types] = [...confTypes];
+			const defaultData = this.data.get(defaultType).data;
+			return hasOwnProperty(defaultData, key) && types.every((type) => {
+				const typeData = this.data.get(type).data;
+				return !hasOwnProperty(typeData, key);
+			});
+		}
+		invalidHandler(k, val, type, source, where) {
+			const typeDescription = require_type_description();
+			log.warn("invalid config", k + "=" + JSON.stringify(val), `set in ${source}`);
+			this.data.get(where)[_valid] = false;
+			if (Array.isArray(type)) {
+				if (type.includes(typeDefs.url.type)) type = typeDefs.url.type;
+				else if (type.includes(typeDefs.path.type)) type = typeDefs.path.type;
+			}
+			const typeDesc = typeDescription(type);
+			const mustBe = typeDesc.filter((m) => m !== void 0 && m !== Array);
+			const msg = "Must be" + this.#getOneOfKeywords(mustBe, typeDesc);
+			const desc = mustBe.length === 1 ? mustBe[0] : [...new Set(mustBe.map((n) => typeof n === "string" ? n : JSON.stringify(n)))].join(", ");
+			log.warn("invalid config", msg, desc);
+		}
+		abbrevHandler(short, long) {
+			throw Object.assign(/* @__PURE__ */ new Error(`Invalid abbreviated flag "--${short}". Did you mean "--${long}"?`), { code: "EUNKNOWNCONFIG" });
+		}
+		unknownHandler(key, next) {
+			if (next) this.queueWarning(`unknown:${next}`, `"${next}" is being parsed as a normal command line argument.`);
+		}
+		#getOneOfKeywords(mustBe, typeDesc) {
+			let keyword;
+			if (mustBe.length === 1 && typeDesc.includes(Array)) keyword = " one or more";
+			else if (mustBe.length > 1 && typeDesc.includes(Array)) keyword = " one or more of:";
+			else if (mustBe.length > 1) keyword = " one of:";
+			else keyword = "";
+			return keyword;
+		}
+		#loadObject(obj, where, source, er = null) {
+			const conf = this.data.get(where);
+			if (conf.source) {
+				const m = `double-loading "${where}" configs from ${source}, previously loaded from ${conf.source}`;
+				throw new Error(m);
+			}
+			if (this.sources.has(source)) {
+				const m = `double-loading config "${source}" as "${where}", previously loaded as "${this.sources.get(source)}"`;
+				throw new Error(m);
+			}
+			conf.source = source;
+			this.sources.set(source, where);
+			if (er) {
+				conf.loadError = er;
+				if (er.code !== "ENOENT") log.verbose("config", `error loading ${where} config`, er);
+			} else {
+				conf.raw = obj;
+				outer: for (const [key, value] of Object.entries(obj)) {
+					const k = envReplace(key, this.env);
+					const v = this.parseField(value, k);
+					if (where !== "default") {
+						this.#checkDeprecated(k);
+						if (this.definitions[key]?.exclusive) {
+							for (const exclusive of this.definitions[key].exclusive) if (!this.isDefault(exclusive)) {
+								if (where === "env") {
+									const cliData = this.data.get("cli").data;
+									if (Object.hasOwn(cliData, exclusive)) continue outer;
+								}
+								throw new TypeError(`--${key} cannot be provided when using --${exclusive}`);
+							}
+						}
+					}
+					if (where !== "default" || key === "npm-version") this.checkUnknown(where, key, source);
+					conf.data[k] = v;
+				}
+			}
+		}
+		checkUnknown(where, key, source = null) {
+			if (this.definitions[key]) return;
+			if (internalEnv.includes(key)) return;
+			const scoped = key.includes(":");
+			let baseKey = null;
+			if (scoped) {
+				baseKey = key.split(":").pop();
+				if (this.definitions[baseKey] || this.nerfDarts.includes(baseKey)) return;
+			}
+			const entry = {
+				where,
+				key,
+				baseKey,
+				source: source ?? this.data.get(where)?.source ?? null
+			};
+			this.#unknownConfigs.push(entry);
+			if (where === "publishConfig") {
+				const hint = " See `npm help npmrc` for supported config options.";
+				const msg = scoped ? `Unknown ${where} config "${baseKey}" (${key}). This will stop working in the next major version of npm.${hint}` : `Unknown ${where} config "${key}". This will stop working in the next major version of npm.${hint}`;
+				this.queueWarning(scoped ? baseKey : key, msg);
+				return;
+			}
+			if (where === "env") {
+				const hint = " See `npm help npmrc` for supported config options.";
+				const msg = scoped ? `Unknown ${where} config "${baseKey}" (${key}). This will error in a future major version of npm.${hint}` : `Unknown ${where} config "${key}". This will error in a future major version of npm.${hint}`;
+				this.queueWarning(scoped ? baseKey : key, msg);
+			}
+		}
+		getUnknownConfigs(where) {
+			if (where) return this.#unknownConfigs.filter((u) => u.where === where);
+			return this.#unknownConfigs.filter((u) => u.where !== "env" && u.where !== "publishConfig");
+		}
+		#checkDeprecated(key) {
+			if (this.deprecated[key]) log.warn("config", key, this.deprecated[key]);
+		}
+		parseField(f, key, listElement = false) {
+			return parseField(f, key, this, listElement);
+		}
+		async #loadFile(file, type) {
+			log.silly("config", `load:file:${file}`);
+			await readFile(file, "utf8").then((data) => {
+				const parsedConfig = ini.parse(data);
+				if (type === "project" && parsedConfig.prefix) log.error("config", `prefix cannot be changed from project config: ${file}.`);
+				return this.#loadObject(parsedConfig, type, file);
+			}, (er) => this.#loadObject(null, type, file, er));
+		}
+		loadBuiltinConfig() {
+			return this.#loadFile(resolve(this.npmPath, "npmrc"), "builtin");
+		}
+		async loadProjectConfig() {
+			await this.loadLocalPrefix();
+			if (this.localPackage == null) this.localPackage = await fileExists(this.localPrefix, "package.json");
+			if (this.#get("global") === true || this.#get("location") === "global") {
+				this.data.get("project").source = "(global mode enabled, ignored)";
+				this.sources.set(this.data.get("project").source, "project");
+				return;
+			}
+			const projectFile = resolve(this.localPrefix, ".npmrc");
+			if (projectFile !== this.#get("userconfig")) return this.#loadFile(projectFile, "project");
+			else {
+				this.data.get("project").source = "(same as \"user\" config, ignored)";
+				this.sources.set(this.data.get("project").source, "project");
+			}
+		}
+		async loadLocalPrefix() {
+			const cliPrefix = this.#get("prefix", "cli");
+			if (cliPrefix) {
+				this.localPrefix = cliPrefix;
+				return;
+			}
+			const cliWorkspaces = this.#get("workspaces", "cli");
+			const isGlobal = this.#get("global") || this.#get("location") === "global";
+			for (const p of walkUp(this.cwd)) {
+				if (this.excludeNpmCwd && p === this.npmPath) break;
+				const hasPackageJson = await fileExists(p, "package.json");
+				if (!this.localPrefix && (hasPackageJson || await dirExists(p, "node_modules"))) {
+					this.localPrefix = p;
+					this.localPackage = hasPackageJson;
+					if (cliWorkspaces === false || isGlobal) return;
+					continue;
+				}
+				if (this.localPrefix && hasPackageJson) {
+					const { content: pkg } = await require_lib$3().normalize(p).catch(() => ({ content: {} }));
+					if (!pkg?.workspaces) continue;
+					const workspaces = await require_lib$1()({
+						cwd: p,
+						pkg
+					});
+					for (const w of workspaces.values()) if (w === this.localPrefix) {
+						if (await fileExists(this.localPrefix, ".npmrc")) log.warn("config", `ignoring workspace config at ${this.localPrefix}/.npmrc`);
+						const { data } = this.data.get("default");
+						data.workspace = [this.localPrefix];
+						this.localPrefix = p;
+						this.localPackage = hasPackageJson;
+						log.info("config", `found workspace root at ${this.localPrefix}`);
+						return;
+					}
+				}
+			}
+			if (!this.localPrefix) this.localPrefix = this.cwd;
+		}
+		loadUserConfig() {
+			return this.#loadFile(this.#get("userconfig"), "user");
+		}
+		loadGlobalConfig() {
+			return this.#loadFile(this.#get("globalconfig"), "global");
+		}
+		async save(where) {
+			if (!this.loaded) throw new Error("call config.load() before saving");
+			if (!confFileTypes.has(where)) throw new Error("invalid config location param: " + where);
+			const conf = this.data.get(where);
+			conf[_loadError] = null;
+			if (where === "user") {}
+			const iniData = ini.stringify(conf.raw).trim() + "\n";
+			if (!iniData.trim()) {
+				await unlink(conf.source).catch(() => {});
+				return;
+			}
+			const dir = dirname(conf.source);
+			await mkdir(dir, { recursive: true });
+			await writeFile(conf.source, iniData, "utf8");
+			const mode = where === "user" ? 384 : 438;
+			await chmod(conf.source, mode);
+		}
+		clearCredentialsByURI(uri, level = "user") {
+			const nerfed = nerfDart(uri);
+			if (nerfDart(this.get("registry")) === nerfed) {
+				this.delete(`-authtoken`, level);
+				this.delete(`_authToken`, level);
+				this.delete(`_authtoken`, level);
+				this.delete(`_auth`, level);
+				this.delete(`_password`, level);
+				this.delete(`username`, level);
+			}
+			this.delete(`${nerfed}:_authToken`, level);
+			this.delete(`${nerfed}:_auth`, level);
+			this.delete(`${nerfed}:_password`, level);
+			this.delete(`${nerfed}:username`, level);
+			this.delete(`${nerfed}:email`, level);
+			this.delete(`${nerfed}:certfile`, level);
+			this.delete(`${nerfed}:keyfile`, level);
+		}
+		setCredentialsByURI(uri, { token, username, password, certfile, keyfile }) {
+			const nerfed = nerfDart(uri);
+			this.delete(`${nerfed}:always-auth`, "user");
+			if (certfile && keyfile) {
+				this.set(`${nerfed}:certfile`, certfile, "user");
+				this.set(`${nerfed}:keyfile`, keyfile, "user");
+			}
+			if (token) {
+				this.set(`${nerfed}:_authToken`, token, "user");
+				this.delete(`${nerfed}:_password`, "user");
+				this.delete(`${nerfed}:username`, "user");
+			} else if (username || password) {
+				if (!username) throw new Error("must include username");
+				if (!password) throw new Error("must include password");
+				this.delete(`${nerfed}:_authToken`, "user");
+				this.set(`${nerfed}:username`, username, "user");
+				const encoded = Buffer.from(password, "utf8").toString("base64");
+				this.set(`${nerfed}:_password`, encoded, "user");
+			} else if (!certfile || !keyfile) throw new Error("No credentials to set.");
+		}
+		getCredentialsByURI(uri) {
+			const nerfed = nerfDart(uri);
+			const creds = {};
+			const email = this.get(`${nerfed}:email`) || this.get("email");
+			if (email) creds.email = email;
+			const certfileReg = this.get(`${nerfed}:certfile`);
+			const keyfileReg = this.get(`${nerfed}:keyfile`);
+			if (certfileReg && keyfileReg) {
+				creds.certfile = certfileReg;
+				creds.keyfile = keyfileReg;
+			}
+			const tokenReg = this.get(`${nerfed}:_authToken`);
+			if (tokenReg) {
+				creds.token = tokenReg;
+				return creds;
+			}
+			const userReg = this.get(`${nerfed}:username`);
+			const passReg = this.get(`${nerfed}:_password`);
+			if (userReg && passReg) {
+				creds.username = userReg;
+				creds.password = Buffer.from(passReg, "base64").toString("utf8");
+				const auth = `${creds.username}:${creds.password}`;
+				creds.auth = Buffer.from(auth, "utf8").toString("base64");
+				return creds;
+			}
+			const authReg = this.get(`${nerfed}:_auth`);
+			if (authReg) {
+				const authSplit = Buffer.from(authReg, "base64").toString("utf8").split(":");
+				creds.username = authSplit.shift();
+				creds.password = authSplit.join(":");
+				creds.auth = authReg;
+				return creds;
+			}
+			return creds;
+		}
+		setEnvs() {
+			setEnvs(this);
+		}
+		removeWarning(key) {
+			this.#warnings = this.#warnings.filter((w) => w.type !== key);
+		}
+		getUnknownPositionals() {
+			return this.#warnings.filter((w) => w.type.startsWith("unknown:")).map((w) => w.type.slice(8));
+		}
+		removeUnknownPositional(value) {
+			this.removeWarning(`unknown:${value}`);
+		}
+		queueWarning(type, ...args) {
+			if (!this.warn) this.#warnings.push({
+				type,
+				args
+			});
+			else log.warn(...args);
+		}
+		logWarnings() {
+			for (const warning of this.#warnings) log.warn(...warning.args);
+			this.#warnings = [];
+		}
+	};
+	const _loadError = Symbol("loadError");
+	const _valid = Symbol("valid");
+	var ConfigData = class {
+		#data;
+		#source = null;
+		#raw = null;
+		constructor(parent) {
+			this.#data = Object.create(parent && parent.data);
+			this.#raw = {};
+			this[_valid] = true;
+		}
+		get data() {
+			return this.#data;
+		}
+		get valid() {
+			return this[_valid];
+		}
+		set source(s) {
+			if (this.#source) throw new Error("cannot set ConfigData source more than once");
+			this.#source = s;
+		}
+		get source() {
+			return this.#source;
+		}
+		set loadError(e) {
+			if (this[_loadError] || Object.keys(this.#raw).length) throw new Error("cannot set ConfigData loadError after load");
+			this[_loadError] = e;
+		}
+		get loadError() {
+			return this[_loadError];
+		}
+		set raw(r) {
+			if (Object.keys(this.#raw).length || this[_loadError]) throw new Error("cannot set ConfigData raw after load");
+			this.#raw = r;
+		}
+		get raw() {
+			return this.#raw;
+		}
+	};
+	const getTypesFromDefinitions = (definitions) => {
+		const types = {};
+		const defaults = {};
+		const deprecated = {};
+		for (const [key, def] of Object.entries(definitions)) {
+			defaults[key] = def.default;
+			types[key] = def.type;
+			if (def.deprecated) deprecated[key] = def.deprecated.trim().replace(/\n +/, "\n");
+		}
+		return {
+			types,
+			defaults,
+			deprecated
+		};
+	};
+	module.exports = Config;
+	module.exports.getTypesFromDefinitions = getTypesFromDefinitions;
+}));
+//#endregion
+export default require_lib();
+export {};
+
+//# sourceMappingURL=lib-HXZBVLKt.mjs.map