@mcp-s/skills 1.0.5 → 1.3.1

package/dist/_chunks/libs/simple-git.mjs

@@ -0,0 +1,3584 @@
+import { r as __toESM } from "../rolldown-runtime.mjs";
+import { n as require_src, t as require_dist } from "./@kwsites/file-exists.mjs";
+import { t as require_dist$1 } from "./@kwsites/promise-deferred.mjs";
+import { spawn } from "child_process";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { normalize } from "node:path";
+import { EventEmitter } from "node:events";
+var import_dist = require_dist();
+var import_src = /* @__PURE__ */ __toESM(require_src(), 1);
+var import_dist$1 = require_dist$1();
+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 esm_default = gitInstanceFactory;
+export { esm_default as t };