@nova-design-system/nova-react 3.22.0 → 3.24.0

package/dist/cjs/i18n.utils-IlwlcG9l-ku0bScip.js

@@ -0,0 +1,2494 @@
+'use strict';
+
+/**
+ * @fileoverview Text normalization utilities for the search engine.
+ * Provides functions for normalizing and tokenizing text for search operations.
+ */
+/**
+ * Normalizes text for search comparison.
+ * - Converts to lowercase
+ * - Removes accents/diacritics
+ * - Replaces punctuation with spaces
+ * - Trims whitespace
+ * - Collapses multiple spaces into single space
+ *
+ * @param {string} text - The text to normalize
+ * @returns {string} The normalized text
+ *
+ * @example
+ * normalize('Système Grid') // 'systeme grid'
+ * normalize('Hello, World!') // 'hello world'
+ * normalize('  Multiple   Spaces  ') // 'multiple spaces'
+ */
+function normalize(text) {
+    if (!text)
+        return '';
+    return (text
+        // Convert to lowercase
+        .toLowerCase()
+        // Remove accents/diacritics using Unicode normalization
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        // Replace punctuation and special characters with spaces
+        .replace(/[^\w\s]/g, ' ')
+        // Collapse multiple spaces into single space
+        .replace(/\s+/g, ' ')
+        // Trim leading/trailing whitespace
+        .trim());
+}
+/**
+ * Tokenizes text into an array of normalized tokens.
+ * Splits by whitespace and normalizes each token.
+ *
+ * @param {string} text - The text to tokenize
+ * @returns {string[]} Array of normalized tokens
+ *
+ * @example
+ * tokenize('System Grid Control') // ['system', 'grid', 'control']
+ * tokenize('Hello, World!') // ['hello', 'world']
+ */
+function tokenize(text) {
+    const normalized = normalize(text);
+    if (!normalized)
+        return [];
+    return normalized.split(' ').filter(token => token.length > 0);
+}
+
+/**
+ * @fileoverview Guard functions for validating and clamping search parameters.
+ * Ensures safe limits for search operations to protect UI performance.
+ */
+/** Default maximum results to return */
+const DEFAULT_MAX_RESULTS = 25;
+/** Minimum allowed max results */
+const MIN_MAX_RESULTS = 10;
+/** Hard cap for max results - protects DOM from rendering too many items */
+const HARD_CAP_MAX_RESULTS = 500;
+/** Default threshold for offloading to Web Worker */
+const DEFAULT_WORKER_THRESHOLD = 2000;
+/** Minimum worker threshold (0 = always use worker) */
+const MIN_WORKER_THRESHOLD = 0;
+/** Maximum worker threshold */
+const MAX_WORKER_THRESHOLD = 50000;
+/** Default fuzzy threshold (0-1, lower = stricter) */
+const DEFAULT_FUZZY_THRESHOLD = 0.3;
+/** Debounce delay for fuzzy mode (ms) */
+const FUZZY_DEBOUNCE_DELAY = 300;
+/**
+ * Clamps the maxResults value to safe limits.
+ * - Minimum: 10
+ * - Default: 200
+ * - Hard cap: 500
+ *
+ * @param {number} [value] - The maxResults value to clamp (undefined uses default)
+ * @returns {number} The clamped maxResults value
+ *
+ * @example
+ * clampMaxResults(undefined) // 200 (default)
+ * clampMaxResults(5) // 10 (minimum)
+ * clampMaxResults(1000) // 500 (hard cap)
+ * clampMaxResults(100) // 100 (valid)
+ */
+function clampMaxResults(value) {
+    if (value === undefined || value === null) {
+        return DEFAULT_MAX_RESULTS;
+    }
+    if (value < MIN_MAX_RESULTS) {
+        return MIN_MAX_RESULTS;
+    }
+    if (value > HARD_CAP_MAX_RESULTS) {
+        return HARD_CAP_MAX_RESULTS;
+    }
+    return Math.floor(value);
+}
+/**
+ * Clamps the workerThreshold value to safe limits.
+ * - Minimum: 0 (always use worker)
+ * - Default: 2000
+ * - Maximum: 50000
+ *
+ * @param {number} [value] - The workerThreshold value to clamp (undefined uses default)
+ * @returns {number} The clamped workerThreshold value
+ *
+ * @example
+ * clampWorkerThreshold(undefined) // 2000 (default)
+ * clampWorkerThreshold(-100) // 0 (minimum)
+ * clampWorkerThreshold(100000) // 50000 (maximum)
+ * clampWorkerThreshold(5000) // 5000 (valid)
+ */
+function clampWorkerThreshold(value) {
+    if (value === undefined || value === null) {
+        return DEFAULT_WORKER_THRESHOLD;
+    }
+    if (value < MIN_WORKER_THRESHOLD) {
+        return MIN_WORKER_THRESHOLD;
+    }
+    if (value > MAX_WORKER_THRESHOLD) {
+        return MAX_WORKER_THRESHOLD;
+    }
+    return Math.floor(value);
+}
+/**
+ * Clamps the fuzzyThreshold value to valid range.
+ * - Minimum: 0 (strictest)
+ * - Default: 0.3
+ * - Maximum: 1 (most permissive)
+ *
+ * @param {number} [value] - The fuzzyThreshold value to clamp (undefined uses default)
+ * @returns {number} The clamped fuzzyThreshold value
+ *
+ * @example
+ * clampFuzzyThreshold(undefined) // 0.3 (default)
+ * clampFuzzyThreshold(-0.5) // 0 (minimum)
+ * clampFuzzyThreshold(1.5) // 1 (maximum)
+ * clampFuzzyThreshold(0.5) // 0.5 (valid)
+ */
+function clampFuzzyThreshold(value) {
+    if (value === undefined || value === null) {
+        return DEFAULT_FUZZY_THRESHOLD;
+    }
+    if (value < 0) {
+        return 0;
+    }
+    if (value > 1) {
+        return 1;
+    }
+    return value;
+}
+
+/**
+ * @fileoverview Indexing utilities for the search engine.
+ * Pre-computes normalized text and tokens for efficient searching.
+ */
+/**
+ * Builds a search index from raw items.
+ * Pre-computes normalized text and tokens for each item for efficient searching.
+ *
+ * @param {RawItem[]} items - Array of raw items with id and label
+ * @returns {IndexedItem[]} Array of indexed items with pre-computed norm and tokens
+ *
+ * @example
+ * const items = [
+ *   { id: '1', label: 'System Grid Control' },
+ *   { id: '2', label: 'Network Manager' }
+ * ];
+ * const indexed = buildIndex(items);
+ * // [
+ * //   { id: '1', label: 'System Grid Control', norm: 'system grid control', tokens: ['system', 'grid', 'control'] },
+ * //   { id: '2', label: 'Network Manager', norm: 'network manager', tokens: ['network', 'manager'] }
+ * // ]
+ */
+function buildIndex(items) {
+    if (!items || !Array.isArray(items)) {
+        return [];
+    }
+    return items.map(item => {
+        const norm = normalize(item.label);
+        return {
+            id: item.id,
+            label: item.label,
+            norm,
+            tokens: tokenize(item.label),
+        };
+    });
+}
+
+/**
+ * @fileoverview Strict search strategy using normalized substring matching.
+ * Fast and deterministic - best for IDs, codes, and references.
+ */
+/**
+ * Searches items using strict substring matching.
+ * The normalized query must be a substring of the normalized label.
+ *
+ * This is the fastest search mode but requires exact substring matches.
+ * Word order matters: "Grid System" won't match "System Grid".
+ *
+ * @param {IndexedItem[]} indexedItems - Array of pre-indexed items
+ * @param {string} query - The search query
+ * @returns {string[]} Array of matching item IDs
+ *
+ * @example
+ * // Given items: [{ id: '1', label: 'System Grid Control', norm: 'system grid control', tokens: [...] }]
+ * searchStrict(items, 'System Grid') // ['1'] - matches
+ * searchStrict(items, 'Grid Sys') // ['1'] - matches (substring)
+ * searchStrict(items, 'Grid System') // [] - no match (wrong order)
+ */
+function searchStrict(indexedItems, query) {
+    if (!query || !indexedItems?.length) {
+        return indexedItems?.map(item => item.id) || [];
+    }
+    const normalizedQuery = normalize(query);
+    if (!normalizedQuery) {
+        return indexedItems.map(item => item.id);
+    }
+    return indexedItems
+        .filter(item => item.norm.includes(normalizedQuery))
+        .map(item => item.id);
+}
+
+/**
+ * @fileoverview Smart search strategy using token-based matching.
+ * All query tokens must exist in the target label (order ignored).
+ */
+/**
+ * Searches items using token-based matching.
+ * All query tokens must exist in the item's normalized text (order ignored).
+ *
+ * This provides a "smart" feel without fuzzy matching overhead.
+ * Word order doesn't matter: "Grid System" will match "System Grid".
+ *
+ * @param {IndexedItem[]} indexedItems - Array of pre-indexed items
+ * @param {string} query - The search query
+ * @returns {string[]} Array of matching item IDs
+ *
+ * @example
+ * // Given items: [{ id: '1', label: 'System Grid Control', norm: 'system grid control', tokens: [...] }]
+ * searchSmart(items, 'System Grid') // ['1'] - matches (all tokens present)
+ * searchSmart(items, 'Grid System') // ['1'] - matches (order ignored)
+ * searchSmart(items, 'Grid Sys') // ['1'] - matches (partial tokens allowed as substrings)
+ * searchSmart(items, 'System Unknown') // [] - no match ('unknown' not present)
+ */
+function searchSmart(indexedItems, query) {
+    if (!query || !indexedItems?.length) {
+        return indexedItems?.map(item => item.id) || [];
+    }
+    const queryTokens = tokenize(query);
+    if (!queryTokens.length) {
+        return indexedItems.map(item => item.id);
+    }
+    return indexedItems
+        .filter(item => {
+        // All query tokens must be found as substrings in the normalized text
+        return queryTokens.every(queryToken => item.norm.includes(queryToken));
+    })
+        .map(item => item.id);
+}
+
+/**
+ * Fuse.js v7.0.0 - Lightweight fuzzy-search (http://fusejs.io)
+ *
+ * Copyright (c) 2023 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)
+}
+function baseToString(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value
+  }
+  let 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)
+}
+
+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 hasOwn = Object.prototype.hasOwnProperty;
+
+class KeyStore {
+  constructor(keys) {
+    this._keys = [];
+    this._keyMap = {};
+
+    let totalWeight = 0;
+
+    keys.forEach((key) => {
+      let obj = createKey(key);
+
+      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) => {
+      key.weight /= totalWeight;
+    });
+  }
+  get(keyId) {
+    return this._keyMap[keyId]
+  }
+  keys() {
+    return this._keys
+  }
+  toJSON() {
+    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'))
+    }
+
+    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))
+      }
+    }
+
+    path = createKeyPath(name);
+    id = createKeyId(name);
+    getFn = key.getFn;
+  }
+
+  return { path, id, weight, src, getFn }
+}
+
+function createKeyPath(key) {
+  return isArray(key) ? key : key.split('.')
+}
+
+function createKeyId(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
+    }
+    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
+      }
+
+      // 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 (let 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]
+}
+
+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.
+  // 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
+};
+
+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.
+  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: (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,
+  // 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
+};
+
+const 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,
+  // 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(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)
+      }
+
+      // 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
+    },
+    clear() {
+      cache.clear();
+    }
+  }
+}
+
+class FuseIndex {
+  constructor({
+    getFn = Config.getFn,
+    fieldNormWeight = Config.fieldNormWeight
+  } = {}) {
+    this.norm = norm(fieldNormWeight, 3);
+    this.getFn = getFn;
+    this.isCreated = false;
+
+    this.setIndexRecords();
+  }
+  setSources(docs = []) {
+    this.docs = docs;
+  }
+  setIndexRecords(records = []) {
+    this.records = records;
+  }
+  setKeys(keys = []) {
+    this.keys = keys;
+    this._keysMap = {};
+    keys.forEach((key, idx) => {
+      this._keysMap[key.id] = idx;
+    });
+  }
+  create() {
+    if (this.isCreated || !this.docs.length) {
+      return
+    }
+
+    this.isCreated = true;
+
+    // List is Array<String>
+    if (isString(this.docs[0])) {
+      this.docs.forEach((doc, docIndex) => {
+        this._addString(doc, docIndex);
+      });
+    } else {
+      // List is Array<Object>
+      this.docs.forEach((doc, docIndex) => {
+        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 {
+      this._addObject(doc, idx);
+    }
+  }
+  // Removes the doc at the specified index of the index
+  removeAt(idx) {
+    this.records.splice(idx, 1);
+
+    // Change ref index of every subsquent doc
+    for (let i = idx, len = this.size(); i < len; i += 1) {
+      this.records[i].i -= 1;
+    }
+  }
+  getValueForItemAtKeyId(item, keyId) {
+    return item[this._keysMap[keyId]]
+  }
+  size() {
+    return this.records.length
+  }
+  _addString(doc, docIndex) {
+    if (!isDefined(doc) || isBlank(doc)) {
+      return
+    }
+
+    let record = {
+      v: doc,
+      i: docIndex,
+      n: this.norm.get(doc)
+    };
+
+    this.records.push(record);
+  }
+  _addObject(doc, docIndex) {
+    let record = { i: docIndex, $: {} };
+
+    // Iterate over every key (i.e, path), and fetch the value at that key
+    this.keys.forEach((key, keyIndex) => {
+      let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
+
+      if (!isDefined(value)) {
+        return
+      }
+
+      if (isArray(value)) {
+        let subRecords = [];
+        const stack = [{ nestedArrIndex: -1, value }];
+
+        while (stack.length) {
+          const { nestedArrIndex, value } = stack.pop();
+
+          if (!isDefined(value)) {
+            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) => {
+              stack.push({
+                nestedArrIndex: k,
+                value: item
+              });
+            });
+          } else ;
+        }
+        record.$[keyIndex] = subRecords;
+      } 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, fieldNormWeight = Config.fieldNormWeight } = {}
+) {
+  const myIndex = new FuseIndex({ getFn, fieldNormWeight });
+  myIndex.setKeys(keys.map(createKey));
+  myIndex.setSources(docs);
+  myIndex.create();
+  return myIndex
+}
+
+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
+}
+
+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
+  }
+
+  const proximity = Math.abs(expectedLocation - currentLocation);
+
+  if (!distance) {
+    // Dodge divide by zero error.
+    return proximity ? 1.0 : accuracy
+  }
+
+  return accuracy + proximity / distance
+}
+
+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) {
+      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
+const MAX_BITS = 32;
+
+function search$1(
+  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))
+  }
+
+  const patternLen = pattern.length;
+  // Set starting location at beginning text and initialize the alphabet.
+  const textLen = text.length;
+  // Handle the case when location > text.length
+  const expectedLocation = Math.max(0, Math.min(location, textLen));
+  // Highest score beyond which we give up.
+  let currentThreshold = threshold;
+  // Is there a nearby exact match? (speedup)
+  let bestLocation = expectedLocation;
+
+  // Performance: only computer matches when the minMatchCharLength > 1
+  // OR if `includeMatches` is true.
+  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$1(pattern, {
+      currentLocation: index,
+      expectedLocation,
+      distance,
+      ignoreLocation
+    });
+
+    currentThreshold = Math.min(score, currentThreshold);
+    bestLocation = index + patternLen;
+
+    if (computeMatches) {
+      let i = 0;
+      while (i < patternLen) {
+        matchMask[index + i] = 1;
+        i += 1;
+      }
+    }
+  }
+
+  // Reset the best location
+  bestLocation = -1;
+
+  let lastBitArr = [];
+  let finalScore = 1;
+  let binMax = patternLen + textLen;
+
+  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$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;
+
+    // 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;
+
+      // Subsequent passes: fuzzy match
+      if (i) {
+        bitArr[j] |=
+          ((lastBitArr[j + 1] | lastBitArr[j]) << 1) | 1 | lastBitArr[j + 1];
+      }
+
+      if (bitArr[j] & mask) {
+        finalScore = computeScore$1(pattern, {
+          errors: i,
+          currentLocation,
+          expectedLocation,
+          distance,
+          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.
+    const score = computeScore$1(pattern, {
+      errors: i + 1,
+      currentLocation: expectedLocation,
+      expectedLocation,
+      distance,
+      ignoreLocation
+    });
+
+    if (score > currentThreshold) {
+      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) {
+      result.isMatch = false;
+    } else if (includeMatches) {
+      result.indices = indices;
+    }
+  }
+
+  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));
+  }
+
+  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
+    } = {}
+  ) {
+    this.options = {
+      location,
+      threshold,
+      distance,
+      includeMatches,
+      findAllMatches,
+      minMatchCharLength,
+      isCaseSensitive,
+      ignoreLocation
+    };
+
+    this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
+
+    this.chunks = [];
+
+    if (!this.pattern.length) {
+      return
+    }
+
+    const addChunk = (pattern, startIndex) => {
+      this.chunks.push({
+        pattern,
+        alphabet: createPatternAlphabet(pattern),
+        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);
+      }
+    } else {
+      addChunk(this.pattern, 0);
+    }
+  }
+
+  searchIn(text) {
+    const { isCaseSensitive, includeMatches } = this.options;
+
+    if (!isCaseSensitive) {
+      text = text.toLowerCase();
+    }
+
+    // Exact match
+    if (this.pattern === text) {
+      let result = {
+        isMatch: true,
+        score: 0
+      };
+
+      if (includeMatches) {
+        result.indices = [[0, text.length - 1]];
+      }
+
+      return result
+    }
+
+    // Otherwise, use Bitap algorithm
+    const {
+      location,
+      distance,
+      threshold,
+      findAllMatches,
+      minMatchCharLength,
+      ignoreLocation
+    } = this.options;
+
+    let allIndices = [];
+    let totalScore = 0;
+    let hasMatches = false;
+
+    this.chunks.forEach(({ pattern, alphabet, startIndex }) => {
+      const { isMatch, score, indices } = search$1(text, pattern, alphabet, {
+        location: location + startIndex,
+        distance,
+        threshold,
+        findAllMatches,
+        minMatchCharLength,
+        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
+  }
+}
+
+class BaseMatch {
+  constructor(pattern) {
+    this.pattern = pattern;
+  }
+  static isMultiMatch(pattern) {
+    return getMatch(pattern, this.multiRegex)
+  }
+  static isSingleMatch(pattern) {
+    return getMatch(pattern, this.singleRegex)
+  }
+  search(/*text*/) {}
+}
+
+function getMatch(pattern, exp) {
+  const matches = pattern.match(exp);
+  return matches ? matches[1] : null
+}
+
+// Token: 'file
+
+class ExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return 'exact'
+  }
+  static get multiRegex() {
+    return /^="(.*)"$/
+  }
+  static get singleRegex() {
+    return /^=(.*)$/
+  }
+  search(text) {
+    const isMatch = text === this.pattern;
+
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [0, this.pattern.length - 1]
+    }
+  }
+}
+
+// Token: !fire
+
+class InverseExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return 'inverse-exact'
+  }
+  static get multiRegex() {
+    return /^!"(.*)"$/
+  }
+  static get singleRegex() {
+    return /^!(.*)$/
+  }
+  search(text) {
+    const index = text.indexOf(this.pattern);
+    const isMatch = index === -1;
+
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [0, text.length - 1]
+    }
+  }
+}
+
+// Token: ^file
+
+class PrefixExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return 'prefix-exact'
+  }
+  static get multiRegex() {
+    return /^\^"(.*)"$/
+  }
+  static get singleRegex() {
+    return /^\^(.*)$/
+  }
+  search(text) {
+    const isMatch = text.startsWith(this.pattern);
+
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [0, this.pattern.length - 1]
+    }
+  }
+}
+
+// Token: !^fire
+
+class InversePrefixExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return 'inverse-prefix-exact'
+  }
+  static get multiRegex() {
+    return /^!\^"(.*)"$/
+  }
+  static get singleRegex() {
+    return /^!\^(.*)$/
+  }
+  search(text) {
+    const isMatch = !text.startsWith(this.pattern);
+
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [0, text.length - 1]
+    }
+  }
+}
+
+// Token: .file$
+
+class SuffixExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return 'suffix-exact'
+  }
+  static get multiRegex() {
+    return /^"(.*)"\$$/
+  }
+  static get singleRegex() {
+    return /^(.*)\$$/
+  }
+  search(text) {
+    const isMatch = text.endsWith(this.pattern);
+
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [text.length - this.pattern.length, text.length - 1]
+    }
+  }
+}
+
+// Token: !.file$
+
+class InverseSuffixExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return 'inverse-suffix-exact'
+  }
+  static get multiRegex() {
+    return /^!"(.*)"\$$/
+  }
+  static get singleRegex() {
+    return /^!(.*)\$$/
+  }
+  search(text) {
+    const isMatch = !text.endsWith(this.pattern);
+    return {
+      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
+    } = {}
+  ) {
+    super(pattern);
+    this._bitapSearch = new BitapSearch(pattern, {
+      location,
+      threshold,
+      distance,
+      includeMatches,
+      findAllMatches,
+      minMatchCharLength,
+      isCaseSensitive,
+      ignoreLocation
+    });
+  }
+  static get type() {
+    return 'fuzzy'
+  }
+  static get multiRegex() {
+    return /^"(.*)"$/
+  }
+  static get singleRegex() {
+    return /^(.*)$/
+  }
+  search(text) {
+    return this._bitapSearch.searchIn(text)
+  }
+}
+
+// Token: 'file
+
+class IncludeMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return 'include'
+  }
+  static get multiRegex() {
+    return /^'"(.*)"$/
+  }
+  static get singleRegex() {
+    return /^'(.*)$/
+  }
+  search(text) {
+    let location = 0;
+    let index;
+
+    const indices = [];
+    const patternLen = this.pattern.length;
+
+    // Get all exact matches
+    while ((index = text.indexOf(this.pattern, location)) > -1) {
+      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 searchersLen = searchers.length;
+
+// Regex to split by spaces, but keep anything in quotes together
+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());
+
+    let results = [];
+    for (let i = 0, len = query.length; i < len; i += 1) {
+      const queryItem = query[i];
+
+      // 1. Handle multiple query match (i.e, once that are quoted, like `"hello world"`)
+      let found = false;
+      let idx = -1;
+      while (!found && ++idx < searchersLen) {
+        const searcher = searchers[idx];
+        let 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) {
+        const searcher = searchers[idx];
+        let token = searcher.isSingleMatch(queryItem);
+        if (token) {
+          results.push(new searcher(token, options));
+          break
+        }
+      }
+    }
+
+    return results
+  })
+}
+
+// These extended matchers can return an array of matches, as opposed
+// to a singl match
+const 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$
+ * ```
+ */
+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
+    } = {}
+  ) {
+    this.query = null;
+    this.options = {
+      isCaseSensitive,
+      includeMatches,
+      minMatchCharLength,
+      findAllMatches,
+      ignoreLocation,
+      location,
+      threshold,
+      distance
+    };
+
+    this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
+    this.query = parseQuery(this.pattern, this.options);
+  }
+
+  static condition(_, options) {
+    return options.useExtendedSearch
+  }
+
+  searchIn(text) {
+    const query = this.query;
+
+    if (!query) {
+      return {
+        isMatch: false,
+        score: 1
+      }
+    }
+
+    const { includeMatches, isCaseSensitive } = this.options;
+
+    text = isCaseSensitive ? text : text.toLowerCase();
+
+    let numMatches = 0;
+    let allIndices = [];
+    let totalScore = 0;
+
+    // ORs
+    for (let i = 0, qLen = query.length; i < qLen; i += 1) {
+      const searchers = query[i];
+
+      // Reset indices
+      allIndices.length = 0;
+      numMatches = 0;
+
+      // ANDs
+      for (let j = 0, pLen = searchers.length; j < pLen; j += 1) {
+        const searcher = searchers[j];
+        const { isMatch, indices, score } = searcher.search(text);
+
+        if (isMatch) {
+          numMatches += 1;
+          totalScore += score;
+          if (includeMatches) {
+            const type = searcher.constructor.type;
+            if (MultiMatchSet.has(type)) {
+              allIndices = [...allIndices, ...indices];
+            } else {
+              allIndices.push(indices);
+            }
+          }
+        } else {
+          totalScore = 0;
+          numMatches = 0;
+          allIndices.length = 0;
+          break
+        }
+      }
+
+      // OR condition, so if TRUE, return
+      if (numMatches) {
+        let result = {
+          isMatch: true,
+          score: totalScore / numMatches
+        };
+
+        if (includeMatches) {
+          result.indices = allIndices;
+        }
+
+        return result
+      }
+    }
+
+    // Nothing was matched
+    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 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) => ({
+    [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) => {
+    let keys = Object.keys(query);
+
+    const isQueryPath = isPath(query);
+
+    if (!isQueryPath && keys.length > 1 && !isExpression(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))
+      }
+
+      const obj = {
+        keyId: createKeyId(key),
+        pattern
+      };
+
+      if (auto) {
+        obj.searcher = createSearcher(pattern, options);
+      }
+
+      return obj
+    }
+
+    let node = {
+      children: [],
+      operator: keys[0]
+    };
+
+    keys.forEach((key) => {
+      const value = query[key];
+
+      if (isArray(value)) {
+        value.forEach((item) => {
+          node.children.push(next(item));
+        });
+      }
+    });
+
+    return node
+  };
+
+  if (!isExpression(query)) {
+    query = convertToExplicit(query);
+  }
+
+  return next(query)
+}
+
+// Practical scoring function
+function computeScore(
+  results,
+  { ignoreFieldNorm = Config.ignoreFieldNorm }
+) {
+  results.forEach((result) => {
+    let totalScore = 1;
+
+    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)
+      );
+    });
+
+    result.score = totalScore;
+  });
+}
+
+function transformMatches(result, data) {
+  const matches = result.matches;
+  data.matches = [];
+
+  if (!isDefined(matches)) {
+    return
+  }
+
+  matches.forEach((match) => {
+    if (!isDefined(match.indices) || !match.indices.length) {
+      return
+    }
+
+    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
+  } = {}
+) {
+  const transformers = [];
+
+  if (includeMatches) transformers.push(transformMatches);
+  if (includeScore) transformers.push(transformScore);
+
+  return results.map((result) => {
+    const { idx } = result;
+
+    const data = {
+      item: docs[idx],
+      refIndex: idx
+    };
+
+    if (transformers.length) {
+      transformers.forEach((transformer) => {
+        transformer(result, data);
+      });
+    }
+
+    return data
+  })
+}
+
+class Fuse {
+  constructor(docs, options = {}, index) {
+    this.options = { ...Config, ...options };
+
+    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)
+    }
+
+    this._myIndex =
+      index ||
+      createIndex(this.options.keys, this._docs, {
+        getFn: this.options.getFn,
+        fieldNormWeight: this.options.fieldNormWeight
+      });
+  }
+
+  add(doc) {
+    if (!isDefined(doc)) {
+      return
+    }
+
+    this._docs.push(doc);
+    this._myIndex.add(doc);
+  }
+
+  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
+  }
+
+  removeAt(idx) {
+    this._docs.splice(idx, 1);
+    this._myIndex.removeAt(idx);
+  }
+
+  getIndex() {
+    return this._myIndex
+  }
+
+  search(query, { limit = -1 } = {}) {
+    const {
+      includeMatches,
+      includeScore,
+      shouldSort,
+      sortFn,
+      ignoreFieldNorm
+    } = this.options;
+
+    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 results = [];
+
+    // Iterate over every string in the index
+    records.forEach(({ v: text, i: idx, n: norm }) => {
+      if (!isDefined(text)) {
+        return
+      }
+
+      const { isMatch, score, indices } = searcher.searchIn(text);
+
+      if (isMatch) {
+        results.push({
+          item: text,
+          idx,
+          matches: [{ score, value: text, norm, indices }]
+        });
+      }
+    });
+
+    return results
+  }
+
+  _searchLogical(query) {
+
+    const expression = parse(query, this.options);
+
+    const evaluate = (node, item, idx) => {
+      if (!node.children) {
+        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 []
+      }
+
+      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 }) => {
+      if (isDefined(item)) {
+        let expResults = evaluate(expression, item, idx);
+
+        if (expResults.length) {
+          // Dedupe when adding
+          if (!resultMap[idx]) {
+            resultMap[idx] = { idx, item, matches: [] };
+            results.push(resultMap[idx]);
+          }
+          expResults.forEach(({ matches }) => {
+            resultMap[idx].matches.push(...matches);
+          });
+        }
+      }
+    });
+
+    return results
+  }
+
+  _searchObjectList(query) {
+    const searcher = createSearcher(query, this.options);
+    const { keys, records } = this._myIndex;
+    const results = [];
+
+    // List is Array<Object>
+    records.forEach(({ $: item, i: idx }) => {
+      if (!isDefined(item)) {
+        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
+          })
+        );
+      });
+
+      if (matches.length) {
+        results.push({
+          idx,
+          item,
+          matches
+        });
+      }
+    });
+
+    return results
+  }
+  _findMatches({ key, value, searcher }) {
+    if (!isDefined(value)) {
+      return []
+    }
+
+    let matches = [];
+
+    if (isArray(value)) {
+      value.forEach(({ v: text, i: idx, n: norm }) => {
+        if (!isDefined(text)) {
+          return
+        }
+
+        const { isMatch, score, indices } = searcher.searchIn(text);
+
+        if (isMatch) {
+          matches.push({
+            score,
+            key,
+            value: text,
+            idx,
+            norm,
+            indices
+          });
+        }
+      });
+    } else {
+      const { v: text, n: norm } = value;
+
+      const { isMatch, score, indices } = searcher.searchIn(text);
+
+      if (isMatch) {
+        matches.push({ score, key, value: text, norm, indices });
+      }
+    }
+
+    return matches
+  }
+}
+
+Fuse.version = '7.0.0';
+Fuse.createIndex = createIndex;
+Fuse.parseIndex = parseIndex;
+Fuse.config = Config;
+
+{
+  Fuse.parseQuery = parse;
+}
+
+{
+  register(ExtendedSearch);
+}
+
+/**
+ * @fileoverview Fuzzy search strategy using Fuse.js.
+ * Typo-tolerant matching for user-friendly search experience.
+ */
+/** Cache for Fuse instances to avoid recreation on every search */
+let fuseCache = null;
+/**
+ * Gets or creates a Fuse.js instance for the given items.
+ * Caches the instance to improve performance for repeated searches.
+ * Recreates if items or threshold change.
+ * @param {IndexedItem[]} items - Array of pre-indexed items
+ * @param {number} threshold - Fuzzy threshold (0-1, lower = stricter, default 0.3)
+ * @returns {Fuse<IndexedItem>} Fuse.js instance
+ */
+function getFuseInstance(items, threshold) {
+    // Check if we can reuse cached instance (same items AND same threshold)
+    if (fuseCache &&
+        fuseCache.items === items &&
+        fuseCache.threshold === threshold) {
+        return fuseCache.fuse;
+    }
+    // Create new Fuse instance
+    const fuse = new Fuse(items, {
+        keys: ['label', 'norm'],
+        threshold: threshold,
+        includeScore: true,
+        ignoreLocation: true,
+        findAllMatches: true,
+    });
+    // Cache for reuse
+    fuseCache = { items, threshold, fuse };
+    return fuse;
+}
+/**
+ * Searches items using fuzzy matching with Fuse.js.
+ * Tolerates typos and finds approximate matches.
+ *
+ * @param {IndexedItem[]} indexedItems - Array of pre-indexed items
+ * @param {string} query - The search query
+ * @param {number} threshold - Fuzzy threshold (0-1, lower = stricter, default 0.3)
+ * @returns {string[]} Array of matching item IDs sorted by relevance
+ * @example
+ * // Given items: [{ id: '1', label: 'System Grid Control', ... }]
+ * searchFuzzy(items, 'Sytem') // ['1'] - matches despite typo
+ * searchFuzzy(items, 'Systm Grid') // ['1'] - matches despite typo
+ */
+function searchFuzzy(indexedItems, query, threshold = 0.3) {
+    if (!query || !indexedItems?.length) {
+        return indexedItems?.map(item => item.id) || [];
+    }
+    const fuse = getFuseInstance(indexedItems, threshold);
+    const results = fuse.search(query);
+    // Return IDs sorted by relevance (best matches first)
+    return results.map(result => result.item.id);
+}
+
+/**
+ * @fileoverview Main search engine that orchestrates search operations.
+ * Provides a unified interface for all filter modes.
+ */
+/**
+ * Default search options.
+ */
+const DEFAULT_OPTIONS = {
+    filterMode: 'strict',
+    startFilterAt: 0,
+};
+/**
+ * Main search function that applies the appropriate strategy based on filter mode.
+ *
+ * @param {IndexedItem[]} indexedItems - Array of pre-indexed items
+ * @param {SearchOptions} options - Search options including query, filterMode, maxResults
+ * @returns {SearchResult} Search result with matching IDs, total count, and truncation flag
+ *
+ * @example
+ * const result = search(indexedItems, {
+ *   query: 'System Grid',
+ *   filterMode: 'smart',
+ *   maxResults: 100
+ * });
+ * // { ids: ['1', '2', '3'], total: 3, truncated: false }
+ */
+function search(indexedItems, options) {
+    const { query, filterMode = DEFAULT_OPTIONS.filterMode, maxResults: rawMaxResults, startFilterAt = DEFAULT_OPTIONS.startFilterAt, fuzzyThreshold: rawFuzzyThreshold, } = options;
+    // Apply guards
+    const maxResults = clampMaxResults(rawMaxResults);
+    const fuzzyThreshold = clampFuzzyThreshold(rawFuzzyThreshold);
+    // If query is too short, return all items (up to maxResults)
+    if (!query || query.length < startFilterAt) {
+        const allIds = indexedItems.map(item => item.id);
+        const truncated = allIds.length > maxResults;
+        return {
+            ids: allIds.slice(0, maxResults),
+            total: allIds.length,
+            truncated,
+        };
+    }
+    // Apply the appropriate search strategy
+    let matchingIds;
+    switch (filterMode) {
+        case 'strict':
+            matchingIds = searchStrict(indexedItems, query);
+            break;
+        case 'smart':
+            matchingIds = searchSmart(indexedItems, query);
+            break;
+        case 'fuzzy':
+            // Fuzzy search using Fuse.js on main thread
+            matchingIds = searchFuzzy(indexedItems, query, fuzzyThreshold);
+            break;
+        default:
+            matchingIds = searchStrict(indexedItems, query);
+    }
+    // Apply maxResults limit
+    const total = matchingIds.length;
+    const truncated = total > maxResults;
+    const limitedIds = truncated ? matchingIds.slice(0, maxResults) : matchingIds;
+    return {
+        ids: limitedIds,
+        total,
+        truncated,
+    };
+}
+/**
+ * Determines if filtering should be offloaded to a Web Worker.
+ *
+ * @param {number} itemCount - Number of items to search
+ * @param {FilterMode} filterMode - Current filter mode
+ * @param {number} workerThreshold - Threshold for offloading to worker
+ * @returns {boolean} True if filtering should use Web Worker
+ */
+function shouldUseWorker(itemCount, filterMode, workerThreshold) {
+    // Fuzzy mode always requires worker (Fuse.js runs there)
+    if (filterMode === 'fuzzy') {
+        return true;
+    }
+    // Large datasets should use worker to keep main thread responsive
+    return itemCount > workerThreshold;
+}
+/**
+ * Checks if Web Workers are supported in the current environment.
+ *
+ * @returns {boolean} True if Web Workers are supported
+ */
+function isWorkerSupported() {
+    return typeof Worker !== 'undefined';
+}
+/**
+ * Gets the effective filter mode, falling back if necessary.
+ * If fuzzy mode is requested but Workers aren't supported, falls back to smart.
+ *
+ * @param {FilterMode} requestedMode - The requested filter mode
+ * @returns {FilterMode} The effective filter mode to use
+ */
+function getEffectiveFilterMode(requestedMode) {
+    if (requestedMode === 'fuzzy' && !isWorkerSupported()) {
+        console.warn('Web Workers not supported. Falling back from fuzzy to smart mode.');
+        return 'smart';
+    }
+    return requestedMode;
+}
+
+/**
+ * @fileoverview Client for communicating with the search Web Worker.
+ * Provides a clean async API for search operations.
+ */
+/**
+ * Client for managing search operations via Web Worker.
+ * Handles worker lifecycle, request tracking, and fallback behavior.
+ */
+class SearchWorkerClient {
+    /**
+     * Creates a new SearchWorkerClient.
+     * @param {string} [workerUrl] - URL to the worker script (optional, uses inline worker if not provided)
+     */
+    constructor(workerUrl) {
+        this.workerUrl = workerUrl;
+        this.worker = null;
+        this.pendingRequests = new Map();
+        this.requestCounter = 0;
+        this.isInitialized = false;
+        this.initPromise = null;
+        /** Flag indicating if fallback mode is active (no worker available) */
+        this.isFallbackMode = false;
+    }
+    /**
+     * Checks if Web Workers are supported in the current environment.
+     * @returns {boolean} True if Web Workers are supported
+     */
+    static isSupported() {
+        return typeof Worker !== 'undefined';
+    }
+    /**
+     * Generates a unique request ID.
+     * @returns {string} A unique request ID
+     */
+    generateRequestId() {
+        return `req-${++this.requestCounter}-${Date.now()}`;
+    }
+    /**
+     * Creates and initializes the worker.
+     * Note: Workers require a workerUrl to be provided. Inline workers are not
+     * supported due to ES module limitations with importScripts.
+     * @returns {Worker | null} The created Worker instance or null if creation failed
+     */
+    createWorker() {
+        if (!SearchWorkerClient.isSupported()) {
+            console.warn('Web Workers are not supported in this environment.');
+            this.onFallback?.();
+            return null;
+        }
+        try {
+            if (this.workerUrl) {
+                return new Worker(this.workerUrl, { type: 'module' });
+            }
+            // No workerUrl provided - fallback to main thread processing
+            // Inline workers with ES modules are not supported
+            console.warn('No workerUrl provided. Falling back to main thread processing.');
+            this.onFallback?.();
+            return null;
+        }
+        catch (error) {
+            console.error('Failed to create Web Worker:', error);
+            this.onFallback?.();
+            return null;
+        }
+    }
+    /**
+     * Sets up message handlers for the worker.
+     */
+    setupMessageHandler() {
+        if (!this.worker)
+            return;
+        this.worker.onmessage = (event) => {
+            const { requestId, type, payload } = event.data;
+            const pending = this.pendingRequests.get(requestId);
+            if (!pending) {
+                console.warn(`Received response for unknown request: ${requestId}`);
+                return;
+            }
+            this.pendingRequests.delete(requestId);
+            if (type === 'ERROR') {
+                pending.reject(new Error(payload.error));
+            }
+            else {
+                pending.resolve(payload);
+            }
+        };
+        this.worker.onerror = (error) => {
+            console.error('Worker error:', error);
+            // Reject all pending requests
+            this.pendingRequests.forEach(pending => {
+                pending.reject(new Error('Worker error'));
+            });
+            this.pendingRequests.clear();
+        };
+    }
+    /**
+     * Sends a request to the worker and returns a promise for the result.
+     * @param {WorkerRequest} request - The request object to send to the worker
+     * @returns {Promise<SearchResult>} Promise that resolves to the search result
+     */
+    sendRequest(request) {
+        return new Promise((resolve, reject) => {
+            if (!this.worker) {
+                reject(new Error('Worker not initialized'));
+                return;
+            }
+            this.pendingRequests.set(request.requestId, { resolve, reject });
+            this.worker.postMessage(request);
+        });
+    }
+    /**
+     * Initializes the worker with items to search.
+     * @param {RawItem[]} items - Array of items to index
+     * @returns {Promise<void>} Promise that resolves when initialization is complete
+     */
+    async init(items) {
+        // If already initializing, wait for it
+        if (this.initPromise) {
+            await this.initPromise;
+            // Re-init with new items
+        }
+        this.initPromise = this.doInit(items);
+        await this.initPromise;
+    }
+    async doInit(items) {
+        // If already in fallback mode, don't try to create worker again
+        if (this.isFallbackMode) {
+            return;
+        }
+        // Create worker if not exists
+        if (!this.worker) {
+            this.worker = this.createWorker();
+            if (!this.worker) {
+                // Worker creation failed - enter fallback mode silently
+                this.isFallbackMode = true;
+                this.onFallback?.();
+                return;
+            }
+            this.setupMessageHandler();
+        }
+        const requestId = this.generateRequestId();
+        try {
+            await this.sendRequest({
+                type: 'INIT',
+                requestId,
+                payload: { items },
+            });
+            this.isInitialized = true;
+        }
+        catch {
+            // Worker init failed - enter fallback mode
+            this.isFallbackMode = true;
+            this.onFallback?.();
+            this.terminate();
+        }
+    }
+    /**
+     * Performs a search operation.
+     * @param {string} query - Search query string
+     * @param {FilterMode} filterMode - Filter mode (strict/smart/fuzzy)
+     * @param {number} maxResults - Maximum results to return
+     * @param {number} fuzzyThreshold - Threshold for fuzzy matching
+     * @returns {Promise<SearchResult>} Promise resolving to search results
+     */
+    async search(query, filterMode = 'strict', maxResults = DEFAULT_MAX_RESULTS, fuzzyThreshold = DEFAULT_FUZZY_THRESHOLD) {
+        if (!this.isInitialized || !this.worker) {
+            throw new Error('Worker not initialized. Call init() first.');
+        }
+        const requestId = this.generateRequestId();
+        return this.sendRequest({
+            type: 'SEARCH',
+            requestId,
+            payload: {
+                query,
+                filterMode,
+                maxResults: clampMaxResults(maxResults),
+                fuzzyThreshold: clampFuzzyThreshold(fuzzyThreshold),
+            },
+        });
+    }
+    /**
+     * Cancels all pending requests.
+     */
+    cancelPending() {
+        this.pendingRequests.forEach(pending => {
+            pending.reject(new Error('Request cancelled'));
+        });
+        this.pendingRequests.clear();
+    }
+    /**
+     * Terminates the worker and cleans up resources.
+     */
+    terminate() {
+        this.cancelPending();
+        this.worker?.terminate();
+        this.worker = null;
+        this.isInitialized = false;
+        this.initPromise = null;
+        // Note: we don't reset isFallbackMode here to avoid retrying worker creation
+    }
+    /**
+     * Returns whether the worker is ready to perform searches.
+     * @returns {boolean} True if the worker is initialized and ready
+     */
+    get isReady() {
+        return this.isInitialized && this.worker !== null;
+    }
+    /**
+     * Returns whether the client is in fallback mode (no worker available).
+     * @returns {boolean} True if the client is operating in fallback mode
+     */
+    get inFallbackMode() {
+        return this.isFallbackMode;
+    }
+}
+
+/**
+ * @fileoverview Internationalization utilities for Nova components.
+ * Provides automatic locale detection and default translations.
+ */
+/**
+ * Default translations for truncated results text.
+ * Supports placeholders: {shown} and {total}
+ */
+const TRUNCATED_RESULTS_TRANSLATIONS = {
+    en: '{shown} results shown out of {total} — refine your search',
+    fr: '{shown} résultats affichés sur {total} — affinez votre recherche',
+    de: '{shown} von {total} Ergebnissen angezeigt — verfeinern Sie Ihre Suche',
+    es: '{shown} resultados mostrados de {total} — refine su búsqueda',
+    it: '{shown} risultati mostrati su {total} — perfeziona la tua ricerca',
+    nl: '{shown} resultaten getoond van {total} — verfijn uw zoekopdracht',
+    pt: '{shown} resultados exibidos de {total} — refine sua pesquisa',
+    ru: '{shown} результатов показано из {total} — уточните поиск',
+    ja: '{shown}件の結果が{total}件中表示されています — 検索を絞り込んでください',
+    zh: '{shown}个结果，共{total}个 — 请细化您的搜索',
+    ko: '{shown}개 결과가 {total}개 중 표시됨 — 검색을 구체화하세요',
+};
+/**
+ * Gets the browser's locale (language code).
+ * Falls back to 'en' if detection fails.
+ *
+ * @returns {string} The locale code (e.g., 'en', 'fr', 'de')
+ */
+function getBrowserLocale() {
+    if (typeof navigator === 'undefined') {
+        return 'en';
+    }
+    // Try navigator.language first (e.g., 'en-US', 'fr-FR')
+    const language = navigator.language || navigator.languages?.[0] || 'en';
+    // Extract the base language code (e.g., 'en' from 'en-US')
+    return language.split('-')[0].toLowerCase();
+}
+/**
+ * Gets the localized truncated results text.
+ * Automatically detects browser locale and provides appropriate translation.
+ * Falls back to English if translation is not available.
+ *
+ * @param {string} [locale] - Optional locale override. If not provided, uses browser locale.
+ * @returns {string} The localized text with placeholders {shown} and {total}
+ *
+ * @example
+ * getTruncatedResultsText() // Uses browser locale
+ * getTruncatedResultsText('fr') // Returns French translation
+ * getTruncatedResultsText('de') // Returns German translation
+ */
+function getTruncatedResultsText(locale) {
+    const targetLocale = locale
+        ? locale.split('-')[0].toLowerCase()
+        : getBrowserLocale();
+    return (TRUNCATED_RESULTS_TRANSLATIONS[targetLocale] ||
+        TRUNCATED_RESULTS_TRANSLATIONS.en);
+}
+/**
+ * Formats the truncated results text by replacing placeholders with actual values.
+ *
+ * @param {string} template - The text template with {shown} and {total} placeholders
+ * @param {number} shown - The number of items shown
+ * @param {number} total - The total number of items
+ * @returns {string} The formatted text with replaced placeholders
+ *
+ * @example
+ * formatTruncatedResults('{shown} of {total}', 10, 100) // '10 of 100'
+ */
+function formatTruncatedResults(template, shown, total) {
+    return template
+        .replace(/{shown}/g, String(shown))
+        .replace(/{total}/g, String(total));
+}
+
+exports.FUZZY_DEBOUNCE_DELAY = FUZZY_DEBOUNCE_DELAY;
+exports.SearchWorkerClient = SearchWorkerClient;
+exports.buildIndex = buildIndex;
+exports.clampMaxResults = clampMaxResults;
+exports.clampWorkerThreshold = clampWorkerThreshold;
+exports.formatTruncatedResults = formatTruncatedResults;
+exports.getEffectiveFilterMode = getEffectiveFilterMode;
+exports.getTruncatedResultsText = getTruncatedResultsText;
+exports.isWorkerSupported = isWorkerSupported;
+exports.search = search;
+exports.shouldUseWorker = shouldUseWorker;