@scrippsproduct/networks-ui-library 1.1.8 → 1.1.10-alpha.0

package/dist/matchers-35e4d3bd-BBPNTlen.mjs

@@ -0,0 +1,2404 @@
+var It = Object.defineProperty;
+var Ht = (e, t, n) => t in e ? It(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var P = (e, t, n) => Ht(e, typeof t != "symbol" ? t + "" : t, n);
+import { g as pe, c as ve } from "./_commonjsHelpers-DaMA6jEr.mjs";
+import { l as he } from "./react.esm-DLSrfVwM.mjs";
+var J, ye;
+function Tt() {
+  return ye || (ye = 1, J = (e) => {
+    const t = e.match(/^[ \t]*(?=\S)/gm);
+    return t ? t.reduce((n, r) => Math.min(n, r.length), 1 / 0) : 0;
+  }), J;
+}
+var Z, Ee;
+function Dt() {
+  if (Ee) return Z;
+  Ee = 1;
+  const e = Tt();
+  return Z = (t) => {
+    const n = e(t);
+    if (n === 0)
+      return t;
+    const r = new RegExp(`^[ \\t]{${n}}`, "gm");
+    return t.replace(r, "");
+  }, Z;
+}
+var ee, we;
+function Bt() {
+  return we || (we = 1, ee = (e, t = 1, n) => {
+    if (n = {
+      indent: " ",
+      includeEmptyLines: !1,
+      ...n
+    }, typeof e != "string")
+      throw new TypeError(
+        `Expected \`input\` to be a \`string\`, got \`${typeof e}\``
+      );
+    if (typeof t != "number")
+      throw new TypeError(
+        `Expected \`count\` to be a \`number\`, got \`${typeof t}\``
+      );
+    if (typeof n.indent != "string")
+      throw new TypeError(
+        `Expected \`options.indent\` to be a \`string\`, got \`${typeof n.indent}\``
+      );
+    if (t === 0)
+      return e;
+    const r = n.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+    return e.replace(r, n.indent.repeat(t));
+  }), ee;
+}
+var te, xe;
+function Pt() {
+  if (xe) return te;
+  xe = 1;
+  const e = Dt(), t = Bt();
+  return te = (n, r = 0, i) => t(e(n), r, i), te;
+}
+var kt = Pt();
+const Ne = /* @__PURE__ */ pe(kt);
+class Mt extends Error {
+  constructor(n, r, i, s, o) {
+    super(`${n}:${i}:${s}: ${r}`);
+    P(this, "reason");
+    P(this, "filename");
+    P(this, "line");
+    P(this, "column");
+    P(this, "source");
+    this.reason = r, this.filename = n, this.line = i, this.column = s, this.source = o;
+  }
+}
+class Lt {
+  constructor(t, n, r) {
+    P(this, "start");
+    P(this, "end");
+    P(this, "source");
+    this.start = t, this.end = n, this.source = r;
+  }
+}
+var N;
+(function(e) {
+  e.stylesheet = "stylesheet", e.rule = "rule", e.declaration = "declaration", e.comment = "comment", e.container = "container", e.charset = "charset", e.document = "document", e.customMedia = "custom-media", e.fontFace = "font-face", e.host = "host", e.import = "import", e.keyframes = "keyframes", e.keyframe = "keyframe", e.layer = "layer", e.media = "media", e.namespace = "namespace", e.page = "page", e.startingStyle = "starting-style", e.supports = "supports";
+})(N || (N = {}));
+const Se = (e, t, n) => {
+  let r = n, i = 1e4;
+  do {
+    const s = t.map((c) => e.indexOf(c, r));
+    s.push(e.indexOf("\\", r));
+    const o = s.filter((c) => c !== -1);
+    if (o.length === 0) return -1;
+    const f = Math.min(...o);
+    if (e[f] !== "\\") return f;
+    r = f + 2, i--;
+  } while (i > 0);
+  throw new Error("Too many escaping");
+}, re = (e, t, n) => {
+  let r = n, i = 1e4;
+  do {
+    const s = t.map((c) => e.indexOf(c, r));
+    s.push(e.indexOf("(", r)), s.push(e.indexOf('"', r)), s.push(e.indexOf("'", r)), s.push(e.indexOf("\\", r));
+    const o = s.filter((c) => c !== -1);
+    if (o.length === 0) return -1;
+    const f = Math.min(...o);
+    switch (e[f]) {
+      case "\\":
+        r = f + 2;
+        break;
+      case "(":
+        {
+          const c = re(e, [")"], f + 1);
+          if (c === -1) return -1;
+          r = c + 1;
+        }
+        break;
+      case '"':
+        {
+          const c = Se(e, ['"'], f + 1);
+          if (c === -1) return -1;
+          r = c + 1;
+        }
+        break;
+      case "'":
+        {
+          const c = Se(e, ["'"], f + 1);
+          if (c === -1) return -1;
+          r = c + 1;
+        }
+        break;
+      default:
+        return f;
+    }
+    i--;
+  } while (i > 0);
+  throw new Error("Too many escaping");
+}, ne = /\/\*[^]*?(?:\*\/|$)/g;
+function R(e) {
+  return e ? e.trim() : "";
+}
+function ie(e, t) {
+  const n = e && typeof e.type == "string", r = n ? e : t;
+  for (const i in e) {
+    const s = e[i];
+    Array.isArray(s) ? s.forEach((o) => {
+      ie(o, r);
+    }) : s && typeof s == "object" && ie(s, r);
+  }
+  return n && Object.defineProperty(e, "parent", { configurable: !0, writable: !0, enumerable: !1, value: t || null }), e;
+}
+const Vt = (e, t) => {
+  t = t || {};
+  let n = 1, r = 1;
+  function i() {
+    const l = { line: n, column: r };
+    return (u) => (u.position = new Lt(l, { line: n, column: r }, (t == null ? void 0 : t.source) || ""), V(), u);
+  }
+  const s = [];
+  function o(l) {
+    const u = new Mt((t == null ? void 0 : t.source) || "", l, n, r, e);
+    if (!(t != null && t.silent)) throw u;
+    s.push(u);
+  }
+  function f() {
+    const l = /^{\s*/.exec(e);
+    return !!l && (h(l), !0);
+  }
+  function c() {
+    const l = /^}/.exec(e);
+    return !!l && (h(l), !0);
+  }
+  function b() {
+    let l;
+    const u = [];
+    for (V(), y(u); e.length && e.charAt(0) !== "}" && (l = I() || D(), l); ) u.push(l), y(u);
+    return u;
+  }
+  function h(l) {
+    const u = l[0];
+    return (function(d) {
+      const p = d.match(/\n/g);
+      p && (n += p.length);
+      const g = d.lastIndexOf(`
+`);
+      r = ~g ? d.length - g : r + d.length;
+    })(u), e = e.slice(u.length), l;
+  }
+  function V() {
+    const l = /^\s*/.exec(e);
+    l && h(l);
+  }
+  function y(l) {
+    l = l || [];
+    let u = H();
+    for (; u; ) l.push(u), u = H();
+    return l;
+  }
+  function H() {
+    const l = i();
+    if (e.charAt(0) !== "/" || e.charAt(1) !== "*") return;
+    const u = /^\/\*[^]*?\*\//.exec(e);
+    return u ? (h(u), l({ type: N.comment, comment: u[0].slice(2, -2) })) : o("End of comment missing");
+  }
+  function U() {
+    const l = /^([^{]+)/.exec(e);
+    if (l)
+      return h(l), ((u, d) => {
+        const p = [];
+        let g = 0;
+        for (; g < u.length; ) {
+          const x = re(u, d, g);
+          if (x === -1) return p.push(u.substring(g)), p;
+          p.push(u.substring(g, x)), g = x + 1;
+        }
+        return p;
+      })(R(l[0]).replace(ne, ""), [","]).map((u) => R(u));
+  }
+  function M() {
+    const l = i(), u = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/.exec(e);
+    if (!u) return;
+    h(u);
+    const d = R(u[0]), p = /^:\s*/.exec(e);
+    if (!p) return o("property missing ':'");
+    h(p);
+    let g = "";
+    const x = re(e, [";", "}"]);
+    x !== -1 && (g = e.substring(0, x), h([g]), g = R(g).replace(ne, ""));
+    const B = l({ type: N.declaration, property: d.replace(ne, ""), value: g }), j = /^[;\s]*/.exec(e);
+    return j && h(j), B;
+  }
+  function O() {
+    const l = [];
+    if (!f()) return o("missing '{'");
+    y(l);
+    let u = M();
+    for (; u; ) l.push(u), y(l), u = M();
+    return c() ? l : o("missing '}'");
+  }
+  function a() {
+    const l = [], u = i();
+    let d = /^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/.exec(e);
+    for (; d; ) {
+      const p = h(d);
+      l.push(p[1]);
+      const g = /^,\s*/.exec(e);
+      g && h(g), d = /^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/.exec(e);
+    }
+    if (l.length) return u({ type: N.keyframe, values: l, declarations: O() || [] });
+  }
+  const w = $("import"), E = $("charset"), T = $("namespace");
+  function $(l) {
+    const u = new RegExp("^@" + l + `\\s*((?::?[^;'"]|"(?:\\\\"|[^"])*?"|'(?:\\\\'|[^'])*?')+)(?:;|$)`);
+    return () => {
+      const d = i(), p = u.exec(e);
+      if (!p) return;
+      const g = h(p), x = { type: l };
+      return x[l] = g[1].trim(), d(x);
+    };
+  }
+  function I() {
+    if (e[0] === "@") return (function() {
+      const l = i(), u = /^@([-\w]+)?keyframes\s*/.exec(e);
+      if (!u) return;
+      const d = h(u)[1], p = /^([-\w]+)\s*/.exec(e);
+      if (!p) return o("@keyframes missing name");
+      const g = h(p)[1];
+      if (!f()) return o("@keyframes missing '{'");
+      let x = y(), B = a();
+      for (; B; ) x.push(B), x = x.concat(y()), B = a();
+      return c() ? l({ type: N.keyframes, name: g, vendor: d, keyframes: x }) : o("@keyframes missing '}'");
+    })() || (function() {
+      const l = i(), u = /^@media *([^{]+)/.exec(e);
+      if (!u) return;
+      const d = R(h(u)[1]);
+      if (!f()) return o("@media missing '{'");
+      const p = y().concat(b());
+      return c() ? l({ type: N.media, media: d, rules: p }) : o("@media missing '}'");
+    })() || (function() {
+      const l = i(), u = /^@custom-media\s+(--\S+)\s+([^{;\s][^{;]*);/.exec(e);
+      if (!u) return;
+      const d = h(u);
+      return l({ type: N.customMedia, name: R(d[1]), media: R(d[2]) });
+    })() || (function() {
+      const l = i(), u = /^@supports *([^{]+)/.exec(e);
+      if (!u) return;
+      const d = R(h(u)[1]);
+      if (!f()) return o("@supports missing '{'");
+      const p = y().concat(b());
+      return c() ? l({ type: N.supports, supports: d, rules: p }) : o("@supports missing '}'");
+    })() || w() || E() || T() || (function() {
+      const l = i(), u = /^@([-\w]+)?document *([^{]+)/.exec(e);
+      if (!u) return;
+      const d = h(u), p = R(d[1]), g = R(d[2]);
+      if (!f()) return o("@document missing '{'");
+      const x = y().concat(b());
+      return c() ? l({ type: N.document, document: g, vendor: p, rules: x }) : o("@document missing '}'");
+    })() || (function() {
+      const l = i(), u = /^@page */.exec(e);
+      if (!u) return;
+      h(u);
+      const d = U() || [];
+      if (!f()) return o("@page missing '{'");
+      let p = y(), g = M();
+      for (; g; ) p.push(g), p = p.concat(y()), g = M();
+      return c() ? l({ type: N.page, selectors: d, declarations: p }) : o("@page missing '}'");
+    })() || (function() {
+      const l = i(), u = /^@host\s*/.exec(e);
+      if (!u) return;
+      if (h(u), !f()) return o("@host missing '{'");
+      const d = y().concat(b());
+      return c() ? l({ type: N.host, rules: d }) : o("@host missing '}'");
+    })() || (function() {
+      const l = i(), u = /^@font-face\s*/.exec(e);
+      if (!u) return;
+      if (h(u), !f()) return o("@font-face missing '{'");
+      let d = y(), p = M();
+      for (; p; ) d.push(p), d = d.concat(y()), p = M();
+      return c() ? l({ type: N.fontFace, declarations: d }) : o("@font-face missing '}'");
+    })() || (function() {
+      const l = i(), u = /^@container *([^{]+)/.exec(e);
+      if (!u) return;
+      const d = R(h(u)[1]);
+      if (!f()) return o("@container missing '{'");
+      const p = y().concat(b());
+      return c() ? l({ type: N.container, container: d, rules: p }) : o("@container missing '}'");
+    })() || (function() {
+      const l = i(), u = /^@starting-style\s*/.exec(e);
+      if (!u) return;
+      if (h(u), !f()) return o("@starting-style missing '{'");
+      const d = y().concat(b());
+      return c() ? l({ type: N.startingStyle, rules: d }) : o("@starting-style missing '}'");
+    })() || (function() {
+      const l = i(), u = /^@layer *([^{;@]+)/.exec(e);
+      if (!u) return;
+      const d = R(h(u)[1]);
+      if (!f()) {
+        const g = /^[;\s]*/.exec(e);
+        return g && h(g), l({ type: N.layer, layer: d });
+      }
+      const p = y().concat(b());
+      return c() ? l({ type: N.layer, layer: d, rules: p }) : o("@layer missing '}'");
+    })();
+  }
+  function D() {
+    const l = i(), u = U();
+    return u ? (y(), l({ type: N.rule, selectors: u, declarations: O() || [] })) : o("selector missing");
+  }
+  return ie((function() {
+    const l = b();
+    return { type: N.stylesheet, stylesheet: { source: t == null ? void 0 : t.source, rules: l, parsingErrors: s } };
+  })());
+};
+var jt = Object.prototype.toString;
+function _t(e) {
+  return typeof e == "function" || jt.call(e) === "[object Function]";
+}
+function qt(e) {
+  var t = Number(e);
+  return isNaN(t) ? 0 : t === 0 || !isFinite(t) ? t : (t > 0 ? 1 : -1) * Math.floor(Math.abs(t));
+}
+var Ft = Math.pow(2, 53) - 1;
+function Ut(e) {
+  var t = qt(e);
+  return Math.min(Math.max(t, 0), Ft);
+}
+function C(e, t) {
+  var n = Array, r = Object(e);
+  if (e == null)
+    throw new TypeError("Array.from requires an array-like object - not null or undefined");
+  for (var i = Ut(r.length), s = _t(n) ? Object(new n(i)) : new Array(i), o = 0, f; o < i; )
+    f = r[o], s[o] = f, o += 1;
+  return s.length = i, s;
+}
+function q(e) {
+  "@babel/helpers - typeof";
+  return q = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, q(e);
+}
+function Gt(e, t) {
+  if (!(e instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function zt(e, t) {
+  for (var n = 0; n < t.length; n++) {
+    var r = t[n];
+    r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, Ve(r.key), r);
+  }
+}
+function Wt(e, t, n) {
+  return t && zt(e.prototype, t), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+}
+function Yt(e, t, n) {
+  return t = Ve(t), t in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
+}
+function Ve(e) {
+  var t = Kt(e, "string");
+  return q(t) === "symbol" ? t : String(t);
+}
+function Kt(e, t) {
+  if (q(e) !== "object" || e === null) return e;
+  var n = e[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var r = n.call(e, t);
+    if (q(r) !== "object") return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+var Xt = /* @__PURE__ */ (function() {
+  function e() {
+    var t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    Gt(this, e), Yt(this, "items", void 0), this.items = t;
+  }
+  return Wt(e, [{
+    key: "add",
+    value: function(n) {
+      return this.has(n) === !1 && this.items.push(n), this;
+    }
+  }, {
+    key: "clear",
+    value: function() {
+      this.items = [];
+    }
+  }, {
+    key: "delete",
+    value: function(n) {
+      var r = this.items.length;
+      return this.items = this.items.filter(function(i) {
+        return i !== n;
+      }), r !== this.items.length;
+    }
+  }, {
+    key: "forEach",
+    value: function(n) {
+      var r = this;
+      this.items.forEach(function(i) {
+        n(i, i, r);
+      });
+    }
+  }, {
+    key: "has",
+    value: function(n) {
+      return this.items.indexOf(n) !== -1;
+    }
+  }, {
+    key: "size",
+    get: function() {
+      return this.items.length;
+    }
+  }]), e;
+})();
+const Qt = typeof Set > "u" ? Set : Xt;
+function A(e) {
+  var t;
+  return (
+    // eslint-disable-next-line no-restricted-properties -- actual guard for environments without localName
+    (t = e.localName) !== null && t !== void 0 ? t : (
+      // eslint-disable-next-line no-restricted-properties -- required for the fallback
+      e.tagName.toLowerCase()
+    )
+  );
+}
+var Jt = {
+  article: "article",
+  aside: "complementary",
+  button: "button",
+  datalist: "listbox",
+  dd: "definition",
+  details: "group",
+  dialog: "dialog",
+  dt: "term",
+  fieldset: "group",
+  figure: "figure",
+  // WARNING: Only with an accessible name
+  form: "form",
+  footer: "contentinfo",
+  h1: "heading",
+  h2: "heading",
+  h3: "heading",
+  h4: "heading",
+  h5: "heading",
+  h6: "heading",
+  header: "banner",
+  hr: "separator",
+  html: "document",
+  legend: "legend",
+  li: "listitem",
+  math: "math",
+  main: "main",
+  menu: "list",
+  nav: "navigation",
+  ol: "list",
+  optgroup: "group",
+  // WARNING: Only in certain context
+  option: "option",
+  output: "status",
+  progress: "progressbar",
+  // WARNING: Only with an accessible name
+  section: "region",
+  summary: "button",
+  table: "table",
+  tbody: "rowgroup",
+  textarea: "textbox",
+  tfoot: "rowgroup",
+  // WARNING: Only in certain context
+  td: "cell",
+  th: "columnheader",
+  thead: "rowgroup",
+  tr: "row",
+  ul: "list"
+}, Zt = {
+  caption: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  code: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  deletion: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  emphasis: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  generic: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby", "aria-roledescription"]),
+  insertion: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  none: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  paragraph: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  presentation: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  strong: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  subscript: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  superscript: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"])
+};
+function en(e, t) {
+  return [
+    "aria-atomic",
+    "aria-busy",
+    "aria-controls",
+    "aria-current",
+    "aria-description",
+    "aria-describedby",
+    "aria-details",
+    // "disabled",
+    "aria-dropeffect",
+    // "errormessage",
+    "aria-flowto",
+    "aria-grabbed",
+    // "haspopup",
+    "aria-hidden",
+    // "invalid",
+    "aria-keyshortcuts",
+    "aria-label",
+    "aria-labelledby",
+    "aria-live",
+    "aria-owns",
+    "aria-relevant",
+    "aria-roledescription"
+  ].some(function(n) {
+    var r;
+    return e.hasAttribute(n) && !((r = Zt[t]) !== null && r !== void 0 && r.has(n));
+  });
+}
+function je(e, t) {
+  return en(e, t);
+}
+function tn(e) {
+  var t = rn(e);
+  if (t === null || se.indexOf(t) !== -1) {
+    var n = nn(e);
+    if (se.indexOf(t || "") === -1 || je(e, n || ""))
+      return n;
+  }
+  return t;
+}
+function nn(e) {
+  var t = Jt[A(e)];
+  if (t !== void 0)
+    return t;
+  switch (A(e)) {
+    case "a":
+    case "area":
+    case "link":
+      if (e.hasAttribute("href"))
+        return "link";
+      break;
+    case "img":
+      return e.getAttribute("alt") === "" && !je(e, "img") ? "presentation" : "img";
+    case "input": {
+      var n = e, r = n.type;
+      switch (r) {
+        case "button":
+        case "image":
+        case "reset":
+        case "submit":
+          return "button";
+        case "checkbox":
+        case "radio":
+          return r;
+        case "range":
+          return "slider";
+        case "email":
+        case "tel":
+        case "text":
+        case "url":
+          return e.hasAttribute("list") ? "combobox" : "textbox";
+        case "search":
+          return e.hasAttribute("list") ? "combobox" : "searchbox";
+        case "number":
+          return "spinbutton";
+        default:
+          return null;
+      }
+    }
+    case "select":
+      return e.hasAttribute("multiple") || e.size > 1 ? "listbox" : "combobox";
+  }
+  return null;
+}
+function rn(e) {
+  var t = e.getAttribute("role");
+  if (t !== null) {
+    var n = t.trim().split(" ")[0];
+    if (n.length > 0)
+      return n;
+  }
+  return null;
+}
+var se = ["presentation", "none"];
+function v(e) {
+  return e !== null && e.nodeType === e.ELEMENT_NODE;
+}
+function _e(e) {
+  return v(e) && A(e) === "caption";
+}
+function z(e) {
+  return v(e) && A(e) === "input";
+}
+function sn(e) {
+  return v(e) && A(e) === "optgroup";
+}
+function on(e) {
+  return v(e) && A(e) === "select";
+}
+function an(e) {
+  return v(e) && A(e) === "table";
+}
+function un(e) {
+  return v(e) && A(e) === "textarea";
+}
+function cn(e) {
+  var t = e.ownerDocument === null ? e : e.ownerDocument, n = t.defaultView;
+  if (n === null)
+    throw new TypeError("no window available");
+  return n;
+}
+function ln(e) {
+  return v(e) && A(e) === "fieldset";
+}
+function fn(e) {
+  return v(e) && A(e) === "legend";
+}
+function dn(e) {
+  return v(e) && A(e) === "slot";
+}
+function pn(e) {
+  return v(e) && e.ownerSVGElement !== void 0;
+}
+function hn(e) {
+  return v(e) && A(e) === "svg";
+}
+function gn(e) {
+  return pn(e) && A(e) === "title";
+}
+function Y(e, t) {
+  if (v(e) && e.hasAttribute(t)) {
+    var n = e.getAttribute(t).split(" "), r = e.getRootNode ? e.getRootNode() : e.ownerDocument;
+    return n.map(function(i) {
+      return r.getElementById(i);
+    }).filter(
+      function(i) {
+        return i !== null;
+      }
+      // TODO: why does this not narrow?
+    );
+  }
+  return [];
+}
+function k(e, t) {
+  return v(e) ? t.indexOf(tn(e)) !== -1 : !1;
+}
+function mn(e) {
+  return e.trim().replace(/\s\s+/g, " ");
+}
+function bn(e, t) {
+  if (!v(e))
+    return !1;
+  if (e.hasAttribute("hidden") || e.getAttribute("aria-hidden") === "true")
+    return !0;
+  var n = t(e);
+  return n.getPropertyValue("display") === "none" || n.getPropertyValue("visibility") === "hidden";
+}
+function vn(e) {
+  return k(e, ["button", "combobox", "listbox", "textbox"]) || qe(e, "range");
+}
+function qe(e, t) {
+  if (!v(e))
+    return !1;
+  switch (t) {
+    case "range":
+      return k(e, ["meter", "progressbar", "scrollbar", "slider", "spinbutton"]);
+    default:
+      throw new TypeError("No knowledge about abstract role '".concat(t, "'. This is likely a bug :("));
+  }
+}
+function Ae(e, t) {
+  var n = C(e.querySelectorAll(t));
+  return Y(e, "aria-owns").forEach(function(r) {
+    n.push.apply(n, C(r.querySelectorAll(t)));
+  }), n;
+}
+function yn(e) {
+  return on(e) ? e.selectedOptions || Ae(e, "[selected]") : Ae(e, '[aria-selected="true"]');
+}
+function En(e) {
+  return k(e, se);
+}
+function wn(e) {
+  return _e(e);
+}
+function xn(e) {
+  return k(e, ["button", "cell", "checkbox", "columnheader", "gridcell", "heading", "label", "legend", "link", "menuitem", "menuitemcheckbox", "menuitemradio", "option", "radio", "row", "rowheader", "switch", "tab", "tooltip", "treeitem"]);
+}
+function Nn(e) {
+  return !1;
+}
+function Sn(e) {
+  return z(e) || un(e) ? e.value : e.textContent || "";
+}
+function Re(e) {
+  var t = e.getPropertyValue("content");
+  return /^["'].*["']$/.test(t) ? t.slice(1, -1) : "";
+}
+function Fe(e) {
+  var t = A(e);
+  return t === "button" || t === "input" && e.getAttribute("type") !== "hidden" || t === "meter" || t === "output" || t === "progress" || t === "select" || t === "textarea";
+}
+function Ue(e) {
+  if (Fe(e))
+    return e;
+  var t = null;
+  return e.childNodes.forEach(function(n) {
+    if (t === null && v(n)) {
+      var r = Ue(n);
+      r !== null && (t = r);
+    }
+  }), t;
+}
+function An(e) {
+  if (e.control !== void 0)
+    return e.control;
+  var t = e.getAttribute("for");
+  return t !== null ? e.ownerDocument.getElementById(t) : Ue(e);
+}
+function Rn(e) {
+  var t = e.labels;
+  if (t === null)
+    return t;
+  if (t !== void 0)
+    return C(t);
+  if (!Fe(e))
+    return null;
+  var n = e.ownerDocument;
+  return C(n.querySelectorAll("label")).filter(function(r) {
+    return An(r) === e;
+  });
+}
+function $n(e) {
+  var t = e.assignedNodes();
+  return t.length === 0 ? C(e.childNodes) : t;
+}
+function Ge(e) {
+  var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, n = new Qt(), r = cn(e), i = t.compute, s = i === void 0 ? "name" : i, o = t.computedStyleSupportsPseudoElements, f = o === void 0 ? t.getComputedStyle !== void 0 : o, c = t.getComputedStyle, b = c === void 0 ? r.getComputedStyle.bind(r) : c, h = t.hidden, V = h === void 0 ? !1 : h;
+  function y(a, w) {
+    var E = "";
+    if (v(a) && f) {
+      var T = b(a, "::before"), $ = Re(T);
+      E = "".concat($, " ").concat(E);
+    }
+    var I = dn(a) ? $n(a) : C(a.childNodes).concat(Y(a, "aria-owns"));
+    if (I.forEach(function(u) {
+      var d = O(u, {
+        isEmbeddedInLabel: w.isEmbeddedInLabel,
+        isReferenced: !1,
+        recursion: !0
+      }), p = v(u) ? b(u).getPropertyValue("display") : "inline", g = p !== "inline" ? " " : "";
+      E += "".concat(g).concat(d).concat(g);
+    }), v(a) && f) {
+      var D = b(a, "::after"), l = Re(D);
+      E = "".concat(E, " ").concat(l);
+    }
+    return E.trim();
+  }
+  function H(a, w) {
+    var E = a.getAttributeNode(w);
+    return E !== null && !n.has(E) && E.value.trim() !== "" ? (n.add(E), E.value) : null;
+  }
+  function U(a) {
+    return v(a) ? H(a, "title") : null;
+  }
+  function M(a) {
+    if (!v(a))
+      return null;
+    if (ln(a)) {
+      n.add(a);
+      for (var w = C(a.childNodes), E = 0; E < w.length; E += 1) {
+        var T = w[E];
+        if (fn(T))
+          return O(T, {
+            isEmbeddedInLabel: !1,
+            isReferenced: !1,
+            recursion: !1
+          });
+      }
+    } else if (an(a)) {
+      n.add(a);
+      for (var $ = C(a.childNodes), I = 0; I < $.length; I += 1) {
+        var D = $[I];
+        if (_e(D))
+          return O(D, {
+            isEmbeddedInLabel: !1,
+            isReferenced: !1,
+            recursion: !1
+          });
+      }
+    } else if (hn(a)) {
+      n.add(a);
+      for (var l = C(a.childNodes), u = 0; u < l.length; u += 1) {
+        var d = l[u];
+        if (gn(d))
+          return d.textContent;
+      }
+      return null;
+    } else if (A(a) === "img" || A(a) === "area") {
+      var p = H(a, "alt");
+      if (p !== null)
+        return p;
+    } else if (sn(a)) {
+      var g = H(a, "label");
+      if (g !== null)
+        return g;
+    }
+    if (z(a) && (a.type === "button" || a.type === "submit" || a.type === "reset")) {
+      var x = H(a, "value");
+      if (x !== null)
+        return x;
+      if (a.type === "submit")
+        return "Submit";
+      if (a.type === "reset")
+        return "Reset";
+    }
+    var B = Rn(a);
+    if (B !== null && B.length !== 0)
+      return n.add(a), C(B).map(function(Q) {
+        return O(Q, {
+          isEmbeddedInLabel: !0,
+          isReferenced: !1,
+          recursion: !0
+        });
+      }).filter(function(Q) {
+        return Q.length > 0;
+      }).join(" ");
+    if (z(a) && a.type === "image") {
+      var j = H(a, "alt");
+      if (j !== null)
+        return j;
+      var me = H(a, "title");
+      return me !== null ? me : "Submit Query";
+    }
+    if (k(a, ["button"])) {
+      var be = y(a, {
+        isEmbeddedInLabel: !1
+      });
+      if (be !== "")
+        return be;
+    }
+    return null;
+  }
+  function O(a, w) {
+    if (n.has(a))
+      return "";
+    if (!V && bn(a, b) && !w.isReferenced)
+      return n.add(a), "";
+    var E = v(a) ? a.getAttributeNode("aria-labelledby") : null, T = E !== null && !n.has(E) ? Y(a, "aria-labelledby") : [];
+    if (s === "name" && !w.isReferenced && T.length > 0)
+      return n.add(E), T.map(function(p) {
+        return O(p, {
+          isEmbeddedInLabel: w.isEmbeddedInLabel,
+          isReferenced: !0,
+          // this isn't recursion as specified, otherwise we would skip
+          // `aria-label` in
+          // <input id="myself" aria-label="foo" aria-labelledby="myself"
+          recursion: !1
+        });
+      }).join(" ");
+    var $ = w.recursion && vn(a) && s === "name";
+    if (!$) {
+      var I = (v(a) && a.getAttribute("aria-label") || "").trim();
+      if (I !== "" && s === "name")
+        return n.add(a), I;
+      if (!En(a)) {
+        var D = M(a);
+        if (D !== null)
+          return n.add(a), D;
+      }
+    }
+    if (k(a, ["menu"]))
+      return n.add(a), "";
+    if ($ || w.isEmbeddedInLabel || w.isReferenced) {
+      if (k(a, ["combobox", "listbox"])) {
+        n.add(a);
+        var l = yn(a);
+        return l.length === 0 ? z(a) ? a.value : "" : C(l).map(function(p) {
+          return O(p, {
+            isEmbeddedInLabel: w.isEmbeddedInLabel,
+            isReferenced: !1,
+            recursion: !0
+          });
+        }).join(" ");
+      }
+      if (qe(a, "range"))
+        return n.add(a), a.hasAttribute("aria-valuetext") ? a.getAttribute("aria-valuetext") : a.hasAttribute("aria-valuenow") ? a.getAttribute("aria-valuenow") : a.getAttribute("value") || "";
+      if (k(a, ["textbox"]))
+        return n.add(a), Sn(a);
+    }
+    if (xn(a) || v(a) && w.isReferenced || wn(a) || Nn()) {
+      var u = y(a, {
+        isEmbeddedInLabel: w.isEmbeddedInLabel
+      });
+      if (u !== "")
+        return n.add(a), u;
+    }
+    if (a.nodeType === a.TEXT_NODE)
+      return n.add(a), a.textContent || "";
+    if (w.recursion)
+      return n.add(a), y(a, {
+        isEmbeddedInLabel: w.isEmbeddedInLabel
+      });
+    var d = U(a);
+    return d !== null ? (n.add(a), d) : (n.add(a), "");
+  }
+  return mn(O(e, {
+    isEmbeddedInLabel: !1,
+    // by spec computeAccessibleDescription starts with the referenced elements as roots
+    isReferenced: s === "description",
+    recursion: !1
+  }));
+}
+function F(e) {
+  "@babel/helpers - typeof";
+  return F = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, F(e);
+}
+function $e(e, t) {
+  var n = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var r = Object.getOwnPropertySymbols(e);
+    t && (r = r.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(e, i).enumerable;
+    })), n.push.apply(n, r);
+  }
+  return n;
+}
+function Ce(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var n = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? $e(Object(n), !0).forEach(function(r) {
+      Cn(e, r, n[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(n)) : $e(Object(n)).forEach(function(r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(n, r));
+    });
+  }
+  return e;
+}
+function Cn(e, t, n) {
+  return t = On(t), t in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
+}
+function On(e) {
+  var t = In(e, "string");
+  return F(t) === "symbol" ? t : String(t);
+}
+function In(e, t) {
+  if (F(e) !== "object" || e === null) return e;
+  var n = e[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var r = n.call(e, t);
+    if (F(r) !== "object") return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+function Hn(e) {
+  var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, n = Y(e, "aria-describedby").map(function(s) {
+    return Ge(s, Ce(Ce({}, t), {}, {
+      compute: "description"
+    }));
+  }).join(" ");
+  if (n === "") {
+    var r = e.getAttribute("aria-description");
+    n = r === null ? "" : r;
+  }
+  if (n === "") {
+    var i = e.getAttribute("title");
+    n = i === null ? "" : i;
+  }
+  return n;
+}
+function Tn(e) {
+  return k(e, ["caption", "code", "deletion", "emphasis", "generic", "insertion", "none", "paragraph", "presentation", "strong", "subscript", "superscript"]);
+}
+function Dn(e) {
+  var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  return Tn(e) ? "" : Ge(e, t);
+}
+var G = { exports: {} }, Oe;
+function Bn() {
+  if (Oe) return G.exports;
+  Oe = 1;
+  var e = String, t = function() {
+    return { isColorSupported: !1, reset: e, bold: e, dim: e, italic: e, underline: e, inverse: e, hidden: e, strikethrough: e, black: e, red: e, green: e, yellow: e, blue: e, magenta: e, cyan: e, white: e, gray: e, bgBlack: e, bgRed: e, bgGreen: e, bgYellow: e, bgBlue: e, bgMagenta: e, bgCyan: e, bgWhite: e, blackBright: e, redBright: e, greenBright: e, yellowBright: e, blueBright: e, magentaBright: e, cyanBright: e, whiteBright: e, bgBlackBright: e, bgRedBright: e, bgGreenBright: e, bgYellowBright: e, bgBlueBright: e, bgMagentaBright: e, bgCyanBright: e, bgWhiteBright: e };
+  };
+  return G.exports = t(), G.exports.createColors = t, G.exports;
+}
+var Pn = /* @__PURE__ */ Bn();
+const kn = /* @__PURE__ */ pe(Pn);
+var W = { exports: {} };
+/*! https://mths.be/cssescape v1.5.1 by @mathias | MIT license */
+var Mn = W.exports, Ie;
+function Ln() {
+  return Ie || (Ie = 1, (function(e, t) {
+    (function(n, r) {
+      e.exports = r(n);
+    })(typeof ve < "u" ? ve : Mn, function(n) {
+      if (n.CSS && n.CSS.escape)
+        return n.CSS.escape;
+      var r = function(i) {
+        if (arguments.length == 0)
+          throw new TypeError("`CSS.escape` requires an argument.");
+        for (var s = String(i), o = s.length, f = -1, c, b = "", h = s.charCodeAt(0); ++f < o; ) {
+          if (c = s.charCodeAt(f), c == 0) {
+            b += "�";
+            continue;
+          }
+          if (
+            // If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+            // U+007F, […]
+            c >= 1 && c <= 31 || c == 127 || // If the character is the first character and is in the range [0-9]
+            // (U+0030 to U+0039), […]
+            f == 0 && c >= 48 && c <= 57 || // If the character is the second character and is in the range [0-9]
+            // (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+            f == 1 && c >= 48 && c <= 57 && h == 45
+          ) {
+            b += "\\" + c.toString(16) + " ";
+            continue;
+          }
+          if (
+            // If the character is the first character and is a `-` (U+002D), and
+            // there is no second character, […]
+            f == 0 && o == 1 && c == 45
+          ) {
+            b += "\\" + s.charAt(f);
+            continue;
+          }
+          if (c >= 128 || c == 45 || c == 95 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122) {
+            b += s.charAt(f);
+            continue;
+          }
+          b += "\\" + s.charAt(f);
+        }
+        return b;
+      };
+      return n.CSS || (n.CSS = {}), n.CSS.escape = r, r;
+    });
+  })(W)), W.exports;
+}
+var Vn = Ln();
+const jn = /* @__PURE__ */ pe(Vn);
+class ze extends Error {
+  constructor(t, n, r, i) {
+    super(), Error.captureStackTrace && Error.captureStackTrace(this, r);
+    let s = "";
+    try {
+      s = i.utils.printWithType(
+        "Received",
+        n,
+        i.utils.printReceived
+      );
+    } catch {
+    }
+    this.message = [
+      i.utils.matcherHint(
+        `${i.isNot ? ".not" : ""}.${r.name}`,
+        "received",
+        ""
+      ),
+      "",
+      // eslint-disable-next-line new-cap
+      `${i.utils.RECEIVED_COLOR(
+        "received"
+      )} value must ${t}.`,
+      s
+    ].join(`
+`);
+  }
+}
+class He extends ze {
+  constructor(...t) {
+    super("be an HTMLElement or an SVGElement", ...t);
+  }
+}
+class Te extends ze {
+  constructor(...t) {
+    super("be a Node", ...t);
+  }
+}
+function We(e, t, ...n) {
+  if (!e || !e.ownerDocument || !e.ownerDocument.defaultView)
+    throw new t(e, ...n);
+}
+function _n(e, ...t) {
+  We(e, Te, ...t);
+  const n = e.ownerDocument.defaultView;
+  if (!(e instanceof n.Node))
+    throw new Te(e, ...t);
+}
+function m(e, ...t) {
+  We(e, He, ...t);
+  const n = e.ownerDocument.defaultView;
+  if (!(e instanceof n.HTMLElement) && !(e instanceof n.SVGElement))
+    throw new He(e, ...t);
+}
+class qn extends Error {
+  constructor(t, n, r) {
+    super(), Error.captureStackTrace && Error.captureStackTrace(this, n), this.message = [
+      t.message,
+      "",
+      // eslint-disable-next-line new-cap
+      r.utils.RECEIVED_COLOR("Failing css:"),
+      // eslint-disable-next-line new-cap
+      r.utils.RECEIVED_COLOR(`${t.css}`)
+    ].join(`
+`);
+  }
+}
+function Fn(e, ...t) {
+  const n = Vt(`selector { ${e} }`, { silent: !0 }).stylesheet;
+  if (n.parsingErrors && n.parsingErrors.length > 0) {
+    const { reason: i, line: s } = n.parsingErrors[0];
+    throw new qn(
+      {
+        css: e,
+        message: `Syntax error parsing expected css: ${i} on line: ${s}`
+      },
+      ...t
+    );
+  }
+  return n.rules[0].declarations.filter((i) => i.type === "declaration").reduce(
+    (i, { property: s, value: o }) => Object.assign(i, { [s]: o }),
+    {}
+  );
+}
+function De(e, t) {
+  return typeof t == "string" ? t : e.utils.stringify(t);
+}
+function S(e, t, n, r, i, s) {
+  return [
+    `${t}
+`,
+    // eslint-disable-next-line new-cap
+    `${n}:
+${e.utils.EXPECTED_COLOR(
+      Ne(De(e, r), 2)
+    )}`,
+    // eslint-disable-next-line new-cap
+    `${i}:
+${e.utils.RECEIVED_COLOR(
+      Ne(De(e, s), 2)
+    )}`
+  ].join(`
+`);
+}
+function Un(e, t) {
+  return t instanceof RegExp ? t.test(e) : e.includes(String(t));
+}
+function K(e, t) {
+  console.warn(
+    `Warning: ${e} has been deprecated and will be removed in future updates.`,
+    t
+  );
+}
+function X(e) {
+  return e.replace(/\s+/g, " ").trim();
+}
+function L(e) {
+  return e.tagName && e.tagName.toLowerCase();
+}
+function Gn({ multiple: e, options: t }) {
+  const n = [...t].filter((r) => r.selected);
+  if (e)
+    return [...n].map((r) => r.value);
+  if (n.length !== 0)
+    return n[0].value;
+}
+function zn(e) {
+  switch (e.type) {
+    case "number":
+      return e.value === "" ? null : Number(e.value);
+    case "checkbox":
+      return e.checked;
+    default:
+      return e.value;
+  }
+}
+const Wn = ["meter", "progressbar", "slider", "spinbutton"];
+function Yn(e) {
+  if (Wn.includes(e.getAttribute("role")))
+    return Number(e.getAttribute("aria-valuenow"));
+}
+function Ye(e) {
+  if (e)
+    switch (e.tagName.toLowerCase()) {
+      case "input":
+        return zn(e);
+      case "select":
+        return Gn(e);
+      default:
+        return e.value ?? Yn(e);
+    }
+}
+function Kn(e, { wordConnector: t = ", ", lastWordConnector: n = " and " } = {}) {
+  return [e.slice(0, -1).join(t), e[e.length - 1]].join(
+    e.length > 1 ? n : ""
+  );
+}
+function ge(e, t) {
+  return Array.isArray(e) && Array.isArray(t) ? [...new Set(e)].every((n) => new Set(t).has(n)) : e === t;
+}
+function oe(e, t) {
+  return K(
+    "toBeInTheDOM",
+    "Please use toBeInTheDocument for searching the entire document and toContainElement for searching a specific container."
+  ), e && m(e, oe, this), t && m(t, oe, this), {
+    pass: t ? t.contains(e) : !!e,
+    message: () => [
+      this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toBeInTheDOM`,
+        "element",
+        ""
+      ),
+      "",
+      "Received:",
+      `  ${this.utils.printReceived(
+        e && e.cloneNode(!1)
+      )}`
+    ].join(`
+`)
+  };
+}
+function Ke(e) {
+  (e !== null || !this.isNot) && m(e, Ke, this);
+  const t = e === null ? !1 : e.ownerDocument === e.getRootNode({ composed: !0 }), n = () => `expected document not to contain element, found ${this.utils.stringify(
+    e.cloneNode(!0)
+  )} instead`, r = () => "element could not be found in the document";
+  return {
+    pass: t,
+    message: () => [
+      this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toBeInTheDocument`,
+        "element",
+        ""
+      ),
+      "",
+      // eslint-disable-next-line new-cap
+      this.utils.RECEIVED_COLOR(this.isNot ? n() : r())
+    ].join(`
+`)
+  };
+}
+function Xe(e) {
+  return K(
+    "toBeEmpty",
+    "Please use instead toBeEmptyDOMElement for finding empty nodes in the DOM."
+  ), m(e, Xe, this), {
+    pass: e.innerHTML === "",
+    message: () => [
+      this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toBeEmpty`,
+        "element",
+        ""
+      ),
+      "",
+      "Received:",
+      `  ${this.utils.printReceived(e.innerHTML)}`
+    ].join(`
+`)
+  };
+}
+function Qe(e) {
+  return m(e, Qe, this), {
+    pass: Xn(e),
+    message: () => [
+      this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toBeEmptyDOMElement`,
+        "element",
+        ""
+      ),
+      "",
+      "Received:",
+      `  ${this.utils.printReceived(e.innerHTML)}`
+    ].join(`
+`)
+  };
+}
+function Xn(e) {
+  return [...e.childNodes].filter((n) => n.nodeType !== 8).length === 0;
+}
+function ae(e, t) {
+  return m(e, ae, this), t !== null && m(t, ae, this), {
+    pass: e.contains(t),
+    message: () => [
+      this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toContainElement`,
+        "element",
+        "element"
+      ),
+      "",
+      // eslint-disable-next-line new-cap
+      this.utils.RECEIVED_COLOR(`${this.utils.stringify(
+        e.cloneNode(!1)
+      )} ${this.isNot ? "contains:" : "does not contain:"} ${this.utils.stringify(t && t.cloneNode(!1))}
+        `)
+    ].join(`
+`)
+  };
+}
+function Qn(e, t) {
+  const n = e.ownerDocument.createElement("div");
+  return n.innerHTML = t, n.innerHTML;
+}
+function Je(e, t) {
+  if (m(e, Je, this), typeof t != "string")
+    throw new Error(`.toContainHTML() expects a string value, got ${t}`);
+  return {
+    pass: e.outerHTML.includes(Qn(e, t)),
+    message: () => [
+      this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toContainHTML`,
+        "element",
+        ""
+      ),
+      "Expected:",
+      // eslint-disable-next-line new-cap
+      `  ${this.utils.EXPECTED_COLOR(t)}`,
+      "Received:",
+      `  ${this.utils.printReceived(e.cloneNode(!0))}`
+    ].join(`
+`)
+  };
+}
+function Ze(e, t, n = { normalizeWhitespace: !0 }) {
+  _n(e, Ze, this);
+  const r = n.normalizeWhitespace ? X(e.textContent) : e.textContent.replace(/\u00a0/g, " "), i = r !== "" && t === "";
+  return {
+    pass: !i && Un(r, t),
+    message: () => {
+      const s = this.isNot ? "not to" : "to";
+      return S(
+        this,
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toHaveTextContent`,
+          "element",
+          ""
+        ),
+        i ? "Checking with empty string will always match, use .toBeEmptyDOMElement() instead" : `Expected element ${s} have text content`,
+        t,
+        "Received",
+        r
+      );
+    }
+  };
+}
+function ue(e, t) {
+  m(e, ue, this);
+  const n = Hn(e), r = arguments.length === 1;
+  let i = !1;
+  return r ? i = n !== "" : i = t instanceof RegExp ? t.test(n) : this.equals(
+    n,
+    t
+  ), {
+    pass: i,
+    message: () => {
+      const s = this.isNot ? "not to" : "to";
+      return S(
+        this,
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.${ue.name}`,
+          "element",
+          ""
+        ),
+        `Expected element ${s} have accessible description`,
+        t,
+        "Received",
+        n
+      );
+    }
+  };
+}
+const _ = "aria-invalid", Jn = ["false"];
+function et(e, t) {
+  var b;
+  m(e, et, this);
+  const n = this.isNot ? "not to" : "to", r = this.isNot ? ".not.toHaveAccessibleErrorMessage" : ".toHaveAccessibleErrorMessage", i = e.getAttribute("aria-errormessage");
+  if (!!i && /\s+/.test(i))
+    return {
+      pass: !1,
+      message: () => S(
+        this,
+        this.utils.matcherHint(r, "element"),
+        "Expected element's `aria-errormessage` attribute to be empty or a single, valid ID",
+        "",
+        "Received",
+        `aria-errormessage="${i}"`
+      )
+    };
+  const o = e.getAttribute(_);
+  if (!e.hasAttribute(_) || Jn.includes(o))
+    return {
+      pass: !1,
+      message: () => S(
+        this,
+        this.utils.matcherHint(r, "element"),
+        "Expected element to be marked as invalid with attribute",
+        `${_}="${String(!0)}"`,
+        "Received",
+        e.hasAttribute("aria-invalid") ? `${_}="${e.getAttribute(_)}` : null
+      )
+    };
+  const c = X(
+    ((b = e.ownerDocument.getElementById(i)) == null ? void 0 : b.textContent) ?? ""
+  );
+  return {
+    pass: t === void 0 ? !!c : t instanceof RegExp ? t.test(c) : this.equals(c, t),
+    message: () => S(
+      this,
+      this.utils.matcherHint(r, "element"),
+      `Expected element ${n} have accessible error message`,
+      t ?? "",
+      "Received",
+      c
+    )
+  };
+}
+const Zn = nr(he.elementRoles);
+function ce(e, t) {
+  m(e, ce, this);
+  const n = er(e);
+  return {
+    pass: n.some((i) => i === t),
+    message: () => {
+      const i = this.isNot ? "not to" : "to";
+      return S(
+        this,
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.${ce.name}`,
+          "element",
+          ""
+        ),
+        `Expected element ${i} have role`,
+        t,
+        "Received",
+        n.join(", ")
+      );
+    }
+  };
+}
+function er(e) {
+  return e.hasAttribute("role") ? e.getAttribute("role").split(" ").filter(Boolean) : tr(e);
+}
+function tr(e) {
+  for (const { match: t, roles: n } of Zn)
+    if (t(e))
+      return [...n];
+  return [];
+}
+function nr(e) {
+  function t({ name: o, attributes: f }) {
+    return `${o}${f.map(({ name: c, value: b, constraints: h = [] }) => h.indexOf("undefined") !== -1 ? `:not([${c}])` : b ? `[${c}="${b}"]` : `[${c}]`).join("")}`;
+  }
+  function n({ attributes: o = [] }) {
+    return o.length;
+  }
+  function r({ specificity: o }, { specificity: f }) {
+    return f - o;
+  }
+  function i(o) {
+    let { attributes: f = [] } = o;
+    const c = f.findIndex(
+      (h) => h.value && h.name === "type" && h.value === "text"
+    );
+    c >= 0 && (f = [
+      ...f.slice(0, c),
+      ...f.slice(c + 1)
+    ]);
+    const b = t({ ...o, attributes: f });
+    return (h) => c >= 0 && h.type !== "text" ? !1 : h.matches(b);
+  }
+  let s = [];
+  for (const [o, f] of e.entries())
+    s = [
+      ...s,
+      {
+        match: i(o),
+        roles: Array.from(f),
+        specificity: n(o)
+      }
+    ];
+  return s.sort(r);
+}
+function le(e, t) {
+  m(e, le, this);
+  const n = Dn(e), r = arguments.length === 1;
+  let i = !1;
+  return r ? i = n !== "" : i = t instanceof RegExp ? t.test(n) : this.equals(n, t), {
+    pass: i,
+    message: () => {
+      const s = this.isNot ? "not to" : "to";
+      return S(
+        this,
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.${le.name}`,
+          "element",
+          ""
+        ),
+        `Expected element ${s} have accessible name`,
+        t,
+        "Received",
+        n
+      );
+    }
+  };
+}
+function Be(e, t, n) {
+  return n === void 0 ? t : `${t}=${e(n)}`;
+}
+function rr(e, t, n) {
+  return n === void 0 ? `element.hasAttribute(${e(t)})` : `element.getAttribute(${e(t)}) === ${e(n)}`;
+}
+function tt(e, t, n) {
+  m(e, tt, this);
+  const r = n !== void 0, i = e.hasAttribute(t), s = e.getAttribute(t);
+  return {
+    pass: r ? i && this.equals(s, n) : i,
+    message: () => {
+      const o = this.isNot ? "not to" : "to", f = i ? Be(this.utils.stringify, t, s) : null, c = this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toHaveAttribute`,
+        "element",
+        this.utils.printExpected(t),
+        {
+          secondArgument: r ? this.utils.printExpected(n) : void 0,
+          comment: rr(
+            this.utils.stringify,
+            t,
+            n
+          )
+        }
+      );
+      return S(
+        this,
+        c,
+        `Expected the element ${o} have attribute`,
+        Be(this.utils.stringify, t, n),
+        "Received",
+        f
+      );
+    }
+  };
+}
+function ir(e) {
+  const t = e.pop();
+  let n, r;
+  return typeof t == "object" && !(t instanceof RegExp) ? (n = e, r = t) : (n = e.concat(t), r = { exact: !1 }), { expectedClassNames: n, options: r };
+}
+function Pe(e) {
+  return e ? e.split(/\s+/).filter((t) => t.length > 0) : [];
+}
+function ke(e, t) {
+  return e.every(
+    (n) => typeof n == "string" ? t.includes(n) : t.some((r) => n.test(r))
+  );
+}
+function nt(e, ...t) {
+  m(e, nt, this);
+  const { expectedClassNames: n, options: r } = ir(t), i = Pe(e.getAttribute("class")), s = n.reduce(
+    (f, c) => f.concat(
+      typeof c == "string" || !c ? Pe(c) : c
+    ),
+    []
+  ), o = s.some((f) => f instanceof RegExp);
+  if (r.exact && o)
+    throw new Error("Exact option does not support RegExp expected class names");
+  return r.exact ? {
+    pass: ke(s, i) && s.length === i.length,
+    message: () => {
+      const f = this.isNot ? "not to" : "to";
+      return S(
+        this,
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toHaveClass`,
+          "element",
+          this.utils.printExpected(s.join(" "))
+        ),
+        `Expected the element ${f} have EXACTLY defined classes`,
+        s.join(" "),
+        "Received",
+        i.join(" ")
+      );
+    }
+  } : s.length > 0 ? {
+    pass: ke(s, i),
+    message: () => {
+      const f = this.isNot ? "not to" : "to";
+      return S(
+        this,
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toHaveClass`,
+          "element",
+          this.utils.printExpected(s.join(" "))
+        ),
+        `Expected the element ${f} have class`,
+        s.join(" "),
+        "Received",
+        i.join(" ")
+      );
+    }
+  } : {
+    pass: this.isNot ? i.length > 0 : !1,
+    message: () => this.isNot ? S(
+      this,
+      this.utils.matcherHint(".not.toHaveClass", "element", ""),
+      "Expected the element to have classes",
+      "(none)",
+      "Received",
+      i.join(" ")
+    ) : [
+      this.utils.matcherHint(".toHaveClass", "element"),
+      "At least one expected class must be provided."
+    ].join(`
+`)
+  };
+}
+function sr(e, t) {
+  const n = {}, r = e.createElement("div");
+  return Object.keys(t).forEach((i) => {
+    r.style[i] = t[i], n[i] = r.style[i];
+  }), n;
+}
+function or(e, t) {
+  return !!Object.keys(e).length && Object.entries(e).every(([n, r]) => {
+    const i = n.startsWith("--"), s = [n];
+    return i || s.push(n.toLowerCase()), s.some(
+      (o) => t[o] === r || t.getPropertyValue(o) === r
+    );
+  });
+}
+function Me(e) {
+  return Object.keys(e).sort().map((t) => `${t}: ${e[t]};`).join(`
+`);
+}
+function ar(e, t, n) {
+  const r = Array.from(n).filter((s) => t[s] !== void 0).reduce(
+    (s, o) => Object.assign(s, { [o]: n.getPropertyValue(o) }),
+    {}
+  );
+  return e(Me(t), Me(r)).replace(`${kn.red("+ Received")}
+`, "");
+}
+function fe(e, t) {
+  m(e, fe, this);
+  const n = typeof t == "object" ? t : Fn(t, fe, this), { getComputedStyle: r } = e.ownerDocument.defaultView, i = sr(e.ownerDocument, n), s = r(e);
+  return {
+    pass: or(i, s),
+    message: () => {
+      const o = `${this.isNot ? ".not" : ""}.toHaveStyle`;
+      return [
+        this.utils.matcherHint(o, "element", ""),
+        ar(this.utils.diff, i, s)
+      ].join(`
+
+`);
+    }
+  };
+}
+function rt(e) {
+  return m(e, rt, this), {
+    pass: e.ownerDocument.activeElement === e,
+    message: () => [
+      this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toHaveFocus`,
+        "element",
+        ""
+      ),
+      "",
+      ...this.isNot ? [
+        "Received element is focused:",
+        `  ${this.utils.printReceived(e)}`
+      ] : [
+        "Expected element with focus:",
+        `  ${this.utils.printExpected(e)}`,
+        "Received element with focus:",
+        `  ${this.utils.printReceived(
+          e.ownerDocument.activeElement
+        )}`
+      ]
+    ].join(`
+`)
+  };
+}
+function ur(e) {
+  const t = [...new Set(e.map((n) => n.type))];
+  if (t.length !== 1)
+    throw new Error(
+      "Multiple form elements with the same name must be of the same type"
+    );
+  switch (t[0]) {
+    case "radio": {
+      const n = e.find((r) => r.checked);
+      return n ? n.value : void 0;
+    }
+    case "checkbox":
+      return e.filter((n) => n.checked).map((n) => n.value);
+    default:
+      return e.map((n) => n.value);
+  }
+}
+function cr(e, t) {
+  const n = [...e.querySelectorAll(`[name="${jn(t)}"]`)];
+  if (n.length !== 0)
+    switch (n.length) {
+      case 1:
+        return Ye(n[0]);
+      default:
+        return ur(n);
+    }
+}
+function lr(e) {
+  return /\[\]$/.test(e) ? e.slice(0, -2) : e;
+}
+function fr(e) {
+  return Array.from(e.elements).map((n) => n.name).reduce(
+    (n, r) => ({
+      ...n,
+      [lr(r)]: cr(e, r)
+    }),
+    {}
+  );
+}
+function it(e, t) {
+  if (m(e, it, this), !e.elements)
+    throw new Error("toHaveFormValues must be called on a form or a fieldset");
+  const n = fr(e);
+  return {
+    pass: Object.entries(t).every(
+      ([r, i]) => ge(n[r], i)
+    ),
+    message: () => {
+      const r = this.isNot ? "not to" : "to", i = `${this.isNot ? ".not" : ""}.toHaveFormValues`, s = Object.keys(n).filter((o) => t.hasOwnProperty(o)).reduce((o, f) => ({ ...o, [f]: n[f] }), {});
+      return [
+        this.utils.matcherHint(i, "element", ""),
+        `Expected the element ${r} have form values`,
+        this.utils.diff(t, s)
+      ].join(`
+
+`);
+    }
+  };
+}
+function dr(e) {
+  const { getComputedStyle: t } = e.ownerDocument.defaultView, { display: n, visibility: r, opacity: i } = t(e);
+  return n !== "none" && r !== "hidden" && r !== "collapse" && i !== "0" && i !== 0;
+}
+function pr(e, t) {
+  let n;
+  return t ? n = e.nodeName === "DETAILS" && t.nodeName !== "SUMMARY" ? e.hasAttribute("open") : !0 : n = e.nodeName === "DETAILS" ? e.hasAttribute("open") : !0, !e.hasAttribute("hidden") && n;
+}
+function st(e, t) {
+  return dr(e) && pr(e, t) && (!e.parentElement || st(e.parentElement, e));
+}
+function ot(e) {
+  m(e, ot, this);
+  const t = e.ownerDocument === e.getRootNode({ composed: !0 }), n = t && st(e);
+  return {
+    pass: n,
+    message: () => {
+      const r = n ? "is" : "is not";
+      return [
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toBeVisible`,
+          "element",
+          ""
+        ),
+        "",
+        `Received element ${r} visible${t ? "" : " (element is not in the document)"}:`,
+        `  ${this.utils.printReceived(e.cloneNode(!1))}`
+      ].join(`
+`);
+    }
+  };
+}
+const hr = [
+  "fieldset",
+  "input",
+  "select",
+  "optgroup",
+  "option",
+  "button",
+  "textarea"
+];
+function gr(e, t) {
+  return L(e) === "legend" && L(t) === "fieldset" && e.isSameNode(
+    Array.from(t.children).find((n) => L(n) === "legend")
+  );
+}
+function mr(e, t) {
+  return ut(t) && !gr(e, t);
+}
+function br(e) {
+  return e.includes("-");
+}
+function at(e) {
+  const t = L(e);
+  return hr.includes(t) || br(t);
+}
+function ut(e) {
+  return at(e) && e.hasAttribute("disabled");
+}
+function ct(e) {
+  const t = e.parentElement;
+  return !!t && (mr(e, t) || ct(t));
+}
+function lt(e) {
+  return at(e) && (ut(e) || ct(e));
+}
+function ft(e) {
+  m(e, ft, this);
+  const t = lt(e);
+  return {
+    pass: t,
+    message: () => {
+      const n = t ? "is" : "is not";
+      return [
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toBeDisabled`,
+          "element",
+          ""
+        ),
+        "",
+        `Received element ${n} disabled:`,
+        `  ${this.utils.printReceived(e.cloneNode(!1))}`
+      ].join(`
+`);
+    }
+  };
+}
+function dt(e) {
+  m(e, dt, this);
+  const t = !lt(e);
+  return {
+    pass: t,
+    message: () => {
+      const n = t ? "is" : "is not";
+      return [
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toBeEnabled`,
+          "element",
+          ""
+        ),
+        "",
+        `Received element ${n} enabled:`,
+        `  ${this.utils.printReceived(e.cloneNode(!1))}`
+      ].join(`
+`);
+    }
+  };
+}
+const vr = ["select", "textarea"], yr = ["input", "select", "textarea"], Er = [
+  "color",
+  "hidden",
+  "range",
+  "submit",
+  "image",
+  "reset"
+], wr = [
+  "checkbox",
+  "combobox",
+  "gridcell",
+  "listbox",
+  "radiogroup",
+  "spinbutton",
+  "textbox",
+  "tree"
+];
+function xr(e) {
+  return vr.includes(L(e)) && e.hasAttribute("required");
+}
+function Nr(e) {
+  return L(e) === "input" && e.hasAttribute("required") && (e.hasAttribute("type") && !Er.includes(e.getAttribute("type")) || !e.hasAttribute("type"));
+}
+function Sr(e) {
+  return e.hasAttribute("aria-required") && e.getAttribute("aria-required") === "true" && (yr.includes(L(e)) || e.hasAttribute("role") && wr.includes(e.getAttribute("role")));
+}
+function pt(e) {
+  m(e, pt, this);
+  const t = xr(e) || Nr(e) || Sr(e);
+  return {
+    pass: t,
+    message: () => {
+      const n = t ? "is" : "is not";
+      return [
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toBeRequired`,
+          "element",
+          ""
+        ),
+        "",
+        `Received element ${n} required:`,
+        `  ${this.utils.printReceived(e.cloneNode(!1))}`
+      ].join(`
+`);
+    }
+  };
+}
+const Ar = ["form", "input", "select", "textarea"];
+function Rr(e) {
+  return e.hasAttribute("aria-invalid") && e.getAttribute("aria-invalid") !== "false";
+}
+function $r(e) {
+  return Ar.includes(L(e));
+}
+function ht(e) {
+  const t = Rr(e);
+  return $r(e) ? t || !e.checkValidity() : t;
+}
+function gt(e) {
+  m(e, gt, this);
+  const t = ht(e);
+  return {
+    pass: t,
+    message: () => {
+      const n = t ? "is" : "is not";
+      return [
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toBeInvalid`,
+          "element",
+          ""
+        ),
+        "",
+        `Received element ${n} currently invalid:`,
+        `  ${this.utils.printReceived(e.cloneNode(!1))}`
+      ].join(`
+`);
+    }
+  };
+}
+function mt(e) {
+  m(e, mt, this);
+  const t = !ht(e);
+  return {
+    pass: t,
+    message: () => {
+      const n = t ? "is" : "is not";
+      return [
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toBeValid`,
+          "element",
+          ""
+        ),
+        "",
+        `Received element ${n} currently valid:`,
+        `  ${this.utils.printReceived(e.cloneNode(!1))}`
+      ].join(`
+`);
+    }
+  };
+}
+function bt(e, t) {
+  if (m(e, bt, this), e.tagName.toLowerCase() === "input" && ["checkbox", "radio"].includes(e.type))
+    throw new Error(
+      "input with type=checkbox or type=radio cannot be used with .toHaveValue(). Use .toBeChecked() for type=checkbox or .toHaveFormValues() instead"
+    );
+  const n = Ye(e), r = t !== void 0;
+  let i = t, s = n;
+  return t == n && t !== n && (i = `${t} (${typeof t})`, s = `${n} (${typeof n})`), {
+    pass: r ? ge(n, t) : !!n,
+    message: () => {
+      const o = this.isNot ? "not to" : "to", f = this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toHaveValue`,
+        "element",
+        t
+      );
+      return S(
+        this,
+        f,
+        `Expected the element ${o} have value`,
+        r ? i : "(any)",
+        "Received",
+        s
+      );
+    }
+  };
+}
+function vt(e, t) {
+  m(e, vt, this);
+  const n = e.tagName.toLowerCase();
+  if (!["select", "input", "textarea"].includes(n))
+    throw new Error(
+      ".toHaveDisplayValue() currently supports only input, textarea or select elements, try with another matcher instead."
+    );
+  if (n === "input" && ["radio", "checkbox"].includes(e.type))
+    throw new Error(
+      `.toHaveDisplayValue() currently does not support input[type="${e.type}"], try with another matcher instead.`
+    );
+  const r = Cr(n, e), i = Or(t), s = i.filter(
+    (c) => r.some(
+      (b) => c instanceof RegExp ? c.test(b) : this.equals(b, String(c))
+    )
+  ).length, o = s === r.length, f = s === i.length;
+  return {
+    pass: o && f,
+    message: () => S(
+      this,
+      this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toHaveDisplayValue`,
+        "element",
+        ""
+      ),
+      `Expected element ${this.isNot ? "not " : ""}to have display value`,
+      t,
+      "Received",
+      r
+    )
+  };
+}
+function Cr(e, t) {
+  return e === "select" ? Array.from(t).filter((n) => n.selected).map((n) => n.textContent) : [t.value];
+}
+function Or(e) {
+  return e instanceof Array ? e : [e];
+}
+function yt(e) {
+  m(e, yt, this);
+  const t = () => e.tagName.toLowerCase() === "input" && ["checkbox", "radio"].includes(e.type), n = () => Et(e.getAttribute("role")) && ["true", "false"].includes(e.getAttribute("aria-checked"));
+  if (!t() && !n())
+    return {
+      pass: !1,
+      message: () => `only inputs with type="checkbox" or type="radio" or elements with ${Ir()} and a valid aria-checked attribute can be used with .toBeChecked(). Use .toHaveValue() instead`
+    };
+  const r = () => t() ? e.checked : e.getAttribute("aria-checked") === "true";
+  return {
+    pass: r(),
+    message: () => {
+      const i = r() ? "is" : "is not";
+      return [
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toBeChecked`,
+          "element",
+          ""
+        ),
+        "",
+        `Received element ${i} checked:`,
+        `  ${this.utils.printReceived(e.cloneNode(!1))}`
+      ].join(`
+`);
+    }
+  };
+}
+function Ir() {
+  return Kn(
+    Hr().map((e) => `role="${e}"`),
+    { lastWordConnector: " or " }
+  );
+}
+function Hr() {
+  return he.roles.keys().filter(Et);
+}
+function Et(e) {
+  var t;
+  return ((t = he.roles.get(e)) == null ? void 0 : t.props["aria-checked"]) !== void 0;
+}
+function wt(e) {
+  m(e, wt, this);
+  const t = () => e.tagName.toLowerCase() === "input" && e.type === "checkbox", n = () => e.getAttribute("role") === "checkbox";
+  if (!t() && !n())
+    return {
+      pass: !1,
+      message: () => 'only inputs with type="checkbox" or elements with role="checkbox" and a valid aria-checked attribute can be used with .toBePartiallyChecked(). Use .toHaveValue() instead'
+    };
+  const r = () => {
+    const i = e.getAttribute("aria-checked") === "mixed";
+    return t() && e.indeterminate || i;
+  };
+  return {
+    pass: r(),
+    message: () => {
+      const i = r() ? "is" : "is not";
+      return [
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toBePartiallyChecked`,
+          "element",
+          ""
+        ),
+        "",
+        `Received element ${i} partially checked:`,
+        `  ${this.utils.printReceived(e.cloneNode(!1))}`
+      ].join(`
+`);
+    }
+  };
+}
+function xt(e, t) {
+  K(
+    "toHaveDescription",
+    "Please use toHaveAccessibleDescription."
+  ), m(e, xt, this);
+  const n = t !== void 0, i = (e.getAttribute("aria-describedby") || "").split(/\s+/).filter(Boolean);
+  let s = "";
+  if (i.length > 0) {
+    const o = e.ownerDocument, f = i.map((c) => o.getElementById(c)).filter(Boolean);
+    s = X(f.map((c) => c.textContent).join(" "));
+  }
+  return {
+    pass: n ? t instanceof RegExp ? t.test(s) : this.equals(s, t) : !!s,
+    message: () => {
+      const o = this.isNot ? "not to" : "to";
+      return S(
+        this,
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toHaveDescription`,
+          "element",
+          ""
+        ),
+        `Expected the element ${o} have description`,
+        this.utils.printExpected(t),
+        "Received",
+        this.utils.printReceived(s)
+      );
+    }
+  };
+}
+function Nt(e, t) {
+  if (K("toHaveErrorMessage", "Please use toHaveAccessibleErrorMessage."), m(e, Nt, this), !e.hasAttribute("aria-invalid") || e.getAttribute("aria-invalid") === "false") {
+    const o = this.isNot ? ".not" : "";
+    return {
+      pass: !1,
+      message: () => S(
+        this,
+        this.utils.matcherHint(`${o}.toHaveErrorMessage`, "element", ""),
+        "Expected the element to have invalid state indicated by",
+        'aria-invalid="true"',
+        "Received",
+        e.hasAttribute("aria-invalid") ? `aria-invalid="${e.getAttribute("aria-invalid")}"` : this.utils.printReceived("")
+      )
+    };
+  }
+  const n = t !== void 0, i = (e.getAttribute("aria-errormessage") || "").split(/\s+/).filter(Boolean);
+  let s = "";
+  if (i.length > 0) {
+    const o = e.ownerDocument, f = i.map((c) => o.getElementById(c)).filter(Boolean);
+    s = X(
+      f.map((c) => c.textContent).join(" ")
+    );
+  }
+  return {
+    pass: n ? t instanceof RegExp ? t.test(s) : this.equals(s, t) : !!s,
+    message: () => {
+      const o = this.isNot ? "not to" : "to";
+      return S(
+        this,
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.toHaveErrorMessage`,
+          "element",
+          ""
+        ),
+        `Expected the element ${o} have error message`,
+        this.utils.printExpected(t),
+        "Received",
+        this.utils.printReceived(s)
+      );
+    }
+  };
+}
+function Tr(e) {
+  const t = e.ownerDocument.getSelection();
+  if (["input", "textarea"].includes(e.tagName.toLowerCase()))
+    return ["radio", "checkbox"].includes(e.type) ? "" : e.value.toString().substring(e.selectionStart, e.selectionEnd);
+  if (t.anchorNode === null || t.focusNode === null)
+    return "";
+  const n = t.getRangeAt(0), r = e.ownerDocument.createRange();
+  if (t.containsNode(e, !1))
+    r.selectNodeContents(e), t.removeAllRanges(), t.addRange(r);
+  else if (!(e.contains(t.anchorNode) && e.contains(t.focusNode))) {
+    const s = e === n.startContainer || e.contains(n.startContainer), o = e === n.endContainer || e.contains(n.endContainer);
+    t.removeAllRanges(), (s || o) && (r.selectNodeContents(e), s && r.setStart(
+      n.startContainer,
+      n.startOffset
+    ), o && r.setEnd(
+      n.endContainer,
+      n.endOffset
+    ), t.addRange(r));
+  }
+  const i = t.toString();
+  return t.removeAllRanges(), t.addRange(n), i;
+}
+function St(e, t) {
+  m(e, St, this);
+  const n = t !== void 0;
+  if (n && typeof t != "string")
+    throw new Error("expected selection must be a string or undefined");
+  const r = Tr(e);
+  return {
+    pass: n ? ge(r, t) : !!r,
+    message: () => {
+      const i = this.isNot ? "not to" : "to", s = this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toHaveSelection`,
+        "element",
+        t
+      );
+      return S(
+        this,
+        s,
+        `Expected the element ${i} have selection`,
+        n ? t : "(any)",
+        "Received",
+        r
+      );
+    }
+  };
+}
+function At(e) {
+  m(e, At, this);
+  const t = (e.getAttribute("role") || "").split(" ").map((o) => o.trim()), n = e.tagName.toLowerCase() === "button" || e.tagName.toLowerCase() === "input" && e.type === "button" || t.includes("button"), r = e.getAttribute("aria-pressed");
+  return !n || !(r === "true" || r === "false") ? {
+    pass: !1,
+    message: () => 'Only button or input with type="button" or element with role="button" and a valid aria-pressed attribute can be used with .toBePressed()'
+  } : {
+    pass: n && r === "true",
+    message: () => {
+      const o = this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toBePressed`,
+        "element",
+        ""
+      );
+      return S(
+        this,
+        o,
+        "Expected element to have",
+        `aria-pressed="${this.isNot ? "false" : "true"}"`,
+        "Received",
+        `aria-pressed="${r}"`
+      );
+    }
+  };
+}
+function Rt(e) {
+  m(e, Rt, this);
+  const t = (e.getAttribute("role") || "").split(" ").map((o) => o.trim()), n = e.tagName.toLowerCase() === "button" || e.tagName.toLowerCase() === "input" && e.type === "button" || t.includes("button"), r = e.getAttribute("aria-pressed");
+  return !n || !(r === "true" || r === "false" || r === "mixed") ? {
+    pass: !1,
+    message: () => 'Only button or input with type="button" or element with role="button" and a valid aria-pressed attribute can be used with .toBePartiallyPressed()'
+  } : {
+    pass: n && r === "mixed",
+    message: () => {
+      const o = this.isNot ? "not to" : "to", f = this.utils.matcherHint(
+        `${this.isNot ? ".not" : ""}.toBePartiallyPressed`,
+        "element",
+        ""
+      );
+      return S(
+        this,
+        f,
+        `Expected element ${o} have`,
+        'aria-pressed="mixed"',
+        "Received",
+        `aria-pressed="${r}"`
+      );
+    }
+  };
+}
+const Dr = 1, $t = 2, Ct = 4, Br = 8, Pr = 16, kr = 32, Le = {
+  [Dr]: "Node.DOCUMENT_POSITION_DISCONNECTED",
+  [$t]: "Node.DOCUMENT_POSITION_PRECEDING",
+  [Ct]: "Node.DOCUMENT_POSITION_FOLLOWING",
+  [Br]: "Node.DOCUMENT_POSITION_CONTAINS",
+  [Pr]: "Node.DOCUMENT_POSITION_CONTAINED_BY",
+  [kr]: "Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC"
+};
+function Mr(e) {
+  return e in Le ? `${Le[e]} (${e})` : `Unknown document position (${e})`;
+}
+function Ot(e, t) {
+  return function(n, r) {
+    m(n, de, this), m(r, de, this);
+    const i = n.compareDocumentPosition(r);
+    return {
+      pass: i === t,
+      message: () => [
+        this.utils.matcherHint(
+          `${this.isNot ? ".not" : ""}.${e}`,
+          "element",
+          "secondElement"
+        ),
+        "",
+        `Received: ${Mr(i)}`
+      ].join(`
+`)
+    };
+  };
+}
+function de(e, t) {
+  return Ot("toAppearBefore", Ct).apply(
+    this,
+    [e, t]
+  );
+}
+function Lr(e, t) {
+  return Ot("toAppearAfter", $t).apply(
+    this,
+    [e, t]
+  );
+}
+var qr = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  toAppearAfter: Lr,
+  toAppearBefore: de,
+  toBeChecked: yt,
+  toBeDisabled: ft,
+  toBeEmpty: Xe,
+  toBeEmptyDOMElement: Qe,
+  toBeEnabled: dt,
+  toBeInTheDOM: oe,
+  toBeInTheDocument: Ke,
+  toBeInvalid: gt,
+  toBePartiallyChecked: wt,
+  toBePartiallyPressed: Rt,
+  toBePressed: At,
+  toBeRequired: pt,
+  toBeValid: mt,
+  toBeVisible: ot,
+  toContainElement: ae,
+  toContainHTML: Je,
+  toHaveAccessibleDescription: ue,
+  toHaveAccessibleErrorMessage: et,
+  toHaveAccessibleName: le,
+  toHaveAttribute: tt,
+  toHaveClass: nt,
+  toHaveDescription: xt,
+  toHaveDisplayValue: vt,
+  toHaveErrorMessage: Nt,
+  toHaveFocus: rt,
+  toHaveFormValues: it,
+  toHaveRole: ce,
+  toHaveSelection: St,
+  toHaveStyle: fe,
+  toHaveTextContent: Ze,
+  toHaveValue: bt
+});
+export {
+  Nt as A,
+  rt as B,
+  it as C,
+  ce as D,
+  St as E,
+  fe as F,
+  Ze as G,
+  bt as H,
+  de as a,
+  yt as b,
+  ft as c,
+  Xe as d,
+  qr as e,
+  Qe as f,
+  dt as g,
+  oe as h,
+  Ke as i,
+  gt as j,
+  wt as k,
+  Rt as l,
+  At as m,
+  pt as n,
+  mt as o,
+  ot as p,
+  ae as q,
+  Je as r,
+  ue as s,
+  Lr as t,
+  et as u,
+  le as v,
+  tt as w,
+  nt as x,
+  xt as y,
+  vt as z
+};