https://www.myticket.de/assets/myticket/libs/tom-select/dist/js/to…?v=9ce997f9af56631057555b829a79747b9a293c6a

2
3* Licensed under the Apache License, Version 2.0 (the "License");
4*/
5
6(function (global, factory) {
7	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
8	typeof define === 'function' && define.amd ? define(factory) :
9	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.TomSelect = factory());
10})(this, (function () { 'use strict';
11
12	/**
13	 * MicroEvent - to make any js object an event emitter
14	 *
15	 * - pure javascript - server compatible, browser compatible
16	 * - dont rely on the browser doms
17	 * - super simple - you get it immediatly, no mistery, no magic involved
18	 *
19	 * @author Jerome Etienne (https://github.com/jeromeetienne)
20	 */
21
22	/**
23	 * Execute callback for each event in space separated list of event names
24	 *
25	 */
26	function forEvents(events, callback) {
27	  events.split(/\s+/).forEach(event => {
28	    callback(event);
29	  });
30	}
31	class MicroEvent {
32	  constructor() {
33	    this._events = {};
34	  }
35	  on(events, fct) {
36	    forEvents(events, event => {
37	      const event_array = this._events[event] || [];
38	      event_array.push(fct);
39	      this._events[event] = event_array;
40	    });
41	  }
42	  off(events, fct) {
43	    var n = arguments.length;
44	    if (n === 0) {
45	      this._events = {};
46	      return;
47	    }
48	    forEvents(events, event => {
49	      if (n === 1) {
50	        delete this._events[event];
51	        return;
52	      }
53	      const event_array = this._events[event];
54	      if (event_array === undefined) return;
55	      event_array.splice(event_array.indexOf(fct), 1);
56	      this._events[event] = event_array;
57	    });
58	  }
59	  trigger(events, ...args) {
60	    var self = this;
61	    forEvents(events, event => {
62	      const event_array = self._events[event];
63	      if (event_array === undefined) return;
64	      event_array.forEach(fct => {
65	        fct.apply(self, args);
66	      });
67	    });
68	  }
69	}
70
71	/**
72	 * microplugin.js
73	 * Copyright (c) 2013 Brian Reavis & contributors
74	 *
75	 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
76	 * file except in compliance with the License. You may obtain a copy of the License at:
77	 * http://www.apache.org/licenses/LICENSE-2.0
78	 *
79	 * Unless required by applicable law or agreed to in writing, software distributed under
80	 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
81	 * ANY KIND, either express or implied. See the License for the specific language
82	 * governing permissions and limitations under the License.
83	 *
84	 * @author Brian Reavis <[email protected]>
85	 */
86
87	function MicroPlugin(Interface) {
88	  Interface.plugins = {};
89	  return class extends Interface {
90	    constructor(...args) {
91	      super(...args);
92	      this.plugins = {
93	        names: [],
94	        settings: {},
95	        requested: {},
96	        loaded: {}
97	      };
98	    }
99	    /**
100	     * Registers a plugin.
101	     *
102	     * @param {function} fn
103	     */
104	    static define(name, fn) {
105	      Interface.plugins[name] = {
106	        'name': name,
107	        'fn': fn
108	      };
109	    }
110
111	    /**
112	     * Initializes the listed plugins (with options).
113	     * Acceptable formats:
114	     *
115	     * List (without options):
116	     *   ['a', 'b', 'c']
117	     *
118	     * List (with options):
119	     *   [{'name': 'a', options: {}}, {'name': 'b', options: {}}]
120	     *
121	     * Hash (with options):
122	     *   {'a': { ... }, 'b': { ... }, 'c': { ... }}
123	     *
124	     * @param {array|object} plugins
125	     */
126	    initializePlugins(plugins) {
127	      var key, name;
128	      const self = this;
129	      const queue = [];
130	      if (Array.isArray(plugins)) {
131	        plugins.forEach(plugin => {
132	          if (typeof plugin === 'string') {
133	            queue.push(plugin);
134	          } else {
135	            self.plugins.settings[plugin.name] = plugin.options;
136	            queue.push(plugin.name);
137	          }
138	        });
139	      } else if (plugins) {
140	        for (key in plugins) {
141	          if (plugins.hasOwnProperty(key)) {
142	            self.plugins.settings[key] = plugins[key];
143	            queue.push(key);
144	          }
145	        }
146	      }
147	      while (name = queue.shift()) {
148	        self.require(name);
149	      }
150	    }
151	    loadPlugin(name) {
152	      var self = this;
153	      var plugins = self.plugins;
154	      var plugin = Interface.plugins[name];
155	      if (!Interface.plugins.hasOwnProperty(name)) {
156	        throw new Error('Unable to find "' + name + '" plugin');
157	      }
158	      plugins.requested[name] = true;
159	      plugins.loaded[name] = plugin.fn.apply(self, [self.plugins.settings[name] || {}]);
160	      plugins.names.push(name);
161	    }
162
163	    /**
164	     * Initializes a plugin.
165	     *
166	     */
167	    require(name) {
168	      var self = this;
169	      var plugins = self.plugins;
170	      if (!self.plugins.loaded.hasOwnProperty(name)) {
171	        if (plugins.requested[name]) {
172	          throw new Error('Plugin has circular dependency ("' + name + '")');
173	        }
174	        self.loadPlugin(name);
175	      }
176	      return plugins.loaded[name];
177	    }
178	  };
179	}
180
181	/**
182	 * Convert array of strings to a regular expression
183	 *	ex ['ab','a'] => (?:ab|a)
184	 * 	ex ['a','b'] => [ab]
185	 */
186	const arrayToPattern = (chars) => {
187	    chars = chars.filter(Boolean);
188	    if (chars.length < 2) {
189	        return chars[0] || '';
190	    }
191	    return (maxValueLength(chars) == 1) ? '[' + chars.join('') + ']' : '(?:' + chars.join('|') + ')';
192	};
193	const sequencePattern = (array) => {
194	    if (!hasDuplicates(array)) {
195	        return array.join('');
196	    }
197	    let pattern = '';
198	    let prev_char_count = 0;
199	    const prev_pattern = () => {
200	        if (prev_char_count > 1) {
201	            pattern += '{' + prev_char_count + '}';
202	        }
203	    };
204	    array.forEach((char, i) => {
205	        if (char === array[i - 1]) {
206	            prev_char_count++;
207	            return;
208	        }
209	        prev_pattern();
210	        pattern += char;
211	        prev_char_count = 1;
212	    });
213	    prev_pattern();
214	    return pattern;
215	};
216	/**
217	 * Convert array of strings to a regular expression
218	 *	ex ['ab','a'] => (?:ab|a)
219	 * 	ex ['a','b'] => [ab]
220	 */
221	const setToPattern = (chars) => {
222	    let array = Array.from(chars);
223	    return arrayToPattern(array);
224	};
225	/**
226	 * https://stackoverflow.com/questions/7376598/in-javascript-how-do-i-check-if-an-array-has-duplicate-values
227	 */
228	const hasDuplicates = (array) => {
229	    return (new Set(array)).size !== array.length;
230	};
231	/**
232	 * https://stackoverflow.com/questions/63006601/why-does-u-throw-an-invalid-escape-error
233	 */
234	const escape_regex = (str) => {
235	    return (str + '').replace(/([\$\(\)\*\+\.\?\[\]\^\{\|\}\\])/gu, '\\$1');
236	};
237	/**
238	 * Return the max length of array values
239	 */
240	const maxValueLength = (array) => {
241	    return array.reduce((longest, value) => Math.max(longest, unicodeLength(value)), 0);
242	};
243	const unicodeLength = (str) => {
244	    return Array.from(str).length;
245	};
246
247	/**
248	 * Get all possible combinations of substrings that add up to the given string
249	 * https://stackoverflow.com/questions/30169587/find-all-the-combination-of-substrings-that-add-up-to-the-given-string
250	 */
251	const allSubstrings = (input) => {
252	    if (input.length === 1)
253	        return [[input]];
254	    let result = [];
255	    const start = input.substring(1);
256	    const suba = allSubstrings(start);
257	    suba.forEach(function (subresult) {
258	        let tmp = subresult.slice(0);
259	        tmp[0] = input.charAt(0) + tmp[0];
260	        result.push(tmp);
261	        tmp = subresult.slice(0);
262	        tmp.unshift(input.charAt(0));
263	        result.push(tmp);
264	    });
265	    return result;
266	};
267
268	const code_points = [[0, 65535]];
269	const accent_pat = '[\u0300-\u036F\u{b7}\u{2be}\u{2bc}]';
270	let unicode_map;
271	let multi_char_reg;
272	const max_char_length = 3;
273	const latin_convert = {};
274	const latin_condensed = {
275	    '/': '⁄∕',
276	    '0': '߀',
277	    "a": "ⱥɐɑ",
278	    "aa": "ꜳ",
279	    "ae": "æǽǣ",
280	    "ao": "ꜵ",
281	    "au": "ꜷ",
282	    "av": "ꜹꜻ",
283	    "ay": "ꜽ",
284	    "b": "ƀɓƃ",
285	    "c": "ꜿƈȼↄ",
286	    "d": "đɗɖᴅƌꮷԁɦ",
287	    "e": "ɛǝᴇɇ",
288	    "f": "ꝼƒ",
289	    "g": "ǥɠꞡᵹꝿɢ",
290	    "h": "ħⱨⱶɥ",
291	    "i": "ɨı",
292	    "j": "ɉȷ",
293	    "k": "ƙⱪꝁꝃꝅꞣ",
294	    "l": "łƚɫⱡꝉꝇꞁɭ",
295	    "m": "ɱɯϻ",
296	    "n": "ꞥƞɲꞑᴎлԉ",
297	    "o": "øǿɔɵꝋꝍᴑ",
298	    "oe": "œ",
299	    "oi": "Æ£",
300	    "oo": "ꝏ",
301	    "ou": "È£",
302	    "p": "ƥᵽꝑꝓꝕρ",
303	    "q": "ꝗꝙɋ",
304	    "r": "ɍɽꝛꞧꞃ",
305	    "s": "ßȿꞩꞅʂ",
306	    "t": "ŧƭʈⱦꞇ",
307	    "th": "þ",
308	    "tz": "ꜩ",
309	    "u": "ʉ",
310	    "v": "ʋꝟʌ",
311	    "vy": "ꝡ",
312	    "w": "â±³",
313	    "y": "ƴɏỿ",
314	    "z": "ƶȥɀⱬꝣ",
315	    "hv": "ƕ"
316	};
317	for (let latin in latin_condensed) {
318	    let unicode = latin_condensed[latin] || '';
319	    for (let i = 0; i < unicode.length; i++) {
320	        let char = unicode.substring(i, i + 1);
321	        latin_convert[char] = latin;
322	    }
323	}
324	const convert_pat = new RegExp(Object.keys(latin_convert).join('|') + '|' + accent_pat, 'gu');
325	/**
326	 * Initialize the unicode_map from the give code point ranges
327	 */
328	const initialize = (_code_points) => {
329	    if (unicode_map !== undefined)
330	        return;
331	    unicode_map = generateMap(code_points);
332	};
333	/**
334	 * Helper method for normalize a string
335	 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize
336	 */
337	const normalize = (str, form = 'NFKD') => str.normalize(form);
338	/**
339	 * Remove accents without reordering string
340	 * calling str.normalize('NFKD') on \u{594}\u{595}\u{596} becomes \u{596}\u{594}\u{595}
341	 * via https://github.com/krisk/Fuse/issues/133#issuecomment-318692703
342	 */
343	const asciifold = (str) => {
344	    return Array.from(str).reduce(
345	    /**
346	     * @param {string} result
347	     * @param {string} char
348	     */
349	    (result, char) => {
350	        return result + _asciifold(char);
351	    }, '');
352	};
353	const _asciifold = (str) => {
354	    str = normalize(str)
355	        .toLowerCase()
356	        .replace(convert_pat, (/** @type {string} */ char) => {
357	        return latin_convert[char] || '';
358	    });
359	    //return str;
360	    return normalize(str, 'NFC');
361	};
362	/**
363	 * Generate a list of unicode variants from the list of code points
364	 */
365	function* generator(code_points) {
366	    for (const [code_point_min, code_point_max] of code_points) {
367	        for (let i = code_point_min; i <= code_point_max; i++) {
368	            let composed = String.fromCharCode(i);
369	            let folded = asciifold(composed);
370	            if (folded == composed.toLowerCase()) {
371	                continue;
372	            }
373	            // skip when folded is a string longer than 3 characters long
374	            // bc the resulting regex patterns will be long
375	            // eg:
376	            // folded صلى الله عليه وسلم length 18 code point 65018
377	            // folded جل جلاله length 8 code point 65019
378	            if (folded.length > max_char_length) {
379	                continue;
380	            }
381	            if (folded.length == 0) {
382	                continue;
383	            }
384	            yield { folded: folded, composed: composed, code_point: i };
385	        }
386	    }
387	}
388	/**
389	 * Generate a unicode map from the list of code points
390	 */
391	const generateSets = (code_points) => {
392	    const unicode_sets = {};
393	    const addMatching = (folded, to_add) => {
394	        /** @type {Set<string>} */
395	        const folded_set = unicode_sets[folded] || new Set();
396	        const patt = new RegExp('^' + setToPattern(folded_set) + '$', 'iu');
397	        if (to_add.match(patt)) {
398	            return;
399	        }
400	        folded_set.add(escape_regex(to_add));
401	        unicode_sets[folded] = folded_set;
402	    };
403	    for (let value of generator(code_points)) {
404	        addMatching(value.folded, value.folded);
405	        addMatching(value.folded, value.composed);
406	    }
407	    return unicode_sets;
408	};
409	/**
410	 * Generate a unicode map from the list of code points
411	 * ae => (?:(?:ae|Æ|Ǽ|Ǣ)|(?:A|Ⓐ|Ａ...)(?:E|ɛ|Ⓔ...))
412	 */
413	const generateMap = (code_points) => {
414	    const unicode_sets = generateSets(code_points);
415	    const unicode_map = {};
416	    let multi_char = [];
417	    for (let folded in unicode_sets) {
418	        let set = unicode_sets[folded];
419	        if (set) {
420	            unicode_map[folded] = setToPattern(set);
421	        }
422	        if (folded.length > 1) {
423	            multi_char.push(escape_regex(folded));
424	        }
425	    }
426	    multi_char.sort((a, b) => b.length - a.length);
427	    const multi_char_patt = arrayToPattern(multi_char);
428	    multi_char_reg = new RegExp('^' + multi_char_patt, 'u');
429	    return unicode_map;
430	};
431	/**
432	 * Map each element of an array from its folded value to all possible unicode matches
433	 */
434	const mapSequence = (strings, min_replacement = 1) => {
435	    let chars_replaced = 0;
436	    strings = strings.map((str) => {
437	        if (unicode_map[str]) {
438	            chars_replaced += str.length;
439	        }
440	        return unicode_map[str] || str;
441	    });
442	    if (chars_replaced >= min_replacement) {
443	        return sequencePattern(strings);
444	    }
445	    return '';
446	};
447	/**
448	 * Convert a short string and split it into all possible patterns
449	 * Keep a pattern only if min_replacement is met
450	 *
451	 * 'abc'
452	 * 		=> [['abc'],['ab','c'],['a','bc'],['a','b','c']]
453	 *		=> ['abc-pattern','ab-c-pattern'...]
454	 */
455	const substringsToPattern = (str, min_replacement = 1) => {
456	    min_replacement = Math.max(min_replacement, str.length - 1);
457	    return arrayToPattern(allSubstrings(str).map((sub_pat) => {
458	        return mapSequence(sub_pat, min_replacement);
459	    }));
460	};
461	/**
462	 * Convert an array of sequences into a pattern
463	 * [{start:0,end:3,length:3,substr:'iii'}...] => (?:iii...)
464	 */
465	const sequencesToPattern = (sequences, all = true) => {
466	    let min_replacement = sequences.length > 1 ? 1 : 0;
467	    return arrayToPattern(sequences.map((sequence) => {
468	        let seq = [];
469	        const len = all ? sequence.length() : sequence.length() - 1;
470	        for (let j = 0; j < len; j++) {
471	            seq.push(substringsToPattern(sequence.substrs[j] || '', min_replacement));
472	        }
473	        return sequencePattern(seq);
474	    }));
475	};
476	/**
477	 * Return true if the sequence is already in the sequences
478	 */
479	const inSequences = (needle_seq, sequences) => {
480	    for (const seq of sequences) {
481	        if (seq.start != needle_seq.start || seq.end != needle_seq.end) {
482	            continue;
483	        }
484	        if (seq.substrs.join('') !== needle_seq.substrs.join('')) {
485	            continue;
486	        }
487	        let needle_parts = needle_seq.parts;
488	        const filter = (part) => {
489	            for (const needle_part of needle_parts) {
490	                if (needle_part.start === part.start && needle_part.substr === part.substr) {
491	                    return false;
492	                }
493	                if (part.length == 1 || needle_part.length == 1) {
494	                    continue;
495	                }
496	                // check for overlapping parts
497	                // a = ['::=','==']
498	                // b = ['::','===']
499	                // a = ['r','sm']
500	                // b = ['rs','m']
501	                if (part.start < needle_part.start && part.end > needle_part.start) {
502	                    return true;
503	                }
504	                if (needle_part.start < part.start && needle_part.end > part.start) {
505	                    return true;
506	                }
507	            }
508	            return false;
509	        };
510	        let filtered = seq.parts.filter(filter);
511	        if (filtered.length > 0) {
512	            continue;
513	        }
514	        return true;
515	    }
516	    return false;
517	};
518	class Sequence {
519	    parts;
520	    substrs;
521	    start;
522	    end;
523	    constructor() {
524	        this.parts = [];
525	        this.substrs = [];
526	        this.start = 0;
527	        this.end = 0;
528	    }
529	    add(part) {
530	        if (part) {
531	            this.parts.push(part);
532	            this.substrs.push(part.substr);
533	            this.start = Math.min(part.start, this.start);
534	            this.end = Math.max(part.end, this.end);
535	        }
536	    }
537	    last() {
538	        return this.parts[this.parts.length - 1];
539	    }
540	    length() {
541	        return this.parts.length;
542	    }
543	    clone(position, last_piece) {
544	        let clone = new Sequence();
545	        let parts = JSON.parse(JSON.stringify(this.parts));
546	        let last_part = parts.pop();
547	        for (const part of parts) {
548	            clone.add(part);
549	        }
550	        let last_substr = last_piece.substr.substring(0, position - last_part.start);
551	        let clone_last_len = last_substr.length;
552	        clone.add({ start: last_part.start, end: last_part.start + clone_last_len, length: clone_last_len, substr: last_substr });
553	        return clone;
554	    }
555	}
556	/**
557	 * Expand a regular expression pattern to include unicode variants
558	 * 	eg /a/ becomes /aⓐａẚàáâầấẫẩãāăằắẵẳȧǡäǟảåǻǎȁȃạậặḁąⱥɐɑAⒶＡÀÁÂẦẤẪẨÃĀĂẰẮẴẲȦǠÄǞẢÅǺǍȀȂẠẬẶḀĄȺⱯ/
559	 *
560	 * Issue:
561	 *  ﺊﺋ [ 'ﺊ = \\u{fe8a}', 'ﺋ = \\u{fe8b}' ]
562	 *	becomes:	ئئ [ 'ي = \\u{64a}', 'ٔ = \\u{654}', 'ي = \\u{64a}', 'ٔ = \\u{654}' ]
563	 *
564	 *	İIJ = IIJ = ⅡJ
565	 *
566	 * 	1/2/4
567	 */
568	const getPattern = (str) => {
569	    initialize();
570	    str = asciifold(str);
571	    let pattern = '';
572	    let sequences = [new Sequence()];
573	    for (let i = 0; i < str.length; i++) {
574	        let substr = str.substring(i);
575	        let match = substr.match(multi_char_reg);
576	        const char = str.substring(i, i + 1);
577	        const match_str = match ? match[0] : null;
578	        // loop through sequences
579	        // add either the char or multi_match
580	        let overlapping = [];
581	        let added_types = new Set();
582	        for (const sequence of sequences) {
583	            const last_piece = sequence.last();
584	            if (!last_piece || last_piece.length == 1 || last_piece.end <= i) {
585	                // if we have a multi match
586	                if (match_str) {
587	                    const len = match_str.length;
588	                    sequence.add({ start: i, end: i + len, length: len, substr: match_str });
589	                    added_types.add('1');
590	                }
591	                else {
592	                    sequence.add({ start: i, end: i + 1, length: 1, substr: char });
593	                    added_types.add('2');
594	                }
595	            }
596	            else if (match_str) {
597	                let clone = sequence.clone(i, last_piece);
598	                const len = match_str.length;
599	                clone.add({ start: i, end: i + len, length: len, substr: match_str });
600	                overlapping.push(clone);
601	            }
602	            else {
603	                // don't add char
604	                // adding would create invalid patterns: 234 => [2,34,4]
605	                added_types.add('3');
606	            }
607	        }
608	        // if we have overlapping
609	        if (overlapping.length > 0) {
610	            // ['ii','iii'] before ['i','i','iii']
611	            overlapping = overlapping.sort((a, b) => {
612	                return a.length() - b.length();
613	            });
614	            for (let clone of overlapping) {
615	                // don't add if we already have an equivalent sequence
616	                if (inSequences(clone, sequences)) {
617	                    continue;
618	                }
619	                sequences.push(clone);
620	            }
621	            continue;
622	        }
623	        // if we haven't done anything unique
624	        // clean up the patterns
625	        // helps keep patterns smaller
626	        // if str = 'r₨㎧aarss', pattern will be 446 instead of 655
627	        if (i > 0 && added_types.size == 1 && !added_types.has('3')) {
628	            pattern += sequencesToPattern(sequences, false);
629	            let new_seq = new Sequence();
630	            const old_seq = sequences[0];
631	            if (old_seq) {
632	                new_seq.add(old_seq.last());
633	            }
634	            sequences = [new_seq];
635	        }
636	    }
637	    pattern += sequencesToPattern(sequences, true);
638	    return pattern;
639	};
640
641	/**
642	 * A property getter resolving dot-notation
643	 * @param  {Object}  obj     The root object to fetch property on
644	 * @param  {String}  name    The optionally dotted property name to fetch
645	 * @return {Object}          The resolved property value
646	 */
647	const getAttr = (obj, name) => {
648	    if (!obj)
649	        return;
650	    return obj[name];
651	};
652	/**
653	 * A property getter resolving dot-notation
654	 * @param  {Object}  obj     The root object to fetch property on
655	 * @param  {String}  name    The optionally dotted property name to fetch
656	 * @return {Object}          The resolved property value
657	 */
658	const getAttrNesting = (obj, name) => {
659	    if (!obj)
660	        return;
661	    var part, names = name.split(".");
662	    while ((part = names.shift()) && (obj = obj[part]))
663	        ;
664	    return obj;
665	};
666	/**
667	 * Calculates how close of a match the
668	 * given value is against a search token.
669	 *
670	 */
671	const scoreValue = (value, token, weight) => {
672	    var score, pos;
673	    if (!value)
674	        return 0;
675	    value = value + '';
676	    if (token.regex == null)
677	        return 0;
678	    pos = value.search(token.regex);
679	    if (pos === -1)
680	        return 0;
681	    score = token.string.length / value.length;
682	    if (pos === 0)
683	        score += 0.5;
684	    return score * weight;
685	};
686	/**
687	 * Cast object property to an array if it exists and has a value
688	 *
689	 */
690	const propToArray = (obj, key) => {
691	    var value = obj[key];
692	    if (typeof value == 'function')
693	        return value;
694	    if (value && !Array.isArray(value)) {
695	        obj[key] = [value];
696	    }
697	};
698	/**
699	 * Iterates over arrays and hashes.
700	 *
701	 * ```
702	 * iterate(this.items, function(item, id) {
703	 *    // invoked for each item
704	 * });
705	 * ```
706	 *
707	 */
708	const iterate$1 = (object, callback) => {
709	    if (Array.isArray(object)) {
710	        object.forEach(callback);
711	    }
712	    else {
713	        for (var key in object) {
714	            if (object.hasOwnProperty(key)) {
715	                callback(object[key], key);
716	            }
717	        }
718	    }
719	};
720	const cmp = (a, b) => {
721	    if (typeof a === 'number' && typeof b === 'number') {
722	        return a > b ? 1 : (a < b ? -1 : 0);
723	    }
724	    a = asciifold(a + '').toLowerCase();
725	    b = asciifold(b + '').toLowerCase();
726	    if (a > b)
727	        return 1;
728	    if (b > a)
729	        return -1;
730	    return 0;
731	};
732
733	/**
734	 * sifter.js
735	 * Copyright (c) 2013–2020 Brian Reavis & contributors
736	 *
737	 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
738	 * file except in compliance with the License. You may obtain a copy of the License at:
739	 * http://www.apache.org/licenses/LICENSE-2.0
740	 *
741	 * Unless required by applicable law or agreed to in writing, software distributed under
742	 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
743	 * ANY KIND, either express or implied. See the License for the specific language
744	 * governing permissions and limitations under the License.
745	 *
746	 * @author Brian Reavis <[email protected]>
747	 */
748	class Sifter {
749	    items; // []|{};
750	    settings;
751	    /**
752	     * Textually searches arrays and hashes of objects
753	     * by property (or multiple properties). Designed
754	     * specifically for autocomplete.
755	     *
756	     */
757	    constructor(items, settings) {
758	        this.items = items;
759	        this.settings = settings || { diacritics: true };
760	    }
761	    ;
762	    /**
763	     * Splits a search string into an array of individual
764	     * regexps to be used to match results.
765	     *
766	     */
767	    tokenize(query, respect_word_boundaries, weights) {
768	        if (!query || !query.length)
769	            return [];
770	        const tokens = [];
771	        const words = query.split(/\s+/);
772	        var field_regex;
773	        if (weights) {
774	            field_regex = new RegExp('^(' + Object.keys(weights).map(escape_regex).join('|') + ')\:(.*)$');
775	        }
776	        words.forEach((word) => {
777	            let field_match;
778	            let field = null;
779	            let regex = null;
780	            // look for "field:query" tokens
781	            if (field_regex && (field_match = word.match(field_regex))) {
782	                field = field_match[1];
783	                word = field_match[2];
784	            }
785	            if (word.length > 0) {
786	                if (this.settings.diacritics) {
787	                    regex = getPattern(word) || null;
788	                }
789	                else {
790	                    regex = escape_regex(word);
791	                }
792	                if (regex && respect_word_boundaries)
793	                    regex = "\\b" + regex;
794	            }
795	            tokens.push({
796	                string: word,
797	                regex: regex ? new RegExp(regex, 'iu') : null,
798	                field: field,
799	            });
800	        });
801	        return tokens;
802	    }
803	    ;
804	    /**
805	     * Returns a function to be used to score individual results.
806	     *
807	     * Good matches will have a higher score than poor matches.
808	     * If an item is not a match, 0 will be returned by the function.
809	     *
810	     * @returns {T.ScoreFn}
811	     */
812	    getScoreFunction(query, options) {
813	        var search = this.prepareSearch(query, options);
814	        return this._getScoreFunction(search);
815	    }
816	    /**
817	     * @returns {T.ScoreFn}
818	     *
819	     */
820	    _getScoreFunction(search) {
821	        const tokens = search.tokens, token_count = tokens.length;
822	        if (!token_count) {
823	            return function () { return 0; };
824	        }
825	        const fields = search.options.fields, weights = search.weights, field_count = fields.length, getAttrFn = search.getAttrFn;
826	        if (!field_count) {
827	            return function () { return 1; };
828	        }
829	        /**
830	         * Calculates the score of an object
831	         * against the search query.
832	         *
833	         */
834	        const scoreObject = (function () {
835	            if (field_count === 1) {
836	                return function (token, data) {
837	                    const field = fields[0].field;
838	                    return scoreValue(getAttrFn(data, field), token, weights[field] || 1);
839	                };
840	            }
841	            return function (token, data) {
842	                var sum = 0;
843	                // is the token specific to a field?
844	                if (token.field) {
845	                    const value = getAttrFn(data, token.field);
846	                    if (!token.regex && value) {
847	                        sum += (1 / field_count);
848	                    }
849	                    else {
850	                        sum += scoreValue(value, token, 1);
851	                    }
852	                }
853	                else {
854	                    iterate$1(weights, (weight, field) => {
855	                        sum += scoreValue(getAttrFn(data, field), token, weight);
856	                    });
857	                }
858	                return sum / field_count;
859	            };
860	        })();
861	        if (token_count === 1) {
862	            return function (data) {
863	                return scoreObject(tokens[0], data);
864	            };
865	        }
866	        if (search.options.conjunction === 'and') {
867	            return function (data) {
868	                var score, sum = 0;
869	                for (let token of tokens) {
870	                    score = scoreObject(token, data);
871	                    if (score <= 0)
872	                        return 0;
873	                    sum += score;
874	                }
875	                return sum / token_count;
876	            };
877	        }
878	        else {
879	            return function (data) {
880	                var sum = 0;
881	                iterate$1(tokens, (token) => {
882	                    sum += scoreObject(token, data);
883	                });
884	                return sum / token_count;
885	            };
886	        }
887	    }
888	    ;
889	    /**
890	     * Returns a function that can be used to compare two
891	     * results, for sorting purposes. If no sorting should
892	     * be performed, `null` will be returned.
893	     *
894	     * @return function(a,b)
895	     */
896	    getSortFunction(query, options) {
897	        var search = this.prepareSearch(query, options);
898	        return this._getSortFunction(search);
899	    }
900	    _getSortFunction(search) {
901	        var implicit_score, sort_flds = [];
902	        const self = this, options = search.options, sort = (!search.query && options.sort_empty) ? options.sort_empty : options.sort;
903	        if (typeof sort == 'function') {
904	            return sort.bind(this);
905	        }
906	        /**
907	         * Fetches the specified sort field value
908	         * from a search result item.
909	         *
910	         */
911	        const get_field = function (name, result) {
912	            if (name === '$score')
913	                return result.score;
914	            return search.getAttrFn(self.items[result.id], name);
915	        };
916	        // parse options
917	        if (sort) {
918	            for (let s of sort) {
919	                if (search.query || s.field !== '$score') {
920	                    sort_flds.push(s);
921	                }
922	            }
923	        }
924	        // the "$score" field is implied to be the primary
925	        // sort field, unless it's manually specified
926	        if (search.query) {
927	            implicit_score = true;
928	            for (let fld of sort_flds) {
929	                if (fld.field === '$score') {
930	                    implicit_score = false;
931	                    break;
932	                }
933	            }
934	            if (implicit_score) {
935	                sort_flds.unshift({ field: '$score', direction: 'desc' });
936	            }
937	            // without a search.query, all items will have the same score
938	        }
939	        else {
940	            sort_flds = sort_flds.filter((fld) => fld.field !== '$score');
941	        }
942	        // build function
943	        const sort_flds_count = sort_flds.length;
944	        if (!sort_flds_count) {
945	            return null;
946	        }
947	        return function (a, b) {
948	            var result, field;
949	            for (let sort_fld of sort_flds) {
950	                field = sort_fld.field;
951	                let multiplier = sort_fld.direction === 'desc' ? -1 : 1;
952	                result = multiplier * cmp(get_field(field, a), get_field(field, b));
953	                if (result)
954	                    return result;
955	            }
956	            return 0;
957	        };
958	    }
959	    ;
960	    /**
961	     * Parses a search query and returns an object
962	     * with tokens and fields ready to be populated
963	     * with results.
964	     *
965	     */
966	    prepareSearch(query, optsUser) {
967	        const weights = {};
968	        var options = Object.assign({}, optsUser);
969	        propToArray(options, 'sort');
970	        propToArray(options, 'sort_empty');
971	        // convert fields to new format
972	        if (options.fields) {
973	            propToArray(options, 'fields');
974	            const fields = [];
975	            options.fields.forEach((field) => {
976	                if (typeof field == 'string') {
977	                    field = { field: field, weight: 1 };
978	                }
979	                fields.push(field);
980	                weights[field.field] = ('weight' in field) ? field.weight : 1;
981	            });
982	            options.fields = fields;
983	        }
984	        return {
985	            options: options,
986	            query: query.toLowerCase().trim(),
987	            tokens: this.tokenize(query, options.respect_word_boundaries, weights),
988	            total: 0,
989	            items: [],
990	            weights: weights,
991	            getAttrFn: (options.nesting) ? getAttrNesting : getAttr,
992	        };
993	    }
994	    ;
995	    /**
996	     * Searches through all items and returns a sorted array of matches.
997	     *
998	     */
999	    search(query, options) {
1000	        var self = this, score, search;
1001	        search = this.prepareSearch(query, options);
1002	        options = search.options;
1003	        query = search.query;
1004	        // generate result scoring function
1005	        const fn_score = options.score || self._getScoreFunction(search);
1006	        // perform search and sort
1007	        if (query.length) {
1008	            iterate$1(self.items, (item, id) => {
1009	                score = fn_score(item);
1010	                if (options.filter === false || score > 0) {
1011	                    search.items.push({ 'score': score, 'id': id });
1012	                }
1013	            });
1014	        }
1015	        else {
1016	            iterate$1(self.items, (_, id) => {
1017	                search.items.push({ 'score': 1, 'id': id });
1018	            });
1019	        }
1020	        const fn_sort = self._getSortFunction(search);
1021	        if (fn_sort)
1022	            search.items.sort(fn_sort);
1023	        // apply limits
1024	        search.total = search.items.length;
1025	        if (typeof options.limit === 'number') {
1026	            search.items = search.items.slice(0, options.limit);
1027	        }
1028	        return search;
1029	    }
1030	    ;
1031	}
1032
1033	/**
1034	 * Converts a scalar to its best string representation
1035	 * for hash keys and HTML attribute values.
1036	 *
1037	 * Transformations:
1038	 *   'str'     -> 'str'
1039	 *   null      -> ''
1040	 *   undefined -> ''
1041	 *   true      -> '1'
1042	 *   false     -> '0'
1043	 *   0         -> '0'
1044	 *   1         -> '1'
1045	 *
1046	 */
1047	const hash_key = value => {
1048	  if (typeof value === 'undefined' || value === null) return null;
1049	  return get_hash(value);
1050	};
1051	const get_hash = value => {
1052	  if (typeof value === 'boolean') return value ? '1' : '0';
1053	  return value + '';
1054	};
1055
1056	/**
1057	 * Escapes a string for use within HTML.
1058	 *
1059	 */
1060	const escape_html = str => {
1061	  return (str + '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
1062	};
1063
1064	/**
1065	 * use setTimeout if timeout > 0 
1066	 */
1067	const timeout = (fn, timeout) => {
1068	  if (timeout > 0) {
1069	    return window.setTimeout(fn, timeout);
1070	  }
1071	  fn.call(null);
1072	  return null;
1073	};
1074
1075	/**
1076	 * Debounce the user provided load function
1077	 *
1078	 */
1079	const loadDebounce = (fn, delay) => {
1080	  var timeout;
1081	  return function (value, callback) {
1082	    var self = this;
1083	    if (timeout) {
1084	      self.loading = Math.max(self.loading - 1, 0);
1085	      clearTimeout(timeout);
1086	    }
1087	    timeout = setTimeout(function () {
1088	      timeout = null;
1089	      self.loadedSearches[value] = true;
1090	      fn.call(self, value, callback);
1091	    }, delay);
1092	  };
1093	};
1094
1095	/**
1096	 * Debounce all fired events types listed in `types`
1097	 * while executing the provided `fn`.
1098	 *
1099	 */
1100	const debounce_events = (self, types, fn) => {
1101	  var type;
1102	  var trigger = self.trigger;
1103	  var event_args = {};
1104
1105	  // override trigger method
1106	  self.trigger = function () {
1107	    var type = arguments[0];
1108	    if (types.indexOf(type) !== -1) {
1109	      event_args[type] = arguments;
1110	    } else {
1111	      return trigger.apply(self, arguments);
1112	    }
1113	  };
1114
1115	  // invoke provided function
1116	  fn.apply(self, []);
1117	  self.trigger = trigger;
1118
1119	  // trigger queued events
1120	  for (type of types) {
1121	    if (type in event_args) {
1122	      trigger.apply(self, event_args[type]);
1123	    }
1124	  }
1125	};
1126
1127	/**
1128	 * Determines the current selection within a text input control.
1129	 * Returns an object containing:
1130	 *   - start
1131	 *   - length
1132	 *
1133	 * Note: "selectionStart, selectionEnd ... apply only to inputs of types text, search, URL, tel and password"
1134	 * 	- https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/setSelectionRange
1135	 */
1136	const getSelection = input => {
1137	  return {
1138	    start: input.selectionStart || 0,
1139	    length: (input.selectionEnd || 0) - (input.selectionStart || 0)
1140	  };
1141	};
1142
1143	/**
1144	 * Prevent default
1145	 *
1146	 */
1147	const preventDefault = (evt, stop = false) => {
1148	  if (evt) {
1149	    evt.preventDefault();
1150	    if (stop) {
1151	      evt.stopPropagation();
1152	    }
1153	  }
1154	};
1155
1156	/**
1157	 * Add event helper
1158	 *
1159	 */
1160	const addEvent = (target, type, callback, options) => {
1161	  target.addEventListener(type, callback, options);
1162	};
1163
1164	/**
1165	 * Return true if the requested key is down
1166	 * Will return false if more than one control character is pressed ( when [ctrl+shift+a] != [ctrl+a] )
1167	 * The current evt may not always set ( eg calling advanceSelection() )
1168	 *
1169	 */
1170	const isKeyDown = (key_name, evt) => {
1171	  if (!evt) {
1172	    return false;
1173	  }
1174	  if (!evt[key_name]) {
1175	    return false;
1176	  }
1177	  var count = (evt.altKey ? 1 : 0) + (evt.ctrlKey ? 1 : 0) + (evt.shiftKey ? 1 : 0) + (evt.metaKey ? 1 : 0);
1178	  if (count === 1) {
1179	    return true;
1180	  }
1181	  return false;
1182	};
1183
1184	/**
1185	 * Get the id of an element
1186	 * If the id attribute is not set, set the attribute with the given id
1187	 *
1188	 */
1189	const getId = (el, id) => {
1190	  const existing_id = el.getAttribute('id');
1191	  if (existing_id) {
1192	    return existing_id;
1193	  }
1194	  el.setAttribute('id', id);
1195	  return id;
1196	};
1197
1198	/**
1199	 * Returns a string with backslashes added before characters that need to be escaped.
1200	 */
1201	const addSlashes = str => {
1202	  return str.replace(/[\\"']/g, '\\$&');
1203	};
1204
1205	/**
1206	 *
1207	 */
1208	const append = (parent, node) => {
1209	  if (node) parent.append(node);
1210	};
1211
1212	/**
1213	 * Iterates over arrays and hashes.
1214	 *
1215	 * ```
1216	 * iterate(this.items, function(item, id) {
1217	 *    // invoked for each item
1218	 * });
1219	 * ```
1220	 *
1221	 */
1222	const iterate = (object, callback) => {
1223	  if (Array.isArray(object)) {
1224	    object.forEach(callback);
1225	  } else {
1226	    for (var key in object) {
1227	      if (object.hasOwnProperty(key)) {
1228	        callback(object[key], key);
1229	      }
1230	    }
1231	  }
1232	};
1233
1234	/**
1235	 * Return a dom element from either a dom query string, jQuery object, a dom element or html string
1236	 * https://stackoverflow.com/questions/494143/creating-a-new-dom-element-from-an-html-string-using-built-in-dom-methods-or-pro/35385518#35385518
1237	 *
1238	 * param query should be {}
1239	 */
1240	const getDom = query => {
1241	  if (query.jquery) {
1242	    return query[0];
1243	  }
1244	  if (query instanceof HTMLElement) {
1245	    return query;
1246	  }
1247	  if (isHtmlString(query)) {
1248	    var tpl = document.createElement('template');
1249	    tpl.innerHTML = query.trim(); // Never return a text node of whitespace as the result
1250	    return tpl.content.firstChild;
1251	  }
1252	  return document.querySelector(query);
1253	};
1254	const isHtmlString = arg => {
1255	  if (typeof arg === 'string' && arg.indexOf('<') > -1) {
1256	    return true;
1257	  }
1258	  return false;
1259	};
1260	const escapeQuery = query => {
1261	  return query.replace(/['"\\]/g, '\\$&');
1262	};
1263
1264	/**
1265	 * Dispatch an event
1266	 *
1267	 */
1268	const triggerEvent = (dom_el, event_name) => {
1269	  var event = document.createEvent('HTMLEvents');
1270	  event.initEvent(event_name, true, false);
1271	  dom_el.dispatchEvent(event);
1272	};
1273
1274	/**
1275	 * Apply CSS rules to a dom element
1276	 *
1277	 */
1278	const applyCSS = (dom_el, css) => {
1279	  Object.assign(dom_el.style, css);
1280	};
1281
1282	/**
1283	 * Add css classes
1284	 *
1285	 */
1286	const addClasses = (elmts, ...classes) => {
1287	  var norm_classes = classesArray(classes);
1288	  elmts = castAsArray(elmts);
1289	  elmts.map(el => {
1290	    norm_classes.map(cls => {
1291	      el.classList.add(cls);
1292	    });
1293	  });
1294	};
1295
1296	/**
1297	 * Remove css classes
1298	 *
1299	 */
1300	const removeClasses = (elmts, ...classes) => {
1301	  var norm_classes = classesArray(classes);
1302	  elmts = castAsArray(elmts);
1303	  elmts.map(el => {
1304	    norm_classes.map(cls => {
1305	      el.classList.remove(cls);
1306	    });
1307	  });
1308	};
1309
1310	/**
1311	 * Return arguments
1312	 *
1313	 */
1314	const classesArray = args => {
1315	  var classes = [];
1316	  iterate(args, _classes => {
1317	    if (typeof _classes === 'string') {
1318	      _classes = _classes.trim().split(/[\t\n\f\r\s]/);
1319	    }
1320	    if (Array.isArray(_classes)) {
1321	      classes = classes.concat(_classes);
1322	    }
1323	  });
1324	  return classes.filter(Boolean);
1325	};
1326
1327	/**
1328	 * Create an array from arg if it's not already an array
1329	 *
1330	 */
1331	const castAsArray = arg => {
1332	  if (!Array.isArray(arg)) {
1333	    arg = [arg];
1334	  }
1335	  return arg;
1336	};
1337
1338	/**
1339	 * Get the closest node to the evt.target matching the selector
1340	 * Stops at wrapper
1341	 *
1342	 */
1343	const parentMatch = (target, selector, wrapper) => {
1344	  if (wrapper && !wrapper.contains(target)) {
1345	    return;
1346	  }
1347	  while (target && target.matches) {
1348	    if (target.matches(selector)) {
1349	      return target;
1350	    }
1351	    target = target.parentNode;
1352	  }
1353	};
1354
1355	/**
1356	 * Get the first or last item from an array
1357	 *
1358	 * > 0 - right (last)
1359	 * <= 0 - left (first)
1360	 *
1361	 */
1362	const getTail = (list, direction = 0) => {
1363	  if (direction > 0) {
1364	    return list[list.length - 1];
1365	  }
1366	  return list[0];
1367	};
1368
1369	/**
1370	 * Return true if an object is empty
1371	 *
1372	 */
1373	const isEmptyObject = obj => {
1374	  return Object.keys(obj).length === 0;
1375	};
1376
1377	/**
1378	 * Get the index of an element amongst sibling nodes of the same type
1379	 *
1380	 */
1381	const nodeIndex = (el, amongst) => {
1382	  if (!el) return -1;
1383	  amongst = amongst || el.nodeName;
1384	  var i = 0;
1385	  while (el = el.previousElementSibling) {
1386	    if (el.matches(amongst)) {
1387	      i++;
1388	    }
1389	  }
1390	  return i;
1391	};
1392
1393	/**
1394	 * Set attributes of an element
1395	 *
1396	 */
1397	const setAttr = (el, attrs) => {
1398	  iterate(attrs, (val, attr) => {
1399	    if (val == null) {
1400	      el.removeAttribute(attr);
1401	    } else {
1402	      el.setAttribute(attr, '' + val);
1403	    }
1404	  });
1405	};
1406
1407	/**
1408	 * Replace a node
1409	 */
1410	const replaceNode = (existing, replacement) => {
1411	  if (existing.parentNode) existing.parentNode.replaceChild(replacement, existing);
1412	};
1413
1414	/**
1415	 * highlight v3 | MIT license | Johann Burkard <[email protected]>
1416	 * Highlights arbitrary terms in a node.
1417	 *
1418	 * - Modified by Marshal <[email protected]> 2011-6-24 (added regex)
1419	 * - Modified by Brian Reavis <[email protected]> 2012-8-27 (cleanup)
1420	 */
1421
1422	const highlight = (element, regex) => {
1423	  if (regex === null) return;
1424
1425	  // convet string to regex
1426	  if (typeof regex === 'string') {
1427	    if (!regex.length) return;
1428	    regex = new RegExp(regex, 'i');
1429	  }
1430
1431	  // Wrap matching part of text node with highlighting <span>, e.g.
1432	  // Soccer  ->  <span class="highlight">Soc</span>cer  for regex = /soc/i
1433	  const highlightText = node => {
1434	    var match = node.data.match(regex);
1435	    if (match && node.data.length > 0) {
1436	      var spannode = document.createElement('span');
1437	      spannode.className = 'highlight';
1438	      var middlebit = node.splitText(match.index);
1439	      middlebit.splitText(match[0].length);
1440	      var middleclone = middlebit.cloneNode(true);
1441	      spannode.appendChild(middleclone);
1442	      replaceNode(middlebit, spannode);
1443	      return 1;
1444	    }
1445	    return 0;
1446	  };
1447
1448	  // Recurse element node, looking for child text nodes to highlight, unless element
1449	  // is childless, <script>, <style>, or already highlighted: <span class="hightlight">
1450	  const highlightChildren = node => {
1451	    if (node.nodeType === 1 && node.childNodes && !/(script|style)/i.test(node.tagName) && (node.className !== 'highlight' || node.tagName !== 'SPAN')) {
1452	      Array.from(node.childNodes).forEach(element => {
1453	        highlightRecursive(element);
1454	      });
1455	    }
1456	  };
1457	  const highlightRecursive = node => {
1458	    if (node.nodeType === 3) {
1459	      return highlightText(node);
1460	    }
1461	    highlightChildren(node);
1462	    return 0;
1463	  };
1464	  highlightRecursive(element);
1465	};
1466
1467	/**
1468	 * removeHighlight fn copied from highlight v5 and
1469	 * edited to remove with(), pass js strict mode, and use without jquery
1470	 */
1471	const removeHighlight = el => {
1472	  var elements = el.querySelectorAll("span.highlight");
1473	  Array.prototype.forEach.call(elements, function (el) {
1474	    var parent = el.parentNode;
1475	    parent.replaceChild(el.firstChild, el);
1476	    parent.normalize();
1477	  });
1478	};
1479
1480	const KEY_A = 65;
1481	const KEY_RETURN = 13;
1482	const KEY_ESC = 27;
1483	const KEY_LEFT = 37;
1484	const KEY_UP = 38;
1485	const KEY_RIGHT = 39;
1486	const KEY_DOWN = 40;
1487	const KEY_BACKSPACE = 8;
1488	const KEY_DELETE = 46;
1489	const KEY_TAB = 9;
1490	const IS_MAC = typeof navigator === 'undefined' ? false : /Mac/.test(navigator.userAgent);
1491	const KEY_SHORTCUT = IS_MAC ? 'metaKey' : 'ctrlKey'; // ctrl key or apple key for ma
1492
1493	var defaults = {
1494	  options: [],
1495	  optgroups: [],
1496	  plugins: [],
1497	  delimiter: ',',
1498	  splitOn: null,
1499	  // regexp or string for splitting up values from a paste command
1500	  persist: true,
1501	  diacritics: true,
1502	  create: null,
1503	  createOnBlur: false,
1504	  createFilter: null,
1505	  highlight: true,
1506	  openOnFocus: true,
1507	  shouldOpen: null,
1508	  maxOptions: 50,
1509	  maxItems: null,
1510	  hideSelected: null,
1511	  duplicates: false,
1512	  addPrecedence: false,
1513	  selectOnTab: false,
1514	  preload: null,
1515	  allowEmptyOption: false,
1516	  //closeAfterSelect: false,
1517	  refreshThrottle: 300,
1518	  loadThrottle: 300,
1519	  loadingClass: 'loading',
1520	  dataAttr: null,
1521	  //'data-data',
1522	  optgroupField: 'optgroup',
1523	  valueField: 'value',
1524	  labelField: 'text',
1525	  disabledField: 'disabled',
1526	  optgroupLabelField: 'label',
1527	  optgroupValueField: 'value',
1528	  lockOptgroupOrder: false,
1529	  sortField: '$order',
1530	  searchField: ['text'],
1531	  searchConjunction: 'and',
1532	  mode: null,
1533	  wrapperClass: 'ts-wrapper',
1534	  controlClass: 'ts-control',
1535	  dropdownClass: 'ts-dropdown',
1536	  dropdownContentClass: 'ts-dropdown-content',
1537	  itemClass: 'item',
1538	  optionClass: 'option',
1539	  dropdownParent: null,
1540	  controlInput: '<input type="text" autocomplete="off" size="1" />',
1541	  copyClassesToDropdown: false,
1542	  placeholder: null,
1543	  hidePlaceholder: null,
1544	  shouldLoad: function (query) {
1545	    return query.length > 0;
1546	  },
1547	  /*
1548	  load                 : null, // function(query, callback) { ... }
1549	  score                : null, // function(search) { ... }
1550	  onInitialize         : null, // function() { ... }
1551	  onChange             : null, // function(value) { ... }
1552	  onItemAdd            : null, // function(value, $item) { ... }
1553	  onItemRemove         : null, // function(value) { ... }
1554	  onClear              : null, // function() { ... }
1555	  onOptionAdd          : null, // function(value, data) { ... }
1556	  onOptionRemove       : null, // function(value) { ... }
1557	  onOptionClear        : null, // function() { ... }
1558	  onOptionGroupAdd     : null, // function(id, data) { ... }
1559	  onOptionGroupRemove  : null, // function(id) { ... }
1560	  onOptionGroupClear   : null, // function() { ... }
1561	  onDropdownOpen       : null, // function(dropdown) { ... }
1562	  onDropdownClose      : null, // function(dropdown) { ... }
1563	  onType               : null, // function(str) { ... }
1564	  onDelete             : null, // function(values) { ... }
1565	  */
1566
1567	  render: {
1568	    /*
1569	    item: null,
1570	    optgroup: null,
1571	    optgroup_header: null,
1572	    option: null,
1573	    option_create: null
1574	    */
1575	  }
1576	};
1577
1578	function getSettings(input, settings_user) {
1579	  var settings = Object.assign({}, defaults, settings_user);
1580	  var attr_data = settings.dataAttr;
1581	  var field_label = settings.labelField;
1582	  var field_value = settings.valueField;
1583	  var field_disabled = settings.disabledField;
1584	  var field_optgroup = settings.optgroupField;
1585	  var field_optgroup_label = settings.optgroupLabelField;
1586	  var field_optgroup_value = settings.optgroupValueField;
1587	  var tag_name = input.tagName.toLowerCase();
1588	  var placeholder = input.getAttribute('placeholder') || input.getAttribute('data-placeholder');
1589	  if (!placeholder && !settings.allowEmptyOption) {
1590	    let option = input.querySelector('option[value=""]');
1591	    if (option) {
1592	      placeholder = option.textContent;
1593	    }
1594	  }
1595	  var settings_element = {
1596	    placeholder: placeholder,
1597	    options: [],
1598	    optgroups: [],
1599	    items: [],
1600	    maxItems: null
1601	  };
1602
1603	  /**
1604	   * Initialize from a <select> element.
1605	   *
1606	   */
1607	  var init_select = () => {
1608	    var tagName;
1609	    var options = settings_element.options;
1610	    var optionsMap = {};
1611	    var group_count = 1;
1612	    let $order = 0;
1613	    var readData = el => {
1614	      var data = Object.assign({}, el.dataset); // get plain object from DOMStringMap
1615	      var json = attr_data && data[attr_data];
1616	      if (typeof json === 'string' && json.length) {
1617	        data = Object.assign(data, JSON.parse(json));
1618	      }
1619	      return data;
1620	    };
1621	    var addOption = (option, group) => {
1622	      var value = hash_key(option.value);
1623	      if (value == null) return;
1624	      if (!value && !settings.allowEmptyOption) return;
1625
1626	      // if the option already exists, it's probably been
1627	      // duplicated in another optgroup. in this case, push
1628	      // the current group to the "optgroup" property on the
1629	      // existing option so that it's rendered in both places.
1630	      if (optionsMap.hasOwnProperty(value)) {
1631	        if (group) {
1632	          var arr = optionsMap[value][field_optgroup];
1633	          if (!arr) {
1634	            optionsMap[value][field_optgroup] = group;
1635	          } else if (!Array.isArray(arr)) {
1636	            optionsMap[value][field_optgroup] = [arr, group];
1637	          } else {
1638	            arr.push(group);
1639	          }
1640	        }
1641	      } else {
1642	        var option_data = readData(option);
1643	        option_data[field_label] = option_data[field_label] || option.textContent;
1644	        option_data[field_value] = option_data[field_value] || value;
1645	        option_data[field_disabled] = option_data[field_disabled] || option.disabled;
1646	        option_data[field_optgroup] = option_data[field_optgroup] || group;
1647	        option_data.$option = option;
1648	        option_data.$order = option_data.$order || ++$order;
1649	        optionsMap[value] = option_data;
1650	        options.push(option_data);
1651	      }
1652	      if (option.selected) {
1653	        settings_element.items.push(value);
1654	      }
1655	    };
1656	    var addGroup = optgroup => {
1657	      var id, optgroup_data;
1658	      optgroup_data = readData(optgroup);
1659	      optgroup_data[field_optgroup_label] = optgroup_data[field_optgroup_label] || optgroup.getAttribute('label') || '';
1660	      optgroup_data[field_optgroup_value] = optgroup_data[field_optgroup_value] || group_count++;
1661	      optgroup_data[field_disabled] = optgroup_data[field_disabled] || optgroup.disabled;
1662	      optgroup_data.$order = optgroup_data.$order || ++$order;
1663	      settings_element.optgroups.push(optgroup_data);
1664	      id = optgroup_data[field_optgroup_value];
1665	      iterate(optgroup.children, option => {
1666	        addOption(option, id);
1667	      });
1668	    };
1669	    settings_element.maxItems = input.hasAttribute('multiple') ? null : 1;
1670	    iterate(input.children, child => {
1671	      tagName = child.tagName.toLowerCase();
1672	      if (tagName === 'optgroup') {
1673	        addGroup(child);
1674	      } else if (tagName === 'option') {
1675	        addOption(child);
1676	      }
1677	    });
1678	  };
1679
1680	  /**
1681	   * Initialize from a <input type="text"> element.
1682	   *
1683	   */
1684	  var init_textbox = () => {
1685	    const data_raw = input.getAttribute(attr_data);
1686	    if (!data_raw) {
1687	      var 

1687value = input.value.trim() || '';
1688	      if (!settings.allowEmptyOption && !value.length) return;
1689	      const values = value.split(settings.delimiter);
1690	      iterate(values, value => {
1691	        const option = {};
1692	        option[field_label] = value;
1693	        option[field_value] = value;
1694	        settings_element.options.push(option);
1695	      });
1696	      settings_element.items = values;
1697	    } else {
1698	      settings_element.options = JSON.parse(data_raw);
1699	      iterate(settings_element.options, opt => {
1700	        settings_element.items.push(opt[field_value]);
1701	      });
1702	    }
1703	  };
1704	  if (tag_name === 'select') {
1705	    init_select();
1706	  } else {
1707	    init_textbox();
1708	  }
1709	  return Object.assign({}, defaults, settings_element, settings_user);
1710	}
1711
1712	var instance_i = 0;
1713	class TomSelect extends MicroPlugin(MicroEvent) {
1714	  constructor(input_arg, user_settings) {
1715	    super();
1716	    this.order = 0;
1717	    this.isOpen = false;
1718	    this.isDisabled = false;
1719	    this.isReadOnly = false;
1720	    this.isInvalid = false;
1721	    // @deprecated 1.8
1722	    this.isValid = true;
1723	    this.isLocked = false;
1724	    this.isFocused = false;
1725	    this.isInputHidden = false;
1726	    this.isSetup = false;
1727	    this.ignoreFocus = false;
1728	    this.ignoreHover = false;
1729	    this.hasOptions = false;
1730	    this.lastValue = '';
1731	    this.caretPos = 0;
1732	    this.loading = 0;
1733	    this.loadedSearches = {};
1734	    this.activeOption = null;
1735	    this.activeItems = [];
1736	    this.optgroups = {};
1737	    this.options = {};
1738	    this.userOptions = {};
1739	    this.items = [];
1740	    this.refreshTimeout = null;
1741	    instance_i++;
1742	    var dir;
1743	    var input = getDom(input_arg);
1744	    if (input.tomselect) {
1745	      throw new Error('Tom Select already initialized on this element');
1746	    }
1747	    input.tomselect = this;
1748
1749	    // detect rtl environment
1750	    var computedStyle = window.getComputedStyle && window.getComputedStyle(input, null);
1751	    dir = computedStyle.getPropertyValue('direction');
1752
1753	    // setup default state
1754	    const settings = getSettings(input, user_settings);
1755	    this.settings = settings;
1756	    this.input = input;
1757	    this.tabIndex = input.tabIndex || 0;
1758	    this.is_select_tag = input.tagName.toLowerCase() === 'select';
1759	    this.rtl = /rtl/i.test(dir);
1760	    this.inputId = getId(input, 'tomselect-' + instance_i);
1761	    this.isRequired = input.required;
1762
1763	    // search system
1764	    this.sifter = new Sifter(this.options, {
1765	      diacritics: settings.diacritics
1766	    });
1767
1768	    // option-dependent defaults
1769	    settings.mode = settings.mode || (settings.maxItems === 1 ? 'single' : 'multi');
1770	    if (typeof settings.hideSelected !== 'boolean') {
1771	      settings.hideSelected = settings.mode === 'multi';
1772	    }
1773	    if (typeof settings.hidePlaceholder !== 'boolean') {
1774	      settings.hidePlaceholder = settings.mode !== 'multi';
1775	    }
1776
1777	    // set up createFilter callback
1778	    var filter = settings.createFilter;
1779	    if (typeof filter !== 'function') {
1780	      if (typeof filter === 'string') {
1781	        filter = new RegExp(filter);
1782	      }
1783	      if (filter instanceof RegExp) {
1784	        settings.createFilter = input => filter.test(input);
1785	      } else {
1786	        settings.createFilter = value => {
1787	          return this.settings.duplicates || !this.options[value];
1788	        };
1789	      }
1790	    }
1791	    this.initializePlugins(settings.plugins);
1792	    this.setupCallbacks();
1793	    this.setupTemplates();
1794
1795	    // Create all elements
1796	    const wrapper = getDom('<div>');
1797	    const control = getDom('<div>');
1798	    const dropdown = this._render('dropdown');
1799	    const dropdown_content = getDom(`<div role="listbox" tabindex="-1">`);
1800	    const classes = this.input.getAttribute('class') || '';
1801	    const inputMode = settings.mode;
1802	    var control_input;
1803	    addClasses(wrapper, settings.wrapperClass, classes, inputMode);
1804	    addClasses(control, settings.controlClass);
1805	    append(wrapper, control);
1806	    addClasses(dropdown, settings.dropdownClass, inputMode);
1807	    if (settings.copyClassesToDropdown) {
1808	      addClasses(dropdown, classes);
1809	    }
1810	    addClasses(dropdown_content, settings.dropdownContentClass);
1811	    append(dropdown, dropdown_content);
1812	    getDom(settings.dropdownParent || wrapper).appendChild(dropdown);
1813
1814	    // default controlInput
1815	    if (isHtmlString(settings.controlInput)) {
1816	      control_input = getDom(settings.controlInput);
1817
1818	      // set attributes
1819	      var attrs = ['autocorrect', 'autocapitalize', 'autocomplete', 'spellcheck'];
1820	      iterate(attrs, attr => {
1821	        if (input.getAttribute(attr)) {
1822	          setAttr(control_input, {
1823	            [attr]: input.getAttribute(attr)
1824	          });
1825	        }
1826	      });
1827	      control_input.tabIndex = -1;
1828	      control.appendChild(control_input);
1829	      this.focus_node = control_input;
1830
1831	      // dom element
1832	    } else if (settings.controlInput) {
1833	      control_input = getDom(settings.controlInput);
1834	      this.focus_node = control_input;
1835	    } else {
1836	      control_input = getDom('<input/>');
1837	      this.focus_node = control;
1838	    }
1839	    this.wrapper = wrapper;
1840	    this.dropdown = dropdown;
1841	    this.dropdown_content = dropdown_content;
1842	    this.control = control;
1843	    this.control_input = control_input;
1844	    this.setup();
1845	  }
1846
1847	  /**
1848	   * set up event bindings.
1849	   *
1850	   */
1851	  setup() {
1852	    const self = this;
1853	    const settings = self.settings;
1854	    const control_input = self.control_input;
1855	    const dropdown = self.dropdown;
1856	    const dropdown_content = self.dropdown_content;
1857	    const wrapper = self.wrapper;
1858	    const control = self.control;
1859	    const input = self.input;
1860	    const focus_node = self.focus_node;
1861	    const passive_event = {
1862	      passive: true
1863	    };
1864	    const listboxId = self.inputId + '-ts-dropdown';
1865	    setAttr(dropdown_content, {
1866	      id: listboxId
1867	    });
1868	    setAttr(focus_node, {
1869	      role: 'combobox',
1870	      'aria-haspopup': 'listbox',
1871	      'aria-expanded': 'false',
1872	      'aria-controls': listboxId
1873	    });
1874	    const control_id = getId(focus_node, self.inputId + '-ts-control');
1875	    const query = "label[for='" + escapeQuery(self.inputId) + "']";
1876	    const label = document.querySelector(query);
1877	    const label_click = self.focus.bind(self);
1878	    if (label) {
1879	      addEvent(label, 'click', label_click);
1880	      setAttr(label, {
1881	        for: control_id
1882	      });
1883	      const label_id = getId(label, self.inputId + '-ts-label');
1884	      setAttr(focus_node, {
1885	        'aria-labelledby': label_id
1886	      });
1887	      setAttr(dropdown_content, {
1888	        'aria-labelledby': label_id
1889	      });
1890	    }
1891	    wrapper.style.width = input.style.width;
1892	    if (self.plugins.names.length) {
1893	      const classes_plugins = 'plugin-' + self.plugins.names.join(' plugin-');
1894	      addClasses([wrapper, dropdown], classes_plugins);
1895	    }
1896	    if ((settings.maxItems === null || settings.maxItems > 1) && self.is_select_tag) {
1897	      setAttr(input, {
1898	        multiple: 'multiple'
1899	      });
1900	    }
1901	    if (settings.placeholder) {
1902	      setAttr(control_input, {
1903	        placeholder: settings.placeholder
1904	      });
1905	    }
1906
1907	    // if splitOn was not passed in, construct it from the delimiter to allow pasting universally
1908	    if (!settings.splitOn && settings.delimiter) {
1909	      settings.splitOn = new RegExp('\\s*' + escape_regex(settings.delimiter) + '+\\s*');
1910	    }
1911
1912	    // debounce user defined load() if loadThrottle > 0
1913	    // after initializePlugins() so plugins can create/modify user defined loaders
1914	    if (settings.load && settings.loadThrottle) {
1915	      settings.load = loadDebounce(settings.load, settings.loadThrottle);
1916	    }
1917	    addEvent(dropdown, 'mousemove', () => {
1918	      self.ignoreHover = false;

1919	    });
1920	    addEvent(dropdown, 'mouseenter', e => {
1921	      var target_match = parentMatch(e.target, '[data-selectable]', dropdown);
1922	      if (target_match) self.onOptionHover(e, target_match);
1923	    }, {
1924	      capture: true
1925	    });
1926
1927	    // clicking on an option should select it
1928	    addEvent(dropdown, 'click', evt => {
1929	      const option = parentMatch(evt.target, '[data-selectable]');
1930	      if (option) {
1931	        self.onOptionSelect(evt, option);
1932	        preventDefault(evt, true);
1933	      }
1934	    });
1935	    addEvent(control, 'click', evt => {
1936	      var target_match = parentMatch(evt.target, '[data-ts-item]', control);
1937	      if (target_match && self.onItemSelect(evt, target_match)) {
1938	        preventDefault(evt, true);
1939	        return;
1940	      }
1941
1942	      // retain focus (see control_input mousedown)
1943	      if (control_input.value != '') {
1944	        return;
1945	      }
1946	      self.onClick();
1947	      preventDefault(evt, true);
1948	    });
1949
1950	    // keydown on focus_node for arrow_down/arrow_up
1951	    addEvent(focus_node, 'keydown', e => self.onKeyDown(e));
1952
1953	    // keypress and input/keyup
1954	    addEvent(control_input, 'keypress', e => self.onKeyPress(e));
1955	    addEvent(control_input, 'input', e => self.onInput(e));
1956	    addEvent(focus_node, 'blur', e => self.onBlur(e));
1957	    addEvent(focus_node, 'focus', e => self.onFocus(e));
1958	    addEvent(control_input, 'paste', e => self.onPaste(e));
1959	    const doc_mousedown = evt => {
1960	      // blur if target is outside of this instance
1961	      // dropdown is not always inside wrapper
1962	      const target = evt.composedPath()[0];
1963	      if (!wrapper.contains(target) && !dropdown.contains(target)) {
1964	        if (self.isFocused) {
1965	          self.blur();
1966	        }
1967	        self.inputState();
1968	        return;
1969	      }
1970
1971	      // retain focus by preventing native handling. if the
1972	      // event target is the input it should not be modified.
1973	      // otherwise, text selection within the input won't work.
1974	      // Fixes bug #212 which is no covered by tests
1975	      if (target == control_input && self.isOpen) {
1976	        evt.stopPropagation();
1977
1978	        // clicking anywhere in the control should not blur the control_input (which would close the dropdown)
1979	      } else {
1980	        preventDefault(evt, true);
1981	      }
1982	    };
1983	    const win_scroll = () => {
1984	      if (self.isOpen) {
1985	        self.positionDropdown();
1986	      }
1987	    };
1988	    addEvent(document, 'mousedown', doc_mousedown);
1989	    addEvent(window, 'scroll', win_scroll, passive_event);
1990	    addEvent(window, 'resize', win_scroll, passive_event);
1991	    this._destroy = () => {
1992	      document.removeEventListener('mousedown', doc_mousedown);
1993	      window.removeEventListener('scroll', win_scroll);
1994	      window.removeEventListener('resize', win_scroll);
1995	      if (label) label.removeEventListener('click', label_click);
1996	    };
1997
1998	    // store original html and tab index so that they can be
1999	    // restored when the destroy() method is called.
2000	    this.revertSettings = {
2001	      innerHTML: input.innerHTML,
2002	      tabIndex: input.tabIndex
2003	    };
2004	    input.tabIndex = -1;
2005	    input.insertAdjacentElement('afterend', self.wrapper);
2006	    self.sync(false);
2007	    settings.items = [];
2008	    delete settings.optgroups;
2009	    delete settings.options;
2010	    addEvent(input, 'invalid', () => {
2011	      if (self.isValid) {
2012	        self.isValid = false;
2013	        self.isInvalid = true;
2014	        self.refreshState();
2015	      }
2016	    });
2017	    self.updateOriginalInput();
2018	    self.refreshItems();
2019	    self.close(false);
2020	    self.inputState();
2021	    self.isSetup = true;
2022	    if (input.disabled) {
2023	      self.disable();
2024	    } else if (input.readOnly) {
2025	      self.setReadOnly(true);
2026	    } else {
2027	      self.enable(); //sets tabIndex
2028	    }

2028
2029	    self.on('change', this.onChange);
2030	    addClasses(input, 'tomselected', 'ts-hidden-accessible');
2031	    self.trigger('initialize');
2032
2033	    // preload options
2034	    if (settings.preload === true) {
2035	      self.preload();
2036	    }
2037	  }
2038
2039	  /**
2040	   * Register options and optgroups
2041	   *
2042	   */
2043	  setupOptions(options = [], optgroups = []) {
2044	    // build options table
2045	    this.addOptions(options);
2046
2047	    // build optgroup table
2048	    iterate(optgroups, optgroup => {
2049	      this.registerOptionGroup(optgroup);
2050	    });
2051	  }
2052
2053	  /**
2054	   * Sets up default rendering functions.
2055	   */
2056	  setupTemplates() {
2057	    var self = this;
2058	    var field_label = self.settings.labelField;
2059	    var field_optgroup = self.settings.optgroupLabelField;
2060	    var templates = {
2061	      'optgroup': data => {
2062	        let optgroup = document.createElement('div');
2063	        optgroup.className = 'optgroup';
2064	        optgroup.appendChild(data.options);
2065	        return optgroup;
2066	      },
2067	      'optgroup_header': (data, escape) => {
2068	        return '<div class="optgroup-header">' + escape(data[field_optgroup]) + '</div>';
2069	      },
2070	      'option': (data, escape) => {
2071	        return '<div>' + escape(data[field_label]) + '</div>';
2072	      },
2073	      'item': (data, escape) => {
2074	        return '<div>' + escape(data[field_label]) + '</div>';
2075	      },
2076	      'option_create': (data, escape) => {
2077	        return '<div class="create">Add <strong>' + escape(data.input) + '</strong>&hellip;</div>';
2078	      },
2079	      'no_results': () => {
2080	        return '<div class="no-results">No results found</div>';
2081	      },
2082	      'loading': () => {
2083	        return '<div class="spinner"></div>';
2084	      },
2085	      'not_loading': () => {},
2086	      'dropdown': () => {
2087	        return '<div></div>';
2088	      }
2089	    };
2090	    self.settings.render = Object.assign({}, templates, self.settings.render);
2091	  }
2092
2093	  /**
2094	   * Maps fired events to callbacks provided
2095	   * in the settings used when creating the control.
2096	   */
2097	  setupCallbacks() {
2098	    var key, fn;
2099	    var callbacks = {
2100	      'initialize': 'onInitialize',
2101	      'change': 'onChange',
2102	      'item_add': 'onItemAdd',
2103	      'item_remove': 'onItemRemove',
2104	      'item_select': 'onItemSelect',
2105	      'clear': 'onClear',
2106	      'option_add': 'onOptionAdd',
2107	      'option_remove': 'onOptionRemove',
2108	      'option_clear': 'onOptionClear',
2109	      'optgroup_add': 'onOptionGroupAdd',
2110	      'optgroup_remove': 'onOptionGroupRemove',
2111	      'optgroup_clear': 'onOptionGroupClear',
2112	      'dropdown_open': 'onDropdownOpen',
2113	      'dropdown_close': 'onDropdownClose',
2114	      'type': 'onType',
2115	      'load': 'onLoad',
2116	      'focus': 'onFocus',
2117	      'blur': 'onBlur'
2118	    };
2119	    for (key in callbacks) {
2120	      fn = this.settings[callbacks[key]];
2121	      if (fn) this.on(key, fn);
2122	    }
2123	  }
2124
2125	  /**
2126	   * Sync the Tom Select instance with the original input or select
2127	   *
2128	   */
2129	  sync(get_settings = true) {
2130	    const self = this;
2131	    const settings = get_settings ? getSettings(self.input, {
2132	      delimiter: self.settings.delimiter

2132
2133	    }) : self.settings;
2134	    self.setupOptions(settings.options, settings.optgroups);
2135	    self.setValue(settings.items || [], true); // silent prevents recursion
2136
2137	    self.lastQuery = null; // so updated options will be displayed in dropdown
2138	  }
2139
2140	  /**
2141	   * Triggered when the main control element
2142	   * has a click event.
2143	   *
2144	   */
2145	  onClick() {
2146	    var self = this;
2147	    if (self.activeItems.length > 0) {
2148	      self.clearActiveItems();
2149	      self.focus();
2150	      return;
2151	    }
2152	    if (self.isFocused && self.isOpen) {
2153	      self.blur();
2154	    } else {
2155	      self.focus();
2156	    }
2157	  }
2158
2159	  /**
2160	   * @deprecated v1.7
2161	   *
2162	   */
2163	  onMouseDown() {}
2164
2165	  /**
2166	   * Triggered when the value of the control has been changed.
2167	   * This should propagate the event to the original DOM
2168	   * input / select element.
2169	   */
2170	  onChange() {
2171	    triggerEvent(this.input, 'input');
2172	    triggerEvent(this.input, 'change');
2173	  }
2174
2175	  /**
2176	   * Triggered on <input> paste.
2177	   *
2178	   */
2179	  onPaste(e) {
2180	    var self = this;
2181	    if (self.isInputHidden || self.isLocked) {
2182	      preventDefault(e);
2183	      return;
2184	    }
2185
2186	    // If a regex or string is included, this will split the pasted
2187	    // input and create Items for each separate value
2188	    if (!self.settings.splitOn) {
2189	      return;
2190	    }
2191
2192	    // Wait for pasted text to be recognized in value
2193	    setTimeout(() => {
2194	      var pastedText = self.inputValue();
2195	      if (!pastedText.match(self.settings.splitOn)) {
2196	        return;
2197	      }
2198	      var splitInput = pastedText.trim().split(self.settings.splitOn);
2199	      iterate(splitInput, piece => {
2200	        const hash = hash_key(piece);
2201	        if (hash) {
2202	          if (this.options[piece]) {
2203	            self.addItem(piece);
2204	          } else {
2205	            self.createItem(piece);
2206	          }
2207	        }
2208	      });
2209	    }, 0);
2210	  }
2211
2212	  /**
2213	   * Triggered on <input> keypress.
2214	   *
2215	   */
2216	  onKeyPress(e) {
2217	    var self = this;
2218	    if (self.isLocked) {
2219	      preventDefault(e);
2220	      return;
2221	    }
2222	    var character = String.fromCharCode(e.keyCode || e.which);
2223	    if (self.settings.create && self.settings.mode === 'multi' && character === self.settings.delimiter) {
2224	      self.createItem();
2225	      preventDefault(e);
2226	      return;
2227	    }
2228	  }
2229
2230	  /**
2231	   * Triggered on <input> keydown.
2232	   *
2233	   */
2234	  onKeyDown(e) {
2235	    var self = this;
2236	    self.ignoreHover = true;
2237	    if (self.isLocked) {
2238	      if (e.keyCode !== KEY_TAB) {
2239	        preventDefault(e);
2240	      }
2241	      return;
2242	    }
2243	    switch (e.keyCode) {
2244	      // ctrl+A: select all
2245	      case KEY_A:
2246	        if (isKeyDown(KEY_SHORTCUT, e)) {
2247	          if (self.control_input.value == '') {
2248	            preventDefault(e);
2249	            self.selectAll();
2250	            return;
2251	          }
2252	        }
2253	        break;
2254
2255	      // esc: close dropdown
2256	      case KEY_ESC:
2257	        if (self.isOpen) {
2258	          preventDefault(e, true);
2259	          self.close();
2260	        }
2261	        self.clearActiveItems();
2262	        return;
2263
2264	      // down: open dropdown or move selection down
2265	      case KEY_DOWN:
2266	        if (!self.isOpen && self.hasOptions) {
2267	          self.open();
2268	        } else if (self.activeOption) {
2269	          let next = self.getAdjacent(self.activeOption, 1);
2270	          if (next) self.setActiveOption(next);
2271	        }
2272	        preventDefault(e);
2273	        return;
2274
2275	      // up: move selection up
2276	      case KEY_UP:
2277	        if (self.activeOption) {
2278	          let prev = self.getAdjacent(self.activeOption, -1);
2279	          if (prev) self.setActiveOption(prev);
2280	        }
2281	        preventDefault(e);
2282	        return;
2283
2284	      // return: select active option
2285	      case KEY_RETURN:
2286	        if (self.canSelect(self.activeOption)) {
2287	          self.onOptionSelect(e, self.activeOption);
2288	          preventDefault(e);
2289
2290	          // if the option_create=null, the dropdown might be closed
2291	        } else if (self.settings.create && self.createItem()) {
2292	          preventDefault(e);
2293
2294	          // don't submit form when searching for a value
2295	        } else if (document.activeElement == self.control_input && self.isOpen) {
2296	          preventDefault(e);
2297	        }
2298	        return;
2299
2300	      // left: modifiy item selection to the left
2301	      case KEY_LEFT:
2302	        self.advanceSelection(-1, e);
2303	        return;
2304
2305	      // right: modifiy item selection to the right
2306	      case KEY_RIGHT:
2307	        self.advanceSelection(1, e);
2308	        return;
2309
2310	      // tab: select active option and/or create item
2311	      case KEY_TAB:
2312	        if (self.settings.selectOnTab) {
2313	          if (self.canSelect(self.activeOption)) {
2314	            self.onOptionSelect(e, self.activeOption);
2315
2316	            // prevent default [tab] behaviour of jump to the next field
2317	            // if select isFull, then the dropdown won't be open and [tab] will work normally
2318	            preventDefault(e);
2319	          }
2320	          if (self.settings.create && self.createItem()) {
2321	            preventDefault(e);
2322	          }
2323	        }
2324	        return;
2325
2326	      // delete|backspace: delete items
2327	      case KEY_BACKSPACE:
2328	      case KEY_DELETE:
2329	        self.deleteSelection(e);
2330	        return;
2331	    }
2332
2333	    // don't enter text in the control_input when active items are selected
2334	    if (self.isInputHidden && !isKeyDown(KEY_SHORTCUT, e)) {
2335	      preventDefault(e);
2336	    }
2337	  }
2338
2339	  /**
2340	   * Triggered on <input> keyup.
2341	   *
2342	   */
2343	  onInput(e) {
2344	    if (this.isLocked) {
2345	      return;
2346	    }
2347	    const value = this.inputValue();
2348	    if (this.lastValue === value) return;
2349	    this.lastValue = value;
2350	    if (value == '') {
2351	      this._onInput();
2352	      return;
2353	    }
2354	    if (this.refreshTimeout) {
2355	      window.clearTimeout(this.refreshTimeout);
2356	    }
2357	    this.refreshTimeout = timeout(() => {
2358	      this.refreshTimeout = null;
2359	      this._onInput();
2360	    }, this.settings.refreshThrottle);
2361	  }
2362	  _onInput() {
2363	    const value = this.lastValue;
2364	    if (this.settings.shouldLoad.call(this, value)) {
2365	      this.load(value);
2366	    }
2367	    this.refreshOptions();
2368	    this.trigger('type', value);
2369	  }
2370
2371	  /**
2372	   * Triggered when the user rolls over
2373	   * an option in the autocomplete dropdown menu.
2374	   *
2375	   */
2376	  onOptionHover(evt, option) {
2377	    if (this.ignoreHover) return;
2378	    this.setActiveOption(option, false);
2379	  }
2380
2381	  /**
2382	   * Triggered on <input> focus.
2383	   *
2384	   */
2385	  onFocus(e) {
2386	    var self = this;
2387	    var wasFocused = self.isFocused;
2388	    if (self.isDisabled || self.isReadOnly) {
2389	      self.blur();
2390	      preventDefault(e);
2391	      return;
2392	    }
2393	    if (self.ignoreFocus) return;
2394	    self.isFocused = true;
2395	    if (self.settings.preload === 'focus') self.preload();
2396	    if (!wasFocused) self.trigger('focus');
2397	    if (!self.activeItems.length) {
2398	      self.inputState();
2399	      self.refreshOptions(!!self.settings.openOnFocus);
2400	    }
2401	    self.refreshState();
2402	  }
2403
2404	  /**
2405	   * Triggered on <input> blur.
2406	   *
2407	   */
2408	  onBlur(e) {
2409	    if (document.hasFocus() === false) return;
2410	    var self = this;
2411	    if (!self.isFocused) return;
2412	    self.isFocused = false;

2413	    self.ignoreFocus = false;
2414	    var deactivate = () => {
2415	      self.close();
2416	      self.setActiveItem();
2417	      self.setCaret(self.items.length);
2418	      self.trigger('blur');
2419	    };
2420	    if (self.settings.create && self.settings.createOnBlur) {
2421	      self.createItem(null, deactivate);
2422	    } else {
2423	      deactivate();
2424	    }
2425	  }
2426
2427	  /**
2428	   * Triggered when the user clicks on an option
2429	   * in the autocomplete dropdown menu.
2430	   *
2431	   */
2432	  onOptionSelect(evt, option) {
2433	    var value,
2434	      self = this;
2435
2436	    // should not be possible to trigger a option under a disabled optgroup
2437	    if (option.parentElement && option.parentElement.matches('[data-disabled]')) {
2438	      return;
2439	    }
2440	    if (option.classList.contains('create')) {
2441	      self.createItem(null, () => {
2442	        if (self.settings.closeAfterSelect) {
2443	          self.close();
2444	        }
2445	      });
2446	    } else {
2447	      value = option.dataset.value;
2448	      if (typeof value !== 'undefined') {
2449	        self.lastQuery = null;
2450	        self.addItem(value);
2451	        if (self.settings.closeAfterSelect) {
2452	          self.close();
2453	        }
2454	        if (!self.settings.hideSelected && evt.type && /click/.test(evt.type)) {
2455	          self.setActiveOption(option);
2456	        }
2457	      }
2458	    }
2459	  }
2460
2461	  /**
2462	   * Return true if the given option can be selected
2463	   *
2464	   */
2465	  canSelect(option) {
2466	    if (this.isOpen && option && this.dropdown_content.contains(option)) {
2467	      return true;
2468	    }
2469	    return false;
2470	  }
2471
2472	  /**
2473	   * Triggered when the user clicks on an item
2474	   * that has been selected.
2475	   *
2476	   */
2477	  onItemSelect(evt, item) {
2478	    var self = this;
2479	    if (!self.isLocked && self.settings.mode === 'multi') {
2480	      preventDefault(evt);
2481	      self.setActiveItem(item, evt);
2482	      return true;
2483	    }
2484	    return false;
2485	  }
2486
2487	  /**
2488	   * Determines whether or not to invoke
2489	   * the user-provided option provider / loader
2490	   *
2491	   * Note, there is a subtle difference between
2492	   * this.canLoad() and this.settings.shouldLoad();
2493	   *
2494	   *	- settings.shouldLoad() is a user-input validator.
2495	   *	When false is returned, the not_loading template
2496	   *	will be added to the dropdown
2497	   *
2498	   *	- canLoad() is lower level validator that checks
2499	   * 	the Tom Select instance. There is no inherent user
2500	   *	feedback when canLoad returns false
2501	   *
2502	   */
2503	  canLoad(value) {
2504	    if (!this.settings.load) return false;
2505	    if (this.loadedSearches.hasOwnProperty(value)) return false;
2506	    return true;
2507	  }
2508
2509	  /**
2510	   * Invokes the user-provided option provider / loader.
2511	   *
2512	   */
2513	  load(value) {
2514	    const self = this;
2515	    if (!self.canLoad(value)) return;
2516	    addClasses(self.wrapper, self.settings.loadingClass);
2517	    self.loading++;
2518	    const callback = self.loadCallback.bind(self);
2519	    self.settings.load.call(self, value, callback);
2520	  }
2521
2522	  /**
2523	   * Invoked by the user-provided option provider
2524	   *
2525	   */
2526	  loadCallback(options, optgroups) {
2527	    const self = this;
2528	    self.loading = Math.max(self.loading - 1, 0);
2529	    self.lastQuery = null

2529;
2530	    self.clearActiveOption(); // when new results load, focus should be on first option
2531	    self.setupOptions(options, optgroups);
2532	    self.refreshOptions(self.isFocused && !self.isInputHidden);
2533	    if (!self.loading) {
2534	      removeClasses(self.wrapper, self.settings.loadingClass);
2535	    }
2536	    self.trigger('load', options, optgroups);
2537	  }
2538	  preload() {
2539	    var classList = this.wrapper.classList;
2540	    if (classList.contains('preloaded')) return;
2541	    classList.add('preloaded');
2542	    this.load('');
2543	  }
2544
2545	  /**
2546	   * Sets the input field of the control to the specified value.
2547	   *
2548	   */
2549	  setTextboxValue(value = '') {
2550	    var input = this.control_input;
2551	    var changed = input.value !== value;
2552	    if (changed) {
2553	      input.value = value;
2554	      triggerEvent(input, 'update');
2555	      this.lastValue = value;
2556	    }
2557	  }
2558
2559	  /**
2560	   * Returns the value of the control. If multiple items
2561	   * can be selected (e.g. <select multiple>), this returns
2562	   * an array. If only one item can be selected, this
2563	   * returns a string.
2564	   *
2565	   */
2566	  getValue() {
2567	    if (this.is_select_tag && this.input.hasAttribute('multiple')) {
2568	      return this.items;
2569	    }
2570	    return this.items.join(this.settings.delimiter);
2571	  }
2572
2573	  /**
2574	   * Resets the selected items to the given value.
2575	   *
2576	   */
2577	  setValue(value, silent) {
2578	    var events = silent ? [] : ['change'];
2579	    debounce_events(this, events, () => {
2580	      this.clear(silent);
2581	      this.addItems(value, silent);
2582	    });
2583	  }
2584
2585	  /**
2586	   * Resets the number of max items to the given value
2587	   *
2588	   */
2589	  setMaxItems(value) {
2590	    if (value === 0) value = null; //reset to unlimited items.
2591	    this.settings.maxItems = value;
2592	    this.refreshState();
2593	  }
2594
2595	  /**
2596	   * Sets the selected item.
2597	   *
2598	   */
2599	  setActiveItem(item, e) {
2600	    var self = this;
2601	    var eventName;
2602	    var i, begin, end, swap;
2603	    var last;
2604	    if (self.settings.mode === 'single') return;
2605
2606	    // clear the active selection
2607	    if (!item) {
2608	      self.clearActiveItems();
2609	      if (self.isFocused) {
2610	        self.inputState();
2611	      }
2612	      return;
2613	    }
2614
2615	    // modify selection
2616	    eventName = e && e.type.toLowerCase();
2617	    if (eventName === 'click' && isKeyDown('shiftKey', e) && self.activeItems.length) {
2618	      last = self.getLastActive();
2619	      begin = Array.prototype.indexOf.call(self.control.children, last);
2620	      end = Array.prototype.indexOf.call(self.control.children, item);
2621	      if (begin > end) {
2622	        swap = begin;
2623	        begin = end;
2624	        end = swap;
2625	      }
2626	      for (i = begin; i <= end; i++) {
2627	        item = self.control.children[i];
2628	        if (self.activeItems.indexOf(item) === -1) {
2629	          self.setActiveItemClass(item);
2630	        }
2631	      }
2632	      preventDefault(e);
2633	    } else if (eventName === 'click' && isKeyDown(KEY_SHORTCUT, e) || eventName === 'keydown' && isKeyDown('shiftKey', e)) {
2634	      if (item.classList.contains('active')) {
2635	        self.removeActiveItem(item);
2636	      } else {
2637	        self.setActiveItemClass(item);
2638	      }
2639	    } else {
2640	      self.clearActiveItems();
2641	      self.setActiveItemClass(item);
2642	    }
2643
2644	    // ensure control has focus
2645	    self.inputState();
2646	    if (!self.isFocused) {
2647	      self.focus();
2648	    }
2649	  }
2650
2651	  /**
2652	   * Set the active and last-active classes
2653	   *
2654	   */
2655	  setActiveItemClass(item) {
2656	    const self = this;
2657	    const last_active = self.control.querySelector('.last-active');
2658	    if (last_active) removeClasses(last_active, 'last-active');
2659	    addClasses(item, 'active last-active');
2660	    self.trigger('item_select', item);
2661	    if (self.activeItems.indexOf(item) == -1) {
2662	      self.activeItems.push(item);
2663	    }
2664	  }
2665
2666	  /**
2667	   * Remove active item
2668	   *
2669	   */
2670	  removeActiveItem(item) {
2671	    var idx = this.activeItems.indexOf(item);
2672	    this.activeItems.splice(idx, 1);
2673	    removeClasses(item, 'active');
2674	  }
2675
2676	  /**
2677	   * Clears all the active items
2678	   *
2679	   */
2680	  clearActiveItems() {
2681	    removeClasses(this.activeItems, 'active');
2682	    this.activeItems = [];
2683	  }
2684
2685	  /**
2686	   * Sets the selected item in the dropdown menu
2687	   * of available options.
2688	   *
2689	   */
2690	  setActiveOption(option, scroll = true) {
2691	    if (option === this.activeOption) {
2692	      return;
2693	    }
2694	    this.clearActiveOption();
2695	    if (!option) return;
2696	    this.activeOption = option;
2697	    setAttr(this.focus_node, {
2698	      'aria-activedescendant': option.getAttribute('id')
2699	    });
2700	    setAttr(option, {
2701	      'aria-selected': 'true'
2702	    });
2703	    addClasses(option, 'active');
2704	    if (scroll) this.scrollToOption(option);
2705	  }
2706
2707	  /**
2708	   * Sets the dropdown_content scrollTop to display the option
2709	   *
2710	   */
2711	  scrollToOption(option, behavior) {
2712	    if (!option) return;
2713	    const content = this.dropdown_content;
2714	    const height_menu = content.clientHeight;
2715	    const scrollTop = content.scrollTop || 0;
2716	    const height_item = option.offsetHeight;
2717	    const y = option.getBoundingClientRect().top - content.getBoundingClientRect().top + scrollTop;
2718	    if (y + height_item > height_menu + scrollTop) {
2719	      this.scroll(y - height_menu + height_item, behavior);
2720	    } else if (y < scrollTop) {
2721	      this.scroll(y, behavior);
2722	    }
2723	  }
2724
2725	  /**
2726	   * Scroll the dropdown to the given position
2727	   *
2728	   */
2729	  scroll(scrollTop, behavior) {
2730	    const content = this.dropdown_content;
2731	    if (behavior) {
2732	      content.style.scrollBehavior = behavior;
2733	    }
2734	    content.scrollTop = scrollTop;
2735	    content.style.scrollBehavior = '';
2736	  }
2737
2738	  /**
2739	   * Clears the active option
2740	   *
2741	   */
2742	  clearActiveOption() {
2743	    if (this.activeOption) {
2744	      removeClasses(this.activeOption, 'active');
2745	      setAttr(this.activeOption, {
2746	        'aria-selected': null
2747	      });
2748	    }
2749	    this.activeOption = null;
2750	    setAttr(this.focus_node, {
2751	      'aria-activedescendant': null
2752	    });
2753	  }
2754
2755	  /**
2756	   * Selects all items (CTRL + A).
2757	   */
2758	  selectAll() {
2759	    const self = this;
2760	    if (self.settings.mode === 'single') return;
2761	    const activeItems = self.controlChildren();
2762	    if (!activeItems.length) return;
2763	    self.inputState();
2764	    self.close();
2765	    self.activeItems = activeItems;
2766	    iterate(activeItems, item => {
2767	      self.setActiveItemClass(item);
2768	    });
2769	  }
2770
2771	  /**
2772	   * Determines if the control_input should be in a hidden or visible state
2773	   *
2774	   */
2775	  inputState() {
2776	    var self = this;
2777	    if (!self.control.contains(self.control_input)) return;
2778	    setAttr(self.control_input, {
2779	      placeholder: self.settings.placeholder
2780	    });
2781	    if (self.activeItems.length > 0 || !self.isFocused && self.settings.hidePlaceholder && self.items.length > 0) {
2782	      self.setTextboxValue();
2783	      self.isInputHidden = true;
2784	    } else {
2785	      if (self.settings.hidePlaceholder && self.items.length > 0) {
2786	        setAttr(self.control_input, {
2787	          placeholder: ''
2788	        });
2789	      }
2790	      self.isInputHidden = false;
2791	    }
2792	    self.wrapper.classList.toggle('input-hidden', self.isInputHidden);
2793	  }
2794
2795	  /**
2796	   * Get the input value
2797	   */
2798	  inputValue() {
2799	    return this.control_input.value.trim();
2800	  }
2801
2802	  /**
2803	   * Gives the control focus.
2804	   */
2805	  focus() {
2806	    var self = this;
2807	    if (self.isDisabled || self.isReadOnly) return;
2808	    self.ignoreFocus = true;
2809