{"version":3,"file":"49-95ee896080510ce1ce94.js","mappings":"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","sources":["webpack://@whitespace/cirkor-gatsby/./node_modules/minisearch/dist/es5m/index.js","webpack://@whitespace/cirkor-gatsby/./src/@whitespace/gatsby-theme-search/hooks/useMiniSearch.js","webpack://@whitespace/cirkor-gatsby/./node_modules/@whitespace/gatsby-theme-search/src/components/LocalSearchBackendProvider.js","webpack://@whitespace/cirkor-gatsby/./src/@whitespace/gatsby-theme-search/hooks/useSearchDocumentsForMiniSearch.js","webpack://@whitespace/cirkor-gatsby/./node_modules/@whitespace/gatsby-theme-search/src/hooks/async.js","webpack://@whitespace/cirkor-gatsby/./node_modules/@babel/runtime/helpers/regeneratorRuntime.js","webpack://@whitespace/cirkor-gatsby/./node_modules/@babel/runtime/regenerator/index.js","webpack://@whitespace/cirkor-gatsby/./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\n\nvar _assign = function __assign() {\n  _assign = Object.assign || function __assign(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n      s = arguments[i];\n      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n    }\n    return t;\n  };\n  return _assign.apply(this, arguments);\n};\nfunction __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator,\n    m = s && o[s],\n    i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n    next: function next() {\n      if (o && i >= o.length) o = void 0;\n      return {\n        value: o && o[i++],\n        done: !o\n      };\n    }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\nfunction __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o),\n    r,\n    ar = [],\n    e;\n  try {\n    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  } catch (error) {\n    e = {\n      error: error\n    };\n  } finally {\n    try {\n      if (r && !r.done && (m = i[\"return\"])) m.call(i);\n    } finally {\n      if (e) throw e.error;\n    }\n  }\n  return ar;\n}\nfunction __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\n/** @ignore */\nvar ENTRIES = 'ENTRIES';\n/** @ignore */\nvar KEYS = 'KEYS';\n/** @ignore */\nvar VALUES = 'VALUES';\n/** @ignore */\nvar LEAF = '';\n/**\n * @private\n */\nvar TreeIterator = /** @class */function () {\n  function TreeIterator(set, type) {\n    var node = set._tree;\n    var keys = Object.keys(node);\n    this.set = set;\n    this._type = type;\n    this._path = keys.length > 0 ? [{\n      node: node,\n      keys: keys\n    }] : [];\n  }\n  TreeIterator.prototype.next = function () {\n    var value = this.dive();\n    this.backtrack();\n    return value;\n  };\n  TreeIterator.prototype.dive = function () {\n    if (this._path.length === 0) {\n      return {\n        done: true,\n        value: undefined\n      };\n    }\n    var _a = last$1(this._path),\n      node = _a.node,\n      keys = _a.keys;\n    if (last$1(keys) === LEAF) {\n      return {\n        done: false,\n        value: this.result()\n      };\n    }\n    this._path.push({\n      node: node[last$1(keys)],\n      keys: Object.keys(node[last$1(keys)])\n    });\n    return this.dive();\n  };\n  TreeIterator.prototype.backtrack = function () {\n    if (this._path.length === 0) {\n      return;\n    }\n    last$1(this._path).keys.pop();\n    if (last$1(this._path).keys.length > 0) {\n      return;\n    }\n    this._path.pop();\n    this.backtrack();\n  };\n  TreeIterator.prototype.key = function () {\n    return this.set._prefix + this._path.map(function (_a) {\n      var keys = _a.keys;\n      return last$1(keys);\n    }).filter(function (key) {\n      return key !== LEAF;\n    }).join('');\n  };\n  TreeIterator.prototype.value = function () {\n    return last$1(this._path).node[LEAF];\n  };\n  TreeIterator.prototype.result = function () {\n    if (this._type === VALUES) {\n      return this.value();\n    }\n    if (this._type === KEYS) {\n      return this.key();\n    }\n    return [this.key(), this.value()];\n  };\n  TreeIterator.prototype[Symbol.iterator] = function () {\n    return this;\n  };\n  return TreeIterator;\n}();\nvar last$1 = function last$1(array) {\n  return array[array.length - 1];\n};\nvar NONE = 0;\nvar CHANGE = 1;\nvar ADD = 2;\nvar DELETE = 3;\n/**\n * @ignore\n */\nvar fuzzySearch = function fuzzySearch(node, query, maxDistance) {\n  var stack = [{\n    distance: 0,\n    i: 0,\n    key: '',\n    node: node\n  }];\n  var results = {};\n  var innerStack = [];\n  var _loop_1 = function _loop_1() {\n    var _a = stack.pop(),\n      node_1 = _a.node,\n      distance = _a.distance,\n      key = _a.key,\n      i = _a.i,\n      edit = _a.edit;\n    Object.keys(node_1).forEach(function (k) {\n      if (k === LEAF) {\n        var totDistance = distance + (query.length - i);\n        var _a = __read(results[key] || [null, Infinity], 2),\n          d = _a[1];\n        if (totDistance <= maxDistance && totDistance < d) {\n          results[key] = [node_1[k], totDistance];\n        }\n      } else {\n        withinDistance(query, k, maxDistance - distance, i, edit, innerStack).forEach(function (_a) {\n          var d = _a.distance,\n            i = _a.i,\n            edit = _a.edit;\n          stack.push({\n            node: node_1[k],\n            distance: distance + d,\n            key: key + k,\n            i: i,\n            edit: edit\n          });\n        });\n      }\n    });\n  };\n  while (stack.length > 0) {\n    _loop_1();\n  }\n  return results;\n};\n/**\n * @ignore\n */\nvar withinDistance = function withinDistance(a, b, maxDistance, i, edit, stack) {\n  stack.push({\n    distance: 0,\n    ia: i,\n    ib: 0,\n    edit: edit\n  });\n  var results = [];\n  while (stack.length > 0) {\n    var _a = stack.pop(),\n      distance = _a.distance,\n      ia = _a.ia,\n      ib = _a.ib,\n      edit_1 = _a.edit;\n    if (ib === b.length) {\n      results.push({\n        distance: distance,\n        i: ia,\n        edit: edit_1\n      });\n      continue;\n    }\n    if (a[ia] === b[ib]) {\n      stack.push({\n        distance: distance,\n        ia: ia + 1,\n        ib: ib + 1,\n        edit: NONE\n      });\n    } else {\n      if (distance >= maxDistance) {\n        continue;\n      }\n      if (edit_1 !== ADD) {\n        stack.push({\n          distance: distance + 1,\n          ia: ia,\n          ib: ib + 1,\n          edit: DELETE\n        });\n      }\n      if (ia < a.length) {\n        if (edit_1 !== DELETE) {\n          stack.push({\n            distance: distance + 1,\n            ia: ia + 1,\n            ib: ib,\n            edit: ADD\n          });\n        }\n        if (edit_1 !== DELETE && edit_1 !== ADD) {\n          stack.push({\n            distance: distance + 1,\n            ia: ia + 1,\n            ib: ib + 1,\n            edit: CHANGE\n          });\n        }\n      }\n    }\n  }\n  return results;\n};\n\n/**\n * A class implementing the same interface as a standard JavaScript\n * [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)\n * with string keys, but adding support for efficiently searching entries with\n * prefix or fuzzy search. This class is used internally by [[MiniSearch]] as\n * the inverted index data structure. The implementation is a radix tree\n * (compressed prefix tree).\n *\n * Since this class can be of general utility beyond _MiniSearch_, it is\n * exported by the `minisearch` package and can be imported (or required) as\n * `minisearch/SearchableMap`.\n *\n * @typeParam T  The type of the values stored in the map.\n */\nvar SearchableMap = /** @class */function () {\n  /**\n   * The constructor is normally called without arguments, creating an empty\n   * map. In order to create a [[SearchableMap]] from an iterable or from an\n   * object, check [[SearchableMap.from]] and [[SearchableMap.fromObject]].\n   *\n   * The constructor arguments are for internal use, when creating derived\n   * mutable views of a map at a prefix.\n   */\n  function SearchableMap(tree, prefix) {\n    if (tree === void 0) {\n      tree = {};\n    }\n    if (prefix === void 0) {\n      prefix = '';\n    }\n    this._tree = tree;\n    this._prefix = prefix;\n  }\n  /**\n   * Creates and returns a mutable view of this [[SearchableMap]], containing only\n   * entries that share the given prefix.\n   *\n   * ### Usage:\n   *\n   * ```javascript\n   * let map = new SearchableMap()\n   * map.set(\"unicorn\", 1)\n   * map.set(\"universe\", 2)\n   * map.set(\"university\", 3)\n   * map.set(\"unique\", 4)\n   * map.set(\"hello\", 5)\n   *\n   * let uni = map.atPrefix(\"uni\")\n   * uni.get(\"unique\") // => 4\n   * uni.get(\"unicorn\") // => 1\n   * uni.get(\"hello\") // => undefined\n   *\n   * let univer = map.atPrefix(\"univer\")\n   * univer.get(\"unique\") // => undefined\n   * univer.get(\"universe\") // => 2\n   * univer.get(\"university\") // => 3\n   * ```\n   *\n   * @param prefix  The prefix\n   * @return A [[SearchableMap]] representing a mutable view of the original Map at the given prefix\n   */\n  SearchableMap.prototype.atPrefix = function (prefix) {\n    var _a;\n    if (!prefix.startsWith(this._prefix)) {\n      throw new Error('Mismatched prefix');\n    }\n    var _b = __read(trackDown(this._tree, prefix.slice(this._prefix.length)), 2),\n      node = _b[0],\n      path = _b[1];\n    if (node === undefined) {\n      var _c = __read(last(path), 2),\n        parentNode = _c[0],\n        key_1 = _c[1];\n      var nodeKey = Object.keys(parentNode).find(function (k) {\n        return k !== LEAF && k.startsWith(key_1);\n      });\n      if (nodeKey !== undefined) {\n        return new SearchableMap((_a = {}, _a[nodeKey.slice(key_1.length)] = parentNode[nodeKey], _a), prefix);\n      }\n    }\n    return new SearchableMap(node || {}, prefix);\n  };\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear\n   */\n  SearchableMap.prototype.clear = function () {\n    delete this._size;\n    this._tree = {};\n  };\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete\n   * @param key  Key to delete\n   */\n  SearchableMap.prototype.delete = function (key) {\n    delete this._size;\n    return remove(this._tree, key);\n  };\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries\n   * @return An iterator iterating through `[key, value]` entries.\n   */\n  SearchableMap.prototype.entries = function () {\n    return new TreeIterator(this, ENTRIES);\n  };\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach\n   * @param fn  Iteration function\n   */\n  SearchableMap.prototype.forEach = function (fn) {\n    var e_1, _a;\n    try {\n      for (var _b = __values(this), _c = _b.next(); !_c.done; _c = _b.next()) {\n        var _d = __read(_c.value, 2),\n          key = _d[0],\n          value = _d[1];\n        fn(key, value, this);\n      }\n    } catch (e_1_1) {\n      e_1 = {\n        error: e_1_1\n      };\n    } finally {\n      try {\n        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n      } finally {\n        if (e_1) throw e_1.error;\n      }\n    }\n  };\n  /**\n   * Returns a key-value object of all the entries that have a key within the\n   * given edit distance from the search key. The keys of the returned object are\n   * the matching keys, while the values are two-elements arrays where the first\n   * element is the value associated to the key, and the second is the edit\n   * distance of the key to the search key.\n   *\n   * ### Usage:\n   *\n   * ```javascript\n   * let map = new SearchableMap()\n   * map.set('hello', 'world')\n   * map.set('hell', 'yeah')\n   * map.set('ciao', 'mondo')\n   *\n   * // Get all entries that match the key 'hallo' with a maximum edit distance of 2\n   * map.fuzzyGet('hallo', 2)\n   * // => { \"hello\": [\"world\", 1], \"hell\": [\"yeah\", 2] }\n   *\n   * // In the example, the \"hello\" key has value \"world\" and edit distance of 1\n   * // (change \"e\" to \"a\"), the key \"hell\" has value \"yeah\" and edit distance of 2\n   * // (change \"e\" to \"a\", delete \"o\")\n   * ```\n   *\n   * @param key  The search key\n   * @param maxEditDistance  The maximum edit distance (Levenshtein)\n   * @return A key-value object of the matching keys to their value and edit distance\n   */\n  SearchableMap.prototype.fuzzyGet = function (key, maxEditDistance) {\n    return fuzzySearch(this._tree, key, maxEditDistance);\n  };\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get\n   * @param key  Key to get\n   * @return Value associated to the key, or `undefined` if the key is not\n   * found.\n   */\n  SearchableMap.prototype.get = function (key) {\n    var node = lookup(this._tree, key);\n    return node !== undefined ? node[LEAF] : undefined;\n  };\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has\n   * @param key  Key\n   * @return True if the key is in the map, false otherwise\n   */\n  SearchableMap.prototype.has = function (key) {\n    var node = lookup(this._tree, key);\n    return node !== undefined && node.hasOwnProperty(LEAF);\n  };\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys\n   * @return An `Iterable` iterating through keys\n   */\n  SearchableMap.prototype.keys = function () {\n    return new TreeIterator(this, KEYS);\n  };\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set\n   * @param key  Key to set\n   * @param value  Value to associate to the key\n   * @return The [[SearchableMap]] itself, to allow chaining\n   */\n  SearchableMap.prototype.set = function (key, value) {\n    if (typeof key !== 'string') {\n      throw new Error('key must be a string');\n    }\n    delete this._size;\n    var node = createPath(this._tree, key);\n    node[LEAF] = value;\n    return this;\n  };\n  Object.defineProperty(SearchableMap.prototype, \"size\", {\n    /**\n     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size\n     */\n    get: function get() {\n      var _this = this;\n      if (this._size) {\n        return this._size;\n      }\n      /** @ignore */\n      this._size = 0;\n      this.forEach(function () {\n        _this._size += 1;\n      });\n      return this._size;\n    },\n    enumerable: false,\n    configurable: true\n  });\n  /**\n   * Updates the value at the given key using the provided function. The function\n   * is called with the current value at the key, and its return value is used as\n   * the new value to be set.\n   *\n   * ### Example:\n   *\n   * ```javascript\n   * // Increment the current value by one\n   * searchableMap.update('somekey', (currentValue) => currentValue == null ? 0 : currentValue + 1)\n   * ```\n   *\n   * @param key  The key to update\n   * @param fn  The function used to compute the new value from the current one\n   * @return The [[SearchableMap]] itself, to allow chaining\n   */\n  SearchableMap.prototype.update = function (key, fn) {\n    if (typeof key !== 'string') {\n      throw new Error('key must be a string');\n    }\n    delete this._size;\n    var node = createPath(this._tree, key);\n    node[LEAF] = fn(node[LEAF]);\n    return this;\n  };\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values\n   * @return An `Iterable` iterating through values.\n   */\n  SearchableMap.prototype.values = function () {\n    return new TreeIterator(this, VALUES);\n  };\n  /**\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@iterator\n   */\n  SearchableMap.prototype[Symbol.iterator] = function () {\n    return this.entries();\n  };\n  /**\n   * Creates a [[SearchableMap]] from an `Iterable` of entries\n   *\n   * @param entries  Entries to be inserted in the [[SearchableMap]]\n   * @return A new [[SearchableMap]] with the given entries\n   */\n  SearchableMap.from = function (entries) {\n    var e_2, _a;\n    var tree = new SearchableMap();\n    try {\n      for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {\n        var _b = __read(entries_1_1.value, 2),\n          key = _b[0],\n          value = _b[1];\n        tree.set(key, value);\n      }\n    } catch (e_2_1) {\n      e_2 = {\n        error: e_2_1\n      };\n    } finally {\n      try {\n        if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);\n      } finally {\n        if (e_2) throw e_2.error;\n      }\n    }\n    return tree;\n  };\n  /**\n   * Creates a [[SearchableMap]] from the iterable properties of a JavaScript object\n   *\n   * @param object  Object of entries for the [[SearchableMap]]\n   * @return A new [[SearchableMap]] with the given entries\n   */\n  SearchableMap.fromObject = function (object) {\n    return SearchableMap.from(Object.entries(object));\n  };\n  return SearchableMap;\n}();\nvar trackDown = function trackDown(tree, key, path) {\n  if (path === void 0) {\n    path = [];\n  }\n  if (key.length === 0 || tree == null) {\n    return [tree, path];\n  }\n  var nodeKey = Object.keys(tree).find(function (k) {\n    return k !== LEAF && key.startsWith(k);\n  });\n  if (nodeKey === undefined) {\n    path.push([tree, key]); // performance: update in place\n    return trackDown(undefined, '', path);\n  }\n  path.push([tree, nodeKey]); // performance: update in place\n  return trackDown(tree[nodeKey], key.slice(nodeKey.length), path);\n};\nvar lookup = function lookup(tree, key) {\n  if (key.length === 0 || tree == null) {\n    return tree;\n  }\n  var nodeKey = Object.keys(tree).find(function (k) {\n    return k !== LEAF && key.startsWith(k);\n  });\n  if (nodeKey === undefined) {\n    return undefined;\n  }\n  return lookup(tree[nodeKey], key.slice(nodeKey.length));\n};\nvar createPath = function createPath(tree, key) {\n  var _a;\n  if (key.length === 0 || tree == null) {\n    return tree;\n  }\n  var nodeKey = Object.keys(tree).find(function (k) {\n    return k !== LEAF && key.startsWith(k);\n  });\n  if (nodeKey === undefined) {\n    var toSplit = Object.keys(tree).find(function (k) {\n      return k !== LEAF && k.startsWith(key[0]);\n    });\n    if (toSplit === undefined) {\n      tree[key] = {};\n    } else {\n      var prefix = commonPrefix(key, toSplit);\n      tree[prefix] = (_a = {}, _a[toSplit.slice(prefix.length)] = tree[toSplit], _a);\n      delete tree[toSplit];\n      return createPath(tree[prefix], key.slice(prefix.length));\n    }\n    return tree[key];\n  }\n  return createPath(tree[nodeKey], key.slice(nodeKey.length));\n};\nvar commonPrefix = function commonPrefix(a, b, i, length, prefix) {\n  if (i === void 0) {\n    i = 0;\n  }\n  if (length === void 0) {\n    length = Math.min(a.length, b.length);\n  }\n  if (prefix === void 0) {\n    prefix = '';\n  }\n  if (i >= length) {\n    return prefix;\n  }\n  if (a[i] !== b[i]) {\n    return prefix;\n  }\n  return commonPrefix(a, b, i + 1, length, prefix + a[i]);\n};\nvar remove = function remove(tree, key) {\n  var _a = __read(trackDown(tree, key), 2),\n    node = _a[0],\n    path = _a[1];\n  if (node === undefined) {\n    return;\n  }\n  delete node[LEAF];\n  var keys = Object.keys(node);\n  if (keys.length === 0) {\n    cleanup(path);\n  }\n  if (keys.length === 1) {\n    merge(path, keys[0], node[keys[0]]);\n  }\n};\nvar cleanup = function cleanup(path) {\n  if (path.length === 0) {\n    return;\n  }\n  var _a = __read(last(path), 2),\n    node = _a[0],\n    key = _a[1];\n  delete node[key];\n  var keys = Object.keys(node);\n  if (keys.length === 0) {\n    cleanup(path.slice(0, -1));\n  }\n  if (keys.length === 1 && keys[0] !== LEAF) {\n    merge(path.slice(0, -1), keys[0], node[keys[0]]);\n  }\n};\nvar merge = function merge(path, key, value) {\n  if (path.length === 0) {\n    return;\n  }\n  var _a = __read(last(path), 2),\n    node = _a[0],\n    nodeKey = _a[1];\n  node[nodeKey + key] = value;\n  delete node[nodeKey];\n};\nvar last = function last(array) {\n  return array[array.length - 1];\n};\nvar _a;\nvar OR = 'or';\nvar AND = 'and';\nvar AND_NOT = 'and_not';\n/**\n * [[MiniSearch]] is the main entrypoint class, implementing a full-text search\n * engine in memory.\n *\n * @typeParam T  The type of the documents being indexed.\n *\n * ### Basic example:\n *\n * ```javascript\n * const documents = [\n *   {\n *     id: 1,\n *     title: 'Moby Dick',\n *     text: 'Call me Ishmael. Some years ago...',\n *     category: 'fiction'\n *   },\n *   {\n *     id: 2,\n *     title: 'Zen and the Art of Motorcycle Maintenance',\n *     text: 'I can see by my watch...',\n *     category: 'fiction'\n *   },\n *   {\n *     id: 3,\n *     title: 'Neuromancer',\n *     text: 'The sky above the port was...',\n *     category: 'fiction'\n *   },\n *   {\n *     id: 4,\n *     title: 'Zen and the Art of Archery',\n *     text: 'At first sight it must seem...',\n *     category: 'non-fiction'\n *   },\n *   // ...and more\n * ]\n *\n * // Create a search engine that indexes the 'title' and 'text' fields for\n * // full-text search. Search results will include 'title' and 'category' (plus the\n * // id field, that is always stored and returned)\n * const miniSearch = new MiniSearch({\n *   fields: ['title', 'text'],\n *   storeFields: ['title', 'category']\n * })\n *\n * // Add documents to the index\n * miniSearch.addAll(documents)\n *\n * // Search for documents:\n * let results = miniSearch.search('zen art motorcycle')\n * // => [\n * //   { id: 2, title: 'Zen and the Art of Motorcycle Maintenance', category: 'fiction', score: 2.77258 },\n * //   { id: 4, title: 'Zen and the Art of Archery', category: 'non-fiction', score: 1.38629 }\n * // ]\n * ```\n */\nvar MiniSearch = /** @class */function () {\n  /**\n   * @param options  Configuration options\n   *\n   * ### Examples:\n   *\n   * ```javascript\n   * // Create a search engine that indexes the 'title' and 'text' fields of your\n   * // documents:\n   * const miniSearch = new MiniSearch({ fields: ['title', 'text'] })\n   * ```\n   *\n   * ### ID Field:\n   *\n   * ```javascript\n   * // Your documents are assumed to include a unique 'id' field, but if you want\n   * // to use a different field for document identification, you can set the\n   * // 'idField' option:\n   * const miniSearch = new MiniSearch({ idField: 'key', fields: ['title', 'text'] })\n   * ```\n   *\n   * ### Options and defaults:\n   *\n   * ```javascript\n   * // The full set of options (here with their default value) is:\n   * const miniSearch = new MiniSearch({\n   *   // idField: field that uniquely identifies a document\n   *   idField: 'id',\n   *\n   *   // extractField: function used to get the value of a field in a document.\n   *   // By default, it assumes the document is a flat object with field names as\n   *   // property keys and field values as string property values, but custom logic\n   *   // can be implemented by setting this option to a custom extractor function.\n   *   extractField: (document, fieldName) => document[fieldName],\n   *\n   *   // tokenize: function used to split fields into individual terms. By\n   *   // default, it is also used to tokenize search queries, unless a specific\n   *   // `tokenize` search option is supplied. When tokenizing an indexed field,\n   *   // the field name is passed as the second argument.\n   *   tokenize: (string, _fieldName) => string.split(SPACE_OR_PUNCTUATION),\n   *\n   *   // processTerm: function used to process each tokenized term before\n   *   // indexing. It can be used for stemming and normalization. Return a falsy\n   *   // value in order to discard a term. By default, it is also used to process\n   *   // search queries, unless a specific `processTerm` option is supplied as a\n   *   // search option. When processing a term from a indexed field, the field\n   *   // name is passed as the second argument.\n   *   processTerm: (term, _fieldName) => term.toLowerCase(),\n   *\n   *   // searchOptions: default search options, see the `search` method for\n   *   // details\n   *   searchOptions: undefined,\n   *\n   *   // fields: document fields to be indexed. Mandatory, but not set by default\n   *   fields: undefined\n   *\n   *   // storeFields: document fields to be stored and returned as part of the\n   *   // search results.\n   *   storeFields: []\n   * })\n   * ```\n   */\n  function MiniSearch(options) {\n    if ((options === null || options === void 0 ? void 0 : options.fields) == null) {\n      throw new Error('MiniSearch: option \"fields\" must be provided');\n    }\n    this._options = _assign(_assign(_assign({}, defaultOptions), options), {\n      searchOptions: _assign(_assign({}, defaultSearchOptions), options.searchOptions || {})\n    });\n    this._index = new SearchableMap();\n    this._documentCount = 0;\n    this._documentIds = {};\n    this._fieldIds = {};\n    this._fieldLength = {};\n    this._averageFieldLength = {};\n    this._nextId = 0;\n    this._storedFields = {};\n    this.addFields(this._options.fields);\n  }\n  /**\n   * Adds a document to the index\n   *\n   * @param document  The document to be indexed\n   */\n  MiniSearch.prototype.add = function (document) {\n    var _this = this;\n    var _a = this._options,\n      extractField = _a.extractField,\n      tokenize = _a.tokenize,\n      processTerm = _a.processTerm,\n      fields = _a.fields,\n      idField = _a.idField;\n    var id = extractField(document, idField);\n    if (id == null) {\n      throw new Error(\"MiniSearch: document does not have ID field \\\"\".concat(idField, \"\\\"\"));\n    }\n    var shortDocumentId = this.addDocumentId(id);\n    this.saveStoredFields(shortDocumentId, document);\n    fields.forEach(function (field) {\n      var fieldValue = extractField(document, field);\n      if (fieldValue == null) {\n        return;\n      }\n      var tokens = tokenize(fieldValue.toString(), field);\n      _this.addFieldLength(shortDocumentId, _this._fieldIds[field], _this.documentCount - 1, tokens.length);\n      tokens.forEach(function (term) {\n        var processedTerm = processTerm(term, field);\n        if (processedTerm) {\n          _this.addTerm(_this._fieldIds[field], shortDocumentId, processedTerm);\n        }\n      });\n    });\n  };\n  /**\n   * Adds all the given documents to the index\n   *\n   * @param documents  An array of documents to be indexed\n   */\n  MiniSearch.prototype.addAll = function (documents) {\n    var _this = this;\n    documents.forEach(function (document) {\n      return _this.add(document);\n    });\n  };\n  /**\n   * Adds all the given documents to the index asynchronously.\n   *\n   * Returns a promise that resolves (to `undefined`) when the indexing is done.\n   * This method is useful when index many documents, to avoid blocking the main\n   * thread. The indexing is performed asynchronously and in chunks.\n   *\n   * @param documents  An array of documents to be indexed\n   * @param options  Configuration options\n   * @return A promise resolving to `undefined` when the indexing is done\n   */\n  MiniSearch.prototype.addAllAsync = function (documents, options) {\n    var _this = this;\n    if (options === void 0) {\n      options = {};\n    }\n    var _a = options.chunkSize,\n      chunkSize = _a === void 0 ? 10 : _a;\n    var acc = {\n      chunk: [],\n      promise: Promise.resolve()\n    };\n    var _b = documents.reduce(function (_a, document, i) {\n        var chunk = _a.chunk,\n          promise = _a.promise;\n        chunk.push(document);\n        if ((i + 1) % chunkSize === 0) {\n          return {\n            chunk: [],\n            promise: promise.then(function () {\n              return new Promise(function (resolve) {\n                return setTimeout(resolve, 0);\n              });\n            }).then(function () {\n              return _this.addAll(chunk);\n            })\n          };\n        } else {\n          return {\n            chunk: chunk,\n            promise: promise\n          };\n        }\n      }, acc),\n      chunk = _b.chunk,\n      promise = _b.promise;\n    return promise.then(function () {\n      return _this.addAll(chunk);\n    });\n  };\n  /**\n   * Removes the given document from the index.\n   *\n   * The document to delete must NOT have changed between indexing and deletion,\n   * otherwise the index will be corrupted. Therefore, when reindexing a document\n   * after a change, the correct order of operations is:\n   *\n   *   1. remove old version\n   *   2. apply changes\n   *   3. index new version\n   *\n   * @param document  The document to be removed\n   */\n  MiniSearch.prototype.remove = function (document) {\n    var _this = this;\n    var _a = this._options,\n      tokenize = _a.tokenize,\n      processTerm = _a.processTerm,\n      extractField = _a.extractField,\n      fields = _a.fields,\n      idField = _a.idField;\n    var id = extractField(document, idField);\n    if (id == null) {\n      throw new Error(\"MiniSearch: document does not have ID field \\\"\".concat(idField, \"\\\"\"));\n    }\n    var _b = __read(Object.entries(this._documentIds).find(function (_a) {\n        var _b = __read(_a, 2);\n        _b[0];\n        var longId = _b[1];\n        return id === longId;\n      }) || [], 1),\n      shortDocumentId = _b[0];\n    if (shortDocumentId == null) {\n      throw new Error(\"MiniSearch: cannot remove document with ID \".concat(id, \": it is not in the index\"));\n    }\n    fields.forEach(function (field) {\n      var fieldValue = extractField(document, field);\n      if (fieldValue == null) {\n        return;\n      }\n      var tokens = tokenize(fieldValue.toString(), field);\n      tokens.forEach(function (term) {\n        var processedTerm = processTerm(term, field);\n        if (processedTerm) {\n          _this.removeTerm(_this._fieldIds[field], shortDocumentId, processedTerm);\n        }\n      });\n      _this.removeFieldLength(shortDocumentId, _this._fieldIds[field], _this.documentCount, tokens.length);\n    });\n    delete this._storedFields[shortDocumentId];\n    delete this._documentIds[shortDocumentId];\n    delete this._fieldLength[shortDocumentId];\n    this._documentCount -= 1;\n  };\n  /**\n   * Removes all the given documents from the index. If called with no arguments,\n   * it removes _all_ documents from the index.\n   *\n   * @param documents  The documents to be removed. If this argument is omitted,\n   * all documents are removed. Note that, for removing all documents, it is\n   * more efficient to call this method with no arguments than to pass all\n   * documents.\n   */\n  MiniSearch.prototype.removeAll = function (documents) {\n    var _this = this;\n    if (documents) {\n      documents.forEach(function (document) {\n        return _this.remove(document);\n      });\n    } else if (arguments.length > 0) {\n      throw new Error('Expected documents to be present. Omit the argument to remove all documents.');\n    } else {\n      this._index = new SearchableMap();\n      this._documentCount = 0;\n      this._documentIds = {};\n      this._fieldLength = {};\n      this._averageFieldLength = {};\n      this._storedFields = {};\n      this._nextId = 0;\n    }\n  };\n  /**\n   * Search for documents matching the given search query.\n   *\n   * The result is a list of scored document IDs matching the query, sorted by\n   * descending score, and each including data about which terms were matched and\n   * in which fields.\n   *\n   * ### Basic usage:\n   *\n   * ```javascript\n   * // Search for \"zen art motorcycle\" with default options: terms have to match\n   * // exactly, and individual terms are joined with OR\n   * miniSearch.search('zen art motorcycle')\n   * // => [ { id: 2, score: 2.77258, match: { ... } }, { id: 4, score: 1.38629, match: { ... } } ]\n   * ```\n   *\n   * ### Restrict search to specific fields:\n   *\n   * ```javascript\n   * // Search only in the 'title' field\n   * miniSearch.search('zen', { fields: ['title'] })\n   * ```\n   *\n   * ### Field boosting:\n   *\n   * ```javascript\n   * // Boost a field\n   * miniSearch.search('zen', { boost: { title: 2 } })\n   * ```\n   *\n   * ### Prefix search:\n   *\n   * ```javascript\n   * // Search for \"moto\" with prefix search (it will match documents\n   * // containing terms that start with \"moto\" or \"neuro\")\n   * miniSearch.search('moto neuro', { prefix: true })\n   * ```\n   *\n   * ### Fuzzy search:\n   *\n   * ```javascript\n   * // Search for \"ismael\" with fuzzy search (it will match documents containing\n   * // terms similar to \"ismael\", with a maximum edit distance of 0.2 term.length\n   * // (rounded to nearest integer)\n   * miniSearch.search('ismael', { fuzzy: 0.2 })\n   * ```\n   *\n   * ### Combining strategies:\n   *\n   * ```javascript\n   * // Mix of exact match, prefix search, and fuzzy search\n   * miniSearch.search('ismael mob', {\n   *  prefix: true,\n   *  fuzzy: 0.2\n   * })\n   * ```\n   *\n   * ### Advanced prefix and fuzzy search:\n   *\n   * ```javascript\n   * // Perform fuzzy and prefix search depending on the search term. Here\n   * // performing prefix and fuzzy search only on terms longer than 3 characters\n   * miniSearch.search('ismael mob', {\n   *  prefix: term => term.length > 3\n   *  fuzzy: term => term.length > 3 ? 0.2 : null\n   * })\n   * ```\n   *\n   * ### Combine with AND:\n   *\n   * ```javascript\n   * // Combine search terms with AND (to match only documents that contain both\n   * // \"motorcycle\" and \"art\")\n   * miniSearch.search('motorcycle art', { combineWith: 'AND' })\n   * ```\n   *\n   * ### Combine with AND_NOT:\n   *\n   * There is also an AND_NOT combinator, that finds documents that match the\n   * first term, but do not match any of the other terms. This combinator is\n   * rarely useful with simple queries, and is meant to be used with advanced\n   * query combinations (see later for more details).\n   *\n   * ### Filtering results:\n   *\n   * ```javascript\n   * // Filter only results in the 'fiction' category (assuming that 'category'\n   * // is a stored field)\n   * miniSearch.search('motorcycle art', {\n   *   filter: (result) => result.category === 'fiction'\n   * })\n   * ```\n   *\n   * ### Advanced combination of queries:\n   *\n   * It is possible to combine different subqueries with OR, AND, and AND_NOT,\n   * and even with different search options, by passing a query expression\n   * tree object as the first argument, instead of a string.\n   *\n   * ```javascript\n   * // Search for documents that contain \"zen\" and (\"motorcycle\" or \"archery\")\n   * miniSearch.search({\n   *   combineWith: 'AND',\n   *   queries: [\n   *     'zen',\n   *     {\n   *       combineWith: 'OR',\n   *       queries: ['motorcycle', 'archery']\n   *     }\n   *   ]\n   * })\n   *\n   * // Search for documents that contain (\"apple\" or \"pear\") but not \"juice\" and\n   * // not \"tree\"\n   * miniSearch.search({\n   *   combineWith: 'AND_NOT',\n   *   queries: [\n   *     {\n   *       combineWith: 'OR',\n   *       queries: ['apple', 'pear']\n   *     },\n   *     'juice',\n   *     'tree'\n   *   ]\n   * })\n   * ```\n   *\n   * Each node in the expression tree can be either a string, or an object that\n   * supports all `SearchOptions` fields, plus a `queries` array field for\n   * subqueries.\n   *\n   * Note that, while this can become complicated to do by hand for complex or\n   * deeply nested queries, it provides a formalized expression tree API for\n   * external libraries that implement a parser for custom query languages.\n   *\n   * @param query  Search query\n   * @param options  Search options. Each option, if not given, defaults to the corresponding value of `searchOptions` given to the constructor, or to the library default.\n   */\n  MiniSearch.prototype.search = function (query, searchOptions) {\n    var _this = this;\n    if (searchOptions === void 0) {\n      searchOptions = {};\n    }\n    var combinedResults = this.executeQuery(query, searchOptions);\n    return Object.entries(combinedResults).reduce(function (results, _a) {\n      var _b = __read(_a, 2),\n        docId = _b[0],\n        _c = _b[1],\n        score = _c.score,\n        match = _c.match,\n        terms = _c.terms;\n      var result = {\n        id: _this._documentIds[docId],\n        terms: uniq(terms),\n        score: score,\n        match: match\n      };\n      Object.assign(result, _this._storedFields[docId]);\n      if (searchOptions.filter == null || searchOptions.filter(result)) {\n        results.push(result);\n      }\n      return results;\n    }, []).sort(function (_a, _b) {\n      var a = _a.score;\n      var b = _b.score;\n      return a < b ? 1 : -1;\n    });\n  };\n  /**\n   * Provide suggestions for the given search query\n   *\n   * The result is a list of suggested modified search queries, derived from the\n   * given search query, each with a relevance score, sorted by descending score.\n   *\n   * ### Basic usage:\n   *\n   * ```javascript\n   * // Get suggestions for 'neuro':\n   * miniSearch.autoSuggest('neuro')\n   * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 0.46240 } ]\n   * ```\n   *\n   * ### Multiple words:\n   *\n   * ```javascript\n   * // Get suggestions for 'zen ar':\n   * miniSearch.autoSuggest('zen ar')\n   * // => [\n   * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },\n   * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }\n   * // ]\n   * ```\n   *\n   * ### Fuzzy suggestions:\n   *\n   * ```javascript\n   * // Correct spelling mistakes using fuzzy search:\n   * miniSearch.autoSuggest('neromancer', { fuzzy: 0.2 })\n   * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 1.03998 } ]\n   * ```\n   *\n   * ### Filtering:\n   *\n   * ```javascript\n   * // Get suggestions for 'zen ar', but only within the 'fiction' category\n   * // (assuming that 'category' is a stored field):\n   * miniSearch.autoSuggest('zen ar', {\n   *   filter: (result) => result.category === 'fiction'\n   * })\n   * // => [\n   * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },\n   * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }\n   * // ]\n   * ```\n   *\n   * @param queryString  Query string to be expanded into suggestions\n   * @param options  Search options. The supported options and default values\n   * are the same as for the `search` method, except that by default prefix\n   * search is performed on the last term in the query.\n   * @return  A sorted array of suggestions sorted by relevance score.\n   */\n  MiniSearch.prototype.autoSuggest = function (queryString, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    options = _assign(_assign({}, defaultAutoSuggestOptions), options);\n    var suggestions = this.search(queryString, options).reduce(function (suggestions, _a) {\n      var score = _a.score,\n        terms = _a.terms;\n      var phrase = terms.join(' ');\n      if (suggestions[phrase] == null) {\n        suggestions[phrase] = {\n          score: score,\n          terms: terms,\n          count: 1\n        };\n      } else {\n        suggestions[phrase].score += score;\n        suggestions[phrase].count += 1;\n      }\n      return suggestions;\n    }, {});\n    return Object.entries(suggestions).map(function (_a) {\n      var _b = __read(_a, 2),\n        suggestion = _b[0],\n        _c = _b[1],\n        score = _c.score,\n        terms = _c.terms,\n        count = _c.count;\n      return {\n        suggestion: suggestion,\n        terms: terms,\n        score: score / count\n      };\n    }).sort(function (_a, _b) {\n      var a = _a.score;\n      var b = _b.score;\n      return a < b ? 1 : -1;\n    });\n  };\n  Object.defineProperty(MiniSearch.prototype, \"documentCount\", {\n    /**\n     * Number of documents in the index\n     */\n    get: function get() {\n      return this._documentCount;\n    },\n    enumerable: false,\n    configurable: true\n  });\n  /**\n   * Deserializes a JSON index (serialized with `miniSearch.toJSON()`) and\n   * instantiates a MiniSearch instance. It should be given the same options\n   * originally used when serializing the index.\n   *\n   * ### Usage:\n   *\n   * ```javascript\n   * // If the index was serialized with:\n   * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })\n   * miniSearch.addAll(documents)\n   *\n   * const json = JSON.stringify(miniSearch)\n   * // It can later be deserialized like this:\n   * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })\n   * ```\n   *\n   * @param json  JSON-serialized index\n   * @param options  configuration options, same as the constructor\n   * @return An instance of MiniSearch deserialized from the given JSON.\n   */\n  MiniSearch.loadJSON = function (json, options) {\n    if (options == null) {\n      throw new Error('MiniSearch: loadJSON should be given the same options used when serializing the index');\n    }\n    return MiniSearch.loadJS(JSON.parse(json), options);\n  };\n  /**\n   * Returns the default value of an option. It will throw an error if no option\n   * with the given name exists.\n   *\n   * @param optionName  Name of the option\n   * @return The default value of the given option\n   *\n   * ### Usage:\n   *\n   * ```javascript\n   * // Get default tokenizer\n   * MiniSearch.getDefault('tokenize')\n   *\n   * // Get default term processor\n   * MiniSearch.getDefault('processTerm')\n   *\n   * // Unknown options will throw an error\n   * MiniSearch.getDefault('notExisting')\n   * // => throws 'MiniSearch: unknown option \"notExisting\"'\n   * ```\n   */\n  MiniSearch.getDefault = function (optionName) {\n    if (defaultOptions.hasOwnProperty(optionName)) {\n      return getOwnProperty(defaultOptions, optionName);\n    } else {\n      throw new Error(\"MiniSearch: unknown option \\\"\".concat(optionName, \"\\\"\"));\n    }\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.loadJS = function (js, options) {\n    var index = js.index,\n      documentCount = js.documentCount,\n      nextId = js.nextId,\n      documentIds = js.documentIds,\n      fieldIds = js.fieldIds,\n      fieldLength = js.fieldLength,\n      averageFieldLength = js.averageFieldLength,\n      storedFields = js.storedFields;\n    var miniSearch = new MiniSearch(options);\n    miniSearch._index = new SearchableMap(index._tree, index._prefix);\n    miniSearch._documentCount = documentCount;\n    miniSearch._nextId = nextId;\n    miniSearch._documentIds = documentIds;\n    miniSearch._fieldIds = fieldIds;\n    miniSearch._fieldLength = fieldLength;\n    miniSearch._averageFieldLength = averageFieldLength;\n    miniSearch._fieldIds = fieldIds;\n    miniSearch._storedFields = storedFields || {};\n    return miniSearch;\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.executeQuery = function (query, searchOptions) {\n    var _this = this;\n    if (searchOptions === void 0) {\n      searchOptions = {};\n    }\n    if (typeof query === 'string') {\n      return this.executeSearch(query, searchOptions);\n    } else {\n      var results = query.queries.map(function (subquery) {\n        var options = _assign(_assign(_assign({}, searchOptions), query), {\n          queries: undefined\n        });\n        return _this.executeQuery(subquery, options);\n      });\n      return this.combineResults(results, query.combineWith);\n    }\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.executeSearch = function (queryString, searchOptions) {\n    var _this = this;\n    if (searchOptions === void 0) {\n      searchOptions = {};\n    }\n    var _a = this._options,\n      tokenize = _a.tokenize,\n      processTerm = _a.processTerm,\n      globalSearchOptions = _a.searchOptions;\n    var options = _assign(_assign({\n      tokenize: tokenize,\n      processTerm: processTerm\n    }, globalSearchOptions), searchOptions);\n    var searchTokenize = options.tokenize,\n      searchProcessTerm = options.processTerm;\n    var terms = searchTokenize(queryString).map(function (term) {\n      return searchProcessTerm(term);\n    }).filter(function (term) {\n      return !!term;\n    });\n    var queries = terms.map(termToQuerySpec(options));\n    var results = queries.map(function (query) {\n      return _this.executeQuerySpec(query, options);\n    });\n    return this.combineResults(results, options.combineWith);\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.executeQuerySpec = function (query, searchOptions) {\n    var _this = this;\n    var options = _assign(_assign({}, this._options.searchOptions), searchOptions);\n    var boosts = (options.fields || this._options.fields).reduce(function (boosts, field) {\n      var _a;\n      return _assign(_assign({}, boosts), (_a = {}, _a[field] = getOwnProperty(boosts, field) || 1, _a));\n    }, options.boost || {});\n    var boostDocument = options.boostDocument,\n      weights = options.weights,\n      maxFuzzy = options.maxFuzzy;\n    var _a = _assign(_assign({}, defaultSearchOptions.weights), weights),\n      fuzzyWeight = _a.fuzzy,\n      prefixWeight = _a.prefix;\n    var exactMatch = this.termResults(query.term, boosts, boostDocument, this._index.get(query.term));\n    if (!query.fuzzy && !query.prefix) {\n      return exactMatch;\n    }\n    var results = [exactMatch];\n    if (query.prefix) {\n      this._index.atPrefix(query.term).forEach(function (term, data) {\n        var weightedDistance = 0.3 * (term.length - query.term.length) / term.length;\n        results.push(_this.termResults(term, boosts, boostDocument, data, prefixWeight, weightedDistance));\n      });\n    }\n    if (query.fuzzy) {\n      var fuzzy = query.fuzzy === true ? 0.2 : query.fuzzy;\n      var maxDistance = fuzzy < 1 ? Math.min(maxFuzzy, Math.round(query.term.length * fuzzy)) : fuzzy;\n      Object.entries(this._index.fuzzyGet(query.term, maxDistance)).forEach(function (_a) {\n        var _b = __read(_a, 2),\n          term = _b[0],\n          _c = __read(_b[1], 2),\n          data = _c[0],\n          distance = _c[1];\n        var weightedDistance = distance / term.length;\n        results.push(_this.termResults(term, boosts, boostDocument, data, fuzzyWeight, weightedDistance));\n      });\n    }\n    return results.reduce(combinators[OR]);\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.combineResults = function (results, combineWith) {\n    if (combineWith === void 0) {\n      combineWith = OR;\n    }\n    if (results.length === 0) {\n      return {};\n    }\n    var operator = combineWith.toLowerCase();\n    return results.reduce(combinators[operator]) || {};\n  };\n  /**\n   * Allows serialization of the index to JSON, to possibly store it and later\n   * deserialize it with `MiniSearch.loadJSON`.\n   *\n   * Normally one does not directly call this method, but rather call the\n   * standard JavaScript `JSON.stringify()` passing the `MiniSearch` instance,\n   * and JavaScript will internally call this method. Upon deserialization, one\n   * must pass to `loadJSON` the same options used to create the original\n   * instance that was serialized.\n   *\n   * ### Usage:\n   *\n   * ```javascript\n   * // Serialize the index:\n   * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })\n   * miniSearch.addAll(documents)\n   * const json = JSON.stringify(miniSearch)\n   *\n   * // Later, to deserialize it:\n   * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })\n   * ```\n   *\n   * @return A plain-object serializeable representation of the search index.\n   */\n  MiniSearch.prototype.toJSON = function () {\n    return {\n      index: this._index,\n      documentCount: this._documentCount,\n      nextId: this._nextId,\n      documentIds: this._documentIds,\n      fieldIds: this._fieldIds,\n      fieldLength: this._fieldLength,\n      averageFieldLength: this._averageFieldLength,\n      storedFields: this._storedFields\n    };\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.termResults = function (term, boosts, boostDocument, indexData, weight, editDistance) {\n    var _this = this;\n    if (editDistance === void 0) {\n      editDistance = 0;\n    }\n    if (indexData == null) {\n      return {};\n    }\n    return Object.entries(boosts).reduce(function (results, _a) {\n      var _b = __read(_a, 2),\n        field = _b[0],\n        boost = _b[1];\n      var fieldId = _this._fieldIds[field];\n      var _c = indexData[fieldId] || {\n          ds: {}\n        },\n        df = _c.df,\n        ds = _c.ds;\n      Object.entries(ds).forEach(function (_a) {\n        var _b = __read(_a, 2),\n          documentId = _b[0],\n          tf = _b[1];\n        var docBoost = boostDocument ? boostDocument(_this._documentIds[documentId], term) : 1;\n        if (!docBoost) {\n          return;\n        }\n        var normalizedLength = _this._fieldLength[documentId][fieldId] / _this._averageFieldLength[fieldId];\n        results[documentId] = results[documentId] || {\n          score: 0,\n          match: {},\n          terms: []\n        };\n        results[documentId].terms.push(term);\n        results[documentId].match[term] = getOwnProperty(results[documentId].match, term) || [];\n        results[documentId].score += docBoost * score(tf, df, _this._documentCount, normalizedLength, boost, editDistance);\n        results[documentId].match[term].push(field);\n      });\n      return results;\n    }, {});\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.addTerm = function (fieldId, documentId, term) {\n    this._index.update(term, function (indexData) {\n      var _a;\n      indexData = indexData || {};\n      var fieldIndex = indexData[fieldId] || {\n        df: 0,\n        ds: {}\n      };\n      if (fieldIndex.ds[documentId] == null) {\n        fieldIndex.df += 1;\n      }\n      fieldIndex.ds[documentId] = (fieldIndex.ds[documentId] || 0) + 1;\n      return _assign(_assign({}, indexData), (_a = {}, _a[fieldId] = fieldIndex, _a));\n    });\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.removeTerm = function (fieldId, documentId, term) {\n    var _this = this;\n    if (!this._index.has(term)) {\n      this.warnDocumentChanged(documentId, fieldId, term);\n      return;\n    }\n    this._index.update(term, function (indexData) {\n      var _a;\n      var fieldIndex = indexData[fieldId];\n      if (fieldIndex == null || fieldIndex.ds[documentId] == null) {\n        _this.warnDocumentChanged(documentId, fieldId, term);\n        return indexData;\n      }\n      if (fieldIndex.ds[documentId] <= 1) {\n        if (fieldIndex.df <= 1) {\n          delete indexData[fieldId];\n          return indexData;\n        }\n        fieldIndex.df -= 1;\n      }\n      if (fieldIndex.ds[documentId] <= 1) {\n        delete fieldIndex.ds[documentId];\n        return indexData;\n      }\n      fieldIndex.ds[documentId] -= 1;\n      return _assign(_assign({}, indexData), (_a = {}, _a[fieldId] = fieldIndex, _a));\n    });\n    if (Object.keys(this._index.get(term)).length === 0) {\n      this._index.delete(term);\n    }\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.warnDocumentChanged = function (shortDocumentId, fieldId, term) {\n    if (console == null || console.warn == null) {\n      return;\n    }\n    var fieldName = Object.entries(this._fieldIds).find(function (_a) {\n      var _b = __read(_a, 2);\n      _b[0];\n      var id = _b[1];\n      return id === fieldId;\n    })[0];\n    console.warn(\"MiniSearch: document with ID \".concat(this._documentIds[shortDocumentId], \" has changed before removal: term \\\"\").concat(term, \"\\\" was not present in field \\\"\").concat(fieldName, \"\\\". Removing a document after it has changed can corrupt the index!\"));\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.addDocumentId = function (documentId) {\n    var shortDocumentId = this._nextId.toString(36);\n    this._documentIds[shortDocumentId] = documentId;\n    this._documentCount += 1;\n    this._nextId += 1;\n    return shortDocumentId;\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.addFields = function (fields) {\n    var _this = this;\n    fields.forEach(function (field, i) {\n      _this._fieldIds[field] = i;\n    });\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.addFieldLength = function (documentId, fieldId, count, length) {\n    this._averageFieldLength[fieldId] = this._averageFieldLength[fieldId] || 0;\n    var totalLength = this._averageFieldLength[fieldId] * count + length;\n    this._fieldLength[documentId] = this._fieldLength[documentId] || {};\n    this._fieldLength[documentId][fieldId] = length;\n    this._averageFieldLength[fieldId] = totalLength / (count + 1);\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.removeFieldLength = function (documentId, fieldId, count, length) {\n    var totalLength = this._averageFieldLength[fieldId] * count - length;\n    this._averageFieldLength[fieldId] = totalLength / (count - 1);\n  };\n  /**\n   * @ignore\n   */\n  MiniSearch.prototype.saveStoredFields = function (documentId, doc) {\n    var _this = this;\n    var _a = this._options,\n      storeFields = _a.storeFields,\n      extractField = _a.extractField;\n    if (storeFields == null || storeFields.length === 0) {\n      return;\n    }\n    this._storedFields[documentId] = this._storedFields[documentId] || {};\n    storeFields.forEach(function (fieldName) {\n      var fieldValue = extractField(doc, fieldName);\n      if (fieldValue === undefined) {\n        return;\n      }\n      _this._storedFields[documentId][fieldName] = fieldValue;\n    });\n  };\n  return MiniSearch;\n}();\nvar getOwnProperty = function getOwnProperty(object, property) {\n  return Object.prototype.hasOwnProperty.call(object, property) ? object[property] : undefined;\n};\nvar combinators = (_a = {}, _a[OR] = function (a, b) {\n  return Object.entries(b).reduce(function (combined, _a) {\n    var _b;\n    var _c = __read(_a, 2),\n      documentId = _c[0],\n      _d = _c[1],\n      score = _d.score,\n      match = _d.match,\n      terms = _d.terms;\n    if (combined[documentId] == null) {\n      combined[documentId] = {\n        score: score,\n        match: match,\n        terms: terms\n      };\n    } else {\n      combined[documentId].score += score;\n      combined[documentId].score *= 1.5;\n      (_b = combined[documentId].terms).push.apply(_b, __spreadArray([], __read(terms), false));\n      Object.assign(combined[documentId].match, match);\n    }\n    return combined;\n  }, a || {});\n}, _a[AND] = function (a, b) {\n  return Object.entries(b).reduce(function (combined, _a) {\n    var _b = __read(_a, 2),\n      documentId = _b[0],\n      _c = _b[1],\n      score = _c.score,\n      match = _c.match,\n      terms = _c.terms;\n    if (a[documentId] === undefined) {\n      return combined;\n    }\n    combined[documentId] = combined[documentId] || {};\n    combined[documentId].score = a[documentId].score + score;\n    combined[documentId].match = _assign(_assign({}, a[documentId].match), match);\n    combined[documentId].terms = __spreadArray(__spreadArray([], __read(a[documentId].terms), false), __read(terms), false);\n    return combined;\n  }, {});\n}, _a[AND_NOT] = function (a, b) {\n  return Object.entries(b).reduce(function (combined, _a) {\n    var _b = __read(_a, 2),\n      documentId = _b[0],\n      _c = _b[1];\n    _c.score;\n    _c.match;\n    _c.terms;\n    delete combined[documentId];\n    return combined;\n  }, a || {});\n}, _a);\nvar tfIdf = function tfIdf(tf, df, n) {\n  return tf * Math.log(n / df);\n};\nvar score = function score(termFrequency, documentFrequency, documentCount, normalizedLength, boost, editDistance) {\n  var weight = boost / (1 + 0.333 * boost * editDistance);\n  return weight * tfIdf(termFrequency, documentFrequency, documentCount) / normalizedLength;\n};\nvar termToQuerySpec = function termToQuerySpec(options) {\n  return function (term, i, terms) {\n    var fuzzy = typeof options.fuzzy === 'function' ? options.fuzzy(term, i, terms) : options.fuzzy || false;\n    var prefix = typeof options.prefix === 'function' ? options.prefix(term, i, terms) : options.prefix === true;\n    return {\n      term: term,\n      fuzzy: fuzzy,\n      prefix: prefix\n    };\n  };\n};\nvar uniq = function uniq(array) {\n  return array.filter(function (element, i, array) {\n    return array.indexOf(element) === i;\n  });\n};\nvar defaultOptions = {\n  idField: 'id',\n  extractField: function extractField(document, fieldName) {\n    return document[fieldName];\n  },\n  tokenize: function tokenize(text, fieldName) {\n    return text.split(SPACE_OR_PUNCTUATION);\n  },\n  processTerm: function processTerm(term, fieldName) {\n    return term.toLowerCase();\n  },\n  fields: undefined,\n  searchOptions: undefined,\n  storeFields: []\n};\nvar defaultSearchOptions = {\n  combineWith: OR,\n  prefix: false,\n  fuzzy: false,\n  maxFuzzy: 6,\n  boost: {},\n  weights: {\n    fuzzy: 0.9,\n    prefix: 0.75\n  }\n};\nvar defaultAutoSuggestOptions = {\n  prefix: function prefix(term, i, terms) {\n    return i === terms.length - 1;\n  }\n};\n// This regular expression matches any Unicode space or punctuation character\n// Adapted from https://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5Cp%7BZ%7D%5Cp%7BP%7D&abb=on&c=on&esc=on\nvar SPACE_OR_PUNCTUATION = /[\\n\\r -#%-\\*,-\\/:;\\?@\\[-\\]_\\{\\}\\xA0\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u1680\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2000-\\u200A\\u2010-\\u2029\\u202F-\\u2043\\u2045-\\u2051\\u2053-\\u205F\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u3000-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]+/;\nexport { MiniSearch as default };","import MiniSearch from \"minisearch\";\nimport { useRef, useState, useEffect } from \"react\";\n\nfunction getLanguageFromPath(\n  path,\n  languages = [\"sv\", \"en\"],\n  defaultLanguage = \"sv\",\n) {\n  let urlPrefix = path.split(\"/\")[1];\n  if (languages.includes(urlPrefix)) {\n    return urlPrefix;\n  }\n  return defaultLanguage;\n}\n\nexport default function useMiniSearch({ documents, ...options }) {\n  const miniSearchRef = useRef();\n\n  useEffect(() => {\n    miniSearchRef.current = new MiniSearch(options);\n    miniSearchRef.current.addAll(documents);\n  }, []);\n\n  const search = async (request) => {\n    if (!request) return null;\n\n    const { query } = request;\n\n    const currentLanguage = getLanguageFromPath(window.location.pathname);\n\n    // Search with default options\n    // and also filter by current language\n    let hits = miniSearchRef.current.search(query, {\n      filter: (result) => {\n        if (!currentLanguage || !result.language) {\n          return true;\n        }\n        return result.language === currentLanguage?.toUpperCase();\n      },\n    });\n\n    return {\n      hits,\n    };\n  };\n\n  return { search };\n}\n","import { isEqual } from \"lodash\";\nimport React, { useState } from \"react\";\n\nimport { useAsync } from \"../hooks/async\";\nimport useMiniSearch from \"../hooks/useMiniSearch\";\nimport useSearchDocumentsForMiniSearch from \"../hooks/useSearchDocumentsForMiniSearch\";\nimport searchBackendContext from \"../searchBackendContext\";\n\nexport default function LocalSearchBackendProvider({\n  settings: { miniSearch = {} },\n  children,\n}) {\n  const { Provider } = searchBackendContext;\n  const [request, setRequest] = useState();\n  const documents = useSearchDocumentsForMiniSearch();\n\n  const { search } = useMiniSearch({\n    documents,\n    fields: [\"title\", \"body\"],\n    storeFields: Object.keys(documents[0]),\n    ...miniSearch,\n  });\n\n  const { result, error, isPending } = useAsync(() => search(request), [\n    request?.query,\n  ]);\n\n  const isEmptyRequest = request == null;\n  return (\n    <Provider\n      value={[\n        {\n          result,\n          isEmptyRequest,\n          isPending,\n          error,\n          isError: !!error,\n        },\n        (newRequest) => {\n          if (!isEqual(newRequest, request)) setRequest(newRequest);\n        },\n      ]}\n    >\n      {children}\n    </Provider>\n  );\n}\n","import { graphql, useStaticQuery } from \"gatsby\";\n\nexport default function useSearchDocumentsForMiniSearch() {\n  return useStaticQuery(graphql`\n    query SearchDocumentsForMiniSearchCustom {\n      allSearchDocument {\n        nodes {\n          id\n          body\n          contentType\n          date\n          title\n          language\n          url\n        }\n      }\n    }\n  `).allSearchDocument.nodes;\n}\n","import { useState, useMemo } from \"react\";\n\nexport function useAsync(maker, deps) {\n  const [isResolved, setIsResolved] = useState(false);\n  const [isRejected, setIsRejected] = useState(false);\n  const [result, setResult] = useState();\n\n  const promise = useMemo(() => {\n    setIsResolved(false);\n    setIsRejected(false);\n    setResult();\n\n    return maker();\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, deps);\n\n  promise.then((result) => {\n    setIsResolved(true);\n    setResult(result);\n  });\n\n  const isPending = !isResolved && !isRejected;\n\n  return {\n    isResolved,\n    isPending,\n    isRejected,\n    result,\n  };\n}\n","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _regeneratorRuntime() {\n  \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */\n  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {\n    return exports;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  var exports = {},\n    Op = Object.prototype,\n    hasOwn = Op.hasOwnProperty,\n    defineProperty = Object.defineProperty || function (obj, key, desc) {\n      obj[key] = desc.value;\n    },\n    $Symbol = \"function\" == typeof Symbol ? Symbol : {},\n    iteratorSymbol = $Symbol.iterator || \"@@iterator\",\n    asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\",\n    toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n  function define(obj, key, value) {\n    return Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }), obj[key];\n  }\n  try {\n    define({}, \"\");\n  } catch (err) {\n    define = function define(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,\n      generator = Object.create(protoGenerator.prototype),\n      context = new Context(tryLocsList || []);\n    return defineProperty(generator, \"_invoke\", {\n      value: makeInvokeMethod(innerFn, self, context)\n    }), generator;\n  }\n  function tryCatch(fn, obj, arg) {\n    try {\n      return {\n        type: \"normal\",\n        arg: fn.call(obj, arg)\n      };\n    } catch (err) {\n      return {\n        type: \"throw\",\n        arg: err\n      };\n    }\n  }\n  exports.wrap = wrap;\n  var ContinueSentinel = {};\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n  var getProto = Object.getPrototypeOf,\n    NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);\n  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function (method) {\n      define(prototype, method, function (arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (\"throw\" !== record.type) {\n        var result = record.arg,\n          value = result.value;\n        return value && \"object\" == _typeof(value) && hasOwn.call(value, \"__await\") ? PromiseImpl.resolve(value.__await).then(function (value) {\n          invoke(\"next\", value, resolve, reject);\n        }, function (err) {\n          invoke(\"throw\", err, resolve, reject);\n        }) : PromiseImpl.resolve(value).then(function (unwrapped) {\n          result.value = unwrapped, resolve(result);\n        }, function (error) {\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n      reject(record.arg);\n    }\n    var previousPromise;\n    defineProperty(this, \"_invoke\", {\n      value: function value(method, arg) {\n        function callInvokeWithMethodAndArg() {\n          return new PromiseImpl(function (resolve, reject) {\n            invoke(method, arg, resolve, reject);\n          });\n        }\n        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n      }\n    });\n  }\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = \"suspendedStart\";\n    return function (method, arg) {\n      if (\"executing\" === state) throw new Error(\"Generator is already running\");\n      if (\"completed\" === state) {\n        if (\"throw\" === method) throw arg;\n        return doneResult();\n      }\n      for (context.method = method, context.arg = arg;;) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n        if (\"next\" === context.method) context.sent = context._sent = context.arg;else if (\"throw\" === context.method) {\n          if (\"suspendedStart\" === state) throw state = \"completed\", context.arg;\n          context.dispatchException(context.arg);\n        } else \"return\" === context.method && context.abrupt(\"return\", context.arg);\n        state = \"executing\";\n        var record = tryCatch(innerFn, self, context);\n        if (\"normal\" === record.type) {\n          if (state = context.done ? \"completed\" : \"suspendedYield\", record.arg === ContinueSentinel) continue;\n          return {\n            value: record.arg,\n            done: context.done\n          };\n        }\n        \"throw\" === record.type && (state = \"completed\", context.method = \"throw\", context.arg = record.arg);\n      }\n    };\n  }\n  function maybeInvokeDelegate(delegate, context) {\n    var methodName = context.method,\n      method = delegate.iterator[methodName];\n    if (undefined === method) return context.delegate = null, \"throw\" === methodName && delegate.iterator[\"return\"] && (context.method = \"return\", context.arg = undefined, maybeInvokeDelegate(delegate, context), \"throw\" === context.method) || \"return\" !== methodName && (context.method = \"throw\", context.arg = new TypeError(\"The iterator does not provide a '\" + methodName + \"' method\")), ContinueSentinel;\n    var record = tryCatch(method, delegate.iterator, context.arg);\n    if (\"throw\" === record.type) return context.method = \"throw\", context.arg = record.arg, context.delegate = null, ContinueSentinel;\n    var info = record.arg;\n    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, \"return\" !== context.method && (context.method = \"next\", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = \"throw\", context.arg = new TypeError(\"iterator result is not an object\"), context.delegate = null, ContinueSentinel);\n  }\n  function pushTryEntry(locs) {\n    var entry = {\n      tryLoc: locs[0]\n    };\n    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);\n  }\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\", delete record.arg, entry.completion = record;\n  }\n  function Context(tryLocsList) {\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);\n  }\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) return iteratorMethod.call(iterable);\n      if (\"function\" == typeof iterable.next) return iterable;\n      if (!isNaN(iterable.length)) {\n        var i = -1,\n          next = function next() {\n            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;\n            return next.value = undefined, next.done = !0, next;\n          };\n        return next.next = next;\n      }\n    }\n    return {\n      next: doneResult\n    };\n  }\n  function doneResult() {\n    return {\n      value: undefined,\n      done: !0\n    };\n  }\n  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, \"constructor\", {\n    value: GeneratorFunctionPrototype,\n    configurable: !0\n  }), defineProperty(GeneratorFunctionPrototype, \"constructor\", {\n    value: GeneratorFunction,\n    configurable: !0\n  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, \"GeneratorFunction\"), exports.isGeneratorFunction = function (genFun) {\n    var ctor = \"function\" == typeof genFun && genFun.constructor;\n    return !!ctor && (ctor === GeneratorFunction || \"GeneratorFunction\" === (ctor.displayName || ctor.name));\n  }, exports.mark = function (genFun) {\n    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, \"GeneratorFunction\")), genFun.prototype = Object.create(Gp), genFun;\n  }, exports.awrap = function (arg) {\n    return {\n      __await: arg\n    };\n  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    void 0 === PromiseImpl && (PromiseImpl = Promise);\n    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);\n    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {\n      return result.done ? result.value : iter.next();\n    });\n  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, \"Generator\"), define(Gp, iteratorSymbol, function () {\n    return this;\n  }), define(Gp, \"toString\", function () {\n    return \"[object Generator]\";\n  }), exports.keys = function (val) {\n    var object = Object(val),\n      keys = [];\n    for (var key in object) keys.push(key);\n    return keys.reverse(), function next() {\n      for (; keys.length;) {\n        var key = keys.pop();\n        if (key in object) return next.value = key, next.done = !1, next;\n      }\n      return next.done = !0, next;\n    };\n  }, exports.values = values, Context.prototype = {\n    constructor: Context,\n    reset: function reset(skipTempReset) {\n      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) \"t\" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);\n    },\n    stop: function stop() {\n      this.done = !0;\n      var rootRecord = this.tryEntries[0].completion;\n      if (\"throw\" === rootRecord.type) throw rootRecord.arg;\n      return this.rval;\n    },\n    dispatchException: function dispatchException(exception) {\n      if (this.done) throw exception;\n      var context = this;\n      function handle(loc, caught) {\n        return record.type = \"throw\", record.arg = exception, context.next = loc, caught && (context.method = \"next\", context.arg = undefined), !!caught;\n      }\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i],\n          record = entry.completion;\n        if (\"root\" === entry.tryLoc) return handle(\"end\");\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\"),\n            hasFinally = hasOwn.call(entry, \"finallyLoc\");\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\n          } else {\n            if (!hasFinally) throw new Error(\"try statement without catch or finally\");\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\n          }\n        }\n      }\n    },\n    abrupt: function abrupt(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev && hasOwn.call(entry, \"finallyLoc\") && this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n      finallyEntry && (\"break\" === type || \"continue\" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);\n      var record = finallyEntry ? finallyEntry.completion : {};\n      return record.type = type, record.arg = arg, finallyEntry ? (this.method = \"next\", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);\n    },\n    complete: function complete(record, afterLoc) {\n      if (\"throw\" === record.type) throw record.arg;\n      return \"break\" === record.type || \"continue\" === record.type ? this.next = record.arg : \"return\" === record.type ? (this.rval = this.arg = record.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;\n    },\n    finish: function finish(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;\n      }\n    },\n    \"catch\": function _catch(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (\"throw\" === record.type) {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n      throw new Error(\"illegal catch attempt\");\n    },\n    delegateYield: function delegateYield(iterable, resultName, nextLoc) {\n      return this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      }, \"next\" === this.method && (this.arg = undefined), ContinueSentinel;\n    }\n  }, exports;\n}\nmodule.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","// TODO(Babel 8): Remove this file.\n\nvar runtime = require(\"../helpers/regeneratorRuntime\")();\nmodule.exports = runtime;\n\n// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n      args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n      _next(undefined);\n    });\n  };\n}"],"names":["_assign","Object","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","this","__values","o","Symbol","iterator","m","next","value","done","TypeError","__read","r","e","ar","push","error","__spreadArray","to","from","pack","l","Array","slice","concat","_a","KEYS","VALUES","LEAF","TreeIterator","set","type","node","_tree","keys","_type","_path","dive","backtrack","undefined","last$1","result","pop","key","_prefix","map","filter","join","array","withinDistance","a","b","maxDistance","edit","stack","distance","ia","ib","results","edit_1","SearchableMap","tree","prefix","atPrefix","startsWith","Error","_b","trackDown","path","_c","last","parentNode","key_1","nodeKey","find","k","clear","_size","delete","remove","entries","forEach","fn","e_1","_d","e_1_1","return","fuzzyGet","maxEditDistance","query","innerStack","_loop_1","node_1","totDistance","d","Infinity","fuzzySearch","get","lookup","has","createPath","defineProperty","_this","enumerable","configurable","update","values","e_2","entries_1","entries_1_1","e_2_1","fromObject","object","toSplit","commonPrefix","Math","min","cleanup","merge","OR","MiniSearch","options","fields","_options","defaultOptions","searchOptions","defaultSearchOptions","_index","_documentCount","_documentIds","_fieldIds","_fieldLength","_averageFieldLength","_nextId","_storedFields","addFields","add","document","extractField","tokenize","processTerm","idField","id","shortDocumentId","addDocumentId","saveStoredFields","field","fieldValue","tokens","toString","addFieldLength","documentCount","term","processedTerm","addTerm","addAll","documents","addAllAsync","chunkSize","acc","chunk","promise","Promise","resolve","reduce","then","setTimeout","longId","removeTerm","removeFieldLength","removeAll","search","combinedResults","executeQuery","docId","score","match","terms","uniq","sort","autoSuggest","queryString","defaultAutoSuggestOptions","suggestions","phrase","count","suggestion","loadJSON","json","loadJS","JSON","parse","getDefault","optionName","getOwnProperty","js","index","nextId","documentIds","fieldIds","fieldLength","averageFieldLength","storedFields","miniSearch","executeSearch","queries","subquery","combineResults","combineWith","globalSearchOptions","searchTokenize","searchProcessTerm","termToQuerySpec","executeQuerySpec","boosts","boost","boostDocument","weights","maxFuzzy","fuzzyWeight","fuzzy","prefixWeight","exactMatch","termResults","data","weightedDistance","round","combinators","operator","toLowerCase","toJSON","indexData","weight","editDistance","fieldId","ds","df","documentId","tf","docBoost","normalizedLength","fieldIndex","warnDocumentChanged","console","warn","fieldName","totalLength","doc","storeFields","property","combined","termFrequency","documentFrequency","log","element","indexOf","text","split","SPACE_OR_PUNCTUATION","getLanguageFromPath","languages","defaultLanguage","urlPrefix","includes","LocalSearchBackendProvider","_ref","_ref$settings$miniSea","settings","children","Provider","searchBackendContext","_useState","useState","request","setRequest","useStaticQuery","allSearchDocument","nodes","_useMiniSearch","_objectWithoutPropertiesLoose","_excluded","miniSearchRef","useRef","useEffect","current","_ref2","_asyncToGenerator","_regeneratorRuntime","_callee","currentLanguage","hits","_context","prev","abrupt","window","location","pathname","language","toUpperCase","stop","_x","useMiniSearch","_useAsync","maker","deps","isResolved","setIsResolved","_useState2","isRejected","setIsRejected","_useState3","setResult","useMemo","isPending","useAsync","isEmptyRequest","___EmotionJSX","isError","newRequest","_isEqual","_typeof","module","exports","__esModule","Op","hasOwn","obj","desc","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","writable","err","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","generator","create","context","Context","makeInvokeMethod","tryCatch","arg","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","Gp","defineIteratorMethods","method","_invoke","AsyncIterator","PromiseImpl","invoke","reject","record","__await","unwrapped","previousPromise","callInvokeWithMethodAndArg","state","doneResult","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","methodName","info","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","displayName","isGeneratorFunction","genFun","ctor","constructor","name","mark","setPrototypeOf","__proto__","awrap","async","iter","val","reverse","skipTempReset","charAt","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","runtime","regeneratorRuntime","accidentalStrictMode","globalThis","Function","asyncGeneratorStep","gen","_next","_throw","args"],"sourceRoot":""}