@prometa/sleek 0.0.4 → 0.0.6

package/dist/sleek-select.js

@@ -0,0 +1,2555 @@
+var Je = Object.defineProperty;
+var Oe = (s) => {
+  throw TypeError(s);
+};
+var We = (s, e, t) => e in s ? Je(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var N = (s, e, t) => We(s, typeof e != "symbol" ? e + "" : e, t), ae = (s, e, t) => e.has(s) || Oe("Cannot " + t);
+var x = (s, e, t) => (ae(s, e, "read from private field"), t ? t.call(s) : e.get(s)), K = (s, e, t) => e.has(s) ? Oe("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(s) : e.set(s, t), H = (s, e, t, i) => (ae(s, e, "write to private field"), i ? i.call(s, t) : e.set(s, t), t), we = (s, e, t) => (ae(s, e, "access private method"), t);
+import { snakeToCamel as Xe } from "./chartjs-chart.js";
+import { t as Ze } from "./utils.js";
+function ce(s, e) {
+  s.split(/\s+/).forEach((t) => {
+    e(t);
+  });
+}
+class et {
+  constructor() {
+    this._events = {};
+  }
+  on(e, t) {
+    ce(e, (i) => {
+      const n = this._events[i] || [];
+      n.push(t), this._events[i] = n;
+    });
+  }
+  off(e, t) {
+    var i = arguments.length;
+    if (i === 0) {
+      this._events = {};
+      return;
+    }
+    ce(e, (n) => {
+      if (i === 1) {
+        delete this._events[n];
+        return;
+      }
+      const o = this._events[n];
+      o !== void 0 && (o.splice(o.indexOf(t), 1), this._events[n] = o);
+    });
+  }
+  trigger(e, ...t) {
+    var i = this;
+    ce(e, (n) => {
+      const o = i._events[n];
+      o !== void 0 && o.forEach((r) => {
+        r.apply(i, t);
+      });
+    });
+  }
+}
+function tt(s) {
+  return s.plugins = {}, class extends s {
+    constructor() {
+      super(...arguments), this.plugins = {
+        names: [],
+        settings: {},
+        requested: {},
+        loaded: {}
+      };
+    }
+    /**
+     * Registers a plugin.
+     *
+     * @param {function} fn
+     */
+    static define(e, t) {
+      s.plugins[e] = {
+        name: e,
+        fn: t
+      };
+    }
+    /**
+     * Initializes the listed plugins (with options).
+     * Acceptable formats:
+     *
+     * List (without options):
+     *   ['a', 'b', 'c']
+     *
+     * List (with options):
+     *   [{'name': 'a', options: {}}, {'name': 'b', options: {}}]
+     *
+     * Hash (with options):
+     *   {'a': { ... }, 'b': { ... }, 'c': { ... }}
+     *
+     * @param {array|object} plugins
+     */
+    initializePlugins(e) {
+      var t, i;
+      const n = this, o = [];
+      if (Array.isArray(e))
+        e.forEach((r) => {
+          typeof r == "string" ? o.push(r) : (n.plugins.settings[r.name] = r.options, o.push(r.name));
+        });
+      else if (e)
+        for (t in e)
+          e.hasOwnProperty(t) && (n.plugins.settings[t] = e[t], o.push(t));
+      for (; i = o.shift(); )
+        n.require(i);
+    }
+    loadPlugin(e) {
+      var t = this, i = t.plugins, n = s.plugins[e];
+      if (!s.plugins.hasOwnProperty(e))
+        throw new Error('Unable to find "' + e + '" plugin');
+      i.requested[e] = !0, i.loaded[e] = n.fn.apply(t, [t.plugins.settings[e] || {}]), i.names.push(e);
+    }
+    /**
+     * Initializes a plugin.
+     *
+     */
+    require(e) {
+      var t = this, i = t.plugins;
+      if (!t.plugins.loaded.hasOwnProperty(e)) {
+        if (i.requested[e])
+          throw new Error('Plugin has circular dependency ("' + e + '")');
+        t.loadPlugin(e);
+      }
+      return i.loaded[e];
+    }
+  };
+}
+const le = (s) => (s = s.filter(Boolean), s.length < 2 ? s[0] || "" : it(s) == 1 ? "[" + s.join("") + "]" : "(?:" + s.join("|") + ")"), Ke = (s) => {
+  if (!st(s))
+    return s.join("");
+  let e = "", t = 0;
+  const i = () => {
+    t > 1 && (e += "{" + t + "}");
+  };
+  return s.forEach((n, o) => {
+    if (n === s[o - 1]) {
+      t++;
+      return;
+    }
+    i(), e += n, t = 1;
+  }), i(), e;
+}, Re = (s) => {
+  let e = Array.from(s);
+  return le(e);
+}, st = (s) => new Set(s).size !== s.length, G = (s) => (s + "").replace(/([\$\(\)\*\+\.\?\[\]\^\{\|\}\\])/gu, "\\$1"), it = (s) => s.reduce((e, t) => Math.max(e, nt(t)), 0), nt = (s) => Array.from(s).length, Be = (s) => {
+  if (s.length === 1)
+    return [[s]];
+  let e = [];
+  const t = s.substring(1);
+  return Be(t).forEach(function(n) {
+    let o = n.slice(0);
+    o[0] = s.charAt(0) + o[0], e.push(o), o = n.slice(0), o.unshift(s.charAt(0)), e.push(o);
+  }), e;
+}, rt = [[0, 65535]], ot = "[̀-ͯ·ʾʼ]";
+let ie, ze;
+const lt = 3, _e = {}, be = {
+  "/": "⁄∕",
+  0: "߀",
+  a: "ⱥɐɑ",
+  aa: "ꜳ",
+  ae: "æǽǣ",
+  ao: "ꜵ",
+  au: "ꜷ",
+  av: "ꜹꜻ",
+  ay: "ꜽ",
+  b: "ƀɓƃ",
+  c: "ꜿƈȼↄ",
+  d: "đɗɖᴅƌꮷԁɦ",
+  e: "ɛǝᴇɇ",
+  f: "ꝼƒ",
+  g: "ǥɠꞡᵹꝿɢ",
+  h: "ħⱨⱶɥ",
+  i: "ɨı",
+  j: "ɉȷ",
+  k: "ƙⱪꝁꝃꝅꞣ",
+  l: "łƚɫⱡꝉꝇꞁɭ",
+  m: "ɱɯϻ",
+  n: "ꞥƞɲꞑᴎлԉ",
+  o: "øǿɔɵꝋꝍᴑ",
+  oe: "œ",
+  oi: "ƣ",
+  oo: "ꝏ",
+  ou: "ȣ",
+  p: "ƥᵽꝑꝓꝕρ",
+  q: "ꝗꝙɋ",
+  r: "ɍɽꝛꞧꞃ",
+  s: "ßȿꞩꞅʂ",
+  t: "ŧƭʈⱦꞇ",
+  th: "þ",
+  tz: "ꜩ",
+  u: "ʉ",
+  v: "ʋꝟʌ",
+  vy: "ꝡ",
+  w: "ⱳ",
+  y: "ƴɏỿ",
+  z: "ƶȥɀⱬꝣ",
+  hv: "ƕ"
+};
+for (let s in be) {
+  let e = be[s] || "";
+  for (let t = 0; t < e.length; t++) {
+    let i = e.substring(t, t + 1);
+    _e[i] = s;
+  }
+}
+const at = new RegExp(Object.keys(_e).join("|") + "|" + ot, "gu"), ct = (s) => {
+  ie === void 0 && (ie = pt(rt));
+}, Ae = (s, e = "NFKD") => s.normalize(e), ne = (s) => Array.from(s).reduce(
+  /**
+   * @param {string} result
+   * @param {string} char
+   */
+  (e, t) => e + ut(t),
+  ""
+), ut = (s) => (s = Ae(s).toLowerCase().replace(at, (e) => _e[e] || ""), Ae(s, "NFC"));
+function* dt(s) {
+  for (const [e, t] of s)
+    for (let i = e; i <= t; i++) {
+      let n = String.fromCharCode(i), o = ne(n);
+      o != n.toLowerCase() && (o.length > lt || o.length != 0 && (yield { folded: o, composed: n, code_point: i }));
+    }
+}
+const ft = (s) => {
+  const e = {}, t = (i, n) => {
+    const o = e[i] || /* @__PURE__ */ new Set(), r = new RegExp("^" + Re(o) + "$", "iu");
+    n.match(r) || (o.add(G(n)), e[i] = o);
+  };
+  for (let i of dt(s))
+    t(i.folded, i.folded), t(i.folded, i.composed);
+  return e;
+}, pt = (s) => {
+  const e = ft(s), t = {};
+  let i = [];
+  for (let o in e) {
+    let r = e[o];
+    r && (t[o] = Re(r)), o.length > 1 && i.push(G(o));
+  }
+  i.sort((o, r) => r.length - o.length);
+  const n = le(i);
+  return ze = new RegExp("^" + n, "u"), t;
+}, ht = (s, e = 1) => {
+  let t = 0;
+  return s = s.map((i) => (ie[i] && (t += i.length), ie[i] || i)), t >= e ? Ke(s) : "";
+}, gt = (s, e = 1) => (e = Math.max(e, s.length - 1), le(Be(s).map((t) => ht(t, e)))), Se = (s, e = !0) => {
+  let t = s.length > 1 ? 1 : 0;
+  return le(s.map((i) => {
+    let n = [];
+    const o = e ? i.length() : i.length() - 1;
+    for (let r = 0; r < o; r++)
+      n.push(gt(i.substrs[r] || "", t));
+    return Ke(n);
+  }));
+}, mt = (s, e) => {
+  for (const t of e) {
+    if (t.start != s.start || t.end != s.end || t.substrs.join("") !== s.substrs.join(""))
+      continue;
+    let i = s.parts;
+    const n = (r) => {
+      for (const l of i) {
+        if (l.start === r.start && l.substr === r.substr)
+          return !1;
+        if (!(r.length == 1 || l.length == 1) && (r.start < l.start && r.end > l.start || l.start < r.start && l.end > r.start))
+          return !0;
+      }
+      return !1;
+    };
+    if (!(t.parts.filter(n).length > 0))
+      return !0;
+  }
+  return !1;
+};
+class re {
+  constructor() {
+    N(this, "parts");
+    N(this, "substrs");
+    N(this, "start");
+    N(this, "end");
+    this.parts = [], this.substrs = [], this.start = 0, this.end = 0;
+  }
+  add(e) {
+    e && (this.parts.push(e), this.substrs.push(e.substr), this.start = Math.min(e.start, this.start), this.end = Math.max(e.end, this.end));
+  }
+  last() {
+    return this.parts[this.parts.length - 1];
+  }
+  length() {
+    return this.parts.length;
+  }
+  clone(e, t) {
+    let i = new re(), n = JSON.parse(JSON.stringify(this.parts)), o = n.pop();
+    for (const c of n)
+      i.add(c);
+    let r = t.substr.substring(0, e - o.start), l = r.length;
+    return i.add({ start: o.start, end: o.start + l, length: l, substr: r }), i;
+  }
+}
+const vt = (s) => {
+  ct(), s = ne(s);
+  let e = "", t = [new re()];
+  for (let i = 0; i < s.length; i++) {
+    let o = s.substring(i).match(ze);
+    const r = s.substring(i, i + 1), l = o ? o[0] : null;
+    let c = [], a = /* @__PURE__ */ new Set();
+    for (const u of t) {
+      const d = u.last();
+      if (!d || d.length == 1 || d.end <= i)
+        if (l) {
+          const p = l.length;
+          u.add({ start: i, end: i + p, length: p, substr: l }), a.add("1");
+        } else
+          u.add({ start: i, end: i + 1, length: 1, substr: r }), a.add("2");
+      else if (l) {
+        let p = u.clone(i, d);
+        const w = l.length;
+        p.add({ start: i, end: i + w, length: w, substr: l }), c.push(p);
+      } else
+        a.add("3");
+    }
+    if (c.length > 0) {
+      c = c.sort((u, d) => u.length() - d.length());
+      for (let u of c)
+        mt(u, t) || t.push(u);
+      continue;
+    }
+    if (i > 0 && a.size == 1 && !a.has("3")) {
+      e += Se(t, !1);
+      let u = new re();
+      const d = t[0];
+      d && u.add(d.last()), t = [u];
+    }
+  }
+  return e += Se(t, !0), e;
+}, _t = (s, e) => {
+  if (s)
+    return s[e];
+}, yt = (s, e) => {
+  if (s) {
+    for (var t, i = e.split("."); (t = i.shift()) && (s = s[t]); )
+      ;
+    return s;
+  }
+}, ue = (s, e, t) => {
+  var i, n;
+  return !s || (s = s + "", e.regex == null) || (n = s.search(e.regex), n === -1) ? 0 : (i = e.string.length / s.length, n === 0 && (i += 0.5), i * t);
+}, de = (s, e) => {
+  var t = s[e];
+  if (typeof t == "function")
+    return t;
+  t && !Array.isArray(t) && (s[e] = [t]);
+}, X = (s, e) => {
+  if (Array.isArray(s))
+    s.forEach(e);
+  else
+    for (var t in s)
+      s.hasOwnProperty(t) && e(s[t], t);
+}, Ot = (s, e) => typeof s == "number" && typeof e == "number" ? s > e ? 1 : s < e ? -1 : 0 : (s = ne(s + "").toLowerCase(), e = ne(e + "").toLowerCase(), s > e ? 1 : e > s ? -1 : 0);
+class wt {
+  /**
+   * Textually searches arrays and hashes of objects
+   * by property (or multiple properties). Designed
+   * specifically for autocomplete.
+   *
+   */
+  constructor(e, t) {
+    N(this, "items");
+    // []|{};
+    N(this, "settings");
+    this.items = e, this.settings = t || { diacritics: !0 };
+  }
+  /**
+   * Splits a search string into an array of individual
+   * regexps to be used to match results.
+   *
+   */
+  tokenize(e, t, i) {
+    if (!e || !e.length)
+      return [];
+    const n = [], o = e.split(/\s+/);
+    var r;
+    return i && (r = new RegExp("^(" + Object.keys(i).map(G).join("|") + "):(.*)$")), o.forEach((l) => {
+      let c, a = null, u = null;
+      r && (c = l.match(r)) && (a = c[1], l = c[2]), l.length > 0 && (this.settings.diacritics ? u = vt(l) || null : u = G(l), u && t && (u = "\\b" + u)), n.push({
+        string: l,
+        regex: u ? new RegExp(u, "iu") : null,
+        field: a
+      });
+    }), n;
+  }
+  /**
+   * Returns a function to be used to score individual results.
+   *
+   * Good matches will have a higher score than poor matches.
+   * If an item is not a match, 0 will be returned by the function.
+   *
+   * @returns {T.ScoreFn}
+   */
+  getScoreFunction(e, t) {
+    var i = this.prepareSearch(e, t);
+    return this._getScoreFunction(i);
+  }
+  /**
+   * @returns {T.ScoreFn}
+   *
+   */
+  _getScoreFunction(e) {
+    const t = e.tokens, i = t.length;
+    if (!i)
+      return function() {
+        return 0;
+      };
+    const n = e.options.fields, o = e.weights, r = n.length, l = e.getAttrFn;
+    if (!r)
+      return function() {
+        return 1;
+      };
+    const c = /* @__PURE__ */ function() {
+      return r === 1 ? function(a, u) {
+        const d = n[0].field;
+        return ue(l(u, d), a, o[d] || 1);
+      } : function(a, u) {
+        var d = 0;
+        if (a.field) {
+          const p = l(u, a.field);
+          !a.regex && p ? d += 1 / r : d += ue(p, a, 1);
+        } else
+          X(o, (p, w) => {
+            d += ue(l(u, w), a, p);
+          });
+        return d / r;
+      };
+    }();
+    return i === 1 ? function(a) {
+      return c(t[0], a);
+    } : e.options.conjunction === "and" ? function(a) {
+      var u, d = 0;
+      for (let p of t) {
+        if (u = c(p, a), u <= 0)
+          return 0;
+        d += u;
+      }
+      return d / i;
+    } : function(a) {
+      var u = 0;
+      return X(t, (d) => {
+        u += c(d, a);
+      }), u / i;
+    };
+  }
+  /**
+   * Returns a function that can be used to compare two
+   * results, for sorting purposes. If no sorting should
+   * be performed, `null` will be returned.
+   *
+   * @return function(a,b)
+   */
+  getSortFunction(e, t) {
+    var i = this.prepareSearch(e, t);
+    return this._getSortFunction(i);
+  }
+  _getSortFunction(e) {
+    var t, i = [];
+    const n = this, o = e.options, r = !e.query && o.sort_empty ? o.sort_empty : o.sort;
+    if (typeof r == "function")
+      return r.bind(this);
+    const l = function(a, u) {
+      return a === "$score" ? u.score : e.getAttrFn(n.items[u.id], a);
+    };
+    if (r)
+      for (let a of r)
+        (e.query || a.field !== "$score") && i.push(a);
+    if (e.query) {
+      t = !0;
+      for (let a of i)
+        if (a.field === "$score") {
+          t = !1;
+          break;
+        }
+      t && i.unshift({ field: "$score", direction: "desc" });
+    } else
+      i = i.filter((a) => a.field !== "$score");
+    return i.length ? function(a, u) {
+      var d, p;
+      for (let w of i)
+        if (p = w.field, d = (w.direction === "desc" ? -1 : 1) * Ot(l(p, a), l(p, u)), d)
+          return d;
+      return 0;
+    } : null;
+  }
+  /**
+   * Parses a search query and returns an object
+   * with tokens and fields ready to be populated
+   * with results.
+   *
+   */
+  prepareSearch(e, t) {
+    const i = {};
+    var n = Object.assign({}, t);
+    if (de(n, "sort"), de(n, "sort_empty"), n.fields) {
+      de(n, "fields");
+      const o = [];
+      n.fields.forEach((r) => {
+        typeof r == "string" && (r = { field: r, weight: 1 }), o.push(r), i[r.field] = "weight" in r ? r.weight : 1;
+      }), n.fields = o;
+    }
+    return {
+      options: n,
+      query: e.toLowerCase().trim(),
+      tokens: this.tokenize(e, n.respect_word_boundaries, i),
+      total: 0,
+      items: [],
+      weights: i,
+      getAttrFn: n.nesting ? yt : _t
+    };
+  }
+  /**
+   * Searches through all items and returns a sorted array of matches.
+   *
+   */
+  search(e, t) {
+    var i = this, n, o;
+    o = this.prepareSearch(e, t), t = o.options, e = o.query;
+    const r = t.score || i._getScoreFunction(o);
+    e.length ? X(i.items, (c, a) => {
+      n = r(c), (t.filter === !1 || n > 0) && o.items.push({ score: n, id: a });
+    }) : X(i.items, (c, a) => {
+      o.items.push({ score: 1, id: a });
+    });
+    const l = i._getSortFunction(o);
+    return l && o.items.sort(l), o.total = o.items.length, typeof t.limit == "number" && (o.items = o.items.slice(0, t.limit)), o;
+  }
+}
+const T = (s) => typeof s > "u" || s === null ? null : se(s), se = (s) => typeof s == "boolean" ? s ? "1" : "0" : s + "", fe = (s) => (s + "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"), bt = (s, e) => e > 0 ? window.setTimeout(s, e) : (s.call(null), null), At = (s, e) => {
+  var t;
+  return function(i, n) {
+    var o = this;
+    t && (o.loading = Math.max(o.loading - 1, 0), clearTimeout(t)), t = setTimeout(function() {
+      t = null, o.loadedSearches[i] = !0, s.call(o, i, n);
+    }, e);
+  };
+}, Ce = (s, e, t) => {
+  var i, n = s.trigger, o = {};
+  s.trigger = function() {
+    var r = arguments[0];
+    if (e.indexOf(r) !== -1)
+      o[r] = arguments;
+    else
+      return n.apply(s, arguments);
+  }, t.apply(s, []), s.trigger = n;
+  for (i of e)
+    i in o && n.apply(s, o[i]);
+}, St = (s) => ({
+  start: s.selectionStart || 0,
+  length: (s.selectionEnd || 0) - (s.selectionStart || 0)
+}), C = (s, e = !1) => {
+  s && (s.preventDefault(), e && s.stopPropagation());
+}, L = (s, e, t, i) => {
+  s.addEventListener(e, t, i);
+}, R = (s, e) => {
+  if (!e || !e[s])
+    return !1;
+  var t = (e.altKey ? 1 : 0) + (e.ctrlKey ? 1 : 0) + (e.shiftKey ? 1 : 0) + (e.metaKey ? 1 : 0);
+  return t === 1;
+}, pe = (s, e) => {
+  const t = s.getAttribute("id");
+  return t || (s.setAttribute("id", e), e);
+}, xe = (s) => s.replace(/[\\"']/g, "\\$&"), B = (s, e) => {
+  e && s.append(e);
+}, I = (s, e) => {
+  if (Array.isArray(s))
+    s.forEach(e);
+  else
+    for (var t in s)
+      s.hasOwnProperty(t) && e(s[t], t);
+}, D = (s) => {
+  if (s.jquery)
+    return s[0];
+  if (s instanceof HTMLElement)
+    return s;
+  if (je(s)) {
+    var e = document.createElement("template");
+    return e.innerHTML = s.trim(), e.content.firstChild;
+  }
+  return document.querySelector(s);
+}, je = (s) => typeof s == "string" && s.indexOf("<") > -1, Ct = (s) => s.replace(/['"\\]/g, "\\$&"), he = (s, e) => {
+  var t = document.createEvent("HTMLEvents");
+  t.initEvent(e, !0, !1), s.dispatchEvent(t);
+}, Z = (s, e) => {
+  Object.assign(s.style, e);
+}, k = (s, ...e) => {
+  var t = Ye(e);
+  s = Qe(s), s.map((i) => {
+    t.map((n) => {
+      i.classList.add(n);
+    });
+  });
+}, M = (s, ...e) => {
+  var t = Ye(e);
+  s = Qe(s), s.map((i) => {
+    t.map((n) => {
+      i.classList.remove(n);
+    });
+  });
+}, Ye = (s) => {
+  var e = [];
+  return I(s, (t) => {
+    typeof t == "string" && (t = t.trim().split(/[\t\n\f\r\s]/)), Array.isArray(t) && (e = e.concat(t));
+  }), e.filter(Boolean);
+}, Qe = (s) => (Array.isArray(s) || (s = [s]), s), ge = (s, e, t) => {
+  if (!(t && !t.contains(s)))
+    for (; s && s.matches; ) {
+      if (s.matches(e))
+        return s;
+      s = s.parentNode;
+    }
+}, Ie = (s, e = 0) => e > 0 ? s[s.length - 1] : s[0], xt = (s) => Object.keys(s).length === 0, Ee = (s, e) => {
+  if (!s)
+    return -1;
+  e = e || s.nodeName;
+  for (var t = 0; s = s.previousElementSibling; )
+    s.matches(e) && t++;
+  return t;
+}, A = (s, e) => {
+  I(e, (t, i) => {
+    t == null ? s.removeAttribute(i) : s.setAttribute(i, "" + t);
+  });
+}, me = (s, e) => {
+  s.parentNode && s.parentNode.replaceChild(e, s);
+}, It = (s, e) => {
+  if (e === null)
+    return;
+  if (typeof e == "string") {
+    if (!e.length)
+      return;
+    e = new RegExp(e, "i");
+  }
+  const t = (o) => {
+    var r = o.data.match(e);
+    if (r && o.data.length > 0) {
+      var l = document.createElement("span");
+      l.className = "highlight";
+      var c = o.splitText(r.index);
+      c.splitText(r[0].length);
+      var a = c.cloneNode(!0);
+      return l.appendChild(a), me(c, l), 1;
+    }
+    return 0;
+  }, i = (o) => {
+    o.nodeType === 1 && o.childNodes && !/(script|style)/i.test(o.tagName) && (o.className !== "highlight" || o.tagName !== "SPAN") && Array.from(o.childNodes).forEach((r) => {
+      n(r);
+    });
+  }, n = (o) => o.nodeType === 3 ? t(o) : (i(o), 0);
+  n(s);
+}, Et = (s) => {
+  var e = s.querySelectorAll("span.highlight");
+  Array.prototype.forEach.call(e, function(t) {
+    var i = t.parentNode;
+    i.replaceChild(t.firstChild, t), i.normalize();
+  });
+}, Lt = 65, Ft = 13, kt = 27, $t = 37, Tt = 38, Pt = 39, Dt = 40, Le = 8, Ht = 46, Fe = 9, Mt = typeof navigator > "u" ? !1 : /Mac/.test(navigator.userAgent), ee = Mt ? "metaKey" : "ctrlKey", ke = {
+  options: [],
+  optgroups: [],
+  plugins: [],
+  delimiter: ",",
+  splitOn: null,
+  // regexp or string for splitting up values from a paste command
+  persist: !0,
+  diacritics: !0,
+  create: null,
+  createOnBlur: !1,
+  createFilter: null,
+  highlight: !0,
+  openOnFocus: !0,
+  shouldOpen: null,
+  maxOptions: 50,
+  maxItems: null,
+  hideSelected: null,
+  duplicates: !1,
+  addPrecedence: !1,
+  selectOnTab: !1,
+  preload: null,
+  allowEmptyOption: !1,
+  //closeAfterSelect: false,
+  refreshThrottle: 300,
+  loadThrottle: 300,
+  loadingClass: "loading",
+  dataAttr: null,
+  //'data-data',
+  optgroupField: "optgroup",
+  valueField: "value",
+  labelField: "text",
+  disabledField: "disabled",
+  optgroupLabelField: "label",
+  optgroupValueField: "value",
+  lockOptgroupOrder: !1,
+  sortField: "$order",
+  searchField: ["text"],
+  searchConjunction: "and",
+  mode: null,
+  wrapperClass: "ts-wrapper",
+  controlClass: "ts-control",
+  dropdownClass: "ts-dropdown",
+  dropdownContentClass: "ts-dropdown-content",
+  itemClass: "item",
+  optionClass: "option",
+  dropdownParent: null,
+  controlInput: '<input type="text" autocomplete="off" size="1" />',
+  copyClassesToDropdown: !1,
+  placeholder: null,
+  hidePlaceholder: null,
+  shouldLoad: function(s) {
+    return s.length > 0;
+  },
+  /*
+  load                 : null, // function(query, callback) { ... }
+  score                : null, // function(search) { ... }
+  onInitialize         : null, // function() { ... }
+  onChange             : null, // function(value) { ... }
+  onItemAdd            : null, // function(value, $item) { ... }
+  onItemRemove         : null, // function(value) { ... }
+  onClear              : null, // function() { ... }
+  onOptionAdd          : null, // function(value, data) { ... }
+  onOptionRemove       : null, // function(value) { ... }
+  onOptionClear        : null, // function() { ... }
+  onOptionGroupAdd     : null, // function(id, data) { ... }
+  onOptionGroupRemove  : null, // function(id) { ... }
+  onOptionGroupClear   : null, // function() { ... }
+  onDropdownOpen       : null, // function(dropdown) { ... }
+  onDropdownClose      : null, // function(dropdown) { ... }
+  onType               : null, // function(str) { ... }
+  onDelete             : null, // function(values) { ... }
+  */
+  render: {
+    /*
+    item: null,
+    optgroup: null,
+    optgroup_header: null,
+    option: null,
+    option_create: null
+    */
+  }
+};
+function $e(s, e) {
+  var t = Object.assign({}, ke, e), i = t.dataAttr, n = t.labelField, o = t.valueField, r = t.disabledField, l = t.optgroupField, c = t.optgroupLabelField, a = t.optgroupValueField, u = s.tagName.toLowerCase(), d = s.getAttribute("placeholder") || s.getAttribute("data-placeholder");
+  if (!d && !t.allowEmptyOption) {
+    let v = s.querySelector('option[value=""]');
+    v && (d = v.textContent);
+  }
+  var p = {
+    placeholder: d,
+    options: [],
+    optgroups: [],
+    items: [],
+    maxItems: null
+  }, w = () => {
+    var v, b = p.options, y = {}, h = 1;
+    let S = 0;
+    var P = (m) => {
+      var _ = Object.assign({}, m.dataset), g = i && _[i];
+      return typeof g == "string" && g.length && (_ = Object.assign(_, JSON.parse(g))), _;
+    }, q = (m, _) => {
+      var g = T(m.value);
+      if (g != null && !(!g && !t.allowEmptyOption)) {
+        if (y.hasOwnProperty(g)) {
+          if (_) {
+            var E = y[g][l];
+            E ? Array.isArray(E) ? E.push(_) : y[g][l] = [E, _] : y[g][l] = _;
+          }
+        } else {
+          var O = P(m);
+          O[n] = O[n] || m.textContent, O[o] = O[o] || g, O[r] = O[r] || m.disabled, O[l] = O[l] || _, O.$option = m, O.$order = O.$order || ++S, y[g] = O, b.push(O);
+        }
+        m.selected && p.items.push(g);
+      }
+    }, j = (m) => {
+      var _, g;
+      g = P(m), g[c] = g[c] || m.getAttribute("label") || "", g[a] = g[a] || h++, g[r] = g[r] || m.disabled, g.$order = g.$order || ++S, p.optgroups.push(g), _ = g[a], I(m.children, (E) => {
+        q(E, _);
+      });
+    };
+    p.maxItems = s.hasAttribute("multiple") ? null : 1, I(s.children, (m) => {
+      v = m.tagName.toLowerCase(), v === "optgroup" ? j(m) : v === "option" && q(m);
+    });
+  }, f = () => {
+    const v = s.getAttribute(i);
+    if (v)
+      p.options = JSON.parse(v), I(p.options, (y) => {
+        p.items.push(y[o]);
+      });
+    else {
+      var b = s.value.trim() || "";
+      if (!t.allowEmptyOption && !b.length)
+        return;
+      const y = b.split(t.delimiter);
+      I(y, (h) => {
+        const S = {};
+        S[n] = h, S[o] = h, p.options.push(S);
+      }), p.items = y;
+    }
+  };
+  return u === "select" ? w() : f(), Object.assign({}, ke, p, e);
+}
+var Te = 0;
+class F extends tt(et) {
+  constructor(e, t) {
+    super(), this.order = 0, this.isOpen = !1, this.isDisabled = !1, this.isReadOnly = !1, this.isInvalid = !1, this.isValid = !0, this.isLocked = !1, this.isFocused = !1, this.isInputHidden = !1, this.isSetup = !1, this.ignoreFocus = !1, this.ignoreHover = !1, this.hasOptions = !1, this.lastValue = "", this.caretPos = 0, this.loading = 0, this.loadedSearches = {}, this.activeOption = null, this.activeItems = [], this.optgroups = {}, this.options = {}, this.userOptions = {}, this.items = [], this.refreshTimeout = null, Te++;
+    var i, n = D(e);
+    if (n.tomselect)
+      throw new Error("Tom Select already initialized on this element");
+    n.tomselect = this;
+    var o = window.getComputedStyle && window.getComputedStyle(n, null);
+    i = o.getPropertyValue("direction");
+    const r = $e(n, t);
+    this.settings = r, this.input = n, this.tabIndex = n.tabIndex || 0, this.is_select_tag = n.tagName.toLowerCase() === "select", this.rtl = /rtl/i.test(i), this.inputId = pe(n, "tomselect-" + Te), this.isRequired = n.required, this.sifter = new wt(this.options, { diacritics: r.diacritics }), r.mode = r.mode || (r.maxItems === 1 ? "single" : "multi"), typeof r.hideSelected != "boolean" && (r.hideSelected = r.mode === "multi"), typeof r.hidePlaceholder != "boolean" && (r.hidePlaceholder = r.mode !== "multi");
+    var l = r.createFilter;
+    typeof l != "function" && (typeof l == "string" && (l = new RegExp(l)), l instanceof RegExp ? r.createFilter = (b) => l.test(b) : r.createFilter = (b) => this.settings.duplicates || !this.options[b]), this.initializePlugins(r.plugins), this.setupCallbacks(), this.setupTemplates();
+    const c = D("<div>"), a = D("<div>"), u = this._render("dropdown"), d = D('<div role="listbox" tabindex="-1">'), p = this.input.getAttribute("class") || "", w = r.mode;
+    var f;
+    if (k(c, r.wrapperClass, p, w), k(a, r.controlClass), B(c, a), k(u, r.dropdownClass, w), r.copyClassesToDropdown && k(u, p), k(d, r.dropdownContentClass), B(u, d), D(r.dropdownParent || c).appendChild(u), je(r.controlInput)) {
+      f = D(r.controlInput);
+      var v = ["autocorrect", "autocapitalize", "autocomplete", "spellcheck"];
+      I(v, (b) => {
+        n.getAttribute(b) && A(f, { [b]: n.getAttribute(b) });
+      }), f.tabIndex = -1, a.appendChild(f), this.focus_node = f;
+    } else r.controlInput ? (f = D(r.controlInput), this.focus_node = f) : (f = D("<input/>"), this.focus_node = a);
+    this.wrapper = c, this.dropdown = u, this.dropdown_content = d, this.control = a, this.control_input = f, this.setup();
+  }
+  /**
+   * set up event bindings.
+   *
+   */
+  setup() {
+    const e = this, t = e.settings, i = e.control_input, n = e.dropdown, o = e.dropdown_content, r = e.wrapper, l = e.control, c = e.input, a = e.focus_node, u = { passive: !0 }, d = e.inputId + "-ts-dropdown";
+    A(o, {
+      id: d
+    }), A(a, {
+      role: "combobox",
+      "aria-haspopup": "listbox",
+      "aria-expanded": "false",
+      "aria-controls": d
+    });
+    const p = pe(a, e.inputId + "-ts-control"), w = "label[for='" + Ct(e.inputId) + "']", f = document.querySelector(w), v = e.focus.bind(e);
+    if (f) {
+      L(f, "click", v), A(f, { for: p });
+      const h = pe(f, e.inputId + "-ts-label");
+      A(a, { "aria-labelledby": h }), A(o, { "aria-labelledby": h });
+    }
+    if (r.style.width = c.style.width, e.plugins.names.length) {
+      const h = "plugin-" + e.plugins.names.join(" plugin-");
+      k([r, n], h);
+    }
+    (t.maxItems === null || t.maxItems > 1) && e.is_select_tag && A(c, { multiple: "multiple" }), t.placeholder && A(i, { placeholder: t.placeholder }), !t.splitOn && t.delimiter && (t.splitOn = new RegExp("\\s*" + G(t.delimiter) + "+\\s*")), t.load && t.loadThrottle && (t.load = At(t.load, t.loadThrottle)), L(n, "mousemove", () => {
+      e.ignoreHover = !1;
+    }), L(n, "mouseenter", (h) => {
+      var S = ge(h.target, "[data-selectable]", n);
+      S && e.onOptionHover(h, S);
+    }, { capture: !0 }), L(n, "click", (h) => {
+      const S = ge(h.target, "[data-selectable]");
+      S && (e.onOptionSelect(h, S), C(h, !0));
+    }), L(l, "click", (h) => {
+      var S = ge(h.target, "[data-ts-item]", l);
+      if (S && e.onItemSelect(h, S)) {
+        C(h, !0);
+        return;
+      }
+      i.value == "" && (e.onClick(), C(h, !0));
+    }), L(a, "keydown", (h) => e.onKeyDown(h)), L(i, "keypress", (h) => e.onKeyPress(h)), L(i, "input", (h) => e.onInput(h)), L(a, "blur", (h) => e.onBlur(h)), L(a, "focus", (h) => e.onFocus(h)), L(i, "paste", (h) => e.onPaste(h));
+    const b = (h) => {
+      const S = h.composedPath()[0];
+      if (!r.contains(S) && !n.contains(S)) {
+        e.isFocused && e.blur(), e.inputState();
+        return;
+      }
+      S == i && e.isOpen ? h.stopPropagation() : C(h, !0);
+    }, y = () => {
+      e.isOpen && e.positionDropdown();
+    };
+    L(document, "mousedown", b), L(window, "scroll", y, u), L(window, "resize", y, u), this._destroy = () => {
+      document.removeEventListener("mousedown", b), window.removeEventListener("scroll", y), window.removeEventListener("resize", y), f && f.removeEventListener("click", v);
+    }, this.revertSettings = {
+      innerHTML: c.innerHTML,
+      tabIndex: c.tabIndex
+    }, c.tabIndex = -1, c.insertAdjacentElement("afterend", e.wrapper), e.sync(!1), t.items = [], delete t.optgroups, delete t.options, L(c, "invalid", () => {
+      e.isValid && (e.isValid = !1, e.isInvalid = !0, e.refreshState());
+    }), e.updateOriginalInput(), e.refreshItems(), e.close(!1), e.inputState(), e.isSetup = !0, c.disabled ? e.disable() : c.readOnly ? e.setReadOnly(!0) : e.enable(), e.on("change", this.onChange), k(c, "tomselected", "ts-hidden-accessible"), e.trigger("initialize"), t.preload === !0 && e.preload();
+  }
+  /**
+   * Register options and optgroups
+   *
+   */
+  setupOptions(e = [], t = []) {
+    this.addOptions(e), I(t, (i) => {
+      this.registerOptionGroup(i);
+    });
+  }
+  /**
+   * Sets up default rendering functions.
+   */
+  setupTemplates() {
+    var e = this, t = e.settings.labelField, i = e.settings.optgroupLabelField, n = {
+      optgroup: (o) => {
+        let r = document.createElement("div");
+        return r.className = "optgroup", r.appendChild(o.options), r;
+      },
+      optgroup_header: (o, r) => '<div class="optgroup-header">' + r(o[i]) + "</div>",
+      option: (o, r) => "<div>" + r(o[t]) + "</div>",
+      item: (o, r) => "<div>" + r(o[t]) + "</div>",
+      option_create: (o, r) => '<div class="create">Add <strong>' + r(o.input) + "</strong>&hellip;</div>",
+      no_results: () => '<div class="no-results">No results found</div>',
+      loading: () => '<div class="spinner"></div>',
+      not_loading: () => {
+      },
+      dropdown: () => "<div></div>"
+    };
+    e.settings.render = Object.assign({}, n, e.settings.render);
+  }
+  /**
+   * Maps fired events to callbacks provided
+   * in the settings used when creating the control.
+   */
+  setupCallbacks() {
+    var e, t, i = {
+      initialize: "onInitialize",
+      change: "onChange",
+      item_add: "onItemAdd",
+      item_remove: "onItemRemove",
+      item_select: "onItemSelect",
+      clear: "onClear",
+      option_add: "onOptionAdd",
+      option_remove: "onOptionRemove",
+      option_clear: "onOptionClear",
+      optgroup_add: "onOptionGroupAdd",
+      optgroup_remove: "onOptionGroupRemove",
+      optgroup_clear: "onOptionGroupClear",
+      dropdown_open: "onDropdownOpen",
+      dropdown_close: "onDropdownClose",
+      type: "onType",
+      load: "onLoad",
+      focus: "onFocus",
+      blur: "onBlur"
+    };
+    for (e in i)
+      t = this.settings[i[e]], t && this.on(e, t);
+  }
+  /**
+   * Sync the Tom Select instance with the original input or select
+   *
+   */
+  sync(e = !0) {
+    const t = this, i = e ? $e(t.input, { delimiter: t.settings.delimiter }) : t.settings;
+    t.setupOptions(i.options, i.optgroups), t.setValue(i.items || [], !0), t.lastQuery = null;
+  }
+  /**
+   * Triggered when the main control element
+   * has a click event.
+   *
+   */
+  onClick() {
+    var e = this;
+    if (e.activeItems.length > 0) {
+      e.clearActiveItems(), e.focus();
+      return;
+    }
+    e.isFocused && e.isOpen ? e.blur() : e.focus();
+  }
+  /**
+   * @deprecated v1.7
+   *
+   */
+  onMouseDown() {
+  }
+  /**
+   * Triggered when the value of the control has been changed.
+   * This should propagate the event to the original DOM
+   * input / select element.
+   */
+  onChange() {
+    he(this.input, "input"), he(this.input, "change");
+  }
+  /**
+   * Triggered on <input> paste.
+   *
+   */
+  onPaste(e) {
+    var t = this;
+    if (t.isInputHidden || t.isLocked) {
+      C(e);
+      return;
+    }
+    t.settings.splitOn && setTimeout(() => {
+      var i = t.inputValue();
+      if (i.match(t.settings.splitOn)) {
+        var n = i.trim().split(t.settings.splitOn);
+        I(n, (o) => {
+          T(o) && (this.options[o] ? t.addItem(o) : t.createItem(o));
+        });
+      }
+    }, 0);
+  }
+  /**
+   * Triggered on <input> keypress.
+   *
+   */
+  onKeyPress(e) {
+    var t = this;
+    if (t.isLocked) {
+      C(e);
+      return;
+    }
+    var i = String.fromCharCode(e.keyCode || e.which);
+    if (t.settings.create && t.settings.mode === "multi" && i === t.settings.delimiter) {
+      t.createItem(), C(e);
+      return;
+    }
+  }
+  /**
+   * Triggered on <input> keydown.
+   *
+   */
+  onKeyDown(e) {
+    var t = this;
+    if (t.ignoreHover = !0, t.isLocked) {
+      e.keyCode !== Fe && C(e);
+      return;
+    }
+    switch (e.keyCode) {
+      // ctrl+A: select all
+      case Lt:
+        if (R(ee, e) && t.control_input.value == "") {
+          C(e), t.selectAll();
+          return;
+        }
+        break;
+      // esc: close dropdown
+      case kt:
+        t.isOpen && (C(e, !0), t.close()), t.clearActiveItems();
+        return;
+      // down: open dropdown or move selection down
+      case Dt:
+        if (!t.isOpen && t.hasOptions)
+          t.open();
+        else if (t.activeOption) {
+          let i = t.getAdjacent(t.activeOption, 1);
+          i && t.setActiveOption(i);
+        }
+        C(e);
+        return;
+      // up: move selection up
+      case Tt:
+        if (t.activeOption) {
+          let i = t.getAdjacent(t.activeOption, -1);
+          i && t.setActiveOption(i);
+        }
+        C(e);
+        return;
+      // return: select active option
+      case Ft:
+        t.canSelect(t.activeOption) ? (t.onOptionSelect(e, t.activeOption), C(e)) : (t.settings.create && t.createItem() || document.activeElement == t.control_input && t.isOpen) && C(e);
+        return;
+      // left: modifiy item selection to the left
+      case $t:
+        t.advanceSelection(-1, e);
+        return;
+      // right: modifiy item selection to the right
+      case Pt:
+        t.advanceSelection(1, e);
+        return;
+      // tab: select active option and/or create item
+      case Fe:
+        t.settings.selectOnTab && (t.canSelect(t.activeOption) && (t.onOptionSelect(e, t.activeOption), C(e)), t.settings.create && t.createItem() && C(e));
+        return;
+      // delete|backspace: delete items
+      case Le:
+      case Ht:
+        t.deleteSelection(e);
+        return;
+    }
+    t.isInputHidden && !R(ee, e) && C(e);
+  }
+  /**
+   * Triggered on <input> keyup.
+   *
+   */
+  onInput(e) {
+    if (this.isLocked)
+      return;
+    const t = this.inputValue();
+    if (this.lastValue !== t) {
+      if (this.lastValue = t, t == "") {
+        this._onInput();
+        return;
+      }
+      this.refreshTimeout && window.clearTimeout(this.refreshTimeout), this.refreshTimeout = bt(() => {
+        this.refreshTimeout = null, this._onInput();
+      }, this.settings.refreshThrottle);
+    }
+  }
+  _onInput() {
+    const e = this.lastValue;
+    this.settings.shouldLoad.call(this, e) && this.load(e), this.refreshOptions(), this.trigger("type", e);
+  }
+  /**
+   * Triggered when the user rolls over
+   * an option in the autocomplete dropdown menu.
+   *
+   */
+  onOptionHover(e, t) {
+    this.ignoreHover || this.setActiveOption(t, !1);
+  }
+  /**
+   * Triggered on <input> focus.
+   *
+   */
+  onFocus(e) {
+    var t = this, i = t.isFocused;
+    if (t.isDisabled || t.isReadOnly) {
+      t.blur(), C(e);
+      return;
+    }
+    t.ignoreFocus || (t.isFocused = !0, t.settings.preload === "focus" && t.preload(), i || t.trigger("focus"), t.activeItems.length || (t.inputState(), t.refreshOptions(!!t.settings.openOnFocus)), t.refreshState());
+  }
+  /**
+   * Triggered on <input> blur.
+   *
+   */
+  onBlur(e) {
+    if (document.hasFocus() !== !1) {
+      var t = this;
+      if (t.isFocused) {
+        t.isFocused = !1, t.ignoreFocus = !1;
+        var i = () => {
+          t.close(), t.setActiveItem(), t.setCaret(t.items.length), t.trigger("blur");
+        };
+        t.settings.create && t.settings.createOnBlur ? t.createItem(null, i) : i();
+      }
+    }
+  }
+  /**
+   * Triggered when the user clicks on an option
+   * in the autocomplete dropdown menu.
+   *
+   */
+  onOptionSelect(e, t) {
+    var i, n = this;
+    t.parentElement && t.parentElement.matches("[data-disabled]") || (t.classList.contains("create") ? n.createItem(null, () => {
+      n.settings.closeAfterSelect && n.close();
+    }) : (i = t.dataset.value, typeof i < "u" && (n.lastQuery = null, n.addItem(i), n.settings.closeAfterSelect && n.close(), !n.settings.hideSelected && e.type && /click/.test(e.type) && n.setActiveOption(t))));
+  }
+  /**
+   * Return true if the given option can be selected
+   *
+   */
+  canSelect(e) {
+    return !!(this.isOpen && e && this.dropdown_content.contains(e));
+  }
+  /**
+   * Triggered when the user clicks on an item
+   * that has been selected.
+   *
+   */
+  onItemSelect(e, t) {
+    var i = this;
+    return !i.isLocked && i.settings.mode === "multi" ? (C(e), i.setActiveItem(t, e), !0) : !1;
+  }
+  /**
+   * Determines whether or not to invoke
+   * the user-provided option provider / loader
+   *
+   * Note, there is a subtle difference between
+   * this.canLoad() and this.settings.shouldLoad();
+   *
+   *	- settings.shouldLoad() is a user-input validator.
+   *	When false is returned, the not_loading template
+   *	will be added to the dropdown
+   *
+   *	- canLoad() is lower level validator that checks
+   * 	the Tom Select instance. There is no inherent user
+   *	feedback when canLoad returns false
+   *
+   */
+  canLoad(e) {
+    return !(!this.settings.load || this.loadedSearches.hasOwnProperty(e));
+  }
+  /**
+   * Invokes the user-provided option provider / loader.
+   *
+   */
+  load(e) {
+    const t = this;
+    if (!t.canLoad(e))
+      return;
+    k(t.wrapper, t.settings.loadingClass), t.loading++;
+    const i = t.loadCallback.bind(t);
+    t.settings.load.call(t, e, i);
+  }
+  /**
+   * Invoked by the user-provided option provider
+   *
+   */
+  loadCallback(e, t) {
+    const i = this;
+    i.loading = Math.max(i.loading - 1, 0), i.lastQuery = null, i.clearActiveOption(), i.setupOptions(e, t), i.refreshOptions(i.isFocused && !i.isInputHidden), i.loading || M(i.wrapper, i.settings.loadingClass), i.trigger("load", e, t);
+  }
+  preload() {
+    var e = this.wrapper.classList;
+    e.contains("preloaded") || (e.add("preloaded"), this.load(""));
+  }
+  /**
+   * Sets the input field of the control to the specified value.
+   *
+   */
+  setTextboxValue(e = "") {
+    var t = this.control_input, i = t.value !== e;
+    i && (t.value = e, he(t, "update"), this.lastValue = e);
+  }
+  /**
+   * Returns the value of the control. If multiple items
+   * can be selected (e.g. <select multiple>), this returns
+   * an array. If only one item can be selected, this
+   * returns a string.
+   *
+   */
+  getValue() {
+    return this.is_select_tag && this.input.hasAttribute("multiple") ? this.items : this.items.join(this.settings.delimiter);
+  }
+  /**
+   * Resets the selected items to the given value.
+   *
+   */
+  setValue(e, t) {
+    var i = t ? [] : ["change"];
+    Ce(this, i, () => {
+      this.clear(t), this.addItems(e, t);
+    });
+  }
+  /**
+   * Resets the number of max items to the given value
+   *
+   */
+  setMaxItems(e) {
+    e === 0 && (e = null), this.settings.maxItems = e, this.refreshState();
+  }
+  /**
+   * Sets the selected item.
+   *
+   */
+  setActiveItem(e, t) {
+    var i = this, n, o, r, l, c, a;
+    if (i.settings.mode !== "single") {
+      if (!e) {
+        i.clearActiveItems(), i.isFocused && i.inputState();
+        return;
+      }
+      if (n = t && t.type.toLowerCase(), n === "click" && R("shiftKey", t) && i.activeItems.length) {
+        for (a = i.getLastActive(), r = Array.prototype.indexOf.call(i.control.children, a), l = Array.prototype.indexOf.call(i.control.children, e), r > l && (c = r, r = l, l = c), o = r; o <= l; o++)
+          e = i.control.children[o], i.activeItems.indexOf(e) === -1 && i.setActiveItemClass(e);
+        C(t);
+      } else n === "click" && R(ee, t) || n === "keydown" && R("shiftKey", t) ? e.classList.contains("active") ? i.removeActiveItem(e) : i.setActiveItemClass(e) : (i.clearActiveItems(), i.setActiveItemClass(e));
+      i.inputState(), i.isFocused || i.focus();
+    }
+  }
+  /**
+   * Set the active and last-active classes
+   *
+   */
+  setActiveItemClass(e) {
+    const t = this, i = t.control.querySelector(".last-active");
+    i && M(i, "last-active"), k(e, "active last-active"), t.trigger("item_select", e), t.activeItems.indexOf(e) == -1 && t.activeItems.push(e);
+  }
+  /**
+   * Remove active item
+   *
+   */
+  removeActiveItem(e) {
+    var t = this.activeItems.indexOf(e);
+    this.activeItems.splice(t, 1), M(e, "active");
+  }
+  /**
+   * Clears all the active items
+   *
+   */
+  clearActiveItems() {
+    M(this.activeItems, "active"), this.activeItems = [];
+  }
+  /**
+   * Sets the selected item in the dropdown menu
+   * of available options.
+   *
+   */
+  setActiveOption(e, t = !0) {
+    e !== this.activeOption && (this.clearActiveOption(), e && (this.activeOption = e, A(this.focus_node, { "aria-activedescendant": e.getAttribute("id") }), A(e, { "aria-selected": "true" }), k(e, "active"), t && this.scrollToOption(e)));
+  }
+  /**
+   * Sets the dropdown_content scrollTop to display the option
+   *
+   */
+  scrollToOption(e, t) {
+    if (!e)
+      return;
+    const i = this.dropdown_content, n = i.clientHeight, o = i.scrollTop || 0, r = e.offsetHeight, l = e.getBoundingClientRect().top - i.getBoundingClientRect().top + o;
+    l + r > n + o ? this.scroll(l - n + r, t) : l < o && this.scroll(l, t);
+  }
+  /**
+   * Scroll the dropdown to the given position
+   *
+   */
+  scroll(e, t) {
+    const i = this.dropdown_content;
+    t && (i.style.scrollBehavior = t), i.scrollTop = e, i.style.scrollBehavior = "";
+  }
+  /**
+   * Clears the active option
+   *
+   */
+  clearActiveOption() {
+    this.activeOption && (M(this.activeOption, "active"), A(this.activeOption, { "aria-selected": null })), this.activeOption = null, A(this.focus_node, { "aria-activedescendant": null });
+  }
+  /**
+   * Selects all items (CTRL + A).
+   */
+  selectAll() {
+    const e = this;
+    if (e.settings.mode === "single")
+      return;
+    const t = e.controlChildren();
+    t.length && (e.inputState(), e.close(), e.activeItems = t, I(t, (i) => {
+      e.setActiveItemClass(i);
+    }));
+  }
+  /**
+   * Determines if the control_input should be in a hidden or visible state
+   *
+   */
+  inputState() {
+    var e = this;
+    e.control.contains(e.control_input) && (A(e.control_input, { placeholder: e.settings.placeholder }), e.activeItems.length > 0 || !e.isFocused && e.settings.hidePlaceholder && e.items.length > 0 ? (e.setTextboxValue(), e.isInputHidden = !0) : (e.settings.hidePlaceholder && e.items.length > 0 && A(e.control_input, { placeholder: "" }), e.isInputHidden = !1), e.wrapper.classList.toggle("input-hidden", e.isInputHidden));
+  }
+  /**
+   * Get the input value
+   */
+  inputValue() {
+    return this.control_input.value.trim();
+  }
+  /**
+   * Gives the control focus.
+   */
+  focus() {
+    var e = this;
+    e.isDisabled || e.isReadOnly || (e.ignoreFocus = !0, e.control_input.offsetWidth ? e.control_input.focus() : e.focus_node.focus(), setTimeout(() => {
+      e.ignoreFocus = !1, e.onFocus();
+    }, 0));
+  }
+  /**
+   * Forces the control out of focus.
+   *
+   */
+  blur() {
+    this.focus_node.blur(), this.onBlur();
+  }
+  /**
+   * Returns a function that scores an object
+   * to show how good of a match it is to the
+   * provided query.
+   *
+   * @return {function}
+   */
+  getScoreFunction(e) {
+    return this.sifter.getScoreFunction(e, this.getSearchOptions());
+  }
+  /**
+   * Returns search options for sifter (the system
+   * for scoring and sorting results).
+   *
+   * @see https://github.com/orchidjs/sifter.js
+   * @return {object}
+   */
+  getSearchOptions() {
+    var e = this.settings, t = e.sortField;
+    return typeof e.sortField == "string" && (t = [{ field: e.sortField }]), {
+      fields: e.searchField,
+      conjunction: e.searchConjunction,
+      sort: t,
+      nesting: e.nesting
+    };
+  }
+  /**
+   * Searches through available options and returns
+   * a sorted array of matches.
+   *
+   */
+  search(e) {
+    var t, i, n = this, o = this.getSearchOptions();
+    if (n.settings.score && (i = n.settings.score.call(n, e), typeof i != "function"))
+      throw new Error('Tom Select "score" setting must be a function that returns a function');
+    return e !== n.lastQuery ? (n.lastQuery = e, t = n.sifter.search(e, Object.assign(o, { score: i })), n.currentResults = t) : t = Object.assign({}, n.currentResults), n.settings.hideSelected && (t.items = t.items.filter((r) => {
+      let l = T(r.id);
+      return !(l && n.items.indexOf(l) !== -1);
+    })), t;
+  }
+  /**
+   * Refreshes the list of available options shown
+   * in the autocomplete dropdown menu.
+   *
+   */
+  refreshOptions(e = !0) {
+    var t, i, n, o, r, l, c, a, u, d;
+    const p = {}, w = [];
+    var f = this, v = f.inputValue();
+    const b = v === f.lastQuery || v == "" && f.lastQuery == null;
+    var y = f.search(v), h = null, S = f.settings.shouldOpen || !1, P = f.dropdown_content;
+    b && (h = f.activeOption, h && (u = h.closest("[data-group]"))), o = y.items.length, typeof f.settings.maxOptions == "number" && (o = Math.min(o, f.settings.maxOptions)), o > 0 && (S = !0);
+    const q = (m, _) => {
+      let g = p[m];
+      if (g !== void 0) {
+        let O = w[g];
+        if (O !== void 0)
+          return [g, O.fragment];
+      }
+      let E = document.createDocumentFragment();
+      return g = w.length, w.push({ fragment: E, order: _, optgroup: m }), [g, E];
+    };
+    for (t = 0; t < o; t++) {
+      let m = y.items[t];
+      if (!m)
+        continue;
+      let _ = m.id, g = f.options[_];
+      if (g === void 0)
+        continue;
+      let E = se(_), O = f.getOption(E, !0);
+      for (f.settings.hideSelected || O.classList.toggle("selected", f.items.includes(E)), r = g[f.settings.optgroupField] || "", l = Array.isArray(r) ? r : [r], i = 0, n = l && l.length; i < n; i++) {
+        r = l[i];
+        let J = g.$order, W = f.optgroups[r];
+        W === void 0 ? r = "" : J = W.$order;
+        const [Ge, qe] = q(r, J);
+        i > 0 && (O = O.cloneNode(!0), A(O, { id: g.$id + "-clone-" + i, "aria-selected": null }), O.classList.add("ts-cloned"), M(O, "active"), f.activeOption && f.activeOption.dataset.value == _ && u && u.dataset.group === r.toString() && (h = O)), qe.appendChild(O), r != "" && (p[r] = Ge);
+      }
+    }
+    f.settings.lockOptgroupOrder && w.sort((m, _) => m.order - _.order), c = document.createDocumentFragment(), I(w, (m) => {
+      let _ = m.fragment, g = m.optgroup;
+      if (!_ || !_.children.length)
+        return;
+      let E = f.optgroups[g];
+      if (E !== void 0) {
+        let O = document.createDocumentFragment(), J = f.render("optgroup_header", E);
+        B(O, J), B(O, _);
+        let W = f.render("optgroup", { group: E, options: O });
+        B(c, W);
+      } else
+        B(c, _);
+    }), P.innerHTML = "", B(P, c), f.settings.highlight && (Et(P), y.query.length && y.tokens.length && I(y.tokens, (m) => {
+      It(P, m.regex);
+    }));
+    var j = (m) => {
+      let _ = f.render(m, { input: v });
+      return _ && (S = !0, P.insertBefore(_, P.firstChild)), _;
+    };
+    if (f.loading ? j("loading") : f.settings.shouldLoad.call(f, v) ? y.items.length === 0 && j("no_results") : j("not_loading"), a = f.canCreate(v), a && (d = j("option_create")), f.hasOptions = y.items.length > 0 || a, S) {
+      if (y.items.length > 0) {
+        if (!h && f.settings.mode === "single" && f.items[0] != null && (h = f.getOption(f.items[0])), !P.contains(h)) {
+          let m = 0;
+          d && !f.settings.addPrecedence && (m = 1), h = f.selectable()[m];
+        }
+      } else d && (h = d);
+      e && !f.isOpen && (f.open(), f.scrollToOption(h, "auto")), f.setActiveOption(h);
+    } else
+      f.clearActiveOption(), e && f.isOpen && f.close(!1);
+  }
+  /**
+   * Return list of selectable options
+   *
+   */
+  selectable() {
+    return this.dropdown_content.querySelectorAll("[data-selectable]");
+  }
+  /**
+   * Adds an available option. If it already exists,
+   * nothing will happen. Note: this does not refresh
+   * the options list dropdown (use `refreshOptions`
+   * for that).
+   *
+   * Usage:
+   *
+   *   this.addOption(data)
+   *
+   */
+  addOption(e, t = !1) {
+    const i = this;
+    if (Array.isArray(e))
+      return i.addOptions(e, t), !1;
+    const n = T(e[i.settings.valueField]);
+    return n === null || i.options.hasOwnProperty(n) ? !1 : (e.$order = e.$order || ++i.order, e.$id = i.inputId + "-opt-" + e.$order, i.options[n] = e, i.lastQuery = null, t && (i.userOptions[n] = t, i.trigger("option_add", n, e)), n);
+  }
+  /**
+   * Add multiple options
+   *
+   */
+  addOptions(e, t = !1) {
+    I(e, (i) => {
+      this.addOption(i, t);
+    });
+  }
+  /**
+   * @deprecated 1.7.7
+   */
+  registerOption(e) {
+    return this.addOption(e);
+  }
+  /**
+   * Registers an option group to the pool of option groups.
+   *
+   * @return {boolean|string}
+   */
+  registerOptionGroup(e) {
+    var t = T(e[this.settings.optgroupValueField]);
+    return t === null ? !1 : (e.$order = e.$order || ++this.order, this.optgroups[t] = e, t);
+  }
+  /**
+   * Registers a new optgroup for options
+   * to be bucketed into.
+   *
+   */
+  addOptionGroup(e, t) {
+    var i;
+    t[this.settings.optgroupValueField] = e, (i = this.registerOptionGroup(t)) && this.trigger("optgroup_add", i, t);
+  }
+  /**
+   * Removes an existing option group.
+   *
+   */
+  removeOptionGroup(e) {
+    this.optgroups.hasOwnProperty(e) && (delete this.optgroups[e], this.clearCache(), this.trigger("optgroup_remove", e));
+  }
+  /**
+   * Clears all existing option groups.
+   */
+  clearOptionGroups() {
+    this.optgroups = {}, this.clearCache(), this.trigger("optgroup_clear");
+  }
+  /**
+   * Updates an option available for selection. If
+   * it is visible in the selected items or options
+   * dropdown, it will be re-rendered automatically.
+   *
+   */
+  updateOption(e, t) {
+    const i = this;
+    var n, o;
+    const r = T(e), l = T(t[i.settings.valueField]);
+    if (r === null)
+      return;
+    const c = i.options[r];
+    if (c == null)
+      return;
+    if (typeof l != "string")
+      throw new Error("Value must be set in option data");
+    const a = i.getOption(r), u = i.getItem(r);
+    if (t.$order = t.$order || c.$order, delete i.options[r], i.uncacheValue(l), i.options[l] = t, a) {
+      if (i.dropdown_content.contains(a)) {
+        const d = i._render("option", t);
+        me(a, d), i.activeOption === a && i.setActiveOption(d);
+      }
+      a.remove();
+    }
+    u && (o = i.items.indexOf(r), o !== -1 && i.items.splice(o, 1, l), n = i._render("item", t), u.classList.contains("active") && k(n, "active"), me(u, n)), i.lastQuery = null;
+  }
+  /**
+   * Removes a single option.
+   *
+   */
+  removeOption(e, t) {
+    const i = this;
+    e = se(e), i.uncacheValue(e), delete i.userOptions[e], delete i.options[e], i.lastQuery = null, i.trigger("option_remove", e), i.removeItem(e, t);
+  }
+  /**
+   * Clears all options.
+   */
+  clearOptions(e) {
+    const t = (e || this.clearFilter).bind(this);
+    this.loadedSearches = {}, this.userOptions = {}, this.clearCache();
+    const i = {};
+    I(this.options, (n, o) => {
+      t(n, o) && (i[o] = n);
+    }), this.options = this.sifter.items = i, this.lastQuery = null, this.trigger("option_clear");
+  }
+  /**
+   * Used by clearOptions() to decide whether or not an option should be removed
+   * Return true to keep an option, false to remove
+   *
+   */
+  clearFilter(e, t) {
+    return this.items.indexOf(t) >= 0;
+  }
+  /**
+   * Returns the dom element of the option
+   * matching the given value.
+   *
+   */
+  getOption(e, t = !1) {
+    const i = T(e);
+    if (i === null)
+      return null;
+    const n = this.options[i];
+    if (n != null) {
+      if (n.$div)
+        return n.$div;
+      if (t)
+        return this._render("option", n);
+    }
+    return null;
+  }
+  /**
+   * Returns the dom element of the next or previous dom element of the same type
+   * Note: adjacent options may not be adjacent DOM elements (optgroups)
+   *
+   */
+  getAdjacent(e, t, i = "option") {
+    var n = this, o;
+    if (!e)
+      return null;
+    i == "item" ? o = n.controlChildren() : o = n.dropdown_content.querySelectorAll("[data-selectable]");
+    for (let r = 0; r < o.length; r++)
+      if (o[r] == e)
+        return t > 0 ? o[r + 1] : o[r - 1];
+    return null;
+  }
+  /**
+   * Returns the dom element of the item
+   * matching the given value.
+   *
+   */
+  getItem(e) {
+    if (typeof e == "object")
+      return e;
+    var t = T(e);
+    return t !== null ? this.control.querySelector(`[data-value="${xe(t)}"]`) : null;
+  }
+  /**
+   * "Selects" multiple items at once. Adds them to the list
+   * at the current caret position.
+   *
+   */
+  addItems(e, t) {
+    var i = this, n = Array.isArray(e) ? e : [e];
+    n = n.filter((r) => i.items.indexOf(r) === -1);
+    const o = n[n.length - 1];
+    n.forEach((r) => {
+      i.isPending = r !== o, i.addItem(r, t);
+    });
+  }
+  /**
+   * "Selects" an item. Adds it to the list
+   * at the current caret position.
+   *
+   */
+  addItem(e, t) {
+    var i = t ? [] : ["change", "dropdown_close"];
+    Ce(this, i, () => {
+      var n, o;
+      const r = this, l = r.settings.mode, c = T(e);
+      if (!(c && r.items.indexOf(c) !== -1 && (l === "single" && r.close(), l === "single" || !r.settings.duplicates)) && !(c === null || !r.options.hasOwnProperty(c)) && (l === "single" && r.clear(t), !(l === "multi" && r.isFull()))) {
+        if (n = r._render("item", r.options[c]), r.control.contains(n) && (n = n.cloneNode(!0)), o = r.isFull(), r.items.splice(r.caretPos, 0, c), r.insertAtCaret(n), r.isSetup) {
+          if (!r.isPending && r.settings.hideSelected) {
+            let a = r.getOption(c), u = r.getAdjacent(a, 1);
+            u && r.setActiveOption(u);
+          }
+          !r.isPending && !r.settings.closeAfterSelect && r.refreshOptions(r.isFocused && l !== "single"), r.settings.closeAfterSelect != !1 && r.isFull() ? r.close() : r.isPending || r.positionDropdown(), r.trigger("item_add", c, n), r.isPending || r.updateOriginalInput({ silent: t });
+        }
+        (!r.isPending || !o && r.isFull()) && (r.inputState(), r.refreshState());
+      }
+    });
+  }
+  /**
+   * Removes the selected item matching
+   * the provided value.
+   *
+   */
+  removeItem(e = null, t) {
+    const i = this;
+    if (e = i.getItem(e), !e)
+      return;
+    var n, o;
+    const r = e.dataset.value;
+    n = Ee(e), e.remove(), e.classList.contains("active") && (o = i.activeItems.indexOf(e), i.activeItems.splice(o, 1), M(e, "active")), i.items.splice(n, 1), i.lastQuery = null, !i.settings.persist && i.userOptions.hasOwnProperty(r) && i.removeOption(r, t), n < i.caretPos && i.setCaret(i.caretPos - 1), i.updateOriginalInput({ silent: t }), i.refreshState(), i.positionDropdown(), i.trigger("item_remove", r, e);
+  }
+  /**
+   * Invokes the `create` method provided in the
+   * TomSelect options that should provide the data
+   * for the new item, given the user input.
+   *
+   * Once this completes, it will be added
+   * to the item list.
+   *
+   */
+  createItem(e = null, t = () => {
+  }) {
+    arguments.length === 3 && (t = arguments[2]), typeof t != "function" && (t = () => {
+    });
+    var i = this, n = i.caretPos, o;
+    if (e = e || i.inputValue(), !i.canCreate(e))
+      return t(), !1;
+    i.lock();
+    var r = !1, l = (c) => {
+      if (i.unlock(), !c || typeof c != "object")
+        return t();
+      var a = T(c[i.settings.valueField]);
+      if (typeof a != "string")
+        return t();
+      i.setTextboxValue(), i.addOption(c, !0), i.setCaret(n), i.addItem(a), t(c), r = !0;
+    };
+    return typeof i.settings.create == "function" ? o = i.settings.create.call(this, e, l) : o = {
+      [i.settings.labelField]: e,
+      [i.settings.valueField]: e
+    }, r || l(o), !0;
+  }
+  /**
+   * Re-renders the selected item lists.
+   */
+  refreshItems() {
+    var e = this;
+    e.lastQuery = null, e.isSetup && e.addItems(e.items), e.updateOriginalInput(), e.refreshState();
+  }
+  /**
+   * Updates all state-dependent attributes
+   * and CSS classes.
+   */
+  refreshState() {
+    const e = this;
+    e.refreshValidityState();
+    const t = e.isFull(), i = e.isLocked;
+    e.wrapper.classList.toggle("rtl", e.rtl);
+    const n = e.wrapper.classList;
+    n.toggle("focus", e.isFocused), n.toggle("disabled", e.isDisabled), n.toggle("readonly", e.isReadOnly), n.toggle("required", e.isRequired), n.toggle("invalid", !e.isValid), n.toggle("locked", i), n.toggle("full", t), n.toggle("input-active", e.isFocused && !e.isInputHidden), n.toggle("dropdown-active", e.isOpen), n.toggle("has-options", xt(e.options)), n.toggle("has-items", e.items.length > 0);
+  }
+  /**
+   * Update the `required` attribute of both input and control input.
+   *
+   * The `required` property needs to be activated on the control input
+   * for the error to be displayed at the right place. `required` also
+   * needs to be temporarily deactivated on the input since the input is
+   * hidden and can't show errors.
+   */
+  refreshValidityState() {
+    var e = this;
+    e.input.validity && (e.isValid = e.input.validity.valid, e.isInvalid = !e.isValid);
+  }
+  /**
+   * Determines whether or not more items can be added
+   * to the control without exceeding the user-defined maximum.
+   *
+   * @returns {boolean}
+   */
+  isFull() {
+    return this.settings.maxItems !== null && this.items.length >= this.settings.maxItems;
+  }
+  /**
+   * Refreshes the original <select> or <input>
+   * element to reflect the current state.
+   *
+   */
+  updateOriginalInput(e = {}) {
+    const t = this;
+    var i, n;
+    const o = t.input.querySelector('option[value=""]');
+    if (t.is_select_tag) {
+      let c = function(a, u, d) {
+        return a || (a = D('<option value="' + fe(u) + '">' + fe(d) + "</option>")), a != o && t.input.append(a), r.push(a), (a != o || l > 0) && (a.selected = !0), a;
+      };
+      const r = [], l = t.input.querySelectorAll("option:checked").length;
+      t.input.querySelectorAll("option:checked").forEach((a) => {
+        a.selected = !1;
+      }), t.items.length == 0 && t.settings.mode == "single" ? c(o, "", "") : t.items.forEach((a) => {
+        if (i = t.options[a], n = i[t.settings.labelField] || "", r.includes(i.$option)) {
+          const u = t.input.querySelector(`option[value="${xe(a)}"]:not(:checked)`);
+          c(u, a, n);
+        } else
+          i.$option = c(i.$option, a, n);
+      });
+    } else
+      t.input.value = t.getValue();
+    t.isSetup && (e.silent || t.trigger("change", t.getValue()));
+  }
+  /**
+   * Shows the autocomplete dropdown containing
+   * the available options.
+   */
+  open() {
+    var e = this;
+    e.isLocked || e.isOpen || e.settings.mode === "multi" && e.isFull() || (e.isOpen = !0, A(e.focus_node, { "aria-expanded": "true" }), e.refreshState(), Z(e.dropdown, { visibility: "hidden", display: "block" }), e.positionDropdown(), Z(e.dropdown, { visibility: "visible", display: "block" }), e.focus(), e.trigger("dropdown_open", e.dropdown));
+  }
+  /**
+   * Closes the autocomplete dropdown menu.
+   */
+  close(e = !0) {
+    var t = this, i = t.isOpen;
+    e && (t.setTextboxValue(), t.settings.mode === "single" && t.items.length && t.inputState()), t.isOpen = !1, A(t.focus_node, { "aria-expanded": "false" }), Z(t.dropdown, { display: "none" }), t.settings.hideSelected && t.clearActiveOption(), t.refreshState(), i && t.trigger("dropdown_close", t.dropdown);
+  }
+  /**
+   * Calculates and applies the appropriate
+   * position of the dropdown if dropdownParent = 'body'.
+   * Otherwise, position is determined by css
+   */
+  positionDropdown() {
+    if (this.settings.dropdownParent === "body") {
+      var e = this.control, t = e.getBoundingClientRect(), i = e.offsetHeight + t.top + window.scrollY, n = t.left + window.scrollX;
+      Z(this.dropdown, {
+        width: t.width + "px",
+        top: i + "px",
+        left: n + "px"
+      });
+    }
+  }
+  /**
+   * Resets / clears all selected items
+   * from the control.
+   *
+   */
+  clear(e) {
+    var t = this;
+    if (t.items.length) {
+      var i = t.controlChildren();
+      I(i, (n) => {
+        t.removeItem(n, !0);
+      }), t.inputState(), e || t.updateOriginalInput(), t.trigger("clear");
+    }
+  }
+  /**
+   * A helper method for inserting an element
+   * at the current caret position.
+   *
+   */
+  insertAtCaret(e) {
+    const t = this, i = t.caretPos, n = t.control;
+    n.insertBefore(e, n.children[i] || null), t.setCaret(i + 1);
+  }
+  /**
+   * Removes the current selected item(s).
+   *
+   */
+  deleteSelection(e) {
+    var t, i, n, o, r = this;
+    t = e && e.keyCode === Le ? -1 : 1, i = St(r.control_input);
+    const l = [];
+    if (r.activeItems.length)
+      o = Ie(r.activeItems, t), n = Ee(o), t > 0 && n++, I(r.activeItems, (c) => l.push(c));
+    else if ((r.isFocused || r.settings.mode === "single") && r.items.length) {
+      const c = r.controlChildren();
+      let a;
+      t < 0 && i.start === 0 && i.length === 0 ? a = c[r.caretPos - 1] : t > 0 && i.start === r.inputValue().length && (a = c[r.caretPos]), a !== void 0 && l.push(a);
+    }
+    if (!r.shouldDelete(l, e))
+      return !1;
+    for (C(e, !0), typeof n < "u" && r.setCaret(n); l.length; )
+      r.removeItem(l.pop());
+    return r.inputState(), r.positionDropdown(), r.refreshOptions(!1), !0;
+  }
+  /**
+   * Return true if the items should be deleted
+   */
+  shouldDelete(e, t) {
+    const i = e.map((n) => n.dataset.value);
+    return !(!i.length || typeof this.settings.onDelete == "function" && this.settings.onDelete(i, t) === !1);
+  }
+  /**
+   * Selects the previous / next item (depending on the `direction` argument).
+   *
+   * > 0 - right
+   * < 0 - left
+   *
+   */
+  advanceSelection(e, t) {
+    var i, n, o = this;
+    o.rtl && (e *= -1), !o.inputValue().length && (R(ee, t) || R("shiftKey", t) ? (i = o.getLastActive(e), i ? i.classList.contains("active") ? n = o.getAdjacent(i, e, "item") : n = i : e > 0 ? n = o.control_input.nextElementSibling : n = o.control_input.previousElementSibling, n && (n.classList.contains("active") && o.removeActiveItem(i), o.setActiveItemClass(n))) : o.moveCaret(e));
+  }
+  moveCaret(e) {
+  }
+  /**
+   * Get the last active item
+   *
+   */
+  getLastActive(e) {
+    let t = this.control.querySelector(".last-active");
+    if (t)
+      return t;
+    var i = this.control.querySelectorAll(".active");
+    if (i)
+      return Ie(i, e);
+  }
+  /**
+   * Moves the caret to the specified index.
+   *
+   * The input must be moved by leaving it in place and moving the
+   * siblings, due to the fact that focus cannot be restored once lost
+   * on mobile webkit devices
+   *
+   */
+  setCaret(e) {
+    this.caretPos = this.items.length;
+  }
+  /**
+   * Return list of item dom elements
+   *
+   */
+  controlChildren() {
+    return Array.from(this.control.querySelectorAll("[data-ts-item]"));
+  }
+  /**
+   * Disables user input on the control. Used while
+   * items are being asynchronously created.
+   */
+  lock() {
+    this.setLocked(!0);
+  }
+  /**
+   * Re-enables user input on the control.
+   */
+  unlock() {
+    this.setLocked(!1);
+  }
+  /**
+   * Disable or enable user input on the control
+   */
+  setLocked(e = this.isReadOnly || this.isDisabled) {
+    this.isLocked = e, this.refreshState();
+  }
+  /**
+   * Disables user input on the control completely.
+   * While disabled, it cannot receive focus.
+   */
+  disable() {
+    this.setDisabled(!0), this.close();
+  }
+  /**
+   * Enables the control so that it can respond
+   * to focus and user input.
+   */
+  enable() {
+    this.setDisabled(!1);
+  }
+  setDisabled(e) {
+    this.focus_node.tabIndex = e ? -1 : this.tabIndex, this.isDisabled = e, this.input.disabled = e, this.control_input.disabled = e, this.setLocked();
+  }
+  setReadOnly(e) {
+    this.isReadOnly = e, this.input.readOnly = e, this.control_input.readOnly = e, this.setLocked();
+  }
+  /**
+   * Completely destroys the control and
+   * unbinds all event listeners so that it can
+   * be garbage collected.
+   */
+  destroy() {
+    var e = this, t = e.revertSettings;
+    e.trigger("destroy"), e.off(), e.wrapper.remove(), e.dropdown.remove(), e.input.innerHTML = t.innerHTML, e.input.tabIndex = t.tabIndex, M(e.input, "tomselected", "ts-hidden-accessible"), e._destroy(), delete e.input.tomselect;
+  }
+  /**
+   * A helper method for rendering "item" and
+   * "option" templates, given the data.
+   *
+   */
+  render(e, t) {
+    var i, n;
+    const o = this;
+    if (typeof this.settings.render[e] != "function" || (n = o.settings.render[e].call(this, t, fe), !n))
+      return null;
+    if (n = D(n), e === "option" || e === "option_create" ? t[o.settings.disabledField] ? A(n, { "aria-disabled": "true" }) : A(n, { "data-selectable": "" }) : e === "optgroup" && (i = t.group[o.settings.optgroupValueField], A(n, { "data-group": i }), t.group[o.settings.disabledField] && A(n, { "data-disabled": "" })), e === "option" || e === "item") {
+      const r = se(t[o.settings.valueField]);
+      A(n, { "data-value": r }), e === "item" ? (k(n, o.settings.itemClass), A(n, { "data-ts-item": "" })) : (k(n, o.settings.optionClass), A(n, {
+        role: "option",
+        id: t.$id
+      }), t.$div = n, o.options[r] = t);
+    }
+    return n;
+  }
+  /**
+   * Type guarded rendering
+   *
+   */
+  _render(e, t) {
+    const i = this.render(e, t);
+    if (i == null)
+      throw "HTMLElement expected";
+    return i;
+  }
+  /**
+   * Clears the render cache for a template. If
+   * no template is given, clears all render
+   * caches.
+   *
+   */
+  clearCache() {
+    I(this.options, (e) => {
+      e.$div && (e.$div.remove(), delete e.$div);
+    });
+  }
+  /**
+   * Removes a value from item and option caches
+   *
+   */
+  uncacheValue(e) {
+    const t = this.getOption(e);
+    t && t.remove();
+  }
+  /**
+   * Determines whether or not to display the
+   * create item prompt, given a user input.
+   *
+   */
+  canCreate(e) {
+    return this.settings.create && e.length > 0 && this.settings.createFilter.call(this, e);
+  }
+  /**
+   * Wraps this.`method` so that `new_fn` can be invoked 'before', 'after', or 'instead' of the original method
+   *
+   * this.hook('instead','onKeyDown',function( arg1, arg2 ...){
+   *
+   * });
+   */
+  hook(e, t, i) {
+    var n = this, o = n[t];
+    n[t] = function() {
+      var r, l;
+      return e === "after" && (r = o.apply(n, arguments)), l = i.apply(n, arguments), e === "instead" ? l : (e === "before" && (r = o.apply(n, arguments)), r);
+    };
+  }
+}
+const Vt = (s, e, t, i) => {
+  s.addEventListener(e, t, i);
+};
+function Nt() {
+  Vt(this.input, "change", () => {
+    this.sync();
+  });
+}
+const Kt = (s) => typeof s > "u" || s === null ? null : Rt(s), Rt = (s) => typeof s == "boolean" ? s ? "1" : "0" : s + "", Pe = (s, e = !1) => {
+  s && (s.preventDefault(), e && s.stopPropagation());
+}, Bt = (s) => {
+  if (s.jquery)
+    return s[0];
+  if (s instanceof HTMLElement)
+    return s;
+  if (zt(s)) {
+    var e = document.createElement("template");
+    return e.innerHTML = s.trim(), e.content.firstChild;
+  }
+  return document.querySelector(s);
+}, zt = (s) => typeof s == "string" && s.indexOf("<") > -1;
+function jt(s) {
+  var e = this, t = e.onOptionSelect;
+  e.settings.hideSelected = !1;
+  const i = Object.assign({
+    // so that the user may add different ones as well
+    className: "tomselect-checkbox",
+    // the following default to the historic plugin's values
+    checkedClassNames: void 0,
+    uncheckedClassNames: void 0
+  }, s);
+  var n = function(l, c) {
+    c ? (l.checked = !0, i.uncheckedClassNames && l.classList.remove(...i.uncheckedClassNames), i.checkedClassNames && l.classList.add(...i.checkedClassNames)) : (l.checked = !1, i.checkedClassNames && l.classList.remove(...i.checkedClassNames), i.uncheckedClassNames && l.classList.add(...i.uncheckedClassNames));
+  }, o = function(l) {
+    setTimeout(() => {
+      var c = l.querySelector("input." + i.className);
+      c instanceof HTMLInputElement && n(c, l.classList.contains("selected"));
+    }, 1);
+  };
+  e.hook("after", "setupTemplates", () => {
+    var r = e.settings.render.option;
+    e.settings.render.option = (l, c) => {
+      var a = Bt(r.call(e, l, c)), u = document.createElement("input");
+      i.className && u.classList.add(i.className), u.addEventListener("click", function(p) {
+        Pe(p);
+      }), u.type = "checkbox";
+      const d = Kt(l[e.settings.valueField]);
+      return n(u, !!(d && e.items.indexOf(d) > -1)), a.prepend(u), a;
+    };
+  }), e.on("item_remove", (r) => {
+    var l = e.getOption(r);
+    l && (l.classList.remove("selected"), o(l));
+  }), e.on("item_add", (r) => {
+    var l = e.getOption(r);
+    l && o(l);
+  }), e.hook("instead", "onOptionSelect", (r, l) => {
+    if (l.classList.contains("selected")) {
+      l.classList.remove("selected"), e.removeItem(l.dataset.value), e.refreshOptions(), Pe(r, !0);
+      return;
+    }
+    t.call(e, r, l), o(l);
+  });
+}
+const Yt = (s) => {
+  if (s.jquery)
+    return s[0];
+  if (s instanceof HTMLElement)
+    return s;
+  if (Qt(s)) {
+    var e = document.createElement("template");
+    return e.innerHTML = s.trim(), e.content.firstChild;
+  }
+  return document.querySelector(s);
+}, Qt = (s) => typeof s == "string" && s.indexOf("<") > -1;
+function Ut(s) {
+  const e = this, t = Object.assign({
+    className: "clear-button",
+    title: "Clear All",
+    html: (i) => `<div class="${i.className}" title="${i.title}">&#10799;</div>`
+  }, s);
+  e.on("initialize", () => {
+    var i = Yt(t.html(t));
+    i.addEventListener("click", (n) => {
+      e.isLocked || (e.clear(), e.settings.mode === "single" && e.settings.allowEmptyOption && e.addItem(""), n.preventDefault(), n.stopPropagation());
+    }), e.control.appendChild(i);
+  });
+}
+const Gt = (s, e = !1) => {
+  s && (s.preventDefault(), e && s.stopPropagation());
+}, Y = (s, e, t, i) => {
+  s.addEventListener(e, t, i);
+}, qt = (s, e) => {
+  if (Array.isArray(s))
+    s.forEach(e);
+  else
+    for (var t in s)
+      s.hasOwnProperty(t) && e(s[t], t);
+}, Jt = (s) => {
+  if (s.jquery)
+    return s[0];
+  if (s instanceof HTMLElement)
+    return s;
+  if (Wt(s)) {
+    var e = document.createElement("template");
+    return e.innerHTML = s.trim(), e.content.firstChild;
+  }
+  return document.querySelector(s);
+}, Wt = (s) => typeof s == "string" && s.indexOf("<") > -1, Xt = (s, e) => {
+  qt(e, (t, i) => {
+    t == null ? s.removeAttribute(i) : s.setAttribute(i, "" + t);
+  });
+}, Zt = (s, e) => {
+  var t;
+  (t = s.parentNode) == null || t.insertBefore(e, s.nextSibling);
+}, es = (s, e) => {
+  var t;
+  (t = s.parentNode) == null || t.insertBefore(e, s);
+}, ts = (s, e) => {
+  do {
+    var t;
+    if (e = (t = e) == null ? void 0 : t.previousElementSibling, s == e)
+      return !0;
+  } while (e && e.previousElementSibling);
+  return !1;
+};
+function ss() {
+  var s = this;
+  if (s.settings.mode !== "multi") return;
+  var e = s.lock, t = s.unlock;
+  let i = !0, n;
+  s.hook("after", "setupTemplates", () => {
+    var o = s.settings.render.item;
+    s.settings.render.item = (r, l) => {
+      const c = Jt(o.call(s, r, l));
+      Xt(c, {
+        draggable: "true"
+      });
+      const a = (v) => {
+        i || Gt(v), v.stopPropagation();
+      }, u = (v) => {
+        n = c, setTimeout(() => {
+          c.classList.add("ts-dragging");
+        }, 0);
+      }, d = (v) => {
+        v.preventDefault(), c.classList.add("ts-drag-over"), w(c, n);
+      }, p = () => {
+        c.classList.remove("ts-drag-over");
+      }, w = (v, b) => {
+        b !== void 0 && (ts(b, c) ? Zt(v, b) : es(v, b));
+      }, f = () => {
+        var v;
+        document.querySelectorAll(".ts-drag-over").forEach((y) => y.classList.remove("ts-drag-over")), (v = n) == null || v.classList.remove("ts-dragging"), n = void 0;
+        var b = [];
+        s.control.querySelectorAll("[data-value]").forEach((y) => {
+          if (y.dataset.value) {
+            let h = y.dataset.value;
+            h && b.push(h);
+          }
+        }), s.setValue(b);
+      };
+      return Y(c, "mousedown", a), Y(c, "dragstart", u), Y(c, "dragenter", d), Y(c, "dragover", d), Y(c, "dragleave", p), Y(c, "dragend", f), c;
+    };
+  }), s.hook("instead", "lock", () => (i = !1, e.call(s))), s.hook("instead", "unlock", () => (i = !0, t.call(s)));
+}
+const is = (s, e = !1) => {
+  s && (s.preventDefault(), e && s.stopPropagation());
+}, ns = (s) => {
+  if (s.jquery)
+    return s[0];
+  if (s instanceof HTMLElement)
+    return s;
+  if (rs(s)) {
+    var e = document.createElement("template");
+    return e.innerHTML = s.trim(), e.content.firstChild;
+  }
+  return document.querySelector(s);
+}, rs = (s) => typeof s == "string" && s.indexOf("<") > -1;
+function os(s) {
+  const e = this, t = Object.assign({
+    title: "Untitled",
+    headerClass: "dropdown-header",
+    titleRowClass: "dropdown-header-title",
+    labelClass: "dropdown-header-label",
+    closeClass: "dropdown-header-close",
+    html: (i) => '<div class="' + i.headerClass + '"><div class="' + i.titleRowClass + '"><span class="' + i.labelClass + '">' + i.title + '</span><a class="' + i.closeClass + '">&times;</a></div></div>'
+  }, s);
+  e.on("initialize", () => {
+    var i = ns(t.html(t)), n = i.querySelector("." + t.closeClass);
+    n && n.addEventListener("click", (o) => {
+      is(o, !0), e.close();
+    }), e.dropdown.insertBefore(i, e.dropdown.firstChild);
+  });
+}
+const ls = (s, e) => {
+  if (Array.isArray(s))
+    s.forEach(e);
+  else
+    for (var t in s)
+      s.hasOwnProperty(t) && e(s[t], t);
+}, as = (s, ...e) => {
+  var t = cs(e);
+  s = us(s), s.map((i) => {
+    t.map((n) => {
+      i.classList.remove(n);
+    });
+  });
+}, cs = (s) => {
+  var e = [];
+  return ls(s, (t) => {
+    typeof t == "string" && (t = t.trim().split(/[\t\n\f\r\s]/)), Array.isArray(t) && (e = e.concat(t));
+  }), e.filter(Boolean);
+}, us = (s) => (Array.isArray(s) || (s = [s]), s), ds = (s, e) => {
+  if (!s) return -1;
+  e = e || s.nodeName;
+  for (var t = 0; s = s.previousElementSibling; )
+    s.matches(e) && t++;
+  return t;
+};
+function fs() {
+  var s = this;
+  s.hook("instead", "setCaret", (e) => {
+    s.settings.mode === "single" || !s.control.contains(s.control_input) ? e = s.items.length : (e = Math.max(0, Math.min(s.items.length, e)), e != s.caretPos && !s.isPending && s.controlChildren().forEach((t, i) => {
+      i < e ? s.control_input.insertAdjacentElement("beforebegin", t) : s.control.appendChild(t);
+    })), s.caretPos = e;
+  }), s.hook("instead", "moveCaret", (e) => {
+    if (!s.isFocused) return;
+    const t = s.getLastActive(e);
+    if (t) {
+      const i = ds(t);
+      s.setCaret(e > 0 ? i + 1 : i), s.setActiveItem(), as(t, "last-active");
+    } else
+      s.setCaret(s.caretPos + e);
+  });
+}
+const ps = 27, hs = 9, gs = (s, e = !1) => {
+  s && (s.preventDefault(), e && s.stopPropagation());
+}, ms = (s, e, t, i) => {
+  s.addEventListener(e, t, i);
+}, vs = (s, e) => {
+  if (Array.isArray(s))
+    s.forEach(e);
+  else
+    for (var t in s)
+      s.hasOwnProperty(t) && e(s[t], t);
+}, De = (s) => {
+  if (s.jquery)
+    return s[0];
+  if (s instanceof HTMLElement)
+    return s;
+  if (_s(s)) {
+    var e = document.createElement("template");
+    return e.innerHTML = s.trim(), e.content.firstChild;
+  }
+  return document.querySelector(s);
+}, _s = (s) => typeof s == "string" && s.indexOf("<") > -1, ys = (s, ...e) => {
+  var t = Os(e);
+  s = ws(s), s.map((i) => {
+    t.map((n) => {
+      i.classList.add(n);
+    });
+  });
+}, Os = (s) => {
+  var e = [];
+  return vs(s, (t) => {
+    typeof t == "string" && (t = t.trim().split(/[\t\n\f\r\s]/)), Array.isArray(t) && (e = e.concat(t));
+  }), e.filter(Boolean);
+}, ws = (s) => (Array.isArray(s) || (s = [s]), s);
+function bs() {
+  const s = this;
+  s.settings.shouldOpen = !0, s.hook("before", "setup", () => {
+    s.focus_node = s.control, ys(s.control_input, "dropdown-input");
+    const e = De('<div class="dropdown-input-wrap">');
+    e.append(s.control_input), s.dropdown.insertBefore(e, s.dropdown.firstChild);
+    const t = De('<input class="items-placeholder" tabindex="-1" />');
+    t.placeholder = s.settings.placeholder || "", s.control.append(t);
+  }), s.on("initialize", () => {
+    s.control_input.addEventListener("keydown", (t) => {
+      switch (t.keyCode) {
+        case ps:
+          s.isOpen && (gs(t, !0), s.close()), s.clearActiveItems();
+          return;
+        case hs:
+          s.focus_node.tabIndex = -1;
+          break;
+      }
+      return s.onKeyDown.call(s, t);
+    }), s.on("blur", () => {
+      s.focus_node.tabIndex = s.isDisabled ? -1 : s.tabIndex;
+    }), s.on("dropdown_open", () => {
+      s.control_input.focus();
+    });
+    const e = s.onBlur;
+    s.hook("instead", "onBlur", (t) => {
+      if (!(t && t.relatedTarget == s.control_input))
+        return e.call(s);
+    }), ms(s.control_input, "blur", () => s.onBlur()), s.hook("before", "close", () => {
+      s.isOpen && s.focus_node.focus({
+        preventScroll: !0
+      });
+    });
+  });
+}
+const te = (s, e, t, i) => {
+  s.addEventListener(e, t, i);
+};
+function As() {
+  var s = this;
+  s.on("initialize", () => {
+    var e = document.createElement("span"), t = s.control_input;
+    e.style.cssText = "position:absolute; top:-99999px; left:-99999px; width:auto; padding:0; white-space:pre; ", s.wrapper.appendChild(e);
+    var i = ["letterSpacing", "fontSize", "fontFamily", "fontWeight", "textTransform"];
+    for (const o of i)
+      e.style[o] = t.style[o];
+    var n = () => {
+      e.textContent = t.value, t.style.width = e.clientWidth + "px";
+    };
+    n(), s.on("update item_add item_remove", n), te(t, "input", n), te(t, "keyup", n), te(t, "blur", n), te(t, "update", n);
+  });
+}
+function Ss() {
+  var s = this, e = s.deleteSelection;
+  this.hook("instead", "deleteSelection", (t) => s.activeItems.length ? e.call(s, t) : !1);
+}
+function Cs() {
+  this.hook("instead", "setActiveItem", () => {
+  }), this.hook("instead", "selectAll", () => {
+  });
+}
+const He = 37, xs = 39, Is = (s, e, t) => {
+  for (; s && s.matches; ) {
+    if (s.matches(e))
+      return s;
+    s = s.parentNode;
+  }
+}, Es = (s, e) => {
+  if (!s) return -1;
+  e = e || s.nodeName;
+  for (var t = 0; s = s.previousElementSibling; )
+    s.matches(e) && t++;
+  return t;
+};
+function Ls() {
+  var s = this, e = s.onKeyDown;
+  s.hook("instead", "onKeyDown", (t) => {
+    var i, n, o, r;
+    if (!s.isOpen || !(t.keyCode === He || t.keyCode === xs))
+      return e.call(s, t);
+    s.ignoreHover = !0, r = Is(s.activeOption, "[data-group]"), i = Es(s.activeOption, "[data-selectable]"), r && (t.keyCode === He ? r = r.previousSibling : r = r.nextSibling, r && (o = r.querySelectorAll("[data-selectable]"), n = o[Math.min(o.length - 1, i)], n && s.setActiveOption(n)));
+  });
+}
+const Fs = (s) => (s + "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"), Me = (s, e = !1) => {
+  s && (s.preventDefault(), e && s.stopPropagation());
+}, Ve = (s, e, t, i) => {
+  s.addEventListener(e, t, i);
+}, Ne = (s) => {
+  if (s.jquery)
+    return s[0];
+  if (s instanceof HTMLElement)
+    return s;
+  if (ks(s)) {
+    var e = document.createElement("template");
+    return e.innerHTML = s.trim(), e.content.firstChild;
+  }
+  return document.querySelector(s);
+}, ks = (s) => typeof s == "string" && s.indexOf("<") > -1;
+function $s(s) {
+  const e = Object.assign({
+    label: "&times;",
+    title: "Remove",
+    className: "remove",
+    append: !0
+  }, s);
+  var t = this;
+  if (e.append) {
+    var i = '<a href="javascript:void(0)" class="' + e.className + '" tabindex="-1" title="' + Fs(e.title) + '">' + e.label + "</a>";
+    t.hook("after", "setupTemplates", () => {
+      var n = t.settings.render.item;
+      t.settings.render.item = (o, r) => {
+        var l = Ne(n.call(t, o, r)), c = Ne(i);
+        return l.appendChild(c), Ve(c, "mousedown", (a) => {
+          Me(a, !0);
+        }), Ve(c, "click", (a) => {
+          t.isLocked || (Me(a, !0), !t.isLocked && t.shouldDelete([l], a) && (t.removeItem(l), t.refreshOptions(!1), t.inputState()));
+        }), l;
+      };
+    });
+  }
+}
+function Ts(s) {
+  const e = this, t = Object.assign({
+    text: (i) => i[e.settings.labelField]
+  }, s);
+  e.on("item_remove", function(i) {
+    if (e.isFocused && e.control_input.value.trim() === "") {
+      var n = e.options[i];
+      n && e.setTextboxValue(t.text.call(e, n));
+    }
+  });
+}
+const Ps = (s, e) => {
+  if (Array.isArray(s))
+    s.forEach(e);
+  else
+    for (var t in s)
+      s.hasOwnProperty(t) && e(s[t], t);
+}, Ds = (s, ...e) => {
+  var t = Hs(e);
+  s = Ms(s), s.map((i) => {
+    t.map((n) => {
+      i.classList.add(n);
+    });
+  });
+}, Hs = (s) => {
+  var e = [];
+  return Ps(s, (t) => {
+    typeof t == "string" && (t = t.trim().split(/[\t\n\f\r\s]/)), Array.isArray(t) && (e = e.concat(t));
+  }), e.filter(Boolean);
+}, Ms = (s) => (Array.isArray(s) || (s = [s]), s);
+function Vs() {
+  const s = this, e = s.canLoad, t = s.clearActiveOption, i = s.loadCallback;
+  var n = {}, o, r = !1, l, c = [];
+  if (s.settings.shouldLoadMore || (s.settings.shouldLoadMore = () => {
+    if (o.clientHeight / (o.scrollHeight - o.scrollTop) > 0.9)
+      return !0;
+    if (s.activeOption) {
+      var p = s.selectable(), w = Array.from(p).indexOf(s.activeOption);
+      if (w >= p.length - 2)
+        return !0;
+    }
+    return !1;
+  }), !s.settings.firstUrl)
+    throw "virtual_scroll plugin requires a firstUrl() method";
+  s.settings.sortField = [{
+    field: "$order"
+  }, {
+    field: "$score"
+  }];
+  const a = (d) => typeof s.settings.maxOptions == "number" && o.children.length >= s.settings.maxOptions ? !1 : !!(d in n && n[d]), u = (d, p) => s.items.indexOf(p) >= 0 || c.indexOf(p) >= 0;
+  s.setNextUrl = (d, p) => {
+    n[d] = p;
+  }, s.getUrl = (d) => {
+    if (d in n) {
+      const p = n[d];
+      return n[d] = !1, p;
+    }
+    return s.clearPagination(), s.settings.firstUrl.call(s, d);
+  }, s.clearPagination = () => {
+    n = {};
+  }, s.hook("instead", "clearActiveOption", () => {
+    if (!r)
+      return t.call(s);
+  }), s.hook("instead", "canLoad", (d) => d in n ? a(d) : e.call(s, d)), s.hook("instead", "loadCallback", (d, p) => {
+    if (!r)
+      s.clearOptions(u);
+    else if (l) {
+      const w = d[0];
+      w !== void 0 && (l.dataset.value = w[s.settings.valueField]);
+    }
+    i.call(s, d, p), r = !1;
+  }), s.hook("after", "refreshOptions", () => {
+    const d = s.lastValue;
+    var p;
+    a(d) ? (p = s.render("loading_more", {
+      query: d
+    }), p && (p.setAttribute("data-selectable", ""), l = p)) : d in n && !o.querySelector(".no-results") && (p = s.render("no_more_results", {
+      query: d
+    })), p && (Ds(p, s.settings.optionClass), o.append(p));
+  }), s.on("initialize", () => {
+    c = Object.keys(s.options), o = s.dropdown_content, s.settings.render = Object.assign({}, {
+      loading_more: () => '<div class="loading-more-results">Loading more results ... </div>',
+      no_more_results: () => '<div class="no-more-results">No more results</div>'
+    }, s.settings.render), o.addEventListener("scroll", () => {
+      s.settings.shouldLoadMore.call(s) && a(s.lastValue) && (r || (r = !0, s.load.call(s, s.lastValue)));
+    });
+  });
+}
+F.define("change_listener", Nt);
+F.define("checkbox_options", jt);
+F.define("clear_button", Ut);
+F.define("drag_drop", ss);
+F.define("dropdown_header", os);
+F.define("caret_position", fs);
+F.define("dropdown_input", bs);
+F.define("input_autogrow", As);
+F.define("no_backspace_delete", Ss);
+F.define("no_active_items", Cs);
+F.define("optgroup_columns", Ls);
+F.define("remove_button", $s);
+F.define("restore_on_backspace", Ts);
+F.define("virtual_scroll", Vs);
+const Ns = "/tom-select.bootstrap5.css";
+var $, Q, z, V, U, oe, Ue;
+const ye = class ye extends HTMLElement {
+  constructor() {
+    super();
+    K(this, oe);
+    K(this, $);
+    K(this, Q);
+    K(this, z);
+    K(this, V);
+    K(this, U, {});
+    H(this, $, document.createElement("select")), H(this, Q, this.attachShadow({ mode: "open" })), H(this, z, this.attachInternals());
+  }
+  connectedCallback() {
+    this.hasAttribute("name") && (x(this, $).name = this.getAttribute("name")), this.hasAttribute("multiple") && x(this, $).setAttribute("multiple", "");
+    const t = document.createElement("link");
+    t.setAttribute("rel", "stylesheet"), t.setAttribute("href", Ns), x(this, Q).appendChild(x(this, $)), x(this, Q).appendChild(t);
+    try {
+      H(this, U, this.getAttributeNames().filter(
+        (i) => i === "options" || i === "value-field" || i === "label-field" || i === "search-field" || i === "items" || i === "optgroup-field" || i === "optgroups"
+      ).reduce((i, n) => {
+        const o = n.split("."), r = o.pop(), l = this.getAttribute(n), c = o.reduce((a, u) => (u in a || (a[u] = {}), a[u]), i);
+        return c[Xe(r)] = Ze(l), i;
+      }, {}));
+    } catch (i) {
+      console.error("Invalid options JSON:", i), H(this, U, {});
+    }
+    this.tomSelect = new F(x(this, $), {
+      ...x(this, U),
+      plugins: ["remove_button", "clear_button"],
+      highlight: !0
+    }), H(this, V, x(this, $).value), x(this, z).setFormValue(x(this, V)), x(this, $).addEventListener("change", (i) => we(this, oe, Ue).call(this, i));
+  }
+  get value() {
+    return x(this, V);
+  }
+  set value(t) {
+    H(this, V, t), x(this, $).value = t, x(this, z).setFormValue(t);
+  }
+};
+$ = new WeakMap(), Q = new WeakMap(), z = new WeakMap(), V = new WeakMap(), U = new WeakMap(), oe = new WeakSet(), Ue = function(t) {
+  const i = Array.from(x(this, $).selectedOptions).map((o) => o.value);
+  H(this, V, i);
+  const n = new FormData();
+  for (const o of i)
+    n.append(x(this, $).name, o);
+  x(this, z).setFormValue(n);
+}, ye.formAssociated = !0;
+let ve = ye;
+customElements.define("sleek-select", ve);