tom-select-rails 2.3.1 → 2.4.3

data/vendor/assets/javascripts/tom-select-rails/js/tom-select.base.js

@@ -1,5 +1,5 @@
 /**
-* Tom Select v2.3.1
+* Tom Select v2.4.3
 * Licensed under the Apache License, Version 2.0 (the "License");
 */
 
@@ -30,7 +30,6 @@
 	}
 	class MicroEvent {
 	  constructor() {
-	    this._events = void 0;
 	    this._events = {};
 	  }
 	  on(events, fct) {
@@ -179,390 +178,271 @@
 	  };
 	}
 
-	/*! @orchidjs/unicode-variants | https://github.com/orchidjs/unicode-variants | Apache License (v2) */
 	/**
 	 * Convert array of strings to a regular expression
 	 *	ex ['ab','a'] => (?:ab|a)
 	 * 	ex ['a','b'] => [ab]
-	 * @param {string[]} chars
-	 * @return {string}
 	 */
-	const arrayToPattern = chars => {
-	  chars = chars.filter(Boolean);
-
-	  if (chars.length < 2) {
-	    return chars[0] || '';
-	  }
-
-	  return maxValueLength(chars) == 1 ? '[' + chars.join('') + ']' : '(?:' + chars.join('|') + ')';
-	};
-	/**
-	 * @param {string[]} array
-	 * @return {string}
-	 */
-
-	const sequencePattern = array => {
-	  if (!hasDuplicates(array)) {
-	    return array.join('');
-	  }
-
-	  let pattern = '';
-	  let prev_char_count = 0;
-
-	  const prev_pattern = () => {
-	    if (prev_char_count > 1) {
-	      pattern += '{' + prev_char_count + '}';
+	const arrayToPattern = (chars) => {
+	    chars = chars.filter(Boolean);
+	    if (chars.length < 2) {
+	        return chars[0] || '';
 	    }
-	  };
-
-	  array.forEach((char, i) => {
-	    if (char === array[i - 1]) {
-	      prev_char_count++;
-	      return;
-	    }
-
+	    return (maxValueLength(chars) == 1) ? '[' + chars.join('') + ']' : '(?:' + chars.join('|') + ')';
+	};
+	const sequencePattern = (array) => {
+	    if (!hasDuplicates(array)) {
+	        return array.join('');
+	    }
+	    let pattern = '';
+	    let prev_char_count = 0;
+	    const prev_pattern = () => {
+	        if (prev_char_count > 1) {
+	            pattern += '{' + prev_char_count + '}';
+	        }
+	    };
+	    array.forEach((char, i) => {
+	        if (char === array[i - 1]) {
+	            prev_char_count++;
+	            return;
+	        }
+	        prev_pattern();
+	        pattern += char;
+	        prev_char_count = 1;
+	    });
 	    prev_pattern();
-	    pattern += char;
-	    prev_char_count = 1;
-	  });
-	  prev_pattern();
-	  return pattern;
+	    return pattern;
 	};
 	/**
 	 * Convert array of strings to a regular expression
 	 *	ex ['ab','a'] => (?:ab|a)
 	 * 	ex ['a','b'] => [ab]
-	 * @param {Set<string>} chars
-	 * @return {string}
 	 */
-
-	const setToPattern = chars => {
-	  let array = toArray(chars);
-	  return arrayToPattern(array);
+	const setToPattern = (chars) => {
+	    let array = Array.from(chars);
+	    return arrayToPattern(array);
 	};
 	/**
-	 *
 	 * https://stackoverflow.com/questions/7376598/in-javascript-how-do-i-check-if-an-array-has-duplicate-values
-	 * @param {any[]} array
 	 */
-
-	const hasDuplicates = array => {
-	  return new Set(array).size !== array.length;
+	const hasDuplicates = (array) => {
+	    return (new Set(array)).size !== array.length;
 	};
 	/**
 	 * https://stackoverflow.com/questions/63006601/why-does-u-throw-an-invalid-escape-error
-	 * @param {string} str
-	 * @return {string}
 	 */
-
-	const escape_regex = str => {
-	  return (str + '').replace(/([\$\(\)\*\+\.\?\[\]\^\{\|\}\\])/gu, '\\$1');
+	const escape_regex = (str) => {
+	    return (str + '').replace(/([\$\(\)\*\+\.\?\[\]\^\{\|\}\\])/gu, '\\$1');
 	};
 	/**
 	 * Return the max length of array values
-	 * @param {string[]} array
-	 *
 	 */
-
-	const maxValueLength = array => {
-	  return array.reduce((longest, value) => Math.max(longest, unicodeLength(value)), 0);
+	const maxValueLength = (array) => {
+	    return array.reduce((longest, value) => Math.max(longest, unicodeLength(value)), 0);
 	};
-	/**
-	 * @param {string} str
-	 */
-
-	const unicodeLength = str => {
-	  return toArray(str).length;
+	const unicodeLength = (str) => {
+	    return Array.from(str).length;
 	};
-	/**
-	 * @param {any} p
-	 * @return {any[]}
-	 */
-
-	const toArray = p => Array.from(p);
 
-	/*! @orchidjs/unicode-variants | https://github.com/orchidjs/unicode-variants | Apache License (v2) */
 	/**
 	 * Get all possible combinations of substrings that add up to the given string
 	 * https://stackoverflow.com/questions/30169587/find-all-the-combination-of-substrings-that-add-up-to-the-given-string
-	 * @param {string} input
-	 * @return {string[][]}
 	 */
-	const allSubstrings = input => {
-	  if (input.length === 1) return [[input]];
-	  /** @type {string[][]} */
-
-	  let result = [];
-	  const start = input.substring(1);
-	  const suba = allSubstrings(start);
-	  suba.forEach(function (subresult) {
-	    let tmp = subresult.slice(0);
-	    tmp[0] = input.charAt(0) + tmp[0];
-	    result.push(tmp);
-	    tmp = subresult.slice(0);
-	    tmp.unshift(input.charAt(0));
-	    result.push(tmp);
-	  });
-	  return result;
+	const allSubstrings = (input) => {
+	    if (input.length === 1)
+	        return [[input]];
+	    let result = [];
+	    const start = input.substring(1);
+	    const suba = allSubstrings(start);
+	    suba.forEach(function (subresult) {
+	        let tmp = subresult.slice(0);
+	        tmp[0] = input.charAt(0) + tmp[0];
+	        result.push(tmp);
+	        tmp = subresult.slice(0);
+	        tmp.unshift(input.charAt(0));
+	        result.push(tmp);
+	    });
+	    return result;
 	};
 
-	/*! @orchidjs/unicode-variants | https://github.com/orchidjs/unicode-variants | Apache License (v2) */
-
-	/**
-	 * @typedef {{[key:string]:string}} TUnicodeMap
-	 * @typedef {{[key:string]:Set<string>}} TUnicodeSets
-	 * @typedef {[[number,number]]} TCodePoints
-	 * @typedef {{folded:string,composed:string,code_point:number}} TCodePointObj
-	 * @typedef {{start:number,end:number,length:number,substr:string}} TSequencePart
-	 */
-	/** @type {TCodePoints} */
-
 	const code_points = [[0, 65535]];
 	const accent_pat = '[\u0300-\u036F\u{b7}\u{2be}\u{2bc}]';
-	/** @type {TUnicodeMap} */
-
 	let unicode_map;
-	/** @type {RegExp} */
-
 	let multi_char_reg;
 	const max_char_length = 3;
-	/** @type {TUnicodeMap} */
-
 	const latin_convert = {};
-	/** @type {TUnicodeMap} */
-
 	const latin_condensed = {
-	  '/': '⁄∕',
-	  '0': '߀',
-	  "a": "ⱥɐɑ",
-	  "aa": "ꜳ",
-	  "ae": "æǽǣ",
-	  "ao": "ꜵ",
-	  "au": "ꜷ",
-	  "av": "ꜹꜻ",
-	  "ay": "ꜽ",
-	  "b": "ƀɓƃ",
-	  "c": "ꜿƈȼↄ",
-	  "d": "đɗɖᴅƌꮷԁɦ",
-	  "e": "ɛǝᴇɇ",
-	  "f": "ꝼƒ",
-	  "g": "ǥɠꞡᵹꝿɢ",
-	  "h": "ħⱨⱶɥ",
-	  "i": "ɨı",
-	  "j": "ɉȷ",
-	  "k": "ƙⱪꝁꝃꝅꞣ",
-	  "l": "łƚɫⱡꝉꝇꞁɭ",
-	  "m": "ɱɯϻ",
-	  "n": "ꞥƞɲꞑᴎлԉ",
-	  "o": "øǿɔɵꝋꝍᴑ",
-	  "oe": "œ",
-	  "oi": "ƣ",
-	  "oo": "ꝏ",
-	  "ou": "ȣ",
-	  "p": "ƥᵽꝑꝓꝕρ",
-	  "q": "ꝗꝙɋ",
-	  "r": "ɍɽꝛꞧꞃ",
-	  "s": "ßȿꞩꞅʂ",
-	  "t": "ŧƭʈⱦꞇ",
-	  "th": "þ",
-	  "tz": "ꜩ",
-	  "u": "ʉ",
-	  "v": "ʋꝟʌ",
-	  "vy": "ꝡ",
-	  "w": "ⱳ",
-	  "y": "ƴɏỿ",
-	  "z": "ƶȥɀⱬꝣ",
-	  "hv": "ƕ"
+	    '/': '⁄∕',
+	    '0': '߀',
+	    "a": "ⱥɐɑ",
+	    "aa": "ꜳ",
+	    "ae": "æǽǣ",
+	    "ao": "ꜵ",
+	    "au": "ꜷ",
+	    "av": "ꜹꜻ",
+	    "ay": "ꜽ",
+	    "b": "ƀɓƃ",
+	    "c": "ꜿƈȼↄ",
+	    "d": "đɗɖᴅƌꮷԁɦ",
+	    "e": "ɛǝᴇɇ",
+	    "f": "ꝼƒ",
+	    "g": "ǥɠꞡᵹꝿɢ",
+	    "h": "ħⱨⱶɥ",
+	    "i": "ɨı",
+	    "j": "ɉȷ",
+	    "k": "ƙⱪꝁꝃꝅꞣ",
+	    "l": "łƚɫⱡꝉꝇꞁɭ",
+	    "m": "ɱɯϻ",
+	    "n": "ꞥƞɲꞑᴎлԉ",
+	    "o": "øǿɔɵꝋꝍᴑ",
+	    "oe": "œ",
+	    "oi": "ƣ",
+	    "oo": "ꝏ",
+	    "ou": "ȣ",
+	    "p": "ƥᵽꝑꝓꝕρ",
+	    "q": "ꝗꝙɋ",
+	    "r": "ɍɽꝛꞧꞃ",
+	    "s": "ßȿꞩꞅʂ",
+	    "t": "ŧƭʈⱦꞇ",
+	    "th": "þ",
+	    "tz": "ꜩ",
+	    "u": "ʉ",
+	    "v": "ʋꝟʌ",
+	    "vy": "ꝡ",
+	    "w": "ⱳ",
+	    "y": "ƴɏỿ",
+	    "z": "ƶȥɀⱬꝣ",
+	    "hv": "ƕ"
 	};
-
 	for (let latin in latin_condensed) {
-	  let unicode = latin_condensed[latin] || '';
-
-	  for (let i = 0; i < unicode.length; i++) {
-	    let char = unicode.substring(i, i + 1);
-	    latin_convert[char] = latin;
-	  }
+	    let unicode = latin_condensed[latin] || '';
+	    for (let i = 0; i < unicode.length; i++) {
+	        let char = unicode.substring(i, i + 1);
+	        latin_convert[char] = latin;
+	    }
 	}
-
 	const convert_pat = new RegExp(Object.keys(latin_convert).join('|') + '|' + accent_pat, 'gu');
 	/**
 	 * Initialize the unicode_map from the give code point ranges
-	 *
-	 * @param {TCodePoints=} _code_points
 	 */
-
-	const initialize = _code_points => {
-	  if (unicode_map !== undefined) return;
-	  unicode_map = generateMap(_code_points || code_points);
+	const initialize = (_code_points) => {
+	    if (unicode_map !== undefined)
+	        return;
+	    unicode_map = generateMap(code_points);
 	};
 	/**
 	 * Helper method for normalize a string
 	 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize
-	 * @param {string} str
-	 * @param {string} form
 	 */
-
 	const normalize = (str, form = 'NFKD') => str.normalize(form);
 	/**
 	 * Remove accents without reordering string
 	 * calling str.normalize('NFKD') on \u{594}\u{595}\u{596} becomes \u{596}\u{594}\u{595}
 	 * via https://github.com/krisk/Fuse/issues/133#issuecomment-318692703
-	 * @param {string} str
-	 * @return {string}
 	 */
-
-	const asciifold = str => {
-	  return toArray(str).reduce(
-	  /**
-	   * @param {string} result
-	   * @param {string} char
-	   */
-	  (result, char) => {
-	    return result + _asciifold(char);
-	  }, '');
+	const asciifold = (str) => {
+	    return Array.from(str).reduce(
+	    /**
+	     * @param {string} result
+	     * @param {string} char
+	     */
+	    (result, char) => {
+	        return result + _asciifold(char);
+	    }, '');
 	};
-	/**
-	 * @param {string} str
-	 * @return {string}
-	 */
-
-	const _asciifold = str => {
-	  str = normalize(str).toLowerCase().replace(convert_pat, (
-	  /** @type {string} */
-	  char) => {
-	    return latin_convert[char] || '';
-	  }); //return str;
-
-	  return normalize(str, 'NFC');
+	const _asciifold = (str) => {
+	    str = normalize(str)
+	        .toLowerCase()
+	        .replace(convert_pat, (/** @type {string} */ char) => {
+	        return latin_convert[char] || '';
+	    });
+	    //return str;
+	    return normalize(str, 'NFC');
 	};
 	/**
 	 * Generate a list of unicode variants from the list of code points
-	 * @param {TCodePoints} code_points
-	 * @yield {TCodePointObj}
 	 */
-
 	function* generator(code_points) {
-	  for (const [code_point_min, code_point_max] of code_points) {
-	    for (let i = code_point_min; i <= code_point_max; i++) {
-	      let composed = String.fromCharCode(i);
-	      let folded = asciifold(composed);
-
-	      if (folded == composed.toLowerCase()) {
-	        continue;
-	      } // skip when folded is a string longer than 3 characters long
-	      // bc the resulting regex patterns will be long
-	      // eg:
-	      // folded صلى الله عليه وسلم length 18 code point 65018
-	      // folded جل جلاله length 8 code point 65019
-
-
-	      if (folded.length > max_char_length) {
-	        continue;
-	      }
-
-	      if (folded.length == 0) {
-	        continue;
-	      }
-
-	      yield {
-	        folded: folded,
-	        composed: composed,
-	        code_point: i
-	      };
+	    for (const [code_point_min, code_point_max] of code_points) {
+	        for (let i = code_point_min; i <= code_point_max; i++) {
+	            let composed = String.fromCharCode(i);
+	            let folded = asciifold(composed);
+	            if (folded == composed.toLowerCase()) {
+	                continue;
+	            }
+	            // skip when folded is a string longer than 3 characters long
+	            // bc the resulting regex patterns will be long
+	            // eg:
+	            // folded صلى الله عليه وسلم length 18 code point 65018
+	            // folded جل جلاله length 8 code point 65019
+	            if (folded.length > max_char_length) {
+	                continue;
+	            }
+	            if (folded.length == 0) {
+	                continue;
+	            }
+	            yield { folded: folded, composed: composed, code_point: i };
+	        }
 	    }
-	  }
 	}
 	/**
 	 * Generate a unicode map from the list of code points
-	 * @param {TCodePoints} code_points
-	 * @return {TUnicodeSets}
 	 */
-
-	const generateSets = code_points => {
-	  /** @type {{[key:string]:Set<string>}} */
-	  const unicode_sets = {};
-	  /**
-	   * @param {string} folded
-	   * @param {string} to_add
-	   */
-
-	  const addMatching = (folded, to_add) => {
-	    /** @type {Set<string>} */
-	    const folded_set = unicode_sets[folded] || new Set();
-	    const patt = new RegExp('^' + setToPattern(folded_set) + '$', 'iu');
-
-	    if (to_add.match(patt)) {
-	      return;
+	const generateSets = (code_points) => {
+	    const unicode_sets = {};
+	    const addMatching = (folded, to_add) => {
+	        /** @type {Set<string>} */
+	        const folded_set = unicode_sets[folded] || new Set();
+	        const patt = new RegExp('^' + setToPattern(folded_set) + '$', 'iu');
+	        if (to_add.match(patt)) {
+	            return;
+	        }
+	        folded_set.add(escape_regex(to_add));
+	        unicode_sets[folded] = folded_set;
+	    };
+	    for (let value of generator(code_points)) {
+	        addMatching(value.folded, value.folded);
+	        addMatching(value.folded, value.composed);
 	    }
-
-	    folded_set.add(escape_regex(to_add));
-	    unicode_sets[folded] = folded_set;
-	  };
-
-	  for (let value of generator(code_points)) {
-	    addMatching(value.folded, value.folded);
-	    addMatching(value.folded, value.composed);
-	  }
-
-	  return unicode_sets;
+	    return unicode_sets;
 	};
 	/**
 	 * Generate a unicode map from the list of code points
 	 * ae => (?:(?:ae|Æ|Ǽ|Ǣ)|(?:A|Ⓐ|Ａ...)(?:E|ɛ|Ⓔ...))
-	 *
-	 * @param {TCodePoints} code_points
-	 * @return {TUnicodeMap}
 	 */
-
-	const generateMap = code_points => {
-	  /** @type {TUnicodeSets} */
-	  const unicode_sets = generateSets(code_points);
-	  /** @type {TUnicodeMap} */
-
-	  const unicode_map = {};
-	  /** @type {string[]} */
-
-	  let multi_char = [];
-
-	  for (let folded in unicode_sets) {
-	    let set = unicode_sets[folded];
-
-	    if (set) {
-	      unicode_map[folded] = setToPattern(set);
-	    }
-
-	    if (folded.length > 1) {
-	      multi_char.push(escape_regex(folded));
+	const generateMap = (code_points) => {
+	    const unicode_sets = generateSets(code_points);
+	    const unicode_map = {};
+	    let multi_char = [];
+	    for (let folded in unicode_sets) {
+	        let set = unicode_sets[folded];
+	        if (set) {
+	            unicode_map[folded] = setToPattern(set);
+	        }
+	        if (folded.length > 1) {
+	            multi_char.push(escape_regex(folded));
+	        }
 	    }
-	  }
-
-	  multi_char.sort((a, b) => b.length - a.length);
-	  const multi_char_patt = arrayToPattern(multi_char);
-	  multi_char_reg = new RegExp('^' + multi_char_patt, 'u');
-	  return unicode_map;
+	    multi_char.sort((a, b) => b.length - a.length);
+	    const multi_char_patt = arrayToPattern(multi_char);
+	    multi_char_reg = new RegExp('^' + multi_char_patt, 'u');
+	    return unicode_map;
 	};
 	/**
-	 * Map each element of an array from it's folded value to all possible unicode matches
-	 * @param {string[]} strings
-	 * @param {number} min_replacement
-	 * @return {string}
+	 * Map each element of an array from its folded value to all possible unicode matches
 	 */
-
 	const mapSequence = (strings, min_replacement = 1) => {
-	  let chars_replaced = 0;
-	  strings = strings.map(str => {
-	    if (unicode_map[str]) {
-	      chars_replaced += str.length;
+	    let chars_replaced = 0;
+	    strings = strings.map((str) => {
+	        if (unicode_map[str]) {
+	            chars_replaced += str.length;
+	        }
+	        return unicode_map[str] || str;
+	    });
+	    if (chars_replaced >= min_replacement) {
+	        return sequencePattern(strings);
 	    }
-
-	    return unicode_map[str] || str;
-	  });
-
-	  if (chars_replaced >= min_replacement) {
-	    return sequencePattern(strings);
-	  }
-
-	  return '';
+	    return '';
 	};
 	/**
 	 * Convert a short string and split it into all possible patterns
@@ -571,158 +451,107 @@
 	 * 'abc'
 	 * 		=> [['abc'],['ab','c'],['a','bc'],['a','b','c']]
 	 *		=> ['abc-pattern','ab-c-pattern'...]
-	 *
-	 *
-	 * @param {string} str
-	 * @param {number} min_replacement
-	 * @return {string}
 	 */
-
 	const substringsToPattern = (str, min_replacement = 1) => {
-	  min_replacement = Math.max(min_replacement, str.length - 1);
-	  return arrayToPattern(allSubstrings(str).map(sub_pat => {
-	    return mapSequence(sub_pat, min_replacement);
-	  }));
+	    min_replacement = Math.max(min_replacement, str.length - 1);
+	    return arrayToPattern(allSubstrings(str).map((sub_pat) => {
+	        return mapSequence(sub_pat, min_replacement);
+	    }));
 	};
 	/**
 	 * Convert an array of sequences into a pattern
 	 * [{start:0,end:3,length:3,substr:'iii'}...] => (?:iii...)
-	 *
-	 * @param {Sequence[]} sequences
-	 * @param {boolean} all
 	 */
-
 	const sequencesToPattern = (sequences, all = true) => {
-	  let min_replacement = sequences.length > 1 ? 1 : 0;
-	  return arrayToPattern(sequences.map(sequence => {
-	    let seq = [];
-	    const len = all ? sequence.length() : sequence.length() - 1;
-
-	    for (let j = 0; j < len; j++) {
-	      seq.push(substringsToPattern(sequence.substrs[j] || '', min_replacement));
-	    }
-
-	    return sequencePattern(seq);
-	  }));
+	    let min_replacement = sequences.length > 1 ? 1 : 0;
+	    return arrayToPattern(sequences.map((sequence) => {
+	        let seq = [];
+	        const len = all ? sequence.length() : sequence.length() - 1;
+	        for (let j = 0; j < len; j++) {
+	            seq.push(substringsToPattern(sequence.substrs[j] || '', min_replacement));
+	        }
+	        return sequencePattern(seq);
+	    }));
 	};
 	/**
 	 * Return true if the sequence is already in the sequences
-	 * @param {Sequence} needle_seq
-	 * @param {Sequence[]} sequences
 	 */
-
-
 	const inSequences = (needle_seq, sequences) => {
-	  for (const seq of sequences) {
-	    if (seq.start != needle_seq.start || seq.end != needle_seq.end) {
-	      continue;
-	    }
-
-	    if (seq.substrs.join('') !== needle_seq.substrs.join('')) {
-	      continue;
-	    }
-
-	    let needle_parts = needle_seq.parts;
-	    /**
-	     * @param {TSequencePart} part
-	     */
-
-	    const filter = part => {
-	      for (const needle_part of needle_parts) {
-	        if (needle_part.start === part.start && needle_part.substr === part.substr) {
-	          return false;
+	    for (const seq of sequences) {
+	        if (seq.start != needle_seq.start || seq.end != needle_seq.end) {
+	            continue;
 	        }
-
-	        if (part.length == 1 || needle_part.length == 1) {
-	          continue;
-	        } // check for overlapping parts
-	        // a = ['::=','==']
-	        // b = ['::','===']
-	        // a = ['r','sm']
-	        // b = ['rs','m']
-
-
-	        if (part.start < needle_part.start && part.end > needle_part.start) {
-	          return true;
+	        if (seq.substrs.join('') !== needle_seq.substrs.join('')) {
+	            continue;
 	        }
-
-	        if (needle_part.start < part.start && needle_part.end > part.start) {
-	          return true;
+	        let needle_parts = needle_seq.parts;
+	        const filter = (part) => {
+	            for (const needle_part of needle_parts) {
+	                if (needle_part.start === part.start && needle_part.substr === part.substr) {
+	                    return false;
+	                }
+	                if (part.length == 1 || needle_part.length == 1) {
+	                    continue;
+	                }
+	                // check for overlapping parts
+	                // a = ['::=','==']
+	                // b = ['::','===']
+	                // a = ['r','sm']
+	                // b = ['rs','m']
+	                if (part.start < needle_part.start && part.end > needle_part.start) {
+	                    return true;
+	                }
+	                if (needle_part.start < part.start && needle_part.end > part.start) {
+	                    return true;
+	                }
+	            }
+	            return false;
+	        };
+	        let filtered = seq.parts.filter(filter);
+	        if (filtered.length > 0) {
+	            continue;
 	        }
-	      }
-
-	      return false;
-	    };
-
-	    let filtered = seq.parts.filter(filter);
-
-	    if (filtered.length > 0) {
-	      continue;
+	        return true;
 	    }
-
-	    return true;
-	  }
-
-	  return false;
+	    return false;
 	};
-
 	class Sequence {
-	  constructor() {
-	    /** @type {TSequencePart[]} */
-	    this.parts = [];
-	    /** @type {string[]} */
-
-	    this.substrs = [];
-	    this.start = 0;
-	    this.end = 0;
-	  }
-	  /**
-	   * @param {TSequencePart|undefined} part
-	   */
-
-
-	  add(part) {
-	    if (part) {
-	      this.parts.push(part);
-	      this.substrs.push(part.substr);
-	      this.start = Math.min(part.start, this.start);
-	      this.end = Math.max(part.end, this.end);
+	    parts;
+	    substrs;
+	    start;
+	    end;
+	    constructor() {
+	        this.parts = [];
+	        this.substrs = [];
+	        this.start = 0;
+	        this.end = 0;
+	    }
+	    add(part) {
+	        if (part) {
+	            this.parts.push(part);
+	            this.substrs.push(part.substr);
+	            this.start = Math.min(part.start, this.start);
+	            this.end = Math.max(part.end, this.end);
+	        }
 	    }
-	  }
-
-	  last() {
-	    return this.parts[this.parts.length - 1];
-	  }
-
-	  length() {
-	    return this.parts.length;
-	  }
-	  /**
-	   * @param {number} position
-	   * @param {TSequencePart} last_piece
-	   */
-
-
-	  clone(position, last_piece) {
-	    let clone = new Sequence();
-	    let parts = JSON.parse(JSON.stringify(this.parts));
-	    let last_part = parts.pop();
-
-	    for (const part of parts) {
-	      clone.add(part);
+	    last() {
+	        return this.parts[this.parts.length - 1];
+	    }
+	    length() {
+	        return this.parts.length;
+	    }
+	    clone(position, last_piece) {
+	        let clone = new Sequence();
+	        let parts = JSON.parse(JSON.stringify(this.parts));
+	        let last_part = parts.pop();
+	        for (const part of parts) {
+	            clone.add(part);
+	        }
+	        let last_substr = last_piece.substr.substring(0, position - last_part.start);
+	        let clone_last_len = last_substr.length;
+	        clone.add({ start: last_part.start, end: last_part.start + clone_last_len, length: clone_last_len, substr: last_substr });
+	        return clone;
 	    }
-
-	    let last_substr = last_piece.substr.substring(0, position - last_part.start);
-	    let clone_last_len = last_substr.length;
-	    clone.add({
-	      start: last_part.start,
-	      end: last_part.start + clone_last_len,
-	      length: clone_last_len,
-	      substr: last_substr
-	    });
-	    return clone;
-	  }
-
 	}
 	/**
 	 * Expand a regular expression pattern to include unicode variants
@@ -735,110 +564,80 @@
 	 *	İIJ = IIJ = ⅡJ
 	 *
 	 * 	1/2/4
-	 *
-	 * @param {string} str
-	 * @return {string|undefined}
 	 */
-
-
-	const getPattern = str => {
-	  initialize();
-	  str = asciifold(str);
-	  let pattern = '';
-	  let sequences = [new Sequence()];
-
-	  for (let i = 0; i < str.length; i++) {
-	    let substr = str.substring(i);
-	    let match = substr.match(multi_char_reg);
-	    const char = str.substring(i, i + 1);
-	    const match_str = match ? match[0] : null; // loop through sequences
-	    // add either the char or multi_match
-
-	    let overlapping = [];
-	    let added_types = new Set();
-
-	    for (const sequence of sequences) {
-	      const last_piece = sequence.last();
-
-	      if (!last_piece || last_piece.length == 1 || last_piece.end <= i) {
-	        // if we have a multi match
-	        if (match_str) {
-	          const len = match_str.length;
-	          sequence.add({
-	            start: i,
-	            end: i + len,
-	            length: len,
-	            substr: match_str
-	          });
-	          added_types.add('1');
-	        } else {
-	          sequence.add({
-	            start: i,
-	            end: i + 1,
-	            length: 1,
-	            substr: char
-	          });
-	          added_types.add('2');
+	const getPattern = (str) => {
+	    initialize();
+	    str = asciifold(str);
+	    let pattern = '';
+	    let sequences = [new Sequence()];
+	    for (let i = 0; i < str.length; i++) {
+	        let substr = str.substring(i);
+	        let match = substr.match(multi_char_reg);
+	        const char = str.substring(i, i + 1);
+	        const match_str = match ? match[0] : null;
+	        // loop through sequences
+	        // add either the char or multi_match
+	        let overlapping = [];
+	        let added_types = new Set();
+	        for (const sequence of sequences) {
+	            const last_piece = sequence.last();
+	            if (!last_piece || last_piece.length == 1 || last_piece.end <= i) {
+	                // if we have a multi match
+	                if (match_str) {
+	                    const len = match_str.length;
+	                    sequence.add({ start: i, end: i + len, length: len, substr: match_str });
+	                    added_types.add('1');
+	                }
+	                else {
+	                    sequence.add({ start: i, end: i + 1, length: 1, substr: char });
+	                    added_types.add('2');
+	                }
+	            }
+	            else if (match_str) {
+	                let clone = sequence.clone(i, last_piece);
+	                const len = match_str.length;
+	                clone.add({ start: i, end: i + len, length: len, substr: match_str });
+	                overlapping.push(clone);
+	            }
+	            else {
+	                // don't add char
+	                // adding would create invalid patterns: 234 => [2,34,4]
+	                added_types.add('3');
+	            }
 	        }
-	      } else if (match_str) {
-	        let clone = sequence.clone(i, last_piece);
-	        const len = match_str.length;
-	        clone.add({
-	          start: i,
-	          end: i + len,
-	          length: len,
-	          substr: match_str
-	        });
-	        overlapping.push(clone);
-	      } else {
-	        // don't add char
-	        // adding would create invalid patterns: 234 => [2,34,4]
-	        added_types.add('3');
-	      }
-	    } // if we have overlapping
-
-
-	    if (overlapping.length > 0) {
-	      // ['ii','iii'] before ['i','i','iii']
-	      overlapping = overlapping.sort((a, b) => {
-	        return a.length() - b.length();
-	      });
-
-	      for (let clone of overlapping) {
-	        // don't add if we already have an equivalent sequence
-	        if (inSequences(clone, sequences)) {
-	          continue;
+	        // if we have overlapping
+	        if (overlapping.length > 0) {
+	            // ['ii','iii'] before ['i','i','iii']
+	            overlapping = overlapping.sort((a, b) => {
+	                return a.length() - b.length();
+	            });
+	            for (let clone of overlapping) {
+	                // don't add if we already have an equivalent sequence
+	                if (inSequences(clone, sequences)) {
+	                    continue;
+	                }
+	                sequences.push(clone);
+	            }
+	            continue;
+	        }
+	        // if we haven't done anything unique
+	        // clean up the patterns
+	        // helps keep patterns smaller
+	        // if str = 'r₨㎧aarss', pattern will be 446 instead of 655
+	        if (i > 0 && added_types.size == 1 && !added_types.has('3')) {
+	            pattern += sequencesToPattern(sequences, false);
+	            let new_seq = new Sequence();
+	            const old_seq = sequences[0];
+	            if (old_seq) {
+	                new_seq.add(old_seq.last());
+	            }
+	            sequences = [new_seq];
 	        }
-
-	        sequences.push(clone);
-	      }
-
-	      continue;
-	    } // if we haven't done anything unique
-	    // clean up the patterns
-	    // helps keep patterns smaller
-	    // if str = 'r₨㎧aarss', pattern will be 446 instead of 655
-
-
-	    if (i > 0 && added_types.size == 1 && !added_types.has('3')) {
-	      pattern += sequencesToPattern(sequences, false);
-	      let new_seq = new Sequence();
-	      const old_seq = sequences[0];
-
-	      if (old_seq) {
-	        new_seq.add(old_seq.last());
-	      }
-
-	      sequences = [new_seq];
 	    }
-	  }
-
-	  pattern += sequencesToPattern(sequences, true);
-	  return pattern;
+	    pattern += sequencesToPattern(sequences, true);
+	    return pattern;
 	};
 
-	/*! sifter.js | https://github.com/orchidjs/sifter.js | Apache License (v2) */
-
 	/**
 	 * A property getter resolving dot-notation
 	 * @param  {Object}  obj     The root object to fetch property on
@@ -846,8 +645,9 @@
 	 * @return {Object}          The resolved property value
 	 */
 	const getAttr = (obj, name) => {
-	  if (!obj) return;
-	  return obj[name];
+	    if (!obj)
+	        return;
+	    return obj[name];
 	};
 	/**
 	 * A property getter resolving dot-notation
@@ -855,45 +655,45 @@
 	 * @param  {String}  name    The optionally dotted property name to fetch
 	 * @return {Object}          The resolved property value
 	 */
-
 	const getAttrNesting = (obj, name) => {
-	  if (!obj) return;
-	  var part,
-	      names = name.split(".");
-
-	  while ((part = names.shift()) && (obj = obj[part]));
-
-	  return obj;
+	    if (!obj)
+	        return;
+	    var part, names = name.split(".");
+	    while ((part = names.shift()) && (obj = obj[part]))
+	        ;
+	    return obj;
 	};
 	/**
 	 * Calculates how close of a match the
 	 * given value is against a search token.
 	 *
 	 */
-
 	const scoreValue = (value, token, weight) => {
-	  var score, pos;
-	  if (!value) return 0;
-	  value = value + '';
-	  if (token.regex == null) return 0;
-	  pos = value.search(token.regex);
-	  if (pos === -1) return 0;
-	  score = token.string.length / value.length;
-	  if (pos === 0) score += 0.5;
-	  return score * weight;
+	    var score, pos;
+	    if (!value)
+	        return 0;
+	    value = value + '';
+	    if (token.regex == null)
+	        return 0;
+	    pos = value.search(token.regex);
+	    if (pos === -1)
+	        return 0;
+	    score = token.string.length / value.length;
+	    if (pos === 0)
+	        score += 0.5;
+	    return score * weight;
 	};
 	/**
 	 * Cast object property to an array if it exists and has a value
 	 *
 	 */
-
 	const propToArray = (obj, key) => {
-	  var value = obj[key];
-	  if (typeof value == 'function') return value;
-
-	  if (value && !Array.isArray(value)) {
-	    obj[key] = [value];
-	  }
+	    var value = obj[key];
+	    if (typeof value == 'function')
+	        return value;
+	    if (value && !Array.isArray(value)) {
+	        obj[key] = [value];
+	    }
 	};
 	/**
 	 * Iterates over arrays and hashes.
@@ -905,32 +705,31 @@
 	 * ```
 	 *
 	 */
-
 	const iterate$1 = (object, callback) => {
-	  if (Array.isArray(object)) {
-	    object.forEach(callback);
-	  } else {
-	    for (var key in object) {
-	      if (object.hasOwnProperty(key)) {
-	        callback(object[key], key);
-	      }
+	    if (Array.isArray(object)) {
+	        object.forEach(callback);
+	    }
+	    else {
+	        for (var key in object) {
+	            if (object.hasOwnProperty(key)) {
+	                callback(object[key], key);
+	            }
+	        }
 	    }
-	  }
 	};
 	const cmp = (a, b) => {
-	  if (typeof a === 'number' && typeof b === 'number') {
-	    return a > b ? 1 : a < b ? -1 : 0;
-	  }
-
-	  a = asciifold(a + '').toLowerCase();
-	  b = asciifold(b + '').toLowerCase();
-	  if (a > b) return 1;
-	  if (b > a) return -1;
-	  return 0;
+	    if (typeof a === 'number' && typeof b === 'number') {
+	        return a > b ? 1 : (a < b ? -1 : 0);
+	    }
+	    a = asciifold(a + '').toLowerCase();
+	    b = asciifold(b + '').toLowerCase();
+	    if (a > b)
+	        return 1;
+	    if (b > a)
+	        return -1;
+	    return 0;
 	};
 
-	/*! sifter.js | https://github.com/orchidjs/sifter.js | Apache License (v2) */
-
 	/**
 	 * sifter.js
 	 * Copyright (c) 2013–2020 Brian Reavis & contributors
@@ -946,349 +745,469 @@
 	 *
 	 * @author Brian Reavis <brian@thirdroute.com>
 	 */
-
 	class Sifter {
-	  // []|{};
-
-	  /**
-	   * Textually searches arrays and hashes of objects
-	   * by property (or multiple properties). Designed
-	   * specifically for autocomplete.
-	   *
-	   */
-	  constructor(items, settings) {
-	    this.items = void 0;
-	    this.settings = void 0;
-	    this.items = items;
-	    this.settings = settings || {
-	      diacritics: true
-	    };
-	  }
-
-	  /**
-	   * Splits a search string into an array of individual
-	   * regexps to be used to match results.
-	   *
-	   */
-	  tokenize(query, respect_word_boundaries, weights) {
-	    if (!query || !query.length) return [];
-	    const tokens = [];
-	    const words = query.split(/\s+/);
-	    var field_regex;
-
-	    if (weights) {
-	      field_regex = new RegExp('^(' + Object.keys(weights).map(escape_regex).join('|') + ')\:(.*)$');
+	    items; // []|{};
+	    settings;
+	    /**
+	     * Textually searches arrays and hashes of objects
+	     * by property (or multiple properties). Designed
+	     * specifically for autocomplete.
+	     *
+	     */
+	    constructor(items, settings) {
+	        this.items = items;
+	        this.settings = settings || { diacritics: true };
 	    }
-
-	    words.forEach(word => {
-	      let field_match;
-	      let field = null;
-	      let regex = null; // look for "field:query" tokens
-
-	      if (field_regex && (field_match = word.match(field_regex))) {
-	        field = field_match[1];
-	        word = field_match[2];
-	      }
-
-	      if (word.length > 0) {
-	        if (this.settings.diacritics) {
-	          regex = getPattern(word) || null;
-	        } else {
-	          regex = escape_regex(word);
+	    ;
+	    /**
+	     * Splits a search string into an array of individual
+	     * regexps to be used to match results.
+	     *
+	     */
+	    tokenize(query, respect_word_boundaries, weights) {
+	        if (!query || !query.length)
+	            return [];
+	        const tokens = [];
+	        const words = query.split(/\s+/);
+	        var field_regex;
+	        if (weights) {
+	            field_regex = new RegExp('^(' + Object.keys(weights).map(escape_regex).join('|') + ')\:(.*)$');
 	        }
-
-	        if (regex && respect_word_boundaries) regex = "\\b" + regex;
-	      }
-
-	      tokens.push({
-	        string: word,
-	        regex: regex ? new RegExp(regex, 'iu') : null,
-	        field: field
-	      });
-	    });
-	    return tokens;
-	  }
-
-	  /**
-	   * Returns a function to be used to score individual results.
-	   *
-	   * Good matches will have a higher score than poor matches.
-	   * If an item is not a match, 0 will be returned by the function.
-	   *
-	   * @returns {T.ScoreFn}
-	   */
-	  getScoreFunction(query, options) {
-	    var search = this.prepareSearch(query, options);
-	    return this._getScoreFunction(search);
-	  }
-	  /**
-	   * @returns {T.ScoreFn}
-	   *
-	   */
-
-
-	  _getScoreFunction(search) {
-	    const tokens = search.tokens,
-	          token_count = tokens.length;
-
-	    if (!token_count) {
-	      return function () {
-	        return 0;
-	      };
+	        words.forEach((word) => {
+	            let field_match;
+	            let field = null;
+	            let regex = null;
+	            // look for "field:query" tokens
+	            if (field_regex && (field_match = word.match(field_regex))) {
+	                field = field_match[1];
+	                word = field_match[2];
+	            }
+	            if (word.length > 0) {
+	                if (this.settings.diacritics) {
+	                    regex = getPattern(word) || null;
+	                }
+	                else {
+	                    regex = escape_regex(word);
+	                }
+	                if (regex && respect_word_boundaries)
+	                    regex = "\\b" + regex;
+	            }
+	            tokens.push({
+	                string: word,
+	                regex: regex ? new RegExp(regex, 'iu') : null,
+	                field: field,
+	            });
+	        });
+	        return tokens;
 	    }
-
-	    const fields = search.options.fields,
-	          weights = search.weights,
-	          field_count = fields.length,
-	          getAttrFn = search.getAttrFn;
-
-	    if (!field_count) {
-	      return function () {
-	        return 1;
-	      };
+	    ;
+	    /**
+	     * Returns a function to be used to score individual results.
+	     *
+	     * Good matches will have a higher score than poor matches.
+	     * If an item is not a match, 0 will be returned by the function.
+	     *
+	     * @returns {T.ScoreFn}
+	     */
+	    getScoreFunction(query, options) {
+	        var search = this.prepareSearch(query, options);
+	        return this._getScoreFunction(search);
 	    }
 	    /**
-	     * Calculates the score of an object
-	     * against the search query.
+	     * @returns {T.ScoreFn}
 	     *
 	     */
-
-
-	    const scoreObject = function () {
-	      if (field_count === 1) {
-	        return function (token, data) {
-	          const field = fields[0].field;
-	          return scoreValue(getAttrFn(data, field), token, weights[field] || 1);
-	        };
-	      }
-
-	      return function (token, data) {
-	        var sum = 0; // is the token specific to a field?
-
-	        if (token.field) {
-	          const value = getAttrFn(data, token.field);
-
-	          if (!token.regex && value) {
-	            sum += 1 / field_count;
-	          } else {
-	            sum += scoreValue(value, token, 1);
-	          }
-	        } else {
-	          iterate$1(weights, (weight, field) => {
-	            sum += scoreValue(getAttrFn(data, field), token, weight);
-	          });
+	    _getScoreFunction(search) {
+	        const tokens = search.tokens, token_count = tokens.length;
+	        if (!token_count) {
+	            return function () { return 0; };
+	        }
+	        const fields = search.options.fields, weights = search.weights, field_count = fields.length, getAttrFn = search.getAttrFn;
+	        if (!field_count) {
+	            return function () { return 1; };
+	        }
+	        /**
+	         * Calculates the score of an object
+	         * against the search query.
+	         *
+	         */
+	        const scoreObject = (function () {
+	            if (field_count === 1) {
+	                return function (token, data) {
+	                    const field = fields[0].field;
+	                    return scoreValue(getAttrFn(data, field), token, weights[field] || 1);
+	                };
+	            }
+	            return function (token, data) {
+	                var sum = 0;
+	                // is the token specific to a field?
+	                if (token.field) {
+	                    const value = getAttrFn(data, token.field);
+	                    if (!token.regex && value) {
+	                        sum += (1 / field_count);
+	                    }
+	                    else {
+	                        sum += scoreValue(value, token, 1);
+	                    }
+	                }
+	                else {
+	                    iterate$1(weights, (weight, field) => {
+	                        sum += scoreValue(getAttrFn(data, field), token, weight);
+	                    });
+	                }
+	                return sum / field_count;
+	            };
+	        })();
+	        if (token_count === 1) {
+	            return function (data) {
+	                return scoreObject(tokens[0], data);
+	            };
+	        }
+	        if (search.options.conjunction === 'and') {
+	            return function (data) {
+	                var score, sum = 0;
+	                for (let token of tokens) {
+	                    score = scoreObject(token, data);
+	                    if (score <= 0)
+	                        return 0;
+	                    sum += score;
+	                }
+	                return sum / token_count;
+	            };
+	        }
+	        else {
+	            return function (data) {
+	                var sum = 0;
+	                iterate$1(tokens, (token) => {
+	                    sum += scoreObject(token, data);
+	                });
+	                return sum / token_count;
+	            };
 	        }
-
-	        return sum / field_count;
-	      };
-	    }();
-
-	    if (token_count === 1) {
-	      return function (data) {
-	        return scoreObject(tokens[0], data);
-	      };
 	    }
-
-	    if (search.options.conjunction === 'and') {
-	      return function (data) {
-	        var score,
-	            sum = 0;
-
-	        for (let token of tokens) {
-	          score = scoreObject(token, data);
-	          if (score <= 0) return 0;
-	          sum += score;
+	    ;
+	    /**
+	     * Returns a function that can be used to compare two
+	     * results, for sorting purposes. If no sorting should
+	     * be performed, `null` will be returned.
+	     *
+	     * @return function(a,b)
+	     */
+	    getSortFunction(query, options) {
+	        var search = this.prepareSearch(query, options);
+	        return this._getSortFunction(search);
+	    }
+	    _getSortFunction(search) {
+	        var implicit_score, sort_flds = [];
+	        const self = this, options = search.options, sort = (!search.query && options.sort_empty) ? options.sort_empty : options.sort;
+	        if (typeof sort == 'function') {
+	            return sort.bind(this);
 	        }
-
-	        return sum / token_count;
-	      };
-	    } else {
-	      return function (data) {
-	        var sum = 0;
-	        iterate$1(tokens, token => {
-	          sum += scoreObject(token, data);
-	        });
-	        return sum / token_count;
-	      };
+	        /**
+	         * Fetches the specified sort field value
+	         * from a search result item.
+	         *
+	         */
+	        const get_field = function (name, result) {
+	            if (name === '$score')
+	                return result.score;
+	            return search.getAttrFn(self.items[result.id], name);
+	        };
+	        // parse options
+	        if (sort) {
+	            for (let s of sort) {
+	                if (search.query || s.field !== '$score') {
+	                    sort_flds.push(s);
+	                }
+	            }
+	        }
+	        // the "$score" field is implied to be the primary
+	        // sort field, unless it's manually specified
+	        if (search.query) {
+	            implicit_score = true;
+	            for (let fld of sort_flds) {
+	                if (fld.field === '$score') {
+	                    implicit_score = false;
+	                    break;
+	                }
+	            }
+	            if (implicit_score) {
+	                sort_flds.unshift({ field: '$score', direction: 'desc' });
+	            }
+	            // without a search.query, all items will have the same score
+	        }
+	        else {
+	            sort_flds = sort_flds.filter((fld) => fld.field !== '$score');
+	        }
+	        // build function
+	        const sort_flds_count = sort_flds.length;
+	        if (!sort_flds_count) {
+	            return null;
+	        }
+	        return function (a, b) {
+	            var result, field;
+	            for (let sort_fld of sort_flds) {
+	                field = sort_fld.field;
+	                let multiplier = sort_fld.direction === 'desc' ? -1 : 1;
+	                result = multiplier * cmp(get_field(field, a), get_field(field, b));
+	                if (result)
+	                    return result;
+	            }
+	            return 0;
+	        };
 	    }
-	  }
-
-	  /**
-	   * Returns a function that can be used to compare two
-	   * results, for sorting purposes. If no sorting should
-	   * be performed, `null` will be returned.
-	   *
-	   * @return function(a,b)
-	   */
-	  getSortFunction(query, options) {
-	    var search = this.prepareSearch(query, options);
-	    return this._getSortFunction(search);
-	  }
-
-	  _getSortFunction(search) {
-	    var implicit_score,
-	        sort_flds = [];
-	    const self = this,
-	          options = search.options,
-	          sort = !search.query && options.sort_empty ? options.sort_empty : options.sort;
-
-	    if (typeof sort == 'function') {
-	      return sort.bind(this);
+	    ;
+	    /**
+	     * Parses a search query and returns an object
+	     * with tokens and fields ready to be populated
+	     * with results.
+	     *
+	     */
+	    prepareSearch(query, optsUser) {
+	        const weights = {};
+	        var options = Object.assign({}, optsUser);
+	        propToArray(options, 'sort');
+	        propToArray(options, 'sort_empty');
+	        // convert fields to new format
+	        if (options.fields) {
+	            propToArray(options, 'fields');
+	            const fields = [];
+	            options.fields.forEach((field) => {
+	                if (typeof field == 'string') {
+	                    field = { field: field, weight: 1 };
+	                }
+	                fields.push(field);
+	                weights[field.field] = ('weight' in field) ? field.weight : 1;
+	            });
+	            options.fields = fields;
+	        }
+	        return {
+	            options: options,
+	            query: query.toLowerCase().trim(),
+	            tokens: this.tokenize(query, options.respect_word_boundaries, weights),
+	            total: 0,
+	            items: [],
+	            weights: weights,
+	            getAttrFn: (options.nesting) ? getAttrNesting : getAttr,
+	        };
 	    }
+	    ;
 	    /**
-	     * Fetches the specified sort field value
-	     * from a search result item.
+	     * Searches through all items and returns a sorted array of matches.
 	     *
 	     */
-
-
-	    const get_field = function get_field(name, result) {
-	      if (name === '$score') return result.score;
-	      return search.getAttrFn(self.items[result.id], name);
-	    }; // parse options
-
-
-	    if (sort) {
-	      for (let s of sort) {
-	        if (search.query || s.field !== '$score') {
-	          sort_flds.push(s);
+	    search(query, options) {
+	        var self = this, score, search;
+	        search = this.prepareSearch(query, options);
+	        options = search.options;
+	        query = search.query;
+	        // generate result scoring function
+	        const fn_score = options.score || self._getScoreFunction(search);
+	        // perform search and sort
+	        if (query.length) {
+	            iterate$1(self.items, (item, id) => {
+	                score = fn_score(item);
+	                if (options.filter === false || score > 0) {
+	                    search.items.push({ 'score': score, 'id': id });
+	                }
+	            });
 	        }
-	      }
-	    } // the "$score" field is implied to be the primary
-	    // sort field, unless it's manually specified
-
-
-	    if (search.query) {
-	      implicit_score = true;
-
-	      for (let fld of sort_flds) {
-	        if (fld.field === '$score') {
-	          implicit_score = false;
-	          break;
+	        else {
+	            iterate$1(self.items, (_, id) => {
+	                search.items.push({ 'score': 1, 'id': id });
+	            });
 	        }
-	      }
-
-	      if (implicit_score) {
-	        sort_flds.unshift({
-	          field: '$score',
-	          direction: 'desc'
-	        });
-	      } // without a search.query, all items will have the same score
-
-	    } else {
-	      sort_flds = sort_flds.filter(fld => fld.field !== '$score');
-	    } // build function
-
-
-	    const sort_flds_count = sort_flds.length;
-
-	    if (!sort_flds_count) {
-	      return null;
+	        const fn_sort = self._getSortFunction(search);
+	        if (fn_sort)
+	            search.items.sort(fn_sort);
+	        // apply limits
+	        search.total = search.items.length;
+	        if (typeof options.limit === 'number') {
+	            search.items = search.items.slice(0, options.limit);
+	        }
+	        return search;
 	    }
+	    ;
+	}
 
-	    return function (a, b) {
-	      var result, field;
+	/**
+	 * Converts a scalar to its best string representation
+	 * for hash keys and HTML attribute values.
+	 *
+	 * Transformations:
+	 *   'str'     -> 'str'
+	 *   null      -> ''
+	 *   undefined -> ''
+	 *   true      -> '1'
+	 *   false     -> '0'
+	 *   0         -> '0'
+	 *   1         -> '1'
+	 *
+	 */
+	const hash_key = value => {
+	  if (typeof value === 'undefined' || value === null) return null;
+	  return get_hash(value);
+	};
+	const get_hash = value => {
+	  if (typeof value === 'boolean') return value ? '1' : '0';
+	  return value + '';
+	};
 
-	      for (let sort_fld of sort_flds) {
-	        field = sort_fld.field;
-	        let multiplier = sort_fld.direction === 'desc' ? -1 : 1;
-	        result = multiplier * cmp(get_field(field, a), get_field(field, b));
-	        if (result) return result;
-	      }
+	/**
+	 * Escapes a string for use within HTML.
+	 *
+	 */
+	const escape_html = str => {
+	  return (str + '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+	};
 
-	      return 0;
-	    };
+	/**
+	 * use setTimeout if timeout > 0 
+	 */
+	const timeout = (fn, timeout) => {
+	  if (timeout > 0) {
+	    return window.setTimeout(fn, timeout);
 	  }
+	  fn.call(null);
+	  return null;
+	};
 
-	  /**
-	   * Parses a search query and returns an object
-	   * with tokens and fields ready to be populated
-	   * with results.
-	   *
-	   */
-	  prepareSearch(query, optsUser) {
-	    const weights = {};
-	    var options = Object.assign({}, optsUser);
-	    propToArray(options, 'sort');
-	    propToArray(options, 'sort_empty'); // convert fields to new format
-
-	    if (options.fields) {
-	      propToArray(options, 'fields');
-	      const fields = [];
-	      options.fields.forEach(field => {
-	        if (typeof field == 'string') {
-	          field = {
-	            field: field,
-	            weight: 1
-	          };
-	        }
-
-	        fields.push(field);
-	        weights[field.field] = 'weight' in field ? field.weight : 1;
-	      });
-	      options.fields = fields;
+	/**
+	 * Debounce the user provided load function
+	 *
+	 */
+	const loadDebounce = (fn, delay) => {
+	  var timeout;
+	  return function (value, callback) {
+	    var self = this;
+	    if (timeout) {
+	      self.loading = Math.max(self.loading - 1, 0);
+	      clearTimeout(timeout);
 	    }
+	    timeout = setTimeout(function () {
+	      timeout = null;
+	      self.loadedSearches[value] = true;
+	      fn.call(self, value, callback);
+	    }, delay);
+	  };
+	};
 
-	    return {
-	      options: options,
-	      query: query.toLowerCase().trim(),
-	      tokens: this.tokenize(query, options.respect_word_boundaries, weights),
-	      total: 0,
-	      items: [],
-	      weights: weights,
-	      getAttrFn: options.nesting ? getAttrNesting : getAttr
-	    };
-	  }
+	/**
+	 * Debounce all fired events types listed in `types`
+	 * while executing the provided `fn`.
+	 *
+	 */
+	const debounce_events = (self, types, fn) => {
+	  var type;
+	  var trigger = self.trigger;
+	  var event_args = {};
 
-	  /**
-	   * Searches through all items and returns a sorted array of matches.
-	   *
-	   */
-	  search(query, options) {
-	    var self = this,
-	        score,
-	        search;
-	    search = this.prepareSearch(query, options);
-	    options = search.options;
-	    query = search.query; // generate result scoring function
+	  // override trigger method
+	  self.trigger = function () {
+	    var type = arguments[0];
+	    if (types.indexOf(type) !== -1) {
+	      event_args[type] = arguments;
+	    } else {
+	      return trigger.apply(self, arguments);
+	    }
+	  };
 
-	    const fn_score = options.score || self._getScoreFunction(search); // perform search and sort
+	  // invoke provided function
+	  fn.apply(self, []);
+	  self.trigger = trigger;
 
+	  // trigger queued events
+	  for (type of types) {
+	    if (type in event_args) {
+	      trigger.apply(self, event_args[type]);
+	    }
+	  }
+	};
 
-	    if (query.length) {
-	      iterate$1(self.items, (item, id) => {
-	        score = fn_score(item);
+	/**
+	 * Determines the current selection within a text input control.
+	 * Returns an object containing:
+	 *   - start
+	 *   - length
+	 *
+	 * Note: "selectionStart, selectionEnd ... apply only to inputs of types text, search, URL, tel and password"
+	 * 	- https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/setSelectionRange
+	 */
+	const getSelection = input => {
+	  return {
+	    start: input.selectionStart || 0,
+	    length: (input.selectionEnd || 0) - (input.selectionStart || 0)
+	  };
+	};
 
-	        if (options.filter === false || score > 0) {
-	          search.items.push({
-	            'score': score,
-	            'id': id
-	          });
-	        }
-	      });
-	    } else {
-	      iterate$1(self.items, (_, id) => {
-	        search.items.push({
-	          'score': 1,
-	          'id': id
-	        });
-	      });
+	/**
+	 * Prevent default
+	 *
+	 */
+	const preventDefault = (evt, stop = false) => {
+	  if (evt) {
+	    evt.preventDefault();
+	    if (stop) {
+	      evt.stopPropagation();
 	    }
+	  }
+	};
 
-	    const fn_sort = self._getSortFunction(search);
-
-	    if (fn_sort) search.items.sort(fn_sort); // apply limits
-
-	    search.total = search.items.length;
+	/**
+	 * Add event helper
+	 *
+	 */
+	const addEvent = (target, type, callback, options) => {
+	  target.addEventListener(type, callback, options);
+	};
 
-	    if (typeof options.limit === 'number') {
-	      search.items = search.items.slice(0, options.limit);
-	    }
+	/**
+	 * Return true if the requested key is down
+	 * Will return false if more than one control character is pressed ( when [ctrl+shift+a] != [ctrl+a] )
+	 * The current evt may not always set ( eg calling advanceSelection() )
+	 *
+	 */
+	const isKeyDown = (key_name, evt) => {
+	  if (!evt) {
+	    return false;
+	  }
+	  if (!evt[key_name]) {
+	    return false;
+	  }
+	  var count = (evt.altKey ? 1 : 0) + (evt.ctrlKey ? 1 : 0) + (evt.shiftKey ? 1 : 0) + (evt.metaKey ? 1 : 0);
+	  if (count === 1) {
+	    return true;
+	  }
+	  return false;
+	};
 
-	    return search;
+	/**
+	 * Get the id of an element
+	 * If the id attribute is not set, set the attribute with the given id
+	 *
+	 */
+	const getId = (el, id) => {
+	  const existing_id = el.getAttribute('id');
+	  if (existing_id) {
+	    return existing_id;
 	  }
+	  el.setAttribute('id', id);
+	  return id;
+	};
 
-	}
+	/**
+	 * Returns a string with backslashes added before characters that need to be escaped.
+	 */
+	const addSlashes = str => {
+	  return str.replace(/[\\"']/g, '\\$&');
+	};
+
+	/**
+	 *
+	 */
+	const append = (parent, node) => {
+	  if (node) parent.append(node);
+	};
 
 	/**
 	 * Iterates over arrays and hashes.
@@ -1396,7 +1315,7 @@
 	  var classes = [];
 	  iterate(args, _classes => {
 	    if (typeof _classes === 'string') {
-	      _classes = _classes.trim().split(/[\11\12\14\15\40]/);
+	      _classes = _classes.trim().split(/[\t\n\f\r\s]/);
 	    }
 	    if (Array.isArray(_classes)) {
 	      classes = classes.concat(_classes);
@@ -1656,185 +1575,6 @@
 	  }
 	};
 
-	/**
-	 * Converts a scalar to its best string representation
-	 * for hash keys and HTML attribute values.
-	 *
-	 * Transformations:
-	 *   'str'     -> 'str'
-	 *   null      -> ''
-	 *   undefined -> ''
-	 *   true      -> '1'
-	 *   false     -> '0'
-	 *   0         -> '0'
-	 *   1         -> '1'
-	 *
-	 */
-	const hash_key = value => {
-	  if (typeof value === 'undefined' || value === null) return null;
-	  return get_hash(value);
-	};
-	const get_hash = value => {
-	  if (typeof value === 'boolean') return value ? '1' : '0';
-	  return value + '';
-	};
-
-	/**
-	 * Escapes a string for use within HTML.
-	 *
-	 */
-	const escape_html = str => {
-	  return (str + '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-	};
-
-	/**
-	 * use setTimeout if timeout > 0 
-	 */
-	const timeout = (fn, timeout) => {
-	  if (timeout > 0) {
-	    return setTimeout(fn, timeout);
-	  }
-	  fn.call(null);
-	  return null;
-	};
-
-	/**
-	 * Debounce the user provided load function
-	 *
-	 */
-	const loadDebounce = (fn, delay) => {
-	  var timeout;
-	  return function (value, callback) {
-	    var self = this;
-	    if (timeout) {
-	      self.loading = Math.max(self.loading - 1, 0);
-	      clearTimeout(timeout);
-	    }
-	    timeout = setTimeout(function () {
-	      timeout = null;
-	      self.loadedSearches[value] = true;
-	      fn.call(self, value, callback);
-	    }, delay);
-	  };
-	};
-
-	/**
-	 * Debounce all fired events types listed in `types`
-	 * while executing the provided `fn`.
-	 *
-	 */
-	const debounce_events = (self, types, fn) => {
-	  var type;
-	  var trigger = self.trigger;
-	  var event_args = {};
-
-	  // override trigger method
-	  self.trigger = function () {
-	    var type = arguments[0];
-	    if (types.indexOf(type) !== -1) {
-	      event_args[type] = arguments;
-	    } else {
-	      return trigger.apply(self, arguments);
-	    }
-	  };
-
-	  // invoke provided function
-	  fn.apply(self, []);
-	  self.trigger = trigger;
-
-	  // trigger queued events
-	  for (type of types) {
-	    if (type in event_args) {
-	      trigger.apply(self, event_args[type]);
-	    }
-	  }
-	};
-
-	/**
-	 * Determines the current selection within a text input control.
-	 * Returns an object containing:
-	 *   - start
-	 *   - length
-	 *
-	 * Note: "selectionStart, selectionEnd ... apply only to inputs of types text, search, URL, tel and password"
-	 * 	- https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/setSelectionRange
-	 */
-	const getSelection = input => {
-	  return {
-	    start: input.selectionStart || 0,
-	    length: (input.selectionEnd || 0) - (input.selectionStart || 0)
-	  };
-	};
-
-	/**
-	 * Prevent default
-	 *
-	 */
-	const preventDefault = (evt, stop = false) => {
-	  if (evt) {
-	    evt.preventDefault();
-	    if (stop) {
-	      evt.stopPropagation();
-	    }
-	  }
-	};
-
-	/**
-	 * Add event helper
-	 *
-	 */
-	const addEvent = (target, type, callback, options) => {
-	  target.addEventListener(type, callback, options);
-	};
-
-	/**
-	 * Return true if the requested key is down
-	 * Will return false if more than one control character is pressed ( when [ctrl+shift+a] != [ctrl+a] )
-	 * The current evt may not always set ( eg calling advanceSelection() )
-	 *
-	 */
-	const isKeyDown = (key_name, evt) => {
-	  if (!evt) {
-	    return false;
-	  }
-	  if (!evt[key_name]) {
-	    return false;
-	  }
-	  var count = (evt.altKey ? 1 : 0) + (evt.ctrlKey ? 1 : 0) + (evt.shiftKey ? 1 : 0) + (evt.metaKey ? 1 : 0);
-	  if (count === 1) {
-	    return true;
-	  }
-	  return false;
-	};
-
-	/**
-	 * Get the id of an element
-	 * If the id attribute is not set, set the attribute with the given id
-	 *
-	 */
-	const getId = (el, id) => {
-	  const existing_id = el.getAttribute('id');
-	  if (existing_id) {
-	    return existing_id;
-	  }
-	  el.setAttribute('id', id);
-	  return id;
-	};
-
-	/**
-	 * Returns a string with backslashes added before characters that need to be escaped.
-	 */
-	const addSlashes = str => {
-	  return str.replace(/[\\"']/g, '\\$&');
-	};
-
-	/**
-	 *
-	 */
-	const append = (parent, node) => {
-	  if (node) parent.append(node);
-	};
-
 	function getSettings(input, settings_user) {
 	  var settings = Object.assign({}, defaults, settings_user);
 	  var attr_data = settings.dataAttr;
@@ -1973,25 +1713,10 @@
 	class TomSelect extends MicroPlugin(MicroEvent) {
 	  constructor(input_arg, user_settings) {
 	    super();
-	    this.control_input = void 0;
-	    this.wrapper = void 0;
-	    this.dropdown = void 0;
-	    this.control = void 0;
-	    this.dropdown_content = void 0;
-	    this.focus_node = void 0;
 	    this.order = 0;
-	    this.settings = void 0;
-	    this.input = void 0;
-	    this.tabIndex = void 0;
-	    this.is_select_tag = void 0;
-	    this.rtl = void 0;
-	    this.inputId = void 0;
-	    this._destroy = void 0;
-	    this.sifter = void 0;
 	    this.isOpen = false;
 	    this.isDisabled = false;
 	    this.isReadOnly = false;
-	    this.isRequired = void 0;
 	    this.isInvalid = false;
 	    // @deprecated 1.8
 	    this.isValid = true;
@@ -2002,7 +1727,6 @@
 	    this.ignoreFocus = false;
 	    this.ignoreHover = false;
 	    this.hasOptions = false;
-	    this.currentResults = void 0;
 	    this.lastValue = '';
 	    this.caretPos = 0;
 	    this.loading = 0;
@@ -2093,7 +1817,7 @@
 
 	      // set attributes
 	      var attrs = ['autocorrect', 'autocapitalize', 'autocomplete', 'spellcheck'];
-	      iterate$1(attrs, attr => {
+	      iterate(attrs, attr => {
 	        if (input.getAttribute(attr)) {
 	          setAttr(control_input, {
 	            [attr]: input.getAttribute(attr)
@@ -2302,7 +2026,6 @@
 	    } else {
 	      self.enable(); //sets tabIndex
 	    }
-
 	    self.on('change', this.onChange);
 	    addClasses(input, 'tomselected', 'ts-hidden-accessible');
 	    self.trigger('initialize');
@@ -2322,7 +2045,7 @@
 	    this.addOptions(options);
 
 	    // build optgroup table
-	    iterate$1(optgroups, optgroup => {
+	    iterate(optgroups, optgroup => {
 	      this.registerOptionGroup(optgroup);
 	    });
 	  }
@@ -2473,7 +2196,7 @@
 	        return;
 	      }
 	      var splitInput = pastedText.trim().split(self.settings.splitOn);
-	      iterate$1(splitInput, piece => {
+	      iterate(splitInput, piece => {
 	        const hash = hash_key(piece);
 	        if (hash) {
 	          if (this.options[piece]) {
@@ -2629,7 +2352,7 @@
 	      return;
 	    }
 	    if (this.refreshTimeout) {
-	      clearTimeout(this.refreshTimeout);
+	      window.clearTimeout(this.refreshTimeout);
 	    }
 	    this.refreshTimeout = timeout(() => {
 	      this.refreshTimeout = null;
@@ -3040,7 +2763,7 @@
 	    self.inputState();
 	    self.close();
 	    self.activeItems = activeItems;
-	    iterate$1(activeItems, item => {
+	    iterate(activeItems, item => {
 	      self.setActiveItemClass(item);
 	    });
 	  }
@@ -3289,7 +3012,7 @@
 
 	    // render optgroup headers & join groups
 	    html = document.createDocumentFragment();
-	    iterate$1(groups_order, group_order => {
+	    iterate(groups_order, group_order => {
 	      let group_fragment = group_order.fragment;
 	      let optgroup = group_order.optgroup;
 	      if (!group_fragment || !group_fragment.children.length) return;
@@ -3315,7 +3038,7 @@
 	    if (self.settings.highlight) {
 	      removeHighlight(dropdown_content);
 	      if (results.query.length && results.tokens.length) {
-	        iterate$1(results.tokens, tok => {
+	        iterate(results.tokens, tok => {
 	          highlight(dropdown_content, tok.regex);
 	        });
 	      }
@@ -3430,7 +3153,7 @@
 	   *
 	   */
 	  addOptions(data, user_created = false) {
-	    iterate$1(data, dat => {
+	    iterate(data, dat => {
 	      this.addOption(dat, user_created);
 	    });
 	  }
@@ -3568,7 +3291,7 @@
 	    this.userOptions = {};
 	    this.clearCache();
 	    const selected = {};
-	    iterate$1(this.options, (option, key) => {
+	    iterate(this.options, (option, key) => {
 	      if (boundFilter(option, key)) {
 	        selected[key] = option;
 	      }
@@ -4032,7 +3755,7 @@
 	    var self = this;
 	    if (!self.items.length) return;
 	    var items = self.controlChildren();
-	    iterate$1(items, item => {
+	    iterate(items, item => {
 	      self.removeItem(item, true);
 	    });
 	    self.inputState();
@@ -4071,7 +3794,7 @@
 	      if (direction > 0) {
 	        caret++;
 	      }
-	      iterate$1(self.activeItems, item => rm_items.push(item));
+	      iterate(self.activeItems, item => rm_items.push(item));
 	    } else if ((self.isFocused || self.settings.mode === 'single') && self.items.length) {
 	      const items = self.controlChildren();
 	      let rm_item;
@@ -4353,7 +4076,7 @@
 	   *
 	   */
 	  clearCache() {
-	    iterate$1(this.options, option => {
+	    iterate(this.options, option => {
 	      if (option.$div) {
 	        option.$div.remove();
 	        delete option.$div;