@organizaone/o1-code 0.9.0 → 0.10.4

package/chunks/dist-ID6B4BSH.js

@@ -0,0 +1,3901 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  require_src
+} from "./chunk-XYMF3VVC.js";
+import "./chunk-WPZM4XOT.js";
+import "./chunk-HXBE3LWB.js";
+import {
+  init_esbuild_shims
+} from "./chunk-S2467S6L.js";
+import {
+  __commonJS,
+  __name,
+  __require,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// node_modules/@kwsites/file-exists/dist/src/index.js
+var require_src2 = __commonJS({
+  "node_modules/@kwsites/file-exists/dist/src/index.js"(exports) {
+    "use strict";
+    init_esbuild_shims();
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var fs_1 = __require("fs");
+    var debug_1 = __importDefault(require_src());
+    var log = debug_1.default("@kwsites/file-exists");
+    function check(path, isFile, isDirectory) {
+      log(`checking %s`, path);
+      try {
+        const stat = fs_1.statSync(path);
+        if (stat.isFile() && isFile) {
+          log(`[OK] path represents a file`);
+          return true;
+        }
+        if (stat.isDirectory() && isDirectory) {
+          log(`[OK] path represents a directory`);
+          return true;
+        }
+        log(`[FAIL] path represents something other than a file or directory`);
+        return false;
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          log(`[FAIL] path is not accessible: %o`, e);
+          return false;
+        }
+        log(`[FATAL] %o`, e);
+        throw e;
+      }
+    }
+    __name(check, "check");
+    function exists(path, type = exports.READABLE) {
+      return check(path, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    }
+    __name(exists, "exists");
+    exports.exists = exists;
+    exports.FILE = 1;
+    exports.FOLDER = 2;
+    exports.READABLE = exports.FILE + exports.FOLDER;
+  }
+});
+
+// node_modules/@kwsites/file-exists/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/@kwsites/file-exists/dist/index.js"(exports) {
+    "use strict";
+    init_esbuild_shims();
+    function __export(m2) {
+      for (var p2 in m2) if (!exports.hasOwnProperty(p2)) exports[p2] = m2[p2];
+    }
+    __name(__export, "__export");
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __export(require_src2());
+  }
+});
+
+// node_modules/@kwsites/promise-deferred/dist/index.js
+var require_dist2 = __commonJS({
+  "node_modules/@kwsites/promise-deferred/dist/index.js"(exports) {
+    "use strict";
+    init_esbuild_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createDeferred = exports.deferred = void 0;
+    function deferred() {
+      let done;
+      let fail;
+      let status = "pending";
+      const promise = new Promise((_done, _fail) => {
+        done = _done;
+        fail = _fail;
+      });
+      return {
+        promise,
+        done(result) {
+          if (status === "pending") {
+            status = "resolved";
+            done(result);
+          }
+        },
+        fail(error) {
+          if (status === "pending") {
+            status = "rejected";
+            fail(error);
+          }
+        },
+        get fulfilled() {
+          return status !== "pending";
+        },
+        get status() {
+          return status;
+        }
+      };
+    }
+    __name(deferred, "deferred");
+    exports.deferred = deferred;
+    exports.createDeferred = deferred;
+    exports.default = deferred;
+  }
+});
+
+// node_modules/simple-git/dist/index.mjs
+init_esbuild_shims();
+
+// node_modules/@simple-git/args-pathspec/dist/index.mjs
+init_esbuild_shims();
+var t = /* @__PURE__ */ new WeakMap();
+function c(...n) {
+  const e = new String(n);
+  return t.set(e, n), e;
+}
+__name(c, "c");
+function r(n) {
+  return n instanceof String && t.has(n);
+}
+__name(r, "r");
+function o(n) {
+  return t.get(n) ?? [];
+}
+__name(o, "o");
+
+// node_modules/simple-git/dist/index.mjs
+var import_file_exists = __toESM(require_dist(), 1);
+var import_debug = __toESM(require_src(), 1);
+var import_promise_deferred = __toESM(require_dist2(), 1);
+import { spawn as ve } from "node:child_process";
+import { normalize as Se } from "node:path";
+
+// node_modules/@simple-git/argv-parser/dist/index.mjs
+init_esbuild_shims();
+function* x(e, n) {
+  const t2 = n === "global";
+  for (const o2 of e)
+    o2.isGlobal === t2 && (yield o2);
+}
+__name(x, "x");
+var P = /* @__PURE__ */ new Set([
+  "--add",
+  "--edit",
+  "--remove-section",
+  "--rename-section",
+  "--replace-all",
+  "--unset",
+  "--unset-all",
+  "-e"
+]);
+var S = /* @__PURE__ */ new Set([
+  "--get",
+  "--get-all",
+  "--get-color",
+  "--get-colorbool",
+  "--get-regexp",
+  "--get-urlmatch",
+  "--list",
+  "-l"
+]);
+var E = /* @__PURE__ */ new Set([
+  "edit",
+  "remove-section",
+  "rename-section",
+  "set",
+  "unset"
+]);
+var F = /* @__PURE__ */ new Set(["get", "get-color", "get-colorbool", "list"]);
+function A(e, n) {
+  for (const { name: o2 } of x(e, "task")) {
+    if (P.has(o2))
+      return w(true, n);
+    if (S.has(o2))
+      return w(false, n);
+  }
+  const t2 = n.at(0)?.toLowerCase();
+  return t2 === void 0 ? null : E.has(t2) ? w(true, n.slice(1)) : F.has(t2) ? w(false, n.slice(1)) : n.length === 1 ? w(false, n) : w(true, n);
+}
+__name(A, "A");
+function w(e = false, n = []) {
+  const t2 = n.at(0)?.toLowerCase();
+  return t2 === void 0 ? null : {
+    isWrite: e,
+    isRead: !e,
+    key: t2,
+    value: n.at(1)
+  };
+}
+__name(w, "w");
+function O(e, n) {
+  return n.isWrite && n.value !== void 0 ? { key: n.key, value: n.value, scope: e } : { key: n.key, scope: e };
+}
+__name(O, "O");
+function G(e) {
+  const n = e?.indexOf("=") || -1;
+  return !e || n < 0 ? null : {
+    key: e.slice(0, n).trim().toLowerCase(),
+    value: e.slice(n + 1)
+  };
+}
+__name(G, "G");
+function M(e) {
+  for (const { name: n } of x(e, "task"))
+    switch (n) {
+      case "--global":
+        return "global";
+      case "--system":
+        return "system";
+      case "--worktree":
+        return "worktree";
+      case "--local":
+        return "local";
+      case "--file":
+      case "-f":
+        return "file";
+    }
+  return "local";
+}
+__name(M, "M");
+function N({ name: e }) {
+  if (e === "-c" || e === "--config")
+    return "inline";
+  if (e === "--config-env")
+    return "env";
+}
+__name(N, "N");
+function* $(e) {
+  for (const n of e) {
+    const t2 = N(n), o2 = t2 && G(n.value);
+    o2 && (yield {
+      ...o2,
+      scope: t2
+    });
+  }
+}
+__name($, "$");
+function D(e, n, t2) {
+  const o2 = {
+    read: [],
+    write: [...$(n)]
+  };
+  return e === "config" && L(
+    o2,
+    M(n),
+    A(n, t2)
+  ), o2;
+}
+__name(D, "D");
+function L(e, n, t2) {
+  if (t2 === null)
+    return;
+  const o2 = O(n, t2);
+  t2.isWrite ? e.write.push(o2) : e.read.push(o2);
+}
+__name(L, "L");
+var C = {
+  short: /* @__PURE__ */ new Map([
+    ["c", true]
+    //  -c <k=v>    set config key for this invocation
+  ])
+};
+var I = {
+  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],
+    // -v          version
+    ...C.short.entries()
+  ]),
+  long: /* @__PURE__ */ new Set([
+    "attr-source",
+    "config-env",
+    "exec-path",
+    "git-dir",
+    "list-cmds",
+    "namespace",
+    "super-prefix",
+    "work-tree"
+  ])
+};
+var 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]
+      // -u <upload-pack>
+    ]),
+    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]
+      // -t <template>
+    ]),
+    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]
+      // -l  list
+    ]),
+    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"])
+  },
+  rebase: {
+    short: /* @__PURE__ */ new Map([
+      ["X", true],
+      // -X <option>   strategy option
+      ["f", false],
+      // -f force-rebase
+      ["i", false],
+      // -i interactive
+      ["k", false],
+      // -k keep-base
+      ["m", false],
+      // -m merge
+      ["n", false],
+      // -n no-stat
+      ["q", false],
+      // -q quiet
+      ["r", false],
+      // -r rebase-merges
+      ["s", true],
+      // -s <strategy>
+      ["v", false],
+      // -v verbose
+      ["x", true]
+      // -x <cmd>      exec
+    ]),
+    long: /* @__PURE__ */ new Set(["exec", "onto", "strategy", "strategy-option"])
+  }
+};
+var T = { short: /* @__PURE__ */ new Map(), long: /* @__PURE__ */ new Set() };
+function B(e) {
+  const n = R[e ?? ""] ?? T;
+  return {
+    short: new Map([...C.short.entries(), ...n.short.entries()]),
+    long: n.long
+  };
+}
+__name(B, "B");
+function b(e, n = I) {
+  if (e.startsWith("--")) {
+    const t2 = e.indexOf("=");
+    if (t2 > 2)
+      return [{ name: e.slice(0, t2), value: e.slice(t2 + 1), needsNext: false }];
+    const o2 = e.slice(2);
+    return [{ name: e, needsNext: n.long.has(o2) }];
+  }
+  if (e.length === 2) {
+    const t2 = e.charAt(1), o2 = n.short.get(t2);
+    return [{ name: e, needsNext: o2 === true }];
+  }
+  return j(e, n.short);
+}
+__name(b, "b");
+function j(e, n) {
+  const t2 = e.slice(1).split(""), o2 = [];
+  for (let a = 0; a < t2.length; a++) {
+    const s = t2[a], r2 = n.get(s);
+    if (r2 === void 0)
+      return [{ name: e, needsNext: false }];
+    if (r2) {
+      const i = t2.slice(a + 1).join("");
+      if (i && ![...i].every((m2) => n.has(m2)))
+        return o2.push({ name: `-${s}`, value: i, needsNext: false }), o2;
+    }
+    o2.push({ name: `-${s}`, needsNext: r2 });
+  }
+  return o2;
+}
+__name(j, "j");
+function W(e, n = []) {
+  let t2 = 0;
+  for (; t2 < e.length; ) {
+    const o2 = String(e[t2]);
+    if (!o2.startsWith("-") || o2.length < 2) break;
+    const a = b(o2);
+    let s = t2 + 1;
+    for (const r2 of a) {
+      const i = {
+        name: r2.name,
+        value: r2.value,
+        absorbedNext: false,
+        isGlobal: true
+      };
+      r2.needsNext && i.value === void 0 && s < e.length && (i.value = String(e[s]), i.absorbedNext = true, s++), n.push(i);
+    }
+    t2 = s;
+  }
+  return { flags: n, taskIndex: t2 };
+}
+__name(W, "W");
+function V(e, n, t2 = []) {
+  const o2 = B(n), a = [], s = [];
+  let r2 = 0;
+  for (; r2 < e.length; ) {
+    const i = e[r2];
+    if (r(i)) {
+      s.push(...o(i)), r2++;
+      continue;
+    }
+    const p2 = String(i);
+    if (p2 === "--") {
+      for (let d2 = r2 + 1; d2 < e.length; d2++) {
+        const g2 = e[d2];
+        r(g2) ? s.push(...o(g2)) : s.push(String(g2));
+      }
+      break;
+    }
+    if (!p2.startsWith("-") || p2.length < 2) {
+      a.push(p2), r2++;
+      continue;
+    }
+    const m2 = b(p2, o2);
+    let u2 = r2 + 1;
+    for (const d2 of m2) {
+      const g2 = {
+        name: d2.name,
+        value: d2.value,
+        absorbedNext: false,
+        isGlobal: false
+      };
+      d2.needsNext && g2.value === void 0 && u2 < e.length && !r(e[u2]) && (g2.value = String(e[u2]), g2.absorbedNext = true, u2++), t2.push(g2);
+    }
+    r2 = u2;
+  }
+  return { flags: t2, positionals: a, pathspecs: s };
+}
+__name(V, "V");
+function* q({
+  write: e
+}) {
+  for (const n of e)
+    for (const t2 of K) {
+      const o2 = t2(n.key);
+      o2 && (yield o2);
+    }
+}
+__name(q, "q");
+function f(e, n, t2 = String(e)) {
+  const o2 = typeof e == "string" ? new RegExp(`\\s*${e.toLowerCase()}`) : e;
+  return function(s) {
+    if (o2.test(s))
+      return {
+        category: n,
+        message: `Configuring ${t2} is not permitted without enabling ${n}`
+      };
+  };
+}
+__name(f, "f");
+function l(e, n) {
+  const t2 = new RegExp(`\\s*${e.toLowerCase().replace(/\./g, "(..+)?.")}`);
+  return f(t2, n, e);
+}
+__name(l, "l");
+var K = [
+  f("alias", "allowUnsafeAlias"),
+  f("core.askPass", "allowUnsafeAskPass"),
+  f("core.editor", "allowUnsafeEditor"),
+  f("core.fsmonitor", "allowUnsafeFsMonitor"),
+  f("core.gitProxy", "allowUnsafeGitProxy"),
+  f("core.hooksPath", "allowUnsafeHooksPath"),
+  f("core.pager", "allowUnsafePager"),
+  f("core.sshCommand", "allowUnsafeSshCommand"),
+  l("credential.helper", "allowUnsafeCredentialHelper"),
+  l("diff.command", "allowUnsafeDiffExternal"),
+  f("diff.external", "allowUnsafeDiffExternal"),
+  l("difftool.cmd", "allowUnsafeDiffExternal"),
+  l("diff.textconv", "allowUnsafeDiffTextConv"),
+  l("filter.clean", "allowUnsafeFilter"),
+  l("filter.process", "allowUnsafeFilter"),
+  l("filter.smudge", "allowUnsafeFilter"),
+  l("gpg.program", "allowUnsafeGpgProgram"),
+  f("include.path", "allowUnsafeInclude"),
+  l("includeIf", "allowUnsafeInclude"),
+  f("init.templateDir", "allowUnsafeTemplateDir"),
+  l("pager.", "allowUnsafePager"),
+  l("merge.driver", "allowUnsafeMergeDriver"),
+  l("mergetool.path", "allowUnsafeMergeDriver"),
+  l("mergetool.cmd", "allowUnsafeMergeDriver"),
+  l("protocol.allow", "allowUnsafeProtocolOverride"),
+  l("remote.receivepack", "allowUnsafePack"),
+  l("remote.uploadpack", "allowUnsafePack"),
+  f("uploadpack.packObjectsHook", "allowUnsafePack"),
+  f("sequence.editor", "allowUnsafeEditor"),
+  l("submodule.update", "allowUnsafeSubmodule"),
+  l("tar.command", "allowUnsafeCommandBinaries"),
+  l("trailer.cmd", "allowUnsafeCommandBinaries"),
+  l("trailer.command", "allowUnsafeCommandBinaries"),
+  l("url.insteadOf", "allowUnsafeUrlRewrite")
+];
+function* H(e, n) {
+  for (const t2 of n)
+    for (const o2 of X) {
+      const a = o2(e, t2);
+      a && (yield a);
+    }
+}
+__name(H, "H");
+function c2(e, n, t2, { name: o2 = String(n), globalOnly: a = false, withValue: s = false } = {}) {
+  const r2 = typeof n == "string" ? new RegExp(`\\s*${n.toLowerCase()}`) : n, i = `Use of ${e ? `${e} with option ` : ""}${o2} is not permitted without enabling ${t2}`;
+  return function(m2, u2) {
+    if (!(e && m2 !== e) && !(a && !u2.isGlobal) && !(s && u2.value === void 0) && r2.test(u2.name))
+      return {
+        category: t2,
+        message: i
+      };
+  };
+}
+__name(c2, "c");
+var h = { globalOnly: true, withValue: true };
+var X = [
+  c2(null, /--(upload|receive)-pack/, "allowUnsafePack", {
+    name: "--upload-pack or --receive-pack"
+  }),
+  c2("clone", /^-\w*u/, "allowUnsafePack"),
+  c2("clone", "--u", "allowUnsafePack"),
+  c2("push", /^--exec$/, "allowUnsafePack", { name: "--exec" }),
+  // `git` accepts unambiguous abbreviations of long options, so `--ex` and `--exe` are `--exec`
+  c2("rebase", /^(-x|--ex(ec?)?)$/, "allowUnsafeExec", { name: "-x or --exec" }),
+  c2(null, "--template", "allowUnsafeTemplateDir"),
+  c2(null, "--exec-path", "allowUnsafeExec", h),
+  // `git` reads the configuration of whichever repository these name, so the
+  // directory alone is enough to deliver config the argv guards never see
+  c2(null, "--git-dir", "allowUnsafeConfigPaths", h),
+  c2(null, "--work-tree", "allowUnsafeConfigPaths", h),
+  c2(null, /^-C$/, "allowUnsafeConfigPaths", { ...h, name: "-C" })
+];
+function k(e, n, t2) {
+  return [...H(e, n), ...q(t2)];
+}
+__name(k, "k");
+function Y(...e) {
+  const { flags: n, taskIndex: t2 } = W(e), o2 = t2 < e.length ? String(e[t2]).toLowerCase() : null, a = o2 !== null ? e.slice(t2 + 1) : [], { positionals: s, pathspecs: r2 } = V(a, o2, n), i = D(o2, n, s);
+  return {
+    task: o2,
+    flags: n.map(J),
+    paths: r2,
+    config: i,
+    vulnerabilities: z(k(o2, n, i))
+  };
+}
+__name(Y, "Y");
+function z(e) {
+  return Object.defineProperty(e, "vulnerabilities", {
+    value: e
+  });
+}
+__name(z, "z");
+function J({ value: e, name: n }) {
+  return e !== void 0 ? { name: n, value: e } : { name: n };
+}
+__name(J, "J");
+var y = {
+  editor: "allowUnsafeEditor",
+  git_askpass: "allowUnsafeAskPass",
+  git_config_global: "allowUnsafeConfigPaths",
+  git_config_system: "allowUnsafeConfigPaths",
+  git_config_count: "allowUnsafeConfigEnvCount",
+  git_config_parameters: "allowUnsafeConfigEnvCount",
+  git_config: "allowUnsafeConfigPaths",
+  git_editor: "allowUnsafeEditor",
+  git_exec_path: "allowUnsafeExec",
+  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",
+  visual: "allowUnsafeEditor"
+};
+function* Q(e) {
+  const n = parseInt(e.git_config_count ?? "0", 10);
+  for (let t2 = 0; t2 < n; t2++) {
+    const o2 = e[`git_config_key_${t2}`], a = e[`git_config_value_${t2}`];
+    o2 !== void 0 && (yield { key: o2.toLowerCase().trim(), value: a, scope: "env" });
+  }
+}
+__name(Q, "Q");
+function* Z(e) {
+  for (const n of Object.keys(e))
+    if (_(n)) {
+      const t2 = y[n];
+      yield {
+        category: t2,
+        message: `Use of "${n.toUpperCase()}" is not permitted without enabling ${t2}`
+      };
+    }
+}
+__name(Z, "Z");
+function _(e) {
+  return Object.hasOwn(y, e);
+}
+__name(_, "_");
+function ee(e) {
+  const n = {};
+  for (const [t2, o2] of Object.entries(e)) {
+    const a = t2.toLowerCase().trim();
+    (_(a) || a.startsWith("git")) && (n[a] = String(o2));
+  }
+  return n;
+}
+__name(ee, "ee");
+function ne(e) {
+  const n = ee(e), t2 = {
+    read: [],
+    write: [...Q(n)]
+  }, o2 = [
+    ...Z(n),
+    ...k(null, [], t2)
+  ];
+  return {
+    config: t2,
+    vulnerabilities: o2
+  };
+}
+__name(ne, "ne");
+function oe(e, n) {
+  return [...Y(...e).vulnerabilities, ...ne(n).vulnerabilities];
+}
+__name(oe, "oe");
+
+// node_modules/simple-git/dist/index.mjs
+import { EventEmitter as Ce } from "node:events";
+var O2 = class extends Error {
+  static {
+    __name(this, "O");
+  }
+  constructor(e, n) {
+    super(n), this.task = e, Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var Ae = class extends O2 {
+  static {
+    __name(this, "Ae");
+  }
+  constructor(e, n) {
+    super(void 0, n), this.config = e;
+  }
+};
+var A2 = class extends O2 {
+  static {
+    __name(this, "A");
+  }
+  constructor(e, n, r2) {
+    super(e, r2), this.task = e, this.plugin = n, Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var at = class extends O2 {
+  static {
+    __name(this, "at");
+  }
+  constructor(e, n) {
+    super(void 0, n || String(e)), this.git = e;
+  }
+};
+var xe = class extends O2 {
+  static {
+    __name(this, "xe");
+  }
+  constructor(e) {
+    super(void 0, e);
+  }
+};
+var I2 = "\0";
+var W2 = /* @__PURE__ */ __name(() => {
+}, "W");
+function Ne(t2) {
+  return typeof t2 != "function" ? W2 : t2;
+}
+__name(Ne, "Ne");
+function $e(t2) {
+  return typeof t2 == "function" && t2 !== W2;
+}
+__name($e, "$e");
+function Pe(t2, e) {
+  const n = t2.indexOf(e);
+  return n <= 0 ? [t2, ""] : [t2.substr(0, n), t2.substr(n + 1)];
+}
+__name(Pe, "Pe");
+function Me(t2, e = 0) {
+  return Dt(t2) && t2.length > e ? t2[e] : void 0;
+}
+__name(Me, "Me");
+function N2(t2, e = 0) {
+  if (Dt(t2) && t2.length > e)
+    return t2[t2.length - 1 - e];
+}
+__name(N2, "N");
+function Dt(t2) {
+  return Bt(t2);
+}
+__name(Dt, "Dt");
+function H2(t2 = "", e = true, n = `
+`) {
+  return t2.split(n).reduce((r2, s) => {
+    const o2 = e ? s.trim() : s;
+    return o2 && r2.push(o2), r2;
+  }, []);
+}
+__name(H2, "H");
+function ut(t2, e) {
+  return H2(t2, true).map((n) => e(n));
+}
+__name(ut, "ut");
+function Lt(t2) {
+  return (0, import_file_exists.exists)(t2, import_file_exists.FOLDER);
+}
+__name(Lt, "Lt");
+function S2(t2, e) {
+  return Array.isArray(t2) ? t2.includes(e) || t2.push(e) : t2.add(e), e;
+}
+__name(S2, "S");
+function De(t2, e) {
+  return Array.isArray(t2) && !t2.includes(e) && t2.push(e), t2;
+}
+__name(De, "De");
+function ct(t2, e) {
+  if (Array.isArray(t2)) {
+    const n = t2.indexOf(e);
+    n >= 0 && t2.splice(n, 1);
+  } else
+    t2.delete(e);
+  return e;
+}
+__name(ct, "ct");
+var ft = Object.prototype.toString.call.bind(Object.prototype.toString);
+function v(t2) {
+  return Array.isArray(t2) ? t2 : [t2];
+}
+__name(v, "v");
+function jt(t2) {
+  return t2.replace(/[\s-]+(.)/g, (e, n) => n.toUpperCase());
+}
+__name(jt, "jt");
+function L2(t2) {
+  return v(t2).map((e) => e instanceof String ? e : String(e));
+}
+__name(L2, "L");
+function p(t2, e = 0) {
+  if (t2 == null)
+    return e;
+  const n = parseInt(t2, 10);
+  return Number.isNaN(n) ? e : n;
+}
+__name(p, "p");
+function U(t2, e) {
+  const n = [];
+  for (let r2 = 0, s = t2.length; r2 < s; r2++)
+    n.push(e, t2[r2]);
+  return n;
+}
+__name(U, "U");
+function F2(t2) {
+  return (Array.isArray(t2) ? Buffer.concat(t2) : t2).toString("utf-8");
+}
+__name(F2, "F");
+function Le(t2) {
+  return t2 ? Buffer.isBuffer(t2) ? t2.length : Buffer.byteLength(t2) : 0;
+}
+__name(Le, "Le");
+function je(t2, e) {
+  const n = {};
+  return e.forEach((r2) => {
+    t2[r2] !== void 0 && (n[r2] = t2[r2]);
+  }), n;
+}
+__name(je, "je");
+function wt(t2 = 0) {
+  return new Promise((e) => setTimeout(e, t2));
+}
+__name(wt, "wt");
+function bt(t2) {
+  if (t2 !== false)
+    return t2;
+}
+__name(bt, "bt");
+function d(t2, e, n) {
+  return e(t2) ? t2 : arguments.length > 2 ? n : void 0;
+}
+__name(d, "d");
+var K2 = /* @__PURE__ */ __name((t2) => Array.isArray(t2), "K");
+function st(t2, e) {
+  const n = r(t2) ? "string" : typeof t2;
+  return /number|string|boolean/.test(n) && (!e || !e.includes(n));
+}
+__name(st, "st");
+var m = /* @__PURE__ */ __name((t2) => typeof t2 == "string" || r(t2), "m");
+var Be = /* @__PURE__ */ __name((t2) => m(t2) || Buffer.isBuffer(t2), "Be");
+var G2 = /* @__PURE__ */ __name((t2) => m(t2) || Array.isArray(t2) && t2.every(m), "G");
+function lt(t2) {
+  return !!t2 && ft(t2) === "[object Object]";
+}
+__name(lt, "lt");
+function Ie(t2) {
+  return typeof t2 == "function";
+}
+__name(Ie, "Ie");
+var Bt = /* @__PURE__ */ __name((t2) => t2 == null || "number|boolean|function".includes(typeof t2) ? false : typeof t2.length == "number", "Bt");
+var V2 = /* @__PURE__ */ ((t2) => (t2[t2.SUCCESS = 0] = "SUCCESS", t2[t2.ERROR = 1] = "ERROR", t2[t2.NOT_FOUND = -2] = "NOT_FOUND", t2[t2.UNCLEAN = 128] = "UNCLEAN", t2))(V2 || {});
+var z2 = class _z {
+  static {
+    __name(this, "z");
+  }
+  constructor(e, n) {
+    this.stdOut = e, this.stdErr = n;
+  }
+  asStrings() {
+    return new _z(this.stdOut.toString("utf8"), this.stdErr.toString("utf8"));
+  }
+};
+function Ue() {
+  throw new Error("LineParser:useMatches not implemented");
+}
+__name(Ue, "Ue");
+var l2 = class {
+  static {
+    __name(this, "l");
+  }
+  constructor(e, n) {
+    this.matches = [], this.useMatches = Ue, this.parse = (r2, s) => (this.resetMatches(), this._regExp.every((o2, i) => this.addMatch(o2, i, r2(i))) ? this.useMatches(s, this.prepareMatches()) !== false : false), this._regExp = Array.isArray(e) ? e : [e], n && (this.useMatches = n);
+  }
+  resetMatches() {
+    this.matches.length = 0;
+  }
+  prepareMatches() {
+    return this.matches;
+  }
+  addMatch(e, n, r2) {
+    const s = r2 && e.exec(r2);
+    return s && this.pushMatch(n, s), !!s;
+  }
+  pushMatch(e, n) {
+    this.matches.push(...n.slice(1));
+  }
+};
+var x2 = class extends l2 {
+  static {
+    __name(this, "x");
+  }
+  addMatch(e, n, r2) {
+    return /^remote:\s/.test(String(r2)) && super.addMatch(e, n, r2);
+  }
+  pushMatch(e, n) {
+    (e > 0 || n.length > 1) && super.pushMatch(e, n);
+  }
+};
+var Fe = {
+  binary: "git",
+  maxConcurrentProcesses: 5,
+  config: [],
+  trimmed: false
+};
+function Ge(...t2) {
+  const e = process.cwd(), n = Object.assign(
+    { baseDir: e, ...Fe },
+    ...t2.filter((r2) => typeof r2 == "object" && r2)
+  );
+  return n.baseDir = n.baseDir || e, n.trimmed = n.trimmed === true, n;
+}
+__name(Ge, "Ge");
+function It(t2, e = []) {
+  return lt(t2) ? Object.keys(t2).reduce((n, r2) => {
+    const s = t2[r2];
+    if (r(s))
+      n.push(s);
+    else if (st(s, ["boolean"]))
+      n.push(r2 + "=" + s);
+    else if (Array.isArray(s))
+      for (const o2 of s)
+        st(o2, ["string", "number"]) || n.push(r2 + "=" + o2);
+    else
+      n.push(r2);
+    return n;
+  }, e) : e;
+}
+__name(It, "It");
+function h2(t2, e = 0, n = false) {
+  const r2 = [];
+  for (let s = 0, o2 = e < 0 ? t2.length : e; s < o2; s++)
+    "string|number".includes(typeof t2[s]) && r2.push(String(t2[s]));
+  return It(ht(t2), r2), n || r2.push(...ze(t2)), r2;
+}
+__name(h2, "h");
+function ze(t2) {
+  const e = typeof N2(t2) == "function";
+  return L2(d(N2(t2, e ? 1 : 0), K2, []));
+}
+__name(ze, "ze");
+function ht(t2) {
+  const e = Ie(N2(t2));
+  return d(N2(t2, e ? 1 : 0), lt);
+}
+__name(ht, "ht");
+function u(t2, e = true) {
+  const n = Ne(N2(t2));
+  return e || $e(n) ? n : void 0;
+}
+__name(u, "u");
+function Tt(t2, e) {
+  return t2(e.stdOut, e.stdErr);
+}
+__name(Tt, "Tt");
+function E2(t2, e, n, r2 = true) {
+  return v(n).forEach((s) => {
+    for (let o2 = H2(s, r2), i = 0, a = o2.length; i < a; i++) {
+      const c3 = /* @__PURE__ */ __name((y2 = 0) => {
+        if (!(i + y2 >= a))
+          return o2[i + y2];
+      }, "c");
+      e.some(({ parse: y2 }) => y2(c3, t2));
+    }
+  }), t2;
+}
+__name(E2, "E");
+var qe = /* @__PURE__ */ ((t2) => (t2.BARE = "bare", t2.IN_TREE = "tree", t2.IS_REPO_ROOT = "root", t2))(qe || {});
+var mt = /* @__PURE__ */ __name(({ exitCode: t2 }, e, n, r2) => {
+  if (t2 === V2.UNCLEAN && Ve(e))
+    return n(Buffer.from("false"));
+  r2(e);
+}, "mt");
+var Ut = /* @__PURE__ */ __name((t2) => t2.trim() === "true", "Ut");
+function We(t2) {
+  switch (t2) {
+    case "bare":
+      return Ke();
+    case "root":
+      return He();
+  }
+  return {
+    commands: ["rev-parse", "--is-inside-work-tree"],
+    format: "utf-8",
+    onError: mt,
+    parser: Ut
+  };
+}
+__name(We, "We");
+function He() {
+  return {
+    commands: ["rev-parse", "--git-dir"],
+    format: "utf-8",
+    onError: mt,
+    parser(e) {
+      return /^\.(git)?$/.test(e.trim());
+    }
+  };
+}
+__name(He, "He");
+function Ke() {
+  return {
+    commands: ["rev-parse", "--is-bare-repository"],
+    format: "utf-8",
+    onError: mt,
+    parser: Ut
+  };
+}
+__name(Ke, "Ke");
+function Ve(t2) {
+  return /(Not a git repository|Kein Git-Repository)/i.test(String(t2));
+}
+__name(Ve, "Ve");
+var Xe = class {
+  static {
+    __name(this, "Xe");
+  }
+  constructor(e) {
+    this.paths = [], this.files = [], this.folders = [], this.dryRun = e;
+  }
+};
+var Ye = /^[a-z]+\s*/i;
+var Qe = /^[a-z]+\s+[a-z]+\s*/i;
+var Je = /\/$/;
+function Ze(t2, e) {
+  const n = new Xe(t2), r2 = t2 ? Qe : Ye;
+  return H2(e).forEach((s) => {
+    const o2 = s.replace(r2, "");
+    n.paths.push(o2), (Je.test(o2) ? n.folders : n.files).push(o2);
+  }), n;
+}
+__name(Ze, "Ze");
+var Ft = [];
+function tn(t2) {
+  return {
+    commands: Ft,
+    format: "empty",
+    parser: t2
+  };
+}
+__name(tn, "tn");
+function b2(t2) {
+  return {
+    commands: Ft,
+    format: "empty",
+    parser() {
+      throw typeof t2 == "string" ? new xe(t2) : t2;
+    }
+  };
+}
+__name(b2, "b");
+function g(t2, e = false) {
+  return {
+    commands: t2,
+    format: "utf-8",
+    parser(n) {
+      return e ? String(n).trim() : n;
+    }
+  };
+}
+__name(g, "g");
+function Gt(t2) {
+  return {
+    commands: t2,
+    format: "buffer",
+    parser(e) {
+      return e;
+    }
+  };
+}
+__name(Gt, "Gt");
+function en(t2) {
+  return t2.format === "buffer";
+}
+__name(en, "en");
+function kt(t2) {
+  return t2.format === "empty" || !t2.commands.length;
+}
+__name(kt, "kt");
+var nn = "Git clean interactive mode is not supported";
+var rn = 'Git clean mode parameter ("n" or "f") is required';
+var sn = "Git clean unknown option found in: ";
+var zt = /* @__PURE__ */ ((t2) => (t2.DRY_RUN = "n", t2.FORCE = "f", t2.IGNORED_INCLUDED = "x", t2.IGNORED_ONLY = "X", t2.EXCLUDING = "e", t2.QUIET = "q", t2.RECURSIVE = "d", t2))(zt || {});
+var qt = /* @__PURE__ */ new Set([
+  "i",
+  ...L2(Object.values(zt))
+]);
+function on(t2, e) {
+  const { cleanMode: n, options: r2, valid: s } = cn(t2);
+  return n ? s.options ? (r2.push(...e), r2.some(hn) ? b2(nn) : an(n, r2)) : b2(sn + JSON.stringify(t2)) : b2(rn);
+}
+__name(on, "on");
+function an(t2, e) {
+  return {
+    commands: ["clean", `-${t2}`, ...e],
+    format: "utf-8",
+    parser(r2) {
+      return Ze(t2 === "n", r2);
+    }
+  };
+}
+__name(an, "an");
+function un(t2) {
+  return Array.isArray(t2) && t2.every((e) => qt.has(e));
+}
+__name(un, "un");
+function cn(t2) {
+  let e, n = [], r2 = { cleanMode: false, options: true };
+  return t2.replace(/[^a-z]i/g, "").split("").forEach((s) => {
+    fn(s) ? (e = s, r2.cleanMode = true) : r2.options = r2.options && ln(n[n.length] = `-${s}`);
+  }), {
+    cleanMode: e,
+    options: n,
+    valid: r2
+  };
+}
+__name(cn, "cn");
+function fn(t2) {
+  return t2 === "f" || t2 === "n";
+}
+__name(fn, "fn");
+function ln(t2) {
+  return /^-[a-z]$/i.test(t2) && qt.has(t2.charAt(1));
+}
+__name(ln, "ln");
+function hn(t2) {
+  return /^-[^\-]/.test(t2) ? t2.indexOf("i") > 0 : t2 === "--interactive";
+}
+__name(hn, "hn");
+var mn = class {
+  static {
+    __name(this, "mn");
+  }
+  constructor() {
+    this.files = [], this.values = /* @__PURE__ */ Object.create(null);
+  }
+  get all() {
+    return this._all || (this._all = this.files.reduce((e, n) => Object.assign(e, this.values[n]), {})), this._all;
+  }
+  addFile(e) {
+    if (!(e in this.values)) {
+      const n = N2(this.files);
+      this.values[e] = n ? Object.create(this.values[n]) : {}, this.files.push(e);
+    }
+    return this.values[e];
+  }
+  addValue(e, n, r2) {
+    const s = this.addFile(e);
+    Object.hasOwn(s, n) ? Array.isArray(s[n]) ? s[n].push(r2) : s[n] = [s[n], r2] : s[n] = r2, this._all = void 0;
+  }
+};
+function pn(t2) {
+  const e = new mn();
+  for (const n of Wt(t2))
+    e.addValue(n.file, String(n.key), n.value);
+  return e;
+}
+__name(pn, "pn");
+function dn(t2, e) {
+  let n = null;
+  const r2 = [], s = /* @__PURE__ */ new Map();
+  for (const o2 of Wt(t2, e))
+    o2.key === e && (r2.push(n = o2.value), s.has(o2.file) || s.set(o2.file, []), s.get(o2.file).push(n));
+  return {
+    key: e,
+    paths: Array.from(s.keys()),
+    scopes: s,
+    value: n,
+    values: r2
+  };
+}
+__name(dn, "dn");
+function gn(t2) {
+  return t2.replace(/^(file):/, "");
+}
+__name(gn, "gn");
+function* Wt(t2, e = null) {
+  const n = t2.split("\0");
+  for (let r2 = 0, s = n.length - 1; r2 < s; ) {
+    const o2 = gn(n[r2++]);
+    let i = n[r2++], a = e;
+    if (i.includes(`
+`)) {
+      const c3 = Pe(i, `
+`);
+      a = c3[0], i = c3[1];
+    }
+    yield { file: o2, key: a, value: i };
+  }
+}
+__name(Wt, "Wt");
+var Ht = /* @__PURE__ */ ((t2) => (t2.system = "system", t2.global = "global", t2.local = "local", t2.worktree = "worktree", t2))(Ht || {});
+function Y2(t2, e) {
+  return typeof t2 == "string" && Object.hasOwn(Ht, t2) ? t2 : e;
+}
+__name(Y2, "Y");
+function yn(t2, e, n, r2) {
+  const s = ["config", `--${r2}`];
+  return n && s.push("--add"), s.push(t2, e), {
+    commands: s,
+    format: "utf-8",
+    parser(o2) {
+      return o2;
+    }
+  };
+}
+__name(yn, "yn");
+function wn(t2, e) {
+  const n = ["config", "--null", "--show-origin", "--get-all", t2];
+  return e && n.splice(1, 0, `--${e}`), {
+    commands: n,
+    format: "utf-8",
+    parser(r2) {
+      return dn(r2, t2);
+    }
+  };
+}
+__name(wn, "wn");
+function bn(t2) {
+  const e = ["config", "--list", "--show-origin", "--null"];
+  return t2 && e.push(`--${t2}`), {
+    commands: e,
+    format: "utf-8",
+    parser(n) {
+      return pn(n);
+    }
+  };
+}
+__name(bn, "bn");
+function Tn() {
+  return {
+    addConfig(t2, e, ...n) {
+      return this._runTask(
+        yn(
+          t2,
+          e,
+          n[0] === true,
+          Y2(
+            n[1],
+            "local"
+            /* local */
+          )
+        ),
+        u(arguments)
+      );
+    },
+    getConfig(t2, e) {
+      return this._runTask(
+        wn(t2, Y2(e, void 0)),
+        u(arguments)
+      );
+    },
+    listConfig(...t2) {
+      return this._runTask(
+        bn(Y2(t2[0], void 0)),
+        u(arguments)
+      );
+    }
+  };
+}
+__name(Tn, "Tn");
+var Kt = /* @__PURE__ */ ((t2) => (t2.ADDED = "A", t2.COPIED = "C", t2.DELETED = "D", t2.MODIFIED = "M", t2.RENAMED = "R", t2.CHANGED = "T", t2.UNMERGED = "U", t2.UNKNOWN = "X", t2.BROKEN = "B", t2))(Kt || {});
+var kn = new Set(Object.values(Kt));
+function _n(t2) {
+  return kn.has(t2);
+}
+__name(_n, "_n");
+var _t;
+var vn = ["-h"];
+var j2 = /* @__PURE__ */ Symbol("grepQuery");
+var En = class {
+  static {
+    __name(this, "En");
+  }
+  constructor() {
+    this[_t] = [];
+  }
+  *[(_t = j2, Symbol.iterator)]() {
+    for (const e of this[j2])
+      yield e;
+  }
+  and(...e) {
+    return e.length && this[j2].push("--and", "(", ...U(e, "-e"), ")"), this;
+  }
+  param(...e) {
+    return this[j2].push(...U(e, "-e")), this;
+  }
+};
+function Sn(...t2) {
+  return new En().param(...t2);
+}
+__name(Sn, "Sn");
+function Rn(t2) {
+  const e = /* @__PURE__ */ new Set(), n = {};
+  return ut(t2, (r2) => {
+    const [s, o2, i] = r2.split(I2);
+    e.add(s), (n[s] = n[s] || []).push({
+      line: p(o2),
+      path: s,
+      preview: i
+    });
+  }), {
+    paths: e,
+    results: n
+  };
+}
+__name(Rn, "Rn");
+function On() {
+  return {
+    grep(t2) {
+      const e = u(arguments), n = h2(arguments);
+      for (const s of vn)
+        if (n.includes(s))
+          return this._runTask(
+            b2(`git.grep: use of "${s}" is not supported.`),
+            e
+          );
+      typeof t2 == "string" && (t2 = Sn().param(t2));
+      const r2 = ["grep", "--null", "-n", "--full-name", ...n, ...t2];
+      return this._runTask(
+        {
+          commands: r2,
+          format: "utf-8",
+          parser(s) {
+            return Rn(s);
+          }
+        },
+        e
+      );
+    }
+  };
+}
+__name(On, "On");
+var Vt = /* @__PURE__ */ ((t2) => (t2.MIXED = "mixed", t2.SOFT = "soft", t2.HARD = "hard", t2.MERGE = "merge", t2.KEEP = "keep", t2))(Vt || {});
+var Cn = L2(Object.values(Vt));
+function An(t2, e) {
+  const n = ["reset"];
+  return Xt(t2) && n.push(`--${t2}`), n.push(...e), g(n);
+}
+__name(An, "An");
+function xn(t2) {
+  if (Xt(t2))
+    return t2;
+  switch (typeof t2) {
+    case "string":
+    case "undefined":
+      return "soft";
+  }
+}
+__name(xn, "xn");
+function Xt(t2) {
+  return typeof t2 == "string" && Cn.includes(t2);
+}
+__name(Xt, "Xt");
+import_debug.default.formatters.L = (t2) => String(Bt(t2) ? t2.length : "-");
+import_debug.default.formatters.B = (t2) => Buffer.isBuffer(t2) ? t2.toString("utf8") : ft(t2);
+function Nn() {
+  return (0, import_debug.default)("simple-git");
+}
+__name(Nn, "Nn");
+function vt(t2, e, n) {
+  return !e || !String(e).replace(/\s*/, "") ? n ? (r2, ...s) => {
+    t2(r2, ...s), n(r2, ...s);
+  } : t2 : (r2, ...s) => {
+    t2(`%s ${r2}`, e, ...s), n && n(r2, ...s);
+  };
+}
+__name(vt, "vt");
+function $n(t2, e, { namespace: n }) {
+  if (typeof t2 == "string")
+    return t2;
+  const r2 = e && e.namespace || "";
+  return r2.startsWith(n) ? r2.substr(n.length + 1) : r2 || n;
+}
+__name($n, "$n");
+function $2(t2, e, n, r2 = Nn()) {
+  const s = t2 && `[${t2}]` || "", o2 = [], i = typeof e == "string" ? r2.extend(e) : e, a = $n(d(e, m), i, r2);
+  return y2(n);
+  function c3(w2, T2) {
+    return S2(
+      o2,
+      $2(t2, a.replace(/^[^:]+/, w2), T2, r2)
+    );
+  }
+  __name(c3, "c");
+  function y2(w2) {
+    const T2 = w2 && `[${w2}]` || "", k2 = i && vt(i, T2) || W2, C2 = vt(r2, `${s} ${T2}`, k2);
+    return Object.assign(i ? k2 : C2, {
+      label: t2,
+      sibling: c3,
+      info: C2,
+      step: y2
+    });
+  }
+  __name(y2, "y");
+}
+__name($2, "$");
+var M2 = class M3 {
+  static {
+    __name(this, "M");
+  }
+  constructor(e = "GitExecutor") {
+    this.logLabel = e, this._queue = /* @__PURE__ */ new Map();
+  }
+  withProgress(e) {
+    return this._queue.get(e);
+  }
+  createProgress(e) {
+    const n = M3.getName(e.commands[0]), r2 = $2(this.logLabel, n);
+    return {
+      task: e,
+      logger: r2,
+      name: n
+    };
+  }
+  push(e) {
+    const n = this.createProgress(e);
+    return n.logger("Adding task to the queue, commands = %o", e.commands), this._queue.set(e, n), n;
+  }
+  fatal(e) {
+    for (const [n, { logger: r2 }] of Array.from(this._queue.entries()))
+      n === e.task ? (r2.info("Failed %o", e), r2(
+        "Fatal exception, any as-yet un-started tasks run through this executor will not be attempted"
+      )) : r2.info(
+        "A fatal exception occurred in a previous task, the queue has been purged: %o",
+        e.message
+      ), this.complete(n);
+    if (this._queue.size !== 0)
+      throw new Error(`Queue size should be zero after fatal: ${this._queue.size}`);
+  }
+  complete(e) {
+    this.withProgress(e) && this._queue.delete(e);
+  }
+  attempt(e) {
+    const n = this.withProgress(e);
+    if (!n)
+      throw new O2(void 0, "TasksPendingQueue: attempt called for an unknown task");
+    return n.logger("Starting task"), n;
+  }
+  static getName(e = "empty") {
+    return `task:${e}:${++M3.counter}`;
+  }
+};
+M2.counter = 0;
+var ot = M2;
+var Pn = class {
+  static {
+    __name(this, "Pn");
+  }
+  constructor(e, n, r2) {
+    this._executor = e, this._scheduler = n, this._plugins = r2, this._chain = Promise.resolve(), this._queue = new ot();
+  }
+  get cwd() {
+    return this._cwd || this._executor.cwd;
+  }
+  set cwd(e) {
+    this._cwd = e;
+  }
+  get env() {
+    return this._executor.env;
+  }
+  get outputHandler() {
+    return this._executor.outputHandler;
+  }
+  chain() {
+    return this;
+  }
+  push(e) {
+    return this._queue.push(e), this._chain = this._chain.then(() => this.attemptTask(e));
+  }
+  async attemptTask(e) {
+    const n = await this._scheduler.next(), r2 = /* @__PURE__ */ __name(() => this._queue.complete(e), "r");
+    try {
+      const { logger: s } = this._queue.attempt(e);
+      return await (kt(e) ? this.attemptEmptyTask(e, s) : this.attemptRemoteTask(e, s));
+    } catch (s) {
+      throw this.onFatalException(e, s);
+    } finally {
+      r2(), n();
+    }
+  }
+  onFatalException(e, n) {
+    const r2 = n instanceof O2 ? Object.assign(n, { task: e }) : new O2(e, n && String(n));
+    return this._chain = Promise.resolve(), this._queue.fatal(r2), r2;
+  }
+  async attemptRemoteTask(e, n) {
+    const r2 = this._plugins.exec("spawn.binary", "", this.taskContext(e, e.commands)), s = this._plugins.exec(
+      "spawn.args",
+      [...e.commands],
+      this.taskContext(e, e.commands)
+    ), o2 = await this.gitResponse(
+      e,
+      r2,
+      s,
+      this.outputHandler,
+      n.step("SPAWN")
+    ), i = await this.handleTaskData(e, s, o2, n.step("HANDLE"));
+    return n("passing response to task's parser as a %s", e.format), en(e) ? Tt(e.parser, i) : Tt(e.parser, i.asStrings());
+  }
+  async attemptEmptyTask(e, n) {
+    return n("empty task bypassing child process to call to task's parser"), e.parser(this);
+  }
+  handleTaskData(e, n, r2, s) {
+    const { exitCode: o2, rejection: i, stdOut: a, stdErr: c3 } = r2;
+    return new Promise((y2, w2) => {
+      s("Preparing to handle process response exitCode=%d stdOut=", o2);
+      const { error: T2 } = this._plugins.exec(
+        "task.error",
+        { error: i },
+        {
+          ...this.taskContext(e, n),
+          ...r2
+        }
+      );
+      if (T2 && e.onError)
+        return s.info("exitCode=%s handling with custom error handler"), e.onError(
+          r2,
+          T2,
+          (k2) => {
+            s.info("custom error handler treated as success"), s("custom error returned a %s", ft(k2)), y2(
+              new z2(
+                Array.isArray(k2) ? Buffer.concat(k2) : k2,
+                Buffer.concat(c3)
+              )
+            );
+          },
+          w2
+        );
+      if (T2)
+        return s.info(
+          "handling as error: exitCode=%s stdErr=%s rejection=%o",
+          o2,
+          c3.length,
+          i
+        ), w2(T2);
+      s.info("retrieving task output complete"), y2(new z2(Buffer.concat(a), Buffer.concat(c3)));
+    });
+  }
+  async gitResponse(e, n, r2, s, o2) {
+    const i = o2.sibling("output"), a = this._plugins.exec(
+      "spawn.options",
+      {
+        cwd: this.cwd,
+        env: this.env,
+        windowsHide: true
+      },
+      this.taskContext(e, e.commands)
+    );
+    return new Promise((c3) => {
+      const y2 = [], w2 = [];
+      o2.info("%s %o", n, r2), o2("%O", a);
+      let T2 = this._beforeSpawn(e, r2);
+      if (T2)
+        return c3({
+          stdOut: y2,
+          stdErr: w2,
+          exitCode: 9901,
+          rejection: T2
+        });
+      this._plugins.exec("spawn.before", void 0, {
+        ...this.taskContext(e, r2),
+        kill(C2) {
+          T2 = C2 || T2;
+        }
+      });
+      const k2 = ve(n, r2, a);
+      k2.stdout.on(
+        "data",
+        Et(y2, "stdOut", o2, i.step("stdOut"))
+      ), k2.stderr.on(
+        "data",
+        Et(w2, "stdErr", o2, i.step("stdErr"))
+      ), k2.on("error", Mn(w2, o2)), s && (o2("Passing child process stdOut/stdErr to custom outputHandler"), s(n, k2.stdout, k2.stderr, [...r2])), this._plugins.exec("spawn.after", void 0, {
+        ...this.taskContext(e, r2),
+        spawned: k2,
+        close(C2, Te) {
+          c3({
+            stdOut: y2,
+            stdErr: w2,
+            exitCode: C2,
+            rejection: T2 || Te
+          });
+        },
+        kill(C2) {
+          k2.killed || (T2 = C2, k2.kill("SIGINT"));
+        }
+      });
+    });
+  }
+  _beforeSpawn(e, n) {
+    let r2;
+    return this._plugins.exec("spawn.before", void 0, {
+      ...this.taskContext(e, n),
+      kill(s) {
+        r2 = s || r2;
+      }
+    }), r2;
+  }
+  taskContext(e, n) {
+    return {
+      method: String(Me(e.commands) || ""),
+      commands: n,
+      env: { ...this.env },
+      input: kt(e) ? void 0 : e.input
+    };
+  }
+};
+function Mn(t2, e) {
+  return (n) => {
+    e("[ERROR] child process exception %o", n), t2.push(Buffer.from(String(n.stack), "ascii"));
+  };
+}
+__name(Mn, "Mn");
+function Et(t2, e, n, r2) {
+  return (s) => {
+    n("%s received %L bytes", e, s), r2("%B", s), t2.push(s);
+  };
+}
+__name(Et, "Et");
+var Dn = class {
+  static {
+    __name(this, "Dn");
+  }
+  constructor(e, n, r2) {
+    this.cwd = e, this._scheduler = n, this._plugins = r2, this._chain = this.chain();
+  }
+  chain() {
+    return new Pn(this, this._scheduler, this._plugins);
+  }
+  push(e) {
+    return this._chain.push(e);
+  }
+};
+function Ln(t2, e, n = W2) {
+  const r2 = /* @__PURE__ */ __name((o2) => {
+    n(null, o2);
+  }, "r"), s = /* @__PURE__ */ __name((o2) => {
+    o2?.task === t2 && n(o2, void 0);
+  }, "s");
+  e.then(r2, s);
+}
+__name(Ln, "Ln");
+function St(t2, e) {
+  return tn((n) => {
+    if (!Lt(t2))
+      throw new Error(`Git.cwd: cannot change to non-directory "${t2}"`);
+    return (e || n).cwd = t2;
+  });
+}
+__name(St, "St");
+function Q2(t2) {
+  const e = ["checkout", ...t2];
+  return e[1] === "-b" && e.includes("-B") && (e[1] = ct(e, "-B")), g(e);
+}
+__name(Q2, "Q");
+function jn() {
+  return {
+    checkout() {
+      return this._runTask(
+        Q2(h2(arguments, 1)),
+        u(arguments)
+      );
+    },
+    checkoutBranch(t2, e) {
+      return this._runTask(
+        Q2(["-b", t2, e, ...h2(arguments)]),
+        u(arguments)
+      );
+    },
+    checkoutLocalBranch(t2) {
+      return this._runTask(
+        Q2(["-b", t2, ...h2(arguments)]),
+        u(arguments)
+      );
+    }
+  };
+}
+__name(jn, "jn");
+var Yt = /* @__PURE__ */ __name((t2, e, n) => {
+  const r2 = ["clone", ...n];
+  return m(t2) && r2.push(c(t2)), m(e) && r2.push(c(e)), g(r2);
+}, "Yt");
+var Bn = /* @__PURE__ */ __name((t2, e, n) => (S2(n, "--mirror"), Yt(t2, e, n)), "Bn");
+function Rt(t2, e, n, ...r2) {
+  return m(n) ? e(n, d(r2[0], m), h2(arguments)) : b2(`git.${t2}() requires a string 'repoPath'`);
+}
+__name(Rt, "Rt");
+function In() {
+  return {
+    clone(t2, ...e) {
+      return this._runTask(
+        Rt("clone", Yt, d(t2, m), ...e),
+        u(arguments)
+      );
+    },
+    mirror(t2, ...e) {
+      return this._runTask(
+        Rt("mirror", Bn, d(t2, m), ...e),
+        u(arguments)
+      );
+    }
+  };
+}
+__name(In, "In");
+var Un = [
+  new l2(/^\[([^\s]+)( \([^)]+\))? ([^\]]+)/, (t2, [e, n, r2]) => {
+    t2.branch = e, t2.commit = r2, t2.root = !!n;
+  }),
+  new l2(/\s*Author:\s(.+)/i, (t2, [e]) => {
+    const n = e.split("<"), r2 = n.pop();
+    !r2 || !r2.includes("@") || (t2.author = {
+      email: r2.substr(0, r2.length - 1),
+      name: n.join("<").trim()
+    });
+  }),
+  new l2(
+    /(\d+)[^,]*(?:,\s*(\d+)[^,]*)(?:,\s*(\d+))/g,
+    (t2, [e, n, r2]) => {
+      t2.summary.changes = parseInt(e, 10) || 0, t2.summary.insertions = parseInt(n, 10) || 0, t2.summary.deletions = parseInt(r2, 10) || 0;
+    }
+  ),
+  new l2(
+    /^(\d+)[^,]*(?:,\s*(\d+)[^(]+\(([+-]))?/,
+    (t2, [e, n, r2]) => {
+      t2.summary.changes = parseInt(e, 10) || 0;
+      const s = parseInt(n, 10) || 0;
+      r2 === "-" ? t2.summary.deletions = s : r2 === "+" && (t2.summary.insertions = s);
+    }
+  )
+];
+function Fn(t2) {
+  return E2({
+    author: null,
+    branch: "",
+    commit: "",
+    root: false,
+    summary: {
+      changes: 0,
+      insertions: 0,
+      deletions: 0
+    }
+  }, Un, t2);
+}
+__name(Fn, "Fn");
+function Gn(t2, e, n) {
+  return {
+    commands: [
+      "-c",
+      "core.abbrev=40",
+      "commit",
+      ...U(t2, "-m"),
+      ...e,
+      ...n
+    ],
+    format: "utf-8",
+    parser: Fn
+  };
+}
+__name(Gn, "Gn");
+function zn() {
+  return {
+    commit(e, ...n) {
+      const r2 = u(arguments), s = t2(e) || Gn(
+        v(e),
+        v(d(n[0], G2, [])),
+        [
+          ...L2(d(n[1], K2, [])),
+          ...h2(arguments, 0, true)
+        ]
+      );
+      return this._runTask(s, r2);
+    }
+  };
+  function t2(e) {
+    return !G2(e) && b2(
+      "git.commit: requires the commit message to be supplied as a string/string[]"
+    );
+  }
+  __name(t2, "t");
+}
+__name(zn, "zn");
+function qn() {
+  return {
+    count: 0,
+    garbage: 0,
+    inPack: 0,
+    packs: 0,
+    prunePackable: 0,
+    size: 0,
+    sizeGarbage: 0,
+    sizePack: 0
+  };
+}
+__name(qn, "qn");
+var Wn = new l2(
+  /([a-z-]+): (\d+)$/,
+  (t2, [e, n]) => {
+    const r2 = jt(e);
+    Object.hasOwn(t2, r2) && (t2[r2] = p(n));
+  }
+);
+function Hn() {
+  return {
+    countObjects() {
+      return this._runTask({
+        commands: ["count-objects", "--verbose"],
+        format: "utf-8",
+        parser(t2) {
+          return E2(qn(), [Wn], t2);
+        }
+      });
+    }
+  };
+}
+__name(Hn, "Hn");
+function Kn() {
+  return {
+    firstCommit() {
+      return this._runTask(
+        g(["rev-list", "--max-parents=0", "HEAD"], true),
+        u(arguments)
+      );
+    }
+  };
+}
+__name(Kn, "Kn");
+function Vn(t2, e) {
+  const n = ["hash-object", t2];
+  return e && n.push("-w"), g(n, true);
+}
+__name(Vn, "Vn");
+var J2 = class {
+  static {
+    __name(this, "J");
+  }
+  constructor(e, n, r2, s) {
+    this.bare = e, this.path = n, this.existing = r2, this.gitDir = s;
+  }
+};
+var Xn = /^Init.+ repository in (.+)$/;
+var Yn = /^Rein.+ in (.+)$/;
+function Qn(t2, e, n) {
+  const r2 = String(n).trim();
+  let s;
+  if (s = Xn.exec(r2))
+    return new J2(t2, e, false, s[1]);
+  if (s = Yn.exec(r2))
+    return new J2(t2, e, true, s[1]);
+  let o2 = "";
+  const i = r2.split(" ");
+  for (; i.length; )
+    if (i.shift() === "in") {
+      o2 = i.join(" ");
+      break;
+    }
+  return new J2(t2, e, /^re/i.test(r2), o2);
+}
+__name(Qn, "Qn");
+var Qt = "--bare";
+function Jn(t2) {
+  return t2.includes(Qt);
+}
+__name(Jn, "Jn");
+function Zn(t2 = false, e, n) {
+  const r2 = ["init", ...n];
+  return t2 && !Jn(r2) && r2.splice(1, 0, Qt), {
+    commands: r2,
+    format: "utf-8",
+    parser(s) {
+      return Qn(r2.includes("--bare"), e, s);
+    }
+  };
+}
+__name(Zn, "Zn");
+function tr(t2) {
+  return t2 === void 0 ? b2("interpretTrailers called without input content") : {
+    format: "utf-8",
+    parser(e) {
+      return Object.fromEntries(
+        ut(e, (n) => {
+          const r2 = n.indexOf(":");
+          return [
+            jt(n.substring(0, r2).toLowerCase()),
+            n.substring(r2 + 2).trim()
+          ];
+        })
+      );
+    },
+    commands: ["interpret-trailers", "--parse"],
+    input: t2
+  };
+}
+__name(tr, "tr");
+function er() {
+  return {
+    interpretTrailers(t2) {
+      return this._runTask(
+        tr(d(t2, Be)),
+        u(arguments)
+      );
+    }
+  };
+}
+__name(er, "er");
+var R2 = /* @__PURE__ */ ((t2) => (t2.NONE = "", t2.STAT = "--stat", t2.NUM_STAT = "--numstat", t2.NAME_ONLY = "--name-only", t2.NAME_STATUS = "--name-status", t2))(R2 || {});
+var Jt = /^--(stat|numstat|name-only|name-status)(=|$)/;
+function pt(t2) {
+  for (let e = 0; e < t2.length; e++) {
+    const n = Jt.exec(t2[e]);
+    if (n)
+      return `--${n[1]}`;
+  }
+  return "";
+}
+__name(pt, "pt");
+function nr(t2) {
+  return Jt.test(t2);
+}
+__name(nr, "nr");
+var rr = class {
+  static {
+    __name(this, "rr");
+  }
+  constructor() {
+    this.changed = 0, this.deletions = 0, this.insertions = 0, this.files = [];
+  }
+};
+var Ot = [
+  new l2(
+    /^(.+)\s+\|\s+(\d+)(\s+[+\-]+)?$/,
+    (t2, [e, n, r2 = ""]) => {
+      t2.files.push({
+        file: e.trim(),
+        changes: p(n),
+        insertions: r2.replace(/[^+]/g, "").length,
+        deletions: r2.replace(/[^-]/g, "").length,
+        binary: false
+      });
+    }
+  ),
+  new l2(
+    /^(.+) \|\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)/,
+    (t2, [e, n, r2]) => {
+      t2.files.push({
+        file: e.trim(),
+        before: p(n),
+        after: p(r2),
+        binary: true
+      });
+    }
+  ),
+  new l2(/^(.+)\s+\|\s+Bin\s*$/, (t2, [e]) => {
+    t2.files.push({
+      file: e.trim(),
+      before: 0,
+      after: 0,
+      binary: true
+    });
+  }),
+  new l2(
+    /(\d+) files? changed\s*((?:, \d+ [^,]+){0,2})/,
+    (t2, [e, n]) => {
+      const r2 = /(\d+) i/.exec(n), s = /(\d+) d/.exec(n);
+      t2.changed = p(e), t2.insertions = p(r2?.[1]), t2.deletions = p(s?.[1]);
+    }
+  )
+];
+var sr = [
+  new l2(
+    /(\d+)\t(\d+)\t(.+)$/,
+    (t2, [e, n, r2]) => {
+      const s = p(e), o2 = p(n);
+      t2.changed++, t2.insertions += s, t2.deletions += o2, t2.files.push({
+        file: r2,
+        changes: s + o2,
+        insertions: s,
+        deletions: o2,
+        binary: false
+      });
+    }
+  ),
+  new l2(/-\t-\t(.+)$/, (t2, [e]) => {
+    t2.changed++, t2.files.push({
+      file: e,
+      after: 0,
+      before: 0,
+      binary: true
+    });
+  })
+];
+var or = [
+  new l2(/(.+)$/, (t2, [e]) => {
+    t2.changed++, t2.files.push({
+      file: e,
+      changes: 0,
+      insertions: 0,
+      deletions: 0,
+      binary: false
+    });
+  })
+];
+var ir = [
+  new l2(
+    /([ACDMRTUXB])([0-9]{0,3})\t(.[^\t]*)(\t(.[^\t]*))?$/,
+    (t2, [e, n, r2, s, o2]) => {
+      t2.changed++, t2.files.push({
+        file: o2 ?? r2,
+        changes: 0,
+        insertions: 0,
+        deletions: 0,
+        binary: false,
+        status: bt(_n(e) && e),
+        from: bt(!!o2 && r2 !== o2 && r2),
+        similarity: p(n)
+      });
+    }
+  )
+];
+var ar = {
+  [R2.NONE]: Ot,
+  [R2.STAT]: Ot,
+  [R2.NUM_STAT]: sr,
+  [R2.NAME_STATUS]: ir,
+  [R2.NAME_ONLY]: or
+};
+function Zt(t2 = R2.NONE) {
+  const e = ar[t2];
+  return (n) => E2(new rr(), e, n, false);
+}
+__name(Zt, "Zt");
+var te = "\xF2\xF2\xF2\xF2\xF2\xF2 ";
+var ee2 = " \xF2\xF2";
+var ne2 = " \xF2 ";
+var ur = ["hash", "date", "message", "refs", "author_name", "author_email"];
+function cr(t2, e) {
+  return e.reduce(
+    (n, r2, s) => (n[r2] = t2[s] || "", n),
+    /* @__PURE__ */ Object.create({ diff: null })
+  );
+}
+__name(cr, "cr");
+function re(t2 = ne2, e = ur, n = R2.NONE) {
+  const r2 = Zt(n);
+  return function(s) {
+    const o2 = H2(
+      s.trim(),
+      false,
+      te
+    ).map(function(i) {
+      const a = i.split(ee2), c3 = cr(a[0].split(t2), e);
+      return a.length > 1 && a[1].trim() && (c3.diff = r2(a[1])), c3;
+    });
+    return {
+      all: o2,
+      latest: o2.length && o2[0] || null,
+      total: o2.length
+    };
+  };
+}
+__name(re, "re");
+function fr(t2) {
+  let e = pt(t2);
+  const n = ["diff"];
+  return e === R2.NONE && (e = R2.STAT, n.push("--stat=4096")), n.push(...t2), dt(n) || {
+    commands: n,
+    format: "utf-8",
+    parser: Zt(e)
+  };
+}
+__name(fr, "fr");
+function dt(t2) {
+  const e = t2.filter(nr);
+  if (e.length > 1)
+    return b2(
+      `Summary flags are mutually exclusive - pick one of ${e.join(",")}`
+    );
+  if (e.length && t2.includes("-z"))
+    return b2(
+      `Summary flag ${e} parsing is not compatible with null termination option '-z'`
+    );
+}
+__name(dt, "dt");
+var se = /* @__PURE__ */ ((t2) => (t2[t2["--pretty"] = 0] = "--pretty", t2[t2["max-count"] = 1] = "max-count", t2[t2.maxCount = 2] = "maxCount", t2[t2.n = 3] = "n", t2[t2.file = 4] = "file", t2[t2.format = 5] = "format", t2[t2.from = 6] = "from", t2[t2.to = 7] = "to", t2[t2.splitter = 8] = "splitter", t2[t2.symmetric = 9] = "symmetric", t2[t2.mailMap = 10] = "mailMap", t2[t2.multiLine = 11] = "multiLine", t2[t2.strictDate = 12] = "strictDate", t2))(se || {});
+function lr(t2, e) {
+  const n = [], r2 = [];
+  return Object.keys(t2).forEach((s) => {
+    n.push(s), r2.push(String(t2[s]));
+  }), [n, r2.join(e)];
+}
+__name(lr, "lr");
+function hr(t2) {
+  return Object.keys(t2).reduce((e, n) => (n in se || (e[n] = t2[n]), e), {});
+}
+__name(hr, "hr");
+function oe2(t2 = {}, e = []) {
+  const n = d(t2.splitter, m, ne2), r2 = lt(t2.format) ? t2.format : {
+    hash: "%H",
+    date: t2.strictDate === false ? "%ai" : "%aI",
+    message: "%s",
+    refs: "%D",
+    body: t2.multiLine ? "%B" : "%b",
+    author_name: t2.mailMap !== false ? "%aN" : "%an",
+    author_email: t2.mailMap !== false ? "%aE" : "%ae"
+  }, [s, o2] = lr(r2, n), i = [], a = [
+    `--pretty=format:${te}${o2}${ee2}`,
+    ...e
+  ], c3 = t2.n || t2["max-count"] || t2.maxCount;
+  if (c3 && a.push(`--max-count=${c3}`), t2.from || t2.to) {
+    const y2 = t2.symmetric !== false ? "..." : "..";
+    i.push(`${t2.from || ""}${y2}${t2.to || ""}`);
+  }
+  return m(t2.file) && a.push("--follow", c(t2.file)), It(hr(t2), a), {
+    fields: s,
+    splitter: n,
+    commands: [...a, ...i]
+  };
+}
+__name(oe2, "oe");
+function mr(t2, e, n) {
+  const r2 = re(t2, e, pt(n));
+  return {
+    commands: ["log", ...n],
+    format: "utf-8",
+    parser: r2
+  };
+}
+__name(mr, "mr");
+function pr() {
+  return {
+    log(...n) {
+      const r2 = u(arguments), s = oe2(
+        ht(arguments),
+        L2(d(arguments[0], K2, []))
+      ), o2 = e(...n) || dt(s.commands) || t2(s);
+      return this._runTask(o2, r2);
+    }
+  };
+  function t2(n) {
+    return mr(n.splitter, n.fields, n.commands);
+  }
+  __name(t2, "t");
+  function e(n, r2) {
+    return m(n) && m(r2) && b2(
+      "git.log(string, string) should be replaced with git.log({ from: string, to: string })"
+    );
+  }
+  __name(e, "e");
+}
+__name(pr, "pr");
+var Z2 = class {
+  static {
+    __name(this, "Z");
+  }
+  constructor(e, n = null, r2) {
+    this.reason = e, this.file = n, this.meta = r2;
+  }
+  toString() {
+    return `${this.file}:${this.reason}`;
+  }
+};
+var dr = class {
+  static {
+    __name(this, "dr");
+  }
+  constructor() {
+    this.conflicts = [], this.merges = [], this.result = "success";
+  }
+  get failed() {
+    return this.conflicts.length > 0;
+  }
+  get reason() {
+    return this.result;
+  }
+  toString() {
+    return this.conflicts.length ? `CONFLICTS: ${this.conflicts.join(", ")}` : "OK";
+  }
+};
+var ie = class {
+  static {
+    __name(this, "ie");
+  }
+  constructor() {
+    this.remoteMessages = {
+      all: []
+    }, this.created = [], this.deleted = [], this.files = [], this.deletions = {}, this.insertions = {}, this.summary = {
+      changes: 0,
+      deletions: 0,
+      insertions: 0
+    };
+  }
+};
+var gr = class {
+  static {
+    __name(this, "gr");
+  }
+  constructor() {
+    this.remote = "", this.hash = {
+      local: "",
+      remote: ""
+    }, this.branch = {
+      local: "",
+      remote: ""
+    }, this.message = "";
+  }
+  toString() {
+    return this.message;
+  }
+};
+function tt(t2) {
+  return t2.objects = t2.objects || {
+    compressing: 0,
+    counting: 0,
+    enumerating: 0,
+    packReused: 0,
+    reused: { count: 0, delta: 0 },
+    total: { count: 0, delta: 0 }
+  };
+}
+__name(tt, "tt");
+function Ct(t2) {
+  const e = /^\s*(\d+)/.exec(t2), n = /delta (\d+)/i.exec(t2);
+  return {
+    count: p(e && e[1] || "0"),
+    delta: p(n && n[1] || "0")
+  };
+}
+__name(Ct, "Ct");
+var yr = [
+  new x2(
+    /^remote:\s*(enumerating|counting|compressing) objects: (\d+),/i,
+    (t2, [e, n]) => {
+      const r2 = e.toLowerCase(), s = tt(t2.remoteMessages);
+      Object.assign(s, { [r2]: p(n) });
+    }
+  ),
+  new x2(
+    /^remote:\s*(enumerating|counting|compressing) objects: \d+% \(\d+\/(\d+)\),/i,
+    (t2, [e, n]) => {
+      const r2 = e.toLowerCase(), s = tt(t2.remoteMessages);
+      Object.assign(s, { [r2]: p(n) });
+    }
+  ),
+  new x2(
+    /total ([^,]+), reused ([^,]+), pack-reused (\d+)/i,
+    (t2, [e, n, r2]) => {
+      const s = tt(t2.remoteMessages);
+      s.total = Ct(e), s.reused = Ct(n), s.packReused = p(r2);
+    }
+  )
+];
+var wr = [
+  new x2(/^remote:\s*(.+)$/, (t2, [e]) => (t2.remoteMessages.all.push(e.trim()), false)),
+  ...yr,
+  new x2(
+    [/create a (?:pull|merge) request/i, /\s(https?:\/\/\S+)$/],
+    (t2, [e]) => {
+      t2.remoteMessages.pullRequestUrl = e;
+    }
+  ),
+  new x2(
+    [/found (\d+) vulnerabilities.+\(([^)]+)\)/i, /\s(https?:\/\/\S+)$/],
+    (t2, [e, n, r2]) => {
+      t2.remoteMessages.vulnerabilities = {
+        count: p(e),
+        summary: n,
+        url: r2
+      };
+    }
+  )
+];
+function ae(t2, e) {
+  return E2({ remoteMessages: new br() }, wr, e);
+}
+__name(ae, "ae");
+var br = class {
+  static {
+    __name(this, "br");
+  }
+  constructor() {
+    this.all = [];
+  }
+};
+var Tr = /^\s*(.+?)\s+\|\s+\d+\s*(\+*)(-*)/;
+var kr = /(\d+)\D+((\d+)\D+\(\+\))?(\D+(\d+)\D+\(-\))?/;
+var _r = /^(create|delete) mode \d+ (.+)/;
+var vr = [
+  new l2(Tr, (t2, [e, n, r2]) => {
+    t2.files.push(e), n && (t2.insertions[e] = n.length), r2 && (t2.deletions[e] = r2.length);
+  }),
+  new l2(kr, (t2, [e, , n, , r2]) => n !== void 0 || r2 !== void 0 ? (t2.summary.changes = +e || 0, t2.summary.insertions = +n || 0, t2.summary.deletions = +r2 || 0, true) : false),
+  new l2(_r, (t2, [e, n]) => {
+    S2(t2.files, n), S2(e === "create" ? t2.created : t2.deleted, n);
+  })
+];
+var Er = [
+  new l2(/^from\s(.+)$/i, (t2, [e]) => {
+    t2.remote = e;
+  }),
+  new l2(/^fatal:\s(.+)$/, (t2, [e]) => {
+    t2.message = e;
+  }),
+  new l2(
+    /([a-z0-9]+)\.\.([a-z0-9]+)\s+(\S+)\s+->\s+(\S+)$/,
+    (t2, [e, n, r2, s]) => {
+      t2.branch.local = r2, t2.hash.local = e, t2.branch.remote = s, t2.hash.remote = n;
+    }
+  )
+];
+var Sr = /* @__PURE__ */ __name((t2, e) => E2(new ie(), vr, [t2, e]), "Sr");
+var ue = /* @__PURE__ */ __name((t2, e) => Object.assign(
+  new ie(),
+  Sr(t2, e),
+  ae(t2, e)
+), "ue");
+function Rr(t2, e) {
+  const n = E2(new gr(), Er, [t2, e]);
+  return n.message && n;
+}
+__name(Rr, "Rr");
+var Or = [
+  new l2(/^Auto-merging\s+(.+)$/, (t2, [e]) => {
+    t2.merges.push(e);
+  }),
+  new l2(/^CONFLICT\s+\((.+)\): Merge conflict in (.+)$/, (t2, [e, n]) => {
+    t2.conflicts.push(new Z2(e, n));
+  }),
+  new l2(
+    /^CONFLICT\s+\((.+\/delete)\): (.+) deleted in (.+) and/,
+    (t2, [e, n, r2]) => {
+      t2.conflicts.push(new Z2(e, n, { deleteRef: r2 }));
+    }
+  ),
+  new l2(/^CONFLICT\s+\((.+)\):/, (t2, [e]) => {
+    t2.conflicts.push(new Z2(e, null));
+  }),
+  new l2(/^Automatic merge failed;\s+(.+)$/, (t2, [e]) => {
+    t2.result = e;
+  })
+];
+var Cr = /* @__PURE__ */ __name((t2, e) => Object.assign(Ar(t2), ue(t2, e)), "Cr");
+var Ar = /* @__PURE__ */ __name((t2) => E2(new dr(), Or, t2), "Ar");
+function At(t2) {
+  return t2.length ? {
+    commands: ["merge", ...t2],
+    format: "utf-8",
+    parser(e, n) {
+      const r2 = Cr(e, n);
+      if (r2.failed)
+        throw new at(r2);
+      return r2;
+    }
+  } : b2("Git.merge requires at least one option");
+}
+__name(At, "At");
+function xr(t2, e, n) {
+  const r2 = n.includes("deleted"), s = n.includes("tag") || /^refs\/tags/.test(t2), o2 = !n.includes("new");
+  return {
+    deleted: r2,
+    tag: s,
+    branch: !s,
+    new: !o2,
+    alreadyUpdated: o2,
+    local: t2,
+    remote: e
+  };
+}
+__name(xr, "xr");
+var Nr = [
+  new l2(/^Pushing to (.+)$/, (t2, [e]) => {
+    t2.repo = e;
+  }),
+  new l2(/^updating local tracking ref '(.+)'/, (t2, [e]) => {
+    t2.ref = {
+      ...t2.ref || {},
+      local: e
+    };
+  }),
+  new l2(/^[=*-]\s+([^:]+):(\S+)\s+\[(.+)]$/, (t2, [e, n, r2]) => {
+    t2.pushed.push(xr(e, n, r2));
+  }),
+  new l2(
+    /^Branch '([^']+)' set up to track remote branch '([^']+)' from '([^']+)'/,
+    (t2, [e, n, r2]) => {
+      t2.branch = {
+        ...t2.branch || {},
+        local: e,
+        remote: n,
+        remoteName: r2
+      };
+    }
+  ),
+  new l2(
+    /^([^:]+):(\S+)\s+([a-z0-9]+)\.\.([a-z0-9]+)$/,
+    (t2, [e, n, r2, s]) => {
+      t2.update = {
+        head: {
+          local: e,
+          remote: n
+        },
+        hash: {
+          from: r2,
+          to: s
+        }
+      };
+    }
+  )
+];
+var $r = /* @__PURE__ */ __name((t2, e) => {
+  const n = Pr(t2, e), r2 = ae(t2, e);
+  return {
+    ...n,
+    ...r2
+  };
+}, "$r");
+var Pr = /* @__PURE__ */ __name((t2, e) => E2({ pushed: [] }, Nr, [t2, e]), "Pr");
+function Mr(t2 = {}, e) {
+  return S2(e, "--tags"), ce(t2, e);
+}
+__name(Mr, "Mr");
+function ce(t2 = {}, e) {
+  const n = ["push", ...e];
+  return t2.branch && n.splice(1, 0, t2.branch), t2.remote && n.splice(1, 0, t2.remote), ct(n, "-v"), S2(n, "--verbose"), S2(n, "--porcelain"), {
+    commands: n,
+    format: "utf-8",
+    parser: $r
+  };
+}
+__name(ce, "ce");
+function Dr() {
+  return {
+    showBuffer() {
+      const t2 = ["show", ...h2(arguments, 1)];
+      return t2.includes("--binary") || t2.splice(1, 0, "--binary"), this._runTask(
+        Gt(t2),
+        u(arguments)
+      );
+    },
+    show() {
+      const t2 = ["show", ...h2(arguments, 1)];
+      return this._runTask(
+        g(t2),
+        u(arguments)
+      );
+    }
+  };
+}
+__name(Dr, "Dr");
+var Lr = /^(.+)\0(.+)$/;
+var jr = class {
+  static {
+    __name(this, "jr");
+  }
+  constructor(e, n, r2) {
+    if (this.path = e, this.index = n, this.working_dir = r2, n === "R" || r2 === "R") {
+      const s = Lr.exec(e) || [null, e, e];
+      this.from = s[2] || "", this.path = s[1] || "";
+    }
+  }
+};
+var Br = class {
+  static {
+    __name(this, "Br");
+  }
+  constructor() {
+    this.not_added = [], this.conflicted = [], this.created = [], this.deleted = [], this.ignored = void 0, this.modified = [], this.renamed = [], this.files = [], this.staged = [], this.ahead = 0, this.behind = 0, this.current = null, this.tracking = null, this.detached = false, this.isClean = () => !this.files.length;
+  }
+};
+function xt(t2) {
+  const [e, n] = t2.split(I2);
+  return {
+    from: n || e,
+    to: e
+  };
+}
+__name(xt, "xt");
+function _2(t2, e, n) {
+  return [`${t2}${e}`, n];
+}
+__name(_2, "_");
+function et(t2, ...e) {
+  return e.map((n) => _2(t2, n, (r2, s) => r2.conflicted.push(s)));
+}
+__name(et, "et");
+var Ir = new Map([
+  _2(
+    " ",
+    "A",
+    (t2, e) => t2.created.push(e)
+  ),
+  _2(
+    " ",
+    "D",
+    (t2, e) => t2.deleted.push(e)
+  ),
+  _2(
+    " ",
+    "M",
+    (t2, e) => t2.modified.push(e)
+  ),
+  _2("A", " ", (t2, e) => {
+    t2.created.push(e), t2.staged.push(e);
+  }),
+  _2("A", "M", (t2, e) => {
+    t2.created.push(e), t2.staged.push(e), t2.modified.push(e);
+  }),
+  _2("D", " ", (t2, e) => {
+    t2.deleted.push(e), t2.staged.push(e);
+  }),
+  _2("M", " ", (t2, e) => {
+    t2.modified.push(e), t2.staged.push(e);
+  }),
+  _2("M", "M", (t2, e) => {
+    t2.modified.push(e), t2.staged.push(e);
+  }),
+  _2("R", " ", (t2, e) => {
+    t2.renamed.push(xt(e));
+  }),
+  _2("R", "M", (t2, e) => {
+    const n = xt(e);
+    t2.renamed.push(n), t2.modified.push(n.to);
+  }),
+  _2("!", "!", (t2, e) => {
+    (t2.ignored = t2.ignored || []).push(e);
+  }),
+  _2(
+    "?",
+    "?",
+    (t2, e) => t2.not_added.push(e)
+  ),
+  ...et(
+    "A",
+    "A",
+    "U"
+    /* UNMERGED */
+  ),
+  ...et(
+    "D",
+    "D",
+    "U"
+    /* UNMERGED */
+  ),
+  ...et(
+    "U",
+    "A",
+    "D",
+    "U"
+    /* UNMERGED */
+  ),
+  [
+    "##",
+    (t2, e) => {
+      const n = /ahead (\d+)/, r2 = /behind (\d+)/, s = /^(.+?(?=(?:\.{3}|\s|$)))/, o2 = /\.{3}(\S*)/, i = /\son\s(\S+?)(?=\.{3}|$)/;
+      let a = n.exec(e);
+      t2.ahead = a && +a[1] || 0, a = r2.exec(e), t2.behind = a && +a[1] || 0, a = s.exec(e), t2.current = d(a?.[1], m, null), a = o2.exec(e), t2.tracking = d(a?.[1], m, null), a = i.exec(e), a && (t2.current = d(a?.[1], m, t2.current)), t2.detached = /\(no branch\)/.test(e);
+    }
+  ]
+]);
+var Ur = /* @__PURE__ */ __name(function(t2) {
+  const e = t2.split(I2), n = new Br();
+  for (let r2 = 0, s = e.length; r2 < s; ) {
+    let o2 = e[r2++].trim();
+    o2 && (o2.charAt(0) === "R" && (o2 += I2 + (e[r2++] || "")), Fr(n, o2));
+  }
+  return n;
+}, "Ur");
+function Fr(t2, e) {
+  const n = e.trim();
+  switch (" ") {
+    case n.charAt(2):
+      return r2(n.charAt(0), n.charAt(1), n.slice(3));
+    case n.charAt(1):
+      return r2(" ", n.charAt(0), n.slice(2));
+    default:
+      return;
+  }
+  function r2(s, o2, i) {
+    const a = `${s}${o2}`, c3 = Ir.get(a);
+    c3 && c3(t2, i), a !== "##" && a !== "!!" && t2.files.push(new jr(i, s, o2));
+  }
+  __name(r2, "r");
+}
+__name(Fr, "Fr");
+var Gr = ["--null", "-z"];
+function zr(t2) {
+  return {
+    format: "utf-8",
+    commands: [
+      "status",
+      "--porcelain",
+      "-b",
+      "-u",
+      "--null",
+      ...t2.filter((n) => !Gr.includes(n))
+    ],
+    parser(n) {
+      return Ur(n);
+    }
+  };
+}
+__name(zr, "zr");
+var fe = "installed=false";
+function q2(t2 = 0, e = 0, n = 0, r2 = "", s = true) {
+  return Object.defineProperty(
+    {
+      major: t2,
+      minor: e,
+      patch: n,
+      agent: r2,
+      installed: s
+    },
+    "toString",
+    {
+      value() {
+        return `${this.major}.${this.minor}.${this.patch}`;
+      },
+      configurable: false,
+      enumerable: false
+    }
+  );
+}
+__name(q2, "q");
+function qr() {
+  return q2(0, 0, 0, "", false);
+}
+__name(qr, "qr");
+function Wr() {
+  return {
+    version() {
+      return this._runTask({
+        commands: ["--version"],
+        format: "utf-8",
+        parser: Kr,
+        onError(t2, e, n, r2) {
+          if (t2.exitCode === V2.NOT_FOUND)
+            return n(Buffer.from(fe));
+          r2(e);
+        }
+      });
+    }
+  };
+}
+__name(Wr, "Wr");
+var Hr = [
+  new l2(
+    /version (\d+)\.(\d+)\.(\d+)(?:\s*\((.+)\))?/,
+    (t2, [e, n, r2, s = ""]) => {
+      Object.assign(
+        t2,
+        q2(p(e), p(n), p(r2), s)
+      );
+    }
+  ),
+  new l2(
+    /version (\d+)\.(\d+)\.(\D+)(.+)?$/,
+    (t2, [e, n, r2, s = ""]) => {
+      Object.assign(t2, q2(p(e), p(n), r2, s));
+    }
+  )
+];
+function Kr(t2) {
+  return t2 === fe ? qr() : E2(q2(0, 0, 0, t2), Hr, t2);
+}
+__name(Kr, "Kr");
+var le = class {
+  static {
+    __name(this, "le");
+  }
+  constructor(e) {
+    this._executor = e;
+  }
+  _runTask(e, n) {
+    const r2 = this._executor.chain(), s = r2.push(e);
+    return n && Ln(e, s, n), Object.create(this, {
+      then: { value: s.then.bind(s) },
+      catch: { value: s.catch.bind(s) },
+      _executor: { value: r2 }
+    });
+  }
+  add(e) {
+    return this._runTask(
+      g(["add", ...v(e)]),
+      u(arguments)
+    );
+  }
+  cwd(e) {
+    const n = u(arguments);
+    return typeof e == "string" ? this._runTask(St(e, this._executor), n) : typeof e?.path == "string" ? this._runTask(
+      St(
+        e.path,
+        e.root && this._executor || void 0
+      ),
+      n
+    ) : this._runTask(
+      b2("Git.cwd: workingDirectory must be supplied as a string"),
+      n
+    );
+  }
+  hashObject(e, n) {
+    return this._runTask(
+      Vn(e, n === true),
+      u(arguments)
+    );
+  }
+  init(e) {
+    return this._runTask(
+      Zn(e === true, this._executor.cwd, h2(arguments)),
+      u(arguments)
+    );
+  }
+  merge() {
+    return this._runTask(
+      At(h2(arguments)),
+      u(arguments)
+    );
+  }
+  mergeFromTo(e, n) {
+    return m(e) && m(n) ? this._runTask(
+      At([e, n, ...h2(arguments)]),
+      u(arguments, false)
+    ) : this._runTask(
+      b2(
+        "Git.mergeFromTo requires that the 'remote' and 'branch' arguments are supplied as strings"
+      )
+    );
+  }
+  outputHandler(e) {
+    return this._executor.outputHandler = e, this;
+  }
+  push() {
+    const e = ce(
+      {
+        remote: d(arguments[0], m),
+        branch: d(arguments[1], m)
+      },
+      h2(arguments)
+    );
+    return this._runTask(e, u(arguments));
+  }
+  stash() {
+    return this._runTask(
+      g(["stash", ...h2(arguments)]),
+      u(arguments)
+    );
+  }
+  status() {
+    return this._runTask(
+      zr(h2(arguments)),
+      u(arguments)
+    );
+  }
+};
+Object.assign(
+  le.prototype,
+  jn(),
+  In(),
+  zn(),
+  Tn(),
+  Hn(),
+  Kn(),
+  On(),
+  er(),
+  pr(),
+  Dr(),
+  Wr()
+);
+var Vr = /* @__PURE__ */ (() => {
+  let t2 = 0;
+  return () => {
+    t2++;
+    const { promise: e, done: n } = (0, import_promise_deferred.createDeferred)();
+    return {
+      promise: e,
+      done: n,
+      id: t2
+    };
+  };
+})();
+var Xr = class {
+  static {
+    __name(this, "Xr");
+  }
+  constructor(e = 2) {
+    this.concurrency = e, this.logger = $2("", "scheduler"), this.pending = [], this.running = [], this.logger("Constructed, concurrency=%s", e);
+  }
+  schedule() {
+    if (!this.pending.length || this.running.length >= this.concurrency) {
+      this.logger(
+        "Schedule attempt ignored, pending=%s running=%s concurrency=%s",
+        this.pending.length,
+        this.running.length,
+        this.concurrency
+      );
+      return;
+    }
+    const e = S2(this.running, this.pending.shift());
+    this.logger("Attempting id=%s", e.id), e.done(() => {
+      this.logger("Completing id=", e.id), ct(this.running, e), this.schedule();
+    });
+  }
+  next() {
+    const { promise: e, id: n } = S2(this.pending, Vr());
+    return this.logger("Scheduling id=%s", n), this.schedule(), e;
+  }
+};
+function Yr(t2, e) {
+  return g(["apply", ...e, ...t2]);
+}
+__name(Yr, "Yr");
+var he = /* @__PURE__ */ ((t2) => (t2.CURRENT = "*", t2.LINKED = "+", t2))(he || {});
+var Qr = class {
+  static {
+    __name(this, "Qr");
+  }
+  constructor() {
+    this.all = [], this.branches = {}, this.current = "", this.detached = false;
+  }
+  push(e, n, r2, s, o2) {
+    e === "*" && (this.detached = n, this.current = r2), this.all.push(r2), this.branches[r2] = {
+      current: e === "*",
+      linkedWorkTree: e === "+",
+      name: r2,
+      commit: s,
+      label: o2
+    };
+  }
+};
+var Jr = [
+  new l2(
+    /^([*+]\s)?\((?:HEAD )?detached (?:from|at) (\S+)\)\s+([a-z0-9]+)\s(.*)$/,
+    (t2, [e, n, r2, s]) => {
+      t2.push(Nt(e), true, n, r2, s);
+    }
+  ),
+  new l2(
+    /^([*+]\s)?(\S+)\s+([a-z0-9]+)\s?(.*)$/s,
+    (t2, [e, n, r2, s]) => {
+      t2.push(Nt(e), false, n, r2, s);
+    }
+  )
+];
+var Zr = new l2(/^(\S+)$/s, (t2, [e]) => {
+  t2.push(he.CURRENT, false, e, "", "");
+});
+function Nt(t2) {
+  return t2 ? t2.charAt(0) : "";
+}
+__name(Nt, "Nt");
+function me(t2, e = false) {
+  return E2(
+    new Qr(),
+    e ? [Zr] : Jr,
+    t2
+  );
+}
+__name(me, "me");
+var ts = class {
+  static {
+    __name(this, "ts");
+  }
+  constructor() {
+    this.all = [], this.branches = {}, this.errors = [];
+  }
+  get success() {
+    return !this.errors.length;
+  }
+};
+function es(t2, e) {
+  return {
+    branch: t2,
+    hash: e,
+    success: true
+  };
+}
+__name(es, "es");
+function ns(t2) {
+  return {
+    branch: t2,
+    hash: null,
+    success: false
+  };
+}
+__name(ns, "ns");
+var rs = /(\S+)\s+\(\S+\s([^)]+)\)/;
+var pe = /^error[^']+'([^']+)'/m;
+var ss = [
+  new l2(rs, (t2, [e, n]) => {
+    const r2 = es(e, n);
+    t2.all.push(r2), t2.branches[e] = r2;
+  }),
+  new l2(pe, (t2, [e]) => {
+    const n = ns(e);
+    t2.errors.push(n), t2.all.push(n), t2.branches[e] = n;
+  })
+];
+var gt = /* @__PURE__ */ __name((t2, e) => E2(new ts(), ss, [t2, e]), "gt");
+function de(t2, e) {
+  return e === V2.ERROR && pe.test(t2);
+}
+__name(de, "de");
+function os(t2) {
+  const e = ["-d", "-D", "--delete"];
+  return t2.some((n) => e.includes(n));
+}
+__name(os, "os");
+function is(t2) {
+  const e = os(t2), n = t2.includes("--show-current"), r2 = ["branch", ...t2];
+  return r2.length === 1 && r2.push("-a"), r2.includes("-v") || r2.splice(1, 0, "-v"), {
+    format: "utf-8",
+    commands: r2,
+    parser(s, o2) {
+      return e ? gt(s, o2).all[0] : me(s, n);
+    }
+  };
+}
+__name(is, "is");
+function as() {
+  return {
+    format: "utf-8",
+    commands: ["branch", "-v"],
+    parser(t2) {
+      return me(t2);
+    }
+  };
+}
+__name(as, "as");
+function us(t2, e = false) {
+  return {
+    format: "utf-8",
+    commands: ["branch", "-v", e ? "-D" : "-d", ...t2],
+    parser(n, r2) {
+      return gt(n, r2);
+    },
+    onError({ exitCode: n, stdOut: r2 }, s, o2, i) {
+      if (!de(String(s), n))
+        return i(s);
+      o2(r2);
+    }
+  };
+}
+__name(us, "us");
+function cs(t2, e = false) {
+  const n = {
+    format: "utf-8",
+    commands: ["branch", "-v", e ? "-D" : "-d", t2],
+    parser(r2, s) {
+      return gt(r2, s).branches[t2];
+    },
+    onError({ exitCode: r2, stdErr: s, stdOut: o2 }, i, a, c3) {
+      if (!de(String(i), r2))
+        return c3(i);
+      throw new at(
+        n.parser(F2(o2), F2(s)),
+        String(i)
+      );
+    }
+  };
+  return n;
+}
+__name(cs, "cs");
+function fs(t2) {
+  return {
+    commands: ["check-ignore", ...t2],
+    format: "utf-8",
+    parser: ls
+  };
+}
+__name(fs, "fs");
+function ls(t2) {
+  return t2.split(/\n/g).map(hs).filter(Boolean);
+}
+__name(ls, "ls");
+function hs(t2) {
+  const e = t2.trim().replace(/^["']|["']$/g, "");
+  return e && Se(e);
+}
+__name(hs, "hs");
+var ms = [
+  new l2(/From (.+)$/, (t2, [e]) => {
+    t2.remote = e;
+  }),
+  new l2(/\* \[new branch]\s+(\S+)\s*-> (.+)$/, (t2, [e, n]) => {
+    t2.branches.push({
+      name: e,
+      tracking: n
+    });
+  }),
+  new l2(/\* \[new tag]\s+(\S+)\s*-> (.+)$/, (t2, [e, n]) => {
+    t2.tags.push({
+      name: e,
+      tracking: n
+    });
+  }),
+  new l2(/- \[deleted]\s+\S+\s*-> (.+)$/, (t2, [e]) => {
+    t2.deleted.push({
+      tracking: e
+    });
+  }),
+  new l2(
+    /\s*([^.]+)\.\.(\S+)\s+(\S+)\s*-> (.+)$/,
+    (t2, [e, n, r2, s]) => {
+      t2.updated.push({
+        name: r2,
+        tracking: s,
+        to: n,
+        from: e
+      });
+    }
+  )
+];
+function ps(t2, e) {
+  return E2({
+    raw: t2,
+    remote: null,
+    branches: [],
+    tags: [],
+    updated: [],
+    deleted: []
+  }, ms, [t2, e]);
+}
+__name(ps, "ps");
+function ds(t2) {
+  return /^--upload-pack(=|$)/.test(t2);
+}
+__name(ds, "ds");
+function gs(t2, e, n) {
+  const r2 = ["fetch", ...n];
+  return t2 && e && r2.push(t2, e), r2.find(ds) ? b2("git.fetch: potential exploit argument blocked.") : {
+    commands: r2,
+    format: "utf-8",
+    parser: ps
+  };
+}
+__name(gs, "gs");
+var ys = [
+  new l2(/^Renaming (.+) to (.+)$/, (t2, [e, n]) => {
+    t2.moves.push({ from: e, to: n });
+  })
+];
+function ws(t2) {
+  return E2({ moves: [] }, ys, t2);
+}
+__name(ws, "ws");
+function bs(t2, e) {
+  return {
+    commands: ["mv", "-v", ...v(t2), e],
+    format: "utf-8",
+    parser: ws
+  };
+}
+__name(bs, "bs");
+function Ts(t2, e, n) {
+  const r2 = ["pull", ...n];
+  return t2 && e && r2.splice(1, 0, t2, e), {
+    commands: r2,
+    format: "utf-8",
+    parser(s, o2) {
+      return ue(s, o2);
+    },
+    onError(s, o2, i, a) {
+      const c3 = Rr(
+        F2(s.stdOut),
+        F2(s.stdErr)
+      );
+      if (c3)
+        return a(new at(c3));
+      a(o2);
+    }
+  };
+}
+__name(Ts, "Ts");
+function ks(t2) {
+  const e = {};
+  return ge(t2, ([n]) => e[n] = { name: n }), Object.values(e);
+}
+__name(ks, "ks");
+function _s(t2) {
+  const e = {};
+  return ge(t2, ([n, r2, s]) => {
+    Object.hasOwn(e, n) || (e[n] = {
+      name: n,
+      refs: { fetch: "", push: "" }
+    }), s && r2 && (e[n].refs[s.replace(/[^a-z]/g, "")] = r2);
+  }), Object.values(e);
+}
+__name(_s, "_s");
+function ge(t2, e) {
+  ut(t2, (n) => e(n.split(/\s+/)));
+}
+__name(ge, "ge");
+function vs(t2, e, n) {
+  return g(["remote", "add", ...n, t2, e]);
+}
+__name(vs, "vs");
+function Es(t2) {
+  const e = ["remote"];
+  return t2 && e.push("-v"), {
+    commands: e,
+    format: "utf-8",
+    parser: t2 ? _s : ks
+  };
+}
+__name(Es, "Es");
+function Ss(t2) {
+  const e = [...t2];
+  return e[0] !== "ls-remote" && e.unshift("ls-remote"), g(e);
+}
+__name(Ss, "Ss");
+function Rs(t2) {
+  const e = [...t2];
+  return e[0] !== "remote" && e.unshift("remote"), g(e);
+}
+__name(Rs, "Rs");
+function Os(t2) {
+  return g(["remote", "remove", t2]);
+}
+__name(Os, "Os");
+function Cs(t2 = {}, e) {
+  const n = oe2(t2), r2 = ["stash", "list", ...n.commands, ...e], s = re(
+    n.splitter,
+    n.fields,
+    pt(r2)
+  );
+  return dt(r2) || {
+    commands: r2,
+    format: "utf-8",
+    parser: s
+  };
+}
+__name(Cs, "Cs");
+function As(t2, e) {
+  return X2(["add", t2, e]);
+}
+__name(As, "As");
+function xs(t2) {
+  return X2(["init", ...t2]);
+}
+__name(xs, "xs");
+function X2(t2) {
+  const e = [...t2];
+  return e[0] !== "submodule" && e.unshift("submodule"), g(e);
+}
+__name(X2, "X");
+function Ns(t2) {
+  return X2(["update", ...t2]);
+}
+__name(Ns, "Ns");
+var $s = class {
+  static {
+    __name(this, "$s");
+  }
+  constructor(e, n) {
+    this.all = e, this.latest = n;
+  }
+};
+var Ps = /* @__PURE__ */ __name(function(t2, e = false) {
+  const n = t2.split(`
+`).map(Ds).filter(Boolean);
+  e || n.sort(function(s, o2) {
+    const i = s.split("."), a = o2.split(".");
+    if (i.length === 1 || a.length === 1)
+      return Ms(B2(i[0]), B2(a[0]));
+    for (let c3 = 0, y2 = Math.max(i.length, a.length); c3 < y2; c3++) {
+      const w2 = ye(B2(i[c3]), B2(a[c3]));
+      if (w2)
+        return w2;
+    }
+    return 0;
+  });
+  const r2 = e ? n[0] : [...n].reverse().find((s) => s.indexOf(".") >= 0);
+  return new $s(n, r2);
+}, "Ps");
+function Ms(t2, e) {
+  const n = Number.isNaN(t2), r2 = Number.isNaN(e);
+  return n !== r2 ? n ? 1 : -1 : n ? ye(t2, e) : 0;
+}
+__name(Ms, "Ms");
+function ye(t2, e) {
+  return t2 === e ? 0 : t2 > e ? 1 : -1;
+}
+__name(ye, "ye");
+function Ds(t2) {
+  return t2.trim();
+}
+__name(Ds, "Ds");
+function B2(t2) {
+  return typeof t2 == "string" && parseInt(t2.replace(/^\D+/g, ""), 10) || 0;
+}
+__name(B2, "B");
+function Ls(t2 = []) {
+  const e = t2.some((n) => /^--sort=/.test(n));
+  return {
+    format: "utf-8",
+    commands: ["tag", "-l", ...t2],
+    parser(n) {
+      return Ps(n, e);
+    }
+  };
+}
+__name(Ls, "Ls");
+function js(t2) {
+  return {
+    format: "utf-8",
+    commands: ["tag", t2],
+    parser() {
+      return { name: t2 };
+    }
+  };
+}
+__name(js, "js");
+function Bs(t2, e) {
+  return {
+    format: "utf-8",
+    commands: ["tag", "-a", "-m", e, t2],
+    parser() {
+      return { name: t2 };
+    }
+  };
+}
+__name(Bs, "Bs");
+function f2(t2, e) {
+  this._plugins = e, this._executor = new Dn(
+    t2.baseDir,
+    new Xr(t2.maxConcurrentProcesses),
+    e
+  ), this._trimmed = t2.trimmed;
+}
+__name(f2, "f");
+(f2.prototype = Object.create(le.prototype)).constructor = f2;
+f2.prototype.customBinary = function(t2) {
+  return this._plugins.reconfigure("binary", t2), this;
+};
+f2.prototype.env = function(t2, e) {
+  return arguments.length === 1 && typeof t2 == "object" ? this._executor.env = t2 : (this._executor.env = this._executor.env || {})[t2] = e, this;
+};
+f2.prototype.stashList = function(t2) {
+  return this._runTask(
+    Cs(
+      ht(arguments) || {},
+      K2(t2) && t2 || []
+    ),
+    u(arguments)
+  );
+};
+f2.prototype.mv = function(t2, e) {
+  return this._runTask(bs(t2, e), u(arguments));
+};
+f2.prototype.checkoutLatestTag = function(t2) {
+  var e = this;
+  return this.pull(function() {
+    e.tags(function(n, r2) {
+      e.checkout(r2.latest, t2);
+    });
+  });
+};
+f2.prototype.pull = function(t2, e, n, r2) {
+  return this._runTask(
+    Ts(
+      d(t2, m),
+      d(e, m),
+      h2(arguments)
+    ),
+    u(arguments)
+  );
+};
+f2.prototype.fetch = function(t2, e) {
+  return this._runTask(
+    gs(
+      d(t2, m),
+      d(e, m),
+      h2(arguments)
+    ),
+    u(arguments)
+  );
+};
+f2.prototype.tags = function(t2, e) {
+  return this._runTask(
+    Ls(h2(arguments)),
+    u(arguments)
+  );
+};
+f2.prototype.rebase = function() {
+  return this._runTask(
+    g(["rebase", ...h2(arguments)]),
+    u(arguments)
+  );
+};
+f2.prototype.reset = function(t2) {
+  return this._runTask(
+    An(xn(t2), h2(arguments)),
+    u(arguments)
+  );
+};
+f2.prototype.revert = function(t2) {
+  const e = u(arguments);
+  return typeof t2 != "string" ? this._runTask(b2("Commit must be a string"), e) : this._runTask(
+    g(["revert", ...h2(arguments, 0, true), t2]),
+    e
+  );
+};
+f2.prototype.addTag = function(t2) {
+  const e = typeof t2 == "string" ? js(t2) : b2("Git.addTag requires a tag name");
+  return this._runTask(e, u(arguments));
+};
+f2.prototype.addAnnotatedTag = function(t2, e) {
+  return this._runTask(
+    Bs(t2, e),
+    u(arguments)
+  );
+};
+f2.prototype.deleteLocalBranch = function(t2, e, n) {
+  return this._runTask(
+    cs(t2, typeof e == "boolean" ? e : false),
+    u(arguments)
+  );
+};
+f2.prototype.deleteLocalBranches = function(t2, e, n) {
+  return this._runTask(
+    us(t2, typeof e == "boolean" ? e : false),
+    u(arguments)
+  );
+};
+f2.prototype.branch = function(t2, e) {
+  return this._runTask(
+    is(h2(arguments)),
+    u(arguments)
+  );
+};
+f2.prototype.branchLocal = function(t2) {
+  return this._runTask(as(), u(arguments));
+};
+f2.prototype.raw = function(t2) {
+  const e = !Array.isArray(t2), n = [].slice.call(e ? arguments : t2, 0);
+  for (let s = 0; s < n.length && e; s++)
+    if (!st(n[s])) {
+      n.splice(s, n.length - s);
+      break;
+    }
+  n.push(...h2(arguments, 0, true));
+  var r2 = u(arguments);
+  return n.length ? this._runTask(g(n, this._trimmed), r2) : this._runTask(
+    b2("Raw: must supply one or more command to execute"),
+    r2
+  );
+};
+f2.prototype.submoduleAdd = function(t2, e, n) {
+  return this._runTask(As(t2, e), u(arguments));
+};
+f2.prototype.submoduleUpdate = function(t2, e) {
+  return this._runTask(
+    Ns(h2(arguments, true)),
+    u(arguments)
+  );
+};
+f2.prototype.submoduleInit = function(t2, e) {
+  return this._runTask(
+    xs(h2(arguments, true)),
+    u(arguments)
+  );
+};
+f2.prototype.subModule = function(t2, e) {
+  return this._runTask(
+    X2(h2(arguments)),
+    u(arguments)
+  );
+};
+f2.prototype.listRemote = function() {
+  return this._runTask(
+    Ss(h2(arguments)),
+    u(arguments)
+  );
+};
+f2.prototype.addRemote = function(t2, e, n) {
+  return this._runTask(
+    vs(t2, e, h2(arguments)),
+    u(arguments)
+  );
+};
+f2.prototype.removeRemote = function(t2, e) {
+  return this._runTask(Os(t2), u(arguments));
+};
+f2.prototype.getRemotes = function(t2, e) {
+  return this._runTask(Es(t2 === true), u(arguments));
+};
+f2.prototype.remote = function(t2, e) {
+  return this._runTask(
+    Rs(h2(arguments)),
+    u(arguments)
+  );
+};
+f2.prototype.tag = function(t2, e) {
+  const n = h2(arguments);
+  return n[0] !== "tag" && n.unshift("tag"), this._runTask(g(n), u(arguments));
+};
+f2.prototype.updateServerInfo = function(t2) {
+  return this._runTask(
+    g(["update-server-info"]),
+    u(arguments)
+  );
+};
+f2.prototype.pushTags = function(t2, e) {
+  const n = Mr(
+    { remote: d(t2, m) },
+    h2(arguments)
+  );
+  return this._runTask(n, u(arguments));
+};
+f2.prototype.rm = function(t2) {
+  return this._runTask(
+    g(["rm", "-f", ...v(t2)]),
+    u(arguments)
+  );
+};
+f2.prototype.rmKeepLocal = function(t2) {
+  return this._runTask(
+    g(["rm", "--cached", ...v(t2)]),
+    u(arguments)
+  );
+};
+f2.prototype.catFile = function(t2, e) {
+  return this._catFile("utf-8", arguments);
+};
+f2.prototype.binaryCatFile = function() {
+  return this._catFile("buffer", arguments);
+};
+f2.prototype._catFile = function(t2, e) {
+  var n = u(e), r2 = ["cat-file"], s = e[0];
+  if (typeof s == "string")
+    return this._runTask(
+      b2("Git.catFile: options must be supplied as an array of strings"),
+      n
+    );
+  Array.isArray(s) && r2.push.apply(r2, s);
+  const o2 = t2 === "buffer" ? Gt(r2) : g(r2);
+  return this._runTask(o2, n);
+};
+f2.prototype.diff = function(t2, e) {
+  const n = m(t2) ? b2(
+    "git.diff: supplying options as a single string is no longer supported, switch to an array of strings"
+  ) : g(["diff", ...h2(arguments)]);
+  return this._runTask(n, u(arguments));
+};
+f2.prototype.diffSummary = function() {
+  return this._runTask(
+    fr(h2(arguments, 1)),
+    u(arguments)
+  );
+};
+f2.prototype.applyPatch = function(t2) {
+  const e = G2(t2) ? Yr(v(t2), h2([].slice.call(arguments, 1))) : b2(
+    "git.applyPatch requires one or more string patches as the first argument"
+  );
+  return this._runTask(e, u(arguments));
+};
+f2.prototype.revparse = function() {
+  const t2 = ["rev-parse", ...h2(arguments, true)];
+  return this._runTask(
+    g(t2, true),
+    u(arguments)
+  );
+};
+f2.prototype.clean = function(t2, e, n) {
+  const r2 = un(t2), s = r2 && t2.join("") || d(t2, m) || "", o2 = h2([].slice.call(arguments, r2 ? 1 : 0));
+  return this._runTask(
+    on(s, o2),
+    u(arguments)
+  );
+};
+f2.prototype.exec = function(t2) {
+  const e = {
+    commands: [],
+    format: "utf-8",
+    parser() {
+      typeof t2 == "function" && t2();
+    }
+  };
+  return this._runTask(e);
+};
+f2.prototype.checkIgnore = function(t2, e) {
+  return this._runTask(
+    fs(v(d(t2, G2, []))),
+    u(arguments)
+  );
+};
+f2.prototype.checkIsRepo = function(t2, e) {
+  return this._runTask(
+    We(d(t2, m)),
+    u(arguments)
+  );
+};
+function Is(t2) {
+  return t2 ? [{
+    type: "spawn.before",
+    action(r2, s) {
+      t2.aborted && s.kill(new A2(void 0, "abort", "Abort already signaled"));
+    }
+  }, {
+    type: "spawn.after",
+    action(r2, s) {
+      function o2() {
+        s.kill(new A2(void 0, "abort", "Abort signal received"));
+      }
+      __name(o2, "o");
+      t2.addEventListener("abort", o2), s.spawned.on("close", () => t2.removeEventListener("abort", o2));
+    }
+  }] : void 0;
+}
+__name(Is, "Is");
+var Us = $2("", "plugin:allowEnvironment");
+function Fs(t2, e = false) {
+  const n = new Set(t2.map((r2) => r2.toLowerCase().trim()));
+  return {
+    type: "spawn.options",
+    action(r2, s) {
+      const o2 = { ...r2.env ?? process.env }, i = new Set(
+        Object.keys(s.env).map((a) => a.toLowerCase().trim())
+      );
+      for (const a of Object.keys(o2)) {
+        const c3 = a.toLowerCase().trim();
+        if (!(!Gs(c3) || n.has(c3))) {
+          if (i.has(c3))
+            throw new A2(
+              void 0,
+              "allowEnvironment",
+              `Use of "${a}" is blocked by the environment guard - add it to the allowEnvironment option to permit it`
+            );
+          Us("removing ambient guarded environment variable %s", a), delete o2[a];
+        }
+      }
+      return {
+        ...r2,
+        env: {
+          ...o2,
+          GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS: String(!e)
+        }
+      };
+    }
+  };
+}
+__name(Fs, "Fs");
+function Gs(t2) {
+  const e = t2.toLowerCase().trim();
+  return e.startsWith("git_") || _(e);
+}
+__name(Gs, "Gs");
+function zs(t2 = {}) {
+  return {
+    type: "spawn.args",
+    action(e, { env: n }) {
+      for (const r2 of oe(e, n))
+        if (t2[r2.category] !== true)
+          throw new A2(void 0, "unsafe", r2.message);
+      return e;
+    }
+  };
+}
+__name(zs, "zs");
+function qs(t2) {
+  const e = U(t2, "-c");
+  return {
+    type: "spawn.args",
+    action(n) {
+      return [...e, ...n];
+    }
+  };
+}
+__name(qs, "qs");
+var $t = (0, import_promise_deferred.deferred)().promise;
+function Ws({
+  onClose: t2 = true,
+  onExit: e = 50
+} = {}) {
+  function n() {
+    let s = -1;
+    const o2 = {
+      close: (0, import_promise_deferred.deferred)(),
+      closeTimeout: (0, import_promise_deferred.deferred)(),
+      exit: (0, import_promise_deferred.deferred)(),
+      exitTimeout: (0, import_promise_deferred.deferred)()
+    }, i = Promise.race([
+      t2 === false ? $t : o2.closeTimeout.promise,
+      e === false ? $t : o2.exitTimeout.promise
+    ]);
+    return r2(t2, o2.close, o2.closeTimeout), r2(e, o2.exit, o2.exitTimeout), {
+      close(a) {
+        s = a, o2.close.done();
+      },
+      exit(a) {
+        s = a, o2.exit.done();
+      },
+      get exitCode() {
+        return s;
+      },
+      result: i
+    };
+  }
+  __name(n, "n");
+  function r2(s, o2, i) {
+    s !== false && (s === true ? o2.promise : o2.promise.then(() => wt(s))).then(i.done);
+  }
+  __name(r2, "r");
+  return {
+    type: "spawn.after",
+    async action(s, { spawned: o2, close: i }) {
+      const a = n();
+      let c3 = true, y2 = /* @__PURE__ */ __name(() => {
+        c3 = false;
+      }, "y");
+      o2.stdout?.on("data", y2), o2.stderr?.on("data", y2), o2.on("error", y2), o2.on("close", (w2) => a.close(w2)), o2.on("exit", (w2) => a.exit(w2));
+      try {
+        await a.result, c3 && await wt(50), i(a.exitCode);
+      } catch (w2) {
+        i(a.exitCode, w2);
+      }
+    }
+  };
+}
+__name(Ws, "Ws");
+var we = $2("", "plugin:binary");
+var Hs = "Invalid value supplied for custom binary, requires a single string or an array containing either one or two strings";
+var Ks = "Invalid value supplied for custom binary, restricted characters must be removed or supply the unsafe.allowUnsafeCustomBinary option";
+function Vs(t2) {
+  return !t2 || !/^([a-z]:)?([a-z0-9/.\\_~-]+)$/i.test(t2);
+}
+__name(Vs, "Vs");
+function Pt(t2, e) {
+  if (t2.length < 1 || t2.length > 2)
+    throw new A2(void 0, "binary", Hs);
+  if (t2.some(Vs))
+    if (e)
+      we("permitted unsafe binary %o", t2);
+    else
+      throw new A2(void 0, "binary", Ks);
+  const [r2, s] = t2;
+  return {
+    binary: r2,
+    prefix: s
+  };
+}
+__name(Pt, "Pt");
+function Xs(t2, e = ["git"], n = false) {
+  let r2 = Pt(v(e), n);
+  t2.on("binary", (s) => {
+    r2 = Pt(v(s), n), we.info("reconfiguring %o", r2);
+  }), t2.append("spawn.binary", () => r2.binary), t2.append("spawn.args", (s) => r2.prefix ? [r2.prefix, ...s] : s);
+}
+__name(Xs, "Xs");
+var be = {
+  DISALLOWED_ABBREVIATED: {
+    text: "disallowed abbreviated or ambiguous option",
+    solution: "Unambiguous abbreviated options blocked with unsafe.allowAbbreviatedOptions setting: {message}"
+  },
+  UNKNOWN: {
+    text: "~ unknown ~",
+    solution: void 0
+  }
+};
+function Ys(t2) {
+  if (!t2)
+    return "UNKNOWN";
+  for (const [e, { text: n }] of Object.entries(be))
+    if (t2.startsWith(`fatal: ${n}`))
+      return e;
+  return "UNKNOWN";
+}
+__name(Ys, "Ys");
+var Qs = class extends O2 {
+  static {
+    __name(this, "Qs");
+  }
+  constructor(e = "") {
+    const n = Ys(e);
+    super(void 0, be[n].solution?.replace("{message}", e) ?? e), this.reason = n;
+  }
+};
+function Js(t2) {
+  return !!(t2.exitCode && t2.stdErr.length);
+}
+__name(Js, "Js");
+function Zs(t2) {
+  return Buffer.concat([...t2.stdOut, ...t2.stdErr]);
+}
+__name(Zs, "Zs");
+function to(t2 = false, e = Js, n = Zs) {
+  return (r2, s) => !t2 && r2 || !e(s) ? r2 : n(s);
+}
+__name(to, "to");
+function eo(t2, e) {
+  return t2 === 128 && e.startsWith("fatal:") ? new Qs(e) : new O2(void 0, e);
+}
+__name(eo, "eo");
+function Mt(t2) {
+  return {
+    type: "task.error",
+    action(e, n) {
+      const r2 = t2(e.error, {
+        stdErr: n.stdErr,
+        stdOut: n.stdOut,
+        exitCode: n.exitCode
+      });
+      return Buffer.isBuffer(r2) ? {
+        error: eo(n.exitCode, r2.toString("utf-8"))
+      } : {
+        error: r2
+      };
+    }
+  };
+}
+__name(Mt, "Mt");
+var nt = $2("", "plugin:input");
+function no(t2) {
+  return {
+    type: "spawn.after",
+    action(e, { commands: n, input: r2, spawned: { stdin: s } }) {
+      if (!s)
+        return;
+      const o2 = t2?.([...n]) ?? r2;
+      if (!o2)
+        return nt("generated zero length content, not writing to stdin");
+      nt("writing %s bytes to stdin", Le(o2)), s.on("error", (i) => {
+        i.code !== "EPIPE" && nt("[ERROR] stdin error %o", i);
+      }), s.end(o2);
+    }
+  };
+}
+__name(no, "no");
+var ro = class {
+  static {
+    __name(this, "ro");
+  }
+  constructor() {
+    this.plugins = /* @__PURE__ */ new Set(), this.events = new Ce();
+  }
+  on(e, n) {
+    this.events.on(e, n);
+  }
+  reconfigure(e, n) {
+    this.events.emit(e, n);
+  }
+  append(e, n) {
+    const r2 = S2(this.plugins, { type: e, action: n });
+    return () => this.plugins.delete(r2);
+  }
+  add(e) {
+    const n = [];
+    return v(e).forEach(
+      (r2) => {
+        r2 && this.plugins.add(S2(n, r2));
+      }
+    ), () => {
+      n.forEach((r2) => {
+        this.plugins.delete(r2);
+      });
+    };
+  }
+  exec(e, n, r2) {
+    let s = n;
+    const o2 = Object.freeze(Object.create(r2));
+    for (const i of this.plugins)
+      i.type === e && (s = i.action(s, o2));
+    return s;
+  }
+};
+function so(t2) {
+  const e = "--progress", n = ["checkout", "clone", "fetch", "pull", "push"];
+  return [{
+    type: "spawn.args",
+    action(o2, i) {
+      return n.includes(i.method) ? De(o2, e) : o2;
+    }
+  }, {
+    type: "spawn.after",
+    action(o2, i) {
+      i.commands.includes(e) && i.spawned.stderr?.on("data", (a) => {
+        const c3 = /^([\s\S]+?):\s*(\d+)% \((\d+)\/(\d+)\)/.exec(a.toString("utf8"));
+        c3 && t2({
+          method: i.method,
+          stage: oo(c3[1]),
+          progress: p(c3[2]),
+          processed: p(c3[3]),
+          total: p(c3[4])
+        });
+      });
+    }
+  }];
+}
+__name(so, "so");
+function oo(t2) {
+  return String(t2.toLowerCase().split(" ", 1)) || "unknown";
+}
+__name(oo, "oo");
+function io(t2) {
+  const e = je(t2, ["uid", "gid"]);
+  return {
+    type: "spawn.options",
+    action(n) {
+      return { ...e, ...n };
+    }
+  };
+}
+__name(io, "io");
+function ao() {
+  return {
+    type: "spawn.args",
+    action(t2) {
+      const e = [];
+      let n;
+      function r2(s) {
+        (n = n || []).push(...s);
+      }
+      __name(r2, "r");
+      for (let s = 0; s < t2.length; s++) {
+        const o2 = t2[s];
+        if (r(o2)) {
+          r2(o(o2));
+          continue;
+        }
+        if (o2 === "--") {
+          r2(
+            t2.slice(s + 1).flatMap((i) => r(i) && o(i) || i)
+          );
+          break;
+        }
+        e.push(o2);
+      }
+      return n ? [...e, "--", ...n.map(String)] : e;
+    }
+  };
+}
+__name(ao, "ao");
+function uo({
+  block: t2,
+  stdErr: e = true,
+  stdOut: n = true
+}) {
+  if (t2 > 0)
+    return {
+      type: "spawn.after",
+      action(r2, s) {
+        let o2;
+        function i() {
+          o2 && clearTimeout(o2), o2 = setTimeout(c3, t2);
+        }
+        __name(i, "i");
+        function a() {
+          s.spawned.stdout?.off("data", i), s.spawned.stderr?.off("data", i), s.spawned.off("exit", a), s.spawned.off("close", a), o2 && clearTimeout(o2);
+        }
+        __name(a, "a");
+        function c3() {
+          a(), s.kill(new A2(void 0, "timeout", "block timeout reached"));
+        }
+        __name(c3, "c");
+        n && s.spawned.stdout?.on("data", i), e && s.spawned.stderr?.on("data", i), s.spawned.on("exit", a), s.spawned.on("close", a), i();
+      }
+    };
+}
+__name(uo, "uo");
+var wo = /* @__PURE__ */ __name((t2, e) => {
+  const n = new ro(), r2 = Ge(
+    t2 && (typeof t2 == "string" ? { baseDir: t2 } : t2) || {},
+    e
+  );
+  if (!Lt(r2.baseDir))
+    throw new Ae(
+      r2,
+      "Cannot use simple-git on a directory that does not exist"
+    );
+  return Array.isArray(r2.config) && n.add(qs(r2.config)), n.add(zs(r2.unsafe)), n.add(Ws(r2.completion)), r2.abort && n.add(Is(r2.abort)), r2.progress && n.add(so(r2.progress)), r2.timeout && n.add(uo(r2.timeout)), r2.spawnOptions && n.add(io(r2.spawnOptions)), n.add(ao()), n.add(no(r2.input)), n.add(Mt(to(true))), r2.errors && n.add(Mt(r2.errors)), Xs(n, r2.binary, r2.unsafe?.allowUnsafeCustomBinary), n.add(
+    Fs(r2.allowEnvironment ?? [], r2.unsafe?.allowAbbreviatedOptions)
+  ), new f2(r2, n);
+}, "wo");
+export {
+  qe as CheckRepoActions,
+  zt as CleanOptions,
+  Kt as DiffNameStatus,
+  Ht as GitConfigScope,
+  Ae as GitConstructError,
+  O2 as GitError,
+  A2 as GitPluginError,
+  at as GitResponseError,
+  Vt as ResetMode,
+  xe as TaskConfigurationError,
+  Sn as grepQueryBuilder,
+  c as pathspec,
+  wo as simpleGit
+};