@nova-design-system/nova-webcomponents 3.24.0 → 3.26.0

package/dist/esm/i18n.utils-IlwlcG9l.js

@@ -1,2485 +0,0 @@
-/**
- * @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));
-}
-
-export { FUZZY_DEBOUNCE_DELAY as F, SearchWorkerClient as S, search as a, buildIndex as b, clampMaxResults as c, getTruncatedResultsText as d, clampWorkerThreshold as e, formatTruncatedResults as f, getEffectiveFilterMode as g, isWorkerSupported as i, shouldUseWorker as s };
-//# sourceMappingURL=i18n.utils-IlwlcG9l.js.map
-
-//# sourceMappingURL=i18n.utils-IlwlcG9l.js.map