@digipair/skill-git 0.8.37 → 0.8.40

package/index.cjs.js

@@ -2,25 +2,1111 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var require$$0$1 = require('fs');
-var require$$1 = require('tty');
-var require$$1$1 = require('util');
-var require$$0 = require('os');
+var require$$0$2 = require('fs');
+var require$$0 = require('tty');
+var require$$1 = require('util');
+var require$$0$1 = require('os');
 var child_process = require('child_process');
 var node_events = require('node:events');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
-var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
-var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
+var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
 var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
+var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
+var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
 
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 
 var dist$1 = {};
 
-var src$1 = {};
+var src$2 = {};
+
+var src$1 = {
+    exports: {}
+};
+
+var browser$1 = {
+    exports: {}
+};
+
+/**
+ * Helpers.
+ */
+
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var s$1 = 1000;
+var m$1 = s$1 * 60;
+var h$1 = m$1 * 60;
+var d$1 = h$1 * 24;
+var w$1 = d$1 * 7;
+var y$1 = d$1 * 365.25;
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */ var ms$1 = function(val, options) {
+    options = options || {};
+    var type = typeof val === "undefined" ? "undefined" : _type_of$2(val);
+    if (type === "string" && val.length > 0) {
+        return parse$1(val);
+    } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong$1(val) : fmtShort$1(val);
+    }
+    throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
+};
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */ function parse$1(str) {
+    str = String(str);
+    if (str.length > 100) {
+        return;
+    }
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+    if (!match) {
+        return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch(type){
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+            return n * y$1;
+        case "weeks":
+        case "week":
+        case "w":
+            return n * w$1;
+        case "days":
+        case "day":
+        case "d":
+            return n * d$1;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+            return n * h$1;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+            return n * m$1;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+            return n * s$1;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+            return n;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */ function fmtShort$1(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d$1) {
+        return Math.round(ms / d$1) + "d";
+    }
+    if (msAbs >= h$1) {
+        return Math.round(ms / h$1) + "h";
+    }
+    if (msAbs >= m$1) {
+        return Math.round(ms / m$1) + "m";
+    }
+    if (msAbs >= s$1) {
+        return Math.round(ms / s$1) + "s";
+    }
+    return ms + "ms";
+}
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */ function fmtLong$1(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d$1) {
+        return plural$1(ms, msAbs, d$1, "day");
+    }
+    if (msAbs >= h$1) {
+        return plural$1(ms, msAbs, h$1, "hour");
+    }
+    if (msAbs >= m$1) {
+        return plural$1(ms, msAbs, m$1, "minute");
+    }
+    if (msAbs >= s$1) {
+        return plural$1(ms, msAbs, s$1, "second");
+    }
+    return ms + " ms";
+}
+/**
+ * Pluralization helper.
+ */ function plural$1(ms, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+}
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ */
+
+function _array_like_to_array$2(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$2(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$2(arr);
+}
+function _instanceof$2(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array$2(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$2() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$2(arr) {
+    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$2(arr) || _non_iterable_spread$2();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
+function setup$1(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = ms$1;
+    createDebug.destroy = destroy;
+    Object.keys(env).forEach(function(key) {
+        createDebug[key] = env[key];
+    });
+    /**
+	* The currently active debug mode names, and names to skip.
+	*/ createDebug.names = [];
+    createDebug.skips = [];
+    /**
+	* Map of special "%n" handling functions, for the debug "format" argument.
+	*
+	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+	*/ createDebug.formatters = {};
+    /**
+	* Selects a color for a debug namespace
+	* @param {String} namespace The namespace string for the debug instance to be colored
+	* @return {Number|String} An ANSI color code for the given namespace
+	* @api private
+	*/ function selectColor(namespace) {
+        var hash = 0;
+        for(var i = 0; i < namespace.length; i++){
+            hash = (hash << 5) - hash + namespace.charCodeAt(i);
+            hash |= 0; // Convert to 32bit integer
+        }
+        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    /**
+	* Create a debugger with the given `namespace`.
+	*
+	* @param {String} namespace
+	* @return {Function}
+	* @api public
+	*/ function createDebug(namespace) {
+        var prevTime;
+        var enableOverride = null;
+        var namespacesCache;
+        var enabledCache;
+        function debug() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            // Disabled?
+            if (!debug.enabled) {
+                return;
+            }
+            var self = debug;
+            // Set `diff` timestamp
+            var curr = Number(new Date());
+            var ms = curr - (prevTime || curr);
+            self.diff = ms;
+            self.prev = prevTime;
+            self.curr = curr;
+            prevTime = curr;
+            args[0] = createDebug.coerce(args[0]);
+            if (typeof args[0] !== "string") {
+                // Anything else let's inspect with %O
+                args.unshift("%O");
+            }
+            // Apply any `formatters` transformations
+            var index = 0;
+            args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
+                // If we encounter an escaped % then don't increase the array index
+                if (match === "%%") {
+                    return "%";
+                }
+                index++;
+                var formatter = createDebug.formatters[format];
+                if (typeof formatter === "function") {
+                    var val = args[index];
+                    match = formatter.call(self, val);
+                    // Now we need to remove `args[index]` since it's inlined in the `format`
+                    args.splice(index, 1);
+                    index--;
+                }
+                return match;
+            });
+            // Apply env-specific formatting (colors, etc.)
+            createDebug.formatArgs.call(self, args);
+            var logFn = self.log || createDebug.log;
+            logFn.apply(self, args);
+        }
+        debug.namespace = namespace;
+        debug.useColors = createDebug.useColors();
+        debug.color = createDebug.selectColor(namespace);
+        debug.extend = extend;
+        debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+        Object.defineProperty(debug, "enabled", {
+            enumerable: true,
+            configurable: false,
+            get: function() {
+                if (enableOverride !== null) {
+                    return enableOverride;
+                }
+                if (namespacesCache !== createDebug.namespaces) {
+                    namespacesCache = createDebug.namespaces;
+                    enabledCache = createDebug.enabled(namespace);
+                }
+                return enabledCache;
+            },
+            set: function(v) {
+                enableOverride = v;
+            }
+        });
+        // Env-specific initialization logic for debug instances
+        if (typeof createDebug.init === "function") {
+            createDebug.init(debug);
+        }
+        return debug;
+    }
+    function extend(namespace, delimiter) {
+        var newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+    }
+    /**
+	* Enables a debug mode by namespaces. This can include modes
+	* separated by a colon and wildcards.
+	*
+	* @param {String} namespaces
+	* @api public
+	*/ function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        var i;
+        var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+        var len = split.length;
+        for(i = 0; i < len; i++){
+            if (!split[i]) {
+                continue;
+            }
+            namespaces = split[i].replace(/\*/g, ".*?");
+            if (namespaces[0] === "-") {
+                createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
+            } else {
+                createDebug.names.push(new RegExp("^" + namespaces + "$"));
+            }
+        }
+    }
+    /**
+	* Disable debug output.
+	*
+	* @return {String} namespaces
+	* @api public
+	*/ function disable() {
+        var namespaces = _to_consumable_array$2(createDebug.names.map(toNamespace)).concat(_to_consumable_array$2(createDebug.skips.map(toNamespace).map(function(namespace) {
+            return "-" + namespace;
+        }))).join(",");
+        createDebug.enable("");
+        return namespaces;
+    }
+    /**
+	* Returns true if the given mode name is enabled, false otherwise.
+	*
+	* @param {String} name
+	* @return {Boolean}
+	* @api public
+	*/ function enabled(name) {
+        if (name[name.length - 1] === "*") {
+            return true;
+        }
+        var i;
+        var len;
+        for(i = 0, len = createDebug.skips.length; i < len; i++){
+            if (createDebug.skips[i].test(name)) {
+                return false;
+            }
+        }
+        for(i = 0, len = createDebug.names.length; i < len; i++){
+            if (createDebug.names[i].test(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+	* Convert regexp to namespace
+	*
+	* @param {RegExp} regxep
+	* @return {String} namespace
+	* @api private
+	*/ function toNamespace(regexp) {
+        return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
+    }
+    /**
+	* Coerce `val`.
+	*
+	* @param {Mixed} val
+	* @return {Mixed}
+	* @api private
+	*/ function coerce(val) {
+        if (_instanceof$2(val, Error)) {
+            return val.stack || val.message;
+        }
+        return val;
+    }
+    /**
+	* XXX DO NOT USE. This is a temporary stub function.
+	* XXX It WILL be removed in the next major release.
+	*/ function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    createDebug.enable(createDebug.load());
+    return createDebug;
+}
+var common$1 = setup$1;
+
+/* eslint-env browser */
+
+(function (module, exports) {
+/**
+ * This is the web browser implementation of `debug()`.
+ */ exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = localstorage();
+exports.destroy = function() {
+    var warned = false;
+    return function() {
+        if (!warned) {
+            warned = true;
+            console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+    };
+}();
+/**
+ * Colors.
+ */ exports.colors = [
+    "#0000CC",
+    "#0000FF",
+    "#0033CC",
+    "#0033FF",
+    "#0066CC",
+    "#0066FF",
+    "#0099CC",
+    "#0099FF",
+    "#00CC00",
+    "#00CC33",
+    "#00CC66",
+    "#00CC99",
+    "#00CCCC",
+    "#00CCFF",
+    "#3300CC",
+    "#3300FF",
+    "#3333CC",
+    "#3333FF",
+    "#3366CC",
+    "#3366FF",
+    "#3399CC",
+    "#3399FF",
+    "#33CC00",
+    "#33CC33",
+    "#33CC66",
+    "#33CC99",
+    "#33CCCC",
+    "#33CCFF",
+    "#6600CC",
+    "#6600FF",
+    "#6633CC",
+    "#6633FF",
+    "#66CC00",
+    "#66CC33",
+    "#9900CC",
+    "#9900FF",
+    "#9933CC",
+    "#9933FF",
+    "#99CC00",
+    "#99CC33",
+    "#CC0000",
+    "#CC0033",
+    "#CC0066",
+    "#CC0099",
+    "#CC00CC",
+    "#CC00FF",
+    "#CC3300",
+    "#CC3333",
+    "#CC3366",
+    "#CC3399",
+    "#CC33CC",
+    "#CC33FF",
+    "#CC6600",
+    "#CC6633",
+    "#CC9900",
+    "#CC9933",
+    "#CCCC00",
+    "#CCCC33",
+    "#FF0000",
+    "#FF0033",
+    "#FF0066",
+    "#FF0099",
+    "#FF00CC",
+    "#FF00FF",
+    "#FF3300",
+    "#FF3333",
+    "#FF3366",
+    "#FF3399",
+    "#FF33CC",
+    "#FF33FF",
+    "#FF6600",
+    "#FF6633",
+    "#FF9900",
+    "#FF9933",
+    "#FFCC00",
+    "#FFCC33"
+];
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */ // eslint-disable-next-line complexity
+function useColors() {
+    // NB: In an Electron preload script, document will be defined but not fully
+    // initialized. Since we know we're in Chrome, we'll just detect this case
+    // explicitly
+    if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+    }
+    // Internet Explorer and Edge do not support colors.
+    if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+    }
+    // Is webkit? http://stackoverflow.com/a/16459606/376773
+    // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+    return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+    typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+    typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+    typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+}
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */ function formatArgs(args) {
+    args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+    if (!this.useColors) {
+        return;
+    }
+    var c = "color: " + this.color;
+    args.splice(1, 0, c, "color: inherit");
+    // The final "%c" is somewhat tricky, because there could be other
+    // arguments passed either before or after the %c, so we need to
+    // figure out the correct index to insert the CSS into
+    var index = 0;
+    var lastC = 0;
+    args[0].replace(/%[a-zA-Z%]/g, function(match) {
+        if (match === "%%") {
+            return;
+        }
+        index++;
+        if (match === "%c") {
+            // We only are interested in the *last* %c
+            // (the user may have provided their own)
+            lastC = index;
+        }
+    });
+    args.splice(lastC, 0, c);
+}
+/**
+ * Invokes `console.debug()` when available.
+ * No-op when `console.debug` is not a "function".
+ * If `console.debug` is not available, falls back
+ * to `console.log`.
+ *
+ * @api public
+ */ exports.log = console.debug || console.log || function() {};
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */ function save(namespaces) {
+    try {
+        if (namespaces) {
+            exports.storage.setItem("debug", namespaces);
+        } else {
+            exports.storage.removeItem("debug");
+        }
+    } catch (error) {
+    // Swallow
+    // XXX (@Qix-) should we be logging these?
+    }
+}
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */ function load() {
+    var r;
+    try {
+        r = exports.storage.getItem("debug");
+    } catch (error) {
+    // Swallow
+    // XXX (@Qix-) should we be logging these?
+    }
+    // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+    if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+    }
+    return r;
+}
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */ function localstorage() {
+    try {
+        // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+        // The Browser also has localStorage in the global context.
+        return localStorage;
+    } catch (error) {
+    // Swallow
+    // XXX (@Qix-) should we be logging these?
+    }
+}
+module.exports = common$1(exports);
+var formatters = module.exports.formatters;
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */ formatters.j = function(v) {
+    try {
+        return JSON.stringify(v);
+    } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+    }
+};
+}(browser$1, browser$1.exports));
+
+var node$1 = {
+    exports: {}
+};
+
+var hasFlag$1 = function(flag) {
+    var argv = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : process.argv;
+    var prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+    var position = argv.indexOf(prefix + flag);
+    var terminatorPosition = argv.indexOf("--");
+    return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+};
+
+var os = require$$0__default$1["default"];
+var tty = require$$0__default["default"];
+var hasFlag = hasFlag$1;
+var env = process.env;
+var forceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+    forceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+    forceColor = 1;
+}
+if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+    } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+    } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+    }
+}
+function translateLevel(level) {
+    if (level === 0) {
+        return false;
+    }
+    return {
+        level: level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+    };
+}
+function supportsColor(haveStream, streamIsTTY) {
+    if (forceColor === 0) {
+        return 0;
+    }
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+    }
+    if (hasFlag("color=256")) {
+        return 2;
+    }
+    if (haveStream && !streamIsTTY && forceColor === undefined) {
+        return 0;
+    }
+    var min = forceColor || 0;
+    if (env.TERM === "dumb") {
+        return min;
+    }
+    if (process.platform === "win32") {
+        // Windows 10 build 10586 is the first Windows release that supports 256 colors.
+        // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+        var osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+            return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+    }
+    if ("CI" in env) {
+        if ([
+            "TRAVIS",
+            "CIRCLECI",
+            "APPVEYOR",
+            "GITLAB_CI",
+            "GITHUB_ACTIONS",
+            "BUILDKITE"
+        ].some(function(sign) {
+            return sign in env;
+        }) || env.CI_NAME === "codeship") {
+            return 1;
+        }
+        return min;
+    }
+    if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    }
+    if (env.COLORTERM === "truecolor") {
+        return 3;
+    }
+    if ("TERM_PROGRAM" in env) {
+        var version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch(env.TERM_PROGRAM){
+            case "iTerm.app":
+                return version >= 3 ? 3 : 2;
+            case "Apple_Terminal":
+                return 2;
+        }
+    }
+    if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+    }
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+    }
+    if ("COLORTERM" in env) {
+        return 1;
+    }
+    return min;
+}
+function getSupportLevel(stream) {
+    var level = supportsColor(stream, stream && stream.isTTY);
+    return translateLevel(level);
+}
+var supportsColor_1 = {
+    supportsColor: getSupportLevel,
+    stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+    stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+};
+
+/**
+ * Module dependencies.
+ */
+
+(function (module, exports) {
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var tty = require$$0__default["default"];
+var util = require$$1__default["default"];
+/**
+ * This is the Node.js implementation of `debug()`.
+ */ exports.init = init;
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.destroy = util.deprecate(function() {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+/**
+ * Colors.
+ */ exports.colors = [
+    6,
+    2,
+    3,
+    4,
+    5,
+    1
+];
+try {
+    // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+    // eslint-disable-next-line import/no-extraneous-dependencies
+    var supportsColor = supportsColor_1;
+    if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+        exports.colors = [
+            20,
+            21,
+            26,
+            27,
+            32,
+            33,
+            38,
+            39,
+            40,
+            41,
+            42,
+            43,
+            44,
+            45,
+            56,
+            57,
+            62,
+            63,
+            68,
+            69,
+            74,
+            75,
+            76,
+            77,
+            78,
+            79,
+            80,
+            81,
+            92,
+            93,
+            98,
+            99,
+            112,
+            113,
+            128,
+            129,
+            134,
+            135,
+            148,
+            149,
+            160,
+            161,
+            162,
+            163,
+            164,
+            165,
+            166,
+            167,
+            168,
+            169,
+            170,
+            171,
+            172,
+            173,
+            178,
+            179,
+            184,
+            185,
+            196,
+            197,
+            198,
+            199,
+            200,
+            201,
+            202,
+            203,
+            204,
+            205,
+            206,
+            207,
+            208,
+            209,
+            214,
+            215,
+            220,
+            221
+        ];
+    }
+} catch (error) {
+// Swallow - we only care if `supports-color` is available; it doesn't have to be.
+}
+/**
+ * Build up the default `inspectOpts` object from the environment variables.
+ *
+ *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+ */ exports.inspectOpts = Object.keys(process.env).filter(function(key) {
+    return /^debug_/i.test(key);
+}).reduce(function(obj, key) {
+    // Camel-case
+    var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function(_, k) {
+        return k.toUpperCase();
+    });
+    // Coerce string value into JS value
+    var val = process.env[key];
+    if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+    } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+    } else if (val === "null") {
+        val = null;
+    } else {
+        val = Number(val);
+    }
+    obj[prop] = val;
+    return obj;
+}, {});
+/**
+ * Is stdout a TTY? Colored output is enabled when `true`.
+ */ function useColors() {
+    return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+}
+/**
+ * Adds ANSI color escape codes if enabled.
+ *
+ * @api public
+ */ function formatArgs(args) {
+    var _this = this, name = _this.namespace, _$useColors = _this.useColors;
+    if (_$useColors) {
+        var c = this.color;
+        var colorCode = "\x1b[3" + (c < 8 ? c : "8;5;" + c);
+        var prefix = "  ".concat(colorCode, ";1m").concat(name, " \x1b[0m");
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1b[0m");
+    } else {
+        args[0] = getDate() + name + " " + args[0];
+    }
+}
+function getDate() {
+    if (exports.inspectOpts.hideDate) {
+        return "";
+    }
+    return new Date().toISOString() + " ";
+}
+/**
+ * Invokes `util.format()` with the specified arguments and writes to stderr.
+ */ function log() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    var _util;
+    return process.stderr.write((_util = util).format.apply(_util, _to_consumable_array(args)) + "\n");
+}
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */ function save(namespaces) {
+    if (namespaces) {
+        process.env.DEBUG = namespaces;
+    } else {
+        // If you set a process.env field to null or undefined, it gets cast to the
+        // string 'null' or 'undefined'. Just delete instead.
+        delete process.env.DEBUG;
+    }
+}
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */ function load() {
+    return process.env.DEBUG;
+}
+/**
+ * Init logic for `debug` instances.
+ *
+ * Create a new `inspectOpts` object in case `useColors` is set
+ * differently for a particular `debug` instance.
+ */ function init(debug) {
+    debug.inspectOpts = {};
+    var keys = Object.keys(exports.inspectOpts);
+    for(var i = 0; i < keys.length; i++){
+        debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+    }
+}
+module.exports = common$1(exports);
+var formatters = module.exports.formatters;
+/**
+ * Map %o to `util.inspect()`, all on a single line.
+ */ formatters.o = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts).split("\n").map(function(str) {
+        return str.trim();
+    }).join(" ");
+};
+/**
+ * Map %O to `util.inspect()`, allowing multiple lines if needed.
+ */ formatters.O = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts);
+};
+}(node$1, node$1.exports));
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+
+if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+    src$1.exports = browser$1.exports;
+} else {
+    src$1.exports = node$1.exports;
+}
+
+(function (exports) {
+var __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : {
+        "default": mod
+    };
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var fs_1 = require$$0__default$2["default"];
+var debug_1 = __importDefault(src$1.exports);
+var log = debug_1.default("@kwsites/file-exists");
+function check(path, isFile, isDirectory) {
+    log("checking %s", path);
+    try {
+        var stat = fs_1.statSync(path);
+        if (stat.isFile() && isFile) {
+            log("[OK] path represents a file");
+            return true;
+        }
+        if (stat.isDirectory() && isDirectory) {
+            log("[OK] path represents a directory");
+            return true;
+        }
+        log("[FAIL] path represents something other than a file or directory");
+        return false;
+    } catch (e) {
+        if (e.code === "ENOENT") {
+            log("[FAIL] path is not accessible: %o", e);
+            return false;
+        }
+        log("[FATAL] %o", e);
+        throw e;
+    }
+}
+/**
+ * Synchronous validation of a path existing either as a file or as a directory.
+ *
+ * @param {string} path The path to check
+ * @param {number} type One or both of the exported numeric constants
+ */ function exists(path) {
+    var type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : exports.READABLE;
+    return check(path, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+}
+exports.exists = exists;
+/**
+ * Constant representing a file
+ */ exports.FILE = 1;
+/**
+ * Constant representing a folder
+ */ exports.FOLDER = 2;
+/**
+ * Constant representing either a file or a folder
+ */ exports.READABLE = exports.FILE + exports.FOLDER; 
+}(src$2));
+
+(function (exports) {
+function __export(m) {
+    for(var p in m)if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+__export(src$2); 
+}(dist$1));
 
 var src = {
     exports: {}
@@ -665,121 +1751,6 @@ var node = {
     exports: {}
 };
 
-var hasFlag$1 = function(flag) {
-    var argv = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : process.argv;
-    var prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-    var position = argv.indexOf(prefix + flag);
-    var terminatorPosition = argv.indexOf("--");
-    return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-};
-
-var os = require$$0__default["default"];
-var tty = require$$1__default["default"];
-var hasFlag = hasFlag$1;
-var env = process.env;
-var forceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-    forceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-    forceColor = 1;
-}
-if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-        forceColor = 1;
-    } else if (env.FORCE_COLOR === "false") {
-        forceColor = 0;
-    } else {
-        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
-    }
-}
-function translateLevel(level) {
-    if (level === 0) {
-        return false;
-    }
-    return {
-        level: level,
-        hasBasic: true,
-        has256: level >= 2,
-        has16m: level >= 3
-    };
-}
-function supportsColor(haveStream, streamIsTTY) {
-    if (forceColor === 0) {
-        return 0;
-    }
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-        return 3;
-    }
-    if (hasFlag("color=256")) {
-        return 2;
-    }
-    if (haveStream && !streamIsTTY && forceColor === undefined) {
-        return 0;
-    }
-    var min = forceColor || 0;
-    if (env.TERM === "dumb") {
-        return min;
-    }
-    if (process.platform === "win32") {
-        // Windows 10 build 10586 is the first Windows release that supports 256 colors.
-        // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
-        var osRelease = os.release().split(".");
-        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-            return Number(osRelease[2]) >= 14931 ? 3 : 2;
-        }
-        return 1;
-    }
-    if ("CI" in env) {
-        if ([
-            "TRAVIS",
-            "CIRCLECI",
-            "APPVEYOR",
-            "GITLAB_CI",
-            "GITHUB_ACTIONS",
-            "BUILDKITE"
-        ].some(function(sign) {
-            return sign in env;
-        }) || env.CI_NAME === "codeship") {
-            return 1;
-        }
-        return min;
-    }
-    if ("TEAMCITY_VERSION" in env) {
-        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-    }
-    if (env.COLORTERM === "truecolor") {
-        return 3;
-    }
-    if ("TERM_PROGRAM" in env) {
-        var version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-        switch(env.TERM_PROGRAM){
-            case "iTerm.app":
-                return version >= 3 ? 3 : 2;
-            case "Apple_Terminal":
-                return 2;
-        }
-    }
-    if (/-256(color)?$/i.test(env.TERM)) {
-        return 2;
-    }
-    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-        return 1;
-    }
-    if ("COLORTERM" in env) {
-        return 1;
-    }
-    return min;
-}
-function getSupportLevel(stream) {
-    var level = supportsColor(stream, stream && stream.isTTY);
-    return translateLevel(level);
-}
-var supportsColor_1 = {
-    supportsColor: getSupportLevel,
-    stdout: translateLevel(supportsColor(true, tty.isatty(1))),
-    stderr: translateLevel(supportsColor(true, tty.isatty(2)))
-};
-
 /**
  * Module dependencies.
  */
@@ -810,8 +1781,8 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-var tty = require$$1__default["default"];
-var util = require$$1__default$1["default"];
+var tty = require$$0__default["default"];
+var util = require$$1__default["default"];
 /**
  * This is the Node.js implementation of `debug()`.
  */ exports.init = init;
@@ -971,13 +1942,15 @@ function getDate() {
     return new Date().toISOString() + " ";
 }
 /**
- * Invokes `util.format()` with the specified arguments and writes to stderr.
+ * Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
  */ function log() {
     for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
         args[_key] = arguments[_key];
     }
     var _util;
-    return process.stderr.write((_util = util).format.apply(_util, _to_consumable_array(args)) + "\n");
+    return process.stderr.write((_util = util).formatWithOptions.apply(_util, [
+        exports.inspectOpts
+    ].concat(_to_consumable_array(args))) + "\n");
 }
 /**
  * Save `namespaces`.
@@ -1044,72 +2017,6 @@ if (typeof process === "undefined" || process.type === "renderer" || process.bro
 
 var debug = src.exports;
 
-(function (exports) {
-var __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || function(mod) {
-    return mod && mod.__esModule ? mod : {
-        "default": mod
-    };
-};
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-var fs_1 = require$$0__default$1["default"];
-var debug_1 = __importDefault(src.exports);
-var log = debug_1.default("@kwsites/file-exists");
-function check(path, isFile, isDirectory) {
-    log("checking %s", path);
-    try {
-        var stat = fs_1.statSync(path);
-        if (stat.isFile() && isFile) {
-            log("[OK] path represents a file");
-            return true;
-        }
-        if (stat.isDirectory() && isDirectory) {
-            log("[OK] path represents a directory");
-            return true;
-        }
-        log("[FAIL] path represents something other than a file or directory");
-        return false;
-    } catch (e) {
-        if (e.code === "ENOENT") {
-            log("[FAIL] path is not accessible: %o", e);
-            return false;
-        }
-        log("[FATAL] %o", e);
-        throw e;
-    }
-}
-/**
- * Synchronous validation of a path existing either as a file or as a directory.
- *
- * @param {string} path The path to check
- * @param {number} type One or both of the exported numeric constants
- */ function exists(path) {
-    var type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : exports.READABLE;
-    return check(path, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
-}
-exports.exists = exists;
-/**
- * Constant representing a file
- */ exports.FILE = 1;
-/**
- * Constant representing a folder
- */ exports.FOLDER = 2;
-/**
- * Constant representing either a file or a folder
- */ exports.READABLE = exports.FILE + exports.FOLDER; 
-}(src$1));
-
-(function (exports) {
-function __export(m) {
-    for(var p in m)if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-__export(src$1); 
-}(dist$1));
-
 var dist = {};
 
 Object.defineProperty(dist, "__esModule", {
@@ -1772,6 +2679,11 @@ function asArray(source) {
         source
     ];
 }
+function asCamelCase(str) {
+    return str.replace(/[\s-]+(.)/g, function(_all, chr) {
+        return chr.toUpperCase();
+    });
+}
 function asStringArray(source) {
     return asArray(source).map(String);
 }
@@ -2074,8 +2986,8 @@ var init_task_options = __esm({
     }
 });
 // src/lib/utils/task-parser.ts
-function callTaskParser(parser3, streams) {
-    return parser3(streams.stdOut, streams.stdErr);
+function callTaskParser(parser4, streams) {
+    return parser4(streams.stdOut, streams.stdErr);
 }
 function parseStringResponse(result, parsers12, texts) {
     var trim = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true;
@@ -2132,6 +3044,9 @@ __export(utils_exports, {
     asArray: function() {
         return asArray;
     },
+    asCamelCase: function() {
+        return asCamelCase;
+    },
     asFunction: function() {
         return asFunction;
     },
@@ -2381,11 +3296,11 @@ __export(task_exports, {
         return straightThroughStringTask;
     }
 });
-function adhocExecTask(parser3) {
+function adhocExecTask(parser4) {
     return {
         commands: EMPTY_COMMANDS,
         format: "empty",
-        parser: parser3
+        parser: parser4
     };
 }
 function configurationErrorTask(error) {
@@ -3688,6 +4603,50 @@ var init_checkout = __esm({
         init_task();
     }
 });
+// src/lib/tasks/count-objects.ts
+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: function countObjects() {
+            return this._runTask({
+                commands: [
+                    "count-objects",
+                    "--verbose"
+                ],
+                format: "utf-8",
+                parser: function parser(stdOut) {
+                    return parseStringResponse(countObjectsResponse(), [
+                        parser2
+                    ], stdOut);
+                }
+            });
+        }
+    };
+}
+var parser2;
+var init_count_objects = __esm({
+    "src/lib/tasks/count-objects.ts": function() {
+        init_utils();
+        parser2 = new LineParser(/([a-z-]+): (\d+)$/, function(result, param) {
+            var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+            var property = asCamelCase(key);
+            if (result.hasOwnProperty(property)) {
+                result[property] = asNumber(value);
+            }
+        });
+    }
+});
 // src/lib/parsers/parse-commit.ts
 function parseCommitResult(stdOut) {
     var result = {
@@ -3911,9 +4870,9 @@ var init_DiffSummary = __esm({
 // src/lib/parsers/parse-diff-summary.ts
 function getDiffParser() {
     var format = arguments.length > 0 && arguments[0] !== void 0 /* NONE */  ? arguments[0] : "";
-    var parser3 = diffSummaryParsers[format];
+    var parser4 = diffSummaryParsers[format];
     return function(stdOut) {
-        return parseStringResponse(new DiffSummary(), parser3, stdOut, false);
+        return parseStringResponse(new DiffSummary(), parser4, stdOut, false);
     };
 }
 var statParser, numStatParser, nameOnlyParser, nameStatusParser, diffSummaryParsers;
@@ -4157,13 +5116,13 @@ function parseLogOptions() {
     };
 }
 function logTask(splitter, fields, customArgs) {
-    var parser3 = createListLogSummaryParser(splitter, fields, logFormatFromCommand(customArgs));
+    var parser4 = createListLogSummaryParser(splitter, fields, logFormatFromCommand(customArgs));
     return {
         commands: [
             "log"
         ].concat(_to_consumable_array(customArgs)),
         format: "utf-8",
-        parser: parser3
+        parser: parser4
     };
 }
 function log_default() {
@@ -4715,7 +5674,7 @@ function renamedFile(line) {
         to: to
     };
 }
-function parser2(indexX, indexY, handler) {
+function parser3(indexX, indexY, handler) {
     return [
         "".concat(indexX).concat(indexY),
         handler
@@ -4726,7 +5685,7 @@ function conflicts(indexX) {
         indexY[_key - 1] = arguments[_key];
     }
     return indexY.map(function(y) {
-        return parser2(indexX, y, function(result, file) {
+        return parser3(indexX, y, function(result, file) {
             return append(result.conflicted, file);
         });
     });
@@ -4779,42 +5738,42 @@ var init_StatusSummary = __esm({
             };
         };
         parsers6 = new Map([
-            parser2(" " /* NONE */ , "A" /* ADDED */ , function(result, file) {
+            parser3(" " /* NONE */ , "A" /* ADDED */ , function(result, file) {
                 return append(result.created, file);
             }),
-            parser2(" " /* NONE */ , "D" /* DELETED */ , function(result, file) {
+            parser3(" " /* NONE */ , "D" /* DELETED */ , function(result, file) {
                 return append(result.deleted, file);
             }),
-            parser2(" " /* NONE */ , "M" /* MODIFIED */ , function(result, file) {
+            parser3(" " /* NONE */ , "M" /* MODIFIED */ , function(result, file) {
                 return append(result.modified, file);
             }),
-            parser2("A" /* ADDED */ , " " /* NONE */ , function(result, file) {
+            parser3("A" /* ADDED */ , " " /* NONE */ , function(result, file) {
                 return append(result.created, file) && append(result.staged, file);
             }),
-            parser2("A" /* ADDED */ , "M" /* MODIFIED */ , function(result, file) {
+            parser3("A" /* ADDED */ , "M" /* MODIFIED */ , function(result, file) {
                 return append(result.created, file) && append(result.staged, file) && append(result.modified, file);
             }),
-            parser2("D" /* DELETED */ , " " /* NONE */ , function(result, file) {
+            parser3("D" /* DELETED */ , " " /* NONE */ , function(result, file) {
                 return append(result.deleted, file) && append(result.staged, file);
             }),
-            parser2("M" /* MODIFIED */ , " " /* NONE */ , function(result, file) {
+            parser3("M" /* MODIFIED */ , " " /* NONE */ , function(result, file) {
                 return append(result.modified, file) && append(result.staged, file);
             }),
-            parser2("M" /* MODIFIED */ , "M" /* MODIFIED */ , function(result, file) {
+            parser3("M" /* MODIFIED */ , "M" /* MODIFIED */ , function(result, file) {
                 return append(result.modified, file) && append(result.staged, file);
             }),
-            parser2("R" /* RENAMED */ , " " /* NONE */ , function(result, file) {
+            parser3("R" /* RENAMED */ , " " /* NONE */ , function(result, file) {
                 append(result.renamed, renamedFile(file));
             }),
-            parser2("R" /* RENAMED */ , "M" /* MODIFIED */ , function(result, file) {
+            parser3("R" /* RENAMED */ , "M" /* MODIFIED */ , function(result, file) {
                 var renamed = renamedFile(file);
                 append(result.renamed, renamed);
                 append(result.modified, renamed.to);
             }),
-            parser2("!" /* IGNORED */ , "!" /* IGNORED */ , function(_result, _file) {
+            parser3("!" /* IGNORED */ , "!" /* IGNORED */ , function(_result, _file) {
                 append(_result.ignored = _result.ignored || [], _file);
             }),
-            parser2("?" /* UNTRACKED */ , "?" /* UNTRACKED */ , function(result, file) {
+            parser3("?" /* UNTRACKED */ , "?" /* UNTRACKED */ , function(result, file) {
                 return append(result.not_added, file);
             })
         ].concat(_to_consumable_array(conflicts("A" /* ADDED */ , "A" /* ADDED */ , "U" /* UNMERGED */ )), _to_consumable_array(conflicts("D" /* DELETED */ , "D" /* DELETED */ , "U" /* UNMERGED */ )), _to_consumable_array(conflicts("U" /* UNMERGED */ , "A" /* ADDED */ , "D" /* DELETED */ , "U" /* UNMERGED */ )), [
@@ -4962,6 +5921,7 @@ var init_simple_git_api = __esm({
         init_task_callback();
         init_change_working_directory();
         init_checkout();
+        init_count_objects();
         init_commit();
         init_config();
         init_first_commit();
@@ -5088,7 +6048,7 @@ var init_simple_git_api = __esm({
             ]);
             return SimpleGitApi;
         }();
-        Object.assign(SimpleGitApi.prototype, checkout_default(), commit_default(), config_default(), first_commit_default(), grep_default(), log_default(), show_default(), version_default());
+        Object.assign(SimpleGitApi.prototype, checkout_default(), commit_default(), config_default(), count_objects_default(), first_commit_default(), grep_default(), log_default(), show_default(), version_default());
     }
 });
 // src/lib/runners/scheduler.ts
@@ -5356,14 +6316,14 @@ function branchTask(customArgs) {
     };
 }
 function branchLocalTask() {
-    var parser3 = parseBranchSummary;
+    var parser4 = parseBranchSummary;
     return {
         format: "utf-8",
         commands: [
             "branch",
             "-v"
         ],
-        parser: parser3
+        parser: parser4
     };
 }
 function deleteBranchesTask(branches) {
@@ -5780,11 +6740,11 @@ function stashListTask() {
         "stash",
         "list"
     ].concat(_to_consumable_array(options.commands), _to_consumable_array(customArgs));
-    var parser3 = createListLogSummaryParser(options.splitter, options.fields, logFormatFromCommand(commands));
+    var parser4 = createListLogSummaryParser(options.splitter, options.fields, logFormatFromCommand(commands));
     return validateLogFormatConfig(commands) || {
         commands: commands,
         format: "utf-8",
-        parser: parser3
+        parser: parser4
     };
 }
 var init_stash_list = __esm({