storybook 9.1.0-alpha.0 → 9.1.0-alpha.10

package/dist/instrumenter/index.js

@@ -1,22 +1,17 @@
-var fr = Object.defineProperty;
-var s = (e, t) => fr(e, "name", { value: t, configurable: !0 });
-var mr = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports);
-
-// (disabled):../node_modules/util/util.js
-var _n = mr(() => {
-});
+var lr = Object.defineProperty;
+var i = (e, t) => lr(e, "name", { value: t, configurable: !0 });
 
 // src/instrumenter/instrumenter.ts
-import { once as Ki } from "storybook/internal/client-logger";
+import { once as qs } from "storybook/internal/client-logger";
 import {
-  FORCE_REMOUNT as sr,
-  SET_CURRENT_STORY as Gi,
-  STORY_RENDER_PHASE_CHANGED as Hi
+  FORCE_REMOUNT as ir,
+  SET_CURRENT_STORY as Ks,
+  STORY_RENDER_PHASE_CHANGED as Gs
 } from "storybook/internal/core-events";
-import { global as U } from "@storybook/global";
+import { global as Z } from "@storybook/global";
 
 // ../node_modules/tinyrainbow/dist/chunk-BVHSVHOK.js
-var pr = {
+var fr = {
   reset: [0, 0],
   bold: [1, 22, "\x1B[22m\x1B[1m"],
   dim: [2, 22, "\x1B[22m\x1B[2m"],
@@ -58,57 +53,57 @@ var pr = {
   bgMagentaBright: [105, 49],
   bgCyanBright: [106, 49],
   bgWhiteBright: [107, 49]
-}, gr = Object.entries(pr);
+}, mr = Object.entries(fr);
 function Ge(e) {
   return String(e);
 }
-s(Ge, "a");
+i(Ge, "a");
 Ge.open = "";
 Ge.close = "";
-function Dt(e = !1) {
+function Ft(e = !1) {
   let t = typeof process < "u" ? process : void 0, n = t?.env || {}, r = t?.argv || [];
   return !("NO_COLOR" in n || r.includes("--no-color")) && ("FORCE_COLOR" in n || r.includes("--color") || t?.platform === "win32" || e && n.
   TERM !== "dumb" || "CI" in n) || typeof window < "u" && !!window.chrome;
 }
-s(Dt, "C");
-function Ft(e = !1) {
-  let t = Dt(e), n = /* @__PURE__ */ s((c, l, u, m) => {
-    let p = "", a = 0;
+i(Ft, "C");
+function jt(e = !1) {
+  let t = Ft(e), n = /* @__PURE__ */ i((c, a, u, m) => {
+    let p = "", l = 0;
     do
-      p += c.substring(a, m) + u, a = m + l.length, m = c.indexOf(l, a);
+      p += c.substring(l, m) + u, l = m + a.length, m = c.indexOf(a, l);
     while (~m);
-    return p + c.substring(a);
-  }, "i"), r = /* @__PURE__ */ s((c, l, u = c) => {
-    let m = /* @__PURE__ */ s((p) => {
-      let a = String(p), S = a.indexOf(l, c.length);
-      return ~S ? c + n(a, l, u, S) + l : c + a + l;
+    return p + c.substring(l);
+  }, "i"), r = /* @__PURE__ */ i((c, a, u = c) => {
+    let m = /* @__PURE__ */ i((p) => {
+      let l = String(p), b = l.indexOf(a, c.length);
+      return ~b ? c + n(l, a, u, b) + a : c + l + a;
     }, "o");
-    return m.open = c, m.close = l, m;
+    return m.open = c, m.close = a, m;
   }, "g"), o = {
     isColorSupported: t
-  }, i = /* @__PURE__ */ s((c) => `\x1B[${c}m`, "d");
-  for (let [c, l] of gr)
+  }, s = /* @__PURE__ */ i((c) => `\x1B[${c}m`, "d");
+  for (let [c, a] of mr)
     o[c] = t ? r(
-      i(l[0]),
-      i(l[1]),
-      l[2]
+      s(a[0]),
+      s(a[1]),
+      a[2]
     ) : Ge;
   return o;
 }
-s(Ft, "p");
+i(jt, "p");
 
 // ../node_modules/tinyrainbow/dist/browser.js
-var v = Ft();
+var v = jt();
 
 // ../node_modules/@vitest/pretty-format/dist/index.js
-function Jt(e, t) {
+function Xt(e, t) {
   return t.forEach(function(n) {
     n && typeof n != "string" && !Array.isArray(n) && Object.keys(n).forEach(function(r) {
       if (r !== "default" && !(r in e)) {
         var o = Object.getOwnPropertyDescriptor(n, r);
         Object.defineProperty(e, r, o.get ? o : {
           enumerable: !0,
-          get: /* @__PURE__ */ s(function() {
+          get: /* @__PURE__ */ i(function() {
             return n[r];
           }, "get")
         });
@@ -116,54 +111,54 @@ function Jt(e, t) {
     });
   }), Object.freeze(e);
 }
-s(Jt, "_mergeNamespaces");
-function hr(e, t) {
+i(Xt, "_mergeNamespaces");
+function pr(e, t) {
   let n = Object.keys(e), r = t === null ? n : n.sort(t);
   if (Object.getOwnPropertySymbols)
     for (let o of Object.getOwnPropertySymbols(e))
       Object.getOwnPropertyDescriptor(e, o).enumerable && r.push(o);
   return r;
 }
-s(hr, "getKeysOfEnumerableProperties");
-function _e(e, t, n, r, o, i, c = ": ") {
-  let l = "", u = 0, m = e.next();
+i(pr, "getKeysOfEnumerableProperties");
+function Ee(e, t, n, r, o, s, c = ": ") {
+  let a = "", u = 0, m = e.next();
   if (!m.done) {
-    l += t.spacingOuter;
+    a += t.spacingOuter;
     let p = n + t.indent;
     for (; !m.done; ) {
-      if (l += p, u++ === t.maxWidth) {
-        l += "\u2026";
+      if (a += p, u++ === t.maxWidth) {
+        a += "\u2026";
         break;
       }
-      let a = i(m.value[0], t, p, r, o), S = i(m.value[1], t, p, r, o);
-      l += a + c + S, m = e.next(), m.done ? t.min || (l += ",") : l += `,${t.spacingInner}`;
+      let l = s(m.value[0], t, p, r, o), b = s(m.value[1], t, p, r, o);
+      a += l + c + b, m = e.next(), m.done ? t.min || (a += ",") : a += `,${t.spacingInner}`;
     }
-    l += t.spacingOuter + n;
+    a += t.spacingOuter + n;
   }
-  return l;
+  return a;
 }
-s(_e, "printIteratorEntries");
-function Qe(e, t, n, r, o, i) {
-  let c = "", l = 0, u = e.next();
+i(Ee, "printIteratorEntries");
+function Qe(e, t, n, r, o, s) {
+  let c = "", a = 0, u = e.next();
   if (!u.done) {
     c += t.spacingOuter;
     let m = n + t.indent;
     for (; !u.done; ) {
-      if (c += m, l++ === t.maxWidth) {
+      if (c += m, a++ === t.maxWidth) {
         c += "\u2026";
         break;
       }
-      c += i(u.value, t, m, r, o), u = e.next(), u.done ? t.min || (c += ",") : c += `,${t.spacingInner}`;
+      c += s(u.value, t, m, r, o), u = e.next(), u.done ? t.min || (c += ",") : c += `,${t.spacingInner}`;
     }
     c += t.spacingOuter + n;
   }
   return c;
 }
-s(Qe, "printIteratorValues");
-function Ne(e, t, n, r, o, i) {
+i(Qe, "printIteratorValues");
+function Ae(e, t, n, r, o, s) {
   let c = "";
   e = e instanceof ArrayBuffer ? new DataView(e) : e;
-  let l = /* @__PURE__ */ s((m) => m instanceof DataView, "isDataView"), u = l(e) ? e.byteLength : e.length;
+  let a = /* @__PURE__ */ i((m) => m instanceof DataView, "isDataView"), u = a(e) ? e.byteLength : e.length;
   if (u > 0) {
     c += t.spacingOuter;
     let m = n + t.indent;
@@ -172,149 +167,149 @@ function Ne(e, t, n, r, o, i) {
         c += "\u2026";
         break;
       }
-      (l(e) || p in e) && (c += i(l(e) ? e.getInt8(p) : e[p], t, m, r, o)), p < u - 1 ? c += `,${t.spacingInner}` : t.min || (c += ",");
+      (a(e) || p in e) && (c += s(a(e) ? e.getInt8(p) : e[p], t, m, r, o)), p < u - 1 ? c += `,${t.spacingInner}` : t.min || (c += ",");
     }
     c += t.spacingOuter + n;
   }
   return c;
 }
-s(Ne, "printListItems");
-function ve(e, t, n, r, o, i) {
-  let c = "", l = hr(e, t.compareKeys);
-  if (l.length > 0) {
+i(Ae, "printListItems");
+function ve(e, t, n, r, o, s) {
+  let c = "", a = pr(e, t.compareKeys);
+  if (a.length > 0) {
     c += t.spacingOuter;
     let u = n + t.indent;
-    for (let m = 0; m < l.length; m++) {
-      let p = l[m], a = i(p, t, u, r, o), S = i(e[p], t, u, r, o);
-      c += `${u + a}: ${S}`, m < l.length - 1 ? c += `,${t.spacingInner}` : t.min || (c += ",");
+    for (let m = 0; m < a.length; m++) {
+      let p = a[m], l = s(p, t, u, r, o), b = s(e[p], t, u, r, o);
+      c += `${u + l}: ${b}`, m < a.length - 1 ? c += `,${t.spacingInner}` : t.min || (c += ",");
     }
     c += t.spacingOuter + n;
   }
   return c;
 }
-s(ve, "printObjectProperties");
-var yr = typeof Symbol == "function" && Symbol.for ? Symbol.for("jest.asymmetricMatcher") : 1267621, Ae = " ", dr = /* @__PURE__ */ s((e, t, n, r, o, i) => {
+i(ve, "printObjectProperties");
+var gr = typeof Symbol == "function" && Symbol.for ? Symbol.for("jest.asymmetricMatcher") : 1267621, we = " ", hr = /* @__PURE__ */ i((e, t, n, r, o, s) => {
   let c = e.toString();
   if (c === "ArrayContaining" || c === "ArrayNotContaining")
-    return ++r > t.maxDepth ? `[${c}]` : `${c + Ae}[${Ne(e.sample, t, n, r, o, i)}]`;
+    return ++r > t.maxDepth ? `[${c}]` : `${c + we}[${Ae(e.sample, t, n, r, o, s)}]`;
   if (c === "ObjectContaining" || c === "ObjectNotContaining")
-    return ++r > t.maxDepth ? `[${c}]` : `${c + Ae}{${ve(e.sample, t, n, r, o, i)}}`;
+    return ++r > t.maxDepth ? `[${c}]` : `${c + we}{${ve(e.sample, t, n, r, o, s)}}`;
   if (c === "StringMatching" || c === "StringNotMatching" || c === "StringContaining" || c === "StringNotContaining")
-    return c + Ae + i(e.sample, t, n, r, o);
+    return c + we + s(e.sample, t, n, r, o);
   if (typeof e.toAsymmetricMatcher != "function")
     throw new TypeError(`Asymmetric matcher ${e.constructor.name} does not implement toAsymmetricMatcher()`);
   return e.toAsymmetricMatcher();
-}, "serialize$5"), br = /* @__PURE__ */ s((e) => e && e.$$typeof === yr, "test$5"), Sr = {
-  serialize: dr,
-  test: br
-}, Er = " ", Xt = /* @__PURE__ */ new Set(["DOMStringMap", "NamedNodeMap"]), _r = /^(?:HTML\w*Collection|NodeList)$/;
+}, "serialize$5"), dr = /* @__PURE__ */ i((e) => e && e.$$typeof === gr, "test$5"), yr = {
+  serialize: hr,
+  test: dr
+}, br = " ", Zt = /* @__PURE__ */ new Set(["DOMStringMap", "NamedNodeMap"]), Sr = /^(?:HTML\w*Collection|NodeList)$/;
+function Er(e) {
+  return Zt.has(e) || Sr.test(e);
+}
+i(Er, "testName");
+var _r = /* @__PURE__ */ i((e) => e && e.constructor && !!e.constructor.name && Er(e.constructor.name), "test$4");
 function Tr(e) {
-  return Xt.has(e) || _r.test(e);
-}
-s(Tr, "testName");
-var Cr = /* @__PURE__ */ s((e) => e && e.constructor && !!e.constructor.name && Tr(e.constructor.name), "test$4");
-function Or(e) {
   return e.constructor.name === "NamedNodeMap";
 }
-s(Or, "isNamedNodeMap");
-var $r = /* @__PURE__ */ s((e, t, n, r, o, i) => {
+i(Tr, "isNamedNodeMap");
+var Cr = /* @__PURE__ */ i((e, t, n, r, o, s) => {
   let c = e.constructor.name;
-  return ++r > t.maxDepth ? `[${c}]` : (t.min ? "" : c + Er) + (Xt.has(c) ? `{${ve(Or(e) ? [...e].reduce((l, u) => (l[u.name] = u.value, l),
-  {}) : { ...e }, t, n, r, o, i)}}` : `[${Ne([...e], t, n, r, o, i)}]`);
-}, "serialize$4"), wr = {
-  serialize: $r,
-  test: Cr
+  return ++r > t.maxDepth ? `[${c}]` : (t.min ? "" : c + br) + (Zt.has(c) ? `{${ve(Tr(e) ? [...e].reduce((a, u) => (a[u.name] = u.value, a),
+  {}) : { ...e }, t, n, r, o, s)}}` : `[${Ae([...e], t, n, r, o, s)}]`);
+}, "serialize$4"), Or = {
+  serialize: Cr,
+  test: _r
 };
-function Zt(e) {
+function Qt(e) {
   return e.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
-s(Zt, "escapeHTML");
-function et(e, t, n, r, o, i, c) {
-  let l = r + n.indent, u = n.colors;
+i(Qt, "escapeHTML");
+function et(e, t, n, r, o, s, c) {
+  let a = r + n.indent, u = n.colors;
   return e.map((m) => {
-    let p = t[m], a = c(p, n, l, o, i);
-    return typeof p != "string" && (a.includes(`
-`) && (a = n.spacingOuter + l + a + n.spacingOuter + r), a = `{${a}}`), `${n.spacingInner + r + u.prop.open + m + u.prop.close}=${u.value.open}${a}${u.
+    let p = t[m], l = c(p, n, a, o, s);
+    return typeof p != "string" && (l.includes(`
+`) && (l = n.spacingOuter + a + l + n.spacingOuter + r), l = `{${l}}`), `${n.spacingInner + r + u.prop.open + m + u.prop.close}=${u.value.open}${l}${u.
     value.close}`;
   }).join("");
 }
-s(et, "printProps");
-function tt(e, t, n, r, o, i) {
-  return e.map((c) => t.spacingOuter + n + (typeof c == "string" ? Qt(c, t) : i(c, t, n, r, o))).join("");
+i(et, "printProps");
+function tt(e, t, n, r, o, s) {
+  return e.map((c) => t.spacingOuter + n + (typeof c == "string" ? vt(c, t) : s(c, t, n, r, o))).join("");
 }
-s(tt, "printChildren");
-function Qt(e, t) {
+i(tt, "printChildren");
+function vt(e, t) {
   let n = t.colors.content;
-  return n.open + Zt(e) + n.close;
+  return n.open + Qt(e) + n.close;
 }
-s(Qt, "printText");
-function Ar(e, t) {
+i(vt, "printText");
+function $r(e, t) {
   let n = t.colors.comment;
-  return `${n.open}<!--${Zt(e)}-->${n.close}`;
+  return `${n.open}<!--${Qt(e)}-->${n.close}`;
 }
-s(Ar, "printComment");
+i($r, "printComment");
 function nt(e, t, n, r, o) {
-  let i = r.colors.tag;
-  return `${i.open}<${e}${t && i.close + t + r.spacingOuter + o + i.open}${n ? `>${i.close}${n}${r.spacingOuter}${o}${i.open}</${e}` : `${t &&
-  !r.min ? "" : " "}/`}>${i.close}`;
+  let s = r.colors.tag;
+  return `${s.open}<${e}${t && s.close + t + r.spacingOuter + o + s.open}${n ? `>${s.close}${n}${r.spacingOuter}${o}${s.open}</${e}` : `${t &&
+  !r.min ? "" : " "}/`}>${s.close}`;
 }
-s(nt, "printElement");
+i(nt, "printElement");
 function rt(e, t) {
   let n = t.colors.tag;
   return `${n.open}<${e}${n.close} \u2026${n.open} />${n.close}`;
 }
-s(rt, "printElementAsLeaf");
-var Rr = 1, vt = 3, en = 8, tn = 11, Nr = /^(?:(?:HTML|SVG)\w*)?Element$/;
-function Ir(e) {
+i(rt, "printElementAsLeaf");
+var wr = 1, en = 3, tn = 8, nn = 11, Rr = /^(?:(?:HTML|SVG)\w*)?Element$/;
+function Ar(e) {
   try {
     return typeof e.hasAttribute == "function" && e.hasAttribute("is");
   } catch {
     return !1;
   }
 }
-s(Ir, "testHasAttribute");
+i(Ar, "testHasAttribute");
 function Pr(e) {
-  let t = e.constructor.name, { nodeType: n, tagName: r } = e, o = typeof r == "string" && r.includes("-") || Ir(e);
-  return n === Rr && (Nr.test(t) || o) || n === vt && t === "Text" || n === en && t === "Comment" || n === tn && t === "DocumentFragment";
+  let t = e.constructor.name, { nodeType: n, tagName: r } = e, o = typeof r == "string" && r.includes("-") || Ar(e);
+  return n === wr && (Rr.test(t) || o) || n === en && t === "Text" || n === tn && t === "Comment" || n === nn && t === "DocumentFragment";
 }
-s(Pr, "testNode");
-var Mr = /* @__PURE__ */ s((e) => {
+i(Pr, "testNode");
+var Nr = /* @__PURE__ */ i((e) => {
   var t;
   return (e == null || (t = e.constructor) === null || t === void 0 ? void 0 : t.name) && Pr(e);
 }, "test$3");
-function Lr(e) {
-  return e.nodeType === vt;
-}
-s(Lr, "nodeIsText");
-function xr(e) {
+function Ir(e) {
   return e.nodeType === en;
 }
-s(xr, "nodeIsComment");
-function He(e) {
+i(Ir, "nodeIsText");
+function Mr(e) {
   return e.nodeType === tn;
 }
-s(He, "nodeIsFragment");
-var Dr = /* @__PURE__ */ s((e, t, n, r, o, i) => {
-  if (Lr(e))
-    return Qt(e.data, t);
-  if (xr(e))
-    return Ar(e.data, t);
+i(Mr, "nodeIsComment");
+function He(e) {
+  return e.nodeType === nn;
+}
+i(He, "nodeIsFragment");
+var Lr = /* @__PURE__ */ i((e, t, n, r, o, s) => {
+  if (Ir(e))
+    return vt(e.data, t);
+  if (Mr(e))
+    return $r(e.data, t);
   let c = He(e) ? "DocumentFragment" : e.tagName.toLowerCase();
-  return ++r > t.maxDepth ? rt(c, t) : nt(c, et(He(e) ? [] : Array.from(e.attributes, (l) => l.name).sort(), He(e) ? {} : [...e.attributes].
-  reduce((l, u) => (l[u.name] = u.value, l), {}), t, n + t.indent, r, o, i), tt(Array.prototype.slice.call(e.childNodes || e.children), t, n +
-  t.indent, r, o, i), t, n);
-}, "serialize$3"), Fr = {
-  serialize: Dr,
-  test: Mr
-}, jr = "@@__IMMUTABLE_ITERABLE__@@", kr = "@@__IMMUTABLE_LIST__@@", Br = "@@__IMMUTABLE_KEYED__@@", zr = "@@__IMMUTABLE_MAP__@@", jt = "@@_\
-_IMMUTABLE_ORDERED__@@", Yr = "@@__IMMUTABLE_RECORD__@@", Ur = "@@__IMMUTABLE_SEQ__@@", Wr = "@@__IMMUTABLE_SET__@@", Vr = "@@__IMMUTABLE_ST\
-ACK__@@", he = /* @__PURE__ */ s((e) => `Immutable.${e}`, "getImmutableName"), Pe = /* @__PURE__ */ s((e) => `[${e}]`, "printAsLeaf"), Ee = "\
- ", kt = "\u2026";
-function qr(e, t, n, r, o, i, c) {
-  return ++r > t.maxDepth ? Pe(he(c)) : `${he(c) + Ee}{${_e(e.entries(), t, n, r, o, i)}}`;
-}
-s(qr, "printImmutableEntries");
-function Kr(e) {
+  return ++r > t.maxDepth ? rt(c, t) : nt(c, et(He(e) ? [] : Array.from(e.attributes, (a) => a.name).sort(), He(e) ? {} : [...e.attributes].
+  reduce((a, u) => (a[u.name] = u.value, a), {}), t, n + t.indent, r, o, s), tt(Array.prototype.slice.call(e.childNodes || e.children), t, n +
+  t.indent, r, o, s), t, n);
+}, "serialize$3"), xr = {
+  serialize: Lr,
+  test: Nr
+}, Dr = "@@__IMMUTABLE_ITERABLE__@@", Fr = "@@__IMMUTABLE_LIST__@@", jr = "@@__IMMUTABLE_KEYED__@@", kr = "@@__IMMUTABLE_MAP__@@", kt = "@@_\
+_IMMUTABLE_ORDERED__@@", Br = "@@__IMMUTABLE_RECORD__@@", zr = "@@__IMMUTABLE_SEQ__@@", Yr = "@@__IMMUTABLE_SET__@@", Ur = "@@__IMMUTABLE_ST\
+ACK__@@", de = /* @__PURE__ */ i((e) => `Immutable.${e}`, "getImmutableName"), Ne = /* @__PURE__ */ i((e) => `[${e}]`, "printAsLeaf"), Se = "\
+ ", Bt = "\u2026";
+function Wr(e, t, n, r, o, s, c) {
+  return ++r > t.maxDepth ? Ne(de(c)) : `${de(c) + Se}{${Ee(e.entries(), t, n, r, o, s)}}`;
+}
+i(Wr, "printImmutableEntries");
+function Vr(e) {
   let t = 0;
   return { next() {
     if (t < e._keys.length) {
@@ -330,45 +325,45 @@ function Kr(e) {
     };
   } };
 }
-s(Kr, "getRecordEntries");
-function Gr(e, t, n, r, o, i) {
-  let c = he(e._name || "Record");
-  return ++r > t.maxDepth ? Pe(c) : `${c + Ee}{${_e(Kr(e), t, n, r, o, i)}}`;
-}
-s(Gr, "printImmutableRecord");
-function Hr(e, t, n, r, o, i) {
-  let c = he("Seq");
-  return ++r > t.maxDepth ? Pe(c) : e[Br] ? `${c + Ee}{${e._iter || e._object ? _e(e.entries(), t, n, r, o, i) : kt}}` : `${c + Ee}[${e._iter ||
-  e._array || e._collection || e._iterable ? Qe(e.values(), t, n, r, o, i) : kt}]`;
-}
-s(Hr, "printImmutableSeq");
-function Je(e, t, n, r, o, i, c) {
-  return ++r > t.maxDepth ? Pe(he(c)) : `${he(c) + Ee}[${Qe(e.values(), t, n, r, o, i)}]`;
-}
-s(Je, "printImmutableValues");
-var Jr = /* @__PURE__ */ s((e, t, n, r, o, i) => e[zr] ? qr(e, t, n, r, o, i, e[jt] ? "OrderedMap" : "Map") : e[kr] ? Je(e, t, n, r, o, i, "\
-List") : e[Wr] ? Je(e, t, n, r, o, i, e[jt] ? "OrderedSet" : "Set") : e[Vr] ? Je(e, t, n, r, o, i, "Stack") : e[Ur] ? Hr(e, t, n, r, o, i) :
-Gr(e, t, n, r, o, i), "serialize$2"), Xr = /* @__PURE__ */ s((e) => e && (e[jr] === !0 || e[Yr] === !0), "test$2"), Zr = {
-  serialize: Jr,
-  test: Xr
+i(Vr, "getRecordEntries");
+function qr(e, t, n, r, o, s) {
+  let c = de(e._name || "Record");
+  return ++r > t.maxDepth ? Ne(c) : `${c + Se}{${Ee(Vr(e), t, n, r, o, s)}}`;
+}
+i(qr, "printImmutableRecord");
+function Kr(e, t, n, r, o, s) {
+  let c = de("Seq");
+  return ++r > t.maxDepth ? Ne(c) : e[jr] ? `${c + Se}{${e._iter || e._object ? Ee(e.entries(), t, n, r, o, s) : Bt}}` : `${c + Se}[${e._iter ||
+  e._array || e._collection || e._iterable ? Qe(e.values(), t, n, r, o, s) : Bt}]`;
+}
+i(Kr, "printImmutableSeq");
+function Je(e, t, n, r, o, s, c) {
+  return ++r > t.maxDepth ? Ne(de(c)) : `${de(c) + Se}[${Qe(e.values(), t, n, r, o, s)}]`;
+}
+i(Je, "printImmutableValues");
+var Gr = /* @__PURE__ */ i((e, t, n, r, o, s) => e[kr] ? Wr(e, t, n, r, o, s, e[kt] ? "OrderedMap" : "Map") : e[Fr] ? Je(e, t, n, r, o, s, "\
+List") : e[Yr] ? Je(e, t, n, r, o, s, e[kt] ? "OrderedSet" : "Set") : e[Ur] ? Je(e, t, n, r, o, s, "Stack") : e[zr] ? Kr(e, t, n, r, o, s) :
+qr(e, t, n, r, o, s), "serialize$2"), Hr = /* @__PURE__ */ i((e) => e && (e[Dr] === !0 || e[Br] === !0), "test$2"), Jr = {
+  serialize: Gr,
+  test: Hr
 };
-function nn(e) {
+function rn(e) {
   return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
 }
-s(nn, "getDefaultExportFromCjs");
+i(rn, "getDefaultExportFromCjs");
 var Xe = { exports: {} };
-var R = {};
-var Bt;
-function Qr() {
-  return Bt || (Bt = 1, function() {
+var A = {};
+var zt;
+function Xr() {
+  return zt || (zt = 1, function() {
     function e(f) {
       if (typeof f == "object" && f !== null) {
-        var y = f.$$typeof;
-        switch (y) {
+        var d = f.$$typeof;
+        switch (d) {
           case t:
             switch (f = f.type, f) {
               case r:
-              case i:
+              case s:
               case o:
               case m:
               case p:
@@ -376,111 +371,111 @@ function Qr() {
                 return f;
               default:
                 switch (f = f && f.$$typeof, f) {
-                  case l:
-                  case u:
-                  case S:
                   case a:
+                  case u:
+                  case b:
+                  case l:
                     return f;
                   case c:
                     return f;
                   default:
-                    return y;
+                    return d;
                 }
             }
           case n:
-            return y;
+            return d;
         }
       }
     }
-    s(e, "typeOf");
+    i(e, "typeOf");
     var t = Symbol.for("react.transitional.element"), n = Symbol.for("react.portal"), r = Symbol.for("react.fragment"), o = Symbol.for("reac\
-t.strict_mode"), i = Symbol.for("react.profiler"), c = Symbol.for("react.consumer"), l = Symbol.for("react.context"), u = Symbol.for("react.\
-forward_ref"), m = Symbol.for("react.suspense"), p = Symbol.for("react.suspense_list"), a = Symbol.for("react.memo"), S = Symbol.for("react.\
+t.strict_mode"), s = Symbol.for("react.profiler"), c = Symbol.for("react.consumer"), a = Symbol.for("react.context"), u = Symbol.for("react.\
+forward_ref"), m = Symbol.for("react.suspense"), p = Symbol.for("react.suspense_list"), l = Symbol.for("react.memo"), b = Symbol.for("react.\
 lazy"), g = Symbol.for("react.view_transition"), h = Symbol.for("react.client.reference");
-    R.ContextConsumer = c, R.ContextProvider = l, R.Element = t, R.ForwardRef = u, R.Fragment = r, R.Lazy = S, R.Memo = a, R.Portal = n, R.Profiler =
-    i, R.StrictMode = o, R.Suspense = m, R.SuspenseList = p, R.isContextConsumer = function(f) {
+    A.ContextConsumer = c, A.ContextProvider = a, A.Element = t, A.ForwardRef = u, A.Fragment = r, A.Lazy = b, A.Memo = l, A.Portal = n, A.Profiler =
+    s, A.StrictMode = o, A.Suspense = m, A.SuspenseList = p, A.isContextConsumer = function(f) {
       return e(f) === c;
-    }, R.isContextProvider = function(f) {
-      return e(f) === l;
-    }, R.isElement = function(f) {
+    }, A.isContextProvider = function(f) {
+      return e(f) === a;
+    }, A.isElement = function(f) {
       return typeof f == "object" && f !== null && f.$$typeof === t;
-    }, R.isForwardRef = function(f) {
+    }, A.isForwardRef = function(f) {
       return e(f) === u;
-    }, R.isFragment = function(f) {
+    }, A.isFragment = function(f) {
       return e(f) === r;
-    }, R.isLazy = function(f) {
-      return e(f) === S;
-    }, R.isMemo = function(f) {
-      return e(f) === a;
-    }, R.isPortal = function(f) {
+    }, A.isLazy = function(f) {
+      return e(f) === b;
+    }, A.isMemo = function(f) {
+      return e(f) === l;
+    }, A.isPortal = function(f) {
       return e(f) === n;
-    }, R.isProfiler = function(f) {
-      return e(f) === i;
-    }, R.isStrictMode = function(f) {
+    }, A.isProfiler = function(f) {
+      return e(f) === s;
+    }, A.isStrictMode = function(f) {
       return e(f) === o;
-    }, R.isSuspense = function(f) {
+    }, A.isSuspense = function(f) {
       return e(f) === m;
-    }, R.isSuspenseList = function(f) {
+    }, A.isSuspenseList = function(f) {
       return e(f) === p;
-    }, R.isValidElementType = function(f) {
-      return typeof f == "string" || typeof f == "function" || f === r || f === i || f === o || f === m || f === p || typeof f == "object" &&
-      f !== null && (f.$$typeof === S || f.$$typeof === a || f.$$typeof === l || f.$$typeof === c || f.$$typeof === u || f.$$typeof === h ||
+    }, A.isValidElementType = function(f) {
+      return typeof f == "string" || typeof f == "function" || f === r || f === s || f === o || f === m || f === p || typeof f == "object" &&
+      f !== null && (f.$$typeof === b || f.$$typeof === l || f.$$typeof === a || f.$$typeof === c || f.$$typeof === u || f.$$typeof === h ||
       f.getModuleId !== void 0);
-    }, R.typeOf = e;
-  }()), R;
+    }, A.typeOf = e;
+  }()), A;
 }
-s(Qr, "requireReactIs_development$1");
-var zt;
-function vr() {
-  return zt || (zt = 1, Xe.exports = Qr()), Xe.exports;
+i(Xr, "requireReactIs_development$1");
+var Yt;
+function Zr() {
+  return Yt || (Yt = 1, Xe.exports = Xr()), Xe.exports;
 }
-s(vr, "requireReactIs$1");
-var rn = vr(), eo = /* @__PURE__ */ nn(rn), to = /* @__PURE__ */ Jt({
+i(Zr, "requireReactIs$1");
+var on = Zr(), Qr = /* @__PURE__ */ rn(on), vr = /* @__PURE__ */ Xt({
   __proto__: null,
-  default: eo
-}, [rn]), Ze = { exports: {} };
+  default: Qr
+}, [on]), Ze = { exports: {} };
 var w = {};
-var Yt;
-function no() {
-  return Yt || (Yt = 1, function() {
+var Ut;
+function eo() {
+  return Ut || (Ut = 1, function() {
     var e = Symbol.for("react.element"), t = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), r = Symbol.for("react.strict_mode"),
-    o = Symbol.for("react.profiler"), i = Symbol.for("react.provider"), c = Symbol.for("react.context"), l = Symbol.for("react.server_contex\
-t"), u = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), p = Symbol.for("react.suspense_list"), a = Symbol.for("react.mem\
-o"), S = Symbol.for("react.lazy"), g = Symbol.for("react.offscreen"), h = !1, f = !1, y = !1, b = !1, _ = !1, O;
+    o = Symbol.for("react.profiler"), s = Symbol.for("react.provider"), c = Symbol.for("react.context"), a = Symbol.for("react.server_contex\
+t"), u = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), p = Symbol.for("react.suspense_list"), l = Symbol.for("react.mem\
+o"), b = Symbol.for("react.lazy"), g = Symbol.for("react.offscreen"), h = !1, f = !1, d = !1, S = !1, _ = !1, O;
     O = Symbol.for("react.module.reference");
-    function d(C) {
-      return !!(typeof C == "string" || typeof C == "function" || C === n || C === o || _ || C === r || C === m || C === p || b || C === g ||
-      h || f || y || typeof C == "object" && C !== null && (C.$$typeof === S || C.$$typeof === a || C.$$typeof === i || C.$$typeof === c || C.
+    function y(C) {
+      return !!(typeof C == "string" || typeof C == "function" || C === n || C === o || _ || C === r || C === m || C === p || S || C === g ||
+      h || f || d || typeof C == "object" && C !== null && (C.$$typeof === b || C.$$typeof === l || C.$$typeof === s || C.$$typeof === c || C.
       $$typeof === u || // This needs to include all possible module reference object
       // types supported by any Flight configuration anywhere since
       // we don't know which Flight build this will end up being used
       // with.
       C.$$typeof === O || C.getModuleId !== void 0));
     }
-    s(d, "isValidElementType");
+    i(y, "isValidElementType");
     function E(C) {
       if (typeof C == "object" && C !== null) {
         var Ke = C.$$typeof;
         switch (Ke) {
           case e:
-            var we = C.type;
-            switch (we) {
+            var $e = C.type;
+            switch ($e) {
               case n:
               case o:
               case r:
               case m:
               case p:
-                return we;
+                return $e;
               default:
-                var xt = we && we.$$typeof;
-                switch (xt) {
-                  case l:
+                var Dt = $e && $e.$$typeof;
+                switch (Dt) {
+                  case a:
                   case c:
                   case u:
-                  case S:
-                  case a:
-                  case i:
-                    return xt;
+                  case b:
+                  case l:
+                  case s:
+                    return Dt;
                   default:
                     return Ke;
                 }
@@ -490,79 +485,79 @@ o"), S = Symbol.for("react.lazy"), g = Symbol.for("react.offscreen"), h = !1, f
         }
       }
     }
-    s(E, "typeOf");
-    var $ = c, T = i, A = e, G = u, Q = n, P = S, k = a, H = t, Y = o, I = r, L = m, x = p, J = !1, F = !1;
-    function V(C) {
-      return J || (J = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.")), !1;
+    i(E, "typeOf");
+    var $ = c, T = s, R = e, K = u, Q = n, I = b, k = l, G = t, Y = o, N = r, L = m, x = p, H = !1, F = !1;
+    function W(C) {
+      return H || (H = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.")), !1;
     }
-    s(V, "isAsyncMode");
+    i(W, "isAsyncMode");
     function re(C) {
       return F || (F = !0, console.warn("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.")), !1;
     }
-    s(re, "isConcurrentMode");
-    function q(C) {
+    i(re, "isConcurrentMode");
+    function V(C) {
       return E(C) === c;
     }
-    s(q, "isContextConsumer");
-    function K(C) {
-      return E(C) === i;
+    i(V, "isContextConsumer");
+    function q(C) {
+      return E(C) === s;
     }
-    s(K, "isContextProvider");
-    function ie(C) {
+    i(q, "isContextProvider");
+    function se(C) {
       return typeof C == "object" && C !== null && C.$$typeof === e;
     }
-    s(ie, "isElement");
-    function X(C) {
+    i(se, "isElement");
+    function J(C) {
       return E(C) === u;
     }
-    s(X, "isForwardRef");
-    function W(C) {
+    i(J, "isForwardRef");
+    function U(C) {
       return E(C) === n;
     }
-    s(W, "isFragment");
+    i(U, "isFragment");
     function oe(C) {
-      return E(C) === S;
+      return E(C) === b;
     }
-    s(oe, "isLazy");
-    function ge(C) {
-      return E(C) === a;
+    i(oe, "isLazy");
+    function he(C) {
+      return E(C) === l;
     }
-    s(ge, "isMemo");
+    i(he, "isMemo");
     function ue(C) {
       return E(C) === t;
     }
-    s(ue, "isPortal");
-    function Se(C) {
+    i(ue, "isPortal");
+    function be(C) {
       return E(C) === o;
     }
-    s(Se, "isProfiler");
-    function Oe(C) {
+    i(be, "isProfiler");
+    function Ce(C) {
       return E(C) === r;
     }
-    s(Oe, "isStrictMode");
-    function $e(C) {
+    i(Ce, "isStrictMode");
+    function Oe(C) {
       return E(C) === m;
     }
-    s($e, "isSuspense");
+    i(Oe, "isSuspense");
     function ar(C) {
       return E(C) === p;
     }
-    s(ar, "isSuspenseList"), w.ContextConsumer = $, w.ContextProvider = T, w.Element = A, w.ForwardRef = G, w.Fragment = Q, w.Lazy = P, w.Memo =
-    k, w.Portal = H, w.Profiler = Y, w.StrictMode = I, w.Suspense = L, w.SuspenseList = x, w.isAsyncMode = V, w.isConcurrentMode = re, w.isContextConsumer =
-    q, w.isContextProvider = K, w.isElement = ie, w.isForwardRef = X, w.isFragment = W, w.isLazy = oe, w.isMemo = ge, w.isPortal = ue, w.isProfiler =
-    Se, w.isStrictMode = Oe, w.isSuspense = $e, w.isSuspenseList = ar, w.isValidElementType = d, w.typeOf = E;
+    i(ar, "isSuspenseList"), w.ContextConsumer = $, w.ContextProvider = T, w.Element = R, w.ForwardRef = K, w.Fragment = Q, w.Lazy = I, w.Memo =
+    k, w.Portal = G, w.Profiler = Y, w.StrictMode = N, w.Suspense = L, w.SuspenseList = x, w.isAsyncMode = W, w.isConcurrentMode = re, w.isContextConsumer =
+    V, w.isContextProvider = q, w.isElement = se, w.isForwardRef = J, w.isFragment = U, w.isLazy = oe, w.isMemo = he, w.isPortal = ue, w.isProfiler =
+    be, w.isStrictMode = Ce, w.isSuspense = Oe, w.isSuspenseList = ar, w.isValidElementType = y, w.typeOf = E;
   }()), w;
 }
-s(no, "requireReactIs_development");
-var Ut;
-function ro() {
-  return Ut || (Ut = 1, Ze.exports = no()), Ze.exports;
+i(eo, "requireReactIs_development");
+var Wt;
+function to() {
+  return Wt || (Wt = 1, Ze.exports = eo()), Ze.exports;
 }
-s(ro, "requireReactIs");
-var on = ro(), oo = /* @__PURE__ */ nn(on), io = /* @__PURE__ */ Jt({
+i(to, "requireReactIs");
+var sn = to(), no = /* @__PURE__ */ rn(sn), ro = /* @__PURE__ */ Xt({
   __proto__: null,
-  default: oo
-}, [on]), so = [
+  default: no
+}, [sn]), oo = [
   "isAsyncMode",
   "isConcurrentMode",
   "isContextConsumer",
@@ -578,108 +573,108 @@ var on = ro(), oo = /* @__PURE__ */ nn(on), io = /* @__PURE__ */ Jt({
   "isSuspense",
   "isSuspenseList",
   "isValidElementType"
-], ae = Object.fromEntries(so.map((e) => [e, (t) => io[e](t) || to[e](t)]));
-function sn(e, t = []) {
+], fe = Object.fromEntries(oo.map((e) => [e, (t) => ro[e](t) || vr[e](t)]));
+function cn(e, t = []) {
   if (Array.isArray(e))
     for (let n of e)
-      sn(n, t);
+      cn(n, t);
   else e != null && e !== !1 && e !== "" && t.push(e);
   return t;
 }
-s(sn, "getChildren");
-function Wt(e) {
+i(cn, "getChildren");
+function Vt(e) {
   let t = e.type;
   if (typeof t == "string")
     return t;
   if (typeof t == "function")
     return t.displayName || t.name || "Unknown";
-  if (ae.isFragment(e))
+  if (fe.isFragment(e))
     return "React.Fragment";
-  if (ae.isSuspense(e))
+  if (fe.isSuspense(e))
     return "React.Suspense";
   if (typeof t == "object" && t !== null) {
-    if (ae.isContextProvider(e))
+    if (fe.isContextProvider(e))
       return "Context.Provider";
-    if (ae.isContextConsumer(e))
+    if (fe.isContextConsumer(e))
       return "Context.Consumer";
-    if (ae.isForwardRef(e)) {
+    if (fe.isForwardRef(e)) {
       if (t.displayName)
         return t.displayName;
       let n = t.render.displayName || t.render.name || "";
       return n === "" ? "ForwardRef" : `ForwardRef(${n})`;
     }
-    if (ae.isMemo(e)) {
+    if (fe.isMemo(e)) {
       let n = t.displayName || t.type.displayName || t.type.name || "";
       return n === "" ? "Memo" : `Memo(${n})`;
     }
   }
   return "UNDEFINED";
 }
-s(Wt, "getType");
-function co(e) {
+i(Vt, "getType");
+function so(e) {
   let { props: t } = e;
   return Object.keys(t).filter((n) => n !== "children" && t[n] !== void 0).sort();
 }
-s(co, "getPropKeys$1");
-var uo = /* @__PURE__ */ s((e, t, n, r, o, i) => ++r > t.maxDepth ? rt(Wt(e), t) : nt(Wt(e), et(co(e), e.props, t, n + t.indent, r, o, i), tt(
-sn(e.props.children), t, n + t.indent, r, o, i), t, n), "serialize$1"), lo = /* @__PURE__ */ s((e) => e != null && ae.isElement(e), "test$1"),
-ao = {
-  serialize: uo,
-  test: lo
-}, fo = typeof Symbol == "function" && Symbol.for ? Symbol.for("react.test.json") : 245830487;
-function mo(e) {
+i(so, "getPropKeys$1");
+var io = /* @__PURE__ */ i((e, t, n, r, o, s) => ++r > t.maxDepth ? rt(Vt(e), t) : nt(Vt(e), et(so(e), e.props, t, n + t.indent, r, o, s), tt(
+cn(e.props.children), t, n + t.indent, r, o, s), t, n), "serialize$1"), co = /* @__PURE__ */ i((e) => e != null && fe.isElement(e), "test$1"),
+uo = {
+  serialize: io,
+  test: co
+}, ao = typeof Symbol == "function" && Symbol.for ? Symbol.for("react.test.json") : 245830487;
+function lo(e) {
   let { props: t } = e;
   return t ? Object.keys(t).filter((n) => t[n] !== void 0).sort() : [];
 }
-s(mo, "getPropKeys");
-var po = /* @__PURE__ */ s((e, t, n, r, o, i) => ++r > t.maxDepth ? rt(e.type, t) : nt(e.type, e.props ? et(mo(e), e.props, t, n + t.indent,
-r, o, i) : "", e.children ? tt(e.children, t, n + t.indent, r, o, i) : "", t, n), "serialize"), go = /* @__PURE__ */ s((e) => e && e.$$typeof ===
-fo, "test"), ho = {
-  serialize: po,
-  test: go
-}, cn = Object.prototype.toString, yo = Date.prototype.toISOString, bo = Error.prototype.toString, Vt = RegExp.prototype.toString;
+i(lo, "getPropKeys");
+var fo = /* @__PURE__ */ i((e, t, n, r, o, s) => ++r > t.maxDepth ? rt(e.type, t) : nt(e.type, e.props ? et(lo(e), e.props, t, n + t.indent,
+r, o, s) : "", e.children ? tt(e.children, t, n + t.indent, r, o, s) : "", t, n), "serialize"), mo = /* @__PURE__ */ i((e) => e && e.$$typeof ===
+ao, "test"), po = {
+  serialize: fo,
+  test: mo
+}, un = Object.prototype.toString, go = Date.prototype.toISOString, ho = Error.prototype.toString, qt = RegExp.prototype.toString;
 function Re(e) {
   return typeof e.constructor == "function" && e.constructor.name || "Object";
 }
-s(Re, "getConstructorName");
-function So(e) {
+i(Re, "getConstructorName");
+function yo(e) {
   return typeof window < "u" && e === window;
 }
-s(So, "isWindow");
-var Eo = /^Symbol\((.*)\)(.*)$/, _o = /\n/g, it = class it extends Error {
+i(yo, "isWindow");
+var bo = /^Symbol\((.*)\)(.*)$/, So = /\n/g, st = class st extends Error {
   constructor(t, n) {
     super(t), this.stack = n, this.name = this.constructor.name;
   }
 };
-s(it, "PrettyFormatPluginError");
-var Ie = it;
-function To(e) {
+i(st, "PrettyFormatPluginError");
+var Pe = st;
+function Eo(e) {
   return e === "[object Array]" || e === "[object ArrayBuffer]" || e === "[object DataView]" || e === "[object Float32Array]" || e === "[obj\
 ect Float64Array]" || e === "[object Int8Array]" || e === "[object Int16Array]" || e === "[object Int32Array]" || e === "[object Uint8Array]" ||
   e === "[object Uint8ClampedArray]" || e === "[object Uint16Array]" || e === "[object Uint32Array]";
 }
-s(To, "isToStringedArrayType");
-function Co(e) {
+i(Eo, "isToStringedArrayType");
+function _o(e) {
   return Object.is(e, -0) ? "-0" : String(e);
 }
-s(Co, "printNumber");
-function Oo(e) {
+i(_o, "printNumber");
+function To(e) {
   return `${e}n`;
 }
-s(Oo, "printBigInt");
-function qt(e, t) {
+i(To, "printBigInt");
+function Kt(e, t) {
   return t ? `[Function ${e.name || "anonymous"}]` : "[Function]";
 }
-s(qt, "printFunction");
-function Kt(e) {
-  return String(e).replace(Eo, "Symbol($1)");
-}
-s(Kt, "printSymbol");
+i(Kt, "printFunction");
 function Gt(e) {
-  return `[${bo.call(e)}]`;
+  return String(e).replace(bo, "Symbol($1)");
+}
+i(Gt, "printSymbol");
+function Ht(e) {
+  return `[${ho.call(e)}]`;
 }
-s(Gt, "printError");
-function un(e, t, n, r) {
+i(Ht, "printError");
+function an(e, t, n, r) {
   if (e === !0 || e === !1)
     return `${e}`;
   if (e === void 0)
@@ -688,102 +683,102 @@ function un(e, t, n, r) {
     return "null";
   let o = typeof e;
   if (o === "number")
-    return Co(e);
+    return _o(e);
   if (o === "bigint")
-    return Oo(e);
+    return To(e);
   if (o === "string")
     return r ? `"${e.replaceAll(/"|\\/g, "\\$&")}"` : `"${e}"`;
   if (o === "function")
-    return qt(e, t);
+    return Kt(e, t);
   if (o === "symbol")
-    return Kt(e);
-  let i = cn.call(e);
-  return i === "[object WeakMap]" ? "WeakMap {}" : i === "[object WeakSet]" ? "WeakSet {}" : i === "[object Function]" || i === "[object Gen\
-eratorFunction]" ? qt(e, t) : i === "[object Symbol]" ? Kt(e) : i === "[object Date]" ? Number.isNaN(+e) ? "Date { NaN }" : yo.call(e) : i ===
-  "[object Error]" ? Gt(e) : i === "[object RegExp]" ? n ? Vt.call(e).replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&") : Vt.call(e) : e instanceof Error ?
-  Gt(e) : null;
-}
-s(un, "printBasicValue");
-function ln(e, t, n, r, o, i) {
+    return Gt(e);
+  let s = un.call(e);
+  return s === "[object WeakMap]" ? "WeakMap {}" : s === "[object WeakSet]" ? "WeakSet {}" : s === "[object Function]" || s === "[object Gen\
+eratorFunction]" ? Kt(e, t) : s === "[object Symbol]" ? Gt(e) : s === "[object Date]" ? Number.isNaN(+e) ? "Date { NaN }" : go.call(e) : s ===
+  "[object Error]" ? Ht(e) : s === "[object RegExp]" ? n ? qt.call(e).replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&") : qt.call(e) : e instanceof Error ?
+  Ht(e) : null;
+}
+i(an, "printBasicValue");
+function ln(e, t, n, r, o, s) {
   if (o.includes(e))
     return "[Circular]";
   o = [...o], o.push(e);
-  let c = ++r > t.maxDepth, l = t.min;
-  if (t.callToJSON && !c && e.toJSON && typeof e.toJSON == "function" && !i)
-    return le(e.toJSON(), t, n, r, o, !0);
-  let u = cn.call(e);
-  return u === "[object Arguments]" ? c ? "[Arguments]" : `${l ? "" : "Arguments "}[${Ne(e, t, n, r, o, le)}]` : To(u) ? c ? `[${e.constructor.
-  name}]` : `${l || !t.printBasicPrototype && e.constructor.name === "Array" ? "" : `${e.constructor.name} `}[${Ne(e, t, n, r, o, le)}]` : u ===
-  "[object Map]" ? c ? "[Map]" : `Map {${_e(e.entries(), t, n, r, o, le, " => ")}}` : u === "[object Set]" ? c ? "[Set]" : `Set {${Qe(e.values(),
-  t, n, r, o, le)}}` : c || So(e) ? `[${Re(e)}]` : `${l || !t.printBasicPrototype && Re(e) === "Object" ? "" : `${Re(e)} `}{${ve(e, t, n, r,
-  o, le)}}`;
-}
-s(ln, "printComplexValue");
-var $o = {
-  test: /* @__PURE__ */ s((e) => e && e instanceof Error, "test"),
-  serialize(e, t, n, r, o, i) {
+  let c = ++r > t.maxDepth, a = t.min;
+  if (t.callToJSON && !c && e.toJSON && typeof e.toJSON == "function" && !s)
+    return ae(e.toJSON(), t, n, r, o, !0);
+  let u = un.call(e);
+  return u === "[object Arguments]" ? c ? "[Arguments]" : `${a ? "" : "Arguments "}[${Ae(e, t, n, r, o, ae)}]` : Eo(u) ? c ? `[${e.constructor.
+  name}]` : `${a || !t.printBasicPrototype && e.constructor.name === "Array" ? "" : `${e.constructor.name} `}[${Ae(e, t, n, r, o, ae)}]` : u ===
+  "[object Map]" ? c ? "[Map]" : `Map {${Ee(e.entries(), t, n, r, o, ae, " => ")}}` : u === "[object Set]" ? c ? "[Set]" : `Set {${Qe(e.values(),
+  t, n, r, o, ae)}}` : c || yo(e) ? `[${Re(e)}]` : `${a || !t.printBasicPrototype && Re(e) === "Object" ? "" : `${Re(e)} `}{${ve(e, t, n, r,
+  o, ae)}}`;
+}
+i(ln, "printComplexValue");
+var Co = {
+  test: /* @__PURE__ */ i((e) => e && e instanceof Error, "test"),
+  serialize(e, t, n, r, o, s) {
     if (o.includes(e))
       return "[Circular]";
     o = [...o, e];
-    let c = ++r > t.maxDepth, { message: l, cause: u, ...m } = e, p = {
-      message: l,
+    let c = ++r > t.maxDepth, { message: a, cause: u, ...m } = e, p = {
+      message: a,
       ...typeof u < "u" ? { cause: u } : {},
       ...e instanceof AggregateError ? { errors: e.errors } : {},
       ...m
-    }, a = e.name !== "Error" ? e.name : Re(e);
-    return c ? `[${a}]` : `${a} {${_e(Object.entries(p).values(), t, n, r, o, i)}}`;
+    }, l = e.name !== "Error" ? e.name : Re(e);
+    return c ? `[${l}]` : `${l} {${Ee(Object.entries(p).values(), t, n, r, o, s)}}`;
   }
 };
-function wo(e) {
+function Oo(e) {
   return e.serialize != null;
 }
-s(wo, "isNewPlugin");
-function an(e, t, n, r, o, i) {
+i(Oo, "isNewPlugin");
+function fn(e, t, n, r, o, s) {
   let c;
   try {
-    c = wo(e) ? e.serialize(t, n, r, o, i, le) : e.print(t, (l) => le(l, n, r, o, i), (l) => {
+    c = Oo(e) ? e.serialize(t, n, r, o, s, ae) : e.print(t, (a) => ae(a, n, r, o, s), (a) => {
       let u = r + n.indent;
-      return u + l.replaceAll(_o, `
+      return u + a.replaceAll(So, `
 ${u}`);
     }, {
       edgeSpacing: n.spacingOuter,
       min: n.min,
       spacing: n.spacingInner
     }, n.colors);
-  } catch (l) {
-    throw new Ie(l.message, l.stack);
+  } catch (a) {
+    throw new Pe(a.message, a.stack);
   }
   if (typeof c != "string")
     throw new TypeError(`pretty-format: Plugin must return type "string" but instead returned "${typeof c}".`);
   return c;
 }
-s(an, "printPlugin");
-function fn(e, t) {
+i(fn, "printPlugin");
+function mn(e, t) {
   for (let n of e)
     try {
       if (n.test(t))
         return n;
     } catch (r) {
-      throw new Ie(r.message, r.stack);
+      throw new Pe(r.message, r.stack);
     }
   return null;
 }
-s(fn, "findPlugin");
-function le(e, t, n, r, o, i) {
-  let c = fn(t.plugins, e);
+i(mn, "findPlugin");
+function ae(e, t, n, r, o, s) {
+  let c = mn(t.plugins, e);
   if (c !== null)
-    return an(c, e, t, n, r, o);
-  let l = un(e, t.printFunctionName, t.escapeRegex, t.escapeString);
-  return l !== null ? l : ln(e, t, n, r, o, i);
+    return fn(c, e, t, n, r, o);
+  let a = an(e, t.printFunctionName, t.escapeRegex, t.escapeString);
+  return a !== null ? a : ln(e, t, n, r, o, s);
 }
-s(le, "printer");
+i(ae, "printer");
 var ot = {
   comment: "gray",
   content: "reset",
   prop: "yellow",
   tag: "cyan",
   value: "green"
-}, mn = Object.keys(ot), ee = {
+}, pn = Object.keys(ot), ee = {
   callToJSON: !0,
   compareKeys: void 0,
   escapeRegex: !1,
@@ -798,16 +793,16 @@ var ot = {
   printFunctionName: !0,
   theme: ot
 };
-function Ao(e) {
+function $o(e) {
   for (let t of Object.keys(e))
     if (!Object.prototype.hasOwnProperty.call(ee, t))
       throw new Error(`pretty-format: Unknown option "${t}".`);
   if (e.min && e.indent !== void 0 && e.indent !== 0)
     throw new Error('pretty-format: Options "min" and "indent" cannot be used together.');
 }
-s(Ao, "validateOptions");
-function Ro() {
-  return mn.reduce((e, t) => {
+i($o, "validateOptions");
+function wo() {
+  return pn.reduce((e, t) => {
     let n = ot[t], r = n && v[n];
     if (r && typeof r.close == "string" && typeof r.open == "string")
       e[t] = r;
@@ -816,69 +811,69 @@ function Ro() {
     return e;
   }, /* @__PURE__ */ Object.create(null));
 }
-s(Ro, "getColorsHighlight");
-function No() {
-  return mn.reduce((e, t) => (e[t] = {
+i(wo, "getColorsHighlight");
+function Ro() {
+  return pn.reduce((e, t) => (e[t] = {
     close: "",
     open: ""
   }, e), /* @__PURE__ */ Object.create(null));
 }
-s(No, "getColorsEmpty");
-function pn(e) {
+i(Ro, "getColorsEmpty");
+function gn(e) {
   return e?.printFunctionName ?? ee.printFunctionName;
 }
-s(pn, "getPrintFunctionName");
-function gn(e) {
+i(gn, "getPrintFunctionName");
+function hn(e) {
   return e?.escapeRegex ?? ee.escapeRegex;
 }
-s(gn, "getEscapeRegex");
-function hn(e) {
+i(hn, "getEscapeRegex");
+function dn(e) {
   return e?.escapeString ?? ee.escapeString;
 }
-s(hn, "getEscapeString");
-function Ht(e) {
+i(dn, "getEscapeString");
+function Jt(e) {
   return {
     callToJSON: e?.callToJSON ?? ee.callToJSON,
-    colors: e?.highlight ? Ro() : No(),
+    colors: e?.highlight ? wo() : Ro(),
     compareKeys: typeof e?.compareKeys == "function" || e?.compareKeys === null ? e.compareKeys : ee.compareKeys,
-    escapeRegex: gn(e),
-    escapeString: hn(e),
-    indent: e?.min ? "" : Io(e?.indent ?? ee.indent),
+    escapeRegex: hn(e),
+    escapeString: dn(e),
+    indent: e?.min ? "" : Ao(e?.indent ?? ee.indent),
     maxDepth: e?.maxDepth ?? ee.maxDepth,
     maxWidth: e?.maxWidth ?? ee.maxWidth,
     min: e?.min ?? ee.min,
     plugins: e?.plugins ?? ee.plugins,
     printBasicPrototype: e?.printBasicPrototype ?? !0,
-    printFunctionName: pn(e),
+    printFunctionName: gn(e),
     spacingInner: e?.min ? " " : `
 `,
     spacingOuter: e?.min ? "" : `
 `
   };
 }
-s(Ht, "getConfig");
-function Io(e) {
+i(Jt, "getConfig");
+function Ao(e) {
   return Array.from({ length: e + 1 }).join(" ");
 }
-s(Io, "createIndent");
-function Z(e, t) {
-  if (t && (Ao(t), t.plugins)) {
-    let r = fn(t.plugins, e);
+i(Ao, "createIndent");
+function X(e, t) {
+  if (t && ($o(t), t.plugins)) {
+    let r = mn(t.plugins, e);
     if (r !== null)
-      return an(r, e, Ht(t), "", 0, []);
-  }
-  let n = un(e, pn(t), gn(t), hn(t));
-  return n !== null ? n : ln(e, Ht(t), "", 0, []);
-}
-s(Z, "format");
-var Te = {
-  AsymmetricMatcher: Sr,
-  DOMCollection: wr,
-  DOMElement: Fr,
-  Immutable: Zr,
-  ReactElement: ao,
-  ReactTestComponent: ho,
-  Error: $o
+      return fn(r, e, Jt(t), "", 0, []);
+  }
+  let n = an(e, gn(t), hn(t), dn(t));
+  return n !== null ? n : ln(e, Jt(t), "", 0, []);
+}
+i(X, "format");
+var _e = {
+  AsymmetricMatcher: yr,
+  DOMCollection: Or,
+  DOMElement: xr,
+  Immutable: Jr,
+  ReactElement: uo,
+  ReactTestComponent: po,
+  Error: Co
 };
 
 // ../node_modules/loupe/lib/helpers.js
@@ -921,93 +916,93 @@ var yn = {
   symbol: "green",
   date: "magenta",
   regexp: "red"
-}, se = "\u2026";
-function Mo(e, t) {
+}, ie = "\u2026";
+function No(e, t) {
   let n = yn[Po[t]] || yn[t] || "";
   return n ? `\x1B[${n[0]}m${String(e)}\x1B[${n[1]}m` : String(e);
 }
-s(Mo, "colorise");
-function dn({
+i(No, "colorise");
+function bn({
   showHidden: e = !1,
   depth: t = 2,
   colors: n = !1,
   customInspect: r = !0,
   showProxy: o = !1,
-  maxArrayLength: i = 1 / 0,
+  maxArrayLength: s = 1 / 0,
   breakLength: c = 1 / 0,
-  seen: l = [],
+  seen: a = [],
   // eslint-disable-next-line no-shadow
   truncate: u = 1 / 0,
   stylize: m = String
 } = {}, p) {
-  let a = {
+  let l = {
     showHidden: !!e,
     depth: Number(t),
     colors: !!n,
     customInspect: !!r,
     showProxy: !!o,
-    maxArrayLength: Number(i),
+    maxArrayLength: Number(s),
     breakLength: Number(c),
     truncate: Number(u),
-    seen: l,
+    seen: a,
     inspect: p,
     stylize: m
   };
-  return a.colors && (a.stylize = Mo), a;
+  return l.colors && (l.stylize = No), l;
 }
-s(dn, "normaliseOptions");
-function Lo(e) {
+i(bn, "normaliseOptions");
+function Io(e) {
   return e >= "\uD800" && e <= "\uDBFF";
 }
-s(Lo, "isHighSurrogate");
-function B(e, t, n = se) {
+i(Io, "isHighSurrogate");
+function B(e, t, n = ie) {
   e = String(e);
   let r = n.length, o = e.length;
   if (r > t && o > r)
     return n;
   if (o > t && o > r) {
-    let i = t - r;
-    return i > 0 && Lo(e[i - 1]) && (i = i - 1), `${e.slice(0, i)}${n}`;
+    let s = t - r;
+    return s > 0 && Io(e[s - 1]) && (s = s - 1), `${e.slice(0, s)}${n}`;
   }
   return e;
 }
-s(B, "truncate");
+i(B, "truncate");
 function D(e, t, n, r = ", ") {
   n = n || t.inspect;
   let o = e.length;
   if (o === 0)
     return "";
-  let i = t.truncate, c = "", l = "", u = "";
+  let s = t.truncate, c = "", a = "", u = "";
   for (let m = 0; m < o; m += 1) {
-    let p = m + 1 === e.length, a = m + 2 === e.length;
-    u = `${se}(${e.length - m})`;
-    let S = e[m];
-    t.truncate = i - c.length - (p ? 0 : r.length);
-    let g = l || n(S, t) + (p ? "" : r), h = c.length + g.length, f = h + u.length;
-    if (p && h > i && c.length + u.length <= i || !p && !a && f > i || (l = p ? "" : n(e[m + 1], t) + (a ? "" : r), !p && a && f > i && h + l.
-    length > i))
+    let p = m + 1 === e.length, l = m + 2 === e.length;
+    u = `${ie}(${e.length - m})`;
+    let b = e[m];
+    t.truncate = s - c.length - (p ? 0 : r.length);
+    let g = a || n(b, t) + (p ? "" : r), h = c.length + g.length, f = h + u.length;
+    if (p && h > s && c.length + u.length <= s || !p && !l && f > s || (a = p ? "" : n(e[m + 1], t) + (l ? "" : r), !p && l && f > s && h + a.
+    length > s))
       break;
-    if (c += g, !p && !a && h + l.length >= i) {
-      u = `${se}(${e.length - m - 1})`;
+    if (c += g, !p && !l && h + a.length >= s) {
+      u = `${ie}(${e.length - m - 1})`;
       break;
     }
     u = "";
   }
   return `${c}${u}`;
 }
-s(D, "inspectList");
-function xo(e) {
+i(D, "inspectList");
+function Mo(e) {
   return e.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/) ? e : JSON.stringify(e).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
 }
-s(xo, "quoteComplexKey");
+i(Mo, "quoteComplexKey");
 function ce([e, t], n) {
-  return n.truncate -= 2, typeof e == "string" ? e = xo(e) : typeof e != "number" && (e = `[${n.inspect(e, n)}]`), n.truncate -= e.length, t =
+  return n.truncate -= 2, typeof e == "string" ? e = Mo(e) : typeof e != "number" && (e = `[${n.inspect(e, n)}]`), n.truncate -= e.length, t =
   n.inspect(t, n), `${e}: ${t}`;
 }
-s(ce, "inspectProperty");
+i(ce, "inspectProperty");
 
 // ../node_modules/loupe/lib/array.js
-function st(e, t) {
+function it(e, t) {
   let n = Object.keys(e).slice(e.length);
   if (!e.length && !n.length)
     return "[]";
@@ -1015,32 +1010,32 @@ function st(e, t) {
   let r = D(e, t);
   t.truncate -= r.length;
   let o = "";
-  return n.length && (o = D(n.map((i) => [i, e[i]]), t, ce)), `[ ${r}${o ? `, ${o}` : ""} ]`;
+  return n.length && (o = D(n.map((s) => [s, e[s]]), t, ce)), `[ ${r}${o ? `, ${o}` : ""} ]`;
 }
-s(st, "inspectArray");
+i(it, "inspectArray");
 
 // ../node_modules/loupe/lib/typedarray.js
-var Do = /* @__PURE__ */ s((e) => typeof Buffer == "function" && e instanceof Buffer ? "Buffer" : e[Symbol.toStringTag] ? e[Symbol.toStringTag] :
+var Lo = /* @__PURE__ */ i((e) => typeof Buffer == "function" && e instanceof Buffer ? "Buffer" : e[Symbol.toStringTag] ? e[Symbol.toStringTag] :
 e.constructor.name, "getArrayName");
 function te(e, t) {
-  let n = Do(e);
+  let n = Lo(e);
   t.truncate -= n.length + 4;
   let r = Object.keys(e).slice(e.length);
   if (!e.length && !r.length)
     return `${n}[]`;
   let o = "";
   for (let c = 0; c < e.length; c++) {
-    let l = `${t.stylize(B(e[c], t.truncate), "number")}${c === e.length - 1 ? "" : ", "}`;
-    if (t.truncate -= l.length, e[c] !== e.length && t.truncate <= 3) {
-      o += `${se}(${e.length - e[c] + 1})`;
+    let a = `${t.stylize(B(e[c], t.truncate), "number")}${c === e.length - 1 ? "" : ", "}`;
+    if (t.truncate -= a.length, e[c] !== e.length && t.truncate <= 3) {
+      o += `${ie}(${e.length - e[c] + 1})`;
       break;
     }
-    o += l;
+    o += a;
   }
-  let i = "";
-  return r.length && (i = D(r.map((c) => [c, e[c]]), t, ce)), `${n}[ ${o}${i ? `, ${i}` : ""} ]`;
+  let s = "";
+  return r.length && (s = D(r.map((c) => [c, e[c]]), t, ce)), `${n}[ ${o}${s ? `, ${s}` : ""} ]`;
 }
-s(te, "inspectTypedArray");
+i(te, "inspectTypedArray");
 
 // ../node_modules/loupe/lib/date.js
 function ct(e, t) {
@@ -1050,70 +1045,70 @@ function ct(e, t) {
   let r = n.split("T"), o = r[0];
   return t.stylize(`${o}T${B(r[1], t.truncate - o.length - 1)}`, "date");
 }
-s(ct, "inspectDate");
+i(ct, "inspectDate");
 
 // ../node_modules/loupe/lib/function.js
-function Me(e, t) {
+function Ie(e, t) {
   let n = e[Symbol.toStringTag] || "Function", r = e.name;
   return r ? t.stylize(`[${n} ${B(r, t.truncate - 11)}]`, "special") : t.stylize(`[${n}]`, "special");
 }
-s(Me, "inspectFunction");
+i(Ie, "inspectFunction");
 
 // ../node_modules/loupe/lib/map.js
-function Fo([e, t], n) {
+function xo([e, t], n) {
   return n.truncate -= 4, e = n.inspect(e, n), n.truncate -= e.length, t = n.inspect(t, n), `${e} => ${t}`;
 }
-s(Fo, "inspectMapEntry");
-function jo(e) {
+i(xo, "inspectMapEntry");
+function Do(e) {
   let t = [];
   return e.forEach((n, r) => {
     t.push([r, n]);
   }), t;
 }
-s(jo, "mapToEntries");
+i(Do, "mapToEntries");
 function ut(e, t) {
-  return e.size === 0 ? "Map{}" : (t.truncate -= 7, `Map{ ${D(jo(e), t, Fo)} }`);
+  return e.size === 0 ? "Map{}" : (t.truncate -= 7, `Map{ ${D(Do(e), t, xo)} }`);
 }
-s(ut, "inspectMap");
+i(ut, "inspectMap");
 
 // ../node_modules/loupe/lib/number.js
-var ko = Number.isNaN || ((e) => e !== e);
-function Le(e, t) {
-  return ko(e) ? t.stylize("NaN", "number") : e === 1 / 0 ? t.stylize("Infinity", "number") : e === -1 / 0 ? t.stylize("-Infinity", "number") :
+var Fo = Number.isNaN || ((e) => e !== e);
+function Me(e, t) {
+  return Fo(e) ? t.stylize("NaN", "number") : e === 1 / 0 ? t.stylize("Infinity", "number") : e === -1 / 0 ? t.stylize("-Infinity", "number") :
   e === 0 ? t.stylize(1 / e === 1 / 0 ? "+0" : "-0", "number") : t.stylize(B(String(e), t.truncate), "number");
 }
-s(Le, "inspectNumber");
+i(Me, "inspectNumber");
 
 // ../node_modules/loupe/lib/bigint.js
-function xe(e, t) {
+function Le(e, t) {
   let n = B(e.toString(), t.truncate - 1);
-  return n !== se && (n += "n"), t.stylize(n, "bigint");
+  return n !== ie && (n += "n"), t.stylize(n, "bigint");
 }
-s(xe, "inspectBigInt");
+i(Le, "inspectBigInt");
 
 // ../node_modules/loupe/lib/regexp.js
-function lt(e, t) {
+function at(e, t) {
   let n = e.toString().split("/")[2], r = t.truncate - (2 + n.length), o = e.source;
   return t.stylize(`/${B(o, r)}/${n}`, "regexp");
 }
-s(lt, "inspectRegExp");
+i(at, "inspectRegExp");
 
 // ../node_modules/loupe/lib/set.js
-function Bo(e) {
+function jo(e) {
   let t = [];
   return e.forEach((n) => {
     t.push(n);
   }), t;
 }
-s(Bo, "arrayFromSet");
-function at(e, t) {
-  return e.size === 0 ? "Set{}" : (t.truncate -= 7, `Set{ ${D(Bo(e), t)} }`);
+i(jo, "arrayFromSet");
+function lt(e, t) {
+  return e.size === 0 ? "Set{}" : (t.truncate -= 7, `Set{ ${D(jo(e), t)} }`);
 }
-s(at, "inspectSet");
+i(lt, "inspectSet");
 
 // ../node_modules/loupe/lib/string.js
-var bn = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\u\
-ffff]", "g"), zo = {
+var Sn = 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",
@@ -1121,66 +1116,66 @@ ffff]", "g"), zo = {
   "\r": "\\r",
   "'": "\\'",
   "\\": "\\\\"
-}, Yo = 16, Uo = 4;
-function Wo(e) {
-  return zo[e] || `\\u${`0000${e.charCodeAt(0).toString(Yo)}`.slice(-Uo)}`;
+}, Bo = 16, zo = 4;
+function Yo(e) {
+  return ko[e] || `\\u${`0000${e.charCodeAt(0).toString(Bo)}`.slice(-zo)}`;
 }
-s(Wo, "escape");
-function De(e, t) {
-  return bn.test(e) && (e = e.replace(bn, Wo)), t.stylize(`'${B(e, t.truncate - 2)}'`, "string");
+i(Yo, "escape");
+function xe(e, t) {
+  return Sn.test(e) && (e = e.replace(Sn, Yo)), t.stylize(`'${B(e, t.truncate - 2)}'`, "string");
 }
-s(De, "inspectString");
+i(xe, "inspectString");
 
 // ../node_modules/loupe/lib/symbol.js
-function Fe(e) {
+function De(e) {
   return "description" in Symbol.prototype ? e.description ? `Symbol(${e.description})` : "Symbol()" : e.toString();
 }
-s(Fe, "inspectSymbol");
+i(De, "inspectSymbol");
 
 // ../node_modules/loupe/lib/promise.js
-var Sn = /* @__PURE__ */ s(() => "Promise{\u2026}", "getPromiseValue");
+var En = /* @__PURE__ */ i(() => "Promise{\u2026}", "getPromiseValue");
 try {
   let { getPromiseDetails: e, kPending: t, kRejected: n } = process.binding("util");
-  Array.isArray(e(Promise.resolve())) && (Sn = /* @__PURE__ */ s((r, o) => {
-    let [i, c] = e(r);
-    return i === t ? "Promise{<pending>}" : `Promise${i === n ? "!" : ""}{${o.inspect(c, o)}}`;
+  Array.isArray(e(Promise.resolve())) && (En = /* @__PURE__ */ i((r, o) => {
+    let [s, c] = e(r);
+    return s === t ? "Promise{<pending>}" : `Promise${s === n ? "!" : ""}{${o.inspect(c, o)}}`;
   }, "getPromiseValue"));
 } catch {
 }
-var En = Sn;
+var _n = En;
 
 // ../node_modules/loupe/lib/object.js
-function fe(e, t) {
+function me(e, t) {
   let n = Object.getOwnPropertyNames(e), r = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(e) : [];
   if (n.length === 0 && r.length === 0)
     return "{}";
   if (t.truncate -= 4, t.seen = t.seen || [], t.seen.includes(e))
     return "[Circular]";
   t.seen.push(e);
-  let o = D(n.map((l) => [l, e[l]]), t, ce), i = D(r.map((l) => [l, e[l]]), t, ce);
+  let o = D(n.map((a) => [a, e[a]]), t, ce), s = D(r.map((a) => [a, e[a]]), t, ce);
   t.seen.pop();
   let c = "";
-  return o && i && (c = ", "), `{ ${o}${c}${i} }`;
+  return o && s && (c = ", "), `{ ${o}${c}${s} }`;
 }
-s(fe, "inspectObject");
+i(me, "inspectObject");
 
 // ../node_modules/loupe/lib/class.js
 var ft = typeof Symbol < "u" && Symbol.toStringTag ? Symbol.toStringTag : !1;
 function mt(e, t) {
   let n = "";
   return ft && ft in e && (n = e[ft]), n = n || e.constructor.name, (!n || n === "_class") && (n = "<Anonymous Class>"), t.truncate -= n.length,
-  `${n}${fe(e, t)}`;
+  `${n}${me(e, t)}`;
 }
-s(mt, "inspectClass");
+i(mt, "inspectClass");
 
 // ../node_modules/loupe/lib/arguments.js
 function pt(e, t) {
   return e.length === 0 ? "Arguments[]" : (t.truncate -= 13, `Arguments[ ${D(e, t)} ]`);
 }
-s(pt, "inspectArguments");
+i(pt, "inspectArguments");
 
 // ../node_modules/loupe/lib/error.js
-var Vo = [
+var Uo = [
   "stack",
   "line",
   "column",
@@ -1194,72 +1189,77 @@ var Vo = [
   "cause"
 ];
 function gt(e, t) {
-  let n = Object.getOwnPropertyNames(e).filter((c) => Vo.indexOf(c) === -1), r = e.name;
+  let n = Object.getOwnPropertyNames(e).filter((c) => Uo.indexOf(c) === -1), r = e.name;
   t.truncate -= r.length;
   let o = "";
   if (typeof e.message == "string" ? o = B(e.message, t.truncate) : n.unshift("message"), o = o ? `: ${o}` : "", t.truncate -= o.length + 5,
   t.seen = t.seen || [], t.seen.includes(e))
     return "[Circular]";
   t.seen.push(e);
-  let i = D(n.map((c) => [c, e[c]]), t, ce);
-  return `${r}${o}${i ? ` { ${i} }` : ""}`;
+  let s = D(n.map((c) => [c, e[c]]), t, ce);
+  return `${r}${o}${s ? ` { ${s} }` : ""}`;
 }
-s(gt, "inspectObject");
+i(gt, "inspectObject");
 
 // ../node_modules/loupe/lib/html.js
-function qo([e, t], n) {
+function Wo([e, t], n) {
   return n.truncate -= 3, t ? `${n.stylize(String(e), "yellow")}=${n.stylize(`"${t}"`, "string")}` : `${n.stylize(String(e), "yellow")}`;
 }
-s(qo, "inspectAttribute");
-function je(e, t) {
-  return D(e, t, ke, `
+i(Wo, "inspectAttribute");
+function Fe(e, t) {
+  return D(e, t, Vo, `
 `);
 }
-s(je, "inspectHTMLCollection");
-function ke(e, t) {
-  let n = e.getAttributeNames(), r = e.tagName.toLowerCase(), o = t.stylize(`<${r}`, "special"), i = t.stylize(">", "special"), c = t.stylize(
+i(Fe, "inspectNodeCollection");
+function Vo(e, t) {
+  switch (e.nodeType) {
+    case 1:
+      return je(e, t);
+    case 3:
+      return t.inspect(e.data, t);
+    default:
+      return t.inspect(e, t);
+  }
+}
+i(Vo, "inspectNode");
+function je(e, t) {
+  let n = e.getAttributeNames(), r = e.tagName.toLowerCase(), o = t.stylize(`<${r}`, "special"), s = t.stylize(">", "special"), c = t.stylize(
   `</${r}>`, "special");
   t.truncate -= r.length * 2 + 5;
-  let l = "";
-  n.length > 0 && (l += " ", l += D(n.map((p) => [p, e.getAttribute(p)]), t, qo, " ")), t.truncate -= l.length;
-  let u = t.truncate, m = je(e.children, t);
-  return m && m.length > u && (m = `${se}(${e.children.length})`), `${o}${l}${i}${m}${c}`;
+  let a = "";
+  n.length > 0 && (a += " ", a += D(n.map((p) => [p, e.getAttribute(p)]), t, Wo, " ")), t.truncate -= a.length;
+  let u = t.truncate, m = Fe(e.children, t);
+  return m && m.length > u && (m = `${ie}(${e.children.length})`), `${o}${a}${s}${m}${c}`;
 }
-s(ke, "inspectHTML");
+i(je, "inspectHTML");
 
 // ../node_modules/loupe/lib/index.js
-var Ko = typeof Symbol == "function" && typeof Symbol.for == "function", ht = Ko ? Symbol.for("chai/inspect") : "@@chai/inspect", ye = !1;
-try {
-  let e = _n();
-  ye = e.inspect ? e.inspect.custom : !1;
-} catch {
-  ye = !1;
-}
-var Tn = /* @__PURE__ */ new WeakMap(), Cn = {}, On = {
-  undefined: /* @__PURE__ */ s((e, t) => t.stylize("undefined", "undefined"), "undefined"),
-  null: /* @__PURE__ */ s((e, t) => t.stylize("null", "null"), "null"),
-  boolean: /* @__PURE__ */ s((e, t) => t.stylize(String(e), "boolean"), "boolean"),
-  Boolean: /* @__PURE__ */ s((e, t) => t.stylize(String(e), "boolean"), "Boolean"),
-  number: Le,
-  Number: Le,
-  bigint: xe,
-  BigInt: xe,
-  string: De,
-  String: De,
-  function: Me,
-  Function: Me,
-  symbol: Fe,
+var qo = typeof Symbol == "function" && typeof Symbol.for == "function", ht = qo ? Symbol.for("chai/inspect") : "@@chai/inspect", dt = Symbol.
+for("nodejs.util.inspect.custom"), Tn = /* @__PURE__ */ new WeakMap(), Cn = {}, On = {
+  undefined: /* @__PURE__ */ i((e, t) => t.stylize("undefined", "undefined"), "undefined"),
+  null: /* @__PURE__ */ i((e, t) => t.stylize("null", "null"), "null"),
+  boolean: /* @__PURE__ */ i((e, t) => t.stylize(String(e), "boolean"), "boolean"),
+  Boolean: /* @__PURE__ */ i((e, t) => t.stylize(String(e), "boolean"), "Boolean"),
+  number: Me,
+  Number: Me,
+  bigint: Le,
+  BigInt: Le,
+  string: xe,
+  String: xe,
+  function: Ie,
+  Function: Ie,
+  symbol: De,
   // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
-  Symbol: Fe,
-  Array: st,
+  Symbol: De,
+  Array: it,
   Date: ct,
   Map: ut,
-  Set: at,
-  RegExp: lt,
-  Promise: En,
+  Set: lt,
+  RegExp: at,
+  Promise: _n,
   // WeakSet, WeakMap are totally opaque to us
-  WeakSet: /* @__PURE__ */ s((e, t) => t.stylize("WeakSet{\u2026}", "special"), "WeakSet"),
-  WeakMap: /* @__PURE__ */ s((e, t) => t.stylize("WeakMap{\u2026}", "special"), "WeakMap"),
+  WeakSet: /* @__PURE__ */ i((e, t) => t.stylize("WeakSet{\u2026}", "special"), "WeakSet"),
+  WeakMap: /* @__PURE__ */ i((e, t) => t.stylize("WeakMap{\u2026}", "special"), "WeakMap"),
   Arguments: pt,
   Int8Array: te,
   Uint8Array: te,
@@ -1270,50 +1270,50 @@ var Tn = /* @__PURE__ */ new WeakMap(), Cn = {}, On = {
   Uint32Array: te,
   Float32Array: te,
   Float64Array: te,
-  Generator: /* @__PURE__ */ s(() => "", "Generator"),
-  DataView: /* @__PURE__ */ s(() => "", "DataView"),
-  ArrayBuffer: /* @__PURE__ */ s(() => "", "ArrayBuffer"),
+  Generator: /* @__PURE__ */ i(() => "", "Generator"),
+  DataView: /* @__PURE__ */ i(() => "", "DataView"),
+  ArrayBuffer: /* @__PURE__ */ i(() => "", "ArrayBuffer"),
   Error: gt,
-  HTMLCollection: je,
-  NodeList: je
-}, Go = /* @__PURE__ */ s((e, t, n) => ht in e && typeof e[ht] == "function" ? e[ht](t) : ye && ye in e && typeof e[ye] == "function" ? e[ye](
-t.depth, t) : "inspect" in e && typeof e.inspect == "function" ? e.inspect(t.depth, t) : "constructor" in e && Tn.has(e.constructor) ? Tn.get(
-e.constructor)(e, t) : Cn[n] ? Cn[n](e, t) : "", "inspectCustom"), Ho = Object.prototype.toString;
-function Be(e, t = {}) {
-  let n = dn(t, Be), { customInspect: r } = n, o = e === null ? "null" : typeof e;
-  if (o === "object" && (o = Ho.call(e).slice(8, -1)), o in On)
+  HTMLCollection: Fe,
+  NodeList: Fe
+}, Ko = /* @__PURE__ */ i((e, t, n) => ht in e && typeof e[ht] == "function" ? e[ht](t) : dt in e && typeof e[dt] == "function" ? e[dt](t.depth,
+t) : "inspect" in e && typeof e.inspect == "function" ? e.inspect(t.depth, t) : "constructor" in e && Tn.has(e.constructor) ? Tn.get(e.constructor)(
+e, t) : Cn[n] ? Cn[n](e, t) : "", "inspectCustom"), Go = Object.prototype.toString;
+function ke(e, t = {}) {
+  let n = bn(t, ke), { customInspect: r } = n, o = e === null ? "null" : typeof e;
+  if (o === "object" && (o = Go.call(e).slice(8, -1)), o in On)
     return On[o](e, n);
   if (r && e) {
-    let c = Go(e, n, o);
+    let c = Ko(e, n, o);
     if (c)
-      return typeof c == "string" ? c : Be(c, n);
+      return typeof c == "string" ? c : ke(c, n);
   }
-  let i = e ? Object.getPrototypeOf(e) : !1;
-  return i === Object.prototype || i === null ? fe(e, n) : e && typeof HTMLElement == "function" && e instanceof HTMLElement ? ke(e, n) : "c\
-onstructor" in e ? e.constructor !== Object ? mt(e, n) : fe(e, n) : e === Object(e) ? fe(e, n) : n.stylize(String(e), o);
+  let s = e ? Object.getPrototypeOf(e) : !1;
+  return s === Object.prototype || s === null ? me(e, n) : e && typeof HTMLElement == "function" && e instanceof HTMLElement ? je(e, n) : "c\
+onstructor" in e ? e.constructor !== Object ? mt(e, n) : me(e, n) : e === Object(e) ? me(e, n) : n.stylize(String(e), o);
 }
-s(Be, "inspect");
+i(ke, "inspect");
 
 // ../node_modules/@vitest/utils/dist/chunk-_commonjsHelpers.js
-var { AsymmetricMatcher: Xo, DOMCollection: Zo, DOMElement: Qo, Immutable: vo, ReactElement: ei, ReactTestComponent: ti } = Te, $n = [
-  ti,
-  ei,
-  Qo,
-  Zo,
+var { AsymmetricMatcher: Jo, DOMCollection: Xo, DOMElement: Zo, Immutable: Qo, ReactElement: vo, ReactTestComponent: es } = _e, $n = [
+  es,
   vo,
-  Xo
+  Zo,
+  Xo,
+  Qo,
+  Jo
 ];
-function me(e, t = 10, { maxLength: n, ...r } = {}) {
-  let o = n ?? 1e4, i;
+function pe(e, t = 10, { maxLength: n, ...r } = {}) {
+  let o = n ?? 1e4, s;
   try {
-    i = Z(e, {
+    s = X(e, {
       maxDepth: t,
       escapeString: !1,
       plugins: $n,
       ...r
     });
   } catch {
-    i = Z(e, {
+    s = X(e, {
       callToJSON: !1,
       maxDepth: t,
       escapeString: !1,
@@ -1321,33 +1321,33 @@ function me(e, t = 10, { maxLength: n, ...r } = {}) {
       ...r
     });
   }
-  return i.length >= o && t > 1 ? me(e, Math.floor(Math.min(t, Number.MAX_SAFE_INTEGER) / 2), {
+  return s.length >= o && t > 1 ? pe(e, Math.floor(Math.min(t, Number.MAX_SAFE_INTEGER) / 2), {
     maxLength: n,
     ...r
-  }) : i;
+  }) : s;
 }
-s(me, "stringify");
-var ni = /%[sdjifoOc%]/g;
+i(pe, "stringify");
+var ts = /%[sdjifoOc%]/g;
 function wn(...e) {
   if (typeof e[0] != "string") {
-    let i = [];
+    let s = [];
     for (let c = 0; c < e.length; c++)
-      i.push(Ce(e[c], {
+      s.push(Te(e[c], {
         depth: 0,
         colors: !1
       }));
-    return i.join(" ");
+    return s.join(" ");
   }
-  let t = e.length, n = 1, r = e[0], o = String(r).replace(ni, (i) => {
-    if (i === "%%")
+  let t = e.length, n = 1, r = e[0], o = String(r).replace(ts, (s) => {
+    if (s === "%%")
       return "%";
     if (n >= t)
-      return i;
-    switch (i) {
+      return s;
+    switch (s) {
       case "%s": {
         let c = e[n++];
         return typeof c == "bigint" ? `${c.toString()}n` : typeof c == "number" && c === 0 && 1 / c < 0 ? "-0" : typeof c == "object" && c !==
-        null ? typeof c.toString == "function" && c.toString !== Object.prototype.toString ? c.toString() : Ce(c, {
+        null ? typeof c.toString == "function" && c.toString !== Object.prototype.toString ? c.toString() : Te(c, {
           depth: 0,
           colors: !1
         }) : String(c);
@@ -1363,66 +1363,66 @@ function wn(...e) {
       case "%f":
         return Number.parseFloat(String(e[n++])).toString();
       case "%o":
-        return Ce(e[n++], {
+        return Te(e[n++], {
           showHidden: !0,
           showProxy: !0
         });
       case "%O":
-        return Ce(e[n++]);
+        return Te(e[n++]);
       case "%c":
         return n++, "";
       case "%j":
         try {
           return JSON.stringify(e[n++]);
         } catch (c) {
-          let l = c.message;
-          if (l.includes("circular structure") || l.includes("cyclic structures") || l.includes("cyclic object"))
+          let a = c.message;
+          if (a.includes("circular structure") || a.includes("cyclic structures") || a.includes("cyclic object"))
             return "[Circular]";
           throw c;
         }
       default:
-        return i;
+        return s;
     }
   });
-  for (let i = e[n]; n < t; i = e[++n])
-    i === null || typeof i != "object" ? o += ` ${i}` : o += ` ${Ce(i)}`;
+  for (let s = e[n]; n < t; s = e[++n])
+    s === null || typeof s != "object" ? o += ` ${s}` : o += ` ${Te(s)}`;
   return o;
 }
-s(wn, "format");
-function Ce(e, t = {}) {
-  return t.truncate === 0 && (t.truncate = Number.POSITIVE_INFINITY), Be(e, t);
+i(wn, "format");
+function Te(e, t = {}) {
+  return t.truncate === 0 && (t.truncate = Number.POSITIVE_INFINITY), ke(e, t);
 }
-s(Ce, "inspect");
-function An(e) {
+i(Te, "inspect");
+function Rn(e) {
   return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
 }
-s(An, "getDefaultExportFromCjs");
+i(Rn, "getDefaultExportFromCjs");
 
 // ../node_modules/@vitest/utils/dist/helpers.js
-function ri(e) {
+function ns(e) {
   return e === Object.prototype || e === Function.prototype || e === RegExp.prototype;
 }
-s(ri, "isFinalObj");
-function ze(e) {
+i(ns, "isFinalObj");
+function Be(e) {
   return Object.prototype.toString.apply(e).slice(8, -1);
 }
-s(ze, "getType");
-function oi(e, t) {
+i(Be, "getType");
+function rs(e, t) {
   let n = typeof t == "function" ? t : (r) => t.add(r);
   Object.getOwnPropertyNames(e).forEach(n), Object.getOwnPropertySymbols(e).forEach(n);
 }
-s(oi, "collectOwnProperties");
-function dt(e) {
+i(rs, "collectOwnProperties");
+function bt(e) {
   let t = /* @__PURE__ */ new Set();
-  return ri(e) ? [] : (oi(e, t), Array.from(t));
+  return ns(e) ? [] : (rs(e, t), Array.from(t));
 }
-s(dt, "getOwnProperties");
-var Rn = { forceWritable: !1 };
-function bt(e, t = Rn) {
+i(bt, "getOwnProperties");
+var An = { forceWritable: !1 };
+function St(e, t = An) {
   return yt(e, /* @__PURE__ */ new WeakMap(), t);
 }
-s(bt, "deepClone");
-function yt(e, t, n = Rn) {
+i(St, "deepClone");
+function yt(e, t, n = An) {
   let r, o;
   if (t.has(e))
     return t.get(e);
@@ -1433,24 +1433,24 @@ function yt(e, t, n = Rn) {
   }
   if (Object.prototype.toString.call(e) === "[object Object]") {
     o = Object.create(Object.getPrototypeOf(e)), t.set(e, o);
-    let i = dt(e);
-    for (let c of i) {
-      let l = Object.getOwnPropertyDescriptor(e, c);
-      if (!l)
+    let s = bt(e);
+    for (let c of s) {
+      let a = Object.getOwnPropertyDescriptor(e, c);
+      if (!a)
         continue;
       let u = yt(e[c], t, n);
       n.forceWritable ? Object.defineProperty(o, c, {
-        enumerable: l.enumerable,
+        enumerable: a.enumerable,
         configurable: !0,
         writable: !0,
         value: u
-      }) : "get" in l ? Object.defineProperty(o, c, {
-        ...l,
+      }) : "get" in a ? Object.defineProperty(o, c, {
+        ...a,
         get() {
           return u;
         }
       }) : Object.defineProperty(o, c, {
-        ...l,
+        ...a,
         value: u
       });
     }
@@ -1458,7 +1458,7 @@ function yt(e, t, n = Rn) {
   }
   return e;
 }
-s(yt, "clone");
+i(yt, "clone");
 
 // ../node_modules/@vitest/utils/dist/diff.js
 var z = -1, j = 1, M = 0, At = class At {
@@ -1468,28 +1468,28 @@ var z = -1, j = 1, M = 0, At = class At {
     this[0] = t, this[1] = n;
   }
 };
-s(At, "Diff");
-var N = At;
-function ii(e, t) {
+i(At, "Diff");
+var P = At;
+function os(e, t) {
   if (!e || !t || e.charAt(0) !== t.charAt(0))
     return 0;
-  let n = 0, r = Math.min(e.length, t.length), o = r, i = 0;
+  let n = 0, r = Math.min(e.length, t.length), o = r, s = 0;
   for (; n < o; )
-    e.substring(i, o) === t.substring(i, o) ? (n = o, i = n) : r = o, o = Math.floor((r - n) / 2 + n);
+    e.substring(s, o) === t.substring(s, o) ? (n = o, s = n) : r = o, o = Math.floor((r - n) / 2 + n);
   return o;
 }
-s(ii, "diff_commonPrefix");
+i(os, "diff_commonPrefix");
 function Vn(e, t) {
   if (!e || !t || e.charAt(e.length - 1) !== t.charAt(t.length - 1))
     return 0;
-  let n = 0, r = Math.min(e.length, t.length), o = r, i = 0;
+  let n = 0, r = Math.min(e.length, t.length), o = r, s = 0;
   for (; n < o; )
-    e.substring(e.length - o, e.length - i) === t.substring(t.length - o, t.length - i) ? (n = o, i = n) : r = o, o = Math.floor((r - n) / 2 +
+    e.substring(e.length - o, e.length - s) === t.substring(t.length - o, t.length - s) ? (n = o, s = n) : r = o, o = Math.floor((r - n) / 2 +
     n);
   return o;
 }
-s(Vn, "diff_commonSuffix");
-function Nn(e, t) {
+i(Vn, "diff_commonSuffix");
+function Pn(e, t) {
   let n = e.length, r = t.length;
   if (n === 0 || r === 0)
     return 0;
@@ -1497,265 +1497,265 @@ function Nn(e, t) {
   let o = Math.min(n, r);
   if (e === t)
     return o;
-  let i = 0, c = 1;
+  let s = 0, c = 1;
   for (; ; ) {
-    let l = e.substring(o - c), u = t.indexOf(l);
+    let a = e.substring(o - c), u = t.indexOf(a);
     if (u === -1)
-      return i;
-    c += u, (u === 0 || e.substring(o - c) === t.substring(0, c)) && (i = c, c++);
-  }
-}
-s(Nn, "diff_commonOverlap_");
-function si(e) {
-  let t = !1, n = [], r = 0, o = null, i = 0, c = 0, l = 0, u = 0, m = 0;
-  for (; i < e.length; )
-    e[i][0] === M ? (n[r++] = i, c = u, l = m, u = 0, m = 0, o = e[i][1]) : (e[i][0] === j ? u += e[i][1].length : m += e[i][1].length, o &&
-    o.length <= Math.max(c, l) && o.length <= Math.max(u, m) && (e.splice(n[r - 1], 0, new N(z, o)), e[n[r - 1] + 1][0] = j, r--, r--, i = r >
-    0 ? n[r - 1] : -1, c = 0, l = 0, u = 0, m = 0, o = null, t = !0)), i++;
-  for (t && qn(e), li(e), i = 1; i < e.length; ) {
-    if (e[i - 1][0] === z && e[i][0] === j) {
-      let p = e[i - 1][1], a = e[i][1], S = Nn(p, a), g = Nn(a, p);
-      S >= g ? (S >= p.length / 2 || S >= a.length / 2) && (e.splice(i, 0, new N(M, a.substring(0, S))), e[i - 1][1] = p.substring(0, p.length -
-      S), e[i + 1][1] = a.substring(S), i++) : (g >= p.length / 2 || g >= a.length / 2) && (e.splice(i, 0, new N(M, p.substring(0, g))), e[i -
-      1][0] = j, e[i - 1][1] = a.substring(0, a.length - g), e[i + 1][0] = z, e[i + 1][1] = p.substring(g), i++), i++;
+      return s;
+    c += u, (u === 0 || e.substring(o - c) === t.substring(0, c)) && (s = c, c++);
+  }
+}
+i(Pn, "diff_commonOverlap_");
+function ss(e) {
+  let t = !1, n = [], r = 0, o = null, s = 0, c = 0, a = 0, u = 0, m = 0;
+  for (; s < e.length; )
+    e[s][0] === M ? (n[r++] = s, c = u, a = m, u = 0, m = 0, o = e[s][1]) : (e[s][0] === j ? u += e[s][1].length : m += e[s][1].length, o &&
+    o.length <= Math.max(c, a) && o.length <= Math.max(u, m) && (e.splice(n[r - 1], 0, new P(z, o)), e[n[r - 1] + 1][0] = j, r--, r--, s = r >
+    0 ? n[r - 1] : -1, c = 0, a = 0, u = 0, m = 0, o = null, t = !0)), s++;
+  for (t && qn(e), us(e), s = 1; s < e.length; ) {
+    if (e[s - 1][0] === z && e[s][0] === j) {
+      let p = e[s - 1][1], l = e[s][1], b = Pn(p, l), g = Pn(l, p);
+      b >= g ? (b >= p.length / 2 || b >= l.length / 2) && (e.splice(s, 0, new P(M, l.substring(0, b))), e[s - 1][1] = p.substring(0, p.length -
+      b), e[s + 1][1] = l.substring(b), s++) : (g >= p.length / 2 || g >= l.length / 2) && (e.splice(s, 0, new P(M, p.substring(0, g))), e[s -
+      1][0] = j, e[s - 1][1] = l.substring(0, l.length - g), e[s + 1][0] = z, e[s + 1][1] = p.substring(g), s++), s++;
     }
-    i++;
+    s++;
   }
 }
-s(si, "diff_cleanupSemantic");
-var In = /[^a-z0-9]/i, Pn = /\s/, Mn = /[\r\n]/, ci = /\n\r?\n$/, ui = /^\r?\n\r?\n/;
-function li(e) {
+i(ss, "diff_cleanupSemantic");
+var Nn = /[^a-z0-9]/i, In = /\s/, Mn = /[\r\n]/, is = /\n\r?\n$/, cs = /^\r?\n\r?\n/;
+function us(e) {
   let t = 1;
   for (; t < e.length - 1; ) {
     if (e[t - 1][0] === M && e[t + 1][0] === M) {
-      let n = e[t - 1][1], r = e[t][1], o = e[t + 1][1], i = Vn(n, r);
-      if (i) {
-        let p = r.substring(r.length - i);
-        n = n.substring(0, n.length - i), r = p + r.substring(0, r.length - i), o = p + o;
+      let n = e[t - 1][1], r = e[t][1], o = e[t + 1][1], s = Vn(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, l = r, u = o, m = Ye(n, r) + Ye(r, o);
+      let c = n, a = r, u = o, m = ze(n, r) + ze(r, o);
       for (; r.charAt(0) === o.charAt(0); ) {
         n += r.charAt(0), r = r.substring(1) + o.charAt(0), o = o.substring(1);
-        let p = Ye(n, r) + Ye(r, o);
-        p >= m && (m = p, c = n, l = r, u = o);
+        let p = ze(n, r) + ze(r, o);
+        p >= m && (m = p, c = n, a = r, u = o);
       }
-      e[t - 1][1] !== c && (c ? e[t - 1][1] = c : (e.splice(t - 1, 1), t--), e[t][1] = l, u ? e[t + 1][1] = u : (e.splice(t + 1, 1), t--));
+      e[t - 1][1] !== c && (c ? e[t - 1][1] = c : (e.splice(t - 1, 1), t--), e[t][1] = a, u ? e[t + 1][1] = u : (e.splice(t + 1, 1), t--));
     }
     t++;
   }
 }
-s(li, "diff_cleanupSemanticLossless");
+i(us, "diff_cleanupSemanticLossless");
 function qn(e) {
-  e.push(new N(M, ""));
-  let t = 0, n = 0, r = 0, o = "", i = "", c;
+  e.push(new P(M, ""));
+  let t = 0, n = 0, r = 0, o = "", s = "", c;
   for (; t < e.length; )
     switch (e[t][0]) {
       case j:
-        r++, i += e[t][1], t++;
+        r++, s += e[t][1], t++;
         break;
       case z:
         n++, o += e[t][1], t++;
         break;
       case M:
-        n + r > 1 ? (n !== 0 && r !== 0 && (c = ii(i, o), c !== 0 && (t - n - r > 0 && e[t - n - r - 1][0] === M ? e[t - n - r - 1][1] += i.
-        substring(0, c) : (e.splice(0, 0, new N(M, i.substring(0, c))), t++), i = i.substring(c), o = o.substring(c)), c = Vn(i, o), c !== 0 &&
-        (e[t][1] = i.substring(i.length - c) + e[t][1], i = i.substring(0, i.length - c), o = o.substring(0, o.length - c))), t -= n + r, e.
-        splice(t, n + r), o.length && (e.splice(t, 0, new N(z, o)), t++), i.length && (e.splice(t, 0, new N(j, i)), t++), t++) : t !== 0 && e[t -
-        1][0] === M ? (e[t - 1][1] += e[t][1], e.splice(t, 1)) : t++, r = 0, n = 0, o = "", i = "";
+        n + r > 1 ? (n !== 0 && r !== 0 && (c = os(s, o), c !== 0 && (t - n - r > 0 && e[t - n - r - 1][0] === M ? e[t - n - r - 1][1] += s.
+        substring(0, c) : (e.splice(0, 0, new P(M, s.substring(0, c))), t++), s = s.substring(c), o = o.substring(c)), c = Vn(s, o), c !== 0 &&
+        (e[t][1] = s.substring(s.length - c) + e[t][1], s = s.substring(0, s.length - c), o = o.substring(0, o.length - c))), t -= n + r, e.
+        splice(t, n + r), o.length && (e.splice(t, 0, new P(z, o)), t++), s.length && (e.splice(t, 0, new P(j, s)), t++), t++) : t !== 0 && e[t -
+        1][0] === M ? (e[t - 1][1] += e[t][1], e.splice(t, 1)) : t++, r = 0, n = 0, o = "", s = "";
         break;
     }
   e[e.length - 1][1] === "" && e.pop();
-  let l = !1;
+  let a = !1;
   for (t = 1; t < e.length - 1; )
     e[t - 1][0] === M && e[t + 1][0] === M && (e[t][1].substring(e[t][1].length - e[t - 1][1].length) === e[t - 1][1] ? (e[t][1] = e[t - 1][1] +
-    e[t][1].substring(0, e[t][1].length - e[t - 1][1].length), e[t + 1][1] = e[t - 1][1] + e[t + 1][1], e.splice(t - 1, 1), l = !0) : e[t][1].
+    e[t][1].substring(0, e[t][1].length - e[t - 1][1].length), e[t + 1][1] = e[t - 1][1] + e[t + 1][1], e.splice(t - 1, 1), a = !0) : e[t][1].
     substring(0, e[t + 1][1].length) === e[t + 1][1] && (e[t - 1][1] += e[t + 1][1], e[t][1] = e[t][1].substring(e[t + 1][1].length) + e[t +
-    1][1], e.splice(t + 1, 1), l = !0)), t++;
-  l && qn(e);
+    1][1], e.splice(t + 1, 1), a = !0)), t++;
+  a && qn(e);
 }
-s(qn, "diff_cleanupMerge");
-function Ye(e, t) {
+i(qn, "diff_cleanupMerge");
+function ze(e, t) {
   if (!e || !t)
     return 6;
-  let n = e.charAt(e.length - 1), r = t.charAt(0), o = n.match(In), i = r.match(In), c = o && n.match(Pn), l = i && r.match(Pn), u = c && n.
-  match(Mn), m = l && r.match(Mn), p = u && e.match(ci), a = m && t.match(ui);
-  return p || a ? 5 : u || m ? 4 : o && !c && l ? 3 : c || l ? 2 : o || i ? 1 : 0;
-}
-s(Ye, "diff_cleanupSemanticScore_");
-var Kn = "Compared values have no visual difference.", ai = "Compared values serialize to the same structure.\nPrinting internal object struc\
-ture without calling `toJSON` instead.", Ue = {}, Ln;
-function fi() {
-  if (Ln) return Ue;
-  Ln = 1, Object.defineProperty(Ue, "__esModule", {
+  let n = e.charAt(e.length - 1), r = t.charAt(0), o = n.match(Nn), s = r.match(Nn), c = o && n.match(In), a = s && r.match(In), u = c && n.
+  match(Mn), m = a && r.match(Mn), p = u && e.match(is), l = m && t.match(cs);
+  return p || l ? 5 : u || m ? 4 : o && !c && a ? 3 : c || a ? 2 : o || s ? 1 : 0;
+}
+i(ze, "diff_cleanupSemanticScore_");
+var Kn = "Compared values have no visual difference.", as = "Compared values serialize to the same structure.\nPrinting internal object struc\
+ture without calling `toJSON` instead.", Ye = {}, Ln;
+function ls() {
+  if (Ln) return Ye;
+  Ln = 1, Object.defineProperty(Ye, "__esModule", {
     value: !0
-  }), Ue.default = S;
-  let e = "diff-sequences", t = 0, n = /* @__PURE__ */ s((g, h, f, y, b) => {
+  }), Ye.default = b;
+  let e = "diff-sequences", t = 0, n = /* @__PURE__ */ i((g, h, f, d, S) => {
     let _ = 0;
-    for (; g < h && f < y && b(g, f); )
+    for (; g < h && f < d && S(g, f); )
       g += 1, f += 1, _ += 1;
     return _;
-  }, "countCommonItemsF"), r = /* @__PURE__ */ s((g, h, f, y, b) => {
+  }, "countCommonItemsF"), r = /* @__PURE__ */ i((g, h, f, d, S) => {
     let _ = 0;
-    for (; g <= h && f <= y && b(h, y); )
-      h -= 1, y -= 1, _ += 1;
+    for (; g <= h && f <= d && S(h, d); )
+      h -= 1, d -= 1, _ += 1;
     return _;
-  }, "countCommonItemsR"), o = /* @__PURE__ */ s((g, h, f, y, b, _, O) => {
-    let d = 0, E = -g, $ = _[d], T = $;
-    _[d] += n(
+  }, "countCommonItemsR"), o = /* @__PURE__ */ i((g, h, f, d, S, _, O) => {
+    let y = 0, E = -g, $ = _[y], T = $;
+    _[y] += n(
       $ + 1,
       h,
-      y + $ - E + 1,
+      d + $ - E + 1,
       f,
-      b
+      S
     );
-    let A = g < O ? g : O;
-    for (d += 1, E += 2; d <= A; d += 1, E += 2) {
-      if (d !== g && T < _[d])
-        $ = _[d];
+    let R = g < O ? g : O;
+    for (y += 1, E += 2; y <= R; y += 1, E += 2) {
+      if (y !== g && T < _[y])
+        $ = _[y];
       else if ($ = T + 1, h <= $)
-        return d - 1;
-      T = _[d], _[d] = $ + n($ + 1, h, y + $ - E + 1, f, b);
+        return y - 1;
+      T = _[y], _[y] = $ + n($ + 1, h, d + $ - E + 1, f, S);
     }
     return O;
-  }, "extendPathsF"), i = /* @__PURE__ */ s((g, h, f, y, b, _, O) => {
-    let d = 0, E = g, $ = _[d], T = $;
-    _[d] -= r(
+  }, "extendPathsF"), s = /* @__PURE__ */ i((g, h, f, d, S, _, O) => {
+    let y = 0, E = g, $ = _[y], T = $;
+    _[y] -= r(
       h,
       $ - 1,
       f,
-      y + $ - E - 1,
-      b
+      d + $ - E - 1,
+      S
     );
-    let A = g < O ? g : O;
-    for (d += 1, E -= 2; d <= A; d += 1, E -= 2) {
-      if (d !== g && _[d] < T)
-        $ = _[d];
+    let R = g < O ? g : O;
+    for (y += 1, E -= 2; y <= R; y += 1, E -= 2) {
+      if (y !== g && _[y] < T)
+        $ = _[y];
       else if ($ = T - 1, $ < h)
-        return d - 1;
-      T = _[d], _[d] = $ - r(
+        return y - 1;
+      T = _[y], _[y] = $ - r(
         h,
         $ - 1,
         f,
-        y + $ - E - 1,
-        b
+        d + $ - E - 1,
+        S
       );
     }
     return O;
-  }, "extendPathsR"), c = /* @__PURE__ */ s((g, h, f, y, b, _, O, d, E, $, T) => {
-    let A = y - h, G = f - h, P = b - y - G, k = -P - (g - 1), H = -P + (g - 1), Y = t, I = g < d ? g : d;
-    for (let L = 0, x = -g; L <= I; L += 1, x += 2) {
-      let J = L === 0 || L !== g && Y < O[L], F = J ? O[L] : Y, V = J ? F : F + 1, re = A + V - x, q = n(
-        V + 1,
+  }, "extendPathsR"), c = /* @__PURE__ */ i((g, h, f, d, S, _, O, y, E, $, T) => {
+    let R = d - h, K = f - h, I = S - d - K, k = -I - (g - 1), G = -I + (g - 1), Y = t, N = g < y ? g : y;
+    for (let L = 0, x = -g; L <= N; L += 1, x += 2) {
+      let H = L === 0 || L !== g && Y < O[L], F = H ? O[L] : Y, W = H ? F : F + 1, re = R + W - x, V = n(
+        W + 1,
         f,
         re + 1,
-        b,
+        S,
         _
-      ), K = V + q;
-      if (Y = O[L], O[L] = K, k <= x && x <= H) {
-        let ie = (g - 1 - (x + P)) / 2;
-        if (ie <= $ && E[ie] - 1 <= K) {
-          let X = A + F - (J ? x + 1 : x - 1), W = r(
+      ), q = W + V;
+      if (Y = O[L], O[L] = q, k <= x && x <= G) {
+        let se = (g - 1 - (x + I)) / 2;
+        if (se <= $ && E[se] - 1 <= q) {
+          let J = R + F - (H ? x + 1 : x - 1), U = r(
             h,
             F,
-            y,
-            X,
+            d,
+            J,
             _
-          ), oe = F - W, ge = X - W, ue = oe + 1, Se = ge + 1;
-          T.nChangePreceding = g - 1, g - 1 === ue + Se - h - y ? (T.aEndPreceding = h, T.bEndPreceding = y) : (T.aEndPreceding = ue, T.bEndPreceding =
-          Se), T.nCommonPreceding = W, W !== 0 && (T.aCommonPreceding = ue, T.bCommonPreceding = Se), T.nCommonFollowing = q, q !== 0 && (T.
-          aCommonFollowing = V + 1, T.bCommonFollowing = re + 1);
-          let Oe = K + 1, $e = re + q + 1;
-          return T.nChangeFollowing = g - 1, g - 1 === f + b - Oe - $e ? (T.aStartFollowing = f, T.bStartFollowing = b) : (T.aStartFollowing =
-          Oe, T.bStartFollowing = $e), !0;
+          ), oe = F - U, he = J - U, ue = oe + 1, be = he + 1;
+          T.nChangePreceding = g - 1, g - 1 === ue + be - h - d ? (T.aEndPreceding = h, T.bEndPreceding = d) : (T.aEndPreceding = ue, T.bEndPreceding =
+          be), T.nCommonPreceding = U, U !== 0 && (T.aCommonPreceding = ue, T.bCommonPreceding = be), T.nCommonFollowing = V, V !== 0 && (T.
+          aCommonFollowing = W + 1, T.bCommonFollowing = re + 1);
+          let Ce = q + 1, Oe = re + V + 1;
+          return T.nChangeFollowing = g - 1, g - 1 === f + S - Ce - Oe ? (T.aStartFollowing = f, T.bStartFollowing = S) : (T.aStartFollowing =
+          Ce, T.bStartFollowing = Oe), !0;
         }
       }
     }
     return !1;
-  }, "extendOverlappablePathsF"), l = /* @__PURE__ */ s((g, h, f, y, b, _, O, d, E, $, T) => {
-    let A = b - f, G = f - h, P = b - y - G, k = P - g, H = P + g, Y = t, I = g < $ ? g : $;
-    for (let L = 0, x = g; L <= I; L += 1, x -= 2) {
-      let J = L === 0 || L !== g && E[L] < Y, F = J ? E[L] : Y, V = J ? F : F - 1, re = A + V - x, q = r(
+  }, "extendOverlappablePathsF"), a = /* @__PURE__ */ i((g, h, f, d, S, _, O, y, E, $, T) => {
+    let R = S - f, K = f - h, I = S - d - K, k = I - g, G = I + g, Y = t, N = g < $ ? g : $;
+    for (let L = 0, x = g; L <= N; L += 1, x -= 2) {
+      let H = L === 0 || L !== g && E[L] < Y, F = H ? E[L] : Y, W = H ? F : F - 1, re = R + W - x, V = r(
         h,
-        V - 1,
-        y,
+        W - 1,
+        d,
         re - 1,
         _
-      ), K = V - q;
-      if (Y = E[L], E[L] = K, k <= x && x <= H) {
-        let ie = (g + (x - P)) / 2;
-        if (ie <= d && K - 1 <= O[ie]) {
-          let X = re - q;
-          if (T.nChangePreceding = g, g === K + X - h - y ? (T.aEndPreceding = h, T.bEndPreceding = y) : (T.aEndPreceding = K, T.bEndPreceding =
-          X), T.nCommonPreceding = q, q !== 0 && (T.aCommonPreceding = K, T.bCommonPreceding = X), T.nChangeFollowing = g - 1, g === 1)
-            T.nCommonFollowing = 0, T.aStartFollowing = f, T.bStartFollowing = b;
+      ), q = W - V;
+      if (Y = E[L], E[L] = q, k <= x && x <= G) {
+        let se = (g + (x - I)) / 2;
+        if (se <= y && q - 1 <= O[se]) {
+          let J = re - V;
+          if (T.nChangePreceding = g, g === q + J - h - d ? (T.aEndPreceding = h, T.bEndPreceding = d) : (T.aEndPreceding = q, T.bEndPreceding =
+          J), T.nCommonPreceding = V, V !== 0 && (T.aCommonPreceding = q, T.bCommonPreceding = J), T.nChangeFollowing = g - 1, g === 1)
+            T.nCommonFollowing = 0, T.aStartFollowing = f, T.bStartFollowing = S;
           else {
-            let W = A + F - (J ? x - 1 : x + 1), oe = n(
+            let U = R + F - (H ? x - 1 : x + 1), oe = n(
               F,
               f,
-              W,
-              b,
+              U,
+              S,
               _
             );
-            T.nCommonFollowing = oe, oe !== 0 && (T.aCommonFollowing = F, T.bCommonFollowing = W);
-            let ge = F + oe, ue = W + oe;
-            g - 1 === f + b - ge - ue ? (T.aStartFollowing = f, T.bStartFollowing = b) : (T.aStartFollowing = ge, T.bStartFollowing = ue);
+            T.nCommonFollowing = oe, oe !== 0 && (T.aCommonFollowing = F, T.bCommonFollowing = U);
+            let he = F + oe, ue = U + oe;
+            g - 1 === f + S - he - ue ? (T.aStartFollowing = f, T.bStartFollowing = S) : (T.aStartFollowing = he, T.bStartFollowing = ue);
           }
           return !0;
         }
       }
     }
     return !1;
-  }, "extendOverlappablePathsR"), u = /* @__PURE__ */ s((g, h, f, y, b, _, O, d, E) => {
-    let $ = y - h, T = b - f, A = f - h, G = b - y, Q = G - A, P = A, k = A;
-    if (O[0] = h - 1, d[0] = f, Q % 2 === 0) {
-      let H = (g || Q) / 2, Y = (A + G) / 2;
-      for (let I = 1; I <= Y; I += 1)
-        if (P = o(I, f, b, $, _, O, P), I < H)
-          k = i(I, h, y, T, _, d, k);
+  }, "extendOverlappablePathsR"), u = /* @__PURE__ */ i((g, h, f, d, S, _, O, y, E) => {
+    let $ = d - h, T = S - f, R = f - h, K = S - d, Q = K - R, I = R, k = R;
+    if (O[0] = h - 1, y[0] = f, Q % 2 === 0) {
+      let G = (g || Q) / 2, Y = (R + K) / 2;
+      for (let N = 1; N <= Y; N += 1)
+        if (I = o(N, f, S, $, _, O, I), N < G)
+          k = s(N, h, d, T, _, y, 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.
-          l(
-            I,
+          a(
+            N,
             h,
             f,
-            y,
-            b,
+            d,
+            S,
             _,
             O,
-            P,
-            d,
+            I,
+            y,
             k,
             E
           )
         )
           return;
     } else {
-      let H = ((g || Q) + 1) / 2, Y = (A + G + 1) / 2, I = 1;
-      for (P = o(I, f, b, $, _, O, P), I += 1; I <= Y; I += 1)
-        if (k = i(
-          I - 1,
+      let G = ((g || Q) + 1) / 2, Y = (R + K + 1) / 2, N = 1;
+      for (I = o(N, f, S, $, _, O, I), N += 1; N <= Y; N += 1)
+        if (k = s(
+          N - 1,
           h,
-          y,
+          d,
           T,
           _,
-          d,
+          y,
           k
-        ), I < H)
-          P = o(I, f, b, $, _, O, P);
+        ), N < G)
+          I = o(N, f, S, $, _, O, I);
         else if (
           // If a forward path overlaps a reverse path in the same diagonal,
           // return a division of the index intervals at the middle change.
           c(
-            I,
+            N,
             h,
             f,
-            y,
-            b,
+            d,
+            S,
             _,
             O,
-            P,
-            d,
+            I,
+            y,
             k,
             E
           )
@@ -1763,94 +1763,94 @@ function fi() {
           return;
     }
     throw new Error(
-      `${e}: no overlap aStart=${h} aEnd=${f} bStart=${y} bEnd=${b}`
+      `${e}: no overlap aStart=${h} aEnd=${f} bStart=${d} bEnd=${S}`
     );
-  }, "divide"), m = /* @__PURE__ */ s((g, h, f, y, b, _, O, d, E, $) => {
-    if (b - y < f - h) {
+  }, "divide"), m = /* @__PURE__ */ i((g, h, f, d, S, _, O, y, E, $) => {
+    if (S - d < f - h) {
       if (_ = !_, _ && O.length === 1) {
-        let { foundSubsequence: K, isCommon: ie } = O[0];
+        let { foundSubsequence: q, isCommon: se } = O[0];
         O[1] = {
-          foundSubsequence: /* @__PURE__ */ s((X, W, oe) => {
-            K(X, oe, W);
+          foundSubsequence: /* @__PURE__ */ i((J, U, oe) => {
+            q(J, oe, U);
           }, "foundSubsequence"),
-          isCommon: /* @__PURE__ */ s((X, W) => ie(W, X), "isCommon")
+          isCommon: /* @__PURE__ */ i((J, U) => se(U, J), "isCommon")
         };
       }
-      let re = h, q = f;
-      h = y, f = b, y = re, b = q;
+      let re = h, V = f;
+      h = d, f = S, d = re, S = V;
     }
-    let { foundSubsequence: T, isCommon: A } = O[_ ? 1 : 0];
+    let { foundSubsequence: T, isCommon: R } = O[_ ? 1 : 0];
     u(
       g,
       h,
       f,
-      y,
-      b,
-      A,
       d,
+      S,
+      R,
+      y,
       E,
       $
     );
     let {
-      nChangePreceding: G,
+      nChangePreceding: K,
       aEndPreceding: Q,
-      bEndPreceding: P,
+      bEndPreceding: I,
       nCommonPreceding: k,
-      aCommonPreceding: H,
+      aCommonPreceding: G,
       bCommonPreceding: Y,
-      nCommonFollowing: I,
+      nCommonFollowing: N,
       aCommonFollowing: L,
       bCommonFollowing: x,
-      nChangeFollowing: J,
+      nChangeFollowing: H,
       aStartFollowing: F,
-      bStartFollowing: V
+      bStartFollowing: W
     } = $;
-    h < Q && y < P && m(
-      G,
+    h < Q && d < I && m(
+      K,
       h,
       Q,
-      y,
-      P,
+      d,
+      I,
       _,
       O,
-      d,
+      y,
       E,
       $
-    ), k !== 0 && T(k, H, Y), I !== 0 && T(I, L, x), F < f && V < b && m(
-      J,
+    ), k !== 0 && T(k, G, Y), N !== 0 && T(N, L, x), F < f && W < S && m(
+      H,
       F,
       f,
-      V,
-      b,
+      W,
+      S,
       _,
       O,
-      d,
+      y,
       E,
       $
     );
-  }, "findSubsequences"), p = /* @__PURE__ */ s((g, h) => {
+  }, "findSubsequences"), p = /* @__PURE__ */ i((g, h) => {
     if (typeof h != "number")
       throw new TypeError(`${e}: ${g} typeof ${typeof h} is not a number`);
     if (!Number.isSafeInteger(h))
       throw new RangeError(`${e}: ${g} value ${h} is not a safe integer`);
     if (h < 0)
       throw new RangeError(`${e}: ${g} value ${h} is a negative integer`);
-  }, "validateLength"), a = /* @__PURE__ */ s((g, h) => {
+  }, "validateLength"), l = /* @__PURE__ */ i((g, h) => {
     let f = typeof h;
     if (f !== "function")
       throw new TypeError(`${e}: ${g} typeof ${f} is not a function`);
   }, "validateCallback");
-  function S(g, h, f, y) {
-    p("aLength", g), p("bLength", h), a("isCommon", f), a("foundSubsequence", y);
-    let b = n(0, g, 0, h, f);
-    if (b !== 0 && y(b, 0, 0), g !== b || h !== b) {
-      let _ = b, O = b, d = r(
+  function b(g, h, f, d) {
+    p("aLength", g), p("bLength", h), l("isCommon", f), l("foundSubsequence", d);
+    let S = n(0, g, 0, h, f);
+    if (S !== 0 && d(S, 0, 0), g !== S || h !== S) {
+      let _ = S, O = S, y = r(
         _,
         g - 1,
         O,
         h - 1,
         f
-      ), E = g - d, $ = h - d, T = b + d;
+      ), E = g - y, $ = h - y, T = S + y;
       g !== T && h !== T && m(
         0,
         _,
@@ -1860,7 +1860,7 @@ function fi() {
         !1,
         [
           {
-            foundSubsequence: y,
+            foundSubsequence: d,
             isCommon: f
           }
         ],
@@ -1880,124 +1880,124 @@ function fi() {
           nCommonFollowing: t,
           nCommonPreceding: t
         }
-      ), d !== 0 && y(d, E, $);
+      ), y !== 0 && d(y, E, $);
     }
   }
-  return s(S, "diffSequence"), Ue;
+  return i(b, "diffSequence"), Ye;
 }
-s(fi, "requireBuild");
-var mi = fi(), Gn = /* @__PURE__ */ An(mi);
-function pi(e, t) {
+i(ls, "requireBuild");
+var fs = ls(), Gn = /* @__PURE__ */ Rn(fs);
+function ms(e, t) {
   return e.replace(/\s+$/, (n) => t(n));
 }
-s(pi, "formatTrailingSpaces");
-function $t(e, t, n, r, o, i) {
-  return e.length !== 0 ? n(`${r} ${pi(e, o)}`) : r !== " " ? n(r) : t && i.length !== 0 ? n(`${r} ${i}`) : "";
+i(ms, "formatTrailingSpaces");
+function wt(e, t, n, r, o, s) {
+  return e.length !== 0 ? n(`${r} ${ms(e, o)}`) : r !== " " ? n(r) : t && s.length !== 0 ? n(`${r} ${s}`) : "";
 }
-s($t, "printDiffLine");
-function Hn(e, t, { aColor: n, aIndicator: r, changeLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: i }) {
-  return $t(e, t, n, r, o, i);
+i(wt, "printDiffLine");
+function Hn(e, t, { aColor: n, aIndicator: r, changeLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: s }) {
+  return wt(e, t, n, r, o, s);
 }
-s(Hn, "printDeleteLine");
-function Jn(e, t, { bColor: n, bIndicator: r, changeLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: i }) {
-  return $t(e, t, n, r, o, i);
+i(Hn, "printDeleteLine");
+function Jn(e, t, { bColor: n, bIndicator: r, changeLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: s }) {
+  return wt(e, t, n, r, o, s);
 }
-s(Jn, "printInsertLine");
-function Xn(e, t, { commonColor: n, commonIndicator: r, commonLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: i }) {
-  return $t(e, t, n, r, o, i);
+i(Jn, "printInsertLine");
+function Xn(e, t, { commonColor: n, commonIndicator: r, commonLineTrailingSpaceColor: o, emptyFirstOrLastLinePlaceholder: s }) {
+  return wt(e, t, n, r, o, s);
 }
-s(Xn, "printCommonLine");
+i(Xn, "printCommonLine");
 function xn(e, t, n, r, { patchColor: o }) {
   return o(`@@ -${e + 1},${t - e} +${n + 1},${r - n} @@`);
 }
-s(xn, "createPatchMark");
-function gi(e, t) {
-  let n = e.length, r = t.contextLines, o = r + r, i = n, c = !1, l = 0, u = 0;
+i(xn, "createPatchMark");
+function ps(e, t) {
+  let n = e.length, r = t.contextLines, o = r + r, s = n, c = !1, a = 0, u = 0;
   for (; u !== n; ) {
-    let d = u;
+    let y = u;
     for (; u !== n && e[u][0] === M; )
       u += 1;
-    if (d !== u)
-      if (d === 0)
-        u > r && (i -= u - r, c = !0);
+    if (y !== u)
+      if (y === 0)
+        u > r && (s -= u - r, c = !0);
       else if (u === n) {
-        let E = u - d;
-        E > r && (i -= E - r, c = !0);
+        let E = u - y;
+        E > r && (s -= E - r, c = !0);
       } else {
-        let E = u - d;
-        E > o && (i -= E - o, l += 1);
+        let E = u - y;
+        E > o && (s -= E - o, a += 1);
       }
     for (; u !== n && e[u][0] !== M; )
       u += 1;
   }
-  let m = l !== 0 || c;
-  l !== 0 ? i += l + 1 : c && (i += 1);
-  let p = i - 1, a = [], S = 0;
-  m && a.push("");
-  let g = 0, h = 0, f = 0, y = 0, b = /* @__PURE__ */ s((d) => {
-    let E = a.length;
-    a.push(Xn(d, E === 0 || E === p, t)), f += 1, y += 1;
-  }, "pushCommonLine"), _ = /* @__PURE__ */ s((d) => {
-    let E = a.length;
-    a.push(Hn(d, E === 0 || E === p, t)), f += 1;
-  }, "pushDeleteLine"), O = /* @__PURE__ */ s((d) => {
-    let E = a.length;
-    a.push(Jn(d, E === 0 || E === p, t)), y += 1;
+  let m = a !== 0 || c;
+  a !== 0 ? s += a + 1 : c && (s += 1);
+  let p = s - 1, l = [], b = 0;
+  m && l.push("");
+  let g = 0, h = 0, f = 0, d = 0, S = /* @__PURE__ */ i((y) => {
+    let E = l.length;
+    l.push(Xn(y, E === 0 || E === p, t)), f += 1, d += 1;
+  }, "pushCommonLine"), _ = /* @__PURE__ */ i((y) => {
+    let E = l.length;
+    l.push(Hn(y, E === 0 || E === p, t)), f += 1;
+  }, "pushDeleteLine"), O = /* @__PURE__ */ i((y) => {
+    let E = l.length;
+    l.push(Jn(y, E === 0 || E === p, t)), d += 1;
   }, "pushInsertLine");
   for (u = 0; u !== n; ) {
-    let d = u;
+    let y = u;
     for (; u !== n && e[u][0] === M; )
       u += 1;
-    if (d !== u)
-      if (d === 0) {
-        u > r && (d = u - r, g = d, h = d, f = g, y = h);
-        for (let E = d; E !== u; E += 1)
-          b(e[E][1]);
+    if (y !== u)
+      if (y === 0) {
+        u > r && (y = u - r, g = y, h = y, f = g, d = h);
+        for (let E = y; E !== u; E += 1)
+          S(e[E][1]);
       } else if (u === n) {
-        let E = u - d > r ? d + r : u;
-        for (let $ = d; $ !== E; $ += 1)
-          b(e[$][1]);
+        let E = u - y > r ? y + r : u;
+        for (let $ = y; $ !== E; $ += 1)
+          S(e[$][1]);
       } else {
-        let E = u - d;
+        let E = u - y;
         if (E > o) {
-          let $ = d + r;
-          for (let A = d; A !== $; A += 1)
-            b(e[A][1]);
-          a[S] = xn(g, f, h, y, t), S = a.length, a.push("");
+          let $ = y + r;
+          for (let R = y; R !== $; R += 1)
+            S(e[R][1]);
+          l[b] = xn(g, f, h, d, t), b = l.length, l.push("");
           let T = E - o;
-          g = f + T, h = y + T, f = g, y = h;
-          for (let A = u - r; A !== u; A += 1)
-            b(e[A][1]);
+          g = f + T, h = d + T, f = g, d = h;
+          for (let R = u - r; R !== u; R += 1)
+            S(e[R][1]);
         } else
-          for (let $ = d; $ !== u; $ += 1)
-            b(e[$][1]);
+          for (let $ = y; $ !== u; $ += 1)
+            S(e[$][1]);
       }
     for (; u !== n && e[u][0] === z; )
       _(e[u][1]), u += 1;
     for (; u !== n && e[u][0] === j; )
       O(e[u][1]), u += 1;
   }
-  return m && (a[S] = xn(g, f, h, y, t)), a.join(`
+  return m && (l[b] = xn(g, f, h, d, t)), l.join(`
 `);
 }
-s(gi, "joinAlignedDiffsNoExpand");
-function hi(e, t) {
+i(ps, "joinAlignedDiffsNoExpand");
+function gs(e, t) {
   return e.map((n, r, o) => {
-    let i = n[1], c = r === 0 || r === o.length - 1;
+    let s = n[1], c = r === 0 || r === o.length - 1;
     switch (n[0]) {
       case z:
-        return Hn(i, c, t);
+        return Hn(s, c, t);
       case j:
-        return Jn(i, c, t);
+        return Jn(s, c, t);
       default:
-        return Xn(i, c, t);
+        return Xn(s, c, t);
     }
   }).join(`
 `);
 }
-s(hi, "joinAlignedDiffsExpand");
-var St = /* @__PURE__ */ s((e) => e, "noColor"), Zn = 5, yi = 0;
-function di() {
+i(gs, "joinAlignedDiffsExpand");
+var Et = /* @__PURE__ */ i((e) => e, "noColor"), Zn = 5, hs = 0;
+function ds() {
   return {
     aAnnotation: "Expected",
     aColor: v.green,
@@ -2006,10 +2006,10 @@ function di() {
     bColor: v.red,
     bIndicator: "+",
     changeColor: v.inverse,
-    changeLineTrailingSpaceColor: St,
+    changeLineTrailingSpaceColor: Et,
     commonColor: v.dim,
     commonIndicator: " ",
-    commonLineTrailingSpaceColor: St,
+    commonLineTrailingSpaceColor: Et,
     compareKeys: void 0,
     contextLines: Zn,
     emptyFirstOrLastLinePlaceholder: "",
@@ -2018,34 +2018,34 @@ function di() {
     omitAnnotationLines: !1,
     patchColor: v.yellow,
     printBasicPrototype: !1,
-    truncateThreshold: yi,
+    truncateThreshold: hs,
     truncateAnnotation: "... Diff result is truncated",
-    truncateAnnotationColor: St
+    truncateAnnotationColor: Et
   };
 }
-s(di, "getDefaultOptions");
-function bi(e) {
+i(ds, "getDefaultOptions");
+function ys(e) {
   return e && typeof e == "function" ? e : void 0;
 }
-s(bi, "getCompareKeys");
-function Si(e) {
+i(ys, "getCompareKeys");
+function bs(e) {
   return typeof e == "number" && Number.isSafeInteger(e) && e >= 0 ? e : Zn;
 }
-s(Si, "getContextLines");
-function pe(e = {}) {
+i(bs, "getContextLines");
+function ge(e = {}) {
   return {
-    ...di(),
+    ...ds(),
     ...e,
-    compareKeys: bi(e.compareKeys),
-    contextLines: Si(e.contextLines)
+    compareKeys: ys(e.compareKeys),
+    contextLines: bs(e.contextLines)
   };
 }
-s(pe, "normalizeDiffOptions");
-function de(e) {
+i(ge, "normalizeDiffOptions");
+function ye(e) {
   return e.length === 1 && e[0].length === 0;
 }
-s(de, "isEmptyString");
-function Ei(e) {
+i(ye, "isEmptyString");
+function Ss(e) {
   let t = 0, n = 0;
   return e.forEach((r) => {
     switch (r[0]) {
@@ -2061,69 +2061,69 @@ function Ei(e) {
     b: n
   };
 }
-s(Ei, "countChanges");
-function _i({ aAnnotation: e, aColor: t, aIndicator: n, bAnnotation: r, bColor: o, bIndicator: i, includeChangeCounts: c, omitAnnotationLines: l }, u) {
-  if (l)
+i(Ss, "countChanges");
+function Es({ aAnnotation: e, aColor: t, aIndicator: n, bAnnotation: r, bColor: o, bIndicator: s, includeChangeCounts: c, omitAnnotationLines: a }, u) {
+  if (a)
     return "";
   let m = "", p = "";
   if (c) {
-    let g = String(u.a), h = String(u.b), f = r.length - e.length, y = " ".repeat(Math.max(0, f)), b = " ".repeat(Math.max(0, -f)), _ = h.length -
-    g.length, O = " ".repeat(Math.max(0, _)), d = " ".repeat(Math.max(0, -_));
-    m = `${y}  ${n} ${O}${g}`, p = `${b}  ${i} ${d}${h}`;
+    let g = String(u.a), h = String(u.b), f = r.length - e.length, d = " ".repeat(Math.max(0, f)), S = " ".repeat(Math.max(0, -f)), _ = h.length -
+    g.length, O = " ".repeat(Math.max(0, _)), y = " ".repeat(Math.max(0, -_));
+    m = `${d}  ${n} ${O}${g}`, p = `${S}  ${s} ${y}${h}`;
   }
-  let a = `${n} ${e}${m}`, S = `${i} ${r}${p}`;
-  return `${t(a)}
-${o(S)}
+  let l = `${n} ${e}${m}`, b = `${s} ${r}${p}`;
+  return `${t(l)}
+${o(b)}
 
 `;
 }
-s(_i, "printAnnotation");
-function wt(e, t, n) {
-  return _i(n, Ei(e)) + (n.expand ? hi(e, n) : gi(e, n)) + (t ? n.truncateAnnotationColor(`
+i(Es, "printAnnotation");
+function Rt(e, t, n) {
+  return Es(n, Ss(e)) + (n.expand ? gs(e, n) : ps(e, n)) + (t ? n.truncateAnnotationColor(`
 ${n.truncateAnnotation}`) : "");
 }
-s(wt, "printDiffLines");
-function Ve(e, t, n) {
-  let r = pe(n), [o, i] = Qn(de(e) ? [] : e, de(t) ? [] : t, r);
-  return wt(o, i, r);
-}
-s(Ve, "diffLinesUnified");
-function Ti(e, t, n, r, o) {
-  if (de(e) && de(n) && (e = [], n = []), de(t) && de(r) && (t = [], r = []), e.length !== n.length || t.length !== r.length)
-    return Ve(e, t, o);
-  let [i, c] = Qn(n, r, o), l = 0, u = 0;
-  return i.forEach((m) => {
+i(Rt, "printDiffLines");
+function We(e, t, n) {
+  let r = ge(n), [o, s] = Qn(ye(e) ? [] : e, ye(t) ? [] : t, r);
+  return Rt(o, s, r);
+}
+i(We, "diffLinesUnified");
+function _s(e, t, n, r, o) {
+  if (ye(e) && ye(n) && (e = [], n = []), ye(t) && ye(r) && (t = [], r = []), e.length !== n.length || t.length !== r.length)
+    return We(e, t, o);
+  let [s, c] = Qn(n, r, o), a = 0, u = 0;
+  return s.forEach((m) => {
     switch (m[0]) {
       case z:
-        m[1] = e[l], l += 1;
+        m[1] = e[a], a += 1;
         break;
       case j:
         m[1] = t[u], u += 1;
         break;
       default:
-        m[1] = t[u], l += 1, u += 1;
+        m[1] = t[u], a += 1, u += 1;
     }
-  }), wt(i, c, pe(o));
+  }), Rt(s, c, ge(o));
 }
-s(Ti, "diffLinesUnified2");
+i(_s, "diffLinesUnified2");
 function Qn(e, t, n) {
-  let r = n?.truncateThreshold ?? !1, o = Math.max(Math.floor(n?.truncateThreshold ?? 0), 0), i = r ? Math.min(e.length, o) : e.length, c = r ?
-  Math.min(t.length, o) : t.length, l = i !== e.length || c !== t.length, u = /* @__PURE__ */ s((g, h) => e[g] === t[h], "isCommon"), m = [],
-  p = 0, a = 0;
-  for (Gn(i, c, u, /* @__PURE__ */ s((g, h, f) => {
+  let r = n?.truncateThreshold ?? !1, o = Math.max(Math.floor(n?.truncateThreshold ?? 0), 0), s = r ? Math.min(e.length, o) : e.length, c = r ?
+  Math.min(t.length, o) : t.length, a = s !== e.length || c !== t.length, u = /* @__PURE__ */ i((g, h) => e[g] === t[h], "isCommon"), m = [],
+  p = 0, l = 0;
+  for (Gn(s, c, u, /* @__PURE__ */ i((g, h, f) => {
     for (; p !== h; p += 1)
-      m.push(new N(z, e[p]));
-    for (; a !== f; a += 1)
-      m.push(new N(j, t[a]));
-    for (; g !== 0; g -= 1, p += 1, a += 1)
-      m.push(new N(M, t[a]));
-  }, "foundSubsequence")); p !== i; p += 1)
-    m.push(new N(z, e[p]));
-  for (; a !== c; a += 1)
-    m.push(new N(j, t[a]));
-  return [m, l];
-}
-s(Qn, "diffLinesRaw");
+      m.push(new P(z, e[p]));
+    for (; l !== f; l += 1)
+      m.push(new P(j, t[l]));
+    for (; g !== 0; g -= 1, p += 1, l += 1)
+      m.push(new P(M, t[l]));
+  }, "foundSubsequence")); p !== s; p += 1)
+    m.push(new P(z, e[p]));
+  for (; l !== c; l += 1)
+    m.push(new P(j, t[l]));
+  return [m, a];
+}
+i(Qn, "diffLinesRaw");
 function Dn(e) {
   if (e === void 0)
     return "undefined";
@@ -2157,36 +2157,36 @@ function Dn(e) {
     return "symbol";
   throw new Error(`value of unknown type: ${e}`);
 }
-s(Dn, "getType");
+i(Dn, "getType");
 function Fn(e) {
   return e.includes(`\r
 `) ? `\r
 ` : `
 `;
 }
-s(Fn, "getNewLineSymbol");
-function Ci(e, t, n) {
-  let r = n?.truncateThreshold ?? !1, o = Math.max(Math.floor(n?.truncateThreshold ?? 0), 0), i = e.length, c = t.length;
+i(Fn, "getNewLineSymbol");
+function Ts(e, t, n) {
+  let r = n?.truncateThreshold ?? !1, o = Math.max(Math.floor(n?.truncateThreshold ?? 0), 0), s = e.length, c = t.length;
   if (r) {
     let g = e.includes(`
 `), h = t.includes(`
-`), f = Fn(e), y = Fn(t), b = g ? `${e.split(f, o).join(f)}
-` : e, _ = h ? `${t.split(y, o).join(y)}
+`), f = Fn(e), d = Fn(t), S = g ? `${e.split(f, o).join(f)}
+` : e, _ = h ? `${t.split(d, o).join(d)}
 ` : t;
-    i = b.length, c = _.length;
+    s = S.length, c = _.length;
   }
-  let l = i !== e.length || c !== t.length, u = /* @__PURE__ */ s((g, h) => e[g] === t[h], "isCommon"), m = 0, p = 0, a = [];
-  return Gn(i, c, u, /* @__PURE__ */ s((g, h, f) => {
-    m !== h && a.push(new N(z, e.slice(m, h))), p !== f && a.push(new N(j, t.slice(p, f))), m = h + g, p = f + g, a.push(new N(M, t.slice(f,
+  let a = s !== e.length || c !== t.length, u = /* @__PURE__ */ i((g, h) => e[g] === t[h], "isCommon"), m = 0, p = 0, l = [];
+  return Gn(s, c, u, /* @__PURE__ */ i((g, h, f) => {
+    m !== h && l.push(new P(z, e.slice(m, h))), p !== f && l.push(new P(j, t.slice(p, f))), m = h + g, p = f + g, l.push(new P(M, t.slice(f,
     p)));
-  }, "foundSubsequence")), m !== i && a.push(new N(z, e.slice(m))), p !== c && a.push(new N(j, t.slice(p))), [a, l];
+  }, "foundSubsequence")), m !== s && l.push(new P(z, e.slice(m))), p !== c && l.push(new P(j, t.slice(p))), [l, a];
 }
-s(Ci, "diffStrings");
-function Oi(e, t, n) {
+i(Ts, "diffStrings");
+function Cs(e, t, n) {
   return t.reduce((r, o) => r + (o[0] === M ? o[1] : o[0] === e && o[1].length !== 0 ? n(o[1]) : ""), "");
 }
-s(Oi, "concatenateRelevantDiffs");
-var Rt = class Rt {
+i(Cs, "concatenateRelevantDiffs");
+var Pt = class Pt {
   op;
   line;
   lines;
@@ -2195,36 +2195,39 @@ var Rt = class Rt {
     this.op = t, this.line = [], this.lines = [], this.changeColor = n;
   }
   pushSubstring(t) {
-    this.pushDiff(new N(this.op, t));
+    this.pushDiff(new P(this.op, t));
   }
   pushLine() {
-    this.lines.push(this.line.length !== 1 ? new N(this.op, Oi(this.op, this.line, this.changeColor)) : this.line[0][0] === this.op ? this.line[0] :
-    new N(this.op, this.line[0][1])), this.line.length = 0;
+    this.lines.push(this.line.length !== 1 ? new P(this.op, Cs(this.op, this.line, this.changeColor)) : this.line[0][0] === this.op ? this.line[0] :
+    new P(this.op, this.line[0][1])), this.line.length = 0;
   }
   isLineEmpty() {
     return this.line.length === 0;
   }
+  // Minor input to buffer.
   pushDiff(t) {
     this.line.push(t);
   }
+  // Main input to buffer.
   align(t) {
     let n = t[1];
     if (n.includes(`
 `)) {
       let r = n.split(`
 `), o = r.length - 1;
-      r.forEach((i, c) => {
-        c < o ? (this.pushSubstring(i), this.pushLine()) : i.length !== 0 && this.pushSubstring(i);
+      r.forEach((s, c) => {
+        c < o ? (this.pushSubstring(s), this.pushLine()) : s.length !== 0 && this.pushSubstring(s);
       });
     } else
       this.pushDiff(t);
   }
+  // Output from buffer.
   moveLinesTo(t) {
     this.isLineEmpty() || this.pushLine(), t.push(...this.lines), this.lines.length = 0;
   }
 };
-s(Rt, "ChangeBuffer");
-var We = Rt, Nt = class Nt {
+i(Pt, "ChangeBuffer");
+var Ue = Pt, Nt = class Nt {
   deleteBuffer;
   insertBuffer;
   lines;
@@ -2242,45 +2245,47 @@ var We = Rt, Nt = class Nt {
   flushChangeLines() {
     this.deleteBuffer.moveLinesTo(this.lines), this.insertBuffer.moveLinesTo(this.lines);
   }
+  // Input to buffer.
   align(t) {
     let n = t[0], r = t[1];
     if (r.includes(`
 `)) {
       let o = r.split(`
-`), i = o.length - 1;
-      o.forEach((c, l) => {
-        if (l === 0) {
-          let u = new N(n, c);
+`), s = o.length - 1;
+      o.forEach((c, a) => {
+        if (a === 0) {
+          let u = new P(n, c);
           this.deleteBuffer.isLineEmpty() && this.insertBuffer.isLineEmpty() ? (this.flushChangeLines(), this.pushDiffCommonLine(u)) : (this.
           pushDiffChangeLines(u), this.flushChangeLines());
-        } else l < i ? this.pushDiffCommonLine(new N(n, c)) : c.length !== 0 && this.pushDiffChangeLines(new N(n, c));
+        } else a < s ? this.pushDiffCommonLine(new P(n, c)) : c.length !== 0 && this.pushDiffChangeLines(new P(n, c));
       });
     } else
       this.pushDiffChangeLines(t);
   }
+  // Output from buffer.
   getLines() {
     return this.flushChangeLines(), this.lines;
   }
 };
-s(Nt, "CommonBuffer");
-var _t = Nt;
-function $i(e, t) {
-  let n = new We(z, t), r = new We(j, t), o = new _t(n, r);
-  return e.forEach((i) => {
-    switch (i[0]) {
+i(Nt, "CommonBuffer");
+var Tt = Nt;
+function Os(e, t) {
+  let n = new Ue(z, t), r = new Ue(j, t), o = new Tt(n, r);
+  return e.forEach((s) => {
+    switch (s[0]) {
       case z:
-        n.align(i);
+        n.align(s);
         break;
       case j:
-        r.align(i);
+        r.align(s);
         break;
       default:
-        o.align(i);
+        o.align(s);
     }
   }), o.getLines();
 }
-s($i, "getAlignedDiffs");
-function wi(e, t) {
+i(Os, "getAlignedDiffs");
+function $s(e, t) {
   if (t) {
     let n = e.length - 1;
     return e.some((r, o) => r[0] === M && (o !== n || r[1] !== `
@@ -2288,43 +2293,43 @@ function wi(e, t) {
   }
   return e.some((n) => n[0] === M);
 }
-s(wi, "hasCommonDiff");
-function Ai(e, t, n) {
+i($s, "hasCommonDiff");
+function ws(e, t, n) {
   if (e !== t && e.length !== 0 && t.length !== 0) {
     let r = e.includes(`
 `) || t.includes(`
-`), [o, i] = vn(r ? `${e}
+`), [o, s] = vn(r ? `${e}
 ` : e, r ? `${t}
 ` : t, !0, n);
-    if (wi(o, r)) {
-      let c = pe(n), l = $i(o, c.changeColor);
-      return wt(l, i, c);
+    if ($s(o, r)) {
+      let c = ge(n), a = Os(o, c.changeColor);
+      return Rt(a, s, c);
     }
   }
-  return Ve(e.split(`
+  return We(e.split(`
 `), t.split(`
 `), n);
 }
-s(Ai, "diffStringsUnified");
+i(ws, "diffStringsUnified");
 function vn(e, t, n, r) {
-  let [o, i] = Ci(e, t, r);
-  return n && si(o), [o, i];
+  let [o, s] = Ts(e, t, r);
+  return n && ss(o), [o, s];
 }
-s(vn, "diffStringsRaw");
-function Tt(e, t) {
-  let { commonColor: n } = pe(t);
+i(vn, "diffStringsRaw");
+function Ct(e, t) {
+  let { commonColor: n } = ge(t);
   return n(e);
 }
-s(Tt, "getCommonMessage");
-var { AsymmetricMatcher: Ri, DOMCollection: Ni, DOMElement: Ii, Immutable: Pi, ReactElement: Mi, ReactTestComponent: Li } = Te, er = [
-  Li,
-  Mi,
-  Ii,
-  Ni,
-  Pi,
-  Ri,
-  Te.Error
-], Ct = {
+i(Ct, "getCommonMessage");
+var { AsymmetricMatcher: Rs, DOMCollection: As, DOMElement: Ps, Immutable: Ns, ReactElement: Is, ReactTestComponent: Ms } = _e, er = [
+  Ms,
+  Is,
+  Ps,
+  As,
+  Ns,
+  Rs,
+  _e.Error
+], Ot = {
   maxDepth: 20,
   plugins: er
 }, tr = {
@@ -2332,83 +2337,83 @@ var { AsymmetricMatcher: Ri, DOMCollection: Ni, DOMElement: Ii, Immutable: Pi, R
   maxDepth: 8,
   plugins: er
 };
-function xi(e, t, n) {
+function Ls(e, t, n) {
   if (Object.is(e, t))
     return "";
-  let r = Dn(e), o = r, i = !1;
+  let r = Dn(e), o = r, s = !1;
   if (r === "object" && typeof e.asymmetricMatch == "function") {
     if (e.$$typeof !== Symbol.for("jest.asymmetricMatcher") || typeof e.getExpectedType != "function")
       return;
-    o = e.getExpectedType(), i = o === "string";
+    o = e.getExpectedType(), s = o === "string";
   }
   if (o !== Dn(t)) {
-    let y = function(O) {
+    let d = function(O) {
       return O.length <= f ? O : `${O.slice(0, f)}...`;
     };
-    s(y, "truncate");
-    let { aAnnotation: c, aColor: l, aIndicator: u, bAnnotation: m, bColor: p, bIndicator: a } = pe(n), S = Ot(tr, n), g = Z(e, S), h = Z(t,
-    S), f = 1e5;
-    g = y(g), h = y(h);
-    let b = `${l(`${u} ${c}:`)} 
-${g}`, _ = `${p(`${a} ${m}:`)} 
+    i(d, "truncate");
+    let { aAnnotation: c, aColor: a, aIndicator: u, bAnnotation: m, bColor: p, bIndicator: l } = ge(n), b = $t(tr, n), g = X(e, b), h = X(t,
+    b), f = 1e5;
+    g = d(g), h = d(h);
+    let S = `${a(`${u} ${c}:`)} 
+${g}`, _ = `${p(`${l} ${m}:`)} 
 ${h}`;
-    return `${b}
+    return `${S}
 
 ${_}`;
   }
-  if (!i)
+  if (!s)
     switch (r) {
       case "string":
-        return Ve(e.split(`
+        return We(e.split(`
 `), t.split(`
 `), n);
       case "boolean":
       case "number":
-        return Di(e, t, n);
+        return xs(e, t, n);
       case "map":
-        return Et(jn(e), jn(t), n);
+        return _t(jn(e), jn(t), n);
       case "set":
-        return Et(kn(e), kn(t), n);
+        return _t(kn(e), kn(t), n);
       default:
-        return Et(e, t, n);
+        return _t(e, t, n);
     }
 }
-s(xi, "diff");
-function Di(e, t, n) {
-  let r = Z(e, Ct), o = Z(t, Ct);
-  return r === o ? "" : Ve(r.split(`
+i(Ls, "diff");
+function xs(e, t, n) {
+  let r = X(e, Ot), o = X(t, Ot);
+  return r === o ? "" : We(r.split(`
 `), o.split(`
 `), n);
 }
-s(Di, "comparePrimitive");
+i(xs, "comparePrimitive");
 function jn(e) {
   return new Map(Array.from(e.entries()).sort());
 }
-s(jn, "sortMap");
+i(jn, "sortMap");
 function kn(e) {
   return new Set(Array.from(e.values()).sort());
 }
-s(kn, "sortSet");
-function Et(e, t, n) {
+i(kn, "sortSet");
+function _t(e, t, n) {
   let r, o = !1;
   try {
-    let c = Ot(Ct, n);
+    let c = $t(Ot, n);
     r = Bn(e, t, c, n);
   } catch {
     o = !0;
   }
-  let i = Tt(Kn, n);
-  if (r === void 0 || r === i) {
-    let c = Ot(tr, n);
-    r = Bn(e, t, c, n), r !== i && !o && (r = `${Tt(ai, n)}
+  let s = Ct(Kn, n);
+  if (r === void 0 || r === s) {
+    let c = $t(tr, n);
+    r = Bn(e, t, c, n), r !== s && !o && (r = `${Ct(as, n)}
 
 ${r}`);
   }
   return r;
 }
-s(Et, "compareObjects");
-function Ot(e, t) {
-  let { compareKeys: n, printBasicPrototype: r, maxDepth: o } = pe(t);
+i(_t, "compareObjects");
+function $t(e, t) {
+  let { compareKeys: n, printBasicPrototype: r, maxDepth: o } = ge(t);
   return {
     ...e,
     compareKeys: n,
@@ -2416,49 +2421,49 @@ function Ot(e, t) {
     maxDepth: o ?? e.maxDepth
   };
 }
-s(Ot, "getFormatOptions");
+i($t, "getFormatOptions");
 function Bn(e, t, n, r) {
   let o = {
     ...n,
     indent: 0
-  }, i = Z(e, o), c = Z(t, o);
-  if (i === c)
-    return Tt(Kn, r);
+  }, s = X(e, o), c = X(t, o);
+  if (s === c)
+    return Ct(Kn, r);
   {
-    let l = Z(e, n), u = Z(t, n);
-    return Ti(l.split(`
+    let a = X(e, n), u = X(t, n);
+    return _s(a.split(`
 `), u.split(`
-`), i.split(`
+`), s.split(`
 `), c.split(`
 `), r);
   }
 }
-s(Bn, "getObjectsDifference");
+i(Bn, "getObjectsDifference");
 var zn = 2e4;
 function Yn(e) {
-  return ze(e) === "Object" && typeof e.asymmetricMatch == "function";
+  return Be(e) === "Object" && typeof e.asymmetricMatch == "function";
 }
-s(Yn, "isAsymmetricMatcher");
+i(Yn, "isAsymmetricMatcher");
 function Un(e, t) {
-  let n = ze(e), r = ze(t);
+  let n = Be(e), r = Be(t);
   return n === r && (n === "Object" || n === "Array");
 }
-s(Un, "isReplaceable");
+i(Un, "isReplaceable");
 function nr(e, t, n) {
-  let { aAnnotation: r, bAnnotation: o } = pe(n);
+  let { aAnnotation: r, bAnnotation: o } = ge(n);
   if (typeof t == "string" && typeof e == "string" && t.length > 0 && e.length > 0 && t.length <= zn && e.length <= zn && t !== e) {
     if (t.includes(`
 `) || e.includes(`
 `))
-      return Ai(t, e, n);
-    let [p] = vn(t, e, !0), a = p.some((f) => f[0] === M), S = Fi(r, o), g = S(r) + Bi(Wn(p, z, a)), h = S(o) + ki(Wn(p, j, a));
+      return ws(t, e, n);
+    let [p] = vn(t, e, !0), l = p.some((f) => f[0] === M), b = Ds(r, o), g = b(r) + ks(Wn(p, z, l)), h = b(o) + js(Wn(p, j, l));
     return `${g}
 ${h}`;
   }
-  let i = bt(t, { forceWritable: !0 }), c = bt(e, { forceWritable: !0 }), { replacedExpected: l, replacedActual: u } = rr(c, i);
-  return xi(l, u, n);
+  let s = St(t, { forceWritable: !0 }), c = St(e, { forceWritable: !0 }), { replacedExpected: a, replacedActual: u } = rr(c, s);
+  return Ls(a, u, n);
 }
-s(nr, "printDiffOrStringify");
+i(nr, "printDiffOrStringify");
 function rr(e, t, n = /* @__PURE__ */ new WeakSet(), r = /* @__PURE__ */ new WeakSet()) {
   return e instanceof Error && t instanceof Error && typeof e.cause < "u" && typeof t.cause > "u" ? (delete e.cause, {
     replacedActual: e,
@@ -2466,15 +2471,15 @@ function rr(e, t, n = /* @__PURE__ */ new WeakSet(), r = /* @__PURE__ */ new Wea
   }) : Un(e, t) ? n.has(e) || r.has(t) ? {
     replacedActual: e,
     replacedExpected: t
-  } : (n.add(e), r.add(t), dt(t).forEach((o) => {
-    let i = t[o], c = e[o];
-    if (Yn(i))
-      i.asymmetricMatch(c) && (e[o] = i);
+  } : (n.add(e), r.add(t), bt(t).forEach((o) => {
+    let s = t[o], c = e[o];
+    if (Yn(s))
+      s.asymmetricMatch(c) && (e[o] = s);
     else if (Yn(c))
-      c.asymmetricMatch(i) && (t[o] = c);
-    else if (Un(c, i)) {
-      let l = rr(c, i, n, r);
-      e[o] = l.replacedActual, t[o] = l.replacedExpected;
+      c.asymmetricMatch(s) && (t[o] = c);
+    else if (Un(c, s)) {
+      let a = rr(c, s, n, r);
+      e[o] = a.replacedActual, t[o] = a.replacedExpected;
     }
   }), {
     replacedActual: e,
@@ -2484,52 +2489,62 @@ function rr(e, t, n = /* @__PURE__ */ new WeakSet(), r = /* @__PURE__ */ new Wea
     replacedExpected: t
   };
 }
-s(rr, "replaceAsymmetricMatcher");
-function Fi(...e) {
+i(rr, "replaceAsymmetricMatcher");
+function Ds(...e) {
   let t = e.reduce((n, r) => r.length > n ? r.length : n, 0);
   return (n) => `${n}: ${" ".repeat(t - n.length)}`;
 }
-s(Fi, "getLabelPrinter");
-var ji = "\xB7";
+i(Ds, "getLabelPrinter");
+var Fs = "\xB7";
 function or(e) {
-  return e.replace(/\s+$/gm, (t) => ji.repeat(t.length));
+  return e.replace(/\s+$/gm, (t) => Fs.repeat(t.length));
 }
-s(or, "replaceTrailingSpaces");
-function ki(e) {
-  return v.red(or(me(e)));
+i(or, "replaceTrailingSpaces");
+function js(e) {
+  return v.red(or(pe(e)));
 }
-s(ki, "printReceived");
-function Bi(e) {
-  return v.green(or(me(e)));
+i(js, "printReceived");
+function ks(e) {
+  return v.green(or(pe(e)));
 }
-s(Bi, "printExpected");
+i(ks, "printExpected");
 function Wn(e, t, n) {
   return e.reduce((r, o) => r + (o[0] === M ? o[1] : o[0] === t ? n ? v.inverse(o[1]) : o[1] : ""), "");
 }
-s(Wn, "getCommonAndChangedSubstrings");
+i(Wn, "getCommonAndChangedSubstrings");
 
 // ../node_modules/@vitest/utils/dist/error.js
-var zi = "@@__IMMUTABLE_RECORD__@@", Yi = "@@__IMMUTABLE_ITERABLE__@@";
-function Ui(e) {
-  return e && (e[Yi] || e[zi]);
+var Bs = "@@__IMMUTABLE_RECORD__@@", zs = "@@__IMMUTABLE_ITERABLE__@@";
+function Ys(e) {
+  return e && (e[zs] || e[Bs]);
 }
-s(Ui, "isImmutable");
-var Wi = Object.getPrototypeOf({});
-function ir(e) {
+i(Ys, "isImmutable");
+var Us = Object.getPrototypeOf({});
+function sr(e) {
   return e instanceof Error ? `<unserializable>: ${e.message}` : typeof e == "string" ? `<unserializable>: ${e}` : "<unserializable>";
 }
-s(ir, "getUnserializableMessage");
-function be(e, t = /* @__PURE__ */ new WeakMap()) {
+i(sr, "getUnserializableMessage");
+function le(e, t = /* @__PURE__ */ new WeakMap()) {
   if (!e || typeof e == "string")
     return e;
+  if (e instanceof Error && "toJSON" in e && typeof e.toJSON == "function") {
+    let n = e.toJSON();
+    return n && n !== e && typeof n == "object" && (typeof e.message == "string" && Ve(() => n.message ?? (n.message = e.message)), typeof e.
+    stack == "string" && Ve(() => n.stack ?? (n.stack = e.stack)), typeof e.name == "string" && Ve(() => n.name ?? (n.name = e.name)), e.cause !=
+    null && Ve(() => n.cause ?? (n.cause = le(e.cause, t)))), le(n, t);
+  }
   if (typeof e == "function")
     return `Function<${e.name || "anonymous"}>`;
   if (typeof e == "symbol")
     return e.toString();
   if (typeof e != "object")
     return e;
-  if (Ui(e))
-    return be(e.toJSON(), t);
+  if (typeof Buffer < "u" && e instanceof Buffer)
+    return `<Buffer(${e.length}) ...>`;
+  if (typeof Uint8Array < "u" && e instanceof Uint8Array)
+    return `<Uint8Array(${e.length}) ...>`;
+  if (Ys(e))
+    return le(e.toJSON(), t);
   if (e instanceof Promise || e.constructor && e.constructor.prototype === "AsyncFunction")
     return "Promise";
   if (typeof Element < "u" && e instanceof Element)
@@ -2537,50 +2552,57 @@ function be(e, t = /* @__PURE__ */ new WeakMap()) {
   if (typeof e.asymmetricMatch == "function")
     return `${e.toString()} ${wn(e.sample)}`;
   if (typeof e.toJSON == "function")
-    return be(e.toJSON(), t);
+    return le(e.toJSON(), t);
   if (t.has(e))
     return t.get(e);
   if (Array.isArray(e)) {
     let n = new Array(e.length);
     return t.set(e, n), e.forEach((r, o) => {
       try {
-        n[o] = be(r, t);
-      } catch (i) {
-        n[o] = ir(i);
+        n[o] = le(r, t);
+      } catch (s) {
+        n[o] = sr(s);
       }
     }), n;
   } else {
     let n = /* @__PURE__ */ Object.create(null);
     t.set(e, n);
     let r = e;
-    for (; r && r !== Wi; )
+    for (; r && r !== Us; )
       Object.getOwnPropertyNames(r).forEach((o) => {
         if (!(o in n))
           try {
-            n[o] = be(e[o], t);
-          } catch (i) {
-            delete n[o], n[o] = ir(i);
+            n[o] = le(e[o], t);
+          } catch (s) {
+            delete n[o], n[o] = sr(s);
           }
       }), r = Object.getPrototypeOf(r);
     return n;
   }
 }
-s(be, "serializeValue");
-function Vi(e) {
+i(le, "serializeValue");
+function Ve(e) {
+  try {
+    return e();
+  } catch {
+  }
+}
+i(Ve, "safe");
+function Ws(e) {
   return e.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
 }
-s(Vi, "normalizeErrorMessage");
+i(Ws, "normalizeErrorMessage");
 function It(e, t, n = /* @__PURE__ */ new WeakSet()) {
   if (!e || typeof e != "object")
     return { message: String(e) };
   let r = e;
-  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 = nr(r.actual, r.expected, {
+  (r.showDiff || r.showDiff === void 0 && r.expected !== void 0 && r.actual !== void 0) && (r.diff = nr(r.actual, r.expected, {
     ...t,
     ...r.diffOptions
-  })), typeof r.expected != "string" && (r.expected = me(r.expected, 10)), typeof r.actual != "string" && (r.actual = me(r.actual, 10));
+  })), "expected" in r && typeof r.expected != "string" && (r.expected = pe(r.expected, 10)), "actual" in r && typeof r.actual != "string" &&
+  (r.actual = pe(r.actual, 10));
   try {
-    typeof r.message == "string" && (r.message = Vi(r.message));
+    typeof r.message == "string" && (r.message = Ws(r.message));
   } catch {
   }
   try {
@@ -2588,13 +2610,13 @@ function It(e, t, n = /* @__PURE__ */ new WeakSet()) {
   } catch {
   }
   try {
-    return be(r);
+    return le(r);
   } catch (o) {
-    return be(new Error(`Failed to fully serialize error: ${o?.message}
+    return le(new Error(`Failed to fully serialize error: ${o?.message}
 Inner error message: ${r?.message}`));
   }
 }
-s(It, "processError");
+i(It, "processError");
 
 // src/instrumenter/EVENTS.ts
 var ne = {
@@ -2611,33 +2633,27 @@ var ne = {
 var qe = globalThis.__STORYBOOK_ADDONS_PREVIEW;
 
 // src/instrumenter/types.ts
-var qi = /* @__PURE__ */ ((o) => (o.DONE = "done", o.ERROR = "error", o.ACTIVE = "active", o.WAITING = "waiting", o))(qi || {});
+var Vs = /* @__PURE__ */ ((o) => (o.DONE = "done", o.ERROR = "error", o.ACTIVE = "active", o.WAITING = "waiting", o))(Vs || {});
 
 // src/instrumenter/instrumenter.ts
-var cr = {
-  start: !1,
-  back: !1,
-  goto: !1,
-  next: !1,
-  end: !1
-}, Ji = new Error(
+var Hs = new Error(
   "This function ran after the play function completed. Did you forget to `await` it?"
-), ur = /* @__PURE__ */ s((e) => Object.prototype.toString.call(e) === "[object Object]", "isObject"), Xi = /* @__PURE__ */ s((e) => Object.
-prototype.toString.call(e) === "[object Module]", "isModule"), Zi = /* @__PURE__ */ s((e) => {
-  if (!ur(e) && !Xi(e))
+), cr = /* @__PURE__ */ i((e) => Object.prototype.toString.call(e) === "[object Object]", "isObject"), Js = /* @__PURE__ */ i((e) => Object.
+prototype.toString.call(e) === "[object Module]", "isModule"), Xs = /* @__PURE__ */ i((e) => {
+  if (!cr(e) && !Js(e))
     return !1;
   if (e.constructor === void 0)
     return !0;
   let t = e.constructor.prototype;
-  return !!ur(t);
-}, "isInstrumentable"), Qi = /* @__PURE__ */ s((e) => {
+  return !!cr(t);
+}, "isInstrumentable"), Zs = /* @__PURE__ */ i((e) => {
   try {
     return new e.constructor();
   } catch {
     return {};
   }
-}, "construct"), Pt = /* @__PURE__ */ s(() => ({
-  renderPhase: void 0,
+}, "construct"), Mt = /* @__PURE__ */ i(() => ({
+  renderPhase: "preparing",
   isDebugging: !1,
   isPlaying: !1,
   isLocked: !1,
@@ -2650,7 +2666,7 @@ prototype.toString.call(e) === "[object Module]", "isModule"), Zi = /* @__PURE__
   playUntil: void 0,
   resolvers: {},
   syncTimeout: void 0
-}), "getInitialState"), lr = /* @__PURE__ */ s((e, t = !1) => {
+}), "getInitialState"), ur = /* @__PURE__ */ i((e, t = !1) => {
   let n = (t ? e.shadowCalls : e.calls).filter((o) => o.retain);
   if (!n.length)
     return;
@@ -2658,238 +2674,279 @@ prototype.toString.call(e) === "[object Module]", "isModule"), Zi = /* @__PURE__
     Array.from(e.callRefsByResult.entries()).filter(([, o]) => o.retain)
   );
   return { cursor: n.length, calls: n, callRefsByResult: r };
-}, "getRetainedState"), Lt = class Lt {
+}, "getRetainedState"), xt = class xt {
   constructor() {
+    this.detached = !1;
     this.initialized = !1;
-    this.state = U.window?.parent?.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ || {};
-    let t = /* @__PURE__ */ s(({
+    // State is tracked per story to deal with multiple stories on the same canvas (i.e. docs mode)
+    this.state = {};
+    this.loadParentWindowState = /* @__PURE__ */ i(() => {
+      try {
+        this.state = Z.window?.parent?.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ || {};
+      } catch {
+        this.detached = !0;
+      }
+    }, "loadParentWindowState");
+    this.updateParentWindowState = /* @__PURE__ */ i(() => {
+      try {
+        Z.window.parent.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ = this.state;
+      } catch {
+        this.detached = !0;
+      }
+    }, "updateParentWindowState");
+    this.loadParentWindowState();
+    let t = /* @__PURE__ */ i(({
       storyId: u,
-      isPlaying: m = !0,
-      isDebugging: p = !1
+      renderPhase: m,
+      isPlaying: p = !0,
+      isDebugging: l = !1
     }) => {
-      let a = this.getState(u);
+      let b = this.getState(u);
       this.setState(u, {
-        ...Pt(),
-        ...lr(a, p),
-        shadowCalls: p ? a.shadowCalls : [],
-        chainedCallIds: p ? a.chainedCallIds : /* @__PURE__ */ new Set(),
-        playUntil: p ? a.playUntil : void 0,
-        isPlaying: m,
-        isDebugging: p
+        ...Mt(),
+        ...ur(b, l),
+        renderPhase: m || b.renderPhase,
+        shadowCalls: l ? b.shadowCalls : [],
+        chainedCallIds: l ? b.chainedCallIds : /* @__PURE__ */ new Set(),
+        playUntil: l ? b.playUntil : void 0,
+        isPlaying: p,
+        isDebugging: l
       }), this.sync(u);
-    }, "resetState"), n = /* @__PURE__ */ s((u) => ({ storyId: m, playUntil: p }) => {
-      this.getState(m).isDebugging || this.setState(m, ({ calls: S }) => ({
+    }, "resetState"), n = /* @__PURE__ */ i((u) => ({ storyId: m, playUntil: p }) => {
+      this.getState(m).isDebugging || this.setState(m, ({ calls: b }) => ({
         calls: [],
-        shadowCalls: S.map((g) => ({ ...g, status: "waiting" })),
+        shadowCalls: b.map((g) => ({ ...g, status: "waiting" })),
         isDebugging: !0
       }));
-      let a = this.getLog(m);
-      this.setState(m, ({ shadowCalls: S }) => {
-        if (p || !a.length)
+      let l = this.getLog(m);
+      this.setState(m, ({ shadowCalls: b }) => {
+        if (p || !l.length)
           return { playUntil: p };
-        let g = S.findIndex((h) => h.id === a[0].callId);
+        let g = b.findIndex((h) => h.id === l[0].callId);
         return {
-          playUntil: S.slice(0, g).filter((h) => h.interceptable && !h.ancestors?.length).slice(-1)[0]?.id
+          playUntil: b.slice(0, g).filter((h) => h.interceptable && !h.ancestors?.length).slice(-1)[0]?.id
         };
-      }), u.emit(sr, { storyId: m, isDebugging: !0 });
-    }, "start"), r = /* @__PURE__ */ s((u) => ({ storyId: m }) => {
-      let p = this.getLog(m).filter((S) => !S.ancestors?.length), a = p.reduceRight((S, g, h) => S >= 0 || g.status === "waiting" ? S : h, -1);
-      n(u)({ storyId: m, playUntil: p[a - 1]?.callId });
-    }, "back"), o = /* @__PURE__ */ s((u) => ({ storyId: m, callId: p }) => {
-      let { calls: a, shadowCalls: S, resolvers: g } = this.getState(m), h = a.find(({ id: y }) => y === p), f = S.find(({ id: y }) => y ===
+      }), u.emit(ir, { storyId: m, isDebugging: !0 });
+    }, "start"), r = /* @__PURE__ */ i((u) => ({ storyId: m }) => {
+      let p = this.getLog(m).filter((b) => !b.ancestors?.length), l = p.reduceRight((b, g, h) => b >= 0 || g.status === "waiting" ? b : h, -1);
+      n(u)({ storyId: m, playUntil: p[l - 1]?.callId });
+    }, "back"), o = /* @__PURE__ */ i((u) => ({ storyId: m, callId: p }) => {
+      let { calls: l, shadowCalls: b, resolvers: g } = this.getState(m), h = l.find(({ id: d }) => d === p), f = b.find(({ id: d }) => d ===
       p);
       if (!h && f && Object.values(g).length > 0) {
-        let y = this.getLog(m).find((b) => b.status === "waiting")?.callId;
-        f.id !== y && this.setState(m, { playUntil: f.id }), Object.values(g).forEach((b) => b());
+        let d = this.getLog(m).find((S) => S.status === "waiting")?.callId;
+        f.id !== d && this.setState(m, { playUntil: f.id }), Object.values(g).forEach((S) => S());
       } else
         n(u)({ storyId: m, playUntil: p });
-    }, "goto"), i = /* @__PURE__ */ s((u) => ({ storyId: m }) => {
+    }, "goto"), s = /* @__PURE__ */ i((u) => ({ storyId: m }) => {
       let { resolvers: p } = this.getState(m);
       if (Object.values(p).length > 0)
-        Object.values(p).forEach((a) => a());
+        Object.values(p).forEach((l) => l());
       else {
-        let a = this.getLog(m).find((S) => S.status === "waiting")?.callId;
-        a ? n(u)({ storyId: m, playUntil: a }) : c({ storyId: m });
+        let l = this.getLog(m).find((b) => b.status === "waiting")?.callId;
+        l ? n(u)({ storyId: m, playUntil: l }) : c({ storyId: m });
       }
-    }, "next"), c = /* @__PURE__ */ s(({ storyId: u }) => {
+    }, "next"), c = /* @__PURE__ */ i(({ storyId: u }) => {
       this.setState(u, { playUntil: void 0, isDebugging: !1 }), Object.values(this.getState(u).resolvers).forEach((m) => m());
-    }, "end"), l = /* @__PURE__ */ s(({ storyId: u, newPhase: m }) => {
+    }, "end"), a = /* @__PURE__ */ i(({
+      storyId: u,
+      newPhase: m
+    }) => {
       let { isDebugging: p } = this.getState(u);
-      this.setState(u, { renderPhase: m }), m === "preparing" && p && t({ storyId: u }), m === "playing" && t({ storyId: u, isDebugging: p }),
-      m === "played" && this.setState(u, {
+      if (m === "preparing" && p)
+        return t({ storyId: u, renderPhase: m });
+      if (m === "playing")
+        return t({ storyId: u, renderPhase: m, isDebugging: p });
+      m === "played" ? this.setState(u, {
+        renderPhase: m,
         isLocked: !1,
         isPlaying: !1,
         isDebugging: !1
-      }), m === "errored" && this.setState(u, {
+      }) : m === "errored" ? this.setState(u, {
+        renderPhase: m,
         isLocked: !1,
         isPlaying: !1
-      });
+      }) : m === "aborted" ? this.setState(u, {
+        renderPhase: m,
+        isLocked: !0,
+        isPlaying: !1
+      }) : this.setState(u, {
+        renderPhase: m
+      }), this.sync(u);
     }, "renderPhaseChanged");
     qe && qe.ready().then(() => {
-      this.channel = qe.getChannel(), this.channel.on(sr, t), this.channel.on(Hi, l), this.channel.on(Gi, () => {
+      this.channel = qe.getChannel(), this.channel.on(ir, t), this.channel.on(Gs, a), this.channel.on(Ks, () => {
         this.initialized ? this.cleanup() : this.initialized = !0;
       }), this.channel.on(ne.START, n(this.channel)), this.channel.on(ne.BACK, r(this.channel)), this.channel.on(ne.GOTO, o(this.channel)), this.
-      channel.on(ne.NEXT, i(this.channel)), this.channel.on(ne.END, c);
+      channel.on(ne.NEXT, s(this.channel)), this.channel.on(ne.END, c);
     });
   }
   getState(t) {
-    return this.state[t] || Pt();
+    return this.state[t] || Mt();
   }
   setState(t, n) {
-    let r = this.getState(t), o = typeof n == "function" ? n(r) : n;
-    this.state = { ...this.state, [t]: { ...r, ...o } }, U.window?.parent && (U.window.parent.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ =
-    this.state);
+    if (t) {
+      let r = this.getState(t), o = typeof n == "function" ? n(r) : n;
+      this.state = { ...this.state, [t]: { ...r, ...o } }, this.updateParentWindowState();
+    }
   }
   cleanup() {
     this.state = Object.entries(this.state).reduce(
-      (n, [r, o]) => {
-        let i = lr(o);
-        return i && (n[r] = Object.assign(Pt(), i)), n;
+      (r, [o, s]) => {
+        let c = ur(s);
+        return c && (r[o] = Object.assign(Mt(), c)), r;
       },
       {}
     );
-    let t = { controlStates: cr, logItems: [] };
-    this.channel?.emit(ne.SYNC, t), U.window?.parent && (U.window.parent.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ = this.state);
+    let n = { controlStates: {
+      detached: this.detached,
+      start: !1,
+      back: !1,
+      goto: !1,
+      next: !1,
+      end: !1
+    }, logItems: [] };
+    this.channel?.emit(ne.SYNC, n), this.updateParentWindowState();
   }
   getLog(t) {
     let { calls: n, shadowCalls: r } = this.getState(t), o = [...r];
-    n.forEach((c, l) => {
-      o[l] = c;
+    n.forEach((c, a) => {
+      o[a] = c;
     });
-    let i = /* @__PURE__ */ new Set();
-    return o.reduceRight((c, l) => (l.args.forEach((u) => {
-      u?.__callId__ && i.add(u.__callId__);
-    }), l.path.forEach((u) => {
-      u.__callId__ && i.add(u.__callId__);
-    }), (l.interceptable || l.exception) && !i.has(l.id) && (c.unshift({ callId: l.id, status: l.status, ancestors: l.ancestors }), i.add(l.
+    let s = /* @__PURE__ */ new Set();
+    return o.reduceRight((c, a) => (a.args.forEach((u) => {
+      u?.__callId__ && s.add(u.__callId__);
+    }), a.path.forEach((u) => {
+      u.__callId__ && s.add(u.__callId__);
+    }), (a.interceptable || a.exception) && !s.has(a.id) && (c.unshift({ callId: a.id, status: a.status, ancestors: a.ancestors }), s.add(a.
     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(t, n, r = 0) {
-    if (!Zi(t))
+    if (!Xs(t))
       return t;
-    let { mutate: o = !1, path: i = [] } = n, c = n.getKeys ? n.getKeys(t, r) : Object.keys(t);
+    let { mutate: o = !1, path: s = [] } = n, c = n.getKeys ? n.getKeys(t, r) : Object.keys(t);
     return r += 1, c.reduce(
-      (l, u) => {
-        let m = es(t, u);
+      (a, u) => {
+        let m = vs(t, u);
         if (typeof m?.get == "function") {
           if (m.configurable) {
-            let a = /* @__PURE__ */ s(() => m?.get?.bind(t)?.(), "getter");
-            Object.defineProperty(l, u, {
-              get: /* @__PURE__ */ s(() => this.instrument(a(), { ...n, path: i.concat(u) }, r), "get")
+            let l = /* @__PURE__ */ i(() => m?.get?.bind(t)?.(), "getter");
+            Object.defineProperty(a, u, {
+              get: /* @__PURE__ */ i(() => this.instrument(l(), { ...n, path: s.concat(u) }, r), "get")
             });
           }
-          return l;
+          return a;
         }
         let p = t[u];
-        return typeof p != "function" ? (l[u] = this.instrument(p, { ...n, path: i.concat(u) }, r), l) : "__originalFn__" in p && typeof p.__originalFn__ ==
-        "function" ? (l[u] = p, l) : (l[u] = (...a) => this.track(u, p, t, a, n), l[u].__originalFn__ = p, Object.defineProperty(l[u], "name",
+        return typeof p != "function" ? (a[u] = this.instrument(p, { ...n, path: s.concat(u) }, r), a) : "__originalFn__" in p && typeof p.__originalFn__ ==
+        "function" ? (a[u] = p, a) : (a[u] = (...l) => this.track(u, p, t, l, n), a[u].__originalFn__ = p, Object.defineProperty(a[u], "name",
         { value: u, writable: !1 }), Object.keys(p).length > 0 && Object.assign(
-          l[u],
-          this.instrument({ ...p }, { ...n, path: i.concat(u) }, r)
-        ), l);
+          a[u],
+          this.instrument({ ...p }, { ...n, path: s.concat(u) }, r)
+        ), a);
       },
-      o ? t : Qi(t)
+      o ? t : Zs(t)
     );
   }
   // 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(t, n, r, o, i) {
-    let c = o?.[0]?.__storyId__ || U.__STORYBOOK_PREVIEW__?.selectionStore?.selection?.storyId, { cursor: l, ancestors: u } = this.getState(
+  track(t, n, r, o, s) {
+    let c = o?.[0]?.__storyId__ || Z.__STORYBOOK_PREVIEW__?.selectionStore?.selection?.storyId, { cursor: a, ancestors: u } = this.getState(
     c);
-    this.setState(c, { cursor: l + 1 });
-    let m = `${u.slice(-1)[0] || c} [${l}] ${t}`, { path: p = [], intercept: a = !1, retain: S = !1 } = i, g = typeof a == "function" ? a(t,
-    p) : a, h = { id: m, cursor: l, storyId: c, ancestors: u, path: p, method: t, args: o, interceptable: g, retain: S }, y = (g && !u.length ?
-    this.intercept : this.invoke).call(this, n, r, h, i);
-    return this.instrument(y, { ...i, mutate: !0, path: [{ __callId__: h.id }] });
+    this.setState(c, { cursor: a + 1 });
+    let m = `${u.slice(-1)[0] || c} [${a}] ${t}`, { path: p = [], intercept: l = !1, retain: b = !1 } = s, g = typeof l == "function" ? l(t,
+    p) : l, h = { id: m, cursor: a, storyId: c, ancestors: u, path: p, method: t, args: o, interceptable: g, retain: b }, d = (g && !u.length ?
+    this.intercept : this.invoke).call(this, n, r, h, s);
+    return this.instrument(d, { ...s, mutate: !0, path: [{ __callId__: h.id }] });
   }
   intercept(t, n, r, o) {
-    let { chainedCallIds: i, isDebugging: c, playUntil: l } = this.getState(r.storyId), u = i.has(r.id);
-    return !c || u || l ? (l === r.id && this.setState(r.storyId, { playUntil: void 0 }), this.invoke(t, n, r, o)) : new Promise((m) => {
+    let { chainedCallIds: s, isDebugging: c, playUntil: a } = this.getState(r.storyId), u = s.has(r.id);
+    return !c || u || a ? (a === r.id && this.setState(r.storyId, { playUntil: void 0 }), this.invoke(t, n, r, o)) : new Promise((m) => {
       this.setState(r.storyId, ({ resolvers: p }) => ({
         isLocked: !1,
         resolvers: { ...p, [r.id]: m }
       }));
     }).then(() => (this.setState(r.storyId, (m) => {
-      let { [r.id]: p, ...a } = m.resolvers;
-      return { isLocked: !0, resolvers: a };
+      let { [r.id]: p, ...l } = m.resolvers;
+      return { isLocked: !0, resolvers: l };
     }), this.invoke(t, n, r, o)));
   }
   invoke(t, n, r, o) {
-    let { callRefsByResult: i, renderPhase: c } = this.getState(r.storyId), l = 25, u = /* @__PURE__ */ s((a, S, g) => {
-      if (g.includes(a))
+    let { callRefsByResult: s, renderPhase: c } = this.getState(r.storyId), a = 25, u = /* @__PURE__ */ i((l, b, g) => {
+      if (g.includes(l))
         return "[Circular]";
-      if (g = [...g, a], S > l)
+      if (g = [...g, l], b > a)
         return "...";
-      if (i.has(a))
-        return i.get(a);
-      if (a instanceof Array)
-        return a.map((h) => u(h, ++S, g));
-      if (a instanceof Date)
-        return { __date__: { value: a.toISOString() } };
-      if (a instanceof Error) {
-        let { name: h, message: f, stack: y } = a;
-        return { __error__: { name: h, message: f, stack: y } };
+      if (s.has(l))
+        return s.get(l);
+      if (l instanceof Array)
+        return l.map((h) => u(h, ++b, g));
+      if (l instanceof Date)
+        return { __date__: { value: l.toISOString() } };
+      if (l instanceof Error) {
+        let { name: h, message: f, stack: d } = l;
+        return { __error__: { name: h, message: f, stack: d } };
       }
-      if (a instanceof RegExp) {
-        let { flags: h, source: f } = a;
+      if (l instanceof RegExp) {
+        let { flags: h, source: f } = l;
         return { __regexp__: { flags: h, source: f } };
       }
-      if (a instanceof U.window?.HTMLElement) {
-        let { prefix: h, localName: f, id: y, classList: b, innerText: _ } = a, O = Array.from(b);
-        return { __element__: { prefix: h, localName: f, id: y, classNames: O, innerText: _ } };
+      if (l instanceof Z.window?.HTMLElement) {
+        let { prefix: h, localName: f, id: d, classList: S, innerText: _ } = l, O = Array.from(S);
+        return { __element__: { prefix: h, localName: f, id: d, classNames: O, innerText: _ } };
       }
-      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(([h, f]) => [h, u(f, ++S, g)])
-      ) : a;
+      return typeof l == "function" ? {
+        __function__: { name: "getMockName" in l ? l.getMockName() : l.name }
+      } : typeof l == "symbol" ? { __symbol__: { description: l.description } } : typeof l == "object" && l?.constructor?.name && l?.constructor?.
+      name !== "Object" ? { __class__: { name: l.constructor.name } } : Object.prototype.toString.call(l) === "[object Object]" ? Object.fromEntries(
+        Object.entries(l).map(([h, f]) => [h, u(f, ++b, g)])
+      ) : l;
     }, "serializeValues"), m = {
       ...r,
-      args: r.args.map((a) => u(a, 0, []))
+      args: r.args.map((l) => u(l, 0, []))
     };
-    r.path.forEach((a) => {
-      a?.__callId__ && this.setState(r.storyId, ({ chainedCallIds: S }) => ({
-        chainedCallIds: new Set(Array.from(S).concat(a.__callId__))
+    r.path.forEach((l) => {
+      l?.__callId__ && this.setState(r.storyId, ({ chainedCallIds: b }) => ({
+        chainedCallIds: new Set(Array.from(b).concat(l.__callId__))
       }));
     });
-    let p = /* @__PURE__ */ s((a) => {
-      if (a instanceof Error) {
-        let { name: S, message: g, stack: h, callId: f = r.id } = a, {
-          showDiff: y = void 0,
-          diff: b = void 0,
+    let p = /* @__PURE__ */ i((l) => {
+      if (l instanceof Error) {
+        let { name: b, message: g, stack: h, callId: f = r.id } = l, {
+          showDiff: d = void 0,
+          diff: S = void 0,
           actual: _ = void 0,
           expected: O = void 0
-        } = a.name === "AssertionError" ? It(a) : a, d = { name: S, message: g, stack: h, callId: f, showDiff: y, diff: b, actual: _, expected: O };
-        if (this.update({ ...m, status: "error", exception: d }), this.setState(r.storyId, (E) => ({
+        } = l.name === "AssertionError" ? It(l) : l, y = { name: b, message: g, stack: h, callId: f, showDiff: d, diff: S, actual: _, expected: O };
+        if (this.update({ ...m, status: "error", exception: y }), this.setState(r.storyId, (E) => ({
           callRefsByResult: new Map([
             ...Array.from(E.callRefsByResult.entries()),
-            [a, { __callId__: r.id, retain: r.retain }]
+            [l, { __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 Object.prototype.hasOwnProperty.call(l, "callId") || Object.defineProperty(l, "callId", { value: r.id }), l;
       }
-      throw a;
+      throw l;
     }, "handleException");
     try {
       if (c === "played" && !r.retain)
-        throw Ji;
-      let S = (o.getArgs ? o.getArgs(r, this.getState(r.storyId)) : r.args).map((h) => typeof h != "function" || ts(h) || Object.keys(h).length ?
+        throw Hs;
+      let b = (o.getArgs ? o.getArgs(r, this.getState(r.storyId)) : r.args).map((h) => typeof h != "function" || ei(h) || Object.keys(h).length ?
       h : (...f) => {
-        let { cursor: y, ancestors: b } = this.getState(r.storyId);
-        this.setState(r.storyId, { cursor: 0, ancestors: [...b, r.id] });
-        let _ = /* @__PURE__ */ s(() => this.setState(r.storyId, { cursor: y, ancestors: b }), "restore"), O = !1;
+        let { cursor: d, ancestors: S } = this.getState(r.storyId);
+        this.setState(r.storyId, { cursor: 0, ancestors: [...S, r.id] });
+        let _ = /* @__PURE__ */ i(() => this.setState(r.storyId, { cursor: d, ancestors: S }), "restore"), O = !1;
         try {
-          let d = h(...f);
-          return d instanceof Promise ? (O = !0, d.finally(_)) : d;
+          let y = h(...f);
+          return y instanceof Promise ? (O = !0, y.finally(_)) : y;
         } finally {
           O || _();
         }
-      }), g = t.apply(n, S);
+      }), g = t.apply(n, b);
       return g && ["object", "function", "symbol"].includes(typeof g) && this.setState(r.storyId, (h) => ({
         callRefsByResult: new Map([
           ...Array.from(h.callRefsByResult.entries()),
@@ -2899,18 +2956,18 @@ prototype.toString.call(e) === "[object Module]", "isModule"), Zi = /* @__PURE__
         ...m,
         status: g instanceof Promise ? "active" : "done"
       }), g instanceof Promise ? g.then((h) => (this.update({ ...m, status: "done" }), h), p) : g;
-    } catch (a) {
-      return p(a);
+    } catch (l) {
+      return p(l);
     }
   }
   // Sends the call info to the manager and synchronizes the log.
   update(t) {
     this.channel?.emit(ne.CALL, t), this.setState(t.storyId, ({ calls: n }) => {
-      let r = n.concat(t).reduce((o, i) => Object.assign(o, { [i.id]: i }), {});
+      let r = n.concat(t).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, i) => o.id.localeCompare(i.id, void 0, { numeric: !0 })
+          (o, s) => o.id.localeCompare(s.id, void 0, { numeric: !0 })
         )
       };
     }), this.sync(t.storyId);
@@ -2918,42 +2975,50 @@ prototype.toString.call(e) === "[object Module]", "isModule"), Zi = /* @__PURE__
   // 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(t) {
-    let n = /* @__PURE__ */ s(() => {
-      let { isLocked: r, isPlaying: o } = this.getState(t), i = this.getLog(t), c = i.filter(({ ancestors: a }) => !a.length).find((a) => a.
-      status === "waiting")?.callId, l = i.some((a) => a.status === "active");
-      if (r || l || i.length === 0) {
-        let a = { controlStates: cr, logItems: i };
-        this.channel?.emit(ne.SYNC, a);
+    let n = /* @__PURE__ */ i(() => {
+      let { isLocked: r, isPlaying: o } = this.getState(t), s = this.getLog(t), c = s.filter(({ ancestors: l }) => !l.length).find((l) => l.
+      status === "waiting")?.callId, a = s.some((l) => l.status === "active");
+      if (this.detached || r || a || s.length === 0) {
+        let b = { controlStates: {
+          detached: this.detached,
+          start: !1,
+          back: !1,
+          goto: !1,
+          next: !1,
+          end: !1
+        }, logItems: s };
+        this.channel?.emit(ne.SYNC, b);
         return;
       }
-      let u = i.some(
-        (a) => a.status === "done" || a.status === "error"
+      let u = s.some(
+        (l) => l.status === "done" || l.status === "error"
       ), p = { controlStates: {
+        detached: this.detached,
         start: u,
         back: u,
         goto: !0,
         next: o,
         end: o
-      }, logItems: i, pausedAt: c };
+      }, logItems: s, pausedAt: c };
       this.channel?.emit(ne.SYNC, p);
     }, "synchronize");
     this.setState(t, ({ syncTimeout: r }) => (clearTimeout(r), { syncTimeout: setTimeout(n, 0) }));
   }
 };
-s(Lt, "Instrumenter");
-var Mt = Lt;
-function vi(e, t = {}) {
+i(xt, "Instrumenter");
+var Lt = xt;
+function Qs(e, t = {}) {
   try {
     let n = !1, r = !1;
-    return U.window?.location?.search?.includes("instrument=true") ? n = !0 : U.window?.location?.search?.includes("instrument=false") && (r =
-    !0), U.window?.parent === U.window && !n || r ? e : (U.window && !U.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__ && (U.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__ =
-    new Mt()), (U.window?.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__).instrument(e, t));
+    return Z.window?.location?.search?.includes("instrument=true") ? n = !0 : Z.window?.location?.search?.includes("instrument=false") && (r =
+    !0), Z.window?.parent === Z.window && !n || r ? e : (Z.window && !Z.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__ && (Z.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__ =
+    new Lt()), (Z.window?.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__).instrument(e, t));
   } catch (n) {
-    return Ki.warn(n), e;
+    return qs.warn(n), e;
   }
 }
-s(vi, "instrument");
-function es(e, t) {
+i(Qs, "instrument");
+function vs(e, t) {
   let n = e;
   for (; n != null; ) {
     let r = Object.getOwnPropertyDescriptor(n, t);
@@ -2962,16 +3027,16 @@ function es(e, t) {
     n = Object.getPrototypeOf(n);
   }
 }
-s(es, "getPropertyDescriptor");
-function ts(e) {
+i(vs, "getPropertyDescriptor");
+function ei(e) {
   if (typeof e != "function")
     return !1;
   let t = Object.getOwnPropertyDescriptor(e, "prototype");
   return t ? !t.writable : !1;
 }
-s(ts, "isClass");
+i(ei, "isClass");
 export {
-  qi as CallStates,
+  Vs as CallStates,
   ne as EVENTS,
-  vi as instrument
+  Qs as instrument
 };