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

package/definitions-ClJIBYEm.mjs

@@ -0,0 +1,3348 @@
+import { St as __require, yt as __commonJSMin } from "./error-DTXBm1nO.mjs";
+import { t as require_type_defs } from "./type-defs-xvRvQI4T.mjs";
+//#region ../../node_modules/.pnpm/@npmcli+config@11.0.1/node_modules/@npmcli/config/lib/definitions/definition.js
+var require_definition = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const required = [
+		"type",
+		"description",
+		"default",
+		"key"
+	];
+	const allowed = [
+		"default",
+		"defaultDescription",
+		"deprecated",
+		"description",
+		"exclusive",
+		"flatten",
+		"hint",
+		"key",
+		"short",
+		"type",
+		"typeDescription",
+		"usage",
+		"envExport",
+		"alias",
+		"required"
+	];
+	const { semver: { type: semver }, Umask: { type: Umask }, url: { type: url }, path: { type: path } } = require_type_defs();
+	var Definition = class {
+		constructor(key, def) {
+			this.key = key;
+			this.envExport = true;
+			Object.assign(this, def);
+			this.validate();
+			if (!this.defaultDescription) this.defaultDescription = describeValue(this.default);
+			if (!this.typeDescription) this.typeDescription = describeType(this.type);
+			if (!this.hint) {
+				if (this.type === Number) this.hint = "<number>";
+				else this.hint = `<${this.key}>`;
+			}
+			if (!this.usage) this.usage = describeUsage(this);
+		}
+		validate() {
+			for (const req of required) if (!Object.prototype.hasOwnProperty.call(this, req)) throw new Error(`config lacks ${req}: ${this.key}`);
+			if (!this.key) throw new Error(`config lacks key: ${this.key}`);
+			for (const field of Object.keys(this)) if (!allowed.includes(field)) throw new Error(`config defines unknown field ${field}: ${this.key}`);
+		}
+		describe() {
+			const description = unindent(this.description);
+			const noEnvExport = this.envExport ? "" : `
+This value is not exported to the environment for child processes.
+`;
+			const deprecated = !this.deprecated ? "" : `* DEPRECATED: ${unindent(this.deprecated)}\n`;
+			const exclusive = !this.exclusive ? "" : `\nThis config cannot be used with: \`${this.exclusive.join("`, `")}\``;
+			return wrapAll(`#### \`${this.key}\`
+
+* Default: ${unindent(this.defaultDescription)}
+* Type: ${unindent(this.typeDescription)}
+${deprecated}
+${description}
+${exclusive}
+${noEnvExport}`);
+		}
+	};
+	const describeUsage = (def) => {
+		let key = "";
+		if (!Array.isArray(def.type)) {
+			if (def.short) key = `-${def.short}|`;
+			if (def.type === Boolean && def.default !== false) key = `${key}--no-${def.key}`;
+			else key = `${key}--${def.key}`;
+			if (def.type !== Boolean) key = `${key} ${def.hint}`;
+			return key;
+		}
+		key = `--${def.key}`;
+		if (def.short) key = `-${def.short}|--${def.key}`;
+		let types = def.type;
+		const multiple = types.includes(Array);
+		const bool = types.includes(Boolean);
+		types = types.filter((t) => t !== null && t !== Array && t !== Boolean);
+		if (!types.length) return key;
+		let description;
+		if (!types.some((t) => typeof t !== "string")) description = `<${types.filter((d) => d).join("|")}>`;
+		else description = def.hint;
+		if (bool) key = `--no-${def.key}|${key}`;
+		const usage = `${key} ${description}`;
+		if (multiple) return `${usage} [${usage} ...]`;
+		else return usage;
+	};
+	const describeType = (type) => {
+		if (Array.isArray(type)) {
+			const descriptions = type.filter((t) => t !== Array).map((t) => describeType(t));
+			const last = descriptions.length > 1 ? [descriptions.pop()] : [];
+			const oxford = descriptions.length > 1 ? ", or " : " or ";
+			return `${[descriptions.join(", ")].concat(last).join(oxford)}${type.includes(Array) ? " (can be set multiple times)" : ""}`;
+		}
+		switch (type) {
+			case String: return "String";
+			case Number: return "Number";
+			case Umask: return "Octal numeric string in range 0000..0777 (0..511)";
+			case Boolean: return "Boolean";
+			case Date: return "Date";
+			case path: return "Path";
+			case semver: return "SemVer string";
+			case url: return "URL";
+			default: return describeValue(type);
+		}
+	};
+	const describeValue = (val) => typeof val === "string" ? JSON.stringify(val) : String(val);
+	const unindent = (s) => {
+		const match = s.match(/\n +/);
+		return !match ? s.trim() : s.split(match[0]).join("\n").trim();
+	};
+	const wrap = (s) => {
+		const cols = Math.min(Math.max(20, process.stdout.columns) || 80, 80) - 5;
+		return unindent(s).split(/[ \n]+/).reduce((left, right) => {
+			const last = left.split("\n").pop();
+			return left + (last.length && last.length + right.length > cols ? "\n" : " ") + right;
+		});
+	};
+	const wrapAll = (s) => {
+		let inCodeBlock = false;
+		return s.split("\n\n").map((block) => {
+			if (inCodeBlock || block.startsWith("```")) {
+				inCodeBlock = !block.endsWith("```");
+				return block;
+			}
+			if (block.charAt(0) === "*") return "* " + block.slice(1).trim().split("\n* ").map((li) => {
+				return wrap(li).replace(/\n/g, "\n  ");
+			}).join("\n* ");
+			else return wrap(block);
+		}).join("\n\n");
+	};
+	module.exports = Definition;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@npmcli+config@11.0.1/node_modules/@npmcli/config/lib/parse-allow-scripts-list.js
+var require_parse_allow_scripts_list = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const parseAllowScriptsList = (raw) => {
+		const parts = [];
+		const entries = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+		for (const entry of entries) {
+			if (typeof entry !== "string") continue;
+			for (const part of entry.split(",")) {
+				const trimmed = part.trim();
+				if (trimmed) parts.push(trimmed);
+			}
+		}
+		return parts;
+	};
+	module.exports = parseAllowScriptsList;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ci-info@4.4.0/node_modules/ci-info/vendors.json
+var require_vendors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = [
+		{
+			"name": "Agola CI",
+			"constant": "AGOLA",
+			"env": "AGOLA_GIT_REF",
+			"pr": "AGOLA_PULL_REQUEST_ID"
+		},
+		{
+			"name": "Alpic",
+			"constant": "ALPIC",
+			"env": "ALPIC_HOST"
+		},
+		{
+			"name": "Appcircle",
+			"constant": "APPCIRCLE",
+			"env": "AC_APPCIRCLE",
+			"pr": {
+				"env": "AC_GIT_PR",
+				"ne": "false"
+			}
+		},
+		{
+			"name": "AppVeyor",
+			"constant": "APPVEYOR",
+			"env": "APPVEYOR",
+			"pr": "APPVEYOR_PULL_REQUEST_NUMBER"
+		},
+		{
+			"name": "AWS CodeBuild",
+			"constant": "CODEBUILD",
+			"env": "CODEBUILD_BUILD_ARN",
+			"pr": {
+				"env": "CODEBUILD_WEBHOOK_EVENT",
+				"any": [
+					"PULL_REQUEST_CREATED",
+					"PULL_REQUEST_UPDATED",
+					"PULL_REQUEST_REOPENED"
+				]
+			}
+		},
+		{
+			"name": "Azure Pipelines",
+			"constant": "AZURE_PIPELINES",
+			"env": "TF_BUILD",
+			"pr": { "BUILD_REASON": "PullRequest" }
+		},
+		{
+			"name": "Bamboo",
+			"constant": "BAMBOO",
+			"env": "bamboo_planKey"
+		},
+		{
+			"name": "Bitbucket Pipelines",
+			"constant": "BITBUCKET",
+			"env": "BITBUCKET_COMMIT",
+			"pr": "BITBUCKET_PR_ID"
+		},
+		{
+			"name": "Bitrise",
+			"constant": "BITRISE",
+			"env": "BITRISE_IO",
+			"pr": "BITRISE_PULL_REQUEST"
+		},
+		{
+			"name": "Buddy",
+			"constant": "BUDDY",
+			"env": "BUDDY_WORKSPACE_ID",
+			"pr": "BUDDY_EXECUTION_PULL_REQUEST_ID"
+		},
+		{
+			"name": "Buildkite",
+			"constant": "BUILDKITE",
+			"env": "BUILDKITE",
+			"pr": {
+				"env": "BUILDKITE_PULL_REQUEST",
+				"ne": "false"
+			}
+		},
+		{
+			"name": "CircleCI",
+			"constant": "CIRCLE",
+			"env": "CIRCLECI",
+			"pr": "CIRCLE_PULL_REQUEST"
+		},
+		{
+			"name": "Cirrus CI",
+			"constant": "CIRRUS",
+			"env": "CIRRUS_CI",
+			"pr": "CIRRUS_PR"
+		},
+		{
+			"name": "Cloudflare Pages",
+			"constant": "CLOUDFLARE_PAGES",
+			"env": "CF_PAGES"
+		},
+		{
+			"name": "Cloudflare Workers",
+			"constant": "CLOUDFLARE_WORKERS",
+			"env": "WORKERS_CI"
+		},
+		{
+			"name": "Codefresh",
+			"constant": "CODEFRESH",
+			"env": "CF_BUILD_ID",
+			"pr": { "any": ["CF_PULL_REQUEST_NUMBER", "CF_PULL_REQUEST_ID"] }
+		},
+		{
+			"name": "Codemagic",
+			"constant": "CODEMAGIC",
+			"env": "CM_BUILD_ID",
+			"pr": "CM_PULL_REQUEST"
+		},
+		{
+			"name": "Codeship",
+			"constant": "CODESHIP",
+			"env": { "CI_NAME": "codeship" }
+		},
+		{
+			"name": "Drone",
+			"constant": "DRONE",
+			"env": "DRONE",
+			"pr": { "DRONE_BUILD_EVENT": "pull_request" }
+		},
+		{
+			"name": "dsari",
+			"constant": "DSARI",
+			"env": "DSARI"
+		},
+		{
+			"name": "Earthly",
+			"constant": "EARTHLY",
+			"env": "EARTHLY_CI"
+		},
+		{
+			"name": "Expo Application Services",
+			"constant": "EAS",
+			"env": "EAS_BUILD"
+		},
+		{
+			"name": "Gerrit",
+			"constant": "GERRIT",
+			"env": "GERRIT_PROJECT"
+		},
+		{
+			"name": "Gitea Actions",
+			"constant": "GITEA_ACTIONS",
+			"env": "GITEA_ACTIONS"
+		},
+		{
+			"name": "GitHub Actions",
+			"constant": "GITHUB_ACTIONS",
+			"env": "GITHUB_ACTIONS",
+			"pr": { "GITHUB_EVENT_NAME": "pull_request" }
+		},
+		{
+			"name": "GitLab CI",
+			"constant": "GITLAB",
+			"env": "GITLAB_CI",
+			"pr": "CI_MERGE_REQUEST_ID"
+		},
+		{
+			"name": "GoCD",
+			"constant": "GOCD",
+			"env": "GO_PIPELINE_LABEL"
+		},
+		{
+			"name": "Google Cloud Build",
+			"constant": "GOOGLE_CLOUD_BUILD",
+			"env": "BUILDER_OUTPUT"
+		},
+		{
+			"name": "Harness CI",
+			"constant": "HARNESS",
+			"env": "HARNESS_BUILD_ID"
+		},
+		{
+			"name": "Heroku",
+			"constant": "HEROKU",
+			"env": {
+				"env": "NODE",
+				"includes": "/app/.heroku/node/bin/node"
+			}
+		},
+		{
+			"name": "Hudson",
+			"constant": "HUDSON",
+			"env": "HUDSON_URL"
+		},
+		{
+			"name": "Jenkins",
+			"constant": "JENKINS",
+			"env": ["JENKINS_URL", "BUILD_ID"],
+			"pr": { "any": ["ghprbPullId", "CHANGE_ID"] }
+		},
+		{
+			"name": "LayerCI",
+			"constant": "LAYERCI",
+			"env": "LAYERCI",
+			"pr": "LAYERCI_PULL_REQUEST"
+		},
+		{
+			"name": "Magnum CI",
+			"constant": "MAGNUM",
+			"env": "MAGNUM"
+		},
+		{
+			"name": "Netlify CI",
+			"constant": "NETLIFY",
+			"env": "NETLIFY",
+			"pr": {
+				"env": "PULL_REQUEST",
+				"ne": "false"
+			}
+		},
+		{
+			"name": "Nevercode",
+			"constant": "NEVERCODE",
+			"env": "NEVERCODE",
+			"pr": {
+				"env": "NEVERCODE_PULL_REQUEST",
+				"ne": "false"
+			}
+		},
+		{
+			"name": "Prow",
+			"constant": "PROW",
+			"env": "PROW_JOB_ID"
+		},
+		{
+			"name": "ReleaseHub",
+			"constant": "RELEASEHUB",
+			"env": "RELEASE_BUILD_ID"
+		},
+		{
+			"name": "Render",
+			"constant": "RENDER",
+			"env": "RENDER",
+			"pr": { "IS_PULL_REQUEST": "true" }
+		},
+		{
+			"name": "Sail CI",
+			"constant": "SAIL",
+			"env": "SAILCI",
+			"pr": "SAIL_PULL_REQUEST_NUMBER"
+		},
+		{
+			"name": "Screwdriver",
+			"constant": "SCREWDRIVER",
+			"env": "SCREWDRIVER",
+			"pr": {
+				"env": "SD_PULL_REQUEST",
+				"ne": "false"
+			}
+		},
+		{
+			"name": "Semaphore",
+			"constant": "SEMAPHORE",
+			"env": "SEMAPHORE",
+			"pr": "PULL_REQUEST_NUMBER"
+		},
+		{
+			"name": "Sourcehut",
+			"constant": "SOURCEHUT",
+			"env": { "CI_NAME": "sourcehut" }
+		},
+		{
+			"name": "Strider CD",
+			"constant": "STRIDER",
+			"env": "STRIDER"
+		},
+		{
+			"name": "TaskCluster",
+			"constant": "TASKCLUSTER",
+			"env": ["TASK_ID", "RUN_ID"]
+		},
+		{
+			"name": "TeamCity",
+			"constant": "TEAMCITY",
+			"env": "TEAMCITY_VERSION"
+		},
+		{
+			"name": "Travis CI",
+			"constant": "TRAVIS",
+			"env": "TRAVIS",
+			"pr": {
+				"env": "TRAVIS_PULL_REQUEST",
+				"ne": "false"
+			}
+		},
+		{
+			"name": "Vela",
+			"constant": "VELA",
+			"env": "VELA",
+			"pr": { "VELA_PULL_REQUEST": "1" }
+		},
+		{
+			"name": "Vercel",
+			"constant": "VERCEL",
+			"env": { "any": ["NOW_BUILDER", "VERCEL"] },
+			"pr": "VERCEL_GIT_PULL_REQUEST_ID"
+		},
+		{
+			"name": "Visual Studio App Center",
+			"constant": "APPCENTER",
+			"env": "APPCENTER_BUILD_ID"
+		},
+		{
+			"name": "Woodpecker",
+			"constant": "WOODPECKER",
+			"env": { "CI": "woodpecker" },
+			"pr": { "CI_BUILD_EVENT": "pull_request" }
+		},
+		{
+			"name": "Xcode Cloud",
+			"constant": "XCODE_CLOUD",
+			"env": "CI_XCODE_PROJECT",
+			"pr": "CI_PULL_REQUEST_NUMBER"
+		},
+		{
+			"name": "Xcode Server",
+			"constant": "XCODE_SERVER",
+			"env": "XCS"
+		}
+	];
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/ci-info@4.4.0/node_modules/ci-info/index.js
+var require_ci_info = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const vendors = require_vendors();
+	const env = process.env;
+	Object.defineProperty(exports, "_vendors", { value: vendors.map(function(v) {
+		return v.constant;
+	}) });
+	exports.name = null;
+	exports.isPR = null;
+	exports.id = null;
+	if (env.CI !== "false") vendors.forEach(function(vendor) {
+		const isCI = (Array.isArray(vendor.env) ? vendor.env : [vendor.env]).every(function(obj) {
+			return checkEnv(obj);
+		});
+		exports[vendor.constant] = isCI;
+		if (!isCI) return;
+		exports.name = vendor.name;
+		exports.isPR = checkPR(vendor);
+		exports.id = vendor.constant;
+	});
+	exports.isCI = !!(env.CI !== "false" && (env.BUILD_ID || env.BUILD_NUMBER || env.CI || env.CI_APP_ID || env.CI_BUILD_ID || env.CI_BUILD_NUMBER || env.CI_NAME || env.CONTINUOUS_INTEGRATION || env.RUN_ID || exports.name || false));
+	function checkEnv(obj) {
+		if (typeof obj === "string") return !!env[obj];
+		if ("env" in obj) return env[obj.env] && env[obj.env].includes(obj.includes);
+		if ("any" in obj) return obj.any.some(function(k) {
+			return !!env[k];
+		});
+		return Object.keys(obj).every(function(k) {
+			return env[k] === obj[k];
+		});
+	}
+	function checkPR(vendor) {
+		switch (typeof vendor.pr) {
+			case "string": return !!env[vendor.pr];
+			case "object": if ("env" in vendor.pr) {
+				if ("any" in vendor.pr) return vendor.pr.any.some(function(key) {
+					return env[vendor.pr.env] === key;
+				});
+				else return vendor.pr.env in env && env[vendor.pr.env] !== vendor.pr.ne;
+			} else if ("any" in vendor.pr) return vendor.pr.any.some(function(key) {
+				return !!env[key];
+			});
+			else return checkEnv(vendor.pr);
+			default: return null;
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@npmcli+config@11.0.1/node_modules/@npmcli/config/lib/definitions/definitions.js
+var require_definitions$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Definition = require_definition();
+	const parseAllowScriptsList = require_parse_allow_scripts_list();
+	const ciInfo = require_ci_info();
+	const querystring = __require("node:querystring");
+	const { join } = __require("node:path");
+	const isWindows = process.platform === "win32";
+	const { readFileSync } = __require("node:fs");
+	const maybeReadFile = (file) => {
+		try {
+			return readFileSync(file, "utf8");
+		} catch (er) {
+			if (er.code !== "ENOENT") throw er;
+			return null;
+		}
+	};
+	const buildOmitList = (obj) => {
+		const include = obj.include || [];
+		const omit = obj.omit || [];
+		const only = obj.only;
+		if (/^prod(uction)?$/.test(only) || obj.production) omit.push("dev");
+		else if (obj.production === false) include.push("dev");
+		if (/^dev/.test(obj.also)) include.push("dev");
+		if (obj.dev) include.push("dev");
+		if (obj.optional === false) omit.push("optional");
+		else if (obj.optional === true) include.push("optional");
+		obj.omit = [...new Set(omit)].filter((type) => !include.includes(type));
+		obj.include = [...new Set(include)];
+		if (obj.omit.includes("dev")) process.env.NODE_ENV = "production";
+		return obj.omit;
+	};
+	const editor = process.env.EDITOR || process.env.VISUAL || (isWindows ? `${process.env.SYSTEMROOT}\\notepad.exe` : "vi");
+	const shell = isWindows ? process.env.ComSpec || "cmd" : process.env.SHELL || "sh";
+	const { networkInterfaces } = __require("node:os");
+	const getLocalAddresses = () => {
+		try {
+			return Object.values(networkInterfaces()).map((int) => int.map(({ address }) => address)).reduce((set, addrs) => set.concat(addrs), [null]);
+		} catch (e) {
+			return [null];
+		}
+	};
+	const unicode = /UTF-?8$/i.test(process.env.LC_ALL || process.env.LC_CTYPE || process.env.LANG);
+	const cache = `${isWindows && process.env.LOCALAPPDATA || "~"}/${isWindows ? "npm-cache" : ".npm"}`;
+	const { semver: { type: Semver }, Umask: { type: Umask }, url: { type: url }, path: { type: path } } = require_type_defs();
+	const flatten = (key, obj, flatOptions) => {
+		const camel = key.replace(/-([a-z])/g, (_0, _1) => _1.toUpperCase());
+		flatOptions[camel] = obj[key];
+	};
+	const definitions = {
+		_auth: new Definition("_auth", {
+			default: null,
+			type: [null, String],
+			description: `
+    A basic-auth string to use when authenticating against the npm registry.
+    This will ONLY be used to authenticate against the npm registry.  For other
+    registries you will need to scope it like "//other-registry.tld/:_auth"
+
+    Warning: This should generally not be set via a command-line option.  It
+    is safer to use a registry-provided authentication bearer token stored in
+    the ~/.npmrc file by running \`npm login\`.
+  `,
+			flatten
+		}),
+		access: new Definition("access", {
+			default: null,
+			defaultDescription: `
+    'public' for new packages, existing packages it will not change the current level
+  `,
+			type: [
+				null,
+				"restricted",
+				"public",
+				"private"
+			],
+			description: `
+    If you do not want your scoped package to be publicly viewable (and
+    installable) set \`--access=restricted\`.
+
+    Unscoped packages cannot be set to \`restricted\`.
+
+    Note: This defaults to not changing the current access level for existing
+    packages.  Specifying a value of \`restricted\` or \`public\` during
+    publish will change the access for an existing package the same way that
+    \`npm access set status\` would.
+
+    The value \`private\` is an alias for \`restricted\`.
+  `,
+			flatten(key, obj, flatOptions) {
+				const value = obj[key];
+				flatOptions.access = value === "private" ? "restricted" : value;
+			}
+		}),
+		all: new Definition("all", {
+			default: false,
+			type: Boolean,
+			short: "a",
+			description: `
+    Show or act on all packages, not just the ones your project directly
+    depends on. For \`npm outdated\` and \`npm ls\` this lists every outdated
+    or installed package. For \`npm approve-scripts\` and \`npm deny-scripts\`
+    it selects every package with pending install scripts.
+  `,
+			flatten
+		}),
+		"allow-same-version": new Definition("allow-same-version", {
+			default: false,
+			type: Boolean,
+			description: `
+    Prevents throwing an error when \`npm version\` is used to set the new
+    version to the same value as the current version.
+  `,
+			flatten
+		}),
+		"allow-directory": new Definition("allow-directory", {
+			default: "all",
+			type: [
+				"all",
+				"none",
+				"root"
+			],
+			description: `
+      Limits the ability for npm to install dependencies from directories.
+      That is, dependencies that point to a directory instead of a version or semver range.
+      Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+      Changing this setting will not remove dependencies that are already installed.
+
+      \`all\` allows any directories to be installed.
+      \`none\` prevents any directories from being installed.
+      \`root\` only allows directories defined in your project's package.json to be installed.  Also allows directory dependencies to be used for other commands like \`npm view\`
+  `,
+			flatten
+		}),
+		"allow-file": new Definition("allow-file", {
+			default: "all",
+			type: [
+				"all",
+				"none",
+				"root"
+			],
+			description: `
+      Limits the ability for npm to install dependencies from tarball files.
+      That is, dependencies that point to a local tarball file instead of a version or semver range.
+      Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+      Changing this setting will not remove dependencies that are already installed.
+
+      \`all\` allows any tarball file to be installed.
+      \`none\` prevents any tarball file from being installed.
+      \`root\` only allows tarball files defined in your project's package.json to be installed.  Also allows tarball file dependencies to be used for other commands like \`npm view\`
+  `,
+			flatten
+		}),
+		"allow-git": new Definition("allow-git", {
+			default: "none",
+			type: [
+				"all",
+				"none",
+				"root"
+			],
+			description: `
+      Limits the ability for npm to fetch dependencies from git references.
+      That is, dependencies that point to a git repo instead of a version or semver range.
+      Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+      Changing this setting will not remove dependencies that are already installed.
+
+      As of npm 12 the default is \`none\`. Git dependencies run \`git\`
+      against a remote repo and may install configuration the project does
+      not control. Opt in explicitly per project (in \`.npmrc\`) or per
+      command (on the CLI) when you need git deps.
+
+      \`all\` allows any git dependencies to be fetched and installed.
+      \`none\` prevents any git dependencies from being fetched and installed.
+      \`root\` only allows git dependencies defined in your project's package.json to be fetched and installed.  Also allows git dependencies to be fetched for other commands like \`npm view\`
+  `,
+			flatten
+		}),
+		"allow-remote": new Definition("allow-remote", {
+			default: "none",
+			type: [
+				"all",
+				"none",
+				"root"
+			],
+			description: `
+      Limits the ability for npm to fetch dependencies from urls.
+      That is, dependencies that point to a tarball url instead of a version or semver range.
+      Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+      Changing this setting will not remove dependencies that are already installed.
+
+      As of npm 12 the default is \`none\`. Tarballs that share a hostname
+      with the configured registry (the typical case for the npm registry,
+      GitHub Packages, and most private registries) are still installed
+      normally. If your registry serves tarballs from a different host,
+      set \`replace-registry-host\` or override this setting. Opt in
+      explicitly per project (in \`.npmrc\`) or per command (on the CLI)
+      when you intentionally install from a URL.
+
+      \`all\` allows any url to be installed.
+      \`none\` prevents any url from being installed.
+      \`root\` only allows urls defined in your project's package.json to be installed.  Also allows url dependencies to be used for other commands like \`npm view\`
+  `,
+			flatten
+		}),
+		"allow-scripts": new Definition("allow-scripts", {
+			default: "",
+			type: [String, Array],
+			hint: "<package-list>",
+			description: `
+      Comma-separated list of packages whose install-time lifecycle scripts
+      (\`preinstall\`, \`install\`, \`postinstall\`, and \`prepare\` for
+      non-registry dependencies) are allowed to run.
+
+      This setting is intended for one-off and global contexts: \`npm exec\`,
+      \`npx\`, and \`npm install -g\`, where no project \`package.json\` is
+      involved. For team-wide policy in a project, use the \`allowScripts\`
+      field in \`package.json\` (which also supports explicit denials), or
+      configure it in \`.npmrc\`. Passing \`--allow-scripts\` on the command
+      line during a project-scoped \`npm install\`, \`ci\`, \`update\`, or
+      \`rebuild\` is an error.
+
+      Each name is matched against a dependency's resolved identity, not
+      against the package's self-reported name. \`--ignore-scripts\` and
+      \`--dangerously-allow-all-scripts\` both override this setting.
+  `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.allowScripts = parseAllowScriptsList(obj[key]);
+			}
+		}),
+		also: new Definition("also", {
+			default: null,
+			type: [
+				null,
+				"dev",
+				"development"
+			],
+			description: `
+      When set to \`dev\` or \`development\`, this is an alias for
+      \`--include=dev\`.
+    `,
+			deprecated: "Please use --include=dev instead.",
+			flatten(key, obj, flatOptions) {
+				definitions.omit.flatten("omit", obj, flatOptions);
+			}
+		}),
+		audit: new Definition("audit", {
+			default: true,
+			type: Boolean,
+			description: `
+      When "true" submit audit reports alongside the current npm command to the
+      default registry and all registries configured for scopes.  See the
+      documentation for [\`npm audit\`](/commands/npm-audit) for details on what
+      is submitted.
+    `,
+			flatten
+		}),
+		"audit-level": new Definition("audit-level", {
+			default: null,
+			type: [
+				null,
+				"info",
+				"low",
+				"moderate",
+				"high",
+				"critical",
+				"none"
+			],
+			description: `
+    The minimum level of vulnerability for \`npm audit\` to exit with
+    a non-zero exit code.
+    `,
+			flatten
+		}),
+		"auth-type": new Definition("auth-type", {
+			default: "web",
+			type: ["legacy", "web"],
+			description: `
+      What authentication strategy to use with \`login\`.
+      Note that if an \`otp\` config is given, this value will always be set to \`legacy\`.
+    `,
+			flatten
+		}),
+		before: new Definition("before", {
+			default: null,
+			hint: "<date>",
+			type: [null, Date],
+			description: `
+      If passed to \`npm install\`, will rebuild the npm tree such that only
+      versions that were available **on or before** the given date are
+      installed.  If there are no versions available for the current set of
+      dependencies, the command will error.
+
+      If the requested version is a \`dist-tag\` and the given tag does not
+      pass the \`--before\` filter, the most recent version less than or equal
+      to that tag will be used. For example, \`foo@latest\` might install
+      \`foo@1.2\` even though \`latest\` is \`2.0\`.
+
+      If \`before\` and \`min-release-age\` are both set in the same source,
+      \`before\` wins (an explicit absolute date overrides a relative window).
+      Across sources, the standard precedence applies (cli > env > project >
+      user > global), so a higher-priority source can always relax or
+      override a lower-priority one.
+
+      As with \`min-release-age\`, when this cutoff blocks a fix that
+      \`npm audit fix\` would install, npm keeps the vulnerable version, warns,
+      and exits with a non-zero code.
+
+      Packages whose names match \`min-release-age-exclude\` are exempt from
+      this filter.
+    `,
+			flatten
+		}),
+		"bin-links": new Definition("bin-links", {
+			default: true,
+			type: Boolean,
+			description: `
+      Tells npm to create symlinks (or \`.cmd\` shims on Windows) for package
+      executables.
+
+      Set to false to have it not do this.  This can be used to work around the
+      fact that some file systems don't support symlinks, even on ostensibly
+      Unix systems.
+    `,
+			flatten
+		}),
+		browser: new Definition("browser", {
+			default: null,
+			defaultDescription: `
+    macOS: \`"open"\`, Windows: \`"start"\`, Others: \`"xdg-open"\`
+    `,
+			type: [
+				null,
+				Boolean,
+				String
+			],
+			description: `
+    The browser that is called by npm commands to open websites.
+
+    Set to \`false\` to suppress browser behavior and instead print urls to
+    terminal.
+
+    Set to \`true\` to use default system URL opener.
+    `,
+			flatten
+		}),
+		"bypass-2fa": new Definition("bypass-2fa", {
+			default: false,
+			type: Boolean,
+			description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      setting this to true will allow the token to bypass two-factor
+      authentication. This is useful for automation and CI/CD workflows.
+    `,
+			flatten
+		}),
+		ca: new Definition("ca", {
+			default: null,
+			type: [
+				null,
+				String,
+				Array
+			],
+			description: `
+    The Certificate Authority signing certificate that is trusted for SSL
+    connections to the registry. Values should be in PEM format (Windows
+      calls it "Base-64 encoded X.509 (.CER)") with newlines replaced by the
+    string "\\n". For example:
+
+    \`\`\`ini
+    ca="-----BEGIN CERTIFICATE-----\\nXXXX\\nXXXX\\n-----END CERTIFICATE-----"
+    \`\`\`
+
+    Set to \`null\` to only allow "known" registrars, or to a specific CA
+    cert to trust only that specific signing authority.
+
+    Multiple CAs can be trusted by specifying an array of certificates:
+
+    \`\`\`ini
+    ca[]="..."
+    ca[]="..."
+    \`\`\`
+
+    See also the \`strict-ssl\` config.
+  `,
+			flatten
+		}),
+		cache: new Definition("cache", {
+			default: cache,
+			defaultDescription: `
+      Windows: \`%LocalAppData%\\npm-cache\`, Posix: \`~/.npm\`
+    `,
+			type: path,
+			description: `
+      The location of npm's cache directory.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.cache = join(obj.cache, "_cacache");
+				flatOptions.npxCache = join(obj.cache, "_npx");
+				flatOptions.tufCache = join(obj.cache, "_tuf");
+			}
+		}),
+		"cache-max": new Definition("cache-max", {
+			default: Infinity,
+			type: Number,
+			description: `
+      \`--cache-max=0\` is an alias for \`--prefer-online\`
+    `,
+			deprecated: `
+      This option has been deprecated in favor of \`--prefer-online\`
+    `,
+			flatten(key, obj, flatOptions) {
+				if (obj[key] <= 0) flatOptions.preferOnline = true;
+			}
+		}),
+		"cache-min": new Definition("cache-min", {
+			default: 0,
+			type: Number,
+			description: `
+      \`--cache-min=9999 (or bigger)\` is an alias for \`--prefer-offline\`.
+    `,
+			deprecated: `
+      This option has been deprecated in favor of \`--prefer-offline\`.
+    `,
+			flatten(key, obj, flatOptions) {
+				if (obj[key] >= 9999) flatOptions.preferOffline = true;
+			}
+		}),
+		cafile: new Definition("cafile", {
+			default: null,
+			type: path,
+			description: `
+      A path to a file containing one or multiple Certificate Authority signing
+      certificates. Similar to the \`ca\` setting, but allows for multiple
+      CA's, as well as for the CA information to be stored in a file on disk.
+    `,
+			flatten(key, obj, flatOptions) {
+				if (!obj.cafile) return;
+				const raw = maybeReadFile(obj.cafile);
+				if (!raw) return;
+				const delim = "-----END CERTIFICATE-----";
+				flatOptions.ca = raw.replace(/\r\n/g, "\n").split(delim).filter((section) => section.trim()).map((section) => section.trimLeft() + delim);
+			}
+		}),
+		call: new Definition("call", {
+			default: "",
+			type: String,
+			short: "c",
+			description: `
+      Optional companion option for \`npm exec\`, \`npx\` that allows for
+      specifying a custom command to be run along with the installed packages.
+
+      \`\`\`bash
+      npm exec --package yo --package generator-node --call "yo node"
+      \`\`\`
+    `,
+			flatten
+		}),
+		cert: new Definition("cert", {
+			default: null,
+			type: [null, String],
+			description: `
+      A client certificate to pass when accessing the registry.  Values should
+      be in PEM format (Windows calls it "Base-64 encoded X.509 (.CER)") with
+      newlines replaced by the string "\\n". For example:
+
+      \`\`\`ini
+      cert="-----BEGIN CERTIFICATE-----\\nXXXX\\nXXXX\\n-----END CERTIFICATE-----"
+      \`\`\`
+
+      It is _not_ the path to a certificate file, though you can set a registry-scoped
+      "certfile" path like "//other-registry.tld/:certfile=/path/to/cert.pem".
+    `,
+			deprecated: `
+      \`key\` and \`cert\` are no longer used for most registry operations.
+      Use registry scoped \`keyfile\` and \`certfile\` instead.
+      Example:
+      //other-registry.tld/:keyfile=/path/to/key.pem
+      //other-registry.tld/:certfile=/path/to/cert.crt
+    `,
+			flatten
+		}),
+		cidr: new Definition("cidr", {
+			default: null,
+			type: [
+				null,
+				String,
+				Array
+			],
+			description: `
+      This is a list of CIDR address to be used when configuring limited access
+      tokens with the \`npm token create\` command.
+    `,
+			flatten
+		}),
+		color: new Definition("color", {
+			default: !process.env.NO_COLOR || process.env.NO_COLOR === "0",
+			usage: "--color|--no-color|--color always",
+			defaultDescription: `
+      true unless the NO_COLOR environ is set to something other than '0'
+    `,
+			type: ["always", Boolean],
+			description: `
+      If false, never shows colors.  If \`"always"\` then always shows colors.
+      If true, then only prints color codes for tty file descriptors.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.color = !obj.color ? false : obj.color === "always" ? true : !!process.stdout.isTTY;
+				flatOptions.logColor = !obj.color ? false : obj.color === "always" ? true : !!process.stderr.isTTY;
+			}
+		}),
+		"commit-hooks": new Definition("commit-hooks", {
+			default: true,
+			type: Boolean,
+			description: `
+      Run git commit hooks when using the \`npm version\` command.
+    `,
+			flatten
+		}),
+		cpu: new Definition("cpu", {
+			default: null,
+			type: [null, String],
+			description: `
+      Override CPU architecture of native modules to install.
+      Acceptable values are same as \`cpu\` field of package.json,
+      which comes from \`process.arch\`.
+    `,
+			flatten
+		}),
+		"dangerously-allow-all-scripts": new Definition("dangerously-allow-all-scripts", {
+			default: false,
+			type: Boolean,
+			description: `
+      If \`true\`, bypass the \`allowScripts\` policy entirely and run every
+      dependency install script regardless of whether it was approved or
+      denied. Intended as a migration escape hatch only; its use is strongly
+      discouraged. \`--ignore-scripts\` still takes precedence over this
+      setting.
+    `,
+			flatten
+		}),
+		depth: new Definition("depth", {
+			default: null,
+			defaultDescription: `
+      \`Infinity\` if \`--all\` is set; otherwise, \`0\`
+    `,
+			type: [null, Number],
+			description: `
+      The depth to go when recursing packages for \`npm ls\`.
+
+      If not set, \`npm ls\` will show only the immediate dependencies of the
+      root project.  If \`--all\` is set, then npm will show all dependencies
+      by default.
+    `,
+			flatten
+		}),
+		description: new Definition("description", {
+			default: true,
+			type: Boolean,
+			usage: "--no-description",
+			description: `
+      Show the description in \`npm search\`
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.search = flatOptions.search || { limit: 20 };
+				flatOptions.search[key] = obj[key];
+			}
+		}),
+		dev: new Definition("dev", {
+			default: false,
+			type: Boolean,
+			description: `
+      Alias for \`--include=dev\`.
+    `,
+			deprecated: "Please use --include=dev instead.",
+			flatten(key, obj, flatOptions) {
+				definitions.omit.flatten("omit", obj, flatOptions);
+			}
+		}),
+		diff: new Definition("diff", {
+			default: [],
+			hint: "<package-spec>",
+			type: [String, Array],
+			description: `
+      Define arguments to compare in \`npm diff\`.
+    `,
+			flatten
+		}),
+		"diff-ignore-all-space": new Definition("diff-ignore-all-space", {
+			default: false,
+			type: Boolean,
+			description: `
+      Ignore whitespace when comparing lines in \`npm diff\`.
+    `,
+			flatten
+		}),
+		"diff-name-only": new Definition("diff-name-only", {
+			default: false,
+			type: Boolean,
+			description: `
+      Prints only filenames when using \`npm diff\`.
+    `,
+			flatten
+		}),
+		"diff-no-prefix": new Definition("diff-no-prefix", {
+			default: false,
+			type: Boolean,
+			description: `
+      Do not show any source or destination prefix in \`npm diff\` output.
+
+      Note: this causes \`npm diff\` to ignore the \`--diff-src-prefix\` and
+      \`--diff-dst-prefix\` configs.
+    `,
+			flatten
+		}),
+		"diff-dst-prefix": new Definition("diff-dst-prefix", {
+			default: "b/",
+			hint: "<path>",
+			type: String,
+			description: `
+      Destination prefix to be used in \`npm diff\` output.
+    `,
+			flatten
+		}),
+		"diff-src-prefix": new Definition("diff-src-prefix", {
+			default: "a/",
+			hint: "<path>",
+			type: String,
+			description: `
+      Source prefix to be used in \`npm diff\` output.
+    `,
+			flatten
+		}),
+		"diff-text": new Definition("diff-text", {
+			default: false,
+			type: Boolean,
+			description: `
+      Treat all files as text in \`npm diff\`.
+    `,
+			flatten
+		}),
+		"diff-unified": new Definition("diff-unified", {
+			default: 3,
+			type: Number,
+			description: `
+      The number of lines of context to print in \`npm diff\`.
+    `,
+			flatten
+		}),
+		"dry-run": new Definition("dry-run", {
+			default: false,
+			type: Boolean,
+			description: `
+      Indicates that you don't want npm to make any changes and that it should
+      only report what it would have done.  This can be passed into any of the
+      commands that modify your local installation, eg, \`install\`,
+      \`update\`, \`dedupe\`, \`uninstall\`, as well as \`pack\` and
+      \`publish\`.
+
+      Note: This is NOT honored by other network related commands, eg
+      \`dist-tags\`, \`owner\`, etc.
+    `,
+			flatten
+		}),
+		editor: new Definition("editor", {
+			default: editor,
+			defaultDescription: `
+      The EDITOR or VISUAL environment variables, or '%SYSTEMROOT%\\notepad.exe' on Windows,
+      or 'vi' on Unix systems
+    `,
+			type: String,
+			description: `
+      The command to run for \`npm edit\` and \`npm config edit\`.
+    `,
+			flatten
+		}),
+		"engine-strict": new Definition("engine-strict", {
+			default: false,
+			type: Boolean,
+			description: `
+      If set to true, then npm will stubbornly refuse to install (or even
+      consider installing) any package that claims to not be compatible with
+      the current Node.js version.
+
+      This can be overridden by setting the \`--force\` flag.
+    `,
+			flatten
+		}),
+		"expect-result-count": new Definition("expect-result-count", {
+			default: null,
+			type: [null, Number],
+			hint: "<count>",
+			exclusive: ["expect-results"],
+			description: `
+      Tells to expect a specific number of results from the command.
+    `
+		}),
+		"expect-results": new Definition("expect-results", {
+			default: null,
+			type: [null, Boolean],
+			exclusive: ["expect-result-count"],
+			description: `
+      Tells npm whether or not to expect results from the command.
+      Can be either true (expect some results) or false (expect no results).
+    `
+		}),
+		expires: new Definition("expires", {
+			default: null,
+			type: [null, Number],
+			description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      this sets the expiration in days. If not specified, the server
+      will determine the default expiration.
+    `,
+			flatten
+		}),
+		"extension-file": new Definition("extension-file", {
+			default: null,
+			type: [null, path],
+			description: `
+      Path to a project-local npm extension file to load instead of
+      discovering \`.npm-extension.mjs\` / \`.npm-extension.cjs\` at the
+      project root. Must resolve inside the project root and use a \`.mjs\`
+      or \`.cjs\` extension. Only honored from project config or the command
+      line, never from user, global, or builtin config.
+    `,
+			flatten
+		}),
+		"fetch-retries": new Definition("fetch-retries", {
+			default: 2,
+			type: Number,
+			description: `
+      The "retries" config for the \`retry\` module to use when fetching
+      packages from the registry.
+
+      npm will retry idempotent read requests to the registry in the case
+      of network failures or 5xx HTTP errors.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.retry = flatOptions.retry || {};
+				flatOptions.retry.retries = obj[key];
+			}
+		}),
+		"fetch-retry-factor": new Definition("fetch-retry-factor", {
+			default: 10,
+			type: Number,
+			description: `
+      The "factor" config for the \`retry\` module to use when fetching
+      packages.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.retry = flatOptions.retry || {};
+				flatOptions.retry.factor = obj[key];
+			}
+		}),
+		"fetch-retry-maxtimeout": new Definition("fetch-retry-maxtimeout", {
+			default: 6e4,
+			defaultDescription: "60000 (1 minute)",
+			type: Number,
+			description: `
+      The "maxTimeout" config for the \`retry\` module to use when fetching
+      packages.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.retry = flatOptions.retry || {};
+				flatOptions.retry.maxTimeout = obj[key];
+			}
+		}),
+		"fetch-retry-mintimeout": new Definition("fetch-retry-mintimeout", {
+			default: 1e4,
+			defaultDescription: "10000 (10 seconds)",
+			type: Number,
+			description: `
+      The "minTimeout" config for the \`retry\` module to use when fetching
+      packages.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.retry = flatOptions.retry || {};
+				flatOptions.retry.minTimeout = obj[key];
+			}
+		}),
+		"fetch-timeout": new Definition("fetch-timeout", {
+			default: 3e5,
+			defaultDescription: `300000 (5 minutes)`,
+			type: Number,
+			description: `
+      The maximum amount of time to wait for HTTP requests to complete.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.timeout = obj[key];
+			}
+		}),
+		force: new Definition("force", {
+			default: false,
+			type: Boolean,
+			short: "f",
+			description: `
+      Removes various protections against unfortunate side effects, common
+      mistakes, unnecessary performance degradation, and malicious input.
+
+      * Allow clobbering non-npm files in global installs.
+      * Allow the \`npm version\` command to work on an unclean git repository.
+      * Allow deleting the cache folder with \`npm cache clean\`.
+      * Allow installing packages that have an \`engines\` declaration
+        requiring a different version of npm.
+      * Allow installing packages that have an \`engines\` declaration
+        requiring a different version of \`node\`, even if \`--engine-strict\`
+        is enabled.
+      * Allow \`npm audit fix\` to install modules outside your stated
+        dependency range (including SemVer-major changes).
+      * Allow unpublishing all versions of a published package.
+      * Allow conflicting peerDependencies to be installed in the root project.
+      * Implicitly set \`--yes\` during \`npm init\`.
+      * Allow clobbering existing values in \`npm pkg\`
+      * Allow unpublishing of entire packages (not just a single version).
+
+      If you don't have a clear idea of what you want to do, it is strongly
+      recommended that you do not use this option!
+    `,
+			flatten
+		}),
+		"foreground-scripts": new Definition("foreground-scripts", {
+			default: false,
+			defaultDescription: `\`false\` unless when using \`npm pack\` or \`npm publish\` where it
+    defaults to \`true\``,
+			type: Boolean,
+			description: `
+      Run all build scripts (ie, \`preinstall\`, \`install\`, and
+      \`postinstall\`) scripts for installed packages in the foreground
+      process, sharing standard input, output, and error with the main npm
+      process.
+
+      Note that this will generally make installs run slower, and be much
+      noisier, but can be useful for debugging.
+    `,
+			flatten
+		}),
+		"format-package-lock": new Definition("format-package-lock", {
+			default: true,
+			type: Boolean,
+			description: `
+      Format \`package-lock.json\` as a human
+      readable file.
+    `,
+			flatten
+		}),
+		fund: new Definition("fund", {
+			default: true,
+			type: Boolean,
+			description: `
+      When "true" displays the message at the end of each \`npm install\`
+      acknowledging the number of dependencies looking for funding.
+      See [\`npm fund\`](/commands/npm-fund) for details.
+    `,
+			flatten
+		}),
+		git: new Definition("git", {
+			default: "git",
+			type: String,
+			description: `
+      The command to use for git commands.  If git is installed on the
+      computer, but is not in the \`PATH\`, then set this to the full path to
+      the git binary.
+    `,
+			flatten
+		}),
+		"git-tag-version": new Definition("git-tag-version", {
+			default: true,
+			type: Boolean,
+			description: `
+      Tag the commit when using the \`npm version\` command.  Setting this to
+      false results in no commit being made at all.
+    `,
+			flatten
+		}),
+		global: new Definition("global", {
+			default: false,
+			type: Boolean,
+			short: "g",
+			description: `
+      Operates in "global" mode, so that packages are installed into the
+      \`prefix\` folder instead of the current working directory.  See
+      [folders](/configuring-npm/folders) for more on the differences in
+      behavior.
+
+      * packages are installed into the \`{prefix}/lib/node_modules\` folder,
+        instead of the current working directory.
+      * bin files are linked to \`{prefix}/bin\`
+      * man pages are linked to \`{prefix}/share/man\`
+    `,
+			flatten: (key, obj, flatOptions) => {
+				flatten(key, obj, flatOptions);
+				if (flatOptions.global) flatOptions.location = "global";
+			}
+		}),
+		globalconfig: new Definition("globalconfig", {
+			type: path,
+			default: "",
+			defaultDescription: `
+      The global --prefix setting plus 'etc/npmrc'. For example,
+      '/usr/local/etc/npmrc'
+    `,
+			description: `
+      The config file to read for global config options.
+    `,
+			flatten
+		}),
+		"global-ignore-file": new Definition("global-ignore-file", {
+			type: path,
+			default: "",
+			defaultDescription: `
+      The global --prefix setting plus 'etc/npmignore'. For example,
+      '/usr/local/etc/npmignore'
+    `,
+			description: `
+      An additional ignore file applied during \`npm pack\` and \`npm
+      publish\`, owned by the current user rather than the package. Patterns
+      follow the same syntax as a package's local \`.npmignore\` file.
+      Useful for keeping editor metadata (such as \`.idea/\` or \`*.iml\`)
+      and scratch directories out of every package you publish, without
+      adding them to each package's own ignore rules.
+
+      The global rules apply in addition to a package's local \`.npmignore\`.
+      When a package uses a \`files\` field in its \`package.json\`, an entry
+      in \`files\` that contradicts a global rule (i.e., explicitly includes
+      a path the global rule would exclude) still wins.
+    `,
+			flatten
+		}),
+		"global-style": new Definition("global-style", {
+			default: false,
+			type: Boolean,
+			description: `
+      Only install direct dependencies in the top level \`node_modules\`,
+      but hoist on deeper dependencies.
+      Sets \`--install-strategy=shallow\`.
+    `,
+			deprecated: `
+      This option has been deprecated in favor of \`--install-strategy=shallow\`
+    `,
+			flatten(key, obj, flatOptions) {
+				if (obj[key]) {
+					obj["install-strategy"] = "shallow";
+					flatOptions.installStrategy = "shallow";
+				}
+			}
+		}),
+		heading: new Definition("heading", {
+			default: "npm",
+			type: String,
+			description: `
+      The string that starts all the debugging log output.
+    `,
+			flatten
+		}),
+		"https-proxy": new Definition("https-proxy", {
+			default: null,
+			type: [null, url],
+			description: `
+      A proxy to use for outgoing https requests. If the \`HTTPS_PROXY\` or
+      \`https_proxy\` or \`HTTP_PROXY\` or \`http_proxy\` environment variables
+      are set, proxy settings will be honored by the underlying
+      \`make-fetch-happen\` library.
+    `,
+			flatten
+		}),
+		"if-present": new Definition("if-present", {
+			default: false,
+			type: Boolean,
+			envExport: false,
+			description: `
+      If true, npm will not exit with an error code when \`run\` is
+      invoked for a script that isn't defined in the \`scripts\` section of
+      \`package.json\`. This option can be used when it's desirable to
+      optionally run a script when it's present and fail if the script fails.
+      This is useful, for example, when running scripts that may only apply for
+      some builds in an otherwise generic CI setup.
+    `,
+			flatten
+		}),
+		"ignore-extension": new Definition("ignore-extension", {
+			default: false,
+			type: Boolean,
+			description: `
+      If true, npm does not import or execute a root \`.npm-extension.mjs\` /
+      \`.npm-extension.cjs\` file (or one selected via \`extension-file\`).
+      \`ignore-scripts\` implies \`ignore-extension\`, since both disable
+      root-owned install-time code.
+    `,
+			flatten
+		}),
+		"ignore-scripts": new Definition("ignore-scripts", {
+			default: false,
+			type: Boolean,
+			description: `
+      If true, npm does not run scripts specified in package.json files.
+
+      Note that commands explicitly intended to run a particular script, such
+      as \`npm start\`, \`npm stop\`, \`npm restart\`, \`npm test\`, and \`npm
+      run\` will still run their intended script if \`ignore-scripts\` is
+      set, but they will *not* run any pre- or post-scripts.
+
+      Setting \`ignore-scripts\` also disables \`.npm-extension\` execution,
+      as if \`ignore-extension\` were set.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.ignoreScripts = obj["ignore-scripts"];
+				if (obj["ignore-scripts"]) flatOptions.ignoreExtension = true;
+			}
+		}),
+		include: new Definition("include", {
+			default: [],
+			type: [
+				Array,
+				"prod",
+				"dev",
+				"optional",
+				"peer"
+			],
+			description: `
+      Option that allows for defining which types of dependencies to install.
+
+      This is the inverse of \`--omit=<type>\`.
+
+      Dependency types specified in \`--include\` will not be omitted,
+      regardless of the order in which omit/include are specified on the
+      command-line.
+    `,
+			flatten(key, obj, flatOptions) {
+				definitions.omit.flatten("omit", obj, flatOptions);
+			}
+		}),
+		"include-staged": new Definition("include-staged", {
+			default: false,
+			type: Boolean,
+			description: `
+      Allow installing "staged" published packages, as defined by [npm RFC PR
+      #92](https://github.com/npm/rfcs/pull/92).
+
+      This is experimental, and not implemented by the npm public registry.
+    `,
+			flatten
+		}),
+		"include-workspace-root": new Definition("include-workspace-root", {
+			default: false,
+			type: Boolean,
+			envExport: false,
+			description: `
+      Include the workspace root when workspaces are enabled for a command.
+
+      When false, specifying individual workspaces via the \`workspace\` config,
+      or all workspaces via the \`workspaces\` flag, will cause npm to operate only
+      on the specified workspaces, and not on the root project.
+    `,
+			flatten
+		}),
+		"include-attestations": new Definition("include-attestations", {
+			default: false,
+			type: Boolean,
+			description: `
+      When used with \`npm audit signatures --json\`, includes the full
+      sigstore attestation bundles in the JSON output for each verified
+      package. The bundles contain DSSE envelopes, verification material,
+      and transparency log entries.
+    `,
+			flatten
+		}),
+		"init-author-email": new Definition("init-author-email", {
+			default: "",
+			hint: "<email>",
+			type: String,
+			description: `
+      The value \`npm init\` should use by default for the package author's
+      email.
+    `
+		}),
+		"init-author-name": new Definition("init-author-name", {
+			default: "",
+			hint: "<name>",
+			type: String,
+			description: `
+      The value \`npm init\` should use by default for the package author's name.
+    `
+		}),
+		"init-author-url": new Definition("init-author-url", {
+			default: "",
+			type: ["", url],
+			hint: "<url>",
+			description: `
+      The value \`npm init\` should use by default for the package author's homepage.
+    `
+		}),
+		"init-license": new Definition("init-license", {
+			default: "",
+			hint: "<license>",
+			type: String,
+			description: `
+      The value \`npm init\` should use by default for the package license.
+      If not set, the license field will be omitted from new packages.
+    `
+		}),
+		"init-module": new Definition("init-module", {
+			default: "~/.npm-init.js",
+			type: path,
+			hint: "<module>",
+			description: `
+      A module that will be loaded by the \`npm init\` command.  See the
+      documentation for the
+      [init-package-json](https://github.com/npm/init-package-json) module for
+      more information, or [npm init](/commands/npm-init).
+    `
+		}),
+		"init-type": new Definition("init-type", {
+			default: "commonjs",
+			type: String,
+			hint: "<type>",
+			description: `
+      The value that \`npm init\` should use by default for the package.json type field.
+    `
+		}),
+		"init-version": new Definition("init-version", {
+			default: "1.0.0",
+			type: Semver,
+			hint: "<version>",
+			description: `
+      The value that \`npm init\` should use by default for the package
+      version number, if not already set in package.json.
+    `
+		}),
+		"init-private": new Definition("init-private", {
+			default: false,
+			type: Boolean,
+			description: `
+      The value \`npm init\` should use by default for the package's private flag.
+    `,
+			flatten
+		}),
+		"init.author.email": new Definition("init.author.email", {
+			default: "",
+			type: String,
+			deprecated: `
+      Use \`--init-author-email\` instead.`,
+			description: `
+      Alias for \`--init-author-email\`
+    `
+		}),
+		"init.author.name": new Definition("init.author.name", {
+			default: "",
+			type: String,
+			deprecated: `
+      Use \`--init-author-name\` instead.
+    `,
+			description: `
+      Alias for \`--init-author-name\`
+    `
+		}),
+		"init.author.url": new Definition("init.author.url", {
+			default: "",
+			type: ["", url],
+			deprecated: `
+      Use \`--init-author-url\` instead.
+    `,
+			description: `
+      Alias for \`--init-author-url\`
+    `
+		}),
+		"init.license": new Definition("init.license", {
+			default: "",
+			type: String,
+			deprecated: `
+      Use \`--init-license\` instead.
+    `,
+			description: `
+      Alias for \`--init-license\`
+    `
+		}),
+		"init.module": new Definition("init.module", {
+			default: "~/.npm-init.js",
+			type: path,
+			deprecated: `
+      Use \`--init-module\` instead.
+    `,
+			description: `
+      Alias for \`--init-module\`
+    `
+		}),
+		"init.version": new Definition("init.version", {
+			default: "1.0.0",
+			type: Semver,
+			deprecated: `
+      Use \`--init-version\` instead.
+    `,
+			description: `
+      Alias for \`--init-version\`
+    `
+		}),
+		"install-links": new Definition("install-links", {
+			default: false,
+			type: Boolean,
+			description: `
+      When set file: protocol dependencies will be packed and installed as
+      regular dependencies instead of creating a symlink. This option has
+      no effect on workspaces.
+    `,
+			flatten
+		}),
+		"install-strategy": new Definition("install-strategy", {
+			default: "hoisted",
+			type: [
+				"hoisted",
+				"nested",
+				"shallow",
+				"linked"
+			],
+			description: `
+      Sets the strategy for installing packages in node_modules.
+      hoisted (default): Install non-duplicated in top-level, and duplicated as
+        necessary within directory structure.
+      nested: (formerly --legacy-bundling) install in place, no hoisting.
+      shallow (formerly --global-style) only install direct deps at top-level.
+      linked: install in node_modules/.store, link in place, unhoisted.
+
+      We recommend that package authors use \`--install-strategy=linked\`
+      during development to catch undeclared ("phantom") dependencies before
+      publishing: the isolated layout only exposes a package's declared
+      dependencies, so an \`import\` of a package that was never added to
+      \`package.json\` can fail instead of resolving by accident and shipping
+      broken. See [Catching undeclared ("phantom")
+      dependencies](/using-npm/developers#catching-undeclared-phantom-dependencies).
+    `,
+			flatten
+		}),
+		json: new Definition("json", {
+			default: false,
+			type: Boolean,
+			description: `
+      Whether or not to output JSON data, rather than the normal output.
+
+      * In \`npm pkg set\` it enables parsing set values with JSON.parse()
+      before saving them to your \`package.json\`.
+
+      Not supported by all npm commands.
+    `,
+			flatten
+		}),
+		key: new Definition("key", {
+			default: null,
+			type: [null, String],
+			description: `
+      A client key to pass when accessing the registry.  Values should be in
+      PEM format with newlines replaced by the string "\\n". For example:
+
+      \`\`\`ini
+      key="-----BEGIN PRIVATE KEY-----\\nXXXX\\nXXXX\\n-----END PRIVATE KEY-----"
+      \`\`\`
+
+      It is _not_ the path to a key file, though you can set a registry-scoped
+      "keyfile" path like "//other-registry.tld/:keyfile=/path/to/key.pem".
+    `,
+			deprecated: `
+      \`key\` and \`cert\` are no longer used for most registry operations.
+      Use registry scoped \`keyfile\` and \`certfile\` instead.
+      Example:
+      //other-registry.tld/:keyfile=/path/to/key.pem
+      //other-registry.tld/:certfile=/path/to/cert.crt
+    `,
+			flatten
+		}),
+		"legacy-bundling": new Definition("legacy-bundling", {
+			default: false,
+			type: Boolean,
+			description: `
+      Instead of hoisting package installs in \`node_modules\`, install packages
+      in the same manner that they are depended on. This may cause very deep
+      directory structures and duplicate package installs as there is no
+      de-duplicating.
+      Sets \`--install-strategy=nested\`.
+    `,
+			deprecated: `
+      This option has been deprecated in favor of \`--install-strategy=nested\`
+    `,
+			flatten(key, obj, flatOptions) {
+				if (obj[key]) {
+					obj["install-strategy"] = "nested";
+					flatOptions.installStrategy = "nested";
+				}
+			}
+		}),
+		"legacy-peer-deps": new Definition("legacy-peer-deps", {
+			default: false,
+			type: Boolean,
+			description: `
+      Causes npm to completely ignore \`peerDependencies\` when building a
+      package tree, as in npm versions 3 through 6.
+
+      If a package cannot be installed because of overly strict
+      \`peerDependencies\` that collide, it provides a way to move forward
+      resolving the situation.
+
+      This differs from \`--omit=peer\`, in that \`--omit=peer\` will avoid
+      unpacking \`peerDependencies\` on disk, but will still design a tree such
+      that \`peerDependencies\` _could_ be unpacked in a correct place.
+
+      Use of \`legacy-peer-deps\` is not recommended, as it will not enforce
+      the \`peerDependencies\` contract that meta-dependencies may rely on.
+    `,
+			flatten
+		}),
+		libc: new Definition("libc", {
+			default: null,
+			type: [null, String],
+			description: `
+      Override libc of native modules to install.
+      Acceptable values are same as \`libc\` field of package.json
+    `,
+			flatten
+		}),
+		link: new Definition("link", {
+			default: false,
+			type: Boolean,
+			description: `
+      Used with \`npm ls\`, limiting output to only those packages that are
+      linked.
+    `
+		}),
+		"local-address": new Definition("local-address", {
+			default: null,
+			type: getLocalAddresses(),
+			typeDescription: "IP Address",
+			description: `
+      The IP address of the local interface to use when making connections to
+      the npm registry.  Must be IPv4 in versions of Node prior to 0.12.
+    `,
+			flatten
+		}),
+		location: new Definition("location", {
+			default: "user",
+			short: "L",
+			type: [
+				"global",
+				"user",
+				"project"
+			],
+			defaultDescription: `
+      "user" unless \`--global\` is passed, which will also set this value to "global"
+    `,
+			description: `
+      When passed to \`npm config\` this refers to which config file to use.
+
+      When set to "global" mode, packages are installed into the \`prefix\` folder
+      instead of the current working directory. See
+      [folders](/configuring-npm/folders) for more on the differences in behavior.
+
+      * packages are installed into the \`{prefix}/lib/node_modules\` folder,
+        instead of the current working directory.
+      * bin files are linked to \`{prefix}/bin\`
+      * man pages are linked to \`{prefix}/share/man\`
+    `,
+			flatten: (key, obj, flatOptions) => {
+				flatten(key, obj, flatOptions);
+				if (flatOptions.global) flatOptions.location = "global";
+				if (obj.location === "global") flatOptions.global = true;
+			}
+		}),
+		"lockfile-version": new Definition("lockfile-version", {
+			default: null,
+			type: [
+				null,
+				1,
+				2,
+				3,
+				"1",
+				"2",
+				"3"
+			],
+			defaultDescription: `
+      Version 3 if no lockfile, auto-converting v1 lockfiles to v3; otherwise,
+      maintain current lockfile version.`,
+			description: `
+      Set the lockfile format version to be used in package-lock.json files.
+      Possible options are:
+
+      1: The lockfile version used by npm versions 5 and 6.  Lacks some data that
+      is used during the install, resulting in slower and possibly less
+      deterministic installs.  Prevents lockfile churn when interoperating with
+      older npm versions.
+
+      2: The default lockfile version used by npm version 7 and 8.  Includes both
+      the version 1 lockfile data and version 3 lockfile data, for maximum
+      determinism and interoperability, at the expense of more bytes on disk.
+
+      3: Only the new lockfile information introduced in npm version 7.  Smaller
+      on disk than lockfile version 2, but not interoperable with older npm
+      versions.  Ideal if all users are on npm version 7 and higher.
+    `,
+			flatten: (key, obj, flatOptions) => {
+				flatOptions.lockfileVersion = obj[key] && parseInt(obj[key], 10);
+			}
+		}),
+		loglevel: new Definition("loglevel", {
+			default: "notice",
+			type: [
+				"silent",
+				"error",
+				"warn",
+				"notice",
+				"http",
+				"info",
+				"verbose",
+				"silly"
+			],
+			description: `
+      What level of logs to report.  All logs are written to a debug log,
+      with the path to that file printed if the execution of a command fails.
+
+      Any logs of a higher level than the setting are shown. The default is
+      "notice".
+
+      See also the \`foreground-scripts\` config.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.silent = obj[key] === "silent";
+			}
+		}),
+		"logs-dir": new Definition("logs-dir", {
+			default: null,
+			type: [null, path],
+			defaultDescription: `
+      A directory named \`_logs\` inside the cache
+  `,
+			description: `
+      The location of npm's log directory.  See [\`npm
+      logging\`](/using-npm/logging) for more information.
+    `
+		}),
+		"logs-max": new Definition("logs-max", {
+			default: 10,
+			type: Number,
+			description: `
+      The maximum number of log files to store.
+
+      If set to 0, no log files will be written for the current run.
+    `
+		}),
+		long: new Definition("long", {
+			default: false,
+			type: Boolean,
+			short: "l",
+			description: `
+      Show extended information in \`ls\`, \`search\`, and \`help-search\`.
+    `
+		}),
+		name: new Definition("name", {
+			default: null,
+			type: [null, String],
+			hint: "<name>",
+			description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      this sets the name/description for the token.
+    `,
+			flatten
+		}),
+		maxsockets: new Definition("maxsockets", {
+			default: 15,
+			type: Number,
+			description: `
+      The maximum number of connections to use per origin (protocol/host/port
+      combination).
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.maxSockets = obj[key];
+			}
+		}),
+		message: new Definition("message", {
+			default: "%s",
+			type: String,
+			short: "m",
+			description: `
+      Commit message which is used by \`npm version\` when creating version commit.
+
+      Any "%s" in the message will be replaced with the version number.
+    `,
+			flatten
+		}),
+		"min-release-age": new Definition("min-release-age", {
+			default: null,
+			hint: "<days>",
+			type: [null, Number],
+			envExport: false,
+			description: `
+       If set, npm will build the npm tree such that only versions that were
+       available more than the given number of days ago will be installed.  If
+       there are no versions available for the current set of dependencies, the
+       command will error.
+
+       This flag is a complement to \`before\`, which accepts an exact date
+       instead of a relative number of days. The two may coexist (e.g.
+       \`min-release-age\` in your \`.npmrc\` is preserved when npm internally
+       spawns a sub-process with \`--before\` while preparing a \`git:\` or
+       \`github:\` dependency); when both apply, \`before\` wins within a
+       single source and across sources the standard precedence rules apply.
+
+       When this window stops \`npm audit fix\` from installing a patched
+       version (because the fix was published too recently), npm keeps the
+       package at its vulnerable version, warns that the fix was blocked, and
+       exits with a non-zero code. To install the fix, add the package to
+       \`min-release-age-exclude\`, or relax \`min-release-age\` or \`before\`.
+
+       Packages whose names match \`min-release-age-exclude\` are exempt from
+       this filter.
+    `,
+			flatten: (key, obj, flatOptions) => {
+				const age = obj["min-release-age"];
+				if (age != null && !Object.hasOwn(obj, "before")) flatOptions.before = age ? /* @__PURE__ */ new Date(Date.now() - 864e5 * age) : null;
+			}
+		}),
+		"min-release-age-exclude": new Definition("min-release-age-exclude", {
+			default: [],
+			hint: "<pkg|glob>",
+			type: [Array, String],
+			envExport: false,
+			description: `
+       A list of package names or \`minimatch\` glob patterns that are exempt
+       from the \`min-release-age\` (and \`before\`) filter. A matching package
+       can always resolve to its newest version, even when a release-age window
+       is set.
+
+       For example, to apply a release-age window to third-party dependencies
+       while letting internally maintained packages update immediately:
+
+       \`\`\`
+       min-release-age=7
+       min-release-age-exclude[]=@myorg/*
+       min-release-age-exclude[]=my-internal-pkg
+       \`\`\`
+
+       Only the named package is exempt; its own dependencies still follow the
+       release-age policy unless they also match a pattern. Patterns match
+       against the package name, so \`@myorg/*\` matches \`@myorg/shared-utils\`.
+
+       Excluding a package does not change which registry it is fetched from. You
+       should own your private scope on the public registry so that nobody else
+       can publish a package with the same name.
+    `,
+			flatten: (key, obj, flatOptions) => {
+				const list = obj[key].flatMap((v) => String(v).split(",")).map((v) => v.trim()).filter(Boolean);
+				flatOptions.minReleaseAgeExclude = [...new Set(list)];
+			}
+		}),
+		"node-gyp": new Definition("node-gyp", {
+			default: (() => {
+				try {
+					return __require.resolve("node-gyp/bin/node-gyp.js");
+				} catch {
+					return "";
+				}
+			})(),
+			defaultDescription: `
+      The path to the node-gyp bin that ships with npm
+    `,
+			type: path,
+			description: `
+      This is the location of the "node-gyp" bin.  By default it uses one that ships with npm itself.
+
+      You can use this config to specify your own "node-gyp" to run when it is required to build a package.
+    `,
+			flatten
+		}),
+		"node-options": new Definition("node-options", {
+			default: null,
+			type: [null, String],
+			description: `
+      Options to pass through to Node.js via the \`NODE_OPTIONS\` environment
+      variable.  This does not impact how npm itself is executed but it does
+      impact how lifecycle scripts are called.
+    `
+		}),
+		noproxy: new Definition("noproxy", {
+			default: "",
+			defaultDescription: `
+      The value of the NO_PROXY environment variable
+    `,
+			type: [String, Array],
+			description: `
+      Domain extensions that should bypass any proxies.
+
+      Also accepts a comma-delimited string.
+    `,
+			flatten(key, obj, flatOptions) {
+				if (Array.isArray(obj[key])) flatOptions.noProxy = obj[key].join(",");
+				else flatOptions.noProxy = obj[key];
+			}
+		}),
+		offline: new Definition("offline", {
+			default: false,
+			type: Boolean,
+			description: `
+      Force offline mode: no network requests will be done during install. To allow
+      the CLI to fill in missing cache data, see \`--prefer-offline\`.
+    `,
+			flatten
+		}),
+		omit: new Definition("omit", {
+			default: process.env.NODE_ENV === "production" ? ["dev"] : [],
+			defaultDescription: `
+      'dev' if the \`NODE_ENV\` environment variable is set to 'production';
+      otherwise, empty.
+    `,
+			type: [
+				Array,
+				"dev",
+				"optional",
+				"peer"
+			],
+			description: `
+      Dependency types to omit from the installation tree on disk.
+
+      Note that these dependencies _are_ still resolved and added to the
+      \`package-lock.json\` file.  They are just
+      not physically installed on disk.
+
+      If a package type appears in both the \`--include\` and \`--omit\`
+      lists, then it will be included.
+
+      If the resulting omit list includes \`'dev'\`, then the \`NODE_ENV\`
+      environment variable will be set to \`'production'\` for all lifecycle
+      scripts.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.omit = buildOmitList(obj);
+			}
+		}),
+		"omit-lockfile-registry-resolved": new Definition("omit-lockfile-registry-resolved", {
+			default: false,
+			type: Boolean,
+			description: `
+      This option causes npm to create lock files without a \`resolved\` key for
+      registry dependencies. Subsequent installs will need to resolve tarball
+      endpoints with the configured registry, likely resulting in a longer install
+      time.
+    `,
+			flatten
+		}),
+		only: new Definition("only", {
+			default: null,
+			type: [
+				null,
+				"prod",
+				"production"
+			],
+			deprecated: `
+      Use \`--omit=dev\` to omit dev dependencies from the install.
+    `,
+			description: `
+      When set to \`prod\` or \`production\`, this is an alias for
+      \`--omit=dev\`.
+    `,
+			flatten(key, obj, flatOptions) {
+				definitions.omit.flatten("omit", obj, flatOptions);
+			}
+		}),
+		orgs: new Definition("orgs", {
+			default: null,
+			type: [
+				null,
+				String,
+				Array
+			],
+			description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      this limits the token access to specific organizations.
+    `,
+			flatten
+		}),
+		optional: new Definition("optional", {
+			default: null,
+			type: [null, Boolean],
+			deprecated: `
+      Use \`--omit=optional\` to exclude optional dependencies, or
+      \`--include=optional\` to include them.
+
+      Default value does install optional deps unless otherwise omitted.
+    `,
+			description: `
+      Alias for --include=optional or --omit=optional
+    `,
+			flatten(key, obj, flatOptions) {
+				definitions.omit.flatten("omit", obj, flatOptions);
+			}
+		}),
+		os: new Definition("os", {
+			default: null,
+			type: [null, String],
+			description: `
+      Override OS of native modules to install.
+      Acceptable values are same as \`os\` field of package.json,
+      which comes from \`process.platform\`.
+    `,
+			flatten
+		}),
+		otp: new Definition("otp", {
+			default: null,
+			type: [null, String],
+			description: `
+      This is a one-time password from a two-factor authenticator.  It's needed
+      when publishing or changing package permissions with \`npm access\`.
+
+      If not set, and a registry response fails with a challenge for a one-time
+      password, npm will prompt on the command line for one.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatten(key, obj, flatOptions);
+				if (obj.otp) {
+					obj["auth-type"] = "legacy";
+					flatten("auth-type", obj, flatOptions);
+				}
+			}
+		}),
+		package: new Definition("package", {
+			default: [],
+			hint: "<package-spec>",
+			type: [String, Array],
+			description: `
+      The package or packages to install for [\`npm exec\`](/commands/npm-exec)
+    `,
+			flatten
+		}),
+		"package-lock": new Definition("package-lock", {
+			default: true,
+			type: Boolean,
+			description: `
+      If set to false, then ignore \`package-lock.json\` files when installing.
+      This will also prevent _writing_ \`package-lock.json\` if \`save\` is
+      true.
+    `,
+			flatten: (key, obj, flatOptions) => {
+				flatten(key, obj, flatOptions);
+				if (flatOptions.packageLockOnly) flatOptions.packageLock = true;
+			}
+		}),
+		"package-lock-only": new Definition("package-lock-only", {
+			default: false,
+			type: Boolean,
+			description: `
+      If set to true, the current operation will only use the \`package-lock.json\`,
+      ignoring \`node_modules\`.
+
+      For \`update\` this means only the \`package-lock.json\` will be updated,
+      instead of checking \`node_modules\` and downloading dependencies.
+
+      For \`list\` this means the output will be based on the tree described by the
+      \`package-lock.json\`, rather than the contents of \`node_modules\`.
+    `,
+			flatten: (key, obj, flatOptions) => {
+				flatten(key, obj, flatOptions);
+				if (flatOptions.packageLockOnly) flatOptions.packageLock = true;
+			}
+		}),
+		"pack-destination": new Definition("pack-destination", {
+			default: ".",
+			type: String,
+			description: `
+      Directory in which \`npm pack\` will save tarballs.
+    `,
+			flatten
+		}),
+		packages: new Definition("packages", {
+			default: [],
+			type: [
+				null,
+				String,
+				Array
+			],
+			description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      this limits the token access to specific packages.
+    `,
+			flatten
+		}),
+		"patches-dir": new Definition("patches-dir", {
+			default: "patches",
+			type: String,
+			description: `
+      The directory, relative to the project root, where \`npm patch commit\`
+      writes patch files for \`patchedDependencies\`.
+    `,
+			flatten
+		}),
+		"allow-unused-patches": new Definition("allow-unused-patches", {
+			default: false,
+			type: Boolean,
+			description: `
+      Install even when a registered patch in \`patchedDependencies\` matches no
+      installed package. Does not silence patch apply failures.
+
+      This flag is only honored when passed on the command line; it is ignored
+      in \`.npmrc\` and environment variables, and rejected by \`npm ci\`.
+    `
+		}),
+		"ignore-patch-failures": new Definition("ignore-patch-failures", {
+			default: false,
+			type: Boolean,
+			description: `
+      Install even when a registered patch fails to apply, with a warning per
+      failure. Intended for incident response only.
+
+      This flag is only honored when passed on the command line; it is ignored
+      in \`.npmrc\` and environment variables, and rejected by \`npm ci\`.
+    `
+		}),
+		"edit-dir": new Definition("edit-dir", {
+			default: null,
+			type: [null, path],
+			description: `
+      Override the temporary directory used by \`npm patch add\` to prepare a
+      package for editing.
+    `
+		}),
+		"ignore-existing": new Definition("ignore-existing", {
+			default: false,
+			type: Boolean,
+			description: `
+      With \`npm patch add\`, discard a previous unfinished edit directory and
+      start fresh.
+    `
+		}),
+		"keep-edit-dir": new Definition("keep-edit-dir", {
+			default: false,
+			type: Boolean,
+			description: `
+      With \`npm patch commit\`, do not remove the edit directory after
+      committing the patch.
+    `
+		}),
+		parseable: new Definition("parseable", {
+			default: false,
+			type: Boolean,
+			short: "p",
+			description: `
+      Output parseable results from commands that write to standard output. For
+      \`npm search\`, this will be tab-separated table format.
+    `,
+			flatten
+		}),
+		"allow-scripts-pending": new Definition("allow-scripts-pending", {
+			default: false,
+			type: Boolean,
+			description: `
+      List packages with install scripts that are not yet covered by the
+      \`allowScripts\` policy, without modifying \`package.json\`. Only
+      meaningful for \`npm approve-scripts\`.
+    `,
+			flatten
+		}),
+		"allow-scripts-pin": new Definition("allow-scripts-pin", {
+			default: true,
+			type: Boolean,
+			description: `
+      Write pinned (\`pkg@version\`) entries when approving install scripts.
+      Set to \`false\` to write name-only entries that allow any version.
+      Has no effect on \`npm deny-scripts\`, which always writes name-only
+      entries regardless of this setting.
+    `,
+			flatten
+		}),
+		"prefer-dedupe": new Definition("prefer-dedupe", {
+			default: false,
+			type: Boolean,
+			description: `
+      Prefer to deduplicate packages if possible, rather than
+      choosing a newer version of a dependency.
+    `,
+			flatten
+		}),
+		"prefer-offline": new Definition("prefer-offline", {
+			default: false,
+			type: Boolean,
+			description: `
+      If true, staleness checks for cached data will be bypassed, but missing
+      data will be requested from the server. To force full offline mode, use
+      \`--offline\`.
+    `,
+			flatten
+		}),
+		"prefer-online": new Definition("prefer-online", {
+			default: false,
+			type: Boolean,
+			description: `
+      If true, staleness checks for cached data will be forced, making the CLI
+      look for updates immediately even for fresh package data.
+    `,
+			flatten
+		}),
+		prefix: new Definition("prefix", {
+			type: path,
+			short: "C",
+			default: "",
+			defaultDescription: `
+      In global mode, the folder where the node executable is installed.
+      Otherwise, the nearest parent folder containing either a package.json
+      file or a node_modules folder.
+    `,
+			description: `
+      The location to install global items.  If set on the command line, then
+      it forces non-global commands to run in the specified folder.
+    `
+		}),
+		preid: new Definition("preid", {
+			default: "",
+			hint: "prerelease-id",
+			type: String,
+			description: `
+      The "prerelease identifier" to use as a prefix for the "prerelease" part
+      of a semver. Like the \`rc\` in \`1.2.0-rc.8\`.
+    `,
+			flatten
+		}),
+		production: new Definition("production", {
+			default: null,
+			type: [null, Boolean],
+			deprecated: "Use `--omit=dev` instead.",
+			description: "Alias for `--omit=dev`",
+			flatten(key, obj, flatOptions) {
+				definitions.omit.flatten("omit", obj, flatOptions);
+			}
+		}),
+		progress: new Definition("progress", {
+			default: !(ciInfo.isCI || !process.stderr.isTTY || !process.stdout.isTTY || process.env.TERM === "dumb"),
+			defaultDescription: `
+      \`true\` when not in CI and both stderr and stdout are TTYs and not in a dumb terminal
+    `,
+			type: Boolean,
+			description: `
+      When set to \`true\`, npm will display a progress bar during time
+      intensive operations, if \`process.stderr\` and \`process.stdout\` are a TTY.
+
+      Set to \`false\` to suppress the progress bar.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.progress = !!obj.progress && !!process.stderr.isTTY && !!process.stdout.isTTY && process.env.TERM !== "dumb";
+			}
+		}),
+		provenance: new Definition("provenance", {
+			default: false,
+			type: Boolean,
+			exclusive: ["provenance-file"],
+			description: `
+      When publishing from a supported cloud CI/CD system, the package will be
+      publicly linked to where it was built and published from.
+    `,
+			flatten
+		}),
+		"provenance-file": new Definition("provenance-file", {
+			default: null,
+			type: path,
+			hint: "<file>",
+			exclusive: ["provenance"],
+			description: `
+      When publishing, the provenance bundle at the given path will be used.
+    `,
+			flatten
+		}),
+		proxy: new Definition("proxy", {
+			default: null,
+			type: [
+				null,
+				false,
+				url
+			],
+			description: `
+      A proxy to use for outgoing http requests. If the \`HTTP_PROXY\` or
+      \`http_proxy\` environment variables are set, proxy settings will be
+      honored by the underlying \`request\` library.
+    `,
+			flatten
+		}),
+		"read-only": new Definition("read-only", {
+			default: false,
+			type: Boolean,
+			description: `
+      This is used to mark a token as unable to publish when configuring
+      limited access tokens with the \`npm token create\` command.
+    `,
+			flatten
+		}),
+		"rebuild-bundle": new Definition("rebuild-bundle", {
+			default: true,
+			type: Boolean,
+			description: `
+      Rebuild bundled dependencies after installation.
+    `,
+			flatten
+		}),
+		registry: new Definition("registry", {
+			default: "https://registry.npmjs.org/",
+			type: url,
+			description: `
+      The base URL of the npm registry.
+    `,
+			flatten
+		}),
+		"replace-registry-host": new Definition("replace-registry-host", {
+			default: "npmjs",
+			hint: "<npmjs|never|always> | hostname | url",
+			type: [
+				"npmjs",
+				"never",
+				"always",
+				String
+			],
+			description: `
+      Defines behavior for replacing the registry host in a lockfile with the
+      configured registry.
+
+      The default behavior is to replace package dist URLs from the default
+      registry (https://registry.npmjs.org) to the configured registry. If set to
+      "never", then use the registry value. If set to "always", then replace the
+      registry host with the configured host every time.
+
+      You may also specify a bare hostname (e.g., "registry.npmjs.org") to only
+      replace URLs coming from that host.
+
+      You may also specify a full URL including a path (e.g.,
+      "https://old-registry.example.com/npm/path"). In that case, resolved URLs
+      whose host and path begin with that prefix will have the entire prefix
+      replaced with the configured registry URL (host and path), without
+      duplicating path segments.
+    `,
+			flatten
+		}),
+		save: new Definition("save", {
+			default: true,
+			defaultDescription: `\`true\` unless when using \`npm update\` where it
+    defaults to \`false\``,
+			usage: "-S|--save|--no-save|--save-prod|--save-dev|--save-optional|--save-peer|--save-bundle",
+			type: Boolean,
+			short: "S",
+			description: `
+      Save installed packages to a \`package.json\` file as dependencies.
+
+      When used with the \`npm rm\` command, removes the dependency from
+      \`package.json\`.
+
+      Will also prevent writing to \`package-lock.json\` if set to \`false\`.
+    `,
+			flatten
+		}),
+		"save-bundle": new Definition("save-bundle", {
+			default: false,
+			type: Boolean,
+			short: "B",
+			description: `
+      If a package would be saved at install time by the use of \`--save\`,
+      \`--save-dev\`, or \`--save-optional\`, then also put it in the
+      \`bundleDependencies\` list.
+
+      Ignored if \`--save-peer\` is set, since peerDependencies cannot be bundled.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.saveBundle = obj["save-bundle"] && !obj["save-peer"];
+			}
+		}),
+		"save-dev": new Definition("save-dev", {
+			default: false,
+			type: Boolean,
+			short: "D",
+			exclusive: [
+				"save-optional",
+				"save-peer",
+				"save-prod"
+			],
+			description: `
+      Save installed packages to a package.json file as \`devDependencies\`.
+    `,
+			flatten(key, obj, flatOptions) {
+				if (!obj[key]) {
+					if (flatOptions.saveType === "dev") delete flatOptions.saveType;
+					return;
+				}
+				flatOptions.saveType = "dev";
+			}
+		}),
+		"save-exact": new Definition("save-exact", {
+			default: false,
+			type: Boolean,
+			short: "E",
+			description: `
+      Dependencies saved to package.json will be configured with an exact
+      version rather than using npm's default semver range operator.
+    `,
+			flatten(key, obj, flatOptions) {
+				definitions["save-prefix"].flatten("save-prefix", obj, flatOptions);
+			}
+		}),
+		"save-optional": new Definition("save-optional", {
+			default: false,
+			type: Boolean,
+			short: "O",
+			exclusive: [
+				"save-dev",
+				"save-peer",
+				"save-prod"
+			],
+			description: `
+      Save installed packages to a package.json file as
+      \`optionalDependencies\`.
+    `,
+			flatten(key, obj, flatOptions) {
+				if (!obj[key]) {
+					if (flatOptions.saveType === "optional") delete flatOptions.saveType;
+					else if (flatOptions.saveType === "peerOptional") flatOptions.saveType = "peer";
+					return;
+				}
+				if (flatOptions.saveType === "peerOptional") return;
+				if (flatOptions.saveType === "peer") flatOptions.saveType = "peerOptional";
+				else flatOptions.saveType = "optional";
+			}
+		}),
+		"save-peer": new Definition("save-peer", {
+			default: false,
+			type: Boolean,
+			exclusive: [
+				"save-dev",
+				"save-optional",
+				"save-prod"
+			],
+			description: `
+      Save installed packages to a package.json file as \`peerDependencies\`
+    `,
+			flatten(key, obj, flatOptions) {
+				if (!obj[key]) {
+					if (flatOptions.saveType === "peer") delete flatOptions.saveType;
+					else if (flatOptions.saveType === "peerOptional") flatOptions.saveType = "optional";
+					return;
+				}
+				if (flatOptions.saveType === "peerOptional") return;
+				if (flatOptions.saveType === "optional") flatOptions.saveType = "peerOptional";
+				else flatOptions.saveType = "peer";
+			}
+		}),
+		"save-prefix": new Definition("save-prefix", {
+			default: "^",
+			type: String,
+			description: `
+      Configure how versions of packages installed to a package.json file via
+      \`--save\` or \`--save-dev\` get prefixed.
+
+      For example if a package has version \`1.2.3\`, by default its version is
+      set to \`^1.2.3\` which allows minor upgrades for that package, but after
+      \`npm config set save-prefix='~'\` it would be set to \`~1.2.3\` which
+      only allows patch upgrades.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.savePrefix = obj["save-exact"] ? "" : obj["save-prefix"];
+				obj["save-prefix"] = flatOptions.savePrefix;
+			}
+		}),
+		"save-prod": new Definition("save-prod", {
+			default: false,
+			type: Boolean,
+			short: "P",
+			exclusive: [
+				"save-dev",
+				"save-optional",
+				"save-peer"
+			],
+			description: `
+      Save installed packages into \`dependencies\` specifically. This is
+      useful if a package already exists in \`devDependencies\` or
+      \`optionalDependencies\`, but you want to move it to be a non-optional
+      production dependency.
+
+      This is the default behavior if \`--save\` is true, and neither
+      \`--save-dev\` or \`--save-optional\` are true.
+    `,
+			flatten(key, obj, flatOptions) {
+				if (!obj[key]) {
+					if (flatOptions.saveType === "prod") delete flatOptions.saveType;
+					return;
+				}
+				flatOptions.saveType = "prod";
+			}
+		}),
+		"sbom-format": new Definition("sbom-format", {
+			default: null,
+			type: ["cyclonedx", "spdx"],
+			description: `
+      SBOM format to use when generating SBOMs.
+    `,
+			flatten
+		}),
+		"sbom-type": new Definition("sbom-type", {
+			default: "library",
+			type: [
+				"library",
+				"application",
+				"framework"
+			],
+			description: `
+      The type of package described by the generated SBOM. For SPDX, this is the
+      value for the \`primaryPackagePurpose\` field. For CycloneDX, this is the
+      value for the \`type\` field.
+    `,
+			flatten
+		}),
+		scope: new Definition("scope", {
+			default: "",
+			defaultDescription: `
+      the scope of the current project, if any, or ""
+    `,
+			type: String,
+			hint: "<@scope>",
+			description: `
+      Associate an operation with a scope for a scoped registry.
+
+      Useful when logging in to or out of a private registry:
+
+      \`\`\`
+      # log in, linking the scope to the custom registry
+      npm login --scope=@mycorp --registry=https://registry.mycorp.com
+
+      # log out, removing the link and the auth token
+      npm logout --scope=@mycorp
+      \`\`\`
+
+      This will cause \`@mycorp\` to be mapped to the registry for future
+      installation of packages specified according to the pattern
+      \`@mycorp/package\`.
+
+      This will also cause \`npm init\` to create a scoped package.
+
+      \`\`\`
+      # accept all defaults, and create a package named "@foo/whatever",
+      # instead of just named "whatever"
+      npm init --scope=@foo --yes
+      \`\`\`
+    `,
+			flatten(key, obj, flatOptions) {
+				const value = obj[key];
+				const scope = value && !/^@/.test(value) ? `@${value}` : value;
+				flatOptions.scope = scope;
+				flatOptions.projectScope = scope;
+			}
+		}),
+		scopes: new Definition("scopes", {
+			default: null,
+			type: [
+				null,
+				String,
+				Array
+			],
+			description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      this limits the token access to specific scopes. Provide
+      a scope name (with or without @ prefix).
+    `,
+			flatten
+		}),
+		"packages-all": new Definition("packages-all", {
+			default: false,
+			type: Boolean,
+			description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      grants the token access to all packages instead of limiting to
+      specific packages.
+    `,
+			flatten
+		}),
+		"packages-and-scopes-permission": new Definition("packages-and-scopes-permission", {
+			default: null,
+			type: [
+				null,
+				"read-only",
+				"read-write",
+				"no-access"
+			],
+			description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      sets the permission level for packages and scopes. Options are
+      "read-only", "read-write", or "no-access".
+    `,
+			flatten
+		}),
+		"orgs-permission": new Definition("orgs-permission", {
+			default: null,
+			type: [
+				null,
+				"read-only",
+				"read-write",
+				"no-access"
+			],
+			description: `
+      When creating a Granular Access Token with \`npm token create\`,
+      sets the permission level for organizations. Options are
+      "read-only", "read-write", or "no-access".
+    `,
+			flatten
+		}),
+		password: new Definition("password", {
+			default: null,
+			type: [null, String],
+			description: `
+      Password for authentication. Can be provided via command line when
+      creating tokens, though it's generally safer to be prompted for it.
+    `,
+			flatten
+		}),
+		"token-description": new Definition("token-description", {
+			default: null,
+			type: [null, String],
+			description: `
+      Description text for the token when using \`npm token create\`.
+    `,
+			flatten
+		}),
+		"script-shell": new Definition("script-shell", {
+			default: null,
+			defaultDescription: `
+      '/bin/sh' on POSIX systems, 'cmd.exe' on Windows
+    `,
+			type: [null, String],
+			description: `
+      The shell to use for scripts run with the \`npm exec\`,
+      \`npm run\` and \`npm init <package-spec>\` commands.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.scriptShell = obj[key] || void 0;
+			}
+		}),
+		searchexclude: new Definition("searchexclude", {
+			default: "",
+			type: String,
+			description: `
+      Space-separated options that limit the results from search.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.search = flatOptions.search || { limit: 20 };
+				flatOptions.search.exclude = obj[key].toLowerCase();
+			}
+		}),
+		searchlimit: new Definition("searchlimit", {
+			default: 20,
+			type: Number,
+			description: `
+      Number of items to limit search results to. Will not apply at all to
+      legacy searches.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.search = flatOptions.search || {};
+				flatOptions.search.limit = obj[key];
+			}
+		}),
+		searchopts: new Definition("searchopts", {
+			default: "",
+			type: String,
+			description: `
+      Space-separated options that are always passed to search.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.search = flatOptions.search || { limit: 20 };
+				flatOptions.search.opts = querystring.parse(obj[key]);
+			}
+		}),
+		searchstaleness: new Definition("searchstaleness", {
+			default: 900,
+			type: Number,
+			description: `
+      The age of the cache, in seconds, before another registry request is made
+      if using legacy search endpoint.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.search = flatOptions.search || { limit: 20 };
+				flatOptions.search.staleness = obj[key];
+			}
+		}),
+		shell: new Definition("shell", {
+			default: shell,
+			defaultDescription: `
+      SHELL environment variable, or "bash" on Posix, or "cmd.exe" on Windows
+    `,
+			type: String,
+			description: `
+      The shell to run for the \`npm explore\` command.
+    `,
+			flatten
+		}),
+		"sign-git-commit": new Definition("sign-git-commit", {
+			default: false,
+			type: Boolean,
+			description: `
+      If set to true, then the \`npm version\` command will commit the new
+      package version using \`-S\` to add a signature.
+
+      Note that git requires you to have set up GPG keys in your git configs
+      for this to work properly.
+    `,
+			flatten
+		}),
+		"sign-git-tag": new Definition("sign-git-tag", {
+			default: false,
+			type: Boolean,
+			description: `
+      If set to true, then the \`npm version\` command will tag the version
+      using \`-s\` to add a signature.
+
+      Note that git requires you to have set up GPG keys in your git configs
+      for this to work properly.
+    `,
+			flatten
+		}),
+		"strict-peer-deps": new Definition("strict-peer-deps", {
+			default: false,
+			type: Boolean,
+			description: `
+      If set to \`true\`, and \`--legacy-peer-deps\` is not set, then _any_
+      conflicting \`peerDependencies\` will be treated as an install failure,
+      even if npm could reasonably guess the appropriate resolution based on
+      non-peer dependency relationships.
+
+      By default, conflicting \`peerDependencies\` deep in the dependency graph
+      will be resolved using the nearest non-peer dependency specification,
+      even if doing so will result in some packages receiving a peer dependency
+      outside the range set in their package's \`peerDependencies\` object.
+
+      When such an override is performed, a warning is printed, explaining the
+      conflict and the packages involved.  If \`--strict-peer-deps\` is set,
+      then this warning is treated as a failure.
+    `,
+			flatten
+		}),
+		"strict-allow-scripts": new Definition("strict-allow-scripts", {
+			default: false,
+			type: Boolean,
+			description: `
+      If \`true\`, turn the install-script policy from a warning into a hard
+      error: any dependency with install scripts that is not covered by
+      \`allowScripts\` will fail the install instead of being blocked with a
+      warning.
+
+      Dependencies explicitly denied with \`false\` in \`allowScripts\` are
+      always silently skipped; this setting only affects unreviewed entries
+      (packages with install scripts that are neither approved nor denied).
+      \`--ignore-scripts\` and \`--dangerously-allow-all-scripts\` both
+      override this setting.
+
+      Optional dependencies that cannot be installed on the current platform
+      or engine (a non-matching \`os\`, \`cpu\`, or \`libc\`) are not flagged,
+      because their install scripts never run.
+    `,
+			flatten
+		}),
+		"strict-npmrc": new Definition("strict-npmrc", {
+			default: false,
+			type: Boolean,
+			description: `
+      If set to \`true\`, unknown configuration keys found in \`.npmrc\` files
+      are treated as a hard error instead of a warning.
+
+      Unknown command line flags and abbreviated flags always error regardless
+      of this setting.
+    `,
+			flatten
+		}),
+		"strict-ssl": new Definition("strict-ssl", {
+			default: true,
+			type: Boolean,
+			description: `
+      Whether or not to do SSL key validation when making requests to the
+      registry via https.
+
+      See also the \`ca\` config.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.strictSSL = obj[key];
+			}
+		}),
+		tag: new Definition("tag", {
+			default: "latest",
+			type: String,
+			description: `
+      If you ask npm to install a package and don't tell it a specific version,
+      then it will install the specified tag.
+
+      It is the tag added to the package@version specified in the
+      \`npm dist-tag add\` command, if no explicit tag is given.
+
+      When used by the \`npm diff\` command, this is the tag used to fetch the
+      tarball that will be compared with the local files by default.
+
+      If used in the \`npm publish\` command, this is the tag that will be
+      added to the package submitted to the registry.
+    `,
+			flatten(key, obj, flatOptions) {
+				flatOptions.defaultTag = obj[key];
+			}
+		}),
+		"tag-version-prefix": new Definition("tag-version-prefix", {
+			default: "v",
+			type: String,
+			description: `
+      If set, alters the prefix used when tagging a new version when performing
+      a version increment using  \`npm version\`. To remove the prefix
+      altogether, set it to the empty string: \`""\`.
+
+      Because other tools may rely on the convention that npm version tags look
+      like \`v1.0.0\`, _only use this property if it is absolutely necessary_.
+      In particular, use care when overriding this setting for public packages.
+    `,
+			flatten
+		}),
+		timing: new Definition("timing", {
+			default: false,
+			type: Boolean,
+			description: `
+      If true, writes timing information to a process specific json file in
+      the cache or \`logs-dir\`. The file name ends with \`-timing.json\`.
+
+      You can quickly view it with this [json](https://npm.im/json) command
+      line: \`cat ~/.npm/_logs/*-timing.json | npm exec -- json -g\`.
+
+      Timing information will also be reported in the terminal. To suppress this
+      while still writing the timing file, use \`--silent\`.
+    `
+		}),
+		to: new Definition("to", {
+			default: null,
+			hint: "<version>",
+			type: [null, String],
+			description: `
+      Used by \`npm patch update\` to set the version to rebase a patch onto
+      when it cannot be read from \`package-lock.json\` — for example an
+      exact-version selector, or a version that has not been installed yet.
+    `
+		}),
+		umask: new Definition("umask", {
+			default: 0,
+			type: Umask,
+			description: `
+      The "umask" value to use when setting the file creation mode on files and
+      folders.
+
+      Folders and executables are given a mode which is \`0o777\` masked
+      against this value.  Other files are given a mode which is \`0o666\`
+      masked against this value.
+
+      Note that the underlying system will _also_ apply its own umask value to
+      files and folders that are created, and npm does not circumvent this, but
+      rather adds the \`--umask\` config to it.
+
+      Thus, the effective default umask value on most POSIX systems is 0o22,
+      meaning that folders and executables are created with a mode of 0o755 and
+      other files are created with a mode of 0o644.
+    `,
+			flatten
+		}),
+		unicode: new Definition("unicode", {
+			default: unicode,
+			defaultDescription: `
+      false on windows, true on mac/unix systems with a unicode locale, as
+      defined by the \`LC_ALL\`, \`LC_CTYPE\`, or \`LANG\` environment variables.
+    `,
+			type: Boolean,
+			description: `
+      When set to true, npm uses unicode characters in the tree output.  When
+      false, it uses ascii characters instead of unicode glyphs.
+    `,
+			flatten
+		}),
+		"update-notifier": new Definition("update-notifier", {
+			default: true,
+			type: Boolean,
+			description: `
+      Set to false to suppress the update notification when using an older
+      version of npm than the latest.
+    `
+		}),
+		usage: new Definition("usage", {
+			default: false,
+			type: Boolean,
+			short: [
+				"?",
+				"H",
+				"h"
+			],
+			description: `
+      Show short usage output about the command specified.
+    `
+		}),
+		"user-agent": new Definition("user-agent", {
+			default: "npm/{npm-version} node/{node-version} {platform} {arch} workspaces/{workspaces} {ci}",
+			type: String,
+			description: `
+      Sets the User-Agent request header.  The following fields are replaced
+      with their actual counterparts:
+
+      * \`{npm-version}\` - The npm version in use
+      * \`{node-version}\` - The Node.js version in use
+      * \`{platform}\` - The value of \`process.platform\`
+      * \`{arch}\` - The value of \`process.arch\`
+      * \`{workspaces}\` - Set to \`true\` if the \`workspaces\` or \`workspace\`
+        options are set.
+      * \`{ci}\` - The value of the \`ci-name\` config, if set, prefixed with
+        \`ci/\`, or an empty string if \`ci-name\` is empty.
+    `,
+			flatten(key, obj, flatOptions) {
+				const value = obj[key];
+				const ciName = ciInfo.name?.toLowerCase().split(" ").join("-") || null;
+				let subCiName = null;
+				if (ciInfo.GITHUB_ACTIONS) {
+					const serverUrl = (process.env.GITHUB_SERVER_URL || "").trim();
+					const runnerEnv = (process.env.RUNNER_ENVIRONMENT || "").trim();
+					let serverHost = "";
+					try {
+						serverHost = new URL(serverUrl).hostname.toLowerCase();
+					} catch {
+						serverHost = "";
+					}
+					if (serverHost === "github.com") {
+						if (runnerEnv === "github-hosted") subCiName = "dotcom-hosted";
+						else if (runnerEnv === "self-hosted") subCiName = "dotcom-selfhosted";
+						else subCiName = "dotcom";
+					} else if (serverHost === "ghe.com" || serverHost.endsWith(".ghe.com")) subCiName = "ghecom";
+					else if (serverHost) subCiName = "ghes";
+				}
+				const ci = ciName ? `ci/${ciName}${subCiName ? `/${subCiName}` : ""}` : "";
+				let inWorkspaces = false;
+				if (obj.workspaces || obj.workspace && obj.workspace.length) inWorkspaces = true;
+				flatOptions.userAgent = value.replace(/\{node-version\}/gi, process.version).replace(/\{npm-version\}/gi, obj["npm-version"]).replace(/\{platform\}/gi, process.platform).replace(/\{arch\}/gi, process.arch).replace(/\{workspaces\}/gi, inWorkspaces).replace(/\{ci\}/gi, ci).trim();
+				process.env.npm_config_user_agent = flatOptions.userAgent;
+			}
+		}),
+		userconfig: new Definition("userconfig", {
+			default: "~/.npmrc",
+			type: path,
+			description: `
+      The location of user-level configuration settings.
+
+      This may be overridden by the \`npm_config_userconfig\` environment
+      variable or the \`--userconfig\` command line option, but may _not_
+      be overridden by settings in the \`globalconfig\` file.
+    `
+		}),
+		version: new Definition("version", {
+			default: false,
+			type: Boolean,
+			short: "v",
+			description: `
+      If true, output the npm version and exit successfully.
+
+      Only relevant when specified explicitly on the command line.
+    `
+		}),
+		versions: new Definition("versions", {
+			default: false,
+			type: Boolean,
+			description: `
+      If true, output the npm version as well as node's \`process.versions\`
+      map and the version in the current working directory's \`package.json\`
+      file if one exists, and exit successfully.
+
+      Only relevant when specified explicitly on the command line.
+    `
+		}),
+		viewer: new Definition("viewer", {
+			default: isWindows ? "browser" : "man",
+			defaultDescription: `
+      "man" on Posix, "browser" on Windows
+    `,
+			type: String,
+			description: `
+      The program to use to view help content.
+
+      Set to \`"browser"\` to view html help content in the default web browser.
+    `
+		}),
+		which: new Definition("which", {
+			default: null,
+			hint: "<fundingSourceNumber>",
+			type: [null, Number],
+			description: `
+      If there are multiple funding sources, which 1-indexed source URL to open.
+    `
+		}),
+		workspace: new Definition("workspace", {
+			default: [],
+			type: [String, Array],
+			hint: "<workspace-name>",
+			short: "w",
+			envExport: false,
+			description: `
+      Enable running a command in the context of the configured workspaces of the
+      current project while filtering by running only the workspaces defined by
+      this configuration option.
+
+      Valid values for the \`workspace\` config are either:
+
+      * Workspace names
+      * Path to a workspace directory
+      * Path to a parent workspace directory (will result in selecting all
+        workspaces within that folder)
+
+      When set for the \`npm init\` command, this may be set to the folder of
+      a workspace which does not yet exist, to create the folder and set it
+      up as a brand new workspace within the project.
+    `,
+			flatten: (key, obj, flatOptions) => {
+				definitions["user-agent"].flatten("user-agent", obj, flatOptions);
+			}
+		}),
+		workspaces: new Definition("workspaces", {
+			default: null,
+			type: [null, Boolean],
+			envExport: false,
+			description: `
+      Set to true to run the command in the context of **all** configured
+      workspaces.
+
+      Explicitly setting this to false will cause commands like \`install\` to
+      ignore workspaces altogether.
+      When not set explicitly:
+
+      - Commands that operate on the \`node_modules\` tree (install, update,
+        etc.) will link workspaces into the \`node_modules\` folder.
+      - Commands that do other things (test, exec, publish, etc.) will operate
+        on the root project, _unless_ one or more workspaces are specified in
+        the \`workspace\` config.
+    `,
+			flatten: (key, obj, flatOptions) => {
+				definitions["user-agent"].flatten("user-agent", obj, flatOptions);
+				flatOptions.workspacesEnabled = obj[key] !== false;
+			}
+		}),
+		"workspaces-update": new Definition("workspaces-update", {
+			default: true,
+			type: Boolean,
+			description: `
+      If set to true, the npm cli will run an update after operations that may
+      possibly change the workspaces installed to the \`node_modules\` folder.
+    `,
+			flatten
+		}),
+		yes: new Definition("yes", {
+			default: null,
+			type: [null, Boolean],
+			short: "y",
+			description: `
+      Automatically answer "yes" to any prompts that npm might print on
+      the command line.
+    `
+		})
+	};
+	module.exports = definitions;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@npmcli+config@11.0.1/node_modules/@npmcli/config/lib/definitions/index.js
+var require_definitions = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const definitions = require_definitions$1();
+	const flatten = (obj, flat = {}) => {
+		for (const [key, val] of Object.entries(obj)) {
+			const def = definitions[key];
+			if (def && def.flatten) def.flatten(key, obj, flat);
+			else if (/@.*:registry$/i.test(key) || /^\/\//.test(key)) flat[key] = val;
+		}
+		return flat;
+	};
+	const definitionProps = Object.entries(definitions).reduce((acc, [key, { short = [], default: d }]) => {
+		for (const s of [].concat(short)) acc.shorthands[s] = [`--${key}`];
+		acc.defaults[key] = d;
+		return acc;
+	}, {
+		shorthands: {},
+		defaults: {}
+	});
+	const shorthands = {
+		"enjoy-by": ["--before"],
+		d: ["--loglevel", "info"],
+		dd: ["--loglevel", "verbose"],
+		ddd: ["--loglevel", "silly"],
+		quiet: ["--loglevel", "warn"],
+		q: ["--loglevel", "warn"],
+		s: ["--loglevel", "silent"],
+		silent: ["--loglevel", "silent"],
+		verbose: ["--loglevel", "verbose"],
+		desc: ["--description"],
+		help: ["--usage"],
+		local: ["--no-global"],
+		n: ["--no-yes"],
+		no: ["--no-yes"],
+		porcelain: ["--parseable"],
+		readonly: ["--read-only"],
+		reg: ["--registry"],
+		iwr: ["--include-workspace-root"],
+		ws: ["--workspaces"],
+		...definitionProps.shorthands
+	};
+	module.exports = {
+		defaults: definitionProps.defaults,
+		definitions,
+		flatten,
+		nerfDarts: [
+			"_auth",
+			"_authToken",
+			"_password",
+			"certfile",
+			"email",
+			"keyfile",
+			"username"
+		],
+		proxyEnv: [
+			"http_proxy",
+			"https_proxy",
+			"proxy",
+			"no_proxy"
+		],
+		shorthands
+	};
+}));
+//#endregion
+export default require_definitions();
+export {};
+
+//# sourceMappingURL=definitions-ClJIBYEm.mjs.map