@startinblox/core 0.17.31 → 0.18.0-beta.2

package/dist/_snowpack/pkg/fusejs.js

@@ -1,16 +1,14 @@
 /**
- * Fuse.js v6.4.6 - Lightweight fuzzy-search (http://fusejs.io)
+ * Fuse.js v6.6.2 - Lightweight fuzzy-search (http://fusejs.io)
  *
- * Copyright (c) 2021 Kiro Risk (http://kiro.me)
+ * Copyright (c) 2022 Kiro Risk (http://kiro.me)
  * All Rights Reserved. Apache Software License 2.0
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
 function isArray(value) {
-  return !Array.isArray
-    ? getTag(value) === '[object Array]'
-    : Array.isArray(value)
+  return !Array.isArray ? getTag(value) === '[object Array]' : Array.isArray(value);
 }
 
 // Adapted from: https://github.com/lodash/lodash/blob/master/.internal/baseToString.js
@@ -18,178 +16,140 @@ const INFINITY = 1 / 0;
 function baseToString(value) {
   // Exit early for strings to avoid a performance hit in some environments.
   if (typeof value == 'string') {
-    return value
+    return value;
   }
   let result = value + '';
-  return result == '0' && 1 / value == -INFINITY ? '-0' : result
+  return result == '0' && 1 / value == -INFINITY ? '-0' : result;
 }
-
 function toString(value) {
-  return value == null ? '' : baseToString(value)
+  return value == null ? '' : baseToString(value);
 }
-
 function isString(value) {
-  return typeof value === 'string'
+  return typeof value === 'string';
 }
-
 function isNumber(value) {
-  return typeof value === 'number'
+  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]')
-  )
+  return value === true || value === false || isObjectLike(value) && getTag(value) == '[object Boolean]';
 }
-
 function isObject(value) {
-  return typeof value === 'object'
+  return typeof value === 'object';
 }
 
 // Checks if `value` is object-like.
 function isObjectLike(value) {
-  return isObject(value) && value !== null
+  return isObject(value) && value !== null;
 }
-
 function isDefined(value) {
-  return value !== undefined && value !== null
+  return value !== undefined && value !== null;
 }
-
 function isBlank(value) {
-  return !value.trim().length
+  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)
+  return value == null ? value === undefined ? '[object Undefined]' : '[object Null]' : Object.prototype.toString.call(value);
 }
-
 const EXTENDED_SEARCH_UNAVAILABLE = 'Extended search is not available';
-
 const INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
-
-const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) =>
-  `Invalid value for key ${key}`;
-
-const PATTERN_LENGTH_TOO_LARGE = (max) =>
-  `Pattern length exceeds max of ${max}.`;
-
-const MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;
-
-const INVALID_KEY_WEIGHT_VALUE = (key) =>
-  `Property 'weight' in key '${key}' must be a positive integer`;
-
+const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = key => `Invalid value for key ${key}`;
+const PATTERN_LENGTH_TOO_LARGE = max => `Pattern length exceeds max of ${max}.`;
+const MISSING_KEY_PROPERTY = name => `Missing ${name} property in key`;
+const INVALID_KEY_WEIGHT_VALUE = key => `Property 'weight' in key '${key}' must be a positive integer`;
 const hasOwn = Object.prototype.hasOwnProperty;
-
 class KeyStore {
   constructor(keys) {
     this._keys = [];
     this._keyMap = {};
-
     let totalWeight = 0;
-
-    keys.forEach((key) => {
+    keys.forEach(key => {
       let 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((key) => {
+    this._keys.forEach(key => {
       key.weight /= totalWeight;
     });
   }
   get(keyId) {
-    return this._keyMap[keyId]
+    return this._keyMap[keyId];
   }
   keys() {
-    return this._keys
+    return this._keys;
   }
   toJSON() {
-    return JSON.stringify(this._keys)
+    return JSON.stringify(this._keys);
   }
 }
-
 function createKey(key) {
   let path = null;
   let id = null;
   let src = null;
   let weight = 1;
-
+  let getFn = null;
   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'))
+      throw new Error(MISSING_KEY_PROPERTY('name'));
     }
-
     const name = key.name;
     src = name;
-
     if (hasOwn.call(key, 'weight')) {
       weight = key.weight;
-
       if (weight <= 0) {
-        throw new Error(INVALID_KEY_WEIGHT_VALUE(name))
+        throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
       }
     }
-
     path = createKeyPath(name);
     id = createKeyId(name);
+    getFn = key.getFn;
   }
-
-  return { path, id, weight, src }
+  return {
+    path,
+    id,
+    weight,
+    src,
+    getFn
+  };
 }
-
 function createKeyPath(key) {
-  return isArray(key) ? key : key.split('.')
+  return isArray(key) ? key : key.split('.');
 }
-
 function createKeyId(key) {
-  return isArray(key) ? key.join('.') : key
+  return isArray(key) ? key.join('.') : key;
 }
-
 function get(obj, path) {
   let list = [];
   let arr = false;
-
   const deepGet = (obj, path, index) => {
     if (!isDefined(obj)) {
-      return
+      return;
     }
     if (!path[index]) {
       // If there's no path left, we've arrived at the object we care about.
       list.push(obj);
     } else {
       let key = path[index];
-
       const value = obj[key];
-
       if (!isDefined(value)) {
-        return
+        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))
-      ) {
+      if (index === path.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
         list.push(toString(value));
       } else if (isArray(value)) {
         arr = true;
@@ -206,10 +166,8 @@ function get(obj, path) {
 
   // Backwards compatibility (since path used to be a string)
   deepGet(obj, isString(path) ? path.split('.') : path, 0);
-
-  return arr ? list : list[0]
+  return arr ? list : list[0];
 }
-
 const 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.
@@ -221,7 +179,6 @@ const MatchOptions = {
   // Minimum number of characters that must be matched before a result is considered a match
   minMatchCharLength: 1
 };
-
 const 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.
@@ -233,10 +190,8 @@ const BasicOptions = {
   // Whether to sort the result list, by score
   shouldSort: true,
   // Default sort function: sort by ascending score, ascending index
-  sortFn: (a, b) =>
-    a.score === b.score ? (a.idx < b.idx ? -1 : 1) : a.score < b.score ? -1 : 1
+  sortFn: (a, b) => a.score === b.score ? a.idx < b.idx ? -1 : 1 : a.score < b.score ? -1 : 1
 };
-
 const FuzzyOptions = {
   // Approximately where in the text is the pattern expected to be found?
   location: 0,
@@ -250,7 +205,6 @@ const FuzzyOptions = {
   // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.
   distance: 100
 };
-
 const AdvancedOptions = {
   // When `true`, it enables the use of unix-like search commands
   useExtendedSearch: false,
@@ -264,53 +218,51 @@ const AdvancedOptions = {
   // 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
+  ignoreFieldNorm: false,
+  // The weight to determine how much field length norm effects scoring.
+  fieldNormWeight: 1
 };
-
 var Config = {
   ...BasicOptions,
   ...MatchOptions,
   ...FuzzyOptions,
   ...AdvancedOptions
 };
-
 const SPACE = /[^ ]+/g;
 
 // Field-length norm: the shorter the field, the higher the weight.
 // Set to 3 decimals to reduce index size.
-function norm(mantissa = 3) {
+function norm(weight = 1, mantissa = 3) {
   const cache = new Map();
   const m = Math.pow(10, mantissa);
-
   return {
     get(value) {
       const numTokens = value.match(SPACE).length;
-
       if (cache.has(numTokens)) {
-        return cache.get(numTokens)
+        return cache.get(numTokens);
       }
 
-      const norm = 1 / Math.sqrt(numTokens);
+      // Default function is 1/sqrt(x), weight makes that variable
+      const norm = 1 / Math.pow(numTokens, 0.5 * weight);
 
       // In place of `toFixed(mantissa)`, for faster computation
       const n = parseFloat(Math.round(norm * m) / m);
-
       cache.set(numTokens, n);
-
-      return n
+      return n;
     },
     clear() {
       cache.clear();
     }
-  }
+  };
 }
-
 class FuseIndex {
-  constructor({ getFn = Config.getFn } = {}) {
-    this.norm = norm(3);
+  constructor({
+    getFn = Config.getFn,
+    fieldNormWeight = Config.fieldNormWeight
+  } = {}) {
+    this.norm = norm(fieldNormWeight, 3);
     this.getFn = getFn;
     this.isCreated = false;
-
     this.setIndexRecords();
   }
   setSources(docs = []) {
@@ -328,9 +280,8 @@ class FuseIndex {
   }
   create() {
     if (this.isCreated || !this.docs.length) {
-      return
+      return;
     }
-
     this.isCreated = true;
 
     // List is Array<String>
@@ -344,13 +295,11 @@ class FuseIndex {
         this._addObject(doc, docIndex);
       });
     }
-
     this.norm.clear();
   }
   // Adds a doc to the end of the index
   add(doc) {
     const idx = this.size();
-
     if (isString(doc)) {
       this._addString(doc, idx);
     } else {
@@ -367,54 +316,54 @@ class FuseIndex {
     }
   }
   getValueForItemAtKeyId(item, keyId) {
-    return item[this._keysMap[keyId]]
+    return item[this._keysMap[keyId]];
   }
   size() {
-    return this.records.length
+    return this.records.length;
   }
   _addString(doc, docIndex) {
     if (!isDefined(doc) || isBlank(doc)) {
-      return
+      return;
     }
-
     let record = {
       v: doc,
       i: docIndex,
       n: this.norm.get(doc)
     };
-
     this.records.push(record);
   }
   _addObject(doc, docIndex) {
-    let record = { i: docIndex, $: {} };
+    let record = {
+      i: docIndex,
+      $: {}
+    };
 
     // Iterate over every key (i.e, path), and fetch the value at that key
     this.keys.forEach((key, keyIndex) => {
-      // console.log(key)
-      let value = this.getFn(doc, key.path);
-
+      let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
       if (!isDefined(value)) {
-        return
+        return;
       }
-
       if (isArray(value)) {
         let subRecords = [];
-        const stack = [{ nestedArrIndex: -1, value }];
-
+        const stack = [{
+          nestedArrIndex: -1,
+          value
+        }];
         while (stack.length) {
-          const { nestedArrIndex, value } = stack.pop();
-
+          const {
+            nestedArrIndex,
+            value
+          } = stack.pop();
           if (!isDefined(value)) {
-            continue
+            continue;
           }
-
           if (isString(value) && !isBlank(value)) {
             let subRecord = {
               v: value,
               i: nestedArrIndex,
               n: this.norm.get(value)
             };
-
             subRecords.push(subRecord);
           } else if (isArray(value)) {
             value.forEach((item, k) => {
@@ -423,80 +372,78 @@ class FuseIndex {
                 value: item
               });
             });
-          }
+          } else ;
         }
         record.$[keyIndex] = subRecords;
-      } else if (!isBlank(value)) {
+      } else if (isString(value) && !isBlank(value)) {
         let subRecord = {
           v: value,
           n: this.norm.get(value)
         };
-
         record.$[keyIndex] = subRecord;
       }
     });
-
     this.records.push(record);
   }
   toJSON() {
     return {
       keys: this.keys,
       records: this.records
-    }
+    };
   }
 }
-
-function createIndex(keys, docs, { getFn = Config.getFn } = {}) {
-  const myIndex = new FuseIndex({ getFn });
+function createIndex(keys, docs, {
+  getFn = Config.getFn,
+  fieldNormWeight = Config.fieldNormWeight
+} = {}) {
+  const myIndex = new FuseIndex({
+    getFn,
+    fieldNormWeight
+  });
   myIndex.setKeys(keys.map(createKey));
   myIndex.setSources(docs);
   myIndex.create();
-  return myIndex
+  return myIndex;
 }
-
-function parseIndex(data, { getFn = Config.getFn } = {}) {
-  const { keys, records } = data;
-  const myIndex = new FuseIndex({ getFn });
+function parseIndex(data, {
+  getFn = Config.getFn,
+  fieldNormWeight = Config.fieldNormWeight
+} = {}) {
+  const {
+    keys,
+    records
+  } = data;
+  const myIndex = new FuseIndex({
+    getFn,
+    fieldNormWeight
+  });
   myIndex.setKeys(keys);
   myIndex.setIndexRecords(records);
-  return myIndex
+  return myIndex;
 }
-
-function computeScore(
-  pattern,
-  {
-    errors = 0,
-    currentLocation = 0,
-    expectedLocation = 0,
-    distance = Config.distance,
-    ignoreLocation = Config.ignoreLocation
-  } = {}
-) {
+function computeScore$1(pattern, {
+  errors = 0,
+  currentLocation = 0,
+  expectedLocation = 0,
+  distance = Config.distance,
+  ignoreLocation = Config.ignoreLocation
+} = {}) {
   const accuracy = errors / pattern.length;
-
   if (ignoreLocation) {
-    return accuracy
+    return accuracy;
   }
-
   const proximity = Math.abs(expectedLocation - currentLocation);
-
   if (!distance) {
     // Dodge divide by zero error.
-    return proximity ? 1.0 : accuracy
+    return proximity ? 1.0 : accuracy;
   }
-
-  return accuracy + proximity / distance
+  return accuracy + proximity / distance;
 }
-
-function convertMaskToIndices(
-  matchmask = [],
-  minMatchCharLength = Config.minMatchCharLength
-) {
+function convertMaskToIndices(matchmask = [], minMatchCharLength = Config.minMatchCharLength) {
   let indices = [];
   let start = -1;
   let end = -1;
   let i = 0;
-
   for (let len = matchmask.length; i < len; i += 1) {
     let match = matchmask[i];
     if (match && start === -1) {
@@ -514,31 +461,23 @@ function convertMaskToIndices(
   if (matchmask[i - 1] && i - start >= minMatchCharLength) {
     indices.push([start, i - 1]);
   }
-
-  return indices
+  return indices;
 }
 
 // Machine word size
 const MAX_BITS = 32;
-
-function search(
-  text,
-  pattern,
-  patternAlphabet,
-  {
-    location = Config.location,
-    distance = Config.distance,
-    threshold = Config.threshold,
-    findAllMatches = Config.findAllMatches,
-    minMatchCharLength = Config.minMatchCharLength,
-    includeMatches = Config.includeMatches,
-    ignoreLocation = Config.ignoreLocation
-  } = {}
-) {
+function search(text, pattern, patternAlphabet, {
+  location = Config.location,
+  distance = Config.distance,
+  threshold = Config.threshold,
+  findAllMatches = Config.findAllMatches,
+  minMatchCharLength = Config.minMatchCharLength,
+  includeMatches = Config.includeMatches,
+  ignoreLocation = Config.ignoreLocation
+} = {}) {
   if (pattern.length > MAX_BITS) {
-    throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS))
+    throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));
   }
-
   const patternLen = pattern.length;
   // Set starting location at beginning text and initialize the alphabet.
   const textLen = text.length;
@@ -554,21 +493,18 @@ function search(
   const computeMatches = minMatchCharLength > 1 || includeMatches;
   // A mask of the matches, used for building the indices
   const matchMask = computeMatches ? Array(textLen) : [];
-
   let index;
 
   // Get all exact matches, here for speed up
   while ((index = text.indexOf(pattern, bestLocation)) > -1) {
-    let score = computeScore(pattern, {
+    let score = computeScore$1(pattern, {
       currentLocation: index,
       expectedLocation,
       distance,
       ignoreLocation
     });
-
     currentThreshold = Math.min(score, currentThreshold);
     bestLocation = index + patternLen;
-
     if (computeMatches) {
       let i = 0;
       while (i < patternLen) {
@@ -580,71 +516,57 @@ function search(
 
   // Reset the best location
   bestLocation = -1;
-
   let lastBitArr = [];
   let finalScore = 1;
   let binMax = patternLen + textLen;
-
-  const mask = 1 << (patternLen - 1);
-
+  const mask = 1 << patternLen - 1;
   for (let 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.
     let binMin = 0;
     let binMid = binMax;
-
     while (binMin < binMid) {
-      const score = computeScore(pattern, {
+      const score = computeScore$1(pattern, {
         errors: i,
         currentLocation: expectedLocation + binMid,
         expectedLocation,
         distance,
         ignoreLocation
       });
-
       if (score <= 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;
-
     let start = Math.max(1, expectedLocation - binMid + 1);
-    let finish = findAllMatches
-      ? textLen
-      : Math.min(expectedLocation + binMid, textLen) + patternLen;
+    let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
 
     // Initialize the bit array
     let bitArr = Array(finish + 2);
-
     bitArr[finish + 1] = (1 << i) - 1;
-
     for (let j = finish; j >= start; j -= 1) {
       let currentLocation = j - 1;
       let 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;
+      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];
+        bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
       }
-
       if (bitArr[j] & mask) {
-        finalScore = computeScore(pattern, {
+        finalScore = computeScore$1(pattern, {
           errors: i,
           currentLocation,
           expectedLocation,
@@ -661,7 +583,7 @@ function search(
 
           // Already passed `loc`, downhill from here on in.
           if (bestLocation <= expectedLocation) {
-            break
+            break;
           }
 
           // When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.
@@ -671,27 +593,23 @@ function search(
     }
 
     // No hope for a (better) match at greater error levels.
-    const score = computeScore(pattern, {
+    const score = computeScore$1(pattern, {
       errors: i + 1,
       currentLocation: expectedLocation,
       expectedLocation,
       distance,
       ignoreLocation
     });
-
     if (score > currentThreshold) {
-      break
+      break;
     }
-
     lastBitArr = bitArr;
   }
-
   const 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) {
     const indices = convertMaskToIndices(matchMask, minMatchCharLength);
     if (!indices.length) {
@@ -700,35 +618,27 @@ function search(
       result.indices = indices;
     }
   }
-
-  return result
+  return result;
 }
-
 function createPatternAlphabet(pattern) {
   let mask = {};
-
   for (let i = 0, len = pattern.length; i < len; i += 1) {
     const char = pattern.charAt(i);
-    mask[char] = (mask[char] || 0) | (1 << (len - i - 1));
+    mask[char] = (mask[char] || 0) | 1 << len - i - 1;
   }
-
-  return mask
+  return mask;
 }
-
 class BitapSearch {
-  constructor(
-    pattern,
-    {
-      location = Config.location,
-      threshold = Config.threshold,
-      distance = Config.distance,
-      includeMatches = Config.includeMatches,
-      findAllMatches = Config.findAllMatches,
-      minMatchCharLength = Config.minMatchCharLength,
-      isCaseSensitive = Config.isCaseSensitive,
-      ignoreLocation = Config.ignoreLocation
-    } = {}
-  ) {
+  constructor(pattern, {
+    location = Config.location,
+    threshold = Config.threshold,
+    distance = Config.distance,
+    includeMatches = Config.includeMatches,
+    findAllMatches = Config.findAllMatches,
+    minMatchCharLength = Config.minMatchCharLength,
+    isCaseSensitive = Config.isCaseSensitive,
+    ignoreLocation = Config.ignoreLocation
+  } = {}) {
     this.options = {
       location,
       threshold,
@@ -739,15 +649,11 @@ class BitapSearch {
       isCaseSensitive,
       ignoreLocation
     };
-
     this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
-
     this.chunks = [];
-
     if (!this.pattern.length) {
-      return
+      return;
     }
-
     const addChunk = (pattern, startIndex) => {
       this.chunks.push({
         pattern,
@@ -755,19 +661,15 @@ class BitapSearch {
         startIndex
       });
     };
-
     const len = this.pattern.length;
-
     if (len > MAX_BITS) {
       let i = 0;
       const remainder = len % MAX_BITS;
       const end = len - remainder;
-
       while (i < end) {
         addChunk(this.pattern.substr(i, MAX_BITS), i);
         i += MAX_BITS;
       }
-
       if (remainder) {
         const startIndex = len - MAX_BITS;
         addChunk(this.pattern.substr(startIndex), startIndex);
@@ -776,10 +678,11 @@ class BitapSearch {
       addChunk(this.pattern, 0);
     }
   }
-
   searchIn(text) {
-    const { isCaseSensitive, includeMatches } = this.options;
-
+    const {
+      isCaseSensitive,
+      includeMatches
+    } = this.options;
     if (!isCaseSensitive) {
       text = text.toLowerCase();
     }
@@ -790,12 +693,10 @@ class BitapSearch {
         isMatch: true,
         score: 0
       };
-
       if (includeMatches) {
         result.indices = [[0, text.length - 1]];
       }
-
-      return result
+      return result;
     }
 
     // Otherwise, use Bitap algorithm
@@ -807,13 +708,19 @@ class BitapSearch {
       minMatchCharLength,
       ignoreLocation
     } = this.options;
-
     let allIndices = [];
     let totalScore = 0;
     let hasMatches = false;
-
-    this.chunks.forEach(({ pattern, alphabet, startIndex }) => {
-      const { isMatch, score, indices } = search(text, pattern, alphabet, {
+    this.chunks.forEach(({
+      pattern,
+      alphabet,
+      startIndex
+    }) => {
+      const {
+        isMatch,
+        score,
+        indices
+      } = search(text, pattern, alphabet, {
         location: location + startIndex,
         distance,
         threshold,
@@ -822,47 +729,39 @@ class BitapSearch {
         includeMatches,
         ignoreLocation
       });
-
       if (isMatch) {
         hasMatches = true;
       }
-
       totalScore += score;
-
       if (isMatch && indices) {
         allIndices = [...allIndices, ...indices];
       }
     });
-
     let result = {
       isMatch: hasMatches,
       score: hasMatches ? totalScore / this.chunks.length : 1
     };
-
     if (hasMatches && includeMatches) {
       result.indices = allIndices;
     }
-
-    return result
+    return result;
   }
 }
-
 class BaseMatch {
   constructor(pattern) {
     this.pattern = pattern;
   }
   static isMultiMatch(pattern) {
-    return getMatch(pattern, this.multiRegex)
+    return getMatch(pattern, this.multiRegex);
   }
   static isSingleMatch(pattern) {
-    return getMatch(pattern, this.singleRegex)
+    return getMatch(pattern, this.singleRegex);
   }
-  search(/*text*/) {}
+  search( /*text*/) {}
 }
-
 function getMatch(pattern, exp) {
   const matches = pattern.match(exp);
-  return matches ? matches[1] : null
+  return matches ? matches[1] : null;
 }
 
 // Token: 'file
@@ -872,22 +771,21 @@ class ExactMatch extends BaseMatch {
     super(pattern);
   }
   static get type() {
-    return 'exact'
+    return 'exact';
   }
   static get multiRegex() {
-    return /^="(.*)"$/
+    return /^="(.*)"$/;
   }
   static get singleRegex() {
-    return /^=(.*)$/
+    return /^=(.*)$/;
   }
   search(text) {
     const isMatch = text === this.pattern;
-
     return {
       isMatch,
       score: isMatch ? 0 : 1,
       indices: [0, this.pattern.length - 1]
-    }
+    };
   }
 }
 
@@ -898,23 +796,22 @@ class InverseExactMatch extends BaseMatch {
     super(pattern);
   }
   static get type() {
-    return 'inverse-exact'
+    return 'inverse-exact';
   }
   static get multiRegex() {
-    return /^!"(.*)"$/
+    return /^!"(.*)"$/;
   }
   static get singleRegex() {
-    return /^!(.*)$/
+    return /^!(.*)$/;
   }
   search(text) {
     const index = text.indexOf(this.pattern);
     const isMatch = index === -1;
-
     return {
       isMatch,
       score: isMatch ? 0 : 1,
       indices: [0, text.length - 1]
-    }
+    };
   }
 }
 
@@ -925,22 +822,21 @@ class PrefixExactMatch extends BaseMatch {
     super(pattern);
   }
   static get type() {
-    return 'prefix-exact'
+    return 'prefix-exact';
   }
   static get multiRegex() {
-    return /^\^"(.*)"$/
+    return /^\^"(.*)"$/;
   }
   static get singleRegex() {
-    return /^\^(.*)$/
+    return /^\^(.*)$/;
   }
   search(text) {
     const isMatch = text.startsWith(this.pattern);
-
     return {
       isMatch,
       score: isMatch ? 0 : 1,
       indices: [0, this.pattern.length - 1]
-    }
+    };
   }
 }
 
@@ -951,22 +847,21 @@ class InversePrefixExactMatch extends BaseMatch {
     super(pattern);
   }
   static get type() {
-    return 'inverse-prefix-exact'
+    return 'inverse-prefix-exact';
   }
   static get multiRegex() {
-    return /^!\^"(.*)"$/
+    return /^!\^"(.*)"$/;
   }
   static get singleRegex() {
-    return /^!\^(.*)$/
+    return /^!\^(.*)$/;
   }
   search(text) {
     const isMatch = !text.startsWith(this.pattern);
-
     return {
       isMatch,
       score: isMatch ? 0 : 1,
       indices: [0, text.length - 1]
-    }
+    };
   }
 }
 
@@ -977,22 +872,21 @@ class SuffixExactMatch extends BaseMatch {
     super(pattern);
   }
   static get type() {
-    return 'suffix-exact'
+    return 'suffix-exact';
   }
   static get multiRegex() {
-    return /^"(.*)"\$$/
+    return /^"(.*)"\$$/;
   }
   static get singleRegex() {
-    return /^(.*)\$$/
+    return /^(.*)\$$/;
   }
   search(text) {
     const isMatch = text.endsWith(this.pattern);
-
     return {
       isMatch,
       score: isMatch ? 0 : 1,
       indices: [text.length - this.pattern.length, text.length - 1]
-    }
+    };
   }
 }
 
@@ -1003,13 +897,13 @@ class InverseSuffixExactMatch extends BaseMatch {
     super(pattern);
   }
   static get type() {
-    return 'inverse-suffix-exact'
+    return 'inverse-suffix-exact';
   }
   static get multiRegex() {
-    return /^!"(.*)"\$$/
+    return /^!"(.*)"\$$/;
   }
   static get singleRegex() {
-    return /^!(.*)\$$/
+    return /^!(.*)\$$/;
   }
   search(text) {
     const isMatch = !text.endsWith(this.pattern);
@@ -1017,24 +911,20 @@ class InverseSuffixExactMatch extends BaseMatch {
       isMatch,
       score: isMatch ? 0 : 1,
       indices: [0, text.length - 1]
-    }
+    };
   }
 }
-
 class FuzzyMatch extends BaseMatch {
-  constructor(
-    pattern,
-    {
-      location = Config.location,
-      threshold = Config.threshold,
-      distance = Config.distance,
-      includeMatches = Config.includeMatches,
-      findAllMatches = Config.findAllMatches,
-      minMatchCharLength = Config.minMatchCharLength,
-      isCaseSensitive = Config.isCaseSensitive,
-      ignoreLocation = Config.ignoreLocation
-    } = {}
-  ) {
+  constructor(pattern, {
+    location = Config.location,
+    threshold = Config.threshold,
+    distance = Config.distance,
+    includeMatches = Config.includeMatches,
+    findAllMatches = Config.findAllMatches,
+    minMatchCharLength = Config.minMatchCharLength,
+    isCaseSensitive = Config.isCaseSensitive,
+    ignoreLocation = Config.ignoreLocation
+  } = {}) {
     super(pattern);
     this._bitapSearch = new BitapSearch(pattern, {
       location,
@@ -1048,16 +938,16 @@ class FuzzyMatch extends BaseMatch {
     });
   }
   static get type() {
-    return 'fuzzy'
+    return 'fuzzy';
   }
   static get multiRegex() {
-    return /^"(.*)"$/
+    return /^"(.*)"$/;
   }
   static get singleRegex() {
-    return /^(.*)$/
+    return /^(.*)$/;
   }
   search(text) {
-    return this._bitapSearch.searchIn(text)
+    return this._bitapSearch.searchIn(text);
   }
 }
 
@@ -1068,18 +958,17 @@ class IncludeMatch extends BaseMatch {
     super(pattern);
   }
   static get type() {
-    return 'include'
+    return 'include';
   }
   static get multiRegex() {
-    return /^'"(.*)"$/
+    return /^'"(.*)"$/;
   }
   static get singleRegex() {
-    return /^'(.*)$/
+    return /^'(.*)$/;
   }
   search(text) {
     let location = 0;
     let index;
-
     const indices = [];
     const patternLen = this.pattern.length;
 
@@ -1088,45 +977,29 @@ class IncludeMatch extends BaseMatch {
       location = index + patternLen;
       indices.push([index, location - 1]);
     }
-
     const isMatch = !!indices.length;
-
     return {
       isMatch,
       score: isMatch ? 0 : 1,
       indices
-    }
+    };
   }
 }
 
 // ❗Order is important. DO NOT CHANGE.
-const searchers = [
-  ExactMatch,
-  IncludeMatch,
-  PrefixExactMatch,
-  InversePrefixExactMatch,
-  InverseSuffixExactMatch,
-  SuffixExactMatch,
-  InverseExactMatch,
-  FuzzyMatch
-];
-
+const searchers = [ExactMatch, IncludeMatch, PrefixExactMatch, InversePrefixExactMatch, InverseSuffixExactMatch, SuffixExactMatch, InverseExactMatch, FuzzyMatch];
 const searchersLen = searchers.length;
 
 // Regex to split by spaces, but keep anything in quotes together
-const SPACE_RE = / +(?=([^\"]*\"[^\"]*\")*[^\"]*$)/;
+const SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
 const 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, options = {}) {
-  return pattern.split(OR_TOKEN).map((item) => {
-    let query = item
-      .trim()
-      .split(SPACE_RE)
-      .filter((item) => item && !!item.trim());
-
+  return pattern.split(OR_TOKEN).map(item => {
+    let query = item.trim().split(SPACE_RE).filter(item => item && !!item.trim());
     let results = [];
     for (let i = 0, len = query.length; i < len; i += 1) {
       const queryItem = query[i];
@@ -1142,9 +1015,8 @@ function parseQuery(pattern, options = {}) {
           found = true;
         }
       }
-
       if (found) {
-        continue
+        continue;
       }
 
       // 2. Handle single query matches (i.e, once that are *not* quoted)
@@ -1154,13 +1026,12 @@ function parseQuery(pattern, options = {}) {
         let token = searcher.isSingleMatch(queryItem);
         if (token) {
           results.push(new searcher(token, options));
-          break
+          break;
         }
       }
     }
-
-    return results
-  })
+    return results;
+  });
 }
 
 // These extended matchers can return an array of matches, as opposed
@@ -1196,19 +1067,16 @@ const MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]);
  * ```
  */
 class ExtendedSearch {
-  constructor(
-    pattern,
-    {
-      isCaseSensitive = Config.isCaseSensitive,
-      includeMatches = Config.includeMatches,
-      minMatchCharLength = Config.minMatchCharLength,
-      ignoreLocation = Config.ignoreLocation,
-      findAllMatches = Config.findAllMatches,
-      location = Config.location,
-      threshold = Config.threshold,
-      distance = Config.distance
-    } = {}
-  ) {
+  constructor(pattern, {
+    isCaseSensitive = Config.isCaseSensitive,
+    includeMatches = Config.includeMatches,
+    minMatchCharLength = Config.minMatchCharLength,
+    ignoreLocation = Config.ignoreLocation,
+    findAllMatches = Config.findAllMatches,
+    location = Config.location,
+    threshold = Config.threshold,
+    distance = Config.distance
+  } = {}) {
     this.query = null;
     this.options = {
       isCaseSensitive,
@@ -1220,29 +1088,25 @@ class ExtendedSearch {
       threshold,
       distance
     };
-
     this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
     this.query = parseQuery(this.pattern, this.options);
   }
-
   static condition(_, options) {
-    return options.useExtendedSearch
+    return options.useExtendedSearch;
   }
-
   searchIn(text) {
     const query = this.query;
-
     if (!query) {
       return {
         isMatch: false,
         score: 1
-      }
+      };
     }
-
-    const { includeMatches, isCaseSensitive } = this.options;
-
+    const {
+      includeMatches,
+      isCaseSensitive
+    } = this.options;
     text = isCaseSensitive ? text : text.toLowerCase();
-
     let numMatches = 0;
     let allIndices = [];
     let totalScore = 0;
@@ -1258,8 +1122,11 @@ class ExtendedSearch {
       // ANDs
       for (let j = 0, pLen = searchers.length; j < pLen; j += 1) {
         const searcher = searchers[j];
-        const { isMatch, indices, score } = searcher.search(text);
-
+        const {
+          isMatch,
+          indices,
+          score
+        } = searcher.search(text);
         if (isMatch) {
           numMatches += 1;
           totalScore += score;
@@ -1275,7 +1142,7 @@ class ExtendedSearch {
           totalScore = 0;
           numMatches = 0;
           allIndices.length = 0;
-          break
+          break;
         }
       }
 
@@ -1285,12 +1152,10 @@ class ExtendedSearch {
           isMatch: true,
           score: totalScore / numMatches
         };
-
         if (includeMatches) {
           result.indices = allIndices;
         }
-
-        return result
+        return result;
       }
     }
 
@@ -1298,263 +1163,207 @@ class ExtendedSearch {
     return {
       isMatch: false,
       score: 1
-    }
+    };
   }
 }
-
 const registeredSearchers = [];
-
 function register(...args) {
   registeredSearchers.push(...args);
 }
-
 function createSearcher(pattern, options) {
   for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {
     let searcherClass = registeredSearchers[i];
     if (searcherClass.condition(pattern, options)) {
-      return new searcherClass(pattern, options)
+      return new searcherClass(pattern, options);
     }
   }
-
-  return new BitapSearch(pattern, options)
+  return new BitapSearch(pattern, options);
 }
-
 const LogicalOperator = {
   AND: '$and',
   OR: '$or'
 };
-
 const KeyType = {
   PATH: '$path',
   PATTERN: '$val'
 };
-
-const isExpression = (query) =>
-  !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
-
-const isPath = (query) => !!query[KeyType.PATH];
-
-const isLeaf = (query) =>
-  !isArray(query) && isObject(query) && !isExpression(query);
-
-const convertToExplicit = (query) => ({
-  [LogicalOperator.AND]: Object.keys(query).map((key) => ({
+const isExpression = query => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
+const isPath = query => !!query[KeyType.PATH];
+const isLeaf = query => !isArray(query) && isObject(query) && !isExpression(query);
+const convertToExplicit = query => ({
+  [LogicalOperator.AND]: Object.keys(query).map(key => ({
     [key]: query[key]
   }))
 });
 
 // When `auto` is `true`, the parse function will infer and initialize and add
 // the appropriate `Searcher` instance
-function parse(query, options, { auto = true } = {}) {
-  const next = (query) => {
+function parse(query, options, {
+  auto = true
+} = {}) {
+  const next = query => {
     let keys = Object.keys(query);
-
     const isQueryPath = isPath(query);
-
     if (!isQueryPath && keys.length > 1 && !isExpression(query)) {
-      return next(convertToExplicit(query))
+      return next(convertToExplicit(query));
     }
-
     if (isLeaf(query)) {
       const key = isQueryPath ? query[KeyType.PATH] : keys[0];
-
       const pattern = isQueryPath ? query[KeyType.PATTERN] : query[key];
-
       if (!isString(pattern)) {
-        throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key))
+        throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
       }
-
       const obj = {
         keyId: createKeyId(key),
         pattern
       };
-
       if (auto) {
         obj.searcher = createSearcher(pattern, options);
       }
-
-      return obj
+      return obj;
     }
-
     let node = {
       children: [],
       operator: keys[0]
     };
-
-    keys.forEach((key) => {
+    keys.forEach(key => {
       const value = query[key];
-
       if (isArray(value)) {
-        value.forEach((item) => {
+        value.forEach(item => {
           node.children.push(next(item));
         });
       }
     });
-
-    return node
+    return node;
   };
-
   if (!isExpression(query)) {
     query = convertToExplicit(query);
   }
-
-  return next(query)
+  return next(query);
 }
 
 // Practical scoring function
-function computeScore$1(
-  results,
-  { ignoreFieldNorm = Config.ignoreFieldNorm }
-) {
-  results.forEach((result) => {
+function computeScore(results, {
+  ignoreFieldNorm = Config.ignoreFieldNorm
+}) {
+  results.forEach(result => {
     let totalScore = 1;
-
-    result.matches.forEach(({ key, norm, score }) => {
+    result.matches.forEach(({
+      key,
+      norm,
+      score
+    }) => {
       const weight = key ? key.weight : null;
-
-      totalScore *= Math.pow(
-        score === 0 && weight ? Number.EPSILON : score,
-        (weight || 1) * (ignoreFieldNorm ? 1 : norm)
-      );
+      totalScore *= Math.pow(score === 0 && weight ? Number.EPSILON : score, (weight || 1) * (ignoreFieldNorm ? 1 : norm));
     });
-
     result.score = totalScore;
   });
 }
-
 function transformMatches(result, data) {
   const matches = result.matches;
   data.matches = [];
-
   if (!isDefined(matches)) {
-    return
+    return;
   }
-
-  matches.forEach((match) => {
+  matches.forEach(match => {
     if (!isDefined(match.indices) || !match.indices.length) {
-      return
+      return;
     }
-
-    const { indices, value } = match;
-
+    const {
+      indices,
+      value
+    } = match;
     let obj = {
       indices,
       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 format(
-  results,
-  docs,
-  {
-    includeMatches = Config.includeMatches,
-    includeScore = Config.includeScore
-  } = {}
-) {
+function format(results, docs, {
+  includeMatches = Config.includeMatches,
+  includeScore = Config.includeScore
+} = {}) {
   const transformers = [];
-
   if (includeMatches) transformers.push(transformMatches);
   if (includeScore) transformers.push(transformScore);
-
-  return results.map((result) => {
-    const { idx } = result;
-
+  return results.map(result => {
+    const {
+      idx
+    } = result;
     const data = {
       item: docs[idx],
       refIndex: idx
     };
-
     if (transformers.length) {
-      transformers.forEach((transformer) => {
+      transformers.forEach(transformer => {
         transformer(result, data);
       });
     }
-
-    return data
-  })
+    return data;
+  });
 }
-
 class Fuse {
   constructor(docs, options = {}, index) {
-    this.options = { ...Config, ...options };
-
-    if (
-      this.options.useExtendedSearch &&
-      !true
-    ) {
-      throw new Error(EXTENDED_SEARCH_UNAVAILABLE)
+    this.options = {
+      ...Config,
+      ...options
+    };
+    if (this.options.useExtendedSearch && !true) {
+      throw new Error(EXTENDED_SEARCH_UNAVAILABLE);
     }
-
     this._keyStore = new KeyStore(this.options.keys);
-
     this.setCollection(docs, index);
   }
-
   setCollection(docs, index) {
     this._docs = docs;
-
     if (index && !(index instanceof FuseIndex)) {
-      throw new Error(INCORRECT_INDEX_TYPE)
+      throw new Error(INCORRECT_INDEX_TYPE);
     }
-
-    this._myIndex =
-      index ||
-      createIndex(this.options.keys, this._docs, {
-        getFn: this.options.getFn
-      });
+    this._myIndex = index || createIndex(this.options.keys, this._docs, {
+      getFn: this.options.getFn,
+      fieldNormWeight: this.options.fieldNormWeight
+    });
   }
-
   add(doc) {
     if (!isDefined(doc)) {
-      return
+      return;
     }
-
     this._docs.push(doc);
     this._myIndex.add(doc);
   }
-
-  remove(predicate = (/* doc, idx */) => false) {
+  remove(predicate = ( /* doc, idx */) => false) {
     const results = [];
-
     for (let i = 0, len = this._docs.length; i < len; i += 1) {
       const doc = this._docs[i];
       if (predicate(doc, i)) {
         this.removeAt(i);
         i -= 1;
         len -= 1;
-
         results.push(doc);
       }
     }
-
-    return results
+    return results;
   }
-
   removeAt(idx) {
     this._docs.splice(idx, 1);
     this._myIndex.removeAt(idx);
   }
-
   getIndex() {
-    return this._myIndex
+    return this._myIndex;
   }
-
-  search(query, { limit = -1 } = {}) {
+  search(query, {
+    limit = -1
+  } = {}) {
     const {
       includeMatches,
       includeScore,
@@ -1562,159 +1371,146 @@ class Fuse {
       sortFn,
       ignoreFieldNorm
     } = this.options;
-
-    let results = isString(query)
-      ? isString(this._docs[0])
-        ? this._searchStringList(query)
-        : this._searchObjectList(query)
-      : this._searchLogical(query);
-
-    computeScore$1(results, { ignoreFieldNorm });
-
+    let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
+    computeScore(results, {
+      ignoreFieldNorm
+    });
     if (shouldSort) {
       results.sort(sortFn);
     }
-
     if (isNumber(limit) && limit > -1) {
       results = results.slice(0, limit);
     }
-
     return format(results, this._docs, {
       includeMatches,
       includeScore
-    })
+    });
   }
-
   _searchStringList(query) {
     const searcher = createSearcher(query, this.options);
-    const { records } = this._myIndex;
+    const {
+      records
+    } = this._myIndex;
     const results = [];
 
     // Iterate over every string in the index
-    records.forEach(({ v: text, i: idx, n: norm }) => {
+    records.forEach(({
+      v: text,
+      i: idx,
+      n: norm
+    }) => {
       if (!isDefined(text)) {
-        return
+        return;
       }
-
-      const { isMatch, score, indices } = searcher.searchIn(text);
-
+      const {
+        isMatch,
+        score,
+        indices
+      } = searcher.searchIn(text);
       if (isMatch) {
         results.push({
           item: text,
           idx,
-          matches: [{ score, value: text, norm, indices }]
+          matches: [{
+            score,
+            value: text,
+            norm,
+            indices
+          }]
         });
       }
     });
-
-    return results
+    return results;
   }
-
   _searchLogical(query) {
-
     const expression = parse(query, this.options);
-
     const evaluate = (node, item, idx) => {
       if (!node.children) {
-        const { keyId, searcher } = node;
-
+        const {
+          keyId,
+          searcher
+        } = node;
         const matches = this._findMatches({
           key: this._keyStore.get(keyId),
           value: this._myIndex.getValueForItemAtKeyId(item, keyId),
           searcher
         });
-
         if (matches && matches.length) {
-          return [
-            {
-              idx,
-              item,
-              matches
-            }
-          ]
+          return [{
+            idx,
+            item,
+            matches
+          }];
         }
-
-        return []
+        return [];
       }
-
-      /*eslint indent: [2, 2, {"SwitchCase": 1}]*/
-      switch (node.operator) {
-        case LogicalOperator.AND: {
-          const res = [];
-          for (let i = 0, len = node.children.length; i < len; i += 1) {
-            const child = node.children[i];
-            const result = evaluate(child, item, idx);
-            if (result.length) {
-              res.push(...result);
-            } else {
-              return []
-            }
-          }
-          return res
-        }
-        case LogicalOperator.OR: {
-          const res = [];
-          for (let i = 0, len = node.children.length; i < len; i += 1) {
-            const child = node.children[i];
-            const result = evaluate(child, item, idx);
-            if (result.length) {
-              res.push(...result);
-              break
-            }
-          }
-          return res
+      const res = [];
+      for (let i = 0, len = node.children.length; i < len; i += 1) {
+        const child = node.children[i];
+        const result = evaluate(child, item, idx);
+        if (result.length) {
+          res.push(...result);
+        } else if (node.operator === LogicalOperator.AND) {
+          return [];
         }
       }
+      return res;
     };
-
     const records = this._myIndex.records;
     const resultMap = {};
     const results = [];
-
-    records.forEach(({ $: item, i: idx }) => {
+    records.forEach(({
+      $: item,
+      i: idx
+    }) => {
       if (isDefined(item)) {
         let expResults = evaluate(expression, item, idx);
-
         if (expResults.length) {
           // Dedupe when adding
           if (!resultMap[idx]) {
-            resultMap[idx] = { idx, item, matches: [] };
+            resultMap[idx] = {
+              idx,
+              item,
+              matches: []
+            };
             results.push(resultMap[idx]);
           }
-          expResults.forEach(({ matches }) => {
+          expResults.forEach(({
+            matches
+          }) => {
             resultMap[idx].matches.push(...matches);
           });
         }
       }
     });
-
-    return results
+    return results;
   }
-
   _searchObjectList(query) {
     const searcher = createSearcher(query, this.options);
-    const { keys, records } = this._myIndex;
+    const {
+      keys,
+      records
+    } = this._myIndex;
     const results = [];
 
     // List is Array<Object>
-    records.forEach(({ $: item, i: idx }) => {
+    records.forEach(({
+      $: item,
+      i: idx
+    }) => {
       if (!isDefined(item)) {
-        return
+        return;
       }
-
       let matches = [];
 
       // Iterate over every key (i.e, path), and fetch the value at that key
       keys.forEach((key, keyIndex) => {
-        matches.push(
-          ...this._findMatches({
-            key,
-            value: item[keyIndex],
-            searcher
-          })
-        );
+        matches.push(...this._findMatches({
+          key,
+          value: item[keyIndex],
+          searcher
+        }));
       });
-
       if (matches.length) {
         results.push({
           idx,
@@ -1723,24 +1519,31 @@ class Fuse {
         });
       }
     });
-
-    return results
+    return results;
   }
-  _findMatches({ key, value, searcher }) {
+  _findMatches({
+    key,
+    value,
+    searcher
+  }) {
     if (!isDefined(value)) {
-      return []
+      return [];
     }
-
     let matches = [];
-
     if (isArray(value)) {
-      value.forEach(({ v: text, i: idx, n: norm }) => {
+      value.forEach(({
+        v: text,
+        i: idx,
+        n: norm
+      }) => {
         if (!isDefined(text)) {
-          return
+          return;
         }
-
-        const { isMatch, score, indices } = searcher.searchIn(text);
-
+        const {
+          isMatch,
+          score,
+          indices
+        } = searcher.searchIn(text);
         if (isMatch) {
           matches.push({
             score,
@@ -1753,28 +1556,35 @@ class Fuse {
         }
       });
     } else {
-      const { v: text, n: norm } = value;
-
-      const { isMatch, score, indices } = searcher.searchIn(text);
-
+      const {
+        v: text,
+        n: norm
+      } = value;
+      const {
+        isMatch,
+        score,
+        indices
+      } = searcher.searchIn(text);
       if (isMatch) {
-        matches.push({ score, key, value: text, norm, indices });
+        matches.push({
+          score,
+          key,
+          value: text,
+          norm,
+          indices
+        });
       }
     }
-
-    return matches
+    return matches;
   }
 }
-
-Fuse.version = '6.4.6';
+Fuse.version = '6.6.2';
 Fuse.createIndex = createIndex;
 Fuse.parseIndex = parseIndex;
 Fuse.config = Config;
-
 {
   Fuse.parseQuery = parse;
 }
-
 {
   register(ExtendedSearch);
 }