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

// ../node_modules/tinyrainbow/dist/chunk-BVHSVHOK.js
var tr = {
  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]
}, Nt = Object.entries(tr);
function Ce(e) {
  return String(e);
}
c(Ce, "a");
Ce.open = "";
Ce.close = "";
var Fi = Nt.reduce(
  (e, [t]) => (e[t] = Ce, e),
  { isColorSupported: !1 }
);
function Mt(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;
}
c(Mt, "C");
function Rt(e = !1) {
  let t = Mt(e), n = /* @__PURE__ */ c((s, l, u, f) => {
    let p = "", h = 0;
    do
      p += s.substring(h, f) + u, h = f + l.length, f = s.indexOf(l, h);
    while (~f);
    return p + s.substring(h);
  }, "i"), r = /* @__PURE__ */ c((s, l, u = s) => {
    let f = /* @__PURE__ */ c((p) => {
      let h = String(p), w = h.indexOf(l, s.length);
      return ~w ? s + n(h, l, u, w) + l : s + h + l;
    }, "o");
    return f.open = s, f.close = l, f;
  }, "g"), o = {
    isColorSupported: t
  }, i = /* @__PURE__ */ c((s) => `\x1B[${s}m`, "d");
  for (let [s, l] of Nt)
    o[s] = t ? r(
      i(l[0]),
      i(l[1]),
      l[2]
    ) : Ce;
  return o;
}
c(Rt, "p");

// ../node_modules/tinyrainbow/dist/browser.js
var Q = Rt();

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

// ../node_modules/loupe/lib/helpers.js
var fn = {
  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"]
}, bo = {
  special: "cyan",
  number: "yellow",
  bigint: "yellow",
  boolean: "yellow",
  undefined: "grey",
  null: "bold",
  string: "green",
  symbol: "green",
  date: "magenta",
  regexp: "red"
}, oe = "\u2026";
function Eo(e, t) {
  let n = fn[bo[t]] || fn[t] || "";
  return n ? `\x1B[${n[0]}m${String(e)}\x1B[${n[1]}m` : String(e);
}
c(Eo, "colorise");
function mn({
  showHidden: e = !1,
  depth: t = 2,
  colors: n = !1,
  customInspect: r = !0,
  showProxy: o = !1,
  maxArrayLength: i = 1 / 0,
  breakLength: s = 1 / 0,
  seen: l = [],
  // eslint-disable-next-line no-shadow
  truncate: u = 1 / 0,
  stylize: f = String
} = {}, p) {
  let h = {
    showHidden: !!e,
    depth: Number(t),
    colors: !!n,
    customInspect: !!r,
    showProxy: !!o,
    maxArrayLength: Number(i),
    breakLength: Number(s),
    truncate: Number(u),
    seen: l,
    inspect: p,
    stylize: f
  };
  return h.colors && (h.stylize = Eo), h;
}
c(mn, "normaliseOptions");
function So(e) {
  return e >= "\uD800" && e <= "\uDBFF";
}
c(So, "isHighSurrogate");
function z(e, t, n = oe) {
  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 && So(e[i - 1]) && (i = i - 1), `${e.slice(0, i)}${n}`;
  }
  return e;
}
c(z, "truncate");
function x(e, t, n, r = ", ") {
  n = n || t.inspect;
  let o = e.length;
  if (o === 0)
    return "";
  let i = t.truncate, s = "", l = "", u = "";
  for (let f = 0; f < o; f += 1) {
    let p = f + 1 === e.length, h = f + 2 === e.length;
    u = `${oe}(${e.length - f})`;
    let w = e[f];
    t.truncate = i - s.length - (p ? 0 : r.length);
    let m = l || n(w, t) + (p ? "" : r), g = s.length + m.length, a = g + u.length;
    if (p && g > i && s.length + u.length <= i || !p && !h && a > i || (l = p ? "" : n(e[f + 1], t) + (h ? "" : r), !p && h && a > i && g + l.length > i))
      break;
    if (s += m, !p && !h && g + l.length >= i) {
      u = `${oe}(${e.length - f - 1})`;
      break;
    }
    u = "";
  }
  return `${s}${u}`;
}
c(x, "inspectList");
function $o(e) {
  return e.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/) ? e : JSON.stringify(e).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
}
c($o, "quoteComplexKey");
function ie([e, t], n) {
  return n.truncate -= 2, typeof e == "string" ? e = $o(e) : typeof e != "number" && (e = `[${n.inspect(e, n)}]`), n.truncate -= e.length, t = n.inspect(t, n), `${e}: ${t}`;
}
c(ie, "inspectProperty");

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

// ../node_modules/loupe/lib/typedarray.js
var _o = /* @__PURE__ */ c((e) => typeof Buffer == "function" && e instanceof Buffer ? "Buffer" : e[Symbol.toStringTag] ? e[Symbol.toStringTag] : e.constructor.name, "getArrayName");
function ee(e, t) {
  let n = _o(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 s = 0; s < e.length; s++) {
    let l = `${t.stylize(z(e[s], t.truncate), "number")}${s === e.length - 1 ? "" : ", "}`;
    if (t.truncate -= l.length, e[s] !== e.length && t.truncate <= 3) {
      o += `${oe}(${e.length - e[s] + 1})`;
      break;
    }
    o += l;
  }
  let i = "";
  return r.length && (i = x(r.map((s) => [s, e[s]]), t, ie)), `${n}[ ${o}${i ? `, ${i}` : ""} ]`;
}
c(ee, "inspectTypedArray");

// ../node_modules/loupe/lib/date.js
function ot(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${z(r[1], t.truncate - o.length - 1)}`, "date");
}
c(ot, "inspectDate");

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

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

// ../node_modules/loupe/lib/number.js
var wo = Number.isNaN || ((e) => e !== e);
function Re(e, t) {
  return wo(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(z(String(e), t.truncate), "number");
}
c(Re, "inspectNumber");

// ../node_modules/loupe/lib/bigint.js
function Le(e, t) {
  let n = z(e.toString(), t.truncate - 1);
  return n !== oe && (n += "n"), t.stylize(n, "bigint");
}
c(Le, "inspectBigInt");

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

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

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

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

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

// ../node_modules/loupe/lib/object.js
function ae(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 = x(n.map((l) => [l, e[l]]), t, ie), i = x(r.map((l) => [l, e[l]]), t, ie);
  t.seen.pop();
  let s = "";
  return o && i && (s = ", "), `{ ${o}${s}${i} }`;
}
c(ae, "inspectObject");

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

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

// ../node_modules/loupe/lib/error.js
var Ro = [
  "stack",
  "line",
  "column",
  "name",
  "message",
  "fileName",
  "lineNumber",
  "columnNumber",
  "number",
  "description",
  "cause"
];
function ft(e, t) {
  let n = Object.getOwnPropertyNames(e).filter((s) => Ro.indexOf(s) === -1), r = e.name;
  t.truncate -= r.length;
  let o = "";
  if (typeof e.message == "string" ? o = z(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 = x(n.map((s) => [s, e[s]]), t, ie);
  return `${r}${o}${i ? ` { ${i} }` : ""}`;
}
c(ft, "inspectObject");

// ../node_modules/loupe/lib/html.js
function Lo([e, t], n) {
  return n.truncate -= 3, t ? `${n.stylize(String(e), "yellow")}=${n.stylize(`"${t}"`, "string")}` : `${n.stylize(String(e), "yellow")}`;
}
c(Lo, "inspectAttribute");
function xe(e, t) {
  return x(e, t, Io, `
`);
}
c(xe, "inspectNodeCollection");
function Io(e, t) {
  switch (e.nodeType) {
    case 1:
      return De(e, t);
    case 3:
      return t.inspect(e.data, t);
    default:
      return t.inspect(e, t);
  }
}
c(Io, "inspectNode");
function De(e, t) {
  let n = e.getAttributeNames(), r = e.tagName.toLowerCase(), o = t.stylize(`<${r}`, "special"), i = t.stylize(">", "special"), s = t.stylize(`</${r}>`, "special");
  t.truncate -= r.length * 2 + 5;
  let l = "";
  n.length > 0 && (l += " ", l += x(n.map((p) => [p, e.getAttribute(p)]), t, Lo, " ")), t.truncate -= l.length;
  let u = t.truncate, f = xe(e.children, t);
  return f && f.length > u && (f = `${oe}(${e.children.length})`), `${o}${l}${i}${f}${s}`;
}
c(De, "inspectHTML");

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

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

// ../node_modules/@vitest/utils/dist/helpers.js
function ls(e, t, n) {
  let r = typeof e;
  if (!n.includes(r))
    throw new TypeError(`${t} value must be ${n.join(" or ")}, received "${r}"`);
}
c(ls, "assertTypes");
function as(e) {
  return e != null && typeof e == "object" && !Array.isArray(e);
}
c(as, "isObject");
function Vo(e) {
  return e === Object.prototype || e === Function.prototype || e === RegExp.prototype;
}
c(Vo, "isFinalObj");
function Be(e) {
  return Object.prototype.toString.apply(e).slice(8, -1);
}
c(Be, "getType");
function Jo(e, t) {
  let n = typeof t == "function" ? t : (r) => t.add(r);
  Object.getOwnPropertyNames(e).forEach(n), Object.getOwnPropertySymbols(e).forEach(n);
}
c(Jo, "collectOwnProperties");
function ht(e) {
  let t = /* @__PURE__ */ new Set();
  return Vo(e) ? [] : (Jo(e, t), Array.from(t));
}
c(ht, "getOwnProperties");
var _n = { forceWritable: !1 };
function yt(e, t = _n) {
  return gt(e, /* @__PURE__ */ new WeakMap(), t);
}
c(yt, "deepClone");
function gt(e, t, n = _n) {
  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] = gt(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 = ht(e);
    for (let s of i) {
      let l = Object.getOwnPropertyDescriptor(e, s);
      if (!l)
        continue;
      let u = gt(e[s], t, n);
      n.forceWritable ? Object.defineProperty(o, s, {
        enumerable: l.enumerable,
        configurable: !0,
        writable: !0,
        value: u
      }) : "get" in l ? Object.defineProperty(o, s, {
        ...l,
        get() {
          return u;
        }
      }) : Object.defineProperty(o, s, {
        ...l,
        value: u
      });
    }
    return o;
  }
  return e;
}
c(gt, "clone");
function fs() {
}
c(fs, "noop");

// ../node_modules/@vitest/utils/dist/diff.js
var k = -1, j = 1, L = 0, wt = class wt {
  0;
  1;
  constructor(t, n) {
    this[0] = t, this[1] = n;
  }
};
c(wt, "Diff");
var N = wt;
function Go(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;
}
c(Go, "diff_commonPrefix");
function Bn(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;
}
c(Bn, "diff_commonSuffix");
function Tn(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, s = 1;
  for (; ; ) {
    let l = e.substring(o - s), u = t.indexOf(l);
    if (u === -1)
      return i;
    s += u, (u === 0 || e.substring(o - s) === t.substring(0, s)) && (i = s, s++);
  }
}
c(Tn, "diff_commonOverlap_");
function Ho(e) {
  let t = !1, n = [], r = 0, o = null, i = 0, s = 0, l = 0, u = 0, f = 0;
  for (; i < e.length; )
    e[i][0] === L ? (n[r++] = i, s = u, l = f, u = 0, f = 0, o = e[i][1]) : (e[i][0] === j ? u += e[i][1].length : f += e[i][1].length, o && o.length <= Math.max(s, l) && o.length <= Math.max(u, f) && (e.splice(n[r - 1], 0, new N(k, o)), e[n[r - 1] + 1][0] = j, r--, r--, i = r > 0 ? n[r - 1] : -1, s = 0, l = 0, u = 0, f = 0, o = null, t = !0)), i++;
  for (t && zn(e), Zo(e), i = 1; i < e.length; ) {
    if (e[i - 1][0] === k && e[i][0] === j) {
      let p = e[i - 1][1], h = e[i][1], w = Tn(p, h), m = Tn(h, p);
      w >= m ? (w >= p.length / 2 || w >= h.length / 2) && (e.splice(i, 0, new N(L, h.substring(0, w))), e[i - 1][1] = p.substring(0, p.length - w), e[i + 1][1] = h.substring(w), i++) : (m >= p.length / 2 || m >= h.length / 2) && (e.splice(i, 0, new N(L, p.substring(0, m))), e[i - 1][0] = j, e[i - 1][1] = h.substring(0, h.length - m), e[i + 1][0] = k, e[i + 1][1] = p.substring(m), i++), i++;
    }
    i++;
  }
}
c(Ho, "diff_cleanupSemantic");
var Cn = /[^a-z0-9]/i, wn = /\s/, On = /[\r\n]/, Ko = /\n\r?\n$/, Xo = /^\r?\n\r?\n/;
function Zo(e) {
  let t = 1;
  for (; t < e.length - 1; ) {
    if (e[t - 1][0] === L && e[t + 1][0] === L) {
      let n = e[t - 1][1], r = e[t][1], o = e[t + 1][1], i = Bn(n, r);
      if (i) {
        let p = r.substring(r.length - i);
        n = n.substring(0, n.length - i), r = p + r.substring(0, r.length - i), o = p + o;
      }
      let s = n, l = r, u = o, f = ze(n, r) + ze(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 p = ze(n, r) + ze(r, o);
        p >= f && (f = p, s = n, l = r, u = o);
      }
      e[t - 1][1] !== s && (s ? e[t - 1][1] = s : (e.splice(t - 1, 1), t--), e[t][1] = l, u ? e[t + 1][1] = u : (e.splice(t + 1, 1), t--));
    }
    t++;
  }
}
c(Zo, "diff_cleanupSemanticLossless");
function zn(e) {
  e.push(new N(L, ""));
  let t = 0, n = 0, r = 0, o = "", i = "", s;
  for (; t < e.length; )
    switch (e[t][0]) {
      case j:
        r++, i += e[t][1], t++;
        break;
      case k:
        n++, o += e[t][1], t++;
        break;
      case L:
        n + r > 1 ? (n !== 0 && r !== 0 && (s = Go(i, o), s !== 0 && (t - n - r > 0 && e[t - n - r - 1][0] === L ? e[t - n - r - 1][1] += i.substring(0, s) : (e.splice(0, 0, new N(L, i.substring(0, s))), t++), i = i.substring(s), o = o.substring(s)), s = Bn(i, o), s !== 0 && (e[t][1] = i.substring(i.length - s) + e[t][1], i = i.substring(0, i.length - s), o = o.substring(0, o.length - s))), t -= n + r, e.splice(t, n + r), o.length && (e.splice(t, 0, new N(k, o)), t++), i.length && (e.splice(t, 0, new N(j, i)), t++), t++) : t !== 0 && e[t - 1][0] === L ? (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 l = !1;
  for (t = 1; t < e.length - 1; )
    e[t - 1][0] === L && e[t + 1][0] === L && (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), l = !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), l = !0)), t++;
  l && zn(e);
}
c(zn, "diff_cleanupMerge");
function ze(e, t) {
  if (!e || !t)
    return 6;
  let n = e.charAt(e.length - 1), r = t.charAt(0), o = n.match(Cn), i = r.match(Cn), s = o && n.match(wn), l = i && r.match(wn), u = s && n.match(On), f = l && r.match(On), p = u && e.match(Ko), h = f && t.match(Xo);
  return p || h ? 5 : u || f ? 4 : o && !s && l ? 3 : s || l ? 2 : o || i ? 1 : 0;
}
c(ze, "diff_cleanupSemanticScore_");
var kn = "Compared values have no visual difference.", Qo = "Compared values serialize to the same structure.\nPrinting internal object structure without calling `toJSON` instead.", ke = {}, An;
function vo() {
  if (An) return ke;
  An = 1, Object.defineProperty(ke, "__esModule", {
    value: !0
  }), ke.default = w;
  let e = "diff-sequences", t = 0, n = /* @__PURE__ */ c((m, g, a, b, d) => {
    let $ = 0;
    for (; m < g && a < b && d(m, a); )
      m += 1, a += 1, $ += 1;
    return $;
  }, "countCommonItemsF"), r = /* @__PURE__ */ c((m, g, a, b, d) => {
    let $ = 0;
    for (; m <= g && a <= b && d(g, b); )
      g -= 1, b -= 1, $ += 1;
    return $;
  }, "countCommonItemsR"), o = /* @__PURE__ */ c((m, g, a, b, d, $, C) => {
    let y = 0, E = -m, T = $[y], S = T;
    $[y] += n(
      T + 1,
      g,
      b + T - E + 1,
      a,
      d
    );
    let A = m < C ? m : C;
    for (y += 1, E += 2; y <= A; y += 1, E += 2) {
      if (y !== m && S < $[y])
        T = $[y];
      else if (T = S + 1, g <= T)
        return y - 1;
      S = $[y], $[y] = T + n(T + 1, g, b + T - E + 1, a, d);
    }
    return C;
  }, "extendPathsF"), i = /* @__PURE__ */ c((m, g, a, b, d, $, C) => {
    let y = 0, E = m, T = $[y], S = T;
    $[y] -= r(
      g,
      T - 1,
      a,
      b + T - E - 1,
      d
    );
    let A = m < C ? m : C;
    for (y += 1, E -= 2; y <= A; y += 1, E -= 2) {
      if (y !== m && $[y] < S)
        T = $[y];
      else if (T = S - 1, T < g)
        return y - 1;
      S = $[y], $[y] = T - r(
        g,
        T - 1,
        a,
        b + T - E - 1,
        d
      );
    }
    return C;
  }, "extendPathsR"), s = /* @__PURE__ */ c((m, g, a, b, d, $, C, y, E, T, S) => {
    let A = b - g, J = a - g, R = d - b - J, B = -R - (m - 1), G = -R + (m - 1), Y = t, M = m < y ? m : y;
    for (let I = 0, F = -m; I <= M; I += 1, F += 2) {
      let H = I === 0 || I !== m && Y < C[I], D = H ? C[I] : Y, q = H ? D : D + 1, te = A + q - F, W = n(
        q + 1,
        a,
        te + 1,
        d,
        $
      ), V = q + W;
      if (Y = C[I], C[I] = V, B <= F && F <= G) {
        let re = (m - 1 - (F + R)) / 2;
        if (re <= T && E[re] - 1 <= V) {
          let K = A + D - (H ? F + 1 : F - 1), U = r(
            g,
            D,
            b,
            K,
            $
          ), ne = D - U, pe = K - U, ce = ne + 1, ye = pe + 1;
          S.nChangePreceding = m - 1, m - 1 === ce + ye - g - b ? (S.aEndPreceding = g, S.bEndPreceding = b) : (S.aEndPreceding = ce, S.bEndPreceding = ye), S.nCommonPreceding = U, U !== 0 && (S.aCommonPreceding = ce, S.bCommonPreceding = ye), S.nCommonFollowing = W, W !== 0 && (S.aCommonFollowing = q + 1, S.bCommonFollowing = te + 1);
          let $e = V + 1, _e = te + W + 1;
          return S.nChangeFollowing = m - 1, m - 1 === a + d - $e - _e ? (S.aStartFollowing = a, S.bStartFollowing = d) : (S.aStartFollowing = $e, S.bStartFollowing = _e), !0;
        }
      }
    }
    return !1;
  }, "extendOverlappablePathsF"), l = /* @__PURE__ */ c((m, g, a, b, d, $, C, y, E, T, S) => {
    let A = d - a, J = a - g, R = d - b - J, B = R - m, G = R + m, Y = t, M = m < T ? m : T;
    for (let I = 0, F = m; I <= M; I += 1, F -= 2) {
      let H = I === 0 || I !== m && E[I] < Y, D = H ? E[I] : Y, q = H ? D : D - 1, te = A + q - F, W = r(
        g,
        q - 1,
        b,
        te - 1,
        $
      ), V = q - W;
      if (Y = E[I], E[I] = V, B <= F && F <= G) {
        let re = (m + (F - R)) / 2;
        if (re <= y && V - 1 <= C[re]) {
          let K = te - W;
          if (S.nChangePreceding = m, m === V + K - g - b ? (S.aEndPreceding = g, S.bEndPreceding = b) : (S.aEndPreceding = V, S.bEndPreceding = K), S.nCommonPreceding = W, W !== 0 && (S.aCommonPreceding = V, S.bCommonPreceding = K), S.nChangeFollowing = m - 1, m === 1)
            S.nCommonFollowing = 0, S.aStartFollowing = a, S.bStartFollowing = d;
          else {
            let U = A + D - (H ? F - 1 : F + 1), ne = n(
              D,
              a,
              U,
              d,
              $
            );
            S.nCommonFollowing = ne, ne !== 0 && (S.aCommonFollowing = D, S.bCommonFollowing = U);
            let pe = D + ne, ce = U + ne;
            m - 1 === a + d - pe - ce ? (S.aStartFollowing = a, S.bStartFollowing = d) : (S.aStartFollowing = pe, S.bStartFollowing = ce);
          }
          return !0;
        }
      }
    }
    return !1;
  }, "extendOverlappablePathsR"), u = /* @__PURE__ */ c((m, g, a, b, d, $, C, y, E) => {
    let T = b - g, S = d - a, A = a - g, J = d - b, Z = J - A, R = A, B = A;
    if (C[0] = g - 1, y[0] = a, Z % 2 === 0) {
      let G = (m || Z) / 2, Y = (A + J) / 2;
      for (let M = 1; M <= Y; M += 1)
        if (R = o(M, a, d, T, $, C, R), M < G)
          B = i(M, g, b, S, $, y, B);
        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.
          l(
            M,
            g,
            a,
            b,
            d,
            $,
            C,
            R,
            y,
            B,
            E
          )
        )
          return;
    } else {
      let G = ((m || Z) + 1) / 2, Y = (A + J + 1) / 2, M = 1;
      for (R = o(M, a, d, T, $, C, R), M += 1; M <= Y; M += 1)
        if (B = i(
          M - 1,
          g,
          b,
          S,
          $,
          y,
          B
        ), M < G)
          R = o(M, a, d, T, $, C, R);
        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.
          s(
            M,
            g,
            a,
            b,
            d,
            $,
            C,
            R,
            y,
            B,
            E
          )
        )
          return;
    }
    throw new Error(
      `${e}: no overlap aStart=${g} aEnd=${a} bStart=${b} bEnd=${d}`
    );
  }, "divide"), f = /* @__PURE__ */ c((m, g, a, b, d, $, C, y, E, T) => {
    if (d - b < a - g) {
      if ($ = !$, $ && C.length === 1) {
        let { foundSubsequence: V, isCommon: re } = C[0];
        C[1] = {
          foundSubsequence: /* @__PURE__ */ c((K, U, ne) => {
            V(K, ne, U);
          }, "foundSubsequence"),
          isCommon: /* @__PURE__ */ c((K, U) => re(U, K), "isCommon")
        };
      }
      let te = g, W = a;
      g = b, a = d, b = te, d = W;
    }
    let { foundSubsequence: S, isCommon: A } = C[$ ? 1 : 0];
    u(
      m,
      g,
      a,
      b,
      d,
      A,
      y,
      E,
      T
    );
    let {
      nChangePreceding: J,
      aEndPreceding: Z,
      bEndPreceding: R,
      nCommonPreceding: B,
      aCommonPreceding: G,
      bCommonPreceding: Y,
      nCommonFollowing: M,
      aCommonFollowing: I,
      bCommonFollowing: F,
      nChangeFollowing: H,
      aStartFollowing: D,
      bStartFollowing: q
    } = T;
    g < Z && b < R && f(
      J,
      g,
      Z,
      b,
      R,
      $,
      C,
      y,
      E,
      T
    ), B !== 0 && S(B, G, Y), M !== 0 && S(M, I, F), D < a && q < d && f(
      H,
      D,
      a,
      q,
      d,
      $,
      C,
      y,
      E,
      T
    );
  }, "findSubsequences"), p = /* @__PURE__ */ c((m, g) => {
    if (typeof g != "number")
      throw new TypeError(`${e}: ${m} typeof ${typeof g} is not a number`);
    if (!Number.isSafeInteger(g))
      throw new RangeError(`${e}: ${m} value ${g} is not a safe integer`);
    if (g < 0)
      throw new RangeError(`${e}: ${m} value ${g} is a negative integer`);
  }, "validateLength"), h = /* @__PURE__ */ c((m, g) => {
    let a = typeof g;
    if (a !== "function")
      throw new TypeError(`${e}: ${m} typeof ${a} is not a function`);
  }, "validateCallback");
  function w(m, g, a, b) {
    p("aLength", m), p("bLength", g), h("isCommon", a), h("foundSubsequence", b);
    let d = n(0, m, 0, g, a);
    if (d !== 0 && b(d, 0, 0), m !== d || g !== d) {
      let $ = d, C = d, y = r(
        $,
        m - 1,
        C,
        g - 1,
        a
      ), E = m - y, T = g - y, S = d + y;
      m !== S && g !== S && f(
        0,
        $,
        E,
        C,
        T,
        !1,
        [
          {
            foundSubsequence: b,
            isCommon: a
          }
        ],
        [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
        }
      ), y !== 0 && b(y, E, T);
    }
  }
  return c(w, "diffSequence"), ke;
}
c(vo, "requireBuild");
var ei = vo(), Yn = $n(ei);
function ti(e, t) {
  return e.replace(/\s+$/, (n) => t(n));
}
c(ti, "formatTrailingSpaces");
function Tt(e, t, n, r, o, i) {
  return e.length !== 0 ? n(`${r} ${ti(e, o)}`) : r !== " " ? n(r) : t && i.length !== 0 ? n(`${r} ${i}`) : "";
}
c(Tt, "printDiffLine");
function Un(e, t, { aColor: n, aIndicator: r, changeLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: i }) {
  return Tt(e, t, n, r, o, i);
}
c(Un, "printDeleteLine");
function qn(e, t, { bColor: n, bIndicator: r, changeLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: i }) {
  return Tt(e, t, n, r, o, i);
}
c(qn, "printInsertLine");
function Wn(e, t, { commonColor: n, commonIndicator: r, commonLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: i }) {
  return Tt(e, t, n, r, o, i);
}
c(Wn, "printCommonLine");
function Pn(e, t, n, r, { patchColor: o }) {
  return o(`@@ -${e + 1},${t - e} +${n + 1},${r - n} @@`);
}
c(Pn, "createPatchMark");
function ni(e, t) {
  let n = e.length, r = t.contextLines, o = r + r, i = n, s = !1, l = 0, u = 0;
  for (; u !== n; ) {
    let y = u;
    for (; u !== n && e[u][0] === L; )
      u += 1;
    if (y !== u)
      if (y === 0)
        u > r && (i -= u - r, s = !0);
      else if (u === n) {
        let E = u - y;
        E > r && (i -= E - r, s = !0);
      } else {
        let E = u - y;
        E > o && (i -= E - o, l += 1);
      }
    for (; u !== n && e[u][0] !== L; )
      u += 1;
  }
  let f = l !== 0 || s;
  l !== 0 ? i += l + 1 : s && (i += 1);
  let p = i - 1, h = [], w = 0;
  f && h.push("");
  let m = 0, g = 0, a = 0, b = 0, d = /* @__PURE__ */ c((y) => {
    let E = h.length;
    h.push(Wn(y, E === 0 || E === p, t)), a += 1, b += 1;
  }, "pushCommonLine"), $ = /* @__PURE__ */ c((y) => {
    let E = h.length;
    h.push(Un(y, E === 0 || E === p, t)), a += 1;
  }, "pushDeleteLine"), C = /* @__PURE__ */ c((y) => {
    let E = h.length;
    h.push(qn(y, E === 0 || E === p, t)), b += 1;
  }, "pushInsertLine");
  for (u = 0; u !== n; ) {
    let y = u;
    for (; u !== n && e[u][0] === L; )
      u += 1;
    if (y !== u)
      if (y === 0) {
        u > r && (y = u - r, m = y, g = y, a = m, b = g);
        for (let E = y; E !== u; E += 1)
          d(e[E][1]);
      } else if (u === n) {
        let E = u - y > r ? y + r : u;
        for (let T = y; T !== E; T += 1)
          d(e[T][1]);
      } else {
        let E = u - y;
        if (E > o) {
          let T = y + r;
          for (let A = y; A !== T; A += 1)
            d(e[A][1]);
          h[w] = Pn(m, a, g, b, t), w = h.length, h.push("");
          let S = E - o;
          m = a + S, g = b + S, a = m, b = g;
          for (let A = u - r; A !== u; A += 1)
            d(e[A][1]);
        } else
          for (let T = y; T !== u; T += 1)
            d(e[T][1]);
      }
    for (; u !== n && e[u][0] === k; )
      $(e[u][1]), u += 1;
    for (; u !== n && e[u][0] === j; )
      C(e[u][1]), u += 1;
  }
  return f && (h[w] = Pn(m, a, g, b, t)), h.join(`
`);
}
c(ni, "joinAlignedDiffsNoExpand");
function ri(e, t) {
  return e.map((n, r, o) => {
    let i = n[1], s = r === 0 || r === o.length - 1;
    switch (n[0]) {
      case k:
        return Un(i, s, t);
      case j:
        return qn(i, s, t);
      default:
        return Wn(i, s, t);
    }
  }).join(`
`);
}
c(ri, "joinAlignedDiffsExpand");
var bt = /* @__PURE__ */ c((e) => e, "noColor"), Vn = 5, oi = 0;
function ii() {
  return {
    aAnnotation: "Expected",
    aColor: Q.green,
    aIndicator: "-",
    bAnnotation: "Received",
    bColor: Q.red,
    bIndicator: "+",
    changeColor: Q.inverse,
    changeLineTrailingSpaceColor: bt,
    commonColor: Q.dim,
    commonIndicator: " ",
    commonLineTrailingSpaceColor: bt,
    compareKeys: void 0,
    contextLines: Vn,
    emptyFirstOrLastLinePlaceholder: "",
    expand: !1,
    includeChangeCounts: !1,
    omitAnnotationLines: !1,
    patchColor: Q.yellow,
    printBasicPrototype: !1,
    truncateThreshold: oi,
    truncateAnnotation: "... Diff result is truncated",
    truncateAnnotationColor: bt
  };
}
c(ii, "getDefaultOptions");
function ci(e) {
  return e && typeof e == "function" ? e : void 0;
}
c(ci, "getCompareKeys");
function si(e) {
  return typeof e == "number" && Number.isSafeInteger(e) && e >= 0 ? e : Vn;
}
c(si, "getContextLines");
function me(e = {}) {
  return {
    ...ii(),
    ...e,
    compareKeys: ci(e.compareKeys),
    contextLines: si(e.contextLines)
  };
}
c(me, "normalizeDiffOptions");
function he(e) {
  return e.length === 1 && e[0].length === 0;
}
c(he, "isEmptyString");
function ui(e) {
  let t = 0, n = 0;
  return e.forEach((r) => {
    switch (r[0]) {
      case k:
        t += 1;
        break;
      case j:
        n += 1;
        break;
    }
  }), {
    a: t,
    b: n
  };
}
c(ui, "countChanges");
function li({ aAnnotation: e, aColor: t, aIndicator: n, bAnnotation: r, bColor: o, bIndicator: i, includeChangeCounts: s, omitAnnotationLines: l }, u) {
  if (l)
    return "";
  let f = "", p = "";
  if (s) {
    let m = String(u.a), g = String(u.b), a = r.length - e.length, b = " ".repeat(Math.max(0, a)), d = " ".repeat(Math.max(0, -a)), $ = g.length - m.length, C = " ".repeat(Math.max(0, $)), y = " ".repeat(Math.max(0, -$));
    f = `${b}  ${n} ${C}${m}`, p = `${d}  ${i} ${y}${g}`;
  }
  let h = `${n} ${e}${f}`, w = `${i} ${r}${p}`;
  return `${t(h)}
${o(w)}

`;
}
c(li, "printAnnotation");
function Ct(e, t, n) {
  return li(n, ui(e)) + (n.expand ? ri(e, n) : ni(e, n)) + (t ? n.truncateAnnotationColor(`
${n.truncateAnnotation}`) : "");
}
c(Ct, "printDiffLines");
function Ue(e, t, n) {
  let r = me(n), [o, i] = Jn(he(e) ? [] : e, he(t) ? [] : t, r);
  return Ct(o, i, r);
}
c(Ue, "diffLinesUnified");
function ai(e, t, n, r, o) {
  if (he(e) && he(n) && (e = [], n = []), he(t) && he(r) && (t = [], r = []), e.length !== n.length || t.length !== r.length)
    return Ue(e, t, o);
  let [i, s] = Jn(n, r, o), l = 0, u = 0;
  return i.forEach((f) => {
    switch (f[0]) {
      case k:
        f[1] = e[l], l += 1;
        break;
      case j:
        f[1] = t[u], u += 1;
        break;
      default:
        f[1] = t[u], l += 1, u += 1;
    }
  }), Ct(i, s, me(o));
}
c(ai, "diffLinesUnified2");
function Jn(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, s = r ? Math.min(t.length, o) : t.length, l = i !== e.length || s !== t.length, u = /* @__PURE__ */ c((m, g) => e[m] === t[g], "isCommon"), f = [], p = 0, h = 0;
  for (Yn(i, s, u, /* @__PURE__ */ c((m, g, a) => {
    for (; p !== g; p += 1)
      f.push(new N(k, e[p]));
    for (; h !== a; h += 1)
      f.push(new N(j, t[h]));
    for (; m !== 0; m -= 1, p += 1, h += 1)
      f.push(new N(L, t[h]));
  }, "foundSubsequence")); p !== i; p += 1)
    f.push(new N(k, e[p]));
  for (; h !== s; h += 1)
    f.push(new N(j, t[h]));
  return [f, l];
}
c(Jn, "diffLinesRaw");
function Nn(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}`);
}
c(Nn, "getType");
function Mn(e) {
  return e.includes(`\r
`) ? `\r
` : `
`;
}
c(Mn, "getNewLineSymbol");
function fi(e, t, n) {
  let r = n?.truncateThreshold ?? !1, o = Math.max(Math.floor(n?.truncateThreshold ?? 0), 0), i = e.length, s = t.length;
  if (r) {
    let m = e.includes(`
`), g = t.includes(`
`), a = Mn(e), b = Mn(t), d = m ? `${e.split(a, o).join(a)}
` : e, $ = g ? `${t.split(b, o).join(b)}
` : t;
    i = d.length, s = $.length;
  }
  let l = i !== e.length || s !== t.length, u = /* @__PURE__ */ c((m, g) => e[m] === t[g], "isCommon"), f = 0, p = 0, h = [];
  return Yn(i, s, u, /* @__PURE__ */ c((m, g, a) => {
    f !== g && h.push(new N(k, e.slice(f, g))), p !== a && h.push(new N(j, t.slice(p, a))), f = g + m, p = a + m, h.push(new N(L, t.slice(a, p)));
  }, "foundSubsequence")), f !== i && h.push(new N(k, e.slice(f))), p !== s && h.push(new N(j, t.slice(p))), [h, l];
}
c(fi, "diffStrings");
function mi(e, t, n) {
  return t.reduce((r, o) => r + (o[0] === L ? o[1] : o[0] === e && o[1].length !== 0 ? n(o[1]) : ""), "");
}
c(mi, "concatenateRelevantDiffs");
var Ot = class Ot {
  op;
  line;
  lines;
  changeColor;
  constructor(t, n) {
    this.op = t, this.line = [], this.lines = [], this.changeColor = n;
  }
  pushSubstring(t) {
    this.pushDiff(new N(this.op, t));
  }
  pushLine() {
    this.lines.push(this.line.length !== 1 ? new N(this.op, mi(this.op, this.line, this.changeColor)) : this.line[0][0] === this.op ? this.line[0] : new N(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, s) => {
        s < 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;
  }
};
c(Ot, "ChangeBuffer");
var Ye = Ot, At = class At {
  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((s, l) => {
        if (l === 0) {
          let u = new N(n, s);
          this.deleteBuffer.isLineEmpty() && this.insertBuffer.isLineEmpty() ? (this.flushChangeLines(), this.pushDiffCommonLine(u)) : (this.pushDiffChangeLines(u), this.flushChangeLines());
        } else l < i ? this.pushDiffCommonLine(new N(n, s)) : s.length !== 0 && this.pushDiffChangeLines(new N(n, s));
      });
    } else
      this.pushDiffChangeLines(t);
  }
  // Output from buffer.
  getLines() {
    return this.flushChangeLines(), this.lines;
  }
};
c(At, "CommonBuffer");
var dt = At;
function pi(e, t) {
  let n = new Ye(k, t), r = new Ye(j, t), o = new dt(n, r);
  return e.forEach((i) => {
    switch (i[0]) {
      case k:
        n.align(i);
        break;
      case j:
        r.align(i);
        break;
      default:
        o.align(i);
    }
  }), o.getLines();
}
c(pi, "getAlignedDiffs");
function gi(e, t) {
  if (t) {
    let n = e.length - 1;
    return e.some((r, o) => r[0] === L && (o !== n || r[1] !== `
`));
  }
  return e.some((n) => n[0] === L);
}
c(gi, "hasCommonDiff");
function hi(e, t, n) {
  if (e !== t && e.length !== 0 && t.length !== 0) {
    let r = e.includes(`
`) || t.includes(`
`), [o, i] = Gn(r ? `${e}
` : e, r ? `${t}
` : t, !0, n);
    if (gi(o, r)) {
      let s = me(n), l = pi(o, s.changeColor);
      return Ct(l, i, s);
    }
  }
  return Ue(e.split(`
`), t.split(`
`), n);
}
c(hi, "diffStringsUnified");
function Gn(e, t, n, r) {
  let [o, i] = fi(e, t, r);
  return n && Ho(o), [o, i];
}
c(Gn, "diffStringsRaw");
function St(e, t) {
  let { commonColor: n } = me(t);
  return n(e);
}
c(St, "getCommonMessage");
var { AsymmetricMatcher: yi, DOMCollection: bi, DOMElement: Ei, Immutable: di, ReactElement: Si, ReactTestComponent: $i } = de, Hn = [
  $i,
  Si,
  Ei,
  bi,
  di,
  yi,
  de.Error
], $t = {
  maxDepth: 20,
  plugins: Hn
}, Kn = {
  callToJSON: !1,
  maxDepth: 8,
  plugins: Hn
};
function _i(e, t, n) {
  if (Object.is(e, t))
    return "";
  let r = Nn(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 !== Nn(t)) {
    let b = function(C) {
      return C.length <= a ? C : `${C.slice(0, a)}...`;
    };
    c(b, "truncate");
    let { aAnnotation: s, aColor: l, aIndicator: u, bAnnotation: f, bColor: p, bIndicator: h } = me(n), w = _t(Kn, n), m = X(e, w), g = X(t, w), a = 1e5;
    m = b(m), g = b(g);
    let d = `${l(`${u} ${s}:`)} 
${m}`, $ = `${p(`${h} ${f}:`)} 
${g}`;
    return `${d}

${$}`;
  }
  if (!i)
    switch (r) {
      case "string":
        return Ue(e.split(`
`), t.split(`
`), n);
      case "boolean":
      case "number":
        return Ti(e, t, n);
      case "map":
        return Et(Rn(e), Rn(t), n);
      case "set":
        return Et(Ln(e), Ln(t), n);
      default:
        return Et(e, t, n);
    }
}
c(_i, "diff");
function Ti(e, t, n) {
  let r = X(e, $t), o = X(t, $t);
  return r === o ? "" : Ue(r.split(`
`), o.split(`
`), n);
}
c(Ti, "comparePrimitive");
function Rn(e) {
  return new Map(Array.from(e.entries()).sort());
}
c(Rn, "sortMap");
function Ln(e) {
  return new Set(Array.from(e.values()).sort());
}
c(Ln, "sortSet");
function Et(e, t, n) {
  let r, o = !1;
  try {
    let s = _t($t, n);
    r = In(e, t, s, n);
  } catch {
    o = !0;
  }
  let i = St(kn, n);
  if (r === void 0 || r === i) {
    let s = _t(Kn, n);
    r = In(e, t, s, n), r !== i && !o && (r = `${St(Qo, n)}

${r}`);
  }
  return r;
}
c(Et, "compareObjects");
function _t(e, t) {
  let { compareKeys: n, printBasicPrototype: r, maxDepth: o } = me(t);
  return {
    ...e,
    compareKeys: n,
    printBasicPrototype: r,
    maxDepth: o ?? e.maxDepth
  };
}
c(_t, "getFormatOptions");
function In(e, t, n, r) {
  let o = {
    ...n,
    indent: 0
  }, i = X(e, o), s = X(t, o);
  if (i === s)
    return St(kn, r);
  {
    let l = X(e, n), u = X(t, n);
    return ai(l.split(`
`), u.split(`
`), i.split(`
`), s.split(`
`), r);
  }
}
c(In, "getObjectsDifference");
var Fn = 2e4;
function xn(e) {
  return Be(e) === "Object" && typeof e.asymmetricMatch == "function";
}
c(xn, "isAsymmetricMatcher");
function Dn(e, t) {
  let n = Be(e), r = Be(t);
  return n === r && (n === "Object" || n === "Array");
}
c(Dn, "isReplaceable");
function Xn(e, t, n) {
  let { aAnnotation: r, bAnnotation: o } = me(n);
  if (typeof t == "string" && typeof e == "string" && t.length > 0 && e.length > 0 && t.length <= Fn && e.length <= Fn && t !== e) {
    if (t.includes(`
`) || e.includes(`
`))
      return hi(t, e, n);
    let [p] = Gn(t, e, !0), h = p.some((a) => a[0] === L), w = Ci(r, o), m = w(r) + Ai(jn(p, k, h)), g = w(o) + Oi(jn(p, j, h));
    return `${m}
${g}`;
  }
  let i = yt(t, { forceWritable: !0 }), s = yt(e, { forceWritable: !0 }), { replacedExpected: l, replacedActual: u } = Zn(s, i);
  return _i(l, u, n);
}
c(Xn, "printDiffOrStringify");
function Zn(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
  }) : Dn(e, t) ? n.has(e) || r.has(t) ? {
    replacedActual: e,
    replacedExpected: t
  } : (n.add(e), r.add(t), ht(t).forEach((o) => {
    let i = t[o], s = e[o];
    if (xn(i))
      i.asymmetricMatch(s) && (e[o] = i);
    else if (xn(s))
      s.asymmetricMatch(i) && (t[o] = s);
    else if (Dn(s, i)) {
      let l = Zn(s, i, n, r);
      e[o] = l.replacedActual, t[o] = l.replacedExpected;
    }
  }), {
    replacedActual: e,
    replacedExpected: t
  }) : {
    replacedActual: e,
    replacedExpected: t
  };
}
c(Zn, "replaceAsymmetricMatcher");
function Ci(...e) {
  let t = e.reduce((n, r) => r.length > n ? r.length : n, 0);
  return (n) => `${n}: ${" ".repeat(t - n.length)}`;
}
c(Ci, "getLabelPrinter");
var wi = "\xB7";
function Qn(e) {
  return e.replace(/\s+$/gm, (t) => wi.repeat(t.length));
}
c(Qn, "replaceTrailingSpaces");
function Oi(e) {
  return Q.red(Qn(fe(e)));
}
c(Oi, "printReceived");
function Ai(e) {
  return Q.green(Qn(fe(e)));
}
c(Ai, "printExpected");
function jn(e, t, n) {
  return e.reduce((r, o) => r + (o[0] === L ? o[1] : o[0] === t ? n ? Q.inverse(o[1]) : o[1] : ""), "");
}
c(jn, "getCommonAndChangedSubstrings");

// ../node_modules/@vitest/utils/dist/error.js
var Pi = "@@__IMMUTABLE_RECORD__@@", Ni = "@@__IMMUTABLE_ITERABLE__@@";
function Mi(e) {
  return e && (e[Ni] || e[Pi]);
}
c(Mi, "isImmutable");
var Ri = Object.getPrototypeOf({});
function vn(e) {
  return e instanceof Error ? `<unserializable>: ${e.message}` : typeof e == "string" ? `<unserializable>: ${e}` : "<unserializable>";
}
c(vn, "getUnserializableMessage");
function ue(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" && qe(() => n.message ?? (n.message = e.message)), typeof e.stack == "string" && qe(() => n.stack ?? (n.stack = e.stack)), typeof e.name == "string" && qe(() => n.name ?? (n.name = e.name)), e.cause != null && qe(() => n.cause ?? (n.cause = ue(e.cause, t)))), ue(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 (Mi(e))
    return ue(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()} ${Sn(e.sample)}`;
  if (typeof e.toJSON == "function")
    return ue(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] = ue(r, t);
      } catch (i) {
        n[o] = vn(i);
      }
    }), n;
  } else {
    let n = /* @__PURE__ */ Object.create(null);
    t.set(e, n);
    let r = e;
    for (; r && r !== Ri; )
      Object.getOwnPropertyNames(r).forEach((o) => {
        if (!(o in n))
          try {
            n[o] = ue(e[o], t);
          } catch (i) {
            delete n[o], n[o] = vn(i);
          }
      }), r = Object.getPrototypeOf(r);
    return n;
  }
}
c(ue, "serializeValue");
function qe(e) {
  try {
    return e();
  } catch {
  }
}
c(qe, "safe");
function Li(e) {
  return e.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
}
c(Li, "normalizeErrorMessage");
function Ii(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 = Xn(r.actual, r.expected, {
    ...t,
    ...r.diffOptions
  })), "expected" in r && typeof r.expected != "string" && (r.expected = fe(r.expected, 10)), "actual" in r && typeof r.actual != "string" && (r.actual = fe(r.actual, 10));
  try {
    typeof r.message == "string" && (r.message = Li(r.message));
  } catch {
  }
  try {
    !n.has(r) && typeof r.cause == "object" && (n.add(r), r.cause = Ii(r.cause, t, n));
  } catch {
  }
  try {
    return ue(r);
  } catch (o) {
    return ue(new Error(`Failed to fully serialize error: ${o?.message}
Inner error message: ${r?.message}`));
  }
}
c(Ii, "processError");

export {
  Q as a,
  fe as b,
  $n as c,
  ls as d,
  as as e,
  Be as f,
  fs as g,
  _i as h,
  Xn as i,
  Ii as j
};
