@redocly/replay 0.30.0-next.6 → 0.30.0-next.7

package/dist/replay-resolve-D1Ex_R0P.js

@@ -0,0 +1,3879 @@
+import { X as ur, a6 as ze, a7 as Re } from "./replay-index-7c2fdTRw.js";
+function fr(e) {
+  return !!e;
+}
+var At = {}, Et, zt;
+function lt() {
+  if (zt) return Et;
+  zt = 1;
+  const e = "\\\\/", t = `[^${e}]`, n = 0, r = "\\.", i = "\\+", o = "\\?", s = "\\/", a = "(?=.)", c = "[^/]", f = `(?:${s}|$)`, l = `(?:^|${s})`, E = `${r}{1,2}${f}`, S = `(?!${r})`, T = `(?!${l}${E})`, C = `(?!${r}{0,1}${f})`, O = `(?!${E})`, w = `[^.${s}]`, b = `${c}*?`, A = {
+    DOT_LITERAL: r,
+    PLUS_LITERAL: i,
+    QMARK_LITERAL: o,
+    SLASH_LITERAL: s,
+    ONE_CHAR: a,
+    QMARK: c,
+    END_ANCHOR: f,
+    DOTS_SLASH: E,
+    NO_DOT: S,
+    NO_DOTS: T,
+    NO_DOT_SLASH: C,
+    NO_DOTS_SLASH: O,
+    QMARK_NO_DOT: w,
+    STAR: b,
+    START_ANCHOR: l,
+    SEP: "/"
+  }, L = {
+    ...A,
+    SLASH_LITERAL: `[${e}]`,
+    QMARK: t,
+    STAR: `${t}*?`,
+    DOTS_SLASH: `${r}{1,2}(?:[${e}]|$)`,
+    NO_DOT: `(?!${r})`,
+    NO_DOTS: `(?!(?:^|[${e}])${r}{1,2}(?:[${e}]|$))`,
+    NO_DOT_SLASH: `(?!${r}{0,1}(?:[${e}]|$))`,
+    NO_DOTS_SLASH: `(?!${r}{1,2}(?:[${e}]|$))`,
+    QMARK_NO_DOT: `[^.${e}]`,
+    START_ANCHOR: `(?:^|[${e}])`,
+    END_ANCHOR: `(?:[${e}]|$)`,
+    SEP: "\\"
+  }, u = {
+    __proto__: null,
+    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 Et = {
+    DEFAULT_MAX_EXTGLOB_RECURSION: n,
+    MAX_LENGTH: 1024 * 64,
+    POSIX_REGEX_SOURCE: u,
+    // 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: {
+      __proto__: null,
+      "***": "*",
+      "**/**": "**",
+      "**/**/**": "**"
+    },
+    // 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(I) {
+      return {
+        "!": { type: "negate", open: "(?:(?!(?:", close: `))${I.STAR})` },
+        "?": { type: "qmark", open: "(?:", close: ")?" },
+        "+": { type: "plus", open: "(?:", close: ")+" },
+        "*": { type: "star", open: "(?:", close: ")*" },
+        "@": { type: "at", open: "(?:", close: ")" }
+      };
+    },
+    /**
+     * Create GLOB_CHARS
+     */
+    globChars(I) {
+      return I === !0 ? L : A;
+    }
+  }, Et;
+}
+var Zt;
+function ut() {
+  return Zt || (Zt = 1, (function(e) {
+    const {
+      REGEX_BACKSLASH: t,
+      REGEX_REMOVE_BACKSLASH: n,
+      REGEX_SPECIAL_CHARS: r,
+      REGEX_SPECIAL_CHARS_GLOBAL: i
+    } = /* @__PURE__ */ lt();
+    e.isObject = (o) => o !== null && typeof o == "object" && !Array.isArray(o), e.hasRegexChars = (o) => r.test(o), e.isRegexChar = (o) => o.length === 1 && e.hasRegexChars(o), e.escapeRegex = (o) => o.replace(i, "\\$1"), e.toPosixSlashes = (o) => o.replace(t, "/"), e.isWindows = () => {
+      if (typeof navigator < "u" && navigator.platform) {
+        const o = navigator.platform.toLowerCase();
+        return o === "win32" || o === "windows";
+      }
+      return typeof process < "u" && process.platform ? process.platform === "win32" : !1;
+    }, e.removeBackslashes = (o) => o.replace(n, (s) => s === "\\" ? "" : s), e.escapeLast = (o, s, a) => {
+      const c = o.lastIndexOf(s, a);
+      return c === -1 ? o : o[c - 1] === "\\" ? e.escapeLast(o, s, c - 1) : `${o.slice(0, c)}\\${o.slice(c)}`;
+    }, e.removePrefix = (o, s = {}) => {
+      let a = o;
+      return a.startsWith("./") && (a = a.slice(2), s.prefix = "./"), a;
+    }, e.wrapOutput = (o, s = {}, a = {}) => {
+      const c = a.contains ? "" : "^", f = a.contains ? "" : "$";
+      let l = `${c}(?:${o})${f}`;
+      return s.negated === !0 && (l = `(?:^(?!${l}).*$)`), l;
+    }, e.basename = (o, { windows: s } = {}) => {
+      const a = o.split(s ? /[\\/]/ : "/"), c = a[a.length - 1];
+      return c === "" ? a[a.length - 2] : c;
+    };
+  })(At)), At;
+}
+var St, Jt;
+function pr() {
+  if (Jt) return St;
+  Jt = 1;
+  const e = /* @__PURE__ */ ut(), {
+    CHAR_ASTERISK: t,
+    /* * */
+    CHAR_AT: n,
+    /* @ */
+    CHAR_BACKWARD_SLASH: r,
+    /* \ */
+    CHAR_COMMA: i,
+    /* , */
+    CHAR_DOT: o,
+    /* . */
+    CHAR_EXCLAMATION_MARK: s,
+    /* ! */
+    CHAR_FORWARD_SLASH: a,
+    /* / */
+    CHAR_LEFT_CURLY_BRACE: c,
+    /* { */
+    CHAR_LEFT_PARENTHESES: f,
+    /* ( */
+    CHAR_LEFT_SQUARE_BRACKET: l,
+    /* [ */
+    CHAR_PLUS: E,
+    /* + */
+    CHAR_QUESTION_MARK: S,
+    /* ? */
+    CHAR_RIGHT_CURLY_BRACE: T,
+    /* } */
+    CHAR_RIGHT_PARENTHESES: C,
+    /* ) */
+    CHAR_RIGHT_SQUARE_BRACKET: O
+    /* ] */
+  } = /* @__PURE__ */ lt(), w = (A) => A === a || A === r, b = (A) => {
+    A.isPrefix !== !0 && (A.depth = A.isGlobstar ? 1 / 0 : 1);
+  };
+  return St = (A, L) => {
+    const u = L || {}, I = A.length - 1, v = u.parts === !0 || u.tokens === !0 || u.scanToEnd === !0, m = [], g = [], R = [];
+    let j = A, F = -1, K = 0, pe = 0, le = !1, me = !1, Q = !1, ye = !1, xe = !1, Ae = !1, G = !1, Ee = !1, Oe = !1, oe = !1, ne = 0, ue, k, D = { value: "", depth: 0, isGlob: !1 };
+    const p = () => F >= I, se = () => j.charCodeAt(F + 1), X = () => (ue = k, j.charCodeAt(++F));
+    for (; F < I; ) {
+      k = X();
+      let U;
+      if (k === r) {
+        G = D.backslashes = !0, k = X(), k === c && (Ae = !0);
+        continue;
+      }
+      if (Ae === !0 || k === c) {
+        for (ne++; p() !== !0 && (k = X()); ) {
+          if (k === r) {
+            G = D.backslashes = !0, X();
+            continue;
+          }
+          if (k === c) {
+            ne++;
+            continue;
+          }
+          if (Ae !== !0 && k === o && (k = X()) === o) {
+            if (le = D.isBrace = !0, Q = D.isGlob = !0, oe = !0, v === !0)
+              continue;
+            break;
+          }
+          if (Ae !== !0 && k === i) {
+            if (le = D.isBrace = !0, Q = D.isGlob = !0, oe = !0, v === !0)
+              continue;
+            break;
+          }
+          if (k === T && (ne--, ne === 0)) {
+            Ae = !1, le = D.isBrace = !0, oe = !0;
+            break;
+          }
+        }
+        if (v === !0)
+          continue;
+        break;
+      }
+      if (k === a) {
+        if (m.push(F), g.push(D), D = { value: "", depth: 0, isGlob: !1 }, oe === !0) continue;
+        if (ue === o && F === K + 1) {
+          K += 2;
+          continue;
+        }
+        pe = F + 1;
+        continue;
+      }
+      if (u.noext !== !0 && (k === E || k === n || k === t || k === S || k === s) === !0 && se() === f) {
+        if (Q = D.isGlob = !0, ye = D.isExtglob = !0, oe = !0, k === s && F === K && (Oe = !0), v === !0) {
+          let fe = 0;
+          for (; p() !== !0 && (k = X()); ) {
+            if (k === r) {
+              G = D.backslashes = !0, X();
+              continue;
+            }
+            if (k === f) {
+              fe++;
+              continue;
+            }
+            if (k === C && --fe === 0) {
+              oe = !0;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+      if (k === t) {
+        if (ue === t && (xe = D.isGlobstar = !0), Q = D.isGlob = !0, oe = !0, v === !0)
+          continue;
+        break;
+      }
+      if (k === S) {
+        if (Q = D.isGlob = !0, oe = !0, v === !0)
+          continue;
+        break;
+      }
+      if (k === l) {
+        for (; p() !== !0 && (U = X()); ) {
+          if (U === r) {
+            G = D.backslashes = !0, X();
+            continue;
+          }
+          if (U === O) {
+            me = D.isBracket = !0, Q = D.isGlob = !0, oe = !0;
+            break;
+          }
+        }
+        if (v === !0)
+          continue;
+        break;
+      }
+      if (u.nonegate !== !0 && k === s && F === K) {
+        Ee = D.negated = !0, K++;
+        continue;
+      }
+      if (u.noparen !== !0 && k === f) {
+        if (Q = D.isGlob = !0, v === !0) {
+          let ce = 1;
+          for (; p() !== !0 && (k = X()); ) {
+            if (k === r) {
+              G = D.backslashes = !0, X();
+              continue;
+            }
+            if (k === f) {
+              ce++;
+              continue;
+            }
+            if (k === C && --ce === 0) {
+              oe = !0;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+      if (Q === !0) {
+        if (oe = !0, v === !0)
+          continue;
+        break;
+      }
+    }
+    u.noext === !0 && (ye = !1, Q = !1);
+    let V = j, h = "", d = "";
+    K > 0 && (h = j.slice(0, K), j = j.slice(K), pe -= K), V && Q === !0 && pe > 0 ? (V = j.slice(0, pe), d = j.slice(pe)) : Q === !0 ? (V = "", d = j) : V = j, V && V !== "" && V !== "/" && V !== j && w(V.charCodeAt(V.length - 1)) && (V = V.slice(0, -1)), u.unescape === !0 && (d && (d = e.removeBackslashes(d)), V && G === !0 && (V = e.removeBackslashes(V)));
+    const de = {
+      prefix: h,
+      input: A,
+      start: K,
+      base: V,
+      glob: d,
+      isBrace: le,
+      isBracket: me,
+      isGlob: Q,
+      isExtglob: ye,
+      isGlobstar: xe,
+      negated: Ee,
+      negatedExtglob: Oe
+    };
+    if (u.tokens === !0 && (de.maxDepth = 0, w(k) || g.push(D), de.tokens = g), u.parts === !0 || u.tokens === !0) {
+      let U;
+      for (let z = 0; z < m.length; z++) {
+        const Fe = U !== void 0 ? U + 1 : K, je = m[z], be = A.slice(Fe, je);
+        u.tokens && (z === 0 && K !== 0 ? (g[z].isPrefix = !0, g[z].value = h) : g[z].value = be, b(g[z]), de.maxDepth += g[z].depth), je >= K && (R.push(be), U = je);
+      }
+      const ce = U !== void 0 ? U + 1 : K, fe = A.slice(ce);
+      R.push(fe), u.tokens && U && U + 1 < A.length && (g[g.length - 1].value = fe, b(g[g.length - 1]), de.maxDepth += g[g.length - 1].depth), de.slashes = m, de.parts = R;
+    }
+    return de;
+  }, St;
+}
+var _t, en;
+function dr() {
+  if (en) return _t;
+  en = 1;
+  const e = /* @__PURE__ */ lt(), t = /* @__PURE__ */ ut(), {
+    MAX_LENGTH: n,
+    POSIX_REGEX_SOURCE: r,
+    REGEX_NON_SPECIAL_CHARS: i,
+    REGEX_SPECIAL_CHARS_BACKREF: o,
+    REPLACEMENTS: s
+  } = e, a = (A, L) => {
+    if (typeof L.expandRange == "function")
+      return L.expandRange(...A, L);
+    A.sort();
+    const u = `[${A.join("-")}]`;
+    try {
+      new RegExp(u);
+    } catch {
+      return A.map((v) => t.escapeRegex(v)).join("..");
+    }
+    return u;
+  }, c = (A, L) => `Missing ${A}: "${L}" - use "\\\\${L}" to match literal characters`, f = (A) => {
+    const L = [];
+    let u = 0, I = 0, v = 0, m = "", g = !1;
+    for (const R of A) {
+      if (g === !0) {
+        m += R, g = !1;
+        continue;
+      }
+      if (R === "\\") {
+        m += R, g = !0;
+        continue;
+      }
+      if (R === '"') {
+        v = v === 1 ? 0 : 1, m += R;
+        continue;
+      }
+      if (v === 0) {
+        if (R === "[")
+          u++;
+        else if (R === "]" && u > 0)
+          u--;
+        else if (u === 0) {
+          if (R === "(")
+            I++;
+          else if (R === ")" && I > 0)
+            I--;
+          else if (R === "|" && I === 0) {
+            L.push(m), m = "";
+            continue;
+          }
+        }
+      }
+      m += R;
+    }
+    return L.push(m), L;
+  }, l = (A) => {
+    let L = !1;
+    for (const u of A) {
+      if (L === !0) {
+        L = !1;
+        continue;
+      }
+      if (u === "\\") {
+        L = !0;
+        continue;
+      }
+      if (/[?*+@!()[\]{}]/.test(u))
+        return !1;
+    }
+    return !0;
+  }, E = (A) => {
+    let L = A.trim(), u = !0;
+    for (; u === !0; )
+      u = !1, /^@\([^\\()[\]{}|]+\)$/.test(L) && (L = L.slice(2, -1), u = !0);
+    if (l(L))
+      return L.replace(/\\(.)/g, "$1");
+  }, S = (A) => {
+    const L = A.map(E).filter(Boolean);
+    for (let u = 0; u < L.length; u++)
+      for (let I = u + 1; I < L.length; I++) {
+        const v = L[u], m = L[I], g = v[0];
+        if (!(!g || v !== g.repeat(v.length) || m !== g.repeat(m.length)) && (v === m || v.startsWith(m) || m.startsWith(v)))
+          return !0;
+      }
+    return !1;
+  }, T = (A, L = !0) => {
+    if (A[0] !== "+" && A[0] !== "*" || A[1] !== "(")
+      return;
+    let u = 0, I = 0, v = 0, m = !1;
+    for (let g = 1; g < A.length; g++) {
+      const R = A[g];
+      if (m === !0) {
+        m = !1;
+        continue;
+      }
+      if (R === "\\") {
+        m = !0;
+        continue;
+      }
+      if (R === '"') {
+        v = v === 1 ? 0 : 1;
+        continue;
+      }
+      if (v !== 1) {
+        if (R === "[") {
+          u++;
+          continue;
+        }
+        if (R === "]" && u > 0) {
+          u--;
+          continue;
+        }
+        if (!(u > 0)) {
+          if (R === "(") {
+            I++;
+            continue;
+          }
+          if (R === ")" && (I--, I === 0))
+            return L === !0 && g !== A.length - 1 ? void 0 : {
+              type: A[0],
+              body: A.slice(2, g),
+              end: g
+            };
+        }
+      }
+    }
+  }, C = (A) => `${A.length === 1 ? t.escapeRegex(A[0]) : `[${A.map((u) => t.escapeRegex(u)).join("")}]`}*`, O = (A) => {
+    let L = 0;
+    const u = [];
+    for (; L < A.length; ) {
+      const I = T(A.slice(L), !1);
+      if (!I || I.type !== "*")
+        return;
+      const v = f(I.body).map((g) => g.trim());
+      if (v.length !== 1)
+        return;
+      const m = E(v[0]);
+      if (!m || m.length !== 1)
+        return;
+      u.push(m), L += I.end + 1;
+    }
+    if (!(u.length < 1))
+      return u;
+  }, w = (A) => {
+    let L = 0, u = A.trim(), I = T(u);
+    for (; I; )
+      L++, u = I.body.trim(), I = T(u);
+    return L;
+  }, b = (A, L) => {
+    if (L.maxExtglobRecursion === !1)
+      return { risky: !1 };
+    const u = typeof L.maxExtglobRecursion == "number" ? L.maxExtglobRecursion : e.DEFAULT_MAX_EXTGLOB_RECURSION, I = f(A).map((R) => R.trim());
+    if (I.length > 1 && (I.some((R) => R === "") || I.some((R) => /^[*?]+$/.test(R)) || S(I)))
+      return { risky: !0 };
+    const v = [];
+    let m = !1, g = !0;
+    for (const R of I) {
+      const j = O(R);
+      if (j) {
+        m = !0, v.push(...j);
+        continue;
+      }
+      const F = E(R);
+      if (F && F.length === 1) {
+        v.push(F);
+        continue;
+      }
+      if (g = !1, w(R) > u)
+        return { risky: !0 };
+    }
+    return m ? g ? { risky: !0, safeOutput: C([...new Set(v)]) } : { risky: !0 } : { risky: !1 };
+  }, $ = (A, L) => {
+    if (typeof A != "string")
+      throw new TypeError("Expected a string");
+    A = s[A] || A;
+    const u = { ...L }, I = typeof u.maxLength == "number" ? Math.min(n, u.maxLength) : n;
+    let v = A.length;
+    if (v > I)
+      throw new SyntaxError(`Input length: ${v}, exceeds maximum allowed length: ${I}`);
+    const m = { type: "bos", value: "", output: u.prepend || "" }, g = [m], R = u.capture ? "" : "?:", j = e.globChars(u.windows), F = e.extglobChars(j), {
+      DOT_LITERAL: K,
+      PLUS_LITERAL: pe,
+      SLASH_LITERAL: le,
+      ONE_CHAR: me,
+      DOTS_SLASH: Q,
+      NO_DOT: ye,
+      NO_DOT_SLASH: xe,
+      NO_DOTS_SLASH: Ae,
+      QMARK: G,
+      QMARK_NO_DOT: Ee,
+      STAR: Oe,
+      START_ANCHOR: oe
+    } = j, ne = (y) => `(${R}(?:(?!${oe}${y.dot ? Q : K}).)*?)`, ue = u.dot ? "" : ye, k = u.dot ? G : Ee;
+    let D = u.bash === !0 ? ne(u) : Oe;
+    u.capture && (D = `(${D})`), typeof u.noext == "boolean" && (u.noextglob = u.noext);
+    const p = {
+      input: A,
+      index: -1,
+      start: 0,
+      dot: u.dot === !0,
+      consumed: "",
+      output: "",
+      prefix: "",
+      backtrack: !1,
+      negated: !1,
+      brackets: 0,
+      braces: 0,
+      parens: 0,
+      quotes: 0,
+      globstar: !1,
+      tokens: g
+    };
+    A = t.removePrefix(A, p), v = A.length;
+    const se = [], X = [], V = [];
+    let h = m, d;
+    const de = () => p.index === v - 1, U = p.peek = (y = 1) => A[p.index + y], ce = p.advance = () => A[++p.index] || "", fe = () => A.slice(p.index + 1), z = (y = "", Y = 0) => {
+      p.consumed += y, p.index += Y;
+    }, Fe = (y) => {
+      p.output += y.output != null ? y.output : y.value, z(y.value);
+    }, je = () => {
+      let y = 1;
+      for (; U() === "!" && (U(2) !== "(" || U(3) === "?"); )
+        ce(), p.start++, y++;
+      return y % 2 === 0 ? !1 : (p.negated = !0, p.start++, !0);
+    }, be = (y) => {
+      p[y]++, V.push(y);
+    }, ve = (y) => {
+      p[y]--, V.pop();
+    }, P = (y) => {
+      if (h.type === "globstar") {
+        const Y = p.braces > 0 && (y.type === "comma" || y.type === "brace"), _ = y.extglob === !0 || se.length && (y.type === "pipe" || y.type === "paren");
+        y.type !== "slash" && y.type !== "paren" && !Y && !_ && (p.output = p.output.slice(0, -h.output.length), h.type = "star", h.value = "*", h.output = D, p.output += h.output);
+      }
+      if (se.length && y.type !== "paren" && (se[se.length - 1].inner += y.value), (y.value || y.output) && Fe(y), h && h.type === "text" && y.type === "text") {
+        h.output = (h.output || h.value) + y.value, h.value += y.value;
+        return;
+      }
+      y.prev = h, g.push(y), h = y;
+    }, Ze = (y, Y) => {
+      const _ = { ...F[Y], conditions: 1, inner: "" };
+      _.prev = h, _.parens = p.parens, _.output = p.output, _.startIndex = p.index, _.tokensIndex = g.length;
+      const B = (u.capture ? "(" : "") + _.open;
+      be("parens"), P({ type: y, value: Y, output: p.output ? "" : me }), P({ type: "paren", extglob: !0, value: ce(), output: B }), se.push(_);
+    }, lr = (y) => {
+      const Y = A.slice(y.startIndex, p.index + 1), _ = A.slice(y.startIndex + 2, p.index), B = b(_, u);
+      if ((y.type === "plus" || y.type === "star") && B.risky) {
+        const q = B.safeOutput ? (y.output ? "" : me) + (u.capture ? `(${B.safeOutput})` : B.safeOutput) : void 0, Se = g[y.tokensIndex];
+        Se.type = "text", Se.value = Y, Se.output = q || t.escapeRegex(Y);
+        for (let Ie = y.tokensIndex + 1; Ie < g.length; Ie++)
+          g[Ie].value = "", g[Ie].output = "", delete g[Ie].suffix;
+        p.output = y.output + Se.output, p.backtrack = !0, P({ type: "paren", extglob: !0, value: d, output: "" }), ve("parens");
+        return;
+      }
+      let W = y.close + (u.capture ? ")" : ""), Z;
+      if (y.type === "negate") {
+        let q = D;
+        if (y.inner && y.inner.length > 1 && y.inner.includes("/") && (q = ne(u)), (q !== D || de() || /^\)+$/.test(fe())) && (W = y.close = `)$))${q}`), y.inner.includes("*") && (Z = fe()) && /^\.[^\\/.]+$/.test(Z)) {
+          const Se = $(Z, { ...L, fastpaths: !1 }).output;
+          W = y.close = `)${Se})${q})`;
+        }
+        y.prev.type === "bos" && (p.negatedExtglob = !0);
+      }
+      P({ type: "paren", extglob: !0, value: d, output: W }), ve("parens");
+    };
+    if (u.fastpaths !== !1 && !/(^[*!]|[/()[\]{}"])/.test(A)) {
+      let y = !1, Y = A.replace(o, (_, B, W, Z, q, Se) => Z === "\\" ? (y = !0, _) : Z === "?" ? B ? B + Z + (q ? G.repeat(q.length) : "") : Se === 0 ? k + (q ? G.repeat(q.length) : "") : G.repeat(W.length) : Z === "." ? K.repeat(W.length) : Z === "*" ? B ? B + Z + (q ? D : "") : D : B ? _ : `\\${_}`);
+      return y === !0 && (u.unescape === !0 ? Y = Y.replace(/\\/g, "") : Y = Y.replace(/\\+/g, (_) => _.length % 2 === 0 ? "\\\\" : _ ? "\\" : "")), Y === A && u.contains === !0 ? (p.output = A, p) : (p.output = t.wrapOutput(Y, p, L), p);
+    }
+    for (; !de(); ) {
+      if (d = ce(), d === "\0")
+        continue;
+      if (d === "\\") {
+        const _ = U();
+        if (_ === "/" && u.bash !== !0 || _ === "." || _ === ";")
+          continue;
+        if (!_) {
+          d += "\\", P({ type: "text", value: d });
+          continue;
+        }
+        const B = /^\\+/.exec(fe());
+        let W = 0;
+        if (B && B[0].length > 2 && (W = B[0].length, p.index += W, W % 2 !== 0 && (d += "\\")), u.unescape === !0 ? d = ce() : d += ce(), p.brackets === 0) {
+          P({ type: "text", value: d });
+          continue;
+        }
+      }
+      if (p.brackets > 0 && (d !== "]" || h.value === "[" || h.value === "[^")) {
+        if (u.posix !== !1 && d === ":") {
+          const _ = h.value.slice(1);
+          if (_.includes("[") && (h.posix = !0, _.includes(":"))) {
+            const B = h.value.lastIndexOf("["), W = h.value.slice(0, B), Z = h.value.slice(B + 2), q = r[Z];
+            if (q) {
+              h.value = W + q, p.backtrack = !0, ce(), !m.output && g.indexOf(h) === 1 && (m.output = me);
+              continue;
+            }
+          }
+        }
+        (d === "[" && U() !== ":" || d === "-" && U() === "]") && (d = `\\${d}`), d === "]" && (h.value === "[" || h.value === "[^") && (d = `\\${d}`), u.posix === !0 && d === "!" && h.value === "[" && (d = "^"), h.value += d, Fe({ value: d });
+        continue;
+      }
+      if (p.quotes === 1 && d !== '"') {
+        d = t.escapeRegex(d), h.value += d, Fe({ value: d });
+        continue;
+      }
+      if (d === '"') {
+        p.quotes = p.quotes === 1 ? 0 : 1, u.keepQuotes === !0 && P({ type: "text", value: d });
+        continue;
+      }
+      if (d === "(") {
+        be("parens"), P({ type: "paren", value: d });
+        continue;
+      }
+      if (d === ")") {
+        if (p.parens === 0 && u.strictBrackets === !0)
+          throw new SyntaxError(c("opening", "("));
+        const _ = se[se.length - 1];
+        if (_ && p.parens === _.parens + 1) {
+          lr(se.pop());
+          continue;
+        }
+        P({ type: "paren", value: d, output: p.parens ? ")" : "\\)" }), ve("parens");
+        continue;
+      }
+      if (d === "[") {
+        if (u.nobracket === !0 || !fe().includes("]")) {
+          if (u.nobracket !== !0 && u.strictBrackets === !0)
+            throw new SyntaxError(c("closing", "]"));
+          d = `\\${d}`;
+        } else
+          be("brackets");
+        P({ type: "bracket", value: d });
+        continue;
+      }
+      if (d === "]") {
+        if (u.nobracket === !0 || h && h.type === "bracket" && h.value.length === 1) {
+          P({ type: "text", value: d, output: `\\${d}` });
+          continue;
+        }
+        if (p.brackets === 0) {
+          if (u.strictBrackets === !0)
+            throw new SyntaxError(c("opening", "["));
+          P({ type: "text", value: d, output: `\\${d}` });
+          continue;
+        }
+        ve("brackets");
+        const _ = h.value.slice(1);
+        if (h.posix !== !0 && _[0] === "^" && !_.includes("/") && (d = `/${d}`), h.value += d, Fe({ value: d }), u.literalBrackets === !1 || t.hasRegexChars(_))
+          continue;
+        const B = t.escapeRegex(h.value);
+        if (p.output = p.output.slice(0, -h.value.length), u.literalBrackets === !0) {
+          p.output += B, h.value = B;
+          continue;
+        }
+        h.value = `(${R}${B}|${h.value})`, p.output += h.value;
+        continue;
+      }
+      if (d === "{" && u.nobrace !== !0) {
+        be("braces");
+        const _ = {
+          type: "brace",
+          value: d,
+          output: "(",
+          outputIndex: p.output.length,
+          tokensIndex: p.tokens.length
+        };
+        X.push(_), P(_);
+        continue;
+      }
+      if (d === "}") {
+        const _ = X[X.length - 1];
+        if (u.nobrace === !0 || !_) {
+          P({ type: "text", value: d, output: d });
+          continue;
+        }
+        let B = ")";
+        if (_.dots === !0) {
+          const W = g.slice(), Z = [];
+          for (let q = W.length - 1; q >= 0 && (g.pop(), W[q].type !== "brace"); q--)
+            W[q].type !== "dots" && Z.unshift(W[q].value);
+          B = a(Z, u), p.backtrack = !0;
+        }
+        if (_.comma !== !0 && _.dots !== !0) {
+          const W = p.output.slice(0, _.outputIndex), Z = p.tokens.slice(_.tokensIndex);
+          _.value = _.output = "\\{", d = B = "\\}", p.output = W;
+          for (const q of Z)
+            p.output += q.output || q.value;
+        }
+        P({ type: "brace", value: d, output: B }), ve("braces"), X.pop();
+        continue;
+      }
+      if (d === "|") {
+        se.length > 0 && se[se.length - 1].conditions++, P({ type: "text", value: d });
+        continue;
+      }
+      if (d === ",") {
+        let _ = d;
+        const B = X[X.length - 1];
+        B && V[V.length - 1] === "braces" && (B.comma = !0, _ = "|"), P({ type: "comma", value: d, output: _ });
+        continue;
+      }
+      if (d === "/") {
+        if (h.type === "dot" && p.index === p.start + 1) {
+          p.start = p.index + 1, p.consumed = "", p.output = "", g.pop(), h = m;
+          continue;
+        }
+        P({ type: "slash", value: d, output: le });
+        continue;
+      }
+      if (d === ".") {
+        if (p.braces > 0 && h.type === "dot") {
+          h.value === "." && (h.output = K);
+          const _ = X[X.length - 1];
+          h.type = "dots", h.output += d, h.value += d, _.dots = !0;
+          continue;
+        }
+        if (p.braces + p.parens === 0 && h.type !== "bos" && h.type !== "slash") {
+          P({ type: "text", value: d, output: K });
+          continue;
+        }
+        P({ type: "dot", value: d, output: K });
+        continue;
+      }
+      if (d === "?") {
+        if (!(h && h.value === "(") && u.noextglob !== !0 && U() === "(" && U(2) !== "?") {
+          Ze("qmark", d);
+          continue;
+        }
+        if (h && h.type === "paren") {
+          const B = U();
+          let W = d;
+          (h.value === "(" && !/[!=<:]/.test(B) || B === "<" && !/<([!=]|\w+>)/.test(fe())) && (W = `\\${d}`), P({ type: "text", value: d, output: W });
+          continue;
+        }
+        if (u.dot !== !0 && (h.type === "slash" || h.type === "bos")) {
+          P({ type: "qmark", value: d, output: Ee });
+          continue;
+        }
+        P({ type: "qmark", value: d, output: G });
+        continue;
+      }
+      if (d === "!") {
+        if (u.noextglob !== !0 && U() === "(" && (U(2) !== "?" || !/[!=<:]/.test(U(3)))) {
+          Ze("negate", d);
+          continue;
+        }
+        if (u.nonegate !== !0 && p.index === 0) {
+          je();
+          continue;
+        }
+      }
+      if (d === "+") {
+        if (u.noextglob !== !0 && U() === "(" && U(2) !== "?") {
+          Ze("plus", d);
+          continue;
+        }
+        if (h && h.value === "(" || u.regex === !1) {
+          P({ type: "plus", value: d, output: pe });
+          continue;
+        }
+        if (h && (h.type === "bracket" || h.type === "paren" || h.type === "brace") || p.parens > 0) {
+          P({ type: "plus", value: d });
+          continue;
+        }
+        P({ type: "plus", value: pe });
+        continue;
+      }
+      if (d === "@") {
+        if (u.noextglob !== !0 && U() === "(" && U(2) !== "?") {
+          P({ type: "at", extglob: !0, value: d, output: "" });
+          continue;
+        }
+        P({ type: "text", value: d });
+        continue;
+      }
+      if (d !== "*") {
+        (d === "$" || d === "^") && (d = `\\${d}`);
+        const _ = i.exec(fe());
+        _ && (d += _[0], p.index += _[0].length), P({ type: "text", value: d });
+        continue;
+      }
+      if (h && (h.type === "globstar" || h.star === !0)) {
+        h.type = "star", h.star = !0, h.value += d, h.output = D, p.backtrack = !0, p.globstar = !0, z(d);
+        continue;
+      }
+      let y = fe();
+      if (u.noextglob !== !0 && /^\([^?]/.test(y)) {
+        Ze("star", d);
+        continue;
+      }
+      if (h.type === "star") {
+        if (u.noglobstar === !0) {
+          z(d);
+          continue;
+        }
+        const _ = h.prev, B = _.prev, W = _.type === "slash" || _.type === "bos", Z = B && (B.type === "star" || B.type === "globstar");
+        if (u.bash === !0 && (!W || y[0] && y[0] !== "/")) {
+          P({ type: "star", value: d, output: "" });
+          continue;
+        }
+        const q = p.braces > 0 && (_.type === "comma" || _.type === "brace"), Se = se.length && (_.type === "pipe" || _.type === "paren");
+        if (!W && _.type !== "paren" && !q && !Se) {
+          P({ type: "star", value: d, output: "" });
+          continue;
+        }
+        for (; y.slice(0, 3) === "/**"; ) {
+          const Pe = A[p.index + 4];
+          if (Pe && Pe !== "/")
+            break;
+          y = y.slice(3), z("/**", 3);
+        }
+        const Ie = de() || p.parens > 0 && y === ")".repeat(p.parens) && !se.some((Pe) => Pe.type === "negate");
+        if (_.type === "bos" && de()) {
+          h.type = "globstar", h.value += d, h.output = ne(u), p.output = h.output, p.globstar = !0, z(d);
+          continue;
+        }
+        if (_.type === "slash" && _.prev.type !== "bos" && !Z && Ie) {
+          p.output = p.output.slice(0, -(_.output + h.output).length), _.output = `(?:${_.output}`, h.type = "globstar", h.output = ne(u) + (u.strictSlashes ? ")" : "|$)"), h.value += d, p.globstar = !0, p.output += _.output + h.output, z(d);
+          continue;
+        }
+        if (_.type === "slash" && _.prev.type !== "bos" && y[0] === "/") {
+          const Pe = y[1] !== void 0 ? "|$" : "";
+          p.output = p.output.slice(0, -(_.output + h.output).length), _.output = `(?:${_.output}`, h.type = "globstar", h.output = `${ne(u)}${le}|${le}${Pe})`, h.value += d, p.output += _.output + h.output, p.globstar = !0, z(d + ce()), P({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        if (_.type === "bos" && y[0] === "/") {
+          h.type = "globstar", h.value += d, h.output = `(?:^|${le}|${ne(u)}${le})`, p.output = h.output, p.globstar = !0, z(d + ce()), P({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        p.output = p.output.slice(0, -h.output.length), h.type = "globstar", h.output = ne(u), h.value += d, p.output += h.output, p.globstar = !0, z(d);
+        continue;
+      }
+      const Y = { type: "star", value: d, output: D };
+      if (u.bash === !0) {
+        Y.output = ".*?", (h.type === "bos" || h.type === "slash") && (Y.output = ue + Y.output), P(Y);
+        continue;
+      }
+      if (h && (h.type === "bracket" || h.type === "paren") && u.regex === !0) {
+        Y.output = d, P(Y);
+        continue;
+      }
+      (p.index === p.start || h.type === "slash" || h.type === "dot") && (h.type === "dot" ? (p.output += xe, h.output += xe) : u.dot === !0 ? (p.output += Ae, h.output += Ae) : (p.output += ue, h.output += ue), U() !== "*" && (p.output += me, h.output += me)), P(Y);
+    }
+    for (; p.brackets > 0; ) {
+      if (u.strictBrackets === !0) throw new SyntaxError(c("closing", "]"));
+      p.output = t.escapeLast(p.output, "["), ve("brackets");
+    }
+    for (; p.parens > 0; ) {
+      if (u.strictBrackets === !0) throw new SyntaxError(c("closing", ")"));
+      p.output = t.escapeLast(p.output, "("), ve("parens");
+    }
+    for (; p.braces > 0; ) {
+      if (u.strictBrackets === !0) throw new SyntaxError(c("closing", "}"));
+      p.output = t.escapeLast(p.output, "{"), ve("braces");
+    }
+    if (u.strictSlashes !== !0 && (h.type === "star" || h.type === "bracket") && P({ type: "maybe_slash", value: "", output: `${le}?` }), p.backtrack === !0) {
+      p.output = "";
+      for (const y of p.tokens)
+        p.output += y.output != null ? y.output : y.value, y.suffix && (p.output += y.suffix);
+    }
+    return p;
+  };
+  return $.fastpaths = (A, L) => {
+    const u = { ...L }, I = typeof u.maxLength == "number" ? Math.min(n, u.maxLength) : n, v = A.length;
+    if (v > I)
+      throw new SyntaxError(`Input length: ${v}, exceeds maximum allowed length: ${I}`);
+    A = s[A] || A;
+    const {
+      DOT_LITERAL: m,
+      SLASH_LITERAL: g,
+      ONE_CHAR: R,
+      DOTS_SLASH: j,
+      NO_DOT: F,
+      NO_DOTS: K,
+      NO_DOTS_SLASH: pe,
+      STAR: le,
+      START_ANCHOR: me
+    } = e.globChars(u.windows), Q = u.dot ? K : F, ye = u.dot ? pe : F, xe = u.capture ? "" : "?:", Ae = { negated: !1, prefix: "" };
+    let G = u.bash === !0 ? ".*?" : le;
+    u.capture && (G = `(${G})`);
+    const Ee = (ue) => ue.noglobstar === !0 ? G : `(${xe}(?:(?!${me}${ue.dot ? j : m}).)*?)`, Oe = (ue) => {
+      switch (ue) {
+        case "*":
+          return `${Q}${R}${G}`;
+        case ".*":
+          return `${m}${R}${G}`;
+        case "*.*":
+          return `${Q}${G}${m}${R}${G}`;
+        case "*/*":
+          return `${Q}${G}${g}${R}${ye}${G}`;
+        case "**":
+          return Q + Ee(u);
+        case "**/*":
+          return `(?:${Q}${Ee(u)}${g})?${ye}${R}${G}`;
+        case "**/*.*":
+          return `(?:${Q}${Ee(u)}${g})?${ye}${G}${m}${R}${G}`;
+        case "**/.*":
+          return `(?:${Q}${Ee(u)}${g})?${m}${R}${G}`;
+        default: {
+          const k = /^(.*?)\.(\w+)$/.exec(ue);
+          if (!k) return;
+          const D = Oe(k[1]);
+          return D ? D + m + k[2] : void 0;
+        }
+      }
+    }, oe = t.removePrefix(A, Ae);
+    let ne = Oe(oe);
+    return ne && u.strictSlashes !== !0 && (ne += `${g}?`), ne;
+  }, _t = $, _t;
+}
+var yt, tn;
+function hr() {
+  if (tn) return yt;
+  tn = 1;
+  const e = /* @__PURE__ */ pr(), t = /* @__PURE__ */ dr(), n = /* @__PURE__ */ ut(), r = /* @__PURE__ */ lt(), i = (s) => s && typeof s == "object" && !Array.isArray(s), o = (s, a, c = !1) => {
+    if (Array.isArray(s)) {
+      const w = s.map(($) => o($, a, c));
+      return ($) => {
+        for (const A of w) {
+          const L = A($);
+          if (L) return L;
+        }
+        return !1;
+      };
+    }
+    const f = i(s) && s.tokens && s.input;
+    if (s === "" || typeof s != "string" && !f)
+      throw new TypeError("Expected pattern to be a non-empty string");
+    const l = a || {}, E = l.windows, S = f ? o.compileRe(s, a) : o.makeRe(s, a, !1, !0), T = S.state;
+    delete S.state;
+    let C = () => !1;
+    if (l.ignore) {
+      const w = { ...a, ignore: null, onMatch: null, onResult: null };
+      C = o(l.ignore, w, c);
+    }
+    const O = (w, b = !1) => {
+      const { isMatch: $, match: A, output: L } = o.test(w, S, a, { glob: s, posix: E }), u = { glob: s, state: T, regex: S, posix: E, input: w, output: L, match: A, isMatch: $ };
+      return typeof l.onResult == "function" && l.onResult(u), $ === !1 ? (u.isMatch = !1, b ? u : !1) : C(w) ? (typeof l.onIgnore == "function" && l.onIgnore(u), u.isMatch = !1, b ? u : !1) : (typeof l.onMatch == "function" && l.onMatch(u), b ? u : !0);
+    };
+    return c && (O.state = T), O;
+  };
+  return o.test = (s, a, c, { glob: f, posix: l } = {}) => {
+    if (typeof s != "string")
+      throw new TypeError("Expected input to be a string");
+    if (s === "")
+      return { isMatch: !1, output: "" };
+    const E = c || {}, S = E.format || (l ? n.toPosixSlashes : null);
+    let T = s === f, C = T && S ? S(s) : s;
+    return T === !1 && (C = S ? S(s) : s, T = C === f), (T === !1 || E.capture === !0) && (E.matchBase === !0 || E.basename === !0 ? T = o.matchBase(s, a, c, l) : T = a.exec(C)), { isMatch: !!T, match: T, output: C };
+  }, o.matchBase = (s, a, c, f = c && c.windows) => (a instanceof RegExp ? a : o.makeRe(a, c)).test(n.basename(s, { windows: f })), o.isMatch = (s, a, c) => o(a, c)(s), o.parse = (s, a) => Array.isArray(s) ? s.map((c) => o.parse(c, a)) : t(s, { ...a, fastpaths: !1 }), o.scan = (s, a) => e(s, a), o.compileRe = (s, a, c = !1, f = !1) => {
+    if (c === !0)
+      return s.output;
+    const l = a || {}, E = l.contains ? "" : "^", S = l.contains ? "" : "$";
+    let T = `${E}(?:${s.output})${S}`;
+    s && s.negated === !0 && (T = `^(?!${T}).*$`);
+    const C = o.toRegex(T, a);
+    return f === !0 && (C.state = s), C;
+  }, o.makeRe = (s, a = {}, c = !1, f = !1) => {
+    if (!s || typeof s != "string")
+      throw new TypeError("Expected a non-empty string");
+    let l = { negated: !1, fastpaths: !0 };
+    return a.fastpaths !== !1 && (s[0] === "." || s[0] === "*") && (l.output = t.fastpaths(s, a)), l.output || (l = t(s, a)), o.compileRe(l, a, c, f);
+  }, o.toRegex = (s, a) => {
+    try {
+      const c = a || {};
+      return new RegExp(s, c.flags || (c.nocase ? "i" : ""));
+    } catch (c) {
+      if (a && a.debug === !0) throw c;
+      return /$^/;
+    }
+  }, o.constants = r, yt = o, yt;
+}
+var Ct, nn;
+function gr() {
+  if (nn) return Ct;
+  nn = 1;
+  const e = /* @__PURE__ */ hr(), t = /* @__PURE__ */ ut();
+  function n(r, i, o = !1) {
+    return i && (i.windows === null || i.windows === void 0) && (i = { ...i, windows: t.isWindows() }), e(r, i, o);
+  }
+  return Object.assign(n, e), Ct = n, Ct;
+}
+var mr = /* @__PURE__ */ gr();
+const Ar = /* @__PURE__ */ ur(mr), Er = typeof window < "u" || typeof process > "u" || process?.platform === "browser", Sr = Er ? {} : process.env || {};
+async function _r(e, t) {
+  const n = {};
+  for (const i of t.headers)
+    yr(e, i.matches) && (n[i.name] = i.envVariable !== void 0 ? Sr[i.envVariable] || "" : i.value);
+  const r = await (t.customFetch || fetch)(e, {
+    headers: n
+  });
+  if (!r.ok)
+    throw new Error(`Failed to load ${e}: ${r.status} ${r.statusText}`);
+  return { body: await r.text(), mimeType: r.headers.get("content-type") };
+}
+function yr(e, t) {
+  return t.match(/^https?:\/\//) || (e = e.replace(/^https?:\/\//, "")), Ar.isMatch(e, t);
+}
+function Ns(e, t = {}) {
+  return {
+    name: `${e}List`,
+    properties: {},
+    items: e,
+    ...t
+  };
+}
+function $s(e, t = {}) {
+  return {
+    name: `${e}Map`,
+    properties: {},
+    additionalProperties: () => e,
+    ...t
+  };
+}
+const et = {
+  name: "SpecExtension",
+  properties: {},
+  // skip validation of additional properties for unknown extensions
+  additionalProperties: { resolvable: !0 }
+};
+function ws(e, t = {}) {
+  const n = {};
+  for (const o of Object.keys(e))
+    n[o] = {
+      ...e[o],
+      name: o
+    };
+  for (const o of Object.values(n))
+    r(o);
+  return n.SpecExtension = et, n;
+  function r(o) {
+    if (o.additionalProperties && (o.additionalProperties = i(o.additionalProperties)), o.items && (o.items = i(o.items)), o.properties) {
+      const s = {};
+      for (const [a, c] of Object.entries(o.properties))
+        s[a] = i(c), t.doNotResolveExamples && c && c.isExample && (s[a] = {
+          ...c,
+          resolvable: !1
+        });
+      o.properties = s;
+    }
+  }
+  function i(o) {
+    if (typeof o == "string") {
+      if (!n[o])
+        throw new Error(`Unknown type name found: ${o}`);
+      return n[o];
+    } else return typeof o == "function" ? (s, a) => i(o(s, a)) : tt(o) ? (o = { ...o }, r(o), o) : o?.directResolveAs !== void 0 ? {
+      ...o,
+      directResolveAs: i(o.directResolveAs) ?? void 0
+    } : o;
+  }
+}
+function tt(e) {
+  return typeof e?.name == "string";
+}
+function Le(e, t) {
+  return e === "" && (e = "#/"), e[e.length - 1] === "/" ? e + t : e + "/" + t;
+}
+function nt(e) {
+  return Re(e) && typeof e.$ref == "string";
+}
+function Cr(e) {
+  return nt(e) && Object.keys(e).length > 1;
+}
+function Tr(e) {
+  return Re(e) && typeof e.externalValue == "string";
+}
+class it {
+  source;
+  pointer;
+  constructor(t, n) {
+    this.source = t, this.pointer = n;
+  }
+  child(t) {
+    return new it(this.source, Le(this.pointer, (Array.isArray(t) ? t : [t]).map(Be).join("/")));
+  }
+  key() {
+    return Object.assign(Object.create(it.prototype), this, { reportOnKey: !0 });
+  }
+  get absolutePointer() {
+    return this.source.absoluteRef + (this.pointer === "#/" ? "" : this.pointer);
+  }
+}
+function vr(e) {
+  const t = e.indexOf("~") === -1 ? e : e.replaceAll("~1", "/").replaceAll("~0", "~");
+  try {
+    return decodeURIComponent(t);
+  } catch {
+    return t;
+  }
+}
+function Be(e) {
+  return typeof e == "number" || e.indexOf("/") === -1 && e.indexOf("~") === -1 ? e : e.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function Lr(e) {
+  const [t, n = ""] = e.split("#/");
+  return {
+    uri: (t.endsWith("#") ? t.slice(0, -1) : t) || null,
+    pointer: Rr(n)
+  };
+}
+function Rr(e) {
+  return e.split("/").map(vr).filter(fr);
+}
+function ks(e) {
+  const t = e.split("/");
+  return t[t.length - 1];
+}
+function Fs(e) {
+  const t = e.split(/[\/\\]/);
+  return t[t.length - 1].replace(/\.[^.]+$/, "");
+}
+function $e(e) {
+  return e.startsWith("http://") || e.startsWith("https://") || e.startsWith("file://") || e.startsWith("data:");
+}
+function Ps(e) {
+  return ze.extname(e) ? $e(e) ? e.substring(0, e.lastIndexOf("/")) : ze.dirname(e) : e;
+}
+function Bs(e, t) {
+  return $e(e) ? new URL(t, e.endsWith("/") ? e : `${e}/`).href : ze.resolve(e, t);
+}
+function Ds(e) {
+  return typeof e == "string" && (e.startsWith("#") || $e(e) || e.startsWith("./") || e.startsWith("../") || e.indexOf("/") > -1 || /\.(ya?ml|json)$/i.test(e));
+}
+function xr(e) {
+  return /^#[A-Za-z][A-Za-z0-9\-_:.]*$/.test(e);
+}
+function Ms(e, t, n) {
+  if (!Re(t.node) && n.parent) {
+    n.parent[n.key] = t.node;
+    return;
+  }
+  delete e.$ref, Re(t.node) && Object.assign(e, { ...t.node, ...e });
+}
+var M = /* @__PURE__ */ Symbol("NOT_RESOLVED");
+function ie(e, t) {
+  return {
+    tagName: e,
+    nodeKind: "scalar",
+    implicit: t.implicit ?? !1,
+    matchByTagPrefix: t.matchByTagPrefix ?? !1,
+    implicitFirstChars: t.implicitFirstChars ?? null,
+    resolve: t.resolve,
+    identify: t.identify,
+    represent: t.represent ?? ((n) => String(n)),
+    representTagName: t.representTagName ?? (() => e)
+  };
+}
+function Ut(e, t) {
+  const n = t.finalize === void 0;
+  return {
+    tagName: e,
+    nodeKind: "sequence",
+    implicit: !1,
+    matchByTagPrefix: t.matchByTagPrefix ?? !1,
+    create: t.create,
+    addItem: t.addItem,
+    finalize: t.finalize ?? ((r) => r),
+    carrierIsResult: n,
+    identify: t.identify,
+    represent: t.represent ?? ((r) => r),
+    representTagName: t.representTagName ?? (() => e)
+  };
+}
+function ft(e, t) {
+  const n = t.finalize === void 0;
+  return {
+    tagName: e,
+    nodeKind: "mapping",
+    implicit: !1,
+    matchByTagPrefix: t.matchByTagPrefix ?? !1,
+    create: t.create,
+    addPair: t.addPair,
+    has: t.has,
+    keys: t.keys,
+    get: t.get,
+    finalize: t.finalize ?? ((r) => r),
+    carrierIsResult: n,
+    identify: t.identify,
+    represent: t.represent ?? ((r) => r),
+    representTagName: t.representTagName ?? (() => e)
+  };
+}
+var Or = ie("tag:yaml.org,2002:str", {
+  resolve: (e) => e,
+  identify: (e) => typeof e == "string"
+}), br = [
+  "",
+  "~",
+  "null",
+  "Null",
+  "NULL"
+], Ir = ie("tag:yaml.org,2002:null", {
+  implicit: !0,
+  implicitFirstChars: [
+    "",
+    "~",
+    "n",
+    "N"
+  ],
+  resolve: (e) => br.indexOf(e) !== -1 ? null : M,
+  identify: (e) => e === null,
+  represent: () => "null"
+}), Nr = ie("tag:yaml.org,2002:null", {
+  implicit: !0,
+  implicitFirstChars: ["n"],
+  resolve: (e, t) => e === "null" || t && e === "" ? null : M,
+  identify: (e) => e === null,
+  represent: () => "null"
+}), $r = [
+  "",
+  "~",
+  "null",
+  "Null",
+  "NULL"
+], wr = ie("tag:yaml.org,2002:null", {
+  implicit: !0,
+  implicitFirstChars: [
+    "",
+    "~",
+    "n",
+    "N"
+  ],
+  resolve: (e) => $r.indexOf(e) !== -1 ? null : M,
+  identify: (e) => e === null,
+  represent: () => "null"
+}), kr = [
+  "true",
+  "True",
+  "TRUE"
+], Fr = [
+  "false",
+  "False",
+  "FALSE"
+], Pr = ie("tag:yaml.org,2002:bool", {
+  implicit: !0,
+  implicitFirstChars: [
+    "t",
+    "T",
+    "f",
+    "F"
+  ],
+  resolve: (e) => kr.indexOf(e) !== -1 ? !0 : Fr.indexOf(e) !== -1 ? !1 : M,
+  identify: (e) => Object.prototype.toString.call(e) === "[object Boolean]",
+  represent: (e) => e ? "true" : "false"
+}), Br = ["true"], Dr = ["false"], Mr = ie("tag:yaml.org,2002:bool", {
+  implicit: !0,
+  implicitFirstChars: ["t", "f"],
+  resolve: (e) => Br.indexOf(e) !== -1 ? !0 : Dr.indexOf(e) !== -1 ? !1 : M,
+  identify: (e) => Object.prototype.toString.call(e) === "[object Boolean]",
+  represent: (e) => e ? "true" : "false"
+}), Hr = [
+  "true",
+  "True",
+  "TRUE",
+  "y",
+  "Y",
+  "yes",
+  "Yes",
+  "YES",
+  "on",
+  "On",
+  "ON"
+], Ur = [
+  "false",
+  "False",
+  "FALSE",
+  "n",
+  "N",
+  "no",
+  "No",
+  "NO",
+  "off",
+  "Off",
+  "OFF"
+], Kr = ie("tag:yaml.org,2002:bool", {
+  implicit: !0,
+  implicitFirstChars: [
+    "y",
+    "Y",
+    "n",
+    "N",
+    "t",
+    "T",
+    "f",
+    "F",
+    "o",
+    "O"
+  ],
+  resolve: (e) => Hr.indexOf(e) !== -1 ? !0 : Ur.indexOf(e) !== -1 ? !1 : M,
+  identify: (e) => Object.prototype.toString.call(e) === "[object Boolean]",
+  represent: (e) => e ? "true" : "false"
+}), Gr = /* @__PURE__ */ new RegExp("^(?:0o[0-7]+|0x[0-9a-fA-F]+|[-+]?[0-9]+)$"), qr = /* @__PURE__ */ new RegExp("^(?:[-+]?0b[0-1]+|[-+]?0o[0-7]+|[-+]?0x[0-9a-fA-F]+|[-+]?[0-9]+)$");
+function Wr(e) {
+  let t = e, n = 1;
+  return (t[0] === "-" || t[0] === "+") && (t[0] === "-" && (n = -1), t = t.slice(1)), t.startsWith("0b") ? n * parseInt(t.slice(2), 2) : t.startsWith("0o") ? n * parseInt(t.slice(2), 8) : t.startsWith("0x") ? n * parseInt(t.slice(2), 16) : n * parseInt(t, 10);
+}
+function Yr(e, t) {
+  if (t) {
+    if (!qr.test(e)) return M;
+  } else if (!Gr.test(e)) return M;
+  const n = Wr(e);
+  return Number.isFinite(n) ? n : M;
+}
+var yn = ie("tag:yaml.org,2002:int", {
+  implicit: !0,
+  implicitFirstChars: [
+    "-",
+    "+",
+    ..."0123456789"
+  ],
+  resolve: Yr,
+  identify: (e) => Number.isInteger(e) && !Object.is(e, -0) && e.toString(10).indexOf("e") < 0,
+  represent: (e) => e.toString(10)
+}), jr = /* @__PURE__ */ new RegExp("^-?(?:0|[1-9][0-9]*)$"), Qr = /* @__PURE__ */ new RegExp("^(?:[-+]?0b[0-1]+|[-+]?0o[0-7]+|[-+]?0x[0-9a-fA-F]+|[-+]?[0-9]+)$");
+function Vr(e) {
+  let t = e, n = 1;
+  return (t[0] === "-" || t[0] === "+") && (t[0] === "-" && (n = -1), t = t.slice(1)), t.startsWith("0b") ? n * parseInt(t.slice(2), 2) : t.startsWith("0o") ? n * parseInt(t.slice(2), 8) : t.startsWith("0x") ? n * parseInt(t.slice(2), 16) : n * parseInt(t, 10);
+}
+function Xr(e, t) {
+  if (t) {
+    if (!Qr.test(e)) return M;
+  } else if (!jr.test(e)) return M;
+  const n = Vr(e);
+  return Number.isFinite(n) ? n : M;
+}
+var zr = ie("tag:yaml.org,2002:int", {
+  implicit: !0,
+  implicitFirstChars: ["-", ..."0123456789"],
+  resolve: Xr,
+  identify: (e) => Number.isInteger(e) && !Object.is(e, -0) && e.toString(10).indexOf("e") < 0,
+  represent: (e) => e.toString(10)
+}), Zr = /* @__PURE__ */ new RegExp("^(?:[-+]?0b[0-1_]+|[-+]?0[0-7_]+|[-+]?0x[0-9a-fA-F_]+|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+|[-+]?(?:0|[1-9][0-9_]*))$");
+function Jr(e) {
+  let t = e.replace(/_/g, ""), n = 1;
+  if ((t[0] === "-" || t[0] === "+") && (t[0] === "-" && (n = -1), t = t.slice(1)), t.startsWith("0b")) return n * parseInt(t.slice(2), 2);
+  if (t.startsWith("0x")) return n * parseInt(t.slice(2), 16);
+  if (t.includes(":")) {
+    let r = 0;
+    for (const i of t.split(":")) r = r * 60 + Number(i);
+    return n * r;
+  }
+  return t !== "0" && t[0] === "0" ? n * parseInt(t, 8) : n * parseInt(t, 10);
+}
+function ei(e) {
+  if (!Zr.test(e)) return M;
+  const t = Jr(e);
+  return Number.isFinite(t) ? t : M;
+}
+var It = ie("tag:yaml.org,2002:int", {
+  implicit: !0,
+  implicitFirstChars: [
+    "-",
+    "+",
+    ..."0123456789"
+  ],
+  resolve: ei,
+  identify: (e) => Number.isInteger(e) && !Object.is(e, -0) && e.toString(10).indexOf("e") < 0,
+  represent: (e) => e.toString(10)
+}), ti = /* @__PURE__ */ new RegExp("^(?:[-+]?[0-9]+(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|[-+]?\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"), ni = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+function ri(e) {
+  if (!ti.test(e)) return M;
+  let t = e.toLowerCase();
+  const n = t[0] === "-" ? -1 : 1;
+  if ("+-".includes(t[0]) && (t = t.slice(1)), t === ".inf") return n === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+  if (t === ".nan") return NaN;
+  const r = n * parseFloat(t);
+  return Number.isFinite(r) || ni.test(e) ? r : M;
+}
+function ii(e) {
+  if (isNaN(e)) return ".nan";
+  if (e === Number.POSITIVE_INFINITY) return ".inf";
+  if (e === Number.NEGATIVE_INFINITY) return "-.inf";
+  if (Object.is(e, -0)) return "-0.0";
+  const t = e.toString(10);
+  return /^[-+]?[0-9]+e/.test(t) ? t.replace("e", ".e") : t;
+}
+var Cn = ie("tag:yaml.org,2002:float", {
+  implicit: !0,
+  implicitFirstChars: [
+    "-",
+    "+",
+    ".",
+    ..."0123456789"
+  ],
+  resolve: ri,
+  identify: (e) => typeof e == "number" && (!Number.isInteger(e) || Object.is(e, -0) || e.toString(10).indexOf("e") >= 0),
+  represent: ii
+}), oi = /* @__PURE__ */ new RegExp("^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$"), si = /* @__PURE__ */ new RegExp("^(?:[-+]?[0-9]+(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|[-+]?\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+function ai(e, t) {
+  if (t) {
+    if (!si.test(e)) return M;
+    let r = e.toLowerCase();
+    const i = r[0] === "-" ? -1 : 1;
+    if ("+-".includes(r[0]) && (r = r.slice(1)), r === ".inf") return i === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+    if (r === ".nan") return NaN;
+    const o = i * parseFloat(r);
+    return Number.isFinite(o) ? o : M;
+  }
+  if (!oi.test(e)) return M;
+  const n = Number(e);
+  return Number.isFinite(n) ? n : M;
+}
+function ci(e) {
+  if (isNaN(e)) return ".nan";
+  if (e === Number.POSITIVE_INFINITY) return ".inf";
+  if (e === Number.NEGATIVE_INFINITY) return "-.inf";
+  if (Object.is(e, -0)) return "-0.0";
+  const t = e.toString(10);
+  return /^[-+]?[0-9]+e/.test(t) ? t.replace("e", ".e") : t;
+}
+var li = ie("tag:yaml.org,2002:float", {
+  implicit: !0,
+  implicitFirstChars: ["-", ..."0123456789"],
+  resolve: ai,
+  identify: (e) => typeof e == "number" && (!Number.isInteger(e) || Object.is(e, -0) || e.toString(10).indexOf("e") >= 0),
+  represent: ci
+}), ui = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:(?:[0-9][0-9_]*)?\\.[0-9_]*)(?:[eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"), fi = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+function pi(e) {
+  if (!ui.test(e)) return M;
+  let t = e.toLowerCase().replace(/_/g, "");
+  const n = t[0] === "-" ? -1 : 1;
+  if ("+-".includes(t[0]) && (t = t.slice(1)), t === ".inf") return n === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+  if (t === ".nan") return NaN;
+  let r = 0;
+  if (t.includes(":")) {
+    for (const i of t.split(":")) r = r * 60 + Number(i);
+    r *= n;
+  } else r = n * parseFloat(t);
+  return Number.isFinite(r) || fi.test(e) ? r : M;
+}
+function di(e) {
+  if (isNaN(e)) return ".nan";
+  if (e === Number.POSITIVE_INFINITY) return ".inf";
+  if (e === Number.NEGATIVE_INFINITY) return "-.inf";
+  if (Object.is(e, -0)) return "-0.0";
+  const t = e.toString(10);
+  return /^[-+]?[0-9]+e/.test(t) ? t.replace("e", ".e") : t;
+}
+var Nt = ie("tag:yaml.org,2002:float", {
+  implicit: !0,
+  implicitFirstChars: [
+    "-",
+    "+",
+    ".",
+    ..."0123456789"
+  ],
+  resolve: pi,
+  identify: (e) => typeof e == "number" && (!Number.isInteger(e) || Object.is(e, -0) || e.toString(10).indexOf("e") >= 0),
+  represent: di
+}), Tn = ie("tag:yaml.org,2002:merge", {
+  implicit: !0,
+  implicitFirstChars: ["<"],
+  resolve: (e, t) => e === "<<" || t && e === "" ? "<<" : M,
+  identify: () => !1
+}), hi = /^[A-Za-z0-9+/]*={0,2}$/;
+function gi(e) {
+  const t = e.replace(/\s/g, "");
+  if (t.length % 4 !== 0 || !hi.test(t)) return M;
+  const n = atob(t), r = new Uint8Array(n.length);
+  for (let i = 0; i < n.length; i++) r[i] = n.charCodeAt(i);
+  return r;
+}
+function mi(e) {
+  let t = "";
+  for (let n = 0; n < e.length; n++) t += String.fromCharCode(e[n]);
+  return btoa(t);
+}
+var vn = ie("tag:yaml.org,2002:binary", {
+  resolve: gi,
+  identify: (e) => Object.prototype.toString.call(e) === "[object Uint8Array]",
+  represent: mi
+}), Ai = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"), Ei = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+function rn(e, t, n, r = 0, i = 0, o = 0, s = 0) {
+  const a = new Date(Date.UTC(e, t, n, r, i, o, s));
+  return a.setUTCFullYear(e, t, n), a;
+}
+function Si(e) {
+  let t = Ai.exec(e);
+  if (t === null && (t = Ei.exec(e)), t === null) return M;
+  const n = +t[1], r = +t[2] - 1, i = +t[3];
+  if (!t[4]) {
+    const l = rn(n, r, i);
+    return l.getUTCFullYear() !== n || l.getUTCMonth() !== r || l.getUTCDate() !== i ? M : l;
+  }
+  const o = +t[4], s = +t[5], a = +t[6];
+  let c = 0;
+  if (o > 23 || s > 59 || a > 59) return M;
+  if (t[7]) {
+    let l = t[7].slice(0, 3);
+    for (; l.length < 3; ) l += "0";
+    c = +l;
+  }
+  const f = rn(n, r, i, o, s, a, c);
+  if (f.getUTCFullYear() !== n || f.getUTCMonth() !== r || f.getUTCDate() !== i) return M;
+  if (t[9]) {
+    const l = +t[10], E = +(t[11] || 0);
+    if (l > 23 || E > 59) return M;
+    const S = (l * 60 + E) * 6e4;
+    f.setTime(f.getTime() - (t[9] === "-" ? -S : S));
+  }
+  return f;
+}
+var _i = ie("tag:yaml.org,2002:timestamp", {
+  implicit: !0,
+  implicitFirstChars: [..."0123456789"],
+  resolve: Si,
+  identify: (e) => e instanceof Date,
+  represent: (e) => e.toISOString()
+}), yi = Ut("tag:yaml.org,2002:seq", {
+  create: () => [],
+  addItem: (e, t) => {
+    e.push(t);
+  },
+  identify: Array.isArray
+});
+function pt(e) {
+  if (e === null || typeof e != "object" || Array.isArray(e)) return !1;
+  const t = Object.getPrototypeOf(e);
+  return t === null || t === Object.prototype;
+}
+function $t(e, t) {
+  const n = {};
+  for (const r of t) e[r] !== void 0 && (n[r] = e[r]);
+  return n;
+}
+var Ln = Ut("tag:yaml.org,2002:omap", {
+  create: () => ({
+    list: [],
+    seen: /* @__PURE__ */ new Set()
+  }),
+  addItem: (e, t) => {
+    let n;
+    if (t instanceof Map) {
+      if (t.size !== 1) return "cannot resolve an ordered map item";
+      n = t.keys().next().value;
+    } else if (pt(t)) {
+      const r = Object.keys(t);
+      if (r.length !== 1) return "cannot resolve an ordered map item";
+      n = r[0];
+    } else return "cannot resolve an ordered map item";
+    return e.seen.has(n) ? "duplicate key in ordered map" : (e.seen.add(n), e.list.push(t), "");
+  },
+  finalize: (e) => e.list,
+  identify: () => !1
+}), Rn = Ut("tag:yaml.org,2002:pairs", {
+  create: () => [],
+  addItem: (e, t) => {
+    if (t instanceof Map)
+      return t.size !== 1 ? "cannot resolve a pairs item" : (e.push(t.entries().next().value), "");
+    if (Object.prototype.toString.call(t) !== "[object Object]") return "cannot resolve a pairs item";
+    const n = t, r = Object.keys(n);
+    return r.length !== 1 ? "cannot resolve a pairs item" : (e.push([r[0], n[r[0]]]), "");
+  },
+  identify: () => !1
+}), Ci = ft("tag:yaml.org,2002:map", {
+  create: () => ({}),
+  identify: pt,
+  represent: (e) => {
+    const t = /* @__PURE__ */ new Map();
+    for (const n of Object.keys(e)) t.set(n, e[n]);
+    return t;
+  },
+  addPair: (e, t, n) => {
+    if (t !== null && typeof t == "object") return "object-based map does not support complex keys";
+    const r = String(t);
+    return r === "__proto__" ? Object.defineProperty(e, r, {
+      value: n,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[r] = n, "";
+  },
+  has: (e, t) => t !== null && typeof t == "object" ? !1 : Object.prototype.hasOwnProperty.call(e, String(t)),
+  keys: (e) => Object.keys(e),
+  get: (e, t) => {
+    const n = String(t);
+    return Object.prototype.hasOwnProperty.call(e, n) ? e[n] : null;
+  }
+}), xn = ft("tag:yaml.org,2002:set", {
+  create: () => /* @__PURE__ */ new Set(),
+  identify: (e) => e instanceof Set,
+  represent: (e) => {
+    const t = /* @__PURE__ */ new Map();
+    for (const n of e) t.set(n, null);
+    return t;
+  },
+  addPair: (e, t, n) => n !== null ? "cannot resolve a set item" : (e.add(t), ""),
+  has: (e, t) => e.has(t),
+  keys: (e) => e.keys(),
+  get: () => null
+});
+function Ti() {
+  return {
+    scalar: /* @__PURE__ */ Object.create(null),
+    sequence: /* @__PURE__ */ Object.create(null),
+    mapping: /* @__PURE__ */ Object.create(null)
+  };
+}
+function vi() {
+  return {
+    scalar: [],
+    sequence: [],
+    mapping: []
+  };
+}
+function Li(e) {
+  const t = [];
+  for (const n of e) {
+    let r = t.length;
+    for (let i = 0; i < t.length; i++) {
+      const o = t[i];
+      if (o.nodeKind === n.nodeKind && o.tagName === n.tagName && o.matchByTagPrefix === n.matchByTagPrefix) {
+        r = i;
+        break;
+      }
+    }
+    t[r] = n;
+  }
+  return t;
+}
+var dt = class On {
+  tags;
+  /** @internal */
+  implicitScalarTags;
+  /**
+  * Dispatch implicit scalar resolvers by `source.charAt(0)`. Each bucket holds
+  * the resolvers that may match that key, in schema order; a key absent from
+  * the map uses
+  * {@link Schema.implicitScalarAnyFirstChar}
+  * (resolvers that declared no first-char constraint, so they apply to any
+  * first character).
+  */
+  implicitScalarByFirstChar;
+  implicitScalarAnyFirstChar;
+  /**
+  * The default scalar tag (`!!str`), resolved once so the composer's fallback
+  * for unresolved plain scalars avoids a keyed lookup per scalar.
+  *
+  * @internal
+  */
+  defaultScalarTag;
+  /**
+  * The default container tags (`!!seq` / `!!map`), used by the dumper: when a
+  * value is identified by its default tag, the tag is implicit and not
+  * printed. Undefined if the schema does not define them (then such values
+  * can't be dumped).
+  *
+  * @internal
+  */
+  defaultSequenceTag;
+  /** @internal */
+  defaultMappingTag;
+  exact;
+  prefix;
+  constructor(t) {
+    const n = Li(t), r = [], i = Ti(), o = vi();
+    for (const l of n) {
+      if (l.nodeKind === "scalar" && l.implicit) {
+        if (l.matchByTagPrefix) throw new Error("Implicit scalar tags cannot match by tag prefix");
+        r.push(l);
+      }
+      switch (l.nodeKind) {
+        case "scalar":
+          l.matchByTagPrefix ? o.scalar.push(l) : i.scalar[l.tagName] = l;
+          break;
+        case "sequence":
+          l.matchByTagPrefix ? o.sequence.push(l) : i.sequence[l.tagName] = l;
+          break;
+        case "mapping":
+          l.matchByTagPrefix ? o.mapping.push(l) : i.mapping[l.tagName] = l;
+          break;
+      }
+    }
+    const s = r.filter((l) => l.implicitFirstChars === null), a = /* @__PURE__ */ new Set();
+    for (const l of r) if (l.implicitFirstChars !== null) for (const E of l.implicitFirstChars) a.add(E);
+    const c = /* @__PURE__ */ new Map();
+    for (const l of a) c.set(l, r.filter((E) => E.implicitFirstChars === null || E.implicitFirstChars.indexOf(l) !== -1));
+    const f = i.scalar["tag:yaml.org,2002:str"];
+    if (!f) throw new Error("schema does not define the default scalar tag (tag:yaml.org,2002:str)");
+    this.tags = n, this.implicitScalarTags = r, this.implicitScalarByFirstChar = c, this.implicitScalarAnyFirstChar = s, this.defaultScalarTag = f, this.defaultSequenceTag = i.sequence["tag:yaml.org,2002:seq"], this.defaultMappingTag = i.mapping["tag:yaml.org,2002:map"], this.exact = i, this.prefix = o;
+  }
+  /** @internal */
+  lookupScalarTag(t) {
+    const n = this.exact.scalar[t];
+    if (n) return n;
+    for (const r of this.prefix.scalar) if (t.startsWith(r.tagName)) return r;
+  }
+  /** @internal */
+  lookupSequenceTag(t) {
+    const n = this.exact.sequence[t];
+    if (n) return n;
+    for (const r of this.prefix.sequence) if (t.startsWith(r.tagName)) return r;
+  }
+  /** @internal */
+  lookupMappingTag(t) {
+    const n = this.exact.mapping[t];
+    if (n) return n;
+    for (const r of this.prefix.mapping) if (t.startsWith(r.tagName)) return r;
+  }
+  /** @internal */
+  resolveImplicitScalarTag(t) {
+    const n = this.implicitScalarByFirstChar.get(t.charAt(0)) ?? this.implicitScalarAnyFirstChar;
+    for (const i of n) {
+      const o = i.resolve(t, !1, i.tagName);
+      if (o !== M) return {
+        value: o,
+        tag: i
+      };
+    }
+    const r = this.defaultScalarTag;
+    return {
+      value: r.resolve(t, !1, r.tagName),
+      tag: r
+    };
+  }
+  /**
+  * Creates a new schema with the specified tags added. If a tag already
+  * exists, it is replaced by the specified tag.
+  *
+  * @example
+  *
+  * ```javascript
+  * import { CORE_SCHEMA, mergeTag, realMapTag } from 'js-yaml'
+  *
+  * const schema = CORE_SCHEMA.withTags(mergeTag, realMapTag)
+  * ```
+  */
+  withTags(...t) {
+    let n = [];
+    for (const r of t) n = n.concat(r);
+    return new On([...this.tags, ...n]);
+  }
+}, Kt = new dt([
+  Or,
+  yi,
+  Ci
+]);
+new dt([
+  ...Kt.tags,
+  Nr,
+  Mr,
+  zr,
+  li
+]);
+var bn = new dt([
+  ...Kt.tags,
+  Ir,
+  Pr,
+  yn,
+  Cn
+]), Ri = new dt([
+  ...Kt.tags,
+  wr,
+  Kr,
+  It,
+  Nt,
+  _i,
+  Tn,
+  vn,
+  Ln,
+  Rn,
+  xn
+]), xi = Ri.withTags({
+  ...It,
+  resolve: (e, t, n) => {
+    const r = It.resolve(e, t, n);
+    return r === M ? yn.resolve(e, t, n) : r;
+  }
+}, {
+  ...Nt,
+  resolve: (e, t, n) => {
+    const r = Nt.resolve(e, t, n);
+    return r === M ? Cn.resolve(e, t, n) : r;
+  }
+});
+ft("tag:yaml.org,2002:map", {
+  create: () => /* @__PURE__ */ new Map(),
+  addPair: (e, t, n) => (e.set(t, n), ""),
+  has: (e, t) => e.has(t),
+  keys: (e) => e.keys(),
+  get: (e, t) => e.get(t),
+  identify: (e) => e instanceof Map || pt(e),
+  represent: (e) => {
+    if (e instanceof Map) return e;
+    const t = /* @__PURE__ */ new Map(), n = e;
+    for (const r of Object.keys(n)) t.set(r, n[r]);
+    return t;
+  }
+});
+function on(e) {
+  if (Array.isArray(e)) {
+    const t = Array.prototype.slice.call(e);
+    for (let n = 0; n < t.length; n++) {
+      if (Array.isArray(t[n])) return null;
+      typeof t[n] == "object" && Object.prototype.toString.call(t[n]) === "[object Object]" && (t[n] = "[object Object]");
+    }
+    return String(t);
+  }
+  return typeof e == "object" && Object.prototype.toString.call(e) === "[object Object]" ? "[object Object]" : String(e);
+}
+ft("tag:yaml.org,2002:map", {
+  create: () => ({}),
+  identify: pt,
+  represent: (e) => {
+    const t = /* @__PURE__ */ new Map();
+    for (const n of Object.keys(e)) t.set(n, e[n]);
+    return t;
+  },
+  addPair: (e, t, n) => {
+    const r = on(t);
+    return r === null ? "nested arrays are not supported inside keys" : (r === "__proto__" ? Object.defineProperty(e, r, {
+      value: n,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[r] = n, "");
+  },
+  has: (e, t) => {
+    const n = on(t);
+    return n !== null && Object.prototype.hasOwnProperty.call(e, n);
+  },
+  keys: (e) => Object.keys(e),
+  get: (e, t) => {
+    const n = String(t);
+    return Object.prototype.hasOwnProperty.call(e, n) ? e[n] : null;
+  }
+});
+var Oi = {
+  maxLength: 79,
+  indent: 1,
+  linesBefore: 3,
+  linesAfter: 2
+};
+function Tt(e, t, n, r, i) {
+  let o = "", s = "";
+  const a = Math.floor(i / 2) - 1;
+  return r - t > a && (o = " ... ", t = r - a + o.length), n - r > a && (s = " ...", n = r + a - s.length), {
+    str: o + e.slice(t, n).replace(/\t/g, "→") + s,
+    pos: r - t + o.length
+  };
+}
+function vt(e, t) {
+  return " ".repeat(Math.max(t - e.length, 0)) + e;
+}
+function bi(e, t) {
+  if (!e.buffer) return null;
+  const n = {
+    ...Oi,
+    ...t
+  }, r = /\r?\n|\r|\0/g, i = [0], o = [];
+  let s, a = -1;
+  for (; s = r.exec(e.buffer); )
+    o.push(s.index), i.push(s.index + s[0].length), e.position <= s.index && a < 0 && (a = i.length - 2);
+  a < 0 && (a = i.length - 1);
+  let c = "";
+  const f = Math.min(e.line + n.linesAfter, o.length).toString().length, l = n.maxLength - (n.indent + f + 3);
+  for (let S = 1; S <= n.linesBefore && !(a - S < 0); S++) {
+    const T = Tt(e.buffer, i[a - S], o[a - S], e.position - (i[a] - i[a - S]), l);
+    c = `${" ".repeat(n.indent)}${vt((e.line - S + 1).toString(), f)} | ${T.str}
+${c}`;
+  }
+  const E = Tt(e.buffer, i[a], o[a], e.position, l);
+  c += `${" ".repeat(n.indent)}${vt((e.line + 1).toString(), f)} | ${E.str}
+`, c += `${"-".repeat(n.indent + f + 3 + E.pos)}^
+`;
+  for (let S = 1; S <= n.linesAfter && !(a + S >= o.length); S++) {
+    const T = Tt(e.buffer, i[a + S], o[a + S], e.position - (i[a] - i[a + S]), l);
+    c += `${" ".repeat(n.indent)}${vt((e.line + S + 1).toString(), f)} | ${T.str}
+`;
+  }
+  return c.replace(/\n$/, "");
+}
+function sn(e, t) {
+  let n = "";
+  return e.mark ? (e.mark.name && (n += `in "${e.mark.name}" `), n += `(${e.mark.line + 1}:${e.mark.column + 1})`, !t && e.mark.snippet && (n += `
+
+${e.mark.snippet}`), `${e.reason} ${n}`) : e.reason;
+}
+var we = class In extends Error {
+  reason;
+  mark;
+  /**
+  * Optional `mark` contains source snippet data. Usually, use
+  * {@link YAMLException.throwAt} instead of passing it directly.
+  */
+  constructor(t, n) {
+    super(), this.name = "YAMLException", this.reason = t, this.mark = n, this.message = sn(this, !1), Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+  }
+  /**
+  * Returns the formatted error, omitting the source snippet in compact mode.
+  */
+  toString(t) {
+    return `${this.name}: ${sn(this, t)}`;
+  }
+  /**
+  * Builds a YAMLException with a source snippet and throws it. `source` is
+  * the raw input text; `position` is an offset into it.
+  */
+  static throwAt(t, n, r, i = "") {
+    let o = 0, s = 0;
+    for (let c = 0; c < n; c++) {
+      const f = t.charCodeAt(c);
+      f === 10 ? (o++, s = c + 1) : f === 13 && (o++, t.charCodeAt(c + 1) === 10 && c++, s = c + 1);
+    }
+    const a = {
+      name: i,
+      buffer: t,
+      position: n,
+      line: o,
+      column: n - s
+    };
+    throw a.snippet = bi(a), new In(r, a);
+  }
+}, ee = {
+  DOCUMENT: 1,
+  SEQUENCE: 2,
+  MAPPING: 3,
+  SCALAR: 4,
+  ALIAS: 5,
+  POP: 6
+}, N = {
+  PLAIN: 1,
+  SINGLE_QUOTED: 2,
+  DOUBLE_QUOTED: 3,
+  LITERAL_BLOCK: 4,
+  FOLDED_BLOCK: 5
+}, he = {
+  BLOCK: 1,
+  FLOW: 2
+}, _e = {
+  CLIP: 1,
+  STRIP: 2,
+  KEEP: 3
+}, Ii = -1;
+function an(e) {
+  switch (e) {
+    case 48:
+      return "\0";
+    case 97:
+      return "\x07";
+    case 98:
+      return "\b";
+    case 116:
+      return "	";
+    case 9:
+      return "	";
+    case 110:
+      return `
+`;
+    case 118:
+      return "\v";
+    case 102:
+      return "\f";
+    case 114:
+      return "\r";
+    case 101:
+      return "\x1B";
+    case 32:
+      return " ";
+    case 34:
+      return '"';
+    case 47:
+      return "/";
+    case 92:
+      return "\\";
+    case 78:
+      return "…";
+    case 95:
+      return " ";
+    case 76:
+      return "\u2028";
+    case 80:
+      return "\u2029";
+    default:
+      return "";
+  }
+}
+var Nn = new Array(256), $n = new Array(256);
+for (let e = 0; e < 256; e++)
+  Nn[e] = an(e) ? 1 : 0, $n[e] = an(e);
+function Ni(e) {
+  return e <= 65535 ? String.fromCharCode(e) : String.fromCharCode((e - 65536 >> 10) + 55296, (e - 65536 & 1023) + 56320);
+}
+function $i(e) {
+  return e >= 48 && e <= 57 ? e - 48 : (e | 32) - 97 + 10;
+}
+function wi(e) {
+  return e === 120 ? 2 : e === 117 ? 4 : 8;
+}
+function ot(e, t, n) {
+  let r = 0;
+  for (; t < n; ) {
+    const i = e.charCodeAt(t);
+    if (i === 10)
+      r++, t++;
+    else if (i === 13)
+      r++, t++, e.charCodeAt(t) === 10 && t++;
+    else if (i === 32 || i === 9) t++;
+    else break;
+  }
+  return {
+    position: t,
+    breaks: r
+  };
+}
+function Gt(e) {
+  return e === 1 ? " " : `
+`.repeat(e - 1);
+}
+function ki(e, t, n) {
+  let r = "", i = t, o = t, s = t;
+  for (; i < n; ) {
+    const a = e.charCodeAt(i);
+    if (a === 10 || a === 13) {
+      r += e.slice(o, s);
+      const c = ot(e, i, n);
+      r += Gt(c.breaks), i = o = s = c.position;
+    } else
+      i++, a !== 32 && a !== 9 && (s = i);
+  }
+  return r + e.slice(o, s);
+}
+function Fi(e, t, n) {
+  let r = "", i = t, o = t, s = t;
+  for (; i < n; ) {
+    const a = e.charCodeAt(i);
+    if (a === 39)
+      r += e.slice(o, i) + "'", i += 2, o = s = i;
+    else if (a === 10 || a === 13) {
+      r += e.slice(o, s);
+      const c = ot(e, i, n);
+      r += Gt(c.breaks), i = o = s = c.position;
+    } else
+      i++, a !== 32 && a !== 9 && (s = i);
+  }
+  return r + e.slice(o, n);
+}
+function Pi(e, t, n) {
+  let r = "", i = t, o = t, s = t;
+  for (; i < n; ) {
+    const a = e.charCodeAt(i);
+    if (a === 92) {
+      r += e.slice(o, i), i++;
+      const c = e.charCodeAt(i);
+      if (c === 10 || c === 13) i = ot(e, i, n).position;
+      else if (c < 256 && Nn[c])
+        r += $n[c], i++;
+      else {
+        let f = wi(c), l = 0;
+        for (; f > 0; f--) {
+          i++;
+          const E = $i(e.charCodeAt(i));
+          l = (l << 4) + E;
+        }
+        r += Ni(l), i++;
+      }
+      o = s = i;
+    } else if (a === 10 || a === 13) {
+      r += e.slice(o, s);
+      const c = ot(e, i, n);
+      r += Gt(c.breaks), i = o = s = c.position;
+    } else
+      i++, a !== 32 && a !== 9 && (s = i);
+  }
+  return r + e.slice(o, n);
+}
+function cn(e, t, n, r, i, o) {
+  const s = r < 0 ? 0 : r, a = e.slice(t, n).replace(/\r\n?/g, `
+`), c = a === "" ? [] : (a.endsWith(`
+`) ? a.slice(0, -1) : a).split(`
+`);
+  let f = "", l = !1, E = 0, S = !1;
+  for (const T of c) {
+    let C = 0;
+    for (; C < s && T.charCodeAt(C) === 32; ) C++;
+    if (r < 0 || C >= T.length) {
+      E++;
+      continue;
+    }
+    const O = T.slice(s), w = O.charCodeAt(0);
+    o ? w === 32 || w === 9 ? (S = !0, f += `
+`.repeat(l ? 1 + E : E)) : S ? (S = !1, f += `
+`.repeat(E + 1)) : E === 0 ? l && (f += " ") : f += `
+`.repeat(E) : f += `
+`.repeat(l ? 1 + E : E), f += O, l = !0, E = 0;
+  }
+  return i === _e.KEEP ? f += `
+`.repeat(l ? 1 + E : E) : i !== _e.STRIP && l && (f += `
+`), f;
+}
+function Bi(e, t) {
+  if (t.valueStart === Ii) return "";
+  const { valueStart: n, valueEnd: r } = t;
+  if (t.fast) return e.slice(n, r);
+  switch (t.style) {
+    case N.SINGLE_QUOTED:
+      return Fi(e, n, r);
+    case N.DOUBLE_QUOTED:
+      return Pi(e, n, r);
+    case N.LITERAL_BLOCK:
+      return cn(e, n, r, t.indent, t.chomping, !1);
+    case N.FOLDED_BLOCK:
+      return cn(e, n, r, t.indent, t.chomping, !0);
+    default:
+      return ki(e, n, r);
+  }
+}
+var Di = Object.assign(/* @__PURE__ */ Object.create(null), {
+  "!": "!",
+  "!!": "tag:yaml.org,2002:"
+});
+function Lt(e) {
+  return encodeURI(e).replace(/!/g, "%21");
+}
+function wn(e, t) {
+  if (e.startsWith("!<") && e.endsWith(">")) return decodeURIComponent(e.slice(2, -1));
+  const n = e.indexOf("!", 1), r = n === -1 ? "!" : e.slice(0, n + 1), i = t?.[r] ?? Di[r] ?? r;
+  return decodeURIComponent(i) + decodeURIComponent(e.slice(r.length));
+}
+function kn(e) {
+  let t = e;
+  return t.charCodeAt(0) === 33 ? (t = t.slice(1), `!${Lt(t)}`) : t.slice(0, 18) === "tag:yaml.org,2002:" ? `!!${Lt(t.slice(18))}` : `!<${Lt(t)}>`;
+}
+var De = -1, Mi = "tag:yaml.org,2002:merge", qt = {
+  filename: "",
+  schema: bn,
+  json: !1,
+  maxTotalMergeKeys: 1e4,
+  maxAliases: -1
+};
+function Hi(e) {
+  return "tagStart" in e && e.tagStart !== De ? e.tagStart : "anchorStart" in e && e.anchorStart !== De ? e.anchorStart : "valueStart" in e && e.valueStart !== De ? e.valueStart : "start" in e ? e.start : 0;
+}
+function te(e, t) {
+  we.throwAt(e.source, e.position, t, e.filename);
+}
+function Fn(e, t, n, r) {
+  try {
+    return n.finalize(r);
+  } catch (i) {
+    if (i instanceof we) throw i;
+    we.throwAt(e.source, t, i instanceof Error ? i.message : String(i), e.filename);
+  }
+}
+function Ui(e, t) {
+  const n = Bi(e.source, t), r = t.tagStart === De ? "" : e.source.slice(t.tagStart, t.tagEnd), i = e.schema.defaultScalarTag;
+  if (r !== "") {
+    if (r === "!") return {
+      value: n,
+      tag: i
+    };
+    const o = wn(r, e.tagHandlers), s = e.schema.lookupScalarTag(o);
+    if (s) {
+      const c = s.resolve(n, !0, o);
+      return c === M && te(e, `cannot resolve a node with !<${o}> explicit tag`), {
+        value: c,
+        tag: s
+      };
+    }
+    const a = e.schema.lookupMappingTag(o) ?? e.schema.lookupSequenceTag(o);
+    if (a) {
+      n !== "" && te(e, `cannot resolve a node with !<${o}> explicit tag`);
+      const c = a.create(o);
+      return {
+        value: a.carrierIsResult ? c : Fn(e, e.position, a, c),
+        tag: a
+      };
+    }
+    te(e, `unknown scalar tag !<${o}>`);
+  }
+  return t.style === N.PLAIN ? e.schema.resolveImplicitScalarTag(n) : {
+    value: i.resolve(n, !1, i.tagName),
+    tag: i
+  };
+}
+function ln(e, t, n) {
+  const r = t.tagStart === De ? "" : e.source.slice(t.tagStart, t.tagEnd);
+  return r === "" || r === "!" ? n : wn(r, e.tagHandlers);
+}
+function Pn(e) {
+  return e.nodeKind === "mapping";
+}
+function un(e) {
+  e.totalMergeKeys++, e.maxTotalMergeKeys !== -1 && e.totalMergeKeys > e.maxTotalMergeKeys && te(e, `merge keys exceeded maxTotalMergeKeys (${e.maxTotalMergeKeys})`);
+}
+function fn(e, t, n, r) {
+  un(e);
+  for (const i of r.keys(n)) {
+    if (un(e), t.tag.has(t.value, i)) continue;
+    const o = t.tag.addPair(t.value, i, r.get(n, i));
+    o && te(e, o), t.overridable ??= /* @__PURE__ */ new Set(), t.overridable.add(i);
+  }
+}
+function Ki(e, t, n, r) {
+  if (e.position = t.keyPosition, Pn(r)) fn(e, t, n, r);
+  else if (r.nodeKind === "sequence" && Array.isArray(n)) {
+    n.length > 100 && te(e, "abnormal merge sequence size");
+    for (const i of n) {
+      const o = e.nodeTags.get(i);
+      o || te(e, "cannot merge mappings; the provided source object is unacceptable"), fn(e, t, i, o);
+    }
+  } else te(e, "cannot merge mappings; the provided source object is unacceptable");
+}
+function Gi(e, t, n, r, i) {
+  if (e.position = t.keyPosition, t.keyIsMerge) {
+    Ki(e, t, r, i);
+    return;
+  }
+  !e.json && t.tag.has(t.value, n) && !t.overridable?.has(n) && te(e, "duplicated mapping key");
+  const o = t.tag.addPair(t.value, n, r);
+  o && te(e, o), t.overridable?.delete(n);
+}
+function Rt(e, t, n) {
+  const r = e.frames[e.frames.length - 1];
+  if (r.kind === "document")
+    r.value = t, r.hasValue = !0;
+  else if (r.kind === "sequence") {
+    Pn(n) && e.nodeTags.set(t, n);
+    const i = r.tag.addItem(r.value, t, r.index++);
+    i && te(e, i);
+  } else if (r.hasKey) {
+    const i = r.key;
+    r.key = void 0, r.hasKey = !1, Gi(e, r, i, t, n);
+  } else
+    r.key = t, r.keyPosition = e.position, r.hasKey = !0, r.keyIsMerge = n.tagName === Mi;
+}
+function xt(e, t, n, r, i) {
+  if (t.anchorStart !== De) {
+    const o = {
+      value: n,
+      tag: r,
+      isValueFinal: i
+    };
+    return e.anchors.set(e.source.slice(t.anchorStart, t.anchorEnd), o), o;
+  }
+  return null;
+}
+function qi(e, t) {
+  const n = {
+    ...qt,
+    ...t,
+    events: e,
+    documents: [],
+    eventIndex: 0,
+    position: 0,
+    frames: [],
+    anchors: /* @__PURE__ */ new Map(),
+    nodeTags: /* @__PURE__ */ new Map(),
+    tagHandlers: /* @__PURE__ */ Object.create(null),
+    totalMergeKeys: 0,
+    aliasCount: 0
+  };
+  for (; n.eventIndex < n.events.length; ) {
+    const r = n.events[n.eventIndex++];
+    switch (n.position = Hi(r), r.type) {
+      case ee.DOCUMENT:
+        n.anchors = /* @__PURE__ */ new Map(), n.nodeTags = /* @__PURE__ */ new Map(), n.aliasCount = 0, n.tagHandlers = /* @__PURE__ */ Object.create(null);
+        for (const i of r.directives) i.kind === "tag" && (n.tagHandlers[i.handle] = i.prefix);
+        n.frames.push({
+          kind: "document",
+          position: n.position,
+          value: void 0,
+          hasValue: !1
+        });
+        break;
+      case ee.SCALAR: {
+        const { value: i, tag: o } = Ui(n, r);
+        xt(n, r, i, o, !0), Rt(n, i, o);
+        break;
+      }
+      case ee.SEQUENCE: {
+        const i = ln(n, r, "tag:yaml.org,2002:seq"), o = n.schema.lookupSequenceTag(i);
+        o || te(n, `unknown sequence tag !<${i}>`);
+        const s = o.create(i), a = xt(n, r, s, o, o.carrierIsResult);
+        n.frames.push({
+          kind: "sequence",
+          position: n.position,
+          value: s,
+          tag: o,
+          anchor: a,
+          index: 0
+        });
+        break;
+      }
+      case ee.MAPPING: {
+        const i = ln(n, r, "tag:yaml.org,2002:map"), o = n.schema.lookupMappingTag(i);
+        o || te(n, `unknown mapping tag !<${i}>`);
+        const s = o.create(i), a = xt(n, r, s, o, o.carrierIsResult);
+        n.frames.push({
+          kind: "mapping",
+          position: n.position,
+          value: s,
+          tag: o,
+          anchor: a,
+          key: void 0,
+          keyPosition: n.position,
+          hasKey: !1,
+          keyIsMerge: !1,
+          overridable: null
+        });
+        break;
+      }
+      case ee.ALIAS: {
+        n.maxAliases !== -1 && ++n.aliasCount > n.maxAliases && te(n, `aliases exceeded maxAliases (${n.maxAliases})`);
+        const i = n.source.slice(r.anchorStart, r.anchorEnd), o = n.anchors.get(i);
+        o || te(n, `unidentified alias "${i}"`), o.isValueFinal || te(n, `recursive alias "${i}" is not supported for tag ${o.tag.tagName} because it uses finalize()`), Rt(n, o.value, o.tag);
+        break;
+      }
+      case ee.POP: {
+        const i = n.frames.pop();
+        if (i.kind === "mapping" && i.hasKey && (n.position = i.keyPosition, te(n, "incomplete mapping pair in event stream")), i.kind === "document") n.documents.push(i.value);
+        else {
+          const o = i.tag.carrierIsResult ? i.value : Fn(n, i.position, i.tag, i.value);
+          i.anchor && (i.anchor.value = o, i.anchor.isValueFinal = !0), Rt(n, o, i.tag);
+        }
+        break;
+      }
+    }
+  }
+  return n.documents;
+}
+var H = -1, Bn = Object.prototype.hasOwnProperty, Ke = 1, Dn = 2, Mn = 3, st = 4, Wi = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/, Yi = /[,\[\]{}]/, Hn = /^(?:!|!!|![0-9A-Za-z-]+!)$/, wt = String.raw`(?:%[0-9A-Fa-f]{2}|[0-9A-Za-z\-#;/?:@&=+$,_.!~*'()\[\]])`, Un = String.raw`(?:%[0-9A-Fa-f]{2}|[0-9A-Za-z\-#;/?:@&=+$.~*'()_])`, ji = new RegExp(`^(?:${wt})*$`), Qi = new RegExp(`^(?:${Un})+$`), Vi = new RegExp(`^(?:!(?:${wt})*|${Un}(?:${wt})*)$`), Wt = {
+  filename: "",
+  maxDepth: 100
+};
+function Xi(e, t, n) {
+  e.events.push({
+    type: ee.DOCUMENT,
+    explicitStart: t,
+    explicitEnd: n,
+    directives: e.directives
+  });
+}
+function Kn(e, t, n, r, i, o, s) {
+  e.events.push({
+    type: ee.SEQUENCE,
+    start: t,
+    anchorStart: n,
+    anchorEnd: r,
+    tagStart: i,
+    tagEnd: o,
+    style: s
+  });
+}
+function Gn(e, t, n, r, i, o, s) {
+  e.events.push({
+    type: ee.MAPPING,
+    start: t,
+    anchorStart: n,
+    anchorEnd: r,
+    tagStart: i,
+    tagEnd: o,
+    style: s
+  });
+}
+function pn(e, t) {
+  e.events.splice(t.eventsLength, 0, {
+    type: ee.MAPPING,
+    start: t.position,
+    anchorStart: H,
+    anchorEnd: H,
+    tagStart: H,
+    tagEnd: H,
+    style: he.FLOW
+  });
+}
+function We(e, t, n, r, i, o, s, a, c = _e.CLIP, f = -1, l = !1) {
+  e.events.push({
+    type: ee.SCALAR,
+    valueStart: t,
+    valueEnd: n,
+    anchorStart: r,
+    anchorEnd: i,
+    tagStart: o,
+    tagEnd: s,
+    style: a,
+    chomping: c,
+    indent: f,
+    fast: l
+  });
+}
+function zi(e, t, n) {
+  e.events.push({
+    type: ee.ALIAS,
+    anchorStart: t,
+    anchorEnd: n
+  });
+}
+function Me(e) {
+  e.events.push({ type: ee.POP });
+}
+function ae(e) {
+  We(e, H, H, H, H, H, H, N.PLAIN);
+}
+function dn() {
+  return {
+    anchorStart: H,
+    anchorEnd: H,
+    tagStart: H,
+    tagEnd: H
+  };
+}
+function He(e) {
+  return {
+    position: e.position,
+    line: e.line,
+    lineStart: e.lineStart,
+    lineIndent: e.lineIndent,
+    firstTabInLine: e.firstTabInLine,
+    eventsLength: e.events.length
+  };
+}
+function Ue(e, t) {
+  e.position = t.position, e.line = t.line, e.lineStart = t.lineStart, e.lineIndent = t.lineIndent, e.firstTabInLine = t.firstTabInLine, e.events.length = t.eventsLength;
+}
+function x(e, t) {
+  we.throwAt(e.input.slice(0, e.length), e.position, t, e.filename);
+}
+function J(e) {
+  return e === 10 || e === 13;
+}
+function Ye(e) {
+  return e === 9 || e === 32;
+}
+function ge(e) {
+  return Ye(e) || J(e);
+}
+function Ce(e) {
+  return e === 0 || ge(e);
+}
+function ke(e) {
+  return e === 44 || e === 91 || e === 93 || e === 123 || e === 125;
+}
+function Zi(e) {
+  return e >= 48 && e <= 57 ? e - 48 : -1;
+}
+function Ji(e) {
+  if (e >= 48 && e <= 57) return e - 48;
+  const t = e | 32;
+  return t >= 97 && t <= 102 ? t - 97 + 10 : -1;
+}
+function eo(e) {
+  return e === 120 ? 2 : e === 117 ? 4 : e === 85 ? 8 : 0;
+}
+function to(e) {
+  return e === 48 || e === 97 || e === 98 || e === 116 || e === 9 || e === 110 || e === 118 || e === 102 || e === 114 || e === 101 || e === 32 || e === 34 || e === 47 || e === 92 || e === 78 || e === 95 || e === 76 || e === 80;
+}
+function at(e) {
+  e.input.charCodeAt(e.position) === 10 ? e.position++ : (e.position++, e.input.charCodeAt(e.position) === 10 && e.position++), e.line++, e.lineStart = e.position, e.lineIndent = 0, e.firstTabInLine = -1;
+}
+function re(e, t) {
+  let n = 0, r = e.input.charCodeAt(e.position), i = e.position === e.lineStart || ge(e.input.charCodeAt(e.position - 1));
+  for (; r !== 0; ) {
+    for (; Ye(r); )
+      i = !0, r === 9 && e.firstTabInLine === -1 && (e.firstTabInLine = e.position), r = e.input.charCodeAt(++e.position);
+    if (t && i && r === 35) do
+      r = e.input.charCodeAt(++e.position);
+    while (!J(r) && r !== 0);
+    if (!J(r)) break;
+    for (at(e), n++, i = !0, r = e.input.charCodeAt(e.position); r === 32; )
+      e.lineIndent++, r = e.input.charCodeAt(++e.position);
+  }
+  return n;
+}
+function Ge(e, t = e.position) {
+  const n = e.input.charCodeAt(t);
+  if ((n === 45 || n === 46) && n === e.input.charCodeAt(t + 1) && n === e.input.charCodeAt(t + 2)) {
+    const r = e.input.charCodeAt(t + 3);
+    return r === 0 || ge(r);
+  }
+  return !1;
+}
+function qn(e) {
+  e.position === e.lineStart && e.input.charCodeAt(e.position) === 65279 && (e.position++, e.lineStart = e.position);
+}
+function Yt(e) {
+  if (e.position !== e.lineStart) return !1;
+  if (Ge(e)) return !0;
+  if (e.input.charCodeAt(e.position) !== 65279) return !1;
+  const t = He(e);
+  qn(e), re(e, !0);
+  const n = e.input.charCodeAt(e.position), r = e.position === e.lineStart && (n === 37 || n === 45 && Ge(e));
+  return Ue(e, t), r;
+}
+function hn(e) {
+  let t = e.input.charCodeAt(e.position);
+  for (; t !== 0 && !J(t); ) t = e.input.charCodeAt(++e.position);
+}
+function Wn(e, t, n) {
+  Wi.test(e.input.slice(t, n)) && x(e, "the stream contains non-printable characters");
+}
+function no(e, t, n) {
+  if (e.input.charCodeAt(e.position) !== 33) return !1;
+  t.tagStart !== H && x(e, "duplication of a tag property");
+  const r = e.position;
+  let i = !1, o = !1, s = "!", a = e.input.charCodeAt(++e.position);
+  a === 60 ? (i = !0, a = e.input.charCodeAt(++e.position)) : a === 33 && (o = !0, s = "!!", a = e.input.charCodeAt(++e.position));
+  let c = e.position, f;
+  if (i) {
+    for (; a !== 0 && a !== 62; ) a = e.input.charCodeAt(++e.position);
+    a !== 62 && x(e, "unexpected end of the stream within a verbatim tag"), f = e.input.slice(c, e.position), e.position++;
+  } else {
+    for (; a !== 0 && !ge(a) && !(n && ke(a)); )
+      a === 33 && (o ? x(e, "tag suffix cannot contain exclamation marks") : (s = e.input.slice(c - 1, e.position + 1), Hn.test(s) || x(e, "named tag handle cannot contain such characters"), o = !0, c = e.position + 1)), a = e.input.charCodeAt(++e.position);
+    f = e.input.slice(c, e.position), Yi.test(f) && x(e, "tag suffix cannot contain flow indicator characters");
+  }
+  return f && !(i ? ji.test(f) : Qi.test(f)) && x(e, `tag name cannot contain such characters: ${f}`), !i && s !== "!" && s !== "!!" && !Bn.call(e.tagHandlers, s) && x(e, `undeclared tag handle "${s}"`), t.tagStart = r, t.tagEnd = e.position, !0;
+}
+function ro(e, t) {
+  if (e.input.charCodeAt(e.position) !== 38) return !1;
+  t.anchorStart !== H && x(e, "duplication of an anchor property"), e.position++;
+  const n = e.position;
+  for (; e.input.charCodeAt(e.position) !== 0 && !ge(e.input.charCodeAt(e.position)) && !ke(e.input.charCodeAt(e.position)); ) e.position++;
+  return e.position === n && x(e, "name of an anchor node must contain at least one character"), t.anchorStart = n, t.anchorEnd = e.position, !0;
+}
+function io(e, t) {
+  if (e.input.charCodeAt(e.position) !== 42) return !1;
+  (t.anchorStart !== H || t.tagStart !== H) && x(e, "alias node should not have any properties"), e.position++;
+  const n = e.position;
+  for (; e.input.charCodeAt(e.position) !== 0 && !ge(e.input.charCodeAt(e.position)) && !ke(e.input.charCodeAt(e.position)); ) e.position++;
+  return e.position === n && x(e, "name of an alias node must contain at least one character"), zi(e, n, e.position), !0;
+}
+function kt(e, t) {
+  re(e, !1), e.lineIndent < t && x(e, "deficient indentation");
+}
+function oo(e, t, n) {
+  if (e.input.charCodeAt(e.position) !== 39) return !1;
+  e.position++;
+  const r = e.position;
+  let i = !0;
+  for (; e.input.charCodeAt(e.position) !== 0; ) {
+    const o = e.input.charCodeAt(e.position);
+    if (o === 39) {
+      if (e.input.charCodeAt(e.position + 1) === 39) {
+        i = !1, e.position += 2;
+        continue;
+      }
+      const s = e.position;
+      return e.position++, We(e, r, s, n.anchorStart, n.anchorEnd, n.tagStart, n.tagEnd, N.SINGLE_QUOTED, _e.CLIP, -1, i), !0;
+    }
+    J(o) ? (i = !1, kt(e, t)) : e.position === e.lineStart && Ge(e) ? x(e, "unexpected end of the document within a single quoted scalar") : o !== 9 && o < 32 ? x(e, "expected valid JSON character") : e.position++;
+  }
+  x(e, "unexpected end of the stream within a single quoted scalar");
+}
+function so(e, t, n) {
+  if (e.input.charCodeAt(e.position) !== 34) return !1;
+  e.position++;
+  const r = e.position;
+  let i = !0;
+  for (; e.input.charCodeAt(e.position) !== 0; ) {
+    const o = e.input.charCodeAt(e.position);
+    if (o === 34) {
+      const s = e.position;
+      return e.position++, We(e, r, s, n.anchorStart, n.anchorEnd, n.tagStart, n.tagEnd, N.DOUBLE_QUOTED, _e.CLIP, -1, i), !0;
+    }
+    if (o === 92) {
+      i = !1;
+      const s = e.input.charCodeAt(++e.position);
+      if (J(s)) kt(e, t);
+      else if (to(s)) e.position++;
+      else {
+        let a = eo(s);
+        for (a === 0 && x(e, "unknown escape sequence"); a-- > 0; )
+          e.position++, Ji(e.input.charCodeAt(e.position)) < 0 && x(e, "expected hexadecimal character");
+        e.position++;
+      }
+    } else J(o) ? (i = !1, kt(e, t)) : e.position === e.lineStart && Ge(e) ? x(e, "unexpected end of the document within a double quoted scalar") : o !== 9 && o < 32 ? x(e, "expected valid JSON character") : e.position++;
+  }
+  x(e, "unexpected end of the stream within a double quoted scalar");
+}
+function ao(e, t, n) {
+  const r = e.input.charCodeAt(e.position);
+  let i = _e.CLIP, o = -1, s = !1;
+  if (r !== 124 && r !== 62) return !1;
+  const a = r === 124 ? N.LITERAL_BLOCK : N.FOLDED_BLOCK;
+  for (e.position++; e.input.charCodeAt(e.position) !== 0; ) {
+    const T = e.input.charCodeAt(e.position), C = Zi(T);
+    if (T === 43 || T === 45)
+      i !== _e.CLIP && x(e, "repeat of a chomping mode identifier"), i = T === 43 ? _e.KEEP : _e.STRIP, e.position++;
+    else if (C >= 0)
+      C === 0 && x(e, "bad explicit indentation width of a block scalar; it cannot be less than one"), s && x(e, "repeat of an indentation width identifier"), o = t + C - 1, s = !0, e.position++;
+    else break;
+  }
+  let c = !1;
+  for (; Ye(e.input.charCodeAt(e.position)); )
+    c = !0, e.position++;
+  c && e.input.charCodeAt(e.position) === 35 && hn(e), J(e.input.charCodeAt(e.position)) ? at(e) : e.input.charCodeAt(e.position) !== 0 && x(e, "a line break is expected");
+  let f = s ? o : -1, l = 0;
+  const E = e.position;
+  let S = e.position;
+  for (; e.input.charCodeAt(e.position) !== 0; ) {
+    const T = e.position;
+    let C = 0;
+    for (; e.input.charCodeAt(T + C) === 32; ) C++;
+    const O = e.input.charCodeAt(T + C);
+    if (O === 0) {
+      f >= 0 ? C > f && (S = T + C) : C > 0 && (S = T + C);
+      break;
+    }
+    if (Yt(e)) break;
+    if (!s && f === -1 && J(O) && (l = Math.max(l, C)), !s && f === -1 && !J(O) && (O === 9 && C < t && (e.position = T + C, x(e, "tab characters must not be used in indentation")), C >= t && C < l && (e.position = T + C, x(e, "bad indentation of a mapping entry"))), f === -1 && O !== 0 && !J(O) && C < t) {
+      e.lineIndent = C, e.position = T + C;
+      break;
+    }
+    !s && O !== 0 && !J(O) && f === -1 && (f = C);
+    const w = f === -1 ? t + 1 : f;
+    if (O !== 0 && !J(O) && C < w) {
+      e.lineIndent = C, e.position = T + C;
+      break;
+    }
+    hn(e), S = e.position, J(e.input.charCodeAt(e.position)) && (at(e), S = e.position);
+  }
+  return Wn(e, E, S), We(e, E, S, n.anchorStart, n.anchorEnd, n.tagStart, n.tagEnd, a, i, f), !0;
+}
+function co(e, t) {
+  const n = e.input.charCodeAt(e.position), r = t === Ke;
+  if (n === 0 || ge(n) || n === 35 || n === 38 || n === 42 || n === 33 || n === 124 || n === 62 || n === 39 || n === 34 || n === 37 || n === 64 || n === 96 || r && ke(n)) return !1;
+  if (n === 63 || n === 45) {
+    const i = e.input.charCodeAt(e.position + 1);
+    if (Ce(i) || r && ke(i)) return !1;
+  }
+  return !0;
+}
+function lo(e, t, n, r) {
+  if (!co(e, n)) return !1;
+  const i = e.position;
+  let o = e.position, s = e.input.charCodeAt(e.position);
+  const a = n === Ke;
+  let c = !1;
+  for (; s !== 0 && !Yt(e); ) {
+    if (s === 58) {
+      const f = e.input.charCodeAt(e.position + 1);
+      if (Ce(f) || a && ke(f)) break;
+    } else if (s === 35) {
+      if (ge(e.input.charCodeAt(e.position - 1))) break;
+    } else {
+      if (a && ke(s)) break;
+      if (J(s)) {
+        const f = e.position, l = e.line, E = e.lineStart, S = e.lineIndent;
+        if (re(e, !1), e.lineIndent >= t) {
+          c = !0, s = e.input.charCodeAt(e.position);
+          continue;
+        }
+        e.position = f, e.line = l, e.lineStart = E, e.lineIndent = S;
+        break;
+      }
+    }
+    Ye(s) || (o = e.position + 1), s = e.input.charCodeAt(++e.position);
+  }
+  return o === i ? !1 : (Wn(e, i, o), We(e, i, o, r.anchorStart, r.anchorEnd, r.tagStart, r.tagEnd, N.PLAIN, _e.CLIP, -1, !c), !0);
+}
+function Qe(e, t) {
+  const n = e.line;
+  re(e, !0), (e.line > n && e.lineIndent < t || e.firstTabInLine !== -1 && e.lineIndent < t) && x(e, "deficient indentation");
+}
+function uo(e, t, n) {
+  const r = e.input.charCodeAt(e.position), i = r === 123, o = e.position;
+  let s = !0;
+  if (r !== 91 && r !== 123) return !1;
+  const a = i ? 125 : 93;
+  for (i ? Gn(e, o, n.anchorStart, n.anchorEnd, n.tagStart, n.tagEnd, he.FLOW) : Kn(e, o, n.anchorStart, n.anchorEnd, n.tagStart, n.tagEnd, he.FLOW), e.position++; e.input.charCodeAt(e.position) !== 0; ) {
+    Qe(e, t);
+    let c = e.input.charCodeAt(e.position);
+    if (c === a)
+      return e.position++, Me(e), !0;
+    s ? c === 44 && x(e, "expected the node content, but found ','") : x(e, "missed comma between flow collection entries");
+    let f = !1, l = !1;
+    c === 63 && ge(e.input.charCodeAt(e.position + 1)) && (f = l = !0, e.position += 1, Qe(e, t));
+    const E = e.line, S = He(e), T = qe(e, t, Ke, !1, !0);
+    Qe(e, t), c = e.input.charCodeAt(e.position), (i || l || e.line === E) && c === 58 ? (f = !0, e.position++, Qe(e, t), i || pn(e, S), T || ae(e), qe(e, t, Ke, !1, !0) || ae(e), Qe(e, t), i || Me(e)) : i && f ? (T || ae(e), ae(e)) : i ? ae(e) : f && (pn(e, S), T || ae(e), ae(e), Me(e)), c = e.input.charCodeAt(e.position), c === 44 ? (s = !0, e.position++) : s = !1;
+  }
+  x(e, "unexpected end of the stream within a flow collection");
+}
+function gn(e, t, n) {
+  if (e.firstTabInLine !== -1 || e.input.charCodeAt(e.position) !== 45 || !Ce(e.input.charCodeAt(e.position + 1))) return !1;
+  for (Kn(e, e.position, n.anchorStart, n.anchorEnd, n.tagStart, n.tagEnd, he.BLOCK); e.input.charCodeAt(e.position) === 45 && Ce(e.input.charCodeAt(e.position + 1)); ) {
+    e.firstTabInLine !== -1 && (e.position = e.firstTabInLine, x(e, "tab characters must not be used in indentation"));
+    const r = e.line;
+    e.position++;
+    const i = re(e, !0) > 0;
+    if (e.firstTabInLine !== -1 && e.input.charCodeAt(e.position) === 45 && Ce(e.input.charCodeAt(e.position + 1)) && x(e, "bad indentation of a sequence entry"), i && e.lineIndent <= t ? ae(e) : qe(e, t, Mn, !1, !0), re(e, !0), e.lineIndent < t || e.position >= e.length) break;
+    e.lineIndent > t && x(e, "bad indentation of a sequence entry"), e.line === r && e.input.charCodeAt(e.position) === 45 && Ce(e.input.charCodeAt(e.position + 1)) && x(e, "bad indentation of a sequence entry");
+  }
+  return Me(e), !0;
+}
+function Ot(e, t, n, r) {
+  let i = !1, o = !1, s = !1, a = !1;
+  if (e.firstTabInLine !== -1) return !1;
+  let c = e.input.charCodeAt(e.position);
+  for (; c !== 0; ) {
+    !i && e.firstTabInLine !== -1 && (e.position = e.firstTabInLine, x(e, "tab characters must not be used in indentation"));
+    const f = e.input.charCodeAt(e.position + 1), l = e.line;
+    if ((c === 63 || c === 58) && Ce(f))
+      s || (Gn(e, e.position, r.anchorStart, r.anchorEnd, r.tagStart, r.tagEnd, he.BLOCK), s = !0), c === 63 ? (i && ae(e), o = !0, i = !0) : (i || (ae(e), o = !0), i = !1), e.position += 1, a = !0;
+    else {
+      i && (ae(e), i = !1);
+      const E = He(e);
+      if (!qe(e, n, Dn, !1, !0)) break;
+      if (e.line === l) {
+        for (c = e.input.charCodeAt(e.position); Ye(c); ) c = e.input.charCodeAt(++e.position);
+        if (c === 58)
+          c = e.input.charCodeAt(++e.position), Ce(c) || x(e, "a whitespace character is expected after the key-value separator within a block mapping"), s || (e.events.splice(E.eventsLength, 0, {
+            type: ee.MAPPING,
+            start: E.position,
+            anchorStart: r.anchorStart,
+            anchorEnd: r.anchorEnd,
+            tagStart: r.tagStart,
+            tagEnd: r.tagEnd,
+            style: he.BLOCK
+          }), s = !0), o = !0, i = !1, a = !1;
+        else if (o) x(e, "expected ':' after a mapping key");
+        else
+          return r.anchorStart !== H || r.tagStart !== H ? (Ue(e, E), !1) : !0;
+      } else if (o) x(e, "can not read a block mapping entry; a multiline key may not be an implicit key");
+      else
+        return r.anchorStart !== H || r.tagStart !== H ? (Ue(e, E), !1) : !0;
+    }
+    if (qe(e, t, st, !0, a) && (a = !1), i || a && (ae(e), a = !1), re(e, !0), c = e.input.charCodeAt(e.position), (e.line === l || e.lineIndent > t) && c !== 0) x(e, "bad indentation of a mapping entry");
+    else if (e.lineIndent < t) break;
+  }
+  return o ? (i && ae(e), s && Me(e), !0) : !1;
+}
+function qe(e, t, n, r, i, o = !0) {
+  e.depth >= e.maxDepth && x(e, `nesting exceeded maxDepth (${e.maxDepth})`), e.depth++;
+  let s = 1, a = !1, c = !1, f = null;
+  const l = dn();
+  let E = n === st || n === Mn, S = E;
+  const T = E;
+  if (r && re(e, !0) && (a = !0, e.lineIndent > t ? s = 1 : e.lineIndent === t ? s = 0 : s = -1), s === 1) for (; ; ) {
+    const C = e.input.charCodeAt(e.position), O = He(e);
+    if (a && s !== 1 && (C === 33 || C === 38)) break;
+    if (a && T && (l.tagStart !== H || l.anchorStart !== H) && (C === 33 || C === 38)) {
+      const w = He(e), b = t + 1;
+      if (Ot(e, e.position - e.lineStart, b, l) && e.events[w.eventsLength]?.type === ee.MAPPING)
+        return e.depth--, !0;
+      Ue(e, w);
+    }
+    if (a && (C === 33 && l.tagStart !== H || C === 38 && l.anchorStart !== H) || !no(e, l, n === Ke) && !ro(e, l)) break;
+    f === null && (f = O), re(e, !0) ? (a = !0, S = T, e.lineIndent > t ? s = 1 : e.lineIndent === t ? s = 0 : s = -1) : S = !1;
+  }
+  if (S && (S = a || i), s === 1 || n === st) {
+    const C = n === Ke || n === Dn ? t : t + 1, O = e.position - e.lineStart;
+    if (s === 1) if (S && (gn(e, O, l) || Ot(e, O, C, l)) || uo(e, C, l)) c = !0;
+    else {
+      const w = e.input.charCodeAt(e.position);
+      if (f !== null && o && T && !S && w !== 124 && w !== 62) {
+        const b = He(e), $ = f.position - f.lineStart;
+        Ue(e, f), Ot(e, $, C, dn()) && e.events[b.eventsLength]?.type === ee.MAPPING ? c = !0 : Ue(e, b);
+      }
+      !c && (E && ao(e, C, l) || oo(e, C, l) || so(e, C, l) || io(e, l) || lo(e, C, n, l)) && (c = !0);
+    }
+    else s === 0 && (c = S && gn(e, O, l));
+  }
+  return E = E && !c, !c && (l.anchorStart !== H || l.tagStart !== H || E) && (We(e, H, H, l.anchorStart, l.anchorEnd, l.tagStart, l.tagEnd, N.PLAIN), c = !0), e.depth--, c || l.anchorStart !== H || l.tagStart !== H;
+}
+function fo(e) {
+  if (e.lineIndent > 0 || e.input.charCodeAt(e.position) !== 37) return !1;
+  e.position++;
+  const t = e.position;
+  for (; e.input.charCodeAt(e.position) !== 0 && !ge(e.input.charCodeAt(e.position)); ) e.position++;
+  const n = e.input.slice(t, e.position), r = [];
+  for (n.length === 0 && x(e, "directive name must not be less than one character in length"); e.input.charCodeAt(e.position) !== 0 && !J(e.input.charCodeAt(e.position)); ) {
+    for (; Ye(e.input.charCodeAt(e.position)); ) e.position++;
+    if (e.input.charCodeAt(e.position) === 35 || J(e.input.charCodeAt(e.position)) || e.input.charCodeAt(e.position) === 0) break;
+    const i = e.position;
+    for (; e.input.charCodeAt(e.position) !== 0 && !ge(e.input.charCodeAt(e.position)); ) e.position++;
+    r.push(e.input.slice(i, e.position));
+  }
+  if (J(e.input.charCodeAt(e.position)) && at(e), n === "YAML") {
+    e.directives.some((o) => o.kind === "yaml") && x(e, "duplication of %YAML directive"), r.length !== 1 && x(e, "YAML directive accepts exactly one argument");
+    const i = /^([0-9]+)\.([0-9]+)$/.exec(r[0]);
+    i === null && x(e, "ill-formed argument of the YAML directive"), parseInt(i[1], 10) !== 1 && x(e, "unacceptable YAML version of the document"), e.directives.push({
+      kind: "yaml",
+      version: r[0]
+    });
+  } else if (n === "TAG") {
+    r.length !== 2 && x(e, "TAG directive accepts exactly two arguments");
+    const [i, o] = r;
+    Hn.test(i) || x(e, "ill-formed tag handle (first argument) of the TAG directive"), Bn.call(e.tagHandlers, i) && x(e, `there is a previously declared suffix for "${i}" tag handle`), Vi.test(o) || x(e, "ill-formed tag prefix (second argument) of the TAG directive"), e.tagHandlers[i] = o, e.directives.push({
+      kind: "tag",
+      handle: i,
+      prefix: o
+    });
+  }
+  return !0;
+}
+function po(e) {
+  e.directives = [], e.tagHandlers = /* @__PURE__ */ Object.create(null);
+  let t = !1;
+  for (re(e, !0); fo(e); )
+    t = !0, re(e, !0);
+  let n = !1, r = !1, i = !0;
+  if (e.lineIndent === 0 && e.input.charCodeAt(e.position) === 45 && e.input.charCodeAt(e.position + 1) === 45 && e.input.charCodeAt(e.position + 2) === 45 && Ce(e.input.charCodeAt(e.position + 3))) {
+    n = !0;
+    const a = e.line;
+    e.position += 3, re(e, !0), i = e.line > a;
+  } else t && x(e, "directives end mark is expected");
+  const o = e.events.length;
+  if (!n && e.position === e.lineStart && e.input.charCodeAt(e.position) === 46 && Ge(e)) {
+    e.position += 3, re(e, !0);
+    return;
+  }
+  if (Xi(e, n, !1), qe(e, e.lineIndent - 1, st, !1, i, i) || ae(e), re(e, !0), e.position === e.lineStart && Ge(e) && (r = e.input.charCodeAt(e.position) === 46, r)) {
+    const a = e.line;
+    e.position += 3, re(e, !0), e.line === a && e.position < e.length && x(e, "end of the stream or a document separator is expected");
+  }
+  const s = e.events[o];
+  s?.type === ee.DOCUMENT && (s.explicitEnd = r), Me(e), !r && e.position < e.length && !Yt(e) && x(e, "end of the stream or a document separator is expected");
+}
+function ho(e, t) {
+  const n = e.length, r = {
+    ...Wt,
+    ...t,
+    input: `${e}\0`,
+    length: n,
+    position: 0,
+    line: 0,
+    lineStart: 0,
+    lineIndent: 0,
+    firstTabInLine: -1,
+    depth: 0,
+    directives: [],
+    tagHandlers: /* @__PURE__ */ Object.create(null),
+    events: []
+  }, i = e.indexOf("\0");
+  for (i !== -1 && we.throwAt(e, i, "null byte is not allowed in input", r.filename); r.position < r.length && (qn(r), re(r, !0), !(r.position >= r.length)); ) {
+    const o = r.position;
+    po(r), r.position === o && x(r, "can not read a document");
+  }
+  return r.events;
+}
+var go = {
+  ...Wt,
+  ...qt
+};
+function mo(e, t = {}) {
+  const n = {
+    ...go,
+    ...t
+  }, r = String(e), i = Object.keys(Wt), o = Object.keys(qt);
+  return qi(ho(r, $t(n, i)), {
+    ...$t(n, o),
+    source: r
+  });
+}
+function Ao(e, t, n) {
+  let r = null;
+  typeof t == "function" ? r = t : t !== null && typeof t == "object" && (n = t);
+  const i = mo(e, n);
+  if (r === null) return i;
+  for (const o of i) r(o);
+}
+var Ne = /* @__PURE__ */ Symbol("INVALID");
+function Eo(e) {
+  const t = new Set([
+    e.defaultScalarTag,
+    e.defaultSequenceTag,
+    e.defaultMappingTag
+  ].filter((o) => o !== void 0)), n = e.implicitScalarTags, r = e.tags.filter((o) => !(o.nodeKind === "scalar" && o.implicit) && !t.has(o)), i = e.tags.filter((o) => t.has(o));
+  return [
+    ...n.map((o) => ({
+      tag: o,
+      implicitTag: !0
+    })),
+    ...r.map((o) => ({
+      tag: o,
+      implicitTag: !1
+    })),
+    ...i.map((o) => ({
+      tag: o,
+      implicitTag: !0
+    }))
+  ];
+}
+function So(e, t) {
+  for (let n = 0, r = e.representTypes.length; n < r; n += 1) {
+    const { tag: i, implicitTag: o } = e.representTypes[n];
+    if (i.identify(t)) {
+      let s;
+      return i.matchByTagPrefix ? s = i.representTagName(t) : s = i.tagName, {
+        tag: i,
+        tagName: s,
+        implicitTag: o
+      };
+    }
+  }
+  return null;
+}
+function Xe(e, t) {
+  if (!e.noRefs && t !== null && typeof t == "object") {
+    const f = e.refs.get(t);
+    if (f)
+      return f.anchor === void 0 && (f.anchor = `ref_${e.refCounter++}`), {
+        kind: "alias",
+        anchor: f.anchor
+      };
+  }
+  const n = So(e, t);
+  if (!n) {
+    if (t === void 0 || e.skipInvalid) return Ne;
+    throw new we(`unacceptable kind of an object to dump ${Object.prototype.toString.call(t)}`);
+  }
+  const { tag: r, tagName: i, implicitTag: o } = n, s = o ? i : kn(i);
+  if (r.nodeKind === "scalar") return {
+    kind: "scalar",
+    tag: s,
+    tagged: !o,
+    style: N.PLAIN,
+    value: r.represent(t)
+  };
+  if (r.nodeKind === "sequence") {
+    const f = r.represent(t), l = {
+      kind: "sequence",
+      tag: s,
+      tagged: !o,
+      style: he.BLOCK,
+      items: []
+    };
+    e.noRefs || e.refs.set(t, l);
+    for (let E = 0, S = f.length; E < S; E += 1) {
+      let T = Xe(e, f[E]);
+      T === Ne && f[E] === void 0 && (T = Xe(e, null)), T !== Ne && l.items.push(T);
+    }
+    return l;
+  }
+  const a = r.represent(t), c = {
+    kind: "mapping",
+    tag: s,
+    tagged: !o,
+    style: he.BLOCK,
+    items: []
+  };
+  e.noRefs || e.refs.set(t, c);
+  for (const [f, l] of a) {
+    const E = Xe(e, f);
+    if (E === Ne) continue;
+    const S = Xe(e, l);
+    S !== Ne && c.items.push({
+      key: E,
+      value: S
+    });
+  }
+  return c;
+}
+function _o(e, t, n = {}) {
+  const r = Xe({
+    representTypes: Eo(t),
+    noRefs: n.noRefs ?? !1,
+    skipInvalid: n.skipInvalid ?? !1,
+    refs: /* @__PURE__ */ new Map(),
+    refCounter: 0
+  }, e);
+  return [{
+    contents: r === Ne ? null : r,
+    directives: []
+  }];
+}
+var yo = /* @__PURE__ */ Symbol("visit:break"), Yn = /* @__PURE__ */ Symbol("visit:skip");
+function rt(e, t, n) {
+  const r = t(e, n);
+  if (r === yo) return !0;
+  if (r === Yn) return !1;
+  const i = n.depth + 1;
+  switch (e.kind) {
+    case "sequence":
+      for (const o of e.items) if (rt(o, t, {
+        depth: i,
+        parent: e,
+        isKey: !1
+      })) return !0;
+      break;
+    case "mapping":
+      for (const { key: o, value: s } of e.items)
+        if (rt(o, t, {
+          depth: i,
+          parent: e,
+          isKey: !0
+        }) || rt(s, t, {
+          depth: i,
+          parent: e,
+          isKey: !1
+        })) return !0;
+      break;
+  }
+  return !1;
+}
+function mn(e, t) {
+  for (const n of e) if (n.contents && rt(n.contents, t, {
+    depth: 0,
+    parent: null,
+    isKey: !1
+  })) return;
+}
+function ht(e, t) {
+  return (e & 1 << t) !== 0;
+}
+var An = {
+  applyQuoteFlowKeysOption: Co,
+  doubleQuoteForInvisibles: To,
+  doubleQuoteWhitespaceOnly: vo,
+  applyForceQuotesOption: Lo,
+  tryLongOrMultilineAsBlock: Ro,
+  quoteInvalidPlain: xo,
+  fallbackToDoubleQuoted: Oo
+};
+function jn(e) {
+  return e.presenterOptions.quoteStyle === "single" && ht(e.allowedStylesMask, N.SINGLE_QUOTED) ? N.SINGLE_QUOTED : N.DOUBLE_QUOTED;
+}
+function Co(e) {
+  e.presenterOptions.quoteFlowKeys && (!e.isKey || !e.flowOnly || e.style !== N.PLAIN || (e.style = N.DOUBLE_QUOTED));
+}
+function To(e) {
+  e.style === N.PLAIN && /[\t\x7F-\xA0\u2028\u2029\uFEFF\uFFFE\uFFFF]/.test(e.node.value) && (e.style = N.DOUBLE_QUOTED);
+}
+function vo(e) {
+  e.style === N.PLAIN && /^\s+$/.test(e.node.value) && (e.style = N.DOUBLE_QUOTED);
+}
+function Lo(e) {
+  e.presenterOptions.forceQuotes && (e.isKey || e.style !== N.PLAIN || e.node.tag === e.presenterOptions.schema.defaultScalarTag.tagName && (e.style = e.node.value.includes(`
+`) ? N.DOUBLE_QUOTED : jn(e)));
+}
+function Ro(e) {
+  if (e.style !== N.PLAIN || e.isKey) return;
+  const t = e.node.value, n = t.indexOf(`
+`) !== -1;
+  if (!ht(e.allowedStylesMask, N.LITERAL_BLOCK)) {
+    n && (e.style = N.DOUBLE_QUOTED);
+    return;
+  }
+  const r = e.presenterOptions.lineWidth;
+  if (r === -1) {
+    n && (e.style = N.LITERAL_BLOCK);
+    return;
+  }
+  const i = Math.max(Math.min(r, 40), r - e.shiftOfContent);
+  let o = 0, s = !1;
+  for (; o <= t.length; ) {
+    let a = t.length;
+    const c = t.indexOf(`
+`, o);
+    c !== -1 && (a = c);
+    const f = t.slice(o, a);
+    if (f.length > i && f[0] !== " " && / [^ \t]/.test(f) && (s = !0), c === -1) break;
+    o = c + 1;
+  }
+  s ? e.style = N.FOLDED_BLOCK : n && (e.style = N.LITERAL_BLOCK);
+}
+function xo(e) {
+  e.style === N.PLAIN && !ht(e.allowedStylesMask, N.PLAIN) && (e.style = jn(e));
+}
+function Oo(e) {
+  ht(e.allowedStylesMask, e.style) || (e.style = N.DOUBLE_QUOTED);
+}
+function Ve(e, t) {
+  return e | 1 << t;
+}
+var bo = "[\\x09\\x0A\\x0D\\x20-\\x7E\\x85\\xA0-\\uD7FF\\uE000-\\uFFFD\\u{10000}-\\u{10FFFF}]", Io = "[\\n\\r]", No = "\\uFEFF", jt = "[ \\t]", Qn = `(?:(?!(?:${Io}|${No}))${bo})`, gt = `(?:(?!${jt})${Qn})`, Vn = "[\\x09\\x20-\\uD7FF\\uE000-\\uFFFF\\u{10000}-\\u{10FFFF}]", Xn = "[-?:,\\[\\]{}#&*!|>'\"%@`]", $o = "[,\\[\\]{}]", Ft = gt, Pt = `(?:(?!${$o})${gt})`, wo = `(?:(?:(?!${Xn})${gt})|[?:-](?=${Ft}))`, ko = `(?:(?:(?!${Xn})${gt})|[?:-](?=${Pt}))`, zn = `(?:(?:(?![:#])${Ft})|:(?=${Ft}))#*`, Zn = `(?:(?:(?![:#])${Pt})|:(?=${Pt}))#*`, Jn = `(?:${jt}*${zn})*`, er = `(?:${jt}*${Zn})*`, tr = `${wo}#*${Jn}`, nr = `${ko}#*${er}`, Fo = tr, Po = nr, Bo = `\\n+${zn}${Jn}`, Do = `\\n+${Zn}${er}`, Mo = `${tr}(?:${Bo})*`, Ho = `${nr}(?:${Do})*`, Uo = new RegExp(`^(?:${Mo})$`, "u"), Ko = new RegExp(`^(?:${Ho})$`, "u"), Go = new RegExp(`^(?:${Fo})$`, "u"), qo = new RegExp(`^(?:${Po})$`, "u"), Wo = new RegExp(`^(?:${Vn})*$`, "u"), Yo = new RegExp(`^(?:${Vn}|\\n)*$`, "u"), jo = new RegExp(`^(?:${Qn}|\\n)*$`, "u"), Qo = /^(?:---|\.\.\.)(?=$|[ \t\n\r])/, Qt = /^(?:---|\.\.\.)(?=$|[ \t\n\r])/m;
+function Vo(e) {
+  const t = e.node.value;
+  if (t !== "") {
+    if (!(e.isKey ? e.flowOnly ? qo : Go : e.flowOnly ? Ko : Uo).test(t) || e.shiftOfFirstLine === 0 && Qo.test(t)) return !1;
+    if (e.shiftOfContent === 0) {
+      const r = t.indexOf(`
+`);
+      if (r !== -1) {
+        const i = t.slice(r + 1);
+        if (Qt.test(i)) return !1;
+      }
+    }
+  }
+  const n = e.presenterOptions.schema.resolveImplicitScalarTag(t).tag.tagName;
+  return !(!e.node.tagged && n !== e.node.tag || !e.node.tagged && t === "=" && n === e.presenterOptions.schema.defaultScalarTag.tagName);
+}
+function Xo(e) {
+  const t = e.node.value;
+  if (!(e.isKey ? Wo : Yo).test(t) || /[ \t]\n|\n[ \t]/.test(t)) return !1;
+  if (!e.isKey && e.shiftOfContent === 0) {
+    const n = t.indexOf(`
+`);
+    if (n !== -1 && Qt.test(t.slice(n + 1))) return !1;
+  }
+  return !0;
+}
+function zo(e) {
+  if (e.flowOnly || !jo.test(e.node.value)) return !1;
+  const t = e.shiftOfContent - e.shiftOfParent;
+  return !(t < 1 || t > 9 && /^\n* /.test(e.node.value) || e.shiftOfContent === 0 && Qt.test(e.node.value));
+}
+function Zo(e) {
+  let t = Ve(0, N.DOUBLE_QUOTED);
+  Vo(e) && (t = Ve(t, N.PLAIN)), Xo(e) && (t = Ve(t, N.SINGLE_QUOTED)), zo(e) && (t = Ve(Ve(t, N.LITERAL_BLOCK), N.FOLDED_BLOCK)), e.allowedStylesMask = t;
+}
+function Jo(e) {
+  switch (e.style) {
+    case N.PLAIN:
+      return es(e);
+    case N.SINGLE_QUOTED:
+      return ts(e);
+    case N.LITERAL_BLOCK:
+      return ns(e);
+    case N.FOLDED_BLOCK:
+      return rs(e);
+    case N.DOUBLE_QUOTED:
+      return is(e);
+  }
+}
+function es(e) {
+  return rr(e.node.value, e.shiftOfContent);
+}
+function ts(e) {
+  return `'${rr(e.node.value, e.shiftOfContent).replace(/'/g, "''")}'`;
+}
+function ns(e) {
+  const t = e.node.value;
+  return "|" + or(t, e.shiftOfParent, e.shiftOfContent) + sr(ir(t, e.shiftOfContent));
+}
+function rs(e) {
+  const t = e.node.value, n = e.presenterOptions.lineWidth;
+  let r = 1 / 0;
+  return n !== -1 && (r = Math.max(Math.min(n, 40), n - e.shiftOfContent)), ">" + or(t, e.shiftOfParent, e.shiftOfContent) + sr(ir(ss(t, r), e.shiftOfContent));
+}
+function is(e) {
+  return `"${ls(e.node.value)}"`;
+}
+function rr(e, t) {
+  let n = e.indexOf(`
+`);
+  if (n === -1) return e;
+  const r = " ".repeat(t);
+  let i = e.slice(0, n);
+  const o = /(\n+)([^\n]*)/g;
+  o.lastIndex = n;
+  let s;
+  for (; s = o.exec(e); ) {
+    const a = s[1].length, c = s[2];
+    i += `
+`.repeat(a + 1) + r + c;
+  }
+  return i;
+}
+function ir(e, t) {
+  const n = " ".repeat(t);
+  let r = 0, i = "";
+  const o = e.length;
+  for (; r < o; ) {
+    let s;
+    const a = e.indexOf(`
+`, r);
+    a === -1 ? (s = e.slice(r), r = o) : (s = e.slice(r, a + 1), r = a + 1), s.length && s !== `
+` && (i += n), i += s;
+  }
+  return i;
+}
+function os(e) {
+  return /^\n* /.test(e);
+}
+function or(e, t, n) {
+  const r = os(e) ? String(n - t) : "", i = e[e.length - 1] === `
+`;
+  return `${r}${i && (e[e.length - 2] === `
+` || e === `
+`) ? "+" : i ? "" : "-"}
+`;
+}
+function sr(e) {
+  return e[e.length - 1] === `
+` ? e.slice(0, -1) : e;
+}
+function Bt(e) {
+  return e === " " || e === "	";
+}
+function En(e, t) {
+  if (e === "" || Bt(e[0])) return e;
+  const n = / [^ \t]/g;
+  let r, i = 0, o, s = 0, a = 0, c = "";
+  for (; r = n.exec(e); )
+    a = r.index, a - i > t && (o = s > i ? s : a, c += `
+${e.slice(i, o)}`, i = o + 1), s = a;
+  return c += `
+`, e.length - i > t && s > i ? c += `${e.slice(i, s)}
+${e.slice(s + 1)}` : c += e.slice(i), c.slice(1);
+}
+function ss(e, t) {
+  const n = /(\n+)([^\n]*)/g;
+  let r = e.indexOf(`
+`);
+  r === -1 && (r = e.length), n.lastIndex = r;
+  let i = En(e.slice(0, r), t), o = e[0] === `
+` || Bt(e[0]), s, a;
+  for (; a = n.exec(e); ) {
+    const c = a[1], f = a[2];
+    s = f !== "" && Bt(f[0]), i += c + (!o && !s && f !== "" ? `
+` : "") + En(f, t), o = s;
+  }
+  return i;
+}
+var as = /["\\\x00-\x1F\x7F-\xA0\u2028\u2029\uD800-\uDFFF\uFEFF\uFFFE\uFFFF]/gu;
+function cs(e) {
+  switch (e) {
+    case "\0":
+      return "\\0";
+    case "\x07":
+      return "\\a";
+    case "\b":
+      return "\\b";
+    case "	":
+      return "\\t";
+    case `
+`:
+      return "\\n";
+    case "\v":
+      return "\\v";
+    case "\f":
+      return "\\f";
+    case "\r":
+      return "\\r";
+    case "\x1B":
+      return "\\e";
+    case '"':
+      return '\\"';
+    case "\\":
+      return "\\\\";
+    case "…":
+      return "\\N";
+    case " ":
+      return "\\_";
+    case "\u2028":
+      return "\\L";
+    case "\u2029":
+      return "\\P";
+  }
+  const t = e.charCodeAt(0), n = t.toString(16).toUpperCase();
+  return t <= 255 ? `\\x${"0".repeat(2 - n.length)}${n}` : `\\u${"0".repeat(4 - n.length)}${n}`;
+}
+function ls(e) {
+  return e.replace(as, cs);
+}
+var ct = 10, Vt = {
+  indent: 2,
+  seqNoIndent: !1,
+  seqInlineFirst: !0,
+  lineWidth: 80,
+  flowBracketPadding: !1,
+  flowSkipCommaSpace: !1,
+  flowSkipColonSpace: !1,
+  quoteFlowKeys: !1,
+  quoteStyle: "single",
+  forceQuotes: !1,
+  scalarStyleRules: Object.keys(An).map((e) => Reflect.get(An, e)),
+  tagBeforeAnchor: !1
+};
+function us(e) {
+  return e.tagged ? e.tag : kn(e.tag);
+}
+function fs(e) {
+  const t = {
+    ...Vt,
+    ...e
+  };
+  return t.flowSkipColonSpace && (t.quoteFlowKeys = !0), {
+    ...t,
+    defaultScalarTagName: t.schema.defaultScalarTag.tagName,
+    openEnded: !1
+  };
+}
+function Dt(e, t) {
+  return `
+${" ".repeat(e.indent * t)}`;
+}
+function ps(e, t, n, r, i, o) {
+  return {
+    node: t,
+    parent: n,
+    level: r,
+    isKey: i,
+    flowOnly: o,
+    shiftOfParent: r === 0 ? -1 : e.indent * (r - 1),
+    shiftOfContent: e.indent * Math.max(1, r),
+    shiftOfFirstLine: r === 0 ? 0 : e.indent * r,
+    presenterOptions: e,
+    allowedStylesMask: 0,
+    style: t.style
+  };
+}
+function ds(e, t, n) {
+  let r = "";
+  for (let o = 0, s = n.items.length; o < s; o += 1) {
+    const a = Te(e, t, n.items[o], n, {}).text;
+    o > 0 && (r += `,${e.flowSkipCommaSpace ? "" : " "}`), r += a;
+  }
+  const i = e.flowBracketPadding && n.items.length > 0 ? " " : "";
+  return `[${i}${r}${i}]`;
+}
+function Sn(e, t, n, r) {
+  let i = "";
+  for (let o = 0, s = n.items.length; o < s; o += 1) {
+    const a = Te(e, t + 1, n.items[o], n, {
+      block: !0,
+      compact: e.seqInlineFirst,
+      isblockseq: !0
+    }).text;
+    (!r || i !== "") && (i += Dt(e, t)), a === "" || ct === a.charCodeAt(0) ? i += "-" : i += "- ", i += a;
+  }
+  return i;
+}
+function hs(e, t, n) {
+  let r = "";
+  for (const { key: o, value: s } of n.items) {
+    let a = "";
+    r !== "" && (a += `,${e.flowSkipCommaSpace ? "" : " "}`);
+    const c = Te(e, t, o, n, { iskey: !0 }), f = c.text, l = Te(e, t, s, n, {}).text, E = e.flowSkipColonSpace || l === "" ? "" : " ", S = o.kind === "scalar" && c.noBody && (o.tagged || o.anchor !== void 0), T = o.kind === "alias" || S ? " " : "";
+    a += `${f}${T}:${E}${l}`, r += a;
+  }
+  const i = e.flowBracketPadding && r !== "" ? " " : "";
+  return `{${i}${r}${i}}`;
+}
+function gs(e, t, n, r) {
+  let i = "";
+  for (let o = 0, s = n.items.length; o < s; o += 1) {
+    let a = "";
+    (!r || i !== "") && (a += Dt(e, t));
+    const { key: c, value: f } = n.items[o], l = (c.kind === "mapping" || c.kind === "sequence") && c.style === he.BLOCK && c.items.length !== 0 || c.kind === "scalar" && (c.style === N.LITERAL_BLOCK || c.style === N.FOLDED_BLOCK), E = l ? Te(e, t + 1, c, n, {
+      block: !0,
+      compact: !0,
+      isblockseq: !Mt(e, c, t + 1)
+    }) : Te(e, t + 1, c, n, {
+      block: !0,
+      compact: !0,
+      iskey: !0
+    }), S = E.text, T = c.kind === "scalar" && c.value.indexOf(`
+`) !== -1, C = S.length > 1024 && /^[\s\S]{1025}/u.test(S), O = l || T || C;
+    O && (S && ct === S.charCodeAt(0) ? a += "?" : a += "? "), a += S, O && (a += Dt(e, t));
+    const w = Te(e, t + 1, f, n, {
+      block: !0,
+      compact: O,
+      isblockseq: O && !Mt(e, f, t + 1)
+    }).text, b = c.kind === "scalar" && E.noBody && (c.tagged || c.anchor !== void 0), $ = !O && (c.kind === "alias" || b) ? " " : "";
+    w === "" || ct === w.charCodeAt(0) ? a += `${$}:` : a += `${$}: `, a += w, i += a;
+  }
+  return i;
+}
+function Mt(e, t, n) {
+  return t.kind === "alias" ? !0 : t.tagged || t.anchor !== void 0 || e.indent < 2 && n > 0;
+}
+function Te(e, t, n, r, i) {
+  if (n.kind === "alias")
+    return e.openEnded = !1, {
+      text: `*${n.anchor}`,
+      noBody: !1
+    };
+  const { block: o = !1, iskey: s = !1, isblockseq: a = !1 } = i;
+  let c = i.compact ?? !1;
+  const f = n.anchor !== void 0;
+  Mt(e, n, t) && (c = !1);
+  let l, E = n.tagged;
+  const S = o && (n.kind === "mapping" || n.kind === "sequence") && n.style === he.BLOCK && n.items.length !== 0;
+  if (n.kind === "mapping") S ? l = gs(e, t, n, c) : l = hs(e, t, n);
+  else if (n.kind === "sequence") S ? e.seqNoIndent && !a && t > 0 ? l = Sn(e, t - 1, n, c) : l = Sn(e, t, n, c) : l = ds(e, t, n);
+  else {
+    const O = ps(e, n, r, t, s, !o);
+    Zo(O);
+    for (const w of e.scalarStyleRules) w(O);
+    l = Jo(O), e.openEnded = (O.style === N.LITERAL_BLOCK || O.style === N.FOLDED_BLOCK) && (n.value === `
+` || n.value.endsWith(`
+
+`)), E = n.tagged || l === "" && O.flowOnly && r?.kind === "sequence" && !f || O.style !== N.PLAIN && n.tag !== e.defaultScalarTagName;
+  }
+  (n.kind === "mapping" || n.kind === "sequence") && !S && (e.openEnded = !1), S && c && t > 0 && e.indent > 2 && (l = `${" ".repeat(e.indent - 2)}${l}`);
+  const T = l === "";
+  let C = l;
+  if (E || f) {
+    const O = [], w = E ? us(n) : null, b = f ? `&${n.anchor}` : null;
+    e.tagBeforeAnchor ? (w !== null && O.push(w), b !== null && O.push(b)) : (b !== null && O.push(b), w !== null && O.push(w));
+    const $ = l === "" || l.charCodeAt(0) === ct ? "" : " ";
+    C = `${O.join(" ")}${$}${l}`;
+  }
+  return {
+    text: C,
+    noBody: T
+  };
+}
+function ms(e) {
+  return (e.kind === "sequence" || e.kind === "mapping") && e.style === he.BLOCK && e.items.length !== 0 && !e.tagged && e.anchor === void 0;
+}
+function As(e) {
+  let t = "";
+  for (const n of e.directives) {
+    if (n.kind === "yaml") {
+      t += `%YAML ${n.version}
+`;
+      continue;
+    }
+    const { handle: r, prefix: i } = n;
+    t += `%TAG ${r} ${i}
+`;
+  }
+  return t;
+}
+function Es(e, t) {
+  const n = fs(t);
+  let r = "", i = !1;
+  for (let o = 0; o < e.length; o += 1) {
+    const s = e[o];
+    n.openEnded = !1;
+    const a = As(s), c = a !== "", f = s.explicitStart || c || o > 0 && !i;
+    if (r += a, s.contents === null)
+      f && (r += `---
+`);
+    else if (f) {
+      const l = Te(n, 0, s.contents, null, {
+        block: !0,
+        compact: !0
+      }).text, E = l === "" ? "" : c || ms(s.contents) ? `
+` : " ";
+      r += `---${E}${l}
+`;
+    } else r += Te(n, 0, s.contents, null, {
+      block: !0,
+      compact: !0
+    }).text + `
+`;
+    i = s.explicitEnd || n.openEnded, i && (r += `...
+`);
+  }
+  return r;
+}
+var Ss = {
+  ...Vt,
+  schema: xi,
+  skipInvalid: !1,
+  noRefs: !1,
+  flowLevel: -1,
+  sortKeys: !1,
+  transform: () => {
+  }
+};
+function _s(e, t) {
+  const n = String(e), r = String(t);
+  return n < r ? -1 : n > r ? 1 : 0;
+}
+function ys(e, t = {}) {
+  const n = {
+    ...Ss,
+    ...t
+  }, r = _o(e, n.schema, {
+    noRefs: n.noRefs,
+    skipInvalid: n.skipInvalid
+  });
+  if (n.flowLevel >= 0 && mn(r, (i, o) => {
+    if (!(o.depth < n.flowLevel))
+      return (i.kind === "sequence" || i.kind === "mapping") && (i.style = he.FLOW), Yn;
+  }), n.sortKeys) {
+    const i = n.sortKeys === !0 ? _s : n.sortKeys;
+    mn(r, (o) => {
+      o.kind === "mapping" && o.items.sort((s, a) => i(s.key.kind === "scalar" ? s.key.value : "", a.key.kind === "scalar" ? a.key.value : ""));
+    });
+  }
+  return n.transform(r), Es(r, {
+    ...$t(n, Object.keys(Vt)),
+    schema: n.schema
+  });
+}
+const Cs = bn.withTags(Tn, vn, Ln, Rn, xn), ar = (e, t) => {
+  const n = Ao(e, { schema: Cs, ...t });
+  if (n.length === 0)
+    return e.trim() === "" ? void 0 : null;
+  if (n.length > 1)
+    throw new we("expected a single document in the stream, but found more");
+  return n[0];
+}, Hs = (e, t) => ys(e, t), Ts = /\((\d+):(\d+)\)$/;
+class mt extends Error {
+  originalError;
+  source;
+  col;
+  line;
+  constructor(t, n) {
+    super(t.message.split(`
+`)[0]), this.originalError = t, this.source = n, Object.setPrototypeOf(this, mt.prototype);
+    const [, r, i] = this.message.match(Ts) || [];
+    this.line = parseInt(r, 10), this.col = parseInt(i, 10);
+  }
+}
+const vs = [".graphql", ".gql"];
+function cr(e) {
+  const t = e.toLowerCase();
+  return vs.some((n) => t.endsWith(n));
+}
+function Ls(e, t) {
+  return e.hasOwnProperty(t) ? e[t] : void 0;
+}
+function Rs(e) {
+  return e.endsWith(".yaml") || e.endsWith(".yml") || e.endsWith(".json");
+}
+function bt(e, t) {
+  return e + "::" + t;
+}
+function xs() {
+  return new Promise((e) => {
+    setTimeout(e);
+  });
+}
+class Ht {
+  absoluteRef;
+  body;
+  mimeType;
+  constructor(t, n, r) {
+    this.absoluteRef = t, this.body = n, this.mimeType = r;
+  }
+  #e;
+  #t;
+  // pass safeLoad as argument to separate it from browser bundle
+  getAst(t) {
+    return this.#e === void 0 && (this.#e = t(this.body, { filename: this.absoluteRef }) ?? void 0, this.#e && this.#e.kind === 0 && // KIND.scalar = 0
+    this.#e.value === "" && this.#e.startPosition !== 1 && (this.#e.startPosition = 1, this.#e.endPosition = 1)), this.#e;
+  }
+  getLines() {
+    return this.#t === void 0 && (this.#t = this.body.split(/\r\n|[\n\r]/g)), this.#t;
+  }
+}
+class Xt extends Error {
+  originalError;
+  constructor(t) {
+    super(t.message), this.originalError = t, Object.setPrototypeOf(this, Xt.prototype);
+  }
+}
+function Us(e, t) {
+  const n = new Ht(t, e);
+  if (cr(t))
+    return { source: n, parsed: e };
+  try {
+    return {
+      source: n,
+      parsed: ar(e, { filename: t })
+    };
+  } catch (r) {
+    throw new mt(r, n);
+  }
+}
+class Ks {
+  config;
+  cache = /* @__PURE__ */ new Map();
+  constructor(t = { http: { headers: [] } }) {
+    this.config = t;
+  }
+  getFiles() {
+    return new Set(Array.from(this.cache.keys()));
+  }
+  resolveExternalRef(t, n) {
+    return $e(n) ? n : t && $e(t) ? new URL(n, t).href : ze.resolve(t ? ze.dirname(t) : process.cwd(), n);
+  }
+  async loadExternalRef(t) {
+    try {
+      if ($e(t)) {
+        const { body: n, mimeType: r } = await _r(t, this.config.http);
+        return new Ht(t, n, r);
+      } else {
+        if ((void 0)(t).isDirectory())
+          throw new Error(`Expected a file but received a folder at ${t}.`);
+        const n = await (void 0).readFile(t, "utf-8");
+        return new Ht(t, n.replace(/\r\n/g, `
+`));
+      }
+    } catch (n) {
+      throw n.message = n.message.replace(", lstat", ""), new Xt(n);
+    }
+  }
+  parseDocument(t, n = !1) {
+    if (cr(t.absoluteRef))
+      return { source: t, parsed: t.body };
+    const r = $e(t.absoluteRef) ? new URL(t.absoluteRef).pathname : t.absoluteRef;
+    if (!Rs(r) && !t.mimeType?.match(/(json|yaml|openapi)/) && !n)
+      return { source: t, parsed: t.body };
+    try {
+      return {
+        source: t,
+        parsed: ar(t.body, { filename: t.absoluteRef })
+      };
+    } catch (i) {
+      throw new mt(i, t);
+    }
+  }
+  async resolveDocument(t, n, r = !1) {
+    const i = this.resolveExternalRef(t, n), o = this.cache.get(i);
+    if (o)
+      return o;
+    const s = this.loadExternalRef(i).then((a) => this.parseDocument(a, r));
+    return this.cache.set(i, s), s;
+  }
+}
+function _n(e, t) {
+  return {
+    prev: e,
+    node: t
+  };
+}
+function Os(e, t) {
+  for (; e; ) {
+    if (e.node === t)
+      return !0;
+    e = e.prev;
+  }
+  return !1;
+}
+const Je = { name: "unknown", properties: {} }, bs = { name: "scalar", properties: {} };
+async function Gs(e) {
+  const { rootDocument: t, externalRefResolver: n, rootType: r } = e, i = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set(), s = [];
+  c(t.parsed, t, "#/", r);
+  let a;
+  do
+    a = await Promise.all(s);
+  while (s.length !== a.length);
+  return i;
+  function c(f, l, E, S) {
+    const T = l.source.absoluteRef, C = /* @__PURE__ */ new Map();
+    O(f, S, T + E);
+    function O(b, $, A) {
+      if (!Re(b) && !Array.isArray(b))
+        return;
+      const L = `${$.name}::${A}`;
+      if (o.has(L))
+        return;
+      if (o.add(L), Array.isArray(b)) {
+        const v = $.items;
+        if (v === void 0 && $ !== Je && $ !== et)
+          return;
+        const m = typeof v == "function";
+        for (let g = 0; g < b.length; g++) {
+          let R = m ? v(b[g], Le(A, g)) : v;
+          if (R === void 0 && $ !== Je && $ !== et)
+            continue;
+          const j = R?.directResolveAs ? { $ref: b[g] } : b[g];
+          R = R?.directResolveAs || R, O(j, tt(R) ? R : Je, Le(A, g));
+        }
+        return;
+      }
+      const [u, I] = Object.entries(b).find(([v]) => v === "$anchor") || [];
+      I && C.set(`#${I}`, b);
+      for (const v of Object.keys(b)) {
+        let m = b[v], g = Ls($.properties, v);
+        const R = $.extensionsPrefix !== void 0 && v.startsWith($.extensionsPrefix);
+        g === void 0 && !R && (g = $.additionalProperties), typeof g == "function" && (g = g(m, v)), R && g === void 0 && (g = et), g === void 0 && (g = Je), !tt(g) && g?.directResolveAs && (g = g.directResolveAs, m = { $ref: m }), g && g.name === void 0 && g.resolvable !== !1 && (g = bs), !(!tt(g) || !(Re(m) || Array.isArray(m))) && O(m, g, Le(A, Be(v)));
+      }
+      if (nt(b)) {
+        const v = w(l, b, {
+          prev: null,
+          node: b
+        }).then((m) => {
+          if (m.resolved) {
+            c(m.node, m.document, m.nodePointer, $);
+            for (const g of m.chain ?? [])
+              c(g.node, g.document, g.location.pointer, $);
+          }
+        });
+        s.push(v);
+      }
+      if (Tr(b)) {
+        const v = w(l, { $ref: b.externalValue }, {
+          prev: null,
+          node: b
+        }).then((m) => {
+          m.resolved && c(m.node, m.document, m.nodePointer, $);
+        });
+        s.push(v);
+      }
+    }
+    async function w(b, $, A) {
+      if (Os(A.prev, $))
+        throw new Error("Self-referencing circular pointer");
+      if (xr($.$ref)) {
+        await xs();
+        const F = {
+          resolved: !0,
+          isRemote: !1,
+          node: C.get($.$ref),
+          document: b,
+          nodePointer: $.$ref
+        }, K = bt(b.source.absoluteRef, $.$ref);
+        return i.set(K, F), F;
+      }
+      const { uri: L, pointer: u } = Lr($.$ref), I = L !== null && n.resolveExternalRef(b.source.absoluteRef, L) !== b.source.absoluteRef;
+      let v;
+      try {
+        v = I ? await n.resolveDocument(b.source.absoluteRef, L) : b;
+      } catch (F) {
+        const K = {
+          resolved: !1,
+          isRemote: I,
+          document: void 0,
+          error: F
+        }, pe = bt(b.source.absoluteRef, $.$ref);
+        return i.set(pe, K), K;
+      }
+      let m = {
+        resolved: !0,
+        document: v,
+        isRemote: I,
+        node: b.parsed,
+        nodePointer: "#/"
+      }, g = v.parsed;
+      const R = u;
+      for (const F of R)
+        if (Re(g) && g[F] !== void 0)
+          g = g[F], m.nodePointer = Le(m.nodePointer, Be(F));
+        else if (Array.isArray(g) && g[+F] !== void 0)
+          g = g[+F], m.nodePointer = Le(m.nodePointer, Be(F));
+        else if (nt(g))
+          if (m = await w(v, g, _n(A, g)), m.chain = void 0, v = m.document || v, Re(m.node))
+            g = m.node[F], m.nodePointer = Le(m.nodePointer, Be(F));
+          else if (Array.isArray(m.node))
+            g = m.node[+F], m.nodePointer = Le(m.nodePointer, Be(F));
+          else {
+            g = void 0;
+            break;
+          }
+        else {
+          g = void 0;
+          break;
+        }
+      m.node = g, m.document = v;
+      const j = bt(b.source.absoluteRef, $.$ref);
+      if (m.document && nt(g)) {
+        const F = Cr(g) ? {
+          node: g,
+          document: m.document,
+          location: new it(m.document.source, m.nodePointer)
+        } : void 0;
+        m = await w(m.document, g, _n(A, g)), F && m.resolved && (m = { ...m, chain: [F, ...m.chain ?? []] });
+      }
+      return i.set(j, m), { ...m };
+    }
+  }
+}
+export {
+  bt as A,
+  Ks as B,
+  Tr as C,
+  ks as D,
+  Fs as E,
+  Rr as F,
+  Sr as G,
+  it as L,
+  Xt as R,
+  Ht as S,
+  mt as Y,
+  Gs as a,
+  $e as b,
+  Er as c,
+  cr as d,
+  Be as e,
+  Ds as f,
+  Ps as g,
+  Rs as h,
+  nt as i,
+  fr as j,
+  Bs as k,
+  Ns as l,
+  Us as m,
+  ws as n,
+  $s as o,
+  ar as p,
+  Cr as q,
+  _r as r,
+  Hs as s,
+  Le as t,
+  vr as u,
+  Lr as v,
+  Ls as w,
+  et as x,
+  tt as y,
+  Ms as z
+};