@sourcegraph/amp 0.0.1748851339-g31df22 → 0.0.1748877319-g69d2be

package/dist/index-DDEnF9L5.js

@@ -0,0 +1,922 @@
+#!/usr/bin/env node
+import { z as xt } from "./console-Dz8kjLXq.js";
+var pt = {}, ft, Et;
+function ct() {
+  if (Et) return ft;
+  Et = 1;
+  const A = "\\\\/", b = `[^${A}]`, y = "\\.", U = "\\+", P = "\\?", a = "\\/", u = "(?=.)", i = "[^/]", p = `(?:${a}|$)`, H = `(?:^|${a})`, c = `${y}{1,2}${p}`, C = `(?!${y})`, s = `(?!${H}${c})`, S = `(?!${y}{0,1}${p})`, $ = `(?!${c})`, m = `[^.${a}]`, x = `${i}*?`, X = {
+    DOT_LITERAL: y,
+    PLUS_LITERAL: U,
+    QMARK_LITERAL: P,
+    SLASH_LITERAL: a,
+    ONE_CHAR: u,
+    QMARK: i,
+    END_ANCHOR: p,
+    DOTS_SLASH: c,
+    NO_DOT: C,
+    NO_DOTS: s,
+    NO_DOT_SLASH: S,
+    NO_DOTS_SLASH: $,
+    QMARK_NO_DOT: m,
+    STAR: x,
+    START_ANCHOR: H,
+    SEP: "/"
+  }, d = {
+    ...X,
+    SLASH_LITERAL: `[${A}]`,
+    QMARK: b,
+    STAR: `${b}*?`,
+    DOTS_SLASH: `${y}{1,2}(?:[${A}]|$)`,
+    NO_DOT: `(?!${y})`,
+    NO_DOTS: `(?!(?:^|[${A}])${y}{1,2}(?:[${A}]|$))`,
+    NO_DOT_SLASH: `(?!${y}{0,1}(?:[${A}]|$))`,
+    NO_DOTS_SLASH: `(?!${y}{1,2}(?:[${A}]|$))`,
+    QMARK_NO_DOT: `[^.${A}]`,
+    START_ANCHOR: `(?:^|[${A}])`,
+    END_ANCHOR: `(?:[${A}]|$)`,
+    SEP: "\\"
+  }, B = {
+    alnum: "a-zA-Z0-9",
+    alpha: "a-zA-Z",
+    ascii: "\\x00-\\x7F",
+    blank: " \\t",
+    cntrl: "\\x00-\\x1F\\x7F",
+    digit: "0-9",
+    graph: "\\x21-\\x7E",
+    lower: "a-z",
+    print: "\\x20-\\x7E ",
+    punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+    space: " \\t\\r\\n\\v\\f",
+    upper: "A-Z",
+    word: "A-Za-z0-9_",
+    xdigit: "A-Fa-f0-9"
+  };
+  return ft = {
+    MAX_LENGTH: 1024 * 64,
+    POSIX_REGEX_SOURCE: B,
+    // regular expressions
+    REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+    REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+    REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+    REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+    REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+    REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+    // Replace globs with equivalent patterns to reduce parsing time.
+    REPLACEMENTS: {
+      "***": "*",
+      "**/**": "**",
+      "**/**/**": "**"
+    },
+    // Digits
+    CHAR_0: 48,
+    /* 0 */
+    CHAR_9: 57,
+    /* 9 */
+    // Alphabet chars.
+    CHAR_UPPERCASE_A: 65,
+    /* A */
+    CHAR_LOWERCASE_A: 97,
+    /* a */
+    CHAR_UPPERCASE_Z: 90,
+    /* Z */
+    CHAR_LOWERCASE_Z: 122,
+    /* z */
+    CHAR_LEFT_PARENTHESES: 40,
+    /* ( */
+    CHAR_RIGHT_PARENTHESES: 41,
+    /* ) */
+    CHAR_ASTERISK: 42,
+    /* * */
+    // Non-alphabetic chars.
+    CHAR_AMPERSAND: 38,
+    /* & */
+    CHAR_AT: 64,
+    /* @ */
+    CHAR_BACKWARD_SLASH: 92,
+    /* \ */
+    CHAR_CARRIAGE_RETURN: 13,
+    /* \r */
+    CHAR_CIRCUMFLEX_ACCENT: 94,
+    /* ^ */
+    CHAR_COLON: 58,
+    /* : */
+    CHAR_COMMA: 44,
+    /* , */
+    CHAR_DOT: 46,
+    /* . */
+    CHAR_DOUBLE_QUOTE: 34,
+    /* " */
+    CHAR_EQUAL: 61,
+    /* = */
+    CHAR_EXCLAMATION_MARK: 33,
+    /* ! */
+    CHAR_FORM_FEED: 12,
+    /* \f */
+    CHAR_FORWARD_SLASH: 47,
+    /* / */
+    CHAR_GRAVE_ACCENT: 96,
+    /* ` */
+    CHAR_HASH: 35,
+    /* # */
+    CHAR_HYPHEN_MINUS: 45,
+    /* - */
+    CHAR_LEFT_ANGLE_BRACKET: 60,
+    /* < */
+    CHAR_LEFT_CURLY_BRACE: 123,
+    /* { */
+    CHAR_LEFT_SQUARE_BRACKET: 91,
+    /* [ */
+    CHAR_LINE_FEED: 10,
+    /* \n */
+    CHAR_NO_BREAK_SPACE: 160,
+    /* \u00A0 */
+    CHAR_PERCENT: 37,
+    /* % */
+    CHAR_PLUS: 43,
+    /* + */
+    CHAR_QUESTION_MARK: 63,
+    /* ? */
+    CHAR_RIGHT_ANGLE_BRACKET: 62,
+    /* > */
+    CHAR_RIGHT_CURLY_BRACE: 125,
+    /* } */
+    CHAR_RIGHT_SQUARE_BRACKET: 93,
+    /* ] */
+    CHAR_SEMICOLON: 59,
+    /* ; */
+    CHAR_SINGLE_QUOTE: 39,
+    /* ' */
+    CHAR_SPACE: 32,
+    /*   */
+    CHAR_TAB: 9,
+    /* \t */
+    CHAR_UNDERSCORE: 95,
+    /* _ */
+    CHAR_VERTICAL_LINE: 124,
+    /* | */
+    CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+    /* \uFEFF */
+    /**
+     * Create EXTGLOB_CHARS
+     */
+    extglobChars(h) {
+      return {
+        "!": { type: "negate", open: "(?:(?!(?:", close: `))${h.STAR})` },
+        "?": { type: "qmark", open: "(?:", close: ")?" },
+        "+": { type: "plus", open: "(?:", close: ")+" },
+        "*": { type: "star", open: "(?:", close: ")*" },
+        "@": { type: "at", open: "(?:", close: ")" }
+      };
+    },
+    /**
+     * Create GLOB_CHARS
+     */
+    globChars(h) {
+      return h === !0 ? d : X;
+    }
+  }, ft;
+}
+var gt;
+function it() {
+  return gt || (gt = 1, function(A) {
+    const {
+      REGEX_BACKSLASH: b,
+      REGEX_REMOVE_BACKSLASH: y,
+      REGEX_SPECIAL_CHARS: U,
+      REGEX_SPECIAL_CHARS_GLOBAL: P
+    } = /* @__PURE__ */ ct();
+    A.isObject = (a) => a !== null && typeof a == "object" && !Array.isArray(a), A.hasRegexChars = (a) => U.test(a), A.isRegexChar = (a) => a.length === 1 && A.hasRegexChars(a), A.escapeRegex = (a) => a.replace(P, "\\$1"), A.toPosixSlashes = (a) => a.replace(b, "/"), A.isWindows = () => {
+      if (typeof navigator < "u" && navigator.platform) {
+        const a = navigator.platform.toLowerCase();
+        return a === "win32" || a === "windows";
+      }
+      return typeof process < "u" && process.platform ? process.platform === "win32" : !1;
+    }, A.removeBackslashes = (a) => a.replace(y, (u) => u === "\\" ? "" : u), A.escapeLast = (a, u, i) => {
+      const p = a.lastIndexOf(u, i);
+      return p === -1 ? a : a[p - 1] === "\\" ? A.escapeLast(a, u, p - 1) : `${a.slice(0, p)}\\${a.slice(p)}`;
+    }, A.removePrefix = (a, u = {}) => {
+      let i = a;
+      return i.startsWith("./") && (i = i.slice(2), u.prefix = "./"), i;
+    }, A.wrapOutput = (a, u = {}, i = {}) => {
+      const p = i.contains ? "" : "^", H = i.contains ? "" : "$";
+      let c = `${p}(?:${a})${H}`;
+      return u.negated === !0 && (c = `(?:^(?!${c}).*$)`), c;
+    }, A.basename = (a, { windows: u } = {}) => {
+      const i = a.split(u ? /[\\/]/ : "/"), p = i[i.length - 1];
+      return p === "" ? i[i.length - 2] : p;
+    };
+  }(pt)), pt;
+}
+var At, Ct;
+function yt() {
+  if (Ct) return At;
+  Ct = 1;
+  const A = /* @__PURE__ */ it(), {
+    CHAR_ASTERISK: b,
+    /* * */
+    CHAR_AT: y,
+    /* @ */
+    CHAR_BACKWARD_SLASH: U,
+    /* \ */
+    CHAR_COMMA: P,
+    /* , */
+    CHAR_DOT: a,
+    /* . */
+    CHAR_EXCLAMATION_MARK: u,
+    /* ! */
+    CHAR_FORWARD_SLASH: i,
+    /* / */
+    CHAR_LEFT_CURLY_BRACE: p,
+    /* { */
+    CHAR_LEFT_PARENTHESES: H,
+    /* ( */
+    CHAR_LEFT_SQUARE_BRACKET: c,
+    /* [ */
+    CHAR_PLUS: C,
+    /* + */
+    CHAR_QUESTION_MARK: s,
+    /* ? */
+    CHAR_RIGHT_CURLY_BRACE: S,
+    /* } */
+    CHAR_RIGHT_PARENTHESES: $,
+    /* ) */
+    CHAR_RIGHT_SQUARE_BRACKET: m
+    /* ] */
+  } = /* @__PURE__ */ ct(), x = (d) => d === i || d === U, w = (d) => {
+    d.isPrefix !== !0 && (d.depth = d.isGlobstar ? 1 / 0 : 1);
+  };
+  return At = (d, B) => {
+    const h = B || {}, V = d.length - 1, G = h.parts === !0 || h.scanToEnd === !0, W = [], O = [], rt = [];
+    let D = d, E = -1, v = 0, tt = 0, st = !1, Z = !1, L = !1, et = !1, q = !1, r = !1, N = !1, Y = !1, ot = !1, t = !1, e = 0, nt, l, _ = { value: "", depth: 0, isGlob: !1 };
+    const z = () => E >= V, J = () => D.charCodeAt(E + 1), M = () => (nt = l, D.charCodeAt(++E));
+    for (; E < V; ) {
+      l = M();
+      let F;
+      if (l === U) {
+        N = _.backslashes = !0, l = M(), l === p && (r = !0);
+        continue;
+      }
+      if (r === !0 || l === p) {
+        for (e++; z() !== !0 && (l = M()); ) {
+          if (l === U) {
+            N = _.backslashes = !0, M();
+            continue;
+          }
+          if (l === p) {
+            e++;
+            continue;
+          }
+          if (r !== !0 && l === a && (l = M()) === a) {
+            if (st = _.isBrace = !0, L = _.isGlob = !0, t = !0, G === !0)
+              continue;
+            break;
+          }
+          if (r !== !0 && l === P) {
+            if (st = _.isBrace = !0, L = _.isGlob = !0, t = !0, G === !0)
+              continue;
+            break;
+          }
+          if (l === S && (e--, e === 0)) {
+            r = !1, st = _.isBrace = !0, t = !0;
+            break;
+          }
+        }
+        if (G === !0)
+          continue;
+        break;
+      }
+      if (l === i) {
+        if (W.push(E), O.push(_), _ = { value: "", depth: 0, isGlob: !1 }, t === !0) continue;
+        if (nt === a && E === v + 1) {
+          v += 2;
+          continue;
+        }
+        tt = E + 1;
+        continue;
+      }
+      if (h.noext !== !0 && (l === C || l === y || l === b || l === s || l === u) === !0 && J() === H) {
+        if (L = _.isGlob = !0, et = _.isExtglob = !0, t = !0, l === u && E === v && (ot = !0), G === !0) {
+          for (; z() !== !0 && (l = M()); ) {
+            if (l === U) {
+              N = _.backslashes = !0, l = M();
+              continue;
+            }
+            if (l === $) {
+              L = _.isGlob = !0, t = !0;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+      if (l === b) {
+        if (nt === b && (q = _.isGlobstar = !0), L = _.isGlob = !0, t = !0, G === !0)
+          continue;
+        break;
+      }
+      if (l === s) {
+        if (L = _.isGlob = !0, t = !0, G === !0)
+          continue;
+        break;
+      }
+      if (l === c) {
+        for (; z() !== !0 && (F = M()); ) {
+          if (F === U) {
+            N = _.backslashes = !0, M();
+            continue;
+          }
+          if (F === m) {
+            Z = _.isBracket = !0, L = _.isGlob = !0, t = !0;
+            break;
+          }
+        }
+        if (G === !0)
+          continue;
+        break;
+      }
+      if (h.nonegate !== !0 && l === u && E === v) {
+        Y = _.negated = !0, v++;
+        continue;
+      }
+      if (h.noparen !== !0 && l === H) {
+        if (L = _.isGlob = !0, G === !0) {
+          for (; z() !== !0 && (l = M()); ) {
+            if (l === H) {
+              N = _.backslashes = !0, l = M();
+              continue;
+            }
+            if (l === $) {
+              t = !0;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+      if (L === !0) {
+        if (t = !0, G === !0)
+          continue;
+        break;
+      }
+    }
+    h.noext === !0 && (et = !1, L = !1);
+    let I = D, ut = "", j = "";
+    v > 0 && (ut = D.slice(0, v), D = D.slice(v), tt -= v), I && L === !0 && tt > 0 ? (I = D.slice(0, tt), j = D.slice(tt)) : L === !0 ? (I = "", j = D) : I = D, I && I !== "" && I !== "/" && I !== D && x(I.charCodeAt(I.length - 1)) && (I = I.slice(0, -1)), h.unescape === !0 && (j && (j = A.removeBackslashes(j)), I && N === !0 && (I = A.removeBackslashes(I)));
+    const f = {
+      prefix: ut,
+      input: d,
+      start: v,
+      base: I,
+      glob: j,
+      isBrace: st,
+      isBracket: Z,
+      isGlob: L,
+      isExtglob: et,
+      isGlobstar: q,
+      negated: Y,
+      negatedExtglob: ot
+    };
+    if (h.tokens === !0 && (f.maxDepth = 0, x(l) || O.push(_), f.tokens = O), h.parts === !0 || h.tokens === !0) {
+      let F;
+      for (let K = 0; K < W.length; K++) {
+        const o = F ? F + 1 : v, g = W[K], n = d.slice(o, g);
+        h.tokens && (K === 0 && v !== 0 ? (O[K].isPrefix = !0, O[K].value = ut) : O[K].value = n, w(O[K]), f.maxDepth += O[K].depth), (K !== 0 || n !== "") && rt.push(n), F = g;
+      }
+      if (F && F + 1 < d.length) {
+        const K = d.slice(F + 1);
+        rt.push(K), h.tokens && (O[O.length - 1].value = K, w(O[O.length - 1]), f.maxDepth += O[O.length - 1].depth);
+      }
+      f.slashes = W, f.parts = rt;
+    }
+    return f;
+  }, At;
+}
+var Rt, St;
+function dt() {
+  if (St) return Rt;
+  St = 1;
+  const A = /* @__PURE__ */ ct(), b = /* @__PURE__ */ it(), {
+    MAX_LENGTH: y,
+    POSIX_REGEX_SOURCE: U,
+    REGEX_NON_SPECIAL_CHARS: P,
+    REGEX_SPECIAL_CHARS_BACKREF: a,
+    REPLACEMENTS: u
+  } = A, i = (c, C) => {
+    if (typeof C.expandRange == "function")
+      return C.expandRange(...c, C);
+    c.sort();
+    const s = `[${c.join("-")}]`;
+    try {
+      new RegExp(s);
+    } catch {
+      return c.map(($) => b.escapeRegex($)).join("..");
+    }
+    return s;
+  }, p = (c, C) => `Missing ${c}: "${C}" - use "\\\\${C}" to match literal characters`, H = (c, C) => {
+    if (typeof c != "string")
+      throw new TypeError("Expected a string");
+    c = u[c] || c;
+    const s = { ...C }, S = typeof s.maxLength == "number" ? Math.min(y, s.maxLength) : y;
+    let $ = c.length;
+    if ($ > S)
+      throw new SyntaxError(`Input length: ${$}, exceeds maximum allowed length: ${S}`);
+    const m = { type: "bos", value: "", output: s.prepend || "" }, x = [m], w = s.capture ? "" : "?:", X = A.globChars(s.windows), d = A.extglobChars(X), {
+      DOT_LITERAL: B,
+      PLUS_LITERAL: h,
+      SLASH_LITERAL: V,
+      ONE_CHAR: G,
+      DOTS_SLASH: W,
+      NO_DOT: O,
+      NO_DOT_SLASH: rt,
+      NO_DOTS_SLASH: D,
+      QMARK: E,
+      QMARK_NO_DOT: v,
+      STAR: tt,
+      START_ANCHOR: st
+    } = X, Z = (o) => `(${w}(?:(?!${st}${o.dot ? W : B}).)*?)`, L = s.dot ? "" : O, et = s.dot ? E : v;
+    let q = s.bash === !0 ? Z(s) : tt;
+    s.capture && (q = `(${q})`), typeof s.noext == "boolean" && (s.noextglob = s.noext);
+    const r = {
+      input: c,
+      index: -1,
+      start: 0,
+      dot: s.dot === !0,
+      consumed: "",
+      output: "",
+      prefix: "",
+      backtrack: !1,
+      negated: !1,
+      brackets: 0,
+      braces: 0,
+      parens: 0,
+      quotes: 0,
+      globstar: !1,
+      tokens: x
+    };
+    c = b.removePrefix(c, r), $ = c.length;
+    const N = [], Y = [], ot = [];
+    let t = m, e;
+    const nt = () => r.index === $ - 1, l = r.peek = (o = 1) => c[r.index + o], _ = r.advance = () => c[++r.index] || "", z = () => c.slice(r.index + 1), J = (o = "", g = 0) => {
+      r.consumed += o, r.index += g;
+    }, M = (o) => {
+      r.output += o.output != null ? o.output : o.value, J(o.value);
+    }, I = () => {
+      let o = 1;
+      for (; l() === "!" && (l(2) !== "(" || l(3) === "?"); )
+        _(), r.start++, o++;
+      return o % 2 === 0 ? !1 : (r.negated = !0, r.start++, !0);
+    }, ut = (o) => {
+      r[o]++, ot.push(o);
+    }, j = (o) => {
+      r[o]--, ot.pop();
+    }, f = (o) => {
+      if (t.type === "globstar") {
+        const g = r.braces > 0 && (o.type === "comma" || o.type === "brace"), n = o.extglob === !0 || N.length && (o.type === "pipe" || o.type === "paren");
+        o.type !== "slash" && o.type !== "paren" && !g && !n && (r.output = r.output.slice(0, -t.output.length), t.type = "star", t.value = "*", t.output = q, r.output += t.output);
+      }
+      if (N.length && o.type !== "paren" && (N[N.length - 1].inner += o.value), (o.value || o.output) && M(o), t && t.type === "text" && o.type === "text") {
+        t.output = (t.output || t.value) + o.value, t.value += o.value;
+        return;
+      }
+      o.prev = t, x.push(o), t = o;
+    }, F = (o, g) => {
+      const n = { ...d[g], conditions: 1, inner: "" };
+      n.prev = t, n.parens = r.parens, n.output = r.output;
+      const R = (s.capture ? "(" : "") + n.open;
+      ut("parens"), f({ type: o, value: g, output: r.output ? "" : G }), f({ type: "paren", extglob: !0, value: _(), output: R }), N.push(n);
+    }, K = (o) => {
+      let g = o.close + (s.capture ? ")" : ""), n;
+      if (o.type === "negate") {
+        let R = q;
+        if (o.inner && o.inner.length > 1 && o.inner.includes("/") && (R = Z(s)), (R !== q || nt() || /^\)+$/.test(z())) && (g = o.close = `)$))${R}`), o.inner.includes("*") && (n = z()) && /^\.[^\\/.]+$/.test(n)) {
+          const T = H(n, { ...C, fastpaths: !1 }).output;
+          g = o.close = `)${T})${R})`;
+        }
+        o.prev.type === "bos" && (r.negatedExtglob = !0);
+      }
+      f({ type: "paren", extglob: !0, value: e, output: g }), j("parens");
+    };
+    if (s.fastpaths !== !1 && !/(^[*!]|[/()[\]{}"])/.test(c)) {
+      let o = !1, g = c.replace(a, (n, R, T, Q, k, lt) => Q === "\\" ? (o = !0, n) : Q === "?" ? R ? R + Q + (k ? E.repeat(k.length) : "") : lt === 0 ? et + (k ? E.repeat(k.length) : "") : E.repeat(T.length) : Q === "." ? B.repeat(T.length) : Q === "*" ? R ? R + Q + (k ? q : "") : q : R ? n : `\\${n}`);
+      return o === !0 && (s.unescape === !0 ? g = g.replace(/\\/g, "") : g = g.replace(/\\+/g, (n) => n.length % 2 === 0 ? "\\\\" : n ? "\\" : "")), g === c && s.contains === !0 ? (r.output = c, r) : (r.output = b.wrapOutput(g, r, C), r);
+    }
+    for (; !nt(); ) {
+      if (e = _(), e === "\0")
+        continue;
+      if (e === "\\") {
+        const n = l();
+        if (n === "/" && s.bash !== !0 || n === "." || n === ";")
+          continue;
+        if (!n) {
+          e += "\\", f({ type: "text", value: e });
+          continue;
+        }
+        const R = /^\\+/.exec(z());
+        let T = 0;
+        if (R && R[0].length > 2 && (T = R[0].length, r.index += T, T % 2 !== 0 && (e += "\\")), s.unescape === !0 ? e = _() : e += _(), r.brackets === 0) {
+          f({ type: "text", value: e });
+          continue;
+        }
+      }
+      if (r.brackets > 0 && (e !== "]" || t.value === "[" || t.value === "[^")) {
+        if (s.posix !== !1 && e === ":") {
+          const n = t.value.slice(1);
+          if (n.includes("[") && (t.posix = !0, n.includes(":"))) {
+            const R = t.value.lastIndexOf("["), T = t.value.slice(0, R), Q = t.value.slice(R + 2), k = U[Q];
+            if (k) {
+              t.value = T + k, r.backtrack = !0, _(), !m.output && x.indexOf(t) === 1 && (m.output = G);
+              continue;
+            }
+          }
+        }
+        (e === "[" && l() !== ":" || e === "-" && l() === "]") && (e = `\\${e}`), e === "]" && (t.value === "[" || t.value === "[^") && (e = `\\${e}`), s.posix === !0 && e === "!" && t.value === "[" && (e = "^"), t.value += e, M({ value: e });
+        continue;
+      }
+      if (r.quotes === 1 && e !== '"') {
+        e = b.escapeRegex(e), t.value += e, M({ value: e });
+        continue;
+      }
+      if (e === '"') {
+        r.quotes = r.quotes === 1 ? 0 : 1, s.keepQuotes === !0 && f({ type: "text", value: e });
+        continue;
+      }
+      if (e === "(") {
+        ut("parens"), f({ type: "paren", value: e });
+        continue;
+      }
+      if (e === ")") {
+        if (r.parens === 0 && s.strictBrackets === !0)
+          throw new SyntaxError(p("opening", "("));
+        const n = N[N.length - 1];
+        if (n && r.parens === n.parens + 1) {
+          K(N.pop());
+          continue;
+        }
+        f({ type: "paren", value: e, output: r.parens ? ")" : "\\)" }), j("parens");
+        continue;
+      }
+      if (e === "[") {
+        if (s.nobracket === !0 || !z().includes("]")) {
+          if (s.nobracket !== !0 && s.strictBrackets === !0)
+            throw new SyntaxError(p("closing", "]"));
+          e = `\\${e}`;
+        } else
+          ut("brackets");
+        f({ type: "bracket", value: e });
+        continue;
+      }
+      if (e === "]") {
+        if (s.nobracket === !0 || t && t.type === "bracket" && t.value.length === 1) {
+          f({ type: "text", value: e, output: `\\${e}` });
+          continue;
+        }
+        if (r.brackets === 0) {
+          if (s.strictBrackets === !0)
+            throw new SyntaxError(p("opening", "["));
+          f({ type: "text", value: e, output: `\\${e}` });
+          continue;
+        }
+        j("brackets");
+        const n = t.value.slice(1);
+        if (t.posix !== !0 && n[0] === "^" && !n.includes("/") && (e = `/${e}`), t.value += e, M({ value: e }), s.literalBrackets === !1 || b.hasRegexChars(n))
+          continue;
+        const R = b.escapeRegex(t.value);
+        if (r.output = r.output.slice(0, -t.value.length), s.literalBrackets === !0) {
+          r.output += R, t.value = R;
+          continue;
+        }
+        t.value = `(${w}${R}|${t.value})`, r.output += t.value;
+        continue;
+      }
+      if (e === "{" && s.nobrace !== !0) {
+        ut("braces");
+        const n = {
+          type: "brace",
+          value: e,
+          output: "(",
+          outputIndex: r.output.length,
+          tokensIndex: r.tokens.length
+        };
+        Y.push(n), f(n);
+        continue;
+      }
+      if (e === "}") {
+        const n = Y[Y.length - 1];
+        if (s.nobrace === !0 || !n) {
+          f({ type: "text", value: e, output: e });
+          continue;
+        }
+        let R = ")";
+        if (n.dots === !0) {
+          const T = x.slice(), Q = [];
+          for (let k = T.length - 1; k >= 0 && (x.pop(), T[k].type !== "brace"); k--)
+            T[k].type !== "dots" && Q.unshift(T[k].value);
+          R = i(Q, s), r.backtrack = !0;
+        }
+        if (n.comma !== !0 && n.dots !== !0) {
+          const T = r.output.slice(0, n.outputIndex), Q = r.tokens.slice(n.tokensIndex);
+          n.value = n.output = "\\{", e = R = "\\}", r.output = T;
+          for (const k of Q)
+            r.output += k.output || k.value;
+        }
+        f({ type: "brace", value: e, output: R }), j("braces"), Y.pop();
+        continue;
+      }
+      if (e === "|") {
+        N.length > 0 && N[N.length - 1].conditions++, f({ type: "text", value: e });
+        continue;
+      }
+      if (e === ",") {
+        let n = e;
+        const R = Y[Y.length - 1];
+        R && ot[ot.length - 1] === "braces" && (R.comma = !0, n = "|"), f({ type: "comma", value: e, output: n });
+        continue;
+      }
+      if (e === "/") {
+        if (t.type === "dot" && r.index === r.start + 1) {
+          r.start = r.index + 1, r.consumed = "", r.output = "", x.pop(), t = m;
+          continue;
+        }
+        f({ type: "slash", value: e, output: V });
+        continue;
+      }
+      if (e === ".") {
+        if (r.braces > 0 && t.type === "dot") {
+          t.value === "." && (t.output = B);
+          const n = Y[Y.length - 1];
+          t.type = "dots", t.output += e, t.value += e, n.dots = !0;
+          continue;
+        }
+        if (r.braces + r.parens === 0 && t.type !== "bos" && t.type !== "slash") {
+          f({ type: "text", value: e, output: B });
+          continue;
+        }
+        f({ type: "dot", value: e, output: B });
+        continue;
+      }
+      if (e === "?") {
+        if (!(t && t.value === "(") && s.noextglob !== !0 && l() === "(" && l(2) !== "?") {
+          F("qmark", e);
+          continue;
+        }
+        if (t && t.type === "paren") {
+          const R = l();
+          let T = e;
+          (t.value === "(" && !/[!=<:]/.test(R) || R === "<" && !/<([!=]|\w+>)/.test(z())) && (T = `\\${e}`), f({ type: "text", value: e, output: T });
+          continue;
+        }
+        if (s.dot !== !0 && (t.type === "slash" || t.type === "bos")) {
+          f({ type: "qmark", value: e, output: v });
+          continue;
+        }
+        f({ type: "qmark", value: e, output: E });
+        continue;
+      }
+      if (e === "!") {
+        if (s.noextglob !== !0 && l() === "(" && (l(2) !== "?" || !/[!=<:]/.test(l(3)))) {
+          F("negate", e);
+          continue;
+        }
+        if (s.nonegate !== !0 && r.index === 0) {
+          I();
+          continue;
+        }
+      }
+      if (e === "+") {
+        if (s.noextglob !== !0 && l() === "(" && l(2) !== "?") {
+          F("plus", e);
+          continue;
+        }
+        if (t && t.value === "(" || s.regex === !1) {
+          f({ type: "plus", value: e, output: h });
+          continue;
+        }
+        if (t && (t.type === "bracket" || t.type === "paren" || t.type === "brace") || r.parens > 0) {
+          f({ type: "plus", value: e });
+          continue;
+        }
+        f({ type: "plus", value: h });
+        continue;
+      }
+      if (e === "@") {
+        if (s.noextglob !== !0 && l() === "(" && l(2) !== "?") {
+          f({ type: "at", extglob: !0, value: e, output: "" });
+          continue;
+        }
+        f({ type: "text", value: e });
+        continue;
+      }
+      if (e !== "*") {
+        (e === "$" || e === "^") && (e = `\\${e}`);
+        const n = P.exec(z());
+        n && (e += n[0], r.index += n[0].length), f({ type: "text", value: e });
+        continue;
+      }
+      if (t && (t.type === "globstar" || t.star === !0)) {
+        t.type = "star", t.star = !0, t.value += e, t.output = q, r.backtrack = !0, r.globstar = !0, J(e);
+        continue;
+      }
+      let o = z();
+      if (s.noextglob !== !0 && /^\([^?]/.test(o)) {
+        F("star", e);
+        continue;
+      }
+      if (t.type === "star") {
+        if (s.noglobstar === !0) {
+          J(e);
+          continue;
+        }
+        const n = t.prev, R = n.prev, T = n.type === "slash" || n.type === "bos", Q = R && (R.type === "star" || R.type === "globstar");
+        if (s.bash === !0 && (!T || o[0] && o[0] !== "/")) {
+          f({ type: "star", value: e, output: "" });
+          continue;
+        }
+        const k = r.braces > 0 && (n.type === "comma" || n.type === "brace"), lt = N.length && (n.type === "pipe" || n.type === "paren");
+        if (!T && n.type !== "paren" && !k && !lt) {
+          f({ type: "star", value: e, output: "" });
+          continue;
+        }
+        for (; o.slice(0, 3) === "/**"; ) {
+          const at = c[r.index + 4];
+          if (at && at !== "/")
+            break;
+          o = o.slice(3), J("/**", 3);
+        }
+        if (n.type === "bos" && nt()) {
+          t.type = "globstar", t.value += e, t.output = Z(s), r.output = t.output, r.globstar = !0, J(e);
+          continue;
+        }
+        if (n.type === "slash" && n.prev.type !== "bos" && !Q && nt()) {
+          r.output = r.output.slice(0, -(n.output + t.output).length), n.output = `(?:${n.output}`, t.type = "globstar", t.output = Z(s) + (s.strictSlashes ? ")" : "|$)"), t.value += e, r.globstar = !0, r.output += n.output + t.output, J(e);
+          continue;
+        }
+        if (n.type === "slash" && n.prev.type !== "bos" && o[0] === "/") {
+          const at = o[1] !== void 0 ? "|$" : "";
+          r.output = r.output.slice(0, -(n.output + t.output).length), n.output = `(?:${n.output}`, t.type = "globstar", t.output = `${Z(s)}${V}|${V}${at})`, t.value += e, r.output += n.output + t.output, r.globstar = !0, J(e + _()), f({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        if (n.type === "bos" && o[0] === "/") {
+          t.type = "globstar", t.value += e, t.output = `(?:^|${V}|${Z(s)}${V})`, r.output = t.output, r.globstar = !0, J(e + _()), f({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        r.output = r.output.slice(0, -t.output.length), t.type = "globstar", t.output = Z(s), t.value += e, r.output += t.output, r.globstar = !0, J(e);
+        continue;
+      }
+      const g = { type: "star", value: e, output: q };
+      if (s.bash === !0) {
+        g.output = ".*?", (t.type === "bos" || t.type === "slash") && (g.output = L + g.output), f(g);
+        continue;
+      }
+      if (t && (t.type === "bracket" || t.type === "paren") && s.regex === !0) {
+        g.output = e, f(g);
+        continue;
+      }
+      (r.index === r.start || t.type === "slash" || t.type === "dot") && (t.type === "dot" ? (r.output += rt, t.output += rt) : s.dot === !0 ? (r.output += D, t.output += D) : (r.output += L, t.output += L), l() !== "*" && (r.output += G, t.output += G)), f(g);
+    }
+    for (; r.brackets > 0; ) {
+      if (s.strictBrackets === !0) throw new SyntaxError(p("closing", "]"));
+      r.output = b.escapeLast(r.output, "["), j("brackets");
+    }
+    for (; r.parens > 0; ) {
+      if (s.strictBrackets === !0) throw new SyntaxError(p("closing", ")"));
+      r.output = b.escapeLast(r.output, "("), j("parens");
+    }
+    for (; r.braces > 0; ) {
+      if (s.strictBrackets === !0) throw new SyntaxError(p("closing", "}"));
+      r.output = b.escapeLast(r.output, "{"), j("braces");
+    }
+    if (s.strictSlashes !== !0 && (t.type === "star" || t.type === "bracket") && f({ type: "maybe_slash", value: "", output: `${V}?` }), r.backtrack === !0) {
+      r.output = "";
+      for (const o of r.tokens)
+        r.output += o.output != null ? o.output : o.value, o.suffix && (r.output += o.suffix);
+    }
+    return r;
+  };
+  return H.fastpaths = (c, C) => {
+    const s = { ...C }, S = typeof s.maxLength == "number" ? Math.min(y, s.maxLength) : y, $ = c.length;
+    if ($ > S)
+      throw new SyntaxError(`Input length: ${$}, exceeds maximum allowed length: ${S}`);
+    c = u[c] || c;
+    const {
+      DOT_LITERAL: m,
+      SLASH_LITERAL: x,
+      ONE_CHAR: w,
+      DOTS_SLASH: X,
+      NO_DOT: d,
+      NO_DOTS: B,
+      NO_DOTS_SLASH: h,
+      STAR: V,
+      START_ANCHOR: G
+    } = A.globChars(s.windows), W = s.dot ? B : d, O = s.dot ? h : d, rt = s.capture ? "" : "?:", D = { negated: !1, prefix: "" };
+    let E = s.bash === !0 ? ".*?" : V;
+    s.capture && (E = `(${E})`);
+    const v = (L) => L.noglobstar === !0 ? E : `(${rt}(?:(?!${G}${L.dot ? X : m}).)*?)`, tt = (L) => {
+      switch (L) {
+        case "*":
+          return `${W}${w}${E}`;
+        case ".*":
+          return `${m}${w}${E}`;
+        case "*.*":
+          return `${W}${E}${m}${w}${E}`;
+        case "*/*":
+          return `${W}${E}${x}${w}${O}${E}`;
+        case "**":
+          return W + v(s);
+        case "**/*":
+          return `(?:${W}${v(s)}${x})?${O}${w}${E}`;
+        case "**/*.*":
+          return `(?:${W}${v(s)}${x})?${O}${E}${m}${w}${E}`;
+        case "**/.*":
+          return `(?:${W}${v(s)}${x})?${m}${w}${E}`;
+        default: {
+          const et = /^(.*?)\.(\w+)$/.exec(L);
+          if (!et) return;
+          const q = tt(et[1]);
+          return q ? q + m + et[2] : void 0;
+        }
+      }
+    }, st = b.removePrefix(c, D);
+    let Z = tt(st);
+    return Z && s.strictSlashes !== !0 && (Z += `${x}?`), Z;
+  }, Rt = H, Rt;
+}
+var _t, bt;
+function Ht() {
+  if (bt) return _t;
+  bt = 1;
+  const A = /* @__PURE__ */ yt(), b = /* @__PURE__ */ dt(), y = /* @__PURE__ */ it(), U = /* @__PURE__ */ ct(), P = (u) => u && typeof u == "object" && !Array.isArray(u), a = (u, i, p = !1) => {
+    if (Array.isArray(u)) {
+      const x = u.map((X) => a(X, i, p));
+      return (X) => {
+        for (const d of x) {
+          const B = d(X);
+          if (B) return B;
+        }
+        return !1;
+      };
+    }
+    const H = P(u) && u.tokens && u.input;
+    if (u === "" || typeof u != "string" && !H)
+      throw new TypeError("Expected pattern to be a non-empty string");
+    const c = i || {}, C = c.windows, s = H ? a.compileRe(u, i) : a.makeRe(u, i, !1, !0), S = s.state;
+    delete s.state;
+    let $ = () => !1;
+    if (c.ignore) {
+      const x = { ...i, ignore: null, onMatch: null, onResult: null };
+      $ = a(c.ignore, x, p);
+    }
+    const m = (x, w = !1) => {
+      const { isMatch: X, match: d, output: B } = a.test(x, s, i, { glob: u, posix: C }), h = { glob: u, state: S, regex: s, posix: C, input: x, output: B, match: d, isMatch: X };
+      return typeof c.onResult == "function" && c.onResult(h), X === !1 ? (h.isMatch = !1, w ? h : !1) : $(x) ? (typeof c.onIgnore == "function" && c.onIgnore(h), h.isMatch = !1, w ? h : !1) : (typeof c.onMatch == "function" && c.onMatch(h), w ? h : !0);
+    };
+    return p && (m.state = S), m;
+  };
+  return a.test = (u, i, p, { glob: H, posix: c } = {}) => {
+    if (typeof u != "string")
+      throw new TypeError("Expected input to be a string");
+    if (u === "")
+      return { isMatch: !1, output: "" };
+    const C = p || {}, s = C.format || (c ? y.toPosixSlashes : null);
+    let S = u === H, $ = S && s ? s(u) : u;
+    return S === !1 && ($ = s ? s(u) : u, S = $ === H), (S === !1 || C.capture === !0) && (C.matchBase === !0 || C.basename === !0 ? S = a.matchBase(u, i, p, c) : S = i.exec($)), { isMatch: !!S, match: S, output: $ };
+  }, a.matchBase = (u, i, p) => (i instanceof RegExp ? i : a.makeRe(i, p)).test(y.basename(u)), a.isMatch = (u, i, p) => a(i, p)(u), a.parse = (u, i) => Array.isArray(u) ? u.map((p) => a.parse(p, i)) : b(u, { ...i, fastpaths: !1 }), a.scan = (u, i) => A(u, i), a.compileRe = (u, i, p = !1, H = !1) => {
+    if (p === !0)
+      return u.output;
+    const c = i || {}, C = c.contains ? "" : "^", s = c.contains ? "" : "$";
+    let S = `${C}(?:${u.output})${s}`;
+    u && u.negated === !0 && (S = `^(?!${S}).*$`);
+    const $ = a.toRegex(S, i);
+    return H === !0 && ($.state = u), $;
+  }, a.makeRe = (u, i = {}, p = !1, H = !1) => {
+    if (!u || typeof u != "string")
+      throw new TypeError("Expected a non-empty string");
+    let c = { negated: !1, fastpaths: !0 };
+    return i.fastpaths !== !1 && (u[0] === "." || u[0] === "*") && (c.output = b.fastpaths(u, i)), c.output || (c = b(u, i)), a.compileRe(c, i, p, H);
+  }, a.toRegex = (u, i) => {
+    try {
+      const p = i || {};
+      return new RegExp(u, p.flags || (p.nocase ? "i" : ""));
+    } catch (p) {
+      if (i && i.debug === !0) throw p;
+      return /$^/;
+    }
+  }, a.constants = U, _t = a, _t;
+}
+var ht, $t;
+function Lt() {
+  if ($t) return ht;
+  $t = 1;
+  const A = /* @__PURE__ */ Ht(), b = /* @__PURE__ */ it();
+  function y(U, P, a = !1) {
+    return P && (P.windows === null || P.windows === void 0) && (P = { ...P, windows: b.isWindows() }), A(U, P, a);
+  }
+  return Object.assign(y, A), ht = y, ht;
+}
+var Tt = /* @__PURE__ */ Lt();
+const vt = /* @__PURE__ */ xt(Tt);
+export {
+  vt as p
+};
+//# sourceMappingURL=index-DDEnF9L5.js.map