@avakhula/ui 0.1.22 → 0.1.23

package/dist/components/TreeSelect/Select.js

@@ -0,0 +1,1871 @@
+import { computed as Z, unref as A, shallowRef as Q, watch as L, triggerRef as j, onScopeDispose as $, resolveComponent as E, resolveDirective as ee, createElementBlock as b, openBlock as y, Fragment as M, createBlock as S, createCommentVNode as v, createElementVNode as x, withCtx as C, createTextVNode as te, toDisplayString as z, mergeProps as se, createVNode as _, normalizeClass as I, createSlots as ie, normalizeStyle as B, withDirectives as R, withKeys as w, renderSlot as D, vShow as P, renderList as F, withModifiers as T } from "vue";
+import ne from "../Form/Input/Input.js";
+import re from "./Option.js";
+import { g as le } from "../../chunks/_commonjsHelpers-DaMA6jEr.js";
+import W from "../../helpers/generateUID.js";
+import oe from "../Dropdown/Dropdown.js";
+import ae from "../Icon.js";
+import he from "../IconButton/IconButton.js";
+import ce from "../Alert/Alert.js";
+import de from "../List.js";
+import ue from "./mixins/InfinityLoaderMixin.js";
+import { TooltipDirective as fe } from "../../directives/tooltip/tooltip.js";
+import pe from "../../helpers/debounce.js";
+import { _ as me } from "../../chunks/_plugin-vue_export-helper-CHgC5LLL.js";
+function N(n, o, t) {
+  let l = t.initialDeps ?? [], r;
+  function e() {
+    var i, s, a, c;
+    let h;
+    t.key && ((i = t.debug) != null && i.call(t)) && (h = Date.now());
+    const u = n();
+    if (!(u.length !== l.length || u.some((f, p) => l[p] !== f)))
+      return r;
+    l = u;
+    let m;
+    if (t.key && ((s = t.debug) != null && s.call(t)) && (m = Date.now()), r = o(...u), t.key && ((a = t.debug) != null && a.call(t))) {
+      const f = Math.round((Date.now() - h) * 100) / 100, p = Math.round((Date.now() - m) * 100) / 100, g = p / 16, O = (k, Y) => {
+        for (k = String(k); k.length < Y; )
+          k = " " + k;
+        return k;
+      };
+      console.info(
+        `%c⏱ ${O(p, 5)} /${O(f, 5)} ms`,
+        `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(
+          0,
+          Math.min(120 - 120 * g, 120)
+        )}deg 100% 31%);`,
+        t == null ? void 0 : t.key
+      );
+    }
+    return (c = t == null ? void 0 : t.onChange) == null || c.call(t, r), r;
+  }
+  return e.updateDeps = (i) => {
+    l = i;
+  }, e;
+}
+function K(n, o) {
+  if (n === void 0)
+    throw new Error("Unexpected undefined");
+  return n;
+}
+const ge = (n, o) => Math.abs(n - o) < 1.01, ye = (n, o, t) => {
+  let l;
+  return function(...r) {
+    n.clearTimeout(l), l = n.setTimeout(() => o.apply(this, r), t);
+  };
+}, q = (n) => {
+  const { offsetWidth: o, offsetHeight: t } = n;
+  return { width: o, height: t };
+}, be = (n) => n, ke = (n) => {
+  const o = Math.max(n.startIndex - n.overscan, 0), t = Math.min(n.endIndex + n.overscan, n.count - 1), l = [];
+  for (let r = o; r <= t; r++)
+    l.push(r);
+  return l;
+}, ve = (n, o) => {
+  const t = n.scrollElement;
+  if (!t)
+    return;
+  const l = n.targetWindow;
+  if (!l)
+    return;
+  const r = (i) => {
+    const { width: s, height: a } = i;
+    o({ width: Math.round(s), height: Math.round(a) });
+  };
+  if (r(q(t)), !l.ResizeObserver)
+    return () => {
+    };
+  const e = new l.ResizeObserver((i) => {
+    const s = () => {
+      const a = i[0];
+      if (a != null && a.borderBoxSize) {
+        const c = a.borderBoxSize[0];
+        if (c) {
+          r({ width: c.inlineSize, height: c.blockSize });
+          return;
+        }
+      }
+      r(q(t));
+    };
+    n.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(s) : s();
+  });
+  return e.observe(t, { box: "border-box" }), () => {
+    e.unobserve(t);
+  };
+}, J = {
+  passive: !0
+}, H = typeof window > "u" ? !0 : "onscrollend" in window, Oe = (n, o) => {
+  const t = n.scrollElement;
+  if (!t)
+    return;
+  const l = n.targetWindow;
+  if (!l)
+    return;
+  let r = 0;
+  const e = n.options.useScrollendEvent && H ? () => {
+  } : ye(
+    l,
+    () => {
+      o(r, !1);
+    },
+    n.options.isScrollingResetDelay
+  ), i = (h) => () => {
+    const { horizontal: u, isRtl: d } = n.options;
+    r = u ? t.scrollLeft * (d && -1 || 1) : t.scrollTop, e(), o(r, h);
+  }, s = i(!0), a = i(!1);
+  a(), t.addEventListener("scroll", s, J);
+  const c = n.options.useScrollendEvent && H;
+  return c && t.addEventListener("scrollend", a, J), () => {
+    t.removeEventListener("scroll", s), c && t.removeEventListener("scrollend", a);
+  };
+}, Ee = (n, o, t) => {
+  if (o != null && o.borderBoxSize) {
+    const l = o.borderBoxSize[0];
+    if (l)
+      return Math.round(
+        l[t.options.horizontal ? "inlineSize" : "blockSize"]
+      );
+  }
+  return n[t.options.horizontal ? "offsetWidth" : "offsetHeight"];
+}, Se = (n, {
+  adjustments: o = 0,
+  behavior: t
+}, l) => {
+  var r, e;
+  const i = n + o;
+  (e = (r = l.scrollElement) == null ? void 0 : r.scrollTo) == null || e.call(r, {
+    [l.options.horizontal ? "left" : "top"]: i,
+    behavior: t
+  });
+};
+class xe {
+  constructor(o) {
+    this.unsubs = [], this.scrollElement = null, this.targetWindow = null, this.isScrolling = !1, this.measurementsCache = [], this.itemSizeCache = /* @__PURE__ */ new Map(), this.pendingMeasuredCacheIndexes = [], this.scrollRect = null, this.scrollOffset = null, this.scrollDirection = null, this.scrollAdjustments = 0, this.elementsCache = /* @__PURE__ */ new Map(), this.observer = /* @__PURE__ */ (() => {
+      let t = null;
+      const l = () => t || (!this.targetWindow || !this.targetWindow.ResizeObserver ? null : t = new this.targetWindow.ResizeObserver((r) => {
+        r.forEach((e) => {
+          const i = () => {
+            this._measureElement(e.target, e);
+          };
+          this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(i) : i();
+        });
+      }));
+      return {
+        disconnect: () => {
+          var r;
+          (r = l()) == null || r.disconnect(), t = null;
+        },
+        observe: (r) => {
+          var e;
+          return (e = l()) == null ? void 0 : e.observe(r, { box: "border-box" });
+        },
+        unobserve: (r) => {
+          var e;
+          return (e = l()) == null ? void 0 : e.unobserve(r);
+        }
+      };
+    })(), this.range = null, this.setOptions = (t) => {
+      Object.entries(t).forEach(([l, r]) => {
+        typeof r > "u" && delete t[l];
+      }), this.options = {
+        debug: !1,
+        initialOffset: 0,
+        overscan: 1,
+        paddingStart: 0,
+        paddingEnd: 0,
+        scrollPaddingStart: 0,
+        scrollPaddingEnd: 0,
+        horizontal: !1,
+        getItemKey: be,
+        rangeExtractor: ke,
+        onChange: () => {
+        },
+        measureElement: Ee,
+        initialRect: { width: 0, height: 0 },
+        scrollMargin: 0,
+        gap: 0,
+        indexAttribute: "data-index",
+        initialMeasurementsCache: [],
+        lanes: 1,
+        isScrollingResetDelay: 150,
+        enabled: !0,
+        isRtl: !1,
+        useScrollendEvent: !1,
+        useAnimationFrameWithResizeObserver: !1,
+        ...t
+      };
+    }, this.notify = (t) => {
+      var l, r;
+      (r = (l = this.options).onChange) == null || r.call(l, this, t);
+    }, this.maybeNotify = N(
+      () => (this.calculateRange(), [
+        this.isScrolling,
+        this.range ? this.range.startIndex : null,
+        this.range ? this.range.endIndex : null
+      ]),
+      (t) => {
+        this.notify(t);
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "maybeNotify",
+        debug: () => this.options.debug,
+        initialDeps: [
+          this.isScrolling,
+          this.range ? this.range.startIndex : null,
+          this.range ? this.range.endIndex : null
+        ]
+      }
+    ), this.cleanup = () => {
+      this.unsubs.filter(Boolean).forEach((t) => t()), this.unsubs = [], this.observer.disconnect(), this.scrollElement = null, this.targetWindow = null;
+    }, this._didMount = () => () => {
+      this.cleanup();
+    }, this._willUpdate = () => {
+      var t;
+      const l = this.options.enabled ? this.options.getScrollElement() : null;
+      if (this.scrollElement !== l) {
+        if (this.cleanup(), !l) {
+          this.maybeNotify();
+          return;
+        }
+        this.scrollElement = l, this.scrollElement && "ownerDocument" in this.scrollElement ? this.targetWindow = this.scrollElement.ownerDocument.defaultView : this.targetWindow = ((t = this.scrollElement) == null ? void 0 : t.window) ?? null, this.elementsCache.forEach((r) => {
+          this.observer.observe(r);
+        }), this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        }), this.unsubs.push(
+          this.options.observeElementRect(this, (r) => {
+            this.scrollRect = r, this.maybeNotify();
+          })
+        ), this.unsubs.push(
+          this.options.observeElementOffset(this, (r, e) => {
+            this.scrollAdjustments = 0, this.scrollDirection = e ? this.getScrollOffset() < r ? "forward" : "backward" : null, this.scrollOffset = r, this.isScrolling = e, this.maybeNotify();
+          })
+        );
+      }
+    }, this.getSize = () => this.options.enabled ? (this.scrollRect = this.scrollRect ?? this.options.initialRect, this.scrollRect[this.options.horizontal ? "width" : "height"]) : (this.scrollRect = null, 0), this.getScrollOffset = () => this.options.enabled ? (this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset == "function" ? this.options.initialOffset() : this.options.initialOffset), this.scrollOffset) : (this.scrollOffset = null, 0), this.getFurthestMeasurement = (t, l) => {
+      const r = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
+      for (let i = l - 1; i >= 0; i--) {
+        const s = t[i];
+        if (r.has(s.lane))
+          continue;
+        const a = e.get(
+          s.lane
+        );
+        if (a == null || s.end > a.end ? e.set(s.lane, s) : s.end < a.end && r.set(s.lane, !0), r.size === this.options.lanes)
+          break;
+      }
+      return e.size === this.options.lanes ? Array.from(e.values()).sort((i, s) => i.end === s.end ? i.index - s.index : i.end - s.end)[0] : void 0;
+    }, this.getMeasurementOptions = N(
+      () => [
+        this.options.count,
+        this.options.paddingStart,
+        this.options.scrollMargin,
+        this.options.getItemKey,
+        this.options.enabled
+      ],
+      (t, l, r, e, i) => (this.pendingMeasuredCacheIndexes = [], {
+        count: t,
+        paddingStart: l,
+        scrollMargin: r,
+        getItemKey: e,
+        enabled: i
+      }),
+      {
+        key: !1
+      }
+    ), this.getMeasurements = N(
+      () => [this.getMeasurementOptions(), this.itemSizeCache],
+      ({ count: t, paddingStart: l, scrollMargin: r, getItemKey: e, enabled: i }, s) => {
+        if (!i)
+          return this.measurementsCache = [], this.itemSizeCache.clear(), [];
+        this.measurementsCache.length === 0 && (this.measurementsCache = this.options.initialMeasurementsCache, this.measurementsCache.forEach((h) => {
+          this.itemSizeCache.set(h.key, h.size);
+        }));
+        const a = this.pendingMeasuredCacheIndexes.length > 0 ? Math.min(...this.pendingMeasuredCacheIndexes) : 0;
+        this.pendingMeasuredCacheIndexes = [];
+        const c = this.measurementsCache.slice(0, a);
+        for (let h = a; h < t; h++) {
+          const u = e(h), d = this.options.lanes === 1 ? c[h - 1] : this.getFurthestMeasurement(c, h), m = d ? d.end + this.options.gap : l + r, f = s.get(u), p = typeof f == "number" ? f : this.options.estimateSize(h), g = m + p, O = d ? d.lane : h % this.options.lanes;
+          c[h] = {
+            index: h,
+            start: m,
+            size: p,
+            end: g,
+            key: u,
+            lane: O
+          };
+        }
+        return this.measurementsCache = c, c;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getMeasurements",
+        debug: () => this.options.debug
+      }
+    ), this.calculateRange = N(
+      () => [
+        this.getMeasurements(),
+        this.getSize(),
+        this.getScrollOffset(),
+        this.options.lanes
+      ],
+      (t, l, r, e) => this.range = t.length > 0 && l > 0 ? Ce({
+        measurements: t,
+        outerSize: l,
+        scrollOffset: r,
+        lanes: e
+      }) : null,
+      {
+        key: process.env.NODE_ENV !== "production" && "calculateRange",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualIndexes = N(
+      () => {
+        let t = null, l = null;
+        const r = this.calculateRange();
+        return r && (t = r.startIndex, l = r.endIndex), this.maybeNotify.updateDeps([this.isScrolling, t, l]), [
+          this.options.rangeExtractor,
+          this.options.overscan,
+          this.options.count,
+          t,
+          l
+        ];
+      },
+      (t, l, r, e, i) => e === null || i === null ? [] : t({
+        startIndex: e,
+        endIndex: i,
+        overscan: l,
+        count: r
+      }),
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualIndexes",
+        debug: () => this.options.debug
+      }
+    ), this.indexFromElement = (t) => {
+      const l = this.options.indexAttribute, r = t.getAttribute(l);
+      return r ? parseInt(r, 10) : (console.warn(
+        `Missing attribute name '${l}={index}' on measured element.`
+      ), -1);
+    }, this._measureElement = (t, l) => {
+      const r = this.indexFromElement(t), e = this.measurementsCache[r];
+      if (!e)
+        return;
+      const i = e.key, s = this.elementsCache.get(i);
+      s !== t && (s && this.observer.unobserve(s), this.observer.observe(t), this.elementsCache.set(i, t)), t.isConnected && this.resizeItem(r, this.options.measureElement(t, l, this));
+    }, this.resizeItem = (t, l) => {
+      const r = this.measurementsCache[t];
+      if (!r)
+        return;
+      const e = this.itemSizeCache.get(r.key) ?? r.size, i = l - e;
+      i !== 0 && ((this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(r, i, this) : r.start < this.getScrollOffset() + this.scrollAdjustments) && (process.env.NODE_ENV !== "production" && this.options.debug && console.info("correction", i), this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: this.scrollAdjustments += i,
+        behavior: void 0
+      })), this.pendingMeasuredCacheIndexes.push(r.index), this.itemSizeCache = new Map(this.itemSizeCache.set(r.key, l)), this.notify(!1));
+    }, this.measureElement = (t) => {
+      if (!t) {
+        this.elementsCache.forEach((l, r) => {
+          l.isConnected || (this.observer.unobserve(l), this.elementsCache.delete(r));
+        });
+        return;
+      }
+      this._measureElement(t, void 0);
+    }, this.getVirtualItems = N(
+      () => [this.getVirtualIndexes(), this.getMeasurements()],
+      (t, l) => {
+        const r = [];
+        for (let e = 0, i = t.length; e < i; e++) {
+          const s = t[e], a = l[s];
+          r.push(a);
+        }
+        return r;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualItems",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualItemForOffset = (t) => {
+      const l = this.getMeasurements();
+      if (l.length !== 0)
+        return K(
+          l[X(
+            0,
+            l.length - 1,
+            (r) => K(l[r]).start,
+            t
+          )]
+        );
+    }, this.getOffsetForAlignment = (t, l, r = 0) => {
+      const e = this.getSize(), i = this.getScrollOffset();
+      l === "auto" && (l = t >= i + e ? "end" : "start"), l === "center" ? t += (r - e) / 2 : l === "end" && (t -= e);
+      const s = this.getTotalSize() + this.options.scrollMargin - e;
+      return Math.max(Math.min(s, t), 0);
+    }, this.getOffsetForIndex = (t, l = "auto") => {
+      t = Math.max(0, Math.min(t, this.options.count - 1));
+      const r = this.measurementsCache[t];
+      if (!r)
+        return;
+      const e = this.getSize(), i = this.getScrollOffset();
+      if (l === "auto")
+        if (r.end >= i + e - this.options.scrollPaddingEnd)
+          l = "end";
+        else if (r.start <= i + this.options.scrollPaddingStart)
+          l = "start";
+        else
+          return [i, l];
+      const s = l === "end" ? r.end + this.options.scrollPaddingEnd : r.start - this.options.scrollPaddingStart;
+      return [
+        this.getOffsetForAlignment(s, l, r.size),
+        l
+      ];
+    }, this.isDynamicMode = () => this.elementsCache.size > 0, this.scrollToOffset = (t, { align: l = "start", behavior: r } = {}) => {
+      r === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), this._scrollToOffset(this.getOffsetForAlignment(t, l), {
+        adjustments: void 0,
+        behavior: r
+      });
+    }, this.scrollToIndex = (t, { align: l = "auto", behavior: r } = {}) => {
+      r === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), t = Math.max(0, Math.min(t, this.options.count - 1));
+      let e = 0;
+      const i = 10, s = (c) => {
+        if (!this.targetWindow) return;
+        const h = this.getOffsetForIndex(t, c);
+        if (!h) {
+          console.warn("Failed to get offset for index:", t);
+          return;
+        }
+        const [u, d] = h;
+        this._scrollToOffset(u, { adjustments: void 0, behavior: r }), this.targetWindow.requestAnimationFrame(() => {
+          const m = this.getScrollOffset(), f = this.getOffsetForIndex(t, d);
+          if (!f) {
+            console.warn("Failed to get offset for index:", t);
+            return;
+          }
+          ge(f[0], m) || a(d);
+        });
+      }, a = (c) => {
+        this.targetWindow && (e++, e < i ? (process.env.NODE_ENV !== "production" && this.options.debug && console.info("Schedule retry", e, i), this.targetWindow.requestAnimationFrame(() => s(c))) : console.warn(
+          `Failed to scroll to index ${t} after ${i} attempts.`
+        ));
+      };
+      s(l);
+    }, this.scrollBy = (t, { behavior: l } = {}) => {
+      l === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), this._scrollToOffset(this.getScrollOffset() + t, {
+        adjustments: void 0,
+        behavior: l
+      });
+    }, this.getTotalSize = () => {
+      var t;
+      const l = this.getMeasurements();
+      let r;
+      if (l.length === 0)
+        r = this.options.paddingStart;
+      else if (this.options.lanes === 1)
+        r = ((t = l[l.length - 1]) == null ? void 0 : t.end) ?? 0;
+      else {
+        const e = Array(this.options.lanes).fill(null);
+        let i = l.length - 1;
+        for (; i >= 0 && e.some((s) => s === null); ) {
+          const s = l[i];
+          e[s.lane] === null && (e[s.lane] = s.end), i--;
+        }
+        r = Math.max(...e.filter((s) => s !== null));
+      }
+      return Math.max(
+        r - this.options.scrollMargin + this.options.paddingEnd,
+        0
+      );
+    }, this._scrollToOffset = (t, {
+      adjustments: l,
+      behavior: r
+    }) => {
+      this.options.scrollToFn(t, { behavior: r, adjustments: l }, this);
+    }, this.measure = () => {
+      this.itemSizeCache = /* @__PURE__ */ new Map(), this.notify(!1);
+    }, this.setOptions(o);
+  }
+}
+const X = (n, o, t, l) => {
+  for (; n <= o; ) {
+    const r = (n + o) / 2 | 0, e = t(r);
+    if (e < l)
+      n = r + 1;
+    else if (e > l)
+      o = r - 1;
+    else
+      return r;
+  }
+  return n > 0 ? n - 1 : 0;
+};
+function Ce({
+  measurements: n,
+  outerSize: o,
+  scrollOffset: t,
+  lanes: l
+}) {
+  const r = n.length - 1, e = (a) => n[a].start;
+  if (n.length <= l)
+    return {
+      startIndex: 0,
+      endIndex: r
+    };
+  let i = X(
+    0,
+    r,
+    e,
+    t
+  ), s = i;
+  if (l === 1)
+    for (; s < r && n[s].end < t + o; )
+      s++;
+  else if (l > 1) {
+    const a = Array(l).fill(0);
+    for (; s < r && a.some((h) => h < t + o); ) {
+      const h = n[s];
+      a[h.lane] = h.end, s++;
+    }
+    const c = Array(l).fill(t + o);
+    for (; i >= 0 && c.some((h) => h >= t); ) {
+      const h = n[i];
+      c[h.lane] = h.start, i--;
+    }
+    i = Math.max(0, i - i % l), s = Math.min(r, s + (l - 1 - s % l));
+  }
+  return { startIndex: i, endIndex: s };
+}
+function Ie(n) {
+  const o = new xe(A(n)), t = Q(o), l = o._didMount();
+  return L(
+    () => A(n).getScrollElement(),
+    (r) => {
+      r && o._willUpdate();
+    },
+    {
+      immediate: !0
+    }
+  ), L(
+    () => A(n),
+    (r) => {
+      o.setOptions({
+        ...r,
+        onChange: (e, i) => {
+          var s;
+          j(t), (s = r.onChange) == null || s.call(r, e, i);
+        }
+      }), o._willUpdate(), j(t);
+    },
+    {
+      immediate: !0
+    }
+  ), $(l), t;
+}
+function we(n) {
+  return Ie(
+    Z(() => ({
+      observeElementRect: ve,
+      observeElementOffset: Oe,
+      scrollToFn: Se,
+      ...A(n)
+    }))
+  );
+}
+var V = { exports: {} };
+/*!***************************************************
+* mark.js v8.11.1
+* https://markjs.io/
+* Copyright (c) 2014–2018, Julian Kühnel
+* Released under the MIT license https://git.io/vwTVl
+*****************************************************/
+var Ne = V.exports, G;
+function Me() {
+  return G || (G = 1, (function(n, o) {
+    (function(t, l) {
+      n.exports = l();
+    })(Ne, function() {
+      class t {
+        constructor(e, i = !0, s = [], a = 5e3) {
+          this.ctx = e, this.iframes = i, this.exclude = s, this.iframesTimeout = a;
+        }
+        static matches(e, i) {
+          const s = typeof i == "string" ? [i] : i, a = e.matches || e.matchesSelector || e.msMatchesSelector || e.mozMatchesSelector || e.oMatchesSelector || e.webkitMatchesSelector;
+          if (a) {
+            let c = !1;
+            return s.every((h) => !a.call(e, h) || (c = !0, !1)), c;
+          }
+          return !1;
+        }
+        getContexts() {
+          let e = [];
+          return (this.ctx !== void 0 && this.ctx ? NodeList.prototype.isPrototypeOf(this.ctx) ? Array.prototype.slice.call(this.ctx) : Array.isArray(this.ctx) ? this.ctx : typeof this.ctx == "string" ? Array.prototype.slice.call(document.querySelectorAll(this.ctx)) : [this.ctx] : []).forEach((i) => {
+            const s = e.filter((a) => a.contains(i)).length > 0;
+            e.indexOf(i) !== -1 || s || e.push(i);
+          }), e;
+        }
+        getIframeContents(e, i, s = (() => {
+        })) {
+          let a;
+          try {
+            const c = e.contentWindow;
+            if (a = c.document, !c || !a) throw new Error("iframe inaccessible");
+          } catch {
+            s();
+          }
+          a && i(a);
+        }
+        isIframeBlank(e) {
+          const i = "about:blank", s = e.getAttribute("src").trim();
+          return e.contentWindow.location.href === i && s !== i && s;
+        }
+        observeIframeLoad(e, i, s) {
+          let a = !1, c = null;
+          const h = () => {
+            if (!a) {
+              a = !0, clearTimeout(c);
+              try {
+                this.isIframeBlank(e) || (e.removeEventListener("load", h), this.getIframeContents(e, i, s));
+              } catch {
+                s();
+              }
+            }
+          };
+          e.addEventListener("load", h), c = setTimeout(h, this.iframesTimeout);
+        }
+        onIframeReady(e, i, s) {
+          try {
+            e.contentWindow.document.readyState === "complete" ? this.isIframeBlank(e) ? this.observeIframeLoad(e, i, s) : this.getIframeContents(e, i, s) : this.observeIframeLoad(e, i, s);
+          } catch {
+            s();
+          }
+        }
+        waitForIframes(e, i) {
+          let s = 0;
+          this.forEachIframe(e, () => !0, (a) => {
+            s++, this.waitForIframes(a.querySelector("html"), () => {
+              --s || i();
+            });
+          }, (a) => {
+            a || i();
+          });
+        }
+        forEachIframe(e, i, s, a = (() => {
+        })) {
+          let c = e.querySelectorAll("iframe"), h = c.length, u = 0;
+          c = Array.prototype.slice.call(c);
+          const d = () => {
+            --h <= 0 && a(u);
+          };
+          h || d(), c.forEach((m) => {
+            t.matches(m, this.exclude) ? d() : this.onIframeReady(m, (f) => {
+              i(m) && (u++, s(f)), d();
+            }, d);
+          });
+        }
+        createIterator(e, i, s) {
+          return document.createNodeIterator(e, i, s, !1);
+        }
+        createInstanceOnIframe(e) {
+          return new t(e.querySelector("html"), this.iframes);
+        }
+        compareNodeIframe(e, i, s) {
+          const a = e.compareDocumentPosition(s), c = Node.DOCUMENT_POSITION_PRECEDING;
+          return !!(a & c && (i === null || i.compareDocumentPosition(s) & Node.DOCUMENT_POSITION_FOLLOWING));
+        }
+        getIteratorNode(e) {
+          const i = e.previousNode();
+          return { prevNode: i, node: (i === null || e.nextNode()) && e.nextNode() };
+        }
+        checkIframeFilter(e, i, s, a) {
+          let c = !1, h = !1;
+          return a.forEach((u, d) => {
+            u.val === s && (c = d, h = u.handled);
+          }), this.compareNodeIframe(e, i, s) ? (c !== !1 || h ? c === !1 || h || (a[c].handled = !0) : a.push({ val: s, handled: !0 }), !0) : (c === !1 && a.push({ val: s, handled: !1 }), !1);
+        }
+        handleOpenIframes(e, i, s, a) {
+          e.forEach((c) => {
+            c.handled || this.getIframeContents(c.val, (h) => {
+              this.createInstanceOnIframe(h).forEachNode(i, s, a);
+            });
+          });
+        }
+        iterateThroughNodes(e, i, s, a, c) {
+          const h = this.createIterator(i, e, a);
+          let u, d, m = [], f = [], p = () => ({ prevNode: d, node: u } = this.getIteratorNode(h), u);
+          for (; p(); ) this.iframes && this.forEachIframe(i, (g) => this.checkIframeFilter(u, d, g, m), (g) => {
+            this.createInstanceOnIframe(g).forEachNode(e, (O) => f.push(O), a);
+          }), f.push(u);
+          f.forEach((g) => {
+            s(g);
+          }), this.iframes && this.handleOpenIframes(m, e, s, a), c();
+        }
+        forEachNode(e, i, s, a = (() => {
+        })) {
+          const c = this.getContexts();
+          let h = c.length;
+          h || a(), c.forEach((u) => {
+            const d = () => {
+              this.iterateThroughNodes(e, u, i, s, () => {
+                --h <= 0 && a();
+              });
+            };
+            this.iframes ? this.waitForIframes(u, d) : d();
+          });
+        }
+      }
+      class l {
+        constructor(e) {
+          this.ctx = e, this.ie = !1;
+          const i = window.navigator.userAgent;
+          (i.indexOf("MSIE") > -1 || i.indexOf("Trident") > -1) && (this.ie = !0);
+        }
+        set opt(e) {
+          this._opt = Object.assign({}, { element: "", className: "", exclude: [], iframes: !1, iframesTimeout: 5e3, separateWordSearch: !0, diacritics: !0, synonyms: {}, accuracy: "partially", acrossElements: !1, caseSensitive: !1, ignoreJoiners: !1, ignoreGroups: 0, ignorePunctuation: [], wildcards: "disabled", each: () => {
+          }, noMatch: () => {
+          }, filter: () => !0, done: () => {
+          }, debug: !1, log: window.console }, e);
+        }
+        get opt() {
+          return this._opt;
+        }
+        get iterator() {
+          return new t(this.ctx, this.opt.iframes, this.opt.exclude, this.opt.iframesTimeout);
+        }
+        log(e, i = "debug") {
+          const s = this.opt.log;
+          this.opt.debug && typeof s == "object" && typeof s[i] == "function" && s[i](`mark.js: ${e}`);
+        }
+        escapeStr(e) {
+          return e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+        }
+        createRegExp(e) {
+          return this.opt.wildcards !== "disabled" && (e = this.setupWildcardsRegExp(e)), e = this.escapeStr(e), Object.keys(this.opt.synonyms).length && (e = this.createSynonymsRegExp(e)), (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) && (e = this.setupIgnoreJoinersRegExp(e)), this.opt.diacritics && (e = this.createDiacriticsRegExp(e)), e = this.createMergedBlanksRegExp(e), (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) && (e = this.createJoinersRegExp(e)), this.opt.wildcards !== "disabled" && (e = this.createWildcardsRegExp(e)), e = this.createAccuracyRegExp(e);
+        }
+        createSynonymsRegExp(e) {
+          const i = this.opt.synonyms, s = this.opt.caseSensitive ? "" : "i", a = this.opt.ignoreJoiners || this.opt.ignorePunctuation.length ? "\0" : "";
+          for (let c in i) if (i.hasOwnProperty(c)) {
+            const h = i[c], u = this.opt.wildcards !== "disabled" ? this.setupWildcardsRegExp(c) : this.escapeStr(c), d = this.opt.wildcards !== "disabled" ? this.setupWildcardsRegExp(h) : this.escapeStr(h);
+            u !== "" && d !== "" && (e = e.replace(new RegExp(`(${this.escapeStr(u)}|${this.escapeStr(d)})`, `gm${s}`), a + `(${this.processSynomyms(u)}|${this.processSynomyms(d)})` + a));
+          }
+          return e;
+        }
+        processSynomyms(e) {
+          return (this.opt.ignoreJoiners || this.opt.ignorePunctuation.length) && (e = this.setupIgnoreJoinersRegExp(e)), e;
+        }
+        setupWildcardsRegExp(e) {
+          return (e = e.replace(/(?:\\)*\?/g, (i) => i.charAt(0) === "\\" ? "?" : "
")).replace(/(?:\\)*\*/g, (i) => i.charAt(0) === "\\" ? "*" : "");
+        }
+        createWildcardsRegExp(e) {
+          let i = this.opt.wildcards === "withSpaces";
+          return e.replace(/\u0001/g, i ? "[\\S\\s]?" : "\\S?").replace(/\u0002/g, i ? "[\\S\\s]*?" : "\\S*");
+        }
+        setupIgnoreJoinersRegExp(e) {
+          return e.replace(/[^(|)\\]/g, (i, s, a) => {
+            let c = a.charAt(s + 1);
+            return /[(|)\\]/.test(c) || c === "" ? i : i + "\0";
+          });
+        }
+        createJoinersRegExp(e) {
+          let i = [];
+          const s = this.opt.ignorePunctuation;
+          return Array.isArray(s) && s.length && i.push(this.escapeStr(s.join(""))), this.opt.ignoreJoiners && i.push("\\u00ad\\u200b\\u200c\\u200d"), i.length ? e.split(/\u0000+/).join(`[${i.join("")}]*`) : e;
+        }
+        createDiacriticsRegExp(e) {
+          const i = this.opt.caseSensitive ? "" : "i", s = this.opt.caseSensitive ? ["aàáảãạăằắẳẵặâầấẩẫậäåāą", "AÀÁẢÃẠĂẰẮẲẴẶÂẦẤẨẪẬÄÅĀĄ", "cçćč", "CÇĆČ", "dđď", "DĐĎ", "eèéẻẽẹêềếểễệëěēę", "EÈÉẺẼẸÊỀẾỂỄỆËĚĒĘ", "iìíỉĩịîïī", "IÌÍỈĨỊÎÏĪ", "lł", "LŁ", "nñňń", "NÑŇŃ", "oòóỏõọôồốổỗộơởỡớờợöøō", "OÒÓỎÕỌÔỒỐỔỖỘƠỞỠỚỜỢÖØŌ", "rř", "RŘ", "sšśșş", "SŠŚȘŞ", "tťțţ", "TŤȚŢ", "uùúủũụưừứửữựûüůū", "UÙÚỦŨỤƯỪỨỬỮỰÛÜŮŪ", "yýỳỷỹỵÿ", "YÝỲỶỸỴŸ", "zžżź", "ZŽŻŹ"] : ["aàáảãạăằắẳẵặâầấẩẫậäåāąAÀÁẢÃẠĂẰẮẲẴẶÂẦẤẨẪẬÄÅĀĄ", "cçćčCÇĆČ", "dđďDĐĎ", "eèéẻẽẹêềếểễệëěēęEÈÉẺẼẸÊỀẾỂỄỆËĚĒĘ", "iìíỉĩịîïīIÌÍỈĨỊÎÏĪ", "lłLŁ", "nñňńNÑŇŃ", "oòóỏõọôồốổỗộơởỡớờợöøōOÒÓỎÕỌÔỒỐỔỖỘƠỞỠỚỜỢÖØŌ", "rřRŘ", "sšśșşSŠŚȘŞ", "tťțţTŤȚŢ", "uùúủũụưừứửữựûüůūUÙÚỦŨỤƯỪỨỬỮỰÛÜŮŪ", "yýỳỷỹỵÿYÝỲỶỸỴŸ", "zžżźZŽŻŹ"];
+          let a = [];
+          return e.split("").forEach((c) => {
+            s.every((h) => {
+              if (h.indexOf(c) !== -1) {
+                if (a.indexOf(h) > -1) return !1;
+                e = e.replace(new RegExp(`[${h}]`, `gm${i}`), `[${h}]`), a.push(h);
+              }
+              return !0;
+            });
+          }), e;
+        }
+        createMergedBlanksRegExp(e) {
+          return e.replace(/[\s]+/gim, "[\\s]+");
+        }
+        createAccuracyRegExp(e) {
+          const i = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~¡¿";
+          let s = this.opt.accuracy, a = typeof s == "string" ? s : s.value, c = typeof s == "string" ? [] : s.limiters, h = "";
+          switch (c.forEach((u) => {
+            h += `|${this.escapeStr(u)}`;
+          }), a) {
+            case "partially":
+            default:
+              return `()(${e})`;
+            case "complementary":
+              return `()([^${h = "\\s" + (h || this.escapeStr(i))}]*${e}[^${h}]*)`;
+            case "exactly":
+              return `(^|\\s${h})(${e})(?=$|\\s${h})`;
+          }
+        }
+        getSeparatedKeywords(e) {
+          let i = [];
+          return e.forEach((s) => {
+            this.opt.separateWordSearch ? s.split(" ").forEach((a) => {
+              a.trim() && i.indexOf(a) === -1 && i.push(a);
+            }) : s.trim() && i.indexOf(s) === -1 && i.push(s);
+          }), { keywords: i.sort((s, a) => a.length - s.length), length: i.length };
+        }
+        isNumeric(e) {
+          return Number(parseFloat(e)) == e;
+        }
+        checkRanges(e) {
+          if (!Array.isArray(e) || Object.prototype.toString.call(e[0]) !== "[object Object]") return this.log("markRanges() will only accept an array of objects"), this.opt.noMatch(e), [];
+          const i = [];
+          let s = 0;
+          return e.sort((a, c) => a.start - c.start).forEach((a) => {
+            let { start: c, end: h, valid: u } = this.callNoMatchOnInvalidRanges(a, s);
+            u && (a.start = c, a.length = h - c, i.push(a), s = h);
+          }), i;
+        }
+        callNoMatchOnInvalidRanges(e, i) {
+          let s, a, c = !1;
+          return e && e.start !== void 0 ? (a = (s = parseInt(e.start, 10)) + parseInt(e.length, 10), this.isNumeric(e.start) && this.isNumeric(e.length) && a - i > 0 && a - s > 0 ? c = !0 : (this.log(`Ignoring invalid or overlapping range: ${JSON.stringify(e)}`), this.opt.noMatch(e))) : (this.log(`Ignoring invalid range: ${JSON.stringify(e)}`), this.opt.noMatch(e)), { start: s, end: a, valid: c };
+        }
+        checkWhitespaceRanges(e, i, s) {
+          let a, c = !0, h = s.length, u = i - h, d = parseInt(e.start, 10) - u;
+          return (a = (d = d > h ? h : d) + parseInt(e.length, 10)) > h && (a = h, this.log(`End range automatically set to the max value of ${h}`)), d < 0 || a - d < 0 || d > h || a > h ? (c = !1, this.log(`Invalid range: ${JSON.stringify(e)}`), this.opt.noMatch(e)) : s.substring(d, a).replace(/\s+/g, "") === "" && (c = !1, this.log("Skipping whitespace only range: " + JSON.stringify(e)), this.opt.noMatch(e)), { start: d, end: a, valid: c };
+        }
+        getTextNodes(e) {
+          let i = "", s = [];
+          this.iterator.forEachNode(NodeFilter.SHOW_TEXT, (a) => {
+            s.push({ start: i.length, end: (i += a.textContent).length, node: a });
+          }, (a) => this.matchesExclude(a.parentNode) ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT, () => {
+            e({ value: i, nodes: s });
+          });
+        }
+        matchesExclude(e) {
+          return t.matches(e, this.opt.exclude.concat(["script", "style", "title", "head", "html"]));
+        }
+        wrapRangeInTextNode(e, i, s) {
+          const a = this.opt.element ? this.opt.element : "mark", c = e.splitText(i), h = c.splitText(s - i);
+          let u = document.createElement(a);
+          return u.setAttribute("data-markjs", "true"), this.opt.className && u.setAttribute("class", this.opt.className), u.textContent = c.textContent, c.parentNode.replaceChild(u, c), h;
+        }
+        wrapRangeInMappedTextNode(e, i, s, a, c) {
+          e.nodes.every((h, u) => {
+            const d = e.nodes[u + 1];
+            if (d === void 0 || d.start > i) {
+              if (!a(h.node)) return !1;
+              const m = i - h.start, f = (s > h.end ? h.end : s) - h.start, p = e.value.substr(0, h.start), g = e.value.substr(f + h.start);
+              if (h.node = this.wrapRangeInTextNode(h.node, m, f), e.value = p + g, e.nodes.forEach((O, k) => {
+                k >= u && (e.nodes[k].start > 0 && k !== u && (e.nodes[k].start -= f), e.nodes[k].end -= f);
+              }), s -= f, c(h.node.previousSibling, h.start), !(s > h.end)) return !1;
+              i = h.end;
+            }
+            return !0;
+          });
+        }
+        wrapMatches(e, i, s, a, c) {
+          const h = i === 0 ? 0 : i + 1;
+          this.getTextNodes((u) => {
+            u.nodes.forEach((d) => {
+              let m;
+              for (d = d.node; (m = e.exec(d.textContent)) !== null && m[h] !== ""; ) {
+                if (!s(m[h], d)) continue;
+                let f = m.index;
+                if (h !== 0) for (let p = 1; p < h; p++) f += m[p].length;
+                d = this.wrapRangeInTextNode(d, f, f + m[h].length), a(d.previousSibling), e.lastIndex = 0;
+              }
+            }), c();
+          });
+        }
+        wrapMatchesAcrossElements(e, i, s, a, c) {
+          const h = i === 0 ? 0 : i + 1;
+          this.getTextNodes((u) => {
+            let d;
+            for (; (d = e.exec(u.value)) !== null && d[h] !== ""; ) {
+              let m = d.index;
+              if (h !== 0) for (let p = 1; p < h; p++) m += d[p].length;
+              const f = m + d[h].length;
+              this.wrapRangeInMappedTextNode(u, m, f, (p) => s(d[h], p), (p, g) => {
+                e.lastIndex = g, a(p);
+              });
+            }
+            c();
+          });
+        }
+        wrapRangeFromIndex(e, i, s, a) {
+          this.getTextNodes((c) => {
+            const h = c.value.length;
+            e.forEach((u, d) => {
+              let { start: m, end: f, valid: p } = this.checkWhitespaceRanges(u, h, c.value);
+              p && this.wrapRangeInMappedTextNode(c, m, f, (g) => i(g, u, c.value.substring(m, f), d), (g) => {
+                s(g, u);
+              });
+            }), a();
+          });
+        }
+        unwrapMatches(e) {
+          const i = e.parentNode;
+          let s = document.createDocumentFragment();
+          for (; e.firstChild; ) s.appendChild(e.removeChild(e.firstChild));
+          i.replaceChild(s, e), this.ie ? this.normalizeTextNode(i) : i.normalize();
+        }
+        normalizeTextNode(e) {
+          if (e) {
+            if (e.nodeType === 3) for (; e.nextSibling && e.nextSibling.nodeType === 3; ) e.nodeValue += e.nextSibling.nodeValue, e.parentNode.removeChild(e.nextSibling);
+            else this.normalizeTextNode(e.firstChild);
+            this.normalizeTextNode(e.nextSibling);
+          }
+        }
+        markRegExp(e, i) {
+          this.opt = i, this.log(`Searching with expression "${e}"`);
+          let s = 0, a = "wrapMatches";
+          const c = (h) => {
+            s++, this.opt.each(h);
+          };
+          this.opt.acrossElements && (a = "wrapMatchesAcrossElements"), this[a](e, this.opt.ignoreGroups, (h, u) => this.opt.filter(u, h, s), c, () => {
+            s === 0 && this.opt.noMatch(e), this.opt.done(s);
+          });
+        }
+        mark(e, i) {
+          this.opt = i;
+          let s = 0, a = "wrapMatches";
+          const { keywords: c, length: h } = this.getSeparatedKeywords(typeof e == "string" ? [e] : e), u = this.opt.caseSensitive ? "" : "i", d = (m) => {
+            let f = new RegExp(this.createRegExp(m), `gm${u}`), p = 0;
+            this.log(`Searching with expression "${f}"`), this[a](f, 1, (g, O) => this.opt.filter(O, m, s, p), (g) => {
+              p++, s++, this.opt.each(g);
+            }, () => {
+              p === 0 && this.opt.noMatch(m), c[h - 1] === m ? this.opt.done(s) : d(c[c.indexOf(m) + 1]);
+            });
+          };
+          this.opt.acrossElements && (a = "wrapMatchesAcrossElements"), h === 0 ? this.opt.done(s) : d(c[0]);
+        }
+        markRanges(e, i) {
+          this.opt = i;
+          let s = 0, a = this.checkRanges(e);
+          a && a.length ? (this.log("Starting to mark with the following ranges: " + JSON.stringify(a)), this.wrapRangeFromIndex(a, (c, h, u, d) => this.opt.filter(c, h, u, d), (c, h) => {
+            s++, this.opt.each(c, h);
+          }, () => {
+            this.opt.done(s);
+          })) : this.opt.done(s);
+        }
+        unmark(e) {
+          this.opt = e;
+          let i = this.opt.element ? this.opt.element : "*";
+          i += "[data-markjs]", this.opt.className && (i += `.${this.opt.className}`), this.log(`Removal selector "${i}"`), this.iterator.forEachNode(NodeFilter.SHOW_ELEMENT, (s) => {
+            this.unwrapMatches(s);
+          }, (s) => {
+            const a = t.matches(s, i), c = this.matchesExclude(s);
+            return !a || c ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT;
+          }, this.opt.done);
+        }
+      }
+      return function(r) {
+        const e = new l(r);
+        return this.mark = ((i, s) => (e.mark(i, s), this)), this.markRegExp = ((i, s) => (e.markRegExp(i, s), this)), this.markRanges = ((i, s) => (e.markRanges(i, s), this)), this.unmark = ((i) => (e.unmark(i), this)), this;
+      };
+    });
+  })(V)), V.exports;
+}
+var Te = Me();
+const ze = /* @__PURE__ */ le(Te);
+function U(n) {
+  return JSON.parse(JSON.stringify(n));
+}
+const _e = {
+  name: "IbTreeSelect",
+  inject: ["LANG_COMPONENTS"],
+  mixins: [ue],
+  props: {
+    classList: [String, Array],
+    keywordHighlighter: {
+      type: Boolean,
+      default: !0
+    },
+    placeholder: {
+      type: String,
+      default: ""
+    },
+    searchPlaceholderText: {
+      type: String,
+      default: ""
+    },
+    clearButtonMessage: {
+      type: String,
+      default: ""
+    },
+    showClearButton: {
+      type: Boolean,
+      default: !0
+    },
+    isResizable: {
+      type: Boolean,
+      default: !1
+    },
+    menuSize: {
+      type: [String, Number]
+    },
+    initialSize: {
+      left: 0,
+      right: 0
+    },
+    ariaLabel: {
+      type: String,
+      default: ""
+    },
+    name: String,
+    id: {
+      type: String,
+      default() {
+        return W();
+      }
+    },
+    options: {
+      type: [Array, Function],
+      default() {
+        return [];
+      }
+    },
+    modelValue: {
+      type: [Number, String, Array]
+    },
+    value: {
+      type: [Number, String, Array],
+      default() {
+        return [];
+      }
+    },
+    maxSelectedNames: {
+      type: Number,
+      default: 2
+    },
+    isMultiple: {
+      type: Boolean,
+      default: !0
+    },
+    parentAutoCheck: {
+      type: Boolean,
+      default: null
+    },
+    strings: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
+    onlyEndNodes: {
+      type: Boolean,
+      default: !1
+    },
+    isRequired: {
+      type: Boolean,
+      default: !0
+    },
+    htmlOptionTitle: {
+      type: Boolean,
+      default: !1
+    },
+    isBookmarkable: {
+      type: Boolean,
+      default: !1
+    },
+    initBookmarks: {
+      type: Array,
+      default: () => []
+    },
+    showInputs: {
+      type: Boolean,
+      default(n) {
+        return n.isMultiple;
+      }
+    },
+    dependency: {
+      type: String
+    },
+    filterId: {
+      type: String,
+      default() {
+        return W();
+      }
+    },
+    staticPlaceholder: {
+      type: Boolean,
+      default: !1
+    },
+    useSearch: {
+      type: Boolean,
+      default: !1
+    },
+    isWatching: {
+      type: Boolean,
+      default: !1
+    },
+    vertical: {
+      type: String
+    },
+    emptyMessage: {
+      type: String,
+      default: ""
+    },
+    errorMessage: {
+      type: String,
+      default: ""
+    },
+    allOptions: {
+      type: Boolean,
+      default: !0
+    },
+    watchClearValue: {
+      type: Boolean,
+      default: !1
+    },
+    isToggle: {
+      type: Boolean,
+      default: !1
+    },
+    alphabetSort: {
+      type: Boolean,
+      default: !1
+    },
+    disable: {
+      type: Boolean,
+      default: !1
+    },
+    searchDebounce: {
+      type: Number,
+      default: 500
+    },
+    alphabeticStyle: {
+      type: Boolean,
+      default: !1
+    },
+    initialDependencyValue: {
+      type: Object
+    }
+  },
+  emits: [
+    "close",
+    "input",
+    "blur",
+    "search",
+    "resize",
+    "submit",
+    "clearValue",
+    "toggle-bookmarked-option",
+    "update:modelValue"
+  ],
+  watch: {
+    value(n) {
+      this.val = n, (!Array.isArray(n) || n.join(",") !== Object.keys(this.selected).join(",")) && this.setPreparedValues(this.actualOptions, !1);
+    },
+    modelValue: {
+      handler(n) {
+        if (this.isInternalChange) return;
+        this.val = n, this.val = n, (!Array.isArray(n) || n.join(",") !== Object.keys(this.selected).join(",")) && this.setPreparedValues(this.actualOptions, !1);
+        const o = new Set(Array.isArray(n) ? n : [n].filter(Boolean));
+        this.syncCheckedBySet(o);
+      },
+      deep: !0
+    },
+    val(n) {
+      this.watchClearValue && (!n || Array.isArray(n) && !n.length) && this.setPreparedValues(this.actualOptions).then(() => {
+        const o = Object.keys(this.selected);
+        this.$globalEvents.$emit("select-" + this.filterId + ":update", {
+          values: o,
+          filter: this.filterId
+        });
+      });
+    },
+    options: {
+      handler(n) {
+        this.initialOptions = typeof n == "function" ? n : U(n);
+      },
+      deep: !0
+    },
+    initialOptions(n) {
+      let o = !0;
+      if (typeof n == "function")
+        o = !1;
+      else {
+        const t = [], l = n;
+        Array.prototype.forEach.call(l, (r) => {
+          r.id !== void 0 && t.push(r.id);
+        }), o = JSON.stringify(t) === JSON.stringify(this.optionsIdsWatch), this.optionsIdsWatch = t;
+      }
+      (this.isInitialized && !o || this.isWatching) && this.setPreparedValues().then(() => {
+        const t = Object.keys(this.selected);
+        this.$globalEvents.$emit("select-" + this.filterId + ":update", {
+          values: t,
+          filter: this.filterId
+        });
+      });
+    },
+    dependency(n, o) {
+      this.$nextTick(() => {
+        this.registerDependency(o);
+      });
+    },
+    initBookmarks() {
+      this.actualBookmarkedOptions = {}, this.setBookmarkedOptions(this.actualOptions);
+    },
+    initialDependencyValue(n) {
+      this.dependencyValue = n, this.hasFilledDependency && this.$nextTick(() => {
+        this.loadValues();
+      });
+    }
+  },
+  mounted() {
+    this.marker = new ze(this.$refs.list.$el), this.registerDependency(), this.$globalEvents.$on("select:refresh", () => {
+      this.setPreparedValues();
+    }), document.addEventListener("mousemove", this.onResize), document.addEventListener("mouseup", this.endResizing);
+  },
+  data() {
+    var n, o, t, l, r, e, i, s;
+    return this.defaultFilter = pe((a) => {
+      var h;
+      this.marker.unmark();
+      const c = this.filterString.toLowerCase().trim();
+      this.countVisibleChildren = this.filterFunc.call(this, a, c), c && this.keywordHighlighter && this.marker.mark(c), (h = this.virtualizer) == null || h.measure();
+    }, 1e3), {
+      virtualizer: null,
+      initialOptions: typeof this.options == "function" ? this.options : U(this.options),
+      val: this.modelValue ? this.modelValue : this.value,
+      size: {
+        left: this.initialSize && this.initialSize.left || 0,
+        right: this.initialSize && this.initialSize.right || 0
+      },
+      resizingProp: null,
+      isInitialized: !1,
+      isLoading: !1,
+      isOpen: !1,
+      optionsIdsWatch: [],
+      actualName: this.isMultiple ? this.name + "[]" : this.name,
+      parentAutoCheckVal: this.parentAutoCheck !== null ? this.parentAutoCheck : this.isMultiple,
+      filterString: "",
+      actualOptions: [],
+      actualBookmarkedOptions: {},
+      selected: [],
+      verticalVal: this.vertical ?? "bottom",
+      allOptionsIsChecked: !0,
+      hasTreeChildren: !1,
+      uid: `f${(~~(Math.random() * 1e8)).toString(16)}`,
+      focusedOptionId: "",
+      actualStrings: {
+        searchPlaceholder: lang(
+          this.searchPlaceholderText.length ? this.searchPlaceholderText : "search_placeholder",
+          (n = this.LANG_COMPONENTS) == null ? void 0 : n.COMPONENT_SELECT
+        ),
+        emptyTitle: lang(
+          "empty_title",
+          (o = this.LANG_COMPONENTS) == null ? void 0 : o.COMPONENT_SELECT
+        ),
+        selectAllOptions: lang(
+          "all_options",
+          (t = this.LANG_COMPONENTS) == null ? void 0 : t.COMPONENT_SELECT
+        ),
+        allSelected: lang(
+          "all_selected",
+          (l = this.LANG_COMPONENTS) == null ? void 0 : l.COMPONENT_SELECT
+        ),
+        loading: lang("loading", (r = this.LANG_COMPONENTS) == null ? void 0 : r.COMPONENT_SELECT) + "...",
+        selectedCount: lang(
+          "selected_count",
+          (e = this.LANG_COMPONENTS) == null ? void 0 : e.COMPONENT_SELECT
+        ),
+        buttonTitle: this.buttonTitle || lang("button_title", (i = this.LANG_COMPONENTS) == null ? void 0 : i.COMPONENT_SELECT),
+        requiredDependencyNotFilled: (
+          // eslint-disable-next-line vue/no-computed-properties-in-data
+          this.requiredDependencyNotFilled || lang(
+            "required_dependency_are_not_filled",
+            (s = this.LANG_COMPONENTS) == null ? void 0 : s.COMPONENT_SELECT
+          )
+        ),
+        ...this.strings
+      },
+      dependencyValue: this.initialDependencyValue,
+      isInternalChange: !1,
+      nodeIndex: /* @__PURE__ */ new Map()
+    };
+  },
+  methods: {
+    toggleDuplicateOptionsFast(n, o) {
+      const t = this.nodeIndex.get(n);
+      if (t)
+        for (const l of t) l.checked = o;
+    },
+    buildNodeIndex() {
+      this.nodeIndex.clear(), this.traverseTree(this.actualOptions, (n) => {
+        this.nodeIndex.has(n.id) || this.nodeIndex.set(n.id, []), this.nodeIndex.get(n.id).push(n);
+      });
+    },
+    syncCheckedBySet(n) {
+      this.traverseTree(this.actualOptions, (o) => {
+        const t = n.has(o.id);
+        o.checked !== t && (o.checked = t);
+      }), this.selected = {}, this.traverseTree(this.actualOptions, (o) => {
+        o.checked && (!this.onlyEndNodes || !o.children) && (this.selected[o.id] = o);
+      }), this.allOptionsIsChecked = this.checkIfOptionsChecked(this.actualOptions);
+    },
+    onBlur() {
+      setTimeout(() => {
+        this.isOpen || this.$emit("blur");
+      }, 200);
+    },
+    inputKeyupDown() {
+      this.focusOnFirstOptions();
+    },
+    comboboxKeyupDown() {
+      if (this.showSearch) {
+        this.$refs.search.focus();
+        return;
+      }
+      this.focusOnFirstOptions();
+    },
+    focus() {
+      this.$refs.combobox.focus();
+    },
+    focusOnFirstOptions() {
+      this.$refs.list.$el.querySelector("[tabindex]:not(hidden)").focus();
+    },
+    startResizing(n) {
+      this.resizingProp = n;
+    },
+    endResizing() {
+      this.resizingProp && (this.resizingProp = null, this.$emit("resize", this.size));
+    },
+    onResize(n) {
+      switch (this.resizingProp) {
+        case "left":
+          this.size.left = Math.max(this.size.left - n.movementX, 0);
+          break;
+        case "right":
+          this.size.right = Math.max(this.size.right + n.movementX, 0);
+          break;
+      }
+    },
+    registerDependency(n) {
+      this.dependency ? (this.$globalEvents.$on(
+        "select-" + this.dependency + ":update",
+        (o) => {
+          this.clear(), this.dependencyValue = o, this.dependencyValue && this.dependencyValue.values && (!Array.isArray(this.dependencyValue.values) || this.dependencyValue.values.length) && this.setPreparedValues();
+        }
+      ), this.isLoading = !1, !n && this.hasFilledDependency && this.setPreparedValues()) : (this.$globalEvents.$off("select-" + n + ":update"), this.setPreparedValues().then(() => {
+        const o = Object.keys(this.selected);
+        this.$globalEvents.$emit("select-" + this.filterId + ":update", {
+          values: o,
+          filter: this.filterId
+        });
+      }));
+    },
+    loadValues() {
+      this.setPreparedValues().then(() => {
+        if (!this.dependency) {
+          const n = Object.keys(this.selected);
+          Array.isArray(this.options) && !this.options.length || this.$globalEvents.$emit("select-" + this.filterId + ":update", { values: n, filter: this.filterId });
+        }
+        this.$emit("loaded", this.dependencyValue);
+      });
+    },
+    filter(n, o) {
+      this.filterString = n, this.$emit("search", this.filterString), this.defaultFilter(o);
+    },
+    setPreparedValues(n) {
+      let o = n || this.initialOptions;
+      return this.alphabetSort && (o = o.sort(
+        (t, l) => t.title.toLowerCase().localeCompare(l.title.toLowerCase())
+      )), this.prepare(o).then(([t, l]) => {
+        this.actualOptions = t, this.buildNodeIndex(), this.allOptionsIsChecked = this.checkIfOptionsChecked(t), this.isInitialized = !0, this.selected = l, this.setBookmarkedOptions(t);
+      });
+    },
+    clear() {
+      this.actualOptions = [], this.allOptionsIsChecked = !1, this.countVisibleChildren = 0, this.selected = [];
+    },
+    clearValue() {
+      this.traverseTree(this.actualOptions, (o) => o.checked = !1), this.clear(), this.isInternalChange = !0;
+      const n = this.isMultiple ? [] : null;
+      this.$emit("update:modelValue", n), this.$emit("input", n), this.$emit("clear-value", n), this.$nextTick(() => this.isInternalChange = !1), this.setPreparedValues();
+    },
+    prepare(n, o = !0) {
+      return new Promise((t) => {
+        const l = {}, r = [];
+        let e = Promise.resolve();
+        typeof n == "function" ? (this.isLoading = !0, this.dependency && (n = n.bind(null, this.dependencyValue)), e = e.then(n)) : e = e.then(() => n), e.then((i) => (this.isLoading = !1, i.forEach((s) => {
+          s.initiallyVisible = typeof s.visible > "u" ? !0 : s.visible, s.visible = s.initiallyVisible, s.readonly = !!s.readonly, s.checked = this.isMultiple ? this.val !== null && this.val.findIndex((a) => s.id == a) > -1 : this.val !== null && this.val == s.id, s.checked && (!this.onlyEndNodes || !s.children) && (l[s.id] = s), s.children && (this.hasTreeChildren = !0, s.isChildrenVisible = !1), r.push(
+            new Promise((a) => {
+              s.children ? this.prepare(s.children).then(
+                ([c, h]) => {
+                  s.children = c, this.parentAutoCheckVal && (s.checked = this.checkIfOptionsChecked(
+                    s.children
+                  )), Object.assign(l, h), a(s);
+                }
+              ) : a(s);
+            })
+          );
+        }), Promise.all(r).then((s) => {
+          t([s, l]);
+        }))).catch((i) => {
+          throw this.isLoading = !1, i;
+        });
+      });
+    },
+    filterFunc(n, o) {
+      let t = 0;
+      return n.forEach((l) => {
+        let r = l.initiallyVisible && l.title && l.title.toString().toLowerCase().includes(o) && !this.actualBookmarkedOptions[l.id];
+        if (l.children && l.children.length) {
+          let e = this.filterFunc(l.children, o);
+          t += e, e && (l.isChildrenVisible = o.length > 0 || !!Object.keys(this.actualBookmarkedOptions).length, l.isDisabled = e < l.children.length && !this.isBookmarkable), r ? e || (r = !1) : r = !!e;
+        }
+        l.visible = r, r && t++;
+      }), t;
+    },
+    submit() {
+      this.change();
+      const n = Object.keys(this.selected);
+      this.$globalEvents.$emit("select-" + this.filterId + ":submit", {
+        values: n,
+        filter: this.filterId
+      }), this.$emit("submit");
+    },
+    change() {
+      const n = Object.keys(this.selected);
+      this.isInternalChange = !0, this.isMultiple ? (this.$emit("update:modelValue", n), this.$emit("input", n)) : (this.$emit("update:modelValue", n[0]), this.$emit("input", n[0])), this.$nextTick(() => this.isInternalChange = !1), this.$globalEvents.$emit("select-" + this.filterId + ":update", { values: n, filter: this.filterId }), this.isMultiple || this.$refs.dropdown.close();
+    },
+    checkIfOptionsChecked(n) {
+      return n.every((o) => o.checked || o.readonly);
+    },
+    registerCheck(n, o, t) {
+      var l;
+      if (o) {
+        if (n.checked = !0, this.isMultiple && !(this.onlyEndNodes && ((l = n.children) != null && l.length)))
+          this.selected[n.id] = n;
+        else if (!this.isMultiple) {
+          const r = Object.keys(this.selected)[0];
+          r && (this.selected[r].checked = !1), this.selected = { [n.id]: n }, this.change();
+          return;
+        }
+      } else
+        delete this.selected[n.id], n.checked = !1;
+      if (this.toggleDuplicateOptionsFast(n.id, o), t && (this.allOptionsIsChecked = this.checkIfOptionsChecked(this.actualOptions)), this.isMultiple) {
+        this.isInternalChange = !0;
+        const r = Object.keys(this.selected);
+        this.$emit("update:modelValue", r), this.$emit("input", r), this.$nextTick(() => this.isInternalChange = !1);
+      }
+    },
+    toggleDuplicateOptions(n, o, t) {
+      for (let l of n)
+        l.id === o && (l.checked = t), l.children && this.toggleDuplicateOptions(l.children, o, t);
+    },
+    manageAll() {
+      this.allOptionsIsChecked = !this.allOptionsIsChecked, this.traverseTree(this.actualOptions, (n) => {
+        n.readonly || this.registerCheck(n, this.allOptionsIsChecked, !1);
+      });
+    },
+    traverseTree(n, o) {
+      n.forEach((t) => {
+        o(t), t.children && t.children.length && this.traverseTree(t.children, o);
+      });
+    },
+    getArrayOptions(n) {
+      let o = [];
+      for (let t of n)
+        o.push(t), t.children && (o = o.concat(this.getArrayOptions(t.children)));
+      return o;
+    },
+    toggleBookmark(n) {
+      this.actualBookmarkedOptions[n.id] ? delete this.actualBookmarkedOptions[n.id] : this.actualBookmarkedOptions[n.id] = n, this.$emit("toggle-bookmarked-option", n.id), this.filter(this.filterString, this.actualOptions);
+    },
+    setBookmarkedOptions(n) {
+      n.forEach((o) => {
+        o.children && o.children.length ? this.setBookmarkedOptions(o.children) : this.initBookmarks.includes(o.id) && (this.actualBookmarkedOptions[o.id] = o);
+      }), this.filter(this.filterString, n);
+    },
+    onClose() {
+      this.isOpen = !1, this.filterString = "", this.filterFunc(this.actualOptions, this.filterString), this.isMultiple ? this.$emit("close", Object.keys(this.selected)) : this.$emit("close", Object.keys(this.selected)[0]), this.virtualizer = null, this.$emit("blur"), this.verticalVal = this.vertical ?? "bottom";
+    },
+    onOpen() {
+      var o;
+      const n = document.documentElement.scrollHeight;
+      this.isOpen = !0, this.virtualizer || (this.virtualizer = we({
+        count: this.actualOptions.length,
+        getScrollElement: () => this.$refs.parentRef,
+        estimateSize: () => 40,
+        overscan: 8
+      })), (o = this.virtualizer) == null || o.measure(), this.vertical !== "bottom" && this.$nextTick(() => {
+        document.documentElement.scrollHeight > n && (this.verticalVal = "top");
+      });
+    }
+  },
+  computed: {
+    hasTrigger() {
+      return !!this.$slots.trigger;
+    },
+    hasTriggerContent() {
+      return !!this.$slots.triggerContent;
+    },
+    hasEmptyMessage() {
+      return !!this.$slots.emptyMessage;
+    },
+    treeDropPos() {
+      return this.menuSize ? {
+        width: this.menuSize + "px",
+        maxWidth: this.menuSize + "px",
+        minWidth: this.menuSize + "px"
+      } : {
+        width: "auto",
+        position: "absolute",
+        left: -this.size.left + "px",
+        right: -this.size.right + "px"
+      };
+    },
+    hasHierarchy() {
+      return this.actualOptions.some((n) => n.children);
+    },
+    selectedKeys() {
+      return Object.keys(this.selected).filter((n) => {
+        if (!this.onlyEndNodes || !this.selected[n].children)
+          return !0;
+      });
+    },
+    selectStatus() {
+      return this.staticPlaceholder ? this.placeholder : this.isLoading ? this.actualStrings.loading : this.selectedKeys.length ? this.selectedKeys.length < this.maxSelectedNames ? this.selectedKeys.map((n) => this.selected[n].title).join(",") : this.allOptionsIsChecked ? this.actualStrings.allSelected : this.actualStrings.selectedCount.replace("{selected}", this.selectedKeys.length).replace("{all}", this.optionsCount) : this.emptyMessage;
+    },
+    isEmpty() {
+      return Array.isArray(this.value) ? !this.value.length : !this.value;
+    },
+    requiredDependencyNotFilled() {
+      return this.dependency && (!this.dependencyValue || !this.dependencyValue.values || !this.dependencyValue.values.length);
+    },
+    showSearch() {
+      return this.useSearch || this.optionsCount > 10 && !this.alphabeticStyle;
+    },
+    arrayOfOptions() {
+      return this.getArrayOptions(this.actualOptions);
+    },
+    optionsCount() {
+      let n = [];
+      for (let o of this.arrayOfOptions)
+        (!this.onlyEndNodes || !o.children) && !n.includes(o.id) && n.push(o.id);
+      return n.length;
+    },
+    visibleOptionsCount() {
+      let n = [];
+      return this.traverseTree(this.actualOptions, (o) => {
+        (!this.onlyEndNodes || !o.children) && !n.includes(o.id) && o.visible && n.push(o.id);
+      }), n.length + (this.isBookmarkable ? Object.keys(this.actualBookmarkedOptions).length : 0);
+    },
+    hasFilledDependency() {
+      var n, o, t;
+      return !!(this.dependency && this.dependencyValue && ((n = this.dependencyValue) != null && n.values) && (!Array.isArray((o = this.dependencyValue) == null ? void 0 : o.values) || (t = this.dependencyValue) != null && t.values.length));
+    }
+  },
+  components: {
+    IbAlert: ce,
+    IbIconButton: he,
+    IbIcon: ae,
+    IbDropdown: oe,
+    IbInput: ne,
+    List: de,
+    "select-option": re
+  },
+  directives: {
+    Tooltip: fe
+  },
+  beforeUnmount() {
+    document.removeEventListener("mousemove", this.onResize), document.removeEventListener("mouseup", this.endResizing);
+  },
+  inheritAttrs: !1
+}, Re = {
+  key: 0,
+  class: "tree-select-empty"
+}, Ae = {
+  key: 1,
+  class: "tree-select-default-empty tree-select-empty"
+}, Ve = {
+  key: 4,
+  class: "scrollable-container"
+}, Be = { ref: "parentRef" }, De = ["data-index"], Pe = {
+  key: 5,
+  ref: "infinityLoader"
+};
+function Fe(n, o, t, l, r, e) {
+  const i = E("ib-alert"), s = E("ib-icon"), a = E("ib-icon-button"), c = E("ib-input"), h = E("select-option"), u = E("list"), d = E("ib-dropdown"), m = ee("tooltip");
+  return y(), b(M, null, [
+    t.errorMessage ? (y(), S(i, {
+      key: 0,
+      class: "tree-select-error"
+    }, {
+      default: C(() => [
+        te(z(t.errorMessage), 1)
+      ]),
+      _: 1
+    })) : v("", !0),
+    x("div", se(Object.fromEntries(Object.entries(n.$attrs).filter(([f]) => f.startsWith("data-"))), {
+      class: ["tree-select", {
+        ...t.classList,
+        "tree-select-custom-trigger-content": e.hasTriggerContent,
+        "disabled-parent-autocheck": t.parentAutoCheck === !1
+      }]
+    }), [
+      _(d, {
+        disabled: r.isLoading || t.disable,
+        "is-resizable": t.isResizable,
+        vertical: r.verticalVal,
+        class: I({
+          disable: t.disable
+        }),
+        ref: "dropdown",
+        onClose: e.onClose,
+        onOpen: e.onOpen
+      }, ie({
+        body: C(() => [
+          x("div", {
+            class: I(["tree-drop", { "not-tree-child": !r.hasTreeChildren }]),
+            style: B(e.treeDropPos),
+            role: "listbox"
+          }, [
+            t.isResizable ? (y(), b("div", {
+              key: 0,
+              class: "ib-dropdown-resizer ib-dropdown-resizer-left",
+              onMousedown: o[6] || (o[6] = (f) => e.startResizing("left"))
+            }, null, 32)) : v("", !0),
+            t.isResizable ? R((y(), b("div", {
+              key: 1,
+              class: "ib-dropdown-resizer ib-dropdown-resizer-right",
+              onMousedown: o[7] || (o[7] = (f) => e.startResizing("right"))
+            }, null, 544)), [
+              [
+                m,
+                n.lang("resize_list", "select"),
+                void 0,
+                { rightCenter: !0 }
+              ]
+            ]) : v("", !0),
+            e.showSearch ? (y(), S(c, {
+              key: 2,
+              class: "tree-search",
+              ref: "search",
+              autocomplete: "new-password",
+              "show-icon": !0,
+              value: r.filterString,
+              debounce: t.searchDebounce,
+              "aria-label": t.searchPlaceholderText ? t.searchPlaceholderText : r.actualStrings.searchPlaceholder,
+              placeholder: t.searchPlaceholderText ? t.searchPlaceholderText : r.actualStrings.searchPlaceholder,
+              onInput: o[8] || (o[8] = (f) => e.filter(f, r.actualOptions)),
+              onKeyup: w(e.inputKeyupDown, ["down"])
+            }, null, 8, ["value", "debounce", "aria-label", "placeholder", "onKeyup"])) : v("", !0),
+            _(u, {
+              ref: "list",
+              role: "listbox",
+              class: I({
+                "tree-select-list": !0,
+                "has-hierarchy": e.hasHierarchy,
+                "alphabetic-list": t.alphabeticStyle
+              })
+            }, {
+              default: C(() => {
+                var f, p;
+                return [
+                  !e.requiredDependencyNotFilled && !e.visibleOptionsCount && e.hasEmptyMessage ? (y(), b("div", Re, [
+                    D(n.$slots, "emptyMessage")
+                  ])) : !e.requiredDependencyNotFilled && !e.visibleOptionsCount ? (y(), b("div", Ae, z(r.actualStrings.emptyTitle), 1)) : v("", !0),
+                  R(x("div", { class: "tree-select-empty" }, z(r.actualStrings.requiredDependencyNotFilled), 513), [
+                    [P, e.requiredDependencyNotFilled]
+                  ]),
+                  !t.isMultiple && !t.isRequired && r.actualOptions.length > 0 ? (y(), S(h, {
+                    key: 2,
+                    option: {
+                      title: n.lang("none", "select"),
+                      id: null,
+                      checked: e.isEmpty
+                    },
+                    name: r.actualName,
+                    "parent-auto-check": r.parentAutoCheckVal,
+                    "is-multiple": t.isMultiple,
+                    role: "option",
+                    onCheck: e.registerCheck,
+                    onToggleBookmark: e.toggleBookmark,
+                    uid: r.uid,
+                    "only-end-nodes": t.onlyEndNodes,
+                    "show-input": t.showInputs
+                  }, null, 8, ["option", "name", "parent-auto-check", "is-multiple", "onCheck", "onToggleBookmark", "uid", "only-end-nodes", "show-input"])) : v("", !0),
+                  Object.keys(r.actualBookmarkedOptions).length > 0 ? (y(!0), b(M, { key: 3 }, F(r.actualBookmarkedOptions, (g) => (y(), S(h, {
+                    key: "bookmark" + g.id,
+                    class: "bookmarked-option",
+                    option: g,
+                    "parent-auto-check": !1,
+                    "is-multiple": t.isMultiple,
+                    "is-bookmarkable": !0,
+                    "is-bookmarked": !0,
+                    role: "option",
+                    onCheck: e.registerCheck,
+                    onToggleBookmark: e.toggleBookmark,
+                    uid: r.uid,
+                    "only-end-nodes": t.onlyEndNodes,
+                    "html-title": t.htmlOptionTitle,
+                    "show-input": t.showInputs
+                  }, null, 8, ["option", "is-multiple", "onCheck", "onToggleBookmark", "uid", "only-end-nodes", "html-title", "show-input"]))), 128)) : v("", !0),
+                  e.requiredDependencyNotFilled ? v("", !0) : (y(), b("div", Ve, [
+                    t.allOptions && !t.alphabeticStyle && t.isMultiple && e.visibleOptionsCount && !e.requiredDependencyNotFilled ? (y(), S(h, {
+                      key: 0,
+                      option: {
+                        title: r.actualStrings.selectAllOptions,
+                        initiallyVisible: !0,
+                        visible: !0,
+                        isDisabled: e.visibleOptionsCount < e.optionsCount,
+                        checked: r.allOptionsIsChecked,
+                        isIndeterminate: !!Object.keys(r.selected).length
+                      },
+                      "is-toggle": t.isToggle,
+                      "parent-auto-check": !1,
+                      "is-multiple": t.isMultiple,
+                      "is-bookmarkable": !1,
+                      uid: r.uid,
+                      "only-end-nodes": t.onlyEndNodes,
+                      "show-input": t.showInputs,
+                      "alphabetic-style": t.alphabeticStyle,
+                      role: "option",
+                      onCheck: e.manageAll,
+                      onOnFocus: o[9] || (o[9] = (g) => r.focusedOptionId = g)
+                    }, null, 8, ["option", "is-toggle", "is-multiple", "uid", "only-end-nodes", "show-input", "alphabetic-style", "onCheck"])) : v("", !0),
+                    x("div", Be, [
+                      x("div", {
+                        style: B({
+                          height: ((f = r.virtualizer) == null ? void 0 : f.getTotalSize()) + "px",
+                          position: "relative"
+                        })
+                      }, [
+                        (y(!0), b(M, null, F((p = r.virtualizer) == null ? void 0 : p.getVirtualItems(), (g) => (y(), b("div", {
+                          key: g.index,
+                          "data-index": g.index,
+                          ref_for: !0,
+                          ref: r.virtualizer.measureElement,
+                          style: B({
+                            position: "absolute",
+                            top: 0,
+                            left: 0,
+                            width: "100%",
+                            transform: `translateY(${g.start}px)`
+                          })
+                        }, [
+                          r.actualOptions[g.index] ? R((y(), S(h, {
+                            key: 0,
+                            option: r.actualOptions[g.index],
+                            "is-toggle": t.isToggle,
+                            name: r.actualName,
+                            role: "option",
+                            "parent-auto-check": r.parentAutoCheckVal,
+                            "is-multiple": t.isMultiple,
+                            "is-bookmarkable": t.isBookmarkable,
+                            uid: r.uid,
+                            "only-end-nodes": t.onlyEndNodes,
+                            "html-title": t.htmlOptionTitle,
+                            "show-input": t.showInputs,
+                            "alphabetic-style": t.alphabeticStyle,
+                            onCheck: e.registerCheck,
+                            onToggleBookmark: e.toggleBookmark,
+                            onOnFocus: o[10] || (o[10] = (O) => r.focusedOptionId = O)
+                          }, null, 8, ["option", "is-toggle", "name", "parent-auto-check", "is-multiple", "is-bookmarkable", "uid", "only-end-nodes", "html-title", "show-input", "alphabetic-style", "onCheck", "onToggleBookmark"])), [
+                            [P, r.actualOptions[g.index].visible && !r.actualOptions[g.index].hidden]
+                          ]) : v("", !0)
+                        ], 12, De))), 128))
+                      ], 4)
+                    ], 512)
+                  ])),
+                  n.infiniteLoader ? (y(), b("div", Pe, null, 512)) : v("", !0)
+                ];
+              }),
+              _: 3
+            }, 8, ["class"])
+          ], 6)
+        ]),
+        _: 2
+      }, [
+        e.hasTrigger ? {
+          name: "trigger",
+          fn: C(() => [
+            D(n.$slots, "trigger", {
+              selectedCount: e.selectedKeys.length,
+              isOpen: r.isOpen
+            })
+          ]),
+          key: "0"
+        } : {
+          name: "trigger",
+          fn: C(({ isOpened: f }) => [
+            x("div", {
+              role: "combobox",
+              tabindex: "0",
+              class: I(["tree-choice", {
+                "tree-choice-opened": f,
+                "has-clear-button": t.showClearButton,
+                "tree-choice-error": t.errorMessage
+              }]),
+              ref: "combobox",
+              "aria-expanded": f,
+              onClick: o[2] || (o[2] = T(() => {
+              }, ["prevent"])),
+              onBlur: o[3] || (o[3] = (...p) => e.onBlur && e.onBlur(...p)),
+              onKeyup: [
+                o[4] || (o[4] = w((...p) => e.comboboxKeyupDown && e.comboboxKeyupDown(...p), ["down"])),
+                o[5] || (o[5] = w((...p) => e.comboboxKeyupDown && e.comboboxKeyupDown(...p), ["up"]))
+              ],
+              "aria-label": t.ariaLabel,
+              "aria-activedescendant": r.focusedOptionId
+            }, [
+              e.hasTriggerContent ? D(n.$slots, "triggerContent", {
+                key: 0,
+                selectedCount: e.selectedKeys.length,
+                isOpen: f
+              }) : (y(), b(M, { key: 1 }, [
+                t.htmlOptionTitle ? (y(), b("span", {
+                  key: 0,
+                  class: I({ placeholder: !e.selectStatus }),
+                  innerHTML: e.selectStatus || t.placeholder
+                }, null, 10, ["innerHTML"])) : (y(), b("span", {
+                  key: 1,
+                  class: I({ placeholder: !e.selectStatus })
+                }, z(e.selectStatus || t.placeholder), 3))
+              ], 64)),
+              t.showClearButton ? R((y(), S(a, {
+                key: 2,
+                kind: "ghost",
+                class: "button-clear",
+                "aria-label": "Clear selection",
+                onClick: T(e.clearValue, ["prevent"]),
+                onKeypress: o[0] || (o[0] = w(T(() => {
+                }, ["stop", "prevent"]), ["enter"])),
+                onKeydown: o[1] || (o[1] = w(T(() => {
+                }, ["stop", "prevent"]), ["enter"])),
+                onKeyup: w(T(e.clearValue, ["prevent"]), ["enter"]),
+                "help-text": t.clearButtonMessage
+              }, {
+                default: C(() => [
+                  _(s, { name: "close-outline" })
+                ]),
+                _: 1
+              }, 8, ["onClick", "onKeyup", "help-text"])), [
+                [P, Object.keys(r.selected).length]
+              ]) : v("", !0),
+              _(s, {
+                name: f ? "chevron-up-outline" : "chevron-down-outline",
+                classes: "tree-select-caret"
+              }, null, 8, ["name"]),
+              (y(!0), b(M, null, F(e.selectedKeys, (p) => (y(), b("input", {
+                type: "hidden",
+                key: "hidden-" + p,
+                name: r.actualName,
+                value: p
+              }, null, 8, ["name", "value"]))), 128))
+            ], 42, ["aria-expanded", "aria-label", "aria-activedescendant"])
+          ]),
+          key: "1"
+        }
+      ]), 1032, ["disabled", "is-resizable", "vertical", "class", "onClose", "onOpen"])
+    ], 16)
+  ], 64);
+}
+const et = /* @__PURE__ */ me(_e, [["render", Fe]]);
+export {
+  et as default
+};