@zuplo/cli 7.13.3 → 7.13.4

package/node_modules/@simple-git/argv-parser/dist/index.mjs

@@ -1,10 +1,10 @@
-import { isPathSpec as m, toPaths as v } from "@simple-git/args-pathspec";
-function* U(e, t) {
-  const n = t === "global";
+import { isPathSpec as v, toPaths as U } from "@simple-git/args-pathspec";
+function* x(e, n) {
+  const t = n === "global";
   for (const o of e)
-    o.isGlobal === n && (yield o);
+    o.isGlobal === t && (yield o);
 }
-const k = /* @__PURE__ */ new Set([
+const P = /* @__PURE__ */ new Set([
   "--add",
   "--edit",
   "--remove-section",
@@ -22,45 +22,45 @@ const k = /* @__PURE__ */ new Set([
   "--get-urlmatch",
   "--list",
   "-l"
-]), P = /* @__PURE__ */ new Set([
+]), E = /* @__PURE__ */ new Set([
   "edit",
   "remove-section",
   "rename-section",
   "set",
   "unset"
-]), E = /* @__PURE__ */ new Set(["get", "get-color", "get-colorbool", "list"]);
-function F(e, t) {
-  for (const { name: o } of U(e, "task")) {
-    if (k.has(o))
-      return p(!0, t);
+]), F = /* @__PURE__ */ new Set(["get", "get-color", "get-colorbool", "list"]);
+function A(e, n) {
+  for (const { name: o } of x(e, "task")) {
+    if (P.has(o))
+      return w(!0, n);
     if (S.has(o))
-      return p(!1, t);
+      return w(!1, n);
   }
-  const n = t.at(0)?.toLowerCase();
-  return n === void 0 ? null : P.has(n) ? p(!0, t.slice(1)) : E.has(n) ? p(!1, t.slice(1)) : t.length === 1 ? p(!1, t) : p(!0, t);
+  const t = n.at(0)?.toLowerCase();
+  return t === void 0 ? null : E.has(t) ? w(!0, n.slice(1)) : F.has(t) ? w(!1, n.slice(1)) : n.length === 1 ? w(!1, n) : w(!0, n);
 }
-function p(e = !1, t = []) {
-  const n = t.at(0)?.toLowerCase();
-  return n === void 0 ? null : {
+function w(e = !1, n = []) {
+  const t = n.at(0)?.toLowerCase();
+  return t === void 0 ? null : {
     isWrite: e,
     isRead: !e,
-    key: n,
-    value: t.at(1)
+    key: t,
+    value: n.at(1)
   };
 }
-function A(e, t) {
-  return t.isWrite && t.value !== void 0 ? { key: t.key, value: t.value, scope: e } : { key: t.key, scope: e };
+function O(e, n) {
+  return n.isWrite && n.value !== void 0 ? { key: n.key, value: n.value, scope: e } : { key: n.key, scope: e };
 }
-function M(e) {
-  const t = e?.indexOf("=") || -1;
-  return !e || t < 0 ? null : {
-    key: e.slice(0, t).trim().toLowerCase(),
-    value: e.slice(t + 1)
+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)
   };
 }
-function N(e) {
-  for (const { name: t } of U(e, "task"))
-    switch (t) {
+function M(e) {
+  for (const { name: n } of x(e, "task"))
+    switch (n) {
       case "--global":
         return "global";
       case "--system":
@@ -75,44 +75,44 @@ function N(e) {
     }
   return "local";
 }
-function G({ name: e }) {
+function N({ name: e }) {
   if (e === "-c" || e === "--config")
     return "inline";
   if (e === "--config-env")
     return "env";
 }
-function* O(e) {
-  for (const t of e) {
-    const n = G(t), o = n && M(t.value);
+function* $(e) {
+  for (const n of e) {
+    const t = N(n), o = t && G(n.value);
     o && (yield {
       ...o,
-      scope: n
+      scope: t
     });
   }
 }
-function L(e, t, n) {
+function D(e, n, t) {
   const o = {
     read: [],
-    write: [...O(t)]
+    write: [...$(n)]
   };
-  return e === "config" && $(
+  return e === "config" && L(
     o,
-    N(t),
-    F(t, n)
+    M(n),
+    A(n, t)
   ), o;
 }
-function $(e, t, n) {
-  if (n === null)
+function L(e, n, t) {
+  if (t === null)
     return;
-  const o = A(t, n);
-  n.isWrite ? e.write.push(o) : e.read.push(o);
+  const o = O(n, t);
+  t.isWrite ? e.write.push(o) : e.read.push(o);
 }
-const x = {
+const C = {
   short: /* @__PURE__ */ new Map([
     ["c", !0]
     //  -c <k=v>    set config key for this invocation
   ])
-}, D = {
+}, I = {
   short: new Map([
     ["C", !0],
     //  -C <path>   change working directory
@@ -124,7 +124,7 @@ const x = {
     // -p          paginate
     ["v", !1],
     // -v          version
-    ...x.short.entries()
+    ...C.short.entries()
   ]),
   long: /* @__PURE__ */ new Set([
     "attr-source",
@@ -199,188 +199,231 @@ const x = {
   push: {
     short: /* @__PURE__ */ new Map(),
     long: /* @__PURE__ */ new Set(["exec", "receive-pack"])
+  },
+  rebase: {
+    short: /* @__PURE__ */ new Map([
+      ["X", !0],
+      // -X <option>   strategy option
+      ["f", !1],
+      // -f force-rebase
+      ["i", !1],
+      // -i interactive
+      ["k", !1],
+      // -k keep-base
+      ["m", !1],
+      // -m merge
+      ["n", !1],
+      // -n no-stat
+      ["q", !1],
+      // -q quiet
+      ["r", !1],
+      // -r rebase-merges
+      ["s", !0],
+      // -s <strategy>
+      ["v", !1],
+      // -v verbose
+      ["x", !0]
+      // -x <cmd>      exec
+    ]),
+    long: /* @__PURE__ */ new Set(["exec", "onto", "strategy", "strategy-option"])
   }
 }, T = { short: /* @__PURE__ */ new Map(), long: /* @__PURE__ */ new Set() };
-function I(e) {
-  const t = R[e ?? ""] ?? T;
+function B(e) {
+  const n = R[e ?? ""] ?? T;
   return {
-    short: new Map([...x.short.entries(), ...t.short.entries()]),
-    long: t.long
+    short: new Map([...C.short.entries(), ...n.short.entries()]),
+    long: n.long
   };
 }
-function b(e, t = D) {
+function b(e, n = I) {
   if (e.startsWith("--")) {
-    const n = e.indexOf("=");
-    if (n > 2)
-      return [{ name: e.slice(0, n), value: e.slice(n + 1), needsNext: !1 }];
+    const t = e.indexOf("=");
+    if (t > 2)
+      return [{ name: e.slice(0, t), value: e.slice(t + 1), needsNext: !1 }];
     const o = e.slice(2);
-    return [{ name: e, needsNext: t.long.has(o) }];
+    return [{ name: e, needsNext: n.long.has(o) }];
   }
   if (e.length === 2) {
-    const n = e.charAt(1), o = t.short.get(n);
+    const t = e.charAt(1), o = n.short.get(t);
     return [{ name: e, needsNext: o === !0 }];
   }
-  return W(e, t.short);
+  return j(e, n.short);
 }
-function W(e, t) {
-  const n = e.slice(1).split(""), o = [];
-  for (let s = 0; s < n.length; s++) {
-    const r = n[s], l = t.get(r);
-    if (l === void 0)
+function j(e, n) {
+  const t = e.slice(1).split(""), o = [];
+  for (let a = 0; a < t.length; a++) {
+    const s = t[a], r = n.get(s);
+    if (r === void 0)
       return [{ name: e, needsNext: !1 }];
-    if (l) {
-      const a = n.slice(s + 1).join("");
-      if (a && ![...a].every((w) => t.has(w)))
-        return o.push({ name: `-${r}`, value: a, needsNext: !1 }), o;
+    if (r) {
+      const i = t.slice(a + 1).join("");
+      if (i && ![...i].every((m) => n.has(m)))
+        return o.push({ name: `-${s}`, value: i, needsNext: !1 }), o;
     }
-    o.push({ name: `-${r}`, needsNext: l });
+    o.push({ name: `-${s}`, needsNext: r });
   }
   return o;
 }
-function j(e, t = []) {
-  let n = 0;
-  for (; n < e.length; ) {
-    const o = String(e[n]);
+function W(e, n = []) {
+  let t = 0;
+  for (; t < e.length; ) {
+    const o = String(e[t]);
     if (!o.startsWith("-") || o.length < 2) break;
-    const s = b(o);
-    let r = n + 1;
-    for (const l of s) {
-      const a = {
-        name: l.name,
-        value: l.value,
+    const a = b(o);
+    let s = t + 1;
+    for (const r of a) {
+      const i = {
+        name: r.name,
+        value: r.value,
         absorbedNext: !1,
         isGlobal: !0
       };
-      l.needsNext && a.value === void 0 && r < e.length && (a.value = String(e[r]), a.absorbedNext = !0, r++), t.push(a);
+      r.needsNext && i.value === void 0 && s < e.length && (i.value = String(e[s]), i.absorbedNext = !0, s++), n.push(i);
     }
-    n = r;
+    t = s;
   }
-  return { flags: t, taskIndex: n };
+  return { flags: n, taskIndex: t };
 }
-function B(e, t, n = []) {
-  const o = I(t), s = [], r = [];
-  let l = 0;
-  for (; l < e.length; ) {
-    const a = e[l];
-    if (m(a)) {
-      r.push(...v(a)), l++;
+function V(e, n, t = []) {
+  const o = B(n), a = [], s = [];
+  let r = 0;
+  for (; r < e.length; ) {
+    const i = e[r];
+    if (v(i)) {
+      s.push(...U(i)), r++;
       continue;
     }
-    const f = String(a);
-    if (f === "--") {
-      for (let g = l + 1; g < e.length; g++) {
-        const u = e[g];
-        m(u) ? r.push(...v(u)) : r.push(String(u));
+    const p = String(i);
+    if (p === "--") {
+      for (let d = r + 1; d < e.length; d++) {
+        const g = e[d];
+        v(g) ? s.push(...U(g)) : s.push(String(g));
       }
       break;
     }
-    if (!f.startsWith("-") || f.length < 2) {
-      s.push(f), l++;
+    if (!p.startsWith("-") || p.length < 2) {
+      a.push(p), r++;
       continue;
     }
-    const w = b(f, o);
-    let d = l + 1;
-    for (const g of w) {
-      const u = {
-        name: g.name,
-        value: g.value,
+    const m = b(p, o);
+    let u = r + 1;
+    for (const d of m) {
+      const g = {
+        name: d.name,
+        value: d.value,
         absorbedNext: !1,
         isGlobal: !1
       };
-      g.needsNext && u.value === void 0 && d < e.length && !m(e[d]) && (u.value = String(e[d]), u.absorbedNext = !0, d++), n.push(u);
+      d.needsNext && g.value === void 0 && u < e.length && !v(e[u]) && (g.value = String(e[u]), g.absorbedNext = !0, u++), t.push(g);
     }
-    l = d;
+    r = u;
   }
-  return { flags: n, positionals: s, pathspecs: r };
+  return { flags: t, positionals: a, pathspecs: s };
 }
-function* V({
+function* q({
   write: e
 }) {
-  for (const t of e)
-    for (const n of q) {
-      const o = n(t.key);
+  for (const n of e)
+    for (const t of K) {
+      const o = t(n.key);
       o && (yield o);
     }
 }
-function c(e, t, n = String(e)) {
+function f(e, n, t = String(e)) {
   const o = typeof e == "string" ? new RegExp(`\\s*${e.toLowerCase()}`) : e;
-  return function(r) {
-    if (o.test(r))
+  return function(s) {
+    if (o.test(s))
       return {
-        category: t,
-        message: `Configuring ${n} is not permitted without enabling ${t}`
+        category: n,
+        message: `Configuring ${t} is not permitted without enabling ${n}`
       };
   };
 }
-function i(e, t) {
-  const n = new RegExp(`\\s*${e.toLowerCase().replace(/\./g, "(..+)?.")}`);
-  return c(n, t, e);
+function l(e, n) {
+  const t = new RegExp(`\\s*${e.toLowerCase().replace(/\./g, "(..+)?.")}`);
+  return f(t, n, e);
 }
-const q = [
-  c("alias", "allowUnsafeAlias"),
-  c("core.askPass", "allowUnsafeAskPass"),
-  c("core.editor", "allowUnsafeEditor"),
-  c("core.fsmonitor", "allowUnsafeFsMonitor"),
-  c("core.gitProxy", "allowUnsafeGitProxy"),
-  c("core.hooksPath", "allowUnsafeHooksPath"),
-  c("core.pager", "allowUnsafePager"),
-  c("core.sshCommand", "allowUnsafeSshCommand"),
-  i("credential.helper", "allowUnsafeCredentialHelper"),
-  i("diff.command", "allowUnsafeDiffExternal"),
-  c("diff.external", "allowUnsafeDiffExternal"),
-  i("diff.textconv", "allowUnsafeDiffTextConv"),
-  i("filter.clean", "allowUnsafeFilter"),
-  i("filter.smudge", "allowUnsafeFilter"),
-  i("gpg.program", "allowUnsafeGpgProgram"),
-  c("init.templateDir", "allowUnsafeTemplateDir"),
-  i("merge.driver", "allowUnsafeMergeDriver"),
-  i("mergetool.path", "allowUnsafeMergeDriver"),
-  i("mergetool.cmd", "allowUnsafeMergeDriver"),
-  i("protocol.allow", "allowUnsafeProtocolOverride"),
-  i("remote.receivepack", "allowUnsafePack"),
-  i("remote.uploadpack", "allowUnsafePack"),
-  c("sequence.editor", "allowUnsafeEditor")
+const 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* K(e, t) {
-  for (const n of t)
-    for (const o of H) {
-      const s = o(e, n.name);
-      s && (yield s);
+function* H(e, n) {
+  for (const t of n)
+    for (const o of X) {
+      const a = o(e, t);
+      a && (yield a);
     }
 }
-function h(e, t, n, o = String(t)) {
-  const s = typeof t == "string" ? new RegExp(`\\s*${t.toLowerCase()}`) : t, r = `Use of ${e ? `${e} with option ` : ""}${o} is not permitted without enabling ${n}`;
-  return function(a, f) {
-    if ((!e || a === e) && s.test(f))
+function c(e, n, t, { name: o = String(n), globalOnly: a = !1, withValue: s = !1 } = {}) {
+  const r = typeof n == "string" ? new RegExp(`\\s*${n.toLowerCase()}`) : n, i = `Use of ${e ? `${e} with option ` : ""}${o} is not permitted without enabling ${t}`;
+  return function(m, u) {
+    if (!(e && m !== e) && !(a && !u.isGlobal) && !(s && u.value === void 0) && r.test(u.name))
       return {
-        category: n,
-        message: r
+        category: t,
+        message: i
       };
   };
 }
-const H = [
-  h(
-    null,
-    /--(upload|receive)-pack/,
-    "allowUnsafePack",
-    "--upload-pack or --receive-pack"
-  ),
-  h("clone", /^-\w*u/, "allowUnsafePack"),
-  h("clone", "--u", "allowUnsafePack"),
-  h("push", "--exec", "allowUnsafePack"),
-  h(null, "--template", "allowUnsafeTemplateDir")
+const h = { globalOnly: !0, withValue: !0 }, X = [
+  c(null, /--(upload|receive)-pack/, "allowUnsafePack", {
+    name: "--upload-pack or --receive-pack"
+  }),
+  c("clone", /^-\w*u/, "allowUnsafePack"),
+  c("clone", "--u", "allowUnsafePack"),
+  c("push", /^--exec$/, "allowUnsafePack", { name: "--exec" }),
+  // `git` accepts unambiguous abbreviations of long options, so `--ex` and `--exe` are `--exec`
+  c("rebase", /^(-x|--ex(ec?)?)$/, "allowUnsafeExec", { name: "-x or --exec" }),
+  c(null, "--template", "allowUnsafeTemplateDir"),
+  c(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
+  c(null, "--git-dir", "allowUnsafeConfigPaths", h),
+  c(null, "--work-tree", "allowUnsafeConfigPaths", h),
+  c(null, /^-C$/, "allowUnsafeConfigPaths", { ...h, name: "-C" })
 ];
-function C(e, t, n) {
-  return [...K(e, t), ...V(n)];
+function k(e, n, t) {
+  return [...H(e, n), ...q(t)];
 }
 function Y(...e) {
-  const { flags: t, taskIndex: n } = j(e), o = n < e.length ? String(e[n]).toLowerCase() : null, s = o !== null ? e.slice(n + 1) : [], { positionals: r, pathspecs: l } = B(s, o, t), a = L(o, t, r);
+  const { flags: n, taskIndex: t } = W(e), o = t < e.length ? String(e[t]).toLowerCase() : null, a = o !== null ? e.slice(t + 1) : [], { positionals: s, pathspecs: r } = V(a, o, n), i = D(o, n, s);
   return {
     task: o,
-    flags: t.map(J),
-    paths: l,
-    config: a,
-    vulnerabilities: z(C(o, t, a))
+    flags: n.map(J),
+    paths: r,
+    config: i,
+    vulnerabilities: z(k(o, n, i))
   };
 }
 function z(e) {
@@ -388,8 +431,8 @@ function z(e) {
     value: e
   });
 }
-function J({ value: e, name: t }) {
-  return e !== void 0 ? { name: t, value: e } : { name: t };
+function J({ value: e, name: n }) {
+  return e !== void 0 ? { name: n, value: e } : { name: n };
 }
 const y = {
   editor: "allowUnsafeEditor",
@@ -397,9 +440,10 @@ const y = {
   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: "allowUnsafeConfigPaths",
+  git_exec_path: "allowUnsafeExec",
   git_external_diff: "allowUnsafeDiffExternal",
   git_pager: "allowUnsafePager",
   git_proxy_command: "allowUnsafeGitProxy",
@@ -409,55 +453,57 @@ const y = {
   git_ssh_command: "allowUnsafeSshCommand",
   pager: "allowUnsafePager",
   prefix: "allowUnsafeConfigPaths",
-  ssh_askpass: "allowUnsafeAskPass"
+  ssh_askpass: "allowUnsafeAskPass",
+  visual: "allowUnsafeEditor"
 };
 function* Q(e) {
-  const t = parseInt(e.git_config_count ?? "0", 10);
-  for (let n = 0; n < t; n++) {
-    const o = e[`git_config_key_${n}`], s = e[`git_config_value_${n}`];
-    o !== void 0 && (yield { key: o.toLowerCase().trim(), value: s, scope: "env" });
+  const n = parseInt(e.git_config_count ?? "0", 10);
+  for (let t = 0; t < n; t++) {
+    const o = e[`git_config_key_${t}`], a = e[`git_config_value_${t}`];
+    o !== void 0 && (yield { key: o.toLowerCase().trim(), value: a, scope: "env" });
   }
 }
-function* X(e) {
-  for (const t of Object.keys(e))
-    if (_(t)) {
-      const n = y[t];
+function* Z(e) {
+  for (const n of Object.keys(e))
+    if (_(n)) {
+      const t = y[n];
       yield {
-        category: n,
-        message: `Use of "${t.toUpperCase()}" is not permitted without enabling ${n}`
+        category: t,
+        message: `Use of "${n.toUpperCase()}" is not permitted without enabling ${t}`
       };
     }
 }
 function _(e) {
   return Object.hasOwn(y, e);
 }
-function Z(e) {
-  const t = {};
-  for (const [n, o] of Object.entries(e)) {
-    const s = n.toLowerCase().trim();
-    (_(s) || s.startsWith("git")) && (t[s] = String(o));
+function ee(e) {
+  const n = {};
+  for (const [t, o] of Object.entries(e)) {
+    const a = t.toLowerCase().trim();
+    (_(a) || a.startsWith("git")) && (n[a] = String(o));
   }
-  return t;
+  return n;
 }
-function ee(e) {
-  const t = Z(e), n = {
+function ne(e) {
+  const n = ee(e), t = {
     read: [],
-    write: [...Q(t)]
+    write: [...Q(n)]
   }, o = [
-    ...X(t),
-    ...C(null, [], n)
+    ...Z(n),
+    ...k(null, [], t)
   ];
   return {
-    config: n,
+    config: t,
     vulnerabilities: o
   };
 }
-function ne(e, t) {
-  return [...Y(...e).vulnerabilities, ...ee(t).vulnerabilities];
+function oe(e, n) {
+  return [...Y(...e).vulnerabilities, ...ne(n).vulnerabilities];
 }
 export {
+  _ as isGitEnvKey,
   Y as parseArgv,
-  ee as parseEnv,
-  ne as vulnerabilityCheck
+  ne as parseEnv,
+  oe as vulnerabilityCheck
 };
 //# sourceMappingURL=index.mjs.map