@foxford/ui 2.59.0-beta-92b12b1-20250115 → 2.61.0-beta-5e98b7f-20250131

package/external/.pnpm/dompurify@3.1.6/node_modules/dompurify/dist/purify.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"purify.mjs","sources":["../../../../../../../../node_modules/.pnpm/dompurify@3.1.6/node_modules/dompurify/dist/purify.js"],"sourcesContent":["/*! @license DOMPurify 3.1.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.1.6/LICENSE */\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.DOMPurify = factory());\n})(this, (function () { 'use strict';\n\n  const {\n    entries,\n    setPrototypeOf,\n    isFrozen,\n    getPrototypeOf,\n    getOwnPropertyDescriptor\n  } = Object;\n  let {\n    freeze,\n    seal,\n    create\n  } = Object; // eslint-disable-line import/no-mutable-exports\n  let {\n    apply,\n    construct\n  } = typeof Reflect !== 'undefined' && Reflect;\n  if (!freeze) {\n    freeze = function freeze(x) {\n      return x;\n    };\n  }\n  if (!seal) {\n    seal = function seal(x) {\n      return x;\n    };\n  }\n  if (!apply) {\n    apply = function apply(fun, thisValue, args) {\n      return fun.apply(thisValue, args);\n    };\n  }\n  if (!construct) {\n    construct = function construct(Func, args) {\n      return new Func(...args);\n    };\n  }\n  const arrayForEach = unapply(Array.prototype.forEach);\n  const arrayPop = unapply(Array.prototype.pop);\n  const arrayPush = unapply(Array.prototype.push);\n  const stringToLowerCase = unapply(String.prototype.toLowerCase);\n  const stringToString = unapply(String.prototype.toString);\n  const stringMatch = unapply(String.prototype.match);\n  const stringReplace = unapply(String.prototype.replace);\n  const stringIndexOf = unapply(String.prototype.indexOf);\n  const stringTrim = unapply(String.prototype.trim);\n  const objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);\n  const regExpTest = unapply(RegExp.prototype.test);\n  const typeErrorCreate = unconstruct(TypeError);\n\n  /**\n   * Creates a new function that calls the given function with a specified thisArg and arguments.\n   *\n   * @param {Function} func - The function to be wrapped and called.\n   * @returns {Function} A new function that calls the given function with a specified thisArg and arguments.\n   */\n  function unapply(func) {\n    return function (thisArg) {\n      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        args[_key - 1] = arguments[_key];\n      }\n      return apply(func, thisArg, args);\n    };\n  }\n\n  /**\n   * Creates a new function that constructs an instance of the given constructor function with the provided arguments.\n   *\n   * @param {Function} func - The constructor function to be wrapped and called.\n   * @returns {Function} A new function that constructs an instance of the given constructor function with the provided arguments.\n   */\n  function unconstruct(func) {\n    return function () {\n      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        args[_key2] = arguments[_key2];\n      }\n      return construct(func, args);\n    };\n  }\n\n  /**\n   * Add properties to a lookup table\n   *\n   * @param {Object} set - The set to which elements will be added.\n   * @param {Array} array - The array containing elements to be added to the set.\n   * @param {Function} transformCaseFunc - An optional function to transform the case of each element before adding to the set.\n   * @returns {Object} The modified set with added elements.\n   */\n  function addToSet(set, array) {\n    let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase;\n    if (setPrototypeOf) {\n      // Make 'in' and truthy checks like Boolean(set.constructor)\n      // independent of any properties defined on Object.prototype.\n      // Prevent prototype setters from intercepting set as a this value.\n      setPrototypeOf(set, null);\n    }\n    let l = array.length;\n    while (l--) {\n      let element = array[l];\n      if (typeof element === 'string') {\n        const lcElement = transformCaseFunc(element);\n        if (lcElement !== element) {\n          // Config presets (e.g. tags.js, attrs.js) are immutable.\n          if (!isFrozen(array)) {\n            array[l] = lcElement;\n          }\n          element = lcElement;\n        }\n      }\n      set[element] = true;\n    }\n    return set;\n  }\n\n  /**\n   * Clean up an array to harden against CSPP\n   *\n   * @param {Array} array - The array to be cleaned.\n   * @returns {Array} The cleaned version of the array\n   */\n  function cleanArray(array) {\n    for (let index = 0; index < array.length; index++) {\n      const isPropertyExist = objectHasOwnProperty(array, index);\n      if (!isPropertyExist) {\n        array[index] = null;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * Shallow clone an object\n   *\n   * @param {Object} object - The object to be cloned.\n   * @returns {Object} A new object that copies the original.\n   */\n  function clone(object) {\n    const newObject = create(null);\n    for (const [property, value] of entries(object)) {\n      const isPropertyExist = objectHasOwnProperty(object, property);\n      if (isPropertyExist) {\n        if (Array.isArray(value)) {\n          newObject[property] = cleanArray(value);\n        } else if (value && typeof value === 'object' && value.constructor === Object) {\n          newObject[property] = clone(value);\n        } else {\n          newObject[property] = value;\n        }\n      }\n    }\n    return newObject;\n  }\n\n  /**\n   * This method automatically checks if the prop is function or getter and behaves accordingly.\n   *\n   * @param {Object} object - The object to look up the getter function in its prototype chain.\n   * @param {String} prop - The property name for which to find the getter function.\n   * @returns {Function} The getter function found in the prototype chain or a fallback function.\n   */\n  function lookupGetter(object, prop) {\n    while (object !== null) {\n      const desc = getOwnPropertyDescriptor(object, prop);\n      if (desc) {\n        if (desc.get) {\n          return unapply(desc.get);\n        }\n        if (typeof desc.value === 'function') {\n          return unapply(desc.value);\n        }\n      }\n      object = getPrototypeOf(object);\n    }\n    function fallbackValue() {\n      return null;\n    }\n    return fallbackValue;\n  }\n\n  const html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);\n\n  // SVG\n  const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);\n  const svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);\n\n  // List of SVG elements that are disallowed by default.\n  // We still need to know them so that we can do namespace\n  // checks properly in case one wants to add them to\n  // allow-list.\n  const svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);\n  const mathMl$1 = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover', 'mprescripts']);\n\n  // Similarly to SVG, we want to know all MathML elements,\n  // even those that we disallow by default.\n  const mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);\n  const text = freeze(['#text']);\n\n  const html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'popover', 'popovertarget', 'popovertargetaction', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'wrap', 'xmlns', 'slot']);\n  const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);\n  const mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);\n  const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);\n\n  // eslint-disable-next-line unicorn/better-regex\n  const MUSTACHE_EXPR = seal(/\\{\\{[\\w\\W]*|[\\w\\W]*\\}\\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode\n  const ERB_EXPR = seal(/<%[\\w\\W]*|[\\w\\W]*%>/gm);\n  const TMPLIT_EXPR = seal(/\\${[\\w\\W]*}/gm);\n  const DATA_ATTR = seal(/^data-[\\-\\w.\\u00B7-\\uFFFF]/); // eslint-disable-line no-useless-escape\n  const ARIA_ATTR = seal(/^aria-[\\-\\w]+$/); // eslint-disable-line no-useless-escape\n  const IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\\-]+(?:[^a-z+.\\-:]|$))/i // eslint-disable-line no-useless-escape\n  );\n  const IS_SCRIPT_OR_DATA = seal(/^(?:\\w+script|data):/i);\n  const ATTR_WHITESPACE = seal(/[\\u0000-\\u0020\\u00A0\\u1680\\u180E\\u2000-\\u2029\\u205F\\u3000]/g // eslint-disable-line no-control-regex\n  );\n  const DOCTYPE_NAME = seal(/^html$/i);\n  const CUSTOM_ELEMENT = seal(/^[a-z][.\\w]*(-[.\\w]+)+$/i);\n\n  var EXPRESSIONS = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    MUSTACHE_EXPR: MUSTACHE_EXPR,\n    ERB_EXPR: ERB_EXPR,\n    TMPLIT_EXPR: TMPLIT_EXPR,\n    DATA_ATTR: DATA_ATTR,\n    ARIA_ATTR: ARIA_ATTR,\n    IS_ALLOWED_URI: IS_ALLOWED_URI,\n    IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA,\n    ATTR_WHITESPACE: ATTR_WHITESPACE,\n    DOCTYPE_NAME: DOCTYPE_NAME,\n    CUSTOM_ELEMENT: CUSTOM_ELEMENT\n  });\n\n  // https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType\n  const NODE_TYPE = {\n    element: 1,\n    attribute: 2,\n    text: 3,\n    cdataSection: 4,\n    entityReference: 5,\n    // Deprecated\n    entityNode: 6,\n    // Deprecated\n    progressingInstruction: 7,\n    comment: 8,\n    document: 9,\n    documentType: 10,\n    documentFragment: 11,\n    notation: 12 // Deprecated\n  };\n  const getGlobal = function getGlobal() {\n    return typeof window === 'undefined' ? null : window;\n  };\n\n  /**\n   * Creates a no-op policy for internal use only.\n   * Don't export this function outside this module!\n   * @param {TrustedTypePolicyFactory} trustedTypes The policy factory.\n   * @param {HTMLScriptElement} purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).\n   * @return {TrustedTypePolicy} The policy created (or null, if Trusted Types\n   * are not supported or creating the policy failed).\n   */\n  const _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, purifyHostElement) {\n    if (typeof trustedTypes !== 'object' || typeof trustedTypes.createPolicy !== 'function') {\n      return null;\n    }\n\n    // Allow the callers to control the unique policy name\n    // by adding a data-tt-policy-suffix to the script element with the DOMPurify.\n    // Policy creation with duplicate names throws in Trusted Types.\n    let suffix = null;\n    const ATTR_NAME = 'data-tt-policy-suffix';\n    if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {\n      suffix = purifyHostElement.getAttribute(ATTR_NAME);\n    }\n    const policyName = 'dompurify' + (suffix ? '#' + suffix : '');\n    try {\n      return trustedTypes.createPolicy(policyName, {\n        createHTML(html) {\n          return html;\n        },\n        createScriptURL(scriptUrl) {\n          return scriptUrl;\n        }\n      });\n    } catch (_) {\n      // Policy creation failed (most likely another DOMPurify script has\n      // already run). Skip creating the policy, as this will only cause errors\n      // if TT are enforced.\n      console.warn('TrustedTypes policy ' + policyName + ' could not be created.');\n      return null;\n    }\n  };\n  function createDOMPurify() {\n    let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();\n    const DOMPurify = root => createDOMPurify(root);\n\n    /**\n     * Version label, exposed for easier checks\n     * if DOMPurify is up to date or not\n     */\n    DOMPurify.version = '3.1.6';\n\n    /**\n     * Array of elements that DOMPurify removed during sanitation.\n     * Empty if nothing was removed.\n     */\n    DOMPurify.removed = [];\n    if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document) {\n      // Not running in a browser, provide a factory function\n      // so that you can pass your own Window\n      DOMPurify.isSupported = false;\n      return DOMPurify;\n    }\n    let {\n      document\n    } = window;\n    const originalDocument = document;\n    const currentScript = originalDocument.currentScript;\n    const {\n      DocumentFragment,\n      HTMLTemplateElement,\n      Node,\n      Element,\n      NodeFilter,\n      NamedNodeMap = window.NamedNodeMap || window.MozNamedAttrMap,\n      HTMLFormElement,\n      DOMParser,\n      trustedTypes\n    } = window;\n    const ElementPrototype = Element.prototype;\n    const cloneNode = lookupGetter(ElementPrototype, 'cloneNode');\n    const remove = lookupGetter(ElementPrototype, 'remove');\n    const getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');\n    const getChildNodes = lookupGetter(ElementPrototype, 'childNodes');\n    const getParentNode = lookupGetter(ElementPrototype, 'parentNode');\n\n    // As per issue #47, the web-components registry is inherited by a\n    // new document created via createHTMLDocument. As per the spec\n    // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)\n    // a new empty registry is used when creating a template contents owner\n    // document, so we use that as our parent document to ensure nothing\n    // is inherited.\n    if (typeof HTMLTemplateElement === 'function') {\n      const template = document.createElement('template');\n      if (template.content && template.content.ownerDocument) {\n        document = template.content.ownerDocument;\n      }\n    }\n    let trustedTypesPolicy;\n    let emptyHTML = '';\n    const {\n      implementation,\n      createNodeIterator,\n      createDocumentFragment,\n      getElementsByTagName\n    } = document;\n    const {\n      importNode\n    } = originalDocument;\n    let hooks = {};\n\n    /**\n     * Expose whether this browser supports running the full DOMPurify.\n     */\n    DOMPurify.isSupported = typeof entries === 'function' && typeof getParentNode === 'function' && implementation && implementation.createHTMLDocument !== undefined;\n    const {\n      MUSTACHE_EXPR,\n      ERB_EXPR,\n      TMPLIT_EXPR,\n      DATA_ATTR,\n      ARIA_ATTR,\n      IS_SCRIPT_OR_DATA,\n      ATTR_WHITESPACE,\n      CUSTOM_ELEMENT\n    } = EXPRESSIONS;\n    let {\n      IS_ALLOWED_URI: IS_ALLOWED_URI$1\n    } = EXPRESSIONS;\n\n    /**\n     * We consider the elements and attributes below to be safe. Ideally\n     * don't add any new ones but feel free to remove unwanted ones.\n     */\n\n    /* allowed element names */\n    let ALLOWED_TAGS = null;\n    const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);\n\n    /* Allowed attribute names */\n    let ALLOWED_ATTR = null;\n    const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);\n\n    /*\n     * Configure how DOMPUrify should handle custom elements and their attributes as well as customized built-in elements.\n     * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)\n     * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)\n     * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.\n     */\n    let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {\n      tagNameCheck: {\n        writable: true,\n        configurable: false,\n        enumerable: true,\n        value: null\n      },\n      attributeNameCheck: {\n        writable: true,\n        configurable: false,\n        enumerable: true,\n        value: null\n      },\n      allowCustomizedBuiltInElements: {\n        writable: true,\n        configurable: false,\n        enumerable: true,\n        value: false\n      }\n    }));\n\n    /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */\n    let FORBID_TAGS = null;\n\n    /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */\n    let FORBID_ATTR = null;\n\n    /* Decide if ARIA attributes are okay */\n    let ALLOW_ARIA_ATTR = true;\n\n    /* Decide if custom data attributes are okay */\n    let ALLOW_DATA_ATTR = true;\n\n    /* Decide if unknown protocols are okay */\n    let ALLOW_UNKNOWN_PROTOCOLS = false;\n\n    /* Decide if self-closing tags in attributes are allowed.\n     * Usually removed due to a mXSS issue in jQuery 3.0 */\n    let ALLOW_SELF_CLOSE_IN_ATTR = true;\n\n    /* Output should be safe for common template engines.\n     * This means, DOMPurify removes data attributes, mustaches and ERB\n     */\n    let SAFE_FOR_TEMPLATES = false;\n\n    /* Output should be safe even for XML used within HTML and alike.\n     * This means, DOMPurify removes comments when containing risky content.\n     */\n    let SAFE_FOR_XML = true;\n\n    /* Decide if document with <html>... should be returned */\n    let WHOLE_DOCUMENT = false;\n\n    /* Track whether config is already set on this instance of DOMPurify. */\n    let SET_CONFIG = false;\n\n    /* Decide if all elements (e.g. style, script) must be children of\n     * document.body. By default, browsers might move them to document.head */\n    let FORCE_BODY = false;\n\n    /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html\n     * string (or a TrustedHTML object if Trusted Types are supported).\n     * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead\n     */\n    let RETURN_DOM = false;\n\n    /* Decide if a DOM `DocumentFragment` should be returned, instead of a html\n     * string  (or a TrustedHTML object if Trusted Types are supported) */\n    let RETURN_DOM_FRAGMENT = false;\n\n    /* Try to return a Trusted Type object instead of a string, return a string in\n     * case Trusted Types are not supported  */\n    let RETURN_TRUSTED_TYPE = false;\n\n    /* Output should be free from DOM clobbering attacks?\n     * This sanitizes markups named with colliding, clobberable built-in DOM APIs.\n     */\n    let SANITIZE_DOM = true;\n\n    /* Achieve full DOM Clobbering protection by isolating the namespace of named\n     * properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.\n     *\n     * HTML/DOM spec rules that enable DOM Clobbering:\n     *   - Named Access on Window (§7.3.3)\n     *   - DOM Tree Accessors (§3.1.5)\n     *   - Form Element Parent-Child Relations (§4.10.3)\n     *   - Iframe srcdoc / Nested WindowProxies (§4.8.5)\n     *   - HTMLCollection (§4.2.10.2)\n     *\n     * Namespace isolation is implemented by prefixing `id` and `name` attributes\n     * with a constant string, i.e., `user-content-`\n     */\n    let SANITIZE_NAMED_PROPS = false;\n    const SANITIZE_NAMED_PROPS_PREFIX = 'user-content-';\n\n    /* Keep element content when removing element? */\n    let KEEP_CONTENT = true;\n\n    /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead\n     * of importing it into a new Document and returning a sanitized copy */\n    let IN_PLACE = false;\n\n    /* Allow usage of profiles like html, svg and mathMl */\n    let USE_PROFILES = {};\n\n    /* Tags to ignore content of when KEEP_CONTENT is true */\n    let FORBID_CONTENTS = null;\n    const DEFAULT_FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);\n\n    /* Tags that are safe for data: URIs */\n    let DATA_URI_TAGS = null;\n    const DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);\n\n    /* Attributes safe for values like \"javascript:\" */\n    let URI_SAFE_ATTRIBUTES = null;\n    const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);\n    const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';\n    const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';\n    const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';\n    /* Document namespace */\n    let NAMESPACE = HTML_NAMESPACE;\n    let IS_EMPTY_INPUT = false;\n\n    /* Allowed XHTML+XML namespaces */\n    let ALLOWED_NAMESPACES = null;\n    const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);\n\n    /* Parsing of strict XHTML documents */\n    let PARSER_MEDIA_TYPE = null;\n    const SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];\n    const DEFAULT_PARSER_MEDIA_TYPE = 'text/html';\n    let transformCaseFunc = null;\n\n    /* Keep a reference to config to pass to hooks */\n    let CONFIG = null;\n\n    /* Ideally, do not touch anything below this line */\n    /* ______________________________________________ */\n\n    const formElement = document.createElement('form');\n    const isRegexOrFunction = function isRegexOrFunction(testValue) {\n      return testValue instanceof RegExp || testValue instanceof Function;\n    };\n\n    /**\n     * _parseConfig\n     *\n     * @param  {Object} cfg optional config literal\n     */\n    // eslint-disable-next-line complexity\n    const _parseConfig = function _parseConfig() {\n      let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      if (CONFIG && CONFIG === cfg) {\n        return;\n      }\n\n      /* Shield configuration object from tampering */\n      if (!cfg || typeof cfg !== 'object') {\n        cfg = {};\n      }\n\n      /* Shield configuration object from prototype pollution */\n      cfg = clone(cfg);\n      PARSER_MEDIA_TYPE =\n      // eslint-disable-next-line unicorn/prefer-includes\n      SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;\n\n      // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.\n      transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? stringToString : stringToLowerCase;\n\n      /* Set configuration parameters */\n      ALLOWED_TAGS = objectHasOwnProperty(cfg, 'ALLOWED_TAGS') ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;\n      ALLOWED_ATTR = objectHasOwnProperty(cfg, 'ALLOWED_ATTR') ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;\n      ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, 'ALLOWED_NAMESPACES') ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;\n      URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, 'ADD_URI_SAFE_ATTR') ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES),\n      // eslint-disable-line indent\n      cfg.ADD_URI_SAFE_ATTR,\n      // eslint-disable-line indent\n      transformCaseFunc // eslint-disable-line indent\n      ) // eslint-disable-line indent\n      : DEFAULT_URI_SAFE_ATTRIBUTES;\n      DATA_URI_TAGS = objectHasOwnProperty(cfg, 'ADD_DATA_URI_TAGS') ? addToSet(clone(DEFAULT_DATA_URI_TAGS),\n      // eslint-disable-line indent\n      cfg.ADD_DATA_URI_TAGS,\n      // eslint-disable-line indent\n      transformCaseFunc // eslint-disable-line indent\n      ) // eslint-disable-line indent\n      : DEFAULT_DATA_URI_TAGS;\n      FORBID_CONTENTS = objectHasOwnProperty(cfg, 'FORBID_CONTENTS') ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;\n      FORBID_TAGS = objectHasOwnProperty(cfg, 'FORBID_TAGS') ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : {};\n      FORBID_ATTR = objectHasOwnProperty(cfg, 'FORBID_ATTR') ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : {};\n      USE_PROFILES = objectHasOwnProperty(cfg, 'USE_PROFILES') ? cfg.USE_PROFILES : false;\n      ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true\n      ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true\n      ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false\n      ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false; // Default true\n      SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false\n      SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false; // Default true\n      WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false\n      RETURN_DOM = cfg.RETURN_DOM || false; // Default false\n      RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false\n      RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false\n      FORCE_BODY = cfg.FORCE_BODY || false; // Default false\n      SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true\n      SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false; // Default false\n      KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true\n      IN_PLACE = cfg.IN_PLACE || false; // Default false\n      IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;\n      NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;\n      CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};\n      if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {\n        CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;\n      }\n      if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {\n        CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;\n      }\n      if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === 'boolean') {\n        CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;\n      }\n      if (SAFE_FOR_TEMPLATES) {\n        ALLOW_DATA_ATTR = false;\n      }\n      if (RETURN_DOM_FRAGMENT) {\n        RETURN_DOM = true;\n      }\n\n      /* Parse profile info */\n      if (USE_PROFILES) {\n        ALLOWED_TAGS = addToSet({}, text);\n        ALLOWED_ATTR = [];\n        if (USE_PROFILES.html === true) {\n          addToSet(ALLOWED_TAGS, html$1);\n          addToSet(ALLOWED_ATTR, html);\n        }\n        if (USE_PROFILES.svg === true) {\n          addToSet(ALLOWED_TAGS, svg$1);\n          addToSet(ALLOWED_ATTR, svg);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n        if (USE_PROFILES.svgFilters === true) {\n          addToSet(ALLOWED_TAGS, svgFilters);\n          addToSet(ALLOWED_ATTR, svg);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n        if (USE_PROFILES.mathMl === true) {\n          addToSet(ALLOWED_TAGS, mathMl$1);\n          addToSet(ALLOWED_ATTR, mathMl);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n      }\n\n      /* Merge configuration parameters */\n      if (cfg.ADD_TAGS) {\n        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {\n          ALLOWED_TAGS = clone(ALLOWED_TAGS);\n        }\n        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);\n      }\n      if (cfg.ADD_ATTR) {\n        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {\n          ALLOWED_ATTR = clone(ALLOWED_ATTR);\n        }\n        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);\n      }\n      if (cfg.ADD_URI_SAFE_ATTR) {\n        addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);\n      }\n      if (cfg.FORBID_CONTENTS) {\n        if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {\n          FORBID_CONTENTS = clone(FORBID_CONTENTS);\n        }\n        addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);\n      }\n\n      /* Add #text in case KEEP_CONTENT is set to true */\n      if (KEEP_CONTENT) {\n        ALLOWED_TAGS['#text'] = true;\n      }\n\n      /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */\n      if (WHOLE_DOCUMENT) {\n        addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);\n      }\n\n      /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */\n      if (ALLOWED_TAGS.table) {\n        addToSet(ALLOWED_TAGS, ['tbody']);\n        delete FORBID_TAGS.tbody;\n      }\n      if (cfg.TRUSTED_TYPES_POLICY) {\n        if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== 'function') {\n          throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a \"createHTML\" hook.');\n        }\n        if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== 'function') {\n          throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a \"createScriptURL\" hook.');\n        }\n\n        // Overwrite existing TrustedTypes policy.\n        trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;\n\n        // Sign local variables required by `sanitize`.\n        emptyHTML = trustedTypesPolicy.createHTML('');\n      } else {\n        // Uninitialized policy, attempt to initialize the internal dompurify policy.\n        if (trustedTypesPolicy === undefined) {\n          trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);\n        }\n\n        // If creating the internal policy succeeded sign internal variables.\n        if (trustedTypesPolicy !== null && typeof emptyHTML === 'string') {\n          emptyHTML = trustedTypesPolicy.createHTML('');\n        }\n      }\n\n      // Prevent further manipulation of configuration.\n      // Not available in IE8, Safari 5, etc.\n      if (freeze) {\n        freeze(cfg);\n      }\n      CONFIG = cfg;\n    };\n    const MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);\n    const HTML_INTEGRATION_POINTS = addToSet({}, ['foreignobject', 'annotation-xml']);\n\n    // Certain elements are allowed in both SVG and HTML\n    // namespace. We need to specify them explicitly\n    // so that they don't get erroneously deleted from\n    // HTML namespace.\n    const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);\n\n    /* Keep track of all possible SVG and MathML tags\n     * so that we can perform the namespace checks\n     * correctly. */\n    const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);\n    const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);\n\n    /**\n     * @param  {Element} element a DOM element whose namespace is being checked\n     * @returns {boolean} Return false if the element has a\n     *  namespace that a spec-compliant parser would never\n     *  return. Return true otherwise.\n     */\n    const _checkValidNamespace = function _checkValidNamespace(element) {\n      let parent = getParentNode(element);\n\n      // In JSDOM, if we're inside shadow DOM, then parentNode\n      // can be null. We just simulate parent in this case.\n      if (!parent || !parent.tagName) {\n        parent = {\n          namespaceURI: NAMESPACE,\n          tagName: 'template'\n        };\n      }\n      const tagName = stringToLowerCase(element.tagName);\n      const parentTagName = stringToLowerCase(parent.tagName);\n      if (!ALLOWED_NAMESPACES[element.namespaceURI]) {\n        return false;\n      }\n      if (element.namespaceURI === SVG_NAMESPACE) {\n        // The only way to switch from HTML namespace to SVG\n        // is via <svg>. If it happens via any other tag, then\n        // it should be killed.\n        if (parent.namespaceURI === HTML_NAMESPACE) {\n          return tagName === 'svg';\n        }\n\n        // The only way to switch from MathML to SVG is via`\n        // svg if parent is either <annotation-xml> or MathML\n        // text integration points.\n        if (parent.namespaceURI === MATHML_NAMESPACE) {\n          return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);\n        }\n\n        // We only allow elements that are defined in SVG\n        // spec. All others are disallowed in SVG namespace.\n        return Boolean(ALL_SVG_TAGS[tagName]);\n      }\n      if (element.namespaceURI === MATHML_NAMESPACE) {\n        // The only way to switch from HTML namespace to MathML\n        // is via <math>. If it happens via any other tag, then\n        // it should be killed.\n        if (parent.namespaceURI === HTML_NAMESPACE) {\n          return tagName === 'math';\n        }\n\n        // The only way to switch from SVG to MathML is via\n        // <math> and HTML integration points\n        if (parent.namespaceURI === SVG_NAMESPACE) {\n          return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];\n        }\n\n        // We only allow elements that are defined in MathML\n        // spec. All others are disallowed in MathML namespace.\n        return Boolean(ALL_MATHML_TAGS[tagName]);\n      }\n      if (element.namespaceURI === HTML_NAMESPACE) {\n        // The only way to switch from SVG to HTML is via\n        // HTML integration points, and from MathML to HTML\n        // is via MathML text integration points\n        if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {\n          return false;\n        }\n        if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {\n          return false;\n        }\n\n        // We disallow tags that are specific for MathML\n        // or SVG and should never appear in HTML namespace\n        return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);\n      }\n\n      // For XHTML and XML documents that support custom namespaces\n      if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && ALLOWED_NAMESPACES[element.namespaceURI]) {\n        return true;\n      }\n\n      // The code should never reach this place (this means\n      // that the element somehow got namespace that is not\n      // HTML, SVG, MathML or allowed via ALLOWED_NAMESPACES).\n      // Return false just in case.\n      return false;\n    };\n\n    /**\n     * _forceRemove\n     *\n     * @param  {Node} node a DOM node\n     */\n    const _forceRemove = function _forceRemove(node) {\n      arrayPush(DOMPurify.removed, {\n        element: node\n      });\n      try {\n        // eslint-disable-next-line unicorn/prefer-dom-node-remove\n        getParentNode(node).removeChild(node);\n      } catch (_) {\n        remove(node);\n      }\n    };\n\n    /**\n     * _removeAttribute\n     *\n     * @param  {String} name an Attribute name\n     * @param  {Node} node a DOM node\n     */\n    const _removeAttribute = function _removeAttribute(name, node) {\n      try {\n        arrayPush(DOMPurify.removed, {\n          attribute: node.getAttributeNode(name),\n          from: node\n        });\n      } catch (_) {\n        arrayPush(DOMPurify.removed, {\n          attribute: null,\n          from: node\n        });\n      }\n      node.removeAttribute(name);\n\n      // We void attribute values for unremovable \"is\"\" attributes\n      if (name === 'is' && !ALLOWED_ATTR[name]) {\n        if (RETURN_DOM || RETURN_DOM_FRAGMENT) {\n          try {\n            _forceRemove(node);\n          } catch (_) {}\n        } else {\n          try {\n            node.setAttribute(name, '');\n          } catch (_) {}\n        }\n      }\n    };\n\n    /**\n     * _initDocument\n     *\n     * @param  {String} dirty a string of dirty markup\n     * @return {Document} a DOM, filled with the dirty markup\n     */\n    const _initDocument = function _initDocument(dirty) {\n      /* Create a HTML document */\n      let doc = null;\n      let leadingWhitespace = null;\n      if (FORCE_BODY) {\n        dirty = '<remove></remove>' + dirty;\n      } else {\n        /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */\n        const matches = stringMatch(dirty, /^[\\r\\n\\t ]+/);\n        leadingWhitespace = matches && matches[0];\n      }\n      if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && NAMESPACE === HTML_NAMESPACE) {\n        // Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)\n        dirty = '<html xmlns=\"http://www.w3.org/1999/xhtml\"><head></head><body>' + dirty + '</body></html>';\n      }\n      const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;\n      /*\n       * Use the DOMParser API by default, fallback later if needs be\n       * DOMParser not work for svg when has multiple root element.\n       */\n      if (NAMESPACE === HTML_NAMESPACE) {\n        try {\n          doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);\n        } catch (_) {}\n      }\n\n      /* Use createHTMLDocument in case DOMParser is not available */\n      if (!doc || !doc.documentElement) {\n        doc = implementation.createDocument(NAMESPACE, 'template', null);\n        try {\n          doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;\n        } catch (_) {\n          // Syntax error if dirtyPayload is invalid xml\n        }\n      }\n      const body = doc.body || doc.documentElement;\n      if (dirty && leadingWhitespace) {\n        body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);\n      }\n\n      /* Work on whole document or just its body */\n      if (NAMESPACE === HTML_NAMESPACE) {\n        return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];\n      }\n      return WHOLE_DOCUMENT ? doc.documentElement : body;\n    };\n\n    /**\n     * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.\n     *\n     * @param  {Node} root The root element or node to start traversing on.\n     * @return {NodeIterator} The created NodeIterator\n     */\n    const _createNodeIterator = function _createNodeIterator(root) {\n      return createNodeIterator.call(root.ownerDocument || root, root,\n      // eslint-disable-next-line no-bitwise\n      NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION, null);\n    };\n\n    /**\n     * _isClobbered\n     *\n     * @param  {Node} elm element to check for clobbering attacks\n     * @return {Boolean} true if clobbered, false if safe\n     */\n    const _isClobbered = function _isClobbered(elm) {\n      return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function');\n    };\n\n    /**\n     * Checks whether the given object is a DOM node.\n     *\n     * @param  {Node} object object to check whether it's a DOM node\n     * @return {Boolean} true is object is a DOM node\n     */\n    const _isNode = function _isNode(object) {\n      return typeof Node === 'function' && object instanceof Node;\n    };\n\n    /**\n     * _executeHook\n     * Execute user configurable hooks\n     *\n     * @param  {String} entryPoint  Name of the hook's entry point\n     * @param  {Node} currentNode node to work on with the hook\n     * @param  {Object} data additional hook parameters\n     */\n    const _executeHook = function _executeHook(entryPoint, currentNode, data) {\n      if (!hooks[entryPoint]) {\n        return;\n      }\n      arrayForEach(hooks[entryPoint], hook => {\n        hook.call(DOMPurify, currentNode, data, CONFIG);\n      });\n    };\n\n    /**\n     * _sanitizeElements\n     *\n     * @protect nodeName\n     * @protect textContent\n     * @protect removeChild\n     *\n     * @param   {Node} currentNode to check for permission to exist\n     * @return  {Boolean} true if node was killed, false if left alive\n     */\n    const _sanitizeElements = function _sanitizeElements(currentNode) {\n      let content = null;\n\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeElements', currentNode, null);\n\n      /* Check if element is clobbered or can clobber */\n      if (_isClobbered(currentNode)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Now let's check the element's type and name */\n      const tagName = transformCaseFunc(currentNode.nodeName);\n\n      /* Execute a hook if present */\n      _executeHook('uponSanitizeElement', currentNode, {\n        tagName,\n        allowedTags: ALLOWED_TAGS\n      });\n\n      /* Detect mXSS attempts abusing namespace confusion */\n      if (currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\\w]/g, currentNode.innerHTML) && regExpTest(/<[/\\w]/g, currentNode.textContent)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Remove any occurrence of processing instructions */\n      if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Remove any kind of possibly harmful comments */\n      if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\\w]/g, currentNode.data)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Remove element if anything forbids its presence */\n      if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {\n        /* Check if we have a custom element to handle */\n        if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {\n          if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {\n            return false;\n          }\n          if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {\n            return false;\n          }\n        }\n\n        /* Keep content except for bad-listed elements */\n        if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {\n          const parentNode = getParentNode(currentNode) || currentNode.parentNode;\n          const childNodes = getChildNodes(currentNode) || currentNode.childNodes;\n          if (childNodes && parentNode) {\n            const childCount = childNodes.length;\n            for (let i = childCount - 1; i >= 0; --i) {\n              const childClone = cloneNode(childNodes[i], true);\n              childClone.__removalCount = (currentNode.__removalCount || 0) + 1;\n              parentNode.insertBefore(childClone, getNextSibling(currentNode));\n            }\n          }\n        }\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Check whether element has a valid namespace */\n      if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Make sure that older browsers don't get fallback-tag mXSS */\n      if ((tagName === 'noscript' || tagName === 'noembed' || tagName === 'noframes') && regExpTest(/<\\/no(script|embed|frames)/i, currentNode.innerHTML)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Sanitize element content to be template-safe */\n      if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {\n        /* Get the element's text content */\n        content = currentNode.textContent;\n        arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {\n          content = stringReplace(content, expr, ' ');\n        });\n        if (currentNode.textContent !== content) {\n          arrayPush(DOMPurify.removed, {\n            element: currentNode.cloneNode()\n          });\n          currentNode.textContent = content;\n        }\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeElements', currentNode, null);\n      return false;\n    };\n\n    /**\n     * _isValidAttribute\n     *\n     * @param  {string} lcTag Lowercase tag name of containing element.\n     * @param  {string} lcName Lowercase attribute name.\n     * @param  {string} value Attribute value.\n     * @return {Boolean} Returns true if `value` is valid, otherwise false.\n     */\n    // eslint-disable-next-line complexity\n    const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {\n      /* Make sure attribute cannot clobber */\n      if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {\n        return false;\n      }\n\n      /* Allow valid data-* attributes: At least one character after \"-\"\n          (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)\n          XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)\n          We don't need to check the value; it's always URI safe. */\n      if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {\n        if (\n        // First condition does a very basic check if a) it's basically a valid custom element tagname AND\n        // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck\n        // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck\n        _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) ||\n        // Alternative, second condition checks if it's an `is`-attribute, AND\n        // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck\n        lcName === 'is' && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))) ; else {\n          return false;\n        }\n        /* Check value is safe. First, is attr inert? If so, is safe */\n      } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if (value) {\n        return false;\n      } else ;\n      return true;\n    };\n\n    /**\n     * _isBasicCustomElement\n     * checks if at least one dash is included in tagName, and it's not the first char\n     * for more sophisticated checking see https://github.com/sindresorhus/validate-element-name\n     *\n     * @param {string} tagName name of the tag of the node to sanitize\n     * @returns {boolean} Returns true if the tag name meets the basic criteria for a custom element, otherwise false.\n     */\n    const _isBasicCustomElement = function _isBasicCustomElement(tagName) {\n      return tagName !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT);\n    };\n\n    /**\n     * _sanitizeAttributes\n     *\n     * @protect attributes\n     * @protect nodeName\n     * @protect removeAttribute\n     * @protect setAttribute\n     *\n     * @param  {Node} currentNode to sanitize\n     */\n    const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeAttributes', currentNode, null);\n      const {\n        attributes\n      } = currentNode;\n\n      /* Check if we have attributes; if not we might have a text node */\n      if (!attributes) {\n        return;\n      }\n      const hookEvent = {\n        attrName: '',\n        attrValue: '',\n        keepAttr: true,\n        allowedAttributes: ALLOWED_ATTR\n      };\n      let l = attributes.length;\n\n      /* Go backwards over all attributes; safely remove bad ones */\n      while (l--) {\n        const attr = attributes[l];\n        const {\n          name,\n          namespaceURI,\n          value: attrValue\n        } = attr;\n        const lcName = transformCaseFunc(name);\n        let value = name === 'value' ? attrValue : stringTrim(attrValue);\n\n        /* Execute a hook if present */\n        hookEvent.attrName = lcName;\n        hookEvent.attrValue = value;\n        hookEvent.keepAttr = true;\n        hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set\n        _executeHook('uponSanitizeAttribute', currentNode, hookEvent);\n        value = hookEvent.attrValue;\n\n        /* Work around a security issue with comments inside attributes */\n        if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\\/(style|title)/i, value)) {\n          _removeAttribute(name, currentNode);\n          continue;\n        }\n\n        /* Did the hooks approve of the attribute? */\n        if (hookEvent.forceKeepAttr) {\n          continue;\n        }\n\n        /* Remove attribute */\n        _removeAttribute(name, currentNode);\n\n        /* Did the hooks approve of the attribute? */\n        if (!hookEvent.keepAttr) {\n          continue;\n        }\n\n        /* Work around a security issue in jQuery 3.0 */\n        if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\\/>/i, value)) {\n          _removeAttribute(name, currentNode);\n          continue;\n        }\n\n        /* Sanitize attribute content to be template-safe */\n        if (SAFE_FOR_TEMPLATES) {\n          arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {\n            value = stringReplace(value, expr, ' ');\n          });\n        }\n\n        /* Is `value` valid for this attribute? */\n        const lcTag = transformCaseFunc(currentNode.nodeName);\n        if (!_isValidAttribute(lcTag, lcName, value)) {\n          continue;\n        }\n\n        /* Full DOM Clobbering protection via namespace isolation,\n         * Prefix id and name attributes with `user-content-`\n         */\n        if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {\n          // Remove the attribute with this value\n          _removeAttribute(name, currentNode);\n\n          // Prefix the value and later re-create the attribute with the sanitized value\n          value = SANITIZE_NAMED_PROPS_PREFIX + value;\n        }\n\n        /* Handle attributes that require Trusted Types */\n        if (trustedTypesPolicy && typeof trustedTypes === 'object' && typeof trustedTypes.getAttributeType === 'function') {\n          if (namespaceURI) ; else {\n            switch (trustedTypes.getAttributeType(lcTag, lcName)) {\n              case 'TrustedHTML':\n                {\n                  value = trustedTypesPolicy.createHTML(value);\n                  break;\n                }\n              case 'TrustedScriptURL':\n                {\n                  value = trustedTypesPolicy.createScriptURL(value);\n                  break;\n                }\n            }\n          }\n        }\n\n        /* Handle invalid data-* attribute set by try-catching it */\n        try {\n          if (namespaceURI) {\n            currentNode.setAttributeNS(namespaceURI, name, value);\n          } else {\n            /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. \"x-schema\". */\n            currentNode.setAttribute(name, value);\n          }\n          if (_isClobbered(currentNode)) {\n            _forceRemove(currentNode);\n          } else {\n            arrayPop(DOMPurify.removed);\n          }\n        } catch (_) {}\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeAttributes', currentNode, null);\n    };\n\n    /**\n     * _sanitizeShadowDOM\n     *\n     * @param  {DocumentFragment} fragment to iterate over recursively\n     */\n    const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {\n      let shadowNode = null;\n      const shadowIterator = _createNodeIterator(fragment);\n\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeShadowDOM', fragment, null);\n      while (shadowNode = shadowIterator.nextNode()) {\n        /* Execute a hook if present */\n        _executeHook('uponSanitizeShadowNode', shadowNode, null);\n\n        /* Sanitize tags and elements */\n        if (_sanitizeElements(shadowNode)) {\n          continue;\n        }\n\n        /* Deep shadow DOM detected */\n        if (shadowNode.content instanceof DocumentFragment) {\n          _sanitizeShadowDOM(shadowNode.content);\n        }\n\n        /* Check attributes, sanitize if necessary */\n        _sanitizeAttributes(shadowNode);\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeShadowDOM', fragment, null);\n    };\n\n    /**\n     * Sanitize\n     * Public method providing core sanitation functionality\n     *\n     * @param {String|Node} dirty string or DOM node\n     * @param {Object} cfg object\n     */\n    // eslint-disable-next-line complexity\n    DOMPurify.sanitize = function (dirty) {\n      let cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      let body = null;\n      let importedNode = null;\n      let currentNode = null;\n      let returnNode = null;\n      /* Make sure we have a string to sanitize.\n        DO NOT return early, as this will return the wrong type if\n        the user has requested a DOM object rather than a string */\n      IS_EMPTY_INPUT = !dirty;\n      if (IS_EMPTY_INPUT) {\n        dirty = '<!-->';\n      }\n\n      /* Stringify, in case dirty is an object */\n      if (typeof dirty !== 'string' && !_isNode(dirty)) {\n        if (typeof dirty.toString === 'function') {\n          dirty = dirty.toString();\n          if (typeof dirty !== 'string') {\n            throw typeErrorCreate('dirty is not a string, aborting');\n          }\n        } else {\n          throw typeErrorCreate('toString is not a function');\n        }\n      }\n\n      /* Return dirty HTML if DOMPurify cannot run */\n      if (!DOMPurify.isSupported) {\n        return dirty;\n      }\n\n      /* Assign config vars */\n      if (!SET_CONFIG) {\n        _parseConfig(cfg);\n      }\n\n      /* Clean up removed elements */\n      DOMPurify.removed = [];\n\n      /* Check if dirty is correctly typed for IN_PLACE */\n      if (typeof dirty === 'string') {\n        IN_PLACE = false;\n      }\n      if (IN_PLACE) {\n        /* Do some early pre-sanitization to avoid unsafe root nodes */\n        if (dirty.nodeName) {\n          const tagName = transformCaseFunc(dirty.nodeName);\n          if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {\n            throw typeErrorCreate('root node is forbidden and cannot be sanitized in-place');\n          }\n        }\n      } else if (dirty instanceof Node) {\n        /* If dirty is a DOM element, append to an empty document to avoid\n           elements being stripped by the parser */\n        body = _initDocument('<!---->');\n        importedNode = body.ownerDocument.importNode(dirty, true);\n        if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === 'BODY') {\n          /* Node is already a body, use as is */\n          body = importedNode;\n        } else if (importedNode.nodeName === 'HTML') {\n          body = importedNode;\n        } else {\n          // eslint-disable-next-line unicorn/prefer-dom-node-append\n          body.appendChild(importedNode);\n        }\n      } else {\n        /* Exit directly if we have nothing to do */\n        if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&\n        // eslint-disable-next-line unicorn/prefer-includes\n        dirty.indexOf('<') === -1) {\n          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;\n        }\n\n        /* Initialize the document to work on */\n        body = _initDocument(dirty);\n\n        /* Check we have a DOM node from the data */\n        if (!body) {\n          return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : '';\n        }\n      }\n\n      /* Remove first element node (ours) if FORCE_BODY is set */\n      if (body && FORCE_BODY) {\n        _forceRemove(body.firstChild);\n      }\n\n      /* Get node iterator */\n      const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);\n\n      /* Now start iterating over the created document */\n      while (currentNode = nodeIterator.nextNode()) {\n        /* Sanitize tags and elements */\n        if (_sanitizeElements(currentNode)) {\n          continue;\n        }\n\n        /* Shadow DOM detected, sanitize it */\n        if (currentNode.content instanceof DocumentFragment) {\n          _sanitizeShadowDOM(currentNode.content);\n        }\n\n        /* Check attributes, sanitize if necessary */\n        _sanitizeAttributes(currentNode);\n      }\n\n      /* If we sanitized `dirty` in-place, return it. */\n      if (IN_PLACE) {\n        return dirty;\n      }\n\n      /* Return sanitized string or DOM */\n      if (RETURN_DOM) {\n        if (RETURN_DOM_FRAGMENT) {\n          returnNode = createDocumentFragment.call(body.ownerDocument);\n          while (body.firstChild) {\n            // eslint-disable-next-line unicorn/prefer-dom-node-append\n            returnNode.appendChild(body.firstChild);\n          }\n        } else {\n          returnNode = body;\n        }\n        if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {\n          /*\n            AdoptNode() is not used because internal state is not reset\n            (e.g. the past names map of a HTMLFormElement), this is safe\n            in theory but we would rather not risk another attack vector.\n            The state that is cloned by importNode() is explicitly defined\n            by the specs.\n          */\n          returnNode = importNode.call(originalDocument, returnNode, true);\n        }\n        return returnNode;\n      }\n      let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;\n\n      /* Serialize doctype if allowed */\n      if (WHOLE_DOCUMENT && ALLOWED_TAGS['!doctype'] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {\n        serializedHTML = '<!DOCTYPE ' + body.ownerDocument.doctype.name + '>\\n' + serializedHTML;\n      }\n\n      /* Sanitize final string template-safe */\n      if (SAFE_FOR_TEMPLATES) {\n        arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {\n          serializedHTML = stringReplace(serializedHTML, expr, ' ');\n        });\n      }\n      return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;\n    };\n\n    /**\n     * Public method to set the configuration once\n     * setConfig\n     *\n     * @param {Object} cfg configuration object\n     */\n    DOMPurify.setConfig = function () {\n      let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      _parseConfig(cfg);\n      SET_CONFIG = true;\n    };\n\n    /**\n     * Public method to remove the configuration\n     * clearConfig\n     *\n     */\n    DOMPurify.clearConfig = function () {\n      CONFIG = null;\n      SET_CONFIG = false;\n    };\n\n    /**\n     * Public method to check if an attribute value is valid.\n     * Uses last set config, if any. Otherwise, uses config defaults.\n     * isValidAttribute\n     *\n     * @param  {String} tag Tag name of containing element.\n     * @param  {String} attr Attribute name.\n     * @param  {String} value Attribute value.\n     * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false.\n     */\n    DOMPurify.isValidAttribute = function (tag, attr, value) {\n      /* Initialize shared config vars if necessary. */\n      if (!CONFIG) {\n        _parseConfig({});\n      }\n      const lcTag = transformCaseFunc(tag);\n      const lcName = transformCaseFunc(attr);\n      return _isValidAttribute(lcTag, lcName, value);\n    };\n\n    /**\n     * AddHook\n     * Public method to add DOMPurify hooks\n     *\n     * @param {String} entryPoint entry point for the hook to add\n     * @param {Function} hookFunction function to execute\n     */\n    DOMPurify.addHook = function (entryPoint, hookFunction) {\n      if (typeof hookFunction !== 'function') {\n        return;\n      }\n      hooks[entryPoint] = hooks[entryPoint] || [];\n      arrayPush(hooks[entryPoint], hookFunction);\n    };\n\n    /**\n     * RemoveHook\n     * Public method to remove a DOMPurify hook at a given entryPoint\n     * (pops it from the stack of hooks if more are present)\n     *\n     * @param {String} entryPoint entry point for the hook to remove\n     * @return {Function} removed(popped) hook\n     */\n    DOMPurify.removeHook = function (entryPoint) {\n      if (hooks[entryPoint]) {\n        return arrayPop(hooks[entryPoint]);\n      }\n    };\n\n    /**\n     * RemoveHooks\n     * Public method to remove all DOMPurify hooks at a given entryPoint\n     *\n     * @param  {String} entryPoint entry point for the hooks to remove\n     */\n    DOMPurify.removeHooks = function (entryPoint) {\n      if (hooks[entryPoint]) {\n        hooks[entryPoint] = [];\n      }\n    };\n\n    /**\n     * RemoveAllHooks\n     * Public method to remove all DOMPurify hooks\n     */\n    DOMPurify.removeAllHooks = function () {\n      hooks = {};\n    };\n    return DOMPurify;\n  }\n  var purify = createDOMPurify();\n\n  return purify;\n\n}));\n//# sourceMappingURL=purify.js.map\n"],"names":["exports","entries","setPrototypeOf","isFrozen","getPrototypeOf","getOwnPropertyDescriptor","Object","freeze","seal","create","apply","construct","Reflect","x","fun","thisValue","args","Func","arrayForEach","unapply","Array","forEach","arrayPop","pop","arrayPush","push","stringToLowerCase","String","toLowerCase","stringToString","toString","stringMatch","match","stringReplace","replace","stringIndexOf","indexOf","stringTrim","trim","objectHasOwnProperty","prototype","hasOwnProperty","regExpTest","RegExp","test","typeErrorCreate","func","TypeError","_len2","arguments","length","_key2","thisArg","_len","_key","addToSet","set","array","transformCaseFunc","undefined","l","element","lcElement","cleanArray","index","clone","object","newObject","property","value","isArray","constructor","lookupGetter","prop","desc","get","html$1","svg$1","svgFilters","svgDisallowed","mathMl$1","mathMlDisallowed","text","html","svg","mathMl","xml","MUSTACHE_EXPR","ERB_EXPR","TMPLIT_EXPR","DATA_ATTR","ARIA_ATTR","IS_ALLOWED_URI","IS_SCRIPT_OR_DATA","ATTR_WHITESPACE","DOCTYPE_NAME","CUSTOM_ELEMENT","EXPRESSIONS","__proto__","getGlobal","window","purify","createDOMPurify","DOMPurify","root","version","removed","document","nodeType","isSupported","originalDocument","currentScript","DocumentFragment","HTMLTemplateElement","Node","Element","NodeFilter","NamedNodeMap","MozNamedAttrMap","HTMLFormElement","DOMParser","trustedTypes","ElementPrototype","cloneNode","remove","getNextSibling","getChildNodes","getParentNode","template","createElement","content","ownerDocument","trustedTypesPolicy","emptyHTML","implementation","createNodeIterator","createDocumentFragment","getElementsByTagName","importNode","hooks","createHTMLDocument","IS_ALLOWED_URI$1","ALLOWED_TAGS","DEFAULT_ALLOWED_TAGS","ALLOWED_ATTR","DEFAULT_ALLOWED_ATTR","CUSTOM_ELEMENT_HANDLING","tagNameCheck","writable","configurable","enumerable","attributeNameCheck","allowCustomizedBuiltInElements","FORBID_TAGS","FORBID_ATTR","ALLOW_ARIA_ATTR","ALLOW_DATA_ATTR","ALLOW_UNKNOWN_PROTOCOLS","ALLOW_SELF_CLOSE_IN_ATTR","SAFE_FOR_TEMPLATES","SAFE_FOR_XML","WHOLE_DOCUMENT","SET_CONFIG","FORCE_BODY","RETURN_DOM","RETURN_DOM_FRAGMENT","RETURN_TRUSTED_TYPE","SANITIZE_DOM","SANITIZE_NAMED_PROPS","KEEP_CONTENT","IN_PLACE","USE_PROFILES","FORBID_CONTENTS","DEFAULT_FORBID_CONTENTS","DATA_URI_TAGS","DEFAULT_DATA_URI_TAGS","URI_SAFE_ATTRIBUTES","DEFAULT_URI_SAFE_ATTRIBUTES","MATHML_NAMESPACE","SVG_NAMESPACE","HTML_NAMESPACE","NAMESPACE","IS_EMPTY_INPUT","ALLOWED_NAMESPACES","DEFAULT_ALLOWED_NAMESPACES","PARSER_MEDIA_TYPE","SUPPORTED_PARSER_MEDIA_TYPES","CONFIG","formElement","isRegexOrFunction","testValue","Function","_parseConfig","cfg","ADD_URI_SAFE_ATTR","ADD_DATA_URI_TAGS","ALLOWED_URI_REGEXP","ADD_TAGS","ADD_ATTR","table","tbody","TRUSTED_TYPES_POLICY","createHTML","createScriptURL","purifyHostElement","createPolicy","suffix","ATTR_NAME","hasAttribute","getAttribute","policyName","scriptUrl","_","console","warn","_createTrustedTypesPolicy","MATHML_TEXT_INTEGRATION_POINTS","HTML_INTEGRATION_POINTS","COMMON_SVG_AND_HTML_ELEMENTS","ALL_SVG_TAGS","ALL_MATHML_TAGS","_forceRemove","node","removeChild","_removeAttribute","name","attribute","getAttributeNode","from","removeAttribute","setAttribute","_initDocument","dirty","doc","leadingWhitespace","matches","dirtyPayload","parseFromString","documentElement","createDocument","innerHTML","body","insertBefore","createTextNode","childNodes","call","_createNodeIterator","SHOW_ELEMENT","SHOW_COMMENT","SHOW_TEXT","SHOW_PROCESSING_INSTRUCTION","SHOW_CDATA_SECTION","_isClobbered","elm","nodeName","textContent","attributes","namespaceURI","hasChildNodes","_isNode","_executeHook","entryPoint","currentNode","data","hook","_sanitizeElements","tagName","allowedTags","firstElementChild","_isBasicCustomElement","parentNode","i","childClone","__removalCount","parent","parentTagName","Boolean","_checkValidNamespace","expr","_isValidAttribute","lcTag","lcName","_sanitizeAttributes","hookEvent","attrName","attrValue","keepAttr","allowedAttributes","attr","forceKeepAttr","getAttributeType","setAttributeNS","_sanitizeShadowDOM","fragment","shadowNode","shadowIterator","nextNode","sanitize","importedNode","returnNode","appendChild","firstChild","nodeIterator","shadowroot","shadowrootmode","serializedHTML","outerHTML","doctype","setConfig","clearConfig","isValidAttribute","tag","addHook","hookFunction","removeHook","removeHooks","removeAllHooks","factory"],"mappings":"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","x_google_ignoreList":[0]}

package/external/.pnpm/fuse.js@7.0.0/node_modules/fuse.js/dist/fuse.js

@@ -1,2 +0,0 @@
-'use strict';function isArray(e){return Array.isArray?Array.isArray(e):getTag(e)==='[object Array]'}function isString(e){return typeof e=='string'}function isNumber(e){return typeof e=='number'}function isObject(e){return typeof e=='object'}function isDefined(e){return e!==void 0&&e!==null}function isBlank(e){return!e.trim().length}function getTag(e){return e==null?e===void 0?'[object Undefined]':'[object Null]':{}.toString.call(e)}Object.defineProperty(exports,'__esModule',{value:!0});const hasOwn={}.hasOwnProperty;class KeyStore{constructor(e){this._keys=[],this._keyMap={};let t=0;e.forEach((e=>{let s=createKey(e);this._keys.push(s),this._keyMap[s.id]=s,t+=s.weight})),this._keys.forEach((e=>{e.weight/=t}))}get(e){return this._keyMap[e]}keys(){return this._keys}toJSON(){return JSON.stringify(this._keys)}}function createKey(e){let t=null;let s=null;let n=null;let i=1;let r=null;if(isString(e)||isArray(e))n=e,t=createKeyPath(e),s=createKeyId(e);else{if(!hasOwn.call(e,'name'))throw new Error("Missing name property in key");const c=e.name;if(n=c,hasOwn.call(e,'weight')&&(i=e.weight,i<=0))throw new Error((e=>`Property 'weight' in key '${e}' must be a positive integer`)(c));t=createKeyPath(c),s=createKeyId(c),r=e.getFn}return{path:t,id:s,weight:i,src:n,getFn:r}}function createKeyPath(e){return isArray(e)?e:e.split('.')}function createKeyId(e){return isArray(e)?e.join('.'):e}var Config={isCaseSensitive:!1,includeScore:!1,keys:[],shouldSort:!0,sortFn:(e,t)=>e.score===t.score?e.idx<t.idx?-1:1:e.score<t.score?-1:1,includeMatches:!1,findAllMatches:!1,minMatchCharLength:1,location:0,threshold:.6,distance:100,useExtendedSearch:!1,getFn:(e,t)=>{let s=[];let n=!1;const deepGet=(e,t,i)=>{if(isDefined(e))if(t[i]){const r=e[t[i]];if(!isDefined(r))return;if(i===t.length-1&&(isString(r)||isNumber(r)||(e=>e===!0||e===!1||(e=>isObject(e)&&e!==null)(e)&&getTag(e)=='[object Boolean]')(r)))s.push((e=>e==null?'':(e=>{if(typeof e=='string')return e;let t=e+'';return t=='0'&&1/e==-1/0?'-0':t})(e))(r));else if(isArray(r)){n=!0;for(let e=0,s=r.length;e<s;e+=1)deepGet(r[e],t,i+1)}else t.length&&deepGet(r,t,i+1)}else s.push(e)};return deepGet(e,isString(t)?t.split('.'):t,0),n?s:s[0]},ignoreLocation:!1,ignoreFieldNorm:!1,fieldNormWeight:1};const SPACE=/[^ ]+/g;class FuseIndex{constructor({getFn:e=Config.getFn,fieldNormWeight:t=Config.fieldNormWeight}={}){this.norm=((e=1,t=3)=>{const s=new Map;const n=Math.pow(10,t);return{get(t){const i=t.match(SPACE).length;if(s.has(i))return s.get(i);const r=1/Math.pow(i,.5*e);const c=parseFloat(Math.round(r*n)/n);return s.set(i,c),c},clear(){s.clear()}}})(t,3),this.getFn=e,this.isCreated=!1,this.setIndexRecords()}setSources(e=[]){this.docs=e}setIndexRecords(e=[]){this.records=e}setKeys(e=[]){this.keys=e,this._keysMap={},e.forEach(((e,t)=>{this._keysMap[e.id]=t}))}create(){!this.isCreated&&this.docs.length&&(this.isCreated=!0,isString(this.docs[0])?this.docs.forEach(((e,t)=>{this._addString(e,t)})):this.docs.forEach(((e,t)=>{this._addObject(e,t)})),this.norm.clear())}add(e){const t=this.size();isString(e)?this._addString(e,t):this._addObject(e,t)}removeAt(e){this.records.splice(e,1);for(let t=e,s=this.size();t<s;t+=1)this.records[t].i-=1}getValueForItemAtKeyId(e,t){return e[this._keysMap[t]]}size(){return this.records.length}_addString(e,t){if(!isDefined(e)||isBlank(e))return;let s={v:e,i:t,n:this.norm.get(e)};this.records.push(s)}_addObject(e,t){let s={i:t,$:{}};this.keys.forEach(((t,n)=>{let i=t.getFn?t.getFn(e):this.getFn(e,t.path);if(isDefined(i))if(isArray(i)){let e=[];const t=[{nestedArrIndex:-1,value:i}];for(;t.length;){const{nestedArrIndex:s,value:n}=t.pop();if(isDefined(n))if(isString(n)&&!isBlank(n)){let t={v:n,i:s,n:this.norm.get(n)};e.push(t)}else isArray(n)&&n.forEach(((e,s)=>{t.push({nestedArrIndex:s,value:e})}))}s.$[n]=e}else if(isString(i)&&!isBlank(i)){let e={v:i,n:this.norm.get(i)};s.$[n]=e}})),this.records.push(s)}toJSON(){return{keys:this.keys,records:this.records}}}function createIndex(e,t,{getFn:s=Config.getFn,fieldNormWeight:n=Config.fieldNormWeight}={}){const i=new FuseIndex({getFn:s,fieldNormWeight:n});return i.setKeys(e.map(createKey)),i.setSources(t),i.create(),i}function computeScore$1(e,{errors:t=0,currentLocation:s=0,expectedLocation:n=0,distance:i=Config.distance,ignoreLocation:r=Config.ignoreLocation}={}){const c=t/e.length;if(r)return c;const o=Math.abs(n-s);return i?c+o/i:o?1:c}function createPatternAlphabet(e){let t={};for(let s=0,n=e.length;s<n;s+=1){const i=e.charAt(s);t[i]=(t[i]||0)|1<<n-s-1}return t}class BitapSearch{constructor(e,{location:t=Config.location,threshold:s=Config.threshold,distance:n=Config.distance,includeMatches:i=Config.includeMatches,findAllMatches:r=Config.findAllMatches,minMatchCharLength:c=Config.minMatchCharLength,isCaseSensitive:o=Config.isCaseSensitive,ignoreLocation:a=Config.ignoreLocation}={}){if(this.options={location:t,threshold:s,distance:n,includeMatches:i,findAllMatches:r,minMatchCharLength:c,isCaseSensitive:o,ignoreLocation:a},this.pattern=o?e:e.toLowerCase(),this.chunks=[],!this.pattern.length)return;const addChunk=(e,t)=>{this.chunks.push({pattern:e,alphabet:createPatternAlphabet(e),startIndex:t})};const h=this.pattern.length;if(h>32){let e=0;const t=h%32;const s=h-t;for(;e<s;)addChunk(this.pattern.substr(e,32),e),e+=32;if(t){const e=h-32;addChunk(this.pattern.substr(e),e)}}else addChunk(this.pattern,0)}searchIn(e){const{isCaseSensitive:t,includeMatches:s}=this.options;if(t||(e=e.toLowerCase()),this.pattern===e){let t={isMatch:!0,score:0};return s&&(t.indices=[[0,e.length-1]]),t}const{location:n,distance:i,threshold:r,findAllMatches:c,minMatchCharLength:o,ignoreLocation:a}=this.options;let h=[];let l=0;let u=!1;this.chunks.forEach((({pattern:t,alphabet:d,startIndex:g})=>{const{isMatch:f,score:p,indices:M}=((e,t,s,{location:n=Config.location,distance:i=Config.distance,threshold:r=Config.threshold,findAllMatches:c=Config.findAllMatches,minMatchCharLength:o=Config.minMatchCharLength,includeMatches:a=Config.includeMatches,ignoreLocation:h=Config.ignoreLocation}={})=>{if(t.length>32)throw new Error("Pattern length exceeds max of 32.");const l=t.length;const u=e.length;const d=Math.max(0,Math.min(n,u));let g=r;let f=d;const p=o>1||a;const M=p?Array(u):[];let m;for(;(m=e.indexOf(t,f))>-1;){let e=computeScore$1(t,{currentLocation:m,expectedLocation:d,distance:i,ignoreLocation:h});if(g=Math.min(e,g),f=m+l,p){let e=0;for(;e<l;)M[m+e]=1,e+=1}}f=-1;let x=[];let y=1;let C=l+u;const S=1<<l-1;for(let n=0;n<l;n+=1){let r=0;let o=C;for(;r<o;)computeScore$1(t,{errors:n,currentLocation:d+o,expectedLocation:d,distance:i,ignoreLocation:h})<=g?r=o:C=o,o=Math.floor((C-r)/2+r);C=o;let a=Math.max(1,d-o+1);let m=c?u:Math.min(d+o,u)+l;let L=Array(m+2);L[m+1]=(1<<n)-1;for(let r=m;r>=a;r-=1){let c=r-1;let o=s[e.charAt(c)];if(p&&(M[c]=+!!o),L[r]=(L[r+1]<<1|1)&o,n&&(L[r]|=(x[r+1]|x[r])<<1|1|x[r+1]),L[r]&S&&(y=computeScore$1(t,{errors:n,currentLocation:c,expectedLocation:d,distance:i,ignoreLocation:h}),y<=g)){if(g=y,f=c,f<=d)break;a=Math.max(1,2*d-f)}}if(computeScore$1(t,{errors:n+1,currentLocation:d,expectedLocation:d,distance:i,ignoreLocation:h})>g)break;x=L}const L={isMatch:f>=0,score:Math.max(.001,y)};if(p){const e=((e=[],t=Config.minMatchCharLength)=>{let s=[];let n=-1;let i=-1;let r=0;for(let c=e.length;r<c;r+=1){let c=e[r];c&&n===-1?n=r:c||n===-1||(i=r-1,i-n+1>=t&&s.push([n,i]),n=-1)}return e[r-1]&&r-n>=t&&s.push([n,r-1]),s})(M,o);e.length?a&&(L.indices=e):L.isMatch=!1}return L})(e,t,d,{location:n+g,distance:i,threshold:r,findAllMatches:c,minMatchCharLength:o,includeMatches:s,ignoreLocation:a});f&&(u=!0),l+=p,f&&M&&(h=[...h,...M])}));let d={isMatch:u,score:u?l/this.chunks.length:1};return u&&s&&(d.indices=h),d}}class BaseMatch{constructor(e){this.pattern=e}static isMultiMatch(e){return getMatch(e,this.multiRegex)}static isSingleMatch(e){return getMatch(e,this.singleRegex)}search(){}}function getMatch(e,t){const s=e.match(t);return s?s[1]:null}class FuzzyMatch extends BaseMatch{constructor(e,{location:t=Config.location,threshold:s=Config.threshold,distance:n=Config.distance,includeMatches:i=Config.includeMatches,findAllMatches:r=Config.findAllMatches,minMatchCharLength:c=Config.minMatchCharLength,isCaseSensitive:o=Config.isCaseSensitive,ignoreLocation:a=Config.ignoreLocation}={}){super(e),this._bitapSearch=new BitapSearch(e,{location:t,threshold:s,distance:n,includeMatches:i,findAllMatches:r,minMatchCharLength:c,isCaseSensitive:o,ignoreLocation:a})}static get type(){return'fuzzy'}static get multiRegex(){return/^"(.*)"$/}static get singleRegex(){return/^(.*)$/}search(e){return this._bitapSearch.searchIn(e)}}class IncludeMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'include'}static get multiRegex(){return/^'"(.*)"$/}static get singleRegex(){return/^'(.*)$/}search(e){let t=0;let s;const n=[];const i=this.pattern.length;for(;(s=e.indexOf(this.pattern,t))>-1;)t=s+i,n.push([s,t-1]);const r=!!n.length;return{isMatch:r,score:r?0:1,indices:n}}}const searchers=[class ExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'exact'}static get multiRegex(){return/^="(.*)"$/}static get singleRegex(){return/^=(.*)$/}search(e){const t=e===this.pattern;return{isMatch:t,score:t?0:1,indices:[0,this.pattern.length-1]}}},IncludeMatch,class PrefixExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'prefix-exact'}static get multiRegex(){return/^\^"(.*)"$/}static get singleRegex(){return/^\^(.*)$/}search(e){const t=e.startsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,this.pattern.length-1]}}},class InversePrefixExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'inverse-prefix-exact'}static get multiRegex(){return/^!\^"(.*)"$/}static get singleRegex(){return/^!\^(.*)$/}search(e){const t=!e.startsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}},class InverseSuffixExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'inverse-suffix-exact'}static get multiRegex(){return/^!"(.*)"\$$/}static get singleRegex(){return/^!(.*)\$$/}search(e){const t=!e.endsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}},class SuffixExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'suffix-exact'}static get multiRegex(){return/^"(.*)"\$$/}static get singleRegex(){return/^(.*)\$$/}search(e){const t=e.endsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[e.length-this.pattern.length,e.length-1]}}},class InverseExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'inverse-exact'}static get multiRegex(){return/^!"(.*)"$/}static get singleRegex(){return/^!(.*)$/}search(e){const t=e.indexOf(this.pattern)===-1;return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}},FuzzyMatch];const searchersLen=searchers.length;const SPACE_RE=/ +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;const MultiMatchSet=new Set([FuzzyMatch.type,IncludeMatch.type]);const registeredSearchers=[];function createSearcher(e,t){for(let s=0,n=registeredSearchers.length;s<n;s+=1){let n=registeredSearchers[s];if(n.condition(e,t))return new n(e,t)}return new BitapSearch(e,t)}const LogicalOperator_AND='$and';const isExpression=e=>!(!e.$and&&!e.$or);const convertToExplicit=e=>({[LogicalOperator_AND]:Object.keys(e).map((t=>({[t]:e[t]})))});function parse(e,t,{auto:s=!0}={}){const next=e=>{let n=Object.keys(e);const i=(e=>!!e.$path)(e);if(!i&&n.length>1&&!isExpression(e))return next(convertToExplicit(e));if((e=>!isArray(e)&&isObject(e)&&!isExpression(e))(e)){const r=i?e.$path:n[0];const c=i?e.$val:e[r];if(!isString(c))throw new Error((e=>`Invalid value for key ${e}`)(r));const o={keyId:createKeyId(r),pattern:c};return s&&(o.searcher=createSearcher(c,t)),o}let r={children:[],operator:n[0]};return n.forEach((t=>{const s=e[t];isArray(s)&&s.forEach((e=>{r.children.push(next(e))}))})),r};return isExpression(e)||(e=convertToExplicit(e)),next(e)}function transformMatches(e,t){const s=e.matches;t.matches=[],isDefined(s)&&s.forEach((e=>{if(!isDefined(e.indices)||!e.indices.length)return;const{indices:s,value:n}=e;let i={indices:s,value:n};e.key&&(i.key=e.key.src),e.idx>-1&&(i.refIndex=e.idx),t.matches.push(i)}))}function transformScore(e,t){t.score=e.score}class Fuse{constructor(e,t={},s){this.options={...Config,...t},this._keyStore=new KeyStore(this.options.keys),this.setCollection(e,s)}setCollection(e,t){if(this._docs=e,t&&!(t instanceof FuseIndex))throw new Error("Incorrect 'index' type");this._myIndex=t||createIndex(this.options.keys,this._docs,{getFn:this.options.getFn,fieldNormWeight:this.options.fieldNormWeight})}add(e){isDefined(e)&&(this._docs.push(e),this._myIndex.add(e))}remove(e=()=>!1){const t=[];for(let s=0,n=this._docs.length;s<n;s+=1){const i=this._docs[s];e(i,s)&&(this.removeAt(s),s-=1,n-=1,t.push(i))}return t}removeAt(e){this._docs.splice(e,1),this._myIndex.removeAt(e)}getIndex(){return this._myIndex}search(e,{limit:t=-1}={}){const{includeMatches:s,includeScore:n,shouldSort:i,sortFn:r,ignoreFieldNorm:c}=this.options;let o=isString(e)?isString(this._docs[0])?this._searchStringList(e):this._searchObjectList(e):this._searchLogical(e);return((e,{ignoreFieldNorm:t=Config.ignoreFieldNorm})=>{e.forEach((e=>{let s=1;e.matches.forEach((({key:e,norm:n,score:i})=>{const r=e?e.weight:null;s*=Math.pow(i===0&&r?Number.EPSILON:i,(r||1)*(t?1:n))})),e.score=s}))})(o,{ignoreFieldNorm:c}),i&&o.sort(r),isNumber(t)&&t>-1&&(o=o.slice(0,t)),((e,t,{includeMatches:s=Config.includeMatches,includeScore:n=Config.includeScore}={})=>{const i=[];return s&&i.push(transformMatches),n&&i.push(transformScore),e.map((e=>{const{idx:s}=e;const n={item:t[s],refIndex:s};return i.length&&i.forEach((t=>{t(e,n)})),n}))})(o,this._docs,{includeMatches:s,includeScore:n})}_searchStringList(e){const t=createSearcher(e,this.options);const{records:s}=this._myIndex;const n=[];return s.forEach((({v:e,i:s,n:i})=>{if(!isDefined(e))return;const{isMatch:r,score:c,indices:o}=t.searchIn(e);r&&n.push({item:e,idx:s,matches:[{score:c,value:e,norm:i,indices:o}]})})),n}_searchLogical(e){const t=parse(e,this.options);const evaluate=(e,t,s)=>{if(!e.children){const{keyId:n,searcher:i}=e;const r=this._findMatches({key:this._keyStore.get(n),value:this._myIndex.getValueForItemAtKeyId(t,n),searcher:i});return r&&r.length?[{idx:s,item:t,matches:r}]:[]}const n=[];for(let i=0,r=e.children.length;i<r;i+=1){const r=evaluate(e.children[i],t,s);if(r.length)n.push(...r);else if(e.operator==="$and")return[]}return n};const s={};const n=[];return this._myIndex.records.forEach((({$:e,i})=>{if(isDefined(e)){let r=evaluate(t,e,i);r.length&&(s[i]||(s[i]={idx:i,item:e,matches:[]},n.push(s[i])),r.forEach((({matches:e})=>{s[i].matches.push(...e)})))}})),n}_searchObjectList(e){const t=createSearcher(e,this.options);const{keys:s,records:n}=this._myIndex;const i=[];return n.forEach((({$:e,i:n})=>{if(!isDefined(e))return;let r=[];s.forEach(((s,n)=>{r.push(...this._findMatches({key:s,value:e[n],searcher:t}))})),r.length&&i.push({idx:n,item:e,matches:r})})),i}_findMatches({key:e,value:t,searcher:s}){if(!isDefined(t))return[];let n=[];if(isArray(t))t.forEach((({v:t,i,n:r})=>{if(!isDefined(t))return;const{isMatch:c,score:o,indices:a}=s.searchIn(t);c&&n.push({score:o,key:e,value:t,idx:i,norm:r,indices:a})}));else{const{v:i,n:r}=t;const{isMatch:c,score:o,indices:a}=s.searchIn(i);c&&n.push({score:o,key:e,value:i,norm:r,indices:a})}return n}}Fuse.version='7.0.0',Fuse.createIndex=createIndex,Fuse.parseIndex=(e,{getFn:t=Config.getFn,fieldNormWeight:s=Config.fieldNormWeight}={})=>{const{keys:n,records:i}=e;const r=new FuseIndex({getFn:t,fieldNormWeight:s});return r.setKeys(n),r.setIndexRecords(i),r},Fuse.config=Config,Fuse.parseQuery=parse,registeredSearchers.push(class ExtendedSearch{constructor(e,{isCaseSensitive:t=Config.isCaseSensitive,includeMatches:s=Config.includeMatches,minMatchCharLength:n=Config.minMatchCharLength,ignoreLocation:i=Config.ignoreLocation,findAllMatches:r=Config.findAllMatches,location:c=Config.location,threshold:o=Config.threshold,distance:a=Config.distance}={}){this.query=null,this.options={isCaseSensitive:t,includeMatches:s,minMatchCharLength:n,findAllMatches:r,ignoreLocation:i,location:c,threshold:o,distance:a},this.pattern=t?e:e.toLowerCase(),this.query=((e,t={})=>this.pattern.split("|").map((e=>{let s=e.trim().split(SPACE_RE).filter((e=>e&&!!e.trim()));let n=[];for(let e=0,i=s.length;e<i;e+=1){const i=s[e];let r=!1;let c=-1;for(;!r&&++c<searchersLen;){const e=searchers[c];let s=e.isMultiMatch(i);s&&(n.push(new e(s,t)),r=!0)}if(!r)for(c=-1;++c<searchersLen;){const e=searchers[c];let s=e.isSingleMatch(i);if(s){n.push(new e(s,t));break}}}return n})))(0,this.options)}static condition(e,t){return t.useExtendedSearch}searchIn(e){const t=this.query;if(!t)return{isMatch:!1,score:1};const{includeMatches:s,isCaseSensitive:n}=this.options;e=n?e:e.toLowerCase();let i=0;let r=[];let c=0;for(let n=0,o=t.length;n<o;n+=1){const o=t[n];r.length=0,i=0;for(let t=0,n=o.length;t<n;t+=1){const n=o[t];const{isMatch:a,indices:h,score:l}=n.search(e);if(!a){c=0,i=0,r.length=0;break}i+=1,c+=l,s&&(MultiMatchSet.has(n.constructor.type)?r=[...r,...h]:r.push(h))}if(i){let e={isMatch:!0,score:c/i};return s&&(e.indices=r),e}}return{isMatch:!1,score:1}}}),exports.default=Fuse;
-//# sourceMappingURL=fuse.js.map

package/external/.pnpm/fuse.js@7.0.0/node_modules/fuse.js/dist/fuse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fuse.js","sources":["../../../../../../../../node_modules/.pnpm/fuse.js@7.0.0/node_modules/fuse.js/dist/fuse.mjs"],"sourcesContent":["/**\n * Fuse.js v7.0.0 - Lightweight fuzzy-search (http://fusejs.io)\n *\n * Copyright (c) 2023 Kiro Risk (http://kiro.me)\n * All Rights Reserved. Apache Software License 2.0\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n */\n\nfunction isArray(value) {\n  return !Array.isArray\n    ? getTag(value) === '[object Array]'\n    : Array.isArray(value)\n}\n\n// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/baseToString.js\nconst INFINITY = 1 / 0;\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value\n  }\n  let result = value + '';\n  return result == '0' && 1 / value == -INFINITY ? '-0' : result\n}\n\nfunction toString(value) {\n  return value == null ? '' : baseToString(value)\n}\n\nfunction isString(value) {\n  return typeof value === 'string'\n}\n\nfunction isNumber(value) {\n  return typeof value === 'number'\n}\n\n// Adapted from: https://github.com/lodash/lodash/blob/master/isBoolean.js\nfunction isBoolean(value) {\n  return (\n    value === true ||\n    value === false ||\n    (isObjectLike(value) && getTag(value) == '[object Boolean]')\n  )\n}\n\nfunction isObject(value) {\n  return typeof value === 'object'\n}\n\n// Checks if `value` is object-like.\nfunction isObjectLike(value) {\n  return isObject(value) && value !== null\n}\n\nfunction isDefined(value) {\n  return value !== undefined && value !== null\n}\n\nfunction isBlank(value) {\n  return !value.trim().length\n}\n\n// Gets the `toStringTag` of `value`.\n// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/getTag.js\nfunction getTag(value) {\n  return value == null\n    ? value === undefined\n      ? '[object Undefined]'\n      : '[object Null]'\n    : Object.prototype.toString.call(value)\n}\n\nconst EXTENDED_SEARCH_UNAVAILABLE = 'Extended search is not available';\n\nconst INCORRECT_INDEX_TYPE = \"Incorrect 'index' type\";\n\nconst LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) =>\n  `Invalid value for key ${key}`;\n\nconst PATTERN_LENGTH_TOO_LARGE = (max) =>\n  `Pattern length exceeds max of ${max}.`;\n\nconst MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;\n\nconst INVALID_KEY_WEIGHT_VALUE = (key) =>\n  `Property 'weight' in key '${key}' must be a positive integer`;\n\nconst hasOwn = Object.prototype.hasOwnProperty;\n\nclass KeyStore {\n  constructor(keys) {\n    this._keys = [];\n    this._keyMap = {};\n\n    let totalWeight = 0;\n\n    keys.forEach((key) => {\n      let obj = createKey(key);\n\n      this._keys.push(obj);\n      this._keyMap[obj.id] = obj;\n\n      totalWeight += obj.weight;\n    });\n\n    // Normalize weights so that their sum is equal to 1\n    this._keys.forEach((key) => {\n      key.weight /= totalWeight;\n    });\n  }\n  get(keyId) {\n    return this._keyMap[keyId]\n  }\n  keys() {\n    return this._keys\n  }\n  toJSON() {\n    return JSON.stringify(this._keys)\n  }\n}\n\nfunction createKey(key) {\n  let path = null;\n  let id = null;\n  let src = null;\n  let weight = 1;\n  let getFn = null;\n\n  if (isString(key) || isArray(key)) {\n    src = key;\n    path = createKeyPath(key);\n    id = createKeyId(key);\n  } else {\n    if (!hasOwn.call(key, 'name')) {\n      throw new Error(MISSING_KEY_PROPERTY('name'))\n    }\n\n    const name = key.name;\n    src = name;\n\n    if (hasOwn.call(key, 'weight')) {\n      weight = key.weight;\n\n      if (weight <= 0) {\n        throw new Error(INVALID_KEY_WEIGHT_VALUE(name))\n      }\n    }\n\n    path = createKeyPath(name);\n    id = createKeyId(name);\n    getFn = key.getFn;\n  }\n\n  return { path, id, weight, src, getFn }\n}\n\nfunction createKeyPath(key) {\n  return isArray(key) ? key : key.split('.')\n}\n\nfunction createKeyId(key) {\n  return isArray(key) ? key.join('.') : key\n}\n\nfunction get(obj, path) {\n  let list = [];\n  let arr = false;\n\n  const deepGet = (obj, path, index) => {\n    if (!isDefined(obj)) {\n      return\n    }\n    if (!path[index]) {\n      // If there's no path left, we've arrived at the object we care about.\n      list.push(obj);\n    } else {\n      let key = path[index];\n\n      const value = obj[key];\n\n      if (!isDefined(value)) {\n        return\n      }\n\n      // If we're at the last value in the path, and if it's a string/number/bool,\n      // add it to the list\n      if (\n        index === path.length - 1 &&\n        (isString(value) || isNumber(value) || isBoolean(value))\n      ) {\n        list.push(toString(value));\n      } else if (isArray(value)) {\n        arr = true;\n        // Search each item in the array.\n        for (let i = 0, len = value.length; i < len; i += 1) {\n          deepGet(value[i], path, index + 1);\n        }\n      } else if (path.length) {\n        // An object. Recurse further.\n        deepGet(value, path, index + 1);\n      }\n    }\n  };\n\n  // Backwards compatibility (since path used to be a string)\n  deepGet(obj, isString(path) ? path.split('.') : path, 0);\n\n  return arr ? list : list[0]\n}\n\nconst MatchOptions = {\n  // Whether the matches should be included in the result set. When `true`, each record in the result\n  // set will include the indices of the matched characters.\n  // These can consequently be used for highlighting purposes.\n  includeMatches: false,\n  // When `true`, the matching function will continue to the end of a search pattern even if\n  // a perfect match has already been located in the string.\n  findAllMatches: false,\n  // Minimum number of characters that must be matched before a result is considered a match\n  minMatchCharLength: 1\n};\n\nconst BasicOptions = {\n  // When `true`, the algorithm continues searching to the end of the input even if a perfect\n  // match is found before the end of the same input.\n  isCaseSensitive: false,\n  // When true, the matching function will continue to the end of a search pattern even if\n  includeScore: false,\n  // List of properties that will be searched. This also supports nested properties.\n  keys: [],\n  // Whether to sort the result list, by score\n  shouldSort: true,\n  // Default sort function: sort by ascending score, ascending index\n  sortFn: (a, b) =>\n    a.score === b.score ? (a.idx < b.idx ? -1 : 1) : a.score < b.score ? -1 : 1\n};\n\nconst FuzzyOptions = {\n  // Approximately where in the text is the pattern expected to be found?\n  location: 0,\n  // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match\n  // (of both letters and location), a threshold of '1.0' would match anything.\n  threshold: 0.6,\n  // Determines how close the match must be to the fuzzy location (specified above).\n  // An exact letter match which is 'distance' characters away from the fuzzy location\n  // would score as a complete mismatch. A distance of '0' requires the match be at\n  // the exact location specified, a threshold of '1000' would require a perfect match\n  // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.\n  distance: 100\n};\n\nconst AdvancedOptions = {\n  // When `true`, it enables the use of unix-like search commands\n  useExtendedSearch: false,\n  // The get function to use when fetching an object's properties.\n  // The default will search nested paths *ie foo.bar.baz*\n  getFn: get,\n  // When `true`, search will ignore `location` and `distance`, so it won't matter\n  // where in the string the pattern appears.\n  // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score\n  ignoreLocation: false,\n  // When `true`, the calculation for the relevance score (used for sorting) will\n  // ignore the field-length norm.\n  // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm\n  ignoreFieldNorm: false,\n  // The weight to determine how much field length norm effects scoring.\n  fieldNormWeight: 1\n};\n\nvar Config = {\n  ...BasicOptions,\n  ...MatchOptions,\n  ...FuzzyOptions,\n  ...AdvancedOptions\n};\n\nconst SPACE = /[^ ]+/g;\n\n// Field-length norm: the shorter the field, the higher the weight.\n// Set to 3 decimals to reduce index size.\nfunction norm(weight = 1, mantissa = 3) {\n  const cache = new Map();\n  const m = Math.pow(10, mantissa);\n\n  return {\n    get(value) {\n      const numTokens = value.match(SPACE).length;\n\n      if (cache.has(numTokens)) {\n        return cache.get(numTokens)\n      }\n\n      // Default function is 1/sqrt(x), weight makes that variable\n      const norm = 1 / Math.pow(numTokens, 0.5 * weight);\n\n      // In place of `toFixed(mantissa)`, for faster computation\n      const n = parseFloat(Math.round(norm * m) / m);\n\n      cache.set(numTokens, n);\n\n      return n\n    },\n    clear() {\n      cache.clear();\n    }\n  }\n}\n\nclass FuseIndex {\n  constructor({\n    getFn = Config.getFn,\n    fieldNormWeight = Config.fieldNormWeight\n  } = {}) {\n    this.norm = norm(fieldNormWeight, 3);\n    this.getFn = getFn;\n    this.isCreated = false;\n\n    this.setIndexRecords();\n  }\n  setSources(docs = []) {\n    this.docs = docs;\n  }\n  setIndexRecords(records = []) {\n    this.records = records;\n  }\n  setKeys(keys = []) {\n    this.keys = keys;\n    this._keysMap = {};\n    keys.forEach((key, idx) => {\n      this._keysMap[key.id] = idx;\n    });\n  }\n  create() {\n    if (this.isCreated || !this.docs.length) {\n      return\n    }\n\n    this.isCreated = true;\n\n    // List is Array<String>\n    if (isString(this.docs[0])) {\n      this.docs.forEach((doc, docIndex) => {\n        this._addString(doc, docIndex);\n      });\n    } else {\n      // List is Array<Object>\n      this.docs.forEach((doc, docIndex) => {\n        this._addObject(doc, docIndex);\n      });\n    }\n\n    this.norm.clear();\n  }\n  // Adds a doc to the end of the index\n  add(doc) {\n    const idx = this.size();\n\n    if (isString(doc)) {\n      this._addString(doc, idx);\n    } else {\n      this._addObject(doc, idx);\n    }\n  }\n  // Removes the doc at the specified index of the index\n  removeAt(idx) {\n    this.records.splice(idx, 1);\n\n    // Change ref index of every subsquent doc\n    for (let i = idx, len = this.size(); i < len; i += 1) {\n      this.records[i].i -= 1;\n    }\n  }\n  getValueForItemAtKeyId(item, keyId) {\n    return item[this._keysMap[keyId]]\n  }\n  size() {\n    return this.records.length\n  }\n  _addString(doc, docIndex) {\n    if (!isDefined(doc) || isBlank(doc)) {\n      return\n    }\n\n    let record = {\n      v: doc,\n      i: docIndex,\n      n: this.norm.get(doc)\n    };\n\n    this.records.push(record);\n  }\n  _addObject(doc, docIndex) {\n    let record = { i: docIndex, $: {} };\n\n    // Iterate over every key (i.e, path), and fetch the value at that key\n    this.keys.forEach((key, keyIndex) => {\n      let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);\n\n      if (!isDefined(value)) {\n        return\n      }\n\n      if (isArray(value)) {\n        let subRecords = [];\n        const stack = [{ nestedArrIndex: -1, value }];\n\n        while (stack.length) {\n          const { nestedArrIndex, value } = stack.pop();\n\n          if (!isDefined(value)) {\n            continue\n          }\n\n          if (isString(value) && !isBlank(value)) {\n            let subRecord = {\n              v: value,\n              i: nestedArrIndex,\n              n: this.norm.get(value)\n            };\n\n            subRecords.push(subRecord);\n          } else if (isArray(value)) {\n            value.forEach((item, k) => {\n              stack.push({\n                nestedArrIndex: k,\n                value: item\n              });\n            });\n          } else ;\n        }\n        record.$[keyIndex] = subRecords;\n      } else if (isString(value) && !isBlank(value)) {\n        let subRecord = {\n          v: value,\n          n: this.norm.get(value)\n        };\n\n        record.$[keyIndex] = subRecord;\n      }\n    });\n\n    this.records.push(record);\n  }\n  toJSON() {\n    return {\n      keys: this.keys,\n      records: this.records\n    }\n  }\n}\n\nfunction createIndex(\n  keys,\n  docs,\n  { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}\n) {\n  const myIndex = new FuseIndex({ getFn, fieldNormWeight });\n  myIndex.setKeys(keys.map(createKey));\n  myIndex.setSources(docs);\n  myIndex.create();\n  return myIndex\n}\n\nfunction parseIndex(\n  data,\n  { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}\n) {\n  const { keys, records } = data;\n  const myIndex = new FuseIndex({ getFn, fieldNormWeight });\n  myIndex.setKeys(keys);\n  myIndex.setIndexRecords(records);\n  return myIndex\n}\n\nfunction computeScore$1(\n  pattern,\n  {\n    errors = 0,\n    currentLocation = 0,\n    expectedLocation = 0,\n    distance = Config.distance,\n    ignoreLocation = Config.ignoreLocation\n  } = {}\n) {\n  const accuracy = errors / pattern.length;\n\n  if (ignoreLocation) {\n    return accuracy\n  }\n\n  const proximity = Math.abs(expectedLocation - currentLocation);\n\n  if (!distance) {\n    // Dodge divide by zero error.\n    return proximity ? 1.0 : accuracy\n  }\n\n  return accuracy + proximity / distance\n}\n\nfunction convertMaskToIndices(\n  matchmask = [],\n  minMatchCharLength = Config.minMatchCharLength\n) {\n  let indices = [];\n  let start = -1;\n  let end = -1;\n  let i = 0;\n\n  for (let len = matchmask.length; i < len; i += 1) {\n    let match = matchmask[i];\n    if (match && start === -1) {\n      start = i;\n    } else if (!match && start !== -1) {\n      end = i - 1;\n      if (end - start + 1 >= minMatchCharLength) {\n        indices.push([start, end]);\n      }\n      start = -1;\n    }\n  }\n\n  // (i-1 - start) + 1 => i - start\n  if (matchmask[i - 1] && i - start >= minMatchCharLength) {\n    indices.push([start, i - 1]);\n  }\n\n  return indices\n}\n\n// Machine word size\nconst MAX_BITS = 32;\n\nfunction search(\n  text,\n  pattern,\n  patternAlphabet,\n  {\n    location = Config.location,\n    distance = Config.distance,\n    threshold = Config.threshold,\n    findAllMatches = Config.findAllMatches,\n    minMatchCharLength = Config.minMatchCharLength,\n    includeMatches = Config.includeMatches,\n    ignoreLocation = Config.ignoreLocation\n  } = {}\n) {\n  if (pattern.length > MAX_BITS) {\n    throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS))\n  }\n\n  const patternLen = pattern.length;\n  // Set starting location at beginning text and initialize the alphabet.\n  const textLen = text.length;\n  // Handle the case when location > text.length\n  const expectedLocation = Math.max(0, Math.min(location, textLen));\n  // Highest score beyond which we give up.\n  let currentThreshold = threshold;\n  // Is there a nearby exact match? (speedup)\n  let bestLocation = expectedLocation;\n\n  // Performance: only computer matches when the minMatchCharLength > 1\n  // OR if `includeMatches` is true.\n  const computeMatches = minMatchCharLength > 1 || includeMatches;\n  // A mask of the matches, used for building the indices\n  const matchMask = computeMatches ? Array(textLen) : [];\n\n  let index;\n\n  // Get all exact matches, here for speed up\n  while ((index = text.indexOf(pattern, bestLocation)) > -1) {\n    let score = computeScore$1(pattern, {\n      currentLocation: index,\n      expectedLocation,\n      distance,\n      ignoreLocation\n    });\n\n    currentThreshold = Math.min(score, currentThreshold);\n    bestLocation = index + patternLen;\n\n    if (computeMatches) {\n      let i = 0;\n      while (i < patternLen) {\n        matchMask[index + i] = 1;\n        i += 1;\n      }\n    }\n  }\n\n  // Reset the best location\n  bestLocation = -1;\n\n  let lastBitArr = [];\n  let finalScore = 1;\n  let binMax = patternLen + textLen;\n\n  const mask = 1 << (patternLen - 1);\n\n  for (let i = 0; i < patternLen; i += 1) {\n    // Scan for the best match; each iteration allows for one more error.\n    // Run a binary search to determine how far from the match location we can stray\n    // at this error level.\n    let binMin = 0;\n    let binMid = binMax;\n\n    while (binMin < binMid) {\n      const score = computeScore$1(pattern, {\n        errors: i,\n        currentLocation: expectedLocation + binMid,\n        expectedLocation,\n        distance,\n        ignoreLocation\n      });\n\n      if (score <= currentThreshold) {\n        binMin = binMid;\n      } else {\n        binMax = binMid;\n      }\n\n      binMid = Math.floor((binMax - binMin) / 2 + binMin);\n    }\n\n    // Use the result from this iteration as the maximum for the next.\n    binMax = binMid;\n\n    let start = Math.max(1, expectedLocation - binMid + 1);\n    let finish = findAllMatches\n      ? textLen\n      : Math.min(expectedLocation + binMid, textLen) + patternLen;\n\n    // Initialize the bit array\n    let bitArr = Array(finish + 2);\n\n    bitArr[finish + 1] = (1 << i) - 1;\n\n    for (let j = finish; j >= start; j -= 1) {\n      let currentLocation = j - 1;\n      let charMatch = patternAlphabet[text.charAt(currentLocation)];\n\n      if (computeMatches) {\n        // Speed up: quick bool to int conversion (i.e, `charMatch ? 1 : 0`)\n        matchMask[currentLocation] = +!!charMatch;\n      }\n\n      // First pass: exact match\n      bitArr[j] = ((bitArr[j + 1] << 1) | 1) & charMatch;\n\n      // Subsequent passes: fuzzy match\n      if (i) {\n        bitArr[j] |=\n          ((lastBitArr[j + 1] | lastBitArr[j]) << 1) | 1 | lastBitArr[j + 1];\n      }\n\n      if (bitArr[j] & mask) {\n        finalScore = computeScore$1(pattern, {\n          errors: i,\n          currentLocation,\n          expectedLocation,\n          distance,\n          ignoreLocation\n        });\n\n        // This match will almost certainly be better than any existing match.\n        // But check anyway.\n        if (finalScore <= currentThreshold) {\n          // Indeed it is\n          currentThreshold = finalScore;\n          bestLocation = currentLocation;\n\n          // Already passed `loc`, downhill from here on in.\n          if (bestLocation <= expectedLocation) {\n            break\n          }\n\n          // When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.\n          start = Math.max(1, 2 * expectedLocation - bestLocation);\n        }\n      }\n    }\n\n    // No hope for a (better) match at greater error levels.\n    const score = computeScore$1(pattern, {\n      errors: i + 1,\n      currentLocation: expectedLocation,\n      expectedLocation,\n      distance,\n      ignoreLocation\n    });\n\n    if (score > currentThreshold) {\n      break\n    }\n\n    lastBitArr = bitArr;\n  }\n\n  const result = {\n    isMatch: bestLocation >= 0,\n    // Count exact matches (those with a score of 0) to be \"almost\" exact\n    score: Math.max(0.001, finalScore)\n  };\n\n  if (computeMatches) {\n    const indices = convertMaskToIndices(matchMask, minMatchCharLength);\n    if (!indices.length) {\n      result.isMatch = false;\n    } else if (includeMatches) {\n      result.indices = indices;\n    }\n  }\n\n  return result\n}\n\nfunction createPatternAlphabet(pattern) {\n  let mask = {};\n\n  for (let i = 0, len = pattern.length; i < len; i += 1) {\n    const char = pattern.charAt(i);\n    mask[char] = (mask[char] || 0) | (1 << (len - i - 1));\n  }\n\n  return mask\n}\n\nclass BitapSearch {\n  constructor(\n    pattern,\n    {\n      location = Config.location,\n      threshold = Config.threshold,\n      distance = Config.distance,\n      includeMatches = Config.includeMatches,\n      findAllMatches = Config.findAllMatches,\n      minMatchCharLength = Config.minMatchCharLength,\n      isCaseSensitive = Config.isCaseSensitive,\n      ignoreLocation = Config.ignoreLocation\n    } = {}\n  ) {\n    this.options = {\n      location,\n      threshold,\n      distance,\n      includeMatches,\n      findAllMatches,\n      minMatchCharLength,\n      isCaseSensitive,\n      ignoreLocation\n    };\n\n    this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();\n\n    this.chunks = [];\n\n    if (!this.pattern.length) {\n      return\n    }\n\n    const addChunk = (pattern, startIndex) => {\n      this.chunks.push({\n        pattern,\n        alphabet: createPatternAlphabet(pattern),\n        startIndex\n      });\n    };\n\n    const len = this.pattern.length;\n\n    if (len > MAX_BITS) {\n      let i = 0;\n      const remainder = len % MAX_BITS;\n      const end = len - remainder;\n\n      while (i < end) {\n        addChunk(this.pattern.substr(i, MAX_BITS), i);\n        i += MAX_BITS;\n      }\n\n      if (remainder) {\n        const startIndex = len - MAX_BITS;\n        addChunk(this.pattern.substr(startIndex), startIndex);\n      }\n    } else {\n      addChunk(this.pattern, 0);\n    }\n  }\n\n  searchIn(text) {\n    const { isCaseSensitive, includeMatches } = this.options;\n\n    if (!isCaseSensitive) {\n      text = text.toLowerCase();\n    }\n\n    // Exact match\n    if (this.pattern === text) {\n      let result = {\n        isMatch: true,\n        score: 0\n      };\n\n      if (includeMatches) {\n        result.indices = [[0, text.length - 1]];\n      }\n\n      return result\n    }\n\n    // Otherwise, use Bitap algorithm\n    const {\n      location,\n      distance,\n      threshold,\n      findAllMatches,\n      minMatchCharLength,\n      ignoreLocation\n    } = this.options;\n\n    let allIndices = [];\n    let totalScore = 0;\n    let hasMatches = false;\n\n    this.chunks.forEach(({ pattern, alphabet, startIndex }) => {\n      const { isMatch, score, indices } = search(text, pattern, alphabet, {\n        location: location + startIndex,\n        distance,\n        threshold,\n        findAllMatches,\n        minMatchCharLength,\n        includeMatches,\n        ignoreLocation\n      });\n\n      if (isMatch) {\n        hasMatches = true;\n      }\n\n      totalScore += score;\n\n      if (isMatch && indices) {\n        allIndices = [...allIndices, ...indices];\n      }\n    });\n\n    let result = {\n      isMatch: hasMatches,\n      score: hasMatches ? totalScore / this.chunks.length : 1\n    };\n\n    if (hasMatches && includeMatches) {\n      result.indices = allIndices;\n    }\n\n    return result\n  }\n}\n\nclass BaseMatch {\n  constructor(pattern) {\n    this.pattern = pattern;\n  }\n  static isMultiMatch(pattern) {\n    return getMatch(pattern, this.multiRegex)\n  }\n  static isSingleMatch(pattern) {\n    return getMatch(pattern, this.singleRegex)\n  }\n  search(/*text*/) {}\n}\n\nfunction getMatch(pattern, exp) {\n  const matches = pattern.match(exp);\n  return matches ? matches[1] : null\n}\n\n// Token: 'file\n\nclass ExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'exact'\n  }\n  static get multiRegex() {\n    return /^=\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^=(.*)$/\n  }\n  search(text) {\n    const isMatch = text === this.pattern;\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, this.pattern.length - 1]\n    }\n  }\n}\n\n// Token: !fire\n\nclass InverseExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'inverse-exact'\n  }\n  static get multiRegex() {\n    return /^!\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^!(.*)$/\n  }\n  search(text) {\n    const index = text.indexOf(this.pattern);\n    const isMatch = index === -1;\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, text.length - 1]\n    }\n  }\n}\n\n// Token: ^file\n\nclass PrefixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'prefix-exact'\n  }\n  static get multiRegex() {\n    return /^\\^\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^\\^(.*)$/\n  }\n  search(text) {\n    const isMatch = text.startsWith(this.pattern);\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, this.pattern.length - 1]\n    }\n  }\n}\n\n// Token: !^fire\n\nclass InversePrefixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'inverse-prefix-exact'\n  }\n  static get multiRegex() {\n    return /^!\\^\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^!\\^(.*)$/\n  }\n  search(text) {\n    const isMatch = !text.startsWith(this.pattern);\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, text.length - 1]\n    }\n  }\n}\n\n// Token: .file$\n\nclass SuffixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'suffix-exact'\n  }\n  static get multiRegex() {\n    return /^\"(.*)\"\\$$/\n  }\n  static get singleRegex() {\n    return /^(.*)\\$$/\n  }\n  search(text) {\n    const isMatch = text.endsWith(this.pattern);\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [text.length - this.pattern.length, text.length - 1]\n    }\n  }\n}\n\n// Token: !.file$\n\nclass InverseSuffixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'inverse-suffix-exact'\n  }\n  static get multiRegex() {\n    return /^!\"(.*)\"\\$$/\n  }\n  static get singleRegex() {\n    return /^!(.*)\\$$/\n  }\n  search(text) {\n    const isMatch = !text.endsWith(this.pattern);\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, text.length - 1]\n    }\n  }\n}\n\nclass FuzzyMatch extends BaseMatch {\n  constructor(\n    pattern,\n    {\n      location = Config.location,\n      threshold = Config.threshold,\n      distance = Config.distance,\n      includeMatches = Config.includeMatches,\n      findAllMatches = Config.findAllMatches,\n      minMatchCharLength = Config.minMatchCharLength,\n      isCaseSensitive = Config.isCaseSensitive,\n      ignoreLocation = Config.ignoreLocation\n    } = {}\n  ) {\n    super(pattern);\n    this._bitapSearch = new BitapSearch(pattern, {\n      location,\n      threshold,\n      distance,\n      includeMatches,\n      findAllMatches,\n      minMatchCharLength,\n      isCaseSensitive,\n      ignoreLocation\n    });\n  }\n  static get type() {\n    return 'fuzzy'\n  }\n  static get multiRegex() {\n    return /^\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^(.*)$/\n  }\n  search(text) {\n    return this._bitapSearch.searchIn(text)\n  }\n}\n\n// Token: 'file\n\nclass IncludeMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'include'\n  }\n  static get multiRegex() {\n    return /^'\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^'(.*)$/\n  }\n  search(text) {\n    let location = 0;\n    let index;\n\n    const indices = [];\n    const patternLen = this.pattern.length;\n\n    // Get all exact matches\n    while ((index = text.indexOf(this.pattern, location)) > -1) {\n      location = index + patternLen;\n      indices.push([index, location - 1]);\n    }\n\n    const isMatch = !!indices.length;\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices\n    }\n  }\n}\n\n// ❗Order is important. DO NOT CHANGE.\nconst searchers = [\n  ExactMatch,\n  IncludeMatch,\n  PrefixExactMatch,\n  InversePrefixExactMatch,\n  InverseSuffixExactMatch,\n  SuffixExactMatch,\n  InverseExactMatch,\n  FuzzyMatch\n];\n\nconst searchersLen = searchers.length;\n\n// Regex to split by spaces, but keep anything in quotes together\nconst SPACE_RE = / +(?=(?:[^\\\"]*\\\"[^\\\"]*\\\")*[^\\\"]*$)/;\nconst OR_TOKEN = '|';\n\n// Return a 2D array representation of the query, for simpler parsing.\n// Example:\n// \"^core go$ | rb$ | py$ xy$\" => [[\"^core\", \"go$\"], [\"rb$\"], [\"py$\", \"xy$\"]]\nfunction parseQuery(pattern, options = {}) {\n  return pattern.split(OR_TOKEN).map((item) => {\n    let query = item\n      .trim()\n      .split(SPACE_RE)\n      .filter((item) => item && !!item.trim());\n\n    let results = [];\n    for (let i = 0, len = query.length; i < len; i += 1) {\n      const queryItem = query[i];\n\n      // 1. Handle multiple query match (i.e, once that are quoted, like `\"hello world\"`)\n      let found = false;\n      let idx = -1;\n      while (!found && ++idx < searchersLen) {\n        const searcher = searchers[idx];\n        let token = searcher.isMultiMatch(queryItem);\n        if (token) {\n          results.push(new searcher(token, options));\n          found = true;\n        }\n      }\n\n      if (found) {\n        continue\n      }\n\n      // 2. Handle single query matches (i.e, once that are *not* quoted)\n      idx = -1;\n      while (++idx < searchersLen) {\n        const searcher = searchers[idx];\n        let token = searcher.isSingleMatch(queryItem);\n        if (token) {\n          results.push(new searcher(token, options));\n          break\n        }\n      }\n    }\n\n    return results\n  })\n}\n\n// These extended matchers can return an array of matches, as opposed\n// to a singl match\nconst MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]);\n\n/**\n * Command-like searching\n * ======================\n *\n * Given multiple search terms delimited by spaces.e.g. `^jscript .python$ ruby !java`,\n * search in a given text.\n *\n * Search syntax:\n *\n * | Token       | Match type                 | Description                            |\n * | ----------- | -------------------------- | -------------------------------------- |\n * | `jscript`   | fuzzy-match                | Items that fuzzy match `jscript`       |\n * | `=scheme`   | exact-match                | Items that are `scheme`                |\n * | `'python`   | include-match              | Items that include `python`            |\n * | `!ruby`     | inverse-exact-match        | Items that do not include `ruby`       |\n * | `^java`     | prefix-exact-match         | Items that start with `java`           |\n * | `!^earlang` | inverse-prefix-exact-match | Items that do not start with `earlang` |\n * | `.js$`      | suffix-exact-match         | Items that end with `.js`              |\n * | `!.go$`     | inverse-suffix-exact-match | Items that do not end with `.go`       |\n *\n * A single pipe character acts as an OR operator. For example, the following\n * query matches entries that start with `core` and end with either`go`, `rb`,\n * or`py`.\n *\n * ```\n * ^core go$ | rb$ | py$\n * ```\n */\nclass ExtendedSearch {\n  constructor(\n    pattern,\n    {\n      isCaseSensitive = Config.isCaseSensitive,\n      includeMatches = Config.includeMatches,\n      minMatchCharLength = Config.minMatchCharLength,\n      ignoreLocation = Config.ignoreLocation,\n      findAllMatches = Config.findAllMatches,\n      location = Config.location,\n      threshold = Config.threshold,\n      distance = Config.distance\n    } = {}\n  ) {\n    this.query = null;\n    this.options = {\n      isCaseSensitive,\n      includeMatches,\n      minMatchCharLength,\n      findAllMatches,\n      ignoreLocation,\n      location,\n      threshold,\n      distance\n    };\n\n    this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();\n    this.query = parseQuery(this.pattern, this.options);\n  }\n\n  static condition(_, options) {\n    return options.useExtendedSearch\n  }\n\n  searchIn(text) {\n    const query = this.query;\n\n    if (!query) {\n      return {\n        isMatch: false,\n        score: 1\n      }\n    }\n\n    const { includeMatches, isCaseSensitive } = this.options;\n\n    text = isCaseSensitive ? text : text.toLowerCase();\n\n    let numMatches = 0;\n    let allIndices = [];\n    let totalScore = 0;\n\n    // ORs\n    for (let i = 0, qLen = query.length; i < qLen; i += 1) {\n      const searchers = query[i];\n\n      // Reset indices\n      allIndices.length = 0;\n      numMatches = 0;\n\n      // ANDs\n      for (let j = 0, pLen = searchers.length; j < pLen; j += 1) {\n        const searcher = searchers[j];\n        const { isMatch, indices, score } = searcher.search(text);\n\n        if (isMatch) {\n          numMatches += 1;\n          totalScore += score;\n          if (includeMatches) {\n            const type = searcher.constructor.type;\n            if (MultiMatchSet.has(type)) {\n              allIndices = [...allIndices, ...indices];\n            } else {\n              allIndices.push(indices);\n            }\n          }\n        } else {\n          totalScore = 0;\n          numMatches = 0;\n          allIndices.length = 0;\n          break\n        }\n      }\n\n      // OR condition, so if TRUE, return\n      if (numMatches) {\n        let result = {\n          isMatch: true,\n          score: totalScore / numMatches\n        };\n\n        if (includeMatches) {\n          result.indices = allIndices;\n        }\n\n        return result\n      }\n    }\n\n    // Nothing was matched\n    return {\n      isMatch: false,\n      score: 1\n    }\n  }\n}\n\nconst registeredSearchers = [];\n\nfunction register(...args) {\n  registeredSearchers.push(...args);\n}\n\nfunction createSearcher(pattern, options) {\n  for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {\n    let searcherClass = registeredSearchers[i];\n    if (searcherClass.condition(pattern, options)) {\n      return new searcherClass(pattern, options)\n    }\n  }\n\n  return new BitapSearch(pattern, options)\n}\n\nconst LogicalOperator = {\n  AND: '$and',\n  OR: '$or'\n};\n\nconst KeyType = {\n  PATH: '$path',\n  PATTERN: '$val'\n};\n\nconst isExpression = (query) =>\n  !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);\n\nconst isPath = (query) => !!query[KeyType.PATH];\n\nconst isLeaf = (query) =>\n  !isArray(query) && isObject(query) && !isExpression(query);\n\nconst convertToExplicit = (query) => ({\n  [LogicalOperator.AND]: Object.keys(query).map((key) => ({\n    [key]: query[key]\n  }))\n});\n\n// When `auto` is `true`, the parse function will infer and initialize and add\n// the appropriate `Searcher` instance\nfunction parse(query, options, { auto = true } = {}) {\n  const next = (query) => {\n    let keys = Object.keys(query);\n\n    const isQueryPath = isPath(query);\n\n    if (!isQueryPath && keys.length > 1 && !isExpression(query)) {\n      return next(convertToExplicit(query))\n    }\n\n    if (isLeaf(query)) {\n      const key = isQueryPath ? query[KeyType.PATH] : keys[0];\n\n      const pattern = isQueryPath ? query[KeyType.PATTERN] : query[key];\n\n      if (!isString(pattern)) {\n        throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key))\n      }\n\n      const obj = {\n        keyId: createKeyId(key),\n        pattern\n      };\n\n      if (auto) {\n        obj.searcher = createSearcher(pattern, options);\n      }\n\n      return obj\n    }\n\n    let node = {\n      children: [],\n      operator: keys[0]\n    };\n\n    keys.forEach((key) => {\n      const value = query[key];\n\n      if (isArray(value)) {\n        value.forEach((item) => {\n          node.children.push(next(item));\n        });\n      }\n    });\n\n    return node\n  };\n\n  if (!isExpression(query)) {\n    query = convertToExplicit(query);\n  }\n\n  return next(query)\n}\n\n// Practical scoring function\nfunction computeScore(\n  results,\n  { ignoreFieldNorm = Config.ignoreFieldNorm }\n) {\n  results.forEach((result) => {\n    let totalScore = 1;\n\n    result.matches.forEach(({ key, norm, score }) => {\n      const weight = key ? key.weight : null;\n\n      totalScore *= Math.pow(\n        score === 0 && weight ? Number.EPSILON : score,\n        (weight || 1) * (ignoreFieldNorm ? 1 : norm)\n      );\n    });\n\n    result.score = totalScore;\n  });\n}\n\nfunction transformMatches(result, data) {\n  const matches = result.matches;\n  data.matches = [];\n\n  if (!isDefined(matches)) {\n    return\n  }\n\n  matches.forEach((match) => {\n    if (!isDefined(match.indices) || !match.indices.length) {\n      return\n    }\n\n    const { indices, value } = match;\n\n    let obj = {\n      indices,\n      value\n    };\n\n    if (match.key) {\n      obj.key = match.key.src;\n    }\n\n    if (match.idx > -1) {\n      obj.refIndex = match.idx;\n    }\n\n    data.matches.push(obj);\n  });\n}\n\nfunction transformScore(result, data) {\n  data.score = result.score;\n}\n\nfunction format(\n  results,\n  docs,\n  {\n    includeMatches = Config.includeMatches,\n    includeScore = Config.includeScore\n  } = {}\n) {\n  const transformers = [];\n\n  if (includeMatches) transformers.push(transformMatches);\n  if (includeScore) transformers.push(transformScore);\n\n  return results.map((result) => {\n    const { idx } = result;\n\n    const data = {\n      item: docs[idx],\n      refIndex: idx\n    };\n\n    if (transformers.length) {\n      transformers.forEach((transformer) => {\n        transformer(result, data);\n      });\n    }\n\n    return data\n  })\n}\n\nclass Fuse {\n  constructor(docs, options = {}, index) {\n    this.options = { ...Config, ...options };\n\n    if (\n      this.options.useExtendedSearch &&\n      !true\n    ) {\n      throw new Error(EXTENDED_SEARCH_UNAVAILABLE)\n    }\n\n    this._keyStore = new KeyStore(this.options.keys);\n\n    this.setCollection(docs, index);\n  }\n\n  setCollection(docs, index) {\n    this._docs = docs;\n\n    if (index && !(index instanceof FuseIndex)) {\n      throw new Error(INCORRECT_INDEX_TYPE)\n    }\n\n    this._myIndex =\n      index ||\n      createIndex(this.options.keys, this._docs, {\n        getFn: this.options.getFn,\n        fieldNormWeight: this.options.fieldNormWeight\n      });\n  }\n\n  add(doc) {\n    if (!isDefined(doc)) {\n      return\n    }\n\n    this._docs.push(doc);\n    this._myIndex.add(doc);\n  }\n\n  remove(predicate = (/* doc, idx */) => false) {\n    const results = [];\n\n    for (let i = 0, len = this._docs.length; i < len; i += 1) {\n      const doc = this._docs[i];\n      if (predicate(doc, i)) {\n        this.removeAt(i);\n        i -= 1;\n        len -= 1;\n\n        results.push(doc);\n      }\n    }\n\n    return results\n  }\n\n  removeAt(idx) {\n    this._docs.splice(idx, 1);\n    this._myIndex.removeAt(idx);\n  }\n\n  getIndex() {\n    return this._myIndex\n  }\n\n  search(query, { limit = -1 } = {}) {\n    const {\n      includeMatches,\n      includeScore,\n      shouldSort,\n      sortFn,\n      ignoreFieldNorm\n    } = this.options;\n\n    let results = isString(query)\n      ? isString(this._docs[0])\n        ? this._searchStringList(query)\n        : this._searchObjectList(query)\n      : this._searchLogical(query);\n\n    computeScore(results, { ignoreFieldNorm });\n\n    if (shouldSort) {\n      results.sort(sortFn);\n    }\n\n    if (isNumber(limit) && limit > -1) {\n      results = results.slice(0, limit);\n    }\n\n    return format(results, this._docs, {\n      includeMatches,\n      includeScore\n    })\n  }\n\n  _searchStringList(query) {\n    const searcher = createSearcher(query, this.options);\n    const { records } = this._myIndex;\n    const results = [];\n\n    // Iterate over every string in the index\n    records.forEach(({ v: text, i: idx, n: norm }) => {\n      if (!isDefined(text)) {\n        return\n      }\n\n      const { isMatch, score, indices } = searcher.searchIn(text);\n\n      if (isMatch) {\n        results.push({\n          item: text,\n          idx,\n          matches: [{ score, value: text, norm, indices }]\n        });\n      }\n    });\n\n    return results\n  }\n\n  _searchLogical(query) {\n\n    const expression = parse(query, this.options);\n\n    const evaluate = (node, item, idx) => {\n      if (!node.children) {\n        const { keyId, searcher } = node;\n\n        const matches = this._findMatches({\n          key: this._keyStore.get(keyId),\n          value: this._myIndex.getValueForItemAtKeyId(item, keyId),\n          searcher\n        });\n\n        if (matches && matches.length) {\n          return [\n            {\n              idx,\n              item,\n              matches\n            }\n          ]\n        }\n\n        return []\n      }\n\n      const res = [];\n      for (let i = 0, len = node.children.length; i < len; i += 1) {\n        const child = node.children[i];\n        const result = evaluate(child, item, idx);\n        if (result.length) {\n          res.push(...result);\n        } else if (node.operator === LogicalOperator.AND) {\n          return []\n        }\n      }\n      return res\n    };\n\n    const records = this._myIndex.records;\n    const resultMap = {};\n    const results = [];\n\n    records.forEach(({ $: item, i: idx }) => {\n      if (isDefined(item)) {\n        let expResults = evaluate(expression, item, idx);\n\n        if (expResults.length) {\n          // Dedupe when adding\n          if (!resultMap[idx]) {\n            resultMap[idx] = { idx, item, matches: [] };\n            results.push(resultMap[idx]);\n          }\n          expResults.forEach(({ matches }) => {\n            resultMap[idx].matches.push(...matches);\n          });\n        }\n      }\n    });\n\n    return results\n  }\n\n  _searchObjectList(query) {\n    const searcher = createSearcher(query, this.options);\n    const { keys, records } = this._myIndex;\n    const results = [];\n\n    // List is Array<Object>\n    records.forEach(({ $: item, i: idx }) => {\n      if (!isDefined(item)) {\n        return\n      }\n\n      let matches = [];\n\n      // Iterate over every key (i.e, path), and fetch the value at that key\n      keys.forEach((key, keyIndex) => {\n        matches.push(\n          ...this._findMatches({\n            key,\n            value: item[keyIndex],\n            searcher\n          })\n        );\n      });\n\n      if (matches.length) {\n        results.push({\n          idx,\n          item,\n          matches\n        });\n      }\n    });\n\n    return results\n  }\n  _findMatches({ key, value, searcher }) {\n    if (!isDefined(value)) {\n      return []\n    }\n\n    let matches = [];\n\n    if (isArray(value)) {\n      value.forEach(({ v: text, i: idx, n: norm }) => {\n        if (!isDefined(text)) {\n          return\n        }\n\n        const { isMatch, score, indices } = searcher.searchIn(text);\n\n        if (isMatch) {\n          matches.push({\n            score,\n            key,\n            value: text,\n            idx,\n            norm,\n            indices\n          });\n        }\n      });\n    } else {\n      const { v: text, n: norm } = value;\n\n      const { isMatch, score, indices } = searcher.searchIn(text);\n\n      if (isMatch) {\n        matches.push({ score, key, value: text, norm, indices });\n      }\n    }\n\n    return matches\n  }\n}\n\nFuse.version = '7.0.0';\nFuse.createIndex = createIndex;\nFuse.parseIndex = parseIndex;\nFuse.config = Config;\n\n{\n  Fuse.parseQuery = parse;\n}\n\n{\n  register(ExtendedSearch);\n}\n\nexport { Fuse as default };\n"],"names":["isArray","value","Array","getTag","isString","isNumber","isObject","isDefined","undefined","isBlank","trim","length","Object","prototype","toString","call","hasOwn","hasOwnProperty","KeyStore","constructor","keys","this","_keys","_keyMap","totalWeight","forEach","key","obj","createKey","push","id","weight","get","keyId","toJSON","JSON","stringify","path","src","getFn","createKeyPath","createKeyId","Error","name","INVALID_KEY_WEIGHT_VALUE","split","join","Config","isCaseSensitive","includeScore","shouldSort","sortFn","a","b","score","idx","includeMatches","findAllMatches","minMatchCharLength","location","threshold","distance","useExtendedSearch","list","arr","deepGet","index","isObjectLike","isBoolean","result","baseToString","i","len","ignoreLocation","ignoreFieldNorm","fieldNormWeight","SPACE","FuseIndex","norm","mantissa","cache","Map","m","Math","pow","numTokens","match","has","n","parseFloat","round","set","clear","isCreated","setIndexRecords","setSources","docs","records","setKeys","_keysMap","create","doc","docIndex","_addString","_addObject","add","size","removeAt","splice","getValueForItemAtKeyId","item","record","v","$","keyIndex","subRecords","stack","nestedArrIndex","pop","subRecord","k","createIndex","myIndex","map","computeScore$1","pattern","errors","currentLocation","expectedLocation","accuracy","proximity","abs","createPatternAlphabet","mask","char","charAt","BitapSearch","options","toLowerCase","chunks","addChunk","startIndex","alphabet","remainder","end","substr","searchIn","text","isMatch","indices","allIndices","totalScore","hasMatches","patternAlphabet","patternLen","textLen","max","min","currentThreshold","bestLocation","computeMatches","matchMask","indexOf","lastBitArr","finalScore","binMax","binMin","binMid","floor","start","finish","bitArr","j","charMatch","matchmask","convertMaskToIndices","search","BaseMatch","isMultiMatch","getMatch","multiRegex","isSingleMatch","singleRegex","exp","matches","FuzzyMatch","super","_bitapSearch","type","IncludeMatch","searchers","ExactMatch","PrefixExactMatch","startsWith","InversePrefixExactMatch","InverseSuffixExactMatch","endsWith","SuffixExactMatch","InverseExactMatch","searchersLen","SPACE_RE","MultiMatchSet","Set","registeredSearchers","createSearcher","searcherClass","condition","LogicalOperator","isExpression","query","convertToExplicit","LogicalOperator_AND","parse","auto","next","isQueryPath","isPath","isLeaf","LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY","searcher","node","children","operator","transformMatches","data","refIndex","transformScore","Fuse","_keyStore","setCollection","_docs","_myIndex","remove","predicate","results","getIndex","limit","_searchStringList","_searchObjectList","_searchLogical","Number","EPSILON","computeScore","sort","slice","transformers","transformer","format","expression","evaluate","_findMatches","res","resultMap","expResults","version","parseIndex","config","parseQuery","ExtendedSearch","filter","queryItem","found","token","_","numMatches","qLen","pLen"],"mappings":"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","x_google_ignoreList":[0]}

package/external/.pnpm/fuse.js@7.0.0/node_modules/fuse.js/dist/fuse.mjs

@@ -1,2 +0,0 @@
-function isArray(e){return Array.isArray?Array.isArray(e):getTag(e)==='[object Array]'}function isString(e){return typeof e=='string'}function isNumber(e){return typeof e=='number'}function isObject(e){return typeof e=='object'}function isDefined(e){return e!==void 0&&e!==null}function isBlank(e){return!e.trim().length}function getTag(e){return e==null?e===void 0?'[object Undefined]':'[object Null]':{}.toString.call(e)}const hasOwn={}.hasOwnProperty;class KeyStore{constructor(e){this._keys=[],this._keyMap={};let t=0;e.forEach((e=>{let s=createKey(e);this._keys.push(s),this._keyMap[s.id]=s,t+=s.weight})),this._keys.forEach((e=>{e.weight/=t}))}get(e){return this._keyMap[e]}keys(){return this._keys}toJSON(){return JSON.stringify(this._keys)}}function createKey(e){let t=null;let s=null;let n=null;let i=1;let r=null;if(isString(e)||isArray(e))n=e,t=createKeyPath(e),s=createKeyId(e);else{if(!hasOwn.call(e,'name'))throw new Error("Missing name property in key");const c=e.name;if(n=c,hasOwn.call(e,'weight')&&(i=e.weight,i<=0))throw new Error((e=>`Property 'weight' in key '${e}' must be a positive integer`)(c));t=createKeyPath(c),s=createKeyId(c),r=e.getFn}return{path:t,id:s,weight:i,src:n,getFn:r}}function createKeyPath(e){return isArray(e)?e:e.split('.')}function createKeyId(e){return isArray(e)?e.join('.'):e}var Config={isCaseSensitive:!1,includeScore:!1,keys:[],shouldSort:!0,sortFn:(e,t)=>e.score===t.score?e.idx<t.idx?-1:1:e.score<t.score?-1:1,includeMatches:!1,findAllMatches:!1,minMatchCharLength:1,location:0,threshold:.6,distance:100,useExtendedSearch:!1,getFn:(e,t)=>{let s=[];let n=!1;const deepGet=(e,t,i)=>{if(isDefined(e))if(t[i]){const r=e[t[i]];if(!isDefined(r))return;if(i===t.length-1&&(isString(r)||isNumber(r)||(e=>e===!0||e===!1||(e=>isObject(e)&&e!==null)(e)&&getTag(e)=='[object Boolean]')(r)))s.push((e=>e==null?'':(e=>{if(typeof e=='string')return e;let t=e+'';return t=='0'&&1/e==-1/0?'-0':t})(e))(r));else if(isArray(r)){n=!0;for(let e=0,s=r.length;e<s;e+=1)deepGet(r[e],t,i+1)}else t.length&&deepGet(r,t,i+1)}else s.push(e)};return deepGet(e,isString(t)?t.split('.'):t,0),n?s:s[0]},ignoreLocation:!1,ignoreFieldNorm:!1,fieldNormWeight:1};const SPACE=/[^ ]+/g;class FuseIndex{constructor({getFn:e=Config.getFn,fieldNormWeight:t=Config.fieldNormWeight}={}){this.norm=((e=1,t=3)=>{const s=new Map;const n=Math.pow(10,t);return{get(t){const i=t.match(SPACE).length;if(s.has(i))return s.get(i);const r=1/Math.pow(i,.5*e);const c=parseFloat(Math.round(r*n)/n);return s.set(i,c),c},clear(){s.clear()}}})(t,3),this.getFn=e,this.isCreated=!1,this.setIndexRecords()}setSources(e=[]){this.docs=e}setIndexRecords(e=[]){this.records=e}setKeys(e=[]){this.keys=e,this._keysMap={},e.forEach(((e,t)=>{this._keysMap[e.id]=t}))}create(){!this.isCreated&&this.docs.length&&(this.isCreated=!0,isString(this.docs[0])?this.docs.forEach(((e,t)=>{this._addString(e,t)})):this.docs.forEach(((e,t)=>{this._addObject(e,t)})),this.norm.clear())}add(e){const t=this.size();isString(e)?this._addString(e,t):this._addObject(e,t)}removeAt(e){this.records.splice(e,1);for(let t=e,s=this.size();t<s;t+=1)this.records[t].i-=1}getValueForItemAtKeyId(e,t){return e[this._keysMap[t]]}size(){return this.records.length}_addString(e,t){if(!isDefined(e)||isBlank(e))return;let s={v:e,i:t,n:this.norm.get(e)};this.records.push(s)}_addObject(e,t){let s={i:t,$:{}};this.keys.forEach(((t,n)=>{let i=t.getFn?t.getFn(e):this.getFn(e,t.path);if(isDefined(i))if(isArray(i)){let e=[];const t=[{nestedArrIndex:-1,value:i}];for(;t.length;){const{nestedArrIndex:s,value:n}=t.pop();if(isDefined(n))if(isString(n)&&!isBlank(n)){let t={v:n,i:s,n:this.norm.get(n)};e.push(t)}else isArray(n)&&n.forEach(((e,s)=>{t.push({nestedArrIndex:s,value:e})}))}s.$[n]=e}else if(isString(i)&&!isBlank(i)){let e={v:i,n:this.norm.get(i)};s.$[n]=e}})),this.records.push(s)}toJSON(){return{keys:this.keys,records:this.records}}}function createIndex(e,t,{getFn:s=Config.getFn,fieldNormWeight:n=Config.fieldNormWeight}={}){const i=new FuseIndex({getFn:s,fieldNormWeight:n});return i.setKeys(e.map(createKey)),i.setSources(t),i.create(),i}function computeScore$1(e,{errors:t=0,currentLocation:s=0,expectedLocation:n=0,distance:i=Config.distance,ignoreLocation:r=Config.ignoreLocation}={}){const c=t/e.length;if(r)return c;const o=Math.abs(n-s);return i?c+o/i:o?1:c}function createPatternAlphabet(e){let t={};for(let s=0,n=e.length;s<n;s+=1){const i=e.charAt(s);t[i]=(t[i]||0)|1<<n-s-1}return t}class BitapSearch{constructor(e,{location:t=Config.location,threshold:s=Config.threshold,distance:n=Config.distance,includeMatches:i=Config.includeMatches,findAllMatches:r=Config.findAllMatches,minMatchCharLength:c=Config.minMatchCharLength,isCaseSensitive:o=Config.isCaseSensitive,ignoreLocation:a=Config.ignoreLocation}={}){if(this.options={location:t,threshold:s,distance:n,includeMatches:i,findAllMatches:r,minMatchCharLength:c,isCaseSensitive:o,ignoreLocation:a},this.pattern=o?e:e.toLowerCase(),this.chunks=[],!this.pattern.length)return;const addChunk=(e,t)=>{this.chunks.push({pattern:e,alphabet:createPatternAlphabet(e),startIndex:t})};const h=this.pattern.length;if(h>32){let e=0;const t=h%32;const s=h-t;for(;e<s;)addChunk(this.pattern.substr(e,32),e),e+=32;if(t){const e=h-32;addChunk(this.pattern.substr(e),e)}}else addChunk(this.pattern,0)}searchIn(e){const{isCaseSensitive:t,includeMatches:s}=this.options;if(t||(e=e.toLowerCase()),this.pattern===e){let t={isMatch:!0,score:0};return s&&(t.indices=[[0,e.length-1]]),t}const{location:n,distance:i,threshold:r,findAllMatches:c,minMatchCharLength:o,ignoreLocation:a}=this.options;let h=[];let l=0;let u=!1;this.chunks.forEach((({pattern:t,alphabet:d,startIndex:g})=>{const{isMatch:f,score:p,indices:M}=((e,t,s,{location:n=Config.location,distance:i=Config.distance,threshold:r=Config.threshold,findAllMatches:c=Config.findAllMatches,minMatchCharLength:o=Config.minMatchCharLength,includeMatches:a=Config.includeMatches,ignoreLocation:h=Config.ignoreLocation}={})=>{if(t.length>32)throw new Error("Pattern length exceeds max of 32.");const l=t.length;const u=e.length;const d=Math.max(0,Math.min(n,u));let g=r;let f=d;const p=o>1||a;const M=p?Array(u):[];let m;for(;(m=e.indexOf(t,f))>-1;){let e=computeScore$1(t,{currentLocation:m,expectedLocation:d,distance:i,ignoreLocation:h});if(g=Math.min(e,g),f=m+l,p){let e=0;for(;e<l;)M[m+e]=1,e+=1}}f=-1;let x=[];let y=1;let C=l+u;const S=1<<l-1;for(let n=0;n<l;n+=1){let r=0;let o=C;for(;r<o;)computeScore$1(t,{errors:n,currentLocation:d+o,expectedLocation:d,distance:i,ignoreLocation:h})<=g?r=o:C=o,o=Math.floor((C-r)/2+r);C=o;let a=Math.max(1,d-o+1);let m=c?u:Math.min(d+o,u)+l;let L=Array(m+2);L[m+1]=(1<<n)-1;for(let r=m;r>=a;r-=1){let c=r-1;let o=s[e.charAt(c)];if(p&&(M[c]=+!!o),L[r]=(L[r+1]<<1|1)&o,n&&(L[r]|=(x[r+1]|x[r])<<1|1|x[r+1]),L[r]&S&&(y=computeScore$1(t,{errors:n,currentLocation:c,expectedLocation:d,distance:i,ignoreLocation:h}),y<=g)){if(g=y,f=c,f<=d)break;a=Math.max(1,2*d-f)}}if(computeScore$1(t,{errors:n+1,currentLocation:d,expectedLocation:d,distance:i,ignoreLocation:h})>g)break;x=L}const L={isMatch:f>=0,score:Math.max(.001,y)};if(p){const e=((e=[],t=Config.minMatchCharLength)=>{let s=[];let n=-1;let i=-1;let r=0;for(let c=e.length;r<c;r+=1){let c=e[r];c&&n===-1?n=r:c||n===-1||(i=r-1,i-n+1>=t&&s.push([n,i]),n=-1)}return e[r-1]&&r-n>=t&&s.push([n,r-1]),s})(M,o);e.length?a&&(L.indices=e):L.isMatch=!1}return L})(e,t,d,{location:n+g,distance:i,threshold:r,findAllMatches:c,minMatchCharLength:o,includeMatches:s,ignoreLocation:a});f&&(u=!0),l+=p,f&&M&&(h=[...h,...M])}));let d={isMatch:u,score:u?l/this.chunks.length:1};return u&&s&&(d.indices=h),d}}class BaseMatch{constructor(e){this.pattern=e}static isMultiMatch(e){return getMatch(e,this.multiRegex)}static isSingleMatch(e){return getMatch(e,this.singleRegex)}search(){}}function getMatch(e,t){const s=e.match(t);return s?s[1]:null}class FuzzyMatch extends BaseMatch{constructor(e,{location:t=Config.location,threshold:s=Config.threshold,distance:n=Config.distance,includeMatches:i=Config.includeMatches,findAllMatches:r=Config.findAllMatches,minMatchCharLength:c=Config.minMatchCharLength,isCaseSensitive:o=Config.isCaseSensitive,ignoreLocation:a=Config.ignoreLocation}={}){super(e),this._bitapSearch=new BitapSearch(e,{location:t,threshold:s,distance:n,includeMatches:i,findAllMatches:r,minMatchCharLength:c,isCaseSensitive:o,ignoreLocation:a})}static get type(){return'fuzzy'}static get multiRegex(){return/^"(.*)"$/}static get singleRegex(){return/^(.*)$/}search(e){return this._bitapSearch.searchIn(e)}}class IncludeMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'include'}static get multiRegex(){return/^'"(.*)"$/}static get singleRegex(){return/^'(.*)$/}search(e){let t=0;let s;const n=[];const i=this.pattern.length;for(;(s=e.indexOf(this.pattern,t))>-1;)t=s+i,n.push([s,t-1]);const r=!!n.length;return{isMatch:r,score:r?0:1,indices:n}}}const searchers=[class ExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'exact'}static get multiRegex(){return/^="(.*)"$/}static get singleRegex(){return/^=(.*)$/}search(e){const t=e===this.pattern;return{isMatch:t,score:t?0:1,indices:[0,this.pattern.length-1]}}},IncludeMatch,class PrefixExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'prefix-exact'}static get multiRegex(){return/^\^"(.*)"$/}static get singleRegex(){return/^\^(.*)$/}search(e){const t=e.startsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,this.pattern.length-1]}}},class InversePrefixExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'inverse-prefix-exact'}static get multiRegex(){return/^!\^"(.*)"$/}static get singleRegex(){return/^!\^(.*)$/}search(e){const t=!e.startsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}},class InverseSuffixExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'inverse-suffix-exact'}static get multiRegex(){return/^!"(.*)"\$$/}static get singleRegex(){return/^!(.*)\$$/}search(e){const t=!e.endsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}},class SuffixExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'suffix-exact'}static get multiRegex(){return/^"(.*)"\$$/}static get singleRegex(){return/^(.*)\$$/}search(e){const t=e.endsWith(this.pattern);return{isMatch:t,score:t?0:1,indices:[e.length-this.pattern.length,e.length-1]}}},class InverseExactMatch extends BaseMatch{constructor(e){super(e)}static get type(){return'inverse-exact'}static get multiRegex(){return/^!"(.*)"$/}static get singleRegex(){return/^!(.*)$/}search(e){const t=e.indexOf(this.pattern)===-1;return{isMatch:t,score:t?0:1,indices:[0,e.length-1]}}},FuzzyMatch];const searchersLen=searchers.length;const SPACE_RE=/ +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;const MultiMatchSet=new Set([FuzzyMatch.type,IncludeMatch.type]);const registeredSearchers=[];function createSearcher(e,t){for(let s=0,n=registeredSearchers.length;s<n;s+=1){let n=registeredSearchers[s];if(n.condition(e,t))return new n(e,t)}return new BitapSearch(e,t)}const LogicalOperator_AND='$and';const isExpression=e=>!(!e.$and&&!e.$or);const convertToExplicit=e=>({[LogicalOperator_AND]:Object.keys(e).map((t=>({[t]:e[t]})))});function parse(e,t,{auto:s=!0}={}){const next=e=>{let n=Object.keys(e);const i=(e=>!!e.$path)(e);if(!i&&n.length>1&&!isExpression(e))return next(convertToExplicit(e));if((e=>!isArray(e)&&isObject(e)&&!isExpression(e))(e)){const r=i?e.$path:n[0];const c=i?e.$val:e[r];if(!isString(c))throw new Error((e=>`Invalid value for key ${e}`)(r));const o={keyId:createKeyId(r),pattern:c};return s&&(o.searcher=createSearcher(c,t)),o}let r={children:[],operator:n[0]};return n.forEach((t=>{const s=e[t];isArray(s)&&s.forEach((e=>{r.children.push(next(e))}))})),r};return isExpression(e)||(e=convertToExplicit(e)),next(e)}function transformMatches(e,t){const s=e.matches;t.matches=[],isDefined(s)&&s.forEach((e=>{if(!isDefined(e.indices)||!e.indices.length)return;const{indices:s,value:n}=e;let i={indices:s,value:n};e.key&&(i.key=e.key.src),e.idx>-1&&(i.refIndex=e.idx),t.matches.push(i)}))}function transformScore(e,t){t.score=e.score}class Fuse{constructor(e,t={},s){this.options={...Config,...t},this._keyStore=new KeyStore(this.options.keys),this.setCollection(e,s)}setCollection(e,t){if(this._docs=e,t&&!(t instanceof FuseIndex))throw new Error("Incorrect 'index' type");this._myIndex=t||createIndex(this.options.keys,this._docs,{getFn:this.options.getFn,fieldNormWeight:this.options.fieldNormWeight})}add(e){isDefined(e)&&(this._docs.push(e),this._myIndex.add(e))}remove(e=()=>!1){const t=[];for(let s=0,n=this._docs.length;s<n;s+=1){const i=this._docs[s];e(i,s)&&(this.removeAt(s),s-=1,n-=1,t.push(i))}return t}removeAt(e){this._docs.splice(e,1),this._myIndex.removeAt(e)}getIndex(){return this._myIndex}search(e,{limit:t=-1}={}){const{includeMatches:s,includeScore:n,shouldSort:i,sortFn:r,ignoreFieldNorm:c}=this.options;let o=isString(e)?isString(this._docs[0])?this._searchStringList(e):this._searchObjectList(e):this._searchLogical(e);return((e,{ignoreFieldNorm:t=Config.ignoreFieldNorm})=>{e.forEach((e=>{let s=1;e.matches.forEach((({key:e,norm:n,score:i})=>{const r=e?e.weight:null;s*=Math.pow(i===0&&r?Number.EPSILON:i,(r||1)*(t?1:n))})),e.score=s}))})(o,{ignoreFieldNorm:c}),i&&o.sort(r),isNumber(t)&&t>-1&&(o=o.slice(0,t)),((e,t,{includeMatches:s=Config.includeMatches,includeScore:n=Config.includeScore}={})=>{const i=[];return s&&i.push(transformMatches),n&&i.push(transformScore),e.map((e=>{const{idx:s}=e;const n={item:t[s],refIndex:s};return i.length&&i.forEach((t=>{t(e,n)})),n}))})(o,this._docs,{includeMatches:s,includeScore:n})}_searchStringList(e){const t=createSearcher(e,this.options);const{records:s}=this._myIndex;const n=[];return s.forEach((({v:e,i:s,n:i})=>{if(!isDefined(e))return;const{isMatch:r,score:c,indices:o}=t.searchIn(e);r&&n.push({item:e,idx:s,matches:[{score:c,value:e,norm:i,indices:o}]})})),n}_searchLogical(e){const t=parse(e,this.options);const evaluate=(e,t,s)=>{if(!e.children){const{keyId:n,searcher:i}=e;const r=this._findMatches({key:this._keyStore.get(n),value:this._myIndex.getValueForItemAtKeyId(t,n),searcher:i});return r&&r.length?[{idx:s,item:t,matches:r}]:[]}const n=[];for(let i=0,r=e.children.length;i<r;i+=1){const r=evaluate(e.children[i],t,s);if(r.length)n.push(...r);else if(e.operator==="$and")return[]}return n};const s={};const n=[];return this._myIndex.records.forEach((({$:e,i})=>{if(isDefined(e)){let r=evaluate(t,e,i);r.length&&(s[i]||(s[i]={idx:i,item:e,matches:[]},n.push(s[i])),r.forEach((({matches:e})=>{s[i].matches.push(...e)})))}})),n}_searchObjectList(e){const t=createSearcher(e,this.options);const{keys:s,records:n}=this._myIndex;const i=[];return n.forEach((({$:e,i:n})=>{if(!isDefined(e))return;let r=[];s.forEach(((s,n)=>{r.push(...this._findMatches({key:s,value:e[n],searcher:t}))})),r.length&&i.push({idx:n,item:e,matches:r})})),i}_findMatches({key:e,value:t,searcher:s}){if(!isDefined(t))return[];let n=[];if(isArray(t))t.forEach((({v:t,i,n:r})=>{if(!isDefined(t))return;const{isMatch:c,score:o,indices:a}=s.searchIn(t);c&&n.push({score:o,key:e,value:t,idx:i,norm:r,indices:a})}));else{const{v:i,n:r}=t;const{isMatch:c,score:o,indices:a}=s.searchIn(i);c&&n.push({score:o,key:e,value:i,norm:r,indices:a})}return n}}Fuse.version='7.0.0',Fuse.createIndex=createIndex,Fuse.parseIndex=(e,{getFn:t=Config.getFn,fieldNormWeight:s=Config.fieldNormWeight}={})=>{const{keys:n,records:i}=e;const r=new FuseIndex({getFn:t,fieldNormWeight:s});return r.setKeys(n),r.setIndexRecords(i),r},Fuse.config=Config,Fuse.parseQuery=parse,registeredSearchers.push(class ExtendedSearch{constructor(e,{isCaseSensitive:t=Config.isCaseSensitive,includeMatches:s=Config.includeMatches,minMatchCharLength:n=Config.minMatchCharLength,ignoreLocation:i=Config.ignoreLocation,findAllMatches:r=Config.findAllMatches,location:c=Config.location,threshold:o=Config.threshold,distance:a=Config.distance}={}){this.query=null,this.options={isCaseSensitive:t,includeMatches:s,minMatchCharLength:n,findAllMatches:r,ignoreLocation:i,location:c,threshold:o,distance:a},this.pattern=t?e:e.toLowerCase(),this.query=((e,t={})=>this.pattern.split("|").map((e=>{let s=e.trim().split(SPACE_RE).filter((e=>e&&!!e.trim()));let n=[];for(let e=0,i=s.length;e<i;e+=1){const i=s[e];let r=!1;let c=-1;for(;!r&&++c<searchersLen;){const e=searchers[c];let s=e.isMultiMatch(i);s&&(n.push(new e(s,t)),r=!0)}if(!r)for(c=-1;++c<searchersLen;){const e=searchers[c];let s=e.isSingleMatch(i);if(s){n.push(new e(s,t));break}}}return n})))(0,this.options)}static condition(e,t){return t.useExtendedSearch}searchIn(e){const t=this.query;if(!t)return{isMatch:!1,score:1};const{includeMatches:s,isCaseSensitive:n}=this.options;e=n?e:e.toLowerCase();let i=0;let r=[];let c=0;for(let n=0,o=t.length;n<o;n+=1){const o=t[n];r.length=0,i=0;for(let t=0,n=o.length;t<n;t+=1){const n=o[t];const{isMatch:a,indices:h,score:l}=n.search(e);if(!a){c=0,i=0,r.length=0;break}i+=1,c+=l,s&&(MultiMatchSet.has(n.constructor.type)?r=[...r,...h]:r.push(h))}if(i){let e={isMatch:!0,score:c/i};return s&&(e.indices=r),e}}return{isMatch:!1,score:1}}});export{Fuse as default};
-//# sourceMappingURL=fuse.mjs.map