"use strict";
var lr = Object.create;
var Et = Object.defineProperty;
var ar = Object.getOwnPropertyDescriptor;
var fr = Object.getOwnPropertyNames;
var pr = Object.getPrototypeOf, mr = Object.prototype.hasOwnProperty;
var i = (t, e) => Et(t, "name", { value: e, configurable: !0 });
var gr = (t, e) => () => (e || t((e = { exports: {} }).exports, e), e.exports), hr = (t, e) => {
  for (var n in e)
    Et(t, n, { get: e[n], enumerable: !0 });
}, Pe = (t, e, n, r) => {
  if (e && typeof e == "object" || typeof e == "function")
    for (let o of fr(e))
      !mr.call(t, o) && o !== n && Et(t, o, { get: () => e[o], enumerable: !(r = ar(e, o)) || r.enumerable });
  return t;
};
var yr = (t, e, n) => (n = t != null ? lr(pr(t)) : {}, Pe(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  e || !t || !t.__esModule ? Et(n, "default", { value: t, enumerable: !0 }) : n,
  t
)), dr = (t) => Pe(Et({}, "__esModule", { value: !0 }), t);

// ../node_modules/@storybook/global/dist/index.js
var xe = gr((ri, Le) => {
  "use strict";
  var Ht = Object.defineProperty, br = Object.getOwnPropertyDescriptor, Sr = Object.getOwnPropertyNames, _r = Object.prototype.hasOwnProperty,
  Er = /* @__PURE__ */ i((t, e) => {
    for (var n in e)
      Ht(t, n, { get: e[n], enumerable: !0 });
  }, "__export"), Or = /* @__PURE__ */ i((t, e, n, r) => {
    if (e && typeof e == "object" || typeof e == "function")
      for (let o of Sr(e))
        !_r.call(t, o) && o !== n && Ht(t, o, { get: /* @__PURE__ */ i(() => e[o], "get"), enumerable: !(r = br(e, o)) || r.enumerable });
    return t;
  }, "__copyProps"), wr = /* @__PURE__ */ i((t) => Or(Ht({}, "__esModule", { value: !0 }), t), "__toCommonJS"), Me = {};
  Er(Me, {
    global: /* @__PURE__ */ i(() => Cr, "global")
  });
  Le.exports = wr(Me);
  var Cr = (() => {
    let t;
    return typeof window < "u" ? t = window : typeof globalThis < "u" ? t = globalThis : typeof global < "u" ? t = global : typeof self < "u" ?
    t = self : t = {}, t;
  })();
});

// src/instrumenter/index.ts
var ei = {};
hr(ei, {
  CallStates: () => er,
  EVENTS: () => nt,
  instrument: () => cr
});
module.exports = dr(ei);

// src/instrumenter/instrumenter.ts
var sr = require("storybook/internal/client-logger"), gt = require("storybook/internal/core-events"), ir = require("storybook/internal/preview-api"),
U = yr(xe(), 1);

// ../node_modules/@vitest/utils/node_modules/tinyrainbow/dist/chunk-BVHSVHOK.js
var $r = {
  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]
}, Tr = Object.entries($r);
function Jt(t) {
  return String(t);
}
i(Jt, "a");
Jt.open = "";
Jt.close = "";
function je(t = !1) {
  let e = typeof process < "u" ? process : void 0, n = e?.env || {}, r = e?.argv || [];
  return !("NO_COLOR" in n || r.includes("--no-color")) && ("FORCE_COLOR" in n || r.includes("--color") || e?.platform === "win32" || t && n.
  TERM !== "dumb" || "CI" in n) || typeof window < "u" && !!window.chrome;
}
i(je, "C");
function De(t = !1) {
  let e = je(t), n = /* @__PURE__ */ i((c, u, l, f) => {
    let p = "", a = 0;
    do
      p += c.substring(a, f) + l, a = f + u.length, f = c.indexOf(u, a);
    while (~f);
    return p + c.substring(a);
  }, "i"), r = /* @__PURE__ */ i((c, u, l = c) => {
    let f = /* @__PURE__ */ i((p) => {
      let a = String(p), _ = a.indexOf(u, c.length);
      return ~_ ? c + n(a, u, l, _) + u : c + a + u;
    }, "o");
    return f.open = c, f.close = u, f;
  }, "g"), o = {
    isColorSupported: e
  }, s = /* @__PURE__ */ i((c) => `\x1B[${c}m`, "d");
  for (let [c, u] of Tr)
    o[c] = e ? r(
      s(u[0]),
      s(u[1]),
      u[2]
    ) : Jt;
  return o;
}
i(De, "p");

// ../node_modules/@vitest/utils/node_modules/tinyrainbow/dist/node.js
var Fe = require("tty"), v = De((0, Fe.isatty)(1));

// ../node_modules/@vitest/utils/node_modules/@vitest/pretty-format/dist/index.js
function Ar(t, e) {
  let n = Object.keys(t), r = e === null ? n : n.sort(e);
  if (Object.getOwnPropertySymbols)
    for (let o of Object.getOwnPropertySymbols(t))
      Object.getOwnPropertyDescriptor(t, o).enumerable && r.push(o);
  return r;
}
i(Ar, "getKeysOfEnumerableProperties");
function Pt(t, e, n, r, o, s, c = ": ") {
  let u = "", l = 0, f = t.next();
  if (!f.done) {
    u += e.spacingOuter;
    let p = n + e.indent;
    for (; !f.done; ) {
      if (u += p, l++ === e.maxWidth) {
        u += "\u2026";
        break;
      }
      let a = s(
        f.value[0],
        e,
        p,
        r,
        o
      ), _ = s(
        f.value[1],
        e,
        p,
        r,
        o
      );
      u += a + c + _, f = t.next(), f.done ? e.min || (u += ",") : u += `,${e.spacingInner}`;
    }
    u += e.spacingOuter + n;
  }
  return u;
}
i(Pt, "printIteratorEntries");
function vt(t, e, n, r, o, s) {
  let c = "", u = 0, l = t.next();
  if (!l.done) {
    c += e.spacingOuter;
    let f = n + e.indent;
    for (; !l.done; ) {
      if (c += f, u++ === e.maxWidth) {
        c += "\u2026";
        break;
      }
      c += s(l.value, e, f, r, o), l = t.next(), l.done ? e.min || (c += ",") : c += `,${e.spacingInner}`;
    }
    c += e.spacingOuter + n;
  }
  return c;
}
i(vt, "printIteratorValues");
function It(t, e, n, r, o, s) {
  let c = "";
  t = t instanceof ArrayBuffer ? new DataView(t) : t;
  let u = /* @__PURE__ */ i((f) => f instanceof DataView, "isDataView"), l = u(t) ? t.byteLength : t.length;
  if (l > 0) {
    c += e.spacingOuter;
    let f = n + e.indent;
    for (let p = 0; p < l; p++) {
      if (c += f, p === e.maxWidth) {
        c += "\u2026";
        break;
      }
      (u(t) || p in t) && (c += s(
        u(t) ? t.getInt8(p) : t[p],
        e,
        f,
        r,
        o
      )), p < l - 1 ? c += `,${e.spacingInner}` : e.min || (c += ",");
    }
    c += e.spacingOuter + n;
  }
  return c;
}
i(It, "printListItems");
function te(t, e, n, r, o, s) {
  let c = "", u = Ar(t, e.compareKeys);
  if (u.length > 0) {
    c += e.spacingOuter;
    let l = n + e.indent;
    for (let f = 0; f < u.length; f++) {
      let p = u[f], a = s(p, e, l, r, o), _ = s(t[p], e, l, r, o);
      c += `${l + a}: ${_}`, f < u.length - 1 ? c += `,${e.spacingInner}` : e.min || (c += ",");
    }
    c += e.spacingOuter + n;
  }
  return c;
}
i(te, "printObjectProperties");
var Nr = typeof Symbol == "function" && Symbol.for ? Symbol.for("jest.asymmetricMatcher") : 1267621, At = " ", Ir = /* @__PURE__ */ i((t, e, n, r, o, s) => {
  let c = t.toString();
  if (c === "ArrayContaining" || c === "ArrayNotContaining")
    return ++r > e.maxDepth ? `[${c}]` : `${c + At}[${It(
      t.sample,
      e,
      n,
      r,
      o,
      s
    )}]`;
  if (c === "ObjectContaining" || c === "ObjectNotContaining")
    return ++r > e.maxDepth ? `[${c}]` : `${c + At}{${te(
      t.sample,
      e,
      n,
      r,
      o,
      s
    )}}`;
  if (c === "StringMatching" || c === "StringNotMatching" || c === "StringContaining" || c === "StringNotContaining")
    return c + At + s(t.sample, e, n, r, o);
  if (typeof t.toAsymmetricMatcher != "function")
    throw new TypeError(
      `Asymmetric matcher ${t.constructor.name} does not implement toAsymmetricMatcher()`
    );
  return t.toAsymmetricMatcher();
}, "serialize$5"), Rr = /* @__PURE__ */ i((t) => t && t.$$typeof === Nr, "test$5"), Pr = { serialize: Ir, test: Rr }, Mr = " ", Je = /* @__PURE__ */ new Set(
["DOMStringMap", "NamedNodeMap"]), Lr = /^(?:HTML\w*Collection|NodeList)$/;
function xr(t) {
  return Je.has(t) || Lr.test(t);
}
i(xr, "testName");
var jr = /* @__PURE__ */ i((t) => t && t.constructor && !!t.constructor.name && xr(t.constructor.name), "test$4");
function Dr(t) {
  return t.constructor.name === "NamedNodeMap";
}
i(Dr, "isNamedNodeMap");
var Fr = /* @__PURE__ */ i((t, e, n, r, o, s) => {
  let c = t.constructor.name;
  return ++r > e.maxDepth ? `[${c}]` : (e.min ? "" : c + Mr) + (Je.has(c) ? `{${te(
    Dr(t) ? [...t].reduce(
      (u, l) => (u[l.name] = l.value, u),
      {}
    ) : { ...t },
    e,
    n,
    r,
    o,
    s
  )}}` : `[${It(
    [...t],
    e,
    n,
    r,
    o,
    s
  )}]`);
}, "serialize$4"), kr = { serialize: Fr, test: jr };
function Xe(t) {
  return t.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
}
i(Xe, "escapeHTML");
function ee(t, e, n, r, o, s, c) {
  let u = r + n.indent, l = n.colors;
  return t.map((f) => {
    let p = e[f], a = c(p, n, u, o, s);
    return typeof p != "string" && (a.includes(`
`) && (a = n.spacingOuter + u + a + n.spacingOuter + r), a = `{${a}}`), `${n.spacingInner + r + l.prop.open + f + l.prop.close}=${l.value.open}${a}${l.
    value.close}`;
  }).join("");
}
i(ee, "printProps");
function ne(t, e, n, r, o, s) {
  return t.map(
    (c) => e.spacingOuter + n + (typeof c == "string" ? Ze(c, e) : s(c, e, n, r, o))
  ).join("");
}
i(ne, "printChildren");
function Ze(t, e) {
  let n = e.colors.content;
  return n.open + Xe(t) + n.close;
}
i(Ze, "printText");
function Br(t, e) {
  let n = e.colors.comment;
  return `${n.open}<!--${Xe(t)}-->${n.close}`;
}
i(Br, "printComment");
function re(t, e, n, r, o) {
  let s = r.colors.tag;
  return `${s.open}<${t}${e && s.close + e + r.spacingOuter + o + s.open}${n ? `>${s.close}${n}${r.spacingOuter}${o}${s.open}</${t}` : `${e &&
  !r.min ? "" : " "}/`}>${s.close}`;
}
i(re, "printElement");
function oe(t, e) {
  let n = e.colors.tag;
  return `${n.open}<${t}${n.close} \u2026${n.open} />${n.close}`;
}
i(oe, "printElementAsLeaf");
var zr = 1, Qe = 3, ve = 8, tn = 11, Ur = /^(?:(?:HTML|SVG)\w*)?Element$/;
function Yr(t) {
  try {
    return typeof t.hasAttribute == "function" && t.hasAttribute("is");
  } catch {
    return !1;
  }
}
i(Yr, "testHasAttribute");
function Wr(t) {
  let e = t.constructor.name, { nodeType: n, tagName: r } = t, o = typeof r == "string" && r.includes("-") || Yr(t);
  return n === zr && (Ur.test(e) || o) || n === Qe && e === "Text" || n === ve && e === "Comment" || n === tn && e === "DocumentFragment";
}
i(Wr, "testNode");
var Vr = /* @__PURE__ */ i((t) => {
  var e;
  return ((e = t?.constructor) == null ? void 0 : e.name) && Wr(t);
}, "test$3");
function Kr(t) {
  return t.nodeType === Qe;
}
i(Kr, "nodeIsText");
function qr(t) {
  return t.nodeType === ve;
}
i(qr, "nodeIsComment");
function Xt(t) {
  return t.nodeType === tn;
}
i(Xt, "nodeIsFragment");
var Gr = /* @__PURE__ */ i((t, e, n, r, o, s) => {
  if (Kr(t))
    return Ze(t.data, e);
  if (qr(t))
    return Br(t.data, e);
  let c = Xt(t) ? "DocumentFragment" : t.tagName.toLowerCase();
  return ++r > e.maxDepth ? oe(c, e) : re(
    c,
    ee(
      Xt(t) ? [] : Array.from(t.attributes, (u) => u.name).sort(),
      Xt(t) ? {} : [...t.attributes].reduce(
        (u, l) => (u[l.name] = l.value, u),
        {}
      ),
      e,
      n + e.indent,
      r,
      o,
      s
    ),
    ne(
      Array.prototype.slice.call(t.childNodes || t.children),
      e,
      n + e.indent,
      r,
      o,
      s
    ),
    e,
    n
  );
}, "serialize$3"), Hr = { serialize: Gr, test: Vr }, Jr = "@@__IMMUTABLE_ITERABLE__@@", Xr = "@@__IMMUTABLE_LIST__@@", Zr = "@@__IMMUTABLE_K\
EYED__@@", Qr = "@@__IMMUTABLE_MAP__@@", ke = "@@__IMMUTABLE_ORDERED__@@", vr = "@@__IMMUTABLE_RECORD__@@", to = "@@__IMMUTABLE_SEQ__@@", eo = "\
@@__IMMUTABLE_SET__@@", no = "@@__IMMUTABLE_STACK__@@", yt = /* @__PURE__ */ i((t) => `Immutable.${t}`, "getImmutableName"), Mt = /* @__PURE__ */ i(
(t) => `[${t}]`, "printAsLeaf"), Ot = " ", Be = "\u2026";
function ro(t, e, n, r, o, s, c) {
  return ++r > e.maxDepth ? Mt(yt(c)) : `${yt(c) + Ot}{${Pt(
    t.entries(),
    e,
    n,
    r,
    o,
    s
  )}}`;
}
i(ro, "printImmutableEntries");
function oo(t) {
  let e = 0;
  return {
    next() {
      if (e < t._keys.length) {
        let n = t._keys[e++];
        return { done: !1, value: [n, t.get(n)] };
      }
      return { done: !0, value: void 0 };
    }
  };
}
i(oo, "getRecordEntries");
function so(t, e, n, r, o, s) {
  let c = yt(t._name || "Record");
  return ++r > e.maxDepth ? Mt(c) : `${c + Ot}{${Pt(
    oo(t),
    e,
    n,
    r,
    o,
    s
  )}}`;
}
i(so, "printImmutableRecord");
function io(t, e, n, r, o, s) {
  let c = yt("Seq");
  return ++r > e.maxDepth ? Mt(c) : t[Zr] ? `${c + Ot}{${// from Immutable collection of entries or from ECMAScript object
  t._iter || t._object ? Pt(
    t.entries(),
    e,
    n,
    r,
    o,
    s
  ) : Be}}` : `${c + Ot}[${t._iter || t._array || t._collection || t._iterable ? vt(
    t.values(),
    e,
    n,
    r,
    o,
    s
  ) : Be}]`;
}
i(io, "printImmutableSeq");
function Zt(t, e, n, r, o, s, c) {
  return ++r > e.maxDepth ? Mt(yt(c)) : `${yt(c) + Ot}[${vt(
    t.values(),
    e,
    n,
    r,
    o,
    s
  )}]`;
}
i(Zt, "printImmutableValues");
var co = /* @__PURE__ */ i((t, e, n, r, o, s) => t[Qr] ? ro(
  t,
  e,
  n,
  r,
  o,
  s,
  t[ke] ? "OrderedMap" : "Map"
) : t[Xr] ? Zt(
  t,
  e,
  n,
  r,
  o,
  s,
  "List"
) : t[eo] ? Zt(
  t,
  e,
  n,
  r,
  o,
  s,
  t[ke] ? "OrderedSet" : "Set"
) : t[no] ? Zt(
  t,
  e,
  n,
  r,
  o,
  s,
  "Stack"
) : t[to] ? io(t, e, n, r, o, s) : so(t, e, n, r, o, s), "serialize$2"), uo = /* @__PURE__ */ i((t) => t && (t[Jr] === !0 || t[vr] === !0), "\
test$2"), lo = { serialize: co, test: uo }, Nt = { exports: {} }, T = {};
var ze;
function ao() {
  if (ze) return T;
  ze = 1;
  var t = Symbol.for("react.element"), e = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), r = Symbol.for("react.strict_mode"),
  o = Symbol.for("react.profiler"), s = Symbol.for("react.provider"), c = Symbol.for("react.context"), u = Symbol.for("react.server_context"),
  l = Symbol.for("react.forward_ref"), f = Symbol.for("react.suspense"), p = Symbol.for("react.suspense_list"), a = Symbol.for("react.memo"),
  _ = Symbol.for("react.lazy"), h = Symbol.for("react.offscreen"), g;
  g = Symbol.for("react.module.reference");
  function y(m) {
    if (typeof m == "object" && m !== null) {
      var b = m.$$typeof;
      switch (b) {
        case t:
          switch (m = m.type, m) {
            case n:
            case o:
            case r:
            case f:
            case p:
              return m;
            default:
              switch (m = m && m.$$typeof, m) {
                case u:
                case c:
                case l:
                case _:
                case a:
                case s:
                  return m;
                default:
                  return b;
              }
          }
        case e:
          return b;
      }
    }
  }
  return i(y, "v"), T.ContextConsumer = c, T.ContextProvider = s, T.Element = t, T.ForwardRef = l, T.Fragment = n, T.Lazy = _, T.Memo = a, T.
  Portal = e, T.Profiler = o, T.StrictMode = r, T.Suspense = f, T.SuspenseList = p, T.isAsyncMode = function() {
    return !1;
  }, T.isConcurrentMode = function() {
    return !1;
  }, T.isContextConsumer = function(m) {
    return y(m) === c;
  }, T.isContextProvider = function(m) {
    return y(m) === s;
  }, T.isElement = function(m) {
    return typeof m == "object" && m !== null && m.$$typeof === t;
  }, T.isForwardRef = function(m) {
    return y(m) === l;
  }, T.isFragment = function(m) {
    return y(m) === n;
  }, T.isLazy = function(m) {
    return y(m) === _;
  }, T.isMemo = function(m) {
    return y(m) === a;
  }, T.isPortal = function(m) {
    return y(m) === e;
  }, T.isProfiler = function(m) {
    return y(m) === o;
  }, T.isStrictMode = function(m) {
    return y(m) === r;
  }, T.isSuspense = function(m) {
    return y(m) === f;
  }, T.isSuspenseList = function(m) {
    return y(m) === p;
  }, T.isValidElementType = function(m) {
    return typeof m == "string" || typeof m == "function" || m === n || m === o || m === r || m === f || m === p || m === h || typeof m == "\
object" && m !== null && (m.$$typeof === _ || m.$$typeof === a || m.$$typeof === s || m.$$typeof === c || m.$$typeof === l || m.$$typeof ===
    g || m.getModuleId !== void 0);
  }, T.typeOf = y, T;
}
i(ao, "requireReactIs_production_min");
var A = {};
var Ue;
function fo() {
  return Ue || (Ue = 1, process.env.NODE_ENV !== "production" && function() {
    var t = Symbol.for("react.element"), e = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), r = Symbol.for("react.strict_mode"),
    o = Symbol.for("react.profiler"), s = Symbol.for("react.provider"), c = Symbol.for("react.context"), u = Symbol.for("react.server_contex\
t"), l = Symbol.for("react.forward_ref"), f = Symbol.for("react.suspense"), p = Symbol.for("react.suspense_list"), a = Symbol.for("react.mem\
o"), _ = Symbol.for("react.lazy"), h = Symbol.for("react.offscreen"), g = !1, y = !1, m = !1, b = !1, E = !1, $;
    $ = Symbol.for("react.module.reference");
    function d(w) {
      return !!(typeof w == "string" || typeof w == "function" || w === n || w === o || E || w === r || w === f || w === p || b || w === h ||
      g || y || m || typeof w == "object" && w !== null && (w.$$typeof === _ || w.$$typeof === a || w.$$typeof === s || w.$$typeof === c || w.
      $$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.
      w.$$typeof === $ || w.getModuleId !== void 0));
    }
    i(d, "isValidElementType");
    function S(w) {
      if (typeof w == "object" && w !== null) {
        var Gt = w.$$typeof;
        switch (Gt) {
          case t:
            var Tt = w.type;
            switch (Tt) {
              case n:
              case o:
              case r:
              case f:
              case p:
                return Tt;
              default:
                var Re = Tt && Tt.$$typeof;
                switch (Re) {
                  case u:
                  case c:
                  case l:
                  case _:
                  case a:
                  case s:
                    return Re;
                  default:
                    return Gt;
                }
            }
          case e:
            return Gt;
        }
      }
    }
    i(S, "typeOf");
    var C = c, O = s, N = t, G = l, Q = n, P = _, k = a, H = e, Y = o, R = r, L = f, x = p, J = !1, D = !1;
    function V(w) {
      return J || (J = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.")), !1;
    }
    i(V, "isAsyncMode");
    function rt(w) {
      return D || (D = !0, console.warn("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.")), !1;
    }
    i(rt, "isConcurrentMode");
    function K(w) {
      return S(w) === c;
    }
    i(K, "isContextConsumer");
    function q(w) {
      return S(w) === s;
    }
    i(q, "isContextProvider");
    function st(w) {
      return typeof w == "object" && w !== null && w.$$typeof === t;
    }
    i(st, "isElement");
    function X(w) {
      return S(w) === l;
    }
    i(X, "isForwardRef");
    function W(w) {
      return S(w) === n;
    }
    i(W, "isFragment");
    function ot(w) {
      return S(w) === _;
    }
    i(ot, "isLazy");
    function ht(w) {
      return S(w) === a;
    }
    i(ht, "isMemo");
    function ut(w) {
      return S(w) === e;
    }
    i(ut, "isPortal");
    function _t(w) {
      return S(w) === o;
    }
    i(_t, "isProfiler");
    function Ct(w) {
      return S(w) === r;
    }
    i(Ct, "isStrictMode");
    function $t(w) {
      return S(w) === f;
    }
    i($t, "isSuspense");
    function ur(w) {
      return S(w) === p;
    }
    i(ur, "isSuspenseList"), A.ContextConsumer = C, A.ContextProvider = O, A.Element = N, A.ForwardRef = G, A.Fragment = Q, A.Lazy = P, A.Memo =
    k, A.Portal = H, A.Profiler = Y, A.StrictMode = R, A.Suspense = L, A.SuspenseList = x, A.isAsyncMode = V, A.isConcurrentMode = rt, A.isContextConsumer =
    K, A.isContextProvider = q, A.isElement = st, A.isForwardRef = X, A.isFragment = W, A.isLazy = ot, A.isMemo = ht, A.isPortal = ut, A.isProfiler =
    _t, A.isStrictMode = Ct, A.isSuspense = $t, A.isSuspenseList = ur, A.isValidElementType = d, A.typeOf = S;
  }()), A;
}
i(fo, "requireReactIs_development");
var Ye;
function po() {
  return Ye || (Ye = 1, process.env.NODE_ENV === "production" ? Nt.exports = ao() : Nt.exports = fo()), Nt.exports;
}
i(po, "requireReactIs");
var at = po();
function en(t, e = []) {
  if (Array.isArray(t))
    for (let n of t)
      en(n, e);
  else t != null && t !== !1 && t !== "" && e.push(t);
  return e;
}
i(en, "getChildren");
function We(t) {
  let e = t.type;
  if (typeof e == "string")
    return e;
  if (typeof e == "function")
    return e.displayName || e.name || "Unknown";
  if (at.isFragment(t))
    return "React.Fragment";
  if (at.isSuspense(t))
    return "React.Suspense";
  if (typeof e == "object" && e !== null) {
    if (at.isContextProvider(t))
      return "Context.Provider";
    if (at.isContextConsumer(t))
      return "Context.Consumer";
    if (at.isForwardRef(t)) {
      if (e.displayName)
        return e.displayName;
      let n = e.render.displayName || e.render.name || "";
      return n === "" ? "ForwardRef" : `ForwardRef(${n})`;
    }
    if (at.isMemo(t)) {
      let n = e.displayName || e.type.displayName || e.type.name || "";
      return n === "" ? "Memo" : `Memo(${n})`;
    }
  }
  return "UNDEFINED";
}
i(We, "getType");
function mo(t) {
  let { props: e } = t;
  return Object.keys(e).filter((n) => n !== "children" && e[n] !== void 0).sort();
}
i(mo, "getPropKeys$1");
var go = /* @__PURE__ */ i((t, e, n, r, o, s) => ++r > e.maxDepth ? oe(We(t), e) : re(
  We(t),
  ee(
    mo(t),
    t.props,
    e,
    n + e.indent,
    r,
    o,
    s
  ),
  ne(
    en(t.props.children),
    e,
    n + e.indent,
    r,
    o,
    s
  ),
  e,
  n
), "serialize$1"), ho = /* @__PURE__ */ i((t) => t != null && at.isElement(t), "test$1"), yo = { serialize: go, test: ho }, bo = typeof Symbol ==
"function" && Symbol.for ? Symbol.for("react.test.json") : 245830487;
function So(t) {
  let { props: e } = t;
  return e ? Object.keys(e).filter((n) => e[n] !== void 0).sort() : [];
}
i(So, "getPropKeys");
var _o = /* @__PURE__ */ i((t, e, n, r, o, s) => ++r > e.maxDepth ? oe(t.type, e) : re(
  t.type,
  t.props ? ee(
    So(t),
    t.props,
    e,
    n + e.indent,
    r,
    o,
    s
  ) : "",
  t.children ? ne(
    t.children,
    e,
    n + e.indent,
    r,
    o,
    s
  ) : "",
  e,
  n
), "serialize"), Eo = /* @__PURE__ */ i((t) => t && t.$$typeof === bo, "test"), Oo = { serialize: _o, test: Eo }, nn = Object.prototype.toString,
wo = Date.prototype.toISOString, Co = Error.prototype.toString, Ve = RegExp.prototype.toString;
function Qt(t) {
  return typeof t.constructor == "function" && t.constructor.name || "Object";
}
i(Qt, "getConstructorName");
function $o(t) {
  return typeof window < "u" && t === window;
}
i($o, "isWindow");
var To = /^Symbol\((.*)\)(.*)$/, Ao = /\n/g, Rt = class extends Error {
  static {
    i(this, "PrettyFormatPluginError");
  }
  constructor(e, n) {
    super(e), this.stack = n, this.name = this.constructor.name;
  }
};
function No(t) {
  return t === "[object Array]" || t === "[object ArrayBuffer]" || t === "[object DataView]" || t === "[object Float32Array]" || t === "[obj\
ect Float64Array]" || t === "[object Int8Array]" || t === "[object Int16Array]" || t === "[object Int32Array]" || t === "[object Uint8Array]" ||
  t === "[object Uint8ClampedArray]" || t === "[object Uint16Array]" || t === "[object Uint32Array]";
}
i(No, "isToStringedArrayType");
function Io(t) {
  return Object.is(t, -0) ? "-0" : String(t);
}
i(Io, "printNumber");
function Ro(t) {
  return `${t}n`;
}
i(Ro, "printBigInt");
function Ke(t, e) {
  return e ? `[Function ${t.name || "anonymous"}]` : "[Function]";
}
i(Ke, "printFunction");
function qe(t) {
  return String(t).replace(To, "Symbol($1)");
}
i(qe, "printSymbol");
function Ge(t) {
  return `[${Co.call(t)}]`;
}
i(Ge, "printError");
function rn(t, e, n, r) {
  if (t === !0 || t === !1)
    return `${t}`;
  if (t === void 0)
    return "undefined";
  if (t === null)
    return "null";
  let o = typeof t;
  if (o === "number")
    return Io(t);
  if (o === "bigint")
    return Ro(t);
  if (o === "string")
    return r ? `"${t.replaceAll(/"|\\/g, "\\$&")}"` : `"${t}"`;
  if (o === "function")
    return Ke(t, e);
  if (o === "symbol")
    return qe(t);
  let s = nn.call(t);
  return s === "[object WeakMap]" ? "WeakMap {}" : s === "[object WeakSet]" ? "WeakSet {}" : s === "[object Function]" || s === "[object Gen\
eratorFunction]" ? Ke(t, e) : s === "[object Symbol]" ? qe(t) : s === "[object Date]" ? Number.isNaN(+t) ? "Date { NaN }" : wo.call(t) : s ===
  "[object Error]" ? Ge(t) : s === "[object RegExp]" ? n ? Ve.call(t).replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&") : Ve.call(t) : t instanceof Error ?
  Ge(t) : null;
}
i(rn, "printBasicValue");
function on(t, e, n, r, o, s) {
  if (o.includes(t))
    return "[Circular]";
  o = [...o], o.push(t);
  let c = ++r > e.maxDepth, u = e.min;
  if (e.callToJSON && !c && t.toJSON && typeof t.toJSON == "function" && !s)
    return lt(t.toJSON(), e, n, r, o, !0);
  let l = nn.call(t);
  return l === "[object Arguments]" ? c ? "[Arguments]" : `${u ? "" : "Arguments "}[${It(
    t,
    e,
    n,
    r,
    o,
    lt
  )}]` : No(l) ? c ? `[${t.constructor.name}]` : `${u || !e.printBasicPrototype && t.constructor.name === "Array" ? "" : `${t.constructor.name}\
 `}[${It(t, e, n, r, o, lt)}]` : l === "[object Map]" ? c ? "[Map]" : `Map {${Pt(
    t.entries(),
    e,
    n,
    r,
    o,
    lt,
    " => "
  )}}` : l === "[object Set]" ? c ? "[Set]" : `Set {${vt(
    t.values(),
    e,
    n,
    r,
    o,
    lt
  )}}` : c || $o(t) ? `[${Qt(t)}]` : `${u || !e.printBasicPrototype && Qt(t) === "Object" ? "" : `${Qt(t)} `}{${te(
    t,
    e,
    n,
    r,
    o,
    lt
  )}}`;
}
i(on, "printComplexValue");
function Po(t) {
  return t.serialize != null;
}
i(Po, "isNewPlugin");
function sn(t, e, n, r, o, s) {
  let c;
  try {
    c = Po(t) ? t.serialize(e, n, r, o, s, lt) : t.print(
      e,
      (u) => lt(u, n, r, o, s),
      (u) => {
        let l = r + n.indent;
        return l + u.replaceAll(Ao, `
${l}`);
      },
      {
        edgeSpacing: n.spacingOuter,
        min: n.min,
        spacing: n.spacingInner
      },
      n.colors
    );
  } catch (u) {
    throw new Rt(u.message, u.stack);
  }
  if (typeof c != "string")
    throw new TypeError(
      `pretty-format: Plugin must return type "string" but instead returned "${typeof c}".`
    );
  return c;
}
i(sn, "printPlugin");
function cn(t, e) {
  for (let n of t)
    try {
      if (n.test(e))
        return n;
    } catch (r) {
      throw new Rt(r.message, r.stack);
    }
  return null;
}
i(cn, "findPlugin");
function lt(t, e, n, r, o, s) {
  let c = cn(e.plugins, t);
  if (c !== null)
    return sn(c, t, e, n, r, o);
  let u = rn(
    t,
    e.printFunctionName,
    e.escapeRegex,
    e.escapeString
  );
  return u !== null ? u : on(
    t,
    e,
    n,
    r,
    o,
    s
  );
}
i(lt, "printer");
var se = {
  comment: "gray",
  content: "reset",
  prop: "yellow",
  tag: "cyan",
  value: "green"
}, un = Object.keys(se), tt = {
  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: se
};
function Mo(t) {
  for (let e of Object.keys(t))
    if (!Object.prototype.hasOwnProperty.call(tt, e))
      throw new Error(`pretty-format: Unknown option "${e}".`);
  if (t.min && t.indent !== void 0 && t.indent !== 0)
    throw new Error(
      'pretty-format: Options "min" and "indent" cannot be used together.'
    );
}
i(Mo, "validateOptions");
function Lo() {
  return un.reduce((t, e) => {
    let n = se[e], r = n && v[n];
    if (r && typeof r.close == "string" && typeof r.open == "string")
      t[e] = r;
    else
      throw new Error(
        `pretty-format: Option "theme" has a key "${e}" whose value "${n}" is undefined in ansi-styles.`
      );
    return t;
  }, /* @__PURE__ */ Object.create(null));
}
i(Lo, "getColorsHighlight");
function xo() {
  return un.reduce((t, e) => (t[e] = { close: "", open: "" }, t), /* @__PURE__ */ Object.create(null));
}
i(xo, "getColorsEmpty");
function ln(t) {
  return t?.printFunctionName ?? tt.printFunctionName;
}
i(ln, "getPrintFunctionName");
function an(t) {
  return t?.escapeRegex ?? tt.escapeRegex;
}
i(an, "getEscapeRegex");
function fn(t) {
  return t?.escapeString ?? tt.escapeString;
}
i(fn, "getEscapeString");
function He(t) {
  return {
    callToJSON: t?.callToJSON ?? tt.callToJSON,
    colors: t?.highlight ? Lo() : xo(),
    compareKeys: typeof t?.compareKeys == "function" || t?.compareKeys === null ? t.compareKeys : tt.compareKeys,
    escapeRegex: an(t),
    escapeString: fn(t),
    indent: t?.min ? "" : jo(t?.indent ?? tt.indent),
    maxDepth: t?.maxDepth ?? tt.maxDepth,
    maxWidth: t?.maxWidth ?? tt.maxWidth,
    min: t?.min ?? tt.min,
    plugins: t?.plugins ?? tt.plugins,
    printBasicPrototype: t?.printBasicPrototype ?? !0,
    printFunctionName: ln(t),
    spacingInner: t?.min ? " " : `
`,
    spacingOuter: t?.min ? "" : `
`
  };
}
i(He, "getConfig");
function jo(t) {
  return Array.from({ length: t + 1 }).join(" ");
}
i(jo, "createIndent");
function Z(t, e) {
  if (e && (Mo(e), e.plugins)) {
    let r = cn(e.plugins, t);
    if (r !== null)
      return sn(r, t, He(e), "", 0, []);
  }
  let n = rn(
    t,
    ln(e),
    an(e),
    fn(e)
  );
  return n !== null ? n : on(t, He(e), "", 0, []);
}
i(Z, "format");
var Lt = {
  AsymmetricMatcher: Pr,
  DOMCollection: kr,
  DOMElement: Hr,
  Immutable: lo,
  ReactElement: yo,
  ReactTestComponent: Oo
};

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

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

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

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

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

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

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

// ../node_modules/loupe/lib/bigint.js
function Dt(t, e) {
  let n = B(t.toString(), e.truncate - 1);
  return n !== it && (n += "n"), e.stylize(n, "bigint");
}
i(Dt, "inspectBigInt");

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

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

// ../node_modules/loupe/lib/string.js
var gn = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\u\
ffff]", "g"), Ko = {
  "\b": "\\b",
  "	": "\\t",
  "\n": "\\n",
  "\f": "\\f",
  "\r": "\\r",
  "'": "\\'",
  "\\": "\\\\"
}, qo = 16, Go = 4;
function Ho(t) {
  return Ko[t] || `\\u${`0000${t.charCodeAt(0).toString(qo)}`.slice(-Go)}`;
}
i(Ho, "escape");
function Ft(t, e) {
  return gn.test(t) && (t = t.replace(gn, Ho)), e.stylize(`'${B(t, e.truncate - 2)}'`, "string");
}
i(Ft, "inspectString");

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

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

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

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

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

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

// ../node_modules/loupe/lib/html.js
function Xo([t, e], n) {
  return n.truncate -= 3, e ? `${n.stylize(String(t), "yellow")}=${n.stylize(`"${e}"`, "string")}` : `${n.stylize(String(t), "yellow")}`;
}
i(Xo, "inspectAttribute");
function Bt(t, e) {
  return j(t, e, zt, `
`);
}
i(Bt, "inspectHTMLCollection");
function zt(t, e) {
  let n = t.getAttributeNames(), r = t.tagName.toLowerCase(), o = e.stylize(`<${r}`, "special"), s = e.stylize(">", "special"), c = e.stylize(
  `</${r}>`, "special");
  e.truncate -= r.length * 2 + 5;
  let u = "";
  n.length > 0 && (u += " ", u += j(n.map((p) => [p, t.getAttribute(p)]), e, Xo, " ")), e.truncate -= u.length;
  let l = e.truncate, f = Bt(t.children, e);
  return f && f.length > l && (f = `${it}(${t.children.length})`), `${o}${u}${s}${f}${c}`;
}
i(zt, "inspectHTML");

// ../node_modules/loupe/lib/index.js
var Zo = typeof Symbol == "function" && typeof Symbol.for == "function", he = Zo ? Symbol.for("chai/inspect") : "@@chai/inspect", dt = !1;
try {
  let t = require("util");
  dt = t.inspect ? t.inspect.custom : !1;
} catch {
  dt = !1;
}
var dn = /* @__PURE__ */ new WeakMap(), bn = {}, Sn = {
  undefined: /* @__PURE__ */ i((t, e) => e.stylize("undefined", "undefined"), "undefined"),
  null: /* @__PURE__ */ i((t, e) => e.stylize("null", "null"), "null"),
  boolean: /* @__PURE__ */ i((t, e) => e.stylize(String(t), "boolean"), "boolean"),
  Boolean: /* @__PURE__ */ i((t, e) => e.stylize(String(t), "boolean"), "Boolean"),
  number: jt,
  Number: jt,
  bigint: Dt,
  BigInt: Dt,
  string: Ft,
  String: Ft,
  function: xt,
  Function: xt,
  symbol: kt,
  // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
  Symbol: kt,
  Array: ie,
  Date: ce,
  Map: ue,
  Set: ae,
  RegExp: le,
  Promise: yn,
  // WeakSet, WeakMap are totally opaque to us
  WeakSet: /* @__PURE__ */ i((t, e) => e.stylize("WeakSet{\u2026}", "special"), "WeakSet"),
  WeakMap: /* @__PURE__ */ i((t, e) => e.stylize("WeakMap{\u2026}", "special"), "WeakMap"),
  Arguments: me,
  Int8Array: et,
  Uint8Array: et,
  Uint8ClampedArray: et,
  Int16Array: et,
  Uint16Array: et,
  Int32Array: et,
  Uint32Array: et,
  Float32Array: et,
  Float64Array: et,
  Generator: /* @__PURE__ */ i(() => "", "Generator"),
  DataView: /* @__PURE__ */ i(() => "", "DataView"),
  ArrayBuffer: /* @__PURE__ */ i(() => "", "ArrayBuffer"),
  Error: ge,
  HTMLCollection: Bt,
  NodeList: Bt
}, Qo = /* @__PURE__ */ i((t, e, n) => he in t && typeof t[he] == "function" ? t[he](e) : dt && dt in t && typeof t[dt] == "function" ? t[dt](
e.depth, e) : "inspect" in t && typeof t.inspect == "function" ? t.inspect(e.depth, e) : "constructor" in t && dn.has(t.constructor) ? dn.get(
t.constructor)(t, e) : bn[n] ? bn[n](t, e) : "", "inspectCustom"), vo = Object.prototype.toString;
function Ut(t, e = {}) {
  let n = mn(e, Ut), { customInspect: r } = n, o = t === null ? "null" : typeof t;
  if (o === "object" && (o = vo.call(t).slice(8, -1)), o in Sn)
    return Sn[o](t, n);
  if (r && t) {
    let c = Qo(t, n, o);
    if (c)
      return typeof c == "string" ? c : Ut(c, n);
  }
  let s = t ? Object.getPrototypeOf(t) : !1;
  return s === Object.prototype || s === null ? ft(t, n) : t && typeof HTMLElement == "function" && t instanceof HTMLElement ? zt(t, n) : "c\
onstructor" in t ? t.constructor !== Object ? pe(t, n) : ft(t, n) : t === Object(t) ? ft(t, n) : n.stylize(String(t), o);
}
i(Ut, "inspect");

// ../node_modules/@vitest/utils/dist/chunk-_commonjsHelpers.js
var {
  AsymmetricMatcher: es,
  DOMCollection: ns,
  DOMElement: rs,
  Immutable: os,
  ReactElement: ss,
  ReactTestComponent: is
} = Lt, _n = [
  is,
  ss,
  rs,
  ns,
  os,
  es
];
function pt(t, e = 10, { maxLength: n, ...r } = {}) {
  let o = n ?? 1e4, s;
  try {
    s = Z(t, {
      maxDepth: e,
      escapeString: !1,
      // min: true,
      plugins: _n,
      ...r
    });
  } catch {
    s = Z(t, {
      callToJSON: !1,
      maxDepth: e,
      escapeString: !1,
      // min: true,
      plugins: _n,
      ...r
    });
  }
  return s.length >= o && e > 1 ? pt(t, Math.floor(e / 2)) : s;
}
i(pt, "stringify");
var cs = /%[sdjifoOc%]/g;
function En(...t) {
  if (typeof t[0] != "string") {
    let s = [];
    for (let c = 0; c < t.length; c++)
      s.push(wt(t[c], { depth: 0, colors: !1 }));
    return s.join(" ");
  }
  let e = t.length, n = 1, r = t[0], o = String(r).replace(cs, (s) => {
    if (s === "%%")
      return "%";
    if (n >= e)
      return s;
    switch (s) {
      case "%s": {
        let c = t[n++];
        return typeof c == "bigint" ? `${c.toString()}n` : typeof c == "number" && c === 0 && 1 / c < 0 ? "-0" : typeof c == "object" && c !==
        null ? wt(c, { depth: 0, colors: !1 }) : String(c);
      }
      case "%d": {
        let c = t[n++];
        return typeof c == "bigint" ? `${c.toString()}n` : Number(c).toString();
      }
      case "%i": {
        let c = t[n++];
        return typeof c == "bigint" ? `${c.toString()}n` : Number.parseInt(String(c)).toString();
      }
      case "%f":
        return Number.parseFloat(String(t[n++])).toString();
      case "%o":
        return wt(t[n++], { showHidden: !0, showProxy: !0 });
      case "%O":
        return wt(t[n++]);
      case "%c":
        return n++, "";
      case "%j":
        try {
          return JSON.stringify(t[n++]);
        } catch (c) {
          let u = c.message;
          if (
            // chromium
            u.includes("circular structure") || u.includes("cyclic structures") || u.includes("cyclic object")
          )
            return "[Circular]";
          throw c;
        }
      default:
        return s;
    }
  });
  for (let s = t[n]; n < e; s = t[++n])
    s === null || typeof s != "object" ? o += ` ${s}` : o += ` ${wt(s)}`;
  return o;
}
i(En, "format");
function wt(t, e = {}) {
  return e.truncate === 0 && (e.truncate = Number.POSITIVE_INFINITY), Ut(t, e);
}
i(wt, "inspect");
function On(t) {
  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
}
i(On, "getDefaultExportFromCjs");

// ../node_modules/@vitest/utils/dist/helpers.js
function us(t) {
  return t === Object.prototype || t === Function.prototype || t === RegExp.prototype;
}
i(us, "isFinalObj");
function Yt(t) {
  return Object.prototype.toString.apply(t).slice(8, -1);
}
i(Yt, "getType");
function ls(t, e) {
  let n = typeof e == "function" ? e : (r) => e.add(r);
  Object.getOwnPropertyNames(t).forEach(n), Object.getOwnPropertySymbols(t).forEach(n);
}
i(ls, "collectOwnProperties");
function de(t) {
  let e = /* @__PURE__ */ new Set();
  return us(t) ? [] : (ls(t, e), Array.from(e));
}
i(de, "getOwnProperties");
var wn = { forceWritable: !1 };
function be(t, e = wn) {
  return ye(t, /* @__PURE__ */ new WeakMap(), e);
}
i(be, "deepClone");
function ye(t, e, n = wn) {
  let r, o;
  if (e.has(t))
    return e.get(t);
  if (Array.isArray(t)) {
    for (o = Array.from({ length: r = t.length }), e.set(t, o); r--; )
      o[r] = ye(t[r], e, n);
    return o;
  }
  if (Object.prototype.toString.call(t) === "[object Object]") {
    o = Object.create(Object.getPrototypeOf(t)), e.set(t, o);
    let s = de(t);
    for (let c of s) {
      let u = Object.getOwnPropertyDescriptor(t, c);
      if (!u)
        continue;
      let l = ye(t[c], e, n);
      n.forceWritable ? Object.defineProperty(o, c, {
        enumerable: u.enumerable,
        configurable: !0,
        writable: !0,
        value: l
      }) : "get" in u ? Object.defineProperty(o, c, {
        ...u,
        get() {
          return l;
        }
      }) : Object.defineProperty(o, c, {
        ...u,
        value: l
      });
    }
    return o;
  }
  return t;
}
i(ye, "clone");

// ../node_modules/@vitest/utils/dist/diff.js
function Cn(t) {
  if (t === void 0)
    return "undefined";
  if (t === null)
    return "null";
  if (Array.isArray(t))
    return "array";
  if (typeof t == "boolean")
    return "boolean";
  if (typeof t == "function")
    return "function";
  if (typeof t == "number")
    return "number";
  if (typeof t == "string")
    return "string";
  if (typeof t == "bigint")
    return "bigint";
  if (typeof t == "object") {
    if (t != null) {
      if (t.constructor === RegExp)
        return "regexp";
      if (t.constructor === Map)
        return "map";
      if (t.constructor === Set)
        return "set";
      if (t.constructor === Date)
        return "date";
    }
    return "object";
  } else if (typeof t == "symbol")
    return "symbol";
  throw new Error(`value of unknown type: ${t}`);
}
i(Cn, "getType");
var z = -1, F = 1, M = 0, I = class {
  static {
    i(this, "Diff");
  }
  0;
  1;
  constructor(e, n) {
    this[0] = e, this[1] = n;
  }
}, as = /* @__PURE__ */ i(function(t, e) {
  if (!t || !e || t.charAt(0) !== e.charAt(0))
    return 0;
  let n = 0, r = Math.min(t.length, e.length), o = r, s = 0;
  for (; n < o; )
    t.substring(s, o) === e.substring(s, o) ? (n = o, s = n) : r = o, o = Math.floor((r - n) / 2 + n);
  return o;
}, "diff_commonPrefix"), Bn = /* @__PURE__ */ i(function(t, e) {
  if (!t || !e || t.charAt(t.length - 1) !== e.charAt(e.length - 1))
    return 0;
  let n = 0, r = Math.min(t.length, e.length), o = r, s = 0;
  for (; n < o; )
    t.substring(t.length - o, t.length - s) === e.substring(e.length - o, e.length - s) ? (n = o, s = n) : r = o, o = Math.floor((r - n) / 2 +
    n);
  return o;
}, "diff_commonSuffix"), $n = /* @__PURE__ */ i(function(t, e) {
  let n = t.length, r = e.length;
  if (n === 0 || r === 0)
    return 0;
  n > r ? t = t.substring(n - r) : n < r && (e = e.substring(0, n));
  let o = Math.min(n, r);
  if (t === e)
    return o;
  let s = 0, c = 1;
  for (; ; ) {
    let u = t.substring(o - c), l = e.indexOf(u);
    if (l === -1)
      return s;
    c += l, (l === 0 || t.substring(o - c) === e.substring(0, c)) && (s = c, c++);
  }
}, "diff_commonOverlap_"), fs = /* @__PURE__ */ i(function(t) {
  let e = !1, n = [], r = 0, o = null, s = 0, c = 0, u = 0, l = 0, f = 0;
  for (; s < t.length; )
    t[s][0] === M ? (n[r++] = s, c = l, u = f, l = 0, f = 0, o = t[s][1]) : (t[s][0] === F ? l += t[s][1].length : f += t[s][1].length, o &&
    o.length <= Math.max(c, u) && o.length <= Math.max(l, f) && (t.splice(
      n[r - 1],
      0,
      new I(z, o)
    ), t[n[r - 1] + 1][0] = F, r--, r--, s = r > 0 ? n[r - 1] : -1, c = 0, u = 0, l = 0, f = 0, o = null, e = !0)), s++;
  for (e && zn(t), gs(t), s = 1; s < t.length; ) {
    if (t[s - 1][0] === z && t[s][0] === F) {
      let p = t[s - 1][1], a = t[s][1], _ = $n(p, a), h = $n(a, p);
      _ >= h ? (_ >= p.length / 2 || _ >= a.length / 2) && (t.splice(
        s,
        0,
        new I(M, a.substring(0, _))
      ), t[s - 1][1] = p.substring(
        0,
        p.length - _
      ), t[s + 1][1] = a.substring(_), s++) : (h >= p.length / 2 || h >= a.length / 2) && (t.splice(
        s,
        0,
        new I(M, p.substring(0, h))
      ), t[s - 1][0] = F, t[s - 1][1] = a.substring(
        0,
        a.length - h
      ), t[s + 1][0] = z, t[s + 1][1] = p.substring(h), s++), s++;
    }
    s++;
  }
}, "diff_cleanupSemantic"), Tn = /[^a-z0-9]/i, An = /\s/, Nn = /[\r\n]/, ps = /\n\r?\n$/, ms = /^\r?\n\r?\n/;
function gs(t) {
  let e = 1;
  for (; e < t.length - 1; ) {
    if (t[e - 1][0] === M && t[e + 1][0] === M) {
      let n = t[e - 1][1], r = t[e][1], o = t[e + 1][1], s = Bn(n, r);
      if (s) {
        let p = r.substring(r.length - s);
        n = n.substring(0, n.length - s), r = p + r.substring(0, r.length - s), o = p + o;
      }
      let c = n, u = r, l = o, f = Wt(n, r) + Wt(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 = Wt(n, r) + Wt(r, o);
        p >= f && (f = p, c = n, u = r, l = o);
      }
      t[e - 1][1] !== c && (c ? t[e - 1][1] = c : (t.splice(e - 1, 1), e--), t[e][1] = u, l ? t[e + 1][1] = l : (t.splice(e + 1, 1), e--));
    }
    e++;
  }
}
i(gs, "diff_cleanupSemanticLossless");
function zn(t) {
  t.push(new I(M, ""));
  let e = 0, n = 0, r = 0, o = "", s = "", c;
  for (; e < t.length; )
    switch (t[e][0]) {
      case F:
        r++, s += t[e][1], e++;
        break;
      case z:
        n++, o += t[e][1], e++;
        break;
      case M:
        n + r > 1 ? (n !== 0 && r !== 0 && (c = as(s, o), c !== 0 && (e - n - r > 0 && t[e - n - r - 1][0] === M ? t[e - n - r - 1][1] += s.
        substring(0, c) : (t.splice(
          0,
          0,
          new I(M, s.substring(0, c))
        ), e++), s = s.substring(c), o = o.substring(c)), c = Bn(s, o), c !== 0 && (t[e][1] = s.substring(s.length - c) + t[e][1], s = s.substring(
          0,
          s.length - c
        ), o = o.substring(
          0,
          o.length - c
        ))), e -= n + r, t.splice(e, n + r), o.length && (t.splice(e, 0, new I(z, o)), e++), s.length && (t.splice(e, 0, new I(F, s)), e++),
        e++) : e !== 0 && t[e - 1][0] === M ? (t[e - 1][1] += t[e][1], t.splice(e, 1)) : e++, r = 0, n = 0, o = "", s = "";
        break;
    }
  t[t.length - 1][1] === "" && t.pop();
  let u = !1;
  for (e = 1; e < t.length - 1; )
    t[e - 1][0] === M && t[e + 1][0] === M && (t[e][1].substring(
      t[e][1].length - t[e - 1][1].length
    ) === t[e - 1][1] ? (t[e][1] = t[e - 1][1] + t[e][1].substring(
      0,
      t[e][1].length - t[e - 1][1].length
    ), t[e + 1][1] = t[e - 1][1] + t[e + 1][1], t.splice(e - 1, 1), u = !0) : t[e][1].substring(0, t[e + 1][1].length) === t[e + 1][1] && (t[e -
    1][1] += t[e + 1][1], t[e][1] = t[e][1].substring(t[e + 1][1].length) + t[e + 1][1], t.splice(e + 1, 1), u = !0)), e++;
  u && zn(t);
}
i(zn, "diff_cleanupMerge");
function Wt(t, e) {
  if (!t || !e)
    return 6;
  let n = t.charAt(t.length - 1), r = e.charAt(0), o = n.match(Tn), s = r.match(Tn), c = o && n.match(An), u = s && r.match(An), l = c && n.
  match(Nn), f = u && r.match(Nn), p = l && t.match(ps), a = f && e.match(ms);
  return p || a ? 5 : l || f ? 4 : o && !c && u ? 3 : c || u ? 2 : o || s ? 1 : 0;
}
i(Wt, "diff_cleanupSemanticScore_");
var Un = "Compared values have no visual difference.", hs = "Compared values serialize to the same structure.\nPrinting internal object struc\
ture without calling `toJSON` instead.", Vt = {}, In;
function ys() {
  if (In) return Vt;
  In = 1, Object.defineProperty(Vt, "__esModule", {
    value: !0
  }), Vt.default = _;
  let t = "diff-sequences", e = 0, n = /* @__PURE__ */ i((h, g, y, m, b) => {
    let E = 0;
    for (; h < g && y < m && b(h, y); )
      h += 1, y += 1, E += 1;
    return E;
  }, "countCommonItemsF"), r = /* @__PURE__ */ i((h, g, y, m, b) => {
    let E = 0;
    for (; h <= g && y <= m && b(g, m); )
      g -= 1, m -= 1, E += 1;
    return E;
  }, "countCommonItemsR"), o = /* @__PURE__ */ i((h, g, y, m, b, E, $) => {
    let d = 0, S = -h, C = E[d], O = C;
    E[d] += n(
      C + 1,
      g,
      m + C - S + 1,
      y,
      b
    );
    let N = h < $ ? h : $;
    for (d += 1, S += 2; d <= N; d += 1, S += 2) {
      if (d !== h && O < E[d])
        C = E[d];
      else if (C = O + 1, g <= C)
        return d - 1;
      O = E[d], E[d] = C + n(C + 1, g, m + C - S + 1, y, b);
    }
    return $;
  }, "extendPathsF"), s = /* @__PURE__ */ i((h, g, y, m, b, E, $) => {
    let d = 0, S = h, C = E[d], O = C;
    E[d] -= r(
      g,
      C - 1,
      y,
      m + C - S - 1,
      b
    );
    let N = h < $ ? h : $;
    for (d += 1, S -= 2; d <= N; d += 1, S -= 2) {
      if (d !== h && E[d] < O)
        C = E[d];
      else if (C = O - 1, C < g)
        return d - 1;
      O = E[d], E[d] = C - r(
        g,
        C - 1,
        y,
        m + C - S - 1,
        b
      );
    }
    return $;
  }, "extendPathsR"), c = /* @__PURE__ */ i((h, g, y, m, b, E, $, d, S, C, O) => {
    let N = m - g, G = y - g, P = b - m - G, k = -P - (h - 1), H = -P + (h - 1), Y = e, R = h < d ? h : d;
    for (let L = 0, x = -h; L <= R; L += 1, x += 2) {
      let J = L === 0 || L !== h && Y < $[L], D = J ? $[L] : Y, V = J ? D : D + 1, rt = N + V - x, K = n(
        V + 1,
        y,
        rt + 1,
        b,
        E
      ), q = V + K;
      if (Y = $[L], $[L] = q, k <= x && x <= H) {
        let st = (h - 1 - (x + P)) / 2;
        if (st <= C && S[st] - 1 <= q) {
          let X = N + D - (J ? x + 1 : x - 1), W = r(
            g,
            D,
            m,
            X,
            E
          ), ot = D - W, ht = X - W, ut = ot + 1, _t = ht + 1;
          O.nChangePreceding = h - 1, h - 1 === ut + _t - g - m ? (O.aEndPreceding = g, O.bEndPreceding = m) : (O.aEndPreceding = ut, O.bEndPreceding =
          _t), O.nCommonPreceding = W, W !== 0 && (O.aCommonPreceding = ut, O.bCommonPreceding = _t), O.nCommonFollowing = K, K !== 0 && (O.
          aCommonFollowing = V + 1, O.bCommonFollowing = rt + 1);
          let Ct = q + 1, $t = rt + K + 1;
          return O.nChangeFollowing = h - 1, h - 1 === y + b - Ct - $t ? (O.aStartFollowing = y, O.bStartFollowing = b) : (O.aStartFollowing =
          Ct, O.bStartFollowing = $t), !0;
        }
      }
    }
    return !1;
  }, "extendOverlappablePathsF"), u = /* @__PURE__ */ i((h, g, y, m, b, E, $, d, S, C, O) => {
    let N = b - y, G = y - g, P = b - m - G, k = P - h, H = P + h, Y = e, R = h < C ? h : C;
    for (let L = 0, x = h; L <= R; L += 1, x -= 2) {
      let J = L === 0 || L !== h && S[L] < Y, D = J ? S[L] : Y, V = J ? D : D - 1, rt = N + V - x, K = r(
        g,
        V - 1,
        m,
        rt - 1,
        E
      ), q = V - K;
      if (Y = S[L], S[L] = q, k <= x && x <= H) {
        let st = (h + (x - P)) / 2;
        if (st <= d && q - 1 <= $[st]) {
          let X = rt - K;
          if (O.nChangePreceding = h, h === q + X - g - m ? (O.aEndPreceding = g, O.bEndPreceding = m) : (O.aEndPreceding = q, O.bEndPreceding =
          X), O.nCommonPreceding = K, K !== 0 && (O.aCommonPreceding = q, O.bCommonPreceding = X), O.nChangeFollowing = h - 1, h === 1)
            O.nCommonFollowing = 0, O.aStartFollowing = y, O.bStartFollowing = b;
          else {
            let W = N + D - (J ? x - 1 : x + 1), ot = n(
              D,
              y,
              W,
              b,
              E
            );
            O.nCommonFollowing = ot, ot !== 0 && (O.aCommonFollowing = D, O.bCommonFollowing = W);
            let ht = D + ot, ut = W + ot;
            h - 1 === y + b - ht - ut ? (O.aStartFollowing = y, O.bStartFollowing = b) : (O.aStartFollowing = ht, O.bStartFollowing = ut);
          }
          return !0;
        }
      }
    }
    return !1;
  }, "extendOverlappablePathsR"), l = /* @__PURE__ */ i((h, g, y, m, b, E, $, d, S) => {
    let C = m - g, O = b - y, N = y - g, G = b - m, Q = G - N, P = N, k = N;
    if ($[0] = g - 1, d[0] = y, Q % 2 === 0) {
      let H = (h || Q) / 2, Y = (N + G) / 2;
      for (let R = 1; R <= Y; R += 1)
        if (P = o(R, y, b, C, E, $, P), R < H)
          k = s(R, g, m, O, E, d, 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.
          u(
            R,
            g,
            y,
            m,
            b,
            E,
            $,
            P,
            d,
            k,
            S
          )
        )
          return;
    } else {
      let H = ((h || Q) + 1) / 2, Y = (N + G + 1) / 2, R = 1;
      for (P = o(R, y, b, C, E, $, P), R += 1; R <= Y; R += 1)
        if (k = s(
          R - 1,
          g,
          m,
          O,
          E,
          d,
          k
        ), R < H)
          P = o(R, y, b, C, E, $, P);
        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(
            R,
            g,
            y,
            m,
            b,
            E,
            $,
            P,
            d,
            k,
            S
          )
        )
          return;
    }
    throw new Error(
      `${t}: no overlap aStart=${g} aEnd=${y} bStart=${m} bEnd=${b}`
    );
  }, "divide"), f = /* @__PURE__ */ i((h, g, y, m, b, E, $, d, S, C) => {
    if (b - m < y - g) {
      if (E = !E, E && $.length === 1) {
        let { foundSubsequence: q, isCommon: st } = $[0];
        $[1] = {
          foundSubsequence: /* @__PURE__ */ i((X, W, ot) => {
            q(X, ot, W);
          }, "foundSubsequence"),
          isCommon: /* @__PURE__ */ i((X, W) => st(W, X), "isCommon")
        };
      }
      let rt = g, K = y;
      g = m, y = b, m = rt, b = K;
    }
    let { foundSubsequence: O, isCommon: N } = $[E ? 1 : 0];
    l(
      h,
      g,
      y,
      m,
      b,
      N,
      d,
      S,
      C
    );
    let {
      nChangePreceding: G,
      aEndPreceding: Q,
      bEndPreceding: P,
      nCommonPreceding: k,
      aCommonPreceding: H,
      bCommonPreceding: Y,
      nCommonFollowing: R,
      aCommonFollowing: L,
      bCommonFollowing: x,
      nChangeFollowing: J,
      aStartFollowing: D,
      bStartFollowing: V
    } = C;
    g < Q && m < P && f(
      G,
      g,
      Q,
      m,
      P,
      E,
      $,
      d,
      S,
      C
    ), k !== 0 && O(k, H, Y), R !== 0 && O(R, L, x), D < y && V < b && f(
      J,
      D,
      y,
      V,
      b,
      E,
      $,
      d,
      S,
      C
    );
  }, "findSubsequences"), p = /* @__PURE__ */ i((h, g) => {
    if (typeof g != "number")
      throw new TypeError(`${t}: ${h} typeof ${typeof g} is not a number`);
    if (!Number.isSafeInteger(g))
      throw new RangeError(`${t}: ${h} value ${g} is not a safe integer`);
    if (g < 0)
      throw new RangeError(`${t}: ${h} value ${g} is a negative integer`);
  }, "validateLength"), a = /* @__PURE__ */ i((h, g) => {
    let y = typeof g;
    if (y !== "function")
      throw new TypeError(`${t}: ${h} typeof ${y} is not a function`);
  }, "validateCallback");
  function _(h, g, y, m) {
    p("aLength", h), p("bLength", g), a("isCommon", y), a("foundSubsequence", m);
    let b = n(0, h, 0, g, y);
    if (b !== 0 && m(b, 0, 0), h !== b || g !== b) {
      let E = b, $ = b, d = r(
        E,
        h - 1,
        $,
        g - 1,
        y
      ), S = h - d, C = g - d, O = b + d;
      h !== O && g !== O && f(
        0,
        E,
        S,
        $,
        C,
        !1,
        [
          {
            foundSubsequence: m,
            isCommon: y
          }
        ],
        [e],
        [e],
        {
          aCommonFollowing: e,
          aCommonPreceding: e,
          aEndPreceding: e,
          aStartFollowing: e,
          bCommonFollowing: e,
          bCommonPreceding: e,
          bEndPreceding: e,
          bStartFollowing: e,
          nChangeFollowing: e,
          nChangePreceding: e,
          nCommonFollowing: e,
          nCommonPreceding: e
        }
      ), d !== 0 && m(d, S, C);
    }
  }
  return i(_, "diffSequence"), Vt;
}
i(ys, "requireBuild");
var ds = ys(), Yn = /* @__PURE__ */ On(ds);
function bs(t, e) {
  return t.replace(/\s+$/, (n) => e(n));
}
i(bs, "formatTrailingSpaces");
function $e(t, e, n, r, o, s) {
  return t.length !== 0 ? n(
    `${r} ${bs(t, o)}`
  ) : r !== " " ? n(r) : e && s.length !== 0 ? n(`${r} ${s}`) : "";
}
i($e, "printDiffLine");
function Wn(t, e, {
  aColor: n,
  aIndicator: r,
  changeLineTrailingSpaceColor: o,
  emptyFirstOrLastLinePlaceholder: s
}) {
  return $e(
    t,
    e,
    n,
    r,
    o,
    s
  );
}
i(Wn, "printDeleteLine");
function Vn(t, e, {
  bColor: n,
  bIndicator: r,
  changeLineTrailingSpaceColor: o,
  emptyFirstOrLastLinePlaceholder: s
}) {
  return $e(
    t,
    e,
    n,
    r,
    o,
    s
  );
}
i(Vn, "printInsertLine");
function Kn(t, e, {
  commonColor: n,
  commonIndicator: r,
  commonLineTrailingSpaceColor: o,
  emptyFirstOrLastLinePlaceholder: s
}) {
  return $e(
    t,
    e,
    n,
    r,
    o,
    s
  );
}
i(Kn, "printCommonLine");
function Rn(t, e, n, r, { patchColor: o }) {
  return o(
    `@@ -${t + 1},${e - t} +${n + 1},${r - n} @@`
  );
}
i(Rn, "createPatchMark");
function Ss(t, e) {
  let n = t.length, r = e.contextLines, o = r + r, s = n, c = !1, u = 0, l = 0;
  for (; l !== n; ) {
    let d = l;
    for (; l !== n && t[l][0] === M; )
      l += 1;
    if (d !== l)
      if (d === 0)
        l > r && (s -= l - r, c = !0);
      else if (l === n) {
        let S = l - d;
        S > r && (s -= S - r, c = !0);
      } else {
        let S = l - d;
        S > o && (s -= S - o, u += 1);
      }
    for (; l !== n && t[l][0] !== M; )
      l += 1;
  }
  let f = u !== 0 || c;
  u !== 0 ? s += u + 1 : c && (s += 1);
  let p = s - 1, a = [], _ = 0;
  f && a.push("");
  let h = 0, g = 0, y = 0, m = 0, b = /* @__PURE__ */ i((d) => {
    let S = a.length;
    a.push(Kn(d, S === 0 || S === p, e)), y += 1, m += 1;
  }, "pushCommonLine"), E = /* @__PURE__ */ i((d) => {
    let S = a.length;
    a.push(Wn(d, S === 0 || S === p, e)), y += 1;
  }, "pushDeleteLine"), $ = /* @__PURE__ */ i((d) => {
    let S = a.length;
    a.push(Vn(d, S === 0 || S === p, e)), m += 1;
  }, "pushInsertLine");
  for (l = 0; l !== n; ) {
    let d = l;
    for (; l !== n && t[l][0] === M; )
      l += 1;
    if (d !== l)
      if (d === 0) {
        l > r && (d = l - r, h = d, g = d, y = h, m = g);
        for (let S = d; S !== l; S += 1)
          b(t[S][1]);
      } else if (l === n) {
        let S = l - d > r ? d + r : l;
        for (let C = d; C !== S; C += 1)
          b(t[C][1]);
      } else {
        let S = l - d;
        if (S > o) {
          let C = d + r;
          for (let N = d; N !== C; N += 1)
            b(t[N][1]);
          a[_] = Rn(
            h,
            y,
            g,
            m,
            e
          ), _ = a.length, a.push("");
          let O = S - o;
          h = y + O, g = m + O, y = h, m = g;
          for (let N = l - r; N !== l; N += 1)
            b(t[N][1]);
        } else
          for (let C = d; C !== l; C += 1)
            b(t[C][1]);
      }
    for (; l !== n && t[l][0] === z; )
      E(t[l][1]), l += 1;
    for (; l !== n && t[l][0] === F; )
      $(t[l][1]), l += 1;
  }
  return f && (a[_] = Rn(h, y, g, m, e)), a.join(`
`);
}
i(Ss, "joinAlignedDiffsNoExpand");
function _s(t, e) {
  return t.map((n, r, o) => {
    let s = n[1], c = r === 0 || r === o.length - 1;
    switch (n[0]) {
      case z:
        return Wn(s, c, e);
      case F:
        return Vn(s, c, e);
      default:
        return Kn(s, c, e);
    }
  }).join(`
`);
}
i(_s, "joinAlignedDiffsExpand");
var Se = /* @__PURE__ */ i((t) => t, "noColor"), qn = 5, Es = 0;
function Os() {
  return {
    aAnnotation: "Expected",
    aColor: v.green,
    aIndicator: "-",
    bAnnotation: "Received",
    bColor: v.red,
    bIndicator: "+",
    changeColor: v.inverse,
    changeLineTrailingSpaceColor: Se,
    commonColor: v.dim,
    commonIndicator: " ",
    commonLineTrailingSpaceColor: Se,
    compareKeys: void 0,
    contextLines: qn,
    emptyFirstOrLastLinePlaceholder: "",
    expand: !0,
    includeChangeCounts: !1,
    omitAnnotationLines: !1,
    patchColor: v.yellow,
    truncateThreshold: Es,
    truncateAnnotation: "... Diff result is truncated",
    truncateAnnotationColor: Se
  };
}
i(Os, "getDefaultOptions");
function ws(t) {
  return t && typeof t == "function" ? t : void 0;
}
i(ws, "getCompareKeys");
function Cs(t) {
  return typeof t == "number" && Number.isSafeInteger(t) && t >= 0 ? t : qn;
}
i(Cs, "getContextLines");
function mt(t = {}) {
  return {
    ...Os(),
    ...t,
    compareKeys: ws(t.compareKeys),
    contextLines: Cs(t.contextLines)
  };
}
i(mt, "normalizeDiffOptions");
function bt(t) {
  return t.length === 1 && t[0].length === 0;
}
i(bt, "isEmptyString");
function $s(t) {
  let e = 0, n = 0;
  return t.forEach((r) => {
    switch (r[0]) {
      case z:
        e += 1;
        break;
      case F:
        n += 1;
        break;
    }
  }), { a: e, b: n };
}
i($s, "countChanges");
function Ts({
  aAnnotation: t,
  aColor: e,
  aIndicator: n,
  bAnnotation: r,
  bColor: o,
  bIndicator: s,
  includeChangeCounts: c,
  omitAnnotationLines: u
}, l) {
  if (u)
    return "";
  let f = "", p = "";
  if (c) {
    let h = String(l.a), g = String(l.b), y = r.length - t.length, m = " ".repeat(Math.max(0, y)), b = " ".repeat(Math.max(0, -y)), E = g.length -
    h.length, $ = " ".repeat(Math.max(0, E)), d = " ".repeat(Math.max(0, -E));
    f = `${m}  ${n} ${$}${h}`, p = `${b}  ${s} ${d}${g}`;
  }
  let a = `${n} ${t}${f}`, _ = `${s} ${r}${p}`;
  return `${e(a)}
${o(_)}

`;
}
i(Ts, "printAnnotation");
function Te(t, e, n) {
  return Ts(n, $s(t)) + (n.expand ? _s(t, n) : Ss(t, n)) + (e ? n.truncateAnnotationColor(`
${n.truncateAnnotation}`) : "");
}
i(Te, "printDiffLines");
function qt(t, e, n) {
  let r = mt(n), [o, s] = Gn(
    bt(t) ? [] : t,
    bt(e) ? [] : e,
    r
  );
  return Te(o, s, r);
}
i(qt, "diffLinesUnified");
function As(t, e, n, r, o) {
  if (bt(t) && bt(n) && (t = [], n = []), bt(e) && bt(r) && (e = [], r = []), t.length !== n.length || e.length !== r.length)
    return qt(t, e, o);
  let [s, c] = Gn(
    n,
    r,
    o
  ), u = 0, l = 0;
  return s.forEach((f) => {
    switch (f[0]) {
      case z:
        f[1] = t[u], u += 1;
        break;
      case F:
        f[1] = e[l], l += 1;
        break;
      default:
        f[1] = e[l], u += 1, l += 1;
    }
  }), Te(s, c, mt(o));
}
i(As, "diffLinesUnified2");
function Gn(t, e, n) {
  let r = n?.truncateThreshold ?? !1, o = Math.max(
    Math.floor(n?.truncateThreshold ?? 0),
    0
  ), s = r ? Math.min(t.length, o) : t.length, c = r ? Math.min(e.length, o) : e.length, u = s !== t.length || c !== e.length, l = /* @__PURE__ */ i(
  (h, g) => t[h] === e[g], "isCommon"), f = [], p = 0, a = 0;
  for (Yn(s, c, l, /* @__PURE__ */ i((h, g, y) => {
    for (; p !== g; p += 1)
      f.push(new I(z, t[p]));
    for (; a !== y; a += 1)
      f.push(new I(F, e[a]));
    for (; h !== 0; h -= 1, p += 1, a += 1)
      f.push(new I(M, e[a]));
  }, "foundSubsequence")); p !== s; p += 1)
    f.push(new I(z, t[p]));
  for (; a !== c; a += 1)
    f.push(new I(F, e[a]));
  return [f, u];
}
i(Gn, "diffLinesRaw");
function Pn(t) {
  return t.includes(`\r
`) ? `\r
` : `
`;
}
i(Pn, "getNewLineSymbol");
function Ns(t, e, n) {
  let r = n?.truncateThreshold ?? !1, o = Math.max(
    Math.floor(n?.truncateThreshold ?? 0),
    0
  ), s = t.length, c = e.length;
  if (r) {
    let h = t.includes(`
`), g = e.includes(`
`), y = Pn(t), m = Pn(e), b = h ? `${t.split(y, o).join(y)}
` : t, E = g ? `${e.split(m, o).join(m)}
` : e;
    s = b.length, c = E.length;
  }
  let u = s !== t.length || c !== e.length, l = /* @__PURE__ */ i((h, g) => t[h] === e[g], "isCommon"), f = 0, p = 0, a = [];
  return Yn(s, c, l, /* @__PURE__ */ i((h, g, y) => {
    f !== g && a.push(new I(z, t.slice(f, g))), p !== y && a.push(new I(F, e.slice(p, y))), f = g + h, p = y + h, a.push(new I(M, e.slice(y,
    p)));
  }, "foundSubsequence")), f !== s && a.push(new I(z, t.slice(f))), p !== c && a.push(new I(F, e.slice(p))), [a, u];
}
i(Ns, "diffStrings");
function Is(t, e, n) {
  return e.reduce(
    (r, o) => r + (o[0] === M ? o[1] : o[0] === t && o[1].length !== 0 ? n(o[1]) : ""),
    ""
  );
}
i(Is, "concatenateRelevantDiffs");
var Kt = class {
  static {
    i(this, "ChangeBuffer");
  }
  op;
  line;
  // incomplete line
  lines;
  // complete lines
  changeColor;
  constructor(e, n) {
    this.op = e, this.line = [], this.lines = [], this.changeColor = n;
  }
  pushSubstring(e) {
    this.pushDiff(new I(this.op, e));
  }
  pushLine() {
    this.lines.push(
      this.line.length !== 1 ? new I(
        this.op,
        Is(this.op, this.line, this.changeColor)
      ) : this.line[0][0] === this.op ? this.line[0] : new I(this.op, this.line[0][1])
      // was common diff
    ), this.line.length = 0;
  }
  isLineEmpty() {
    return this.line.length === 0;
  }
  // Minor input to buffer.
  pushDiff(e) {
    this.line.push(e);
  }
  // Main input to buffer.
  align(e) {
    let n = e[1];
    if (n.includes(`
`)) {
      let r = n.split(`
`), o = r.length - 1;
      r.forEach((s, c) => {
        c < o ? (this.pushSubstring(s), this.pushLine()) : s.length !== 0 && this.pushSubstring(s);
      });
    } else
      this.pushDiff(e);
  }
  // Output from buffer.
  moveLinesTo(e) {
    this.isLineEmpty() || this.pushLine(), e.push(...this.lines), this.lines.length = 0;
  }
}, Ee = class {
  static {
    i(this, "CommonBuffer");
  }
  deleteBuffer;
  insertBuffer;
  lines;
  constructor(e, n) {
    this.deleteBuffer = e, this.insertBuffer = n, this.lines = [];
  }
  pushDiffCommonLine(e) {
    this.lines.push(e);
  }
  pushDiffChangeLines(e) {
    let n = e[1].length === 0;
    (!n || this.deleteBuffer.isLineEmpty()) && this.deleteBuffer.pushDiff(e), (!n || this.insertBuffer.isLineEmpty()) && this.insertBuffer.pushDiff(
    e);
  }
  flushChangeLines() {
    this.deleteBuffer.moveLinesTo(this.lines), this.insertBuffer.moveLinesTo(this.lines);
  }
  // Input to buffer.
  align(e) {
    let n = e[0], r = e[1];
    if (r.includes(`
`)) {
      let o = r.split(`
`), s = o.length - 1;
      o.forEach((c, u) => {
        if (u === 0) {
          let l = new I(n, c);
          this.deleteBuffer.isLineEmpty() && this.insertBuffer.isLineEmpty() ? (this.flushChangeLines(), this.pushDiffCommonLine(l)) : (this.
          pushDiffChangeLines(l), this.flushChangeLines());
        } else u < s ? this.pushDiffCommonLine(new I(n, c)) : c.length !== 0 && this.pushDiffChangeLines(new I(n, c));
      });
    } else
      this.pushDiffChangeLines(e);
  }
  // Output from buffer.
  getLines() {
    return this.flushChangeLines(), this.lines;
  }
};
function Rs(t, e) {
  let n = new Kt(z, e), r = new Kt(F, e), o = new Ee(n, r);
  return t.forEach((s) => {
    switch (s[0]) {
      case z:
        n.align(s);
        break;
      case F:
        r.align(s);
        break;
      default:
        o.align(s);
    }
  }), o.getLines();
}
i(Rs, "getAlignedDiffs");
function Ps(t, e) {
  if (e) {
    let n = t.length - 1;
    return t.some(
      (r, o) => r[0] === M && (o !== n || r[1] !== `
`)
    );
  }
  return t.some((n) => n[0] === M);
}
i(Ps, "hasCommonDiff");
function Ms(t, e, n) {
  if (t !== e && t.length !== 0 && e.length !== 0) {
    let r = t.includes(`
`) || e.includes(`
`), [o, s] = Hn(
      r ? `${t}
` : t,
      r ? `${e}
` : e,
      !0,
      // cleanupSemantic
      n
    );
    if (Ps(o, r)) {
      let c = mt(n), u = Rs(o, c.changeColor);
      return Te(u, s, c);
    }
  }
  return qt(t.split(`
`), e.split(`
`), n);
}
i(Ms, "diffStringsUnified");
function Hn(t, e, n, r) {
  let [o, s] = Ns(t, e, r);
  return n && fs(o), [o, s];
}
i(Hn, "diffStringsRaw");
function Oe(t, e) {
  let { commonColor: n } = mt(e);
  return n(t);
}
i(Oe, "getCommonMessage");
var {
  AsymmetricMatcher: Ls,
  DOMCollection: xs,
  DOMElement: js,
  Immutable: Ds,
  ReactElement: Fs,
  ReactTestComponent: ks
} = Lt, Jn = [
  ks,
  Fs,
  js,
  xs,
  Ds,
  Ls
], we = {
  plugins: Jn
}, Xn = {
  callToJSON: !1,
  maxDepth: 10,
  plugins: Jn
};
function Bs(t, e, n) {
  if (Object.is(t, e))
    return "";
  let r = Cn(t), o = r, s = !1;
  if (r === "object" && typeof t.asymmetricMatch == "function") {
    if (t.$$typeof !== Symbol.for("jest.asymmetricMatcher") || typeof t.getExpectedType != "function")
      return;
    o = t.getExpectedType(), s = o === "string";
  }
  if (o !== Cn(e)) {
    let { aAnnotation: c, aColor: u, aIndicator: l, bAnnotation: f, bColor: p, bIndicator: a } = mt(n), _ = Ce(Xn, n), h = Z(t, _), g = Z(e,
    _), y = `${u(`${l} ${c}:`)} 
${h}`, m = `${p(`${a} ${f}:`)} 
${g}`;
    return `${y}

${m}`;
  }
  if (!s)
    switch (r) {
      case "string":
        return qt(t.split(`
`), e.split(`
`), n);
      case "boolean":
      case "number":
        return zs(t, e, n);
      case "map":
        return _e(Mn(t), Mn(e), n);
      case "set":
        return _e(Ln(t), Ln(e), n);
      default:
        return _e(t, e, n);
    }
}
i(Bs, "diff");
function zs(t, e, n) {
  let r = Z(t, we), o = Z(e, we);
  return r === o ? "" : qt(r.split(`
`), o.split(`
`), n);
}
i(zs, "comparePrimitive");
function Mn(t) {
  return new Map(Array.from(t.entries()).sort());
}
i(Mn, "sortMap");
function Ln(t) {
  return new Set(Array.from(t.values()).sort());
}
i(Ln, "sortSet");
function _e(t, e, n) {
  let r, o = !1;
  try {
    let c = Ce(we, n);
    r = xn(t, e, c, n);
  } catch {
    o = !0;
  }
  let s = Oe(Un, n);
  if (r === void 0 || r === s) {
    let c = Ce(Xn, n);
    r = xn(t, e, c, n), r !== s && !o && (r = `${Oe(
      hs,
      n
    )}

${r}`);
  }
  return r;
}
i(_e, "compareObjects");
function Ce(t, e) {
  let { compareKeys: n } = mt(e);
  return {
    ...t,
    compareKeys: n
  };
}
i(Ce, "getFormatOptions");
function xn(t, e, n, r) {
  let o = { ...n, indent: 0 }, s = Z(t, o), c = Z(e, o);
  if (s === c)
    return Oe(Un, r);
  {
    let u = Z(t, n), l = Z(e, n);
    return As(
      u.split(`
`),
      l.split(`
`),
      s.split(`
`),
      c.split(`
`),
      r
    );
  }
}
i(xn, "getObjectsDifference");
var jn = 2e4;
function Dn(t) {
  return Yt(t) === "Object" && typeof t.asymmetricMatch == "function";
}
i(Dn, "isAsymmetricMatcher");
function Fn(t, e) {
  let n = Yt(t), r = Yt(e);
  return n === r && (n === "Object" || n === "Array");
}
i(Fn, "isReplaceable");
function Zn(t, e, n) {
  let { aAnnotation: r, bAnnotation: o } = mt(n);
  if (typeof t == "string" && typeof e == "string" && t.length > 0 && e.length > 0 && t.length <= jn && e.length <= jn && t !== e) {
    if (t.includes(`
`) || e.includes(`
`))
      return Ms(e, t, n);
    let [p] = Hn(e, t, !0), a = p.some((y) => y[0] === M), _ = Us(r, o), h = _(r) + Vs(
      kn(p, z, a)
    ), g = _(o) + Ws(
      kn(p, F, a)
    );
    return `${h}
${g}`;
  }
  let s = be(t, { forceWritable: !0 }), c = be(e, { forceWritable: !0 }), { replacedExpected: u, replacedActual: l } = Qn(s, c);
  return Bs(u, l, n);
}
i(Zn, "printDiffOrStringify");
function Qn(t, e, n = /* @__PURE__ */ new WeakSet(), r = /* @__PURE__ */ new WeakSet()) {
  return Fn(t, e) ? n.has(t) || r.has(e) ? { replacedActual: t, replacedExpected: e } : (n.add(t), r.add(e), de(e).forEach((o) => {
    let s = e[o], c = t[o];
    if (Dn(s))
      s.asymmetricMatch(c) && (t[o] = s);
    else if (Dn(c))
      c.asymmetricMatch(s) && (e[o] = c);
    else if (Fn(c, s)) {
      let u = Qn(
        c,
        s,
        n,
        r
      );
      t[o] = u.replacedActual, e[o] = u.replacedExpected;
    }
  }), {
    replacedActual: t,
    replacedExpected: e
  }) : { replacedActual: t, replacedExpected: e };
}
i(Qn, "replaceAsymmetricMatcher");
function Us(...t) {
  let e = t.reduce(
    (n, r) => r.length > n ? r.length : n,
    0
  );
  return (n) => `${n}: ${" ".repeat(e - n.length)}`;
}
i(Us, "getLabelPrinter");
var Ys = "\xB7";
function vn(t) {
  return t.replace(/\s+$/gm, (e) => Ys.repeat(e.length));
}
i(vn, "replaceTrailingSpaces");
function Ws(t) {
  return v.red(vn(pt(t)));
}
i(Ws, "printReceived");
function Vs(t) {
  return v.green(vn(pt(t)));
}
i(Vs, "printExpected");
function kn(t, e, n) {
  return t.reduce(
    (r, o) => r + (o[0] === M ? o[1] : o[0] === e ? n ? v.inverse(o[1]) : o[1] : ""),
    ""
  );
}
i(kn, "getCommonAndChangedSubstrings");

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

// src/instrumenter/types.ts
var er = /* @__PURE__ */ ((o) => (o.DONE = "done", o.ERROR = "error", o.ACTIVE = "active", o.WAITING = "waiting", o))(er || {});

// src/instrumenter/instrumenter.ts
var nt = {
  CALL: "storybook/instrumenter/call",
  SYNC: "storybook/instrumenter/sync",
  START: "storybook/instrumenter/start",
  BACK: "storybook/instrumenter/back",
  GOTO: "storybook/instrumenter/goto",
  NEXT: "storybook/instrumenter/next",
  END: "storybook/instrumenter/end"
}, nr = {
  start: !1,
  back: !1,
  goto: !1,
  next: !1,
  end: !1
}, Xs = new Error(
  "This function ran after the play function completed. Did you forget to `await` it?"
), rr = /* @__PURE__ */ i((t) => Object.prototype.toString.call(t) === "[object Object]", "isObject"), Zs = /* @__PURE__ */ i((t) => Object.
prototype.toString.call(t) === "[object Module]", "isModule"), Qs = /* @__PURE__ */ i((t) => {
  if (!rr(t) && !Zs(t))
    return !1;
  if (t.constructor === void 0)
    return !0;
  let e = t.constructor.prototype;
  return !!rr(e);
}, "isInstrumentable"), vs = /* @__PURE__ */ i((t) => {
  try {
    return new t.constructor();
  } catch {
    return {};
  }
}, "construct"), Ne = /* @__PURE__ */ i(() => ({
  renderPhase: void 0,
  isDebugging: !1,
  isPlaying: !1,
  isLocked: !1,
  cursor: 0,
  calls: [],
  shadowCalls: [],
  callRefsByResult: /* @__PURE__ */ new Map(),
  chainedCallIds: /* @__PURE__ */ new Set(),
  ancestors: [],
  playUntil: void 0,
  resolvers: {},
  syncTimeout: void 0
}), "getInitialState"), or = /* @__PURE__ */ i((t, e = !1) => {
  let n = (e ? t.shadowCalls : t.calls).filter((o) => o.retain);
  if (!n.length)
    return;
  let r = new Map(
    Array.from(t.callRefsByResult.entries()).filter(([, o]) => o.retain)
  );
  return { cursor: n.length, calls: n, callRefsByResult: r };
}, "getRetainedState"), Ie = class {
  constructor() {
    this.initialized = !1;
    this.channel = ir.addons.getChannel(), this.state = U.global.window?.parent.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ || {};
    let e = /* @__PURE__ */ i(({
      storyId: u,
      isPlaying: l = !0,
      isDebugging: f = !1
    }) => {
      let p = this.getState(u);
      this.setState(u, {
        ...Ne(),
        ...or(p, f),
        shadowCalls: f ? p.shadowCalls : [],
        chainedCallIds: f ? p.chainedCallIds : /* @__PURE__ */ new Set(),
        playUntil: f ? p.playUntil : void 0,
        isPlaying: l,
        isDebugging: f
      }), this.sync(u);
    }, "resetState");
    this.channel.on(gt.FORCE_REMOUNT, e), this.channel.on(gt.STORY_RENDER_PHASE_CHANGED, ({ storyId: u, newPhase: l }) => {
      let { isDebugging: f } = this.getState(u);
      this.setState(u, { renderPhase: l }), l === "preparing" && f && e({ storyId: u }), l === "playing" && e({ storyId: u, isDebugging: f }),
      l === "played" && this.setState(u, {
        isLocked: !1,
        isPlaying: !1,
        isDebugging: !1
      }), l === "errored" && this.setState(u, {
        isLocked: !1,
        isPlaying: !1
      });
    }), this.channel.on(gt.SET_CURRENT_STORY, () => {
      this.initialized ? this.cleanup() : this.initialized = !0;
    });
    let n = /* @__PURE__ */ i(({ storyId: u, playUntil: l }) => {
      this.getState(u).isDebugging || this.setState(u, ({ calls: p }) => ({
        calls: [],
        shadowCalls: p.map((a) => ({ ...a, status: "waiting" })),
        isDebugging: !0
      }));
      let f = this.getLog(u);
      this.setState(u, ({ shadowCalls: p }) => {
        if (l || !f.length)
          return { playUntil: l };
        let a = p.findIndex((_) => _.id === f[0].callId);
        return {
          playUntil: p.slice(0, a).filter((_) => _.interceptable && !_.ancestors?.length).slice(-1)[0]?.id
        };
      }), this.channel.emit(gt.FORCE_REMOUNT, { storyId: u, isDebugging: !0 });
    }, "start"), r = /* @__PURE__ */ i(({ storyId: u }) => {
      let l = this.getLog(u).filter((p) => !p.ancestors?.length), f = l.reduceRight((p, a, _) => p >= 0 || a.status === "waiting" ? p : _, -1);
      n({ storyId: u, playUntil: l[f - 1]?.callId });
    }, "back"), o = /* @__PURE__ */ i(({ storyId: u, callId: l }) => {
      let { calls: f, shadowCalls: p, resolvers: a } = this.getState(u), _ = f.find(({ id: g }) => g === l), h = p.find(({ id: g }) => g ===
      l);
      if (!_ && h && Object.values(a).length > 0) {
        let g = this.getLog(u).find((y) => y.status === "waiting")?.callId;
        h.id !== g && this.setState(u, { playUntil: h.id }), Object.values(a).forEach((y) => y());
      } else
        n({ storyId: u, playUntil: l });
    }, "goto"), s = /* @__PURE__ */ i(({ storyId: u }) => {
      let { resolvers: l } = this.getState(u);
      if (Object.values(l).length > 0)
        Object.values(l).forEach((f) => f());
      else {
        let f = this.getLog(u).find((p) => p.status === "waiting")?.callId;
        f ? n({ storyId: u, playUntil: f }) : c({ storyId: u });
      }
    }, "next"), c = /* @__PURE__ */ i(({ storyId: u }) => {
      this.setState(u, { playUntil: void 0, isDebugging: !1 }), Object.values(this.getState(u).resolvers).forEach((l) => l());
    }, "end");
    this.channel.on(nt.START, n), this.channel.on(nt.BACK, r), this.channel.on(nt.GOTO, o), this.channel.on(nt.NEXT, s), this.channel.on(nt.
    END, c);
  }
  static {
    i(this, "Instrumenter");
  }
  getState(e) {
    return this.state[e] || Ne();
  }
  setState(e, n) {
    let r = this.getState(e), o = typeof n == "function" ? n(r) : n;
    this.state = { ...this.state, [e]: { ...r, ...o } }, U.global.window?.parent && (U.global.window.parent.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ =
    this.state);
  }
  cleanup() {
    this.state = Object.entries(this.state).reduce(
      (n, [r, o]) => {
        let s = or(o);
        return s && (n[r] = Object.assign(Ne(), s)), n;
      },
      {}
    );
    let e = { controlStates: nr, logItems: [] };
    this.channel.emit(nt.SYNC, e), U.global.window?.parent && (U.global.window.parent.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ = this.
    state);
  }
  getLog(e) {
    let { calls: n, shadowCalls: r } = this.getState(e), o = [...r];
    n.forEach((c, u) => {
      o[u] = c;
    });
    let s = /* @__PURE__ */ new Set();
    return o.reduceRight((c, u) => (u.args.forEach((l) => {
      l?.__callId__ && s.add(l.__callId__);
    }), u.path.forEach((l) => {
      l.__callId__ && s.add(l.__callId__);
    }), (u.interceptable || u.exception) && !s.has(u.id) && (c.unshift({ callId: u.id, status: u.status, ancestors: u.ancestors }), s.add(u.
    id)), c), []);
  }
  // Traverses the object structure to recursively patch all function properties.
  // Returns the original object, or a new object with the same constructor,
  // depending on whether it should mutate.
  instrument(e, n, r = 0) {
    if (!Qs(e))
      return e;
    let { mutate: o = !1, path: s = [] } = n, c = n.getKeys ? n.getKeys(e, r) : Object.keys(e);
    return r += 1, c.reduce(
      (u, l) => {
        let f = ti(e, l);
        if (typeof f?.get == "function") {
          let a = /* @__PURE__ */ i(() => f?.get?.bind(e)?.(), "getter");
          return Object.defineProperty(u, l, {
            get: /* @__PURE__ */ i(() => this.instrument(a(), { ...n, path: s.concat(l) }, r), "get")
          }), u;
        }
        let p = e[l];
        return typeof p != "function" ? (u[l] = this.instrument(p, { ...n, path: s.concat(l) }, r), u) : "__originalFn__" in p && typeof p.__originalFn__ ==
        "function" ? (u[l] = p, u) : (u[l] = (...a) => this.track(l, p, e, a, n), u[l].__originalFn__ = p, Object.defineProperty(u[l], "name",
        { value: l, writable: !1 }), Object.keys(p).length > 0 && Object.assign(
          u[l],
          this.instrument({ ...p }, { ...n, path: s.concat(l) }, r)
        ), u);
      },
      o ? e : vs(e)
    );
  }
  // Monkey patch an object method to record calls.
  // Returns a function that invokes the original function, records the invocation ("call") and
  // returns the original result.
  track(e, n, r, o, s) {
    let c = o?.[0]?.__storyId__ || U.global.__STORYBOOK_PREVIEW__?.selectionStore?.selection?.storyId, { cursor: u, ancestors: l } = this.getState(
    c);
    this.setState(c, { cursor: u + 1 });
    let f = `${l.slice(-1)[0] || c} [${u}] ${e}`, { path: p = [], intercept: a = !1, retain: _ = !1 } = s, h = typeof a == "function" ? a(e,
    p) : a, g = { id: f, cursor: u, storyId: c, ancestors: l, path: p, method: e, args: o, interceptable: h, retain: _ }, m = (h && !l.length ?
    this.intercept : this.invoke).call(this, n, r, g, s);
    return this.instrument(m, { ...s, mutate: !0, path: [{ __callId__: g.id }] });
  }
  intercept(e, n, r, o) {
    let { chainedCallIds: s, isDebugging: c, playUntil: u } = this.getState(r.storyId), l = s.has(r.id);
    return !c || l || u ? (u === r.id && this.setState(r.storyId, { playUntil: void 0 }), this.invoke(e, n, r, o)) : new Promise((f) => {
      this.setState(r.storyId, ({ resolvers: p }) => ({
        isLocked: !1,
        resolvers: { ...p, [r.id]: f }
      }));
    }).then(() => (this.setState(r.storyId, (f) => {
      let { [r.id]: p, ...a } = f.resolvers;
      return { isLocked: !0, resolvers: a };
    }), this.invoke(e, n, r, o)));
  }
  invoke(e, n, r, o) {
    let { callRefsByResult: s, renderPhase: c } = this.getState(r.storyId), u = 25, l = /* @__PURE__ */ i((a, _, h) => {
      if (h.includes(a))
        return "[Circular]";
      if (h = [...h, a], _ > u)
        return "...";
      if (s.has(a))
        return s.get(a);
      if (a instanceof Array)
        return a.map((g) => l(g, ++_, h));
      if (a instanceof Date)
        return { __date__: { value: a.toISOString() } };
      if (a instanceof Error) {
        let { name: g, message: y, stack: m } = a;
        return { __error__: { name: g, message: y, stack: m } };
      }
      if (a instanceof RegExp) {
        let { flags: g, source: y } = a;
        return { __regexp__: { flags: g, source: y } };
      }
      if (a instanceof U.global.window?.HTMLElement) {
        let { prefix: g, localName: y, id: m, classList: b, innerText: E } = a, $ = Array.from(b);
        return { __element__: { prefix: g, localName: y, id: m, classNames: $, innerText: E } };
      }
      return typeof a == "function" ? {
        __function__: { name: "getMockName" in a ? a.getMockName() : a.name }
      } : typeof a == "symbol" ? { __symbol__: { description: a.description } } : typeof a == "object" && a?.constructor?.name && a?.constructor?.
      name !== "Object" ? { __class__: { name: a.constructor.name } } : Object.prototype.toString.call(a) === "[object Object]" ? Object.fromEntries(
        Object.entries(a).map(([g, y]) => [g, l(y, ++_, h)])
      ) : a;
    }, "serializeValues"), f = {
      ...r,
      args: r.args.map((a) => l(a, 0, []))
    };
    r.path.forEach((a) => {
      a?.__callId__ && this.setState(r.storyId, ({ chainedCallIds: _ }) => ({
        chainedCallIds: new Set(Array.from(_).concat(a.__callId__))
      }));
    });
    let p = /* @__PURE__ */ i((a) => {
      if (a instanceof Error) {
        let { name: _, message: h, stack: g, callId: y = r.id } = a, {
          showDiff: m = void 0,
          diff: b = void 0,
          actual: E = void 0,
          expected: $ = void 0
        } = a.name === "AssertionError" ? Ae(a) : a, d = { name: _, message: h, stack: g, callId: y, showDiff: m, diff: b, actual: E, expected: $ };
        if (this.update({ ...f, status: "error", exception: d }), this.setState(r.storyId, (S) => ({
          callRefsByResult: new Map([
            ...Array.from(S.callRefsByResult.entries()),
            [a, { __callId__: r.id, retain: r.retain }]
          ])
        })), r.ancestors?.length)
          throw Object.prototype.hasOwnProperty.call(a, "callId") || Object.defineProperty(a, "callId", { value: r.id }), a;
      }
      throw a;
    }, "handleException");
    try {
      if (c === "played" && !r.retain)
        throw Xs;
      let _ = (o.getArgs ? o.getArgs(r, this.getState(r.storyId)) : r.args).map((g) => typeof g != "function" || Object.keys(g).length ? g :
      (...y) => {
        let { cursor: m, ancestors: b } = this.getState(r.storyId);
        this.setState(r.storyId, { cursor: 0, ancestors: [...b, r.id] });
        let E = /* @__PURE__ */ i(() => this.setState(r.storyId, { cursor: m, ancestors: b }), "restore"), $ = !1;
        try {
          let d = g(...y);
          return d instanceof Promise ? ($ = !0, d.finally(E)) : d;
        } finally {
          $ || E();
        }
      }), h = e.apply(n, _);
      return h && ["object", "function", "symbol"].includes(typeof h) && this.setState(r.storyId, (g) => ({
        callRefsByResult: new Map([
          ...Array.from(g.callRefsByResult.entries()),
          [h, { __callId__: r.id, retain: r.retain }]
        ])
      })), this.update({
        ...f,
        status: h instanceof Promise ? "active" : "done"
      }), h instanceof Promise ? h.then((g) => (this.update({ ...f, status: "done" }), g), p) : h;
    } catch (a) {
      return p(a);
    }
  }
  // Sends the call info to the manager and synchronizes the log.
  update(e) {
    this.channel.emit(nt.CALL, e), this.setState(e.storyId, ({ calls: n }) => {
      let r = n.concat(e).reduce((o, s) => Object.assign(o, { [s.id]: s }), {});
      return {
        // Calls are sorted to ensure parent calls always come before calls in their callback.
        calls: Object.values(r).sort(
          (o, s) => o.id.localeCompare(s.id, void 0, { numeric: !0 })
        )
      };
    }), this.sync(e.storyId);
  }
  // Builds a log of interceptable calls and control states and sends it to the manager.
  // Uses a 0ms debounce because this might get called many times in one tick.
  sync(e) {
    let n = /* @__PURE__ */ i(() => {
      let { isLocked: r, isPlaying: o } = this.getState(e), s = this.getLog(e), c = s.filter(({ ancestors: a }) => !a.length).find((a) => a.
      status === "waiting")?.callId, u = s.some((a) => a.status === "active");
      if (r || u || s.length === 0) {
        let a = { controlStates: nr, logItems: s };
        this.channel.emit(nt.SYNC, a);
        return;
      }
      let l = s.some(
        (a) => a.status === "done" || a.status === "error"
      ), p = { controlStates: {
        start: l,
        back: l,
        goto: !0,
        next: o,
        end: o
      }, logItems: s, pausedAt: c };
      this.channel.emit(nt.SYNC, p);
    }, "synchronize");
    this.setState(e, ({ syncTimeout: r }) => (clearTimeout(r), { syncTimeout: setTimeout(n, 0) }));
  }
};
function cr(t, e = {}) {
  try {
    let n = !1, r = !1;
    return U.global.window?.location?.search?.includes("instrument=true") ? n = !0 : U.global.window?.location?.search?.includes("instrument\
=false") && (r = !0), U.global.window?.parent === U.global.window && !n || r ? t : (U.global.window && !U.global.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__ &&
    (U.global.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__ = new Ie()), (U.global.window?.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__).
    instrument(t, e));
  } catch (n) {
    return sr.once.warn(n), t;
  }
}
i(cr, "instrument");
function ti(t, e) {
  let n = t;
  for (; n != null; ) {
    let r = Object.getOwnPropertyDescriptor(n, e);
    if (r)
      return r;
    n = Object.getPrototypeOf(n);
  }
}
i(ti, "getPropertyDescriptor");
