import {
  a as s
} from "./chunk-IO47FP3U.js";

// ../node_modules/tinyrainbow/dist/chunk-BVHSVHOK.js
var ir = {
  reset: [0, 0],
  bold: [1, 22, "\x1B[22m\x1B[1m"],
  dim: [2, 22, "\x1B[22m\x1B[2m"],
  italic: [3, 23],
  underline: [4, 24],
  inverse: [7, 27],
  hidden: [8, 28],
  strikethrough: [9, 29],
  black: [30, 39],
  red: [31, 39],
  green: [32, 39],
  yellow: [33, 39],
  blue: [34, 39],
  magenta: [35, 39],
  cyan: [36, 39],
  white: [37, 39],
  gray: [90, 39],
  bgBlack: [40, 49],
  bgRed: [41, 49],
  bgGreen: [42, 49],
  bgYellow: [43, 49],
  bgBlue: [44, 49],
  bgMagenta: [45, 49],
  bgCyan: [46, 49],
  bgWhite: [47, 49],
  blackBright: [90, 39],
  redBright: [91, 39],
  greenBright: [92, 39],
  yellowBright: [93, 39],
  blueBright: [94, 39],
  magentaBright: [95, 39],
  cyanBright: [96, 39],
  whiteBright: [97, 39],
  bgBlackBright: [100, 49],
  bgRedBright: [101, 49],
  bgGreenBright: [102, 49],
  bgYellowBright: [103, 49],
  bgBlueBright: [104, 49],
  bgMagentaBright: [105, 49],
  bgCyanBright: [106, 49],
  bgWhiteBright: [107, 49]
}, Rt = Object.entries(ir);
function Oe(e) {
  return String(e);
}
s(Oe, "a");
Oe.open = "";
Oe.close = "";
var ki = Rt.reduce(
  (e, [t]) => (e[t] = Oe, e),
  { isColorSupported: !1 }
);
function Lt(e = !1) {
  let t = typeof process < "u" ? process : void 0, n = t?.env || {}, r = t?.argv || [];
  return !("NO_COLOR" in n || r.includes("--no-color")) && ("FORCE_COLOR" in n || r.includes("--color") || t?.platform === "win32" || e && n.TERM !== "dumb" || "CI" in n) || typeof window < "u" && !!window.chrome;
}
s(Lt, "C");
function It(e = !1) {
  let t = Lt(e), n = /* @__PURE__ */ s((c, a, l, m) => {
    let g = "", y = 0;
    do
      g += c.substring(y, m) + l, y = m + a.length, m = c.indexOf(a, y);
    while (~m);
    return g + c.substring(y);
  }, "i"), r = /* @__PURE__ */ s((c, a, l = c) => {
    let m = /* @__PURE__ */ s((g) => {
      let y = String(g), T = y.indexOf(a, c.length);
      return ~T ? c + n(y, a, l, T) + a : c + y + a;
    }, "o");
    return m.open = c, m.close = a, m;
  }, "g"), o = {
    isColorSupported: t
  }, i = /* @__PURE__ */ s((c) => `\x1B[${c}m`, "d");
  for (let [c, a] of Rt)
    o[c] = t ? r(
      i(a[0]),
      i(a[1]),
      a[2]
    ) : Oe;
  return o;
}
s(It, "p");

// ../node_modules/tinyrainbow/dist/browser.js
var ee = It();

// ../node_modules/@vitest/pretty-format/dist/index.js
function Ht(e, t) {
  return t.forEach(function(n) {
    n && typeof n != "string" && !Array.isArray(n) && Object.keys(n).forEach(function(r) {
      if (r !== "default" && !(r in e)) {
        var o = Object.getOwnPropertyDescriptor(n, r);
        Object.defineProperty(e, r, o.get ? o : {
          enumerable: !0,
          get: /* @__PURE__ */ s(function() {
            return n[r];
          }, "get")
        });
      }
    });
  }), Object.freeze(e);
}
s(Ht, "_mergeNamespaces");
function cr(e, t) {
  let n = Object.keys(e), r = t === null ? n : n.sort(t);
  if (Object.getOwnPropertySymbols)
    for (let o of Object.getOwnPropertySymbols(e))
      Object.getOwnPropertyDescriptor(e, o).enumerable && r.push(o);
  return r;
}
s(cr, "getKeysOfEnumerableProperties");
function Se(e, t, n, r, o, i, c = ": ") {
  let a = "", l = 0, m = e.next();
  if (!m.done) {
    a += t.spacingOuter;
    let g = n + t.indent;
    for (; !m.done; ) {
      if (a += g, l++ === t.maxWidth) {
        a += "\u2026";
        break;
      }
      let y = i(m.value[0], t, g, r, o), T = i(m.value[1], t, g, r, o);
      a += y + c + T, m = e.next(), m.done ? t.min || (a += ",") : a += `,${t.spacingInner}`;
    }
    a += t.spacingOuter + n;
  }
  return a;
}
s(Se, "printIteratorEntries");
function Ze(e, t, n, r, o, i) {
  let c = "", a = 0, l = e.next();
  if (!l.done) {
    c += t.spacingOuter;
    let m = n + t.indent;
    for (; !l.done; ) {
      if (c += m, a++ === t.maxWidth) {
        c += "\u2026";
        break;
      }
      c += i(l.value, t, m, r, o), l = e.next(), l.done ? t.min || (c += ",") : c += `,${t.spacingInner}`;
    }
    c += t.spacingOuter + n;
  }
  return c;
}
s(Ze, "printIteratorValues");
function Re(e, t, n, r, o, i) {
  let c = "";
  e = e instanceof ArrayBuffer ? new DataView(e) : e;
  let a = /* @__PURE__ */ s((m) => m instanceof DataView, "isDataView"), l = a(e) ? e.byteLength : e.length;
  if (l > 0) {
    c += t.spacingOuter;
    let m = n + t.indent;
    for (let g = 0; g < l; g++) {
      if (c += m, g === t.maxWidth) {
        c += "\u2026";
        break;
      }
      (a(e) || g in e) && (c += i(a(e) ? e.getInt8(g) : e[g], t, m, r, o)), g < l - 1 ? c += `,${t.spacingInner}` : t.min || (c += ",");
    }
    c += t.spacingOuter + n;
  }
  return c;
}
s(Re, "printListItems");
function Qe(e, t, n, r, o, i) {
  let c = "", a = cr(e, t.compareKeys);
  if (a.length > 0) {
    c += t.spacingOuter;
    let l = n + t.indent;
    for (let m = 0; m < a.length; m++) {
      let g = a[m], y = i(g, t, l, r, o), T = i(e[g], t, l, r, o);
      c += `${l + y}: ${T}`, m < a.length - 1 ? c += `,${t.spacingInner}` : t.min || (c += ",");
    }
    c += t.spacingOuter + n;
  }
  return c;
}
s(Qe, "printObjectProperties");
var sr = typeof Symbol == "function" && Symbol.for ? Symbol.for("jest.asymmetricMatcher") : 1267621, Ae = " ", ur = /* @__PURE__ */ s((e, t, n, r, o, i) => {
  let c = e.toString();
  if (c === "ArrayContaining" || c === "ArrayNotContaining")
    return ++r > t.maxDepth ? `[${c}]` : `${c + Ae}[${Re(e.sample, t, n, r, o, i)}]`;
  if (c === "ObjectContaining" || c === "ObjectNotContaining")
    return ++r > t.maxDepth ? `[${c}]` : `${c + Ae}{${Qe(e.sample, t, n, r, o, i)}}`;
  if (c === "StringMatching" || c === "StringNotMatching" || c === "StringContaining" || c === "StringNotContaining")
    return c + Ae + i(e.sample, t, n, r, o);
  if (typeof e.toAsymmetricMatcher != "function")
    throw new TypeError(`Asymmetric matcher ${e.constructor.name} does not implement toAsymmetricMatcher()`);
  return e.toAsymmetricMatcher();
}, "serialize$5"), lr = /* @__PURE__ */ s((e) => e && e.$$typeof === sr, "test$5"), ar = {
  serialize: ur,
  test: lr
}, fr = " ", Kt = /* @__PURE__ */ new Set(["DOMStringMap", "NamedNodeMap"]), mr = /^(?:HTML\w*Collection|NodeList)$/;
function pr(e) {
  return Kt.has(e) || mr.test(e);
}
s(pr, "testName");
var gr = /* @__PURE__ */ s((e) => e && e.constructor && !!e.constructor.name && pr(e.constructor.name), "test$4");
function hr(e) {
  return e.constructor.name === "NamedNodeMap";
}
s(hr, "isNamedNodeMap");
var yr = /* @__PURE__ */ s((e, t, n, r, o, i) => {
  let c = e.constructor.name;
  return ++r > t.maxDepth ? `[${c}]` : (t.min ? "" : c + fr) + (Kt.has(c) ? `{${Qe(hr(e) ? [...e].reduce((a, l) => (a[l.name] = l.value, a), {}) : { ...e }, t, n, r, o, i)}}` : `[${Re([...e], t, n, r, o, i)}]`);
}, "serialize$4"), br = {
  serialize: yr,
  test: gr
};
function Xt(e) {
  return e.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
}
s(Xt, "escapeHTML");
function ve(e, t, n, r, o, i, c) {
  let a = r + n.indent, l = n.colors;
  return e.map((m) => {
    let g = t[m], y = c(g, n, a, o, i);
    return typeof g != "string" && (y.includes(`
`) && (y = n.spacingOuter + a + y + n.spacingOuter + r), y = `{${y}}`), `${n.spacingInner + r + l.prop.open + m + l.prop.close}=${l.value.open}${y}${l.value.close}`;
  }).join("");
}
s(ve, "printProps");
function et(e, t, n, r, o, i) {
  return e.map((c) => t.spacingOuter + n + (typeof c == "string" ? Zt(c, t) : i(c, t, n, r, o))).join("");
}
s(et, "printChildren");
function Zt(e, t) {
  let n = t.colors.content;
  return n.open + Xt(e) + n.close;
}
s(Zt, "printText");
function Er(e, t) {
  let n = t.colors.comment;
  return `${n.open}<!--${Xt(e)}-->${n.close}`;
}
s(Er, "printComment");
function tt(e, t, n, r, o) {
  let i = r.colors.tag;
  return `${i.open}<${e}${t && i.close + t + r.spacingOuter + o + i.open}${n ? `>${i.close}${n}${r.spacingOuter}${o}${i.open}</${e}` : `${t && !r.min ? "" : " "}/`}>${i.close}`;
}
s(tt, "printElement");
function nt(e, t) {
  let n = t.colors.tag;
  return `${n.open}<${e}${n.close} \u2026${n.open} />${n.close}`;
}
s(nt, "printElementAsLeaf");
var dr = 1, Qt = 3, vt = 8, en = 11, Sr = /^(?:(?:HTML|SVG)\w*)?Element$/;
function $r(e) {
  try {
    return typeof e.hasAttribute == "function" && e.hasAttribute("is");
  } catch {
    return !1;
  }
}
s($r, "testHasAttribute");
function _r(e) {
  let t = e.constructor.name, { nodeType: n, tagName: r } = e, o = typeof r == "string" && r.includes("-") || $r(e);
  return n === dr && (Sr.test(t) || o) || n === Qt && t === "Text" || n === vt && t === "Comment" || n === en && t === "DocumentFragment";
}
s(_r, "testNode");
var Tr = /* @__PURE__ */ s((e) => {
  var t;
  return (e == null || (t = e.constructor) === null || t === void 0 ? void 0 : t.name) && _r(e);
}, "test$3");
function Cr(e) {
  return e.nodeType === Qt;
}
s(Cr, "nodeIsText");
function wr(e) {
  return e.nodeType === vt;
}
s(wr, "nodeIsComment");
function Ke(e) {
  return e.nodeType === en;
}
s(Ke, "nodeIsFragment");
var Or = /* @__PURE__ */ s((e, t, n, r, o, i) => {
  if (Cr(e))
    return Zt(e.data, t);
  if (wr(e))
    return Er(e.data, t);
  let c = Ke(e) ? "DocumentFragment" : e.tagName.toLowerCase();
  return ++r > t.maxDepth ? nt(c, t) : tt(c, ve(Ke(e) ? [] : Array.from(e.attributes, (a) => a.name).sort(), Ke(e) ? {} : [...e.attributes].reduce((a, l) => (a[l.name] = l.value, a), {}), t, n + t.indent, r, o, i), et(Array.prototype.slice.call(e.childNodes || e.children), t, n + t.indent, r, o, i), t, n);
}, "serialize$3"), Ar = {
  serialize: Or,
  test: Tr
}, Pr = "@@__IMMUTABLE_ITERABLE__@@", Nr = "@@__IMMUTABLE_LIST__@@", Mr = "@@__IMMUTABLE_KEYED__@@", Rr = "@@__IMMUTABLE_MAP__@@", Ft = "@@__IMMUTABLE_ORDERED__@@", Lr = "@@__IMMUTABLE_RECORD__@@", Ir = "@@__IMMUTABLE_SEQ__@@", Fr = "@@__IMMUTABLE_SET__@@", xr = "@@__IMMUTABLE_STACK__@@", ye = /* @__PURE__ */ s((e) => `Immutable.${e}`, "getImmutableName"), Ie = /* @__PURE__ */ s((e) => `[${e}]`, "printAsLeaf"), de = " ", xt = "\u2026";
function Dr(e, t, n, r, o, i, c) {
  return ++r > t.maxDepth ? Ie(ye(c)) : `${ye(c) + de}{${Se(e.entries(), t, n, r, o, i)}}`;
}
s(Dr, "printImmutableEntries");
function jr(e) {
  let t = 0;
  return { next() {
    if (t < e._keys.length) {
      let n = e._keys[t++];
      return {
        done: !1,
        value: [n, e.get(n)]
      };
    }
    return {
      done: !0,
      value: void 0
    };
  } };
}
s(jr, "getRecordEntries");
function Br(e, t, n, r, o, i) {
  let c = ye(e._name || "Record");
  return ++r > t.maxDepth ? Ie(c) : `${c + de}{${Se(jr(e), t, n, r, o, i)}}`;
}
s(Br, "printImmutableRecord");
function zr(e, t, n, r, o, i) {
  let c = ye("Seq");
  return ++r > t.maxDepth ? Ie(c) : e[Mr] ? `${c + de}{${e._iter || e._object ? Se(e.entries(), t, n, r, o, i) : xt}}` : `${c + de}[${e._iter || e._array || e._collection || e._iterable ? Ze(e.values(), t, n, r, o, i) : xt}]`;
}
s(zr, "printImmutableSeq");
function Xe(e, t, n, r, o, i, c) {
  return ++r > t.maxDepth ? Ie(ye(c)) : `${ye(c) + de}[${Ze(e.values(), t, n, r, o, i)}]`;
}
s(Xe, "printImmutableValues");
var kr = /* @__PURE__ */ s((e, t, n, r, o, i) => e[Rr] ? Dr(e, t, n, r, o, i, e[Ft] ? "OrderedMap" : "Map") : e[Nr] ? Xe(e, t, n, r, o, i, "List") : e[Fr] ? Xe(e, t, n, r, o, i, e[Ft] ? "OrderedSet" : "Set") : e[xr] ? Xe(e, t, n, r, o, i, "Stack") : e[Ir] ? zr(e, t, n, r, o, i) : Br(e, t, n, r, o, i), "serialize$2"), Yr = /* @__PURE__ */ s((e) => e && (e[Pr] === !0 || e[Lr] === !0), "test$2"), Ur = {
  serialize: kr,
  test: Yr
};
function tn(e) {
  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
}
s(tn, "getDefaultExportFromCjs");
var Pe = { exports: {} }, N = {};
var Dt;
function Wr() {
  if (Dt) return N;
  Dt = 1;
  var e = Symbol.for("react.transitional.element"), t = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), r = Symbol.for("react.strict_mode"), o = Symbol.for("react.profiler"), i = Symbol.for("react.consumer"), c = Symbol.for("react.context"), a = Symbol.for("react.forward_ref"), l = Symbol.for("react.suspense"), m = Symbol.for("react.suspense_list"), g = Symbol.for("react.memo"), y = Symbol.for("react.lazy"), T = Symbol.for("react.view_transition"), h = Symbol.for("react.client.reference");
  function p(u) {
    if (typeof u == "object" && u !== null) {
      var f = u.$$typeof;
      switch (f) {
        case e:
          switch (u = u.type, u) {
            case n:
            case o:
            case r:
            case l:
            case m:
            case T:
              return u;
            default:
              switch (u = u && u.$$typeof, u) {
                case c:
                case a:
                case y:
                case g:
                  return u;
                case i:
                  return u;
                default:
                  return f;
              }
          }
        case t:
          return f;
      }
    }
  }
  return s(p, "typeOf"), N.ContextConsumer = i, N.ContextProvider = c, N.Element = e, N.ForwardRef = a, N.Fragment = n, N.Lazy = y, N.Memo = g, N.Portal = t, N.Profiler = o, N.StrictMode = r, N.Suspense = l, N.SuspenseList = m, N.isContextConsumer = function(u) {
    return p(u) === i;
  }, N.isContextProvider = function(u) {
    return p(u) === c;
  }, N.isElement = function(u) {
    return typeof u == "object" && u !== null && u.$$typeof === e;
  }, N.isForwardRef = function(u) {
    return p(u) === a;
  }, N.isFragment = function(u) {
    return p(u) === n;
  }, N.isLazy = function(u) {
    return p(u) === y;
  }, N.isMemo = function(u) {
    return p(u) === g;
  }, N.isPortal = function(u) {
    return p(u) === t;
  }, N.isProfiler = function(u) {
    return p(u) === o;
  }, N.isStrictMode = function(u) {
    return p(u) === r;
  }, N.isSuspense = function(u) {
    return p(u) === l;
  }, N.isSuspenseList = function(u) {
    return p(u) === m;
  }, N.isValidElementType = function(u) {
    return typeof u == "string" || typeof u == "function" || u === n || u === o || u === r || u === l || u === m || typeof u == "object" && u !== null && (u.$$typeof === y || u.$$typeof === g || u.$$typeof === c || u.$$typeof === i || u.$$typeof === a || u.$$typeof === h || u.getModuleId !== void 0);
  }, N.typeOf = p, N;
}
s(Wr, "requireReactIs_production");
var M = {};
var jt;
function qr() {
  return jt || (jt = 1, process.env.NODE_ENV !== "production" && function() {
    function e(u) {
      if (typeof u == "object" && u !== null) {
        var f = u.$$typeof;
        switch (f) {
          case t:
            switch (u = u.type, u) {
              case r:
              case i:
              case o:
              case m:
              case g:
              case h:
                return u;
              default:
                switch (u = u && u.$$typeof, u) {
                  case a:
                  case l:
                  case T:
                  case y:
                    return u;
                  case c:
                    return u;
                  default:
                    return f;
                }
            }
          case n:
            return f;
        }
      }
    }
    s(e, "typeOf");
    var t = Symbol.for("react.transitional.element"), n = Symbol.for("react.portal"), r = Symbol.for("react.fragment"), o = Symbol.for("react.strict_mode"), i = Symbol.for("react.profiler"), c = Symbol.for("react.consumer"), a = Symbol.for("react.context"), l = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), g = Symbol.for("react.suspense_list"), y = Symbol.for("react.memo"), T = Symbol.for("react.lazy"), h = Symbol.for("react.view_transition"), p = Symbol.for("react.client.reference");
    M.ContextConsumer = c, M.ContextProvider = a, M.Element = t, M.ForwardRef = l, M.Fragment = r, M.Lazy = T, M.Memo = y, M.Portal = n, M.Profiler = i, M.StrictMode = o, M.Suspense = m, M.SuspenseList = g, M.isContextConsumer = function(u) {
      return e(u) === c;
    }, M.isContextProvider = function(u) {
      return e(u) === a;
    }, M.isElement = function(u) {
      return typeof u == "object" && u !== null && u.$$typeof === t;
    }, M.isForwardRef = function(u) {
      return e(u) === l;
    }, M.isFragment = function(u) {
      return e(u) === r;
    }, M.isLazy = function(u) {
      return e(u) === T;
    }, M.isMemo = function(u) {
      return e(u) === y;
    }, M.isPortal = function(u) {
      return e(u) === n;
    }, M.isProfiler = function(u) {
      return e(u) === i;
    }, M.isStrictMode = function(u) {
      return e(u) === o;
    }, M.isSuspense = function(u) {
      return e(u) === m;
    }, M.isSuspenseList = function(u) {
      return e(u) === g;
    }, M.isValidElementType = function(u) {
      return typeof u == "string" || typeof u == "function" || u === r || u === i || u === o || u === m || u === g || typeof u == "object" && u !== null && (u.$$typeof === T || u.$$typeof === y || u.$$typeof === a || u.$$typeof === c || u.$$typeof === l || u.$$typeof === p || u.getModuleId !== void 0);
    }, M.typeOf = e;
  }()), M;
}
s(qr, "requireReactIs_development$1");
var Bt;
function Vr() {
  return Bt || (Bt = 1, process.env.NODE_ENV === "production" ? Pe.exports = Wr() : Pe.exports = qr()), Pe.exports;
}
s(Vr, "requireReactIs$1");
var nn = Vr(), Jr = tn(nn), Gr = Ht({
  __proto__: null,
  default: Jr
}, [nn]), Ne = { exports: {} }, O = {};
var zt;
function Hr() {
  if (zt) return O;
  zt = 1;
  var e = Symbol.for("react.element"), t = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), r = Symbol.for("react.strict_mode"), o = Symbol.for("react.profiler"), i = Symbol.for("react.provider"), c = Symbol.for("react.context"), a = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), g = Symbol.for("react.suspense_list"), y = Symbol.for("react.memo"), T = Symbol.for("react.lazy"), h = Symbol.for("react.offscreen"), p;
  p = Symbol.for("react.module.reference");
  function u(f) {
    if (typeof f == "object" && f !== null) {
      var E = f.$$typeof;
      switch (E) {
        case e:
          switch (f = f.type, f) {
            case n:
            case o:
            case r:
            case m:
            case g:
              return f;
            default:
              switch (f = f && f.$$typeof, f) {
                case a:
                case c:
                case l:
                case T:
                case y:
                case i:
                  return f;
                default:
                  return E;
              }
          }
        case t:
          return E;
      }
    }
  }
  return s(u, "v"), O.ContextConsumer = c, O.ContextProvider = i, O.Element = e, O.ForwardRef = l, O.Fragment = n, O.Lazy = T, O.Memo = y, O.Portal = t, O.Profiler = o, O.StrictMode = r, O.Suspense = m, O.SuspenseList = g, O.isAsyncMode = function() {
    return !1;
  }, O.isConcurrentMode = function() {
    return !1;
  }, O.isContextConsumer = function(f) {
    return u(f) === c;
  }, O.isContextProvider = function(f) {
    return u(f) === i;
  }, O.isElement = function(f) {
    return typeof f == "object" && f !== null && f.$$typeof === e;
  }, O.isForwardRef = function(f) {
    return u(f) === l;
  }, O.isFragment = function(f) {
    return u(f) === n;
  }, O.isLazy = function(f) {
    return u(f) === T;
  }, O.isMemo = function(f) {
    return u(f) === y;
  }, O.isPortal = function(f) {
    return u(f) === t;
  }, O.isProfiler = function(f) {
    return u(f) === o;
  }, O.isStrictMode = function(f) {
    return u(f) === r;
  }, O.isSuspense = function(f) {
    return u(f) === m;
  }, O.isSuspenseList = function(f) {
    return u(f) === g;
  }, O.isValidElementType = function(f) {
    return typeof f == "string" || typeof f == "function" || f === n || f === o || f === r || f === m || f === g || f === h || typeof f == "object" && f !== null && (f.$$typeof === T || f.$$typeof === y || f.$$typeof === i || f.$$typeof === c || f.$$typeof === l || f.$$typeof === p || f.getModuleId !== void 0);
  }, O.typeOf = u, O;
}
s(Hr, "requireReactIs_production_min");
var A = {};
var kt;
function Kr() {
  return kt || (kt = 1, process.env.NODE_ENV !== "production" && function() {
    var e = Symbol.for("react.element"), t = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), r = Symbol.for("react.strict_mode"), o = Symbol.for("react.profiler"), i = Symbol.for("react.provider"), c = Symbol.for("react.context"), a = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), g = Symbol.for("react.suspense_list"), y = Symbol.for("react.memo"), T = Symbol.for("react.lazy"), h = Symbol.for("react.offscreen"), p = !1, u = !1, f = !1, E = !1, $ = !1, w;
    w = Symbol.for("react.module.reference");
    function b(_) {
      return !!(typeof _ == "string" || typeof _ == "function" || _ === n || _ === o || $ || _ === r || _ === m || _ === g || E || _ === h || p || u || f || typeof _ == "object" && _ !== null && (_.$$typeof === T || _.$$typeof === y || _.$$typeof === i || _.$$typeof === c || _.$$typeof === l || // This needs to include all possible module reference object
      // types supported by any Flight configuration anywhere since
      // we don't know which Flight build this will end up being used
      // with.
      _.$$typeof === w || _.getModuleId !== void 0));
    }
    s(b, "isValidElementType");
    function d(_) {
      if (typeof _ == "object" && _ !== null) {
        var He = _.$$typeof;
        switch (He) {
          case e:
            var we = _.type;
            switch (we) {
              case n:
              case o:
              case r:
              case m:
              case g:
                return we;
              default:
                var Mt = we && we.$$typeof;
                switch (Mt) {
                  case a:
                  case c:
                  case l:
                  case T:
                  case y:
                  case i:
                    return Mt;
                  default:
                    return He;
                }
            }
          case t:
            return He;
        }
      }
    }
    s(d, "typeOf");
    var C = c, S = i, P = e, H = l, v = n, I = T, k = y, K = t, W = o, L = r, x = m, D = g, X = !1, B = !1;
    function V(_) {
      return X || (X = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.")), !1;
    }
    s(V, "isAsyncMode");
    function re(_) {
      return B || (B = !0, console.warn("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.")), !1;
    }
    s(re, "isConcurrentMode");
    function J(_) {
      return d(_) === c;
    }
    s(J, "isContextConsumer");
    function G(_) {
      return d(_) === i;
    }
    s(G, "isContextProvider");
    function ie(_) {
      return typeof _ == "object" && _ !== null && _.$$typeof === e;
    }
    s(ie, "isElement");
    function Z(_) {
      return d(_) === l;
    }
    s(Z, "isForwardRef");
    function q(_) {
      return d(_) === n;
    }
    s(q, "isFragment");
    function oe(_) {
      return d(_) === T;
    }
    s(oe, "isLazy");
    function he(_) {
      return d(_) === y;
    }
    s(he, "isMemo");
    function ue(_) {
      return d(_) === t;
    }
    s(ue, "isPortal");
    function Ee(_) {
      return d(_) === o;
    }
    s(Ee, "isProfiler");
    function Te(_) {
      return d(_) === r;
    }
    s(Te, "isStrictMode");
    function Ce(_) {
      return d(_) === m;
    }
    s(Ce, "isSuspense");
    function or(_) {
      return d(_) === g;
    }
    s(or, "isSuspenseList"), A.ContextConsumer = C, A.ContextProvider = S, A.Element = P, A.ForwardRef = H, A.Fragment = v, A.Lazy = I, A.Memo = k, A.Portal = K, A.Profiler = W, A.StrictMode = L, A.Suspense = x, A.SuspenseList = D, A.isAsyncMode = V, A.isConcurrentMode = re, A.isContextConsumer = J, A.isContextProvider = G, A.isElement = ie, A.isForwardRef = Z, A.isFragment = q, A.isLazy = oe, A.isMemo = he, A.isPortal = ue, A.isProfiler = Ee, A.isStrictMode = Te, A.isSuspense = Ce, A.isSuspenseList = or, A.isValidElementType = b, A.typeOf = d;
  }()), A;
}
s(Kr, "requireReactIs_development");
var Yt;
function Xr() {
  return Yt || (Yt = 1, process.env.NODE_ENV === "production" ? Ne.exports = Hr() : Ne.exports = Kr()), Ne.exports;
}
s(Xr, "requireReactIs");
var rn = Xr(), Zr = tn(rn), Qr = Ht({
  __proto__: null,
  default: Zr
}, [rn]), vr = [
  "isAsyncMode",
  "isConcurrentMode",
  "isContextConsumer",
  "isContextProvider",
  "isElement",
  "isForwardRef",
  "isFragment",
  "isLazy",
  "isMemo",
  "isPortal",
  "isProfiler",
  "isStrictMode",
  "isSuspense",
  "isSuspenseList",
  "isValidElementType"
], fe = Object.fromEntries(vr.map((e) => [e, (t) => Qr[e](t) || Gr[e](t)]));
function on(e, t = []) {
  if (Array.isArray(e))
    for (let n of e)
      on(n, t);
  else e != null && e !== !1 && e !== "" && t.push(e);
  return t;
}
s(on, "getChildren");
function Ut(e) {
  let t = e.type;
  if (typeof t == "string")
    return t;
  if (typeof t == "function")
    return t.displayName || t.name || "Unknown";
  if (fe.isFragment(e))
    return "React.Fragment";
  if (fe.isSuspense(e))
    return "React.Suspense";
  if (typeof t == "object" && t !== null) {
    if (fe.isContextProvider(e))
      return "Context.Provider";
    if (fe.isContextConsumer(e))
      return "Context.Consumer";
    if (fe.isForwardRef(e)) {
      if (t.displayName)
        return t.displayName;
      let n = t.render.displayName || t.render.name || "";
      return n === "" ? "ForwardRef" : `ForwardRef(${n})`;
    }
    if (fe.isMemo(e)) {
      let n = t.displayName || t.type.displayName || t.type.name || "";
      return n === "" ? "Memo" : `Memo(${n})`;
    }
  }
  return "UNDEFINED";
}
s(Ut, "getType");
function eo(e) {
  let { props: t } = e;
  return Object.keys(t).filter((n) => n !== "children" && t[n] !== void 0).sort();
}
s(eo, "getPropKeys$1");
var to = /* @__PURE__ */ s((e, t, n, r, o, i) => ++r > t.maxDepth ? nt(Ut(e), t) : tt(Ut(e), ve(eo(e), e.props, t, n + t.indent, r, o, i), et(on(e.props.children), t, n + t.indent, r, o, i), t, n), "serialize$1"), no = /* @__PURE__ */ s((e) => e != null && fe.isElement(e), "test$1"), ro = {
  serialize: to,
  test: no
}, oo = typeof Symbol == "function" && Symbol.for ? Symbol.for("react.test.json") : 245830487;
function io(e) {
  let { props: t } = e;
  return t ? Object.keys(t).filter((n) => t[n] !== void 0).sort() : [];
}
s(io, "getPropKeys");
var co = /* @__PURE__ */ s((e, t, n, r, o, i) => ++r > t.maxDepth ? nt(e.type, t) : tt(e.type, e.props ? ve(io(e), e.props, t, n + t.indent, r, o, i) : "", e.children ? et(e.children, t, n + t.indent, r, o, i) : "", t, n), "serialize"), so = /* @__PURE__ */ s((e) => e && e.$$typeof === oo, "test"), uo = {
  serialize: co,
  test: so
}, cn = Object.prototype.toString, lo = Date.prototype.toISOString, ao = Error.prototype.toString, Wt = RegExp.prototype.toString;
function Me(e) {
  return typeof e.constructor == "function" && e.constructor.name || "Object";
}
s(Me, "getConstructorName");
function fo(e) {
  return typeof window < "u" && e === window;
}
s(fo, "isWindow");
var mo = /^Symbol\((.*)\)(.*)$/, po = /\n/g, ot = class ot extends Error {
  constructor(t, n) {
    super(t), this.stack = n, this.name = this.constructor.name;
  }
};
s(ot, "PrettyFormatPluginError");
var Le = ot;
function go(e) {
  return e === "[object Array]" || e === "[object ArrayBuffer]" || e === "[object DataView]" || e === "[object Float32Array]" || e === "[object Float64Array]" || e === "[object Int8Array]" || e === "[object Int16Array]" || e === "[object Int32Array]" || e === "[object Uint8Array]" || e === "[object Uint8ClampedArray]" || e === "[object Uint16Array]" || e === "[object Uint32Array]";
}
s(go, "isToStringedArrayType");
function ho(e) {
  return Object.is(e, -0) ? "-0" : String(e);
}
s(ho, "printNumber");
function yo(e) {
  return `${e}n`;
}
s(yo, "printBigInt");
function qt(e, t) {
  return t ? `[Function ${e.name || "anonymous"}]` : "[Function]";
}
s(qt, "printFunction");
function Vt(e) {
  return String(e).replace(mo, "Symbol($1)");
}
s(Vt, "printSymbol");
function Jt(e) {
  return `[${ao.call(e)}]`;
}
s(Jt, "printError");
function sn(e, t, n, r) {
  if (e === !0 || e === !1)
    return `${e}`;
  if (e === void 0)
    return "undefined";
  if (e === null)
    return "null";
  let o = typeof e;
  if (o === "number")
    return ho(e);
  if (o === "bigint")
    return yo(e);
  if (o === "string")
    return r ? `"${e.replaceAll(/"|\\/g, "\\$&")}"` : `"${e}"`;
  if (o === "function")
    return qt(e, t);
  if (o === "symbol")
    return Vt(e);
  let i = cn.call(e);
  return i === "[object WeakMap]" ? "WeakMap {}" : i === "[object WeakSet]" ? "WeakSet {}" : i === "[object Function]" || i === "[object GeneratorFunction]" ? qt(e, t) : i === "[object Symbol]" ? Vt(e) : i === "[object Date]" ? Number.isNaN(+e) ? "Date { NaN }" : lo.call(e) : i === "[object Error]" ? Jt(e) : i === "[object RegExp]" ? n ? Wt.call(e).replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&") : Wt.call(e) : e instanceof Error ? Jt(e) : null;
}
s(sn, "printBasicValue");
function un(e, t, n, r, o, i) {
  if (o.includes(e))
    return "[Circular]";
  o = [...o], o.push(e);
  let c = ++r > t.maxDepth, a = t.min;
  if (t.callToJSON && !c && e.toJSON && typeof e.toJSON == "function" && !i)
    return le(e.toJSON(), t, n, r, o, !0);
  let l = cn.call(e);
  return l === "[object Arguments]" ? c ? "[Arguments]" : `${a ? "" : "Arguments "}[${Re(e, t, n, r, o, le)}]` : go(l) ? c ? `[${e.constructor.name}]` : `${a || !t.printBasicPrototype && e.constructor.name === "Array" ? "" : `${e.constructor.name} `}[${Re(e, t, n, r, o, le)}]` : l === "[object Map]" ? c ? "[Map]" : `Map {${Se(e.entries(), t, n, r, o, le, " => ")}}` : l === "[object Set]" ? c ? "[Set]" : `Set {${Ze(e.values(), t, n, r, o, le)}}` : c || fo(e) ? `[${Me(e)}]` : `${a || !t.printBasicPrototype && Me(e) === "Object" ? "" : `${Me(e)} `}{${Qe(e, t, n, r, o, le)}}`;
}
s(un, "printComplexValue");
var bo = {
  test: /* @__PURE__ */ s((e) => e && e instanceof Error, "test"),
  serialize(e, t, n, r, o, i) {
    if (o.includes(e))
      return "[Circular]";
    o = [...o, e];
    let c = ++r > t.maxDepth, { message: a, cause: l, ...m } = e, g = {
      message: a,
      ...typeof l < "u" ? { cause: l } : {},
      ...e instanceof AggregateError ? { errors: e.errors } : {},
      ...m
    }, y = e.name !== "Error" ? e.name : Me(e);
    return c ? `[${y}]` : `${y} {${Se(Object.entries(g).values(), t, n, r, o, i)}}`;
  }
};
function Eo(e) {
  return e.serialize != null;
}
s(Eo, "isNewPlugin");
function ln(e, t, n, r, o, i) {
  let c;
  try {
    c = Eo(e) ? e.serialize(t, n, r, o, i, le) : e.print(t, (a) => le(a, n, r, o, i), (a) => {
      let l = r + n.indent;
      return l + a.replaceAll(po, `
${l}`);
    }, {
      edgeSpacing: n.spacingOuter,
      min: n.min,
      spacing: n.spacingInner
    }, n.colors);
  } catch (a) {
    throw new Le(a.message, a.stack);
  }
  if (typeof c != "string")
    throw new TypeError(`pretty-format: Plugin must return type "string" but instead returned "${typeof c}".`);
  return c;
}
s(ln, "printPlugin");
function an(e, t) {
  for (let n of e)
    try {
      if (n.test(t))
        return n;
    } catch (r) {
      throw new Le(r.message, r.stack);
    }
  return null;
}
s(an, "findPlugin");
function le(e, t, n, r, o, i) {
  let c = an(t.plugins, e);
  if (c !== null)
    return ln(c, e, t, n, r, o);
  let a = sn(e, t.printFunctionName, t.escapeRegex, t.escapeString);
  return a !== null ? a : un(e, t, n, r, o, i);
}
s(le, "printer");
var rt = {
  comment: "gray",
  content: "reset",
  prop: "yellow",
  tag: "cyan",
  value: "green"
}, fn = Object.keys(rt), te = {
  callToJSON: !0,
  compareKeys: void 0,
  escapeRegex: !1,
  escapeString: !0,
  highlight: !1,
  indent: 2,
  maxDepth: Number.POSITIVE_INFINITY,
  maxWidth: Number.POSITIVE_INFINITY,
  min: !1,
  plugins: [],
  printBasicPrototype: !0,
  printFunctionName: !0,
  theme: rt
};
function So(e) {
  for (let t of Object.keys(e))
    if (!Object.prototype.hasOwnProperty.call(te, t))
      throw new Error(`pretty-format: Unknown option "${t}".`);
  if (e.min && e.indent !== void 0 && e.indent !== 0)
    throw new Error('pretty-format: Options "min" and "indent" cannot be used together.');
}
s(So, "validateOptions");
function $o() {
  return fn.reduce((e, t) => {
    let n = rt[t], r = n && ee[n];
    if (r && typeof r.close == "string" && typeof r.open == "string")
      e[t] = r;
    else
      throw new Error(`pretty-format: Option "theme" has a key "${t}" whose value "${n}" is undefined in ansi-styles.`);
    return e;
  }, /* @__PURE__ */ Object.create(null));
}
s($o, "getColorsHighlight");
function _o() {
  return fn.reduce((e, t) => (e[t] = {
    close: "",
    open: ""
  }, e), /* @__PURE__ */ Object.create(null));
}
s(_o, "getColorsEmpty");
function mn(e) {
  return e?.printFunctionName ?? te.printFunctionName;
}
s(mn, "getPrintFunctionName");
function pn(e) {
  return e?.escapeRegex ?? te.escapeRegex;
}
s(pn, "getEscapeRegex");
function gn(e) {
  return e?.escapeString ?? te.escapeString;
}
s(gn, "getEscapeString");
function Gt(e) {
  return {
    callToJSON: e?.callToJSON ?? te.callToJSON,
    colors: e?.highlight ? $o() : _o(),
    compareKeys: typeof e?.compareKeys == "function" || e?.compareKeys === null ? e.compareKeys : te.compareKeys,
    escapeRegex: pn(e),
    escapeString: gn(e),
    indent: e?.min ? "" : To(e?.indent ?? te.indent),
    maxDepth: e?.maxDepth ?? te.maxDepth,
    maxWidth: e?.maxWidth ?? te.maxWidth,
    min: e?.min ?? te.min,
    plugins: e?.plugins ?? te.plugins,
    printBasicPrototype: e?.printBasicPrototype ?? !0,
    printFunctionName: mn(e),
    spacingInner: e?.min ? " " : `
`,
    spacingOuter: e?.min ? "" : `
`
  };
}
s(Gt, "getConfig");
function To(e) {
  return Array.from({ length: e + 1 }).join(" ");
}
s(To, "createIndent");
function Q(e, t) {
  if (t && (So(t), t.plugins)) {
    let r = an(t.plugins, e);
    if (r !== null)
      return ln(r, e, Gt(t), "", 0, []);
  }
  let n = sn(e, mn(t), pn(t), gn(t));
  return n !== null ? n : un(e, Gt(t), "", 0, []);
}
s(Q, "format");
var $e = {
  AsymmetricMatcher: ar,
  DOMCollection: br,
  DOMElement: Ar,
  Immutable: Ur,
  ReactElement: ro,
  ReactTestComponent: uo,
  Error: bo
};

// ../node_modules/loupe/lib/helpers.js
var hn = {
  bold: ["1", "22"],
  dim: ["2", "22"],
  italic: ["3", "23"],
  underline: ["4", "24"],
  // 5 & 6 are blinking
  inverse: ["7", "27"],
  hidden: ["8", "28"],
  strike: ["9", "29"],
  // 10-20 are fonts
  // 21-29 are resets for 1-9
  black: ["30", "39"],
  red: ["31", "39"],
  green: ["32", "39"],
  yellow: ["33", "39"],
  blue: ["34", "39"],
  magenta: ["35", "39"],
  cyan: ["36", "39"],
  white: ["37", "39"],
  brightblack: ["30;1", "39"],
  brightred: ["31;1", "39"],
  brightgreen: ["32;1", "39"],
  brightyellow: ["33;1", "39"],
  brightblue: ["34;1", "39"],
  brightmagenta: ["35;1", "39"],
  brightcyan: ["36;1", "39"],
  brightwhite: ["37;1", "39"],
  grey: ["90", "39"]
}, Co = {
  special: "cyan",
  number: "yellow",
  bigint: "yellow",
  boolean: "yellow",
  undefined: "grey",
  null: "bold",
  string: "green",
  symbol: "green",
  date: "magenta",
  regexp: "red"
}, ce = "\u2026";
function wo(e, t) {
  let n = hn[Co[t]] || hn[t] || "";
  return n ? `\x1B[${n[0]}m${String(e)}\x1B[${n[1]}m` : String(e);
}
s(wo, "colorise");
function yn({
  showHidden: e = !1,
  depth: t = 2,
  colors: n = !1,
  customInspect: r = !0,
  showProxy: o = !1,
  maxArrayLength: i = 1 / 0,
  breakLength: c = 1 / 0,
  seen: a = [],
  // eslint-disable-next-line no-shadow
  truncate: l = 1 / 0,
  stylize: m = String
} = {}, g) {
  let y = {
    showHidden: !!e,
    depth: Number(t),
    colors: !!n,
    customInspect: !!r,
    showProxy: !!o,
    maxArrayLength: Number(i),
    breakLength: Number(c),
    truncate: Number(l),
    seen: a,
    inspect: g,
    stylize: m
  };
  return y.colors && (y.stylize = wo), y;
}
s(yn, "normaliseOptions");
function Oo(e) {
  return e >= "\uD800" && e <= "\uDBFF";
}
s(Oo, "isHighSurrogate");
function Y(e, t, n = ce) {
  e = String(e);
  let r = n.length, o = e.length;
  if (r > t && o > r)
    return n;
  if (o > t && o > r) {
    let i = t - r;
    return i > 0 && Oo(e[i - 1]) && (i = i - 1), `${e.slice(0, i)}${n}`;
  }
  return e;
}
s(Y, "truncate");
function j(e, t, n, r = ", ") {
  n = n || t.inspect;
  let o = e.length;
  if (o === 0)
    return "";
  let i = t.truncate, c = "", a = "", l = "";
  for (let m = 0; m < o; m += 1) {
    let g = m + 1 === e.length, y = m + 2 === e.length;
    l = `${ce}(${e.length - m})`;
    let T = e[m];
    t.truncate = i - c.length - (g ? 0 : r.length);
    let h = a || n(T, t) + (g ? "" : r), p = c.length + h.length, u = p + l.length;
    if (g && p > i && c.length + l.length <= i || !g && !y && u > i || (a = g ? "" : n(e[m + 1], t) + (y ? "" : r), !g && y && u > i && p + a.length > i))
      break;
    if (c += h, !g && !y && p + a.length >= i) {
      l = `${ce}(${e.length - m - 1})`;
      break;
    }
    l = "";
  }
  return `${c}${l}`;
}
s(j, "inspectList");
function Ao(e) {
  return e.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/) ? e : JSON.stringify(e).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
}
s(Ao, "quoteComplexKey");
function se([e, t], n) {
  return n.truncate -= 2, typeof e == "string" ? e = Ao(e) : typeof e != "number" && (e = `[${n.inspect(e, n)}]`), n.truncate -= e.length, t = n.inspect(t, n), `${e}: ${t}`;
}
s(se, "inspectProperty");

// ../node_modules/loupe/lib/array.js
function it(e, t) {
  let n = Object.keys(e).slice(e.length);
  if (!e.length && !n.length)
    return "[]";
  t.truncate -= 4;
  let r = j(e, t);
  t.truncate -= r.length;
  let o = "";
  return n.length && (o = j(n.map((i) => [i, e[i]]), t, se)), `[ ${r}${o ? `, ${o}` : ""} ]`;
}
s(it, "inspectArray");

// ../node_modules/loupe/lib/typedarray.js
var Po = /* @__PURE__ */ s((e) => typeof Buffer == "function" && e instanceof Buffer ? "Buffer" : e[Symbol.toStringTag] ? e[Symbol.toStringTag] : e.constructor.name, "getArrayName");
function ne(e, t) {
  let n = Po(e);
  t.truncate -= n.length + 4;
  let r = Object.keys(e).slice(e.length);
  if (!e.length && !r.length)
    return `${n}[]`;
  let o = "";
  for (let c = 0; c < e.length; c++) {
    let a = `${t.stylize(Y(e[c], t.truncate), "number")}${c === e.length - 1 ? "" : ", "}`;
    if (t.truncate -= a.length, e[c] !== e.length && t.truncate <= 3) {
      o += `${ce}(${e.length - e[c] + 1})`;
      break;
    }
    o += a;
  }
  let i = "";
  return r.length && (i = j(r.map((c) => [c, e[c]]), t, se)), `${n}[ ${o}${i ? `, ${i}` : ""} ]`;
}
s(ne, "inspectTypedArray");

// ../node_modules/loupe/lib/date.js
function ct(e, t) {
  let n = e.toJSON();
  if (n === null)
    return "Invalid Date";
  let r = n.split("T"), o = r[0];
  return t.stylize(`${o}T${Y(r[1], t.truncate - o.length - 1)}`, "date");
}
s(ct, "inspectDate");

// ../node_modules/loupe/lib/function.js
function Fe(e, t) {
  let n = e[Symbol.toStringTag] || "Function", r = e.name;
  return r ? t.stylize(`[${n} ${Y(r, t.truncate - 11)}]`, "special") : t.stylize(`[${n}]`, "special");
}
s(Fe, "inspectFunction");

// ../node_modules/loupe/lib/map.js
function No([e, t], n) {
  return n.truncate -= 4, e = n.inspect(e, n), n.truncate -= e.length, t = n.inspect(t, n), `${e} => ${t}`;
}
s(No, "inspectMapEntry");
function Mo(e) {
  let t = [];
  return e.forEach((n, r) => {
    t.push([r, n]);
  }), t;
}
s(Mo, "mapToEntries");
function st(e, t) {
  return e.size === 0 ? "Map{}" : (t.truncate -= 7, `Map{ ${j(Mo(e), t, No)} }`);
}
s(st, "inspectMap");

// ../node_modules/loupe/lib/number.js
var Ro = Number.isNaN || ((e) => e !== e);
function xe(e, t) {
  return Ro(e) ? t.stylize("NaN", "number") : e === 1 / 0 ? t.stylize("Infinity", "number") : e === -1 / 0 ? t.stylize("-Infinity", "number") : e === 0 ? t.stylize(1 / e === 1 / 0 ? "+0" : "-0", "number") : t.stylize(Y(String(e), t.truncate), "number");
}
s(xe, "inspectNumber");

// ../node_modules/loupe/lib/bigint.js
function De(e, t) {
  let n = Y(e.toString(), t.truncate - 1);
  return n !== ce && (n += "n"), t.stylize(n, "bigint");
}
s(De, "inspectBigInt");

// ../node_modules/loupe/lib/regexp.js
function ut(e, t) {
  let n = e.toString().split("/")[2], r = t.truncate - (2 + n.length), o = e.source;
  return t.stylize(`/${Y(o, r)}/${n}`, "regexp");
}
s(ut, "inspectRegExp");

// ../node_modules/loupe/lib/set.js
function Lo(e) {
  let t = [];
  return e.forEach((n) => {
    t.push(n);
  }), t;
}
s(Lo, "arrayFromSet");
function lt(e, t) {
  return e.size === 0 ? "Set{}" : (t.truncate -= 7, `Set{ ${j(Lo(e), t)} }`);
}
s(lt, "inspectSet");

// ../node_modules/loupe/lib/string.js
var bn = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g"), Io = {
  "\b": "\\b",
  "	": "\\t",
  "\n": "\\n",
  "\f": "\\f",
  "\r": "\\r",
  "'": "\\'",
  "\\": "\\\\"
}, Fo = 16, xo = 4;
function Do(e) {
  return Io[e] || `\\u${`0000${e.charCodeAt(0).toString(Fo)}`.slice(-xo)}`;
}
s(Do, "escape");
function je(e, t) {
  return bn.test(e) && (e = e.replace(bn, Do)), t.stylize(`'${Y(e, t.truncate - 2)}'`, "string");
}
s(je, "inspectString");

// ../node_modules/loupe/lib/symbol.js
function Be(e) {
  return "description" in Symbol.prototype ? e.description ? `Symbol(${e.description})` : "Symbol()" : e.toString();
}
s(Be, "inspectSymbol");

// ../node_modules/loupe/lib/promise.js
var En = /* @__PURE__ */ s(() => "Promise{\u2026}", "getPromiseValue");
try {
  let { getPromiseDetails: e, kPending: t, kRejected: n } = process.binding("util");
  Array.isArray(e(Promise.resolve())) && (En = /* @__PURE__ */ s((r, o) => {
    let [i, c] = e(r);
    return i === t ? "Promise{<pending>}" : `Promise${i === n ? "!" : ""}{${o.inspect(c, o)}}`;
  }, "getPromiseValue"));
} catch {
}
var dn = En;

// ../node_modules/loupe/lib/object.js
function me(e, t) {
  let n = Object.getOwnPropertyNames(e), r = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(e) : [];
  if (n.length === 0 && r.length === 0)
    return "{}";
  if (t.truncate -= 4, t.seen = t.seen || [], t.seen.includes(e))
    return "[Circular]";
  t.seen.push(e);
  let o = j(n.map((a) => [a, e[a]]), t, se), i = j(r.map((a) => [a, e[a]]), t, se);
  t.seen.pop();
  let c = "";
  return o && i && (c = ", "), `{ ${o}${c}${i} }`;
}
s(me, "inspectObject");

// ../node_modules/loupe/lib/class.js
var at = typeof Symbol < "u" && Symbol.toStringTag ? Symbol.toStringTag : !1;
function ft(e, t) {
  let n = "";
  return at && at in e && (n = e[at]), n = n || e.constructor.name, (!n || n === "_class") && (n = "<Anonymous Class>"), t.truncate -= n.length, `${n}${me(e, t)}`;
}
s(ft, "inspectClass");

// ../node_modules/loupe/lib/arguments.js
function mt(e, t) {
  return e.length === 0 ? "Arguments[]" : (t.truncate -= 13, `Arguments[ ${j(e, t)} ]`);
}
s(mt, "inspectArguments");

// ../node_modules/loupe/lib/error.js
var jo = [
  "stack",
  "line",
  "column",
  "name",
  "message",
  "fileName",
  "lineNumber",
  "columnNumber",
  "number",
  "description",
  "cause"
];
function pt(e, t) {
  let n = Object.getOwnPropertyNames(e).filter((c) => jo.indexOf(c) === -1), r = e.name;
  t.truncate -= r.length;
  let o = "";
  if (typeof e.message == "string" ? o = Y(e.message, t.truncate) : n.unshift("message"), o = o ? `: ${o}` : "", t.truncate -= o.length + 5, t.seen = t.seen || [], t.seen.includes(e))
    return "[Circular]";
  t.seen.push(e);
  let i = j(n.map((c) => [c, e[c]]), t, se);
  return `${r}${o}${i ? ` { ${i} }` : ""}`;
}
s(pt, "inspectObject");

// ../node_modules/loupe/lib/html.js
function Bo([e, t], n) {
  return n.truncate -= 3, t ? `${n.stylize(String(e), "yellow")}=${n.stylize(`"${t}"`, "string")}` : `${n.stylize(String(e), "yellow")}`;
}
s(Bo, "inspectAttribute");
function ze(e, t) {
  return j(e, t, zo, `
`);
}
s(ze, "inspectNodeCollection");
function zo(e, t) {
  switch (e.nodeType) {
    case 1:
      return ke(e, t);
    case 3:
      return t.inspect(e.data, t);
    default:
      return t.inspect(e, t);
  }
}
s(zo, "inspectNode");
function ke(e, t) {
  let n = e.getAttributeNames(), r = e.tagName.toLowerCase(), o = t.stylize(`<${r}`, "special"), i = t.stylize(">", "special"), c = t.stylize(`</${r}>`, "special");
  t.truncate -= r.length * 2 + 5;
  let a = "";
  n.length > 0 && (a += " ", a += j(n.map((g) => [g, e.getAttribute(g)]), t, Bo, " ")), t.truncate -= a.length;
  let l = t.truncate, m = ze(e.children, t);
  return m && m.length > l && (m = `${ce}(${e.children.length})`), `${o}${a}${i}${m}${c}`;
}
s(ke, "inspectHTML");

// ../node_modules/loupe/lib/index.js
var ko = typeof Symbol == "function" && typeof Symbol.for == "function", gt = ko ? Symbol.for("chai/inspect") : "@@chai/inspect", ht = Symbol.for("nodejs.util.inspect.custom"), Sn = /* @__PURE__ */ new WeakMap(), $n = {}, _n = {
  undefined: /* @__PURE__ */ s((e, t) => t.stylize("undefined", "undefined"), "undefined"),
  null: /* @__PURE__ */ s((e, t) => t.stylize("null", "null"), "null"),
  boolean: /* @__PURE__ */ s((e, t) => t.stylize(String(e), "boolean"), "boolean"),
  Boolean: /* @__PURE__ */ s((e, t) => t.stylize(String(e), "boolean"), "Boolean"),
  number: xe,
  Number: xe,
  bigint: De,
  BigInt: De,
  string: je,
  String: je,
  function: Fe,
  Function: Fe,
  symbol: Be,
  // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
  Symbol: Be,
  Array: it,
  Date: ct,
  Map: st,
  Set: lt,
  RegExp: ut,
  Promise: dn,
  // WeakSet, WeakMap are totally opaque to us
  WeakSet: /* @__PURE__ */ s((e, t) => t.stylize("WeakSet{\u2026}", "special"), "WeakSet"),
  WeakMap: /* @__PURE__ */ s((e, t) => t.stylize("WeakMap{\u2026}", "special"), "WeakMap"),
  Arguments: mt,
  Int8Array: ne,
  Uint8Array: ne,
  Uint8ClampedArray: ne,
  Int16Array: ne,
  Uint16Array: ne,
  Int32Array: ne,
  Uint32Array: ne,
  Float32Array: ne,
  Float64Array: ne,
  Generator: /* @__PURE__ */ s(() => "", "Generator"),
  DataView: /* @__PURE__ */ s(() => "", "DataView"),
  ArrayBuffer: /* @__PURE__ */ s(() => "", "ArrayBuffer"),
  Error: pt,
  HTMLCollection: ze,
  NodeList: ze
}, Yo = /* @__PURE__ */ s((e, t, n) => gt in e && typeof e[gt] == "function" ? e[gt](t) : ht in e && typeof e[ht] == "function" ? e[ht](t.depth, t) : "inspect" in e && typeof e.inspect == "function" ? e.inspect(t.depth, t) : "constructor" in e && Sn.has(e.constructor) ? Sn.get(e.constructor)(e, t) : $n[n] ? $n[n](e, t) : "", "inspectCustom"), Uo = Object.prototype.toString;
function Ye(e, t = {}) {
  let n = yn(t, Ye), { customInspect: r } = n, o = e === null ? "null" : typeof e;
  if (o === "object" && (o = Uo.call(e).slice(8, -1)), o in _n)
    return _n[o](e, n);
  if (r && e) {
    let c = Yo(e, n, o);
    if (c)
      return typeof c == "string" ? c : Ye(c, n);
  }
  let i = e ? Object.getPrototypeOf(e) : !1;
  return i === Object.prototype || i === null ? me(e, n) : e && typeof HTMLElement == "function" && e instanceof HTMLElement ? ke(e, n) : "constructor" in e ? e.constructor !== Object ? ft(e, n) : me(e, n) : e === Object(e) ? me(e, n) : n.stylize(String(e), o);
}
s(Ye, "inspect");

// ../node_modules/@vitest/utils/dist/chunk-_commonjsHelpers.js
var { AsymmetricMatcher: qo, DOMCollection: Vo, DOMElement: Jo, Immutable: Go, ReactElement: Ho, ReactTestComponent: Ko } = $e, Tn = [
  Ko,
  Ho,
  Jo,
  Vo,
  Go,
  qo
];
function pe(e, t = 10, { maxLength: n, ...r } = {}) {
  let o = n ?? 1e4, i;
  try {
    i = Q(e, {
      maxDepth: t,
      escapeString: !1,
      plugins: Tn,
      ...r
    });
  } catch {
    i = Q(e, {
      callToJSON: !1,
      maxDepth: t,
      escapeString: !1,
      plugins: Tn,
      ...r
    });
  }
  return i.length >= o && t > 1 ? pe(e, Math.floor(Math.min(t, Number.MAX_SAFE_INTEGER) / 2), {
    maxLength: n,
    ...r
  }) : i;
}
s(pe, "stringify");
var Xo = /%[sdjifoOc%]/g;
function Cn(...e) {
  if (typeof e[0] != "string") {
    let i = [];
    for (let c = 0; c < e.length; c++)
      i.push(_e(e[c], {
        depth: 0,
        colors: !1
      }));
    return i.join(" ");
  }
  let t = e.length, n = 1, r = e[0], o = String(r).replace(Xo, (i) => {
    if (i === "%%")
      return "%";
    if (n >= t)
      return i;
    switch (i) {
      case "%s": {
        let c = e[n++];
        return typeof c == "bigint" ? `${c.toString()}n` : typeof c == "number" && c === 0 && 1 / c < 0 ? "-0" : typeof c == "object" && c !== null ? typeof c.toString == "function" && c.toString !== Object.prototype.toString ? c.toString() : _e(c, {
          depth: 0,
          colors: !1
        }) : String(c);
      }
      case "%d": {
        let c = e[n++];
        return typeof c == "bigint" ? `${c.toString()}n` : Number(c).toString();
      }
      case "%i": {
        let c = e[n++];
        return typeof c == "bigint" ? `${c.toString()}n` : Number.parseInt(String(c)).toString();
      }
      case "%f":
        return Number.parseFloat(String(e[n++])).toString();
      case "%o":
        return _e(e[n++], {
          showHidden: !0,
          showProxy: !0
        });
      case "%O":
        return _e(e[n++]);
      case "%c":
        return n++, "";
      case "%j":
        try {
          return JSON.stringify(e[n++]);
        } catch (c) {
          let a = c.message;
          if (a.includes("circular structure") || a.includes("cyclic structures") || a.includes("cyclic object"))
            return "[Circular]";
          throw c;
        }
      default:
        return i;
    }
  });
  for (let i = e[n]; n < t; i = e[++n])
    i === null || typeof i != "object" ? o += ` ${i}` : o += ` ${_e(i)}`;
  return o;
}
s(Cn, "format");
function _e(e, t = {}) {
  return t.truncate === 0 && (t.truncate = Number.POSITIVE_INFINITY), Ye(e, t);
}
s(_e, "inspect");
function wn(e) {
  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
}
s(wn, "getDefaultExportFromCjs");

// ../node_modules/@vitest/utils/dist/helpers.js
function hs(e, t, n) {
  let r = typeof e;
  if (!n.includes(r))
    throw new TypeError(`${t} value must be ${n.join(" or ")}, received "${r}"`);
}
s(hs, "assertTypes");
function ys(e) {
  return e != null && typeof e == "object" && !Array.isArray(e);
}
s(ys, "isObject");
function Zo(e) {
  return e === Object.prototype || e === Function.prototype || e === RegExp.prototype;
}
s(Zo, "isFinalObj");
function Ue(e) {
  return Object.prototype.toString.apply(e).slice(8, -1);
}
s(Ue, "getType");
function Qo(e, t) {
  let n = typeof t == "function" ? t : (r) => t.add(r);
  Object.getOwnPropertyNames(e).forEach(n), Object.getOwnPropertySymbols(e).forEach(n);
}
s(Qo, "collectOwnProperties");
function bt(e) {
  let t = /* @__PURE__ */ new Set();
  return Zo(e) ? [] : (Qo(e, t), Array.from(t));
}
s(bt, "getOwnProperties");
var On = { forceWritable: !1 };
function Et(e, t = On) {
  return yt(e, /* @__PURE__ */ new WeakMap(), t);
}
s(Et, "deepClone");
function yt(e, t, n = On) {
  let r, o;
  if (t.has(e))
    return t.get(e);
  if (Array.isArray(e)) {
    for (o = Array.from({ length: r = e.length }), t.set(e, o); r--; )
      o[r] = yt(e[r], t, n);
    return o;
  }
  if (Object.prototype.toString.call(e) === "[object Object]") {
    o = Object.create(Object.getPrototypeOf(e)), t.set(e, o);
    let i = bt(e);
    for (let c of i) {
      let a = Object.getOwnPropertyDescriptor(e, c);
      if (!a)
        continue;
      let l = yt(e[c], t, n);
      n.forceWritable ? Object.defineProperty(o, c, {
        enumerable: a.enumerable,
        configurable: !0,
        writable: !0,
        value: l
      }) : "get" in a ? Object.defineProperty(o, c, {
        ...a,
        get() {
          return l;
        }
      }) : Object.defineProperty(o, c, {
        ...a,
        value: l
      });
    }
    return o;
  }
  return e;
}
s(yt, "clone");
function bs() {
}
s(bs, "noop");

// ../node_modules/@vitest/utils/dist/diff.js
var U = -1, z = 1, F = 0, At = class At {
  0;
  1;
  constructor(t, n) {
    this[0] = t, this[1] = n;
  }
};
s(At, "Diff");
var R = At;
function vo(e, t) {
  if (!e || !t || e.charAt(0) !== t.charAt(0))
    return 0;
  let n = 0, r = Math.min(e.length, t.length), o = r, i = 0;
  for (; n < o; )
    e.substring(i, o) === t.substring(i, o) ? (n = o, i = n) : r = o, o = Math.floor((r - n) / 2 + n);
  return o;
}
s(vo, "diff_commonPrefix");
function Un(e, t) {
  if (!e || !t || e.charAt(e.length - 1) !== t.charAt(t.length - 1))
    return 0;
  let n = 0, r = Math.min(e.length, t.length), o = r, i = 0;
  for (; n < o; )
    e.substring(e.length - o, e.length - i) === t.substring(t.length - o, t.length - i) ? (n = o, i = n) : r = o, o = Math.floor((r - n) / 2 + n);
  return o;
}
s(Un, "diff_commonSuffix");
function An(e, t) {
  let n = e.length, r = t.length;
  if (n === 0 || r === 0)
    return 0;
  n > r ? e = e.substring(n - r) : n < r && (t = t.substring(0, n));
  let o = Math.min(n, r);
  if (e === t)
    return o;
  let i = 0, c = 1;
  for (; ; ) {
    let a = e.substring(o - c), l = t.indexOf(a);
    if (l === -1)
      return i;
    c += l, (l === 0 || e.substring(o - c) === t.substring(0, c)) && (i = c, c++);
  }
}
s(An, "diff_commonOverlap_");
function ei(e) {
  let t = !1, n = [], r = 0, o = null, i = 0, c = 0, a = 0, l = 0, m = 0;
  for (; i < e.length; )
    e[i][0] === F ? (n[r++] = i, c = l, a = m, l = 0, m = 0, o = e[i][1]) : (e[i][0] === z ? l += e[i][1].length : m += e[i][1].length, o && o.length <= Math.max(c, a) && o.length <= Math.max(l, m) && (e.splice(n[r - 1], 0, new R(U, o)), e[n[r - 1] + 1][0] = z, r--, r--, i = r > 0 ? n[r - 1] : -1, c = 0, a = 0, l = 0, m = 0, o = null, t = !0)), i++;
  for (t && Wn(e), ri(e), i = 1; i < e.length; ) {
    if (e[i - 1][0] === U && e[i][0] === z) {
      let g = e[i - 1][1], y = e[i][1], T = An(g, y), h = An(y, g);
      T >= h ? (T >= g.length / 2 || T >= y.length / 2) && (e.splice(i, 0, new R(F, y.substring(0, T))), e[i - 1][1] = g.substring(0, g.length - T), e[i + 1][1] = y.substring(T), i++) : (h >= g.length / 2 || h >= y.length / 2) && (e.splice(i, 0, new R(F, g.substring(0, h))), e[i - 1][0] = z, e[i - 1][1] = y.substring(0, y.length - h), e[i + 1][0] = U, e[i + 1][1] = g.substring(h), i++), i++;
    }
    i++;
  }
}
s(ei, "diff_cleanupSemantic");
var Pn = /[^a-z0-9]/i, Nn = /\s/, Mn = /[\r\n]/, ti = /\n\r?\n$/, ni = /^\r?\n\r?\n/;
function ri(e) {
  let t = 1;
  for (; t < e.length - 1; ) {
    if (e[t - 1][0] === F && e[t + 1][0] === F) {
      let n = e[t - 1][1], r = e[t][1], o = e[t + 1][1], i = Un(n, r);
      if (i) {
        let g = r.substring(r.length - i);
        n = n.substring(0, n.length - i), r = g + r.substring(0, r.length - i), o = g + o;
      }
      let c = n, a = r, l = o, m = We(n, r) + We(r, o);
      for (; r.charAt(0) === o.charAt(0); ) {
        n += r.charAt(0), r = r.substring(1) + o.charAt(0), o = o.substring(1);
        let g = We(n, r) + We(r, o);
        g >= m && (m = g, c = n, a = r, l = o);
      }
      e[t - 1][1] !== c && (c ? e[t - 1][1] = c : (e.splice(t - 1, 1), t--), e[t][1] = a, l ? e[t + 1][1] = l : (e.splice(t + 1, 1), t--));
    }
    t++;
  }
}
s(ri, "diff_cleanupSemanticLossless");
function Wn(e) {
  e.push(new R(F, ""));
  let t = 0, n = 0, r = 0, o = "", i = "", c;
  for (; t < e.length; )
    switch (e[t][0]) {
      case z:
        r++, i += e[t][1], t++;
        break;
      case U:
        n++, o += e[t][1], t++;
        break;
      case F:
        n + r > 1 ? (n !== 0 && r !== 0 && (c = vo(i, o), c !== 0 && (t - n - r > 0 && e[t - n - r - 1][0] === F ? e[t - n - r - 1][1] += i.substring(0, c) : (e.splice(0, 0, new R(F, i.substring(0, c))), t++), i = i.substring(c), o = o.substring(c)), c = Un(i, o), c !== 0 && (e[t][1] = i.substring(i.length - c) + e[t][1], i = i.substring(0, i.length - c), o = o.substring(0, o.length - c))), t -= n + r, e.splice(t, n + r), o.length && (e.splice(t, 0, new R(U, o)), t++), i.length && (e.splice(t, 0, new R(z, i)), t++), t++) : t !== 0 && e[t - 1][0] === F ? (e[t - 1][1] += e[t][1], e.splice(t, 1)) : t++, r = 0, n = 0, o = "", i = "";
        break;
    }
  e[e.length - 1][1] === "" && e.pop();
  let a = !1;
  for (t = 1; t < e.length - 1; )
    e[t - 1][0] === F && e[t + 1][0] === F && (e[t][1].substring(e[t][1].length - e[t - 1][1].length) === e[t - 1][1] ? (e[t][1] = e[t - 1][1] + e[t][1].substring(0, e[t][1].length - e[t - 1][1].length), e[t + 1][1] = e[t - 1][1] + e[t + 1][1], e.splice(t - 1, 1), a = !0) : e[t][1].substring(0, e[t + 1][1].length) === e[t + 1][1] && (e[t - 1][1] += e[t + 1][1], e[t][1] = e[t][1].substring(e[t + 1][1].length) + e[t + 1][1], e.splice(t + 1, 1), a = !0)), t++;
  a && Wn(e);
}
s(Wn, "diff_cleanupMerge");
function We(e, t) {
  if (!e || !t)
    return 6;
  let n = e.charAt(e.length - 1), r = t.charAt(0), o = n.match(Pn), i = r.match(Pn), c = o && n.match(Nn), a = i && r.match(Nn), l = c && n.match(Mn), m = a && r.match(Mn), g = l && e.match(ti), y = m && t.match(ni);
  return g || y ? 5 : l || m ? 4 : o && !c && a ? 3 : c || a ? 2 : o || i ? 1 : 0;
}
s(We, "diff_cleanupSemanticScore_");
var qn = "Compared values have no visual difference.", oi = "Compared values serialize to the same structure.\nPrinting internal object structure without calling `toJSON` instead.", qe = {}, Rn;
function ii() {
  if (Rn) return qe;
  Rn = 1, Object.defineProperty(qe, "__esModule", {
    value: !0
  }), qe.default = T;
  let e = "diff-sequences", t = 0, n = /* @__PURE__ */ s((h, p, u, f, E) => {
    let $ = 0;
    for (; h < p && u < f && E(h, u); )
      h += 1, u += 1, $ += 1;
    return $;
  }, "countCommonItemsF"), r = /* @__PURE__ */ s((h, p, u, f, E) => {
    let $ = 0;
    for (; h <= p && u <= f && E(p, f); )
      p -= 1, f -= 1, $ += 1;
    return $;
  }, "countCommonItemsR"), o = /* @__PURE__ */ s((h, p, u, f, E, $, w) => {
    let b = 0, d = -h, C = $[b], S = C;
    $[b] += n(
      C + 1,
      p,
      f + C - d + 1,
      u,
      E
    );
    let P = h < w ? h : w;
    for (b += 1, d += 2; b <= P; b += 1, d += 2) {
      if (b !== h && S < $[b])
        C = $[b];
      else if (C = S + 1, p <= C)
        return b - 1;
      S = $[b], $[b] = C + n(C + 1, p, f + C - d + 1, u, E);
    }
    return w;
  }, "extendPathsF"), i = /* @__PURE__ */ s((h, p, u, f, E, $, w) => {
    let b = 0, d = h, C = $[b], S = C;
    $[b] -= r(
      p,
      C - 1,
      u,
      f + C - d - 1,
      E
    );
    let P = h < w ? h : w;
    for (b += 1, d -= 2; b <= P; b += 1, d -= 2) {
      if (b !== h && $[b] < S)
        C = $[b];
      else if (C = S - 1, C < p)
        return b - 1;
      S = $[b], $[b] = C - r(
        p,
        C - 1,
        u,
        f + C - d - 1,
        E
      );
    }
    return w;
  }, "extendPathsR"), c = /* @__PURE__ */ s((h, p, u, f, E, $, w, b, d, C, S) => {
    let P = f - p, H = u - p, I = E - f - H, k = -I - (h - 1), K = -I + (h - 1), W = t, L = h < b ? h : b;
    for (let x = 0, D = -h; x <= L; x += 1, D += 2) {
      let X = x === 0 || x !== h && W < w[x], B = X ? w[x] : W, V = X ? B : B + 1, re = P + V - D, J = n(
        V + 1,
        u,
        re + 1,
        E,
        $
      ), G = V + J;
      if (W = w[x], w[x] = G, k <= D && D <= K) {
        let ie = (h - 1 - (D + I)) / 2;
        if (ie <= C && d[ie] - 1 <= G) {
          let Z = P + B - (X ? D + 1 : D - 1), q = r(
            p,
            B,
            f,
            Z,
            $
          ), oe = B - q, he = Z - q, ue = oe + 1, Ee = he + 1;
          S.nChangePreceding = h - 1, h - 1 === ue + Ee - p - f ? (S.aEndPreceding = p, S.bEndPreceding = f) : (S.aEndPreceding = ue, S.bEndPreceding = Ee), S.nCommonPreceding = q, q !== 0 && (S.aCommonPreceding = ue, S.bCommonPreceding = Ee), S.nCommonFollowing = J, J !== 0 && (S.aCommonFollowing = V + 1, S.bCommonFollowing = re + 1);
          let Te = G + 1, Ce = re + J + 1;
          return S.nChangeFollowing = h - 1, h - 1 === u + E - Te - Ce ? (S.aStartFollowing = u, S.bStartFollowing = E) : (S.aStartFollowing = Te, S.bStartFollowing = Ce), !0;
        }
      }
    }
    return !1;
  }, "extendOverlappablePathsF"), a = /* @__PURE__ */ s((h, p, u, f, E, $, w, b, d, C, S) => {
    let P = E - u, H = u - p, I = E - f - H, k = I - h, K = I + h, W = t, L = h < C ? h : C;
    for (let x = 0, D = h; x <= L; x += 1, D -= 2) {
      let X = x === 0 || x !== h && d[x] < W, B = X ? d[x] : W, V = X ? B : B - 1, re = P + V - D, J = r(
        p,
        V - 1,
        f,
        re - 1,
        $
      ), G = V - J;
      if (W = d[x], d[x] = G, k <= D && D <= K) {
        let ie = (h + (D - I)) / 2;
        if (ie <= b && G - 1 <= w[ie]) {
          let Z = re - J;
          if (S.nChangePreceding = h, h === G + Z - p - f ? (S.aEndPreceding = p, S.bEndPreceding = f) : (S.aEndPreceding = G, S.bEndPreceding = Z), S.nCommonPreceding = J, J !== 0 && (S.aCommonPreceding = G, S.bCommonPreceding = Z), S.nChangeFollowing = h - 1, h === 1)
            S.nCommonFollowing = 0, S.aStartFollowing = u, S.bStartFollowing = E;
          else {
            let q = P + B - (X ? D - 1 : D + 1), oe = n(
              B,
              u,
              q,
              E,
              $
            );
            S.nCommonFollowing = oe, oe !== 0 && (S.aCommonFollowing = B, S.bCommonFollowing = q);
            let he = B + oe, ue = q + oe;
            h - 1 === u + E - he - ue ? (S.aStartFollowing = u, S.bStartFollowing = E) : (S.aStartFollowing = he, S.bStartFollowing = ue);
          }
          return !0;
        }
      }
    }
    return !1;
  }, "extendOverlappablePathsR"), l = /* @__PURE__ */ s((h, p, u, f, E, $, w, b, d) => {
    let C = f - p, S = E - u, P = u - p, H = E - f, v = H - P, I = P, k = P;
    if (w[0] = p - 1, b[0] = u, v % 2 === 0) {
      let K = (h || v) / 2, W = (P + H) / 2;
      for (let L = 1; L <= W; L += 1)
        if (I = o(L, u, E, C, $, w, I), L < K)
          k = i(L, p, f, S, $, b, k);
        else if (
          // If a reverse path overlaps a forward path in the same diagonal,
          // return a division of the index intervals at the middle change.
          a(
            L,
            p,
            u,
            f,
            E,
            $,
            w,
            I,
            b,
            k,
            d
          )
        )
          return;
    } else {
      let K = ((h || v) + 1) / 2, W = (P + H + 1) / 2, L = 1;
      for (I = o(L, u, E, C, $, w, I), L += 1; L <= W; L += 1)
        if (k = i(
          L - 1,
          p,
          f,
          S,
          $,
          b,
          k
        ), L < K)
          I = o(L, u, E, C, $, w, I);
        else if (
          // If a forward path overlaps a reverse path in the same diagonal,
          // return a division of the index intervals at the middle change.
          c(
            L,
            p,
            u,
            f,
            E,
            $,
            w,
            I,
            b,
            k,
            d
          )
        )
          return;
    }
    throw new Error(
      `${e}: no overlap aStart=${p} aEnd=${u} bStart=${f} bEnd=${E}`
    );
  }, "divide"), m = /* @__PURE__ */ s((h, p, u, f, E, $, w, b, d, C) => {
    if (E - f < u - p) {
      if ($ = !$, $ && w.length === 1) {
        let { foundSubsequence: G, isCommon: ie } = w[0];
        w[1] = {
          foundSubsequence: /* @__PURE__ */ s((Z, q, oe) => {
            G(Z, oe, q);
          }, "foundSubsequence"),
          isCommon: /* @__PURE__ */ s((Z, q) => ie(q, Z), "isCommon")
        };
      }
      let re = p, J = u;
      p = f, u = E, f = re, E = J;
    }
    let { foundSubsequence: S, isCommon: P } = w[$ ? 1 : 0];
    l(
      h,
      p,
      u,
      f,
      E,
      P,
      b,
      d,
      C
    );
    let {
      nChangePreceding: H,
      aEndPreceding: v,
      bEndPreceding: I,
      nCommonPreceding: k,
      aCommonPreceding: K,
      bCommonPreceding: W,
      nCommonFollowing: L,
      aCommonFollowing: x,
      bCommonFollowing: D,
      nChangeFollowing: X,
      aStartFollowing: B,
      bStartFollowing: V
    } = C;
    p < v && f < I && m(
      H,
      p,
      v,
      f,
      I,
      $,
      w,
      b,
      d,
      C
    ), k !== 0 && S(k, K, W), L !== 0 && S(L, x, D), B < u && V < E && m(
      X,
      B,
      u,
      V,
      E,
      $,
      w,
      b,
      d,
      C
    );
  }, "findSubsequences"), g = /* @__PURE__ */ s((h, p) => {
    if (typeof p != "number")
      throw new TypeError(`${e}: ${h} typeof ${typeof p} is not a number`);
    if (!Number.isSafeInteger(p))
      throw new RangeError(`${e}: ${h} value ${p} is not a safe integer`);
    if (p < 0)
      throw new RangeError(`${e}: ${h} value ${p} is a negative integer`);
  }, "validateLength"), y = /* @__PURE__ */ s((h, p) => {
    let u = typeof p;
    if (u !== "function")
      throw new TypeError(`${e}: ${h} typeof ${u} is not a function`);
  }, "validateCallback");
  function T(h, p, u, f) {
    g("aLength", h), g("bLength", p), y("isCommon", u), y("foundSubsequence", f);
    let E = n(0, h, 0, p, u);
    if (E !== 0 && f(E, 0, 0), h !== E || p !== E) {
      let $ = E, w = E, b = r(
        $,
        h - 1,
        w,
        p - 1,
        u
      ), d = h - b, C = p - b, S = E + b;
      h !== S && p !== S && m(
        0,
        $,
        d,
        w,
        C,
        !1,
        [
          {
            foundSubsequence: f,
            isCommon: u
          }
        ],
        [t],
        [t],
        {
          aCommonFollowing: t,
          aCommonPreceding: t,
          aEndPreceding: t,
          aStartFollowing: t,
          bCommonFollowing: t,
          bCommonPreceding: t,
          bEndPreceding: t,
          bStartFollowing: t,
          nChangeFollowing: t,
          nChangePreceding: t,
          nCommonFollowing: t,
          nCommonPreceding: t
        }
      ), b !== 0 && f(b, d, C);
    }
  }
  return s(T, "diffSequence"), qe;
}
s(ii, "requireBuild");
var ci = ii(), Vn = wn(ci);
function si(e, t) {
  return e.replace(/\s+$/, (n) => t(n));
}
s(si, "formatTrailingSpaces");
function wt(e, t, n, r, o, i) {
  return e.length !== 0 ? n(`${r} ${si(e, o)}`) : r !== " " ? n(r) : t && i.length !== 0 ? n(`${r} ${i}`) : "";
}
s(wt, "printDiffLine");
function Jn(e, t, { aColor: n, aIndicator: r, changeLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: i }) {
  return wt(e, t, n, r, o, i);
}
s(Jn, "printDeleteLine");
function Gn(e, t, { bColor: n, bIndicator: r, changeLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: i }) {
  return wt(e, t, n, r, o, i);
}
s(Gn, "printInsertLine");
function Hn(e, t, { commonColor: n, commonIndicator: r, commonLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: i }) {
  return wt(e, t, n, r, o, i);
}
s(Hn, "printCommonLine");
function Ln(e, t, n, r, { patchColor: o }) {
  return o(`@@ -${e + 1},${t - e} +${n + 1},${r - n} @@`);
}
s(Ln, "createPatchMark");
function ui(e, t) {
  let n = e.length, r = t.contextLines, o = r + r, i = n, c = !1, a = 0, l = 0;
  for (; l !== n; ) {
    let b = l;
    for (; l !== n && e[l][0] === F; )
      l += 1;
    if (b !== l)
      if (b === 0)
        l > r && (i -= l - r, c = !0);
      else if (l === n) {
        let d = l - b;
        d > r && (i -= d - r, c = !0);
      } else {
        let d = l - b;
        d > o && (i -= d - o, a += 1);
      }
    for (; l !== n && e[l][0] !== F; )
      l += 1;
  }
  let m = a !== 0 || c;
  a !== 0 ? i += a + 1 : c && (i += 1);
  let g = i - 1, y = [], T = 0;
  m && y.push("");
  let h = 0, p = 0, u = 0, f = 0, E = /* @__PURE__ */ s((b) => {
    let d = y.length;
    y.push(Hn(b, d === 0 || d === g, t)), u += 1, f += 1;
  }, "pushCommonLine"), $ = /* @__PURE__ */ s((b) => {
    let d = y.length;
    y.push(Jn(b, d === 0 || d === g, t)), u += 1;
  }, "pushDeleteLine"), w = /* @__PURE__ */ s((b) => {
    let d = y.length;
    y.push(Gn(b, d === 0 || d === g, t)), f += 1;
  }, "pushInsertLine");
  for (l = 0; l !== n; ) {
    let b = l;
    for (; l !== n && e[l][0] === F; )
      l += 1;
    if (b !== l)
      if (b === 0) {
        l > r && (b = l - r, h = b, p = b, u = h, f = p);
        for (let d = b; d !== l; d += 1)
          E(e[d][1]);
      } else if (l === n) {
        let d = l - b > r ? b + r : l;
        for (let C = b; C !== d; C += 1)
          E(e[C][1]);
      } else {
        let d = l - b;
        if (d > o) {
          let C = b + r;
          for (let P = b; P !== C; P += 1)
            E(e[P][1]);
          y[T] = Ln(h, u, p, f, t), T = y.length, y.push("");
          let S = d - o;
          h = u + S, p = f + S, u = h, f = p;
          for (let P = l - r; P !== l; P += 1)
            E(e[P][1]);
        } else
          for (let C = b; C !== l; C += 1)
            E(e[C][1]);
      }
    for (; l !== n && e[l][0] === U; )
      $(e[l][1]), l += 1;
    for (; l !== n && e[l][0] === z; )
      w(e[l][1]), l += 1;
  }
  return m && (y[T] = Ln(h, u, p, f, t)), y.join(`
`);
}
s(ui, "joinAlignedDiffsNoExpand");
function li(e, t) {
  return e.map((n, r, o) => {
    let i = n[1], c = r === 0 || r === o.length - 1;
    switch (n[0]) {
      case U:
        return Jn(i, c, t);
      case z:
        return Gn(i, c, t);
      default:
        return Hn(i, c, t);
    }
  }).join(`
`);
}
s(li, "joinAlignedDiffsExpand");
var dt = /* @__PURE__ */ s((e) => e, "noColor"), Kn = 5, ai = 0;
function fi() {
  return {
    aAnnotation: "Expected",
    aColor: ee.green,
    aIndicator: "-",
    bAnnotation: "Received",
    bColor: ee.red,
    bIndicator: "+",
    changeColor: ee.inverse,
    changeLineTrailingSpaceColor: dt,
    commonColor: ee.dim,
    commonIndicator: " ",
    commonLineTrailingSpaceColor: dt,
    compareKeys: void 0,
    contextLines: Kn,
    emptyFirstOrLastLinePlaceholder: "",
    expand: !1,
    includeChangeCounts: !1,
    omitAnnotationLines: !1,
    patchColor: ee.yellow,
    printBasicPrototype: !1,
    truncateThreshold: ai,
    truncateAnnotation: "... Diff result is truncated",
    truncateAnnotationColor: dt
  };
}
s(fi, "getDefaultOptions");
function mi(e) {
  return e && typeof e == "function" ? e : void 0;
}
s(mi, "getCompareKeys");
function pi(e) {
  return typeof e == "number" && Number.isSafeInteger(e) && e >= 0 ? e : Kn;
}
s(pi, "getContextLines");
function ge(e = {}) {
  return {
    ...fi(),
    ...e,
    compareKeys: mi(e.compareKeys),
    contextLines: pi(e.contextLines)
  };
}
s(ge, "normalizeDiffOptions");
function be(e) {
  return e.length === 1 && e[0].length === 0;
}
s(be, "isEmptyString");
function gi(e) {
  let t = 0, n = 0;
  return e.forEach((r) => {
    switch (r[0]) {
      case U:
        t += 1;
        break;
      case z:
        n += 1;
        break;
    }
  }), {
    a: t,
    b: n
  };
}
s(gi, "countChanges");
function hi({ aAnnotation: e, aColor: t, aIndicator: n, bAnnotation: r, bColor: o, bIndicator: i, includeChangeCounts: c, omitAnnotationLines: a }, l) {
  if (a)
    return "";
  let m = "", g = "";
  if (c) {
    let h = String(l.a), p = String(l.b), u = r.length - e.length, f = " ".repeat(Math.max(0, u)), E = " ".repeat(Math.max(0, -u)), $ = p.length - h.length, w = " ".repeat(Math.max(0, $)), b = " ".repeat(Math.max(0, -$));
    m = `${f}  ${n} ${w}${h}`, g = `${E}  ${i} ${b}${p}`;
  }
  let y = `${n} ${e}${m}`, T = `${i} ${r}${g}`;
  return `${t(y)}
${o(T)}

`;
}
s(hi, "printAnnotation");
function Ot(e, t, n) {
  return hi(n, gi(e)) + (n.expand ? li(e, n) : ui(e, n)) + (t ? n.truncateAnnotationColor(`
${n.truncateAnnotation}`) : "");
}
s(Ot, "printDiffLines");
function Je(e, t, n) {
  let r = ge(n), [o, i] = Xn(be(e) ? [] : e, be(t) ? [] : t, r);
  return Ot(o, i, r);
}
s(Je, "diffLinesUnified");
function yi(e, t, n, r, o) {
  if (be(e) && be(n) && (e = [], n = []), be(t) && be(r) && (t = [], r = []), e.length !== n.length || t.length !== r.length)
    return Je(e, t, o);
  let [i, c] = Xn(n, r, o), a = 0, l = 0;
  return i.forEach((m) => {
    switch (m[0]) {
      case U:
        m[1] = e[a], a += 1;
        break;
      case z:
        m[1] = t[l], l += 1;
        break;
      default:
        m[1] = t[l], a += 1, l += 1;
    }
  }), Ot(i, c, ge(o));
}
s(yi, "diffLinesUnified2");
function Xn(e, t, n) {
  let r = n?.truncateThreshold ?? !1, o = Math.max(Math.floor(n?.truncateThreshold ?? 0), 0), i = r ? Math.min(e.length, o) : e.length, c = r ? Math.min(t.length, o) : t.length, a = i !== e.length || c !== t.length, l = /* @__PURE__ */ s((h, p) => e[h] === t[p], "isCommon"), m = [], g = 0, y = 0;
  for (Vn(i, c, l, /* @__PURE__ */ s((h, p, u) => {
    for (; g !== p; g += 1)
      m.push(new R(U, e[g]));
    for (; y !== u; y += 1)
      m.push(new R(z, t[y]));
    for (; h !== 0; h -= 1, g += 1, y += 1)
      m.push(new R(F, t[y]));
  }, "foundSubsequence")); g !== i; g += 1)
    m.push(new R(U, e[g]));
  for (; y !== c; y += 1)
    m.push(new R(z, t[y]));
  return [m, a];
}
s(Xn, "diffLinesRaw");
function In(e) {
  if (e === void 0)
    return "undefined";
  if (e === null)
    return "null";
  if (Array.isArray(e))
    return "array";
  if (typeof e == "boolean")
    return "boolean";
  if (typeof e == "function")
    return "function";
  if (typeof e == "number")
    return "number";
  if (typeof e == "string")
    return "string";
  if (typeof e == "bigint")
    return "bigint";
  if (typeof e == "object") {
    if (e != null) {
      if (e.constructor === RegExp)
        return "regexp";
      if (e.constructor === Map)
        return "map";
      if (e.constructor === Set)
        return "set";
      if (e.constructor === Date)
        return "date";
    }
    return "object";
  } else if (typeof e == "symbol")
    return "symbol";
  throw new Error(`value of unknown type: ${e}`);
}
s(In, "getType");
function Fn(e) {
  return e.includes(`\r
`) ? `\r
` : `
`;
}
s(Fn, "getNewLineSymbol");
function bi(e, t, n) {
  let r = n?.truncateThreshold ?? !1, o = Math.max(Math.floor(n?.truncateThreshold ?? 0), 0), i = e.length, c = t.length;
  if (r) {
    let h = e.includes(`
`), p = t.includes(`
`), u = Fn(e), f = Fn(t), E = h ? `${e.split(u, o).join(u)}
` : e, $ = p ? `${t.split(f, o).join(f)}
` : t;
    i = E.length, c = $.length;
  }
  let a = i !== e.length || c !== t.length, l = /* @__PURE__ */ s((h, p) => e[h] === t[p], "isCommon"), m = 0, g = 0, y = [];
  return Vn(i, c, l, /* @__PURE__ */ s((h, p, u) => {
    m !== p && y.push(new R(U, e.slice(m, p))), g !== u && y.push(new R(z, t.slice(g, u))), m = p + h, g = u + h, y.push(new R(F, t.slice(u, g)));
  }, "foundSubsequence")), m !== i && y.push(new R(U, e.slice(m))), g !== c && y.push(new R(z, t.slice(g))), [y, a];
}
s(bi, "diffStrings");
function Ei(e, t, n) {
  return t.reduce((r, o) => r + (o[0] === F ? o[1] : o[0] === e && o[1].length !== 0 ? n(o[1]) : ""), "");
}
s(Ei, "concatenateRelevantDiffs");
var Pt = class Pt {
  op;
  line;
  lines;
  changeColor;
  constructor(t, n) {
    this.op = t, this.line = [], this.lines = [], this.changeColor = n;
  }
  pushSubstring(t) {
    this.pushDiff(new R(this.op, t));
  }
  pushLine() {
    this.lines.push(this.line.length !== 1 ? new R(this.op, Ei(this.op, this.line, this.changeColor)) : this.line[0][0] === this.op ? this.line[0] : new R(this.op, this.line[0][1])), this.line.length = 0;
  }
  isLineEmpty() {
    return this.line.length === 0;
  }
  // Minor input to buffer.
  pushDiff(t) {
    this.line.push(t);
  }
  // Main input to buffer.
  align(t) {
    let n = t[1];
    if (n.includes(`
`)) {
      let r = n.split(`
`), o = r.length - 1;
      r.forEach((i, c) => {
        c < o ? (this.pushSubstring(i), this.pushLine()) : i.length !== 0 && this.pushSubstring(i);
      });
    } else
      this.pushDiff(t);
  }
  // Output from buffer.
  moveLinesTo(t) {
    this.isLineEmpty() || this.pushLine(), t.push(...this.lines), this.lines.length = 0;
  }
};
s(Pt, "ChangeBuffer");
var Ve = Pt, Nt = class Nt {
  deleteBuffer;
  insertBuffer;
  lines;
  constructor(t, n) {
    this.deleteBuffer = t, this.insertBuffer = n, this.lines = [];
  }
  pushDiffCommonLine(t) {
    this.lines.push(t);
  }
  pushDiffChangeLines(t) {
    let n = t[1].length === 0;
    (!n || this.deleteBuffer.isLineEmpty()) && this.deleteBuffer.pushDiff(t), (!n || this.insertBuffer.isLineEmpty()) && this.insertBuffer.pushDiff(t);
  }
  flushChangeLines() {
    this.deleteBuffer.moveLinesTo(this.lines), this.insertBuffer.moveLinesTo(this.lines);
  }
  // Input to buffer.
  align(t) {
    let n = t[0], r = t[1];
    if (r.includes(`
`)) {
      let o = r.split(`
`), i = o.length - 1;
      o.forEach((c, a) => {
        if (a === 0) {
          let l = new R(n, c);
          this.deleteBuffer.isLineEmpty() && this.insertBuffer.isLineEmpty() ? (this.flushChangeLines(), this.pushDiffCommonLine(l)) : (this.pushDiffChangeLines(l), this.flushChangeLines());
        } else a < i ? this.pushDiffCommonLine(new R(n, c)) : c.length !== 0 && this.pushDiffChangeLines(new R(n, c));
      });
    } else
      this.pushDiffChangeLines(t);
  }
  // Output from buffer.
  getLines() {
    return this.flushChangeLines(), this.lines;
  }
};
s(Nt, "CommonBuffer");
var $t = Nt;
function di(e, t) {
  let n = new Ve(U, t), r = new Ve(z, t), o = new $t(n, r);
  return e.forEach((i) => {
    switch (i[0]) {
      case U:
        n.align(i);
        break;
      case z:
        r.align(i);
        break;
      default:
        o.align(i);
    }
  }), o.getLines();
}
s(di, "getAlignedDiffs");
function Si(e, t) {
  if (t) {
    let n = e.length - 1;
    return e.some((r, o) => r[0] === F && (o !== n || r[1] !== `
`));
  }
  return e.some((n) => n[0] === F);
}
s(Si, "hasCommonDiff");
function $i(e, t, n) {
  if (e !== t && e.length !== 0 && t.length !== 0) {
    let r = e.includes(`
`) || t.includes(`
`), [o, i] = Zn(r ? `${e}
` : e, r ? `${t}
` : t, !0, n);
    if (Si(o, r)) {
      let c = ge(n), a = di(o, c.changeColor);
      return Ot(a, i, c);
    }
  }
  return Je(e.split(`
`), t.split(`
`), n);
}
s($i, "diffStringsUnified");
function Zn(e, t, n, r) {
  let [o, i] = bi(e, t, r);
  return n && ei(o), [o, i];
}
s(Zn, "diffStringsRaw");
function _t(e, t) {
  let { commonColor: n } = ge(t);
  return n(e);
}
s(_t, "getCommonMessage");
var { AsymmetricMatcher: _i, DOMCollection: Ti, DOMElement: Ci, Immutable: wi, ReactElement: Oi, ReactTestComponent: Ai } = $e, Qn = [
  Ai,
  Oi,
  Ci,
  Ti,
  wi,
  _i,
  $e.Error
], Tt = {
  maxDepth: 20,
  plugins: Qn
}, vn = {
  callToJSON: !1,
  maxDepth: 8,
  plugins: Qn
};
function Pi(e, t, n) {
  if (Object.is(e, t))
    return "";
  let r = In(e), o = r, i = !1;
  if (r === "object" && typeof e.asymmetricMatch == "function") {
    if (e.$$typeof !== Symbol.for("jest.asymmetricMatcher") || typeof e.getExpectedType != "function")
      return;
    o = e.getExpectedType(), i = o === "string";
  }
  if (o !== In(t)) {
    let f = function(w) {
      return w.length <= u ? w : `${w.slice(0, u)}...`;
    };
    s(f, "truncate");
    let { aAnnotation: c, aColor: a, aIndicator: l, bAnnotation: m, bColor: g, bIndicator: y } = ge(n), T = Ct(vn, n), h = Q(e, T), p = Q(t, T), u = 1e5;
    h = f(h), p = f(p);
    let E = `${a(`${l} ${c}:`)} 
${h}`, $ = `${g(`${y} ${m}:`)} 
${p}`;
    return `${E}

${$}`;
  }
  if (!i)
    switch (r) {
      case "string":
        return Je(e.split(`
`), t.split(`
`), n);
      case "boolean":
      case "number":
        return Ni(e, t, n);
      case "map":
        return St(xn(e), xn(t), n);
      case "set":
        return St(Dn(e), Dn(t), n);
      default:
        return St(e, t, n);
    }
}
s(Pi, "diff");
function Ni(e, t, n) {
  let r = Q(e, Tt), o = Q(t, Tt);
  return r === o ? "" : Je(r.split(`
`), o.split(`
`), n);
}
s(Ni, "comparePrimitive");
function xn(e) {
  return new Map(Array.from(e.entries()).sort());
}
s(xn, "sortMap");
function Dn(e) {
  return new Set(Array.from(e.values()).sort());
}
s(Dn, "sortSet");
function St(e, t, n) {
  let r, o = !1;
  try {
    let c = Ct(Tt, n);
    r = jn(e, t, c, n);
  } catch {
    o = !0;
  }
  let i = _t(qn, n);
  if (r === void 0 || r === i) {
    let c = Ct(vn, n);
    r = jn(e, t, c, n), r !== i && !o && (r = `${_t(oi, n)}

${r}`);
  }
  return r;
}
s(St, "compareObjects");
function Ct(e, t) {
  let { compareKeys: n, printBasicPrototype: r, maxDepth: o } = ge(t);
  return {
    ...e,
    compareKeys: n,
    printBasicPrototype: r,
    maxDepth: o ?? e.maxDepth
  };
}
s(Ct, "getFormatOptions");
function jn(e, t, n, r) {
  let o = {
    ...n,
    indent: 0
  }, i = Q(e, o), c = Q(t, o);
  if (i === c)
    return _t(qn, r);
  {
    let a = Q(e, n), l = Q(t, n);
    return yi(a.split(`
`), l.split(`
`), i.split(`
`), c.split(`
`), r);
  }
}
s(jn, "getObjectsDifference");
var Bn = 2e4;
function zn(e) {
  return Ue(e) === "Object" && typeof e.asymmetricMatch == "function";
}
s(zn, "isAsymmetricMatcher");
function kn(e, t) {
  let n = Ue(e), r = Ue(t);
  return n === r && (n === "Object" || n === "Array");
}
s(kn, "isReplaceable");
function er(e, t, n) {
  let { aAnnotation: r, bAnnotation: o } = ge(n);
  if (typeof t == "string" && typeof e == "string" && t.length > 0 && e.length > 0 && t.length <= Bn && e.length <= Bn && t !== e) {
    if (t.includes(`
`) || e.includes(`
`))
      return $i(t, e, n);
    let [g] = Zn(t, e, !0), y = g.some((u) => u[0] === F), T = Mi(r, o), h = T(r) + Ii(Yn(g, U, y)), p = T(o) + Li(Yn(g, z, y));
    return `${h}
${p}`;
  }
  let i = Et(t, { forceWritable: !0 }), c = Et(e, { forceWritable: !0 }), { replacedExpected: a, replacedActual: l } = tr(c, i);
  return Pi(a, l, n);
}
s(er, "printDiffOrStringify");
function tr(e, t, n = /* @__PURE__ */ new WeakSet(), r = /* @__PURE__ */ new WeakSet()) {
  return e instanceof Error && t instanceof Error && typeof e.cause < "u" && typeof t.cause > "u" ? (delete e.cause, {
    replacedActual: e,
    replacedExpected: t
  }) : kn(e, t) ? n.has(e) || r.has(t) ? {
    replacedActual: e,
    replacedExpected: t
  } : (n.add(e), r.add(t), bt(t).forEach((o) => {
    let i = t[o], c = e[o];
    if (zn(i))
      i.asymmetricMatch(c) && (e[o] = i);
    else if (zn(c))
      c.asymmetricMatch(i) && (t[o] = c);
    else if (kn(c, i)) {
      let a = tr(c, i, n, r);
      e[o] = a.replacedActual, t[o] = a.replacedExpected;
    }
  }), {
    replacedActual: e,
    replacedExpected: t
  }) : {
    replacedActual: e,
    replacedExpected: t
  };
}
s(tr, "replaceAsymmetricMatcher");
function Mi(...e) {
  let t = e.reduce((n, r) => r.length > n ? r.length : n, 0);
  return (n) => `${n}: ${" ".repeat(t - n.length)}`;
}
s(Mi, "getLabelPrinter");
var Ri = "\xB7";
function nr(e) {
  return e.replace(/\s+$/gm, (t) => Ri.repeat(t.length));
}
s(nr, "replaceTrailingSpaces");
function Li(e) {
  return ee.red(nr(pe(e)));
}
s(Li, "printReceived");
function Ii(e) {
  return ee.green(nr(pe(e)));
}
s(Ii, "printExpected");
function Yn(e, t, n) {
  return e.reduce((r, o) => r + (o[0] === F ? o[1] : o[0] === t ? n ? ee.inverse(o[1]) : o[1] : ""), "");
}
s(Yn, "getCommonAndChangedSubstrings");

// ../node_modules/@vitest/utils/dist/error.js
var Fi = "@@__IMMUTABLE_RECORD__@@", xi = "@@__IMMUTABLE_ITERABLE__@@";
function Di(e) {
  return e && (e[xi] || e[Fi]);
}
s(Di, "isImmutable");
var ji = Object.getPrototypeOf({});
function rr(e) {
  return e instanceof Error ? `<unserializable>: ${e.message}` : typeof e == "string" ? `<unserializable>: ${e}` : "<unserializable>";
}
s(rr, "getUnserializableMessage");
function ae(e, t = /* @__PURE__ */ new WeakMap()) {
  if (!e || typeof e == "string")
    return e;
  if (e instanceof Error && "toJSON" in e && typeof e.toJSON == "function") {
    let n = e.toJSON();
    return n && n !== e && typeof n == "object" && (typeof e.message == "string" && Ge(() => n.message ?? (n.message = e.message)), typeof e.stack == "string" && Ge(() => n.stack ?? (n.stack = e.stack)), typeof e.name == "string" && Ge(() => n.name ?? (n.name = e.name)), e.cause != null && Ge(() => n.cause ?? (n.cause = ae(e.cause, t)))), ae(n, t);
  }
  if (typeof e == "function")
    return `Function<${e.name || "anonymous"}>`;
  if (typeof e == "symbol")
    return e.toString();
  if (typeof e != "object")
    return e;
  if (typeof Buffer < "u" && e instanceof Buffer)
    return `<Buffer(${e.length}) ...>`;
  if (typeof Uint8Array < "u" && e instanceof Uint8Array)
    return `<Uint8Array(${e.length}) ...>`;
  if (Di(e))
    return ae(e.toJSON(), t);
  if (e instanceof Promise || e.constructor && e.constructor.prototype === "AsyncFunction")
    return "Promise";
  if (typeof Element < "u" && e instanceof Element)
    return e.tagName;
  if (typeof e.asymmetricMatch == "function")
    return `${e.toString()} ${Cn(e.sample)}`;
  if (typeof e.toJSON == "function")
    return ae(e.toJSON(), t);
  if (t.has(e))
    return t.get(e);
  if (Array.isArray(e)) {
    let n = new Array(e.length);
    return t.set(e, n), e.forEach((r, o) => {
      try {
        n[o] = ae(r, t);
      } catch (i) {
        n[o] = rr(i);
      }
    }), n;
  } else {
    let n = /* @__PURE__ */ Object.create(null);
    t.set(e, n);
    let r = e;
    for (; r && r !== ji; )
      Object.getOwnPropertyNames(r).forEach((o) => {
        if (!(o in n))
          try {
            n[o] = ae(e[o], t);
          } catch (i) {
            delete n[o], n[o] = rr(i);
          }
      }), r = Object.getPrototypeOf(r);
    return n;
  }
}
s(ae, "serializeValue");
function Ge(e) {
  try {
    return e();
  } catch {
  }
}
s(Ge, "safe");
function Bi(e) {
  return e.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
}
s(Bi, "normalizeErrorMessage");
function zi(e, t, n = /* @__PURE__ */ new WeakSet()) {
  if (!e || typeof e != "object")
    return { message: String(e) };
  let r = e;
  (r.showDiff || r.showDiff === void 0 && r.expected !== void 0 && r.actual !== void 0) && (r.diff = er(r.actual, r.expected, {
    ...t,
    ...r.diffOptions
  })), "expected" in r && typeof r.expected != "string" && (r.expected = pe(r.expected, 10)), "actual" in r && typeof r.actual != "string" && (r.actual = pe(r.actual, 10));
  try {
    typeof r.message == "string" && (r.message = Bi(r.message));
  } catch {
  }
  try {
    !n.has(r) && typeof r.cause == "object" && (n.add(r), r.cause = zi(r.cause, t, n));
  } catch {
  }
  try {
    return ae(r);
  } catch (o) {
    return ae(new Error(`Failed to fully serialize error: ${o?.message}
Inner error message: ${r?.message}`));
  }
}
s(zi, "processError");

export {
  ee as a,
  pe as b,
  wn as c,
  hs as d,
  ys as e,
  Ue as f,
  bs as g,
  Pi as h,
  er as i,
  zi as j
};
