@digipair/skill-git 0.136.0 → 0.136.3

package/dist/index.esm.js

@@ -1,8 +1,8 @@
-import { Buffer as Buffer$1 } from 'node:buffer';
 import require$$0$1 from 'fs';
 import require$$0 from 'tty';
 import require$$1 from 'util';
 import { spawn } from 'child_process';
+import { normalize } from 'node:path';
 import { EventEmitter } from 'node:events';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -1119,6 +1119,29 @@ var debug = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
 	__export(src$1); 
 } (dist$1));
 
+function _instanceof$1(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+var t = /* @__PURE__ */ new WeakMap();
+function c$1() {
+    for(var _len = arguments.length, n = new Array(_len), _key = 0; _key < _len; _key++){
+        n[_key] = arguments[_key];
+    }
+    var e = new String(n);
+    return t.set(e, n), e;
+}
+function r(n) {
+    return _instanceof$1(n, String) && t.has(n);
+}
+function o(n) {
+    var _t_get;
+    return (_t_get = t.get(n)) !== null && _t_get !== void 0 ? _t_get : [];
+}
+
 var dist = {};
 
 Object.defineProperty(dist, "__esModule", {
@@ -1140,43 +1163,1405 @@ var createDeferred = dist.createDeferred = deferred_1 = dist.deferred = void 0;
         fail = _fail;
     });
     return {
-        promise: promise,
-        done: function done1(result) {
-            if (status === 'pending') {
-                status = 'resolved';
-                done(result);
+        promise: promise,
+        done: function done1(result) {
+            if (status === 'pending') {
+                status = 'resolved';
+                done(result);
+            }
+        },
+        fail: function fail1(error) {
+            if (status === 'pending') {
+                status = 'rejected';
+                fail(error);
+            }
+        },
+        get fulfilled () {
+            return status !== 'pending';
+        },
+        get status () {
+            return status;
+        }
+    };
+}
+var deferred_1 = dist.deferred = deferred;
+/**
+ * Alias of the exported `deferred` function, to help consumers wanting to use `deferred` as the
+ * local variable name rather than the factory import name, without needing to rename on import.
+ *
+ * ```typescript
+ import {createDeferred} from '@kwsites/promise-deferred`;
+ ```
+ */ createDeferred = dist.createDeferred = deferred;
+/**
+ * Default export allows use as:
+ *
+ * ```typescript
+ import deferred from '@kwsites/promise-deferred`;
+ ```
+ */ dist.default = deferred;
+
+function _array_like_to_array$1(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_with_holes$1(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit$1(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$1() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread$1() {
+    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 _object_spread$1(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$1(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$1(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array$1(arr, i) {
+    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest$1();
+}
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread$1();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(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$1(o, minLen);
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function U(e, t) {
+    var n, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, o, _tmp, err;
+    return _ts_generator$1(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                n = t === "global";
+                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                _state.label = 1;
+            case 1:
+                _state.trys.push([
+                    1,
+                    7,
+                    8,
+                    9
+                ]);
+                _iterator = e[Symbol.iterator]();
+                _state.label = 2;
+            case 2:
+                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                    3,
+                    6
+                ];
+                o = _step.value;
+                _tmp = o.isGlobal === n;
+                if (!_tmp) return [
+                    3,
+                    4
+                ];
+                return [
+                    4,
+                    o
+                ];
+            case 3:
+                _tmp = _state.sent();
+                _state.label = 4;
+            case 4:
+                _state.label = 5;
+            case 5:
+                _iteratorNormalCompletion = true;
+                return [
+                    3,
+                    2
+                ];
+            case 6:
+                return [
+                    3,
+                    9
+                ];
+            case 7:
+                err = _state.sent();
+                _didIteratorError = true;
+                _iteratorError = err;
+                return [
+                    3,
+                    9
+                ];
+            case 8:
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+                return [
+                    7
+                ];
+            case 9:
+                return [
+                    2
+                ];
+        }
+    });
+}
+var k = /* @__PURE__ */ new Set([
+    "--add",
+    "--edit",
+    "--remove-section",
+    "--rename-section",
+    "--replace-all",
+    "--unset",
+    "--unset-all",
+    "-e"
+]), S = /* @__PURE__ */ new Set([
+    "--get",
+    "--get-all",
+    "--get-color",
+    "--get-colorbool",
+    "--get-regexp",
+    "--get-urlmatch",
+    "--list",
+    "-l"
+]), P = /* @__PURE__ */ new Set([
+    "edit",
+    "remove-section",
+    "rename-section",
+    "set",
+    "unset"
+]), E = /* @__PURE__ */ new Set([
+    "get",
+    "get-color",
+    "get-colorbool",
+    "list"
+]);
+function F(e, t) {
+    var _t_at;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = U(e, "task")[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _step.value, o = _step_value.name;
+            if (k.has(o)) return p(!0, t);
+            if (S.has(o)) return p(!1, t);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var n = (_t_at = t.at(0)) === null || _t_at === void 0 ? void 0 : _t_at.toLowerCase();
+    return n === void 0 ? null : P.has(n) ? p(true, t.slice(1)) : E.has(n) ? p(false, t.slice(1)) : t.length === 1 ? p(false, t) : p(true, t);
+}
+function p() {
+    var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false, t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+    var _t_at;
+    var n = (_t_at = t.at(0)) === null || _t_at === void 0 ? void 0 : _t_at.toLowerCase();
+    return n === void 0 ? null : {
+        isWrite: e,
+        isRead: !e,
+        key: n,
+        value: t.at(1)
+    };
+}
+function A(e, t) {
+    return t.isWrite && t.value !== void 0 ? {
+        key: t.key,
+        value: t.value,
+        scope: e
+    } : {
+        key: t.key,
+        scope: e
+    };
+}
+function M(e) {
+    var t = (e === null || e === void 0 ? void 0 : e.indexOf("=")) || -1;
+    return !e || t < 0 ? null : {
+        key: e.slice(0, t).trim().toLowerCase(),
+        value: e.slice(t + 1)
+    };
+}
+function N(e) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = U(e, "task")[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _step.value, t = _step_value.name;
+            switch(t){
+                case "--global":
+                    return "global";
+                case "--system":
+                    return "system";
+                case "--worktree":
+                    return "worktree";
+                case "--local":
+                    return "local";
+                case "--file":
+                case "-f":
+                    return "file";
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return "local";
+}
+function G(param) {
+    var e = param.name;
+    if (e === "-c" || e === "--config") return "inline";
+    if (e === "--config-env") return "env";
+}
+function O(e) {
+    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, t, n, o, _tmp, err;
+    return _ts_generator$1(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                _state.label = 1;
+            case 1:
+                _state.trys.push([
+                    1,
+                    7,
+                    8,
+                    9
+                ]);
+                _iterator = e[Symbol.iterator]();
+                _state.label = 2;
+            case 2:
+                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                    3,
+                    6
+                ];
+                t = _step.value;
+                n = G(t), o = n && M(t.value);
+                _tmp = o;
+                if (!_tmp) return [
+                    3,
+                    4
+                ];
+                return [
+                    4,
+                    _object_spread_props$1(_object_spread$1({}, o), {
+                        scope: n
+                    })
+                ];
+            case 3:
+                _tmp = _state.sent();
+                _state.label = 4;
+            case 4:
+                _state.label = 5;
+            case 5:
+                _iteratorNormalCompletion = true;
+                return [
+                    3,
+                    2
+                ];
+            case 6:
+                return [
+                    3,
+                    9
+                ];
+            case 7:
+                err = _state.sent();
+                _didIteratorError = true;
+                _iteratorError = err;
+                return [
+                    3,
+                    9
+                ];
+            case 8:
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+                return [
+                    7
+                ];
+            case 9:
+                return [
+                    2
+                ];
+        }
+    });
+}
+function L(e, t, n) {
+    var o = {
+        read: [],
+        write: _to_consumable_array$1(O(t))
+    };
+    return e === "config" && $(o, N(t), F(t, n)), o;
+}
+function $(e, t, n) {
+    if (n === null) return;
+    var o = A(t, n);
+    n.isWrite ? e.write.push(o) : e.read.push(o);
+}
+var x = {
+    short: /* @__PURE__ */ new Map([
+        [
+            "c",
+            true
+        ]
+    ])
+}, D = {
+    short: new Map([
+        [
+            "C",
+            true
+        ],
+        //  -C <path>   change working directory
+        [
+            "P",
+            false
+        ],
+        // -P          no pager (alias for --no-pager)
+        [
+            "h",
+            false
+        ],
+        // -h          help
+        [
+            "p",
+            false
+        ],
+        // -p          paginate
+        [
+            "v",
+            false
+        ]
+    ].concat(// -v          version
+    _to_consumable_array$1(x.short.entries()))),
+    long: /* @__PURE__ */ new Set([
+        "attr-source",
+        "config-env",
+        "exec-path",
+        "git-dir",
+        "list-cmds",
+        "namespace",
+        "super-prefix",
+        "work-tree"
+    ])
+}, R = {
+    clone: {
+        short: /* @__PURE__ */ new Map([
+            [
+                "b",
+                true
+            ],
+            // -b <branch>
+            [
+                "j",
+                true
+            ],
+            // -j <n>          parallel jobs
+            [
+                "l",
+                false
+            ],
+            // -l local
+            [
+                "n",
+                false
+            ],
+            // -n no-checkout
+            [
+                "o",
+                true
+            ],
+            // -o <name>       remote name
+            [
+                "q",
+                false
+            ],
+            // -q quiet
+            [
+                "s",
+                false
+            ],
+            // -s shared
+            [
+                "u",
+                true
+            ]
+        ]),
+        long: /* @__PURE__ */ new Set([
+            "branch",
+            "config",
+            "jobs",
+            "origin",
+            "upload-pack",
+            "u",
+            "template"
+        ])
+    },
+    commit: {
+        short: /* @__PURE__ */ new Map([
+            [
+                "C",
+                true
+            ],
+            // -C <commit>  reuse message
+            [
+                "F",
+                true
+            ],
+            // -F <file>    read message from file
+            [
+                "c",
+                true
+            ],
+            // -c <commit>  reedit message
+            [
+                "m",
+                true
+            ],
+            // -m <msg>
+            [
+                "t",
+                true
+            ]
+        ]),
+        long: /* @__PURE__ */ new Set([
+            "file",
+            "message",
+            "reedit-message",
+            "reuse-message",
+            "template"
+        ])
+    },
+    config: {
+        short: /* @__PURE__ */ new Map([
+            [
+                "e",
+                false
+            ],
+            // -e  open editor
+            [
+                "f",
+                true
+            ],
+            //  -f <file>
+            [
+                "l",
+                false
+            ]
+        ]),
+        long: /* @__PURE__ */ new Set([
+            "blob",
+            "comment",
+            "default",
+            "file",
+            "type",
+            "value"
+        ])
+    },
+    fetch: {
+        short: /* @__PURE__ */ new Map(),
+        long: /* @__PURE__ */ new Set([
+            "upload-pack"
+        ])
+    },
+    init: {
+        short: /* @__PURE__ */ new Map(),
+        long: /* @__PURE__ */ new Set([
+            "template"
+        ])
+    },
+    pull: {
+        short: /* @__PURE__ */ new Map(),
+        long: /* @__PURE__ */ new Set([
+            "upload-pack"
+        ])
+    },
+    push: {
+        short: /* @__PURE__ */ new Map(),
+        long: /* @__PURE__ */ new Set([
+            "exec",
+            "receive-pack"
+        ])
+    }
+}, T = {
+    short: /* @__PURE__ */ new Map(),
+    long: /* @__PURE__ */ new Set()
+};
+function I(e) {
+    var _R_;
+    var t = (_R_ = R[e !== null && e !== void 0 ? e : ""]) !== null && _R_ !== void 0 ? _R_ : T;
+    return {
+        short: new Map(_to_consumable_array$1(x.short.entries()).concat(_to_consumable_array$1(t.short.entries()))),
+        long: t.long
+    };
+}
+function b(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : D;
+    if (e.startsWith("--")) {
+        var n = e.indexOf("=");
+        if (n > 2) return [
+            {
+                name: e.slice(0, n),
+                value: e.slice(n + 1),
+                needsNext: false
+            }
+        ];
+        var o = e.slice(2);
+        return [
+            {
+                name: e,
+                needsNext: t.long.has(o)
+            }
+        ];
+    }
+    if (e.length === 2) {
+        var n1 = e.charAt(1), o1 = t.short.get(n1);
+        return [
+            {
+                name: e,
+                needsNext: o1 === true
+            }
+        ];
+    }
+    return W(e, t.short);
+}
+function W(e, t) {
+    var n = e.slice(1).split(""), o = [];
+    for(var s = 0; s < n.length; s++){
+        var r = n[s], l = t.get(r);
+        if (l === void 0) return [
+            {
+                name: e,
+                needsNext: false
+            }
+        ];
+        if (l) {
+            var a = n.slice(s + 1).join("");
+            if (a && !_to_consumable_array$1(a).every(function(w) {
+                return t.has(w);
+            })) return o.push({
+                name: "-".concat(r),
+                value: a,
+                needsNext: false
+            }), o;
+        }
+        o.push({
+            name: "-".concat(r),
+            needsNext: l
+        });
+    }
+    return o;
+}
+function j(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+    var n = 0;
+    for(; n < e.length;){
+        var o = String(e[n]);
+        if (!o.startsWith("-") || o.length < 2) break;
+        var s = b(o);
+        var r = n + 1;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = s[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var l = _step.value;
+                var a = {
+                    name: l.name,
+                    value: l.value,
+                    absorbedNext: !1,
+                    isGlobal: !0
+                };
+                l.needsNext && a.value === void 0 && r < e.length && (a.value = String(e[r]), a.absorbedNext = !0, r++), t.push(a);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        n = r;
+    }
+    return {
+        flags: t,
+        taskIndex: n
+    };
+}
+function B(e, t) {
+    var n = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
+    var o$1 = I(t), s = [], r$1 = [];
+    var l = 0;
+    for(; l < e.length;){
+        var a = e[l];
+        if (r(a)) {
+            var _r;
+            (_r = r$1).push.apply(_r, _to_consumable_array$1(o(a))), l++;
+            continue;
+        }
+        var f = String(a);
+        if (f === "--") {
+            for(var g = l + 1; g < e.length; g++){
+                var _r1;
+                var u = e[g];
+                r(u) ? (_r1 = r$1).push.apply(_r1, _to_consumable_array$1(o(u))) : r$1.push(String(u));
+            }
+            break;
+        }
+        if (!f.startsWith("-") || f.length < 2) {
+            s.push(f), l++;
+            continue;
+        }
+        var w = b(f, o$1);
+        var d = l + 1;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = w[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var g1 = _step.value;
+                var u1 = {
+                    name: g1.name,
+                    value: g1.value,
+                    absorbedNext: !1,
+                    isGlobal: !1
+                };
+                g1.needsNext && u1.value === void 0 && d < e.length && !r(e[d]) && (u1.value = String(e[d]), u1.absorbedNext = !0, d++), n.push(u1);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        l = d;
+    }
+    return {
+        flags: n,
+        positionals: s,
+        pathspecs: r$1
+    };
+}
+function V(param) {
+    var e, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator, _step, t, _iterator1, _step1, n, o, _tmp, err, err;
+    return _ts_generator$1(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                e = param.write;
+                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined, _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                _state.label = 1;
+            case 1:
+                _state.trys.push([
+                    1,
+                    13,
+                    14,
+                    15
+                ]);
+                _iterator = e[Symbol.iterator]();
+                _state.label = 2;
+            case 2:
+                if (!!(_iteratorNormalCompletion1 = (_step = _iterator.next()).done)) return [
+                    3,
+                    12
+                ];
+                t = _step.value;
+                _state.label = 3;
+            case 3:
+                _state.trys.push([
+                    3,
+                    9,
+                    10,
+                    11
+                ]);
+                _iterator1 = q[Symbol.iterator]();
+                _state.label = 4;
+            case 4:
+                if (!!(_iteratorNormalCompletion = (_step1 = _iterator1.next()).done)) return [
+                    3,
+                    8
+                ];
+                n = _step1.value;
+                o = n(t.key);
+                _tmp = o;
+                if (!_tmp) return [
+                    3,
+                    6
+                ];
+                return [
+                    4,
+                    o
+                ];
+            case 5:
+                _tmp = _state.sent();
+                _state.label = 6;
+            case 6:
+                _state.label = 7;
+            case 7:
+                _iteratorNormalCompletion = true;
+                return [
+                    3,
+                    4
+                ];
+            case 8:
+                return [
+                    3,
+                    11
+                ];
+            case 9:
+                err = _state.sent();
+                _didIteratorError = true;
+                _iteratorError = err;
+                return [
+                    3,
+                    11
+                ];
+            case 10:
+                try {
+                    if (!_iteratorNormalCompletion && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+                return [
+                    7
+                ];
+            case 11:
+                _iteratorNormalCompletion1 = true;
+                return [
+                    3,
+                    2
+                ];
+            case 12:
+                return [
+                    3,
+                    15
+                ];
+            case 13:
+                err = _state.sent();
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+                return [
+                    3,
+                    15
+                ];
+            case 14:
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+                return [
+                    7
+                ];
+            case 15:
+                return [
+                    2
+                ];
+        }
+    });
+}
+function c(e, t) {
+    var n = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : String(e);
+    var o = typeof e == "string" ? new RegExp("\\s*".concat(e.toLowerCase())) : e;
+    return function(r) {
+        if (o.test(r)) return {
+            category: t,
+            message: "Configuring ".concat(n, " is not permitted without enabling ").concat(t)
+        };
+    };
+}
+function i(e, t) {
+    var n = new RegExp("\\s*".concat(e.toLowerCase().replace(/\./g, "(..+)?.")));
+    return c(n, t, e);
+}
+var q = [
+    c("alias", "allowUnsafeAlias"),
+    c("core.askPass", "allowUnsafeAskPass"),
+    c("core.editor", "allowUnsafeEditor"),
+    c("core.fsmonitor", "allowUnsafeFsMonitor"),
+    c("core.gitProxy", "allowUnsafeGitProxy"),
+    c("core.hooksPath", "allowUnsafeHooksPath"),
+    c("core.pager", "allowUnsafePager"),
+    c("core.sshCommand", "allowUnsafeSshCommand"),
+    i("credential.helper", "allowUnsafeCredentialHelper"),
+    i("diff.command", "allowUnsafeDiffExternal"),
+    c("diff.external", "allowUnsafeDiffExternal"),
+    i("diff.textconv", "allowUnsafeDiffTextConv"),
+    i("filter.clean", "allowUnsafeFilter"),
+    i("filter.smudge", "allowUnsafeFilter"),
+    i("gpg.program", "allowUnsafeGpgProgram"),
+    c("init.templateDir", "allowUnsafeTemplateDir"),
+    i("merge.driver", "allowUnsafeMergeDriver"),
+    i("mergetool.path", "allowUnsafeMergeDriver"),
+    i("mergetool.cmd", "allowUnsafeMergeDriver"),
+    i("protocol.allow", "allowUnsafeProtocolOverride"),
+    i("remote.receivepack", "allowUnsafePack"),
+    i("remote.uploadpack", "allowUnsafePack"),
+    c("sequence.editor", "allowUnsafeEditor")
+];
+function K(e, t) {
+    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator, _step, n, _iterator1, _step1, o, s, _tmp, err, err;
+    return _ts_generator$1(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined, _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                _state.label = 1;
+            case 1:
+                _state.trys.push([
+                    1,
+                    13,
+                    14,
+                    15
+                ]);
+                _iterator = t[Symbol.iterator]();
+                _state.label = 2;
+            case 2:
+                if (!!(_iteratorNormalCompletion1 = (_step = _iterator.next()).done)) return [
+                    3,
+                    12
+                ];
+                n = _step.value;
+                _state.label = 3;
+            case 3:
+                _state.trys.push([
+                    3,
+                    9,
+                    10,
+                    11
+                ]);
+                _iterator1 = H[Symbol.iterator]();
+                _state.label = 4;
+            case 4:
+                if (!!(_iteratorNormalCompletion = (_step1 = _iterator1.next()).done)) return [
+                    3,
+                    8
+                ];
+                o = _step1.value;
+                s = o(e, n.name);
+                _tmp = s;
+                if (!_tmp) return [
+                    3,
+                    6
+                ];
+                return [
+                    4,
+                    s
+                ];
+            case 5:
+                _tmp = _state.sent();
+                _state.label = 6;
+            case 6:
+                _state.label = 7;
+            case 7:
+                _iteratorNormalCompletion = true;
+                return [
+                    3,
+                    4
+                ];
+            case 8:
+                return [
+                    3,
+                    11
+                ];
+            case 9:
+                err = _state.sent();
+                _didIteratorError = true;
+                _iteratorError = err;
+                return [
+                    3,
+                    11
+                ];
+            case 10:
+                try {
+                    if (!_iteratorNormalCompletion && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+                return [
+                    7
+                ];
+            case 11:
+                _iteratorNormalCompletion1 = true;
+                return [
+                    3,
+                    2
+                ];
+            case 12:
+                return [
+                    3,
+                    15
+                ];
+            case 13:
+                err = _state.sent();
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+                return [
+                    3,
+                    15
+                ];
+            case 14:
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+                return [
+                    7
+                ];
+            case 15:
+                return [
+                    2
+                ];
+        }
+    });
+}
+function h(e, t, n) {
+    var o = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : String(t);
+    var s = typeof t == "string" ? new RegExp("\\s*".concat(t.toLowerCase())) : t, r = "Use of ".concat(e ? "".concat(e, " with option ") : "").concat(o, " is not permitted without enabling ").concat(n);
+    return function(a, f) {
+        if ((!e || a === e) && s.test(f)) return {
+            category: n,
+            message: r
+        };
+    };
+}
+var H = [
+    h(null, /--(upload|receive)-pack/, "allowUnsafePack", "--upload-pack or --receive-pack"),
+    h("clone", /^-\w*u/, "allowUnsafePack"),
+    h("clone", "--u", "allowUnsafePack"),
+    h("push", "--exec", "allowUnsafePack"),
+    h(null, "--template", "allowUnsafeTemplateDir")
+];
+function C(e, t, n) {
+    return _to_consumable_array$1(K(e, t)).concat(_to_consumable_array$1(V(n)));
+}
+function Y() {
+    for(var _len = arguments.length, e = new Array(_len), _key = 0; _key < _len; _key++){
+        e[_key] = arguments[_key];
+    }
+    var _j = j(e), t = _j.flags, n = _j.taskIndex, o = n < e.length ? String(e[n]).toLowerCase() : null, s = o !== null ? e.slice(n + 1) : [], _B = B(s, o, t), r = _B.positionals, l = _B.pathspecs, a = L(o, t, r);
+    return {
+        task: o,
+        flags: t.map(J),
+        paths: l,
+        config: a,
+        vulnerabilities: z(C(o, t, a))
+    };
+}
+function z(e) {
+    return Object.defineProperty(e, "vulnerabilities", {
+        value: e
+    });
+}
+function J(param) {
+    var e = param.value, t = param.name;
+    return e !== void 0 ? {
+        name: t,
+        value: e
+    } : {
+        name: t
+    };
+}
+var y = {
+    editor: "allowUnsafeEditor",
+    git_askpass: "allowUnsafeAskPass",
+    git_config_global: "allowUnsafeConfigPaths",
+    git_config_system: "allowUnsafeConfigPaths",
+    git_config_count: "allowUnsafeConfigEnvCount",
+    git_config: "allowUnsafeConfigPaths",
+    git_editor: "allowUnsafeEditor",
+    git_exec_path: "allowUnsafeConfigPaths",
+    git_external_diff: "allowUnsafeDiffExternal",
+    git_pager: "allowUnsafePager",
+    git_proxy_command: "allowUnsafeGitProxy",
+    git_template_dir: "allowUnsafeTemplateDir",
+    git_sequence_editor: "allowUnsafeEditor",
+    git_ssh: "allowUnsafeSshCommand",
+    git_ssh_command: "allowUnsafeSshCommand",
+    pager: "allowUnsafePager",
+    prefix: "allowUnsafeConfigPaths",
+    ssh_askpass: "allowUnsafeAskPass"
+};
+function Q(e) {
+    var _e_git_config_count, t, n, o, s, _tmp;
+    return _ts_generator$1(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                t = parseInt((_e_git_config_count = e.git_config_count) !== null && _e_git_config_count !== void 0 ? _e_git_config_count : "0", 10);
+                n = 0;
+                _state.label = 1;
+            case 1:
+                if (!(n < t)) return [
+                    3,
+                    5
+                ];
+                o = e["git_config_key_".concat(n)], s = e["git_config_value_".concat(n)];
+                _tmp = o !== void 0;
+                if (!_tmp) return [
+                    3,
+                    3
+                ];
+                return [
+                    4,
+                    {
+                        key: o.toLowerCase().trim(),
+                        value: s,
+                        scope: "env"
+                    }
+                ];
+            case 2:
+                _tmp = _state.sent();
+                _state.label = 3;
+            case 3:
+                _state.label = 4;
+            case 4:
+                n++;
+                return [
+                    3,
+                    1
+                ];
+            case 5:
+                return [
+                    2
+                ];
+        }
+    });
+}
+function X(e) {
+    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, t, n, err;
+    return _ts_generator$1(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                _state.label = 1;
+            case 1:
+                _state.trys.push([
+                    1,
+                    6,
+                    7,
+                    8
+                ]);
+                _iterator = Object.keys(e)[Symbol.iterator]();
+                _state.label = 2;
+            case 2:
+                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                    3,
+                    5
+                ];
+                t = _step.value;
+                if (!_(t)) return [
+                    3,
+                    4
+                ];
+                n = y[t];
+                return [
+                    4,
+                    {
+                        category: n,
+                        message: 'Use of "'.concat(t.toUpperCase(), '" is not permitted without enabling ').concat(n)
+                    }
+                ];
+            case 3:
+                _state.sent();
+                _state.label = 4;
+            case 4:
+                _iteratorNormalCompletion = true;
+                return [
+                    3,
+                    2
+                ];
+            case 5:
+                return [
+                    3,
+                    8
+                ];
+            case 6:
+                err = _state.sent();
+                _didIteratorError = true;
+                _iteratorError = err;
+                return [
+                    3,
+                    8
+                ];
+            case 7:
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+                return [
+                    7
+                ];
+            case 8:
+                return [
+                    2
+                ];
+        }
+    });
+}
+function _(e) {
+    return Object.hasOwn(y, e);
+}
+function Z(e) {
+    var t = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(e)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array$1(_step.value, 2), n = _step_value[0], o = _step_value[1];
+            var s = n.toLowerCase().trim();
+            (_(s) || s.startsWith("git")) && (t[s] = String(o));
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
             }
-        },
-        fail: function fail1(error) {
-            if (status === 'pending') {
-                status = 'rejected';
-                fail(error);
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
             }
-        },
-        get fulfilled () {
-            return status !== 'pending';
-        },
-        get status () {
-            return status;
         }
+    }
+    return t;
+}
+function ee(e) {
+    var t = Z(e), n = {
+        read: [],
+        write: _to_consumable_array$1(Q(t))
+    }, o = _to_consumable_array$1(X(t)).concat(_to_consumable_array$1(C(null, [], n)));
+    return {
+        config: n,
+        vulnerabilities: o
     };
 }
-var deferred_1 = dist.deferred = deferred;
-/**
- * Alias of the exported `deferred` function, to help consumers wanting to use `deferred` as the
- * local variable name rather than the factory import name, without needing to rename on import.
- *
- * ```typescript
- import {createDeferred} from '@kwsites/promise-deferred`;
- ```
- */ createDeferred = dist.createDeferred = deferred;
-/**
- * Default export allows use as:
- *
- * ```typescript
- import deferred from '@kwsites/promise-deferred`;
- ```
- */ dist.default = deferred;
+function ne(e, t) {
+    return _to_consumable_array$1(Y.apply(void 0, _to_consumable_array$1(e)).vulnerabilities).concat(_to_consumable_array$1(ee(t).vulnerabilities));
+}
 
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -1626,27 +3011,6 @@ var __toCommonJS = function(mod) {
         value: true
     }), mod);
 };
-// src/lib/args/pathspec.ts
-function pathspec() {
-    for(var _len = arguments.length, paths = new Array(_len), _key = 0; _key < _len; _key++){
-        paths[_key] = arguments[_key];
-    }
-    var key = new String(paths);
-    cache.set(key, paths);
-    return key;
-}
-function isPathSpec(path) {
-    return _instanceof(path, String) && cache.has(path);
-}
-function toPaths(pathSpec) {
-    return cache.get(pathSpec) || [];
-}
-var cache;
-var init_pathspec = __esm({
-    "src/lib/args/pathspec.ts": function() {
-        cache = /* @__PURE__ */ new WeakMap();
-    }
-});
 // src/lib/errors/git-error.ts
 var GitError;
 var init_git_error = __esm({
@@ -1734,7 +3098,7 @@ function last(input) {
     }
 }
 function isArrayLike(input) {
-    return !!(input && typeof input.length === "number");
+    return filterHasLength(input);
 }
 function toLinesWithContent() {
     var input = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "", trimmed2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true, separator = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "\n";
@@ -1792,7 +3156,9 @@ function asCamelCase(str) {
     });
 }
 function asStringArray(source) {
-    return asArray(source).map(String);
+    return asArray(source).map(function(item) {
+        return _instanceof(item, String) ? item : String(item);
+    });
 }
 function asNumber(source) {
     var onNaN = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
@@ -1800,7 +3166,7 @@ function asNumber(source) {
         return onNaN;
     }
     var num = parseInt(source, 10);
-    return isNaN(num) ? onNaN : num;
+    return Number.isNaN(num) ? onNaN : num;
 }
 function prefixedArray(input, prefix) {
     var output = [];
@@ -1810,15 +3176,16 @@ function prefixedArray(input, prefix) {
     return output;
 }
 function bufferToString(input) {
-    return (Array.isArray(input) ? Buffer$1.concat(input) : input).toString("utf-8");
+    return (Array.isArray(input) ? Buffer.concat(input) : input).toString("utf-8");
 }
 function pick(source, properties) {
-    var _Object;
-    return (_Object = Object).assign.apply(_Object, [
-        {}
-    ].concat(_to_consumable_array(properties.map(function(property) {
-        return property in source ? _define_property({}, property, source[property]) : {};
-    }))));
+    var out = {};
+    properties.forEach(function(key) {
+        if (source[key] !== void 0) {
+            out[key] = source[key];
+        }
+    });
+    return out;
 }
 function delay() {
     var duration = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
@@ -1835,12 +3202,12 @@ function orVoid(input) {
 var NULL, NOOP, objectToString;
 var init_util = __esm({
     "src/lib/utils/util.ts": function() {
+        init_argument_filters();
         NULL = "\0";
         NOOP = function() {};
         objectToString = Object.prototype.toString.call.bind(Object.prototype.toString);
     }
 });
-// src/lib/utils/argument-filters.ts
 function filterType(input, filter, def) {
     if (filter(input)) {
         return input;
@@ -1848,7 +3215,7 @@ function filterType(input, filter, def) {
     return arguments.length > 2 ? def : void 0;
 }
 function filterPrimitives(input, omit) {
-    var type = isPathSpec(input) ? "string" : typeof input === "undefined" ? "undefined" : _type_of(input);
+    var type = r(input) ? "string" : typeof input === "undefined" ? "undefined" : _type_of(input);
     return /number|string|boolean/.test(type) && (!omit || !omit.includes(type));
 }
 function filterPlainObject(input) {
@@ -1857,19 +3224,18 @@ function filterPlainObject(input) {
 function filterFunction(input) {
     return typeof input === "function";
 }
-var filterArray, filterString, filterStringArray, filterStringOrStringArray, filterHasLength;
+var filterArray, filterNumber, filterString, filterStringOrStringArray, filterHasLength;
 var init_argument_filters = __esm({
     "src/lib/utils/argument-filters.ts": function() {
         init_util();
-        init_pathspec();
         filterArray = function(input) {
             return Array.isArray(input);
         };
-        filterString = function(input) {
-            return typeof input === "string";
+        filterNumber = function(input) {
+            return typeof input === "number";
         };
-        filterStringArray = function(input) {
-            return Array.isArray(input) && input.every(filterString);
+        filterString = function(input) {
+            return typeof input === "string" || r(input);
         };
         filterStringOrStringArray = function(input) {
             return filterString(input) || Array.isArray(input) && input.every(filterString);
@@ -1878,7 +3244,7 @@ var init_argument_filters = __esm({
             if (input == null || "number|boolean|function".includes(typeof input === "undefined" ? "undefined" : _type_of(input))) {
                 return false;
             }
-            return Array.isArray(input) || typeof input === "string" || typeof input.length === "number";
+            return typeof input.length === "number";
         };
     }
 });
@@ -1918,6 +3284,9 @@ var init_git_output_streams = __esm({
     }
 });
 // src/lib/utils/line-parser.ts
+function useMatchesDefault() {
+    throw new Error("LineParser:useMatches not implemented");
+}
 var LineParser, RemoteLineParser;
 var init_line_parser = __esm({
     "src/lib/utils/line-parser.ts": function() {
@@ -1926,6 +3295,7 @@ var init_line_parser = __esm({
                 var _this = this;
                 _class_call_check(this, LineParser);
                 this.matches = [];
+                this.useMatches = useMatchesDefault;
                 this.parse = function(line, target) {
                     _this.resetMatches();
                     if (!_this._regExp.every(function(reg, index) {
@@ -1943,13 +3313,6 @@ var init_line_parser = __esm({
                 }
             }
             _create_class(LineParser, [
-                {
-                    // @ts-ignore
-                    key: "useMatches",
-                    value: function useMatches(target, match) {
-                        throw new Error("LineParser:useMatches not implemented");
-                    }
-                },
                 {
                     key: "resetMatches",
                     value: function resetMatches() {
@@ -2038,7 +3401,6 @@ var init_simple_git_options = __esm({
         };
     }
 });
-// src/lib/utils/task-options.ts
 function appendTaskOptions(options) {
     var commands = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
     if (!filterPlainObject(options)) {
@@ -2046,7 +3408,7 @@ function appendTaskOptions(options) {
     }
     return Object.keys(options).reduce(function(commands2, key) {
         var value = options[key];
-        if (isPathSpec(value)) {
+        if (r(value)) {
             commands2.push(value);
         } else if (filterPrimitives(value, [
             "boolean"
@@ -2101,7 +3463,7 @@ function getTrailingOptions(args) {
 }
 function trailingArrayArgument(args) {
     var hasTrailingCallback = typeof last(args) === "function";
-    return filterType(last(args, hasTrailingCallback ? 1 : 0), filterArray, []);
+    return asStringArray(filterType(last(args, hasTrailingCallback ? 1 : 0), filterArray, []));
 }
 function trailingOptionsArgument(args) {
     var hasTrailingCallback = filterFunction(last(args));
@@ -2116,7 +3478,6 @@ var init_task_options = __esm({
     "src/lib/utils/task-options.ts": function() {
         init_argument_filters();
         init_util();
-        init_pathspec();
     }
 });
 // src/lib/utils/task-parser.ts
@@ -2211,6 +3572,9 @@ __export(utils_exports, {
     filterHasLength: function() {
         return filterHasLength;
     },
+    filterNumber: function() {
+        return filterNumber;
+    },
     filterPlainObject: function() {
         return filterPlainObject;
     },
@@ -2220,9 +3584,6 @@ __export(utils_exports, {
     filterString: function() {
         return filterString;
     },
-    filterStringArray: function() {
-        return filterStringArray;
-    },
     filterStringOrStringArray: function() {
         return filterStringOrStringArray;
     },
@@ -2744,7 +4105,7 @@ var init_ConfigList = __esm({
                     key: "addValue",
                     value: function addValue(file, key, value) {
                         var values = this.addFile(file);
-                        if (!values.hasOwnProperty(key)) {
+                        if (!Object.hasOwn(values, key)) {
                             values[key] = value;
                         } else if (Array.isArray(values[key])) {
                             values[key].push(value);
@@ -2764,7 +4125,7 @@ var init_ConfigList = __esm({
 });
 // src/lib/tasks/config.ts
 function asConfigScope(scope, fallback) {
-    if (typeof scope === "string" && GitConfigScope.hasOwnProperty(scope)) {
+    if (typeof scope === "string" && Object.hasOwn(GitConfigScope, scope)) {
         return scope;
     }
     return fallback;
@@ -3103,11 +4464,12 @@ function getResetMode(mode) {
     return;
 }
 function isValidResetMode(mode) {
-    return ResetModes.includes(mode);
+    return typeof mode === "string" && validResetModes.includes(mode);
 }
-var ResetMode, ResetModes;
+var ResetMode, validResetModes;
 var init_reset = __esm({
     "src/lib/tasks/reset.ts": function() {
+        init_utils();
         init_task();
         ResetMode = /* @__PURE__ */ function(ResetMode2) {
             ResetMode2["MIXED"] = "mixed";
@@ -3117,7 +4479,7 @@ var init_reset = __esm({
             ResetMode2["KEEP"] = "keep";
             return ResetMode2;
         }(ResetMode || {});
-        ResetModes = Array.from(Object.values(ResetMode));
+        validResetModes = asStringArray(Object.values(ResetMode));
     }
 });
 function createLog() {
@@ -3456,7 +4818,9 @@ var init_git_executor_chain = __esm({
                                 switch(_state.label){
                                     case 0:
                                         binary = _this._plugins.exec("spawn.binary", "", pluginContext(task, task.commands));
-                                        args = _this._plugins.exec("spawn.args", _to_consumable_array(task.commands), pluginContext(task, task.commands));
+                                        args = _this._plugins.exec("spawn.args", _to_consumable_array(task.commands), _object_spread_props(_object_spread({}, pluginContext(task, task.commands)), {
+                                            env: _object_spread({}, _this.env)
+                                        }));
                                         return [
                                             4,
                                             _this.gitResponse(task, binary, args, _this.outputHandler, logger.step("SPAWN"))
@@ -3776,7 +5140,7 @@ var init_count_objects = __esm({
         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)) {
+            if (Object.hasOwn(result, property)) {
                 result[property] = asNumber(value);
             }
         });
@@ -3859,7 +5223,7 @@ function commit_default() {
                 rest[_key - 1] = arguments[_key];
             }
             var next = trailingFunctionArgument(arguments);
-            var task = rejectDeprecatedSignatures(message) || commitTask(asArray(message), asArray(filterType(rest[0], filterStringOrStringArray, [])), _to_consumable_array(filterType(rest[1], filterArray, [])).concat(_to_consumable_array(getTrailingOptions(arguments, 0, true))));
+            var task = rejectDeprecatedSignatures(message) || commitTask(asArray(message), asArray(filterType(rest[0], filterStringOrStringArray, [])), _to_consumable_array(asStringArray(filterType(rest[1], filterArray, []))).concat(_to_consumable_array(getTrailingOptions(arguments, 0, true))));
             return this._runTask(task, next);
         }
     };
@@ -4196,7 +5560,6 @@ var init_diff = __esm({
         init_task();
     }
 });
-// src/lib/tasks/log.ts
 function prettyFormat(format, splitter) {
     var fields = [];
     var formatStr = [];
@@ -4243,7 +5606,7 @@ function parseLogOptions() {
         suffix.push("".concat(opt.from || "").concat(rangeOperator).concat(opt.to || ""));
     }
     if (filterString(opt.file)) {
-        command.push("--follow", pathspec(opt.file));
+        command.push("--follow", c$1(opt.file));
     }
     appendTaskOptions(userOptions(opt), command);
     return {
@@ -4269,7 +5632,7 @@ function log_default() {
                 rest[_key] = arguments[_key];
             }
             var next = trailingFunctionArgument(arguments);
-            var options = parseLogOptions(trailingOptionsArgument(arguments), filterType(arguments[0], filterArray));
+            var options = parseLogOptions(trailingOptionsArgument(arguments), asStringArray(filterType(arguments[0], filterArray, [])));
             var task = rejectDeprecatedSignatures.apply(void 0, _to_consumable_array(rest)) || validateLogFormatConfig(options.commands) || createLogTask(options);
             return this._runTask(task, next);
         }
@@ -4285,7 +5648,6 @@ var excludeOptions;
 var init_log = __esm({
     "src/lib/tasks/log.ts": function() {
         init_log_format();
-        init_pathspec();
         init_parse_list_log_summary();
         init_utils();
         init_task();
@@ -4823,7 +6185,7 @@ function conflicts(indexX) {
     }
     return indexY.map(function(y) {
         return parser3(indexX, y, function(result, file) {
-            return append(result.conflicted, file);
+            return result.conflicted.push(file);
         });
     });
 }
@@ -4831,9 +6193,9 @@ function splitLine(result, lineStr) {
     var trimmed2 = lineStr.trim();
     switch(" "){
         case trimmed2.charAt(2):
-            return data(trimmed2.charAt(0), trimmed2.charAt(1), trimmed2.substr(3));
+            return data(trimmed2.charAt(0), trimmed2.charAt(1), trimmed2.slice(3));
         case trimmed2.charAt(1):
-            return data(" " /* NONE */ , trimmed2.charAt(0), trimmed2.substr(2));
+            return data(" " /* NONE */ , trimmed2.charAt(0), trimmed2.slice(2));
         default:
             return;
     }
@@ -4876,42 +6238,48 @@ var init_StatusSummary = __esm({
         };
         parsers6 = new Map([
             parser3(" " /* NONE */ , "A" /* ADDED */ , function(result, file) {
-                return append(result.created, file);
+                return result.created.push(file);
             }),
             parser3(" " /* NONE */ , "D" /* DELETED */ , function(result, file) {
-                return append(result.deleted, file);
+                return result.deleted.push(file);
             }),
             parser3(" " /* NONE */ , "M" /* MODIFIED */ , function(result, file) {
-                return append(result.modified, file);
+                return result.modified.push(file);
             }),
             parser3("A" /* ADDED */ , " " /* NONE */ , function(result, file) {
-                return append(result.created, file) && append(result.staged, file);
+                result.created.push(file);
+                result.staged.push(file);
             }),
             parser3("A" /* ADDED */ , "M" /* MODIFIED */ , function(result, file) {
-                return append(result.created, file) && append(result.staged, file) && append(result.modified, file);
+                result.created.push(file);
+                result.staged.push(file);
+                result.modified.push(file);
             }),
             parser3("D" /* DELETED */ , " " /* NONE */ , function(result, file) {
-                return append(result.deleted, file) && append(result.staged, file);
+                result.deleted.push(file);
+                result.staged.push(file);
             }),
             parser3("M" /* MODIFIED */ , " " /* NONE */ , function(result, file) {
-                return append(result.modified, file) && append(result.staged, file);
+                result.modified.push(file);
+                result.staged.push(file);
             }),
             parser3("M" /* MODIFIED */ , "M" /* MODIFIED */ , function(result, file) {
-                return append(result.modified, file) && append(result.staged, file);
+                result.modified.push(file);
+                result.staged.push(file);
             }),
             parser3("R" /* RENAMED */ , " " /* NONE */ , function(result, file) {
-                append(result.renamed, renamedFile(file));
+                result.renamed.push(renamedFile(file));
             }),
             parser3("R" /* RENAMED */ , "M" /* MODIFIED */ , function(result, file) {
                 var renamed = renamedFile(file);
-                append(result.renamed, renamed);
-                append(result.modified, renamed.to);
+                result.renamed.push(renamed);
+                result.modified.push(renamed.to);
             }),
             parser3("!" /* IGNORED */ , "!" /* IGNORED */ , function(_result, _file) {
-                append(_result.ignored = _result.ignored || [], _file);
+                (_result.ignored = _result.ignored || []).push(_file);
             }),
             parser3("?" /* UNTRACKED */ , "?" /* UNTRACKED */ , function(result, file) {
-                return append(result.not_added, file);
+                return result.not_added.push(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 */ )), [
             [
@@ -4921,18 +6289,19 @@ var init_StatusSummary = __esm({
                     var behindReg = /behind (\d+)/;
                     var currentReg = /^(.+?(?=(?:\.{3}|\s|$)))/;
                     var trackingReg = /\.{3}(\S*)/;
-                    var onEmptyBranchReg = /\son\s([\S]+)$/;
-                    var regexResult;
-                    regexResult = aheadReg.exec(line);
+                    var onEmptyBranchReg = /\son\s(\S+?)(?=\.{3}|$)/;
+                    var 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 = regexResult && regexResult[1];
+                    result.current = filterType(regexResult === null || regexResult === void 0 ? void 0 : regexResult[1], filterString, null);
                     regexResult = trackingReg.exec(line);
-                    result.tracking = regexResult && regexResult[1];
+                    result.tracking = filterType(regexResult === null || regexResult === void 0 ? void 0 : regexResult[1], filterString, null);
                     regexResult = onEmptyBranchReg.exec(line);
-                    result.current = regexResult && regexResult[1] || result.current;
+                    if (regexResult) {
+                        result.current = filterType(regexResult === null || regexResult === void 0 ? void 0 : regexResult[1], filterString, result.current);
+                    }
                     result.detached = /\(no branch\)/.test(line);
                 }
             ]
@@ -5045,6 +6414,58 @@ var init_version = __esm({
         ];
     }
 });
+function createCloneTask(api, task, repoPath) {
+    for(var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
+        args[_key - 3] = arguments[_key];
+    }
+    if (!filterString(repoPath)) {
+        return configurationErrorTask("git.".concat(api, "() requires a string 'repoPath'"));
+    }
+    return task(repoPath, filterType(args[0], filterString), getTrailingOptions(arguments));
+}
+function clone_default() {
+    return {
+        clone: function clone(repo) {
+            for(var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                rest[_key - 1] = arguments[_key];
+            }
+            return this._runTask(createCloneTask.apply(void 0, [
+                "clone",
+                cloneTask,
+                filterType(repo, filterString)
+            ].concat(_to_consumable_array(rest))), trailingFunctionArgument(arguments));
+        },
+        mirror: function mirror(repo) {
+            for(var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                rest[_key - 1] = arguments[_key];
+            }
+            return this._runTask(createCloneTask.apply(void 0, [
+                "mirror",
+                cloneMirrorTask,
+                filterType(repo, filterString)
+            ].concat(_to_consumable_array(rest))), trailingFunctionArgument(arguments));
+        }
+    };
+}
+var cloneTask, cloneMirrorTask;
+var init_clone = __esm({
+    "src/lib/tasks/clone.ts": function() {
+        init_task();
+        init_utils();
+        cloneTask = function(repo, directory, customArgs) {
+            var commands = [
+                "clone"
+            ].concat(_to_consumable_array(customArgs));
+            filterString(repo) && commands.push(c$1(repo));
+            filterString(directory) && commands.push(c$1(directory));
+            return straightThroughStringTask(commands);
+        };
+        cloneMirrorTask = function(repo, directory, customArgs) {
+            append(customArgs, "--mirror");
+            return cloneTask(repo, directory, customArgs);
+        };
+    }
+});
 // src/lib/simple-git-api.ts
 var simple_git_api_exports = {};
 __export(simple_git_api_exports, {
@@ -5073,6 +6494,7 @@ var init_simple_git_api = __esm({
         init_task();
         init_version();
         init_utils();
+        init_clone();
         SimpleGitApi = /*#__PURE__*/ function() {
             function SimpleGitApi(_executor) {
                 _class_call_check(this, SimpleGitApi);
@@ -5185,7 +6607,7 @@ var init_simple_git_api = __esm({
             ]);
             return SimpleGitApi;
         }();
-        Object.assign(SimpleGitApi.prototype, checkout_default(), commit_default(), config_default(), count_objects_default(), first_commit_default(), grep_default(), log_default(), show_default(), version_default());
+        Object.assign(SimpleGitApi.prototype, checkout_default(), clone_default(), commit_default(), config_default(), count_objects_default(), first_commit_default(), grep_default(), log_default(), show_default(), version_default());
     }
 });
 // src/lib/runners/scheduler.ts
@@ -5382,9 +6804,12 @@ function branchStatus(input) {
     return input ? input.charAt(0) : "";
 }
 function parseBranchSummary(stdOut) {
-    return parseStringResponse(new BranchSummaryResult(), parsers9, stdOut);
+    var currentOnly = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    return parseStringResponse(new BranchSummaryResult(), currentOnly ? [
+        currentBranchParser
+    ] : parsers9, stdOut);
 }
-var parsers9;
+var parsers9, currentBranchParser;
 var init_parse_branch = __esm({
     "src/lib/parsers/parse-branch.ts": function() {
         init_BranchSummary();
@@ -5399,6 +6824,10 @@ var init_parse_branch = __esm({
                 result.push(branchStatus(current), false, name, commit, label);
             })
         ];
+        currentBranchParser = new LineParser(RegExp("^(\\S+)$", "s"), function(result, param) {
+            var _param = _sliced_to_array(param, 1), name = _param[0];
+            result.push("*" /* CURRENT */ , false, name, "", "");
+        });
     }
 });
 // src/lib/tasks/branch.ts
@@ -5432,6 +6861,7 @@ function containsDeleteBranchCommand(commands) {
 }
 function branchTask(customArgs) {
     var isDelete = containsDeleteBranchCommand(customArgs);
+    var isCurrentOnly = customArgs.includes("--show-current");
     var commands = [
         "branch"
     ].concat(_to_consumable_array(customArgs));
@@ -5448,19 +6878,20 @@ function branchTask(customArgs) {
             if (isDelete) {
                 return parseBranchDeletions(stdOut, stdErr).all[0];
             }
-            return parseBranchSummary(stdOut);
+            return parseBranchSummary(stdOut, isCurrentOnly);
         }
     };
 }
 function branchLocalTask() {
-    var parser4 = parseBranchSummary;
     return {
         format: "utf-8",
         commands: [
             "branch",
             "-v"
         ],
-        parser: parser4
+        parser: function parser(stdOut) {
+            return parseBranchSummary(stdOut);
+        }
     };
 }
 function deleteBranchesTask(branches) {
@@ -5515,16 +6946,15 @@ var init_branch = __esm({
         init_utils();
     }
 });
-// src/lib/responses/CheckIgnore.ts
+function toPath(input) {
+    var path = input.trim().replace(/^["']|["']$/g, "");
+    return path && normalize(path);
+}
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
     "src/lib/responses/CheckIgnore.ts": function() {
         parseCheckIgnore = function(text) {
-            return text.split(/\n/g).map(function(line) {
-                return line.trim();
-            }).filter(function(file) {
-                return !!file;
-            });
+            return text.split(/\n/g).map(toPath).filter(Boolean);
         };
     }
 });
@@ -5549,41 +6979,6 @@ var init_check_ignore = __esm({
         init_CheckIgnore();
     }
 });
-// src/lib/tasks/clone.ts
-var clone_exports = {};
-__export(clone_exports, {
-    cloneMirrorTask: function() {
-        return cloneMirrorTask;
-    },
-    cloneTask: function() {
-        return cloneTask;
-    }
-});
-function disallowedCommand(command) {
-    return /^--upload-pack(=|$)/.test(command);
-}
-function cloneTask(repo, directory, customArgs) {
-    var commands = [
-        "clone"
-    ].concat(_to_consumable_array(customArgs));
-    filterString(repo) && commands.push(repo);
-    filterString(directory) && commands.push(directory);
-    var banned = commands.find(disallowedCommand);
-    if (banned) {
-        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": function() {
-        init_task();
-        init_utils();
-    }
-});
 // src/lib/parsers/parse-fetch.ts
 function parseFetchResult(stdOut, stdErr) {
     var result = {
@@ -5647,7 +7042,7 @@ __export(fetch_exports, {
         return fetchTask;
     }
 });
-function disallowedCommand2(command) {
+function disallowedCommand(command) {
     return /^--upload-pack(=|$)/.test(command);
 }
 function fetchTask(remote, branch, customArgs) {
@@ -5657,7 +7052,7 @@ function fetchTask(remote, branch, customArgs) {
     if (remote && branch) {
         commands.push(remote, branch);
     }
-    var banned = commands.find(disallowedCommand2);
+    var banned = commands.find(disallowedCommand);
     if (banned) {
         return configurationErrorTask("git.fetch: potential exploit argument blocked.");
     }
@@ -5770,7 +7165,7 @@ function parseGetRemotesVerbose(text) {
     var remotes = {};
     forEach(text, function(param) {
         var _param = _sliced_to_array(param, 3), name = _param[0], url = _param[1], purpose = _param[2];
-        if (!remotes.hasOwnProperty(name)) {
+        if (!Object.hasOwn(remotes, name)) {
             remotes[name] = {
                 name: name,
                 refs: {
@@ -5939,8 +7334,8 @@ var init_sub_module = __esm({
 });
 // src/lib/responses/TagList.ts
 function singleSorted(a, b) {
-    var aIsNum = isNaN(a);
-    var bIsNum = isNaN(b);
+    var aIsNum = Number.isNaN(a);
+    var bIsNum = Number.isNaN(b);
     if (aIsNum !== bIsNum) {
         return aIsNum ? 1 : -1;
     }
@@ -6063,25 +7458,24 @@ var require_git = __commonJS({
         var _ref = (init_git_executor(), __toCommonJS(git_executor_exports)), GitExecutor2 = _ref.GitExecutor;
         var _ref1 = (init_simple_git_api(), __toCommonJS(simple_git_api_exports)), SimpleGitApi2 = _ref1.SimpleGitApi;
         var _ref2 = (init_scheduler(), __toCommonJS(scheduler_exports)), Scheduler2 = _ref2.Scheduler;
-        var _ref3 = (init_task(), __toCommonJS(task_exports)), configurationErrorTask2 = _ref3.configurationErrorTask;
+        var _ref3 = (init_task(), __toCommonJS(task_exports)), adhocExecTask2 = _ref3.adhocExecTask, configurationErrorTask2 = _ref3.configurationErrorTask;
         var _ref4 = (init_utils(), __toCommonJS(utils_exports)), asArray2 = _ref4.asArray, filterArray2 = _ref4.filterArray, filterPrimitives2 = _ref4.filterPrimitives, filterString2 = _ref4.filterString, filterStringOrStringArray2 = _ref4.filterStringOrStringArray, filterType2 = _ref4.filterType, getTrailingOptions2 = _ref4.getTrailingOptions, trailingFunctionArgument2 = _ref4.trailingFunctionArgument, trailingOptionsArgument2 = _ref4.trailingOptionsArgument;
         var _ref5 = (init_apply_patch(), __toCommonJS(apply_patch_exports)), applyPatchTask2 = _ref5.applyPatchTask;
         var _ref6 = (init_branch(), __toCommonJS(branch_exports)), branchTask2 = _ref6.branchTask, branchLocalTask2 = _ref6.branchLocalTask, deleteBranchesTask2 = _ref6.deleteBranchesTask, deleteBranchTask2 = _ref6.deleteBranchTask;
         var _ref7 = (init_check_ignore(), __toCommonJS(check_ignore_exports)), checkIgnoreTask2 = _ref7.checkIgnoreTask;
         var _ref8 = (init_check_is_repo(), __toCommonJS(check_is_repo_exports)), checkIsRepoTask2 = _ref8.checkIsRepoTask;
-        var _ref9 = (init_clone(), __toCommonJS(clone_exports)), cloneTask2 = _ref9.cloneTask, cloneMirrorTask2 = _ref9.cloneMirrorTask;
-        var _ref10 = (init_clean(), __toCommonJS(clean_exports)), cleanWithOptionsTask2 = _ref10.cleanWithOptionsTask, isCleanOptionsArray2 = _ref10.isCleanOptionsArray;
-        var _ref11 = (init_diff(), __toCommonJS(diff_exports)), diffSummaryTask2 = _ref11.diffSummaryTask;
-        var _ref12 = (init_fetch(), __toCommonJS(fetch_exports)), fetchTask2 = _ref12.fetchTask;
-        var _ref13 = (init_move(), __toCommonJS(move_exports)), moveTask2 = _ref13.moveTask;
-        var _ref14 = (init_pull(), __toCommonJS(pull_exports)), pullTask2 = _ref14.pullTask;
-        var _ref15 = (init_push(), __toCommonJS(push_exports)), pushTagsTask2 = _ref15.pushTagsTask;
-        var _ref16 = (init_remote(), __toCommonJS(remote_exports)), addRemoteTask2 = _ref16.addRemoteTask, getRemotesTask2 = _ref16.getRemotesTask, listRemotesTask2 = _ref16.listRemotesTask, remoteTask2 = _ref16.remoteTask, removeRemoteTask2 = _ref16.removeRemoteTask;
-        var _ref17 = (init_reset(), __toCommonJS(reset_exports)), getResetMode2 = _ref17.getResetMode, resetTask2 = _ref17.resetTask;
-        var _ref18 = (init_stash_list(), __toCommonJS(stash_list_exports)), stashListTask2 = _ref18.stashListTask;
-        var _ref19 = (init_sub_module(), __toCommonJS(sub_module_exports)), addSubModuleTask2 = _ref19.addSubModuleTask, initSubModuleTask2 = _ref19.initSubModuleTask, subModuleTask2 = _ref19.subModuleTask, updateSubModuleTask2 = _ref19.updateSubModuleTask;
-        var _ref20 = (init_tag(), __toCommonJS(tag_exports)), addAnnotatedTagTask2 = _ref20.addAnnotatedTagTask, addTagTask2 = _ref20.addTagTask, tagListTask2 = _ref20.tagListTask;
-        var _ref21 = (init_task(), __toCommonJS(task_exports)), straightThroughBufferTask2 = _ref21.straightThroughBufferTask, straightThroughStringTask2 = _ref21.straightThroughStringTask;
+        var _ref9 = (init_clean(), __toCommonJS(clean_exports)), cleanWithOptionsTask2 = _ref9.cleanWithOptionsTask, isCleanOptionsArray2 = _ref9.isCleanOptionsArray;
+        var _ref10 = (init_diff(), __toCommonJS(diff_exports)), diffSummaryTask2 = _ref10.diffSummaryTask;
+        var _ref11 = (init_fetch(), __toCommonJS(fetch_exports)), fetchTask2 = _ref11.fetchTask;
+        var _ref12 = (init_move(), __toCommonJS(move_exports)), moveTask2 = _ref12.moveTask;
+        var _ref13 = (init_pull(), __toCommonJS(pull_exports)), pullTask2 = _ref13.pullTask;
+        var _ref14 = (init_push(), __toCommonJS(push_exports)), pushTagsTask2 = _ref14.pushTagsTask;
+        var _ref15 = (init_remote(), __toCommonJS(remote_exports)), addRemoteTask2 = _ref15.addRemoteTask, getRemotesTask2 = _ref15.getRemotesTask, listRemotesTask2 = _ref15.listRemotesTask, remoteTask2 = _ref15.remoteTask, removeRemoteTask2 = _ref15.removeRemoteTask;
+        var _ref16 = (init_reset(), __toCommonJS(reset_exports)), getResetMode2 = _ref16.getResetMode, resetTask2 = _ref16.resetTask;
+        var _ref17 = (init_stash_list(), __toCommonJS(stash_list_exports)), stashListTask2 = _ref17.stashListTask;
+        var _ref18 = (init_sub_module(), __toCommonJS(sub_module_exports)), addSubModuleTask2 = _ref18.addSubModuleTask, initSubModuleTask2 = _ref18.initSubModuleTask, subModuleTask2 = _ref18.subModuleTask, updateSubModuleTask2 = _ref18.updateSubModuleTask;
+        var _ref19 = (init_tag(), __toCommonJS(tag_exports)), addAnnotatedTagTask2 = _ref19.addAnnotatedTagTask, addTagTask2 = _ref19.addTagTask, tagListTask2 = _ref19.tagListTask;
+        var _ref20 = (init_task(), __toCommonJS(task_exports)), straightThroughBufferTask2 = _ref20.straightThroughBufferTask, straightThroughStringTask2 = _ref20.straightThroughStringTask;
         function Git2(options, plugins) {
             this._plugins = plugins;
             this._executor = new GitExecutor2(options.baseDir, new Scheduler2(options.maxConcurrentProcesses), plugins);
@@ -6103,24 +7497,6 @@ var require_git = __commonJS({
         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.".concat(api, "() requires a string 'repoPath'"));
-            }
-            return task(repoPath, filterType2(localPath, filterString2), getTrailingOptions2(arguments));
-        }
-        Git2.prototype.clone = function() {
-            return this._runTask(createCloneTask.apply(void 0, [
-                "clone",
-                cloneTask2
-            ].concat(Array.prototype.slice.call(arguments))), trailingFunctionArgument2(arguments));
-        };
-        Git2.prototype.mirror = function() {
-            return this._runTask(createCloneTask.apply(void 0, [
-                "mirror",
-                cloneMirrorTask2
-            ].concat(Array.prototype.slice.call(arguments))), trailingFunctionArgument2(arguments));
-        };
         Git2.prototype.mv = function(from, to) {
             return this._runTask(moveTask2(from, to), trailingFunctionArgument2(arguments));
         };
@@ -6139,8 +7515,9 @@ var require_git = __commonJS({
             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;
+            return this._runTask(adhocExecTask2(function() {
+                return console.warn("simple-git deprecation notice: git.silent: logging should be configured using the `debug` library / `DEBUG` environment variable, this method will be removed.");
+            }));
         };
         Git2.prototype.tags = function(options, then) {
             return this._runTask(tagListTask2(getTrailingOptions2(arguments)), trailingFunctionArgument2(arguments));
@@ -6316,7 +7693,9 @@ var require_git = __commonJS({
             return this._runTask(task);
         };
         Git2.prototype.clearQueue = function() {
-            return this;
+            return this._runTask(adhocExecTask2(function() {
+                return console.warn("simple-git deprecation notice: clearQueue() is deprecated and will be removed, switch to using the abortPlugin instead.");
+            }));
         };
         Git2.prototype.checkIgnore = function(pathnames, then) {
             return this._runTask(checkIgnoreTask2(asArray2(filterType2(pathnames, filterStringOrStringArray2, []))), trailingFunctionArgument2(arguments));
@@ -6327,8 +7706,6 @@ var require_git = __commonJS({
         module.exports = Git2;
     }
 });
-// src/lib/api.ts
-init_pathspec();
 // src/lib/errors/git-construct-error.ts
 init_git_error();
 var GitConstructError = /*#__PURE__*/ function(GitError) {
@@ -6400,40 +7777,34 @@ function abortPlugin(signal) {
         onSpawnAfter
     ];
 }
-// src/lib/plugins/block-unsafe-operations-plugin.ts
-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() {
-    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_allowUnsafeProtocolOverride = _ref.allowUnsafeProtocolOverride, allowUnsafeProtocolOverride = _ref_allowUnsafeProtocolOverride === void 0 ? false : _ref_allowUnsafeProtocolOverride, _ref_allowUnsafePack = _ref.allowUnsafePack, allowUnsafePack = _ref_allowUnsafePack === void 0 ? false : _ref_allowUnsafePack;
+    var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
     return {
         type: "spawn.args",
-        action: function action(args, context) {
-            args.forEach(function(current, index) {
-                var next = index < args.length ? args[index + 1] : "";
-                allowUnsafeProtocolOverride || preventProtocolOverride(current, next);
-                allowUnsafePack || preventUploadPack(current, context.method);
-            });
+        action: function action(args, param) {
+            var env = param.env;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = ne(args, env)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var vulnerability = _step.value;
+                    if (options[vulnerability.category] !== true) {
+                        throw new GitPluginError(void 0, "unsafe", vulnerability.message);
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
             return args;
         }
     };
@@ -6567,7 +7938,7 @@ 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);
+    return !arg || !/^([a-z]:)?([a-z0-9/.\\_~-]+)$/i.test(arg);
 }
 function toBinaryConfig(input, allowUnsafe) {
     if (input.length < 1 || input.length > 2) {
@@ -6821,8 +8192,6 @@ function timeoutPlugin(param) {
         };
     }
 }
-// src/lib/plugins/suffix-paths.plugin.ts
-init_pathspec();
 function suffixPathsPlugin() {
     return {
         type: "spawn.args",
@@ -6835,13 +8204,13 @@ function suffixPathsPlugin() {
             }
             for(var i = 0; i < data.length; i++){
                 var param = data[i];
-                if (isPathSpec(param)) {
-                    append2(toPaths(param));
+                if (r(param)) {
+                    append2(o(param));
                     continue;
                 }
                 if (param === "--") {
                     append2(data.slice(i + 1).flatMap(function(item) {
-                        return isPathSpec(item) && toPaths(item) || item;
+                        return r(item) && o(item) || item;
                     }));
                     break;
                 }
@@ -6869,12 +8238,12 @@ function gitInstanceFactory(baseDir, options) {
         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(suffixPathsPlugin());
     plugins.add(errorDetectionPlugin(errorDetectionHandler(true)));
     config.errors && plugins.add(errorDetectionPlugin(config.errors));
     customBinaryPlugin(plugins, config.binary, (_config_unsafe = config.unsafe) === null || _config_unsafe === void 0 ? void 0 : _config_unsafe.allowUnsafeCustomBinary);