1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242
/** * Fuse.js v6.4.1 - Lightweight fuzzy-search (http://fusejs.io) * * Copyright (c) 2020 Kiro Risk (http://kiro.me) * All Rights Reserved. Apache Software License 2.0 * * http://www.apache.org/licenses/LICENSE-2.0 */
(function (global, factory) {  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :  typeof define === 'function' && define.amd ? define(factory) :  (global = global || self, global.Fuse = factory());}(this, (function () { 'use strict';
  function _typeof(obj) {    "@babel/helpers - typeof";
    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {      _typeof = function (obj) {        return typeof obj;      };    } else {      _typeof = function (obj) {        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;      };    }
    return _typeof(obj);  }
  function _classCallCheck(instance, Constructor) {    if (!(instance instanceof Constructor)) {      throw new TypeError("Cannot call a class as a function");    }  }
  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 _inherits(subClass, superClass) {    if (typeof superClass !== "function" && superClass !== null) {      throw new TypeError("Super expression must either be null or a function");    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {      constructor: {        value: subClass,        writable: true,        configurable: true      }    });    if (superClass) _setPrototypeOf(subClass, superClass);  }
  function _getPrototypeOf(o) {    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {      return o.__proto__ || Object.getPrototypeOf(o);    };    return _getPrototypeOf(o);  }
  function _setPrototypeOf(o, p) {    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {      o.__proto__ = p;      return o;    };
    return _setPrototypeOf(o, p);  }
  function _isNativeReflectConstruct() {    if (typeof Reflect === "undefined" || !Reflect.construct) return false;    if (Reflect.construct.sham) return false;    if (typeof Proxy === "function") return true;
    try {      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));      return true;    } catch (e) {      return false;    }  }
  function _assertThisInitialized(self) {    if (self === void 0) {      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");    }
    return self;  }
  function _possibleConstructorReturn(self, call) {    if (call && (typeof call === "object" || typeof call === "function")) {      return call;    }
    return _assertThisInitialized(self);  }
  function _createSuper(Derived) {    var hasNativeReflectConstruct = _isNativeReflectConstruct();
    return function _createSuperInternal() {      var Super = _getPrototypeOf(Derived),          result;
      if (hasNativeReflectConstruct) {        var NewTarget = _getPrototypeOf(this).constructor;
        result = Reflect.construct(Super, arguments, NewTarget);      } else {        result = Super.apply(this, arguments);      }
      return _possibleConstructorReturn(this, result);    };  }
  function _toConsumableArray(arr) {    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();  }
  function _arrayWithoutHoles(arr) {    if (Array.isArray(arr)) return _arrayLikeToArray(arr);  }
  function _iterableToArray(iter) {    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);  }
  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 _nonIterableSpread() {    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");  }
  function isArray(value) {    return !Array.isArray ? getTag(value) === '[object Array]' : Array.isArray(value);  } // Adapted from: https://github.com/lodash/lodash/blob/master/.internal/baseToString.js
  var INFINITY = 1 / 0;  function baseToString(value) {    // Exit early for strings to avoid a performance hit in some environments.    if (typeof value == 'string') {      return value;    }
    var result = value + '';    return result == '0' && 1 / value == -INFINITY ? '-0' : result;  }  function toString(value) {    return value == null ? '' : baseToString(value);  }  function isString(value) {    return typeof value === 'string';  }  function isNumber(value) {    return typeof value === 'number';  } // Adapted from: https://github.com/lodash/lodash/blob/master/isBoolean.js
  function isBoolean(value) {    return value === true || value === false || isObjectLike(value) && getTag(value) == '[object Boolean]';  }  function isObject(value) {    return _typeof(value) === 'object';  } // Checks if `value` is object-like.
  function isObjectLike(value) {    return isObject(value) && value !== null;  }  function isDefined(value) {    return value !== undefined && value !== null;  }  function isBlank(value) {    return !value.trim().length;  } // Gets the `toStringTag` of `value`.  // Adapted from: https://github.com/lodash/lodash/blob/master/.internal/getTag.js
  function getTag(value) {    return value == null ? value === undefined ? '[object Undefined]' : '[object Null]' : Object.prototype.toString.call(value);  }
  var EXTENDED_SEARCH_UNAVAILABLE = 'Extended search is not available';  var INCORRECT_INDEX_TYPE = "Incorrect 'index' type";  var LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = function LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key) {    return "Invalid value for key ".concat(key);  };  var PATTERN_LENGTH_TOO_LARGE = function PATTERN_LENGTH_TOO_LARGE(max) {    return "Pattern length exceeds max of ".concat(max, ".");  };  var MISSING_KEY_PROPERTY = function MISSING_KEY_PROPERTY(name) {    return "Missing ".concat(name, " property in key");  };  var INVALID_KEY_WEIGHT_VALUE = function INVALID_KEY_WEIGHT_VALUE(key) {    return "Property 'weight' in key '".concat(key, "' must be a positive integer");  };
  var hasOwn = Object.prototype.hasOwnProperty;
  var KeyStore = /*#__PURE__*/function () {    function KeyStore(keys) {      var _this = this;
      _classCallCheck(this, KeyStore);
      this._keys = [];      this._keyMap = {};      var totalWeight = 0;      keys.forEach(function (key) {        var obj = createKey(key);        totalWeight += obj.weight;
        _this._keys.push(obj);
        _this._keyMap[obj.id] = obj;        totalWeight += obj.weight;      }); // Normalize weights so that their sum is equal to 1
      this._keys.forEach(function (key) {        key.weight /= totalWeight;      });    }
    _createClass(KeyStore, [{      key: "get",      value: function get(keyId) {        return this._keyMap[keyId];      }    }, {      key: "keys",      value: function keys() {        return this._keys;      }    }, {      key: "toJSON",      value: function toJSON() {        return JSON.stringify(this._keys);      }    }]);
    return KeyStore;  }();  function createKey(key) {    var path = null;    var id = null;    var src = null;    var weight = 1;
    if (isString(key) || isArray(key)) {      src = key;      path = createKeyPath(key);      id = createKeyId(key);    } else {      if (!hasOwn.call(key, 'name')) {        throw new Error(MISSING_KEY_PROPERTY('name'));      }
      var name = key.name;      src = name;
      if (hasOwn.call(key, 'weight')) {        weight = key.weight;
        if (weight <= 0) {          throw new Error(INVALID_KEY_WEIGHT_VALUE(name));        }      }
      path = createKeyPath(name);      id = createKeyId(name);    }
    return {      path: path,      id: id,      weight: weight,      src: src    };  }  function createKeyPath(key) {    return isArray(key) ? key : key.split('.');  }  function createKeyId(key) {    return isArray(key) ? key.join('.') : key;  }
  function get(obj, path) {    var list = [];    var arr = false;
    var deepGet = function deepGet(obj, path, index) {      if (!path[index]) {        // If there's no path left, we've arrived at the object we care about.        list.push(obj);      } else {        var key = path[index];        var value = obj[key];
        if (!isDefined(value)) {          return;        } // If we're at the last value in the path, and if it's a string/number/bool,        // add it to the list

        if (index === path.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {          list.push(toString(value));        } else if (isArray(value)) {          arr = true; // Search each item in the array.
          for (var i = 0, len = value.length; i < len; i += 1) {            deepGet(value[i], path, index + 1);          }        } else if (path.length) {          // An object. Recurse further.          deepGet(value, path, index + 1);        }      }    }; // Backwards compatibility (since path used to be a string)

    deepGet(obj, isString(path) ? path.split('.') : path, 0);    return arr ? list : list[0];  }
  var MatchOptions = {    // Whether the matches should be included in the result set. When `true`, each record in the result    // set will include the indices of the matched characters.    // These can consequently be used for highlighting purposes.    includeMatches: false,    // When `true`, the matching function will continue to the end of a search pattern even if    // a perfect match has already been located in the string.    findAllMatches: false,    // Minimum number of characters that must be matched before a result is considered a match    minMatchCharLength: 1  };  var BasicOptions = {    // When `true`, the algorithm continues searching to the end of the input even if a perfect    // match is found before the end of the same input.    isCaseSensitive: false,    // When true, the matching function will continue to the end of a search pattern even if    includeScore: false,    // List of properties that will be searched. This also supports nested properties.    keys: [],    // Whether to sort the result list, by score    shouldSort: true,    // Default sort function: sort by ascending score, ascending index    sortFn: function sortFn(a, b) {      return a.score === b.score ? a.idx < b.idx ? -1 : 1 : a.score < b.score ? -1 : 1;    }  };  var FuzzyOptions = {    // Approximately where in the text is the pattern expected to be found?    location: 0,    // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match    // (of both letters and location), a threshold of '1.0' would match anything.    threshold: 0.6,    // Determines how close the match must be to the fuzzy location (specified above).    // An exact letter match which is 'distance' characters away from the fuzzy location    // would score as a complete mismatch. A distance of '0' requires the match be at    // the exact location specified, a threshold of '1000' would require a perfect match    // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.    distance: 100  };  var AdvancedOptions = {    // When `true`, it enables the use of unix-like search commands    useExtendedSearch: false,    // The get function to use when fetching an object's properties.    // The default will search nested paths *ie foo.bar.baz*    getFn: get,    // When `true`, search will ignore `location` and `distance`, so it won't matter    // where in the string the pattern appears.    // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score    ignoreLocation: false,    // When `true`, the calculation for the relevance score (used for sorting) will    // ignore the field-length norm.    // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm    ignoreFieldNorm: false  };  var Config = _objectSpread2({}, BasicOptions, {}, MatchOptions, {}, FuzzyOptions, {}, AdvancedOptions);
  var SPACE = /[^ ]+/g; // Field-length norm: the shorter the field, the higher the weight.  // Set to 3 decimals to reduce index size.
  function norm() {    var mantissa = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 3;    var cache = new Map();    return {      get: function get(value) {        var numTokens = value.match(SPACE).length;
        if (cache.has(numTokens)) {          return cache.get(numTokens);        }
        var n = parseFloat((1 / Math.sqrt(numTokens)).toFixed(mantissa));        cache.set(numTokens, n);        return n;      },      clear: function clear() {        cache.clear();      }    };  }
  var FuseIndex = /*#__PURE__*/function () {    function FuseIndex() {      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},          _ref$getFn = _ref.getFn,          getFn = _ref$getFn === void 0 ? Config.getFn : _ref$getFn;
      _classCallCheck(this, FuseIndex);
      this.norm = norm(3);      this.getFn = getFn;      this.isCreated = false;      this.setIndexRecords();    }
    _createClass(FuseIndex, [{      key: "setSources",      value: function setSources() {        var docs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];        this.docs = docs;      }    }, {      key: "setIndexRecords",      value: function setIndexRecords() {        var records = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];        this.records = records;      }    }, {      key: "setKeys",      value: function setKeys() {        var _this = this;
        var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];        this.keys = keys;        this._keysMap = {};        keys.forEach(function (key, idx) {          _this._keysMap[key.id] = idx;        });      }    }, {      key: "create",      value: function create() {        var _this2 = this;
        if (this.isCreated || !this.docs.length) {          return;        }
        this.isCreated = true; // List is Array<String>
        if (isString(this.docs[0])) {          this.docs.forEach(function (doc, docIndex) {            _this2._addString(doc, docIndex);          });        } else {          // List is Array<Object>          this.docs.forEach(function (doc, docIndex) {            _this2._addObject(doc, docIndex);          });        }
        this.norm.clear();      } // Adds a doc to the end of the index
    }, {      key: "add",      value: function add(doc) {        var idx = this.size();
        if (isString(doc)) {          this._addString(doc, idx);        } else {          this._addObject(doc, idx);        }      } // Removes the doc at the specified index of the index
    }, {      key: "removeAt",      value: function removeAt(idx) {        this.records.splice(idx, 1); // Change ref index of every subsquent doc
        for (var i = idx, len = this.size(); i < len; i += 1) {          this.records[i].i -= 1;        }      }    }, {      key: "getValueForItemAtKeyId",      value: function getValueForItemAtKeyId(item, keyId) {        return item[this._keysMap[keyId]];      }    }, {      key: "size",      value: function size() {        return this.records.length;      }    }, {      key: "_addString",      value: function _addString(doc, docIndex) {        if (!isDefined(doc) || isBlank(doc)) {          return;        }
        var record = {          v: doc,          i: docIndex,          n: this.norm.get(doc)        };        this.records.push(record);      }    }, {      key: "_addObject",      value: function _addObject(doc, docIndex) {        var _this3 = this;
        var record = {          i: docIndex,          $: {}        }; // Iterate over every key (i.e, path), and fetch the value at that key
        this.keys.forEach(function (key, keyIndex) {          // console.log(key)          var value = _this3.getFn(doc, key.path);
          if (!isDefined(value)) {            return;          }
          if (isArray(value)) {            (function () {              var subRecords = [];              var stack = [{                nestedArrIndex: -1,                value: value              }];
              while (stack.length) {                var _stack$pop = stack.pop(),                    nestedArrIndex = _stack$pop.nestedArrIndex,                    _value = _stack$pop.value;
                if (!isDefined(_value)) {                  continue;                }
                if (isString(_value) && !isBlank(_value)) {                  var subRecord = {                    v: _value,                    i: nestedArrIndex,                    n: _this3.norm.get(_value)                  };                  subRecords.push(subRecord);                } else if (isArray(_value)) {                  _value.forEach(function (item, k) {                    stack.push({                      nestedArrIndex: k,                      value: item                    });                  });                }              }
              record.$[keyIndex] = subRecords;            })();          } else if (!isBlank(value)) {            var subRecord = {              v: value,              n: _this3.norm.get(value)            };            record.$[keyIndex] = subRecord;          }        });        this.records.push(record);      }    }, {      key: "toJSON",      value: function toJSON() {        return {          keys: this.keys,          records: this.records        };      }    }]);
    return FuseIndex;  }();  function createIndex(keys, docs) {    var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},        _ref2$getFn = _ref2.getFn,        getFn = _ref2$getFn === void 0 ? Config.getFn : _ref2$getFn;
    var myIndex = new FuseIndex({      getFn: getFn    });    myIndex.setKeys(keys.map(createKey));    myIndex.setSources(docs);    myIndex.create();    return myIndex;  }  function parseIndex(data) {    var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},        _ref3$getFn = _ref3.getFn,        getFn = _ref3$getFn === void 0 ? Config.getFn : _ref3$getFn;
    var keys = data.keys,        records = data.records;    var myIndex = new FuseIndex({      getFn: getFn    });    myIndex.setKeys(keys);    myIndex.setIndexRecords(records);    return myIndex;  }
  function transformMatches(result, data) {    var matches = result.matches;    data.matches = [];
    if (!isDefined(matches)) {      return;    }
    matches.forEach(function (match) {      if (!isDefined(match.indices) || !match.indices.length) {        return;      }
      var indices = match.indices,          value = match.value;      var obj = {        indices: indices,        value: value      };
      if (match.key) {        obj.key = match.key.src;      }
      if (match.idx > -1) {        obj.refIndex = match.idx;      }
      data.matches.push(obj);    });  }
  function transformScore(result, data) {    data.score = result.score;  }
  function computeScore(pattern) {    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},        _ref$errors = _ref.errors,        errors = _ref$errors === void 0 ? 0 : _ref$errors,        _ref$currentLocation = _ref.currentLocation,        currentLocation = _ref$currentLocation === void 0 ? 0 : _ref$currentLocation,        _ref$expectedLocation = _ref.expectedLocation,        expectedLocation = _ref$expectedLocation === void 0 ? 0 : _ref$expectedLocation,        _ref$distance = _ref.distance,        distance = _ref$distance === void 0 ? Config.distance : _ref$distance,        _ref$ignoreLocation = _ref.ignoreLocation,        ignoreLocation = _ref$ignoreLocation === void 0 ? Config.ignoreLocation : _ref$ignoreLocation;
    var accuracy = errors / pattern.length;
    if (ignoreLocation) {      return accuracy;    }
    var proximity = Math.abs(expectedLocation - currentLocation);
    if (!distance) {      // Dodge divide by zero error.      return proximity ? 1.0 : accuracy;    }
    return accuracy + proximity / distance;  }
  function convertMaskToIndices() {    var matchmask = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];    var minMatchCharLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Config.minMatchCharLength;    var indices = [];    var start = -1;    var end = -1;    var i = 0;
    for (var len = matchmask.length; i < len; i += 1) {      var match = matchmask[i];
      if (match && start === -1) {        start = i;      } else if (!match && start !== -1) {        end = i - 1;
        if (end - start + 1 >= minMatchCharLength) {          indices.push([start, end]);        }
        start = -1;      }    } // (i-1 - start) + 1 => i - start

    if (matchmask[i - 1] && i - start >= minMatchCharLength) {      indices.push([start, i - 1]);    }
    return indices;  }
  // Machine word size  var MAX_BITS = 32;
  function search(text, pattern, patternAlphabet) {    var _ref = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},        _ref$location = _ref.location,        location = _ref$location === void 0 ? Config.location : _ref$location,        _ref$distance = _ref.distance,        distance = _ref$distance === void 0 ? Config.distance : _ref$distance,        _ref$threshold = _ref.threshold,        threshold = _ref$threshold === void 0 ? Config.threshold : _ref$threshold,        _ref$findAllMatches = _ref.findAllMatches,        findAllMatches = _ref$findAllMatches === void 0 ? Config.findAllMatches : _ref$findAllMatches,        _ref$minMatchCharLeng = _ref.minMatchCharLength,        minMatchCharLength = _ref$minMatchCharLeng === void 0 ? Config.minMatchCharLength : _ref$minMatchCharLeng,        _ref$includeMatches = _ref.includeMatches,        includeMatches = _ref$includeMatches === void 0 ? Config.includeMatches : _ref$includeMatches,        _ref$ignoreLocation = _ref.ignoreLocation,        ignoreLocation = _ref$ignoreLocation === void 0 ? Config.ignoreLocation : _ref$ignoreLocation;
    if (pattern.length > MAX_BITS) {      throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));    }
    var patternLen = pattern.length; // Set starting location at beginning text and initialize the alphabet.
    var textLen = text.length; // Handle the case when location > text.length
    var expectedLocation = Math.max(0, Math.min(location, textLen)); // Highest score beyond which we give up.
    var currentThreshold = threshold; // Is there a nearby exact match? (speedup)
    var bestLocation = expectedLocation; // Performance: only computer matches when the minMatchCharLength > 1    // OR if `includeMatches` is true.
    var computeMatches = minMatchCharLength > 1 || includeMatches; // A mask of the matches, used for building the indices
    var matchMask = computeMatches ? Array(textLen) : [];    var index; // Get all exact matches, here for speed up
    while ((index = text.indexOf(pattern, bestLocation)) > -1) {      var score = computeScore(pattern, {        currentLocation: index,        expectedLocation: expectedLocation,        distance: distance,        ignoreLocation: ignoreLocation      });      currentThreshold = Math.min(score, currentThreshold);      bestLocation = index + patternLen;
      if (computeMatches) {        var i = 0;
        while (i < patternLen) {          matchMask[index + i] = 1;          i += 1;        }      }    } // Reset the best location

    bestLocation = -1;    var lastBitArr = [];    var finalScore = 1;    var binMax = patternLen + textLen;    var mask = 1 << patternLen - 1;
    for (var _i = 0; _i < patternLen; _i += 1) {      // Scan for the best match; each iteration allows for one more error.      // Run a binary search to determine how far from the match location we can stray      // at this error level.      var binMin = 0;      var binMid = binMax;
      while (binMin < binMid) {        var _score2 = computeScore(pattern, {          errors: _i,          currentLocation: expectedLocation + binMid,          expectedLocation: expectedLocation,          distance: distance,          ignoreLocation: ignoreLocation        });
        if (_score2 <= currentThreshold) {          binMin = binMid;        } else {          binMax = binMid;        }
        binMid = Math.floor((binMax - binMin) / 2 + binMin);      } // Use the result from this iteration as the maximum for the next.

      binMax = binMid;      var start = Math.max(1, expectedLocation - binMid + 1);      var finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen; // Initialize the bit array
      var bitArr = Array(finish + 2);      bitArr[finish + 1] = (1 << _i) - 1;
      for (var j = finish; j >= start; j -= 1) {        var currentLocation = j - 1;        var charMatch = patternAlphabet[text.charAt(currentLocation)];
        if (computeMatches) {          // Speed up: quick bool to int conversion (i.e, `charMatch ? 1 : 0`)          matchMask[currentLocation] = +!!charMatch;        } // First pass: exact match

        bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch; // Subsequent passes: fuzzy match
        if (_i) {          bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];        }
        if (bitArr[j] & mask) {          finalScore = computeScore(pattern, {            errors: _i,            currentLocation: currentLocation,            expectedLocation: expectedLocation,            distance: distance,            ignoreLocation: ignoreLocation          }); // This match will almost certainly be better than any existing match.          // But check anyway.
          if (finalScore <= currentThreshold) {            // Indeed it is            currentThreshold = finalScore;            bestLocation = currentLocation; // Already passed `loc`, downhill from here on in.
            if (bestLocation <= expectedLocation) {              break;            } // When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.

            start = Math.max(1, 2 * expectedLocation - bestLocation);          }        }      } // No hope for a (better) match at greater error levels.

      var _score = computeScore(pattern, {        errors: _i + 1,        currentLocation: expectedLocation,        expectedLocation: expectedLocation,        distance: distance,        ignoreLocation: ignoreLocation      });
      if (_score > currentThreshold) {        break;      }
      lastBitArr = bitArr;    }
    var result = {      isMatch: bestLocation >= 0,      // Count exact matches (those with a score of 0) to be "almost" exact      score: Math.max(0.001, finalScore)    };
    if (computeMatches) {      var indices = convertMaskToIndices(matchMask, minMatchCharLength);
      if (!indices.length) {        result.isMatch = false;      } else if (includeMatches) {        result.indices = indices;      }    }
    return result;  }
  function createPatternAlphabet(pattern) {    var mask = {};
    for (var i = 0, len = pattern.length; i < len; i += 1) {      var char = pattern.charAt(i);      mask[char] = (mask[char] || 0) | 1 << len - i - 1;    }
    return mask;  }
  var BitapSearch = /*#__PURE__*/function () {    function BitapSearch(pattern) {      var _this = this;
      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},          _ref$location = _ref.location,          location = _ref$location === void 0 ? Config.location : _ref$location,          _ref$threshold = _ref.threshold,          threshold = _ref$threshold === void 0 ? Config.threshold : _ref$threshold,          _ref$distance = _ref.distance,          distance = _ref$distance === void 0 ? Config.distance : _ref$distance,          _ref$includeMatches = _ref.includeMatches,          includeMatches = _ref$includeMatches === void 0 ? Config.includeMatches : _ref$includeMatches,          _ref$findAllMatches = _ref.findAllMatches,          findAllMatches = _ref$findAllMatches === void 0 ? Config.findAllMatches : _ref$findAllMatches,          _ref$minMatchCharLeng = _ref.minMatchCharLength,          minMatchCharLength = _ref$minMatchCharLeng === void 0 ? Config.minMatchCharLength : _ref$minMatchCharLeng,          _ref$isCaseSensitive = _ref.isCaseSensitive,          isCaseSensitive = _ref$isCaseSensitive === void 0 ? Config.isCaseSensitive : _ref$isCaseSensitive,          _ref$ignoreLocation = _ref.ignoreLocation,          ignoreLocation = _ref$ignoreLocation === void 0 ? Config.ignoreLocation : _ref$ignoreLocation;
      _classCallCheck(this, BitapSearch);
      this.options = {        location: location,        threshold: threshold,        distance: distance,        includeMatches: includeMatches,        findAllMatches: findAllMatches,        minMatchCharLength: minMatchCharLength,        isCaseSensitive: isCaseSensitive,        ignoreLocation: ignoreLocation      };      this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();      this.chunks = [];
      if (!this.pattern.length) {        return;      }
      var addChunk = function addChunk(pattern, startIndex) {        _this.chunks.push({          pattern: pattern,          alphabet: createPatternAlphabet(pattern),          startIndex: startIndex        });      };
      var len = this.pattern.length;
      if (len > MAX_BITS) {        var i = 0;        var remainder = len % MAX_BITS;        var end = len - remainder;
        while (i < end) {          addChunk(this.pattern.substr(i, MAX_BITS), i);          i += MAX_BITS;        }
        if (remainder) {          var startIndex = len - MAX_BITS;          addChunk(this.pattern.substr(startIndex), startIndex);        }      } else {        addChunk(this.pattern, 0);      }    }
    _createClass(BitapSearch, [{      key: "searchIn",      value: function searchIn(text) {        var _this$options = this.options,            isCaseSensitive = _this$options.isCaseSensitive,            includeMatches = _this$options.includeMatches;
        if (!isCaseSensitive) {          text = text.toLowerCase();        } // Exact match

        if (this.pattern === text) {          var _result = {            isMatch: true,            score: 0          };
          if (includeMatches) {            _result.indices = [[0, text.length - 1]];          }
          return _result;        } // Otherwise, use Bitap algorithm

        var _this$options2 = this.options,            location = _this$options2.location,            distance = _this$options2.distance,            threshold = _this$options2.threshold,            findAllMatches = _this$options2.findAllMatches,            minMatchCharLength = _this$options2.minMatchCharLength,            ignoreLocation = _this$options2.ignoreLocation;        var allIndices = [];        var totalScore = 0;        var hasMatches = false;        this.chunks.forEach(function (_ref2) {          var pattern = _ref2.pattern,              alphabet = _ref2.alphabet,              startIndex = _ref2.startIndex;
          var _search = search(text, pattern, alphabet, {            location: location + startIndex,            distance: distance,            threshold: threshold,            findAllMatches: findAllMatches,            minMatchCharLength: minMatchCharLength,            includeMatches: includeMatches,            ignoreLocation: ignoreLocation          }),              isMatch = _search.isMatch,              score = _search.score,              indices = _search.indices;
          if (isMatch) {            hasMatches = true;          }
          totalScore += score;
          if (isMatch && indices) {            allIndices = [].concat(_toConsumableArray(allIndices), _toConsumableArray(indices));          }        });        var result = {          isMatch: hasMatches,          score: hasMatches ? totalScore / this.chunks.length : 1        };
        if (hasMatches && includeMatches) {          result.indices = allIndices;        }
        return result;      }    }]);
    return BitapSearch;  }();
  var BaseMatch = /*#__PURE__*/function () {    function BaseMatch(pattern) {      _classCallCheck(this, BaseMatch);
      this.pattern = pattern;    }
    _createClass(BaseMatch, [{      key: "search",      value: function search()      /*text*/      {}    }], [{      key: "isMultiMatch",      value: function isMultiMatch(pattern) {        return getMatch(pattern, this.multiRegex);      }    }, {      key: "isSingleMatch",      value: function isSingleMatch(pattern) {        return getMatch(pattern, this.singleRegex);      }    }]);
    return BaseMatch;  }();
  function getMatch(pattern, exp) {    var matches = pattern.match(exp);    return matches ? matches[1] : null;  }
  var ExactMatch = /*#__PURE__*/function (_BaseMatch) {    _inherits(ExactMatch, _BaseMatch);
    var _super = _createSuper(ExactMatch);
    function ExactMatch(pattern) {      _classCallCheck(this, ExactMatch);
      return _super.call(this, pattern);    }
    _createClass(ExactMatch, [{      key: "search",      value: function search(text) {        var isMatch = text === this.pattern;        return {          isMatch: isMatch,          score: isMatch ? 0 : 1,          indices: [0, this.pattern.length - 1]        };      }    }], [{      key: "type",      get: function get() {        return 'exact';      }    }, {      key: "multiRegex",      get: function get() {        return /^="(.*)"$/;      }    }, {      key: "singleRegex",      get: function get() {        return /^=(.*)$/;      }    }]);
    return ExactMatch;  }(BaseMatch);
  var InverseExactMatch = /*#__PURE__*/function (_BaseMatch) {    _inherits(InverseExactMatch, _BaseMatch);
    var _super = _createSuper(InverseExactMatch);
    function InverseExactMatch(pattern) {      _classCallCheck(this, InverseExactMatch);
      return _super.call(this, pattern);    }
    _createClass(InverseExactMatch, [{      key: "search",      value: function search(text) {        var index = text.indexOf(this.pattern);        var isMatch = index === -1;        return {          isMatch: isMatch,          score: isMatch ? 0 : 1,          indices: [0, text.length - 1]        };      }    }], [{      key: "type",      get: function get() {        return 'inverse-exact';      }    }, {      key: "multiRegex",      get: function get() {        return /^!"(.*)"$/;      }    }, {      key: "singleRegex",      get: function get() {        return /^!(.*)$/;      }    }]);
    return InverseExactMatch;  }(BaseMatch);
  var PrefixExactMatch = /*#__PURE__*/function (_BaseMatch) {    _inherits(PrefixExactMatch, _BaseMatch);
    var _super = _createSuper(PrefixExactMatch);
    function PrefixExactMatch(pattern) {      _classCallCheck(this, PrefixExactMatch);
      return _super.call(this, pattern);    }
    _createClass(PrefixExactMatch, [{      key: "search",      value: function search(text) {        var isMatch = text.startsWith(this.pattern);        return {          isMatch: isMatch,          score: isMatch ? 0 : 1,          indices: [0, this.pattern.length - 1]        };      }    }], [{      key: "type",      get: function get() {        return 'prefix-exact';      }    }, {      key: "multiRegex",      get: function get() {        return /^\^"(.*)"$/;      }    }, {      key: "singleRegex",      get: function get() {        return /^\^(.*)$/;      }    }]);
    return PrefixExactMatch;  }(BaseMatch);
  var InversePrefixExactMatch = /*#__PURE__*/function (_BaseMatch) {    _inherits(InversePrefixExactMatch, _BaseMatch);
    var _super = _createSuper(InversePrefixExactMatch);
    function InversePrefixExactMatch(pattern) {      _classCallCheck(this, InversePrefixExactMatch);
      return _super.call(this, pattern);    }
    _createClass(InversePrefixExactMatch, [{      key: "search",      value: function search(text) {        var isMatch = !text.startsWith(this.pattern);        return {          isMatch: isMatch,          score: isMatch ? 0 : 1,          indices: [0, text.length - 1]        };      }    }], [{      key: "type",      get: function get() {        return 'inverse-prefix-exact';      }    }, {      key: "multiRegex",      get: function get() {        return /^!\^"(.*)"$/;      }    }, {      key: "singleRegex",      get: function get() {        return /^!\^(.*)$/;      }    }]);
    return InversePrefixExactMatch;  }(BaseMatch);
  var SuffixExactMatch = /*#__PURE__*/function (_BaseMatch) {    _inherits(SuffixExactMatch, _BaseMatch);
    var _super = _createSuper(SuffixExactMatch);
    function SuffixExactMatch(pattern) {      _classCallCheck(this, SuffixExactMatch);
      return _super.call(this, pattern);    }
    _createClass(SuffixExactMatch, [{      key: "search",      value: function search(text) {        var isMatch = text.endsWith(this.pattern);        return {          isMatch: isMatch,          score: isMatch ? 0 : 1,          indices: [text.length - this.pattern.length, text.length - 1]        };      }    }], [{      key: "type",      get: function get() {        return 'suffix-exact';      }    }, {      key: "multiRegex",      get: function get() {        return /^"(.*)"\$$/;      }    }, {      key: "singleRegex",      get: function get() {        return /^(.*)\$$/;      }    }]);
    return SuffixExactMatch;  }(BaseMatch);
  var InverseSuffixExactMatch = /*#__PURE__*/function (_BaseMatch) {    _inherits(InverseSuffixExactMatch, _BaseMatch);
    var _super = _createSuper(InverseSuffixExactMatch);
    function InverseSuffixExactMatch(pattern) {      _classCallCheck(this, InverseSuffixExactMatch);
      return _super.call(this, pattern);    }
    _createClass(InverseSuffixExactMatch, [{      key: "search",      value: function search(text) {        var isMatch = !text.endsWith(this.pattern);        return {          isMatch: isMatch,          score: isMatch ? 0 : 1,          indices: [0, text.length - 1]        };      }    }], [{      key: "type",      get: function get() {        return 'inverse-suffix-exact';      }    }, {      key: "multiRegex",      get: function get() {        return /^!"(.*)"\$$/;      }    }, {      key: "singleRegex",      get: function get() {        return /^!(.*)\$$/;      }    }]);
    return InverseSuffixExactMatch;  }(BaseMatch);
  var FuzzyMatch = /*#__PURE__*/function (_BaseMatch) {    _inherits(FuzzyMatch, _BaseMatch);
    var _super = _createSuper(FuzzyMatch);
    function FuzzyMatch(pattern) {      var _this;
      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},          _ref$location = _ref.location,          location = _ref$location === void 0 ? Config.location : _ref$location,          _ref$threshold = _ref.threshold,          threshold = _ref$threshold === void 0 ? Config.threshold : _ref$threshold,          _ref$distance = _ref.distance,          distance = _ref$distance === void 0 ? Config.distance : _ref$distance,          _ref$includeMatches = _ref.includeMatches,          includeMatches = _ref$includeMatches === void 0 ? Config.includeMatches : _ref$includeMatches,          _ref$findAllMatches = _ref.findAllMatches,          findAllMatches = _ref$findAllMatches === void 0 ? Config.findAllMatches : _ref$findAllMatches,          _ref$minMatchCharLeng = _ref.minMatchCharLength,          minMatchCharLength = _ref$minMatchCharLeng === void 0 ? Config.minMatchCharLength : _ref$minMatchCharLeng,          _ref$isCaseSensitive = _ref.isCaseSensitive,          isCaseSensitive = _ref$isCaseSensitive === void 0 ? Config.isCaseSensitive : _ref$isCaseSensitive;
      _classCallCheck(this, FuzzyMatch);
      _this = _super.call(this, pattern);      _this._bitapSearch = new BitapSearch(pattern, {        location: location,        threshold: threshold,        distance: distance,        includeMatches: includeMatches,        findAllMatches: findAllMatches,        minMatchCharLength: minMatchCharLength,        isCaseSensitive: isCaseSensitive      });      return _this;    }
    _createClass(FuzzyMatch, [{      key: "search",      value: function search(text) {        return this._bitapSearch.searchIn(text);      }    }], [{      key: "type",      get: function get() {        return 'fuzzy';      }    }, {      key: "multiRegex",      get: function get() {        return /^"(.*)"$/;      }    }, {      key: "singleRegex",      get: function get() {        return /^(.*)$/;      }    }]);
    return FuzzyMatch;  }(BaseMatch);
  var IncludeMatch = /*#__PURE__*/function (_BaseMatch) {    _inherits(IncludeMatch, _BaseMatch);
    var _super = _createSuper(IncludeMatch);
    function IncludeMatch(pattern) {      _classCallCheck(this, IncludeMatch);
      return _super.call(this, pattern);    }
    _createClass(IncludeMatch, [{      key: "search",      value: function search(text) {        var location = 0;        var index;        var indices = [];        var patternLen = this.pattern.length; // Get all exact matches
        while ((index = text.indexOf(this.pattern, location)) > -1) {          location = index + patternLen;          indices.push([index, location - 1]);        }
        var isMatch = !!indices.length;        return {          isMatch: isMatch,          score: isMatch ? 1 : 0,          indices: indices        };      }    }], [{      key: "type",      get: function get() {        return 'include';      }    }, {      key: "multiRegex",      get: function get() {        return /^'"(.*)"$/;      }    }, {      key: "singleRegex",      get: function get() {        return /^'(.*)$/;      }    }]);
    return IncludeMatch;  }(BaseMatch);
  var searchers = [ExactMatch, IncludeMatch, PrefixExactMatch, InversePrefixExactMatch, InverseSuffixExactMatch, SuffixExactMatch, InverseExactMatch, FuzzyMatch];  var searchersLen = searchers.length; // Regex to split by spaces, but keep anything in quotes together
  var SPACE_RE = / +(?=([^\"]*\"[^\"]*\")*[^\"]*$)/;  var OR_TOKEN = '|'; // Return a 2D array representation of the query, for simpler parsing.  // Example:  // "^core go$ | rb$ | py$ xy$" => [["^core", "go$"], ["rb$"], ["py$", "xy$"]]
  function parseQuery(pattern) {    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};    return pattern.split(OR_TOKEN).map(function (item) {      var query = item.trim().split(SPACE_RE).filter(function (item) {        return item && !!item.trim();      });      var results = [];
      for (var i = 0, len = query.length; i < len; i += 1) {        var queryItem = query[i]; // 1. Handle multiple query match (i.e, once that are quoted, like `"hello world"`)
        var found = false;        var idx = -1;
        while (!found && ++idx < searchersLen) {          var searcher = searchers[idx];          var token = searcher.isMultiMatch(queryItem);
          if (token) {            results.push(new searcher(token, options));            found = true;          }        }
        if (found) {          continue;        } // 2. Handle single query matches (i.e, once that are *not* quoted)

        idx = -1;
        while (++idx < searchersLen) {          var _searcher = searchers[idx];
          var _token = _searcher.isSingleMatch(queryItem);
          if (_token) {            results.push(new _searcher(_token, options));            break;          }        }      }
      return results;    });  }
  // to a singl match
  var MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]);  /**   * Command-like searching   * ======================   *   * Given multiple search terms delimited by spaces.e.g. `^jscript .python$ ruby !java`,   * search in a given text.   *   * Search syntax:   *   * | Token       | Match type                 | Description                            |   * | ----------- | -------------------------- | -------------------------------------- |   * | `jscript`   | fuzzy-match                | Items that fuzzy match `jscript`       |   * | `=scheme`   | exact-match                | Items that are `scheme`                |   * | `'python`   | include-match              | Items that include `python`            |   * | `!ruby`     | inverse-exact-match        | Items that do not include `ruby`       |   * | `^java`     | prefix-exact-match         | Items that start with `java`           |   * | `!^earlang` | inverse-prefix-exact-match | Items that do not start with `earlang` |   * | `.js$`      | suffix-exact-match         | Items that end with `.js`              |   * | `!.go$`     | inverse-suffix-exact-match | Items that do not end with `.go`       |   *   * A single pipe character acts as an OR operator. For example, the following   * query matches entries that start with `core` and end with either`go`, `rb`,   * or`py`.   *   * ```   * ^core go$ | rb$ | py$   * ```   */
  var ExtendedSearch = /*#__PURE__*/function () {    function ExtendedSearch(pattern) {      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},          _ref$isCaseSensitive = _ref.isCaseSensitive,          isCaseSensitive = _ref$isCaseSensitive === void 0 ? Config.isCaseSensitive : _ref$isCaseSensitive,          _ref$includeMatches = _ref.includeMatches,          includeMatches = _ref$includeMatches === void 0 ? Config.includeMatches : _ref$includeMatches,          _ref$minMatchCharLeng = _ref.minMatchCharLength,          minMatchCharLength = _ref$minMatchCharLeng === void 0 ? Config.minMatchCharLength : _ref$minMatchCharLeng,          _ref$findAllMatches = _ref.findAllMatches,          findAllMatches = _ref$findAllMatches === void 0 ? Config.findAllMatches : _ref$findAllMatches,          _ref$location = _ref.location,          location = _ref$location === void 0 ? Config.location : _ref$location,          _ref$threshold = _ref.threshold,          threshold = _ref$threshold === void 0 ? Config.threshold : _ref$threshold,          _ref$distance = _ref.distance,          distance = _ref$distance === void 0 ? Config.distance : _ref$distance;
      _classCallCheck(this, ExtendedSearch);
      this.query = null;      this.options = {        isCaseSensitive: isCaseSensitive,        includeMatches: includeMatches,        minMatchCharLength: minMatchCharLength,        findAllMatches: findAllMatches,        location: location,        threshold: threshold,        distance: distance      };      this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();      this.query = parseQuery(this.pattern, this.options);    }
    _createClass(ExtendedSearch, [{      key: "searchIn",      value: function searchIn(text) {        var query = this.query;
        if (!query) {          return {            isMatch: false,            score: 1          };        }
        var _this$options = this.options,            includeMatches = _this$options.includeMatches,            isCaseSensitive = _this$options.isCaseSensitive;        text = isCaseSensitive ? text : text.toLowerCase();        var numMatches = 0;        var allIndices = [];        var totalScore = 0; // ORs
        for (var i = 0, qLen = query.length; i < qLen; i += 1) {          var searchers = query[i]; // Reset indices
          allIndices.length = 0;          numMatches = 0; // ANDs
          for (var j = 0, pLen = searchers.length; j < pLen; j += 1) {            var searcher = searchers[j];
            var _searcher$search = searcher.search(text),                isMatch = _searcher$search.isMatch,                indices = _searcher$search.indices,                score = _searcher$search.score;
            if (isMatch) {              numMatches += 1;              totalScore += score;
              if (includeMatches) {                var type = searcher.constructor.type;
                if (MultiMatchSet.has(type)) {                  allIndices = [].concat(_toConsumableArray(allIndices), _toConsumableArray(indices));                } else {                  allIndices.push(indices);                }              }            } else {              totalScore = 0;              numMatches = 0;              allIndices.length = 0;              break;            }          } // OR condition, so if TRUE, return

          if (numMatches) {            var result = {              isMatch: true,              score: totalScore / numMatches            };
            if (includeMatches) {              result.indices = allIndices;            }
            return result;          }        } // Nothing was matched

        return {          isMatch: false,          score: 1        };      }    }], [{      key: "condition",      value: function condition(_, options) {        return options.useExtendedSearch;      }    }]);
    return ExtendedSearch;  }();
  var registeredSearchers = [];  function register() {    registeredSearchers.push.apply(registeredSearchers, arguments);  }  function createSearcher(pattern, options) {    for (var i = 0, len = registeredSearchers.length; i < len; i += 1) {      var searcherClass = registeredSearchers[i];
      if (searcherClass.condition(pattern, options)) {        return new searcherClass(pattern, options);      }    }
    return new BitapSearch(pattern, options);  }
  var LogicalOperator = {    AND: '$and',    OR: '$or'  };  var KeyType = {    PATH: '$path',    PATTERN: '$val'  };
  var isExpression = function isExpression(query) {    return !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);  };
  var isPath = function isPath(query) {    return !!query[KeyType.PATH];  };
  var isLeaf = function isLeaf(query) {    return !isArray(query) && isObject(query) && !isExpression(query);  };
  var convertToExplicit = function convertToExplicit(query) {    return _defineProperty({}, LogicalOperator.AND, Object.keys(query).map(function (key) {      return _defineProperty({}, key, query[key]);    }));  }; // When `auto` is `true`, the parse function will infer and initialize and add  // the appropriate `Searcher` instance

  function parse(query, options) {    var _ref3 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},        _ref3$auto = _ref3.auto,        auto = _ref3$auto === void 0 ? true : _ref3$auto;
    var next = function next(query) {      var keys = Object.keys(query);      var isQueryPath = isPath(query);
      if (!isQueryPath && keys.length > 1 && !isExpression(query)) {        return next(convertToExplicit(query));      }
      if (isLeaf(query)) {        var key = isQueryPath ? query[KeyType.PATH] : keys[0];        var pattern = isQueryPath ? query[KeyType.PATTERN] : query[key];
        if (!isString(pattern)) {          throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));        }
        var obj = {          keyId: createKeyId(key),          pattern: pattern        };
        if (auto) {          obj.searcher = createSearcher(pattern, options);        }
        return obj;      }
      var node = {        children: [],        operator: keys[0]      };      keys.forEach(function (key) {        var value = query[key];
        if (isArray(value)) {          value.forEach(function (item) {            node.children.push(next(item));          });        }      });      return node;    };
    if (!isExpression(query)) {      query = convertToExplicit(query);    }
    return next(query);  }
  var Fuse = /*#__PURE__*/function () {    function Fuse(docs) {      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};      var index = arguments.length > 2 ? arguments[2] : undefined;
      _classCallCheck(this, Fuse);
      this.options = _objectSpread2({}, Config, {}, options);
      if (this.options.useExtendedSearch && !true) {        throw new Error(EXTENDED_SEARCH_UNAVAILABLE);      }
      this._keyStore = new KeyStore(this.options.keys);      this.setCollection(docs, index);    }
    _createClass(Fuse, [{      key: "setCollection",      value: function setCollection(docs, index) {        this._docs = docs;
        if (index && !(index instanceof FuseIndex)) {          throw new Error(INCORRECT_INDEX_TYPE);        }
        this._myIndex = index || createIndex(this.options.keys, this._docs, {          getFn: this.options.getFn        });      }    }, {      key: "add",      value: function add(doc) {        if (!isDefined(doc)) {          return;        }
        this._docs.push(doc);
        this._myIndex.add(doc);      }    }, {      key: "remove",      value: function remove() {        var predicate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function () {          return (            /* doc, idx */            false          );        };        var results = [];
        for (var i = 0, len = this._docs.length; i < len; i += 1) {          var doc = this._docs[i];
          if (predicate(doc, i)) {            this.removeAt(i);            i -= 1;            results.push(doc);          }        }
        return results;      }    }, {      key: "removeAt",      value: function removeAt(idx) {        this._docs.splice(idx, 1);
        this._myIndex.removeAt(idx);      }    }, {      key: "getIndex",      value: function getIndex() {        return this._myIndex;      }    }, {      key: "search",      value: function search(query) {        var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},            _ref$limit = _ref.limit,            limit = _ref$limit === void 0 ? -1 : _ref$limit;
        var _this$options = this.options,            includeMatches = _this$options.includeMatches,            includeScore = _this$options.includeScore,            shouldSort = _this$options.shouldSort,            sortFn = _this$options.sortFn,            ignoreFieldNorm = _this$options.ignoreFieldNorm;        var results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);        computeScore$1(results, {          ignoreFieldNorm: ignoreFieldNorm        });
        if (shouldSort) {          results.sort(sortFn);        }
        if (isNumber(limit) && limit > -1) {          results = results.slice(0, limit);        }
        return format(results, this._docs, {          includeMatches: includeMatches,          includeScore: includeScore        });      }    }, {      key: "_searchStringList",      value: function _searchStringList(query) {        var searcher = createSearcher(query, this.options);        var records = this._myIndex.records;        var results = []; // Iterate over every string in the index
        records.forEach(function (_ref2) {          var text = _ref2.v,              idx = _ref2.i,              norm = _ref2.n;
          if (!isDefined(text)) {            return;          }
          var _searcher$searchIn = searcher.searchIn(text),              isMatch = _searcher$searchIn.isMatch,              score = _searcher$searchIn.score,              indices = _searcher$searchIn.indices;
          if (isMatch) {            results.push({              item: text,              idx: idx,              matches: [{                score: score,                value: text,                norm: norm,                indices: indices              }]            });          }        });        return results;      }    }, {      key: "_searchLogical",      value: function _searchLogical(query) {        var _this = this;
        var expression = parse(query, this.options);
        var evaluate = function evaluate(node, item, idx) {          if (!node.children) {            var keyId = node.keyId,                searcher = node.searcher;
            var matches = _this._findMatches({              key: _this._keyStore.get(keyId),              value: _this._myIndex.getValueForItemAtKeyId(item, keyId),              searcher: searcher            });
            if (matches && matches.length) {              return [{                idx: idx,                item: item,                matches: matches              }];            }
            return [];          }          /*eslint indent: [2, 2, {"SwitchCase": 1}]*/

          switch (node.operator) {            case LogicalOperator.AND:              {                var res = [];
                for (var i = 0, len = node.children.length; i < len; i += 1) {                  var child = node.children[i];                  var result = evaluate(child, item, idx);
                  if (result.length) {                    res.push.apply(res, _toConsumableArray(result));                  } else {                    return [];                  }                }
                return res;              }
            case LogicalOperator.OR:              {                var _res = [];
                for (var _i = 0, _len = node.children.length; _i < _len; _i += 1) {                  var _child = node.children[_i];
                  var _result = evaluate(_child, item, idx);
                  if (_result.length) {                    _res.push.apply(_res, _toConsumableArray(_result));
                    break;                  }                }
                return _res;              }          }        };
        var records = this._myIndex.records;        var resultMap = {};        var results = [];        records.forEach(function (_ref3) {          var item = _ref3.$,              idx = _ref3.i;
          if (isDefined(item)) {            var expResults = evaluate(expression, item, idx);
            if (expResults.length) {              // Dedupe when adding              if (!resultMap[idx]) {                resultMap[idx] = {                  idx: idx,                  item: item,                  matches: []                };                results.push(resultMap[idx]);              }
              expResults.forEach(function (_ref4) {                var _resultMap$idx$matche;
                var matches = _ref4.matches;
                (_resultMap$idx$matche = resultMap[idx].matches).push.apply(_resultMap$idx$matche, _toConsumableArray(matches));              });            }          }        });        return results;      }    }, {      key: "_searchObjectList",      value: function _searchObjectList(query) {        var _this2 = this;
        var searcher = createSearcher(query, this.options);        var _this$_myIndex = this._myIndex,            keys = _this$_myIndex.keys,            records = _this$_myIndex.records;        var results = []; // List is Array<Object>
        records.forEach(function (_ref5) {          var item = _ref5.$,              idx = _ref5.i;
          if (!isDefined(item)) {            return;          }
          var matches = []; // Iterate over every key (i.e, path), and fetch the value at that key
          keys.forEach(function (key, keyIndex) {            matches.push.apply(matches, _toConsumableArray(_this2._findMatches({              key: key,              value: item[keyIndex],              searcher: searcher            })));          });
          if (matches.length) {            results.push({              idx: idx,              item: item,              matches: matches            });          }        });        return results;      }    }, {      key: "_findMatches",      value: function _findMatches(_ref6) {        var key = _ref6.key,            value = _ref6.value,            searcher = _ref6.searcher;
        if (!isDefined(value)) {          return [];        }
        var matches = [];
        if (isArray(value)) {          value.forEach(function (_ref7) {            var text = _ref7.v,                idx = _ref7.i,                norm = _ref7.n;
            if (!isDefined(text)) {              return;            }
            var _searcher$searchIn2 = searcher.searchIn(text),                isMatch = _searcher$searchIn2.isMatch,                score = _searcher$searchIn2.score,                indices = _searcher$searchIn2.indices;
            if (isMatch) {              matches.push({                score: score,                key: key,                value: text,                idx: idx,                norm: norm,                indices: indices              });            }          });        } else {          var text = value.v,              norm = value.n;
          var _searcher$searchIn3 = searcher.searchIn(text),              isMatch = _searcher$searchIn3.isMatch,              score = _searcher$searchIn3.score,              indices = _searcher$searchIn3.indices;
          if (isMatch) {            matches.push({              score: score,              key: key,              value: text,              norm: norm,              indices: indices            });          }        }
        return matches;      }    }]);
    return Fuse;  }(); // Practical scoring function
  function computeScore$1(results, _ref8) {    var _ref8$ignoreFieldNorm = _ref8.ignoreFieldNorm,        ignoreFieldNorm = _ref8$ignoreFieldNorm === void 0 ? Config.ignoreFieldNorm : _ref8$ignoreFieldNorm;    results.forEach(function (result) {      var totalScore = 1;      result.matches.forEach(function (_ref9) {        var key = _ref9.key,            norm = _ref9.norm,            score = _ref9.score;        var weight = key ? key.weight : null;        totalScore *= Math.pow(score === 0 && weight ? Number.EPSILON : score, (weight || 1) * (ignoreFieldNorm ? 1 : norm));      });      result.score = totalScore;    });  }
  function format(results, docs) {    var _ref10 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},        _ref10$includeMatches = _ref10.includeMatches,        includeMatches = _ref10$includeMatches === void 0 ? Config.includeMatches : _ref10$includeMatches,        _ref10$includeScore = _ref10.includeScore,        includeScore = _ref10$includeScore === void 0 ? Config.includeScore : _ref10$includeScore;
    var transformers = [];    if (includeMatches) transformers.push(transformMatches);    if (includeScore) transformers.push(transformScore);    return results.map(function (result) {      var idx = result.idx;      var data = {        item: docs[idx],        refIndex: idx      };
      if (transformers.length) {        transformers.forEach(function (transformer) {          transformer(result, data);        });      }
      return data;    });  }
  Fuse.version = '6.4.1';  Fuse.createIndex = createIndex;  Fuse.parseIndex = parseIndex;  Fuse.config = Config;
  {    Fuse.parseQuery = parse;  }
  {    register(ExtendedSearch);  }
  return Fuse;
})));