@baton-dx/cli 0.4.4 → 0.5.0

package/dist/{src-dY02psbw.mjs → src-n95I0s2u.mjs}

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
-import { n as __require, r as __toESM, t as __commonJSMin } from "./chunk-BbwQpWto.mjs";
-import { m as require_dist } from "./context-detection-Ddu0mj_K.mjs";
-import { i as AI_TOOL_PATHS, r as evaluateDetection } from "./ai-tool-detection-CMsBNa9e.mjs";
-import { d as esm_default, m as simpleGit } from "./esm-BagM-kVd.mjs";
+import { _ as __commonJSMin, m as require_dist$2, v as __require, y as __toESM } from "./context-detection-C7T1evnW.mjs";
+import { i as AI_TOOL_PATHS, r as evaluateDetection } from "./ai-tool-detection-DMnwwNBI.mjs";
 import { access, mkdir, readFile, readdir, rm, rmdir, stat, symlink, unlink, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, normalize, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { spawn } from "child_process";
+import { EventEmitter } from "node:events";
 import { execFile } from "node:child_process";
 
 //#region ../ai-tool-paths/src/types.ts
@@ -146,7 +147,7 @@ var FileNotFoundError = class extends BatonError {
 
 //#endregion
 //#region ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/util.js
-var util;
+var util$1;
 (function(util) {
 	util.assertEqual = (_) => {};
 	function assertIs(_arg) {}
@@ -188,7 +189,7 @@ var util;
 		if (typeof value === "bigint") return value.toString();
 		return value;
 	};
-})(util || (util = {}));
+})(util$1 || (util$1 = {}));
 var objectUtil;
 (function(objectUtil) {
 	objectUtil.mergeShapes = (first, second) => {
@@ -198,7 +199,7 @@ var objectUtil;
 		};
 	};
 })(objectUtil || (objectUtil = {}));
-const ZodParsedType = util.arrayToEnum([
+const ZodParsedType = util$1.arrayToEnum([
 	"string",
 	"nan",
 	"number",
@@ -243,7 +244,7 @@ const getParsedType = (data) => {
 
 //#endregion
 //#region ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/ZodError.js
-const ZodIssueCode = util.arrayToEnum([
+const ZodIssueCode = util$1.arrayToEnum([
 	"invalid_type",
 	"invalid_literal",
 	"custom",
@@ -315,7 +316,7 @@ var ZodError = class ZodError extends Error {
 		return this.message;
 	}
 	get message() {
-		return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
+		return JSON.stringify(this.issues, util$1.jsonStringifyReplacer, 2);
 	}
 	get isEmpty() {
 		return this.issues.length === 0;
@@ -351,19 +352,19 @@ const errorMap = (issue, _ctx) => {
 			else message = `Expected ${issue.expected}, received ${issue.received}`;
 			break;
 		case ZodIssueCode.invalid_literal:
-			message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
+			message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util$1.jsonStringifyReplacer)}`;
 			break;
 		case ZodIssueCode.unrecognized_keys:
-			message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
+			message = `Unrecognized key(s) in object: ${util$1.joinValues(issue.keys, ", ")}`;
 			break;
 		case ZodIssueCode.invalid_union:
 			message = `Invalid input`;
 			break;
 		case ZodIssueCode.invalid_union_discriminator:
-			message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
+			message = `Invalid discriminator value. Expected ${util$1.joinValues(issue.options)}`;
 			break;
 		case ZodIssueCode.invalid_enum_value:
-			message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
+			message = `Invalid enum value. Expected ${util$1.joinValues(issue.options)}, received '${issue.received}'`;
 			break;
 		case ZodIssueCode.invalid_arguments:
 			message = `Invalid function arguments`;
@@ -380,7 +381,7 @@ const errorMap = (issue, _ctx) => {
 				if (typeof issue.validation.position === "number") message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
 			} else if ("startsWith" in issue.validation) message = `Invalid input: must start with "${issue.validation.startsWith}"`;
 			else if ("endsWith" in issue.validation) message = `Invalid input: must end with "${issue.validation.endsWith}"`;
-			else util.assertNever(issue.validation);
+			else util$1.assertNever(issue.validation);
 			else if (issue.validation !== "regex") message = `Invalid ${issue.validation}`;
 			else message = "Invalid";
 			break;
@@ -414,7 +415,7 @@ const errorMap = (issue, _ctx) => {
 			break;
 		default:
 			message = _ctx.defaultError;
-			util.assertNever(issue);
+			util$1.assertNever(issue);
 	}
 	return { message };
 };
@@ -1212,7 +1213,7 @@ var ZodString = class ZodString extends ZodType {
 				});
 				status.dirty();
 			}
-		} else util.assertNever(check);
+		} else util$1.assertNever(check);
 		return {
 			status: status.value,
 			value: input.data
@@ -1521,7 +1522,7 @@ var ZodNumber = class ZodNumber extends ZodType {
 		let ctx = void 0;
 		const status = new ParseStatus();
 		for (const check of this._def.checks) if (check.kind === "int") {
-			if (!util.isInteger(input.data)) {
+			if (!util$1.isInteger(input.data)) {
 				ctx = this._getOrReturnCtx(input, ctx);
 				addIssueToContext(ctx, {
 					code: ZodIssueCode.invalid_type,
@@ -1576,7 +1577,7 @@ var ZodNumber = class ZodNumber extends ZodType {
 				});
 				status.dirty();
 			}
-		} else util.assertNever(check);
+		} else util$1.assertNever(check);
 		return {
 			status: status.value,
 			value: input.data
@@ -1690,7 +1691,7 @@ var ZodNumber = class ZodNumber extends ZodType {
 		return max;
 	}
 	get isInt() {
-		return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value));
+		return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util$1.isInteger(ch.value));
 	}
 	get isFinite() {
 		let max = null;
@@ -1761,7 +1762,7 @@ var ZodBigInt = class ZodBigInt extends ZodType {
 				});
 				status.dirty();
 			}
-		} else util.assertNever(check);
+		} else util$1.assertNever(check);
 		return {
 			status: status.value,
 			value: input.data
@@ -1933,7 +1934,7 @@ var ZodDate = class ZodDate extends ZodType {
 				});
 				status.dirty();
 			}
-		} else util.assertNever(check);
+		} else util$1.assertNever(check);
 		return {
 			status: status.value,
 			value: new Date(input.data.getTime())
@@ -2256,7 +2257,7 @@ var ZodObject = class ZodObject extends ZodType {
 		const shape = this._def.shape();
 		this._cached = {
 			shape,
-			keys: util.objectKeys(shape)
+			keys: util$1.objectKeys(shape)
 		};
 		return this._cached;
 	}
@@ -2404,7 +2405,7 @@ var ZodObject = class ZodObject extends ZodType {
 	}
 	pick(mask) {
 		const shape = {};
-		for (const key of util.objectKeys(mask)) if (mask[key] && this.shape[key]) shape[key] = this.shape[key];
+		for (const key of util$1.objectKeys(mask)) if (mask[key] && this.shape[key]) shape[key] = this.shape[key];
 		return new ZodObject({
 			...this._def,
 			shape: () => shape
@@ -2412,7 +2413,7 @@ var ZodObject = class ZodObject extends ZodType {
 	}
 	omit(mask) {
 		const shape = {};
-		for (const key of util.objectKeys(this.shape)) if (!mask[key]) shape[key] = this.shape[key];
+		for (const key of util$1.objectKeys(this.shape)) if (!mask[key]) shape[key] = this.shape[key];
 		return new ZodObject({
 			...this._def,
 			shape: () => shape
@@ -2426,7 +2427,7 @@ var ZodObject = class ZodObject extends ZodType {
 	}
 	partial(mask) {
 		const newShape = {};
-		for (const key of util.objectKeys(this.shape)) {
+		for (const key of util$1.objectKeys(this.shape)) {
 			const fieldSchema = this.shape[key];
 			if (mask && !mask[key]) newShape[key] = fieldSchema;
 			else newShape[key] = fieldSchema.optional();
@@ -2438,7 +2439,7 @@ var ZodObject = class ZodObject extends ZodType {
 	}
 	required(mask) {
 		const newShape = {};
-		for (const key of util.objectKeys(this.shape)) if (mask && !mask[key]) newShape[key] = this.shape[key];
+		for (const key of util$1.objectKeys(this.shape)) if (mask && !mask[key]) newShape[key] = this.shape[key];
 		else {
 			let newField = this.shape[key];
 			while (newField instanceof ZodOptional) newField = newField._def.innerType;
@@ -2450,7 +2451,7 @@ var ZodObject = class ZodObject extends ZodType {
 		});
 	}
 	keyof() {
-		return createZodEnum(util.objectKeys(this.shape));
+		return createZodEnum(util$1.objectKeys(this.shape));
 	}
 };
 ZodObject.create = (shape, params) => {
@@ -2567,7 +2568,7 @@ const getDiscriminator = (type) => {
 	else if (type instanceof ZodEffects) return getDiscriminator(type.innerType());
 	else if (type instanceof ZodLiteral) return [type.value];
 	else if (type instanceof ZodEnum) return type.options;
-	else if (type instanceof ZodNativeEnum) return util.objectValues(type.enum);
+	else if (type instanceof ZodNativeEnum) return util$1.objectValues(type.enum);
 	else if (type instanceof ZodDefault) return getDiscriminator(type._def.innerType);
 	else if (type instanceof ZodUndefined) return [void 0];
 	else if (type instanceof ZodNull) return [null];
@@ -2655,8 +2656,8 @@ function mergeValues(a, b) {
 		data: a
 	};
 	else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
-		const bKeys = util.objectKeys(b);
-		const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
+		const bKeys = util$1.objectKeys(b);
+		const sharedKeys = util$1.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
 		const newObj = {
 			...a,
 			...b
@@ -3161,7 +3162,7 @@ var ZodEnum = class ZodEnum extends ZodType {
 			const ctx = this._getOrReturnCtx(input);
 			const expectedValues = this._def.values;
 			addIssueToContext(ctx, {
-				expected: util.joinValues(expectedValues),
+				expected: util$1.joinValues(expectedValues),
 				received: ctx.parsedType,
 				code: ZodIssueCode.invalid_type
 			});
@@ -3214,20 +3215,20 @@ var ZodEnum = class ZodEnum extends ZodType {
 ZodEnum.create = createZodEnum;
 var ZodNativeEnum = class extends ZodType {
 	_parse(input) {
-		const nativeEnumValues = util.getValidEnumValues(this._def.values);
+		const nativeEnumValues = util$1.getValidEnumValues(this._def.values);
 		const ctx = this._getOrReturnCtx(input);
 		if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
-			const expectedValues = util.objectValues(nativeEnumValues);
+			const expectedValues = util$1.objectValues(nativeEnumValues);
 			addIssueToContext(ctx, {
-				expected: util.joinValues(expectedValues),
+				expected: util$1.joinValues(expectedValues),
 				received: ctx.parsedType,
 				code: ZodIssueCode.invalid_type
 			});
 			return INVALID;
 		}
-		if (!this._cache) this._cache = new Set(util.getValidEnumValues(this._def.values));
+		if (!this._cache) this._cache = new Set(util$1.getValidEnumValues(this._def.values));
 		if (!this._cache.has(input.data)) {
-			const expectedValues = util.objectValues(nativeEnumValues);
+			const expectedValues = util$1.objectValues(nativeEnumValues);
 			addIssueToContext(ctx, {
 				received: ctx.data,
 				code: ZodIssueCode.invalid_enum_value,
@@ -3384,7 +3385,7 @@ var ZodEffects = class extends ZodType {
 				value: result
 			}));
 		});
-		util.assertNever(effect);
+		util$1.assertNever(effect);
 	}
 };
 ZodEffects.create = (schema, effect, params) => {
@@ -3909,7 +3910,7 @@ const lockfileSchema = objectType({
 
 //#endregion
 //#region ../core/src/utils/yaml-parser.ts
-var import_dist = require_dist();
+var import_dist$2 = require_dist$2();
 function isErrnoException(error) {
 	return error instanceof Error && "code" in error;
 }
@@ -3918,7 +3919,7 @@ function isErrnoException(error) {
 */
 async function loadAndValidateYaml(filePath, schema, entityName) {
 	try {
-		const data = (0, import_dist.parse)(await readFile(filePath, "utf-8"));
+		const data = (0, import_dist$2.parse)(await readFile(filePath, "utf-8"));
 		const result = schema.safeParse(data);
 		if (!result.success) throw new ManifestValidationError(`Invalid ${entityName}: ${result.error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("; ")}`);
 		return result.data;
@@ -3933,7 +3934,7 @@ async function loadAndValidateYaml(filePath, schema, entityName) {
 */
 async function loadProfileManifest(filePath) {
 	try {
-		const raw = (0, import_dist.parse)(await readFile(filePath, "utf-8"));
+		const raw = (0, import_dist$2.parse)(await readFile(filePath, "utf-8"));
 		if (raw && typeof raw === "object" && "tools" in raw && !raw.ai?.tools) console.warn(`Warning: "${filePath}" has top-level "tools:" — this is ignored. Move it under "ai:" section:\n\nai:\n  tools:\n    - ...\n`);
 	} catch {}
 	return loadAndValidateYaml(filePath, profileManifestSchema, "profile manifest");
@@ -3944,12 +3945,6 @@ async function loadProfileManifest(filePath) {
 async function loadProjectManifest(filePath) {
 	return loadAndValidateYaml(filePath, projectManifestSchema, "project manifest");
 }
-/**
-* Loads and validates a lockfile from a YAML file
-*/
-async function loadLockfile(filePath) {
-	return loadAndValidateYaml(filePath, lockfileSchema, "lockfile");
-}
 
 //#endregion
 //#region ../core/src/utils/source-parser.ts
@@ -4073,7 +4068,7 @@ function parseFrontmatter(raw) {
 	const yamlBlock = trimmed.slice(4, endIndex);
 	const content = trimmed.slice(endIndex + 4).trimStart();
 	try {
-		const data = (0, import_dist.parse)(yamlBlock);
+		const data = (0, import_dist$2.parse)(yamlBlock);
 		return {
 			data: typeof data === "object" && data !== null ? data : {},
 			content
@@ -4107,7 +4102,7 @@ var BaseAIToolAdapter = class {
 	memoryFilename = "AGENTS.md";
 	async isInstalled() {
 		try {
-			const { detectInstalledAITools } = await import("./ai-tool-detection-BFep6YS9.mjs");
+			const { detectInstalledAITools } = await import("./ai-tool-detection-Bw4qveB8.mjs");
 			return (await detectInstalledAITools()).includes(this.key);
 		} catch {
 			return false;
@@ -4760,7 +4755,7 @@ async function removeGitignoreManagedSection(projectRoot) {
 * predictable .gitignore content regardless of which tools a profile supports
 * or a developer has installed.
 *
-* Returns deduplicated, sorted patterns including baton.lock.
+* Returns deduplicated, sorted patterns for AI tool and IDE configurations.
 */
 function collectComprehensivePatterns(options) {
 	const patterns = /* @__PURE__ */ new Set();
@@ -4783,10 +4778,4526 @@ function collectComprehensivePatterns(options) {
 		}
 	}
 	for (const target of fileTargets) patterns.add(target);
-	patterns.add("baton.lock");
 	return [...patterns].sort();
 }
 
+//#endregion
+//#region ../../node_modules/.bun/ms@2.1.3/node_modules/ms/index.js
+var require_ms = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Helpers.
+	*/
+	var s = 1e3;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+	/**
+	* Parse or format the given `val`.
+	*
+	* Options:
+	*
+	*  - `long` verbose formatting [false]
+	*
+	* @param {String|Number} val
+	* @param {Object} [options]
+	* @throws {Error} throw an error if val is not a non-empty string or a number
+	* @return {String|Number}
+	* @api public
+	*/
+	module.exports = function(val, options) {
+		options = options || {};
+		var type = typeof val;
+		if (type === "string" && val.length > 0) return parse(val);
+		else if (type === "number" && isFinite(val)) return options.long ? fmtLong(val) : fmtShort(val);
+		throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
+	};
+	/**
+	* Parse the given `str` and return milliseconds.
+	*
+	* @param {String} str
+	* @return {Number}
+	* @api private
+	*/
+	function parse(str) {
+		str = String(str);
+		if (str.length > 100) return;
+		var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+		if (!match) return;
+		var n = parseFloat(match[1]);
+		switch ((match[2] || "ms").toLowerCase()) {
+			case "years":
+			case "year":
+			case "yrs":
+			case "yr":
+			case "y": return n * y;
+			case "weeks":
+			case "week":
+			case "w": return n * w;
+			case "days":
+			case "day":
+			case "d": return n * d;
+			case "hours":
+			case "hour":
+			case "hrs":
+			case "hr":
+			case "h": return n * h;
+			case "minutes":
+			case "minute":
+			case "mins":
+			case "min":
+			case "m": return n * m;
+			case "seconds":
+			case "second":
+			case "secs":
+			case "sec":
+			case "s": return n * s;
+			case "milliseconds":
+			case "millisecond":
+			case "msecs":
+			case "msec":
+			case "ms": return n;
+			default: return;
+		}
+	}
+	/**
+	* Short format for `ms`.
+	*
+	* @param {Number} ms
+	* @return {String}
+	* @api private
+	*/
+	function fmtShort(ms) {
+		var msAbs = Math.abs(ms);
+		if (msAbs >= d) return Math.round(ms / d) + "d";
+		if (msAbs >= h) return Math.round(ms / h) + "h";
+		if (msAbs >= m) return Math.round(ms / m) + "m";
+		if (msAbs >= s) return Math.round(ms / s) + "s";
+		return ms + "ms";
+	}
+	/**
+	* Long format for `ms`.
+	*
+	* @param {Number} ms
+	* @return {String}
+	* @api private
+	*/
+	function fmtLong(ms) {
+		var msAbs = Math.abs(ms);
+		if (msAbs >= d) return plural(ms, msAbs, d, "day");
+		if (msAbs >= h) return plural(ms, msAbs, h, "hour");
+		if (msAbs >= m) return plural(ms, msAbs, m, "minute");
+		if (msAbs >= s) return plural(ms, msAbs, s, "second");
+		return ms + " ms";
+	}
+	/**
+	* Pluralization helper.
+	*/
+	function plural(ms, msAbs, n, name) {
+		var isPlural = msAbs >= n * 1.5;
+		return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/common.js
+var require_common = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* This is the common logic for both the Node.js and web browser
+	* implementations of `debug()`.
+	*/
+	function setup(env) {
+		createDebug.debug = createDebug;
+		createDebug.default = createDebug;
+		createDebug.coerce = coerce;
+		createDebug.disable = disable;
+		createDebug.enable = enable;
+		createDebug.enabled = enabled;
+		createDebug.humanize = require_ms();
+		createDebug.destroy = destroy;
+		Object.keys(env).forEach((key) => {
+			createDebug[key] = env[key];
+		});
+		/**
+		* The currently active debug mode names, and names to skip.
+		*/
+		createDebug.names = [];
+		createDebug.skips = [];
+		/**
+		* Map of special "%n" handling functions, for the debug "format" argument.
+		*
+		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+		*/
+		createDebug.formatters = {};
+		/**
+		* Selects a color for a debug namespace
+		* @param {String} namespace The namespace string for the debug instance to be colored
+		* @return {Number|String} An ANSI color code for the given namespace
+		* @api private
+		*/
+		function selectColor(namespace) {
+			let hash = 0;
+			for (let i = 0; i < namespace.length; i++) {
+				hash = (hash << 5) - hash + namespace.charCodeAt(i);
+				hash |= 0;
+			}
+			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+		}
+		createDebug.selectColor = selectColor;
+		/**
+		* Create a debugger with the given `namespace`.
+		*
+		* @param {String} namespace
+		* @return {Function}
+		* @api public
+		*/
+		function createDebug(namespace) {
+			let prevTime;
+			let enableOverride = null;
+			let namespacesCache;
+			let enabledCache;
+			function debug(...args) {
+				if (!debug.enabled) return;
+				const self = debug;
+				const curr = Number(/* @__PURE__ */ new Date());
+				self.diff = curr - (prevTime || curr);
+				self.prev = prevTime;
+				self.curr = curr;
+				prevTime = curr;
+				args[0] = createDebug.coerce(args[0]);
+				if (typeof args[0] !== "string") args.unshift("%O");
+				let index = 0;
+				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+					if (match === "%%") return "%";
+					index++;
+					const formatter = createDebug.formatters[format];
+					if (typeof formatter === "function") {
+						const val = args[index];
+						match = formatter.call(self, val);
+						args.splice(index, 1);
+						index--;
+					}
+					return match;
+				});
+				createDebug.formatArgs.call(self, args);
+				(self.log || createDebug.log).apply(self, args);
+			}
+			debug.namespace = namespace;
+			debug.useColors = createDebug.useColors();
+			debug.color = createDebug.selectColor(namespace);
+			debug.extend = extend;
+			debug.destroy = createDebug.destroy;
+			Object.defineProperty(debug, "enabled", {
+				enumerable: true,
+				configurable: false,
+				get: () => {
+					if (enableOverride !== null) return enableOverride;
+					if (namespacesCache !== createDebug.namespaces) {
+						namespacesCache = createDebug.namespaces;
+						enabledCache = createDebug.enabled(namespace);
+					}
+					return enabledCache;
+				},
+				set: (v) => {
+					enableOverride = v;
+				}
+			});
+			if (typeof createDebug.init === "function") createDebug.init(debug);
+			return debug;
+		}
+		function extend(namespace, delimiter) {
+			const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+			newDebug.log = this.log;
+			return newDebug;
+		}
+		/**
+		* Enables a debug mode by namespaces. This can include modes
+		* separated by a colon and wildcards.
+		*
+		* @param {String} namespaces
+		* @api public
+		*/
+		function enable(namespaces) {
+			createDebug.save(namespaces);
+			createDebug.namespaces = namespaces;
+			createDebug.names = [];
+			createDebug.skips = [];
+			const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+			for (const ns of split) if (ns[0] === "-") createDebug.skips.push(ns.slice(1));
+			else createDebug.names.push(ns);
+		}
+		/**
+		* Checks if the given string matches a namespace template, honoring
+		* asterisks as wildcards.
+		*
+		* @param {String} search
+		* @param {String} template
+		* @return {Boolean}
+		*/
+		function matchesTemplate(search, template) {
+			let searchIndex = 0;
+			let templateIndex = 0;
+			let starIndex = -1;
+			let matchIndex = 0;
+			while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) if (template[templateIndex] === "*") {
+				starIndex = templateIndex;
+				matchIndex = searchIndex;
+				templateIndex++;
+			} else {
+				searchIndex++;
+				templateIndex++;
+			}
+			else if (starIndex !== -1) {
+				templateIndex = starIndex + 1;
+				matchIndex++;
+				searchIndex = matchIndex;
+			} else return false;
+			while (templateIndex < template.length && template[templateIndex] === "*") templateIndex++;
+			return templateIndex === template.length;
+		}
+		/**
+		* Disable debug output.
+		*
+		* @return {String} namespaces
+		* @api public
+		*/
+		function disable() {
+			const namespaces = [...createDebug.names, ...createDebug.skips.map((namespace) => "-" + namespace)].join(",");
+			createDebug.enable("");
+			return namespaces;
+		}
+		/**
+		* Returns true if the given mode name is enabled, false otherwise.
+		*
+		* @param {String} name
+		* @return {Boolean}
+		* @api public
+		*/
+		function enabled(name) {
+			for (const skip of createDebug.skips) if (matchesTemplate(name, skip)) return false;
+			for (const ns of createDebug.names) if (matchesTemplate(name, ns)) return true;
+			return false;
+		}
+		/**
+		* Coerce `val`.
+		*
+		* @param {Mixed} val
+		* @return {Mixed}
+		* @api private
+		*/
+		function coerce(val) {
+			if (val instanceof Error) return val.stack || val.message;
+			return val;
+		}
+		/**
+		* XXX DO NOT USE. This is a temporary stub function.
+		* XXX It WILL be removed in the next major release.
+		*/
+		function destroy() {
+			console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+		}
+		createDebug.enable(createDebug.load());
+		return createDebug;
+	}
+	module.exports = setup;
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/browser.js
+var require_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* This is the web browser implementation of `debug()`.
+	*/
+	exports.formatArgs = formatArgs;
+	exports.save = save;
+	exports.load = load;
+	exports.useColors = useColors;
+	exports.storage = localstorage();
+	exports.destroy = (() => {
+		let warned = false;
+		return () => {
+			if (!warned) {
+				warned = true;
+				console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+			}
+		};
+	})();
+	/**
+	* Colors.
+	*/
+	exports.colors = [
+		"#0000CC",
+		"#0000FF",
+		"#0033CC",
+		"#0033FF",
+		"#0066CC",
+		"#0066FF",
+		"#0099CC",
+		"#0099FF",
+		"#00CC00",
+		"#00CC33",
+		"#00CC66",
+		"#00CC99",
+		"#00CCCC",
+		"#00CCFF",
+		"#3300CC",
+		"#3300FF",
+		"#3333CC",
+		"#3333FF",
+		"#3366CC",
+		"#3366FF",
+		"#3399CC",
+		"#3399FF",
+		"#33CC00",
+		"#33CC33",
+		"#33CC66",
+		"#33CC99",
+		"#33CCCC",
+		"#33CCFF",
+		"#6600CC",
+		"#6600FF",
+		"#6633CC",
+		"#6633FF",
+		"#66CC00",
+		"#66CC33",
+		"#9900CC",
+		"#9900FF",
+		"#9933CC",
+		"#9933FF",
+		"#99CC00",
+		"#99CC33",
+		"#CC0000",
+		"#CC0033",
+		"#CC0066",
+		"#CC0099",
+		"#CC00CC",
+		"#CC00FF",
+		"#CC3300",
+		"#CC3333",
+		"#CC3366",
+		"#CC3399",
+		"#CC33CC",
+		"#CC33FF",
+		"#CC6600",
+		"#CC6633",
+		"#CC9900",
+		"#CC9933",
+		"#CCCC00",
+		"#CCCC33",
+		"#FF0000",
+		"#FF0033",
+		"#FF0066",
+		"#FF0099",
+		"#FF00CC",
+		"#FF00FF",
+		"#FF3300",
+		"#FF3333",
+		"#FF3366",
+		"#FF3399",
+		"#FF33CC",
+		"#FF33FF",
+		"#FF6600",
+		"#FF6633",
+		"#FF9900",
+		"#FF9933",
+		"#FFCC00",
+		"#FFCC33"
+	];
+	/**
+	* Currently only WebKit-based Web Inspectors, Firefox >= v31,
+	* and the Firebug extension (any Firefox version) are known
+	* to support "%c" CSS customizations.
+	*
+	* TODO: add a `localStorage` variable to explicitly enable/disable colors
+	*/
+	function useColors() {
+		if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) return true;
+		if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) return false;
+		let m;
+		return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+	}
+	/**
+	* Colorize log arguments if enabled.
+	*
+	* @api public
+	*/
+	function formatArgs(args) {
+		args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+		if (!this.useColors) return;
+		const c = "color: " + this.color;
+		args.splice(1, 0, c, "color: inherit");
+		let index = 0;
+		let lastC = 0;
+		args[0].replace(/%[a-zA-Z%]/g, (match) => {
+			if (match === "%%") return;
+			index++;
+			if (match === "%c") lastC = index;
+		});
+		args.splice(lastC, 0, c);
+	}
+	/**
+	* Invokes `console.debug()` when available.
+	* No-op when `console.debug` is not a "function".
+	* If `console.debug` is not available, falls back
+	* to `console.log`.
+	*
+	* @api public
+	*/
+	exports.log = console.debug || console.log || (() => {});
+	/**
+	* Save `namespaces`.
+	*
+	* @param {String} namespaces
+	* @api private
+	*/
+	function save(namespaces) {
+		try {
+			if (namespaces) exports.storage.setItem("debug", namespaces);
+			else exports.storage.removeItem("debug");
+		} catch (error) {}
+	}
+	/**
+	* Load `namespaces`.
+	*
+	* @return {String} returns the previously persisted debug modes
+	* @api private
+	*/
+	function load() {
+		let r;
+		try {
+			r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+		} catch (error) {}
+		if (!r && typeof process !== "undefined" && "env" in process) r = process.env.DEBUG;
+		return r;
+	}
+	/**
+	* Localstorage attempts to return the localstorage.
+	*
+	* This is necessary because safari throws
+	* when a user disables cookies/localstorage
+	* and you attempt to access it.
+	*
+	* @return {LocalStorage}
+	* @api private
+	*/
+	function localstorage() {
+		try {
+			return localStorage;
+		} catch (error) {}
+	}
+	module.exports = require_common()(exports);
+	const { formatters } = module.exports;
+	/**
+	* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+	*/
+	formatters.j = function(v) {
+		try {
+			return JSON.stringify(v);
+		} catch (error) {
+			return "[UnexpectedJSONParseError]: " + error.message;
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/has-flag@4.0.0/node_modules/has-flag/index.js
+var require_has_flag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = (flag, argv = process.argv) => {
+		const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+		const position = argv.indexOf(prefix + flag);
+		const terminatorPosition = argv.indexOf("--");
+		return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/supports-color@7.2.0/node_modules/supports-color/index.js
+var require_supports_color = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const os = __require("os");
+	const tty$1 = __require("tty");
+	const hasFlag = require_has_flag();
+	const { env } = process;
+	let forceColor;
+	if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) forceColor = 0;
+	else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) forceColor = 1;
+	if ("FORCE_COLOR" in env) if (env.FORCE_COLOR === "true") forceColor = 1;
+	else if (env.FORCE_COLOR === "false") forceColor = 0;
+	else forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+	function translateLevel(level) {
+		if (level === 0) return false;
+		return {
+			level,
+			hasBasic: true,
+			has256: level >= 2,
+			has16m: level >= 3
+		};
+	}
+	function supportsColor(haveStream, streamIsTTY) {
+		if (forceColor === 0) return 0;
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+		if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+		const min = forceColor || 0;
+		if (env.TERM === "dumb") return min;
+		if (process.platform === "win32") {
+			const osRelease = os.release().split(".");
+			if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+			return 1;
+		}
+		if ("CI" in env) {
+			if ([
+				"TRAVIS",
+				"CIRCLECI",
+				"APPVEYOR",
+				"GITLAB_CI",
+				"GITHUB_ACTIONS",
+				"BUILDKITE"
+			].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+			return min;
+		}
+		if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+		if (env.COLORTERM === "truecolor") return 3;
+		if ("TERM_PROGRAM" in env) {
+			const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+			switch (env.TERM_PROGRAM) {
+				case "iTerm.app": return version >= 3 ? 3 : 2;
+				case "Apple_Terminal": return 2;
+			}
+		}
+		if (/-256(color)?$/i.test(env.TERM)) return 2;
+		if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+		if ("COLORTERM" in env) return 1;
+		return min;
+	}
+	function getSupportLevel(stream) {
+		return translateLevel(supportsColor(stream, stream && stream.isTTY));
+	}
+	module.exports = {
+		supportsColor: getSupportLevel,
+		stdout: translateLevel(supportsColor(true, tty$1.isatty(1))),
+		stderr: translateLevel(supportsColor(true, tty$1.isatty(2)))
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/node.js
+var require_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	*/
+	const tty = __require("tty");
+	const util = __require("util");
+	/**
+	* This is the Node.js implementation of `debug()`.
+	*/
+	exports.init = init;
+	exports.log = log;
+	exports.formatArgs = formatArgs;
+	exports.save = save;
+	exports.load = load;
+	exports.useColors = useColors;
+	exports.destroy = util.deprecate(() => {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+	/**
+	* Colors.
+	*/
+	exports.colors = [
+		6,
+		2,
+		3,
+		4,
+		5,
+		1
+	];
+	try {
+		const supportsColor = require_supports_color();
+		if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) exports.colors = [
+			20,
+			21,
+			26,
+			27,
+			32,
+			33,
+			38,
+			39,
+			40,
+			41,
+			42,
+			43,
+			44,
+			45,
+			56,
+			57,
+			62,
+			63,
+			68,
+			69,
+			74,
+			75,
+			76,
+			77,
+			78,
+			79,
+			80,
+			81,
+			92,
+			93,
+			98,
+			99,
+			112,
+			113,
+			128,
+			129,
+			134,
+			135,
+			148,
+			149,
+			160,
+			161,
+			162,
+			163,
+			164,
+			165,
+			166,
+			167,
+			168,
+			169,
+			170,
+			171,
+			172,
+			173,
+			178,
+			179,
+			184,
+			185,
+			196,
+			197,
+			198,
+			199,
+			200,
+			201,
+			202,
+			203,
+			204,
+			205,
+			206,
+			207,
+			208,
+			209,
+			214,
+			215,
+			220,
+			221
+		];
+	} catch (error) {}
+	/**
+	* Build up the default `inspectOpts` object from the environment variables.
+	*
+	*   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+	*/
+	exports.inspectOpts = Object.keys(process.env).filter((key) => {
+		return /^debug_/i.test(key);
+	}).reduce((obj, key) => {
+		const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+			return k.toUpperCase();
+		});
+		let val = process.env[key];
+		if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
+		else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
+		else if (val === "null") val = null;
+		else val = Number(val);
+		obj[prop] = val;
+		return obj;
+	}, {});
+	/**
+	* Is stdout a TTY? Colored output is enabled when `true`.
+	*/
+	function useColors() {
+		return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+	}
+	/**
+	* Adds ANSI color escape codes if enabled.
+	*
+	* @api public
+	*/
+	function formatArgs(args) {
+		const { namespace: name, useColors } = this;
+		if (useColors) {
+			const c = this.color;
+			const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+			const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+			args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+			args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+		} else args[0] = getDate() + name + " " + args[0];
+	}
+	function getDate() {
+		if (exports.inspectOpts.hideDate) return "";
+		return (/* @__PURE__ */ new Date()).toISOString() + " ";
+	}
+	/**
+	* Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
+	*/
+	function log(...args) {
+		return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
+	}
+	/**
+	* Save `namespaces`.
+	*
+	* @param {String} namespaces
+	* @api private
+	*/
+	function save(namespaces) {
+		if (namespaces) process.env.DEBUG = namespaces;
+		else delete process.env.DEBUG;
+	}
+	/**
+	* Load `namespaces`.
+	*
+	* @return {String} returns the previously persisted debug modes
+	* @api private
+	*/
+	function load() {
+		return process.env.DEBUG;
+	}
+	/**
+	* Init logic for `debug` instances.
+	*
+	* Create a new `inspectOpts` object in case `useColors` is set
+	* differently for a particular `debug` instance.
+	*/
+	function init(debug) {
+		debug.inspectOpts = {};
+		const keys = Object.keys(exports.inspectOpts);
+		for (let i = 0; i < keys.length; i++) debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+	}
+	module.exports = require_common()(exports);
+	const { formatters } = module.exports;
+	/**
+	* Map %o to `util.inspect()`, all on a single line.
+	*/
+	formatters.o = function(v) {
+		this.inspectOpts.colors = this.useColors;
+		return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+	};
+	/**
+	* Map %O to `util.inspect()`, allowing multiple lines if needed.
+	*/
+	formatters.O = function(v) {
+		this.inspectOpts.colors = this.useColors;
+		return util.inspect(v, this.inspectOpts);
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/index.js
+var require_src$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Detect Electron renderer / nwjs process, which is node, but we should
+	* treat as a browser.
+	*/
+	if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) module.exports = require_browser();
+	else module.exports = require_node();
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/src/index.js
+var require_src = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const fs_1 = __require("fs");
+	const log = __importDefault(require_src$1()).default("@kwsites/file-exists");
+	function check(path, isFile, isDirectory) {
+		log(`checking %s`, path);
+		try {
+			const stat = fs_1.statSync(path);
+			if (stat.isFile() && isFile) {
+				log(`[OK] path represents a file`);
+				return true;
+			}
+			if (stat.isDirectory() && isDirectory) {
+				log(`[OK] path represents a directory`);
+				return true;
+			}
+			log(`[FAIL] path represents something other than a file or directory`);
+			return false;
+		} catch (e) {
+			if (e.code === "ENOENT") {
+				log(`[FAIL] path is not accessible: %o`, e);
+				return false;
+			}
+			log(`[FATAL] %o`, e);
+			throw e;
+		}
+	}
+	/**
+	* Synchronous validation of a path existing either as a file or as a directory.
+	*
+	* @param {string} path The path to check
+	* @param {number} type One or both of the exported numeric constants
+	*/
+	function exists(path, type = exports.READABLE) {
+		return check(path, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+	}
+	exports.exists = exists;
+	/**
+	* Constant representing a file
+	*/
+	exports.FILE = 1;
+	/**
+	* Constant representing a folder
+	*/
+	exports.FOLDER = 2;
+	/**
+	* Constant representing either a file or a folder
+	*/
+	exports.READABLE = exports.FILE + exports.FOLDER;
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/index.js
+var require_dist$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	function __export(m) {
+		for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+	}
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__export(require_src());
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/@kwsites+promise-deferred@1.1.1/node_modules/@kwsites/promise-deferred/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createDeferred = exports.deferred = void 0;
+	/**
+	* Creates a new `DeferredPromise`
+	*
+	* ```typescript
+	import {deferred} from '@kwsites/promise-deferred`;
+	```
+	*/
+	function deferred() {
+		let done;
+		let fail;
+		let status = "pending";
+		return {
+			promise: new Promise((_done, _fail) => {
+				done = _done;
+				fail = _fail;
+			}),
+			done(result) {
+				if (status === "pending") {
+					status = "resolved";
+					done(result);
+				}
+			},
+			fail(error) {
+				if (status === "pending") {
+					status = "rejected";
+					fail(error);
+				}
+			},
+			get fulfilled() {
+				return status !== "pending";
+			},
+			get status() {
+				return status;
+			}
+		};
+	}
+	exports.deferred = deferred;
+	/**
+	* Alias of the exported `deferred` function, to help consumers wanting to use `deferred` as the
+	* local variable name rather than the factory import name, without needing to rename on import.
+	*
+	* ```typescript
+	import {createDeferred} from '@kwsites/promise-deferred`;
+	```
+	*/
+	exports.createDeferred = deferred;
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/simple-git@3.30.0/node_modules/simple-git/dist/esm/index.js
+var import_dist = require_dist$1();
+var import_src = /* @__PURE__ */ __toESM(require_src$1(), 1);
+var import_dist$1 = require_dist();
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+function pathspec(...paths) {
+	const key = new String(paths);
+	cache.set(key, paths);
+	return key;
+}
+function isPathSpec(path) {
+	return path instanceof String && cache.has(path);
+}
+function toPaths(pathSpec) {
+	return cache.get(pathSpec) || [];
+}
+var cache;
+var init_pathspec = __esm({ "src/lib/args/pathspec.ts"() {
+	"use strict";
+	cache = /* @__PURE__ */ new WeakMap();
+} });
+var GitError;
+var init_git_error = __esm({ "src/lib/errors/git-error.ts"() {
+	"use strict";
+	GitError = class extends Error {
+		constructor(task, message) {
+			super(message);
+			this.task = task;
+			Object.setPrototypeOf(this, new.target.prototype);
+		}
+	};
+} });
+var GitResponseError;
+var init_git_response_error = __esm({ "src/lib/errors/git-response-error.ts"() {
+	"use strict";
+	init_git_error();
+	GitResponseError = class extends GitError {
+		constructor(git, message) {
+			super(void 0, message || String(git));
+			this.git = git;
+		}
+	};
+} });
+var TaskConfigurationError;
+var init_task_configuration_error = __esm({ "src/lib/errors/task-configuration-error.ts"() {
+	"use strict";
+	init_git_error();
+	TaskConfigurationError = class extends GitError {
+		constructor(message) {
+			super(void 0, message);
+		}
+	};
+} });
+function asFunction(source) {
+	if (typeof source !== "function") return NOOP;
+	return source;
+}
+function isUserFunction(source) {
+	return typeof source === "function" && source !== NOOP;
+}
+function splitOn(input, char) {
+	const index = input.indexOf(char);
+	if (index <= 0) return [input, ""];
+	return [input.substr(0, index), input.substr(index + 1)];
+}
+function first(input, offset = 0) {
+	return isArrayLike(input) && input.length > offset ? input[offset] : void 0;
+}
+function last(input, offset = 0) {
+	if (isArrayLike(input) && input.length > offset) return input[input.length - 1 - offset];
+}
+function isArrayLike(input) {
+	return filterHasLength(input);
+}
+function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
+	return input.split(separator).reduce((output, line) => {
+		const lineContent = trimmed2 ? line.trim() : line;
+		if (lineContent) output.push(lineContent);
+		return output;
+	}, []);
+}
+function forEachLineWithContent(input, callback) {
+	return toLinesWithContent(input, true).map((line) => callback(line));
+}
+function folderExists(path) {
+	return (0, import_dist.exists)(path, import_dist.FOLDER);
+}
+function append(target, item) {
+	if (Array.isArray(target)) {
+		if (!target.includes(item)) target.push(item);
+	} else target.add(item);
+	return item;
+}
+function including(target, item) {
+	if (Array.isArray(target) && !target.includes(item)) target.push(item);
+	return target;
+}
+function remove(target, item) {
+	if (Array.isArray(target)) {
+		const index = target.indexOf(item);
+		if (index >= 0) target.splice(index, 1);
+	} else target.delete(item);
+	return item;
+}
+function asArray(source) {
+	return Array.isArray(source) ? source : [source];
+}
+function asCamelCase(str) {
+	return str.replace(/[\s-]+(.)/g, (_all, chr) => {
+		return chr.toUpperCase();
+	});
+}
+function asStringArray(source) {
+	return asArray(source).map((item) => {
+		return item instanceof String ? item : String(item);
+	});
+}
+function asNumber(source, onNaN = 0) {
+	if (source == null) return onNaN;
+	const num = parseInt(source, 10);
+	return Number.isNaN(num) ? onNaN : num;
+}
+function prefixedArray(input, prefix) {
+	const output = [];
+	for (let i = 0, max = input.length; i < max; i++) output.push(prefix, input[i]);
+	return output;
+}
+function bufferToString(input) {
+	return (Array.isArray(input) ? Buffer$1.concat(input) : input).toString("utf-8");
+}
+function pick(source, properties) {
+	const out = {};
+	properties.forEach((key) => {
+		if (source[key] !== void 0) out[key] = source[key];
+	});
+	return out;
+}
+function delay(duration = 0) {
+	return new Promise((done) => setTimeout(done, duration));
+}
+function orVoid(input) {
+	if (input === false) return;
+	return input;
+}
+var NULL, NOOP, objectToString;
+var init_util = __esm({ "src/lib/utils/util.ts"() {
+	"use strict";
+	init_argument_filters();
+	NULL = "\0";
+	NOOP = () => {};
+	objectToString = Object.prototype.toString.call.bind(Object.prototype.toString);
+} });
+function filterType(input, filter, def) {
+	if (filter(input)) return input;
+	return arguments.length > 2 ? def : void 0;
+}
+function filterPrimitives(input, omit) {
+	const type = isPathSpec(input) ? "string" : typeof input;
+	return /number|string|boolean/.test(type) && (!omit || !omit.includes(type));
+}
+function filterPlainObject(input) {
+	return !!input && objectToString(input) === "[object Object]";
+}
+function filterFunction(input) {
+	return typeof input === "function";
+}
+var filterArray, filterNumber, filterString, filterStringOrStringArray, filterHasLength;
+var init_argument_filters = __esm({ "src/lib/utils/argument-filters.ts"() {
+	"use strict";
+	init_pathspec();
+	init_util();
+	filterArray = (input) => {
+		return Array.isArray(input);
+	};
+	filterNumber = (input) => {
+		return typeof input === "number";
+	};
+	filterString = (input) => {
+		return typeof input === "string";
+	};
+	filterStringOrStringArray = (input) => {
+		return filterString(input) || Array.isArray(input) && input.every(filterString);
+	};
+	filterHasLength = (input) => {
+		if (input == null || "number|boolean|function".includes(typeof input)) return false;
+		return typeof input.length === "number";
+	};
+} });
+var ExitCodes;
+var init_exit_codes = __esm({ "src/lib/utils/exit-codes.ts"() {
+	"use strict";
+	ExitCodes = /* @__PURE__ */ ((ExitCodes2) => {
+		ExitCodes2[ExitCodes2["SUCCESS"] = 0] = "SUCCESS";
+		ExitCodes2[ExitCodes2["ERROR"] = 1] = "ERROR";
+		ExitCodes2[ExitCodes2["NOT_FOUND"] = -2] = "NOT_FOUND";
+		ExitCodes2[ExitCodes2["UNCLEAN"] = 128] = "UNCLEAN";
+		return ExitCodes2;
+	})(ExitCodes || {});
+} });
+var GitOutputStreams;
+var init_git_output_streams = __esm({ "src/lib/utils/git-output-streams.ts"() {
+	"use strict";
+	GitOutputStreams = class _GitOutputStreams {
+		constructor(stdOut, stdErr) {
+			this.stdOut = stdOut;
+			this.stdErr = stdErr;
+		}
+		asStrings() {
+			return new _GitOutputStreams(this.stdOut.toString("utf8"), this.stdErr.toString("utf8"));
+		}
+	};
+} });
+function useMatchesDefault() {
+	throw new Error(`LineParser:useMatches not implemented`);
+}
+var LineParser, RemoteLineParser;
+var init_line_parser = __esm({ "src/lib/utils/line-parser.ts"() {
+	"use strict";
+	LineParser = class {
+		constructor(regExp, useMatches) {
+			this.matches = [];
+			this.useMatches = useMatchesDefault;
+			this.parse = (line, target) => {
+				this.resetMatches();
+				if (!this._regExp.every((reg, index) => this.addMatch(reg, index, line(index)))) return false;
+				return this.useMatches(target, this.prepareMatches()) !== false;
+			};
+			this._regExp = Array.isArray(regExp) ? regExp : [regExp];
+			if (useMatches) this.useMatches = useMatches;
+		}
+		resetMatches() {
+			this.matches.length = 0;
+		}
+		prepareMatches() {
+			return this.matches;
+		}
+		addMatch(reg, index, line) {
+			const matched = line && reg.exec(line);
+			if (matched) this.pushMatch(index, matched);
+			return !!matched;
+		}
+		pushMatch(_index, matched) {
+			this.matches.push(...matched.slice(1));
+		}
+	};
+	RemoteLineParser = class extends LineParser {
+		addMatch(reg, index, line) {
+			return /^remote:\s/.test(String(line)) && super.addMatch(reg, index, line);
+		}
+		pushMatch(index, matched) {
+			if (index > 0 || matched.length > 1) super.pushMatch(index, matched);
+		}
+	};
+} });
+function createInstanceConfig(...options) {
+	const baseDir = process.cwd();
+	const config = Object.assign({
+		baseDir,
+		...defaultOptions
+	}, ...options.filter((o) => typeof o === "object" && o));
+	config.baseDir = config.baseDir || baseDir;
+	config.trimmed = config.trimmed === true;
+	return config;
+}
+var defaultOptions;
+var init_simple_git_options = __esm({ "src/lib/utils/simple-git-options.ts"() {
+	"use strict";
+	defaultOptions = {
+		binary: "git",
+		maxConcurrentProcesses: 5,
+		config: [],
+		trimmed: false
+	};
+} });
+function appendTaskOptions(options, commands = []) {
+	if (!filterPlainObject(options)) return commands;
+	return Object.keys(options).reduce((commands2, key) => {
+		const value = options[key];
+		if (isPathSpec(value)) commands2.push(value);
+		else if (filterPrimitives(value, ["boolean"])) commands2.push(key + "=" + value);
+		else if (Array.isArray(value)) {
+			for (const v of value) if (!filterPrimitives(v, ["string", "number"])) commands2.push(key + "=" + v);
+		} else commands2.push(key);
+		return commands2;
+	}, commands);
+}
+function getTrailingOptions(args, initialPrimitive = 0, objectOnly = false) {
+	const command = [];
+	for (let i = 0, max = initialPrimitive < 0 ? args.length : initialPrimitive; i < max; i++) if ("string|number".includes(typeof args[i])) command.push(String(args[i]));
+	appendTaskOptions(trailingOptionsArgument(args), command);
+	if (!objectOnly) command.push(...trailingArrayArgument(args));
+	return command;
+}
+function trailingArrayArgument(args) {
+	return asStringArray(filterType(last(args, typeof last(args) === "function" ? 1 : 0), filterArray, []));
+}
+function trailingOptionsArgument(args) {
+	return filterType(last(args, filterFunction(last(args)) ? 1 : 0), filterPlainObject);
+}
+function trailingFunctionArgument(args, includeNoop = true) {
+	const callback = asFunction(last(args));
+	return includeNoop || isUserFunction(callback) ? callback : void 0;
+}
+var init_task_options = __esm({ "src/lib/utils/task-options.ts"() {
+	"use strict";
+	init_argument_filters();
+	init_util();
+	init_pathspec();
+} });
+function callTaskParser(parser4, streams) {
+	return parser4(streams.stdOut, streams.stdErr);
+}
+function parseStringResponse(result, parsers12, texts, trim = true) {
+	asArray(texts).forEach((text) => {
+		for (let lines = toLinesWithContent(text, trim), i = 0, max = lines.length; i < max; i++) {
+			const line = (offset = 0) => {
+				if (i + offset >= max) return;
+				return lines[i + offset];
+			};
+			parsers12.some(({ parse }) => parse(line, result));
+		}
+	});
+	return result;
+}
+var init_task_parser = __esm({ "src/lib/utils/task-parser.ts"() {
+	"use strict";
+	init_util();
+} });
+var utils_exports = {};
+__export(utils_exports, {
+	ExitCodes: () => ExitCodes,
+	GitOutputStreams: () => GitOutputStreams,
+	LineParser: () => LineParser,
+	NOOP: () => NOOP,
+	NULL: () => NULL,
+	RemoteLineParser: () => RemoteLineParser,
+	append: () => append,
+	appendTaskOptions: () => appendTaskOptions,
+	asArray: () => asArray,
+	asCamelCase: () => asCamelCase,
+	asFunction: () => asFunction,
+	asNumber: () => asNumber,
+	asStringArray: () => asStringArray,
+	bufferToString: () => bufferToString,
+	callTaskParser: () => callTaskParser,
+	createInstanceConfig: () => createInstanceConfig,
+	delay: () => delay,
+	filterArray: () => filterArray,
+	filterFunction: () => filterFunction,
+	filterHasLength: () => filterHasLength,
+	filterNumber: () => filterNumber,
+	filterPlainObject: () => filterPlainObject,
+	filterPrimitives: () => filterPrimitives,
+	filterString: () => filterString,
+	filterStringOrStringArray: () => filterStringOrStringArray,
+	filterType: () => filterType,
+	first: () => first,
+	folderExists: () => folderExists,
+	forEachLineWithContent: () => forEachLineWithContent,
+	getTrailingOptions: () => getTrailingOptions,
+	including: () => including,
+	isUserFunction: () => isUserFunction,
+	last: () => last,
+	objectToString: () => objectToString,
+	orVoid: () => orVoid,
+	parseStringResponse: () => parseStringResponse,
+	pick: () => pick,
+	prefixedArray: () => prefixedArray,
+	remove: () => remove,
+	splitOn: () => splitOn,
+	toLinesWithContent: () => toLinesWithContent,
+	trailingFunctionArgument: () => trailingFunctionArgument,
+	trailingOptionsArgument: () => trailingOptionsArgument
+});
+var init_utils = __esm({ "src/lib/utils/index.ts"() {
+	"use strict";
+	init_argument_filters();
+	init_exit_codes();
+	init_git_output_streams();
+	init_line_parser();
+	init_simple_git_options();
+	init_task_options();
+	init_task_parser();
+	init_util();
+} });
+var check_is_repo_exports = {};
+__export(check_is_repo_exports, {
+	CheckRepoActions: () => CheckRepoActions,
+	checkIsBareRepoTask: () => checkIsBareRepoTask,
+	checkIsRepoRootTask: () => checkIsRepoRootTask,
+	checkIsRepoTask: () => checkIsRepoTask
+});
+function checkIsRepoTask(action) {
+	switch (action) {
+		case "bare": return checkIsBareRepoTask();
+		case "root": return checkIsRepoRootTask();
+	}
+	return {
+		commands: ["rev-parse", "--is-inside-work-tree"],
+		format: "utf-8",
+		onError,
+		parser
+	};
+}
+function checkIsRepoRootTask() {
+	return {
+		commands: ["rev-parse", "--git-dir"],
+		format: "utf-8",
+		onError,
+		parser(path) {
+			return /^\.(git)?$/.test(path.trim());
+		}
+	};
+}
+function checkIsBareRepoTask() {
+	return {
+		commands: ["rev-parse", "--is-bare-repository"],
+		format: "utf-8",
+		onError,
+		parser
+	};
+}
+function isNotRepoMessage(error) {
+	return /(Not a git repository|Kein Git-Repository)/i.test(String(error));
+}
+var CheckRepoActions, onError, parser;
+var init_check_is_repo = __esm({ "src/lib/tasks/check-is-repo.ts"() {
+	"use strict";
+	init_utils();
+	CheckRepoActions = /* @__PURE__ */ ((CheckRepoActions2) => {
+		CheckRepoActions2["BARE"] = "bare";
+		CheckRepoActions2["IN_TREE"] = "tree";
+		CheckRepoActions2["IS_REPO_ROOT"] = "root";
+		return CheckRepoActions2;
+	})(CheckRepoActions || {});
+	onError = ({ exitCode }, error, done, fail) => {
+		if (exitCode === 128 && isNotRepoMessage(error)) return done(Buffer.from("false"));
+		fail(error);
+	};
+	parser = (text) => {
+		return text.trim() === "true";
+	};
+} });
+function cleanSummaryParser(dryRun, text) {
+	const summary = new CleanResponse(dryRun);
+	const regexp = dryRun ? dryRunRemovalRegexp : removalRegexp;
+	toLinesWithContent(text).forEach((line) => {
+		const removed = line.replace(regexp, "");
+		summary.paths.push(removed);
+		(isFolderRegexp.test(removed) ? summary.folders : summary.files).push(removed);
+	});
+	return summary;
+}
+var CleanResponse, removalRegexp, dryRunRemovalRegexp, isFolderRegexp;
+var init_CleanSummary = __esm({ "src/lib/responses/CleanSummary.ts"() {
+	"use strict";
+	init_utils();
+	CleanResponse = class {
+		constructor(dryRun) {
+			this.dryRun = dryRun;
+			this.paths = [];
+			this.files = [];
+			this.folders = [];
+		}
+	};
+	removalRegexp = /^[a-z]+\s*/i;
+	dryRunRemovalRegexp = /^[a-z]+\s+[a-z]+\s*/i;
+	isFolderRegexp = /\/$/;
+} });
+var task_exports = {};
+__export(task_exports, {
+	EMPTY_COMMANDS: () => EMPTY_COMMANDS,
+	adhocExecTask: () => adhocExecTask,
+	configurationErrorTask: () => configurationErrorTask,
+	isBufferTask: () => isBufferTask,
+	isEmptyTask: () => isEmptyTask,
+	straightThroughBufferTask: () => straightThroughBufferTask,
+	straightThroughStringTask: () => straightThroughStringTask
+});
+function adhocExecTask(parser4) {
+	return {
+		commands: EMPTY_COMMANDS,
+		format: "empty",
+		parser: parser4
+	};
+}
+function configurationErrorTask(error) {
+	return {
+		commands: EMPTY_COMMANDS,
+		format: "empty",
+		parser() {
+			throw typeof error === "string" ? new TaskConfigurationError(error) : error;
+		}
+	};
+}
+function straightThroughStringTask(commands, trimmed2 = false) {
+	return {
+		commands,
+		format: "utf-8",
+		parser(text) {
+			return trimmed2 ? String(text).trim() : text;
+		}
+	};
+}
+function straightThroughBufferTask(commands) {
+	return {
+		commands,
+		format: "buffer",
+		parser(buffer) {
+			return buffer;
+		}
+	};
+}
+function isBufferTask(task) {
+	return task.format === "buffer";
+}
+function isEmptyTask(task) {
+	return task.format === "empty" || !task.commands.length;
+}
+var EMPTY_COMMANDS;
+var init_task = __esm({ "src/lib/tasks/task.ts"() {
+	"use strict";
+	init_task_configuration_error();
+	EMPTY_COMMANDS = [];
+} });
+var clean_exports = {};
+__export(clean_exports, {
+	CONFIG_ERROR_INTERACTIVE_MODE: () => CONFIG_ERROR_INTERACTIVE_MODE,
+	CONFIG_ERROR_MODE_REQUIRED: () => CONFIG_ERROR_MODE_REQUIRED,
+	CONFIG_ERROR_UNKNOWN_OPTION: () => CONFIG_ERROR_UNKNOWN_OPTION,
+	CleanOptions: () => CleanOptions,
+	cleanTask: () => cleanTask,
+	cleanWithOptionsTask: () => cleanWithOptionsTask,
+	isCleanOptionsArray: () => isCleanOptionsArray
+});
+function cleanWithOptionsTask(mode, customArgs) {
+	const { cleanMode, options, valid } = getCleanOptions(mode);
+	if (!cleanMode) return configurationErrorTask(CONFIG_ERROR_MODE_REQUIRED);
+	if (!valid.options) return configurationErrorTask(CONFIG_ERROR_UNKNOWN_OPTION + JSON.stringify(mode));
+	options.push(...customArgs);
+	if (options.some(isInteractiveMode)) return configurationErrorTask(CONFIG_ERROR_INTERACTIVE_MODE);
+	return cleanTask(cleanMode, options);
+}
+function cleanTask(mode, customArgs) {
+	return {
+		commands: [
+			"clean",
+			`-${mode}`,
+			...customArgs
+		],
+		format: "utf-8",
+		parser(text) {
+			return cleanSummaryParser(mode === "n", text);
+		}
+	};
+}
+function isCleanOptionsArray(input) {
+	return Array.isArray(input) && input.every((test) => CleanOptionValues.has(test));
+}
+function getCleanOptions(input) {
+	let cleanMode;
+	let options = [];
+	let valid = {
+		cleanMode: false,
+		options: true
+	};
+	input.replace(/[^a-z]i/g, "").split("").forEach((char) => {
+		if (isCleanMode(char)) {
+			cleanMode = char;
+			valid.cleanMode = true;
+		} else valid.options = valid.options && isKnownOption(options[options.length] = `-${char}`);
+	});
+	return {
+		cleanMode,
+		options,
+		valid
+	};
+}
+function isCleanMode(cleanMode) {
+	return cleanMode === "f" || cleanMode === "n";
+}
+function isKnownOption(option) {
+	return /^-[a-z]$/i.test(option) && CleanOptionValues.has(option.charAt(1));
+}
+function isInteractiveMode(option) {
+	if (/^-[^\-]/.test(option)) return option.indexOf("i") > 0;
+	return option === "--interactive";
+}
+var CONFIG_ERROR_INTERACTIVE_MODE, CONFIG_ERROR_MODE_REQUIRED, CONFIG_ERROR_UNKNOWN_OPTION, CleanOptions, CleanOptionValues;
+var init_clean = __esm({ "src/lib/tasks/clean.ts"() {
+	"use strict";
+	init_CleanSummary();
+	init_utils();
+	init_task();
+	CONFIG_ERROR_INTERACTIVE_MODE = "Git clean interactive mode is not supported";
+	CONFIG_ERROR_MODE_REQUIRED = "Git clean mode parameter (\"n\" or \"f\") is required";
+	CONFIG_ERROR_UNKNOWN_OPTION = "Git clean unknown option found in: ";
+	CleanOptions = /* @__PURE__ */ ((CleanOptions2) => {
+		CleanOptions2["DRY_RUN"] = "n";
+		CleanOptions2["FORCE"] = "f";
+		CleanOptions2["IGNORED_INCLUDED"] = "x";
+		CleanOptions2["IGNORED_ONLY"] = "X";
+		CleanOptions2["EXCLUDING"] = "e";
+		CleanOptions2["QUIET"] = "q";
+		CleanOptions2["RECURSIVE"] = "d";
+		return CleanOptions2;
+	})(CleanOptions || {});
+	CleanOptionValues = /* @__PURE__ */ new Set(["i", ...asStringArray(Object.values(CleanOptions))]);
+} });
+function configListParser(text) {
+	const config = new ConfigList();
+	for (const item of configParser(text)) config.addValue(item.file, String(item.key), item.value);
+	return config;
+}
+function configGetParser(text, key) {
+	let value = null;
+	const values = [];
+	const scopes = /* @__PURE__ */ new Map();
+	for (const item of configParser(text, key)) {
+		if (item.key !== key) continue;
+		values.push(value = item.value);
+		if (!scopes.has(item.file)) scopes.set(item.file, []);
+		scopes.get(item.file).push(value);
+	}
+	return {
+		key,
+		paths: Array.from(scopes.keys()),
+		scopes,
+		value,
+		values
+	};
+}
+function configFilePath(filePath) {
+	return filePath.replace(/^(file):/, "");
+}
+function* configParser(text, requestedKey = null) {
+	const lines = text.split("\0");
+	for (let i = 0, max = lines.length - 1; i < max;) {
+		const file = configFilePath(lines[i++]);
+		let value = lines[i++];
+		let key = requestedKey;
+		if (value.includes("\n")) {
+			const line = splitOn(value, "\n");
+			key = line[0];
+			value = line[1];
+		}
+		yield {
+			file,
+			key,
+			value
+		};
+	}
+}
+var ConfigList;
+var init_ConfigList = __esm({ "src/lib/responses/ConfigList.ts"() {
+	"use strict";
+	init_utils();
+	ConfigList = class {
+		constructor() {
+			this.files = [];
+			this.values = /* @__PURE__ */ Object.create(null);
+		}
+		get all() {
+			if (!this._all) this._all = this.files.reduce((all, file) => {
+				return Object.assign(all, this.values[file]);
+			}, {});
+			return this._all;
+		}
+		addFile(file) {
+			if (!(file in this.values)) {
+				const latest = last(this.files);
+				this.values[file] = latest ? Object.create(this.values[latest]) : {};
+				this.files.push(file);
+			}
+			return this.values[file];
+		}
+		addValue(file, key, value) {
+			const values = this.addFile(file);
+			if (!Object.hasOwn(values, key)) values[key] = value;
+			else if (Array.isArray(values[key])) values[key].push(value);
+			else values[key] = [values[key], value];
+			this._all = void 0;
+		}
+	};
+} });
+function asConfigScope(scope, fallback) {
+	if (typeof scope === "string" && Object.hasOwn(GitConfigScope, scope)) return scope;
+	return fallback;
+}
+function addConfigTask(key, value, append2, scope) {
+	const commands = ["config", `--${scope}`];
+	if (append2) commands.push("--add");
+	commands.push(key, value);
+	return {
+		commands,
+		format: "utf-8",
+		parser(text) {
+			return text;
+		}
+	};
+}
+function getConfigTask(key, scope) {
+	const commands = [
+		"config",
+		"--null",
+		"--show-origin",
+		"--get-all",
+		key
+	];
+	if (scope) commands.splice(1, 0, `--${scope}`);
+	return {
+		commands,
+		format: "utf-8",
+		parser(text) {
+			return configGetParser(text, key);
+		}
+	};
+}
+function listConfigTask(scope) {
+	const commands = [
+		"config",
+		"--list",
+		"--show-origin",
+		"--null"
+	];
+	if (scope) commands.push(`--${scope}`);
+	return {
+		commands,
+		format: "utf-8",
+		parser(text) {
+			return configListParser(text);
+		}
+	};
+}
+function config_default() {
+	return {
+		addConfig(key, value, ...rest) {
+			return this._runTask(addConfigTask(key, value, rest[0] === true, asConfigScope(rest[1], "local")), trailingFunctionArgument(arguments));
+		},
+		getConfig(key, scope) {
+			return this._runTask(getConfigTask(key, asConfigScope(scope, void 0)), trailingFunctionArgument(arguments));
+		},
+		listConfig(...rest) {
+			return this._runTask(listConfigTask(asConfigScope(rest[0], void 0)), trailingFunctionArgument(arguments));
+		}
+	};
+}
+var GitConfigScope;
+var init_config = __esm({ "src/lib/tasks/config.ts"() {
+	"use strict";
+	init_ConfigList();
+	init_utils();
+	GitConfigScope = /* @__PURE__ */ ((GitConfigScope2) => {
+		GitConfigScope2["system"] = "system";
+		GitConfigScope2["global"] = "global";
+		GitConfigScope2["local"] = "local";
+		GitConfigScope2["worktree"] = "worktree";
+		return GitConfigScope2;
+	})(GitConfigScope || {});
+} });
+function isDiffNameStatus(input) {
+	return diffNameStatus.has(input);
+}
+var DiffNameStatus, diffNameStatus;
+var init_diff_name_status = __esm({ "src/lib/tasks/diff-name-status.ts"() {
+	"use strict";
+	DiffNameStatus = /* @__PURE__ */ ((DiffNameStatus2) => {
+		DiffNameStatus2["ADDED"] = "A";
+		DiffNameStatus2["COPIED"] = "C";
+		DiffNameStatus2["DELETED"] = "D";
+		DiffNameStatus2["MODIFIED"] = "M";
+		DiffNameStatus2["RENAMED"] = "R";
+		DiffNameStatus2["CHANGED"] = "T";
+		DiffNameStatus2["UNMERGED"] = "U";
+		DiffNameStatus2["UNKNOWN"] = "X";
+		DiffNameStatus2["BROKEN"] = "B";
+		return DiffNameStatus2;
+	})(DiffNameStatus || {});
+	diffNameStatus = new Set(Object.values(DiffNameStatus));
+} });
+function grepQueryBuilder(...params) {
+	return new GrepQuery().param(...params);
+}
+function parseGrep(grep) {
+	const paths = /* @__PURE__ */ new Set();
+	const results = {};
+	forEachLineWithContent(grep, (input) => {
+		const [path, line, preview] = input.split(NULL);
+		paths.add(path);
+		(results[path] = results[path] || []).push({
+			line: asNumber(line),
+			path,
+			preview
+		});
+	});
+	return {
+		paths,
+		results
+	};
+}
+function grep_default() {
+	return { grep(searchTerm) {
+		const then = trailingFunctionArgument(arguments);
+		const options = getTrailingOptions(arguments);
+		for (const option of disallowedOptions) if (options.includes(option)) return this._runTask(configurationErrorTask(`git.grep: use of "${option}" is not supported.`), then);
+		if (typeof searchTerm === "string") searchTerm = grepQueryBuilder().param(searchTerm);
+		const commands = [
+			"grep",
+			"--null",
+			"-n",
+			"--full-name",
+			...options,
+			...searchTerm
+		];
+		return this._runTask({
+			commands,
+			format: "utf-8",
+			parser(stdOut) {
+				return parseGrep(stdOut);
+			}
+		}, then);
+	} };
+}
+var disallowedOptions, Query, _a, GrepQuery;
+var init_grep = __esm({ "src/lib/tasks/grep.ts"() {
+	"use strict";
+	init_utils();
+	init_task();
+	disallowedOptions = ["-h"];
+	Query = Symbol("grepQuery");
+	GrepQuery = class {
+		constructor() {
+			this[_a] = [];
+		}
+		*[(_a = Query, Symbol.iterator)]() {
+			for (const query of this[Query]) yield query;
+		}
+		and(...and) {
+			and.length && this[Query].push("--and", "(", ...prefixedArray(and, "-e"), ")");
+			return this;
+		}
+		param(...param) {
+			this[Query].push(...prefixedArray(param, "-e"));
+			return this;
+		}
+	};
+} });
+var reset_exports = {};
+__export(reset_exports, {
+	ResetMode: () => ResetMode,
+	getResetMode: () => getResetMode,
+	resetTask: () => resetTask
+});
+function resetTask(mode, customArgs) {
+	const commands = ["reset"];
+	if (isValidResetMode(mode)) commands.push(`--${mode}`);
+	commands.push(...customArgs);
+	return straightThroughStringTask(commands);
+}
+function getResetMode(mode) {
+	if (isValidResetMode(mode)) return mode;
+	switch (typeof mode) {
+		case "string":
+		case "undefined": return "soft";
+	}
+}
+function isValidResetMode(mode) {
+	return typeof mode === "string" && validResetModes.includes(mode);
+}
+var ResetMode, validResetModes;
+var init_reset = __esm({ "src/lib/tasks/reset.ts"() {
+	"use strict";
+	init_utils();
+	init_task();
+	ResetMode = /* @__PURE__ */ ((ResetMode2) => {
+		ResetMode2["MIXED"] = "mixed";
+		ResetMode2["SOFT"] = "soft";
+		ResetMode2["HARD"] = "hard";
+		ResetMode2["MERGE"] = "merge";
+		ResetMode2["KEEP"] = "keep";
+		return ResetMode2;
+	})(ResetMode || {});
+	validResetModes = asStringArray(Object.values(ResetMode));
+} });
+function createLog() {
+	return (0, import_src.default)("simple-git");
+}
+function prefixedLogger(to, prefix, forward) {
+	if (!prefix || !String(prefix).replace(/\s*/, "")) return !forward ? to : (message, ...args) => {
+		to(message, ...args);
+		forward(message, ...args);
+	};
+	return (message, ...args) => {
+		to(`%s ${message}`, prefix, ...args);
+		if (forward) forward(message, ...args);
+	};
+}
+function childLoggerName(name, childDebugger, { namespace: parentNamespace }) {
+	if (typeof name === "string") return name;
+	const childNamespace = childDebugger && childDebugger.namespace || "";
+	if (childNamespace.startsWith(parentNamespace)) return childNamespace.substr(parentNamespace.length + 1);
+	return childNamespace || parentNamespace;
+}
+function createLogger(label, verbose, initialStep, infoDebugger = createLog()) {
+	const labelPrefix = label && `[${label}]` || "";
+	const spawned = [];
+	const debugDebugger = typeof verbose === "string" ? infoDebugger.extend(verbose) : verbose;
+	const key = childLoggerName(filterType(verbose, filterString), debugDebugger, infoDebugger);
+	return step(initialStep);
+	function sibling(name, initial) {
+		return append(spawned, createLogger(label, key.replace(/^[^:]+/, name), initial, infoDebugger));
+	}
+	function step(phase) {
+		const stepPrefix = phase && `[${phase}]` || "";
+		const debug2 = debugDebugger && prefixedLogger(debugDebugger, stepPrefix) || NOOP;
+		const info = prefixedLogger(infoDebugger, `${labelPrefix} ${stepPrefix}`, debug2);
+		return Object.assign(debugDebugger ? debug2 : info, {
+			label,
+			sibling,
+			info,
+			step
+		});
+	}
+}
+var init_git_logger = __esm({ "src/lib/git-logger.ts"() {
+	"use strict";
+	init_utils();
+	import_src.default.formatters.L = (value) => String(filterHasLength(value) ? value.length : "-");
+	import_src.default.formatters.B = (value) => {
+		if (Buffer.isBuffer(value)) return value.toString("utf8");
+		return objectToString(value);
+	};
+} });
+var TasksPendingQueue;
+var init_tasks_pending_queue = __esm({ "src/lib/runners/tasks-pending-queue.ts"() {
+	"use strict";
+	init_git_error();
+	init_git_logger();
+	TasksPendingQueue = class _TasksPendingQueue {
+		constructor(logLabel = "GitExecutor") {
+			this.logLabel = logLabel;
+			this._queue = /* @__PURE__ */ new Map();
+		}
+		withProgress(task) {
+			return this._queue.get(task);
+		}
+		createProgress(task) {
+			const name = _TasksPendingQueue.getName(task.commands[0]);
+			return {
+				task,
+				logger: createLogger(this.logLabel, name),
+				name
+			};
+		}
+		push(task) {
+			const progress = this.createProgress(task);
+			progress.logger("Adding task to the queue, commands = %o", task.commands);
+			this._queue.set(task, progress);
+			return progress;
+		}
+		fatal(err) {
+			for (const [task, { logger }] of Array.from(this._queue.entries())) {
+				if (task === err.task) {
+					logger.info(`Failed %o`, err);
+					logger(`Fatal exception, any as-yet un-started tasks run through this executor will not be attempted`);
+				} else logger.info(`A fatal exception occurred in a previous task, the queue has been purged: %o`, err.message);
+				this.complete(task);
+			}
+			if (this._queue.size !== 0) throw new Error(`Queue size should be zero after fatal: ${this._queue.size}`);
+		}
+		complete(task) {
+			if (this.withProgress(task)) this._queue.delete(task);
+		}
+		attempt(task) {
+			const progress = this.withProgress(task);
+			if (!progress) throw new GitError(void 0, "TasksPendingQueue: attempt called for an unknown task");
+			progress.logger("Starting task");
+			return progress;
+		}
+		static getName(name = "empty") {
+			return `task:${name}:${++_TasksPendingQueue.counter}`;
+		}
+		static {
+			this.counter = 0;
+		}
+	};
+} });
+function pluginContext(task, commands) {
+	return {
+		method: first(task.commands) || "",
+		commands
+	};
+}
+function onErrorReceived(target, logger) {
+	return (err) => {
+		logger(`[ERROR] child process exception %o`, err);
+		target.push(Buffer.from(String(err.stack), "ascii"));
+	};
+}
+function onDataReceived(target, name, logger, output) {
+	return (buffer) => {
+		logger(`%s received %L bytes`, name, buffer);
+		output(`%B`, buffer);
+		target.push(buffer);
+	};
+}
+var GitExecutorChain;
+var init_git_executor_chain = __esm({ "src/lib/runners/git-executor-chain.ts"() {
+	"use strict";
+	init_git_error();
+	init_task();
+	init_utils();
+	init_tasks_pending_queue();
+	GitExecutorChain = class {
+		constructor(_executor, _scheduler, _plugins) {
+			this._executor = _executor;
+			this._scheduler = _scheduler;
+			this._plugins = _plugins;
+			this._chain = Promise.resolve();
+			this._queue = new TasksPendingQueue();
+		}
+		get cwd() {
+			return this._cwd || this._executor.cwd;
+		}
+		set cwd(cwd) {
+			this._cwd = cwd;
+		}
+		get env() {
+			return this._executor.env;
+		}
+		get outputHandler() {
+			return this._executor.outputHandler;
+		}
+		chain() {
+			return this;
+		}
+		push(task) {
+			this._queue.push(task);
+			return this._chain = this._chain.then(() => this.attemptTask(task));
+		}
+		async attemptTask(task) {
+			const onScheduleComplete = await this._scheduler.next();
+			const onQueueComplete = () => this._queue.complete(task);
+			try {
+				const { logger } = this._queue.attempt(task);
+				return await (isEmptyTask(task) ? this.attemptEmptyTask(task, logger) : this.attemptRemoteTask(task, logger));
+			} catch (e) {
+				throw this.onFatalException(task, e);
+			} finally {
+				onQueueComplete();
+				onScheduleComplete();
+			}
+		}
+		onFatalException(task, e) {
+			const gitError = e instanceof GitError ? Object.assign(e, { task }) : new GitError(task, e && String(e));
+			this._chain = Promise.resolve();
+			this._queue.fatal(gitError);
+			return gitError;
+		}
+		async attemptRemoteTask(task, logger) {
+			const binary = this._plugins.exec("spawn.binary", "", pluginContext(task, task.commands));
+			const args = this._plugins.exec("spawn.args", [...task.commands], pluginContext(task, task.commands));
+			const raw = await this.gitResponse(task, binary, args, this.outputHandler, logger.step("SPAWN"));
+			const outputStreams = await this.handleTaskData(task, args, raw, logger.step("HANDLE"));
+			logger(`passing response to task's parser as a %s`, task.format);
+			if (isBufferTask(task)) return callTaskParser(task.parser, outputStreams);
+			return callTaskParser(task.parser, outputStreams.asStrings());
+		}
+		async attemptEmptyTask(task, logger) {
+			logger(`empty task bypassing child process to call to task's parser`);
+			return task.parser(this);
+		}
+		handleTaskData(task, args, result, logger) {
+			const { exitCode, rejection, stdOut, stdErr } = result;
+			return new Promise((done, fail) => {
+				logger(`Preparing to handle process response exitCode=%d stdOut=`, exitCode);
+				const { error } = this._plugins.exec("task.error", { error: rejection }, {
+					...pluginContext(task, args),
+					...result
+				});
+				if (error && task.onError) {
+					logger.info(`exitCode=%s handling with custom error handler`);
+					return task.onError(result, error, (newStdOut) => {
+						logger.info(`custom error handler treated as success`);
+						logger(`custom error returned a %s`, objectToString(newStdOut));
+						done(new GitOutputStreams(Array.isArray(newStdOut) ? Buffer.concat(newStdOut) : newStdOut, Buffer.concat(stdErr)));
+					}, fail);
+				}
+				if (error) {
+					logger.info(`handling as error: exitCode=%s stdErr=%s rejection=%o`, exitCode, stdErr.length, rejection);
+					return fail(error);
+				}
+				logger.info(`retrieving task output complete`);
+				done(new GitOutputStreams(Buffer.concat(stdOut), Buffer.concat(stdErr)));
+			});
+		}
+		async gitResponse(task, command, args, outputHandler, logger) {
+			const outputLogger = logger.sibling("output");
+			const spawnOptions = this._plugins.exec("spawn.options", {
+				cwd: this.cwd,
+				env: this.env,
+				windowsHide: true
+			}, pluginContext(task, task.commands));
+			return new Promise((done) => {
+				const stdOut = [];
+				const stdErr = [];
+				logger.info(`%s %o`, command, args);
+				logger("%O", spawnOptions);
+				let rejection = this._beforeSpawn(task, args);
+				if (rejection) return done({
+					stdOut,
+					stdErr,
+					exitCode: 9901,
+					rejection
+				});
+				this._plugins.exec("spawn.before", void 0, {
+					...pluginContext(task, args),
+					kill(reason) {
+						rejection = reason || rejection;
+					}
+				});
+				const spawned = spawn(command, args, spawnOptions);
+				spawned.stdout.on("data", onDataReceived(stdOut, "stdOut", logger, outputLogger.step("stdOut")));
+				spawned.stderr.on("data", onDataReceived(stdErr, "stdErr", logger, outputLogger.step("stdErr")));
+				spawned.on("error", onErrorReceived(stdErr, logger));
+				if (outputHandler) {
+					logger(`Passing child process stdOut/stdErr to custom outputHandler`);
+					outputHandler(command, spawned.stdout, spawned.stderr, [...args]);
+				}
+				this._plugins.exec("spawn.after", void 0, {
+					...pluginContext(task, args),
+					spawned,
+					close(exitCode, reason) {
+						done({
+							stdOut,
+							stdErr,
+							exitCode,
+							rejection: rejection || reason
+						});
+					},
+					kill(reason) {
+						if (spawned.killed) return;
+						rejection = reason;
+						spawned.kill("SIGINT");
+					}
+				});
+			});
+		}
+		_beforeSpawn(task, args) {
+			let rejection;
+			this._plugins.exec("spawn.before", void 0, {
+				...pluginContext(task, args),
+				kill(reason) {
+					rejection = reason || rejection;
+				}
+			});
+			return rejection;
+		}
+	};
+} });
+var git_executor_exports = {};
+__export(git_executor_exports, { GitExecutor: () => GitExecutor });
+var GitExecutor;
+var init_git_executor = __esm({ "src/lib/runners/git-executor.ts"() {
+	"use strict";
+	init_git_executor_chain();
+	GitExecutor = class {
+		constructor(cwd, _scheduler, _plugins) {
+			this.cwd = cwd;
+			this._scheduler = _scheduler;
+			this._plugins = _plugins;
+			this._chain = new GitExecutorChain(this, this._scheduler, this._plugins);
+		}
+		chain() {
+			return new GitExecutorChain(this, this._scheduler, this._plugins);
+		}
+		push(task) {
+			return this._chain.push(task);
+		}
+	};
+} });
+function taskCallback(task, response, callback = NOOP) {
+	const onSuccess = (data) => {
+		callback(null, data);
+	};
+	const onError2 = (err) => {
+		if (err?.task === task) callback(err instanceof GitResponseError ? addDeprecationNoticeToError(err) : err, void 0);
+	};
+	response.then(onSuccess, onError2);
+}
+function addDeprecationNoticeToError(err) {
+	let log = (name) => {
+		console.warn(`simple-git deprecation notice: accessing GitResponseError.${name} should be GitResponseError.git.${name}, this will no longer be available in version 3`);
+		log = NOOP;
+	};
+	return Object.create(err, Object.getOwnPropertyNames(err.git).reduce(descriptorReducer, {}));
+	function descriptorReducer(all, name) {
+		if (name in err) return all;
+		all[name] = {
+			enumerable: false,
+			configurable: false,
+			get() {
+				log(name);
+				return err.git[name];
+			}
+		};
+		return all;
+	}
+}
+var init_task_callback = __esm({ "src/lib/task-callback.ts"() {
+	"use strict";
+	init_git_response_error();
+	init_utils();
+} });
+function changeWorkingDirectoryTask(directory, root) {
+	return adhocExecTask((instance) => {
+		if (!folderExists(directory)) throw new Error(`Git.cwd: cannot change to non-directory "${directory}"`);
+		return (root || instance).cwd = directory;
+	});
+}
+var init_change_working_directory = __esm({ "src/lib/tasks/change-working-directory.ts"() {
+	"use strict";
+	init_utils();
+	init_task();
+} });
+function checkoutTask(args) {
+	const commands = ["checkout", ...args];
+	if (commands[1] === "-b" && commands.includes("-B")) commands[1] = remove(commands, "-B");
+	return straightThroughStringTask(commands);
+}
+function checkout_default() {
+	return {
+		checkout() {
+			return this._runTask(checkoutTask(getTrailingOptions(arguments, 1)), trailingFunctionArgument(arguments));
+		},
+		checkoutBranch(branchName, startPoint) {
+			return this._runTask(checkoutTask([
+				"-b",
+				branchName,
+				startPoint,
+				...getTrailingOptions(arguments)
+			]), trailingFunctionArgument(arguments));
+		},
+		checkoutLocalBranch(branchName) {
+			return this._runTask(checkoutTask([
+				"-b",
+				branchName,
+				...getTrailingOptions(arguments)
+			]), trailingFunctionArgument(arguments));
+		}
+	};
+}
+var init_checkout = __esm({ "src/lib/tasks/checkout.ts"() {
+	"use strict";
+	init_utils();
+	init_task();
+} });
+function countObjectsResponse() {
+	return {
+		count: 0,
+		garbage: 0,
+		inPack: 0,
+		packs: 0,
+		prunePackable: 0,
+		size: 0,
+		sizeGarbage: 0,
+		sizePack: 0
+	};
+}
+function count_objects_default() {
+	return { countObjects() {
+		return this._runTask({
+			commands: ["count-objects", "--verbose"],
+			format: "utf-8",
+			parser(stdOut) {
+				return parseStringResponse(countObjectsResponse(), [parser2], stdOut);
+			}
+		});
+	} };
+}
+var parser2;
+var init_count_objects = __esm({ "src/lib/tasks/count-objects.ts"() {
+	"use strict";
+	init_utils();
+	parser2 = new LineParser(/([a-z-]+): (\d+)$/, (result, [key, value]) => {
+		const property = asCamelCase(key);
+		if (Object.hasOwn(result, property)) result[property] = asNumber(value);
+	});
+} });
+function parseCommitResult(stdOut) {
+	return parseStringResponse({
+		author: null,
+		branch: "",
+		commit: "",
+		root: false,
+		summary: {
+			changes: 0,
+			insertions: 0,
+			deletions: 0
+		}
+	}, parsers, stdOut);
+}
+var parsers;
+var init_parse_commit = __esm({ "src/lib/parsers/parse-commit.ts"() {
+	"use strict";
+	init_utils();
+	parsers = [
+		new LineParser(/^\[([^\s]+)( \([^)]+\))? ([^\]]+)/, (result, [branch, root, commit]) => {
+			result.branch = branch;
+			result.commit = commit;
+			result.root = !!root;
+		}),
+		new LineParser(/\s*Author:\s(.+)/i, (result, [author]) => {
+			const parts = author.split("<");
+			const email = parts.pop();
+			if (!email || !email.includes("@")) return;
+			result.author = {
+				email: email.substr(0, email.length - 1),
+				name: parts.join("<").trim()
+			};
+		}),
+		new LineParser(/(\d+)[^,]*(?:,\s*(\d+)[^,]*)(?:,\s*(\d+))/g, (result, [changes, insertions, deletions]) => {
+			result.summary.changes = parseInt(changes, 10) || 0;
+			result.summary.insertions = parseInt(insertions, 10) || 0;
+			result.summary.deletions = parseInt(deletions, 10) || 0;
+		}),
+		new LineParser(/^(\d+)[^,]*(?:,\s*(\d+)[^(]+\(([+-]))?/, (result, [changes, lines, direction]) => {
+			result.summary.changes = parseInt(changes, 10) || 0;
+			const count = parseInt(lines, 10) || 0;
+			if (direction === "-") result.summary.deletions = count;
+			else if (direction === "+") result.summary.insertions = count;
+		})
+	];
+} });
+function commitTask(message, files, customArgs) {
+	return {
+		commands: [
+			"-c",
+			"core.abbrev=40",
+			"commit",
+			...prefixedArray(message, "-m"),
+			...files,
+			...customArgs
+		],
+		format: "utf-8",
+		parser: parseCommitResult
+	};
+}
+function commit_default() {
+	return { commit(message, ...rest) {
+		const next = trailingFunctionArgument(arguments);
+		const task = rejectDeprecatedSignatures(message) || commitTask(asArray(message), asArray(filterType(rest[0], filterStringOrStringArray, [])), [...asStringArray(filterType(rest[1], filterArray, [])), ...getTrailingOptions(arguments, 0, true)]);
+		return this._runTask(task, next);
+	} };
+	function rejectDeprecatedSignatures(message) {
+		return !filterStringOrStringArray(message) && configurationErrorTask(`git.commit: requires the commit message to be supplied as a string/string[]`);
+	}
+}
+var init_commit = __esm({ "src/lib/tasks/commit.ts"() {
+	"use strict";
+	init_parse_commit();
+	init_utils();
+	init_task();
+} });
+function first_commit_default() {
+	return { firstCommit() {
+		return this._runTask(straightThroughStringTask([
+			"rev-list",
+			"--max-parents=0",
+			"HEAD"
+		], true), trailingFunctionArgument(arguments));
+	} };
+}
+var init_first_commit = __esm({ "src/lib/tasks/first-commit.ts"() {
+	"use strict";
+	init_utils();
+	init_task();
+} });
+function hashObjectTask(filePath, write) {
+	const commands = ["hash-object", filePath];
+	if (write) commands.push("-w");
+	return straightThroughStringTask(commands, true);
+}
+var init_hash_object = __esm({ "src/lib/tasks/hash-object.ts"() {
+	"use strict";
+	init_task();
+} });
+function parseInit(bare, path, text) {
+	const response = String(text).trim();
+	let result;
+	if (result = initResponseRegex.exec(response)) return new InitSummary(bare, path, false, result[1]);
+	if (result = reInitResponseRegex.exec(response)) return new InitSummary(bare, path, true, result[1]);
+	let gitDir = "";
+	const tokens = response.split(" ");
+	while (tokens.length) if (tokens.shift() === "in") {
+		gitDir = tokens.join(" ");
+		break;
+	}
+	return new InitSummary(bare, path, /^re/i.test(response), gitDir);
+}
+var InitSummary, initResponseRegex, reInitResponseRegex;
+var init_InitSummary = __esm({ "src/lib/responses/InitSummary.ts"() {
+	"use strict";
+	InitSummary = class {
+		constructor(bare, path, existing, gitDir) {
+			this.bare = bare;
+			this.path = path;
+			this.existing = existing;
+			this.gitDir = gitDir;
+		}
+	};
+	initResponseRegex = /^Init.+ repository in (.+)$/;
+	reInitResponseRegex = /^Rein.+ in (.+)$/;
+} });
+function hasBareCommand(command) {
+	return command.includes(bareCommand);
+}
+function initTask(bare = false, path, customArgs) {
+	const commands = ["init", ...customArgs];
+	if (bare && !hasBareCommand(commands)) commands.splice(1, 0, bareCommand);
+	return {
+		commands,
+		format: "utf-8",
+		parser(text) {
+			return parseInit(commands.includes("--bare"), path, text);
+		}
+	};
+}
+var bareCommand;
+var init_init = __esm({ "src/lib/tasks/init.ts"() {
+	"use strict";
+	init_InitSummary();
+	bareCommand = "--bare";
+} });
+function logFormatFromCommand(customArgs) {
+	for (let i = 0; i < customArgs.length; i++) {
+		const format = logFormatRegex.exec(customArgs[i]);
+		if (format) return `--${format[1]}`;
+	}
+	return "";
+}
+function isLogFormat(customArg) {
+	return logFormatRegex.test(customArg);
+}
+var logFormatRegex;
+var init_log_format = __esm({ "src/lib/args/log-format.ts"() {
+	"use strict";
+	logFormatRegex = /^--(stat|numstat|name-only|name-status)(=|$)/;
+} });
+var DiffSummary;
+var init_DiffSummary = __esm({ "src/lib/responses/DiffSummary.ts"() {
+	"use strict";
+	DiffSummary = class {
+		constructor() {
+			this.changed = 0;
+			this.deletions = 0;
+			this.insertions = 0;
+			this.files = [];
+		}
+	};
+} });
+function getDiffParser(format = "") {
+	const parser4 = diffSummaryParsers[format];
+	return (stdOut) => parseStringResponse(new DiffSummary(), parser4, stdOut, false);
+}
+var statParser, numStatParser, nameOnlyParser, nameStatusParser, diffSummaryParsers;
+var init_parse_diff_summary = __esm({ "src/lib/parsers/parse-diff-summary.ts"() {
+	"use strict";
+	init_log_format();
+	init_DiffSummary();
+	init_diff_name_status();
+	init_utils();
+	statParser = [
+		new LineParser(/^(.+)\s+\|\s+(\d+)(\s+[+\-]+)?$/, (result, [file, changes, alterations = ""]) => {
+			result.files.push({
+				file: file.trim(),
+				changes: asNumber(changes),
+				insertions: alterations.replace(/[^+]/g, "").length,
+				deletions: alterations.replace(/[^-]/g, "").length,
+				binary: false
+			});
+		}),
+		new LineParser(/^(.+) \|\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)/, (result, [file, before, after]) => {
+			result.files.push({
+				file: file.trim(),
+				before: asNumber(before),
+				after: asNumber(after),
+				binary: true
+			});
+		}),
+		new LineParser(/(\d+) files? changed\s*((?:, \d+ [^,]+){0,2})/, (result, [changed, summary]) => {
+			const inserted = /(\d+) i/.exec(summary);
+			const deleted = /(\d+) d/.exec(summary);
+			result.changed = asNumber(changed);
+			result.insertions = asNumber(inserted?.[1]);
+			result.deletions = asNumber(deleted?.[1]);
+		})
+	];
+	numStatParser = [new LineParser(/(\d+)\t(\d+)\t(.+)$/, (result, [changesInsert, changesDelete, file]) => {
+		const insertions = asNumber(changesInsert);
+		const deletions = asNumber(changesDelete);
+		result.changed++;
+		result.insertions += insertions;
+		result.deletions += deletions;
+		result.files.push({
+			file,
+			changes: insertions + deletions,
+			insertions,
+			deletions,
+			binary: false
+		});
+	}), new LineParser(/-\t-\t(.+)$/, (result, [file]) => {
+		result.changed++;
+		result.files.push({
+			file,
+			after: 0,
+			before: 0,
+			binary: true
+		});
+	})];
+	nameOnlyParser = [new LineParser(/(.+)$/, (result, [file]) => {
+		result.changed++;
+		result.files.push({
+			file,
+			changes: 0,
+			insertions: 0,
+			deletions: 0,
+			binary: false
+		});
+	})];
+	nameStatusParser = [new LineParser(/([ACDMRTUXB])([0-9]{0,3})\t(.[^\t]*)(\t(.[^\t]*))?$/, (result, [status, similarity, from, _to, to]) => {
+		result.changed++;
+		result.files.push({
+			file: to ?? from,
+			changes: 0,
+			insertions: 0,
+			deletions: 0,
+			binary: false,
+			status: orVoid(isDiffNameStatus(status) && status),
+			from: orVoid(!!to && from !== to && from),
+			similarity: asNumber(similarity)
+		});
+	})];
+	diffSummaryParsers = {
+		[""]: statParser,
+		["--stat"]: statParser,
+		["--numstat"]: numStatParser,
+		["--name-status"]: nameStatusParser,
+		["--name-only"]: nameOnlyParser
+	};
+} });
+function lineBuilder(tokens, fields) {
+	return fields.reduce((line, field, index) => {
+		line[field] = tokens[index] || "";
+		return line;
+	}, /* @__PURE__ */ Object.create({ diff: null }));
+}
+function createListLogSummaryParser(splitter = SPLITTER, fields = defaultFieldNames, logFormat = "") {
+	const parseDiffResult = getDiffParser(logFormat);
+	return function(stdOut) {
+		const all = toLinesWithContent(stdOut.trim(), false, START_BOUNDARY).map(function(item) {
+			const lineDetail = item.split(COMMIT_BOUNDARY);
+			const listLogLine = lineBuilder(lineDetail[0].split(splitter), fields);
+			if (lineDetail.length > 1 && !!lineDetail[1].trim()) listLogLine.diff = parseDiffResult(lineDetail[1]);
+			return listLogLine;
+		});
+		return {
+			all,
+			latest: all.length && all[0] || null,
+			total: all.length
+		};
+	};
+}
+var START_BOUNDARY, COMMIT_BOUNDARY, SPLITTER, defaultFieldNames;
+var init_parse_list_log_summary = __esm({ "src/lib/parsers/parse-list-log-summary.ts"() {
+	"use strict";
+	init_utils();
+	init_parse_diff_summary();
+	init_log_format();
+	START_BOUNDARY = "òòòòòò ";
+	COMMIT_BOUNDARY = " òò";
+	SPLITTER = " ò ";
+	defaultFieldNames = [
+		"hash",
+		"date",
+		"message",
+		"refs",
+		"author_name",
+		"author_email"
+	];
+} });
+var diff_exports = {};
+__export(diff_exports, {
+	diffSummaryTask: () => diffSummaryTask,
+	validateLogFormatConfig: () => validateLogFormatConfig
+});
+function diffSummaryTask(customArgs) {
+	let logFormat = logFormatFromCommand(customArgs);
+	const commands = ["diff"];
+	if (logFormat === "") {
+		logFormat = "--stat";
+		commands.push("--stat=4096");
+	}
+	commands.push(...customArgs);
+	return validateLogFormatConfig(commands) || {
+		commands,
+		format: "utf-8",
+		parser: getDiffParser(logFormat)
+	};
+}
+function validateLogFormatConfig(customArgs) {
+	const flags = customArgs.filter(isLogFormat);
+	if (flags.length > 1) return configurationErrorTask(`Summary flags are mutually exclusive - pick one of ${flags.join(",")}`);
+	if (flags.length && customArgs.includes("-z")) return configurationErrorTask(`Summary flag ${flags} parsing is not compatible with null termination option '-z'`);
+}
+var init_diff = __esm({ "src/lib/tasks/diff.ts"() {
+	"use strict";
+	init_log_format();
+	init_parse_diff_summary();
+	init_task();
+} });
+function prettyFormat(format, splitter) {
+	const fields = [];
+	const formatStr = [];
+	Object.keys(format).forEach((field) => {
+		fields.push(field);
+		formatStr.push(String(format[field]));
+	});
+	return [fields, formatStr.join(splitter)];
+}
+function userOptions(input) {
+	return Object.keys(input).reduce((out, key) => {
+		if (!(key in excludeOptions)) out[key] = input[key];
+		return out;
+	}, {});
+}
+function parseLogOptions(opt = {}, customArgs = []) {
+	const splitter = filterType(opt.splitter, filterString, SPLITTER);
+	const [fields, formatStr] = prettyFormat(filterPlainObject(opt.format) ? opt.format : {
+		hash: "%H",
+		date: opt.strictDate === false ? "%ai" : "%aI",
+		message: "%s",
+		refs: "%D",
+		body: opt.multiLine ? "%B" : "%b",
+		author_name: opt.mailMap !== false ? "%aN" : "%an",
+		author_email: opt.mailMap !== false ? "%aE" : "%ae"
+	}, splitter);
+	const suffix = [];
+	const command = [`--pretty=format:${START_BOUNDARY}${formatStr}${COMMIT_BOUNDARY}`, ...customArgs];
+	const maxCount = opt.n || opt["max-count"] || opt.maxCount;
+	if (maxCount) command.push(`--max-count=${maxCount}`);
+	if (opt.from || opt.to) {
+		const rangeOperator = opt.symmetric !== false ? "..." : "..";
+		suffix.push(`${opt.from || ""}${rangeOperator}${opt.to || ""}`);
+	}
+	if (filterString(opt.file)) command.push("--follow", pathspec(opt.file));
+	appendTaskOptions(userOptions(opt), command);
+	return {
+		fields,
+		splitter,
+		commands: [...command, ...suffix]
+	};
+}
+function logTask(splitter, fields, customArgs) {
+	const parser4 = createListLogSummaryParser(splitter, fields, logFormatFromCommand(customArgs));
+	return {
+		commands: ["log", ...customArgs],
+		format: "utf-8",
+		parser: parser4
+	};
+}
+function log_default() {
+	return { log(...rest) {
+		const next = trailingFunctionArgument(arguments);
+		const options = parseLogOptions(trailingOptionsArgument(arguments), asStringArray(filterType(arguments[0], filterArray, [])));
+		const task = rejectDeprecatedSignatures(...rest) || validateLogFormatConfig(options.commands) || createLogTask(options);
+		return this._runTask(task, next);
+	} };
+	function createLogTask(options) {
+		return logTask(options.splitter, options.fields, options.commands);
+	}
+	function rejectDeprecatedSignatures(from, to) {
+		return filterString(from) && filterString(to) && configurationErrorTask(`git.log(string, string) should be replaced with git.log({ from: string, to: string })`);
+	}
+}
+var excludeOptions;
+var init_log = __esm({ "src/lib/tasks/log.ts"() {
+	"use strict";
+	init_log_format();
+	init_pathspec();
+	init_parse_list_log_summary();
+	init_utils();
+	init_task();
+	init_diff();
+	excludeOptions = /* @__PURE__ */ ((excludeOptions2) => {
+		excludeOptions2[excludeOptions2["--pretty"] = 0] = "--pretty";
+		excludeOptions2[excludeOptions2["max-count"] = 1] = "max-count";
+		excludeOptions2[excludeOptions2["maxCount"] = 2] = "maxCount";
+		excludeOptions2[excludeOptions2["n"] = 3] = "n";
+		excludeOptions2[excludeOptions2["file"] = 4] = "file";
+		excludeOptions2[excludeOptions2["format"] = 5] = "format";
+		excludeOptions2[excludeOptions2["from"] = 6] = "from";
+		excludeOptions2[excludeOptions2["to"] = 7] = "to";
+		excludeOptions2[excludeOptions2["splitter"] = 8] = "splitter";
+		excludeOptions2[excludeOptions2["symmetric"] = 9] = "symmetric";
+		excludeOptions2[excludeOptions2["mailMap"] = 10] = "mailMap";
+		excludeOptions2[excludeOptions2["multiLine"] = 11] = "multiLine";
+		excludeOptions2[excludeOptions2["strictDate"] = 12] = "strictDate";
+		return excludeOptions2;
+	})(excludeOptions || {});
+} });
+var MergeSummaryConflict, MergeSummaryDetail;
+var init_MergeSummary = __esm({ "src/lib/responses/MergeSummary.ts"() {
+	"use strict";
+	MergeSummaryConflict = class {
+		constructor(reason, file = null, meta) {
+			this.reason = reason;
+			this.file = file;
+			this.meta = meta;
+		}
+		toString() {
+			return `${this.file}:${this.reason}`;
+		}
+	};
+	MergeSummaryDetail = class {
+		constructor() {
+			this.conflicts = [];
+			this.merges = [];
+			this.result = "success";
+		}
+		get failed() {
+			return this.conflicts.length > 0;
+		}
+		get reason() {
+			return this.result;
+		}
+		toString() {
+			if (this.conflicts.length) return `CONFLICTS: ${this.conflicts.join(", ")}`;
+			return "OK";
+		}
+	};
+} });
+var PullSummary, PullFailedSummary;
+var init_PullSummary = __esm({ "src/lib/responses/PullSummary.ts"() {
+	"use strict";
+	PullSummary = class {
+		constructor() {
+			this.remoteMessages = { all: [] };
+			this.created = [];
+			this.deleted = [];
+			this.files = [];
+			this.deletions = {};
+			this.insertions = {};
+			this.summary = {
+				changes: 0,
+				deletions: 0,
+				insertions: 0
+			};
+		}
+	};
+	PullFailedSummary = class {
+		constructor() {
+			this.remote = "";
+			this.hash = {
+				local: "",
+				remote: ""
+			};
+			this.branch = {
+				local: "",
+				remote: ""
+			};
+			this.message = "";
+		}
+		toString() {
+			return this.message;
+		}
+	};
+} });
+function objectEnumerationResult(remoteMessages) {
+	return remoteMessages.objects = remoteMessages.objects || {
+		compressing: 0,
+		counting: 0,
+		enumerating: 0,
+		packReused: 0,
+		reused: {
+			count: 0,
+			delta: 0
+		},
+		total: {
+			count: 0,
+			delta: 0
+		}
+	};
+}
+function asObjectCount(source) {
+	const count = /^\s*(\d+)/.exec(source);
+	const delta = /delta (\d+)/i.exec(source);
+	return {
+		count: asNumber(count && count[1] || "0"),
+		delta: asNumber(delta && delta[1] || "0")
+	};
+}
+var remoteMessagesObjectParsers;
+var init_parse_remote_objects = __esm({ "src/lib/parsers/parse-remote-objects.ts"() {
+	"use strict";
+	init_utils();
+	remoteMessagesObjectParsers = [
+		new RemoteLineParser(/^remote:\s*(enumerating|counting|compressing) objects: (\d+),/i, (result, [action, count]) => {
+			const key = action.toLowerCase();
+			const enumeration = objectEnumerationResult(result.remoteMessages);
+			Object.assign(enumeration, { [key]: asNumber(count) });
+		}),
+		new RemoteLineParser(/^remote:\s*(enumerating|counting|compressing) objects: \d+% \(\d+\/(\d+)\),/i, (result, [action, count]) => {
+			const key = action.toLowerCase();
+			const enumeration = objectEnumerationResult(result.remoteMessages);
+			Object.assign(enumeration, { [key]: asNumber(count) });
+		}),
+		new RemoteLineParser(/total ([^,]+), reused ([^,]+), pack-reused (\d+)/i, (result, [total, reused, packReused]) => {
+			const objects = objectEnumerationResult(result.remoteMessages);
+			objects.total = asObjectCount(total);
+			objects.reused = asObjectCount(reused);
+			objects.packReused = asNumber(packReused);
+		})
+	];
+} });
+function parseRemoteMessages(_stdOut, stdErr) {
+	return parseStringResponse({ remoteMessages: new RemoteMessageSummary() }, parsers2, stdErr);
+}
+var parsers2, RemoteMessageSummary;
+var init_parse_remote_messages = __esm({ "src/lib/parsers/parse-remote-messages.ts"() {
+	"use strict";
+	init_utils();
+	init_parse_remote_objects();
+	parsers2 = [
+		new RemoteLineParser(/^remote:\s*(.+)$/, (result, [text]) => {
+			result.remoteMessages.all.push(text.trim());
+			return false;
+		}),
+		...remoteMessagesObjectParsers,
+		new RemoteLineParser([/create a (?:pull|merge) request/i, /\s(https?:\/\/\S+)$/], (result, [pullRequestUrl]) => {
+			result.remoteMessages.pullRequestUrl = pullRequestUrl;
+		}),
+		new RemoteLineParser([/found (\d+) vulnerabilities.+\(([^)]+)\)/i, /\s(https?:\/\/\S+)$/], (result, [count, summary, url]) => {
+			result.remoteMessages.vulnerabilities = {
+				count: asNumber(count),
+				summary,
+				url
+			};
+		})
+	];
+	RemoteMessageSummary = class {
+		constructor() {
+			this.all = [];
+		}
+	};
+} });
+function parsePullErrorResult(stdOut, stdErr) {
+	const pullError = parseStringResponse(new PullFailedSummary(), errorParsers, [stdOut, stdErr]);
+	return pullError.message && pullError;
+}
+var FILE_UPDATE_REGEX, SUMMARY_REGEX, ACTION_REGEX, parsers3, errorParsers, parsePullDetail, parsePullResult;
+var init_parse_pull = __esm({ "src/lib/parsers/parse-pull.ts"() {
+	"use strict";
+	init_PullSummary();
+	init_utils();
+	init_parse_remote_messages();
+	FILE_UPDATE_REGEX = /^\s*(.+?)\s+\|\s+\d+\s*(\+*)(-*)/;
+	SUMMARY_REGEX = /(\d+)\D+((\d+)\D+\(\+\))?(\D+(\d+)\D+\(-\))?/;
+	ACTION_REGEX = /^(create|delete) mode \d+ (.+)/;
+	parsers3 = [
+		new LineParser(FILE_UPDATE_REGEX, (result, [file, insertions, deletions]) => {
+			result.files.push(file);
+			if (insertions) result.insertions[file] = insertions.length;
+			if (deletions) result.deletions[file] = deletions.length;
+		}),
+		new LineParser(SUMMARY_REGEX, (result, [changes, , insertions, , deletions]) => {
+			if (insertions !== void 0 || deletions !== void 0) {
+				result.summary.changes = +changes || 0;
+				result.summary.insertions = +insertions || 0;
+				result.summary.deletions = +deletions || 0;
+				return true;
+			}
+			return false;
+		}),
+		new LineParser(ACTION_REGEX, (result, [action, file]) => {
+			append(result.files, file);
+			append(action === "create" ? result.created : result.deleted, file);
+		})
+	];
+	errorParsers = [
+		new LineParser(/^from\s(.+)$/i, (result, [remote]) => void (result.remote = remote)),
+		new LineParser(/^fatal:\s(.+)$/, (result, [message]) => void (result.message = message)),
+		new LineParser(/([a-z0-9]+)\.\.([a-z0-9]+)\s+(\S+)\s+->\s+(\S+)$/, (result, [hashLocal, hashRemote, branchLocal, branchRemote]) => {
+			result.branch.local = branchLocal;
+			result.hash.local = hashLocal;
+			result.branch.remote = branchRemote;
+			result.hash.remote = hashRemote;
+		})
+	];
+	parsePullDetail = (stdOut, stdErr) => {
+		return parseStringResponse(new PullSummary(), parsers3, [stdOut, stdErr]);
+	};
+	parsePullResult = (stdOut, stdErr) => {
+		return Object.assign(new PullSummary(), parsePullDetail(stdOut, stdErr), parseRemoteMessages(stdOut, stdErr));
+	};
+} });
+var parsers4, parseMergeResult, parseMergeDetail;
+var init_parse_merge = __esm({ "src/lib/parsers/parse-merge.ts"() {
+	"use strict";
+	init_MergeSummary();
+	init_utils();
+	init_parse_pull();
+	parsers4 = [
+		new LineParser(/^Auto-merging\s+(.+)$/, (summary, [autoMerge]) => {
+			summary.merges.push(autoMerge);
+		}),
+		new LineParser(/^CONFLICT\s+\((.+)\): Merge conflict in (.+)$/, (summary, [reason, file]) => {
+			summary.conflicts.push(new MergeSummaryConflict(reason, file));
+		}),
+		new LineParser(/^CONFLICT\s+\((.+\/delete)\): (.+) deleted in (.+) and/, (summary, [reason, file, deleteRef]) => {
+			summary.conflicts.push(new MergeSummaryConflict(reason, file, { deleteRef }));
+		}),
+		new LineParser(/^CONFLICT\s+\((.+)\):/, (summary, [reason]) => {
+			summary.conflicts.push(new MergeSummaryConflict(reason, null));
+		}),
+		new LineParser(/^Automatic merge failed;\s+(.+)$/, (summary, [result]) => {
+			summary.result = result;
+		})
+	];
+	parseMergeResult = (stdOut, stdErr) => {
+		return Object.assign(parseMergeDetail(stdOut, stdErr), parsePullResult(stdOut, stdErr));
+	};
+	parseMergeDetail = (stdOut) => {
+		return parseStringResponse(new MergeSummaryDetail(), parsers4, stdOut);
+	};
+} });
+function mergeTask(customArgs) {
+	if (!customArgs.length) return configurationErrorTask("Git.merge requires at least one option");
+	return {
+		commands: ["merge", ...customArgs],
+		format: "utf-8",
+		parser(stdOut, stdErr) {
+			const merge = parseMergeResult(stdOut, stdErr);
+			if (merge.failed) throw new GitResponseError(merge);
+			return merge;
+		}
+	};
+}
+var init_merge = __esm({ "src/lib/tasks/merge.ts"() {
+	"use strict";
+	init_git_response_error();
+	init_parse_merge();
+	init_task();
+} });
+function pushResultPushedItem(local, remote, status) {
+	const deleted = status.includes("deleted");
+	const tag = status.includes("tag") || /^refs\/tags/.test(local);
+	const alreadyUpdated = !status.includes("new");
+	return {
+		deleted,
+		tag,
+		branch: !tag,
+		new: !alreadyUpdated,
+		alreadyUpdated,
+		local,
+		remote
+	};
+}
+var parsers5, parsePushResult, parsePushDetail;
+var init_parse_push = __esm({ "src/lib/parsers/parse-push.ts"() {
+	"use strict";
+	init_utils();
+	init_parse_remote_messages();
+	parsers5 = [
+		new LineParser(/^Pushing to (.+)$/, (result, [repo]) => {
+			result.repo = repo;
+		}),
+		new LineParser(/^updating local tracking ref '(.+)'/, (result, [local]) => {
+			result.ref = {
+				...result.ref || {},
+				local
+			};
+		}),
+		new LineParser(/^[=*-]\s+([^:]+):(\S+)\s+\[(.+)]$/, (result, [local, remote, type]) => {
+			result.pushed.push(pushResultPushedItem(local, remote, type));
+		}),
+		new LineParser(/^Branch '([^']+)' set up to track remote branch '([^']+)' from '([^']+)'/, (result, [local, remote, remoteName]) => {
+			result.branch = {
+				...result.branch || {},
+				local,
+				remote,
+				remoteName
+			};
+		}),
+		new LineParser(/^([^:]+):(\S+)\s+([a-z0-9]+)\.\.([a-z0-9]+)$/, (result, [local, remote, from, to]) => {
+			result.update = {
+				head: {
+					local,
+					remote
+				},
+				hash: {
+					from,
+					to
+				}
+			};
+		})
+	];
+	parsePushResult = (stdOut, stdErr) => {
+		const pushDetail = parsePushDetail(stdOut, stdErr);
+		const responseDetail = parseRemoteMessages(stdOut, stdErr);
+		return {
+			...pushDetail,
+			...responseDetail
+		};
+	};
+	parsePushDetail = (stdOut, stdErr) => {
+		return parseStringResponse({ pushed: [] }, parsers5, [stdOut, stdErr]);
+	};
+} });
+var push_exports = {};
+__export(push_exports, {
+	pushTagsTask: () => pushTagsTask,
+	pushTask: () => pushTask
+});
+function pushTagsTask(ref = {}, customArgs) {
+	append(customArgs, "--tags");
+	return pushTask(ref, customArgs);
+}
+function pushTask(ref = {}, customArgs) {
+	const commands = ["push", ...customArgs];
+	if (ref.branch) commands.splice(1, 0, ref.branch);
+	if (ref.remote) commands.splice(1, 0, ref.remote);
+	remove(commands, "-v");
+	append(commands, "--verbose");
+	append(commands, "--porcelain");
+	return {
+		commands,
+		format: "utf-8",
+		parser: parsePushResult
+	};
+}
+var init_push = __esm({ "src/lib/tasks/push.ts"() {
+	"use strict";
+	init_parse_push();
+	init_utils();
+} });
+function show_default() {
+	return {
+		showBuffer() {
+			const commands = ["show", ...getTrailingOptions(arguments, 1)];
+			if (!commands.includes("--binary")) commands.splice(1, 0, "--binary");
+			return this._runTask(straightThroughBufferTask(commands), trailingFunctionArgument(arguments));
+		},
+		show() {
+			const commands = ["show", ...getTrailingOptions(arguments, 1)];
+			return this._runTask(straightThroughStringTask(commands), trailingFunctionArgument(arguments));
+		}
+	};
+}
+var init_show = __esm({ "src/lib/tasks/show.ts"() {
+	"use strict";
+	init_utils();
+	init_task();
+} });
+var fromPathRegex, FileStatusSummary;
+var init_FileStatusSummary = __esm({ "src/lib/responses/FileStatusSummary.ts"() {
+	"use strict";
+	fromPathRegex = /^(.+)\0(.+)$/;
+	FileStatusSummary = class {
+		constructor(path, index, working_dir) {
+			this.path = path;
+			this.index = index;
+			this.working_dir = working_dir;
+			if (index === "R" || working_dir === "R") {
+				const detail = fromPathRegex.exec(path) || [
+					null,
+					path,
+					path
+				];
+				this.from = detail[2] || "";
+				this.path = detail[1] || "";
+			}
+		}
+	};
+} });
+function renamedFile(line) {
+	const [to, from] = line.split(NULL);
+	return {
+		from: from || to,
+		to
+	};
+}
+function parser3(indexX, indexY, handler) {
+	return [`${indexX}${indexY}`, handler];
+}
+function conflicts(indexX, ...indexY) {
+	return indexY.map((y) => parser3(indexX, y, (result, file) => append(result.conflicted, file)));
+}
+function splitLine(result, lineStr) {
+	const trimmed2 = lineStr.trim();
+	switch (" ") {
+		case trimmed2.charAt(2): return data(trimmed2.charAt(0), trimmed2.charAt(1), trimmed2.substr(3));
+		case trimmed2.charAt(1): return data(" ", trimmed2.charAt(0), trimmed2.substr(2));
+		default: return;
+	}
+	function data(index, workingDir, path) {
+		const raw = `${index}${workingDir}`;
+		const handler = parsers6.get(raw);
+		if (handler) handler(result, path);
+		if (raw !== "##" && raw !== "!!") result.files.push(new FileStatusSummary(path, index, workingDir));
+	}
+}
+var StatusSummary, parsers6, parseStatusSummary;
+var init_StatusSummary = __esm({ "src/lib/responses/StatusSummary.ts"() {
+	"use strict";
+	init_utils();
+	init_FileStatusSummary();
+	StatusSummary = class {
+		constructor() {
+			this.not_added = [];
+			this.conflicted = [];
+			this.created = [];
+			this.deleted = [];
+			this.ignored = void 0;
+			this.modified = [];
+			this.renamed = [];
+			this.files = [];
+			this.staged = [];
+			this.ahead = 0;
+			this.behind = 0;
+			this.current = null;
+			this.tracking = null;
+			this.detached = false;
+			this.isClean = () => {
+				return !this.files.length;
+			};
+		}
+	};
+	parsers6 = new Map([
+		parser3(" ", "A", (result, file) => append(result.created, file)),
+		parser3(" ", "D", (result, file) => append(result.deleted, file)),
+		parser3(" ", "M", (result, file) => append(result.modified, file)),
+		parser3("A", " ", (result, file) => append(result.created, file) && append(result.staged, file)),
+		parser3("A", "M", (result, file) => append(result.created, file) && append(result.staged, file) && append(result.modified, file)),
+		parser3("D", " ", (result, file) => append(result.deleted, file) && append(result.staged, file)),
+		parser3("M", " ", (result, file) => append(result.modified, file) && append(result.staged, file)),
+		parser3("M", "M", (result, file) => append(result.modified, file) && append(result.staged, file)),
+		parser3("R", " ", (result, file) => {
+			append(result.renamed, renamedFile(file));
+		}),
+		parser3("R", "M", (result, file) => {
+			const renamed = renamedFile(file);
+			append(result.renamed, renamed);
+			append(result.modified, renamed.to);
+		}),
+		parser3("!", "!", (_result, _file) => {
+			append(_result.ignored = _result.ignored || [], _file);
+		}),
+		parser3("?", "?", (result, file) => append(result.not_added, file)),
+		...conflicts("A", "A", "U"),
+		...conflicts("D", "D", "U"),
+		...conflicts("U", "A", "D", "U"),
+		["##", (result, line) => {
+			const aheadReg = /ahead (\d+)/;
+			const behindReg = /behind (\d+)/;
+			const currentReg = /^(.+?(?=(?:\.{3}|\s|$)))/;
+			const trackingReg = /\.{3}(\S*)/;
+			const onEmptyBranchReg = /\son\s(\S+?)(?=\.{3}|$)/;
+			let regexResult = aheadReg.exec(line);
+			result.ahead = regexResult && +regexResult[1] || 0;
+			regexResult = behindReg.exec(line);
+			result.behind = regexResult && +regexResult[1] || 0;
+			regexResult = currentReg.exec(line);
+			result.current = filterType(regexResult?.[1], filterString, null);
+			regexResult = trackingReg.exec(line);
+			result.tracking = filterType(regexResult?.[1], filterString, null);
+			regexResult = onEmptyBranchReg.exec(line);
+			if (regexResult) result.current = filterType(regexResult?.[1], filterString, result.current);
+			result.detached = /\(no branch\)/.test(line);
+		}]
+	]);
+	parseStatusSummary = function(text) {
+		const lines = text.split(NULL);
+		const status = new StatusSummary();
+		for (let i = 0, l = lines.length; i < l;) {
+			let line = lines[i++].trim();
+			if (!line) continue;
+			if (line.charAt(0) === "R") line += NULL + (lines[i++] || "");
+			splitLine(status, line);
+		}
+		return status;
+	};
+} });
+function statusTask(customArgs) {
+	return {
+		format: "utf-8",
+		commands: [
+			"status",
+			"--porcelain",
+			"-b",
+			"-u",
+			"--null",
+			...customArgs.filter((arg) => !ignoredOptions.includes(arg))
+		],
+		parser(text) {
+			return parseStatusSummary(text);
+		}
+	};
+}
+var ignoredOptions;
+var init_status = __esm({ "src/lib/tasks/status.ts"() {
+	"use strict";
+	init_StatusSummary();
+	ignoredOptions = ["--null", "-z"];
+} });
+function versionResponse(major = 0, minor = 0, patch = 0, agent = "", installed = true) {
+	return Object.defineProperty({
+		major,
+		minor,
+		patch,
+		agent,
+		installed
+	}, "toString", {
+		value() {
+			return `${this.major}.${this.minor}.${this.patch}`;
+		},
+		configurable: false,
+		enumerable: false
+	});
+}
+function notInstalledResponse() {
+	return versionResponse(0, 0, 0, "", false);
+}
+function version_default() {
+	return { version() {
+		return this._runTask({
+			commands: ["--version"],
+			format: "utf-8",
+			parser: versionParser,
+			onError(result, error, done, fail) {
+				if (result.exitCode === -2) return done(Buffer.from(NOT_INSTALLED));
+				fail(error);
+			}
+		});
+	} };
+}
+function versionParser(stdOut) {
+	if (stdOut === NOT_INSTALLED) return notInstalledResponse();
+	return parseStringResponse(versionResponse(0, 0, 0, stdOut), parsers7, stdOut);
+}
+var NOT_INSTALLED, parsers7;
+var init_version = __esm({ "src/lib/tasks/version.ts"() {
+	"use strict";
+	init_utils();
+	NOT_INSTALLED = "installed=false";
+	parsers7 = [new LineParser(/version (\d+)\.(\d+)\.(\d+)(?:\s*\((.+)\))?/, (result, [major, minor, patch, agent = ""]) => {
+		Object.assign(result, versionResponse(asNumber(major), asNumber(minor), asNumber(patch), agent));
+	}), new LineParser(/version (\d+)\.(\d+)\.(\D+)(.+)?$/, (result, [major, minor, patch, agent = ""]) => {
+		Object.assign(result, versionResponse(asNumber(major), asNumber(minor), patch, agent));
+	})];
+} });
+var simple_git_api_exports = {};
+__export(simple_git_api_exports, { SimpleGitApi: () => SimpleGitApi });
+var SimpleGitApi;
+var init_simple_git_api = __esm({ "src/lib/simple-git-api.ts"() {
+	"use strict";
+	init_task_callback();
+	init_change_working_directory();
+	init_checkout();
+	init_count_objects();
+	init_commit();
+	init_config();
+	init_first_commit();
+	init_grep();
+	init_hash_object();
+	init_init();
+	init_log();
+	init_merge();
+	init_push();
+	init_show();
+	init_status();
+	init_task();
+	init_version();
+	init_utils();
+	SimpleGitApi = class {
+		constructor(_executor) {
+			this._executor = _executor;
+		}
+		_runTask(task, then) {
+			const chain = this._executor.chain();
+			const promise = chain.push(task);
+			if (then) taskCallback(task, promise, then);
+			return Object.create(this, {
+				then: { value: promise.then.bind(promise) },
+				catch: { value: promise.catch.bind(promise) },
+				_executor: { value: chain }
+			});
+		}
+		add(files) {
+			return this._runTask(straightThroughStringTask(["add", ...asArray(files)]), trailingFunctionArgument(arguments));
+		}
+		cwd(directory) {
+			const next = trailingFunctionArgument(arguments);
+			if (typeof directory === "string") return this._runTask(changeWorkingDirectoryTask(directory, this._executor), next);
+			if (typeof directory?.path === "string") return this._runTask(changeWorkingDirectoryTask(directory.path, directory.root && this._executor || void 0), next);
+			return this._runTask(configurationErrorTask("Git.cwd: workingDirectory must be supplied as a string"), next);
+		}
+		hashObject(path, write) {
+			return this._runTask(hashObjectTask(path, write === true), trailingFunctionArgument(arguments));
+		}
+		init(bare) {
+			return this._runTask(initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
+		}
+		merge() {
+			return this._runTask(mergeTask(getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
+		}
+		mergeFromTo(remote, branch) {
+			if (!(filterString(remote) && filterString(branch))) return this._runTask(configurationErrorTask(`Git.mergeFromTo requires that the 'remote' and 'branch' arguments are supplied as strings`));
+			return this._runTask(mergeTask([
+				remote,
+				branch,
+				...getTrailingOptions(arguments)
+			]), trailingFunctionArgument(arguments, false));
+		}
+		outputHandler(handler) {
+			this._executor.outputHandler = handler;
+			return this;
+		}
+		push() {
+			const task = pushTask({
+				remote: filterType(arguments[0], filterString),
+				branch: filterType(arguments[1], filterString)
+			}, getTrailingOptions(arguments));
+			return this._runTask(task, trailingFunctionArgument(arguments));
+		}
+		stash() {
+			return this._runTask(straightThroughStringTask(["stash", ...getTrailingOptions(arguments)]), trailingFunctionArgument(arguments));
+		}
+		status() {
+			return this._runTask(statusTask(getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
+		}
+	};
+	Object.assign(SimpleGitApi.prototype, checkout_default(), commit_default(), config_default(), count_objects_default(), first_commit_default(), grep_default(), log_default(), show_default(), version_default());
+} });
+var scheduler_exports = {};
+__export(scheduler_exports, { Scheduler: () => Scheduler });
+var createScheduledTask, Scheduler;
+var init_scheduler = __esm({ "src/lib/runners/scheduler.ts"() {
+	"use strict";
+	init_utils();
+	init_git_logger();
+	createScheduledTask = /* @__PURE__ */ (() => {
+		let id = 0;
+		return () => {
+			id++;
+			const { promise, done } = (0, import_dist$1.createDeferred)();
+			return {
+				promise,
+				done,
+				id
+			};
+		};
+	})();
+	Scheduler = class {
+		constructor(concurrency = 2) {
+			this.concurrency = concurrency;
+			this.logger = createLogger("", "scheduler");
+			this.pending = [];
+			this.running = [];
+			this.logger(`Constructed, concurrency=%s`, concurrency);
+		}
+		schedule() {
+			if (!this.pending.length || this.running.length >= this.concurrency) {
+				this.logger(`Schedule attempt ignored, pending=%s running=%s concurrency=%s`, this.pending.length, this.running.length, this.concurrency);
+				return;
+			}
+			const task = append(this.running, this.pending.shift());
+			this.logger(`Attempting id=%s`, task.id);
+			task.done(() => {
+				this.logger(`Completing id=`, task.id);
+				remove(this.running, task);
+				this.schedule();
+			});
+		}
+		next() {
+			const { promise, id } = append(this.pending, createScheduledTask());
+			this.logger(`Scheduling id=%s`, id);
+			this.schedule();
+			return promise;
+		}
+	};
+} });
+var apply_patch_exports = {};
+__export(apply_patch_exports, { applyPatchTask: () => applyPatchTask });
+function applyPatchTask(patches, customArgs) {
+	return straightThroughStringTask([
+		"apply",
+		...customArgs,
+		...patches
+	]);
+}
+var init_apply_patch = __esm({ "src/lib/tasks/apply-patch.ts"() {
+	"use strict";
+	init_task();
+} });
+function branchDeletionSuccess(branch, hash) {
+	return {
+		branch,
+		hash,
+		success: true
+	};
+}
+function branchDeletionFailure(branch) {
+	return {
+		branch,
+		hash: null,
+		success: false
+	};
+}
+var BranchDeletionBatch;
+var init_BranchDeleteSummary = __esm({ "src/lib/responses/BranchDeleteSummary.ts"() {
+	"use strict";
+	BranchDeletionBatch = class {
+		constructor() {
+			this.all = [];
+			this.branches = {};
+			this.errors = [];
+		}
+		get success() {
+			return !this.errors.length;
+		}
+	};
+} });
+function hasBranchDeletionError(data, processExitCode) {
+	return processExitCode === 1 && deleteErrorRegex.test(data);
+}
+var deleteSuccessRegex, deleteErrorRegex, parsers8, parseBranchDeletions;
+var init_parse_branch_delete = __esm({ "src/lib/parsers/parse-branch-delete.ts"() {
+	"use strict";
+	init_BranchDeleteSummary();
+	init_utils();
+	deleteSuccessRegex = /(\S+)\s+\(\S+\s([^)]+)\)/;
+	deleteErrorRegex = /^error[^']+'([^']+)'/m;
+	parsers8 = [new LineParser(deleteSuccessRegex, (result, [branch, hash]) => {
+		const deletion = branchDeletionSuccess(branch, hash);
+		result.all.push(deletion);
+		result.branches[branch] = deletion;
+	}), new LineParser(deleteErrorRegex, (result, [branch]) => {
+		const deletion = branchDeletionFailure(branch);
+		result.errors.push(deletion);
+		result.all.push(deletion);
+		result.branches[branch] = deletion;
+	})];
+	parseBranchDeletions = (stdOut, stdErr) => {
+		return parseStringResponse(new BranchDeletionBatch(), parsers8, [stdOut, stdErr]);
+	};
+} });
+var BranchSummaryResult;
+var init_BranchSummary = __esm({ "src/lib/responses/BranchSummary.ts"() {
+	"use strict";
+	BranchSummaryResult = class {
+		constructor() {
+			this.all = [];
+			this.branches = {};
+			this.current = "";
+			this.detached = false;
+		}
+		push(status, detached, name, commit, label) {
+			if (status === "*") {
+				this.detached = detached;
+				this.current = name;
+			}
+			this.all.push(name);
+			this.branches[name] = {
+				current: status === "*",
+				linkedWorkTree: status === "+",
+				name,
+				commit,
+				label
+			};
+		}
+	};
+} });
+function branchStatus(input) {
+	return input ? input.charAt(0) : "";
+}
+function parseBranchSummary(stdOut, currentOnly = false) {
+	return parseStringResponse(new BranchSummaryResult(), currentOnly ? [currentBranchParser] : parsers9, stdOut);
+}
+var parsers9, currentBranchParser;
+var init_parse_branch = __esm({ "src/lib/parsers/parse-branch.ts"() {
+	"use strict";
+	init_BranchSummary();
+	init_utils();
+	parsers9 = [new LineParser(/^([*+]\s)?\((?:HEAD )?detached (?:from|at) (\S+)\)\s+([a-z0-9]+)\s(.*)$/, (result, [current, name, commit, label]) => {
+		result.push(branchStatus(current), true, name, commit, label);
+	}), new LineParser(/^([*+]\s)?(\S+)\s+([a-z0-9]+)\s?(.*)$/s, (result, [current, name, commit, label]) => {
+		result.push(branchStatus(current), false, name, commit, label);
+	})];
+	currentBranchParser = new LineParser(/^(\S+)$/s, (result, [name]) => {
+		result.push("*", false, name, "", "");
+	});
+} });
+var branch_exports = {};
+__export(branch_exports, {
+	branchLocalTask: () => branchLocalTask,
+	branchTask: () => branchTask,
+	containsDeleteBranchCommand: () => containsDeleteBranchCommand,
+	deleteBranchTask: () => deleteBranchTask,
+	deleteBranchesTask: () => deleteBranchesTask
+});
+function containsDeleteBranchCommand(commands) {
+	const deleteCommands = [
+		"-d",
+		"-D",
+		"--delete"
+	];
+	return commands.some((command) => deleteCommands.includes(command));
+}
+function branchTask(customArgs) {
+	const isDelete = containsDeleteBranchCommand(customArgs);
+	const isCurrentOnly = customArgs.includes("--show-current");
+	const commands = ["branch", ...customArgs];
+	if (commands.length === 1) commands.push("-a");
+	if (!commands.includes("-v")) commands.splice(1, 0, "-v");
+	return {
+		format: "utf-8",
+		commands,
+		parser(stdOut, stdErr) {
+			if (isDelete) return parseBranchDeletions(stdOut, stdErr).all[0];
+			return parseBranchSummary(stdOut, isCurrentOnly);
+		}
+	};
+}
+function branchLocalTask() {
+	return {
+		format: "utf-8",
+		commands: ["branch", "-v"],
+		parser(stdOut) {
+			return parseBranchSummary(stdOut);
+		}
+	};
+}
+function deleteBranchesTask(branches, forceDelete = false) {
+	return {
+		format: "utf-8",
+		commands: [
+			"branch",
+			"-v",
+			forceDelete ? "-D" : "-d",
+			...branches
+		],
+		parser(stdOut, stdErr) {
+			return parseBranchDeletions(stdOut, stdErr);
+		},
+		onError({ exitCode, stdOut }, error, done, fail) {
+			if (!hasBranchDeletionError(String(error), exitCode)) return fail(error);
+			done(stdOut);
+		}
+	};
+}
+function deleteBranchTask(branch, forceDelete = false) {
+	const task = {
+		format: "utf-8",
+		commands: [
+			"branch",
+			"-v",
+			forceDelete ? "-D" : "-d",
+			branch
+		],
+		parser(stdOut, stdErr) {
+			return parseBranchDeletions(stdOut, stdErr).branches[branch];
+		},
+		onError({ exitCode, stdErr, stdOut }, error, _, fail) {
+			if (!hasBranchDeletionError(String(error), exitCode)) return fail(error);
+			throw new GitResponseError(task.parser(bufferToString(stdOut), bufferToString(stdErr)), String(error));
+		}
+	};
+	return task;
+}
+var init_branch = __esm({ "src/lib/tasks/branch.ts"() {
+	"use strict";
+	init_git_response_error();
+	init_parse_branch_delete();
+	init_parse_branch();
+	init_utils();
+} });
+function toPath(input) {
+	const path = input.trim().replace(/^["']|["']$/g, "");
+	return path && normalize(path);
+}
+var parseCheckIgnore;
+var init_CheckIgnore = __esm({ "src/lib/responses/CheckIgnore.ts"() {
+	"use strict";
+	parseCheckIgnore = (text) => {
+		return text.split(/\n/g).map(toPath).filter(Boolean);
+	};
+} });
+var check_ignore_exports = {};
+__export(check_ignore_exports, { checkIgnoreTask: () => checkIgnoreTask });
+function checkIgnoreTask(paths) {
+	return {
+		commands: ["check-ignore", ...paths],
+		format: "utf-8",
+		parser: parseCheckIgnore
+	};
+}
+var init_check_ignore = __esm({ "src/lib/tasks/check-ignore.ts"() {
+	"use strict";
+	init_CheckIgnore();
+} });
+var clone_exports = {};
+__export(clone_exports, {
+	cloneMirrorTask: () => cloneMirrorTask,
+	cloneTask: () => cloneTask
+});
+function disallowedCommand(command) {
+	return /^--upload-pack(=|$)/.test(command);
+}
+function cloneTask(repo, directory, customArgs) {
+	const commands = ["clone", ...customArgs];
+	filterString(repo) && commands.push(repo);
+	filterString(directory) && commands.push(directory);
+	if (commands.find(disallowedCommand)) return configurationErrorTask(`git.fetch: potential exploit argument blocked.`);
+	return straightThroughStringTask(commands);
+}
+function cloneMirrorTask(repo, directory, customArgs) {
+	append(customArgs, "--mirror");
+	return cloneTask(repo, directory, customArgs);
+}
+var init_clone = __esm({ "src/lib/tasks/clone.ts"() {
+	"use strict";
+	init_task();
+	init_utils();
+} });
+function parseFetchResult(stdOut, stdErr) {
+	return parseStringResponse({
+		raw: stdOut,
+		remote: null,
+		branches: [],
+		tags: [],
+		updated: [],
+		deleted: []
+	}, parsers10, [stdOut, stdErr]);
+}
+var parsers10;
+var init_parse_fetch = __esm({ "src/lib/parsers/parse-fetch.ts"() {
+	"use strict";
+	init_utils();
+	parsers10 = [
+		new LineParser(/From (.+)$/, (result, [remote]) => {
+			result.remote = remote;
+		}),
+		new LineParser(/\* \[new branch]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => {
+			result.branches.push({
+				name,
+				tracking
+			});
+		}),
+		new LineParser(/\* \[new tag]\s+(\S+)\s*-> (.+)$/, (result, [name, tracking]) => {
+			result.tags.push({
+				name,
+				tracking
+			});
+		}),
+		new LineParser(/- \[deleted]\s+\S+\s*-> (.+)$/, (result, [tracking]) => {
+			result.deleted.push({ tracking });
+		}),
+		new LineParser(/\s*([^.]+)\.\.(\S+)\s+(\S+)\s*-> (.+)$/, (result, [from, to, name, tracking]) => {
+			result.updated.push({
+				name,
+				tracking,
+				to,
+				from
+			});
+		})
+	];
+} });
+var fetch_exports = {};
+__export(fetch_exports, { fetchTask: () => fetchTask });
+function disallowedCommand2(command) {
+	return /^--upload-pack(=|$)/.test(command);
+}
+function fetchTask(remote, branch, customArgs) {
+	const commands = ["fetch", ...customArgs];
+	if (remote && branch) commands.push(remote, branch);
+	if (commands.find(disallowedCommand2)) return configurationErrorTask(`git.fetch: potential exploit argument blocked.`);
+	return {
+		commands,
+		format: "utf-8",
+		parser: parseFetchResult
+	};
+}
+var init_fetch = __esm({ "src/lib/tasks/fetch.ts"() {
+	"use strict";
+	init_parse_fetch();
+	init_task();
+} });
+function parseMoveResult(stdOut) {
+	return parseStringResponse({ moves: [] }, parsers11, stdOut);
+}
+var parsers11;
+var init_parse_move = __esm({ "src/lib/parsers/parse-move.ts"() {
+	"use strict";
+	init_utils();
+	parsers11 = [new LineParser(/^Renaming (.+) to (.+)$/, (result, [from, to]) => {
+		result.moves.push({
+			from,
+			to
+		});
+	})];
+} });
+var move_exports = {};
+__export(move_exports, { moveTask: () => moveTask });
+function moveTask(from, to) {
+	return {
+		commands: [
+			"mv",
+			"-v",
+			...asArray(from),
+			to
+		],
+		format: "utf-8",
+		parser: parseMoveResult
+	};
+}
+var init_move = __esm({ "src/lib/tasks/move.ts"() {
+	"use strict";
+	init_parse_move();
+	init_utils();
+} });
+var pull_exports = {};
+__export(pull_exports, { pullTask: () => pullTask });
+function pullTask(remote, branch, customArgs) {
+	const commands = ["pull", ...customArgs];
+	if (remote && branch) commands.splice(1, 0, remote, branch);
+	return {
+		commands,
+		format: "utf-8",
+		parser(stdOut, stdErr) {
+			return parsePullResult(stdOut, stdErr);
+		},
+		onError(result, _error, _done, fail) {
+			const pullError = parsePullErrorResult(bufferToString(result.stdOut), bufferToString(result.stdErr));
+			if (pullError) return fail(new GitResponseError(pullError));
+			fail(_error);
+		}
+	};
+}
+var init_pull = __esm({ "src/lib/tasks/pull.ts"() {
+	"use strict";
+	init_git_response_error();
+	init_parse_pull();
+	init_utils();
+} });
+function parseGetRemotes(text) {
+	const remotes = {};
+	forEach(text, ([name]) => remotes[name] = { name });
+	return Object.values(remotes);
+}
+function parseGetRemotesVerbose(text) {
+	const remotes = {};
+	forEach(text, ([name, url, purpose]) => {
+		if (!Object.hasOwn(remotes, name)) remotes[name] = {
+			name,
+			refs: {
+				fetch: "",
+				push: ""
+			}
+		};
+		if (purpose && url) remotes[name].refs[purpose.replace(/[^a-z]/g, "")] = url;
+	});
+	return Object.values(remotes);
+}
+function forEach(text, handler) {
+	forEachLineWithContent(text, (line) => handler(line.split(/\s+/)));
+}
+var init_GetRemoteSummary = __esm({ "src/lib/responses/GetRemoteSummary.ts"() {
+	"use strict";
+	init_utils();
+} });
+var remote_exports = {};
+__export(remote_exports, {
+	addRemoteTask: () => addRemoteTask,
+	getRemotesTask: () => getRemotesTask,
+	listRemotesTask: () => listRemotesTask,
+	remoteTask: () => remoteTask,
+	removeRemoteTask: () => removeRemoteTask
+});
+function addRemoteTask(remoteName, remoteRepo, customArgs) {
+	return straightThroughStringTask([
+		"remote",
+		"add",
+		...customArgs,
+		remoteName,
+		remoteRepo
+	]);
+}
+function getRemotesTask(verbose) {
+	const commands = ["remote"];
+	if (verbose) commands.push("-v");
+	return {
+		commands,
+		format: "utf-8",
+		parser: verbose ? parseGetRemotesVerbose : parseGetRemotes
+	};
+}
+function listRemotesTask(customArgs) {
+	const commands = [...customArgs];
+	if (commands[0] !== "ls-remote") commands.unshift("ls-remote");
+	return straightThroughStringTask(commands);
+}
+function remoteTask(customArgs) {
+	const commands = [...customArgs];
+	if (commands[0] !== "remote") commands.unshift("remote");
+	return straightThroughStringTask(commands);
+}
+function removeRemoteTask(remoteName) {
+	return straightThroughStringTask([
+		"remote",
+		"remove",
+		remoteName
+	]);
+}
+var init_remote = __esm({ "src/lib/tasks/remote.ts"() {
+	"use strict";
+	init_GetRemoteSummary();
+	init_task();
+} });
+var stash_list_exports = {};
+__export(stash_list_exports, { stashListTask: () => stashListTask });
+function stashListTask(opt = {}, customArgs) {
+	const options = parseLogOptions(opt);
+	const commands = [
+		"stash",
+		"list",
+		...options.commands,
+		...customArgs
+	];
+	const parser4 = createListLogSummaryParser(options.splitter, options.fields, logFormatFromCommand(commands));
+	return validateLogFormatConfig(commands) || {
+		commands,
+		format: "utf-8",
+		parser: parser4
+	};
+}
+var init_stash_list = __esm({ "src/lib/tasks/stash-list.ts"() {
+	"use strict";
+	init_log_format();
+	init_parse_list_log_summary();
+	init_diff();
+	init_log();
+} });
+var sub_module_exports = {};
+__export(sub_module_exports, {
+	addSubModuleTask: () => addSubModuleTask,
+	initSubModuleTask: () => initSubModuleTask,
+	subModuleTask: () => subModuleTask,
+	updateSubModuleTask: () => updateSubModuleTask
+});
+function addSubModuleTask(repo, path) {
+	return subModuleTask([
+		"add",
+		repo,
+		path
+	]);
+}
+function initSubModuleTask(customArgs) {
+	return subModuleTask(["init", ...customArgs]);
+}
+function subModuleTask(customArgs) {
+	const commands = [...customArgs];
+	if (commands[0] !== "submodule") commands.unshift("submodule");
+	return straightThroughStringTask(commands);
+}
+function updateSubModuleTask(customArgs) {
+	return subModuleTask(["update", ...customArgs]);
+}
+var init_sub_module = __esm({ "src/lib/tasks/sub-module.ts"() {
+	"use strict";
+	init_task();
+} });
+function singleSorted(a, b) {
+	const aIsNum = Number.isNaN(a);
+	if (aIsNum !== Number.isNaN(b)) return aIsNum ? 1 : -1;
+	return aIsNum ? sorted(a, b) : 0;
+}
+function sorted(a, b) {
+	return a === b ? 0 : a > b ? 1 : -1;
+}
+function trimmed(input) {
+	return input.trim();
+}
+function toNumber(input) {
+	if (typeof input === "string") return parseInt(input.replace(/^\D+/g, ""), 10) || 0;
+	return 0;
+}
+var TagList, parseTagList;
+var init_TagList = __esm({ "src/lib/responses/TagList.ts"() {
+	"use strict";
+	TagList = class {
+		constructor(all, latest) {
+			this.all = all;
+			this.latest = latest;
+		}
+	};
+	parseTagList = function(data, customSort = false) {
+		const tags = data.split("\n").map(trimmed).filter(Boolean);
+		if (!customSort) tags.sort(function(tagA, tagB) {
+			const partsA = tagA.split(".");
+			const partsB = tagB.split(".");
+			if (partsA.length === 1 || partsB.length === 1) return singleSorted(toNumber(partsA[0]), toNumber(partsB[0]));
+			for (let i = 0, l = Math.max(partsA.length, partsB.length); i < l; i++) {
+				const diff = sorted(toNumber(partsA[i]), toNumber(partsB[i]));
+				if (diff) return diff;
+			}
+			return 0;
+		});
+		const latest = customSort ? tags[0] : [...tags].reverse().find((tag) => tag.indexOf(".") >= 0);
+		return new TagList(tags, latest);
+	};
+} });
+var tag_exports = {};
+__export(tag_exports, {
+	addAnnotatedTagTask: () => addAnnotatedTagTask,
+	addTagTask: () => addTagTask,
+	tagListTask: () => tagListTask
+});
+function tagListTask(customArgs = []) {
+	const hasCustomSort = customArgs.some((option) => /^--sort=/.test(option));
+	return {
+		format: "utf-8",
+		commands: [
+			"tag",
+			"-l",
+			...customArgs
+		],
+		parser(text) {
+			return parseTagList(text, hasCustomSort);
+		}
+	};
+}
+function addTagTask(name) {
+	return {
+		format: "utf-8",
+		commands: ["tag", name],
+		parser() {
+			return { name };
+		}
+	};
+}
+function addAnnotatedTagTask(name, tagMessage) {
+	return {
+		format: "utf-8",
+		commands: [
+			"tag",
+			"-a",
+			"-m",
+			tagMessage,
+			name
+		],
+		parser() {
+			return { name };
+		}
+	};
+}
+var init_tag = __esm({ "src/lib/tasks/tag.ts"() {
+	"use strict";
+	init_TagList();
+} });
+var require_git = __commonJS({ "src/git.js"(exports, module) {
+	"use strict";
+	var { GitExecutor: GitExecutor2 } = (init_git_executor(), __toCommonJS(git_executor_exports));
+	var { SimpleGitApi: SimpleGitApi2 } = (init_simple_git_api(), __toCommonJS(simple_git_api_exports));
+	var { Scheduler: Scheduler2 } = (init_scheduler(), __toCommonJS(scheduler_exports));
+	var { configurationErrorTask: configurationErrorTask2 } = (init_task(), __toCommonJS(task_exports));
+	var { asArray: asArray2, filterArray: filterArray2, filterPrimitives: filterPrimitives2, filterString: filterString2, filterStringOrStringArray: filterStringOrStringArray2, filterType: filterType2, getTrailingOptions: getTrailingOptions2, trailingFunctionArgument: trailingFunctionArgument2, trailingOptionsArgument: trailingOptionsArgument2 } = (init_utils(), __toCommonJS(utils_exports));
+	var { applyPatchTask: applyPatchTask2 } = (init_apply_patch(), __toCommonJS(apply_patch_exports));
+	var { branchTask: branchTask2, branchLocalTask: branchLocalTask2, deleteBranchesTask: deleteBranchesTask2, deleteBranchTask: deleteBranchTask2 } = (init_branch(), __toCommonJS(branch_exports));
+	var { checkIgnoreTask: checkIgnoreTask2 } = (init_check_ignore(), __toCommonJS(check_ignore_exports));
+	var { checkIsRepoTask: checkIsRepoTask2 } = (init_check_is_repo(), __toCommonJS(check_is_repo_exports));
+	var { cloneTask: cloneTask2, cloneMirrorTask: cloneMirrorTask2 } = (init_clone(), __toCommonJS(clone_exports));
+	var { cleanWithOptionsTask: cleanWithOptionsTask2, isCleanOptionsArray: isCleanOptionsArray2 } = (init_clean(), __toCommonJS(clean_exports));
+	var { diffSummaryTask: diffSummaryTask2 } = (init_diff(), __toCommonJS(diff_exports));
+	var { fetchTask: fetchTask2 } = (init_fetch(), __toCommonJS(fetch_exports));
+	var { moveTask: moveTask2 } = (init_move(), __toCommonJS(move_exports));
+	var { pullTask: pullTask2 } = (init_pull(), __toCommonJS(pull_exports));
+	var { pushTagsTask: pushTagsTask2 } = (init_push(), __toCommonJS(push_exports));
+	var { addRemoteTask: addRemoteTask2, getRemotesTask: getRemotesTask2, listRemotesTask: listRemotesTask2, remoteTask: remoteTask2, removeRemoteTask: removeRemoteTask2 } = (init_remote(), __toCommonJS(remote_exports));
+	var { getResetMode: getResetMode2, resetTask: resetTask2 } = (init_reset(), __toCommonJS(reset_exports));
+	var { stashListTask: stashListTask2 } = (init_stash_list(), __toCommonJS(stash_list_exports));
+	var { addSubModuleTask: addSubModuleTask2, initSubModuleTask: initSubModuleTask2, subModuleTask: subModuleTask2, updateSubModuleTask: updateSubModuleTask2 } = (init_sub_module(), __toCommonJS(sub_module_exports));
+	var { addAnnotatedTagTask: addAnnotatedTagTask2, addTagTask: addTagTask2, tagListTask: tagListTask2 } = (init_tag(), __toCommonJS(tag_exports));
+	var { straightThroughBufferTask: straightThroughBufferTask2, straightThroughStringTask: straightThroughStringTask2 } = (init_task(), __toCommonJS(task_exports));
+	function Git2(options, plugins) {
+		this._plugins = plugins;
+		this._executor = new GitExecutor2(options.baseDir, new Scheduler2(options.maxConcurrentProcesses), plugins);
+		this._trimmed = options.trimmed;
+	}
+	(Git2.prototype = Object.create(SimpleGitApi2.prototype)).constructor = Git2;
+	Git2.prototype.customBinary = function(command) {
+		this._plugins.reconfigure("binary", command);
+		return this;
+	};
+	Git2.prototype.env = function(name, value) {
+		if (arguments.length === 1 && typeof name === "object") this._executor.env = name;
+		else (this._executor.env = this._executor.env || {})[name] = value;
+		return this;
+	};
+	Git2.prototype.stashList = function(options) {
+		return this._runTask(stashListTask2(trailingOptionsArgument2(arguments) || {}, filterArray2(options) && options || []), trailingFunctionArgument2(arguments));
+	};
+	function createCloneTask(api, task, repoPath, localPath) {
+		if (typeof repoPath !== "string") return configurationErrorTask2(`git.${api}() requires a string 'repoPath'`);
+		return task(repoPath, filterType2(localPath, filterString2), getTrailingOptions2(arguments));
+	}
+	Git2.prototype.clone = function() {
+		return this._runTask(createCloneTask("clone", cloneTask2, ...arguments), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.mirror = function() {
+		return this._runTask(createCloneTask("mirror", cloneMirrorTask2, ...arguments), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.mv = function(from, to) {
+		return this._runTask(moveTask2(from, to), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.checkoutLatestTag = function(then) {
+		var git = this;
+		return this.pull(function() {
+			git.tags(function(err, tags) {
+				git.checkout(tags.latest, then);
+			});
+		});
+	};
+	Git2.prototype.pull = function(remote, branch, options, then) {
+		return this._runTask(pullTask2(filterType2(remote, filterString2), filterType2(branch, filterString2), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.fetch = function(remote, branch) {
+		return this._runTask(fetchTask2(filterType2(remote, filterString2), filterType2(branch, filterString2), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.silent = function(silence) {
+		console.warn("simple-git deprecation notice: git.silent: logging should be configured using the `debug` library / `DEBUG` environment variable, this will be an error in version 3");
+		return this;
+	};
+	Git2.prototype.tags = function(options, then) {
+		return this._runTask(tagListTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.rebase = function() {
+		return this._runTask(straightThroughStringTask2(["rebase", ...getTrailingOptions2(arguments)]), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.reset = function(mode) {
+		return this._runTask(resetTask2(getResetMode2(mode), getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.revert = function(commit) {
+		const next = trailingFunctionArgument2(arguments);
+		if (typeof commit !== "string") return this._runTask(configurationErrorTask2("Commit must be a string"), next);
+		return this._runTask(straightThroughStringTask2([
+			"revert",
+			...getTrailingOptions2(arguments, 0, true),
+			commit
+		]), next);
+	};
+	Git2.prototype.addTag = function(name) {
+		const task = typeof name === "string" ? addTagTask2(name) : configurationErrorTask2("Git.addTag requires a tag name");
+		return this._runTask(task, trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.addAnnotatedTag = function(tagName, tagMessage) {
+		return this._runTask(addAnnotatedTagTask2(tagName, tagMessage), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.deleteLocalBranch = function(branchName, forceDelete, then) {
+		return this._runTask(deleteBranchTask2(branchName, typeof forceDelete === "boolean" ? forceDelete : false), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.deleteLocalBranches = function(branchNames, forceDelete, then) {
+		return this._runTask(deleteBranchesTask2(branchNames, typeof forceDelete === "boolean" ? forceDelete : false), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.branch = function(options, then) {
+		return this._runTask(branchTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.branchLocal = function(then) {
+		return this._runTask(branchLocalTask2(), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.raw = function(commands) {
+		const createRestCommands = !Array.isArray(commands);
+		const command = [].slice.call(createRestCommands ? arguments : commands, 0);
+		for (let i = 0; i < command.length && createRestCommands; i++) if (!filterPrimitives2(command[i])) {
+			command.splice(i, command.length - i);
+			break;
+		}
+		command.push(...getTrailingOptions2(arguments, 0, true));
+		var next = trailingFunctionArgument2(arguments);
+		if (!command.length) return this._runTask(configurationErrorTask2("Raw: must supply one or more command to execute"), next);
+		return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
+	};
+	Git2.prototype.submoduleAdd = function(repo, path, then) {
+		return this._runTask(addSubModuleTask2(repo, path), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.submoduleUpdate = function(args, then) {
+		return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.submoduleInit = function(args, then) {
+		return this._runTask(initSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.subModule = function(options, then) {
+		return this._runTask(subModuleTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.listRemote = function() {
+		return this._runTask(listRemotesTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.addRemote = function(remoteName, remoteRepo, then) {
+		return this._runTask(addRemoteTask2(remoteName, remoteRepo, getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.removeRemote = function(remoteName, then) {
+		return this._runTask(removeRemoteTask2(remoteName), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.getRemotes = function(verbose, then) {
+		return this._runTask(getRemotesTask2(verbose === true), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.remote = function(options, then) {
+		return this._runTask(remoteTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.tag = function(options, then) {
+		const command = getTrailingOptions2(arguments);
+		if (command[0] !== "tag") command.unshift("tag");
+		return this._runTask(straightThroughStringTask2(command), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.updateServerInfo = function(then) {
+		return this._runTask(straightThroughStringTask2(["update-server-info"]), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.pushTags = function(remote, then) {
+		const task = pushTagsTask2({ remote: filterType2(remote, filterString2) }, getTrailingOptions2(arguments));
+		return this._runTask(task, trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.rm = function(files) {
+		return this._runTask(straightThroughStringTask2([
+			"rm",
+			"-f",
+			...asArray2(files)
+		]), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.rmKeepLocal = function(files) {
+		return this._runTask(straightThroughStringTask2([
+			"rm",
+			"--cached",
+			...asArray2(files)
+		]), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.catFile = function(options, then) {
+		return this._catFile("utf-8", arguments);
+	};
+	Git2.prototype.binaryCatFile = function() {
+		return this._catFile("buffer", arguments);
+	};
+	Git2.prototype._catFile = function(format, args) {
+		var handler = trailingFunctionArgument2(args);
+		var command = ["cat-file"];
+		var options = args[0];
+		if (typeof options === "string") return this._runTask(configurationErrorTask2("Git.catFile: options must be supplied as an array of strings"), handler);
+		if (Array.isArray(options)) command.push.apply(command, options);
+		const task = format === "buffer" ? straightThroughBufferTask2(command) : straightThroughStringTask2(command);
+		return this._runTask(task, handler);
+	};
+	Git2.prototype.diff = function(options, then) {
+		const task = filterString2(options) ? configurationErrorTask2("git.diff: supplying options as a single string is no longer supported, switch to an array of strings") : straightThroughStringTask2(["diff", ...getTrailingOptions2(arguments)]);
+		return this._runTask(task, trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.diffSummary = function() {
+		return this._runTask(diffSummaryTask2(getTrailingOptions2(arguments, 1)), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.applyPatch = function(patches) {
+		const task = !filterStringOrStringArray2(patches) ? configurationErrorTask2(`git.applyPatch requires one or more string patches as the first argument`) : applyPatchTask2(asArray2(patches), getTrailingOptions2([].slice.call(arguments, 1)));
+		return this._runTask(task, trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.revparse = function() {
+		const commands = ["rev-parse", ...getTrailingOptions2(arguments, true)];
+		return this._runTask(straightThroughStringTask2(commands, true), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.clean = function(mode, options, then) {
+		const usingCleanOptionsArray = isCleanOptionsArray2(mode);
+		const cleanMode = usingCleanOptionsArray && mode.join("") || filterType2(mode, filterString2) || "";
+		const customArgs = getTrailingOptions2([].slice.call(arguments, usingCleanOptionsArray ? 1 : 0));
+		return this._runTask(cleanWithOptionsTask2(cleanMode, customArgs), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.exec = function(then) {
+		return this._runTask({
+			commands: [],
+			format: "utf-8",
+			parser() {
+				if (typeof then === "function") then();
+			}
+		});
+	};
+	Git2.prototype.clearQueue = function() {
+		return this;
+	};
+	Git2.prototype.checkIgnore = function(pathnames, then) {
+		return this._runTask(checkIgnoreTask2(asArray2(filterType2(pathnames, filterStringOrStringArray2, []))), trailingFunctionArgument2(arguments));
+	};
+	Git2.prototype.checkIsRepo = function(checkType, then) {
+		return this._runTask(checkIsRepoTask2(filterType2(checkType, filterString2)), trailingFunctionArgument2(arguments));
+	};
+	module.exports = Git2;
+} });
+init_pathspec();
+init_git_error();
+var GitConstructError = class extends GitError {
+	constructor(config, message) {
+		super(void 0, message);
+		this.config = config;
+	}
+};
+init_git_error();
+init_git_error();
+var GitPluginError = class extends GitError {
+	constructor(task, plugin, message) {
+		super(task, message);
+		this.task = task;
+		this.plugin = plugin;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+init_git_response_error();
+init_task_configuration_error();
+init_check_is_repo();
+init_clean();
+init_config();
+init_diff_name_status();
+init_grep();
+init_reset();
+function abortPlugin(signal) {
+	if (!signal) return;
+	return [{
+		type: "spawn.before",
+		action(_data, context) {
+			if (signal.aborted) context.kill(new GitPluginError(void 0, "abort", "Abort already signaled"));
+		}
+	}, {
+		type: "spawn.after",
+		action(_data, context) {
+			function kill() {
+				context.kill(new GitPluginError(void 0, "abort", "Abort signal received"));
+			}
+			signal.addEventListener("abort", kill);
+			context.spawned.on("close", () => signal.removeEventListener("abort", kill));
+		}
+	}];
+}
+function isConfigSwitch(arg) {
+	return typeof arg === "string" && arg.trim().toLowerCase() === "-c";
+}
+function preventProtocolOverride(arg, next) {
+	if (!isConfigSwitch(arg)) return;
+	if (!/^\s*protocol(.[a-z]+)?.allow/.test(next)) return;
+	throw new GitPluginError(void 0, "unsafe", "Configuring protocol.allow is not permitted without enabling allowUnsafeExtProtocol");
+}
+function preventUploadPack(arg, method) {
+	if (/^\s*--(upload|receive)-pack/.test(arg)) throw new GitPluginError(void 0, "unsafe", `Use of --upload-pack or --receive-pack is not permitted without enabling allowUnsafePack`);
+	if (method === "clone" && /^\s*-u\b/.test(arg)) throw new GitPluginError(void 0, "unsafe", `Use of clone with option -u is not permitted without enabling allowUnsafePack`);
+	if (method === "push" && /^\s*--exec\b/.test(arg)) throw new GitPluginError(void 0, "unsafe", `Use of push with option --exec is not permitted without enabling allowUnsafePack`);
+}
+function blockUnsafeOperationsPlugin({ allowUnsafeProtocolOverride = false, allowUnsafePack = false } = {}) {
+	return {
+		type: "spawn.args",
+		action(args, context) {
+			args.forEach((current, index) => {
+				const next = index < args.length ? args[index + 1] : "";
+				allowUnsafeProtocolOverride || preventProtocolOverride(current, next);
+				allowUnsafePack || preventUploadPack(current, context.method);
+			});
+			return args;
+		}
+	};
+}
+init_utils();
+function commandConfigPrefixingPlugin(configuration) {
+	const prefix = prefixedArray(configuration, "-c");
+	return {
+		type: "spawn.args",
+		action(data) {
+			return [...prefix, ...data];
+		}
+	};
+}
+init_utils();
+var never = (0, import_dist$1.deferred)().promise;
+function completionDetectionPlugin({ onClose = true, onExit = 50 } = {}) {
+	function createEvents() {
+		let exitCode = -1;
+		const events = {
+			close: (0, import_dist$1.deferred)(),
+			closeTimeout: (0, import_dist$1.deferred)(),
+			exit: (0, import_dist$1.deferred)(),
+			exitTimeout: (0, import_dist$1.deferred)()
+		};
+		const result = Promise.race([onClose === false ? never : events.closeTimeout.promise, onExit === false ? never : events.exitTimeout.promise]);
+		configureTimeout(onClose, events.close, events.closeTimeout);
+		configureTimeout(onExit, events.exit, events.exitTimeout);
+		return {
+			close(code) {
+				exitCode = code;
+				events.close.done();
+			},
+			exit(code) {
+				exitCode = code;
+				events.exit.done();
+			},
+			get exitCode() {
+				return exitCode;
+			},
+			result
+		};
+	}
+	function configureTimeout(flag, event, timeout) {
+		if (flag === false) return;
+		(flag === true ? event.promise : event.promise.then(() => delay(flag))).then(timeout.done);
+	}
+	return {
+		type: "spawn.after",
+		async action(_data, { spawned, close }) {
+			const events = createEvents();
+			let deferClose = true;
+			let quickClose = () => void (deferClose = false);
+			spawned.stdout?.on("data", quickClose);
+			spawned.stderr?.on("data", quickClose);
+			spawned.on("error", quickClose);
+			spawned.on("close", (code) => events.close(code));
+			spawned.on("exit", (code) => events.exit(code));
+			try {
+				await events.result;
+				if (deferClose) await delay(50);
+				close(events.exitCode);
+			} catch (err) {
+				close(events.exitCode, err);
+			}
+		}
+	};
+}
+init_utils();
+var WRONG_NUMBER_ERR = `Invalid value supplied for custom binary, requires a single string or an array containing either one or two strings`;
+var WRONG_CHARS_ERR = `Invalid value supplied for custom binary, restricted characters must be removed or supply the unsafe.allowUnsafeCustomBinary option`;
+function isBadArgument(arg) {
+	return !arg || !/^([a-z]:)?([a-z0-9/.\\_-]+)$/i.test(arg);
+}
+function toBinaryConfig(input, allowUnsafe) {
+	if (input.length < 1 || input.length > 2) throw new GitPluginError(void 0, "binary", WRONG_NUMBER_ERR);
+	if (input.some(isBadArgument)) if (allowUnsafe) console.warn(WRONG_CHARS_ERR);
+	else throw new GitPluginError(void 0, "binary", WRONG_CHARS_ERR);
+	const [binary, prefix] = input;
+	return {
+		binary,
+		prefix
+	};
+}
+function customBinaryPlugin(plugins, input = ["git"], allowUnsafe = false) {
+	let config = toBinaryConfig(asArray(input), allowUnsafe);
+	plugins.on("binary", (input2) => {
+		config = toBinaryConfig(asArray(input2), allowUnsafe);
+	});
+	plugins.append("spawn.binary", () => {
+		return config.binary;
+	});
+	plugins.append("spawn.args", (data) => {
+		return config.prefix ? [config.prefix, ...data] : data;
+	});
+}
+init_git_error();
+function isTaskError(result) {
+	return !!(result.exitCode && result.stdErr.length);
+}
+function getErrorMessage(result) {
+	return Buffer.concat([...result.stdOut, ...result.stdErr]);
+}
+function errorDetectionHandler(overwrite = false, isError = isTaskError, errorMessage = getErrorMessage) {
+	return (error, result) => {
+		if (!overwrite && error || !isError(result)) return error;
+		return errorMessage(result);
+	};
+}
+function errorDetectionPlugin(config) {
+	return {
+		type: "task.error",
+		action(data, context) {
+			const error = config(data.error, {
+				stdErr: context.stdErr,
+				stdOut: context.stdOut,
+				exitCode: context.exitCode
+			});
+			if (Buffer.isBuffer(error)) return { error: new GitError(void 0, error.toString("utf-8")) };
+			return { error };
+		}
+	};
+}
+init_utils();
+var PluginStore = class {
+	constructor() {
+		this.plugins = /* @__PURE__ */ new Set();
+		this.events = new EventEmitter();
+	}
+	on(type, listener) {
+		this.events.on(type, listener);
+	}
+	reconfigure(type, data) {
+		this.events.emit(type, data);
+	}
+	append(type, action) {
+		const plugin = append(this.plugins, {
+			type,
+			action
+		});
+		return () => this.plugins.delete(plugin);
+	}
+	add(plugin) {
+		const plugins = [];
+		asArray(plugin).forEach((plugin2) => plugin2 && this.plugins.add(append(plugins, plugin2)));
+		return () => {
+			plugins.forEach((plugin2) => this.plugins.delete(plugin2));
+		};
+	}
+	exec(type, data, context) {
+		let output = data;
+		const contextual = Object.freeze(Object.create(context));
+		for (const plugin of this.plugins) if (plugin.type === type) output = plugin.action(output, contextual);
+		return output;
+	}
+};
+init_utils();
+function progressMonitorPlugin(progress) {
+	const progressCommand = "--progress";
+	const progressMethods = [
+		"checkout",
+		"clone",
+		"fetch",
+		"pull",
+		"push"
+	];
+	return [{
+		type: "spawn.args",
+		action(args, context) {
+			if (!progressMethods.includes(context.method)) return args;
+			return including(args, progressCommand);
+		}
+	}, {
+		type: "spawn.after",
+		action(_data, context) {
+			if (!context.commands.includes(progressCommand)) return;
+			context.spawned.stderr?.on("data", (chunk) => {
+				const message = /^([\s\S]+?):\s*(\d+)% \((\d+)\/(\d+)\)/.exec(chunk.toString("utf8"));
+				if (!message) return;
+				progress({
+					method: context.method,
+					stage: progressEventStage(message[1]),
+					progress: asNumber(message[2]),
+					processed: asNumber(message[3]),
+					total: asNumber(message[4])
+				});
+			});
+		}
+	}];
+}
+function progressEventStage(input) {
+	return String(input.toLowerCase().split(" ", 1)) || "unknown";
+}
+init_utils();
+function spawnOptionsPlugin(spawnOptions) {
+	const options = pick(spawnOptions, ["uid", "gid"]);
+	return {
+		type: "spawn.options",
+		action(data) {
+			return {
+				...options,
+				...data
+			};
+		}
+	};
+}
+function timeoutPlugin({ block, stdErr = true, stdOut = true }) {
+	if (block > 0) return {
+		type: "spawn.after",
+		action(_data, context) {
+			let timeout;
+			function wait() {
+				timeout && clearTimeout(timeout);
+				timeout = setTimeout(kill, block);
+			}
+			function stop() {
+				context.spawned.stdout?.off("data", wait);
+				context.spawned.stderr?.off("data", wait);
+				context.spawned.off("exit", stop);
+				context.spawned.off("close", stop);
+				timeout && clearTimeout(timeout);
+			}
+			function kill() {
+				stop();
+				context.kill(new GitPluginError(void 0, "timeout", `block timeout reached`));
+			}
+			stdOut && context.spawned.stdout?.on("data", wait);
+			stdErr && context.spawned.stderr?.on("data", wait);
+			context.spawned.on("exit", stop);
+			context.spawned.on("close", stop);
+			wait();
+		}
+	};
+}
+init_pathspec();
+function suffixPathsPlugin() {
+	return {
+		type: "spawn.args",
+		action(data) {
+			const prefix = [];
+			let suffix;
+			function append2(args) {
+				(suffix = suffix || []).push(...args);
+			}
+			for (let i = 0; i < data.length; i++) {
+				const param = data[i];
+				if (isPathSpec(param)) {
+					append2(toPaths(param));
+					continue;
+				}
+				if (param === "--") {
+					append2(data.slice(i + 1).flatMap((item) => isPathSpec(item) && toPaths(item) || item));
+					break;
+				}
+				prefix.push(param);
+			}
+			return !suffix ? prefix : [
+				...prefix,
+				"--",
+				...suffix.map(String)
+			];
+		}
+	};
+}
+init_utils();
+var Git = require_git();
+function gitInstanceFactory(baseDir, options) {
+	const plugins = new PluginStore();
+	const config = createInstanceConfig(baseDir && (typeof baseDir === "string" ? { baseDir } : baseDir) || {}, options);
+	if (!folderExists(config.baseDir)) throw new GitConstructError(config, `Cannot use simple-git on a directory that does not exist`);
+	if (Array.isArray(config.config)) plugins.add(commandConfigPrefixingPlugin(config.config));
+	plugins.add(blockUnsafeOperationsPlugin(config.unsafe));
+	plugins.add(suffixPathsPlugin());
+	plugins.add(completionDetectionPlugin(config.completion));
+	config.abort && plugins.add(abortPlugin(config.abort));
+	config.progress && plugins.add(progressMonitorPlugin(config.progress));
+	config.timeout && plugins.add(timeoutPlugin(config.timeout));
+	config.spawnOptions && plugins.add(spawnOptionsPlugin(config.spawnOptions));
+	plugins.add(errorDetectionPlugin(errorDetectionHandler(true)));
+	config.errors && plugins.add(errorDetectionPlugin(config.errors));
+	customBinaryPlugin(plugins, config.binary, config.unsafe?.allowUnsafeCustomBinary);
+	return new Git(config, plugins);
+}
+init_git_response_error();
+var simpleGit = gitInstanceFactory;
+var esm_default = gitInstanceFactory;
+
 //#endregion
 //#region ../core/src/sources/git-clone.ts
 const CACHE_DIR = join(homedir(), ".baton", "cache");
@@ -6480,14 +10991,14 @@ function generateLock(packages) {
 * Writes a lockfile object to disk as YAML
 */
 async function writeLock(lockfile, filePath) {
-	await writeFile(filePath, (0, import_dist.stringify)(lockfile), "utf-8");
+	await writeFile(filePath, (0, import_dist$2.stringify)(lockfile), "utf-8");
 }
 /**
 * Reads and validates an existing lockfile from disk
 */
 async function readLock(filePath) {
 	try {
-		const parsed = (0, import_dist.parse)(await readFile(filePath, "utf-8"));
+		const parsed = (0, import_dist$2.parse)(await readFile(filePath, "utf-8"));
 		const result = lockfileSchema.safeParse(parsed);
 		if (!result.success) throw new Error(`Invalid lockfile: ${result.error.errors.map((e) => e.message).join(", ")}`);
 		return result.data;
@@ -6552,7 +11063,7 @@ async function removePlacedFiles(filePaths, projectRoot) {
 async function loadProfileManifestSafe(sourceRoot, profilePath) {
 	const manifestPath = join(sourceRoot, profilePath, "baton.profile.yaml");
 	try {
-		const parsed = (0, import_dist.parse)(await readFile(manifestPath, "utf-8"));
+		const parsed = (0, import_dist$2.parse)(await readFile(manifestPath, "utf-8"));
 		const manifest = profileManifestSchema.parse(parsed);
 		return {
 			name: manifest.name,
@@ -6583,7 +11094,7 @@ async function loadProfileManifestSafe(sourceRoot, profilePath) {
 async function findSourceManifest(sourceRoot) {
 	const manifestPath = join(sourceRoot, "baton.source.yaml");
 	try {
-		const parsed = (0, import_dist.parse)(await readFile(manifestPath, "utf-8"));
+		const parsed = (0, import_dist$2.parse)(await readFile(manifestPath, "utf-8"));
 		return sourceManifestSchema.parse(parsed);
 	} catch (error) {
 		if (error.code === "ENOENT") throw new Error(`Source manifest not found at ${manifestPath}. This directory is not a Baton source repository.`);
@@ -14546,7 +19057,7 @@ function getGlobalConfigPath() {
 async function loadGlobalConfig() {
 	const configPath = getGlobalConfigPath();
 	try {
-		const parsed = (0, import_dist.parse)(await readFile(configPath, "utf-8"));
+		const parsed = (0, import_dist$2.parse)(await readFile(configPath, "utf-8"));
 		return globalConfigSchema.parse(parsed);
 	} catch (error) {
 		if (error.code === "ENOENT") return globalConfigSchema.parse({});
@@ -14566,7 +19077,7 @@ async function saveGlobalConfig(config) {
 	const validated = globalConfigSchema.parse(config);
 	const configPath = getGlobalConfigPath();
 	await mkdir(getBatonHome(), { recursive: true });
-	await writeFile(configPath, (0, import_dist.stringify)(validated), "utf-8");
+	await writeFile(configPath, (0, import_dist$2.stringify)(validated), "utf-8");
 }
 /**
 * Adds a source repository to the global configuration.
@@ -14813,7 +19324,7 @@ function getPreferencesPath(projectRoot) {
 async function readProjectPreferences(projectRoot) {
 	const prefsPath = getPreferencesPath(projectRoot);
 	try {
-		const parsed = (0, import_dist.parse)(await readFile(prefsPath, "utf-8"));
+		const parsed = (0, import_dist$2.parse)(await readFile(prefsPath, "utf-8"));
 		return projectPreferencesSchema.parse(parsed);
 	} catch (error) {
 		if (error.code === "ENOENT") return null;
@@ -14833,7 +19344,7 @@ async function writeProjectPreferences(projectRoot, prefs) {
 	const validated = projectPreferencesSchema.parse(prefs);
 	const prefsPath = getPreferencesPath(projectRoot);
 	await mkdir(dirname(prefsPath), { recursive: true });
-	await writeFile(prefsPath, (0, import_dist.stringify)(validated), "utf-8");
+	await writeFile(prefsPath, (0, import_dist$2.stringify)(validated), "utf-8");
 	await ensureBatonDirGitignored(projectRoot);
 }
 
@@ -14887,5 +19398,5 @@ async function resolvePreferences(projectRoot) {
 }
 
 //#endregion
-export { loadLockfile as $, resolveProfileChain as A, cloneGitSource as B, mergeSkills as C, sortProfilesByWeight as D, isLockedProfile as E, removePlacedFiles as F, getIdePlatformTargetDir as G, ensureBatonDirGitignored as H, generateLock as I, isKnownIdePlatform as J, getRegisteredIdePlatforms as K, readLock as L, placeFile as M, discoverProfilesInSourceRepo as N, mergeContentParts as O, findSourceManifest as P, parseSource as Q, writeLock as R, mergeRulesWithWarnings as S, getProfileWeight as T, removeGitignoreManagedSection as U, collectComprehensivePatterns as V, updateGitignore as W, getAllAIToolAdapters as X, getAIToolAdaptersForKeys as Y, parseFrontmatter as Z, require_lib as _, clearIdeCache as a, getAIToolConfig as at, mergeAgentsWithWarnings as b, getDefaultGlobalSource as c, getGlobalSources as d, loadProfileManifest as et, loadGlobalConfig as f, setGlobalIdePlatforms as g, setGlobalAiTools as h, computeIntersection as i, SourceParseError as it, detectLegacyPaths as j, resolveProfileSupport as k, getGlobalAiTools as l, saveGlobalConfig as m, readProjectPreferences as n, KEBAB_CASE_REGEX as nt, detectInstalledIdes as o, getAIToolPath as ot, removeGlobalSource as p, idePlatformRegistry as q, writeProjectPreferences as r, FileNotFoundError as rt, addGlobalSource as s, getAllAIToolKeys as st, resolvePreferences as t, loadProjectManifest as tt, getGlobalIdePlatforms as u, mergeMemory as v, mergeSkillsWithWarnings as w, mergeRules as x, mergeMemoryWithWarnings as y, resolveVersion as z };
-//# sourceMappingURL=src-dY02psbw.mjs.map
+export { parseSource as $, resolveProfileChain as A, cloneGitSource as B, mergeSkills as C, sortProfilesByWeight as D, isLockedProfile as E, removePlacedFiles as F, updateGitignore as G, collectComprehensivePatterns as H, generateLock as I, idePlatformRegistry as J, getIdePlatformTargetDir as K, readLock as L, placeFile as M, discoverProfilesInSourceRepo as N, mergeContentParts as O, findSourceManifest as P, parseFrontmatter as Q, writeLock as R, mergeRulesWithWarnings as S, getProfileWeight as T, ensureBatonDirGitignored as U, esm_default as V, removeGitignoreManagedSection as W, getAIToolAdaptersForKeys as X, isKnownIdePlatform as Y, getAllAIToolAdapters as Z, require_lib as _, clearIdeCache as a, getAIToolConfig as at, mergeAgentsWithWarnings as b, getDefaultGlobalSource as c, getGlobalSources as d, loadProfileManifest as et, loadGlobalConfig as f, setGlobalIdePlatforms as g, setGlobalAiTools as h, computeIntersection as i, SourceParseError as it, detectLegacyPaths as j, resolveProfileSupport as k, getGlobalAiTools as l, saveGlobalConfig as m, readProjectPreferences as n, KEBAB_CASE_REGEX as nt, detectInstalledIdes as o, getAIToolPath as ot, removeGlobalSource as p, getRegisteredIdePlatforms as q, writeProjectPreferences as r, FileNotFoundError as rt, addGlobalSource as s, getAllAIToolKeys as st, resolvePreferences as t, loadProjectManifest as tt, getGlobalIdePlatforms as u, mergeMemory as v, mergeSkillsWithWarnings as w, mergeRules as x, mergeMemoryWithWarnings as y, resolveVersion as z };
+//# sourceMappingURL=src-n95I0s2u.mjs.map