@yorozu/build 0.1.0

package/chunks/CMapqBQB.js

@@ -0,0 +1,2620 @@
+import { __toESM as __toESM$1, asNonNull, asyncPool, collectPackageJsons, error, fileExists, filterPackageJsonsForPublish, findPackageByName, findRootPackage, getWorkspaceRoot, info, loadBuildConfig, normalizeFilePath, number, object, parsePackageJsonFile, processPackageJson, require_picomatch, string as string$1, warn } from "./21EFCjEU.js";
+import { exec, require_semver, sortWorkspaceByPublishOrder } from "./Cr5v7tI0.js";
+import { randomUUID } from "node:crypto";
+import { appendFileSync } from "node:fs";
+import { EOL, tmpdir } from "node:os";
+import process$1 from "node:process";
+import { join, relative, resolve } from "node:path";
+import * as fsp from "node:fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
+import * as td from "typedoc";
+//#region src/ci/github-actions.ts
+function isRunningInGithubActions() {
+	return Boolean(process$1.env.GITHUB_ACTIONS);
+}
+function getGithubActionsInput(name) {
+	let input = process$1.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`];
+	if (input === void 0) return void 0;
+	return input.trim();
+}
+function writeGithubActionsOutput(name, value) {
+	if (process$1.env.GITHUB_OUTPUT === void 0) throw new Error("GITHUB_OUTPUT is not set");
+	if (!value.includes(EOL)) {
+		appendFileSync(process$1.env.GITHUB_OUTPUT, `${name}=${value}${EOL}`, "utf8");
+		return;
+	}
+	let delim = `---${randomUUID()}---`;
+	appendFileSync(process$1.env.GITHUB_OUTPUT, `${name}<<${delim}${EOL}${value}${EOL}${delim}${EOL}`, "utf8");
+}
+//#endregion
+//#region ../utils/src/structures/lru-map.ts
+var LruMap = class {
+	#capacity;
+	#map;
+	constructor(capacity, MapImpl = Map) {
+		this.#capacity = capacity;
+		this.#map = new MapImpl();
+	}
+	get size() {
+		return this.#map.size;
+	}
+	get(key) {
+		if (!this.#map.has(key)) return void 0;
+		let value = this.#map.get(key);
+		this.#map.delete(key);
+		this.#map.set(key, value);
+		return value;
+	}
+	has(key) {
+		return this.#map.has(key);
+	}
+	set(key, value) {
+		if (this.#map.has(key)) this.#map.delete(key);
+		this.#map.set(key, value);
+		if (this.#map.size > this.#capacity) {
+			let oldest = this.#map.keys().next().value;
+			if (oldest !== void 0) this.#map.delete(oldest);
+		}
+	}
+	delete(key) {
+		this.#map.delete(key);
+	}
+	clear() {
+		this.#map.clear();
+	}
+	*[Symbol.iterator]() {
+		yield* this.#map;
+	}
+	entries() {
+		return this.#map.entries();
+	}
+	keys() {
+		return this.#map.keys();
+	}
+	values() {
+		return this.#map.values();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@drizzle-team+brocli@0.12.0/node_modules/@drizzle-team/brocli/index.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var require_clone = __commonJS({ "node_modules/.pnpm/clone@2.1.2/node_modules/clone/clone.js"(exports, module) {
+	"use strict";
+	var clone2 = function() {
+		"use strict";
+		function _instanceof(obj, type) {
+			return type != null && obj instanceof type;
+		}
+		var nativeMap;
+		try {
+			nativeMap = Map;
+		} catch (_) {
+			nativeMap = function() {};
+		}
+		var nativeSet;
+		try {
+			nativeSet = Set;
+		} catch (_) {
+			nativeSet = function() {};
+		}
+		var nativePromise;
+		try {
+			nativePromise = Promise;
+		} catch (_) {
+			nativePromise = function() {};
+		}
+		function clone3(parent, circular, depth, prototype, includeNonEnumerable) {
+			if (typeof circular === "object") {
+				depth = circular.depth;
+				prototype = circular.prototype;
+				includeNonEnumerable = circular.includeNonEnumerable;
+				circular = circular.circular;
+			}
+			var allParents = [];
+			var allChildren = [];
+			var useBuffer = typeof Buffer != "undefined";
+			if (typeof circular == "undefined") circular = true;
+			if (typeof depth == "undefined") depth = Infinity;
+			function _clone(parent2, depth2) {
+				if (parent2 === null) return null;
+				if (depth2 === 0) return parent2;
+				var child;
+				var proto;
+				if (typeof parent2 != "object") return parent2;
+				if (_instanceof(parent2, nativeMap)) child = new nativeMap();
+				else if (_instanceof(parent2, nativeSet)) child = new nativeSet();
+				else if (_instanceof(parent2, nativePromise)) child = new nativePromise(function(resolve, reject) {
+					parent2.then(function(value) {
+						resolve(_clone(value, depth2 - 1));
+					}, function(err) {
+						reject(_clone(err, depth2 - 1));
+					});
+				});
+				else if (clone3.__isArray(parent2)) child = [];
+				else if (clone3.__isRegExp(parent2)) {
+					child = new RegExp(parent2.source, __getRegExpFlags(parent2));
+					if (parent2.lastIndex) child.lastIndex = parent2.lastIndex;
+				} else if (clone3.__isDate(parent2)) child = new Date(parent2.getTime());
+				else if (useBuffer && Buffer.isBuffer(parent2)) {
+					if (Buffer.allocUnsafe) child = Buffer.allocUnsafe(parent2.length);
+					else child = new Buffer(parent2.length);
+					parent2.copy(child);
+					return child;
+				} else if (_instanceof(parent2, Error)) child = Object.create(parent2);
+				else if (typeof prototype == "undefined") {
+					proto = Object.getPrototypeOf(parent2);
+					child = Object.create(proto);
+				} else {
+					child = Object.create(prototype);
+					proto = prototype;
+				}
+				if (circular) {
+					var index = allParents.indexOf(parent2);
+					if (index != -1) return allChildren[index];
+					allParents.push(parent2);
+					allChildren.push(child);
+				}
+				if (_instanceof(parent2, nativeMap)) parent2.forEach(function(value, key) {
+					var keyChild = _clone(key, depth2 - 1);
+					var valueChild = _clone(value, depth2 - 1);
+					child.set(keyChild, valueChild);
+				});
+				if (_instanceof(parent2, nativeSet)) parent2.forEach(function(value) {
+					var entryChild = _clone(value, depth2 - 1);
+					child.add(entryChild);
+				});
+				for (var i in parent2) {
+					var attrs;
+					if (proto) attrs = Object.getOwnPropertyDescriptor(proto, i);
+					if (attrs && attrs.set == null) continue;
+					child[i] = _clone(parent2[i], depth2 - 1);
+				}
+				if (Object.getOwnPropertySymbols) {
+					var symbols = Object.getOwnPropertySymbols(parent2);
+					for (var i = 0; i < symbols.length; i++) {
+						var symbol = symbols[i];
+						var descriptor = Object.getOwnPropertyDescriptor(parent2, symbol);
+						if (descriptor && !descriptor.enumerable && !includeNonEnumerable) continue;
+						child[symbol] = _clone(parent2[symbol], depth2 - 1);
+						if (!descriptor.enumerable) Object.defineProperty(child, symbol, { enumerable: false });
+					}
+				}
+				if (includeNonEnumerable) {
+					var allPropertyNames = Object.getOwnPropertyNames(parent2);
+					for (var i = 0; i < allPropertyNames.length; i++) {
+						var propertyName = allPropertyNames[i];
+						var descriptor = Object.getOwnPropertyDescriptor(parent2, propertyName);
+						if (descriptor && descriptor.enumerable) continue;
+						child[propertyName] = _clone(parent2[propertyName], depth2 - 1);
+						Object.defineProperty(child, propertyName, { enumerable: false });
+					}
+				}
+				return child;
+			}
+			return _clone(parent, depth);
+		}
+		clone3.clonePrototype = function clonePrototype(parent) {
+			if (parent === null) return null;
+			var c = function() {};
+			c.prototype = parent;
+			return new c();
+		};
+		function __objToStr(o) {
+			return Object.prototype.toString.call(o);
+		}
+		clone3.__objToStr = __objToStr;
+		function __isDate(o) {
+			return typeof o === "object" && __objToStr(o) === "[object Date]";
+		}
+		clone3.__isDate = __isDate;
+		function __isArray(o) {
+			return typeof o === "object" && __objToStr(o) === "[object Array]";
+		}
+		clone3.__isArray = __isArray;
+		function __isRegExp(o) {
+			return typeof o === "object" && __objToStr(o) === "[object RegExp]";
+		}
+		clone3.__isRegExp = __isRegExp;
+		function __getRegExpFlags(re) {
+			var flags = "";
+			if (re.global) flags += "g";
+			if (re.ignoreCase) flags += "i";
+			if (re.multiline) flags += "m";
+			return flags;
+		}
+		clone3.__getRegExpFlags = __getRegExpFlags;
+		return clone3;
+	}();
+	if (typeof module === "object" && module.exports) module.exports = clone2;
+} });
+var require_quote = __commonJS({ "node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/quote.js"(exports, module) {
+	"use strict";
+	module.exports = function quote(xs) {
+		return xs.map(function(s) {
+			if (s && typeof s === "object") return s.op.replace(/(.)/g, "\\$1");
+			if (/["\s]/.test(s) && !/'/.test(s)) return "'" + s.replace(/(['\\])/g, "\\$1") + "'";
+			if (/["'\s]/.test(s)) return "\"" + s.replace(/(["\\$`!])/g, "\\$1") + "\"";
+			return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, "$1\\$2");
+		}).join(" ");
+	};
+} });
+var require_parse = __commonJS({ "node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/parse.js"(exports, module) {
+	"use strict";
+	var CONTROL = "(?:" + [
+		"\\|\\|",
+		"\\&\\&",
+		";;",
+		"\\|\\&",
+		"\\<\\(",
+		"\\<\\<\\<",
+		">>",
+		">\\&",
+		"<\\&",
+		"[&;()|<>]"
+	].join("|") + ")";
+	var controlRE = new RegExp("^" + CONTROL + "$");
+	var META = "|&;()<> \\t";
+	var SINGLE_QUOTE = "\"((\\\\\"|[^\"])*?)\"";
+	var DOUBLE_QUOTE = "'((\\\\'|[^'])*?)'";
+	var hash = /^#$/;
+	var SQ = "'";
+	var DQ = "\"";
+	var DS = "$";
+	var TOKEN = "";
+	var mult = 4294967296;
+	for (i = 0; i < 4; i++) TOKEN += (mult * Math.random()).toString(16);
+	var i;
+	var startsWithToken = new RegExp("^" + TOKEN);
+	function matchAll(s, r) {
+		var origIndex = r.lastIndex;
+		var matches = [];
+		var matchObj;
+		while (matchObj = r.exec(s)) {
+			matches.push(matchObj);
+			if (r.lastIndex === matchObj.index) r.lastIndex += 1;
+		}
+		r.lastIndex = origIndex;
+		return matches;
+	}
+	function getVar(env, pre, key) {
+		var r = typeof env === "function" ? env(key) : env[key];
+		if (typeof r === "undefined" && key != "") r = "";
+		else if (typeof r === "undefined") r = "$";
+		if (typeof r === "object") return pre + TOKEN + JSON.stringify(r) + TOKEN;
+		return pre + r;
+	}
+	function parseInternal(string2, env, opts) {
+		if (!opts) opts = {};
+		var BS = opts.escape || "\\";
+		var BAREWORD = "(\\" + BS + `['"` + META + `]|[^\\s'"` + META + "])+";
+		var matches = matchAll(string2, new RegExp(["(" + CONTROL + ")", "(" + BAREWORD + "|" + SINGLE_QUOTE + "|" + DOUBLE_QUOTE + ")+"].join("|"), "g"));
+		if (matches.length === 0) return [];
+		if (!env) env = {};
+		var commented = false;
+		return matches.map(function(match) {
+			var s = match[0];
+			if (!s || commented) return;
+			if (controlRE.test(s)) return { op: s };
+			var quote = false;
+			var esc = false;
+			var out = "";
+			var isGlob = false;
+			var i2;
+			function parseEnvVar() {
+				i2 += 1;
+				var varend;
+				var varname;
+				var char = s.charAt(i2);
+				if (char === "{") {
+					i2 += 1;
+					if (s.charAt(i2) === "}") throw new Error("Bad substitution: " + s.slice(i2 - 2, i2 + 1));
+					varend = s.indexOf("}", i2);
+					if (varend < 0) throw new Error("Bad substitution: " + s.slice(i2));
+					varname = s.slice(i2, varend);
+					i2 = varend;
+				} else if (/[*@#?$!_-]/.test(char)) {
+					varname = char;
+					i2 += 1;
+				} else {
+					var slicedFromI = s.slice(i2);
+					varend = slicedFromI.match(/[^\w\d_]/);
+					if (!varend) {
+						varname = slicedFromI;
+						i2 = s.length;
+					} else {
+						varname = slicedFromI.slice(0, varend.index);
+						i2 += varend.index - 1;
+					}
+				}
+				return getVar(env, "", varname);
+			}
+			for (i2 = 0; i2 < s.length; i2++) {
+				var c = s.charAt(i2);
+				isGlob = isGlob || !quote && (c === "*" || c === "?");
+				if (esc) {
+					out += c;
+					esc = false;
+				} else if (quote) if (c === quote) quote = false;
+				else if (quote == SQ) out += c;
+				else if (c === BS) {
+					i2 += 1;
+					c = s.charAt(i2);
+					if (c === DQ || c === BS || c === DS) out += c;
+					else out += BS + c;
+				} else if (c === DS) out += parseEnvVar();
+				else out += c;
+				else if (c === DQ || c === SQ) quote = c;
+				else if (controlRE.test(c)) return { op: s };
+				else if (hash.test(c)) {
+					commented = true;
+					var commentObj = { comment: string2.slice(match.index + i2 + 1) };
+					if (out.length) return [out, commentObj];
+					return [commentObj];
+				} else if (c === BS) esc = true;
+				else if (c === DS) out += parseEnvVar();
+				else out += c;
+			}
+			if (isGlob) return {
+				op: "glob",
+				pattern: out
+			};
+			return out;
+		}).reduce(function(prev, arg) {
+			return typeof arg === "undefined" ? prev : prev.concat(arg);
+		}, []);
+	}
+	module.exports = function parse(s, env, opts) {
+		var mapped = parseInternal(s, env, opts);
+		if (typeof env !== "function") return mapped;
+		return mapped.reduce(function(acc, s2) {
+			if (typeof s2 === "object") return acc.concat(s2);
+			var xs = s2.split(RegExp("(" + TOKEN + ".*?" + TOKEN + ")", "g"));
+			if (xs.length === 1) return acc.concat(xs[0]);
+			return acc.concat(xs.filter(Boolean).map(function(x) {
+				if (startsWithToken.test(x)) return JSON.parse(x.split(TOKEN)[1]);
+				return x;
+			}));
+		}, []);
+	};
+} });
+var require_shell_quote = __commonJS({ "node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/index.js"(exports) {
+	"use strict";
+	exports.quote = require_quote();
+	exports.parse = require_parse();
+} });
+var BroCliError = class extends Error {
+	constructor(message, event) {
+		super(message === void 0 ? message : `BroCli error: ${message}`);
+		this.event = event;
+	}
+};
+var import_clone = __toESM(require_clone(), 1);
+var getOptionTypeText = (option) => {
+	let result = "";
+	switch (option.type) {
+		case "boolean":
+			result = "";
+			break;
+		case "number":
+			if ((option.minVal ?? option.maxVal) !== void 0) {
+				let text = "";
+				if (option.isInt) text = text + `integer `;
+				if (option.minVal !== void 0) text = text + `[${option.minVal};`;
+				else text = text + `(\u221E;`;
+				if (option.maxVal !== void 0) text = text + `${option.maxVal}]`;
+				else text = text + `\u221E)`;
+				result = text;
+				break;
+			}
+			if (option.isInt) {
+				result = "integer";
+				break;
+			}
+			result = "number";
+			break;
+		case "string":
+			if (option.enumVals) {
+				result = "[ " + option.enumVals.join(" | ") + " ]";
+				break;
+			}
+			result = "string";
+			break;
+		case "positional":
+			result = `${option.isRequired ? "<" : "["}${option.enumVals ? option.enumVals.join("|") : option.name}${option.isRequired ? ">" : "]"}`;
+			break;
+	}
+	if (option.isRequired && option.type !== "positional") result = "!" + (result.length ? "" + result : " ");
+	return result;
+};
+var defaultEventHandler = async (event) => {
+	switch (event.type) {
+		case "command_help": {
+			const command2 = event.command;
+			const commandName = getCommandNameWithParents(command2);
+			const cliName = event.name;
+			const desc = command2.desc ?? command2.shortDesc;
+			const subs = command2.subcommands?.filter((s) => !s.hidden);
+			const subcommands = subs && subs.length ? subs : void 0;
+			const defaultGlobals = [{
+				config: {
+					name: "--help",
+					aliases: ["-h"],
+					type: "boolean",
+					description: `help for ${commandName}`,
+					default: void 0
+				},
+				$output: void 0
+			}, {
+				config: {
+					name: "--version",
+					aliases: ["-v"],
+					type: "boolean",
+					description: `version${cliName ? ` for ${cliName}` : ""}`,
+					default: void 0
+				},
+				$output: void 0
+			}];
+			const globals = event.globals ? [...Object.values(event.globals), ...defaultGlobals] : defaultGlobals;
+			if (desc !== void 0) console.log(`
+${desc}`);
+			const opts = Object.values(command2.options ?? {}).filter((opt) => !opt.config.isHidden);
+			const positionals = opts.filter((opt) => opt.config.type === "positional");
+			const options = [...opts.filter((opt) => opt.config.type !== "positional"), ...globals];
+			console.log("\nUsage:");
+			if (command2.handler) console.log(`  ${cliName ? cliName + " " : ""}${commandName}${positionals.length ? " " + positionals.map(({ config: p }) => getOptionTypeText(p)).join(" ") : ""} [flags]`);
+			else console.log(`  ${cliName ? cliName + " " : ""}${commandName} [command]`);
+			if (command2.aliases) {
+				console.log(`
+Aliases:`);
+				console.log(`  ${[command2.name, ...command2.aliases].join(", ")}`);
+			}
+			if (subcommands) {
+				console.log("\nAvailable Commands:");
+				const paddedLength = subcommands.reduce((p, e) => e.name.length > p ? e.name.length : p, 0) + 3;
+				const preDescPad = 2 + paddedLength;
+				const data = subcommands.map((s) => `  ${s.name.padEnd(paddedLength)}${(() => {
+					const description = s.shortDesc ?? s.desc;
+					if (!description?.length) return "";
+					const split = description.split("\n");
+					return [split.shift(), ...split.map((s2) => "".padEnd(preDescPad) + s2)].join("\n");
+				})()}`).join("\n");
+				console.log(data);
+			}
+			if (options.length) {
+				const aliasLength = options.reduce((p, e) => {
+					const currentLength = e.config.aliases.reduce((pa, a) => pa + a.length, 0) + (e.config.aliases.length - 1) * 2 + 1;
+					return currentLength > p ? currentLength : p;
+				}, 0);
+				const paddedAliasLength = aliasLength > 0 ? aliasLength + 1 : 0;
+				const nameLength = options.reduce((p, e) => {
+					const typeLen = getOptionTypeText(e.config).length;
+					const length = typeLen > 0 ? e.config.name.length + 1 + typeLen : e.config.name.length;
+					return length > p ? length : p;
+				}, 0) + 3;
+				const preDescPad = paddedAliasLength + nameLength + 2;
+				const data = options.map(({ config: opt }) => `  ${`${opt.aliases.length ? opt.aliases.join(", ") + "," : ""}`.padEnd(paddedAliasLength)}${`${opt.name}${(() => {
+					const typeText = getOptionTypeText(opt);
+					return typeText.length ? " " + typeText : "";
+				})()}`.padEnd(nameLength)}${(() => {
+					if (!opt.description?.length) return opt.default !== void 0 ? `default: ${JSON.stringify(opt.default)}` : "";
+					const split = opt.description.split("\n");
+					const first = split.shift();
+					const def = opt.default !== void 0 ? ` (default: ${JSON.stringify(opt.default)})` : "";
+					return [first, ...split.map((s) => "".padEnd(preDescPad) + s)].join("\n") + def;
+				})()}`).join("\n");
+				console.log("\nFlags:");
+				console.log(data);
+			}
+			if (subcommands) console.log(`
+Use "${cliName ? cliName + " " : ""}${commandName} [command] --help" for more information about a command.
+`);
+			return true;
+		}
+		case "global_help": {
+			const cliName = event.name;
+			const desc = event.description;
+			const commands = event.commands.filter((c) => !c.hidden);
+			const defaultGlobals = [{
+				config: {
+					name: "--help",
+					aliases: ["-h"],
+					type: "boolean",
+					description: `help${cliName ? ` for ${cliName}` : ""}`,
+					default: void 0
+				},
+				$output: void 0
+			}, {
+				config: {
+					name: "--version",
+					aliases: ["-v"],
+					type: "boolean",
+					description: `version${cliName ? ` for ${cliName}` : ""}`,
+					default: void 0
+				},
+				$output: void 0
+			}];
+			const globals = event.globals ? [...defaultGlobals, ...Object.values(event.globals)] : defaultGlobals;
+			if (desc !== void 0) console.log(`${desc}
+`);
+			console.log("Usage:");
+			console.log(`  ${cliName ? cliName + " " : ""}[command]`);
+			if (commands.length) {
+				console.log("\nAvailable Commands:");
+				const paddedLength = commands.reduce((p, e) => e.name.length > p ? e.name.length : p, 0) + 3;
+				const data = commands.map((c) => `  ${c.name.padEnd(paddedLength)}${(() => {
+					const desc2 = c.shortDesc ?? c.desc;
+					if (!desc2?.length) return "";
+					const split = desc2.split("\n");
+					return [split.shift(), ...split.map((s) => "".padEnd(paddedLength + 2) + s)].join("\n");
+				})()}`).join("\n");
+				console.log(data);
+			} else console.log("\nNo available commands.");
+			const aliasLength = globals.reduce((p, e) => {
+				const currentLength = e.config.aliases.reduce((pa, a) => pa + a.length, 0) + (e.config.aliases.length - 1) * 2 + 1;
+				return currentLength > p ? currentLength : p;
+			}, 0);
+			const paddedAliasLength = aliasLength > 0 ? aliasLength + 1 : 0;
+			const nameLength = globals.reduce((p, e) => {
+				const typeLen = getOptionTypeText(e.config).length;
+				const length = typeLen > 0 ? e.config.name.length + 1 + typeLen : e.config.name.length;
+				return length > p ? length : p;
+			}, 0) + 3;
+			const preDescPad = paddedAliasLength + nameLength + 2;
+			const gData = globals.map(({ config: opt }) => `  ${`${opt.aliases.length ? opt.aliases.join(", ") + "," : ""}`.padEnd(paddedAliasLength)}${`${opt.name}${(() => {
+				const typeText = getOptionTypeText(opt);
+				return typeText.length ? " " + typeText : "";
+			})()}`.padEnd(nameLength)}${(() => {
+				if (!opt.description?.length) return opt.default !== void 0 ? `default: ${JSON.stringify(opt.default)}` : "";
+				const split = opt.description.split("\n");
+				const first = split.shift();
+				const def = opt.default !== void 0 ? ` (default: ${JSON.stringify(opt.default)})` : "";
+				return [first, ...split.map((s) => "".padEnd(preDescPad) + s)].join("\n") + def;
+			})()}`).join("\n");
+			console.log("\nFlags:");
+			console.log(gData);
+			return true;
+		}
+		case "version": return true;
+		case "error": {
+			let msg;
+			switch (event.violation) {
+				case "above_max": {
+					const matchedName = event.offender.namePart;
+					const data = event.offender.dataPart;
+					msg = `Invalid value: number type argument '${matchedName}' expects maximal value of ${event.option.maxVal} as an input, got: ${data}`;
+					break;
+				}
+				case "below_min": {
+					const matchedName = event.offender.namePart;
+					const data = event.offender.dataPart;
+					msg = `Invalid value: number type argument '${matchedName}' expects minimal value of ${event.option.minVal} as an input, got: ${data}`;
+					break;
+				}
+				case "expected_int":
+					msg = `Invalid value: number type argument '${event.offender.namePart}' expects an integer as an input, got: ${event.offender.dataPart}`;
+					break;
+				case "invalid_boolean_syntax": {
+					const matchedName = event.offender.namePart;
+					event.offender.dataPart;
+					msg = `Invalid syntax: boolean type argument '${matchedName}' must have it's value passed in the following formats: ${matchedName}=<value> | ${matchedName} <value> | ${matchedName}.
+Allowed values: true, false, 0, 1`;
+					break;
+				}
+				case "invalid_string_syntax": {
+					const matchedName = event.offender.namePart;
+					msg = `Invalid syntax: string type argument '${matchedName}' must have it's value passed in the following formats: ${matchedName}=<value> | ${matchedName} <value>`;
+					break;
+				}
+				case "invalid_number_syntax": {
+					const matchedName = event.offender.namePart;
+					msg = `Invalid syntax: number type argument '${matchedName}' must have it's value passed in the following formats: ${matchedName}=<value> | ${matchedName} <value>`;
+					break;
+				}
+				case "invalid_number_value":
+					msg = `Invalid value: number type argument '${event.offender.namePart}' expects a number as an input, got: ${event.offender.dataPart}`;
+					break;
+				case "enum_violation": {
+					const matchedName = event.offender.namePart;
+					const data = event.offender.dataPart;
+					const option = event.option;
+					const values = option.enumVals;
+					msg = option.type === "positional" ? `Invalid value: value for the positional argument '${option.name}' must be either one of the following: ${values.join(", ")}; Received: ${data}` : `Invalid value: value for the argument '${matchedName}' must be either one of the following: ${values.join(", ")}; Received: ${data}`;
+					break;
+				}
+				case "unknown_command_error": {
+					const msg2 = `Unknown command: '${event.offender}'.
+Type '--help' to get help on the cli.`;
+					console.error(msg2);
+					return true;
+				}
+				case "unknown_subcommand_error": {
+					const cName = getCommandNameWithParents(event.command);
+					const msg2 = `Unknown command: ${cName} ${event.offender}.
+Type '${cName} --help' to get the help on command.`;
+					console.error(msg2);
+					return true;
+				}
+				case "missing_args_error": {
+					const { missing: missingOpts, command: command2 } = event;
+					msg = command2 === "globals" ? `Missing` : `Command '${command2.name}' is missing following required options: ${missingOpts.map((opt) => {
+						const name = opt.shift();
+						const aliases = opt;
+						if (aliases.length) return `${name} [${aliases.join(", ")}]`;
+						return name;
+					}).join(", ")}`;
+					break;
+				}
+				case "unrecognized_args_error": {
+					const { command: command2, unrecognized } = event;
+					msg = `Unrecognized options for command '${command2.name}': ${unrecognized.join(", ")}`;
+					break;
+				}
+				case "unknown_error": {
+					const e = event.error;
+					console.error(typeof e === "object" && e !== null && "message" in e ? e.message : e);
+					return true;
+				}
+			}
+			console.error(msg);
+			return true;
+		}
+	}
+	return false;
+};
+var eventHandlerWrapper = (customEventHandler) => async (event, options) => await customEventHandler(event, options) ? true : await defaultEventHandler(event, options);
+__toESM(require_shell_quote(), 1);
+function isInt(value) {
+	return value === Math.floor(value);
+}
+var executeOrLog = async (target, arg) => typeof target === "string" ? console.log(target) : target ? await target(arg) : void 0;
+var generatePrefix = (name) => name.startsWith("-") ? name : name.length > 1 ? `--${name}` : `-${name}`;
+var validateOptions = (config) => {
+	const cloned = (0, import_clone.default)(config);
+	const entries = [];
+	const storedNames = [];
+	const cfgEntries = Object.entries(cloned);
+	for (const [key, value] of cfgEntries) {
+		const cfg = value._.config;
+		if (cfg.name === void 0) cfg.name = key;
+		if (cfg.type === "positional") continue;
+		if (cfg.name.includes("=")) throw new BroCliError(`Can't define option '${generatePrefix(cfg.name)}' - option names and aliases cannot contain '='!`);
+		for (const alias of cfg.aliases) if (alias.includes("=")) throw new BroCliError(`Can't define option '${generatePrefix(cfg.name)}' - option names and aliases cannot contain '='!`);
+		cfg.name = generatePrefix(cfg.name);
+		cfg.aliases = cfg.aliases.map((a) => generatePrefix(a));
+	}
+	for (const [key, value] of cfgEntries) {
+		const cfg = value._.config;
+		if (cfg.type === "positional") {
+			entries.push([key, {
+				config: cfg,
+				$output: void 0
+			}]);
+			continue;
+		}
+		const reservedNames = [
+			"--help",
+			"-h",
+			"--version",
+			"-v"
+		];
+		const allNames = [cfg.name, ...cfg.aliases];
+		for (const name of allNames) {
+			const match = reservedNames.find((n) => n === name);
+			if (match) throw new BroCliError(`Can't define option '${cfg.name}' - name '${match}' is reserved!`);
+		}
+		for (const storage of storedNames) {
+			if (!storage.find((e) => e === cfg.name)) continue;
+			throw new BroCliError(`Can't define option '${cfg.name}' - name is already in use by option '${storage[0]}'!`);
+		}
+		for (const alias of cfg.aliases) for (const storage of storedNames) {
+			if (!storage.find((e) => e === alias)) continue;
+			throw new BroCliError(`Can't define option '${cfg.name}' - alias '${alias}' is already in use by option '${storage[0]}'!`);
+		}
+		const currentNames = [cfg.name, ...cfg.aliases];
+		storedNames.push(currentNames);
+		currentNames.forEach((name, idx) => {
+			if (currentNames.findIndex((e) => e === name) === idx) return;
+			throw new BroCliError(`Can't define option '${cfg.name}' - duplicate alias '${name}'!`);
+		});
+		entries.push([key, {
+			config: cfg,
+			$output: void 0
+		}]);
+	}
+	return Object.fromEntries(entries);
+};
+var assignParent = (parent, subcommands) => subcommands.forEach((e) => {
+	e.parent = parent;
+	if (e.subcommands) assignParent(e, e.subcommands);
+});
+var command = (command2) => {
+	const allNames = command2.aliases ? [command2.name, ...command2.aliases] : [command2.name];
+	const cmd = (0, import_clone.default)(command2);
+	if (command2.subcommands && command2.options && Object.values(command2.options).find((opt) => opt._.config.type === "positional")) throw new BroCliError(`Can't define command '${cmd.name}' - command can't have subcommands and positional args at the same time!`);
+	if (!command2.handler && !command2.subcommands) throw new BroCliError(`Can't define command '${cmd.name}' - command without subcommands must have a handler present!`);
+	cmd.options = command2.options ? validateOptions(command2.options) : void 0;
+	cmd.name = cmd.name ?? cmd.aliases?.shift();
+	if (!cmd.name) throw new BroCliError(`Can't define command without name!`);
+	cmd.aliases = cmd.aliases?.length ? cmd.aliases : void 0;
+	if (cmd.name.startsWith("-")) throw new BroCliError(`Can't define command '${cmd.name}' - command name can't start with '-'!`);
+	cmd.aliases?.forEach((a) => {
+		if (a.startsWith("-")) throw new BroCliError(`Can't define command '${cmd.name}' - command aliases can't start with '-'!`);
+	});
+	allNames.forEach((n, i) => {
+		if (n === "help") throw new BroCliError(`Can't define command '${cmd.name}' - 'help' is a reserved name. If you want to redefine help message - do so in runCli's config.`);
+		const lCaseName = n?.toLowerCase();
+		if (lCaseName === "0" || lCaseName === "1" || lCaseName === "true" || lCaseName === "false") throw new BroCliError(`Can't define command '${cmd.name}' - '${n}' is a reserved for boolean values name!`);
+		if (allNames.findIndex((an) => an === n) !== i) throw new BroCliError(`Can't define command '${cmd.name}' - duplicate alias '${n}'!`);
+	});
+	if (cmd.subcommands) assignParent(cmd, cmd.subcommands);
+	return cmd;
+};
+var getCommandInner = (commands, candidates, args, cliName, cliDescription) => {
+	const { data: arg, originalIndex: index } = candidates.shift();
+	const command2 = commands.find((c) => {
+		return (c.aliases ? [c.name, ...c.aliases] : [c.name]).find((name) => name === arg);
+	});
+	if (!command2) return {
+		command: command2,
+		args
+	};
+	const newArgs = removeByIndex(args, index);
+	if (!candidates.length || !command2.subcommands) return {
+		command: command2,
+		args: newArgs
+	};
+	const newCandidates = candidates.map((c) => ({
+		data: c.data,
+		originalIndex: c.originalIndex - 1
+	}));
+	const subcommand = getCommandInner(command2.subcommands, newCandidates, newArgs, cliName, cliDescription);
+	if (!subcommand.command) throw new BroCliError(void 0, {
+		type: "error",
+		violation: "unknown_subcommand_error",
+		name: cliName,
+		description: cliDescription,
+		command: command2,
+		offender: candidates[0].data
+	});
+	return subcommand;
+};
+var getCommand = (commands, args, cliName, cliDescription) => {
+	const candidates = [];
+	for (let i = 0; i < args.length; ++i) {
+		const arg = args[i];
+		if (arg === "--help" || arg === "-h" || arg === "--version" || arg === "-v") {
+			const lCaseNext = args[i + 1]?.toLowerCase();
+			if (lCaseNext === "0" || lCaseNext === "1" || lCaseNext === "true" || lCaseNext === "false") ++i;
+			continue;
+		}
+		if (arg?.startsWith("-")) {
+			if (!arg.includes("=")) ++i;
+			continue;
+		}
+		candidates.push({
+			data: arg,
+			originalIndex: i
+		});
+	}
+	if (!candidates.length) return {
+		command: void 0,
+		args
+	};
+	const firstCandidate = candidates[0];
+	if (firstCandidate.data === "help") return {
+		command: "help",
+		args: removeByIndex(args, firstCandidate.originalIndex)
+	};
+	const { command: command2, args: argsRes } = getCommandInner(commands, candidates, args, cliName, cliDescription);
+	if (!command2) throw new BroCliError(void 0, {
+		type: "error",
+		violation: "unknown_command_error",
+		commands,
+		name: cliName,
+		description: cliDescription,
+		offender: firstCandidate.data
+	});
+	return {
+		command: command2,
+		args: argsRes
+	};
+};
+var parseArg = (command2, options, positionals, arg, nextArg, cliName, cliDescription) => {
+	let data = void 0;
+	const argSplit = arg.split("=");
+	const hasEq = arg.includes("=");
+	const namePart = argSplit.shift();
+	const dataPart = hasEq ? argSplit.join("=") : nextArg;
+	let lcaseData = dataPart?.toLowerCase();
+	let skipNext = !hasEq;
+	if (namePart === "--help" || namePart === "-h") return {
+		isHelp: true,
+		skipNext: !hasEq && nextArg?.startsWith("-") ? false : skipNext
+	};
+	if (namePart === "--version" || namePart === "-v") return {
+		isVersion: true,
+		skipNext: !hasEq && nextArg?.startsWith("-") ? false : skipNext
+	};
+	if (!arg.startsWith("-")) {
+		if (!positionals.length) return {};
+		const pos = positionals.shift();
+		if (pos[1].enumVals && !pos[1].enumVals.find((val) => val === arg)) throw new BroCliError(void 0, {
+			type: "error",
+			name: cliName,
+			description: cliDescription,
+			violation: "enum_violation",
+			command: command2,
+			option: pos[1],
+			offender: { dataPart: arg }
+		});
+		data = arg;
+		return {
+			data,
+			skipNext: false,
+			name: pos[0],
+			option: pos[1]
+		};
+	}
+	const option = options.find(([optKey, opt]) => {
+		const names = [opt.name, ...opt.aliases];
+		if (opt.type === "boolean") {
+			if (!names.find((name) => name === namePart)) return false;
+			if (!hasEq && nextArg?.startsWith("-")) {
+				data = true;
+				skipNext = false;
+				return true;
+			}
+			if (lcaseData === void 0 || lcaseData === "" || lcaseData === "true" || lcaseData === "1") {
+				data = true;
+				return true;
+			}
+			if (lcaseData === "false" || lcaseData === "0") {
+				data = false;
+				return true;
+			}
+			if (!hasEq) {
+				data = true;
+				skipNext = false;
+				return true;
+			}
+			throw new BroCliError(void 0, {
+				type: "error",
+				name: cliName,
+				description: cliDescription,
+				violation: "invalid_boolean_syntax",
+				option: opt,
+				command: command2,
+				offender: {
+					namePart,
+					dataPart
+				}
+			});
+		} else {
+			if (!names.find((name) => name === namePart)) return false;
+			if (opt.type === "string") {
+				if (!hasEq && nextArg === void 0) throw new BroCliError(void 0, {
+					type: "error",
+					name: cliName,
+					description: cliDescription,
+					violation: "invalid_string_syntax",
+					option: opt,
+					command: command2,
+					offender: {
+						namePart,
+						dataPart
+					}
+				});
+				if (opt.enumVals && !opt.enumVals.find((val) => val === dataPart)) throw new BroCliError(void 0, {
+					type: "error",
+					name: cliName,
+					description: cliDescription,
+					violation: "enum_violation",
+					option: opt,
+					command: command2,
+					offender: {
+						namePart,
+						dataPart
+					}
+				});
+				data = dataPart;
+				return true;
+			}
+			if (!hasEq && nextArg === void 0) throw new BroCliError(void 0, {
+				type: "error",
+				name: cliName,
+				description: cliDescription,
+				violation: "invalid_number_syntax",
+				option: opt,
+				command: command2,
+				offender: {
+					namePart,
+					dataPart
+				}
+			});
+			const numData = Number(dataPart);
+			if (isNaN(numData)) throw new BroCliError(void 0, {
+				type: "error",
+				name: cliName,
+				description: cliDescription,
+				violation: "invalid_number_value",
+				option: opt,
+				command: command2,
+				offender: {
+					namePart,
+					dataPart
+				}
+			});
+			if (opt.isInt && !isInt(numData)) throw new BroCliError(void 0, {
+				type: "error",
+				name: cliName,
+				description: cliDescription,
+				violation: "expected_int",
+				option: opt,
+				command: command2,
+				offender: {
+					namePart,
+					dataPart
+				}
+			});
+			if (opt.minVal !== void 0 && numData < opt.minVal) throw new BroCliError(void 0, {
+				type: "error",
+				name: cliName,
+				description: cliDescription,
+				violation: "below_min",
+				option: opt,
+				command: command2,
+				offender: {
+					namePart,
+					dataPart
+				}
+			});
+			if (opt.maxVal !== void 0 && numData > opt.maxVal) throw new BroCliError(void 0, {
+				type: "error",
+				name: cliName,
+				description: cliDescription,
+				violation: "above_max",
+				option: opt,
+				command: command2,
+				offender: {
+					namePart,
+					dataPart
+				}
+			});
+			data = numData;
+			return true;
+		}
+	});
+	return {
+		data,
+		skipNext,
+		name: option?.[0],
+		option: option?.[1]
+	};
+};
+var parseOptions = (command2, args, cliName, cliDescription, omitKeysOfUndefinedOptions) => {
+	const options = command2.options;
+	let noOpts = !options;
+	const optEntries = Object.entries(options ?? {}).map((opt) => [opt[0], opt[1].config]);
+	const nonPositionalEntries = optEntries.filter(([key, opt]) => opt.type !== "positional");
+	const positionalEntries = optEntries.filter(([key, opt]) => opt.type === "positional");
+	const result = {};
+	const missingRequiredArr = [];
+	const unrecognizedArgsArr = [];
+	for (let i = 0; i < args.length; ++i) {
+		const arg = args[i];
+		const nextArg = args[i + 1];
+		const { data, name, option, skipNext, isHelp, isVersion } = parseArg(command2, nonPositionalEntries, positionalEntries, arg, nextArg, cliName, cliDescription);
+		if (!option) unrecognizedArgsArr.push(arg.split("=")[0]);
+		if (skipNext) ++i;
+		if (isHelp) return "help";
+		if (isVersion) return "version";
+		result[name] = data;
+	}
+	for (const [optKey, option] of optEntries) {
+		const data = result[optKey] ?? option.default;
+		if (!omitKeysOfUndefinedOptions) result[optKey] = data;
+		else if (data !== void 0) result[optKey] = data;
+		if (option.isRequired && result[optKey] === void 0) missingRequiredArr.push([option.name, ...option.aliases]);
+	}
+	if (missingRequiredArr.length) throw new BroCliError(void 0, {
+		type: "error",
+		violation: "missing_args_error",
+		name: cliName,
+		description: cliDescription,
+		command: command2,
+		missing: missingRequiredArr
+	});
+	if (unrecognizedArgsArr.length) throw new BroCliError(void 0, {
+		type: "error",
+		violation: "unrecognized_args_error",
+		name: cliName,
+		description: cliDescription,
+		command: command2,
+		unrecognized: unrecognizedArgsArr
+	});
+	return noOpts ? void 0 : result;
+};
+var parseGlobals = (command2, globals, args, cliName, cliDescription, omitKeysOfUndefinedOptions, ignoreSpecialCases) => {
+	if (!globals) return void 0;
+	const optEntries = Object.entries(globals).map((opt) => [opt[0], opt[1].config]);
+	const result = {};
+	const missingRequiredArr = [];
+	for (let i = 0; i < args.length; ++i) {
+		const arg = args[i];
+		const nextArg = args[i + 1];
+		const { data, name, option, skipNext, isHelp, isVersion } = parseArg(command2, optEntries, [], arg, nextArg, cliName, cliDescription);
+		if (skipNext) ++i;
+		if (!ignoreSpecialCases) {
+			if (isHelp) return "help";
+			if (isVersion) return "version";
+		}
+		if (!option) continue;
+		delete args[i];
+		if (skipNext) delete args[i - 1];
+		result[name] = data;
+	}
+	for (const [optKey, option] of optEntries) {
+		const data = result[optKey] ?? option.default;
+		if (!omitKeysOfUndefinedOptions) result[optKey] = data;
+		else if (data !== void 0) result[optKey] = data;
+		if (option.isRequired && result[optKey] === void 0) missingRequiredArr.push([option.name, ...option.aliases]);
+	}
+	if (missingRequiredArr.length) throw new BroCliError(void 0, {
+		type: "error",
+		violation: "missing_args_error",
+		name: cliName,
+		description: cliDescription,
+		command: command2,
+		missing: missingRequiredArr
+	});
+	return Object.keys(result).length ? result : void 0;
+};
+var getCommandNameWithParents = (command2) => command2.parent ? `${getCommandNameWithParents(command2.parent)} ${command2.name}` : command2.name;
+var validateCommands = (commands, parent) => {
+	const storedNames = {};
+	for (const cmd of commands) {
+		const storageVals = Object.values(storedNames);
+		for (const storage of storageVals) {
+			if (!storage.find((e) => e === cmd.name)) continue;
+			throw new BroCliError(`Can't define command '${getCommandNameWithParents(cmd)}': name is already in use by command '${parent ? `${getCommandNameWithParents(parent)} ` : ""}${storage[0]}'!`);
+		}
+		if (cmd.aliases) for (const alias of cmd.aliases) for (const storage of storageVals) {
+			if (!storage.find((e) => e === alias)) continue;
+			throw new BroCliError(`Can't define command '${getCommandNameWithParents(cmd)}': alias '${alias}' is already in use by command '${parent ? `${getCommandNameWithParents(parent)} ` : ""}${storage[0]}'!`);
+		}
+		storedNames[cmd.name] = cmd.aliases ? [cmd.name, ...cmd.aliases] : [cmd.name];
+		if (cmd.subcommands) cmd.subcommands = validateCommands(cmd.subcommands, cmd);
+	}
+	return commands;
+};
+var validateGlobalsInner = (commands, globals) => {
+	for (const c of commands) {
+		const { options } = c;
+		if (!options) continue;
+		for (const { config: opt } of Object.values(options)) {
+			if (globals.find(({ config: g }) => g.name === opt.name)) throw new BroCliError(`Global options overlap with option '${opt.name}' of command '${getCommandNameWithParents(c)}' on name`);
+			let foundAliasOverlap = opt.aliases.find((a) => globals.find(({ config: g }) => g.name === a)) ?? globals.find(({ config: g }) => opt.aliases.find((a) => a === g.name));
+			if (!foundAliasOverlap) for (const { config: g } of globals) {
+				foundAliasOverlap = g.aliases.find((gAlias) => opt.name === gAlias);
+				if (foundAliasOverlap) break;
+			}
+			if (!foundAliasOverlap) for (const { config: g } of globals) {
+				foundAliasOverlap = g.aliases.find((gAlias) => opt.aliases.find((a) => a === gAlias));
+				if (foundAliasOverlap) break;
+			}
+			if (foundAliasOverlap) throw new BroCliError(`Global options overlap with option '${opt.name}' of command '${getCommandNameWithParents(c)}' on alias '${foundAliasOverlap}'`);
+		}
+		if (c.subcommands) validateGlobalsInner(c.subcommands, globals);
+	}
+};
+var validateGlobals = (commands, globals) => {
+	if (!globals) return;
+	validateGlobalsInner(commands, Object.values(globals));
+};
+var removeByIndex = (arr, idx) => [...arr.slice(0, idx), ...arr.slice(idx + 1, arr.length)];
+var run = async (commands, config) => {
+	const eventHandler = config?.theme ? eventHandlerWrapper(config.theme) : defaultEventHandler;
+	const argSource = config?.argSource ?? process.argv;
+	const version = config?.version;
+	const help = config?.help;
+	const omitKeysOfUndefinedOptions = config?.omitKeysOfUndefinedOptions ?? false;
+	const cliName = config?.name;
+	const cliDescription = config?.description;
+	const globals = config?.globals;
+	let prepassError;
+	let processedGlobals;
+	let processedCmds;
+	const args = argSource.slice(2, argSource.length);
+	try {
+		processedCmds = validateCommands(commands);
+		processedGlobals = globals ? validateOptions(globals) : void 0;
+		if (processedGlobals) validateGlobals(processedCmds, processedGlobals);
+	} catch (e) {
+		prepassError = e;
+		processedCmds = [];
+	}
+	let preparseError;
+	let _preparsedGlobals;
+	const preparsedGlobals = () => {
+		if (preparseError) throw preparseError;
+		return _preparsedGlobals;
+	};
+	try {
+		_preparsedGlobals = parseGlobals("globals", processedGlobals, [...args], cliName, cliDescription, omitKeysOfUndefinedOptions, true);
+	} catch (e) {
+		preparseError = e;
+	}
+	try {
+		if (prepassError) throw prepassError;
+		if (!args.length) return help !== void 0 ? await executeOrLog(help, preparsedGlobals()) : await eventHandler({
+			type: "global_help",
+			description: cliDescription,
+			name: cliName,
+			commands: processedCmds,
+			globals: processedGlobals
+		}, preparsedGlobals());
+		const helpIndex = args.findIndex((arg) => arg === "--help" || arg === "-h");
+		if (helpIndex !== -1 && (helpIndex > 0 ? args[helpIndex - 1]?.startsWith("-") && !args[helpIndex - 1].includes("=") ? false : true : true)) {
+			const command3 = getCommand(processedCmds, args, cliName, cliDescription).command;
+			if (typeof command3 === "object") return command3.help !== void 0 ? await executeOrLog(command3.help) : await eventHandler({
+				type: "command_help",
+				description: cliDescription,
+				name: cliName,
+				command: command3,
+				globals: processedGlobals
+			}, preparsedGlobals());
+			else return help !== void 0 ? await executeOrLog(help, preparsedGlobals()) : await eventHandler({
+				type: "global_help",
+				description: cliDescription,
+				name: cliName,
+				commands: processedCmds,
+				globals: processedGlobals
+			}, preparsedGlobals());
+		}
+		const versionIndex = args.findIndex((arg) => arg === "--version" || arg === "-v");
+		if (versionIndex !== -1 && (versionIndex > 0 ? args[versionIndex - 1]?.startsWith("-") ? false : true : true)) return version !== void 0 ? await executeOrLog(version, preparsedGlobals()) : await eventHandler({
+			type: "version",
+			name: cliName,
+			description: cliDescription
+		}, preparsedGlobals());
+		const { command: command2, args: newArgs } = getCommand(processedCmds, args, cliName, cliDescription);
+		if (!command2) return help !== void 0 ? await executeOrLog(help, preparsedGlobals()) : await eventHandler({
+			type: "global_help",
+			description: cliDescription,
+			name: cliName,
+			commands: processedCmds,
+			globals: processedGlobals
+		}, preparsedGlobals());
+		if (command2 === "help") {
+			let helpCommand;
+			let newestArgs = newArgs;
+			do {
+				const res = getCommand(processedCmds, newestArgs, cliName, cliDescription);
+				helpCommand = res.command;
+				newestArgs = res.args;
+			} while (helpCommand === "help");
+			return helpCommand ? helpCommand.help !== void 0 ? await executeOrLog(helpCommand.help) : await eventHandler({
+				type: "command_help",
+				description: cliDescription,
+				name: cliName,
+				command: helpCommand,
+				globals: processedGlobals
+			}, preparsedGlobals()) : help !== void 0 ? await executeOrLog(help, preparsedGlobals()) : await eventHandler({
+				type: "global_help",
+				description: cliDescription,
+				name: cliName,
+				commands: processedCmds,
+				globals: processedGlobals
+			}, preparsedGlobals());
+		}
+		const gOptionResult = parseGlobals(command2, processedGlobals, newArgs, cliName, cliDescription, omitKeysOfUndefinedOptions);
+		const optionResult = gOptionResult && (gOptionResult === "help" || gOptionResult === "version") ? gOptionResult : parseOptions(command2, globals ? newArgs.filter((a) => a !== void 0) : newArgs, cliName, cliDescription, omitKeysOfUndefinedOptions);
+		if (optionResult === "help" || gOptionResult === "help") return command2.help !== void 0 ? await executeOrLog(command2.help) : await eventHandler({
+			type: "command_help",
+			description: cliDescription,
+			name: cliName,
+			command: command2,
+			globals: processedGlobals
+		}, preparsedGlobals());
+		if (optionResult === "version" || gOptionResult === "version") return version !== void 0 ? await executeOrLog(version, preparsedGlobals()) : await eventHandler({
+			type: "version",
+			name: cliName,
+			description: cliDescription
+		}, preparsedGlobals());
+		if (command2.handler) {
+			if (config?.hook) await config.hook("before", command2, gOptionResult);
+			await command2.handler(command2.transform ? await command2.transform(optionResult) : optionResult);
+			if (config?.hook) await config.hook("after", command2, gOptionResult);
+			return;
+		} else return command2.help !== void 0 ? await executeOrLog(command2.help) : await eventHandler({
+			type: "command_help",
+			description: cliDescription,
+			name: cliName,
+			command: command2,
+			globals: processedGlobals
+		}, preparsedGlobals());
+	} catch (e) {
+		if (e instanceof BroCliError) if (e.event) await eventHandler(e.event, preparsedGlobals());
+		else if (!config?.noExit) console.error(e.message);
+		else return e.message;
+		else await eventHandler({
+			type: "error",
+			violation: "unknown_error",
+			name: cliName,
+			description: cliDescription,
+			error: e
+		}, preparsedGlobals());
+		if (!config?.noExit) process.exit(1);
+		return;
+	}
+};
+var OptionBuilderBase = class _OptionBuilderBase {
+	_;
+	config = () => this._.config;
+	constructor(config) {
+		this._ = {
+			config: config ?? {
+				aliases: [],
+				type: "string"
+			},
+			$output: void 0
+		};
+	}
+	string(name) {
+		return new _OptionBuilderBase({
+			...this.config(),
+			type: "string",
+			name
+		});
+	}
+	number(name) {
+		return new _OptionBuilderBase({
+			...this.config(),
+			type: "number",
+			name
+		});
+	}
+	boolean(name) {
+		return new _OptionBuilderBase({
+			...this.config(),
+			type: "boolean",
+			name
+		});
+	}
+	positional(displayName) {
+		return new _OptionBuilderBase({
+			...this.config(),
+			type: "positional",
+			name: displayName
+		});
+	}
+	alias(...aliases) {
+		return new _OptionBuilderBase({
+			...this.config(),
+			aliases
+		});
+	}
+	desc(description) {
+		return new _OptionBuilderBase({
+			...this.config(),
+			description
+		});
+	}
+	hidden() {
+		return new _OptionBuilderBase({
+			...this.config(),
+			isHidden: true
+		});
+	}
+	required() {
+		return new _OptionBuilderBase({
+			...this.config(),
+			isRequired: true
+		});
+	}
+	default(value) {
+		const config = this.config();
+		const enums = config.enumVals;
+		if (enums && !enums.find((v) => value === v)) throw new Error(`Option enums [ ${enums.join(", ")} ] are incompatible with default value ${value}`);
+		return new _OptionBuilderBase({
+			...config,
+			default: value
+		});
+	}
+	enum(...values) {
+		const config = this.config();
+		const defaultVal = config.default;
+		if (defaultVal !== void 0 && !values.find((v) => defaultVal === v)) throw new Error(`Option enums [ ${values.join(", ")} ] are incompatible with default value ${defaultVal}`);
+		return new _OptionBuilderBase({
+			...config,
+			enumVals: values
+		});
+	}
+	min(value) {
+		const config = this.config();
+		const maxVal = config.maxVal;
+		if (maxVal !== void 0 && maxVal < value) throw new BroCliError("Unable to define option's min value to be higher than max value!");
+		return new _OptionBuilderBase({
+			...config,
+			minVal: value
+		});
+	}
+	max(value) {
+		const config = this.config();
+		const minVal = config.minVal;
+		if (minVal !== void 0 && minVal > value) throw new BroCliError("Unable to define option's max value to be lower than min value!");
+		return new _OptionBuilderBase({
+			...config,
+			maxVal: value
+		});
+	}
+	int() {
+		return new _OptionBuilderBase({
+			...this.config(),
+			isInt: true
+		});
+	}
+};
+function string(name) {
+	return typeof name === "string" ? new OptionBuilderBase().string(name) : new OptionBuilderBase().string();
+}
+function boolean(name) {
+	return typeof name === "string" ? new OptionBuilderBase().boolean(name) : new OptionBuilderBase().boolean();
+}
+function positional(displayName) {
+	return typeof displayName === "string" ? new OptionBuilderBase().positional(displayName) : new OptionBuilderBase().positional();
+}
+//#endregion
+//#region src/cli/commands/_utils.ts
+function resolveWorkspaceRoot(root) {
+	return root != null ? resolve(process$1.cwd(), root) : getWorkspaceRoot();
+}
+async function loadConfig(params) {
+	let { workspaceRoot, require = false } = params;
+	let config = await loadBuildConfig(workspaceRoot);
+	if (!config && require) throw new Error(`Config not found at ${workspaceRoot}`);
+	return config ?? null;
+}
+//#endregion
+//#region src/cli/commands/build.ts
+async function resolveViteConfig(workspaceRoot, configured) {
+	if (configured != null) return configured;
+	if (await fileExists(join(workspaceRoot, "vite.config.ts"))) return "vite.config.ts";
+	if (await fileExists(join(workspaceRoot, "vite.config.js"))) return "vite.config.js";
+	return "vite.config.ts";
+}
+/**
+* build a single package using vite
+*
+* tiny wrapper on top of `vite build`
+*/
+async function buildPackage(params) {
+	let config = await loadConfig({ workspaceRoot: params.workspaceRoot });
+	let workspacePackages = params.workspace ?? await collectPackageJsons(params.workspaceRoot, true);
+	let viteConfig = await resolveViteConfig(params.workspaceRoot, config?.viteConfig);
+	let packageRoot = findPackageByName(workspacePackages, params.packageName).path;
+	let env = {
+		...process$1.env,
+		__YOROZU_INTERNAL_PACKAGES_LIST: JSON.stringify(workspacePackages)
+	};
+	if (params.fixedVersion != null) env.__YOROZU_INTERNAL_FIXED_VERSION = params.fixedVersion;
+	await exec([
+		"npx",
+		"vite",
+		"build",
+		"--config",
+		join(params.workspaceRoot, viteConfig)
+	], {
+		env,
+		cwd: packageRoot,
+		stdio: "inherit",
+		throwOnError: true
+	});
+}
+/**
+* build every npm-publishable workspace package in publish order
+*/
+async function buildWorkspace(params) {
+	let workspace = await collectPackageJsons(params.workspaceRoot, true);
+	let ordered = filterPackageJsonsForPublish(sortWorkspaceByPublishOrder(workspace.filter((pkg) => !pkg.root)), "npm");
+	for (let pkg of ordered) {
+		let packageName = asNonNull(pkg.json.name);
+		info(`building ${packageName}`);
+		await buildPackage({
+			workspaceRoot: params.workspaceRoot,
+			workspace,
+			packageName,
+			fixedVersion: params.fixedVersion
+		});
+	}
+}
+var buildPackageCli = command({
+	name: "build",
+	desc: "build a package",
+	options: {
+		config: string("config").desc("path to the build.config.js file"),
+		root: string().desc("path to the root of the workspace (default: cwd)"),
+		packageName: positional("package-name").desc("name of the package to build (or :all to build the entire workspace)").default(":all"),
+		fixedVersion: string("fixed-version").desc("fixed version for every managed package (useful for pre-releases)")
+	},
+	handler: async (args) => {
+		let workspaceRoot = args.root != null ? resolve(process$1.cwd(), args.root) : getWorkspaceRoot();
+		if (args.packageName === ":all") {
+			await buildWorkspace({
+				workspaceRoot,
+				fixedVersion: args.fixedVersion
+			});
+			return;
+		}
+		await buildPackage({
+			workspaceRoot,
+			packageName: args.packageName,
+			configPath: args.config,
+			fixedVersion: args.fixedVersion
+		});
+	}
+});
+//#endregion
+//#region src/npm/npm-api.ts
+var USER_AGENT$1 = "@yorozu/build";
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var REQUEST_TIMEOUT_MS$1 = 3e4;
+var NPM_PACKAGE_NAME_REGEX = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+async function npmCheckVersion(params) {
+	let url = `${(params.registry ?? DEFAULT_REGISTRY).replace(/\/$/, "")}/${params.package}/${params.version}`;
+	let res = await fetch(url, {
+		headers: { "User-Agent": USER_AGENT$1 },
+		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS$1)
+	});
+	if (res.body) res.body.cancel();
+	return res.status === 200;
+}
+//#endregion
+//#region src/cli/commands/publish.ts
+var DEFAULT_REGISTRY_URL = "https://registry.npmjs.org";
+function normalizeNpmAuthToken(token) {
+	if (token == null) return void 0;
+	let trimmed = token.trim();
+	return trimmed === "" ? void 0 : trimmed;
+}
+function formatNpmAuthRc(registryUrl, token) {
+	return `${new URL(":_authToken", registryUrl).href.replace(/^https:\/\//, "//")}=${token}\n`;
+}
+async function prepareNpmPublishAuth(params) {
+	let token = normalizeNpmAuthToken(params.token);
+	if (token == null) return {
+		extraArgs: [],
+		extraEnv: {},
+		cleanup: async () => {}
+	};
+	let dir = await fsp.mkdtemp(join(tmpdir(), "yorozu-npm-auth-"));
+	let npmrcPath = join(dir, ".npmrc");
+	await fsp.writeFile(npmrcPath, formatNpmAuthRc(params.registryUrl, token), { mode: 384 });
+	return {
+		extraArgs: ["--userconfig", npmrcPath],
+		extraEnv: {
+			NPM_TOKEN: token,
+			NODE_AUTH_TOKEN: token
+		},
+		cleanup: async () => {
+			await fsp.rm(dir, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+async function publishPackages(params) {
+	let { workspaceRoot = process$1.cwd(), workspace = await collectPackageJsons(workspaceRoot, true), packages, unpublishExisting = false, skipVersionCheck = false, registryUrl = DEFAULT_REGISTRY_URL, token, distDir = "dist", publishArgs = [], dryRun, withTarballs, withBuild, fixedVersion, noProvenance = false } = params;
+	let ordered = filterPackageJsonsForPublish(sortWorkspaceByPublishOrder(workspace.filter((pkg) => !pkg.root)), "npm");
+	let toPublish = packages.length === 1 && packages[0] === ":all" ? ordered : ordered.filter((pkg) => packages.includes(asNonNull(pkg.json.name)));
+	let failed = [];
+	let tarballs = [];
+	let auth = await prepareNpmPublishAuth({
+		token: dryRun ? void 0 : token,
+		registryUrl
+	});
+	let npmEnv = {
+		...process$1.env,
+		...auth.extraEnv
+	};
+	try {
+		if (!dryRun) await exec([
+			"npm",
+			...auth.extraArgs,
+			"whoami",
+			"--registry",
+			registryUrl
+		], {
+			throwOnError: true,
+			env: npmEnv
+		});
+		if (!noProvenance && isRunningInGithubActions() && Boolean(process$1.env.ACTIONS_ID_TOKEN_REQUEST_URL) && registryUrl === DEFAULT_REGISTRY_URL) {
+			if (!publishArgs.some((it) => it.startsWith("--provenance"))) publishArgs.push("--provenance");
+		}
+		for (let pkg of toPublish) {
+			let pkgVersion = fixedVersion ?? asNonNull(pkg.json.version);
+			if (!dryRun && !skipVersionCheck && await npmCheckVersion({
+				registry: registryUrl,
+				package: asNonNull(pkg.json.name),
+				version: pkgVersion
+			})) if (unpublishExisting) await exec([
+				"npm",
+				...auth.extraArgs,
+				"unpublish",
+				"--force",
+				"--registry",
+				registryUrl,
+				`${asNonNull(pkg.json.name)}@${pkgVersion}`
+			], {
+				stdio: "inherit",
+				env: npmEnv
+			});
+			else {
+				info(`Skipping ${pkg.json.name}@${pkgVersion} because it is already published`);
+				continue;
+			}
+			if (withBuild) if (pkg.json.scripts?.build !== void 0) {
+				if ((await exec([
+					"npm",
+					"run",
+					"build"
+				], {
+					cwd: join(pkg.path),
+					stdio: "inherit"
+				})).exitCode !== 0) {
+					info(`failed to build ${pkg.json.name}`);
+					failed.push(asNonNull(pkg.json.name));
+					continue;
+				}
+			} else try {
+				await buildPackage({
+					workspaceRoot,
+					workspace,
+					packageName: asNonNull(pkg.json.name),
+					fixedVersion
+				});
+			} catch (err) {
+				info(`failed to build ${pkg.json.name}:`);
+				error(err instanceof Error ? err : new Error(String(err)));
+				failed.push(asNonNull(pkg.json.name));
+				continue;
+			}
+			let fullDistDir = join(pkg.path, distDir);
+			if (fixedVersion != null) {
+				let distPkgJsonPath = join(fullDistDir, "package.json");
+				let pkgJson = await parsePackageJsonFile(distPkgJsonPath);
+				pkgJson.version = fixedVersion;
+				await fsp.writeFile(distPkgJsonPath, JSON.stringify(pkgJson, null, 4));
+			}
+			info(`publishing ${pkg.json.name}@${pkgVersion}`);
+			if (pkg.json.name?.includes("/")) {
+				if (!publishArgs.some((it) => it.startsWith("--access"))) publishArgs.push("--access=public");
+			}
+			if ((await exec([
+				"npm",
+				...auth.extraArgs,
+				"publish",
+				"--registry",
+				registryUrl,
+				...dryRun ? ["--dry-run"] : ["-q"],
+				...publishArgs
+			], {
+				cwd: fullDistDir,
+				stdio: "inherit",
+				env: npmEnv
+			})).exitCode !== 0) failed.push(asNonNull(pkg.json.name));
+			if (withTarballs) {
+				let tar = await exec([
+					"npm",
+					"pack",
+					"-q"
+				], { cwd: fullDistDir });
+				if (tar.exitCode !== 0) error(new Error(tar.stderr));
+				else tarballs.push(join(fullDistDir, tar.stdout.trim()));
+			}
+		}
+		return {
+			failed,
+			tarballs
+		};
+	} finally {
+		await auth.cleanup();
+	}
+}
+var publishPackagesCli = command({
+	name: "publish",
+	desc: "publish packages to npm",
+	options: {
+		root: string().desc("path to the root of the workspace (default: cwd)"),
+		unpublishExisting: boolean("unpublish-existing").desc("whether to unpublish if the version is already published (only available for certain registries, won't work with registry.npmjs.org)"),
+		skipVersionCheck: boolean("skip-version-check").desc("whether to skip checking if the version is already published"),
+		registryUrl: string("registry").desc("URL of the registry to publish to"),
+		token: string("token").desc("token to use for publishing (passed via env and a temporary local .npmrc, never the global config)"),
+		distDir: string("dist-dir").desc("directory to publish from, relative to package root (default: dist)"),
+		dryRun: boolean("dry-run").desc("whether to skip publishing and only print what is going to happen"),
+		publishArgs: string("publish-args").desc("arguments to pass to `npm publish`"),
+		packages: positional("packages").desc("name of the packages to publish (comma-separated, or :all to publish the entire workspace)").default(":all"),
+		withTarballs: boolean("with-tarballs").desc("whether to generate tarballs in the dist directory using `npm pack` (doesn't work with jsr)"),
+		withBuild: boolean("with-build").desc("whether to build the package before publishing using `build` npm script (or defaulting to building using yorozu-build if one is not found)"),
+		fixedVersion: string("fixed-version").desc("fixed version for every managed package (useful for pre-releases)"),
+		noProvenance: boolean("no-provenance").desc("version to NOT use provenance even when it should be possible")
+	},
+	handler: async (options) => {
+		let { failed, tarballs } = await publishPackages({
+			...options,
+			workspaceRoot: options.root != null ? resolve(process$1.cwd(), options.root) : getWorkspaceRoot(),
+			packages: options.packages.split(","),
+			publishArgs: options.publishArgs?.split(" ")
+		});
+		if (failed.length > 0) {
+			info("failed to publish:");
+			for (let pkg of failed) info(`  ${pkg}`);
+			process$1.exit(1);
+		}
+		if (tarballs.length > 0) if (isRunningInGithubActions()) {
+			info("written paths to tarballs to `tarballs` output");
+			writeGithubActionsOutput("tarballs", tarballs.join(","));
+		} else {
+			info("tarballs generated:");
+			for (let tar of tarballs) info(`  ${tar}`);
+		}
+	}
+});
+//#endregion
+//#region src/cli/commands/docs.ts
+var CUSTOM_ROOT_FIELDS = ["includePackages", "excludePackages"];
+var DEFAULT_CONFIG = {
+	includeVersion: true,
+	validation: {
+		notExported: true,
+		invalidLink: true,
+		notDocumented: false
+	},
+	excludePrivate: true,
+	excludeExternals: true,
+	excludeInternal: true,
+	exclude: [
+		"**/*/node_modules",
+		"**/*.unit.ts",
+		"**/*.test.ts",
+		"**/*.test-utils.ts"
+	]
+};
+var YorozuTypedocReader = class {
+	name = "@yorozu/build";
+	order = 0;
+	supportsPackages = true;
+	_workspace;
+	_rootConfig;
+	constructor(workspaceRoot) {
+		this.workspaceRoot = workspaceRoot;
+	}
+	_forwardOptions(options, config, cwd) {
+		for (let [key, val] of Object.entries(config)) {
+			if (CUSTOM_ROOT_FIELDS.includes(key)) continue;
+			options.setValue(key, val, cwd);
+		}
+	}
+	async read(options, _logger, cwd, _usedFile) {
+		if (cwd === this.workspaceRoot) {
+			let config = await loadBuildConfig(cwd);
+			this._rootConfig = config;
+			let data = config?.typedoc;
+			if (data != null) this._forwardOptions(options, data, cwd);
+			options.setValue("entryPointStrategy", "packages");
+			this._workspace = await collectPackageJsons(cwd);
+			let entrypoints = [];
+			for (let pkg of this._workspace) {
+				let pkgName = asNonNull(pkg.json.name);
+				if (data?.includePackages && !data.includePackages.includes(pkgName)) continue;
+				if (data?.excludePackages?.includes(pkgName)) continue;
+				if (pkg.json.exports == null && !data?.includePackages?.includes(pkgName)) continue;
+				entrypoints.push(pkg.path);
+			}
+			options.setValue("entryPoints", entrypoints, cwd);
+			return;
+		}
+		let rootConfig = asNonNull(this._rootConfig);
+		if (rootConfig.typedoc != null) this._forwardOptions(options, rootConfig.typedoc, cwd);
+		let pkg = asNonNull(this._workspace?.find((item) => item.path.replace(/\/$/, "") === cwd.replace(/\/$/, "")));
+		let pkgConfig = await loadBuildConfig(cwd);
+		let hookContext = {
+			outDir: "",
+			packageDir: pkg.path,
+			packageName: asNonNull(pkg.json.name),
+			packageJson: pkg.json,
+			jsr: false,
+			typedoc: true
+		};
+		pkgConfig?.preparePackageJson?.(hookContext);
+		let { entrypoints } = processPackageJson({
+			packageJson: pkg.json,
+			onlyEntrypoints: true
+		});
+		options.setValue("entryPoints", Object.values(Object.fromEntries(entrypoints)), cwd);
+		if (!pkgConfig?.typedoc) return;
+		let data = pkgConfig.typedoc;
+		if (typeof data === "function") data = data(options.getRawValues());
+		this._forwardOptions(options, data, cwd);
+	}
+};
+async function generateDocs(params) {
+	let app = await td.Application.bootstrapWithPlugins(DEFAULT_CONFIG, [
+		new YorozuTypedocReader(params.workspaceRoot),
+		new td.TSConfigReader(),
+		new td.TypeDocReader()
+	]);
+	let project = await app.convert();
+	if (!project) throw new Error("Could not convert to typedoc project");
+	if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) throw new Error("There were warnings while converting the project");
+	let preValidationWarnCount = app.logger.warningCount;
+	app.validate(project);
+	let hadValidationWarnings = app.logger.warningCount !== preValidationWarnCount;
+	if (app.logger.hasErrors()) throw new Error("There were errors while validating the project");
+	if (hadValidationWarnings && (app.options.getValue("treatWarningsAsErrors") || app.options.getValue("treatValidationWarningsAsErrors"))) throw new Error("There were warnings while validating the project");
+	if (app.options.getValue("emit") === "none") return;
+	await app.generateOutputs(project);
+	if (app.logger.hasErrors()) throw new Error("There were errors while generating the outputs");
+	if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) throw new Error("There were warnings while generating the outputs");
+}
+var generateDocsCli = command({
+	name: "docs",
+	desc: "generate docs using typedoc",
+	options: { root: string().desc("path to the root of the workspace (default: cwd)") },
+	handler: async (args) => {
+		await generateDocs({ workspaceRoot: resolveWorkspaceRoot(args.root) });
+	}
+});
+//#endregion
+//#region src/cli/commands/gen-deps-graph.ts
+async function generateDepsGraph(params) {
+	let { workspaceRoot, includeRoot = false, includeExternal = false } = params;
+	let pjs = await collectPackageJsons(workspaceRoot, includeRoot);
+	let workspacePackages = /* @__PURE__ */ new Set();
+	let commonPrefix;
+	for (let { json: pj } of pjs) {
+		if (pj.name === void 0) continue;
+		workspacePackages.add(pj.name);
+		let [org, name] = pj.name.split("/");
+		if (!name) {
+			commonPrefix = void 0;
+			break;
+		}
+		if (commonPrefix === void 0) commonPrefix = org;
+		else if (commonPrefix !== org) {
+			commonPrefix = void 0;
+			break;
+		}
+	}
+	const getName = (name) => {
+		if (commonPrefix !== void 0) {
+			let [org, pkg] = name.split("/");
+			if (org === commonPrefix) return pkg;
+		}
+		return name;
+	};
+	let lines = [];
+	for (let { json: pj } of pjs) {
+		if (pj.name === void 0) continue;
+		let name = getName(pj.name);
+		for (let dep of Object.keys(pj.dependencies || {})) {
+			if (!workspacePackages.has(dep) && !includeExternal) continue;
+			lines.push(`"${name}" -> "${getName(dep)}"`);
+		}
+		for (let dep of Object.keys(pj.devDependencies || {})) {
+			if (!workspacePackages.has(dep) && !includeExternal) continue;
+			lines.push(`"${name}" -> "${getName(dep)}" [style=dashed,color=grey]`);
+		}
+	}
+	return `digraph {\n${lines.join("\n")}\n}`;
+}
+var generateDepsGraphCli = command({
+	name: "gen-deps-graph",
+	desc: "generate a graphviz dot file of the workspace dependencies",
+	options: {
+		includeRoot: boolean("include-root").desc("whether to include the root package.json in the graph"),
+		includeExternal: boolean("include-external").desc("whether to include external dependencies in the graph"),
+		root: string().desc("path to the root of the workspace (default: cwd)")
+	},
+	handler: async (args) => {
+		info(await generateDepsGraph({
+			workspaceRoot: resolveWorkspaceRoot(args.root),
+			includeRoot: args.includeRoot,
+			includeExternal: args.includeExternal
+		}));
+	}
+});
+//#endregion
+//#region src/git/utils.ts
+var CONVENTIONAL_COMMIT_RE = /^(\w+)(?:\(([^)]+)\))?(!?): (.+)$/;
+var BREAKING_CHANGE_RE = /^BREAKING[- ]CHANGE:/;
+async function getLatestTag(cwd) {
+	let res = await exec([
+		"git",
+		"describe",
+		"--abbrev=0",
+		"--tags"
+	], { cwd });
+	if (res.exitCode !== 0) {
+		if (res.stderr.match(/^fatal: (?:No names found|No tags can describe)/i)) return null;
+		throw new Error(`git describe failed: ${res.stderr}`);
+	}
+	return res.stdout.trim();
+}
+async function getFirstCommit(cwd) {
+	return (await exec([
+		"git",
+		"rev-list",
+		"--max-parents=0",
+		"HEAD"
+	], {
+		cwd,
+		throwOnError: true
+	})).stdout.trim();
+}
+async function getCurrentCommit(cwd) {
+	return (await exec([
+		"git",
+		"rev-parse",
+		"HEAD"
+	], {
+		cwd,
+		throwOnError: true
+	})).stdout.trim();
+}
+async function getCurrentBranch(cwd) {
+	return (await exec([
+		"git",
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	], {
+		cwd,
+		throwOnError: true
+	})).stdout.trim();
+}
+async function gitTagExists(tag, cwd) {
+	return (await exec([
+		"git",
+		"tag",
+		"--list",
+		tag
+	], {
+		cwd,
+		throwOnError: true
+	})).stdout.trim() !== "";
+}
+async function findChangedFiles(params) {
+	let { since, until = "HEAD", cwd } = params;
+	let files = (await exec([
+		"git",
+		"diff",
+		"--name-only",
+		since,
+		until
+	], {
+		cwd,
+		throwOnError: true
+	})).stdout.trim().split("\n");
+	if (files.length === 1 && files[0] === "") return [];
+	return files;
+}
+async function getCommitsBetween(params) {
+	let { since, until = "HEAD", cwd, files } = params;
+	let delim = `---${randomUUID()}---`;
+	let lines = (await exec([
+		"git",
+		"log",
+		`--pretty=format:%H %s%n%an%n%ae%n%aI%n%cn%n%ce%n%cI%n%b%n${delim}`,
+		since != null ? `${since}..${until}` : until,
+		...files?.length ? ["--", ...files] : []
+	], {
+		cwd,
+		throwOnError: true
+	})).stdout.trim().split("\n");
+	if (lines.length === 1 && lines[0] === "") return [];
+	let items = [];
+	let current = null;
+	for (let i = 0; i < lines.length; i++) {
+		let line = lines[i];
+		if (line === delim) {
+			if (current) items.push(current);
+			current = null;
+		} else if (current) {
+			if (current.description) current.description += "\n";
+			current.description += line;
+		} else {
+			let [hash, ...msg] = line.split(" ");
+			let authorName = lines[++i];
+			let authorEmail = lines[++i];
+			let authorDate = lines[++i];
+			let committerName = lines[++i];
+			let committerEmail = lines[++i];
+			let committerDate = lines[++i];
+			current = {
+				hash,
+				author: {
+					name: authorName,
+					email: authorEmail,
+					date: new Date(authorDate)
+				},
+				committer: {
+					name: committerName,
+					email: committerEmail,
+					date: new Date(committerDate)
+				},
+				message: msg.join(" "),
+				description: ""
+			};
+		}
+	}
+	if (current) items.push(current);
+	return items.reverse();
+}
+function parseConventionalCommit(msg) {
+	let [header, ...rest] = msg.split("\n");
+	let match = header.match(CONVENTIONAL_COMMIT_RE);
+	if (!match) return null;
+	let [, type, scope, bang, subject] = match;
+	let footerBreaking = rest.some((line) => BREAKING_CHANGE_RE.test(line.trim()));
+	return {
+		type,
+		...scope ? { scope } : {},
+		breaking: Boolean(bang) || footerBreaking,
+		subject
+	};
+}
+//#endregion
+//#region src/misc/tsconfig.ts
+var import_picomatch = /* @__PURE__ */ __toESM$1(require_picomatch(), 1);
+var tsconfigFilesCache = new LruMap(32);
+async function getTsconfigFor(cwd) {
+	let res = await exec([
+		"npx",
+		"tsc",
+		"--showConfig"
+	], {
+		cwd,
+		throwOnError: true
+	});
+	return JSON.parse(res.stdout);
+}
+async function getTsconfigFiles(cwd) {
+	let cached = tsconfigFilesCache.get(cwd);
+	if (cached) return cached;
+	let config = await getTsconfigFor(cwd);
+	if (typeof config !== "object" || config === null) throw new Error("tsconfig.json is not an object");
+	if (!("files" in config) || !Array.isArray(config.files)) throw new Error("tsconfig.json > .files is not an array");
+	let files = config.files.map((file) => file.replace(/^\.\//, ""));
+	tsconfigFilesCache.set(cwd, files);
+	return files;
+}
+//#endregion
+//#region src/versioning/collect-files.ts
+var DEFAULT_EXCLUDE = ["**/*.unit.ts", "**/*.md"];
+async function defaultShouldInclude(file) {
+	if (!file.file.endsWith(".ts")) return true;
+	try {
+		return (await getTsconfigFiles(join(file.root, file.package.path))).includes(file.file);
+	} catch {
+		return true;
+	}
+}
+function fileBelongsToPackage(file, pkgPath) {
+	if (pkgPath === "" || pkgPath === ".") return true;
+	return file === pkgPath || file.startsWith(`${pkgPath}/`);
+}
+async function findProjectChangedFiles(params) {
+	let { params: { include, exclude = DEFAULT_EXCLUDE, shouldInclude = defaultShouldInclude } = {}, root: rootInput = process$1.cwd(), since, until } = params;
+	let root = normalizeFilePath(rootInput);
+	let changed = await findChangedFiles({
+		since,
+		until,
+		cwd: root
+	});
+	if (!changed.length) return [];
+	let packages = (params.workspace ?? await collectPackageJsons(root)).filter((pkg) => !pkg.root).map((pkg) => ({
+		pkg,
+		relPath: relative(root, pkg.path)
+	})).sort((a, b) => b.relPath.length - a.relPath.length);
+	let files = [];
+	let includeGlobs = include == null ? null : (0, import_picomatch.default)(include);
+	let excludeGlobs = exclude == null ? null : (0, import_picomatch.default)(exclude);
+	for (let file of changed) {
+		let match = packages.find((item) => fileBelongsToPackage(file, item.relPath));
+		if (!match) continue;
+		let relPath = relative(match.relPath, file);
+		if (includeGlobs != null && !includeGlobs(relPath)) continue;
+		if (excludeGlobs != null && excludeGlobs(relPath)) continue;
+		let info = {
+			file: relPath,
+			package: match.pkg,
+			root
+		};
+		if (!await shouldInclude(info)) continue;
+		files.push(info);
+	}
+	return files;
+}
+async function findProjectChangedPackages(params) {
+	let files = await findProjectChangedFiles(params);
+	let set = /* @__PURE__ */ new Set();
+	for (let file of files) set.add(file.package);
+	return Array.from(set);
+}
+//#endregion
+//#region src/cli/commands/cr.ts
+function selectChangedNpmPackages(params) {
+	let { publishable, changed } = params;
+	let selected = [...changed];
+	let selectedNames = /* @__PURE__ */ new Set();
+	for (let pkg of selected) selectedNames.add(asNonNull(pkg.json.name));
+	let hadChanges = true;
+	while (hadChanges) {
+		hadChanges = false;
+		for (let pkg of publishable) {
+			let pkgName = asNonNull(pkg.json.name);
+			for (let field of ["dependencies", "peerDependencies"]) {
+				let deps = pkg.json[field];
+				if (deps == null) continue;
+				for (let name of Object.keys(deps)) if (selectedNames.has(name) && !selectedNames.has(pkgName)) {
+					hadChanges = true;
+					selected.push(pkg);
+					selectedNames.add(pkgName);
+					break;
+				}
+			}
+		}
+	}
+	return filterPackageJsonsForPublish(selected, "npm");
+}
+async function runContinuousRelease(params) {
+	let { workspaceRoot = resolveWorkspaceRoot(), workspace = await collectPackageJsons(workspaceRoot, true), distDir = "dist", extraArgs = [], onlyChanged = false, onlyChangedSince } = params;
+	let workspaceWithoutRoot = workspace.filter((pkg) => !pkg.root);
+	let packages = filterPackageJsonsForPublish(workspaceWithoutRoot, "npm");
+	if (onlyChanged) {
+		let config = await loadConfig({
+			workspaceRoot,
+			require: false
+		});
+		let since = onlyChangedSince ?? await getLatestTag(workspaceRoot);
+		if (since == null) throw new Error("no previous tag found, cannot determine changeset");
+		let changedPackages = await findProjectChangedPackages({
+			params: config?.versioning,
+			workspace: workspaceWithoutRoot,
+			root: workspaceRoot,
+			since
+		});
+		if (!changedPackages.length) {
+			info(`no packages changed since ${since}, nothing to do`);
+			return;
+		}
+		packages = selectChangedNpmPackages({
+			publishable: packages,
+			changed: changedPackages
+		});
+		if (!packages.length) {
+			info(`no packages changed since ${since}, nothing to do`);
+			return;
+		}
+		info(`only publishing changed packages since ${since}:`);
+		for (let pkg of packages) info(`  - ${pkg.json.name}`);
+	}
+	if (!isRunningInGithubActions()) throw new Error("cr command is only supported in github actions");
+	let distPaths = [];
+	for (let pkg of packages) {
+		if (pkg.json.scripts?.build !== void 0) await exec([
+			"npm",
+			"run",
+			"build"
+		], {
+			cwd: join(pkg.path),
+			stdio: "inherit",
+			throwOnError: true
+		});
+		else await buildPackage({
+			workspaceRoot,
+			workspace,
+			packageName: asNonNull(pkg.json.name)
+		});
+		distPaths.push(join(pkg.path, distDir));
+	}
+	if (extraArgs.some((item) => item.startsWith("--pnpm"))) warn("`--pnpm` flag is not supported and may cause issues, please avoid using it");
+	await exec([
+		"npx",
+		"pkg-pr-new",
+		"publish",
+		...extraArgs,
+		...distPaths
+	], {
+		cwd: workspaceRoot,
+		throwOnError: true,
+		stdio: "inherit"
+	});
+}
+var runContinuousReleaseCli = command({
+	name: "cr",
+	desc: "publish the workspace to pkg.pr.new",
+	options: {
+		root: string().desc("path to the root of the workspace (default: cwd)"),
+		distDir: string("dist-dir").desc("directory to publish from, relative to package root (default: dist)"),
+		extraArgs: string("extra-args").desc("extra arguments to pass to pkg-pr-new"),
+		onlyChanged: boolean("only-changed").desc("whether to only publish packages changed since the last release.").default(false),
+		onlyChangedSince: string("only-changed-since").desc("starting point for the changelog (defaults to latest tag)")
+	},
+	transform: (args) => {
+		return {
+			workspaceRoot: resolveWorkspaceRoot(args.root),
+			distDir: args.distDir,
+			extraArgs: args.extraArgs?.split(" "),
+			onlyChanged: args.onlyChanged,
+			onlyChangedSince: args.onlyChangedSince
+		};
+	},
+	handler: runContinuousRelease
+});
+//#endregion
+//#region src/cli/commands/lint/validate-workspace-deps.ts
+var import_semver = /* @__PURE__ */ __toESM$1(require_semver(), 1);
+var DEP_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+function versionsCompatible(version, otherVersion) {
+	if (otherVersion.match(/^(?:https?:\/\/|catalog:)/)) return version === otherVersion;
+	if ((0, import_semver.valid)(version) != null) return (0, import_semver.satisfies)(version, otherVersion);
+	if ((0, import_semver.validRange)(version) != null) return (0, import_semver.subset)(otherVersion, version);
+	return version === otherVersion;
+}
+async function validateWorkspaceDeps(params) {
+	let { workspaceRoot, config: { includeRoot, externalDependencies: { enabled: externalDependenciesEnabled = true, skipPeerDependencies: externalDependenciesSkipPeerDependencies = false, shouldSkip: externalDependenciesShouldSkip } = {} } = {} } = params;
+	let packages = params.packages ?? await collectPackageJsons(workspaceRoot, includeRoot);
+	let packagesMap = new Map(packages.map((pkg) => [pkg.json.name, pkg]));
+	let versions = {};
+	let errors = [];
+	for (let pkg of packages) {
+		let pj = pkg.json;
+		if (pj.name === void 0) throw new Error("package.json without name is not supported");
+		for (let field of DEP_FIELDS) {
+			let deps = pj[field];
+			if (!deps) continue;
+			for (let [name, version] of Object.entries(deps)) {
+				if (packagesMap.has(name)) {
+					let otherPkg = packagesMap.get(name);
+					if (!Boolean(otherPkg?.json.yorozu?.standalone) && !version.startsWith("workspace:")) errors.push({
+						type: "internal",
+						package: pj.name,
+						dependency: name,
+						subtype: "not_workspace_proto"
+					});
+					continue;
+				}
+				if (version.startsWith("workspace:")) {
+					errors.push({
+						type: "internal",
+						package: pj.name,
+						dependency: name,
+						subtype: "not_workspace_dep"
+					});
+					continue;
+				}
+				if (!externalDependenciesEnabled) continue;
+				if (field === "peerDependencies" && externalDependenciesSkipPeerDependencies) continue;
+				if (externalDependenciesShouldSkip?.({
+					package: pkg,
+					dependency: name,
+					version,
+					field
+				})) continue;
+				if (versions[name] === void 0) versions[name] = {};
+				for (let [pkgName, pkgDepVersion] of Object.entries(versions[name])) if (!versionsCompatible(version, pkgDepVersion)) errors.push({
+					type: "external",
+					package: pj.name,
+					dependency: name,
+					version,
+					at: field,
+					otherPackage: pkgName,
+					otherVersion: pkgDepVersion
+				});
+				versions[name][pj.name] = version;
+			}
+		}
+	}
+	return errors;
+}
+//#endregion
+//#region src/git/github.ts
+var USER_AGENT = "@yorozu/build";
+var GITHUB_API_VERSION = "2022-11-28";
+var DEFAULT_API_URL = "https://api.github.com";
+var REQUEST_TIMEOUT_MS = 3e4;
+var UPLOAD_TIMEOUT_MS = 6e4;
+var ReleaseResponseSchema = object({
+	id: number(),
+	upload_url: string$1()
+});
+function toBodyInit(body) {
+	return body;
+}
+function githubHeaders(token, extra) {
+	return {
+		Accept: "application/vnd.github+json",
+		"User-Agent": USER_AGENT,
+		"X-GitHub-Api-Version": GITHUB_API_VERSION,
+		Authorization: `Bearer ${token}`,
+		...extra
+	};
+}
+async function readErrorBody(res) {
+	try {
+		return await res.text();
+	} catch {
+		return "";
+	}
+}
+async function createGithubRelease(params) {
+	let apiUrl = (params.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "");
+	let res = await fetch(`${apiUrl}/repos/${params.repo}/releases`, {
+		method: "POST",
+		headers: githubHeaders(params.token, { "Content-Type": "application/json" }),
+		body: JSON.stringify({
+			tag_name: params.tag,
+			name: params.name,
+			body: params.body,
+			draft: params.draft ?? false,
+			prerelease: params.prerelease ?? false
+		}),
+		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+	});
+	if (res.status !== 201) throw new Error(`GitHub release request failed with ${res.status}: ${await readErrorBody(res)}`);
+	let release = ReleaseResponseSchema.parse(await res.json());
+	let uploadUrl = release.upload_url.split("{")[0];
+	if (params.artifacts != null && params.artifacts.length > 0) await asyncPool(params.artifacts, async (file) => {
+		let url = new URL(uploadUrl);
+		url.searchParams.set("name", file.name);
+		let upload = await fetch(url, {
+			method: "POST",
+			headers: githubHeaders(params.token, {
+				"Content-Type": file.type,
+				"Content-Length": String(file.body.byteLength)
+			}),
+			body: toBodyInit(file.body),
+			signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS)
+		});
+		if (upload.status !== 201) throw new Error(`failed to upload artifact: ${file.name}: GitHub artifact upload failed with ${upload.status}: ${await readErrorBody(upload)}`);
+	});
+	return release.id;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/detect-indent@7.0.2/node_modules/detect-indent/index.js
+var INDENT_REGEX = /^(?:( )+|\t+)/;
+var INDENT_TYPE_SPACE = "space";
+var INDENT_TYPE_TAB = "tab";
+function shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, value) {
+	return ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && value === 1;
+}
+/**
+Make a Map that counts how many indents/unindents have occurred for a given size and how many lines follow a given indentation.
+
+The key is a concatenation of the indentation type (s = space and t = tab) and the size of the indents/unindents.
+
+```
+indents = {
+t3: [1, 0],
+t4: [1, 5],
+s5: [1, 0],
+s12: [1, 0],
+}
+```
+*/
+function makeIndentsMap(string, ignoreSingleSpaces) {
+	const indents = /* @__PURE__ */ new Map();
+	let previousSize = 0;
+	let previousIndentType;
+	let key;
+	for (const line of string.split(/\n/g)) {
+		if (!line) continue;
+		const matches = line.match(INDENT_REGEX);
+		if (matches === null) {
+			previousSize = 0;
+			previousIndentType = "";
+		} else {
+			const indent = matches[0].length;
+			const indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+			if (shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, indent)) continue;
+			if (indentType !== previousIndentType) previousSize = 0;
+			previousIndentType = indentType;
+			let use = 1;
+			let weight = 0;
+			const indentDifference = indent - previousSize;
+			previousSize = indent;
+			if (indentDifference === 0) {
+				use = 0;
+				weight = 1;
+			} else {
+				const absoluteIndentDifference = Math.abs(indentDifference);
+				if (shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, absoluteIndentDifference)) continue;
+				key = encodeIndentsKey(indentType, absoluteIndentDifference);
+			}
+			const entry = indents.get(key);
+			indents.set(key, entry === void 0 ? [1, 0] : [entry[0] + use, entry[1] + weight]);
+		}
+	}
+	return indents;
+}
+function encodeIndentsKey(indentType, indentAmount) {
+	return (indentType === INDENT_TYPE_SPACE ? "s" : "t") + String(indentAmount);
+}
+function decodeIndentsKey(indentsKey) {
+	return {
+		type: indentsKey[0] === "s" ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB,
+		amount: Number(indentsKey.slice(1))
+	};
+}
+function getMostUsedKey(indents) {
+	let result;
+	let maxUsed = 0;
+	let maxWeight = 0;
+	for (const [key, [usedCount, weight]] of indents) if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
+		maxUsed = usedCount;
+		maxWeight = weight;
+		result = key;
+	}
+	return result;
+}
+function makeIndentString(type, amount) {
+	return (type === INDENT_TYPE_SPACE ? " " : "	").repeat(amount);
+}
+function detectIndent(string) {
+	if (typeof string !== "string") throw new TypeError("Expected a string");
+	let indents = makeIndentsMap(string, true);
+	if (indents.size === 0) indents = makeIndentsMap(string, false);
+	const keyOfMostUsedIndent = getMostUsedKey(indents);
+	let type;
+	let amount = 0;
+	let indent = "";
+	if (keyOfMostUsedIndent !== void 0) {
+		({type, amount} = decodeIndentsKey(keyOfMostUsedIndent));
+		indent = makeIndentString(type, amount);
+	}
+	return {
+		amount,
+		type,
+		indent
+	};
+}
+//#endregion
+//#region src/versioning/bump-version.ts
+function isOwnVersioning(pkg) {
+	return Boolean(pkg.json.yorozu?.ownVersioning);
+}
+function isStandalone(pkg) {
+	return Boolean(pkg.json.yorozu?.standalone);
+}
+function isManaged(pkg) {
+	return !pkg.root && !isOwnVersioning(pkg) && !isStandalone(pkg);
+}
+function parseCommit(commit) {
+	return parseConventionalCommit(`${commit.message}\n${commit.description}`);
+}
+function summarizeCommits(commits) {
+	let hasBreakingChanges = false;
+	let hasFeatures = false;
+	for (let commit of commits) {
+		let parsed = parseCommit(commit);
+		if (!parsed) continue;
+		if (parsed.breaking) hasBreakingChanges = true;
+		if (parsed.type === "feat") hasFeatures = true;
+	}
+	return {
+		hasBreakingChanges,
+		hasFeatures
+	};
+}
+function bumpFromFlags(oldVersion, flags) {
+	let parsedVersion = (0, import_semver.parse)(oldVersion);
+	if (!parsedVersion) throw new Error(`Invalid version: ${oldVersion}`);
+	if (flags.hasBreakingChanges) {
+		if (parsedVersion.major === 0 && parsedVersion.minor === 0) return "patch";
+		if (parsedVersion.major === 0) return "minor";
+		return "major";
+	}
+	if (flags.hasFeatures) return parsedVersion.major === 0 ? "patch" : "minor";
+	return "patch";
+}
+function determineBumpType(params) {
+	return bumpFromFlags(params.oldVersion, summarizeCommits(params.commits));
+}
+async function writePackageVersion(pkg, version, dryRun) {
+	if (!dryRun) {
+		let pkgJsonPath = pkg.packageJsonPath;
+		let pkgJsonText = await readFile(pkgJsonPath, "utf8");
+		let indent = detectIndent(pkgJsonText).indent || "    ";
+		let pkgJson = JSON.parse(pkgJsonText);
+		pkgJson.version = version;
+		await writeFile(pkgJsonPath, `${JSON.stringify(pkgJson, null, indent)}\n`);
+	}
+	pkg.json.version = version;
+}
+async function nextStandaloneVersion(pkg, cwd) {
+	let current = asNonNull(pkg.json.version);
+	let tag;
+	try {
+		tag = await getLatestTag(pkg.path);
+	} catch {
+		tag = null;
+	}
+	if (tag == null) return current;
+	let commits;
+	try {
+		let rel = relative(normalizeFilePath(cwd), pkg.path);
+		let pathspec = rel === "" || rel === "." ? "." : rel.endsWith("/") ? rel : `${rel}/`;
+		commits = await getCommitsBetween({
+			since: tag,
+			cwd,
+			files: [pathspec]
+		});
+	} catch {
+		return current;
+	}
+	if (commits.length === 0) return current;
+	let bumpType = determineBumpType({
+		oldVersion: current,
+		commits
+	});
+	let next = (0, import_semver.inc)(current, bumpType);
+	if (next == null) throw new Error(`Invalid version increment: ${current} → ${bumpType}`);
+	return next;
+}
+function recordVersion(nextVersions, changedPackages, pkg, prevVersion, next) {
+	if (pkg.json.name != null) nextVersions[pkg.json.name] = next;
+	if (next !== prevVersion) changedPackages.push({
+		package: pkg,
+		prevVersion
+	});
+}
+async function bumpVersion(params) {
+	let { workspace, type: explicitType, cwd = process$1.cwd(), since, dryRun = false, withRoot = false } = params;
+	let rootPackage = findRootPackage(workspace);
+	let previousVersion = rootPackage.json.version;
+	if (previousVersion == null) throw new Error("Workspace root package.json is missing a version");
+	let type;
+	let hasFeatures = false;
+	let hasBreakingChanges = false;
+	if (explicitType == null) {
+		let commits = await getCommitsBetween({
+			since,
+			cwd
+		});
+		({hasFeatures, hasBreakingChanges} = summarizeCommits(commits));
+		type = bumpFromFlags(previousVersion, {
+			hasFeatures,
+			hasBreakingChanges
+		});
+	} else type = explicitType;
+	let nextVersion = (0, import_semver.inc)(previousVersion, type);
+	if (nextVersion == null) throw new Error(`Invalid version increment: ${previousVersion} → ${type}`);
+	let nextVersions = {};
+	let changedPackages = [];
+	for (let pkg of workspace) {
+		if (!isManaged(pkg)) continue;
+		let prevVersion = asNonNull(pkg.json.version);
+		await writePackageVersion(pkg, nextVersion, dryRun);
+		recordVersion(nextVersions, changedPackages, pkg, prevVersion, nextVersion);
+	}
+	if (withRoot) {
+		await writePackageVersion(rootPackage, nextVersion, dryRun);
+		recordVersion(nextVersions, changedPackages, rootPackage, previousVersion, nextVersion);
+	}
+	for (let pkg of workspace) {
+		if (pkg.root || isOwnVersioning(pkg) || !isStandalone(pkg)) continue;
+		let prevVersion = asNonNull(pkg.json.version);
+		let standaloneNext = await nextStandaloneVersion(pkg, cwd);
+		if (standaloneNext === prevVersion) continue;
+		await writePackageVersion(pkg, standaloneNext, dryRun);
+		recordVersion(nextVersions, changedPackages, pkg, prevVersion, standaloneNext);
+	}
+	return {
+		previousVersion,
+		nextVersion,
+		nextVersions,
+		changedPackages,
+		releaseType: type,
+		hasBreakingChanges,
+		hasFeatures
+	};
+}
+//#endregion
+//#region src/versioning/generate-changelog.ts
+var SKIPPED_TYPES = new Set([
+	"chore",
+	"ci",
+	"docs",
+	"test"
+]);
+function defaultOnParseFailed(commit) {
+	warn(`Failed to parse commit message: ${commit.message}`);
+}
+function defaultCommitFormatter(commit, parsed) {
+	let line = `- ${commit.hash}: ${parsed.breaking ? "**❗ BREAKING** " : ""}${commit.message}`;
+	if (parsed.breaking && commit.description) line += `\n${commit.description.trim().split("\n").map((item) => `  ${item}`).join("\n")}`;
+	return line;
+}
+function defaultCommitFilter(_commit, parsed) {
+	if (parsed.breaking) return true;
+	if (!parsed.type || SKIPPED_TYPES.has(parsed.type)) return false;
+	return true;
+}
+function defaultPackageCommitsFormatter(packageName, commits) {
+	return `### ${packageName}\n${Object.values(commits).join("\n")}`;
+}
+async function generateChangelog(params) {
+	let { cwd, since, params: { changelog: { onCommitParseFailed = defaultOnParseFailed, onCommitsFetched, commitFilter = defaultCommitFilter, commitFilterWithFiles, commitFormatter = defaultCommitFormatter, packageCommitsFormatter = defaultPackageCommitsFormatter } = {} } = {} } = params;
+	let commitsByPackage = {};
+	let changedFiles = await findProjectChangedFiles({
+		params: params.params ?? {},
+		workspace: params.workspace,
+		root: cwd,
+		since
+	});
+	let changedFilesByPackage = /* @__PURE__ */ new Map();
+	for (let file of changedFiles) changedFilesByPackage.set(join(relative(file.root, file.package.path), file.file), file.package);
+	let commits = await getCommitsBetween({
+		since,
+		cwd
+	});
+	await onCommitsFetched?.(commits);
+	for (let commit of commits) {
+		let parsed = parseConventionalCommit(`${commit.message}\n${commit.description}`);
+		if (!parsed) {
+			onCommitParseFailed(commit);
+			continue;
+		}
+		if (!commitFilter(commit, parsed)) continue;
+		let changed = await findChangedFiles({
+			since: `${commit.hash}~1`,
+			until: commit.hash,
+			cwd
+		});
+		if (commitFilterWithFiles && !commitFilterWithFiles(commit, parsed, changed)) continue;
+		for (let file of changed) {
+			let pkg = changedFilesByPackage.get(file);
+			if (!pkg) continue;
+			let packageName = asNonNull(pkg.json.name);
+			if (commitsByPackage[packageName] == null) commitsByPackage[packageName] = {};
+			commitsByPackage[packageName][commit.hash] = commitFormatter(commit, parsed, changed);
+		}
+	}
+	let changelog = "";
+	for (let [pkg, packageCommits] of Object.entries(commitsByPackage)) {
+		changelog += packageCommitsFormatter(pkg, packageCommits);
+		changelog += "\n\n";
+	}
+	return changelog;
+}
+//#endregion
+export { LruMap, NPM_PACKAGE_NAME_REGEX, boolean, buildPackage, buildPackageCli, buildWorkspace, bumpVersion, command, createGithubRelease, determineBumpType, findChangedFiles, findProjectChangedFiles, findProjectChangedPackages, generateChangelog, generateDepsGraph, generateDepsGraphCli, generateDocs, generateDocsCli, getCommitsBetween, getCurrentBranch, getCurrentCommit, getFirstCommit, getGithubActionsInput, getLatestTag, getTsconfigFiles, getTsconfigFor, gitTagExists, isRunningInGithubActions, loadConfig, npmCheckVersion, parseConventionalCommit, publishPackages, publishPackagesCli, resolveWorkspaceRoot, run, runContinuousRelease, runContinuousReleaseCli, string, validateWorkspaceDeps, writeGithubActionsOutput };