(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.MiniSearch = factory());
}(this, (function () { 'use strict';

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
  }

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};

      if (i % 2) {
        ownKeys(Object(source), true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }

    return target;
  }

  function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
  }

  function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

    return arr2;
  }

  function _createForOfIteratorHelperLoose(o, allowArrayLike) {
    var it;

    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
        if (it) o = it;
        var i = 0;
        return function () {
          if (i >= o.length) return {
            done: true
          };
          return {
            done: false,
            value: o[i++]
          };
        };
      }

      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
    }

    it = o[Symbol.iterator]();
    return it.next.bind(it);
  }

  /**
  * @private
  */
  var TreeIterator = /*#__PURE__*/function () {
    function TreeIterator(set, type) {
      var node = set._tree;
      var keys = Object.keys(node);
      this.set = set;
      this.type = type;
      this.path = keys.length > 0 ? [{
        node: node,
        keys: keys
      }] : [];
    }

    var _proto = TreeIterator.prototype;

    _proto.next = function next() {
      var value = this.dive();
      this.backtrack();
      return value;
    };

    _proto.dive = function dive() {
      if (this.path.length === 0) {
        return {
          done: true
        };
      }

      var _last = last(this.path),
          node = _last.node,
          keys = _last.keys;

      if (last(keys) === LEAF) {
        return {
          done: false,
          value: this.result()
        };
      }

      this.path.push({
        node: node[last(keys)],
        keys: Object.keys(node[last(keys)])
      });
      return this.dive();
    };

    _proto.backtrack = function backtrack() {
      if (this.path.length === 0) {
        return;
      }

      last(this.path).keys.pop();

      if (last(this.path).keys.length > 0) {
        return;
      }

      this.path.pop();
      this.backtrack();
    };

    _proto.key = function key() {
      return this.set._prefix + this.path.map(function (_ref) {
        var keys = _ref.keys;
        return last(keys);
      }).filter(function (key) {
        return key !== LEAF;
      }).join('');
    };

    _proto.value = function value() {
      return last(this.path).node[LEAF];
    };

    _proto.result = function result() {
      if (this.type === VALUES) {
        return this.value();
      }

      if (this.type === KEYS) {
        return this.key();
      }

      return [this.key(), this.value()];
    };

    _proto[Symbol.iterator] = function () {
      return this;
    };

    return TreeIterator;
  }();
  /** @ignore */


  var ENTRIES = 'ENTRIES';
  /** @ignore */

  var KEYS = 'KEYS';
  /** @ignore */

  var VALUES = 'VALUES';
  /** @ignore */

  var LEAF = '';

  var last = function last(array) {
    return array[array.length - 1];
  };

  /**
  * @ignore
  */

  var fuzzySearch = function fuzzySearch(node, query, maxDistance) {
    var stack = [{
      distance: 0,
      i: 0,
      key: '',
      node: node
    }];
    var results = {};
    var innerStack = [];

    var _loop = function _loop() {
      var _stack$pop = stack.pop(),
          node = _stack$pop.node,
          distance = _stack$pop.distance,
          key = _stack$pop.key,
          i = _stack$pop.i,
          edit = _stack$pop.edit;

      Object.keys(node).forEach(function (k) {
        if (k === LEAF) {
          var totDistance = distance + (query.length - i);

          var _ref = results[key] || [null, Infinity],
              d = _ref[1];

          if (totDistance <= maxDistance && totDistance < d) {
            results[key] = [node[k], totDistance];
          }
        } else {
          withinDistance(query, k, maxDistance - distance, i, edit, innerStack).forEach(function (_ref2) {
            var d = _ref2.distance,
                i = _ref2.i,
                edit = _ref2.edit;
            stack.push({
              node: node[k],
              distance: distance + d,
              key: key + k,
              i: i,
              edit: edit
            });
          });
        }
      });
    };

    while (stack.length > 0) {
      _loop();
    }

    return results;
  };
  /**
  * @ignore
  */

  var withinDistance = function withinDistance(a, b, maxDistance, i, edit, stack) {
    stack.push({
      distance: 0,
      ia: i,
      ib: 0,
      edit: edit
    });
    var results = [];

    while (stack.length > 0) {
      var _stack$pop2 = stack.pop(),
          distance = _stack$pop2.distance,
          ia = _stack$pop2.ia,
          ib = _stack$pop2.ib,
          _edit = _stack$pop2.edit;

      if (ib === b.length) {
        results.push({
          distance: distance,
          i: ia,
          edit: _edit
        });
        continue;
      }

      if (a[ia] === b[ib]) {
        stack.push({
          distance: distance,
          ia: ia + 1,
          ib: ib + 1,
          edit: NONE
        });
      } else {
        if (distance >= maxDistance) {
          continue;
        }

        if (_edit !== ADD) {
          stack.push({
            distance: distance + 1,
            ia: ia,
            ib: ib + 1,
            edit: DELETE
          });
        }

        if (ia < a.length) {
          if (_edit !== DELETE) {
            stack.push({
              distance: distance + 1,
              ia: ia + 1,
              ib: ib,
              edit: ADD
            });
          }

          if (_edit !== DELETE && _edit !== ADD) {
            stack.push({
              distance: distance + 1,
              ia: ia + 1,
              ib: ib + 1,
              edit: CHANGE
            });
          }
        }
      }
    }

    return results;
  };
  var NONE = 0;
  var CHANGE = 1;
  var ADD = 2;
  var DELETE = 3;

  /**
  * A class implementing the same interface as a standard JavaScript `Map` with
  * string keys, but adding support for efficiently searching entries with prefix
  * or fuzzy search. This is the class internally used by `MiniSearch` as the
  * inverted index data structure. The implementation is a radix tree (compressed
  * prefix tree).
  *
  * @implements {Map}
  */

  var SearchableMap = /*#__PURE__*/function () {
    function SearchableMap(tree, prefix) {
      if (tree === void 0) {
        tree = {};
      }

      if (prefix === void 0) {
        prefix = '';
      }

      /** @private */
      this._tree = tree;
      /** @private */

      this._prefix = prefix;
    }
    /**
    * Creates and returns a mutable view of this `SearchableMap`, containing only
    * entries that share the given prefix.
    *
    * @example
    * let map = new SearchableMap()
    * map.set("unicorn", 1)
    * map.set("universe", 2)
    * map.set("university", 3)
    * map.set("unique", 4)
    * map.set("hello", 5)
    *
    * let uni = map.atPrefix("uni")
    * uni.get("unique") // => 4
    * uni.get("unicorn") // => 1
    * uni.get("hello") // => undefined
    *
    * let univer = map.atPrefix("univer")
    * univer.get("unique") // => undefined
    * univer.get("universe") // => 2
    * univer.get("university") // => 3
    *
    * @param {string} prefix - The prefix
    * @return {SearchableMap} A `SearchableMap` representing a mutable view of the original Map at the given prefix
    */


    var _proto = SearchableMap.prototype;

    _proto.atPrefix = function atPrefix(prefix) {
      if (!prefix.startsWith(this._prefix)) {
        throw new Error('Mismatched prefix');
      }

      var _trackDown = trackDown(this._tree, prefix.slice(this._prefix.length)),
          node = _trackDown[0],
          path = _trackDown[1];

      if (node === undefined) {
        var _last = last$1(path),
            parentNode = _last[0],
            key = _last[1];

        var nodeKey = Object.keys(parentNode).find(function (k) {
          return k !== LEAF && k.startsWith(key);
        });

        if (nodeKey !== undefined) {
          var _SearchableMap;

          return new SearchableMap((_SearchableMap = {}, _SearchableMap[nodeKey.slice(key.length)] = parentNode[nodeKey], _SearchableMap), prefix);
        }
      }

      return new SearchableMap(node || {}, prefix);
    }
    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear
    * @return {undefined}
    */
    ;

    _proto.clear = function clear() {
      delete this._size;
      this._tree = {};
    }
    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete
    * @param {string} key
    * @return {undefined}
    */
    ;

    _proto.delete = function _delete(key) {
      delete this._size;
      return remove(this._tree, key);
    }
    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries
    * @return {Iterator}
    */
    ;

    _proto.entries = function entries() {
      return new TreeIterator(this, ENTRIES);
    }
    /**
     * @callback SearchableMap~forEachFn
     * @param {string} key - Key
     * @param {any} value - Value associated to key
     * @return any
     */

    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach
    * @param {SearchableMap~forEachFn} fn
    * @return {undefined}
    */
    ;

    _proto.forEach = function forEach(fn) {
      for (var _iterator = _createForOfIteratorHelperLoose(this), _step; !(_step = _iterator()).done;) {
        var _step$value = _step.value,
            key = _step$value[0],
            value = _step$value[1];
        fn(key, value, this);
      }
    }
    /**
    * Returns a key-value object of all the entries that have a key within the
    * given edit distance from the search key. The keys of the returned object are
    * the matching keys, while the values are two-elements arrays where the first
    * element is the value associated to the key, and the second is the edit
    * distance of the key to the search key.
    *
    * @example
    * let map = new SearchableMap()
    * map.set('hello', 'world')
    * map.set('hell', 'yeah')
    * map.set('ciao', 'mondo')
    *
    * // Get all entries that match the key 'hallo' with a maximum edit distance of 2
    * map.fuzzyGet('hallo', 2)
    * // => { "hello": ["world", 1], "hell": ["yeah", 2] }
    *
    * // In the example, the "hello" key has value "world" and edit distance of 1
    * // (change "e" to "a"), the key "hell" has value "yeah" and edit distance of 2
    * // (change "e" to "a", delete "o")
    *
    * @param {string} key - The search key
    * @param {number} maxEditDistance - The maximum edit distance
    * @return {Object<string, Array>} A key-value object of the matching keys to their value and edit distance
    */
    ;

    _proto.fuzzyGet = function fuzzyGet(key, maxEditDistance) {
      return fuzzySearch(this._tree, key, maxEditDistance);
    }
    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get
    * @param {string} key
    * @return {any}
    */
    ;

    _proto.get = function get(key) {
      var node = lookup(this._tree, key);
      return node !== undefined ? node[LEAF] : undefined;
    }
    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has
    * @param {string} key
    * @return {boolean}
    */
    ;

    _proto.has = function has(key) {
      var node = lookup(this._tree, key);
      return node !== undefined && node.hasOwnProperty(LEAF);
    }
    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys
    * @return {Iterator}
    */
    ;

    _proto.keys = function keys() {
      return new TreeIterator(this, KEYS);
    }
    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set
    * @param {string} key
    * @param {any} value
    * @return {SearchableMap} The `SearchableMap` itself, to allow chaining
    */
    ;

    _proto.set = function set(key, value) {
      if (typeof key !== 'string') {
        throw new Error('key must be a string');
      }

      delete this._size;
      var node = createPath(this._tree, key);
      node[LEAF] = value;
      return this;
    }
    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size
    * @type {number}
    */
    ;

    /**
     * @callback SearchableMap~updateFn
     * @param {any} currentValue - The current value
     * @return any - the updated value
     */

    /**
    * Updates the value at the given key using the provided function. The function
    * is called with the current value at the key, and its return value is used as
    * the new value to be set.
    *
    * @example
    * // Increment the current value by one
    * searchableMap.update('somekey', (currentValue) => currentValue == null ? 0 : currentValue + 1)
    *
    * @param {string} key - The key
    * @param {SearchableMap~updateFn} fn - The function used to compute the new value from the current one
    * @return {SearchableMap} The `SearchableMap` itself, to allow chaining
    */
    _proto.update = function update(key, fn) {
      if (typeof key !== 'string') {
        throw new Error('key must be a string');
      }

      delete this._size;
      var node = createPath(this._tree, key);
      node[LEAF] = fn(node[LEAF]);
      return this;
    }
    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values
    * @return {Iterator}
    */
    ;

    _proto.values = function values() {
      return new TreeIterator(this, VALUES);
    }
    /**
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@iterator
    * @return {Iterator}
    */
    ;

    _proto[Symbol.iterator] = function () {
      return this.entries();
    };

    _createClass(SearchableMap, [{
      key: "size",
      get: function get() {
        var _this = this;

        if (this._size) {
          return this._size;
        }
        /** @ignore */


        this._size = 0;
        this.forEach(function () {
          _this._size += 1;
        });
        return this._size;
      }
    }]);

    return SearchableMap;
  }();
  /**
  * Creates a `SearchableMap` from an `Iterable` of entries
  *
  * @param {Iterable|Array} entries - Entries to be inserted in the `SearchableMap`
  * @return {SearchableMap} A new `SearchableMap` with the given entries
  **/


  SearchableMap.from = function (entries) {
    var tree = new SearchableMap();

    for (var _iterator2 = _createForOfIteratorHelperLoose(entries), _step2; !(_step2 = _iterator2()).done;) {
      var _step2$value = _step2.value,
          key = _step2$value[0],
          value = _step2$value[1];
      tree.set(key, value);
    }

    return tree;
  };
  /**
  * Creates a `SearchableMap` from the iterable properties of a JavaScript object
  *
  * @param {Object} object - Object of entries for the `SearchableMap`
  * @return {SearchableMap} A new `SearchableMap` with the given entries
  **/


  SearchableMap.fromObject = function (object) {
    return SearchableMap.from(Object.entries(object));
  };

  var trackDown = function trackDown(tree, key, path) {
    if (path === void 0) {
      path = [];
    }

    if (key.length === 0) {
      return [tree, path];
    }

    var nodeKey = Object.keys(tree).find(function (k) {
      return k !== LEAF && key.startsWith(k);
    });

    if (nodeKey === undefined) {
      return trackDown(undefined, '', [].concat(path, [[tree, key]]));
    }

    return trackDown(tree[nodeKey], key.slice(nodeKey.length), [].concat(path, [[tree, nodeKey]]));
  };

  var lookup = function lookup(tree, key) {
    if (key.length === 0) {
      return tree;
    }

    var nodeKey = Object.keys(tree).find(function (k) {
      return k !== LEAF && key.startsWith(k);
    });

    if (nodeKey === undefined) {
      return undefined;
    }

    return lookup(tree[nodeKey], key.slice(nodeKey.length));
  };

  var createPath = function createPath(tree, key) {
    if (key.length === 0) {
      return tree;
    }

    var nodeKey = Object.keys(tree).find(function (k) {
      return k !== LEAF && key.startsWith(k);
    });

    if (nodeKey === undefined) {
      var toSplit = Object.keys(tree).find(function (k) {
        return k !== LEAF && k.startsWith(key[0]);
      });

      if (toSplit === undefined) {
        tree[key] = {};
      } else {
        var _tree$prefix;

        var prefix = commonPrefix(key, toSplit);
        tree[prefix] = (_tree$prefix = {}, _tree$prefix[toSplit.slice(prefix.length)] = tree[toSplit], _tree$prefix);
        delete tree[toSplit];
        return createPath(tree[prefix], key.slice(prefix.length));
      }

      return tree[key];
    }

    return createPath(tree[nodeKey], key.slice(nodeKey.length));
  };

  var commonPrefix = function commonPrefix(a, b, i, length, prefix) {
    if (i === void 0) {
      i = 0;
    }

    if (length === void 0) {
      length = Math.min(a.length, b.length);
    }

    if (prefix === void 0) {
      prefix = '';
    }

    if (i >= length) {
      return prefix;
    }

    if (a[i] !== b[i]) {
      return prefix;
    }

    return commonPrefix(a, b, i + 1, length, prefix + a[i]);
  };

  var remove = function remove(tree, key) {
    var _trackDown2 = trackDown(tree, key),
        node = _trackDown2[0],
        path = _trackDown2[1];

    if (node === undefined) {
      return;
    }

    delete node[LEAF];
    var keys = Object.keys(node);

    if (keys.length === 0) {
      cleanup(path);
    }

    if (keys.length === 1) {
      merge(path, keys[0], node[keys[0]]);
    }
  };

  var cleanup = function cleanup(path) {
    if (path.length === 0) {
      return;
    }

    var _last2 = last$1(path),
        node = _last2[0],
        key = _last2[1];

    delete node[key];

    if (Object.keys(node).length === 0) {
      cleanup(path.slice(0, -1));
    }
  };

  var merge = function merge(path, key, value) {
    if (path.length === 0) {
      return;
    }

    var _last3 = last$1(path),
        node = _last3[0],
        nodeKey = _last3[1];

    node[nodeKey + key] = value;
    delete node[nodeKey];
  };

  var last$1 = function last(array) {
    return array[array.length - 1];
  };

  var _combinators;
  var OR = 'or';
  var AND = 'and';
  /**
  * MiniSearch is the main entrypoint class, and represents a full-text search
  * engine.
  *
  * @example
  * const documents = [
  *   {
  *     id: 1,
  *     title: 'Moby Dick',
  *     text: 'Call me Ishmael. Some years ago...',
  *     category: 'fiction'
  *   },
  *   {
  *     id: 2,
  *     title: 'Zen and the Art of Motorcycle Maintenance',
  *     text: 'I can see by my watch...',
  *     category: 'fiction'
  *   },
  *   {
  *     id: 3,
  *     title: 'Neuromancer',
  *     text: 'The sky above the port was...',
  *     category: 'fiction'
  *   },
  *   {
  *     id: 4,
  *     title: 'Zen and the Art of Archery',
  *     text: 'At first sight it must seem...',
  *     category: 'non-fiction'
  *   },
  *   // ...and more
  * ]
  *
  * // Create a search engine that indexes the 'title' and 'text' fields for
  * // full-text search. Search results will include 'title' and 'category' (plus the
  * // id field, that is always stored and returned)
  * const miniSearch = MiniSearch.new({
  *   fields: ['title', 'text'],
  *   storeFields: ['title', 'category']
  * })
  *
  * // Add documents to the index
  * miniSearch.addAll(documents)
  *
  * // Search for documents:
  * let results = miniSearch.search('zen art motorcycle')
  * // => [
  *   { id: 2, title: 'Zen and the Art of Motorcycle Maintenance', category: 'fiction', score: 2.77258 },
  *   { id: 4, title: 'Zen and the Art of Archery', category: 'non-fiction', score: 1.38629 }
  * ]
  * */

  var MiniSearch = /*#__PURE__*/function () {
    /**
     * @callback MiniSearch~extractField
     * @param {Object} document - A document object
     * @param {string} fieldName - Name of the field to extract
     * @return string - Value of the field
     */

    /**
     * @callback MiniSearch~tokenize
     * @param {string} text - Text to tokenize
     * @param {?string} fieldName - Name of the field to tokenize
     * @return string[] - Tokenized terms
     */

    /**
     * @callback MiniSearch~processTerm
     * @param {string} text - The text to tokenize
     * @param {?string} fieldName - The name of the field to tokenize
     * @return string|null|undefined|false - Processed term, or a falsy value to discard the term
     */

    /**
    * @param {Object} options - Configuration options
    * @param {Array<string>} options.fields - Fields to be indexed. Required.
    * @param {string} [options.idField='id'] - ID field, uniquely identifying a document
    * @param {Array<string>} [options.storeFields] - Fields to store, so that search results would include them. By default none, so resuts would only contain the id field.
    * @param {MiniSearch~extractField} [options.extractField] - Function used to get the value of a field in a document
    * @param {MiniSearch~tokenize} [options.tokenize] - Function used to split a field into individual terms
    * @param {MiniSearch~processTerm} [options.processTerm] - Function used to process a term before indexing it or searching
    * @param {Object} [options.searchOptions] - Default search options (see the `search` method for details)
    *
    * @example
    * // Create a search engine that indexes the 'title' and 'text' fields of your
    * // documents:
    * const miniSearch = MiniSearch.new({ fields: ['title', 'text'] })
    *
    * @example
    * // Your documents are assumed to include a unique 'id' field, but if you want
    * // to use a different field for document identification, you can set the
    * // 'idField' option:
    * const miniSearch = MiniSearch.new({ idField: 'key', fields: ['title', 'text'] })
    *
    * @example
    * // The full set of options (here with their default value) is:
    * const miniSearch = MiniSearch.new({
    *   // idField: field that uniquely identifies a document
    *   idField: 'id',
    *
    *   // extractField: function used to get the value of a field in a document.
    *   // By default, it assumes the document is a flat object with field names as
    *   // property keys and field values as string property values, but custom logic
    *   // can be implemented by setting this option to a custom extractor function.
    *   extractField: (document, fieldName) => document[fieldName],
    *
    *   // tokenize: function used to split fields into individual terms. By
    *   // default, it is also used to tokenize search queries, unless a specific
    *   // `tokenize` search option is supplied. When tokenizing an indexed field,
    *   // the field name is passed as the second argument.
    *   tokenize: (string, _fieldName) => string.split(SPACE_OR_PUNCTUATION),
    *
    *   // processTerm: function used to process each tokenized term before
    *   // indexing. It can be used for stemming and normalization. Return a falsy
    *   // value in order to discard a term. By default, it is also used to process
    *   // search queries, unless a specific `processTerm` option is supplied as a
    *   // search option. When processing a term from a indexed field, the field
    *   // name is passed as the second argument.
    *   processTerm: (term, _fieldName) => term.toLowerCase(),
    *
    *   // searchOptions: default search options, see the `search` method for
    *   // details
    *   searchOptions: undefined,
    *
    *   // fields: document fields to be indexed. Mandatory, but not set by default
    *   fields: undefined
    *
    *   // storeFields: document fields to be stored and returned as part of the
    *   // search results.
    *   storeFields: []
    * })
    */
    function MiniSearch(options) {
      if (options === void 0) {
        options = {};
      }

      /** @private */
      this._options = _objectSpread2(_objectSpread2({}, defaultOptions), options);
      this._options.searchOptions = _objectSpread2(_objectSpread2({}, defaultSearchOptions), this._options.searchOptions || {});
      var fields = this._options.fields;

      if (fields == null) {
        throw new Error('MiniSearch: option "fields" must be provided');
      }
      /** @private */


      this._index = new SearchableMap();
      /** @private */

      this._documentCount = 0;
      /** @private */

      this._documentIds = {};
      /** @private */

      this._fieldIds = {};
      /** @private */

      this._fieldLength = {};
      /** @private */

      this._averageFieldLength = {};
      /** @private */

      this._nextId = 0;
      /** @private */

      this._storedFields = {};
      addFields(this, fields);
    }
    /**
    * Adds a document to the index
    *
    * @param {Object} document - the document to be indexed
    */


    var _proto = MiniSearch.prototype;

    _proto.add = function add(document) {
      var _this = this;

      var _this$_options = this._options,
          extractField = _this$_options.extractField,
          tokenize = _this$_options.tokenize,
          processTerm = _this$_options.processTerm,
          fields = _this$_options.fields,
          idField = _this$_options.idField;
      var id = extractField(document, idField);

      if (id == null) {
        throw new Error("MiniSearch: document does not have ID field \"" + idField + "\"");
      }

      var shortDocumentId = addDocumentId(this, id);
      saveStoredFields(this, shortDocumentId, document);
      fields.forEach(function (field) {
        var fieldValue = extractField(document, field);

        if (fieldValue == null) {
          return;
        }

        var tokens = tokenize(fieldValue.toString(), field);
        addFieldLength(_this, shortDocumentId, _this._fieldIds[field], _this.documentCount - 1, tokens.length);
        tokens.forEach(function (term) {
          var processedTerm = processTerm(term, field);

          if (isTruthy(processedTerm)) {
            addTerm(_this, _this._fieldIds[field], shortDocumentId, processedTerm);
          }
        });
      });
    }
    /**
    * Adds all the given documents to the index
    *
    * @param {Object[]} documents - an array of documents to be indexed
    */
    ;

    _proto.addAll = function addAll(documents) {
      var _this2 = this;

      documents.forEach(function (document) {
        return _this2.add(document);
      });
    }
    /**
    * Adds all the given documents to the index asynchronously.
    *
    * Returns a promise that resolves to undefined when the indexing is done. This
    * method is useful when index many documents, to avoid blocking the main
    * thread. The indexing is performed asynchronously and in chunks.
    *
    * @param {Object[]} documents - an array of documents to be indexed
    * @param {Object} [options] - Configuration options
    * @param {number} [options.chunkSize] - Size of the document chunks indexed, 10 by default
    * @return {Promise} A promise resolving to `null` when the indexing is done
    */
    ;

    _proto.addAllAsync = function addAllAsync(documents, options) {
      var _this3 = this;

      if (options === void 0) {
        options = {};
      }

      var _options = options,
          _options$chunkSize = _options.chunkSize,
          chunkSize = _options$chunkSize === void 0 ? 10 : _options$chunkSize;
      var acc = {
        chunk: [],
        promise: Promise.resolve(null)
      };

      var _documents$reduce = documents.reduce(function (_ref, document, i) {
        var chunk = _ref.chunk,
            promise = _ref.promise;
        chunk.push(document);

        if ((i + 1) % chunkSize === 0) {
          return {
            chunk: [],
            promise: promise.then(function () {
              return _this3.addAll(chunk);
            })
          };
        } else {
          return {
            chunk: chunk,
            promise: promise
          };
        }
      }, acc),
          chunk = _documents$reduce.chunk,
          promise = _documents$reduce.promise;

      return promise.then(function () {
        return _this3.addAll(chunk);
      });
    }
    /**
    * Removes the given document from the index.
    *
    * The document to delete must NOT have changed between indexing and deletion,
    * otherwise the index will be corrupted. Therefore, when reindexing a document
    * after a change, the correct order of operations is:
    *
    *   1. remove old version
    *   2. apply changes
    *   3. index new version
    *
    * @param {Object} document - the document to be removed
    */
    ;

    _proto.remove = function remove(document) {
      var _this4 = this;

      var _this$_options2 = this._options,
          tokenize = _this$_options2.tokenize,
          processTerm = _this$_options2.processTerm,
          extractField = _this$_options2.extractField,
          fields = _this$_options2.fields,
          idField = _this$_options2.idField;
      var id = extractField(document, idField);

      if (id == null) {
        throw new Error("MiniSearch: document does not have ID field \"" + idField + "\"");
      }

      var _ref2 = Object.entries(this._documentIds).find(function (_ref3) {
        var _ = _ref3[0],
            longId = _ref3[1];
        return id === longId;
      }) || [],
          shortDocumentId = _ref2[0];

      if (shortDocumentId == null) {
        throw new Error("MiniSearch: cannot remove document with ID " + id + ": it is not in the index");
      }

      fields.forEach(function (field) {
        var fieldValue = extractField(document, field);

        if (fieldValue == null) {
          return;
        }

        var tokens = tokenize(fieldValue.toString(), field);
        tokens.forEach(function (term) {
          var processedTerm = processTerm(term, field);

          if (isTruthy(processedTerm)) {
            removeTerm(_this4, _this4._fieldIds[field], shortDocumentId, processedTerm);
          }
        });
      });
      delete this._storedFields[shortDocumentId];
      delete this._documentIds[shortDocumentId];
      this._documentCount -= 1;
    }
    /**
    * Removes all the given documents from the index. If called with no arguments,
    * it removes _all_ documents from the index.
    *
    * @param {Array<Object>} [documents] - the documents to be removed
    */
    ;

    _proto.removeAll = function removeAll(documents) {
      var _this5 = this;

      if (arguments.length === 0) {
        this._index = new SearchableMap();
        this._documentCount = 0;
        this._documentIds = {};
        this._fieldLength = {};
        this._averageFieldLength = {};
        this._storedFields = {};
        this._nextId = 0;
      } else {
        documents.forEach(function (document) {
          return _this5.remove(document);
        });
      }
    }
    /**
     * @callback MiniSearch~prefixFn
     * @param {string} term - Search term
     * @param {number} i - Index of the term in the query terms array
     * @param {string[]} terms - Array of all query terms
     * @return boolean - `true` to perform prefix search, `false` to not perform it
     */

    /**
     * @callback MiniSearch~fuzzyFn
     * @param {string} term - Search term
     * @param {number} i - Index of the search term in the tokenized search query
     * @param {string[]} terms - Array of all query terms
     * @return number|false - Maximum edit distance, or `false` to not perform fuzzy search
     */

    /**
     * @callback MiniSearch~filter
     * @param {Object} result - A search result
     * @return boolean - `true` to keep the result, `false` to filter it out
     */

    /**
    * Search for documents matching the given search query.
    *
    * The result is a list of scored document IDs matching the query, sorted by
    * descending score, and each including data about which terms were matched and
    * in which fields.
    *
    * @param {string} queryString - Query string to search for
    * @param {Object} [options] - Search options. Each option, if not given, defaults to the corresponding value of `searchOptions` given to the constructor, or to the library default.
    * @param {Array<string>} [options.fields] - Fields to search in. If omitted, all fields are searched
    * @param {Object<string, number>} [options.boost] - Key-value object of boosting values for fields
    * @param {boolean|MiniSearch~prefixFn} [options.prefix=false] - Whether to perform prefix search. Value can be a boolean, or a function computing the boolean from each tokenized and processed query term. If a function is given, it is called with the following arguments: `term: string` - the query term; `i: number` - the term index in the query terms; `terms: Array<string>` - the array of query terms.
    * @param {number|false|MiniSearch~fuzzyFn} [options.fuzzy=false] - If set to a number greater than or equal 1, it performs fuzzy search within a maximum edit distance equal to that value. If set to a number less than 1, it performs fuzzy search with a maximum edit distance equal to the term length times the value, rouded at the nearest integer. If set to a function, it calls the function for each tokenized and processed query term and expects a numeric value indicating the maximum edit distance, or a falsy falue if fuzzy search should not be performed. If a function is given, it is called with the following arguments: `term: string` - the query term; `i: number` - the term index in the query terms; `terms: Array<string>` - the array of query terms.
    * @param {string} [options.combineWith='OR'] - How to combine term queries (it can be 'OR' or 'AND')
    * @param {MiniSearch~tokenize} [options.tokenize] - Function used to tokenize the search query. It defaults to the same tokenizer used for indexing.
    * @param {MiniSearch~processTerm} [options.processTerm] - Function used to process each search term. Return a falsy value to discard a term. Defaults to the same function used to process terms upon indexing.
    * @param {MiniSearch~filter} [options.filter] - Function used to filter search results, for example on the basis of stored fields
    * @return {Array<{ id: any, score: number, match: Object }>} A sorted array of scored document IDs matching the search
    *
    * @example
    * // Search for "zen art motorcycle" with default options: terms have to match
    * // exactly, and individual terms are joined with OR
    * miniSearch.search('zen art motorcycle')
    * // => [ { id: 2, score: 2.77258, match: { ... } }, { id: 4, score: 1.38629, match: { ... } } ]
    *
    * @example
    * // Search only in the 'title' field
    * miniSearch.search('zen', { fields: ['title'] })
    *
    * @example
    * // Boost a field
    * miniSearch.search('zen', { boost: { title: 2 } })
    *
    * @example
    * // Search for "moto" with prefix search (it will match documents
    * // containing terms that start with "moto" or "neuro")
    * miniSearch.search('moto neuro', { prefix: true })
    *
    * @example
    * // Search for "ismael" with fuzzy search (it will match documents containing
    * // terms similar to "ismael", with a maximum edit distance of 0.2 term.length
    * // (rounded to nearest integer)
    * miniSearch.search('ismael', { fuzzy: 0.2 })
    *
    * @example
    * // Mix of exact match, prefix search, and fuzzy search
    * miniSearch.search('ismael mob', {
    *  prefix: true,
    *  fuzzy: 0.2
    * })
    *
    * @example
    * // Perform fuzzy and prefix search depending on the search term. Here
    * // performing prefix and fuzzy search only on terms longer than 3 characters
    * miniSearch.search('ismael mob', {
    *  prefix: term => term.length > 3
    *  fuzzy: term => term.length > 3 ? 0.2 : null
    * })
    *
    * @example
    * // Combine search terms with AND (to match only documents that contain both
    * // "motorcycle" and "art")
    * miniSearch.search('motorcycle art', { combineWith: 'AND' })
    *
    * @example
    * // Filter only results in the 'fiction' category (assuming that 'category'
    * // is a stored field)
    * miniSearch.search('motorcycle art', {
    *   filter: (result) => result.category === 'fiction'
    * })
    */
    ;

    _proto.search = function search(queryString, options) {
      var _this6 = this;

      if (options === void 0) {
        options = {};
      }

      var _this$_options3 = this._options,
          tokenize = _this$_options3.tokenize,
          processTerm = _this$_options3.processTerm,
          searchOptions = _this$_options3.searchOptions;
      options = _objectSpread2(_objectSpread2({
        tokenize: tokenize,
        processTerm: processTerm
      }, searchOptions), options);
      var _options2 = options,
          searchTokenize = _options2.tokenize,
          searchProcessTerm = _options2.processTerm;
      var queries = searchTokenize(queryString).map(function (term) {
        return searchProcessTerm(term);
      }).filter(isTruthy).map(termToQuery(options));
      var results = queries.map(function (query) {
        return _this6.executeQuery(query, options);
      });
      var combinedResults = this.combineResults(results, options.combineWith);
      return Object.entries(combinedResults).reduce(function (results, _ref4) {
        var docId = _ref4[0],
            _ref4$ = _ref4[1],
            score = _ref4$.score,
            match = _ref4$.match,
            terms = _ref4$.terms;
        var result = {
          id: _this6._documentIds[docId],
          terms: uniq(terms),
          score: score,
          match: match
        };
        Object.assign(result, _this6._storedFields[docId]);

        if (options.filter == null || options.filter(result)) {
          results.push(result);
        }

        return results;
      }, []).sort(function (_ref5, _ref6) {
        var a = _ref5.score;
        var b = _ref6.score;
        return a < b ? 1 : -1;
      });
    }
    /**
    * Provide suggestions for the given search query
    *
    * The result is a list of suggested modified search queries, derived from the
    * given search query, each with a relevance score, sorted by descending score.
    *
    * @param {string} queryString - Query string to be expanded into suggestions
    * @param {Object} [options] - Search options. The supported options and default values are the same as for the `search` method, except that by default prefix search is performed on the last term in the query.
    * @return {Array<{ suggestion: string, score: number }>} A sorted array of suggestions sorted by relevance score.
    *
    * @example
    * // Get suggestions for 'neuro':
    * miniSearch.autoSuggest('neuro')
    * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 0.46240 } ]
    *
    * @example
    * // Get suggestions for 'zen ar':
    * miniSearch.autoSuggest('zen ar')
    * // => [
    * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
    * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
    * // ]
    *
    * @example
    * // Correct spelling mistakes using fuzzy search:
    * miniSearch.autoSuggest('neromancer', { fuzzy: 0.2 })
    * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 1.03998 } ]
    *
    * @example
    * // Get suggestions for 'zen ar', but only within the 'fiction' category
    * // (assuming that 'category' is a stored field):
    * miniSearch.autoSuggest('zen ar', {
    *   filter: (result) => result.category === 'fiction'
    * })
    * // => [
    * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
    * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
    * // ]
    */
    ;

    _proto.autoSuggest = function autoSuggest(queryString, options) {
      if (options === void 0) {
        options = {};
      }

      options = _objectSpread2(_objectSpread2({}, defaultAutoSuggestOptions), options);
      var suggestions = this.search(queryString, options).reduce(function (suggestions, _ref7) {
        var score = _ref7.score,
            terms = _ref7.terms;
        var phrase = terms.join(' ');

        if (suggestions[phrase] == null) {
          suggestions[phrase] = {
            score: score,
            terms: terms,
            count: 1
          };
        } else {
          suggestions[phrase].score += score;
          suggestions[phrase].count += 1;
        }

        return suggestions;
      }, {});
      return Object.entries(suggestions).map(function (_ref8) {
        var suggestion = _ref8[0],
            _ref8$ = _ref8[1],
            score = _ref8$.score,
            terms = _ref8$.terms,
            count = _ref8$.count;
        return {
          suggestion: suggestion,
          terms: terms,
          score: score / count
        };
      }).sort(function (_ref9, _ref10) {
        var a = _ref9.score;
        var b = _ref10.score;
        return a < b ? 1 : -1;
      });
    }
    /**
    * Number of documents in the index
    *
    * @type {number}
    */
    ;

    /**
    * Deserializes a JSON index (serialized with `miniSearch.toJSON()`) and
    * instantiates a MiniSearch instance. It should be given the same options
    * originally used when serializing the index.
    *
    * @example
    * // If the index was serialized with:
    * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
    * miniSearch.addAll(documents)
    *
    * const json = JSON.stringify(miniSearch)
    * // It can later be deserialized like this:
    * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
    *
    * @param {string} json - JSON-serialized index
    * @param {Object} options - configuration options, same as the constructor
    * @return {MiniSearch} an instance of MiniSearch
    */
    MiniSearch.loadJSON = function loadJSON(json, options) {
      if (options == null) {
        throw new Error('MiniSearch: loadJSON should be given the same options used when serializing the index');
      }

      return MiniSearch.loadJS(JSON.parse(json), options);
    }
    /**
    * Get the default value of an option. It will throw an error if no option with
    * the given name exists.
    *
    * @param {string} optionName - name of the option
    * @return {any} the default value of the given option
    *
    * @example
    * // Get default tokenizer
    * MiniSearch.getDefault('tokenize')
    *
    * @example
    * // Get default term processor
    * MiniSearch.getDefault('processTerm')
    *
    * @example
    * // Unknown options will throw an error
    * MiniSearch.getDefault('notExisting')
    * // => throws 'MiniSearch: unknown option "notExisting"'
    */
    ;

    MiniSearch.getDefault = function getDefault(optionName) {
      if (defaultOptions.hasOwnProperty(optionName)) {
        return defaultOptions[optionName];
      } else {
        throw new Error("MiniSearch: unknown option \"" + optionName + "\"");
      }
    }
    /**
    * @private
    */
    ;

    MiniSearch.loadJS = function loadJS(js, options) {
      if (options === void 0) {
        options = {};
      }

      var index = js.index,
          documentCount = js.documentCount,
          nextId = js.nextId,
          documentIds = js.documentIds,
          fieldIds = js.fieldIds,
          fieldLength = js.fieldLength,
          averageFieldLength = js.averageFieldLength,
          storedFields = js.storedFields;
      var miniSearch = new MiniSearch(options);
      miniSearch._index = new SearchableMap(index._tree, index._prefix);
      miniSearch._documentCount = documentCount;
      miniSearch._nextId = nextId;
      miniSearch._documentIds = documentIds;
      miniSearch._fieldIds = fieldIds;
      miniSearch._fieldLength = fieldLength;
      miniSearch._averageFieldLength = averageFieldLength;
      miniSearch._fieldIds = fieldIds;
      miniSearch._storedFields = storedFields || {};
      return miniSearch;
    }
    /**
    * @private
    * @ignore
    */
    ;

    _proto.executeQuery = function executeQuery(query, options) {
      var _this7 = this;

      if (options === void 0) {
        options = {};
      }

      options = _objectSpread2(_objectSpread2({}, this._options.searchOptions), options);

      var boosts = (options.fields || this._options.fields).reduce(function (boosts, field) {
        var _objectSpread2$1;

        return _objectSpread2(_objectSpread2({}, boosts), {}, (_objectSpread2$1 = {}, _objectSpread2$1[field] = getOwnProperty(boosts, field) || 1, _objectSpread2$1));
      }, options.boost || {});

      var _options3 = options,
          boostDocument = _options3.boostDocument,
          _options3$weights = _options3.weights,
          _options3$weights$fuz = _options3$weights.fuzzy,
          fuzzyWeight = _options3$weights$fuz === void 0 ? 0.9 : _options3$weights$fuz,
          _options3$weights$pre = _options3$weights.prefix,
          prefixWeight = _options3$weights$pre === void 0 ? 0.75 : _options3$weights$pre;
      var exactMatch = termResults(this, query.term, boosts, boostDocument, this._index.get(query.term));

      if (!query.fuzzy && !query.prefix) {
        return exactMatch;
      }

      var results = [exactMatch];

      if (query.prefix) {
        this._index.atPrefix(query.term).forEach(function (term, data) {
          var weightedDistance = 0.3 * (term.length - query.term.length) / term.length;
          results.push(termResults(_this7, term, boosts, boostDocument, data, prefixWeight, weightedDistance));
        });
      }

      if (query.fuzzy) {
        var maxDistance = query.fuzzy < 1 ? Math.round(query.term.length * query.fuzzy) : query.fuzzy;
        Object.entries(this._index.fuzzyGet(query.term, maxDistance)).forEach(function (_ref11) {
          var term = _ref11[0],
              _ref11$ = _ref11[1],
              data = _ref11$[0],
              distance = _ref11$[1];
          var weightedDistance = distance / term.length;
          results.push(termResults(_this7, term, boosts, boostDocument, data, fuzzyWeight, weightedDistance));
        });
      }

      return results.reduce(combinators[OR], {});
    }
    /**
    * @private
    * @ignore
    */
    ;

    _proto.combineResults = function combineResults(results, combineWith) {
      if (combineWith === void 0) {
        combineWith = OR;
      }

      if (results.length === 0) {
        return {};
      }

      var operator = combineWith.toLowerCase();
      return results.reduce(combinators[operator], null);
    }
    /**
    * Allows serialization of the index to JSON, to possibly store it and later
    * deserialize it with `MiniSearch.loadJSON`.
    *
    * Normally one does not directly call this method, but rather call the
    * standard JavaScript `JSON.stringify()` passing the `MiniSearch` instance,
    * and JavaScript will internally call this method. Upon deserialization, one
    * must pass to `loadJSON` the same options used to create the original
    * instance that was serialized.
    *
    * @example
    * // Serialize the index:
    * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
    * miniSearch.addAll(documents)
    * const json = JSON.stringify(miniSearch)
    *
    * // Later, to deserialize it:
    * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
    *
    * @return {Object} the serializeable representation of the search index
    */
    ;

    _proto.toJSON = function toJSON() {
      return {
        index: this._index,
        documentCount: this._documentCount,
        nextId: this._nextId,
        documentIds: this._documentIds,
        fieldIds: this._fieldIds,
        fieldLength: this._fieldLength,
        averageFieldLength: this._averageFieldLength,
        storedFields: this._storedFields
      };
    };

    _createClass(MiniSearch, [{
      key: "documentCount",
      get: function get() {
        return this._documentCount;
      }
    }]);

    return MiniSearch;
  }();

  MiniSearch.SearchableMap = SearchableMap;

  var addTerm = function addTerm(self, fieldId, documentId, term) {
    self._index.update(term, function (indexData) {
      var _objectSpread3;

      indexData = indexData || {};
      var fieldIndex = indexData[fieldId] || {
        df: 0,
        ds: {}
      };

      if (fieldIndex.ds[documentId] == null) {
        fieldIndex.df += 1;
      }

      fieldIndex.ds[documentId] = (fieldIndex.ds[documentId] || 0) + 1;
      return _objectSpread2(_objectSpread2({}, indexData), {}, (_objectSpread3 = {}, _objectSpread3[fieldId] = fieldIndex, _objectSpread3));
    });
  };

  var removeTerm = function removeTerm(self, fieldId, documentId, term) {
    if (!self._index.has(term)) {
      warnDocumentChanged(self, documentId, fieldId, term);
      return;
    }

    self._index.update(term, function (indexData) {
      var _objectSpread4;

      var fieldIndex = indexData[fieldId];

      if (fieldIndex == null || fieldIndex.ds[documentId] == null) {
        warnDocumentChanged(self, documentId, fieldId, term);
        return indexData;
      }

      if (fieldIndex.ds[documentId] <= 1) {
        if (fieldIndex.df <= 1) {
          delete indexData[fieldId];
          return indexData;
        }

        fieldIndex.df -= 1;
      }

      if (fieldIndex.ds[documentId] <= 1) {
        delete fieldIndex.ds[documentId];
        return indexData;
      }

      fieldIndex.ds[documentId] -= 1;
      return _objectSpread2(_objectSpread2({}, indexData), {}, (_objectSpread4 = {}, _objectSpread4[fieldId] = fieldIndex, _objectSpread4));
    });

    if (Object.keys(self._index.get(term)).length === 0) {
      self._index.delete(term);
    }
  };

  var warnDocumentChanged = function warnDocumentChanged(self, shortDocumentId, fieldId, term) {
    if (console == null || console.warn == null) {
      return;
    }

    var fieldName = Object.entries(self._fieldIds).find(function (_ref12) {
      var name = _ref12[0],
          id = _ref12[1];
      return id === fieldId;
    })[0];
    console.warn("MiniSearch: document with ID " + self._documentIds[shortDocumentId] + " has changed before removal: term \"" + term + "\" was not present in field \"" + fieldName + "\". Removing a document after it has changed can corrupt the index!");
  };

  var addDocumentId = function addDocumentId(self, documentId) {
    var shortDocumentId = self._nextId.toString(36);

    self._documentIds[shortDocumentId] = documentId;
    self._documentCount += 1;
    self._nextId += 1;
    return shortDocumentId;
  };

  var addFields = function addFields(self, fields) {
    fields.forEach(function (field, i) {
      self._fieldIds[field] = i;
    });
  };

  var termResults = function termResults(self, term, boosts, boostDocument, indexData, weight, editDistance) {

    if (editDistance === void 0) {
      editDistance = 0;
    }

    if (indexData == null) {
      return {};
    }

    return Object.entries(boosts).reduce(function (results, _ref13) {
      var field = _ref13[0],
          boost = _ref13[1];
      var fieldId = self._fieldIds[field];

      var _ref14 = indexData[fieldId] || {
        ds: {}
      },
          df = _ref14.df,
          ds = _ref14.ds;

      Object.entries(ds).forEach(function (_ref15) {
        var documentId = _ref15[0],
            tf = _ref15[1];
        var docBoost = boostDocument ? boostDocument(self._documentIds[documentId], term) : 1;

        if (!docBoost) {
          return;
        }

        var normalizedLength = self._fieldLength[documentId][fieldId] / self._averageFieldLength[fieldId];
        results[documentId] = results[documentId] || {
          score: 0,
          match: {},
          terms: []
        };
        results[documentId].terms.push(term);
        results[documentId].match[term] = getOwnProperty(results[documentId].match, term) || [];
        results[documentId].score += docBoost * score(tf, df, self._documentCount, normalizedLength, boost, editDistance);
        results[documentId].match[term].push(field);
      });
      return results;
    }, {});
  };

  var getOwnProperty = function getOwnProperty(object, property) {
    return Object.prototype.hasOwnProperty.call(object, property) ? object[property] : undefined;
  };

  var addFieldLength = function addFieldLength(self, documentId, fieldId, count, length) {
    self._averageFieldLength[fieldId] = self._averageFieldLength[fieldId] || 0;
    var totalLength = self._averageFieldLength[fieldId] * count + length;
    self._fieldLength[documentId] = self._fieldLength[documentId] || {};
    self._fieldLength[documentId][fieldId] = length;
    self._averageFieldLength[fieldId] = totalLength / (count + 1);
  };

  var saveStoredFields = function saveStoredFields(self, documentId, doc) {
    var _self$_options = self._options,
        storeFields = _self$_options.storeFields,
        extractField = _self$_options.extractField;

    if (storeFields == null || storeFields.length === 0) {
      return;
    }

    self._storedFields[documentId] = self._storedFields[documentId] || {};
    storeFields.forEach(function (fieldName) {
      var fieldValue = extractField(doc, fieldName);

      if (fieldValue === undefined) {
        return;
      }

      self._storedFields[documentId][fieldName] = fieldValue;
    });
  };

  var combinators = (_combinators = {}, _combinators[OR] = function (a, b) {
    return Object.entries(b).reduce(function (combined, _ref16) {
      var documentId = _ref16[0],
          _ref16$ = _ref16[1],
          score = _ref16$.score,
          match = _ref16$.match,
          terms = _ref16$.terms;

      if (combined[documentId] == null) {
        combined[documentId] = {
          score: score,
          match: match,
          terms: terms
        };
      } else {
        combined[documentId].score += score;
        combined[documentId].score *= 1.5;
        combined[documentId].terms = [].concat(combined[documentId].terms, terms);
        Object.assign(combined[documentId].match, match);
      }

      return combined;
    }, a || {});
  }, _combinators[AND] = function (a, b) {
    if (a == null) {
      return b;
    }

    return Object.entries(b).reduce(function (combined, _ref17) {
      var documentId = _ref17[0],
          _ref17$ = _ref17[1],
          score = _ref17$.score,
          match = _ref17$.match,
          terms = _ref17$.terms;

      if (a[documentId] === undefined) {
        return combined;
      }

      combined[documentId] = combined[documentId] || {};
      combined[documentId].score = a[documentId].score + score;
      combined[documentId].match = _objectSpread2(_objectSpread2({}, a[documentId].match), match);
      combined[documentId].terms = [].concat(a[documentId].terms, terms);
      return combined;
    }, {});
  }, _combinators);

  var tfIdf = function tfIdf(tf, df, n) {
    return tf * Math.log(n / df);
  };

  var score = function score(termFrequency, documentFrequency, documentCount, normalizedLength, boost, editDistance) {
    var weight = boost / (1 + 0.333 * boost * editDistance);
    return weight * tfIdf(termFrequency, documentFrequency, documentCount) / normalizedLength;
  };

  var termToQuery = function termToQuery(options) {
    return function (term, i, terms) {
      var fuzzy = typeof options.fuzzy === 'function' ? options.fuzzy(term, i, terms) : options.fuzzy;
      var prefix = typeof options.prefix === 'function' ? options.prefix(term, i, terms) : options.prefix;
      return {
        term: term,
        fuzzy: fuzzy,
        prefix: prefix
      };
    };
  };

  var uniq = function uniq(array) {
    return array.filter(function (element, i, array) {
      return array.indexOf(element) === i;
    });
  };

  var isTruthy = function isTruthy(x) {
    return !!x;
  };

  var defaultOptions = {
    idField: 'id',
    extractField: function extractField(document, fieldName) {
      return document[fieldName];
    },
    tokenize: function tokenize(string, _fieldName) {
      return string.split(SPACE_OR_PUNCTUATION);
    },
    processTerm: function processTerm(term, _fieldName) {
      return term.toLowerCase();
    },
    fields: undefined,
    searchOptions: undefined,
    storeFields: []
  };
  var defaultSearchOptions = {
    combineWith: OR,
    prefix: false,
    fuzzy: false,
    weights: {}
  };
  var defaultAutoSuggestOptions = {
    prefix: function prefix(term, i, terms) {
      return i === terms.length - 1;
    }
  }; // This regular expression matches any Unicode space or punctuation character
  // Adapted from https://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5Cp%7BZ%7D%5Cp%7BP%7D&abb=on&c=on&esc=on

  var 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]+/;

  return MiniSearch;

})));
//# sourceMappingURL=index.js.map