@ansidev-oss/vitepress-theme-ansidev 1.0.6

package/dist/client/VPLocalSearchBox-ihwA4uH-.js

@@ -0,0 +1,4086 @@
+import { shallowRef as Z, watch as Le, computed as Se, toValue as He, readonly as Et, defineComponent as Tt, ref as ue, watchEffect as It, onMounted as Ne, nextTick as de, onBeforeUnmount as kt, openBlock as B, createBlock as Nt, Teleport as Ft, createElementVNode as T, withModifiers as Rt, unref as C, withDirectives as At, isRef as Ot, vModelText as Ct, createElementBlock as H, normalizeClass as qe, createCommentVNode as me, Fragment as Ge, renderList as Qe, createTextVNode as fe, toDisplayString as he, markRaw as Ye, createApp as Mt } from "vue";
+import Lt from "@localSearchIndex";
+import { t as Dt, u as Pt, n as zt, a as Vt, i as jt, s as Ze, b as ct, c as Xe, d as $t, e as Bt, w as Wt, o as ge, f as Kt, g as Jt, h as Ut, _ as Ht } from "./index-CZCdwVUW.js";
+import { useRouter as qt, dataSymbol as Gt, inBrowser as Qt } from "vitepress";
+import Yt from "@siteData";
+var ut = ["input:not([inert]):not([inert] *)", "select:not([inert]):not([inert] *)", "textarea:not([inert]):not([inert] *)", "a[href]:not([inert]):not([inert] *)", "button:not([inert]):not([inert] *)", "[tabindex]:not(slot):not([inert]):not([inert] *)", "audio[controls]:not([inert]):not([inert] *)", "video[controls]:not([inert]):not([inert] *)", '[contenteditable]:not([contenteditable="false"]):not([inert]):not([inert] *)', "details>summary:first-of-type:not([inert]):not([inert] *)", "details:not([inert]):not([inert] *)"], _e = /* @__PURE__ */ ut.join(","), dt = typeof Element > "u", X = dt ? function() {
+} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector, xe = !dt && Element.prototype.getRootNode ? function(a) {
+  var e;
+  return a == null || (e = a.getRootNode) === null || e === void 0 ? void 0 : e.call(a);
+} : function(a) {
+  return a?.ownerDocument;
+}, Ee = function(e, t) {
+  var n;
+  t === void 0 && (t = !0);
+  var r = e == null || (n = e.getAttribute) === null || n === void 0 ? void 0 : n.call(e, "inert"), s = r === "" || r === "true", i = s || t && e && // closest does not exist on shadow roots, so we fall back to a manual
+  // lookup upward, in case it is not defined.
+  (typeof e.closest == "function" ? e.closest("[inert]") : Ee(e.parentNode));
+  return i;
+}, Zt = function(e) {
+  var t, n = e == null || (t = e.getAttribute) === null || t === void 0 ? void 0 : t.call(e, "contenteditable");
+  return n === "" || n === "true";
+}, ft = function(e, t, n) {
+  if (Ee(e))
+    return [];
+  var r = Array.prototype.slice.apply(e.querySelectorAll(_e));
+  return t && X.call(e, _e) && r.unshift(e), r = r.filter(n), r;
+}, Te = function(e, t, n) {
+  for (var r = [], s = Array.from(e); s.length; ) {
+    var i = s.shift();
+    if (!Ee(i, !1))
+      if (i.tagName === "SLOT") {
+        var o = i.assignedElements(), l = o.length ? o : i.children, c = Te(l, !0, n);
+        n.flatten ? r.push.apply(r, c) : r.push({
+          scopeParent: i,
+          candidates: c
+        });
+      } else {
+        var f = X.call(i, _e);
+        f && n.filter(i) && (t || !e.includes(i)) && r.push(i);
+        var p = i.shadowRoot || // check for an undisclosed shadow
+        typeof n.getShadowRoot == "function" && n.getShadowRoot(i), v = !Ee(p, !1) && (!n.shadowRootFilter || n.shadowRootFilter(i));
+        if (p && v) {
+          var y = Te(p === !0 ? i.children : p.children, !0, n);
+          n.flatten ? r.push.apply(r, y) : r.push({
+            scopeParent: i,
+            candidates: y
+          });
+        } else
+          s.unshift.apply(s, i.children);
+      }
+  }
+  return r;
+}, ht = function(e) {
+  return !isNaN(parseInt(e.getAttribute("tabindex"), 10));
+}, Y = function(e) {
+  if (!e)
+    throw new Error("No node provided");
+  return e.tabIndex < 0 && (/^(AUDIO|VIDEO|DETAILS)$/.test(e.tagName) || Zt(e)) && !ht(e) ? 0 : e.tabIndex;
+}, Xt = function(e, t) {
+  var n = Y(e);
+  return n < 0 && t && !ht(e) ? 0 : n;
+}, en = function(e, t) {
+  return e.tabIndex === t.tabIndex ? e.documentOrder - t.documentOrder : e.tabIndex - t.tabIndex;
+}, pt = function(e) {
+  return e.tagName === "INPUT";
+}, tn = function(e) {
+  return pt(e) && e.type === "hidden";
+}, nn = function(e) {
+  var t = e.tagName === "DETAILS" && Array.prototype.slice.apply(e.children).some(function(n) {
+    return n.tagName === "SUMMARY";
+  });
+  return t;
+}, rn = function(e, t) {
+  for (var n = 0; n < e.length; n++)
+    if (e[n].checked && e[n].form === t)
+      return e[n];
+}, sn = function(e) {
+  if (!e.name)
+    return !0;
+  var t = e.form || xe(e), n = function(o) {
+    return t.querySelectorAll('input[type="radio"][name="' + o + '"]');
+  }, r;
+  if (typeof window < "u" && typeof window.CSS < "u" && typeof window.CSS.escape == "function")
+    r = n(window.CSS.escape(e.name));
+  else
+    try {
+      r = n(e.name);
+    } catch (i) {
+      return console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", i.message), !1;
+    }
+  var s = rn(r, e.form);
+  return !s || s === e;
+}, an = function(e) {
+  return pt(e) && e.type === "radio";
+}, on = function(e) {
+  return an(e) && !sn(e);
+}, ln = function(e) {
+  var t, n = e && xe(e), r = (t = n) === null || t === void 0 ? void 0 : t.host, s = !1;
+  if (n && n !== e) {
+    var i, o, l;
+    for (s = !!((i = r) !== null && i !== void 0 && (o = i.ownerDocument) !== null && o !== void 0 && o.contains(r) || e != null && (l = e.ownerDocument) !== null && l !== void 0 && l.contains(e)); !s && r; ) {
+      var c, f, p;
+      n = xe(r), r = (c = n) === null || c === void 0 ? void 0 : c.host, s = !!((f = r) !== null && f !== void 0 && (p = f.ownerDocument) !== null && p !== void 0 && p.contains(r));
+    }
+  }
+  return s;
+}, et = function(e) {
+  var t = e.getBoundingClientRect(), n = t.width, r = t.height;
+  return n === 0 && r === 0;
+}, cn = function(e, t) {
+  var n = t.displayCheck, r = t.getShadowRoot;
+  if (n === "full-native" && "checkVisibility" in e) {
+    var s = e.checkVisibility({
+      // Checking opacity might be desirable for some use cases, but natively,
+      // opacity zero elements _are_ focusable and tabbable.
+      checkOpacity: !1,
+      opacityProperty: !1,
+      contentVisibilityAuto: !0,
+      visibilityProperty: !0,
+      // This is an alias for `visibilityProperty`. Contemporary browsers
+      // support both. However, this alias has wider browser support (Chrome
+      // >= 105 and Firefox >= 106, vs. Chrome >= 121 and Firefox >= 122), so
+      // we include it anyway.
+      checkVisibilityCSS: !0
+    });
+    return !s;
+  }
+  if (getComputedStyle(e).visibility === "hidden")
+    return !0;
+  var i = X.call(e, "details>summary:first-of-type"), o = i ? e.parentElement : e;
+  if (X.call(o, "details:not([open]) *"))
+    return !0;
+  if (!n || n === "full" || // full-native can run this branch when it falls through in case
+  // Element#checkVisibility is unsupported
+  n === "full-native" || n === "legacy-full") {
+    if (typeof r == "function") {
+      for (var l = e; e; ) {
+        var c = e.parentElement, f = xe(e);
+        if (c && !c.shadowRoot && r(c) === !0)
+          return et(e);
+        e.assignedSlot ? e = e.assignedSlot : !c && f !== e.ownerDocument ? e = f.host : e = c;
+      }
+      e = l;
+    }
+    if (ln(e))
+      return !e.getClientRects().length;
+    if (n !== "legacy-full")
+      return !0;
+  } else if (n === "non-zero-area")
+    return et(e);
+  return !1;
+}, un = function(e) {
+  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(e.tagName))
+    for (var t = e.parentElement; t; ) {
+      if (t.tagName === "FIELDSET" && t.disabled) {
+        for (var n = 0; n < t.children.length; n++) {
+          var r = t.children.item(n);
+          if (r.tagName === "LEGEND")
+            return X.call(t, "fieldset[disabled] *") ? !0 : !r.contains(e);
+        }
+        return !0;
+      }
+      t = t.parentElement;
+    }
+  return !1;
+}, Ie = function(e, t) {
+  return !(t.disabled || tn(t) || cn(t, e) || // For a details element with a summary, the summary element gets the focus
+  nn(t) || un(t));
+}, De = function(e, t) {
+  return !(on(t) || Y(t) < 0 || !Ie(e, t));
+}, dn = function(e) {
+  var t = parseInt(e.getAttribute("tabindex"), 10);
+  return !!(isNaN(t) || t >= 0);
+}, vt = function(e) {
+  var t = [], n = [];
+  return e.forEach(function(r, s) {
+    var i = !!r.scopeParent, o = i ? r.scopeParent : r, l = Xt(o, i), c = i ? vt(r.candidates) : o;
+    l === 0 ? i ? t.push.apply(t, c) : t.push(o) : n.push({
+      documentOrder: s,
+      tabIndex: l,
+      item: r,
+      isScope: i,
+      content: c
+    });
+  }), n.sort(en).reduce(function(r, s) {
+    return s.isScope ? r.push.apply(r, s.content) : r.push(s.content), r;
+  }, []).concat(t);
+}, fn = function(e, t) {
+  t = t || {};
+  var n;
+  return t.getShadowRoot ? n = Te([e], t.includeContainer, {
+    filter: De.bind(null, t),
+    flatten: !1,
+    getShadowRoot: t.getShadowRoot,
+    shadowRootFilter: dn
+  }) : n = ft(e, t.includeContainer, De.bind(null, t)), vt(n);
+}, hn = function(e, t) {
+  t = t || {};
+  var n;
+  return t.getShadowRoot ? n = Te([e], t.includeContainer, {
+    filter: Ie.bind(null, t),
+    flatten: !0,
+    getShadowRoot: t.getShadowRoot
+  }) : n = ft(e, t.includeContainer, Ie.bind(null, t)), n;
+}, te = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return X.call(e, _e) === !1 ? !1 : De(t, e);
+}, pn = /* @__PURE__ */ ut.concat("iframe:not([inert]):not([inert] *)").join(","), Fe = function(e, t) {
+  if (t = t || {}, !e)
+    throw new Error("No node provided");
+  return X.call(e, pn) === !1 ? !1 : Ie(t, e);
+};
+function Pe(a, e) {
+  (e == null || e > a.length) && (e = a.length);
+  for (var t = 0, n = Array(e); t < e; t++) n[t] = a[t];
+  return n;
+}
+function vn(a) {
+  if (Array.isArray(a)) return Pe(a);
+}
+function tt(a, e) {
+  var t = typeof Symbol < "u" && a[Symbol.iterator] || a["@@iterator"];
+  if (!t) {
+    if (Array.isArray(a) || (t = mt(a)) || e) {
+      t && (a = t);
+      var n = 0, r = function() {
+      };
+      return {
+        s: r,
+        n: function() {
+          return n >= a.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: a[n++]
+          };
+        },
+        e: function(l) {
+          throw l;
+        },
+        f: r
+      };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var s, i = !0, o = !1;
+  return {
+    s: function() {
+      t = t.call(a);
+    },
+    n: function() {
+      var l = t.next();
+      return i = l.done, l;
+    },
+    e: function(l) {
+      o = !0, s = l;
+    },
+    f: function() {
+      try {
+        i || t.return == null || t.return();
+      } finally {
+        if (o) throw s;
+      }
+    }
+  };
+}
+function mn(a, e, t) {
+  return (e = Sn(e)) in a ? Object.defineProperty(a, e, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : a[e] = t, a;
+}
+function gn(a) {
+  if (typeof Symbol < "u" && a[Symbol.iterator] != null || a["@@iterator"] != null) return Array.from(a);
+}
+function bn() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function nt(a, e) {
+  var t = Object.keys(a);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(a);
+    e && (n = n.filter(function(r) {
+      return Object.getOwnPropertyDescriptor(a, r).enumerable;
+    })), t.push.apply(t, n);
+  }
+  return t;
+}
+function it(a) {
+  for (var e = 1; e < arguments.length; e++) {
+    var t = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? nt(Object(t), !0).forEach(function(n) {
+      mn(a, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(a, Object.getOwnPropertyDescriptors(t)) : nt(Object(t)).forEach(function(n) {
+      Object.defineProperty(a, n, Object.getOwnPropertyDescriptor(t, n));
+    });
+  }
+  return a;
+}
+function yn(a) {
+  return vn(a) || gn(a) || mt(a) || bn();
+}
+function wn(a, e) {
+  if (typeof a != "object" || !a) return a;
+  var t = a[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var n = t.call(a, e);
+    if (typeof n != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(a);
+}
+function Sn(a) {
+  var e = wn(a, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function mt(a, e) {
+  if (a) {
+    if (typeof a == "string") return Pe(a, e);
+    var t = {}.toString.call(a).slice(8, -1);
+    return t === "Object" && a.constructor && (t = a.constructor.name), t === "Map" || t === "Set" ? Array.from(a) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? Pe(a, e) : void 0;
+  }
+}
+var W = {
+  // Returns the trap from the top of the stack.
+  getActiveTrap: function(e) {
+    return e?.length > 0 ? e[e.length - 1] : null;
+  },
+  // Pauses the currently active trap, then adds a new trap to the stack.
+  activateTrap: function(e, t) {
+    var n = W.getActiveTrap(e);
+    t !== n && W.pauseTrap(e);
+    var r = e.indexOf(t);
+    r === -1 || e.splice(r, 1), e.push(t);
+  },
+  // Removes the trap from the top of the stack, then unpauses the next trap down.
+  deactivateTrap: function(e, t) {
+    var n = e.indexOf(t);
+    n !== -1 && e.splice(n, 1), W.unpauseTrap(e);
+  },
+  // Pauses the trap at the top of the stack.
+  pauseTrap: function(e) {
+    var t = W.getActiveTrap(e);
+    t?._setPausedState(!0);
+  },
+  // Unpauses the trap at the top of the stack.
+  unpauseTrap: function(e) {
+    var t = W.getActiveTrap(e);
+    t && !t._isManuallyPaused() && t._setPausedState(!1);
+  }
+}, _n = function(e) {
+  return e.tagName && e.tagName.toLowerCase() === "input" && typeof e.select == "function";
+}, xn = function(e) {
+  return e?.key === "Escape" || e?.key === "Esc" || e?.keyCode === 27;
+}, ve = function(e) {
+  return e?.key === "Tab" || e?.keyCode === 9;
+}, En = function(e) {
+  return ve(e) && !e.shiftKey;
+}, Tn = function(e) {
+  return ve(e) && e.shiftKey;
+}, rt = function(e) {
+  return setTimeout(e, 0);
+}, pe = function(e) {
+  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), r = 1; r < t; r++)
+    n[r - 1] = arguments[r];
+  return typeof e == "function" ? e.apply(void 0, n) : e;
+}, be = function(e) {
+  return e.target.shadowRoot && typeof e.composedPath == "function" ? e.composedPath()[0] : e.target;
+}, In = [], kn = function(e, t) {
+  var n = t?.document || document, r = t?.trapStack || In, s = it({
+    returnFocusOnDeactivate: !0,
+    escapeDeactivates: !0,
+    delayInitialFocus: !0,
+    isolateSubtrees: !1,
+    isKeyForward: En,
+    isKeyBackward: Tn
+  }, t), i = {
+    // containers given to createFocusTrap()
+    /** @type {Array<HTMLElement>} */
+    containers: [],
+    // list of objects identifying tabbable nodes in `containers` in the trap
+    // NOTE: it's possible that a group has no tabbable nodes if nodes get removed while the trap
+    //  is active, but the trap should never get to a state where there isn't at least one group
+    //  with at least one tabbable node in it (that would lead to an error condition that would
+    //  result in an error being thrown)
+    /** @type {Array<{
+     *    container: HTMLElement,
+     *    tabbableNodes: Array<HTMLElement>, // empty if none
+     *    focusableNodes: Array<HTMLElement>, // empty if none
+     *    posTabIndexesFound: boolean,
+     *    firstTabbableNode: HTMLElement|undefined,
+     *    lastTabbableNode: HTMLElement|undefined,
+     *    firstDomTabbableNode: HTMLElement|undefined,
+     *    lastDomTabbableNode: HTMLElement|undefined,
+     *    nextTabbableNode: (node: HTMLElement, forward: boolean) => HTMLElement|undefined
+     *  }>}
+     */
+    containerGroups: [],
+    // same order/length as `containers` list
+    // references to objects in `containerGroups`, but only those that actually have
+    //  tabbable nodes in them
+    // NOTE: same order as `containers` and `containerGroups`, but __not necessarily__
+    //  the same length
+    tabbableGroups: [],
+    // references to nodes that are siblings to the ancestors of this trap's containers.
+    /** @type {Set<HTMLElement>} */
+    adjacentElements: /* @__PURE__ */ new Set(),
+    // references to nodes that were inert or aria-hidden before the trap was activated.
+    /** @type {Set<HTMLElement>} */
+    alreadySilent: /* @__PURE__ */ new Set(),
+    nodeFocusedBeforeActivation: null,
+    mostRecentlyFocusedNode: null,
+    active: !1,
+    paused: !1,
+    manuallyPaused: !1,
+    // timer ID for when delayInitialFocus is true and initial focus in this trap
+    //  has been delayed during activation
+    delayInitialFocusTimer: void 0,
+    // the most recent KeyboardEvent for the configured nav key (typically [SHIFT+]TAB), if any
+    recentNavEvent: void 0
+  }, o, l = function(u, d, b) {
+    return u && u[d] !== void 0 ? u[d] : s[b || d];
+  }, c = function(u, d) {
+    var b = typeof d?.composedPath == "function" ? d.composedPath() : void 0;
+    return i.containerGroups.findIndex(function(I) {
+      var m = I.container, h = I.tabbableNodes;
+      return m.contains(u) || b?.includes(m) || h.find(function(g) {
+        return g === u;
+      });
+    });
+  }, f = function(u) {
+    var d = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, b = d.hasFallback, I = b === void 0 ? !1 : b, m = d.params, h = m === void 0 ? [] : m, g = s[u];
+    if (typeof g == "function" && (g = g.apply(void 0, yn(h))), g === !0 && (g = void 0), !g) {
+      if (g === void 0 || g === !1)
+        return g;
+      throw new Error("`".concat(u, "` was specified but was not a node, or did not return a node"));
+    }
+    var E = g;
+    if (typeof g == "string") {
+      try {
+        E = n.querySelector(g);
+      } catch (k) {
+        throw new Error("`".concat(u, '` appears to be an invalid selector; error="').concat(k.message, '"'));
+      }
+      if (!E && !I)
+        throw new Error("`".concat(u, "` as selector refers to no known node"));
+    }
+    return E;
+  }, p = function() {
+    var u = f("initialFocus", {
+      hasFallback: !0
+    });
+    if (u === !1)
+      return !1;
+    if (u === void 0 || u && !Fe(u, s.tabbableOptions))
+      if (c(n.activeElement) >= 0)
+        u = n.activeElement;
+      else {
+        var d = i.tabbableGroups[0], b = d && d.firstTabbableNode;
+        u = b || f("fallbackFocus");
+      }
+    else u === null && (u = f("fallbackFocus"));
+    if (!u)
+      throw new Error("Your focus-trap needs to have at least one focusable element");
+    return u;
+  }, v = function() {
+    if (i.containerGroups = i.containers.map(function(u) {
+      var d = fn(u, s.tabbableOptions), b = hn(u, s.tabbableOptions), I = d.length > 0 ? d[0] : void 0, m = d.length > 0 ? d[d.length - 1] : void 0, h = b.find(function(k) {
+        return te(k);
+      }), g = b.slice().reverse().find(function(k) {
+        return te(k);
+      }), E = !!d.find(function(k) {
+        return Y(k) > 0;
+      });
+      return {
+        container: u,
+        tabbableNodes: d,
+        focusableNodes: b,
+        /** True if at least one node with positive `tabindex` was found in this container. */
+        posTabIndexesFound: E,
+        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */
+        firstTabbableNode: I,
+        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */
+        lastTabbableNode: m,
+        // NOTE: DOM order is NOT NECESSARILY "document position" order, but figuring that out
+        //  would require more than just https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition
+        //  because that API doesn't work with Shadow DOM as well as it should (@see
+        //  https://github.com/whatwg/dom/issues/320) and since this first/last is only needed, so far,
+        //  to address an edge case related to positive tabindex support, this seems like a much easier,
+        //  "close enough most of the time" alternative for positive tabindexes which should generally
+        //  be avoided anyway...
+        /** First tabbable node in container, __DOM__ order; `undefined` if none. */
+        firstDomTabbableNode: h,
+        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */
+        lastDomTabbableNode: g,
+        /**
+         * Finds the __tabbable__ node that follows the given node in the specified direction,
+         *  in this container, if any.
+         * @param {HTMLElement} node
+         * @param {boolean} [forward] True if going in forward tab order; false if going
+         *  in reverse.
+         * @returns {HTMLElement|undefined} The next tabbable node, if any.
+         */
+        nextTabbableNode: function(R) {
+          var P = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0, D = d.indexOf(R);
+          return D < 0 ? P ? b.slice(b.indexOf(R) + 1).find(function($) {
+            return te($);
+          }) : b.slice(0, b.indexOf(R)).reverse().find(function($) {
+            return te($);
+          }) : d[D + (P ? 1 : -1)];
+        }
+      };
+    }), i.tabbableGroups = i.containerGroups.filter(function(u) {
+      return u.tabbableNodes.length > 0;
+    }), i.tabbableGroups.length <= 0 && !f("fallbackFocus"))
+      throw new Error("Your focus-trap must have at least one container with at least one tabbable node in it at all times");
+    if (i.containerGroups.find(function(u) {
+      return u.posTabIndexesFound;
+    }) && i.containerGroups.length > 1)
+      throw new Error("At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps.");
+  }, y = function(u) {
+    var d = u.activeElement;
+    if (d)
+      return d.shadowRoot && d.shadowRoot.activeElement !== null ? y(d.shadowRoot) : d;
+  }, S = function(u) {
+    if (u !== !1 && u !== y(document)) {
+      if (!u || !u.focus) {
+        S(p());
+        return;
+      }
+      u.focus({
+        preventScroll: !!s.preventScroll
+      }), i.mostRecentlyFocusedNode = u, _n(u) && u.select();
+    }
+  }, w = function(u) {
+    var d = f("setReturnFocus", {
+      params: [u]
+    });
+    return d || (d === !1 ? !1 : u);
+  }, _ = function(u) {
+    var d = u.target, b = u.event, I = u.isBackward, m = I === void 0 ? !1 : I;
+    d = d || be(b), v();
+    var h = null;
+    if (i.tabbableGroups.length > 0) {
+      var g = c(d, b), E = g >= 0 ? i.containerGroups[g] : void 0;
+      if (g < 0)
+        m ? h = i.tabbableGroups[i.tabbableGroups.length - 1].lastTabbableNode : h = i.tabbableGroups[0].firstTabbableNode;
+      else if (m) {
+        var k = i.tabbableGroups.findIndex(function(J) {
+          var U = J.firstTabbableNode;
+          return d === U;
+        });
+        if (k < 0 && (E.container === d || Fe(d, s.tabbableOptions) && !te(d, s.tabbableOptions) && !E.nextTabbableNode(d, !1)) && (k = g), k >= 0) {
+          var R = k === 0 ? i.tabbableGroups.length - 1 : k - 1, P = i.tabbableGroups[R];
+          h = Y(d) >= 0 ? P.lastTabbableNode : P.lastDomTabbableNode;
+        } else ve(b) || (h = E.nextTabbableNode(d, !1));
+      } else {
+        var D = i.tabbableGroups.findIndex(function(J) {
+          var U = J.lastTabbableNode;
+          return d === U;
+        });
+        if (D < 0 && (E.container === d || Fe(d, s.tabbableOptions) && !te(d, s.tabbableOptions) && !E.nextTabbableNode(d)) && (D = g), D >= 0) {
+          var $ = D === i.tabbableGroups.length - 1 ? 0 : D + 1, A = i.tabbableGroups[$];
+          h = Y(d) >= 0 ? A.firstTabbableNode : A.firstDomTabbableNode;
+        } else ve(b) || (h = E.nextTabbableNode(d));
+      }
+    } else
+      h = f("fallbackFocus");
+    return h;
+  }, N = function(u) {
+    var d = be(u);
+    if (!(c(d, u) >= 0)) {
+      if (pe(s.clickOutsideDeactivates, u)) {
+        o.deactivate({
+          // NOTE: by setting `returnFocus: false`, deactivate() will do nothing,
+          //  which will result in the outside click setting focus to the node
+          //  that was clicked (and if not focusable, to "nothing"); by setting
+          //  `returnFocus: true`, we'll attempt to re-focus the node originally-focused
+          //  on activation (or the configured `setReturnFocus` node), whether the
+          //  outside click was on a focusable node or not
+          returnFocus: s.returnFocusOnDeactivate
+        });
+        return;
+      }
+      pe(s.allowOutsideClick, u) || u.preventDefault();
+    }
+  }, F = function(u) {
+    var d = be(u), b = c(d, u) >= 0;
+    if (b || d instanceof Document)
+      b && (i.mostRecentlyFocusedNode = d);
+    else {
+      u.stopImmediatePropagation();
+      var I, m = !0;
+      if (i.mostRecentlyFocusedNode)
+        if (Y(i.mostRecentlyFocusedNode) > 0) {
+          var h = c(i.mostRecentlyFocusedNode), g = i.containerGroups[h].tabbableNodes;
+          if (g.length > 0) {
+            var E = g.findIndex(function(k) {
+              return k === i.mostRecentlyFocusedNode;
+            });
+            E >= 0 && (s.isKeyForward(i.recentNavEvent) ? E + 1 < g.length && (I = g[E + 1], m = !1) : E - 1 >= 0 && (I = g[E - 1], m = !1));
+          }
+        } else
+          i.containerGroups.some(function(k) {
+            return k.tabbableNodes.some(function(R) {
+              return Y(R) > 0;
+            });
+          }) || (m = !1);
+      else
+        m = !1;
+      m && (I = _({
+        // move FROM the MRU node, not event-related node (which will be the node that is
+        //  outside the trap causing the focus escape we're trying to fix)
+        target: i.mostRecentlyFocusedNode,
+        isBackward: s.isKeyBackward(i.recentNavEvent)
+      })), S(I || i.mostRecentlyFocusedNode || p());
+    }
+    i.recentNavEvent = void 0;
+  }, G = function(u) {
+    var d = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+    i.recentNavEvent = u;
+    var b = _({
+      event: u,
+      isBackward: d
+    });
+    b && (ve(u) && u.preventDefault(), S(b));
+  }, z = function(u) {
+    (s.isKeyForward(u) || s.isKeyBackward(u)) && G(u, s.isKeyBackward(u));
+  }, j = function(u) {
+    xn(u) && pe(s.escapeDeactivates, u) !== !1 && (u.preventDefault(), o.deactivate());
+  }, L = function(u) {
+    var d = be(u);
+    c(d, u) >= 0 || pe(s.clickOutsideDeactivates, u) || pe(s.allowOutsideClick, u) || (u.preventDefault(), u.stopImmediatePropagation());
+  }, V = function() {
+    if (i.active)
+      return W.activateTrap(r, o), i.delayInitialFocusTimer = s.delayInitialFocus ? rt(function() {
+        S(p());
+      }) : S(p()), n.addEventListener("focusin", F, !0), n.addEventListener("mousedown", N, {
+        capture: !0,
+        passive: !1
+      }), n.addEventListener("touchstart", N, {
+        capture: !0,
+        passive: !1
+      }), n.addEventListener("click", L, {
+        capture: !0,
+        passive: !1
+      }), n.addEventListener("keydown", z, {
+        capture: !0,
+        passive: !1
+      }), n.addEventListener("keydown", j), o;
+  }, O = function(u) {
+    i.active && !i.paused && o._setSubtreeIsolation(!1), i.adjacentElements.clear(), i.alreadySilent.clear();
+    var d = /* @__PURE__ */ new Set(), b = /* @__PURE__ */ new Set(), I = tt(u), m;
+    try {
+      for (I.s(); !(m = I.n()).done; ) {
+        var h = m.value;
+        d.add(h);
+        for (var g = typeof ShadowRoot < "u" && h.getRootNode() instanceof ShadowRoot, E = h; E; ) {
+          d.add(E);
+          var k = E.parentElement, R = [];
+          k ? R = k.children : !k && g && (R = E.getRootNode().children, k = E.getRootNode().host, g = typeof ShadowRoot < "u" && k.getRootNode() instanceof ShadowRoot);
+          var P = tt(R), D;
+          try {
+            for (P.s(); !(D = P.n()).done; ) {
+              var $ = D.value;
+              b.add($);
+            }
+          } catch (A) {
+            P.e(A);
+          } finally {
+            P.f();
+          }
+          E = k;
+        }
+      }
+    } catch (A) {
+      I.e(A);
+    } finally {
+      I.f();
+    }
+    d.forEach(function(A) {
+      b.delete(A);
+    }), i.adjacentElements = b;
+  }, K = function() {
+    if (i.active)
+      return n.removeEventListener("focusin", F, !0), n.removeEventListener("mousedown", N, !0), n.removeEventListener("touchstart", N, !0), n.removeEventListener("click", L, !0), n.removeEventListener("keydown", z, !0), n.removeEventListener("keydown", j), o;
+  }, se = function(u) {
+    var d = u.some(function(b) {
+      var I = Array.from(b.removedNodes);
+      return I.some(function(m) {
+        return m === i.mostRecentlyFocusedNode;
+      });
+    });
+    d && S(p());
+  }, ae = typeof window < "u" && "MutationObserver" in window ? new MutationObserver(se) : void 0, ee = function() {
+    ae && (ae.disconnect(), i.active && !i.paused && i.containers.map(function(u) {
+      ae.observe(u, {
+        subtree: !0,
+        childList: !0
+      });
+    }));
+  };
+  return o = {
+    get active() {
+      return i.active;
+    },
+    get paused() {
+      return i.paused;
+    },
+    activate: function(u) {
+      if (i.active)
+        return this;
+      var d = l(u, "onActivate"), b = l(u, "onPostActivate"), I = l(u, "checkCanFocusTrap"), m = W.getActiveTrap(r), h = !1;
+      if (m && !m.paused) {
+        var g;
+        (g = m._setSubtreeIsolation) === null || g === void 0 || g.call(m, !1), h = !0;
+      }
+      try {
+        I || v(), i.active = !0, i.paused = !1, i.nodeFocusedBeforeActivation = y(n), d?.();
+        var E = function() {
+          I && v(), V(), ee(), s.isolateSubtrees && o._setSubtreeIsolation(!0), b?.();
+        };
+        if (I)
+          return I(i.containers.concat()).then(E, E), this;
+        E();
+      } catch (R) {
+        if (m === W.getActiveTrap(r) && h) {
+          var k;
+          (k = m._setSubtreeIsolation) === null || k === void 0 || k.call(m, !0);
+        }
+        throw R;
+      }
+      return this;
+    },
+    deactivate: function(u) {
+      if (!i.active)
+        return this;
+      var d = it({
+        onDeactivate: s.onDeactivate,
+        onPostDeactivate: s.onPostDeactivate,
+        checkCanReturnFocus: s.checkCanReturnFocus
+      }, u);
+      clearTimeout(i.delayInitialFocusTimer), i.delayInitialFocusTimer = void 0, i.paused || o._setSubtreeIsolation(!1), i.alreadySilent.clear(), K(), i.active = !1, i.paused = !1, ee(), W.deactivateTrap(r, o);
+      var b = l(d, "onDeactivate"), I = l(d, "onPostDeactivate"), m = l(d, "checkCanReturnFocus"), h = l(d, "returnFocus", "returnFocusOnDeactivate");
+      b?.();
+      var g = function() {
+        rt(function() {
+          h && S(w(i.nodeFocusedBeforeActivation)), I?.();
+        });
+      };
+      return h && m ? (m(w(i.nodeFocusedBeforeActivation)).then(g, g), this) : (g(), this);
+    },
+    pause: function(u) {
+      return i.active ? (i.manuallyPaused = !0, this._setPausedState(!0, u)) : this;
+    },
+    unpause: function(u) {
+      return i.active ? (i.manuallyPaused = !1, r[r.length - 1] !== this ? this : this._setPausedState(!1, u)) : this;
+    },
+    updateContainerElements: function(u) {
+      var d = [].concat(u).filter(Boolean);
+      return i.containers = d.map(function(b) {
+        return typeof b == "string" ? n.querySelector(b) : b;
+      }), s.isolateSubtrees && O(i.containers), i.active && (v(), s.isolateSubtrees && !i.paused && o._setSubtreeIsolation(!0)), ee(), this;
+    }
+  }, Object.defineProperties(o, {
+    _isManuallyPaused: {
+      value: function() {
+        return i.manuallyPaused;
+      }
+    },
+    _setPausedState: {
+      value: function(u, d) {
+        if (i.paused === u)
+          return this;
+        if (i.paused = u, u) {
+          var b = l(d, "onPause"), I = l(d, "onPostPause");
+          b?.(), K(), ee(), o._setSubtreeIsolation(!1), I?.();
+        } else {
+          var m = l(d, "onUnpause"), h = l(d, "onPostUnpause");
+          m?.(), o._setSubtreeIsolation(!0), v(), V(), ee(), h?.();
+        }
+        return this;
+      }
+    },
+    _setSubtreeIsolation: {
+      value: function(u) {
+        s.isolateSubtrees && i.adjacentElements.forEach(function(d) {
+          var b;
+          u ? s.isolateSubtrees === "aria-hidden" ? ((d.ariaHidden === "true" || ((b = d.getAttribute("aria-hidden")) === null || b === void 0 ? void 0 : b.toLowerCase()) === "true") && i.alreadySilent.add(d), d.setAttribute("aria-hidden", "true")) : ((d.inert || d.hasAttribute("inert")) && i.alreadySilent.add(d), d.setAttribute("inert", !0)) : i.alreadySilent.has(d) || (s.isolateSubtrees === "aria-hidden" ? d.removeAttribute("aria-hidden") : d.removeAttribute("inert"));
+        });
+      }
+    }
+  }), o.updateContainerElements(e), o;
+};
+function Nn(a, e = {}) {
+  let t;
+  const { immediate: n, ...r } = e, s = Z(!1), i = Z(!1), o = (p) => t && t.activate(p), l = (p) => t && t.deactivate(p), c = () => {
+    t && (t.pause(), i.value = !0);
+  }, f = () => {
+    t && (t.unpause(), i.value = !1);
+  };
+  return Le(Se(() => Dt(He(a)).map((p) => {
+    const v = He(p);
+    return typeof v == "string" ? v : Pt(v);
+  }).filter(zt)), (p) => {
+    if (p.length)
+      if (!t)
+        t = kn(p, {
+          ...r,
+          onActivate() {
+            s.value = !0, e.onActivate && e.onActivate();
+          },
+          onDeactivate() {
+            s.value = !1, e.onDeactivate && e.onDeactivate();
+          }
+        }), n && o();
+      else {
+        const v = t?.active;
+        t?.updateContainerElements(p), !v && n && o();
+      }
+  }, { flush: "post" }), Vt(() => l()), {
+    hasFocus: s,
+    isPaused: i,
+    activate: o,
+    deactivate: l,
+    pause: c,
+    unpause: f
+  };
+}
+class ie {
+  /**
+   * @param {HTMLElement|HTMLElement[]|NodeList|string} ctx - The context DOM
+   * element, an array of DOM elements, a NodeList or a selector
+   * @param {boolean} [iframes=true] - A boolean indicating if iframes should
+   * be handled
+   * @param {string[]} [exclude=[]] - An array containing exclusion selectors
+   * for iframes
+   * @param {number} [iframesTimeout=5000] - A number indicating the ms to
+   * wait before an iframe should be skipped, in case the load event isn't
+   * fired. This also applies if the user is offline and the resource of the
+   * iframe is online (either by the browsers "offline" mode or because
+   * there's no internet connection)
+   */
+  constructor(e, t = !0, n = [], r = 5e3) {
+    this.ctx = e, this.iframes = t, this.exclude = n, this.iframesTimeout = r;
+  }
+  /**
+   * Checks if the specified DOM element matches the selector
+   * @param  {HTMLElement} element - The DOM element
+   * @param  {string|string[]} selector - The selector or an array with
+   * selectors
+   * @return {boolean}
+   * @access public
+   */
+  static matches(e, t) {
+    const n = typeof t == "string" ? [t] : t, r = e.matches || e.matchesSelector || e.msMatchesSelector || e.mozMatchesSelector || e.oMatchesSelector || e.webkitMatchesSelector;
+    if (r) {
+      let s = !1;
+      return n.every((i) => r.call(e, i) ? (s = !0, !1) : !0), s;
+    } else
+      return !1;
+  }
+  /**
+   * Returns all contexts filtered by duplicates (even nested)
+   * @return {HTMLElement[]} - An array containing DOM contexts
+   * @access protected
+   */
+  getContexts() {
+    let e, t = [];
+    return typeof this.ctx > "u" || !this.ctx ? e = [] : NodeList.prototype.isPrototypeOf(this.ctx) ? e = Array.prototype.slice.call(this.ctx) : Array.isArray(this.ctx) ? e = this.ctx : typeof this.ctx == "string" ? e = Array.prototype.slice.call(
+      document.querySelectorAll(this.ctx)
+    ) : e = [this.ctx], e.forEach((n) => {
+      const r = t.filter((s) => s.contains(n)).length > 0;
+      t.indexOf(n) === -1 && !r && t.push(n);
+    }), t;
+  }
+  /**
+   * @callback DOMIterator~getIframeContentsSuccessCallback
+   * @param {HTMLDocument} contents - The contentDocument of the iframe
+   */
+  /**
+   * Calls the success callback function with the iframe document. If it can't
+   * be accessed it calls the error callback function
+   * @param {HTMLElement} ifr - The iframe DOM element
+   * @param {DOMIterator~getIframeContentsSuccessCallback} successFn
+   * @param {function} [errorFn]
+   * @access protected
+   */
+  getIframeContents(e, t, n = () => {
+  }) {
+    let r;
+    try {
+      const s = e.contentWindow;
+      if (r = s.document, !s || !r)
+        throw new Error("iframe inaccessible");
+    } catch {
+      n();
+    }
+    r && t(r);
+  }
+  /**
+   * Checks if an iframe is empty (if about:blank is the shown page)
+   * @param {HTMLElement} ifr - The iframe DOM element
+   * @return {boolean}
+   * @access protected
+   */
+  isIframeBlank(e) {
+    const t = "about:blank", n = e.getAttribute("src").trim();
+    return e.contentWindow.location.href === t && n !== t && n;
+  }
+  /**
+   * Observes the onload event of an iframe and calls the success callback or
+   * the error callback if the iframe is inaccessible. If the event isn't
+   * fired within the specified {@link DOMIterator#iframesTimeout}, then it'll
+   * call the error callback too
+   * @param {HTMLElement} ifr - The iframe DOM element
+   * @param {DOMIterator~getIframeContentsSuccessCallback} successFn
+   * @param {function} errorFn
+   * @access protected
+   */
+  observeIframeLoad(e, t, n) {
+    let r = !1, s = null;
+    const i = () => {
+      if (!r) {
+        r = !0, clearTimeout(s);
+        try {
+          this.isIframeBlank(e) || (e.removeEventListener("load", i), this.getIframeContents(e, t, n));
+        } catch {
+          n();
+        }
+      }
+    };
+    e.addEventListener("load", i), s = setTimeout(i, this.iframesTimeout);
+  }
+  /**
+   * Callback when the iframe is ready
+   * @callback DOMIterator~onIframeReadySuccessCallback
+   * @param {HTMLDocument} contents - The contentDocument of the iframe
+   */
+  /**
+   * Callback if the iframe can't be accessed
+   * @callback DOMIterator~onIframeReadyErrorCallback
+   */
+  /**
+   * Calls the callback if the specified iframe is ready for DOM access
+   * @param  {HTMLElement} ifr - The iframe DOM element
+   * @param  {DOMIterator~onIframeReadySuccessCallback} successFn - Success
+   * callback
+   * @param {DOMIterator~onIframeReadyErrorCallback} errorFn - Error callback
+   * @see {@link http://stackoverflow.com/a/36155560/3894981} for
+   * background information
+   * @access protected
+   */
+  onIframeReady(e, t, n) {
+    try {
+      e.contentWindow.document.readyState === "complete" ? this.isIframeBlank(e) ? this.observeIframeLoad(e, t, n) : this.getIframeContents(e, t, n) : this.observeIframeLoad(e, t, n);
+    } catch {
+      n();
+    }
+  }
+  /**
+   * Callback when all iframes are ready for DOM access
+   * @callback DOMIterator~waitForIframesDoneCallback
+   */
+  /**
+   * Iterates over all iframes and calls the done callback when all of them
+   * are ready for DOM access (including nested ones)
+   * @param {HTMLElement} ctx - The context DOM element
+   * @param {DOMIterator~waitForIframesDoneCallback} done - Done callback
+   */
+  waitForIframes(e, t) {
+    let n = 0;
+    this.forEachIframe(e, () => !0, (r) => {
+      n++, this.waitForIframes(r.querySelector("html"), () => {
+        --n || t();
+      });
+    }, (r) => {
+      r || t();
+    });
+  }
+  /**
+   * Callback allowing to filter an iframe. Must return true when the element
+   * should remain, otherwise false
+   * @callback DOMIterator~forEachIframeFilterCallback
+   * @param {HTMLElement} iframe - The iframe DOM element
+   */
+  /**
+   * Callback for each iframe content
+   * @callback DOMIterator~forEachIframeEachCallback
+   * @param {HTMLElement} content - The iframe document
+   */
+  /**
+   * Callback if all iframes inside the context were handled
+   * @callback DOMIterator~forEachIframeEndCallback
+   * @param {number} handled - The number of handled iframes (those who
+   * wheren't filtered)
+   */
+  /**
+   * Iterates over all iframes inside the specified context and calls the
+   * callbacks when they're ready. Filters iframes based on the instance
+   * exclusion selectors
+   * @param {HTMLElement} ctx - The context DOM element
+   * @param {DOMIterator~forEachIframeFilterCallback} filter - Filter callback
+   * @param {DOMIterator~forEachIframeEachCallback} each - Each callback
+   * @param {DOMIterator~forEachIframeEndCallback} [end] - End callback
+   * @access protected
+   */
+  forEachIframe(e, t, n, r = () => {
+  }) {
+    let s = e.querySelectorAll("iframe"), i = s.length, o = 0;
+    s = Array.prototype.slice.call(s);
+    const l = () => {
+      --i <= 0 && r(o);
+    };
+    i || l(), s.forEach((c) => {
+      ie.matches(c, this.exclude) ? l() : this.onIframeReady(c, (f) => {
+        t(c) && (o++, n(f)), l();
+      }, l);
+    });
+  }
+  /**
+   * Creates a NodeIterator on the specified context
+   * @see {@link https://developer.mozilla.org/en/docs/Web/API/NodeIterator}
+   * @param {HTMLElement} ctx - The context DOM element
+   * @param {DOMIterator~whatToShow} whatToShow
+   * @param {DOMIterator~filterCb} filter
+   * @return {NodeIterator}
+   * @access protected
+   */
+  createIterator(e, t, n) {
+    return document.createNodeIterator(e, t, n, !1);
+  }
+  /**
+   * Creates an instance of DOMIterator in an iframe
+   * @param {HTMLDocument} contents - Iframe document
+   * @return {DOMIterator}
+   * @access protected
+   */
+  createInstanceOnIframe(e) {
+    return new ie(e.querySelector("html"), this.iframes);
+  }
+  /**
+   * Checks if an iframe occurs between two nodes, more specifically if an
+   * iframe occurs before the specified node and after the specified prevNode
+   * @param {HTMLElement} node - The node that should occur after the iframe
+   * @param {HTMLElement} prevNode - The node that should occur before the
+   * iframe
+   * @param {HTMLElement} ifr - The iframe to check against
+   * @return {boolean}
+   * @access protected
+   */
+  compareNodeIframe(e, t, n) {
+    const r = e.compareDocumentPosition(n), s = Node.DOCUMENT_POSITION_PRECEDING;
+    if (r & s)
+      if (t !== null) {
+        const i = t.compareDocumentPosition(n), o = Node.DOCUMENT_POSITION_FOLLOWING;
+        if (i & o)
+          return !0;
+      } else
+        return !0;
+    return !1;
+  }
+  /**
+   * @typedef {DOMIterator~getIteratorNodeReturn}
+   * @type {object.<string>}
+   * @property {HTMLElement} prevNode - The previous node or null if there is
+   * no
+   * @property {HTMLElement} node - The current node
+   */
+  /**
+   * Returns the previous and current node of the specified iterator
+   * @param {NodeIterator} itr - The iterator
+   * @return {DOMIterator~getIteratorNodeReturn}
+   * @access protected
+   */
+  getIteratorNode(e) {
+    const t = e.previousNode();
+    let n;
+    return t === null ? n = e.nextNode() : n = e.nextNode() && e.nextNode(), {
+      prevNode: t,
+      node: n
+    };
+  }
+  /**
+   * An array containing objects. The object key "val" contains an iframe
+   * DOM element. The object key "handled" contains a boolean indicating if
+   * the iframe was handled already.
+   * It wouldn't be enough to save all open or all already handled iframes.
+   * The information of open iframes is necessary because they may occur after
+   * all other text nodes (and compareNodeIframe would never be true). The
+   * information of already handled iframes is necessary as otherwise they may
+   * be handled multiple times
+   * @typedef DOMIterator~checkIframeFilterIfr
+   * @type {object[]}
+   */
+  /**
+   * Checks if an iframe wasn't handled already and if so, calls
+   * {@link DOMIterator#compareNodeIframe} to check if it should be handled.
+   * Information wheter an iframe was or wasn't handled is given within the
+   * <code>ifr</code> dictionary
+   * @param {HTMLElement} node - The node that should occur after the iframe
+   * @param {HTMLElement} prevNode - The node that should occur before the
+   * iframe
+   * @param {HTMLElement} currIfr - The iframe to check
+   * @param {DOMIterator~checkIframeFilterIfr} ifr - The iframe dictionary.
+   * Will be manipulated (by reference)
+   * @return {boolean} Returns true when it should be handled, otherwise false
+   * @access protected
+   */
+  checkIframeFilter(e, t, n, r) {
+    let s = !1, i = !1;
+    return r.forEach((o, l) => {
+      o.val === n && (s = l, i = o.handled);
+    }), this.compareNodeIframe(e, t, n) ? (s === !1 && !i ? r.push({
+      val: n,
+      handled: !0
+    }) : s !== !1 && !i && (r[s].handled = !0), !0) : (s === !1 && r.push({
+      val: n,
+      handled: !1
+    }), !1);
+  }
+  /**
+   * Creates an iterator on all open iframes in the specified array and calls
+   * the end callback when finished
+   * @param {DOMIterator~checkIframeFilterIfr} ifr
+   * @param {DOMIterator~whatToShow} whatToShow
+   * @param  {DOMIterator~forEachNodeCallback} eCb - Each callback
+   * @param {DOMIterator~filterCb} fCb
+   * @access protected
+   */
+  handleOpenIframes(e, t, n, r) {
+    e.forEach((s) => {
+      s.handled || this.getIframeContents(s.val, (i) => {
+        this.createInstanceOnIframe(i).forEachNode(
+          t,
+          n,
+          r
+        );
+      });
+    });
+  }
+  /**
+   * Iterates through all nodes in the specified context and handles iframe
+   * nodes at the correct position
+   * @param {DOMIterator~whatToShow} whatToShow
+   * @param {HTMLElement} ctx - The context
+   * @param  {DOMIterator~forEachNodeCallback} eachCb - Each callback
+   * @param {DOMIterator~filterCb} filterCb - Filter callback
+   * @param {DOMIterator~forEachNodeEndCallback} doneCb - End callback
+   * @access protected
+   */
+  iterateThroughNodes(e, t, n, r, s) {
+    const i = this.createIterator(t, e, r);
+    let o = [], l = [], c, f, p = () => ({
+      prevNode: f,
+      node: c
+    } = this.getIteratorNode(i), c);
+    for (; p(); )
+      this.iframes && this.forEachIframe(t, (v) => this.checkIframeFilter(c, f, v, o), (v) => {
+        this.createInstanceOnIframe(v).forEachNode(
+          e,
+          (y) => l.push(y),
+          r
+        );
+      }), l.push(c);
+    l.forEach((v) => {
+      n(v);
+    }), this.iframes && this.handleOpenIframes(o, e, n, r), s();
+  }
+  /**
+   * Callback for each node
+   * @callback DOMIterator~forEachNodeCallback
+   * @param {HTMLElement} node - The DOM text node element
+   */
+  /**
+   * Callback if all contexts were handled
+   * @callback DOMIterator~forEachNodeEndCallback
+   */
+  /**
+   * Iterates over all contexts and initializes
+   * {@link DOMIterator#iterateThroughNodes iterateThroughNodes} on them
+   * @param {DOMIterator~whatToShow} whatToShow
+   * @param  {DOMIterator~forEachNodeCallback} each - Each callback
+   * @param {DOMIterator~filterCb} filter - Filter callback
+   * @param {DOMIterator~forEachNodeEndCallback} done - End callback
+   * @access public
+   */
+  forEachNode(e, t, n, r = () => {
+  }) {
+    const s = this.getContexts();
+    let i = s.length;
+    i || r(), s.forEach((o) => {
+      const l = () => {
+        this.iterateThroughNodes(e, o, t, n, () => {
+          --i <= 0 && r();
+        });
+      };
+      this.iframes ? this.waitForIframes(o, l) : l();
+    });
+  }
+  /**
+   * Callback to filter nodes. Can return e.g. NodeFilter.FILTER_ACCEPT or
+   * NodeFilter.FILTER_REJECT
+   * @see {@link http://tinyurl.com/zdczmm2}
+   * @callback DOMIterator~filterCb
+   * @param {HTMLElement} node - The node to filter
+   */
+  /**
+   * @typedef DOMIterator~whatToShow
+   * @see {@link http://tinyurl.com/zfqqkx2}
+   * @type {number}
+   */
+}
+let Fn = class {
+  // eslint-disable-line no-unused-vars
+  /**
+   * @param {HTMLElement|HTMLElement[]|NodeList|string} ctx - The context DOM
+   * element, an array of DOM elements, a NodeList or a selector
+   */
+  constructor(e) {
+    this.ctx = e, this.ie = !1;
+    const t = window.navigator.userAgent;
+    (t.indexOf("MSIE") > -1 || t.indexOf("Trident") > -1) && (this.ie = !0);
+  }
+  /**
+   * Options defined by the user. They will be initialized from one of the
+   * public methods. See {@link Mark#mark}, {@link Mark#markRegExp},
+   * {@link Mark#markRanges} and {@link Mark#unmark} for option properties.
+   * @type {object}
+   * @param {object} [val] - An object that will be merged with defaults
+   * @access protected
+   */
+  set opt(e) {
+    this._opt = Object.assign({}, {
+      element: "",
+      className: "",
+      exclude: [],
+      iframes: !1,
+      iframesTimeout: 5e3,
+      separateWordSearch: !0,
+      diacritics: !0,
+      synonyms: {},
+      accuracy: "partially",
+      acrossElements: !1,
+      caseSensitive: !1,
+      ignoreJoiners: !1,
+      ignoreGroups: 0,
+      ignorePunctuation: [],
+      wildcards: "disabled",
+      each: () => {
+      },
+      noMatch: () => {
+      },
+      filter: () => !0,
+      done: () => {
+      },
+      debug: !1,
+      log: window.console
+    }, e);
+  }
+  get opt() {
+    return this._opt;
+  }
+  /**
+   * An instance of DOMIterator
+   * @type {DOMIterator}
+   * @access protected
+   */
+  get iterator() {
+    return new ie(
+      this.ctx,
+      this.opt.iframes,
+      this.opt.exclude,
+      this.opt.iframesTimeout
+    );
+  }
+  /**
+   * Logs a message if log is enabled
+   * @param {string} msg - The message to log
+   * @param {string} [level="debug"] - The log level, e.g. <code>warn</code>
+   * <code>error</code>, <code>debug</code>
+   * @access protected
+   */
+  log(e, t = "debug") {
+    const n = this.opt.log;
+    this.opt.debug && typeof n == "object" && typeof n[t] == "function" && n[t](`mark.js: ${e}`);
+  }
+  /**
+   * Escapes a string for usage within a regular expression
+   * @param {string} str - The string to escape
+   * @return {string}
+   * @access protected
+   */
+  escapeStr(e) {
+    return e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+  }
+  /**
+   * Creates a regular expression string to match the specified search
+   * term including synonyms, diacritics and accuracy if defined
+   * @param  {string} str - The search term to be used
+   * @return {string}
+   * @access protected
+   */
+  createRegExp(e) {
+    return this.opt.wildcards !== "disabled" && (e = this.setupWildcardsRegExp(e)), e = this.escapeStr(e), Object.keys(this.opt.synonyms).length && (e = this.createSynonymsRegExp(e)), (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) && (e = this.setupIgnoreJoinersRegExp(e)), this.opt.diacritics && (e = this.createDiacriticsRegExp(e)), e = this.createMergedBlanksRegExp(e), (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) && (e = this.createJoinersRegExp(e)), this.opt.wildcards !== "disabled" && (e = this.createWildcardsRegExp(e)), e = this.createAccuracyRegExp(e), e;
+  }
+  /**
+   * Creates a regular expression string to match the defined synonyms
+   * @param  {string} str - The search term to be used
+   * @return {string}
+   * @access protected
+   */
+  createSynonymsRegExp(e) {
+    const t = this.opt.synonyms, n = this.opt.caseSensitive ? "" : "i", r = this.opt.ignoreJoiners || this.opt.ignorePunctuation.length ? "\0" : "";
+    for (let s in t)
+      if (t.hasOwnProperty(s)) {
+        const i = t[s], o = this.opt.wildcards !== "disabled" ? this.setupWildcardsRegExp(s) : this.escapeStr(s), l = this.opt.wildcards !== "disabled" ? this.setupWildcardsRegExp(i) : this.escapeStr(i);
+        o !== "" && l !== "" && (e = e.replace(
+          new RegExp(
+            `(${this.escapeStr(o)}|${this.escapeStr(l)})`,
+            `gm${n}`
+          ),
+          r + `(${this.processSynomyms(o)}|${this.processSynomyms(l)})` + r
+        ));
+      }
+    return e;
+  }
+  /**
+   * Setup synonyms to work with ignoreJoiners and or ignorePunctuation
+   * @param {string} str - synonym key or value to process
+   * @return {string} - processed synonym string
+   */
+  processSynomyms(e) {
+    return (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) && (e = this.setupIgnoreJoinersRegExp(e)), e;
+  }
+  /**
+   * Sets up the regular expression string to allow later insertion of
+   * wildcard regular expression matches
+   * @param  {string} str - The search term to be used
+   * @return {string}
+   * @access protected
+   */
+  setupWildcardsRegExp(e) {
+    return e = e.replace(/(?:\\)*\?/g, (t) => t.charAt(0) === "\\" ? "?" : "
"), e.replace(/(?:\\)*\*/g, (t) => t.charAt(0) === "\\" ? "*" : "");
+  }
+  /**
+   * Sets up the regular expression string to allow later insertion of
+   * wildcard regular expression matches
+   * @param  {string} str - The search term to be used
+   * @return {string}
+   * @access protected
+   */
+  createWildcardsRegExp(e) {
+    let t = this.opt.wildcards === "withSpaces";
+    return e.replace(/\u0001/g, t ? "[\\S\\s]?" : "\\S?").replace(/\u0002/g, t ? "[\\S\\s]*?" : "\\S*");
+  }
+  /**
+   * Sets up the regular expression string to allow later insertion of
+   * designated characters (soft hyphens & zero width characters)
+   * @param  {string} str - The search term to be used
+   * @return {string}
+   * @access protected
+   */
+  setupIgnoreJoinersRegExp(e) {
+    return e.replace(/[^(|)\\]/g, (t, n, r) => {
+      let s = r.charAt(n + 1);
+      return /[(|)\\]/.test(s) || s === "" ? t : t + "\0";
+    });
+  }
+  /**
+   * Creates a regular expression string to allow ignoring of designated
+   * characters (soft hyphens, zero width characters & punctuation) based on
+   * the specified option values of <code>ignorePunctuation</code> and
+   * <code>ignoreJoiners</code>
+   * @param  {string} str - The search term to be used
+   * @return {string}
+   * @access protected
+   */
+  createJoinersRegExp(e) {
+    let t = [];
+    const n = this.opt.ignorePunctuation;
+    return Array.isArray(n) && n.length && t.push(this.escapeStr(n.join(""))), this.opt.ignoreJoiners && t.push("\\u00ad\\u200b\\u200c\\u200d"), t.length ? e.split(/\u0000+/).join(`[${t.join("")}]*`) : e;
+  }
+  /**
+   * Creates a regular expression string to match diacritics
+   * @param  {string} str - The search term to be used
+   * @return {string}
+   * @access protected
+   */
+  createDiacriticsRegExp(e) {
+    const t = this.opt.caseSensitive ? "" : "i", n = this.opt.caseSensitive ? [
+      "aàáảãạăằắẳẵặâầấẩẫậäåāą",
+      "AÀÁẢÃẠĂẰẮẲẴẶÂẦẤẨẪẬÄÅĀĄ",
+      "cçćč",
+      "CÇĆČ",
+      "dđď",
+      "DĐĎ",
+      "eèéẻẽẹêềếểễệëěēę",
+      "EÈÉẺẼẸÊỀẾỂỄỆËĚĒĘ",
+      "iìíỉĩịîïī",
+      "IÌÍỈĨỊÎÏĪ",
+      "lł",
+      "LŁ",
+      "nñňń",
+      "NÑŇŃ",
+      "oòóỏõọôồốổỗộơởỡớờợöøō",
+      "OÒÓỎÕỌÔỒỐỔỖỘƠỞỠỚỜỢÖØŌ",
+      "rř",
+      "RŘ",
+      "sšśșş",
+      "SŠŚȘŞ",
+      "tťțţ",
+      "TŤȚŢ",
+      "uùúủũụưừứửữựûüůū",
+      "UÙÚỦŨỤƯỪỨỬỮỰÛÜŮŪ",
+      "yýỳỷỹỵÿ",
+      "YÝỲỶỸỴŸ",
+      "zžżź",
+      "ZŽŻŹ"
+    ] : [
+      "aàáảãạăằắẳẵặâầấẩẫậäåāąAÀÁẢÃẠĂẰẮẲẴẶÂẦẤẨẪẬÄÅĀĄ",
+      "cçćčCÇĆČ",
+      "dđďDĐĎ",
+      "eèéẻẽẹêềếểễệëěēęEÈÉẺẼẸÊỀẾỂỄỆËĚĒĘ",
+      "iìíỉĩịîïīIÌÍỈĨỊÎÏĪ",
+      "lłLŁ",
+      "nñňńNÑŇŃ",
+      "oòóỏõọôồốổỗộơởỡớờợöøōOÒÓỎÕỌÔỒỐỔỖỘƠỞỠỚỜỢÖØŌ",
+      "rřRŘ",
+      "sšśșşSŠŚȘŞ",
+      "tťțţTŤȚŢ",
+      "uùúủũụưừứửữựûüůūUÙÚỦŨỤƯỪỨỬỮỰÛÜŮŪ",
+      "yýỳỷỹỵÿYÝỲỶỸỴŸ",
+      "zžżźZŽŻŹ"
+    ];
+    let r = [];
+    return e.split("").forEach((s) => {
+      n.every((i) => {
+        if (i.indexOf(s) !== -1) {
+          if (r.indexOf(i) > -1)
+            return !1;
+          e = e.replace(
+            new RegExp(`[${i}]`, `gm${t}`),
+            `[${i}]`
+          ), r.push(i);
+        }
+        return !0;
+      });
+    }), e;
+  }
+  /**
+   * Creates a regular expression string that merges whitespace characters
+   * including subsequent ones into a single pattern, one or multiple
+   * whitespaces
+   * @param  {string} str - The search term to be used
+   * @return {string}
+   * @access protected
+   */
+  createMergedBlanksRegExp(e) {
+    return e.replace(/[\s]+/gmi, "[\\s]+");
+  }
+  /**
+   * Creates a regular expression string to match the specified string with
+   * the defined accuracy. As in the regular expression of "exactly" can be
+   * a group containing a blank at the beginning, all regular expressions will
+   * be created with two groups. The first group can be ignored (may contain
+   * the said blank), the second contains the actual match
+   * @param  {string} str - The searm term to be used
+   * @return {str}
+   * @access protected
+   */
+  createAccuracyRegExp(e) {
+    const t = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~¡¿";
+    let n = this.opt.accuracy, r = typeof n == "string" ? n : n.value, s = typeof n == "string" ? [] : n.limiters, i = "";
+    switch (s.forEach((o) => {
+      i += `|${this.escapeStr(o)}`;
+    }), r) {
+      case "partially":
+      default:
+        return `()(${e})`;
+      case "complementary":
+        return i = "\\s" + (i || this.escapeStr(t)), `()([^${i}]*${e}[^${i}]*)`;
+      case "exactly":
+        return `(^|\\s${i})(${e})(?=$|\\s${i})`;
+    }
+  }
+  /**
+   * @typedef Mark~separatedKeywords
+   * @type {object.<string>}
+   * @property {array.<string>} keywords - The list of keywords
+   * @property {number} length - The length
+   */
+  /**
+   * Returns a list of keywords dependent on whether separate word search
+   * was defined. Also it filters empty keywords
+   * @param {array} sv - The array of keywords
+   * @return {Mark~separatedKeywords}
+   * @access protected
+   */
+  getSeparatedKeywords(e) {
+    let t = [];
+    return e.forEach((n) => {
+      this.opt.separateWordSearch ? n.split(" ").forEach((r) => {
+        r.trim() && t.indexOf(r) === -1 && t.push(r);
+      }) : n.trim() && t.indexOf(n) === -1 && t.push(n);
+    }), {
+      // sort because of https://git.io/v6USg
+      keywords: t.sort((n, r) => r.length - n.length),
+      length: t.length
+    };
+  }
+  /**
+   * Check if a value is a number
+   * @param {number|string} value - the value to check;
+   * numeric strings allowed
+   * @return {boolean}
+   * @access protected
+   */
+  isNumeric(e) {
+    return Number(parseFloat(e)) == e;
+  }
+  /**
+   * @typedef Mark~rangeObject
+   * @type {object}
+   * @property {number} start - The start position within the composite value
+   * @property {number} length - The length of the string to mark within the
+   * composite value.
+   */
+  /**
+   * @typedef Mark~setOfRanges
+   * @type {object[]}
+   * @property {Mark~rangeObject}
+   */
+  /**
+   * Returns a processed list of integer offset indexes that do not overlap
+   * each other, and remove any string values or additional elements
+   * @param {Mark~setOfRanges} array - unprocessed raw array
+   * @return {Mark~setOfRanges} - processed array with any invalid entries
+   * removed
+   * @throws Will throw an error if an array of objects is not passed
+   * @access protected
+   */
+  checkRanges(e) {
+    if (!Array.isArray(e) || Object.prototype.toString.call(e[0]) !== "[object Object]")
+      return this.log("markRanges() will only accept an array of objects"), this.opt.noMatch(e), [];
+    const t = [];
+    let n = 0;
+    return e.sort((r, s) => r.start - s.start).forEach((r) => {
+      let { start: s, end: i, valid: o } = this.callNoMatchOnInvalidRanges(r, n);
+      o && (r.start = s, r.length = i - s, t.push(r), n = i);
+    }), t;
+  }
+  /**
+   * @typedef Mark~validObject
+   * @type {object}
+   * @property {number} start - The start position within the composite value
+   * @property {number} end - The calculated end position within the composite
+   * value.
+   * @property {boolean} valid - boolean value indicating that the start and
+   * calculated end range is valid
+   */
+  /**
+    * Initial validation of ranges for markRanges. Preliminary checks are done
+    * to ensure the start and length values exist and are not zero or non-
+    * numeric
+    * @param {Mark~rangeObject} range - the current range object
+    * @param {number} last - last index of range
+    * @return {Mark~validObject}
+    * @access protected
+    */
+  callNoMatchOnInvalidRanges(e, t) {
+    let n, r, s = !1;
+    return e && typeof e.start < "u" ? (n = parseInt(e.start, 10), r = n + parseInt(e.length, 10), this.isNumeric(e.start) && this.isNumeric(e.length) && r - t > 0 && r - n > 0 ? s = !0 : (this.log(
+      `Ignoring invalid or overlapping range: ${JSON.stringify(e)}`
+    ), this.opt.noMatch(e))) : (this.log(`Ignoring invalid range: ${JSON.stringify(e)}`), this.opt.noMatch(e)), {
+      start: n,
+      end: r,
+      valid: s
+    };
+  }
+  /**
+   * Check valid range for markRanges. Check ranges with access to the context
+   * string. Range values are double checked, lengths that extend the mark
+   * beyond the string length are limitied and ranges containing only
+   * whitespace are ignored
+   * @param {Mark~rangeObject} range - the current range object
+   * @param {number} originalLength - original length of the context string
+   * @param {string} string - current content string
+   * @return {Mark~validObject}
+   * @access protected
+   */
+  checkWhitespaceRanges(e, t, n) {
+    let r, s = !0, i = n.length, o = t - i, l = parseInt(e.start, 10) - o;
+    return l = l > i ? i : l, r = l + parseInt(e.length, 10), r > i && (r = i, this.log(`End range automatically set to the max value of ${i}`)), l < 0 || r - l < 0 || l > i || r > i ? (s = !1, this.log(`Invalid range: ${JSON.stringify(e)}`), this.opt.noMatch(e)) : n.substring(l, r).replace(/\s+/g, "") === "" && (s = !1, this.log("Skipping whitespace only range: " + JSON.stringify(e)), this.opt.noMatch(e)), {
+      start: l,
+      end: r,
+      valid: s
+    };
+  }
+  /**
+   * @typedef Mark~getTextNodesDict
+   * @type {object.<string>}
+   * @property {string} value - The composite value of all text nodes
+   * @property {object[]} nodes - An array of objects
+   * @property {number} nodes.start - The start position within the composite
+   * value
+   * @property {number} nodes.end - The end position within the composite
+   * value
+   * @property {HTMLElement} nodes.node - The DOM text node element
+   */
+  /**
+   * Callback
+   * @callback Mark~getTextNodesCallback
+   * @param {Mark~getTextNodesDict}
+   */
+  /**
+   * Calls the callback with an object containing all text nodes (including
+   * iframe text nodes) with start and end positions and the composite value
+   * of them (string)
+   * @param {Mark~getTextNodesCallback} cb - Callback
+   * @access protected
+   */
+  getTextNodes(e) {
+    let t = "", n = [];
+    this.iterator.forEachNode(NodeFilter.SHOW_TEXT, (r) => {
+      n.push({
+        start: t.length,
+        end: (t += r.textContent).length,
+        node: r
+      });
+    }, (r) => this.matchesExclude(r.parentNode) ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT, () => {
+      e({
+        value: t,
+        nodes: n
+      });
+    });
+  }
+  /**
+   * Checks if an element matches any of the specified exclude selectors. Also
+   * it checks for elements in which no marks should be performed (e.g.
+   * script and style tags) and optionally already marked elements
+   * @param  {HTMLElement} el - The element to check
+   * @return {boolean}
+   * @access protected
+   */
+  matchesExclude(e) {
+    return ie.matches(e, this.opt.exclude.concat([
+      // ignores the elements itself, not their childrens (selector *)
+      "script",
+      "style",
+      "title",
+      "head",
+      "html"
+    ]));
+  }
+  /**
+   * Wraps the instance element and class around matches that fit the start
+   * and end positions within the node
+   * @param  {HTMLElement} node - The DOM text node
+   * @param  {number} start - The position where to start wrapping
+   * @param  {number} end - The position where to end wrapping
+   * @return {HTMLElement} Returns the splitted text node that will appear
+   * after the wrapped text node
+   * @access protected
+   */
+  wrapRangeInTextNode(e, t, n) {
+    const r = this.opt.element ? this.opt.element : "mark", s = e.splitText(t), i = s.splitText(n - t);
+    let o = document.createElement(r);
+    return o.setAttribute("data-markjs", "true"), this.opt.className && o.setAttribute("class", this.opt.className), o.textContent = s.textContent, s.parentNode.replaceChild(o, s), i;
+  }
+  /**
+   * @typedef Mark~wrapRangeInMappedTextNodeDict
+   * @type {object.<string>}
+   * @property {string} value - The composite value of all text nodes
+   * @property {object[]} nodes - An array of objects
+   * @property {number} nodes.start - The start position within the composite
+   * value
+   * @property {number} nodes.end - The end position within the composite
+   * value
+   * @property {HTMLElement} nodes.node - The DOM text node element
+   */
+  /**
+   * Each callback
+   * @callback Mark~wrapMatchesEachCallback
+   * @param {HTMLElement} node - The wrapped DOM element
+   * @param {number} lastIndex - The last matching position within the
+   * composite value of text nodes
+   */
+  /**
+   * Filter callback
+   * @callback Mark~wrapMatchesFilterCallback
+   * @param {HTMLElement} node - The matching text node DOM element
+   */
+  /**
+   * Determines matches by start and end positions using the text node
+   * dictionary even across text nodes and calls
+   * {@link Mark#wrapRangeInTextNode} to wrap them
+   * @param  {Mark~wrapRangeInMappedTextNodeDict} dict - The dictionary
+   * @param  {number} start - The start position of the match
+   * @param  {number} end - The end position of the match
+   * @param  {Mark~wrapMatchesFilterCallback} filterCb - Filter callback
+   * @param  {Mark~wrapMatchesEachCallback} eachCb - Each callback
+   * @access protected
+   */
+  wrapRangeInMappedTextNode(e, t, n, r, s) {
+    e.nodes.every((i, o) => {
+      const l = e.nodes[o + 1];
+      if (typeof l > "u" || l.start > t) {
+        if (!r(i.node))
+          return !1;
+        const c = t - i.start, f = (n > i.end ? i.end : n) - i.start, p = e.value.substr(0, i.start), v = e.value.substr(f + i.start);
+        if (i.node = this.wrapRangeInTextNode(i.node, c, f), e.value = p + v, e.nodes.forEach((y, S) => {
+          S >= o && (e.nodes[S].start > 0 && S !== o && (e.nodes[S].start -= f), e.nodes[S].end -= f);
+        }), n -= f, s(i.node.previousSibling, i.start), n > i.end)
+          t = i.end;
+        else
+          return !1;
+      }
+      return !0;
+    });
+  }
+  /**
+   * Filter callback before each wrapping
+   * @callback Mark~wrapMatchesFilterCallback
+   * @param {string} match - The matching string
+   * @param {HTMLElement} node - The text node where the match occurs
+   */
+  /**
+   * Callback for each wrapped element
+   * @callback Mark~wrapMatchesEachCallback
+   * @param {HTMLElement} element - The marked DOM element
+   */
+  /**
+   * Callback on end
+   * @callback Mark~wrapMatchesEndCallback
+   */
+  /**
+   * Wraps the instance element and class around matches within single HTML
+   * elements in all contexts
+   * @param {RegExp} regex - The regular expression to be searched for
+   * @param {number} ignoreGroups - A number indicating the amount of RegExp
+   * matching groups to ignore
+   * @param {Mark~wrapMatchesFilterCallback} filterCb
+   * @param {Mark~wrapMatchesEachCallback} eachCb
+   * @param {Mark~wrapMatchesEndCallback} endCb
+   * @access protected
+   */
+  wrapMatches(e, t, n, r, s) {
+    const i = t === 0 ? 0 : t + 1;
+    this.getTextNodes((o) => {
+      o.nodes.forEach((l) => {
+        l = l.node;
+        let c;
+        for (; (c = e.exec(l.textContent)) !== null && c[i] !== ""; ) {
+          if (!n(c[i], l))
+            continue;
+          let f = c.index;
+          if (i !== 0)
+            for (let p = 1; p < i; p++)
+              f += c[p].length;
+          l = this.wrapRangeInTextNode(
+            l,
+            f,
+            f + c[i].length
+          ), r(l.previousSibling), e.lastIndex = 0;
+        }
+      }), s();
+    });
+  }
+  /**
+   * Callback for each wrapped element
+   * @callback Mark~wrapMatchesAcrossElementsEachCallback
+   * @param {HTMLElement} element - The marked DOM element
+   */
+  /**
+   * Filter callback before each wrapping
+   * @callback Mark~wrapMatchesAcrossElementsFilterCallback
+   * @param {string} match - The matching string
+   * @param {HTMLElement} node - The text node where the match occurs
+   */
+  /**
+   * Callback on end
+   * @callback Mark~wrapMatchesAcrossElementsEndCallback
+   */
+  /**
+   * Wraps the instance element and class around matches across all HTML
+   * elements in all contexts
+   * @param {RegExp} regex - The regular expression to be searched for
+   * @param {number} ignoreGroups - A number indicating the amount of RegExp
+   * matching groups to ignore
+   * @param {Mark~wrapMatchesAcrossElementsFilterCallback} filterCb
+   * @param {Mark~wrapMatchesAcrossElementsEachCallback} eachCb
+   * @param {Mark~wrapMatchesAcrossElementsEndCallback} endCb
+   * @access protected
+   */
+  wrapMatchesAcrossElements(e, t, n, r, s) {
+    const i = t === 0 ? 0 : t + 1;
+    this.getTextNodes((o) => {
+      let l;
+      for (; (l = e.exec(o.value)) !== null && l[i] !== ""; ) {
+        let c = l.index;
+        if (i !== 0)
+          for (let p = 1; p < i; p++)
+            c += l[p].length;
+        const f = c + l[i].length;
+        this.wrapRangeInMappedTextNode(o, c, f, (p) => n(l[i], p), (p, v) => {
+          e.lastIndex = v, r(p);
+        });
+      }
+      s();
+    });
+  }
+  /**
+   * Callback for each wrapped element
+   * @callback Mark~wrapRangeFromIndexEachCallback
+   * @param {HTMLElement} element - The marked DOM element
+   * @param {Mark~rangeObject} range - the current range object; provided
+   * start and length values will be numeric integers modified from the
+   * provided original ranges.
+   */
+  /**
+   * Filter callback before each wrapping
+   * @callback Mark~wrapRangeFromIndexFilterCallback
+   * @param {HTMLElement} node - The text node which includes the range
+   * @param {Mark~rangeObject} range - the current range object
+   * @param {string} match - string extracted from the matching range
+   * @param {number} counter - A counter indicating the number of all marks
+   */
+  /**
+   * Callback on end
+   * @callback Mark~wrapRangeFromIndexEndCallback
+   */
+  /**
+   * Wraps the indicated ranges across all HTML elements in all contexts
+   * @param {Mark~setOfRanges} ranges
+   * @param {Mark~wrapRangeFromIndexFilterCallback} filterCb
+   * @param {Mark~wrapRangeFromIndexEachCallback} eachCb
+   * @param {Mark~wrapRangeFromIndexEndCallback} endCb
+   * @access protected
+   */
+  wrapRangeFromIndex(e, t, n, r) {
+    this.getTextNodes((s) => {
+      const i = s.value.length;
+      e.forEach((o, l) => {
+        let { start: c, end: f, valid: p } = this.checkWhitespaceRanges(
+          o,
+          i,
+          s.value
+        );
+        p && this.wrapRangeInMappedTextNode(s, c, f, (v) => t(
+          v,
+          o,
+          s.value.substring(c, f),
+          l
+        ), (v) => {
+          n(v, o);
+        });
+      }), r();
+    });
+  }
+  /**
+   * Unwraps the specified DOM node with its content (text nodes or HTML)
+   * without destroying possibly present events (using innerHTML) and
+   * normalizes the parent at the end (merge splitted text nodes)
+   * @param  {HTMLElement} node - The DOM node to unwrap
+   * @access protected
+   */
+  unwrapMatches(e) {
+    const t = e.parentNode;
+    let n = document.createDocumentFragment();
+    for (; e.firstChild; )
+      n.appendChild(e.removeChild(e.firstChild));
+    t.replaceChild(n, e), this.ie ? this.normalizeTextNode(t) : t.normalize();
+  }
+  /**
+   * Normalizes text nodes. It's a workaround for the native normalize method
+   * that has a bug in IE (see attached link). Should only be used in IE
+   * browsers as it's slower than the native method.
+   * @see {@link http://tinyurl.com/z5asa8c}
+   * @param {HTMLElement} node - The DOM node to normalize
+   * @access protected
+   */
+  normalizeTextNode(e) {
+    if (e) {
+      if (e.nodeType === 3)
+        for (; e.nextSibling && e.nextSibling.nodeType === 3; )
+          e.nodeValue += e.nextSibling.nodeValue, e.parentNode.removeChild(e.nextSibling);
+      else
+        this.normalizeTextNode(e.firstChild);
+      this.normalizeTextNode(e.nextSibling);
+    }
+  }
+  /**
+   * Callback when finished
+   * @callback Mark~commonDoneCallback
+   * @param {number} totalMatches - The number of marked elements
+   */
+  /**
+   * @typedef Mark~commonOptions
+   * @type {object.<string>}
+   * @property {string} [element="mark"] - HTML element tag name
+   * @property {string} [className] - An optional class name
+   * @property {string[]} [exclude] - An array with exclusion selectors.
+   * Elements matching those selectors will be ignored
+   * @property {boolean} [iframes=false] - Whether to search inside iframes
+   * @property {Mark~commonDoneCallback} [done]
+   * @property {boolean} [debug=false] - Wheter to log messages
+   * @property {object} [log=window.console] - Where to log messages (only if
+   * debug is true)
+   */
+  /**
+   * Callback for each marked element
+   * @callback Mark~markRegExpEachCallback
+   * @param {HTMLElement} element - The marked DOM element
+   */
+  /**
+   * Callback if there were no matches
+   * @callback Mark~markRegExpNoMatchCallback
+   * @param {RegExp} regexp - The regular expression
+   */
+  /**
+   * Callback to filter matches
+   * @callback Mark~markRegExpFilterCallback
+   * @param {HTMLElement} textNode - The text node which includes the match
+   * @param {string} match - The matching string for the RegExp
+   * @param {number} counter - A counter indicating the number of all marks
+   */
+  /**
+   * These options also include the common options from
+   * {@link Mark~commonOptions}
+   * @typedef Mark~markRegExpOptions
+   * @type {object.<string>}
+   * @property {Mark~markRegExpEachCallback} [each]
+   * @property {Mark~markRegExpNoMatchCallback} [noMatch]
+   * @property {Mark~markRegExpFilterCallback} [filter]
+   */
+  /**
+   * Marks a custom regular expression
+   * @param  {RegExp} regexp - The regular expression
+   * @param  {Mark~markRegExpOptions} [opt] - Optional options object
+   * @access public
+   */
+  markRegExp(e, t) {
+    this.opt = t, this.log(`Searching with expression "${e}"`);
+    let n = 0, r = "wrapMatches";
+    const s = (i) => {
+      n++, this.opt.each(i);
+    };
+    this.opt.acrossElements && (r = "wrapMatchesAcrossElements"), this[r](e, this.opt.ignoreGroups, (i, o) => this.opt.filter(o, i, n), s, () => {
+      n === 0 && this.opt.noMatch(e), this.opt.done(n);
+    });
+  }
+  /**
+   * Callback for each marked element
+   * @callback Mark~markEachCallback
+   * @param {HTMLElement} element - The marked DOM element
+   */
+  /**
+   * Callback if there were no matches
+   * @callback Mark~markNoMatchCallback
+   * @param {RegExp} term - The search term that was not found
+   */
+  /**
+   * Callback to filter matches
+   * @callback Mark~markFilterCallback
+   * @param {HTMLElement} textNode - The text node which includes the match
+   * @param {string} match - The matching term
+   * @param {number} totalCounter - A counter indicating the number of all
+   * marks
+   * @param {number} termCounter - A counter indicating the number of marks
+   * for the specific match
+   */
+  /**
+   * @typedef Mark~markAccuracyObject
+   * @type {object.<string>}
+   * @property {string} value - A accuracy string value
+   * @property {string[]} limiters - A custom array of limiters. For example
+   * <code>["-", ","]</code>
+   */
+  /**
+   * @typedef Mark~markAccuracySetting
+   * @type {string}
+   * @property {"partially"|"complementary"|"exactly"|Mark~markAccuracyObject}
+   * [accuracy="partially"] - Either one of the following string values:
+   * <ul>
+   *   <li><i>partially</i>: When searching for "lor" only "lor" inside
+   *   "lorem" will be marked</li>
+   *   <li><i>complementary</i>: When searching for "lor" the whole word
+   *   "lorem" will be marked</li>
+   *   <li><i>exactly</i>: When searching for "lor" only those exact words
+   *   will be marked. In this example nothing inside "lorem". This value
+   *   is equivalent to the previous option <i>wordBoundary</i></li>
+   * </ul>
+   * Or an object containing two properties:
+   * <ul>
+   *   <li><i>value</i>: One of the above named string values</li>
+   *   <li><i>limiters</i>: A custom array of string limiters for accuracy
+   *   "exactly" or "complementary"</li>
+   * </ul>
+   */
+  /**
+   * @typedef Mark~markWildcardsSetting
+   * @type {string}
+   * @property {"disabled"|"enabled"|"withSpaces"}
+   * [wildcards="disabled"] - Set to any of the following string values:
+   * <ul>
+   *   <li><i>disabled</i>: Disable wildcard usage</li>
+   *   <li><i>enabled</i>: When searching for "lor?m", the "?" will match zero
+   *   or one non-space character (e.g. "lorm", "loram", "lor3m", etc). When
+   *   searching for "lor*m", the "*" will match zero or more non-space
+   *   characters (e.g. "lorm", "loram", "lor123m", etc).</li>
+   *   <li><i>withSpaces</i>: When searching for "lor?m", the "?" will
+   *   match zero or one space or non-space character (e.g. "lor m", "loram",
+   *   etc). When searching for "lor*m", the "*" will match zero or more space
+   *   or non-space characters (e.g. "lorm", "lore et dolor ipsum", "lor: m",
+   *   etc).</li>
+   * </ul>
+   */
+  /**
+   * @typedef Mark~markIgnorePunctuationSetting
+   * @type {string[]}
+   * @property {string} The strings in this setting will contain punctuation
+   * marks that will be ignored:
+   * <ul>
+   *   <li>These punctuation marks can be between any characters, e.g. setting
+   *   this option to <code>["'"]</code> would match "Worlds", "World's" and
+   *   "Wo'rlds"</li>
+   *   <li>One or more apostrophes between the letters would still produce a
+   *   match (e.g. "W'o''r'l'd's").</li>
+   *   <li>A typical setting for this option could be as follows:
+   *   <pre>ignorePunctuation: ":;.,-–—‒_(){}[]!'\"+=".split(""),</pre> This
+   *   setting includes common punctuation as well as a minus, en-dash,
+   *   em-dash and figure-dash
+   *   ({@link https://en.wikipedia.org/wiki/Dash#Figure_dash ref}), as well
+   *   as an underscore.</li>
+   * </ul>
+   */
+  /**
+   * These options also include the common options from
+   * {@link Mark~commonOptions}
+   * @typedef Mark~markOptions
+   * @type {object.<string>}
+   * @property {boolean} [separateWordSearch=true] - Whether to search for
+   * each word separated by a blank instead of the complete term
+   * @property {boolean} [diacritics=true] - If diacritic characters should be
+   * matched. ({@link https://en.wikipedia.org/wiki/Diacritic Diacritics})
+   * @property {object} [synonyms] - An object with synonyms. The key will be
+   * a synonym for the value and the value for the key
+   * @property {Mark~markAccuracySetting} [accuracy]
+   * @property {Mark~markWildcardsSetting} [wildcards]
+   * @property {boolean} [acrossElements=false] - Whether to find matches
+   * across HTML elements. By default, only matches within single HTML
+   * elements will be found
+   * @property {boolean} [ignoreJoiners=false] - Whether to ignore word
+   * joiners inside of key words. These include soft-hyphens, zero-width
+   * space, zero-width non-joiners and zero-width joiners.
+   * @property {Mark~markIgnorePunctuationSetting} [ignorePunctuation]
+   * @property {Mark~markEachCallback} [each]
+   * @property {Mark~markNoMatchCallback} [noMatch]
+   * @property {Mark~markFilterCallback} [filter]
+   */
+  /**
+   * Marks the specified search terms
+   * @param {string|string[]} [sv] - Search value, either a search string or
+   * an array containing multiple search strings
+   * @param  {Mark~markOptions} [opt] - Optional options object
+   * @access public
+   */
+  mark(e, t) {
+    this.opt = t;
+    let n = 0, r = "wrapMatches";
+    const {
+      keywords: s,
+      length: i
+    } = this.getSeparatedKeywords(typeof e == "string" ? [e] : e), o = this.opt.caseSensitive ? "" : "i", l = (c) => {
+      let f = new RegExp(this.createRegExp(c), `gm${o}`), p = 0;
+      this.log(`Searching with expression "${f}"`), this[r](f, 1, (v, y) => this.opt.filter(y, c, n, p), (v) => {
+        p++, n++, this.opt.each(v);
+      }, () => {
+        p === 0 && this.opt.noMatch(c), s[i - 1] === c ? this.opt.done(n) : l(s[s.indexOf(c) + 1]);
+      });
+    };
+    this.opt.acrossElements && (r = "wrapMatchesAcrossElements"), i === 0 ? this.opt.done(n) : l(s[0]);
+  }
+  /**
+   * Callback for each marked element
+   * @callback Mark~markRangesEachCallback
+   * @param {HTMLElement} element - The marked DOM element
+   * @param {array} range - array of range start and end points
+   */
+  /**
+   * Callback if a processed range is invalid, out-of-bounds, overlaps another
+   * range, or only matches whitespace
+   * @callback Mark~markRangesNoMatchCallback
+   * @param {Mark~rangeObject} range - a range object
+   */
+  /**
+   * Callback to filter matches
+   * @callback Mark~markRangesFilterCallback
+   * @param {HTMLElement} node - The text node which includes the range
+   * @param {array} range - array of range start and end points
+   * @param {string} match - string extracted from the matching range
+   * @param {number} counter - A counter indicating the number of all marks
+   */
+  /**
+   * These options also include the common options from
+   * {@link Mark~commonOptions}
+   * @typedef Mark~markRangesOptions
+   * @type {object.<string>}
+   * @property {Mark~markRangesEachCallback} [each]
+   * @property {Mark~markRangesNoMatchCallback} [noMatch]
+   * @property {Mark~markRangesFilterCallback} [filter]
+   */
+  /**
+   * Marks an array of objects containing a start with an end or length of the
+   * string to mark
+   * @param  {Mark~setOfRanges} rawRanges - The original (preprocessed)
+   * array of objects
+   * @param  {Mark~markRangesOptions} [opt] - Optional options object
+   * @access public
+   */
+  markRanges(e, t) {
+    this.opt = t;
+    let n = 0, r = this.checkRanges(e);
+    r && r.length ? (this.log(
+      "Starting to mark with the following ranges: " + JSON.stringify(r)
+    ), this.wrapRangeFromIndex(
+      r,
+      (s, i, o, l) => this.opt.filter(s, i, o, l),
+      (s, i) => {
+        n++, this.opt.each(s, i);
+      },
+      () => {
+        this.opt.done(n);
+      }
+    )) : this.opt.done(n);
+  }
+  /**
+   * Removes all marked elements inside the context with their HTML and
+   * normalizes the parent at the end
+   * @param  {Mark~commonOptions} [opt] - Optional options object
+   * @access public
+   */
+  unmark(e) {
+    this.opt = e;
+    let t = this.opt.element ? this.opt.element : "*";
+    t += "[data-markjs]", this.opt.className && (t += `.${this.opt.className}`), this.log(`Removal selector "${t}"`), this.iterator.forEachNode(NodeFilter.SHOW_ELEMENT, (n) => {
+      this.unwrapMatches(n);
+    }, (n) => {
+      const r = ie.matches(n, t), s = this.matchesExclude(n);
+      return !r || s ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT;
+    }, this.opt.done);
+  }
+};
+function Rn(a) {
+  const e = new Fn(a);
+  return this.mark = (t, n) => (e.mark(t, n), this), this.markRegExp = (t, n) => (e.markRegExp(t, n), this), this.markRanges = (t, n) => (e.markRanges(t, n), this), this.unmark = (t) => (e.unmark(t), this), this;
+}
+const An = "ENTRIES", gt = "KEYS", bt = "VALUES", M = "";
+class Re {
+  constructor(e, t) {
+    const n = e._tree, r = Array.from(n.keys());
+    this.set = e, this._type = t, this._path = r.length > 0 ? [{ node: n, keys: r }] : [];
+  }
+  next() {
+    const e = this.dive();
+    return this.backtrack(), e;
+  }
+  dive() {
+    if (this._path.length === 0)
+      return { done: !0, value: void 0 };
+    const { node: e, keys: t } = ne(this._path);
+    if (ne(t) === M)
+      return { done: !1, value: this.result() };
+    const n = e.get(ne(t));
+    return this._path.push({ node: n, keys: Array.from(n.keys()) }), this.dive();
+  }
+  backtrack() {
+    if (this._path.length === 0)
+      return;
+    const e = ne(this._path).keys;
+    e.pop(), !(e.length > 0) && (this._path.pop(), this.backtrack());
+  }
+  key() {
+    return this.set._prefix + this._path.map(({ keys: e }) => ne(e)).filter((e) => e !== M).join("");
+  }
+  value() {
+    return ne(this._path).node.get(M);
+  }
+  result() {
+    switch (this._type) {
+      case bt:
+        return this.value();
+      case gt:
+        return this.key();
+      default:
+        return [this.key(), this.value()];
+    }
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+const ne = (a) => a[a.length - 1], On = (a, e, t) => {
+  const n = /* @__PURE__ */ new Map();
+  if (e === void 0)
+    return n;
+  const r = e.length + 1, s = r + t, i = new Uint8Array(s * r).fill(t + 1);
+  for (let o = 0; o < r; ++o)
+    i[o] = o;
+  for (let o = 1; o < s; ++o)
+    i[o * r] = o;
+  return yt(a, e, t, n, i, 1, r, ""), n;
+}, yt = (a, e, t, n, r, s, i, o) => {
+  const l = s * i;
+  e: for (const c of a.keys())
+    if (c === M) {
+      const f = r[l - 1];
+      f <= t && n.set(o, [a.get(c), f]);
+    } else {
+      let f = s;
+      for (let p = 0; p < c.length; ++p, ++f) {
+        const v = c[p], y = i * f, S = y - i;
+        let w = r[y];
+        const _ = Math.max(0, f - t - 1), N = Math.min(i - 1, f + t);
+        for (let F = _; F < N; ++F) {
+          const G = v !== e[F], z = r[S + F] + +G, j = r[S + F + 1] + 1, L = r[y + F] + 1, V = r[y + F + 1] = Math.min(z, j, L);
+          V < w && (w = V);
+        }
+        if (w > t)
+          continue e;
+      }
+      yt(a.get(c), e, t, n, r, f, i, o + c);
+    }
+};
+class q {
+  /**
+   * The constructor is normally called without arguments, creating an empty
+   * map. In order to create a {@link SearchableMap} from an iterable or from an
+   * object, check {@link SearchableMap.from} and {@link
+   * SearchableMap.fromObject}.
+   *
+   * The constructor arguments are for internal use, when creating derived
+   * mutable views of a map at a prefix.
+   */
+  constructor(e = /* @__PURE__ */ new Map(), t = "") {
+    this._size = void 0, this._tree = e, this._prefix = t;
+  }
+  /**
+   * Creates and returns a mutable view of this {@link SearchableMap},
+   * containing only entries that share the given prefix.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * let map = new SearchableMap()
+   * map.set("unicorn", 1)
+   * map.set("universe", 2)
+   * map.set("university", 3)
+   * map.set("unique", 4)
+   * map.set("hello", 5)
+   *
+   * let uni = map.atPrefix("uni")
+   * uni.get("unique") // => 4
+   * uni.get("unicorn") // => 1
+   * uni.get("hello") // => undefined
+   *
+   * let univer = map.atPrefix("univer")
+   * univer.get("unique") // => undefined
+   * univer.get("universe") // => 2
+   * univer.get("university") // => 3
+   * ```
+   *
+   * @param prefix  The prefix
+   * @return A {@link SearchableMap} representing a mutable view of the original
+   * Map at the given prefix
+   */
+  atPrefix(e) {
+    if (!e.startsWith(this._prefix))
+      throw new Error("Mismatched prefix");
+    const [t, n] = ke(this._tree, e.slice(this._prefix.length));
+    if (t === void 0) {
+      const [r, s] = $e(n);
+      for (const i of r.keys())
+        if (i !== M && i.startsWith(s)) {
+          const o = /* @__PURE__ */ new Map();
+          return o.set(i.slice(s.length), r.get(i)), new q(o, e);
+        }
+    }
+    return new q(t, e);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear
+   */
+  clear() {
+    this._size = void 0, this._tree.clear();
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete
+   * @param key  Key to delete
+   */
+  delete(e) {
+    return this._size = void 0, Cn(this._tree, e);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries
+   * @return An iterator iterating through `[key, value]` entries.
+   */
+  entries() {
+    return new Re(this, An);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach
+   * @param fn  Iteration function
+   */
+  forEach(e) {
+    for (const [t, n] of this)
+      e(t, n, this);
+  }
+  /**
+   * Returns a Map of all the entries that have a key within the given edit
+   * distance from the search key. The keys of the returned Map are the matching
+   * keys, while the values are two-element arrays where the first element is
+   * the value associated to the key, and the second is the edit distance of the
+   * key to the search key.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * let map = new SearchableMap()
+   * map.set('hello', 'world')
+   * map.set('hell', 'yeah')
+   * map.set('ciao', 'mondo')
+   *
+   * // Get all entries that match the key 'hallo' with a maximum edit distance of 2
+   * map.fuzzyGet('hallo', 2)
+   * // => Map(2) { 'hello' => ['world', 1], 'hell' => ['yeah', 2] }
+   *
+   * // In the example, the "hello" key has value "world" and edit distance of 1
+   * // (change "e" to "a"), the key "hell" has value "yeah" and edit distance of 2
+   * // (change "e" to "a", delete "o")
+   * ```
+   *
+   * @param key  The search key
+   * @param maxEditDistance  The maximum edit distance (Levenshtein)
+   * @return A Map of the matching keys to their value and edit distance
+   */
+  fuzzyGet(e, t) {
+    return On(this._tree, e, t);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get
+   * @param key  Key to get
+   * @return Value associated to the key, or `undefined` if the key is not
+   * found.
+   */
+  get(e) {
+    const t = ze(this._tree, e);
+    return t !== void 0 ? t.get(M) : void 0;
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has
+   * @param key  Key
+   * @return True if the key is in the map, false otherwise
+   */
+  has(e) {
+    const t = ze(this._tree, e);
+    return t !== void 0 && t.has(M);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys
+   * @return An `Iterable` iterating through keys
+   */
+  keys() {
+    return new Re(this, gt);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set
+   * @param key  Key to set
+   * @param value  Value to associate to the key
+   * @return The {@link SearchableMap} itself, to allow chaining
+   */
+  set(e, t) {
+    if (typeof e != "string")
+      throw new Error("key must be a string");
+    return this._size = void 0, Ae(this._tree, e).set(M, t), this;
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size
+   */
+  get size() {
+    if (this._size)
+      return this._size;
+    this._size = 0;
+    const e = this.entries();
+    for (; !e.next().done; )
+      this._size += 1;
+    return this._size;
+  }
+  /**
+   * Updates the value at the given key using the provided function. The function
+   * is called with the current value at the key, and its return value is used as
+   * the new value to be set.
+   *
+   * ### Example:
+   *
+   * ```javascript
+   * // Increment the current value by one
+   * searchableMap.update('somekey', (currentValue) => currentValue == null ? 0 : currentValue + 1)
+   * ```
+   *
+   * If the value at the given key is or will be an object, it might not require
+   * re-assignment. In that case it is better to use `fetch()`, because it is
+   * faster.
+   *
+   * @param key  The key to update
+   * @param fn  The function used to compute the new value from the current one
+   * @return The {@link SearchableMap} itself, to allow chaining
+   */
+  update(e, t) {
+    if (typeof e != "string")
+      throw new Error("key must be a string");
+    this._size = void 0;
+    const n = Ae(this._tree, e);
+    return n.set(M, t(n.get(M))), this;
+  }
+  /**
+   * Fetches the value of the given key. If the value does not exist, calls the
+   * given function to create a new value, which is inserted at the given key
+   * and subsequently returned.
+   *
+   * ### Example:
+   *
+   * ```javascript
+   * const map = searchableMap.fetch('somekey', () => new Map())
+   * map.set('foo', 'bar')
+   * ```
+   *
+   * @param key  The key to update
+   * @param initial  A function that creates a new value if the key does not exist
+   * @return The existing or new value at the given key
+   */
+  fetch(e, t) {
+    if (typeof e != "string")
+      throw new Error("key must be a string");
+    this._size = void 0;
+    const n = Ae(this._tree, e);
+    let r = n.get(M);
+    return r === void 0 && n.set(M, r = t()), r;
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values
+   * @return An `Iterable` iterating through values.
+   */
+  values() {
+    return new Re(this, bt);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@iterator
+   */
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  /**
+   * Creates a {@link SearchableMap} from an `Iterable` of entries
+   *
+   * @param entries  Entries to be inserted in the {@link SearchableMap}
+   * @return A new {@link SearchableMap} with the given entries
+   */
+  static from(e) {
+    const t = new q();
+    for (const [n, r] of e)
+      t.set(n, r);
+    return t;
+  }
+  /**
+   * Creates a {@link SearchableMap} from the iterable properties of a JavaScript object
+   *
+   * @param object  Object of entries for the {@link SearchableMap}
+   * @return A new {@link SearchableMap} with the given entries
+   */
+  static fromObject(e) {
+    return q.from(Object.entries(e));
+  }
+}
+const ke = (a, e, t = []) => {
+  if (e.length === 0 || a == null)
+    return [a, t];
+  for (const n of a.keys())
+    if (n !== M && e.startsWith(n))
+      return t.push([a, n]), ke(a.get(n), e.slice(n.length), t);
+  return t.push([a, e]), ke(void 0, "", t);
+}, ze = (a, e) => {
+  if (e.length === 0 || a == null)
+    return a;
+  for (const t of a.keys())
+    if (t !== M && e.startsWith(t))
+      return ze(a.get(t), e.slice(t.length));
+}, Ae = (a, e) => {
+  const t = e.length;
+  e: for (let n = 0; a && n < t; ) {
+    for (const s of a.keys())
+      if (s !== M && e[n] === s[0]) {
+        const i = Math.min(t - n, s.length);
+        let o = 1;
+        for (; o < i && e[n + o] === s[o]; )
+          ++o;
+        const l = a.get(s);
+        if (o === s.length)
+          a = l;
+        else {
+          const c = /* @__PURE__ */ new Map();
+          c.set(s.slice(o), l), a.set(e.slice(n, n + o), c), a.delete(s), a = c;
+        }
+        n += o;
+        continue e;
+      }
+    const r = /* @__PURE__ */ new Map();
+    return a.set(e.slice(n), r), r;
+  }
+  return a;
+}, Cn = (a, e) => {
+  const [t, n] = ke(a, e);
+  if (t !== void 0) {
+    if (t.delete(M), t.size === 0)
+      wt(n);
+    else if (t.size === 1) {
+      const [r, s] = t.entries().next().value;
+      St(n, r, s);
+    }
+  }
+}, wt = (a) => {
+  if (a.length === 0)
+    return;
+  const [e, t] = $e(a);
+  if (e.delete(t), e.size === 0)
+    wt(a.slice(0, -1));
+  else if (e.size === 1) {
+    const [n, r] = e.entries().next().value;
+    n !== M && St(a.slice(0, -1), n, r);
+  }
+}, St = (a, e, t) => {
+  if (a.length === 0)
+    return;
+  const [n, r] = $e(a);
+  n.set(r + e, t), n.delete(r);
+}, $e = (a) => a[a.length - 1], Be = "or", _t = "and", Mn = "and_not";
+class re {
+  /**
+   * @param options  Configuration options
+   *
+   * ### Examples:
+   *
+   * ```javascript
+   * // Create a search engine that indexes the 'title' and 'text' fields of your
+   * // documents:
+   * const miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+   * ```
+   *
+   * ### ID Field:
+   *
+   * ```javascript
+   * // Your documents are assumed to include a unique 'id' field, but if you want
+   * // to use a different field for document identification, you can set the
+   * // 'idField' option:
+   * const miniSearch = new MiniSearch({ idField: 'key', fields: ['title', 'text'] })
+   * ```
+   *
+   * ### Options and defaults:
+   *
+   * ```javascript
+   * // The full set of options (here with their default value) is:
+   * const miniSearch = new MiniSearch({
+   *   // idField: field that uniquely identifies a document
+   *   idField: 'id',
+   *
+   *   // extractField: function used to get the value of a field in a document.
+   *   // By default, it assumes the document is a flat object with field names as
+   *   // property keys and field values as string property values, but custom logic
+   *   // can be implemented by setting this option to a custom extractor function.
+   *   extractField: (document, fieldName) => document[fieldName],
+   *
+   *   // tokenize: function used to split fields into individual terms. By
+   *   // default, it is also used to tokenize search queries, unless a specific
+   *   // `tokenize` search option is supplied. When tokenizing an indexed field,
+   *   // the field name is passed as the second argument.
+   *   tokenize: (string, _fieldName) => string.split(SPACE_OR_PUNCTUATION),
+   *
+   *   // processTerm: function used to process each tokenized term before
+   *   // indexing. It can be used for stemming and normalization. Return a falsy
+   *   // value in order to discard a term. By default, it is also used to process
+   *   // search queries, unless a specific `processTerm` option is supplied as a
+   *   // search option. When processing a term from a indexed field, the field
+   *   // name is passed as the second argument.
+   *   processTerm: (term, _fieldName) => term.toLowerCase(),
+   *
+   *   // searchOptions: default search options, see the `search` method for
+   *   // details
+   *   searchOptions: undefined,
+   *
+   *   // fields: document fields to be indexed. Mandatory, but not set by default
+   *   fields: undefined
+   *
+   *   // storeFields: document fields to be stored and returned as part of the
+   *   // search results.
+   *   storeFields: []
+   * })
+   * ```
+   */
+  constructor(e) {
+    if (e?.fields == null)
+      throw new Error('MiniSearch: option "fields" must be provided');
+    const t = e.autoVacuum == null || e.autoVacuum === !0 ? Me : e.autoVacuum;
+    this._options = {
+      ...Ce,
+      ...e,
+      autoVacuum: t,
+      searchOptions: { ...st, ...e.searchOptions || {} },
+      autoSuggestOptions: { ...Vn, ...e.autoSuggestOptions || {} }
+    }, this._index = new q(), this._documentCount = 0, this._documentIds = /* @__PURE__ */ new Map(), this._idToShortId = /* @__PURE__ */ new Map(), this._fieldIds = {}, this._fieldLength = /* @__PURE__ */ new Map(), this._avgFieldLength = [], this._nextId = 0, this._storedFields = /* @__PURE__ */ new Map(), this._dirtCount = 0, this._currentVacuum = null, this._enqueuedVacuum = null, this._enqueuedVacuumConditions = je, this.addFields(this._options.fields);
+  }
+  /**
+   * Adds a document to the index
+   *
+   * @param document  The document to be indexed
+   */
+  add(e) {
+    const { extractField: t, stringifyField: n, tokenize: r, processTerm: s, fields: i, idField: o } = this._options, l = t(e, o);
+    if (l == null)
+      throw new Error(`MiniSearch: document does not have ID field "${o}"`);
+    if (this._idToShortId.has(l))
+      throw new Error(`MiniSearch: duplicate ID ${l}`);
+    const c = this.addDocumentId(l);
+    this.saveStoredFields(c, e);
+    for (const f of i) {
+      const p = t(e, f);
+      if (p == null)
+        continue;
+      const v = r(n(p, f), f), y = this._fieldIds[f], S = new Set(v).size;
+      this.addFieldLength(c, y, this._documentCount - 1, S);
+      for (const w of v) {
+        const _ = s(w, f);
+        if (Array.isArray(_))
+          for (const N of _)
+            this.addTerm(y, c, N);
+        else _ && this.addTerm(y, c, _);
+      }
+    }
+  }
+  /**
+   * Adds all the given documents to the index
+   *
+   * @param documents  An array of documents to be indexed
+   */
+  addAll(e) {
+    for (const t of e)
+      this.add(t);
+  }
+  /**
+   * Adds all the given documents to the index asynchronously.
+   *
+   * Returns a promise that resolves (to `undefined`) when the indexing is done.
+   * This method is useful when index many documents, to avoid blocking the main
+   * thread. The indexing is performed asynchronously and in chunks.
+   *
+   * @param documents  An array of documents to be indexed
+   * @param options  Configuration options
+   * @return A promise resolving to `undefined` when the indexing is done
+   */
+  addAllAsync(e, t = {}) {
+    const { chunkSize: n = 10 } = t, r = { chunk: [], promise: Promise.resolve() }, { chunk: s, promise: i } = e.reduce(({ chunk: o, promise: l }, c, f) => (o.push(c), (f + 1) % n === 0 ? {
+      chunk: [],
+      promise: l.then(() => new Promise((p) => setTimeout(p, 0))).then(() => this.addAll(o))
+    } : { chunk: o, promise: l }), r);
+    return i.then(() => this.addAll(s));
+  }
+  /**
+   * Removes the given document from the index.
+   *
+   * The document to remove must NOT have changed between indexing and removal,
+   * otherwise the index will be corrupted.
+   *
+   * This method requires passing the full document to be removed (not just the
+   * ID), and immediately removes the document from the inverted index, allowing
+   * memory to be released. A convenient alternative is {@link
+   * MiniSearch#discard}, which needs only the document ID, and has the same
+   * visible effect, but delays cleaning up the index until the next vacuuming.
+   *
+   * @param document  The document to be removed
+   */
+  remove(e) {
+    const { tokenize: t, processTerm: n, extractField: r, stringifyField: s, fields: i, idField: o } = this._options, l = r(e, o);
+    if (l == null)
+      throw new Error(`MiniSearch: document does not have ID field "${o}"`);
+    const c = this._idToShortId.get(l);
+    if (c == null)
+      throw new Error(`MiniSearch: cannot remove document with ID ${l}: it is not in the index`);
+    for (const f of i) {
+      const p = r(e, f);
+      if (p == null)
+        continue;
+      const v = t(s(p, f), f), y = this._fieldIds[f], S = new Set(v).size;
+      this.removeFieldLength(c, y, this._documentCount, S);
+      for (const w of v) {
+        const _ = n(w, f);
+        if (Array.isArray(_))
+          for (const N of _)
+            this.removeTerm(y, c, N);
+        else _ && this.removeTerm(y, c, _);
+      }
+    }
+    this._storedFields.delete(c), this._documentIds.delete(c), this._idToShortId.delete(l), this._fieldLength.delete(c), this._documentCount -= 1;
+  }
+  /**
+   * Removes all the given documents from the index. If called with no arguments,
+   * it removes _all_ documents from the index.
+   *
+   * @param documents  The documents to be removed. If this argument is omitted,
+   * all documents are removed. Note that, for removing all documents, it is
+   * more efficient to call this method with no arguments than to pass all
+   * documents.
+   */
+  removeAll(e) {
+    if (e)
+      for (const t of e)
+        this.remove(t);
+    else {
+      if (arguments.length > 0)
+        throw new Error("Expected documents to be present. Omit the argument to remove all documents.");
+      this._index = new q(), this._documentCount = 0, this._documentIds = /* @__PURE__ */ new Map(), this._idToShortId = /* @__PURE__ */ new Map(), this._fieldLength = /* @__PURE__ */ new Map(), this._avgFieldLength = [], this._storedFields = /* @__PURE__ */ new Map(), this._nextId = 0;
+    }
+  }
+  /**
+   * Discards the document with the given ID, so it won't appear in search results
+   *
+   * It has the same visible effect of {@link MiniSearch.remove} (both cause the
+   * document to stop appearing in searches), but a different effect on the
+   * internal data structures:
+   *
+   *   - {@link MiniSearch#remove} requires passing the full document to be
+   *   removed as argument, and removes it from the inverted index immediately.
+   *
+   *   - {@link MiniSearch#discard} instead only needs the document ID, and
+   *   works by marking the current version of the document as discarded, so it
+   *   is immediately ignored by searches. This is faster and more convenient
+   *   than {@link MiniSearch#remove}, but the index is not immediately
+   *   modified. To take care of that, vacuuming is performed after a certain
+   *   number of documents are discarded, cleaning up the index and allowing
+   *   memory to be released.
+   *
+   * After discarding a document, it is possible to re-add a new version, and
+   * only the new version will appear in searches. In other words, discarding
+   * and re-adding a document works exactly like removing and re-adding it. The
+   * {@link MiniSearch.replace} method can also be used to replace a document
+   * with a new version.
+   *
+   * #### Details about vacuuming
+   *
+   * Repetite calls to this method would leave obsolete document references in
+   * the index, invisible to searches. Two mechanisms take care of cleaning up:
+   * clean up during search, and vacuuming.
+   *
+   *   - Upon search, whenever a discarded ID is found (and ignored for the
+   *   results), references to the discarded document are removed from the
+   *   inverted index entries for the search terms. This ensures that subsequent
+   *   searches for the same terms do not need to skip these obsolete references
+   *   again.
+   *
+   *   - In addition, vacuuming is performed automatically by default (see the
+   *   `autoVacuum` field in {@link Options}) after a certain number of
+   *   documents are discarded. Vacuuming traverses all terms in the index,
+   *   cleaning up all references to discarded documents. Vacuuming can also be
+   *   triggered manually by calling {@link MiniSearch#vacuum}.
+   *
+   * @param id  The ID of the document to be discarded
+   */
+  discard(e) {
+    const t = this._idToShortId.get(e);
+    if (t == null)
+      throw new Error(`MiniSearch: cannot discard document with ID ${e}: it is not in the index`);
+    this._idToShortId.delete(e), this._documentIds.delete(t), this._storedFields.delete(t), (this._fieldLength.get(t) || []).forEach((n, r) => {
+      this.removeFieldLength(t, r, this._documentCount, n);
+    }), this._fieldLength.delete(t), this._documentCount -= 1, this._dirtCount += 1, this.maybeAutoVacuum();
+  }
+  maybeAutoVacuum() {
+    if (this._options.autoVacuum === !1)
+      return;
+    const { minDirtFactor: e, minDirtCount: t, batchSize: n, batchWait: r } = this._options.autoVacuum;
+    this.conditionalVacuum({ batchSize: n, batchWait: r }, { minDirtCount: t, minDirtFactor: e });
+  }
+  /**
+   * Discards the documents with the given IDs, so they won't appear in search
+   * results
+   *
+   * It is equivalent to calling {@link MiniSearch#discard} for all the given
+   * IDs, but with the optimization of triggering at most one automatic
+   * vacuuming at the end.
+   *
+   * Note: to remove all documents from the index, it is faster and more
+   * convenient to call {@link MiniSearch.removeAll} with no argument, instead
+   * of passing all IDs to this method.
+   */
+  discardAll(e) {
+    const t = this._options.autoVacuum;
+    try {
+      this._options.autoVacuum = !1;
+      for (const n of e)
+        this.discard(n);
+    } finally {
+      this._options.autoVacuum = t;
+    }
+    this.maybeAutoVacuum();
+  }
+  /**
+   * It replaces an existing document with the given updated version
+   *
+   * It works by discarding the current version and adding the updated one, so
+   * it is functionally equivalent to calling {@link MiniSearch#discard}
+   * followed by {@link MiniSearch#add}. The ID of the updated document should
+   * be the same as the original one.
+   *
+   * Since it uses {@link MiniSearch#discard} internally, this method relies on
+   * vacuuming to clean up obsolete document references from the index, allowing
+   * memory to be released (see {@link MiniSearch#discard}).
+   *
+   * @param updatedDocument  The updated document to replace the old version
+   * with
+   */
+  replace(e) {
+    const { idField: t, extractField: n } = this._options, r = n(e, t);
+    this.discard(r), this.add(e);
+  }
+  /**
+   * Triggers a manual vacuuming, cleaning up references to discarded documents
+   * from the inverted index
+   *
+   * Vacuuming is only useful for applications that use the {@link
+   * MiniSearch#discard} or {@link MiniSearch#replace} methods.
+   *
+   * By default, vacuuming is performed automatically when needed (controlled by
+   * the `autoVacuum` field in {@link Options}), so there is usually no need to
+   * call this method, unless one wants to make sure to perform vacuuming at a
+   * specific moment.
+   *
+   * Vacuuming traverses all terms in the inverted index in batches, and cleans
+   * up references to discarded documents from the posting list, allowing memory
+   * to be released.
+   *
+   * The method takes an optional object as argument with the following keys:
+   *
+   *   - `batchSize`: the size of each batch (1000 by default)
+   *
+   *   - `batchWait`: the number of milliseconds to wait between batches (10 by
+   *   default)
+   *
+   * On large indexes, vacuuming could have a non-negligible cost: batching
+   * avoids blocking the thread for long, diluting this cost so that it is not
+   * negatively affecting the application. Nonetheless, this method should only
+   * be called when necessary, and relying on automatic vacuuming is usually
+   * better.
+   *
+   * It returns a promise that resolves (to undefined) when the clean up is
+   * completed. If vacuuming is already ongoing at the time this method is
+   * called, a new one is enqueued immediately after the ongoing one, and a
+   * corresponding promise is returned. However, no more than one vacuuming is
+   * enqueued on top of the ongoing one, even if this method is called more
+   * times (enqueuing multiple ones would be useless).
+   *
+   * @param options  Configuration options for the batch size and delay. See
+   * {@link VacuumOptions}.
+   */
+  vacuum(e = {}) {
+    return this.conditionalVacuum(e);
+  }
+  conditionalVacuum(e, t) {
+    return this._currentVacuum ? (this._enqueuedVacuumConditions = this._enqueuedVacuumConditions && t, this._enqueuedVacuum != null ? this._enqueuedVacuum : (this._enqueuedVacuum = this._currentVacuum.then(() => {
+      const n = this._enqueuedVacuumConditions;
+      return this._enqueuedVacuumConditions = je, this.performVacuuming(e, n);
+    }), this._enqueuedVacuum)) : this.vacuumConditionsMet(t) === !1 ? Promise.resolve() : (this._currentVacuum = this.performVacuuming(e), this._currentVacuum);
+  }
+  async performVacuuming(e, t) {
+    const n = this._dirtCount;
+    if (this.vacuumConditionsMet(t)) {
+      const r = e.batchSize || Ve.batchSize, s = e.batchWait || Ve.batchWait;
+      let i = 1;
+      for (const [o, l] of this._index) {
+        for (const [c, f] of l)
+          for (const [p] of f)
+            this._documentIds.has(p) || (f.size <= 1 ? l.delete(c) : f.delete(p));
+        this._index.get(o).size === 0 && this._index.delete(o), i % r === 0 && await new Promise((c) => setTimeout(c, s)), i += 1;
+      }
+      this._dirtCount -= n;
+    }
+    await null, this._currentVacuum = this._enqueuedVacuum, this._enqueuedVacuum = null;
+  }
+  vacuumConditionsMet(e) {
+    if (e == null)
+      return !0;
+    let { minDirtCount: t, minDirtFactor: n } = e;
+    return t = t || Me.minDirtCount, n = n || Me.minDirtFactor, this.dirtCount >= t && this.dirtFactor >= n;
+  }
+  /**
+   * Is `true` if a vacuuming operation is ongoing, `false` otherwise
+   */
+  get isVacuuming() {
+    return this._currentVacuum != null;
+  }
+  /**
+   * The number of documents discarded since the most recent vacuuming
+   */
+  get dirtCount() {
+    return this._dirtCount;
+  }
+  /**
+   * A number between 0 and 1 giving an indication about the proportion of
+   * documents that are discarded, and can therefore be cleaned up by vacuuming.
+   * A value close to 0 means that the index is relatively clean, while a higher
+   * value means that the index is relatively dirty, and vacuuming could release
+   * memory.
+   */
+  get dirtFactor() {
+    return this._dirtCount / (1 + this._documentCount + this._dirtCount);
+  }
+  /**
+   * Returns `true` if a document with the given ID is present in the index and
+   * available for search, `false` otherwise
+   *
+   * @param id  The document ID
+   */
+  has(e) {
+    return this._idToShortId.has(e);
+  }
+  /**
+   * Returns the stored fields (as configured in the `storeFields` constructor
+   * option) for the given document ID. Returns `undefined` if the document is
+   * not present in the index.
+   *
+   * @param id  The document ID
+   */
+  getStoredFields(e) {
+    const t = this._idToShortId.get(e);
+    if (t != null)
+      return this._storedFields.get(t);
+  }
+  /**
+   * Search for documents matching the given search query.
+   *
+   * The result is a list of scored document IDs matching the query, sorted by
+   * descending score, and each including data about which terms were matched and
+   * in which fields.
+   *
+   * ### Basic usage:
+   *
+   * ```javascript
+   * // Search for "zen art motorcycle" with default options: terms have to match
+   * // exactly, and individual terms are joined with OR
+   * miniSearch.search('zen art motorcycle')
+   * // => [ { id: 2, score: 2.77258, match: { ... } }, { id: 4, score: 1.38629, match: { ... } } ]
+   * ```
+   *
+   * ### Restrict search to specific fields:
+   *
+   * ```javascript
+   * // Search only in the 'title' field
+   * miniSearch.search('zen', { fields: ['title'] })
+   * ```
+   *
+   * ### Field boosting:
+   *
+   * ```javascript
+   * // Boost a field
+   * miniSearch.search('zen', { boost: { title: 2 } })
+   * ```
+   *
+   * ### Prefix search:
+   *
+   * ```javascript
+   * // Search for "moto" with prefix search (it will match documents
+   * // containing terms that start with "moto" or "neuro")
+   * miniSearch.search('moto neuro', { prefix: true })
+   * ```
+   *
+   * ### Fuzzy search:
+   *
+   * ```javascript
+   * // Search for "ismael" with fuzzy search (it will match documents containing
+   * // terms similar to "ismael", with a maximum edit distance of 0.2 term.length
+   * // (rounded to nearest integer)
+   * miniSearch.search('ismael', { fuzzy: 0.2 })
+   * ```
+   *
+   * ### Combining strategies:
+   *
+   * ```javascript
+   * // Mix of exact match, prefix search, and fuzzy search
+   * miniSearch.search('ismael mob', {
+   *  prefix: true,
+   *  fuzzy: 0.2
+   * })
+   * ```
+   *
+   * ### Advanced prefix and fuzzy search:
+   *
+   * ```javascript
+   * // Perform fuzzy and prefix search depending on the search term. Here
+   * // performing prefix and fuzzy search only on terms longer than 3 characters
+   * miniSearch.search('ismael mob', {
+   *  prefix: term => term.length > 3
+   *  fuzzy: term => term.length > 3 ? 0.2 : null
+   * })
+   * ```
+   *
+   * ### Combine with AND:
+   *
+   * ```javascript
+   * // Combine search terms with AND (to match only documents that contain both
+   * // "motorcycle" and "art")
+   * miniSearch.search('motorcycle art', { combineWith: 'AND' })
+   * ```
+   *
+   * ### Combine with AND_NOT:
+   *
+   * There is also an AND_NOT combinator, that finds documents that match the
+   * first term, but do not match any of the other terms. This combinator is
+   * rarely useful with simple queries, and is meant to be used with advanced
+   * query combinations (see later for more details).
+   *
+   * ### Filtering results:
+   *
+   * ```javascript
+   * // Filter only results in the 'fiction' category (assuming that 'category'
+   * // is a stored field)
+   * miniSearch.search('motorcycle art', {
+   *   filter: (result) => result.category === 'fiction'
+   * })
+   * ```
+   *
+   * ### Wildcard query
+   *
+   * Searching for an empty string (assuming the default tokenizer) returns no
+   * results. Sometimes though, one needs to match all documents, like in a
+   * "wildcard" search. This is possible by passing the special value
+   * {@link MiniSearch.wildcard} as the query:
+   *
+   * ```javascript
+   * // Return search results for all documents
+   * miniSearch.search(MiniSearch.wildcard)
+   * ```
+   *
+   * Note that search options such as `filter` and `boostDocument` are still
+   * applied, influencing which results are returned, and their order:
+   *
+   * ```javascript
+   * // Return search results for all documents in the 'fiction' category
+   * miniSearch.search(MiniSearch.wildcard, {
+   *   filter: (result) => result.category === 'fiction'
+   * })
+   * ```
+   *
+   * ### Advanced combination of queries:
+   *
+   * It is possible to combine different subqueries with OR, AND, and AND_NOT,
+   * and even with different search options, by passing a query expression
+   * tree object as the first argument, instead of a string.
+   *
+   * ```javascript
+   * // Search for documents that contain "zen" and ("motorcycle" or "archery")
+   * miniSearch.search({
+   *   combineWith: 'AND',
+   *   queries: [
+   *     'zen',
+   *     {
+   *       combineWith: 'OR',
+   *       queries: ['motorcycle', 'archery']
+   *     }
+   *   ]
+   * })
+   *
+   * // Search for documents that contain ("apple" or "pear") but not "juice" and
+   * // not "tree"
+   * miniSearch.search({
+   *   combineWith: 'AND_NOT',
+   *   queries: [
+   *     {
+   *       combineWith: 'OR',
+   *       queries: ['apple', 'pear']
+   *     },
+   *     'juice',
+   *     'tree'
+   *   ]
+   * })
+   * ```
+   *
+   * Each node in the expression tree can be either a string, or an object that
+   * supports all {@link SearchOptions} fields, plus a `queries` array field for
+   * subqueries.
+   *
+   * Note that, while this can become complicated to do by hand for complex or
+   * deeply nested queries, it provides a formalized expression tree API for
+   * external libraries that implement a parser for custom query languages.
+   *
+   * @param query  Search query
+   * @param searchOptions  Search options. Each option, if not given, defaults to the corresponding value of `searchOptions` given to the constructor, or to the library default.
+   */
+  search(e, t = {}) {
+    const { searchOptions: n } = this._options, r = { ...n, ...t }, s = this.executeQuery(e, t), i = [];
+    for (const [o, { score: l, terms: c, match: f }] of s) {
+      const p = c.length || 1, v = {
+        id: this._documentIds.get(o),
+        score: l * p,
+        terms: Object.keys(f),
+        queryTerms: c,
+        match: f
+      };
+      Object.assign(v, this._storedFields.get(o)), (r.filter == null || r.filter(v)) && i.push(v);
+    }
+    return e === re.wildcard && r.boostDocument == null || i.sort(ot), i;
+  }
+  /**
+   * Provide suggestions for the given search query
+   *
+   * The result is a list of suggested modified search queries, derived from the
+   * given search query, each with a relevance score, sorted by descending score.
+   *
+   * By default, it uses the same options used for search, except that by
+   * default it performs prefix search on the last term of the query, and
+   * combine terms with `'AND'` (requiring all query terms to match). Custom
+   * options can be passed as a second argument. Defaults can be changed upon
+   * calling the {@link MiniSearch} constructor, by passing a
+   * `autoSuggestOptions` option.
+   *
+   * ### Basic usage:
+   *
+   * ```javascript
+   * // Get suggestions for 'neuro':
+   * miniSearch.autoSuggest('neuro')
+   * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 0.46240 } ]
+   * ```
+   *
+   * ### Multiple words:
+   *
+   * ```javascript
+   * // Get suggestions for 'zen ar':
+   * miniSearch.autoSuggest('zen ar')
+   * // => [
+   * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
+   * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
+   * // ]
+   * ```
+   *
+   * ### Fuzzy suggestions:
+   *
+   * ```javascript
+   * // Correct spelling mistakes using fuzzy search:
+   * miniSearch.autoSuggest('neromancer', { fuzzy: 0.2 })
+   * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 1.03998 } ]
+   * ```
+   *
+   * ### Filtering:
+   *
+   * ```javascript
+   * // Get suggestions for 'zen ar', but only within the 'fiction' category
+   * // (assuming that 'category' is a stored field):
+   * miniSearch.autoSuggest('zen ar', {
+   *   filter: (result) => result.category === 'fiction'
+   * })
+   * // => [
+   * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
+   * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
+   * // ]
+   * ```
+   *
+   * @param queryString  Query string to be expanded into suggestions
+   * @param options  Search options. The supported options and default values
+   * are the same as for the {@link MiniSearch#search} method, except that by
+   * default prefix search is performed on the last term in the query, and terms
+   * are combined with `'AND'`.
+   * @return  A sorted array of suggestions sorted by relevance score.
+   */
+  autoSuggest(e, t = {}) {
+    t = { ...this._options.autoSuggestOptions, ...t };
+    const n = /* @__PURE__ */ new Map();
+    for (const { score: s, terms: i } of this.search(e, t)) {
+      const o = i.join(" "), l = n.get(o);
+      l != null ? (l.score += s, l.count += 1) : n.set(o, { score: s, terms: i, count: 1 });
+    }
+    const r = [];
+    for (const [s, { score: i, terms: o, count: l }] of n)
+      r.push({ suggestion: s, terms: o, score: i / l });
+    return r.sort(ot), r;
+  }
+  /**
+   * Total number of documents available to search
+   */
+  get documentCount() {
+    return this._documentCount;
+  }
+  /**
+   * Number of terms in the index
+   */
+  get termCount() {
+    return this._index.size;
+  }
+  /**
+   * Deserializes a JSON index (serialized with `JSON.stringify(miniSearch)`)
+   * and instantiates a MiniSearch instance. It should be given the same options
+   * originally used when serializing the index.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * // If the index was serialized with:
+   * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+   * miniSearch.addAll(documents)
+   *
+   * const json = JSON.stringify(miniSearch)
+   * // It can later be deserialized like this:
+   * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
+   * ```
+   *
+   * @param json  JSON-serialized index
+   * @param options  configuration options, same as the constructor
+   * @return An instance of MiniSearch deserialized from the given JSON.
+   */
+  static loadJSON(e, t) {
+    if (t == null)
+      throw new Error("MiniSearch: loadJSON should be given the same options used when serializing the index");
+    return this.loadJS(JSON.parse(e), t);
+  }
+  /**
+   * Async equivalent of {@link MiniSearch.loadJSON}
+   *
+   * This function is an alternative to {@link MiniSearch.loadJSON} that returns
+   * a promise, and loads the index in batches, leaving pauses between them to avoid
+   * blocking the main thread. It tends to be slower than the synchronous
+   * version, but does not block the main thread, so it can be a better choice
+   * when deserializing very large indexes.
+   *
+   * @param json  JSON-serialized index
+   * @param options  configuration options, same as the constructor
+   * @return A Promise that will resolve to an instance of MiniSearch deserialized from the given JSON.
+   */
+  static async loadJSONAsync(e, t) {
+    if (t == null)
+      throw new Error("MiniSearch: loadJSON should be given the same options used when serializing the index");
+    return this.loadJSAsync(JSON.parse(e), t);
+  }
+  /**
+   * Returns the default value of an option. It will throw an error if no option
+   * with the given name exists.
+   *
+   * @param optionName  Name of the option
+   * @return The default value of the given option
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * // Get default tokenizer
+   * MiniSearch.getDefault('tokenize')
+   *
+   * // Get default term processor
+   * MiniSearch.getDefault('processTerm')
+   *
+   * // Unknown options will throw an error
+   * MiniSearch.getDefault('notExisting')
+   * // => throws 'MiniSearch: unknown option "notExisting"'
+   * ```
+   */
+  static getDefault(e) {
+    if (Ce.hasOwnProperty(e))
+      return Oe(Ce, e);
+    throw new Error(`MiniSearch: unknown option "${e}"`);
+  }
+  /**
+   * @ignore
+   */
+  static loadJS(e, t) {
+    const { index: n, documentIds: r, fieldLength: s, storedFields: i, serializationVersion: o } = e, l = this.instantiateMiniSearch(e, t);
+    l._documentIds = ye(r), l._fieldLength = ye(s), l._storedFields = ye(i);
+    for (const [c, f] of l._documentIds)
+      l._idToShortId.set(f, c);
+    for (const [c, f] of n) {
+      const p = /* @__PURE__ */ new Map();
+      for (const v of Object.keys(f)) {
+        let y = f[v];
+        o === 1 && (y = y.ds), p.set(parseInt(v, 10), ye(y));
+      }
+      l._index.set(c, p);
+    }
+    return l;
+  }
+  /**
+   * @ignore
+   */
+  static async loadJSAsync(e, t) {
+    const { index: n, documentIds: r, fieldLength: s, storedFields: i, serializationVersion: o } = e, l = this.instantiateMiniSearch(e, t);
+    l._documentIds = await we(r), l._fieldLength = await we(s), l._storedFields = await we(i);
+    for (const [f, p] of l._documentIds)
+      l._idToShortId.set(p, f);
+    let c = 0;
+    for (const [f, p] of n) {
+      const v = /* @__PURE__ */ new Map();
+      for (const y of Object.keys(p)) {
+        let S = p[y];
+        o === 1 && (S = S.ds), v.set(parseInt(y, 10), await we(S));
+      }
+      ++c % 1e3 === 0 && await xt(0), l._index.set(f, v);
+    }
+    return l;
+  }
+  /**
+   * @ignore
+   */
+  static instantiateMiniSearch(e, t) {
+    const { documentCount: n, nextId: r, fieldIds: s, averageFieldLength: i, dirtCount: o, serializationVersion: l } = e;
+    if (l !== 1 && l !== 2)
+      throw new Error("MiniSearch: cannot deserialize an index created with an incompatible version");
+    const c = new re(t);
+    return c._documentCount = n, c._nextId = r, c._idToShortId = /* @__PURE__ */ new Map(), c._fieldIds = s, c._avgFieldLength = i, c._dirtCount = o || 0, c._index = new q(), c;
+  }
+  /**
+   * @ignore
+   */
+  executeQuery(e, t = {}) {
+    if (e === re.wildcard)
+      return this.executeWildcardQuery(t);
+    if (typeof e != "string") {
+      const v = { ...t, ...e, queries: void 0 }, y = e.queries.map((S) => this.executeQuery(S, v));
+      return this.combineResults(y, v.combineWith);
+    }
+    const { tokenize: n, processTerm: r, searchOptions: s } = this._options, i = { tokenize: n, processTerm: r, ...s, ...t }, { tokenize: o, processTerm: l } = i, p = o(e).flatMap((v) => l(v)).filter((v) => !!v).map(zn(i)).map((v) => this.executeQuerySpec(v, i));
+    return this.combineResults(p, i.combineWith);
+  }
+  /**
+   * @ignore
+   */
+  executeQuerySpec(e, t) {
+    const n = { ...this._options.searchOptions, ...t }, r = (n.fields || this._options.fields).reduce((w, _) => ({ ...w, [_]: Oe(n.boost, _) || 1 }), {}), { boostDocument: s, weights: i, maxFuzzy: o, bm25: l } = n, { fuzzy: c, prefix: f } = { ...st.weights, ...i }, p = this._index.get(e.term), v = this.termResults(e.term, e.term, 1, e.termBoost, p, r, s, l);
+    let y, S;
+    if (e.prefix && (y = this._index.atPrefix(e.term)), e.fuzzy) {
+      const w = e.fuzzy === !0 ? 0.2 : e.fuzzy, _ = w < 1 ? Math.min(o, Math.round(e.term.length * w)) : w;
+      _ && (S = this._index.fuzzyGet(e.term, _));
+    }
+    if (y)
+      for (const [w, _] of y) {
+        const N = w.length - e.term.length;
+        if (!N)
+          continue;
+        S?.delete(w);
+        const F = f * w.length / (w.length + 0.3 * N);
+        this.termResults(e.term, w, F, e.termBoost, _, r, s, l, v);
+      }
+    if (S)
+      for (const w of S.keys()) {
+        const [_, N] = S.get(w);
+        if (!N)
+          continue;
+        const F = c * w.length / (w.length + N);
+        this.termResults(e.term, w, F, e.termBoost, _, r, s, l, v);
+      }
+    return v;
+  }
+  /**
+   * @ignore
+   */
+  executeWildcardQuery(e) {
+    const t = /* @__PURE__ */ new Map(), n = { ...this._options.searchOptions, ...e };
+    for (const [r, s] of this._documentIds) {
+      const i = n.boostDocument ? n.boostDocument(s, "", this._storedFields.get(r)) : 1;
+      t.set(r, {
+        score: i,
+        terms: [],
+        match: {}
+      });
+    }
+    return t;
+  }
+  /**
+   * @ignore
+   */
+  combineResults(e, t = Be) {
+    if (e.length === 0)
+      return /* @__PURE__ */ new Map();
+    const n = t.toLowerCase(), r = Ln[n];
+    if (!r)
+      throw new Error(`Invalid combination operator: ${t}`);
+    return e.reduce(r) || /* @__PURE__ */ new Map();
+  }
+  /**
+   * Allows serialization of the index to JSON, to possibly store it and later
+   * deserialize it with {@link MiniSearch.loadJSON}.
+   *
+   * Normally one does not directly call this method, but rather call the
+   * standard JavaScript `JSON.stringify()` passing the {@link MiniSearch}
+   * instance, and JavaScript will internally call this method. Upon
+   * deserialization, one must pass to {@link MiniSearch.loadJSON} the same
+   * options used to create the original instance that was serialized.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * // Serialize the index:
+   * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+   * miniSearch.addAll(documents)
+   * const json = JSON.stringify(miniSearch)
+   *
+   * // Later, to deserialize it:
+   * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
+   * ```
+   *
+   * @return A plain-object serializable representation of the search index.
+   */
+  toJSON() {
+    const e = [];
+    for (const [t, n] of this._index) {
+      const r = {};
+      for (const [s, i] of n)
+        r[s] = Object.fromEntries(i);
+      e.push([t, r]);
+    }
+    return {
+      documentCount: this._documentCount,
+      nextId: this._nextId,
+      documentIds: Object.fromEntries(this._documentIds),
+      fieldIds: this._fieldIds,
+      fieldLength: Object.fromEntries(this._fieldLength),
+      averageFieldLength: this._avgFieldLength,
+      storedFields: Object.fromEntries(this._storedFields),
+      dirtCount: this._dirtCount,
+      index: e,
+      serializationVersion: 2
+    };
+  }
+  /**
+   * @ignore
+   */
+  termResults(e, t, n, r, s, i, o, l, c = /* @__PURE__ */ new Map()) {
+    if (s == null)
+      return c;
+    for (const f of Object.keys(i)) {
+      const p = i[f], v = this._fieldIds[f], y = s.get(v);
+      if (y == null)
+        continue;
+      let S = y.size;
+      const w = this._avgFieldLength[v];
+      for (const _ of y.keys()) {
+        if (!this._documentIds.has(_)) {
+          this.removeTerm(v, _, t), S -= 1;
+          continue;
+        }
+        const N = o ? o(this._documentIds.get(_), t, this._storedFields.get(_)) : 1;
+        if (!N)
+          continue;
+        const F = y.get(_), G = this._fieldLength.get(_)[v], z = Pn(F, S, this._documentCount, G, w, l), j = n * r * p * N * z, L = c.get(_);
+        if (L) {
+          L.score += j, jn(L.terms, e);
+          const V = Oe(L.match, t);
+          V ? V.push(f) : L.match[t] = [f];
+        } else
+          c.set(_, {
+            score: j,
+            terms: [e],
+            match: { [t]: [f] }
+          });
+      }
+    }
+    return c;
+  }
+  /**
+   * @ignore
+   */
+  addTerm(e, t, n) {
+    const r = this._index.fetch(n, lt);
+    let s = r.get(e);
+    if (s == null)
+      s = /* @__PURE__ */ new Map(), s.set(t, 1), r.set(e, s);
+    else {
+      const i = s.get(t);
+      s.set(t, (i || 0) + 1);
+    }
+  }
+  /**
+   * @ignore
+   */
+  removeTerm(e, t, n) {
+    if (!this._index.has(n)) {
+      this.warnDocumentChanged(t, e, n);
+      return;
+    }
+    const r = this._index.fetch(n, lt), s = r.get(e);
+    s == null || s.get(t) == null ? this.warnDocumentChanged(t, e, n) : s.get(t) <= 1 ? s.size <= 1 ? r.delete(e) : s.delete(t) : s.set(t, s.get(t) - 1), this._index.get(n).size === 0 && this._index.delete(n);
+  }
+  /**
+   * @ignore
+   */
+  warnDocumentChanged(e, t, n) {
+    for (const r of Object.keys(this._fieldIds))
+      if (this._fieldIds[r] === t) {
+        this._options.logger("warn", `MiniSearch: document with ID ${this._documentIds.get(e)} has changed before removal: term "${n}" was not present in field "${r}". Removing a document after it has changed can corrupt the index!`, "version_conflict");
+        return;
+      }
+  }
+  /**
+   * @ignore
+   */
+  addDocumentId(e) {
+    const t = this._nextId;
+    return this._idToShortId.set(e, t), this._documentIds.set(t, e), this._documentCount += 1, this._nextId += 1, t;
+  }
+  /**
+   * @ignore
+   */
+  addFields(e) {
+    for (let t = 0; t < e.length; t++)
+      this._fieldIds[e[t]] = t;
+  }
+  /**
+   * @ignore
+   */
+  addFieldLength(e, t, n, r) {
+    let s = this._fieldLength.get(e);
+    s == null && this._fieldLength.set(e, s = []), s[t] = r;
+    const o = (this._avgFieldLength[t] || 0) * n + r;
+    this._avgFieldLength[t] = o / (n + 1);
+  }
+  /**
+   * @ignore
+   */
+  removeFieldLength(e, t, n, r) {
+    if (n === 1) {
+      this._avgFieldLength[t] = 0;
+      return;
+    }
+    const s = this._avgFieldLength[t] * n - r;
+    this._avgFieldLength[t] = s / (n - 1);
+  }
+  /**
+   * @ignore
+   */
+  saveStoredFields(e, t) {
+    const { storeFields: n, extractField: r } = this._options;
+    if (n == null || n.length === 0)
+      return;
+    let s = this._storedFields.get(e);
+    s == null && this._storedFields.set(e, s = {});
+    for (const i of n) {
+      const o = r(t, i);
+      o !== void 0 && (s[i] = o);
+    }
+  }
+}
+re.wildcard = /* @__PURE__ */ Symbol("*");
+const Oe = (a, e) => Object.prototype.hasOwnProperty.call(a, e) ? a[e] : void 0, Ln = {
+  [Be]: (a, e) => {
+    for (const t of e.keys()) {
+      const n = a.get(t);
+      if (n == null)
+        a.set(t, e.get(t));
+      else {
+        const { score: r, terms: s, match: i } = e.get(t);
+        n.score = n.score + r, n.match = Object.assign(n.match, i), at(n.terms, s);
+      }
+    }
+    return a;
+  },
+  [_t]: (a, e) => {
+    const t = /* @__PURE__ */ new Map();
+    for (const n of e.keys()) {
+      const r = a.get(n);
+      if (r == null)
+        continue;
+      const { score: s, terms: i, match: o } = e.get(n);
+      at(r.terms, i), t.set(n, {
+        score: r.score + s,
+        terms: r.terms,
+        match: Object.assign(r.match, o)
+      });
+    }
+    return t;
+  },
+  [Mn]: (a, e) => {
+    for (const t of e.keys())
+      a.delete(t);
+    return a;
+  }
+}, Dn = { k: 1.2, b: 0.7, d: 0.5 }, Pn = (a, e, t, n, r, s) => {
+  const { k: i, b: o, d: l } = s;
+  return Math.log(1 + (t - e + 0.5) / (e + 0.5)) * (l + a * (i + 1) / (a + i * (1 - o + o * n / r)));
+}, zn = (a) => (e, t, n) => {
+  const r = typeof a.fuzzy == "function" ? a.fuzzy(e, t, n) : a.fuzzy || !1, s = typeof a.prefix == "function" ? a.prefix(e, t, n) : a.prefix === !0, i = typeof a.boostTerm == "function" ? a.boostTerm(e, t, n) : 1;
+  return { term: e, fuzzy: r, prefix: s, termBoost: i };
+}, Ce = {
+  idField: "id",
+  extractField: (a, e) => a[e],
+  stringifyField: (a, e) => a.toString(),
+  tokenize: (a) => a.split($n),
+  processTerm: (a) => a.toLowerCase(),
+  fields: void 0,
+  searchOptions: void 0,
+  storeFields: [],
+  logger: (a, e) => {
+    typeof console?.[a] == "function" && console[a](e);
+  },
+  autoVacuum: !0
+}, st = {
+  combineWith: Be,
+  prefix: !1,
+  fuzzy: !1,
+  maxFuzzy: 6,
+  boost: {},
+  weights: { fuzzy: 0.45, prefix: 0.375 },
+  bm25: Dn
+}, Vn = {
+  combineWith: _t,
+  prefix: (a, e, t) => e === t.length - 1
+}, Ve = { batchSize: 1e3, batchWait: 10 }, je = { minDirtFactor: 0.1, minDirtCount: 20 }, Me = { ...Ve, ...je }, jn = (a, e) => {
+  a.includes(e) || a.push(e);
+}, at = (a, e) => {
+  for (const t of e)
+    a.includes(t) || a.push(t);
+}, ot = ({ score: a }, { score: e }) => e - a, lt = () => /* @__PURE__ */ new Map(), ye = (a) => {
+  const e = /* @__PURE__ */ new Map();
+  for (const t of Object.keys(a))
+    e.set(parseInt(t, 10), a[t]);
+  return e;
+}, we = async (a) => {
+  const e = /* @__PURE__ */ new Map();
+  let t = 0;
+  for (const n of Object.keys(a))
+    e.set(parseInt(n, 10), a[n]), ++t % 1e3 === 0 && await xt(0);
+  return e;
+}, xt = (a) => new Promise((e) => setTimeout(e, a)), $n = /[\n\r\p{Z}\p{P}]+/u;
+Z(Et(Yt));
+function Bn(a) {
+  let e = a.replace(/\.html$/, "");
+  if (e = decodeURIComponent(e), e = e.replace(/\/$/, "/index"), jt) {
+    e = Ze(e.slice(1).replace(/\//g, "_") || "index") + ".md";
+    let n = __VP_HASH_MAP__[e.toLowerCase()];
+    if (n || (e = e.endsWith("_index.md") ? e.slice(0, -9) + ".md" : e.slice(0, -3) + "_index.md", n = __VP_HASH_MAP__[e.toLowerCase()]), !n)
+      return null;
+    e = `/${__ASSETS_DIR__}/${e}.${n}.js`;
+  } else
+    e = `./${Ze(e.slice(1).replace(/\//g, "_"))}.md.js`;
+  return e;
+}
+class Wn {
+  max;
+  cache;
+  constructor(e = 10) {
+    this.max = e, this.cache = /* @__PURE__ */ new Map();
+  }
+  get(e) {
+    let t = this.cache.get(e);
+    return t !== void 0 && (this.cache.delete(e), this.cache.set(e, t)), t;
+  }
+  set(e, t) {
+    this.cache.has(e) ? this.cache.delete(e) : this.cache.size === this.max && this.cache.delete(this.first()), this.cache.set(e, t);
+  }
+  first() {
+    return this.cache.keys().next().value;
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+function Kn(a) {
+  const { localeIndex: e, theme: t } = ct();
+  function n(r) {
+    const s = r.split("."), i = t.value.search?.options, o = i && typeof i == "object", l = o && i.locales?.[e.value]?.translations || null, c = o && i.translations || null;
+    let f = l, p = c, v = a;
+    const y = s.pop();
+    for (const S of s) {
+      let w = null;
+      const _ = v?.[S];
+      _ && (w = v = _);
+      const N = p?.[S];
+      N && (w = p = N);
+      const F = f?.[S];
+      F && (w = f = F), _ || (v = w), N || (p = w), F || (f = w);
+    }
+    return f?.[y] ?? p?.[y] ?? v?.[y] ?? "";
+  }
+  return n;
+}
+const Jn = ["aria-owns"], Un = { class: "shell" }, Hn = ["title"], qn = { class: "search-actions before" }, Gn = ["title"], Qn = ["aria-activedescendant", "aria-controls", "placeholder"], Yn = { class: "search-actions" }, Zn = ["title"], Xn = ["disabled", "title"], ei = ["id", "role", "aria-labelledby"], ti = ["id", "aria-selected"], ni = ["href", "aria-label", "onMouseenter", "onFocusin", "data-index"], ii = { class: "titles" }, ri = ["innerHTML"], si = { class: "title main" }, ai = ["innerHTML"], oi = {
+  key: 0,
+  class: "excerpt-wrapper"
+}, li = {
+  key: 0,
+  class: "excerpt",
+  inert: ""
+}, ci = ["innerHTML"], ui = {
+  key: 0,
+  class: "no-results"
+}, di = { class: "search-keyboard-shortcuts" }, fi = ["aria-label"], hi = ["aria-label"], pi = ["aria-label"], vi = ["aria-label"], mi = /* @__PURE__ */ Tt({
+  __name: "VPLocalSearchBox",
+  emits: ["close"],
+  setup(a, { emit: e }) {
+    const t = e, n = Z(), r = Z(), s = Z(Lt), i = ct(), { activate: o } = Nn(n, {
+      immediate: !0,
+      allowOutsideClick: !0,
+      clickOutsideDeactivates: !0,
+      escapeDeactivates: !0
+    }), { localeIndex: l, theme: c } = i, f = Xe(
+      async () => Ye(
+        re.loadJSON(
+          (await s.value[l.value]?.())?.default,
+          {
+            fields: ["title", "titles", "text"],
+            storeFields: ["title", "titles"],
+            searchOptions: {
+              fuzzy: 0.2,
+              prefix: !0,
+              boost: { title: 4, text: 2, titles: 1 },
+              ...c.value.search?.provider === "local" && c.value.search.options?.miniSearch?.searchOptions
+            },
+            ...c.value.search?.provider === "local" && c.value.search.options?.miniSearch?.options
+          }
+        )
+      )
+    ), v = Se(() => c.value.search?.provider === "local" && c.value.search.options?.disableQueryPersistence === !0).value ? ue("") : $t("vitepress:local-search-filter", ""), y = Bt(
+      "vitepress:local-search-detailed-list",
+      c.value.search?.provider === "local" && c.value.search.options?.detailedView === !0
+    ), S = Se(() => c.value.search?.provider === "local" && (c.value.search.options?.disableDetailedView === !0 || c.value.search.options?.detailedView === !1));
+    It(() => {
+      S.value && (y.value = !1);
+    });
+    const w = Z([]), _ = ue(!1);
+    Le(v, () => {
+      _.value = !1;
+    });
+    const N = Xe(async () => {
+      if (r.value)
+        return Ye(new Rn(r.value));
+    }, null), F = new Wn(16);
+    Wt(
+      () => [f.value, v.value, y.value],
+      async ([m, h, g], E, k) => {
+        E?.[0] !== m && F.clear();
+        let R = !1;
+        if (k(() => {
+          R = !0;
+        }), !m) return;
+        w.value = m.search(h).slice(0, 16), _.value = !0;
+        const P = g ? await Promise.all(w.value.map((A) => G(A.id))) : [];
+        if (R) return;
+        for (const { id: A, mod: J } of P) {
+          const U = A.slice(0, A.indexOf("#"));
+          let oe = F.get(U);
+          if (oe) continue;
+          oe = /* @__PURE__ */ new Map(), F.set(U, oe);
+          const le = J.default ?? J;
+          if (le?.render || le?.setup) {
+            const Q = Mt(le);
+            Q.config.warnHandler = () => {
+            }, Q.provide(Gt, i), Object.defineProperties(Q.config.globalProperties, {
+              $frontmatter: {
+                get() {
+                  return i.frontmatter.value;
+                }
+              },
+              $params: {
+                get() {
+                  return i.page.value.params;
+                }
+              }
+            });
+            const We = document.createElement("div");
+            Q.mount(We), We.querySelectorAll("h1, h2, h3, h4, h5, h6").forEach((ce) => {
+              const Ke = ce.querySelector("a")?.getAttribute("href"), Je = Ke?.startsWith("#") && Ke.slice(1);
+              if (!Je) return;
+              let Ue = "";
+              for (; (ce = ce.nextElementSibling) && !/^h[1-6]$/i.test(ce.tagName); )
+                Ue += ce.outerHTML;
+              oe.set(Je, Ue);
+            }), Q.unmount();
+          }
+          if (R) return;
+        }
+        const D = /* @__PURE__ */ new Set();
+        if (w.value = w.value.map((A) => {
+          const [J, U] = A.id.split("#"), le = F.get(J)?.get(U) ?? "";
+          for (const Q in A.match)
+            D.add(Q);
+          return { ...A, text: le };
+        }), await de(), R) return;
+        await new Promise((A) => {
+          N.value?.unmark({
+            done: () => {
+              N.value?.markRegExp(b(D), { done: A });
+            }
+          });
+        });
+        const $ = n.value?.querySelectorAll(".result .excerpt") ?? [];
+        for (const A of $)
+          A.querySelector('mark[data-markjs="true"]')?.scrollIntoView({ block: "center" });
+        r.value?.firstElementChild?.scrollIntoView({ block: "start" });
+      },
+      { debounce: 200, immediate: !0 }
+    );
+    async function G(m) {
+      const h = Bn(m.slice(0, m.indexOf("#")));
+      try {
+        if (!h) throw new Error(`Cannot find file for id: ${m}`);
+        return { id: m, mod: await import(
+          /*@vite-ignore*/
+          h
+        ) };
+      } catch (g) {
+        return console.error(g), { id: m, mod: {} };
+      }
+    }
+    const z = ue(), j = Se(() => v.value?.length <= 0);
+    function L(m = !0) {
+      z.value?.focus(), m && z.value?.select();
+    }
+    Ne(() => {
+      L();
+    });
+    function V(m) {
+      m.pointerType === "mouse" && L();
+    }
+    const O = ue(-1), K = ue(!0);
+    Le(w, (m) => {
+      O.value = m.length ? 0 : -1, se();
+    });
+    function se() {
+      de(() => {
+        document.querySelector(".result.selected")?.scrollIntoView({ block: "nearest" });
+      });
+    }
+    ge("ArrowUp", (m) => {
+      m.preventDefault(), O.value--, O.value < 0 && (O.value = w.value.length - 1), K.value = !0, se();
+    }), ge("ArrowDown", (m) => {
+      m.preventDefault(), O.value++, O.value >= w.value.length && (O.value = 0), K.value = !0, se();
+    });
+    const ae = qt();
+    ge("Enter", (m) => {
+      if (m.isComposing || m.target instanceof HTMLButtonElement && m.target.type !== "submit")
+        return;
+      const h = w.value[O.value];
+      if (m.target instanceof HTMLInputElement && !h) {
+        m.preventDefault();
+        return;
+      }
+      h && (ae.go(h.id), t("close"));
+    }), ge("Escape", () => {
+      t("close");
+    });
+    const x = Kn({
+      button: {
+        buttonText: "Search"
+      },
+      modal: {
+        displayDetails: "Display detailed list",
+        resetButtonTitle: "Reset search",
+        backButtonTitle: "Close search",
+        noResultsText: "No results for",
+        footer: {
+          selectText: "to select",
+          selectKeyAriaLabel: "enter",
+          navigateText: "to navigate",
+          navigateUpKeyAriaLabel: "up arrow",
+          navigateDownKeyAriaLabel: "down arrow",
+          closeText: "to close",
+          closeKeyAriaLabel: "escape"
+        }
+      }
+    });
+    Ne(() => {
+      window.history.pushState(null, "", null);
+    }), Kt("popstate", (m) => {
+      m.preventDefault(), t("close");
+    });
+    const u = Jt(Qt ? document.body : null);
+    Ne(() => {
+      de(() => {
+        u.value = !0, de().then(() => o());
+      });
+    }), kt(() => {
+      u.value = !1;
+    });
+    function d() {
+      v.value = "", de().then(() => L(!1));
+    }
+    function b(m) {
+      return new RegExp(
+        [...m].sort((h, g) => g.length - h.length).map((h) => `(${Ut(h)})`).join("|"),
+        "gi"
+      );
+    }
+    function I(m) {
+      if (!K.value) return;
+      const h = m.target?.closest(".result"), g = Number.parseInt(h?.dataset.index);
+      g >= 0 && g !== O.value && (O.value = g), K.value = !1;
+    }
+    return (m, h) => (B(), Nt(Ft, { to: "body" }, [
+      T("div", {
+        ref_key: "el",
+        ref: n,
+        role: "button",
+        "aria-owns": w.value?.length ? "localsearch-list" : void 0,
+        "aria-expanded": "true",
+        "aria-haspopup": "listbox",
+        "aria-labelledby": "localsearch-label",
+        class: "VPLocalSearchBox"
+      }, [
+        T("div", {
+          class: "backdrop",
+          onClick: h[0] || (h[0] = (g) => m.$emit("close"))
+        }),
+        T("div", Un, [
+          T("form", {
+            class: "search-bar",
+            onPointerup: h[4] || (h[4] = (g) => V(g)),
+            onSubmit: h[5] || (h[5] = Rt(() => {
+            }, ["prevent"]))
+          }, [
+            T("label", {
+              title: C(x)("button.buttonText"),
+              id: "localsearch-label",
+              for: "localsearch-input"
+            }, [...h[7] || (h[7] = [
+              T("span", {
+                "aria-hidden": "true",
+                class: "vpi-search search-icon local-search-icon"
+              }, null, -1)
+            ])], 8, Hn),
+            T("div", qn, [
+              T("button", {
+                class: "back-button",
+                title: C(x)("modal.backButtonTitle"),
+                onClick: h[1] || (h[1] = (g) => m.$emit("close"))
+              }, [...h[8] || (h[8] = [
+                T("span", { class: "vpi-arrow-left local-search-icon" }, null, -1)
+              ])], 8, Gn)
+            ]),
+            At(T("input", {
+              ref_key: "searchInput",
+              ref: z,
+              "onUpdate:modelValue": h[2] || (h[2] = (g) => Ot(v) ? v.value = g : null),
+              "aria-activedescendant": O.value > -1 ? "localsearch-item-" + O.value : void 0,
+              "aria-autocomplete": "both",
+              "aria-controls": w.value?.length ? "localsearch-list" : void 0,
+              "aria-labelledby": "localsearch-label",
+              autocapitalize: "off",
+              autocomplete: "off",
+              autocorrect: "off",
+              class: "search-input",
+              id: "localsearch-input",
+              enterkeyhint: "go",
+              maxlength: "64",
+              placeholder: C(x)("button.buttonText"),
+              spellcheck: "false",
+              type: "search"
+            }, null, 8, Qn), [
+              [Ct, C(v)]
+            ]),
+            T("div", Yn, [
+              S.value ? me("", !0) : (B(), H("button", {
+                key: 0,
+                class: qe(["toggle-layout-button", { "detailed-list": C(y) }]),
+                type: "button",
+                title: C(x)("modal.displayDetails"),
+                onClick: h[3] || (h[3] = (g) => O.value > -1 && (y.value = !C(y)))
+              }, [...h[9] || (h[9] = [
+                T("span", { class: "vpi-layout-list local-search-icon" }, null, -1)
+              ])], 10, Zn)),
+              T("button", {
+                class: "clear-button",
+                type: "reset",
+                disabled: j.value,
+                title: C(x)("modal.resetButtonTitle"),
+                onClick: d
+              }, [...h[10] || (h[10] = [
+                T("span", { class: "vpi-delete local-search-icon" }, null, -1)
+              ])], 8, Xn)
+            ])
+          ], 32),
+          T("ul", {
+            ref_key: "resultsEl",
+            ref: r,
+            id: w.value?.length ? "localsearch-list" : void 0,
+            role: w.value?.length ? "listbox" : void 0,
+            "aria-labelledby": w.value?.length ? "localsearch-label" : void 0,
+            class: "results",
+            onMousemove: I
+          }, [
+            (B(!0), H(Ge, null, Qe(w.value, (g, E) => (B(), H("li", {
+              key: g.id,
+              id: "localsearch-item-" + E,
+              "aria-selected": O.value === E ? "true" : "false",
+              role: "option"
+            }, [
+              T("a", {
+                href: g.id,
+                class: qe(["result", {
+                  selected: O.value === E
+                }]),
+                "aria-label": [...g.titles, g.title].join(" > "),
+                onMouseenter: (k) => !K.value && (O.value = E),
+                onFocusin: (k) => O.value = E,
+                onClick: h[6] || (h[6] = (k) => m.$emit("close")),
+                "data-index": E
+              }, [
+                T("div", null, [
+                  T("div", ii, [
+                    h[12] || (h[12] = T("span", { class: "title-icon" }, "#", -1)),
+                    (B(!0), H(Ge, null, Qe(g.titles, (k, R) => (B(), H("span", {
+                      key: R,
+                      class: "title"
+                    }, [
+                      T("span", {
+                        class: "text",
+                        innerHTML: k
+                      }, null, 8, ri),
+                      h[11] || (h[11] = T("span", { class: "vpi-chevron-right local-search-icon" }, null, -1))
+                    ]))), 128)),
+                    T("span", si, [
+                      T("span", {
+                        class: "text",
+                        innerHTML: g.title
+                      }, null, 8, ai)
+                    ])
+                  ]),
+                  C(y) ? (B(), H("div", oi, [
+                    g.text ? (B(), H("div", li, [
+                      T("div", {
+                        class: "vp-doc",
+                        innerHTML: g.text
+                      }, null, 8, ci)
+                    ])) : me("", !0),
+                    h[13] || (h[13] = T("div", { class: "excerpt-gradient-bottom" }, null, -1)),
+                    h[14] || (h[14] = T("div", { class: "excerpt-gradient-top" }, null, -1))
+                  ])) : me("", !0)
+                ])
+              ], 42, ni)
+            ], 8, ti))), 128)),
+            C(v) && !w.value.length && _.value ? (B(), H("li", ui, [
+              fe(he(C(x)("modal.noResultsText")) + ' "', 1),
+              T("strong", null, he(C(v)), 1),
+              h[15] || (h[15] = fe('" ', -1))
+            ])) : me("", !0)
+          ], 40, ei),
+          T("div", di, [
+            T("span", null, [
+              T("kbd", {
+                "aria-label": C(x)("modal.footer.navigateUpKeyAriaLabel")
+              }, [...h[16] || (h[16] = [
+                T("span", { class: "vpi-arrow-up navigate-icon" }, null, -1)
+              ])], 8, fi),
+              T("kbd", {
+                "aria-label": C(x)("modal.footer.navigateDownKeyAriaLabel")
+              }, [...h[17] || (h[17] = [
+                T("span", { class: "vpi-arrow-down navigate-icon" }, null, -1)
+              ])], 8, hi),
+              fe(" " + he(C(x)("modal.footer.navigateText")), 1)
+            ]),
+            T("span", null, [
+              T("kbd", {
+                "aria-label": C(x)("modal.footer.selectKeyAriaLabel")
+              }, [...h[18] || (h[18] = [
+                T("span", { class: "vpi-corner-down-left navigate-icon" }, null, -1)
+              ])], 8, pi),
+              fe(" " + he(C(x)("modal.footer.selectText")), 1)
+            ]),
+            T("span", null, [
+              T("kbd", {
+                "aria-label": C(x)("modal.footer.closeKeyAriaLabel")
+              }, "esc", 8, vi),
+              fe(" " + he(C(x)("modal.footer.closeText")), 1)
+            ])
+          ])
+        ])
+      ], 8, Jn)
+    ]));
+  }
+}), Ei = /* @__PURE__ */ Ht(mi, [["__scopeId", "data-v-b3462fe7"]]);
+export {
+  Ei as default
+};