@web-utils/component 2.0.14 → 2.2.0

package/vue-tree-select/index.mjs

@@ -0,0 +1,2881 @@
+var Fe = Object.defineProperty, ke = Object.defineProperties;
+var He = Object.getOwnPropertyDescriptors;
+var G = Object.getOwnPropertySymbols;
+var Pe = Object.prototype.hasOwnProperty, We = Object.prototype.propertyIsEnumerable;
+var J = (e, t, s) => t in e ? Fe(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s, _ = (e, t) => {
+  for (var s in t || (t = {}))
+    Pe.call(t, s) && J(e, s, t[s]);
+  if (G)
+    for (var s of G(t))
+      We.call(t, s) && J(e, s, t[s]);
+  return e;
+}, b = (e, t) => ke(e, He(t));
+import { noop as je, identity as Qe, last as Z, once as Ke, debounce as qe } from "lodash-es";
+import { isPromise as Oe } from "@web-utils/core";
+import { n as f } from "../chunks/vueComponentNormalizer.JwmUNtgn.mjs";
+import Ue from "vue";
+const S = process.env.NODE_ENV === "production" ? (
+  /* istanbul ignore next */
+  je
+) : function(t, s) {
+  if (!t()) {
+    const n = ["[Vue-TreeSelect Warning]"].concat(s());
+    console.error(...n);
+  }
+};
+function N(e) {
+  return function(s, ...n) {
+    s.type === "mousedown" && s.button === 0 && e.call(this, s, ...n);
+  };
+}
+function Ye(e, t) {
+  const s = e.getBoundingClientRect(), n = t.getBoundingClientRect(), i = t.offsetHeight / 3;
+  n.bottom + i > s.bottom ? e.scrollTop = Math.min(
+    t.offsetTop + t.clientHeight - e.offsetHeight + i,
+    e.scrollHeight
+  ) : n.top - i < s.top && (e.scrollTop = Math.max(t.offsetTop - i, 0));
+}
+function ye(e, t) {
+  const s = e.indexOf(t);
+  s !== -1 && e.splice(s, 1);
+}
+let K;
+const T = [], Xe = 100;
+function Ge() {
+  K = setInterval(() => {
+    T.forEach(Ee);
+  }, Xe);
+}
+function Je() {
+  clearInterval(K), K = null;
+}
+function Ee(e) {
+  const { $el: t, listener: s, lastWidth: n, lastHeight: i } = e, o = t.offsetWidth, r = t.offsetHeight;
+  (n !== o || i !== r) && (e.lastWidth = o, e.lastHeight = r, s({ width: o, height: r }));
+}
+function Ze(e, t) {
+  const s = {
+    $el: e,
+    listener: t,
+    lastWidth: null,
+    lastHeight: null
+  }, n = () => {
+    ye(T, s), T.length || Je();
+  };
+  return T.push(s), Ee(s), Ge(), n;
+}
+function et(e, t) {
+  const s = document.createElement("_"), n = s.appendChild(document.createElement("_")), i = s.appendChild(document.createElement("_")), o = n.appendChild(document.createElement("_"));
+  let r, c;
+  return n.style.cssText = s.style.cssText = "height:100%;left:0;opacity:0;overflow:hidden;pointer-events:none;position:absolute;top:0;transition:0s;width:100%;z-index:-1", o.style.cssText = i.style.cssText = "display:block;height:100%;transition:0s;width:100%", o.style.width = o.style.height = "200%", e.appendChild(s), d(), m;
+  function d() {
+    a();
+    const p = e.offsetWidth, y = e.offsetHeight;
+    (p !== r || y !== c) && (r = p, c = y, i.style.width = `${p * 2}px`, i.style.height = `${y * 2}px`, s.scrollLeft = s.scrollWidth, s.scrollTop = s.scrollHeight, n.scrollLeft = n.scrollWidth, n.scrollTop = n.scrollHeight, t({ width: p, height: y })), n.addEventListener("scroll", d), s.addEventListener("scroll", d);
+  }
+  function a() {
+    n.removeEventListener("scroll", d), s.removeEventListener("scroll", d);
+  }
+  function m() {
+    a(), e.removeChild(s);
+  }
+}
+function Ne(e, t) {
+  const s = document.documentMode === 9;
+  let n = !0;
+  const r = (s ? Ze : et)(e, (...c) => n || t(...c));
+  return n = !1, r;
+}
+function tt(e) {
+  const t = [];
+  let s = e.parentNode;
+  for (; s && s.nodeName !== "BODY" && s.nodeType === document.ELEMENT_NODE; )
+    st(s) && t.push(s), s = s.parentNode;
+  return t.push(window), t;
+}
+function st(e) {
+  const { overflow: t, overflowX: s, overflowY: n } = getComputedStyle(e);
+  return /(auto|scroll|overlay)/.test(t + n + s);
+}
+function be(e, t) {
+  const s = tt(e);
+  return window.addEventListener("resize", t, { passive: !0 }), s.forEach((n) => {
+    n.addEventListener("scroll", t, { passive: !0 });
+  }), function() {
+    window.removeEventListener("resize", t, { passive: !0 }), s.forEach((i) => {
+      i.removeEventListener("scroll", t, { passive: !0 });
+    });
+  };
+}
+function $e(e) {
+  return Number.isNaN(e);
+}
+const g = () => /* @__PURE__ */ Object.create(null);
+function we(e) {
+  return e == null || typeof e != "object" ? !1 : Object.getPrototypeOf(e) === Object.prototype;
+}
+function nt(e, t, s) {
+  we(s) ? (e[t] || (e[t] = {}), q(e[t], s)) : e[t] = s;
+}
+function q(e, t) {
+  if (we(t)) {
+    const s = Object.keys(t);
+    for (let n = 0, i = s.length; n < i; n++)
+      nt(e, s[n], t[s[n]]);
+  }
+  return e;
+}
+function O(e, t) {
+  return e.indexOf(t) !== -1;
+}
+function Ce(e, t, s) {
+  for (let n = 0, i = e.length; n < i; n++)
+    if (t.call(s, e[n], n, e))
+      return e[n];
+}
+function V(e, t) {
+  if (e.length !== t.length)
+    return !0;
+  for (let s = 0; s < e.length; s++)
+    if (e[s] !== t[s])
+      return !0;
+  return !1;
+}
+function it(e, t) {
+  const s = t.length, n = e.length;
+  if (n > s)
+    return !1;
+  if (n === s)
+    return e === t;
+  e:
+    for (let i = 0, o = 0; i < n; i++) {
+      const r = e.charCodeAt(i);
+      for (; o < s; )
+        if (t.charCodeAt(o++) === r)
+          continue e;
+      return !1;
+    }
+  return !0;
+}
+const E = null, U = 0, Le = 1, Me = 2, $ = "ALL_CHILDREN", w = "ALL_DESCENDANTS", C = "LEAF_CHILDREN", L = "LEAF_DESCENDANTS", rt = "LOAD_ROOT_OPTIONS", ot = "LOAD_CHILDREN_OPTIONS", lt = "ASYNC_SEARCH", B = "ALL", x = "BRANCH_PRIORITY", z = "LEAF_PRIORITY", F = "ALL_WITH_INDETERMINATE", ee = "ORDER_SELECTED", te = "LEVEL", se = "INDEX", h = {
+  BACKSPACE: 8,
+  ENTER: 13,
+  ESCAPE: 27,
+  END: 35,
+  HOME: 36,
+  ARROW_LEFT: 37,
+  ARROW_UP: 38,
+  ARROW_RIGHT: 39,
+  ARROW_DOWN: 40,
+  DELETE: 46
+}, at = process.env.NODE_ENV === "testing" ? (
+  /* to speed up unit testing */
+  10
+) : (
+  /* istanbul ignore next */
+  200
+), ne = 5, ie = 40;
+function xe(e, t) {
+  let s = 0;
+  do {
+    if (e.level < s)
+      return -1;
+    if (t.level < s)
+      return 1;
+    if (e.index[s] !== t.index[s])
+      return e.index[s] - t.index[s];
+    s++;
+  } while (!0);
+}
+function ct(e, t) {
+  return e.level === t.level ? xe(e, t) : e.level - t.level;
+}
+function k() {
+  return {
+    isLoaded: !1,
+    isLoading: !1,
+    loadingError: ""
+  };
+}
+function ut(e) {
+  return typeof e == "string" ? e : typeof e == "number" && !$e(e) ? `${e}` : "";
+}
+function re(e, t, s) {
+  return e ? it(t, s) : O(s, t);
+}
+function H(e) {
+  return e.message || /* istanbul ignore next */
+  String(e);
+}
+let ht = 0;
+const dt = {
+  provide() {
+    return {
+      // Enable access to the instance of root component of vue-treeselect
+      // across hierarchy.
+      instance: this
+    };
+  },
+  props: {
+    /**
+     * Whether to allow resetting value even if there are disabled selected nodes.
+     */
+    allowClearingDisabled: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * When an ancestor node is selected/deselected, whether its disabled descendants should be selected/deselected.
+     * You may want to use this in conjunction with `allowClearingDisabled` prop.
+     */
+    allowSelectingDisabledDescendants: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Whether the menu should be always open.
+     */
+    alwaysOpen: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Append the menu to <body />?
+     */
+    appendToBody: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Whether to enable async search mode.
+     */
+    async: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Automatically focus the component on mount?
+     */
+    autoFocus: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Automatically load root options on mount. When set to `false`, root options will be loaded when the menu is opened.
+     */
+    autoLoadRootOptions: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * When user deselects a node, automatically deselect its ancestors. Applies to flat mode only.
+     */
+    autoDeselectAncestors: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * When user deselects a node, automatically deselect its descendants. Applies to flat mode only.
+     */
+    autoDeselectDescendants: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * When user selects a node, automatically select its ancestors. Applies to flat mode only.
+     */
+    autoSelectAncestors: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * When user selects a node, automatically select its descendants. Applies to flat mode only.
+     */
+    autoSelectDescendants: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Whether pressing backspace key removes the last item if there is no text input.
+     */
+    backspaceRemoves: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Function that processes before clearing all input fields.
+     * Return `false` to prevent value from being cleared.
+     * @type {function(): (boolean|Promise<boolean>)}
+     */
+    beforeClearAll: {
+      type: Function,
+      default: () => !0
+    },
+    /**
+     * Show branch nodes before leaf nodes?
+     */
+    branchNodesFirst: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Should cache results of every search request?
+     */
+    cacheOptions: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Show an "×" button that resets value?
+     */
+    clearable: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Title for the "×" button when `multiple: true`.
+     */
+    clearAllText: {
+      type: String,
+      default: "Clear all"
+    },
+    /**
+     * Whether to clear the search input after selecting.
+     * Use only when `multiple` is `true`.
+     * For single-select mode, it **always** clears the input after selecting an option regardless of the prop value.
+     */
+    clearOnSelect: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Title for the "×" button.
+     */
+    clearValueText: {
+      type: String,
+      default: "Clear value"
+    },
+    /**
+     * Whether to close the menu after selecting an option?
+     * Use only when `multiple` is `true`.
+     */
+    closeOnSelect: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * How many levels of branch nodes should be automatically expanded when loaded.
+     * Set `Infinity` to make all branch nodes expanded by default.
+     */
+    defaultExpandLevel: {
+      type: Number,
+      default: 0
+    },
+    /**
+     * The default set of options to show before the user starts searching. Used for async search mode.
+     * When set to `true`, the results for search query as a empty string will be autoloaded.
+     * @type {boolean|node[]}
+     */
+    defaultOptions: {
+      default: !1
+    },
+    /**
+     * Whether pressing delete key removes the last item if there is no text input.
+     */
+    deleteRemoves: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Delimiter to use to join multiple values for the hidden field value.
+     */
+    delimiter: {
+      type: String,
+      default: ","
+    },
+    /**
+     * Only show the nodes that match the search value directly, excluding its ancestors.
+     *
+     * @type {Object}
+     */
+    flattenSearchResults: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Prevent branch nodes from being selected?
+     */
+    disableBranchNodes: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Disable the control?
+     */
+    disabled: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Disable the fuzzy matching functionality?
+     */
+    disableFuzzyMatching: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Whether to enable flat mode or not. Non-flat mode (default) means:
+     *   - Whenever a branch node gets checked, all its children will be checked too
+     *   - Whenever a branch node has all children checked, the branch node itself will be checked too
+     * Set `true` to disable this mechanism
+     */
+    flat: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Will be passed with all events as the last param.
+     * Useful for identifying events origin.
+    */
+    instanceId: {
+      // Add two trailing "$" to distinguish from explictly specified ids.
+      default: () => `${ht++}$$`,
+      type: [String, Number]
+    },
+    /**
+     * Joins multiple values into a single form field with the `delimiter` (legacy mode).
+    */
+    joinValues: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Limit the display of selected options.
+     * The rest will be hidden within the limitText string.
+     */
+    limit: {
+      type: Number,
+      default: 1 / 0
+    },
+    /**
+     * Function that processes the message shown when selected elements pass the defined limit.
+     * @type {function(number): string}
+     */
+    limitText: {
+      type: Function,
+      default: function(t) {
+        return `and ${t} more`;
+      }
+    },
+    /**
+     * Text displayed when loading options.
+     */
+    loadingText: {
+      type: String,
+      default: "Loading..."
+    },
+    /**
+     * Used for dynamically loading options.
+     * @type {function({action: string, callback: (function((Error|string)=): void), parentNode: node=, instanceId}): void}
+     */
+    loadOptions: {
+      type: Function
+    },
+    /**
+     * Which node properties to filter on.
+     */
+    matchKeys: {
+      type: Array,
+      default: () => ["label"]
+    },
+    /**
+     * Sets `maxHeight` style value of the menu.
+     */
+    maxHeight: {
+      type: Number,
+      default: 300
+    },
+    /**
+     * Set `true` to allow selecting multiple options (a.k.a., multi-select mode).
+     */
+    multiple: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Generates a hidden <input /> tag with this field name for html forms.
+     */
+    name: {
+      type: String
+    },
+    /**
+     * Text displayed when a branch node has no children.
+     */
+    noChildrenText: {
+      type: String,
+      default: "No sub-options."
+    },
+    /**
+     * Text displayed when there are no available options.
+     */
+    noOptionsText: {
+      type: String,
+      default: "No options available."
+    },
+    /**
+     * Text displayed when there are no matching search results.
+     */
+    noResultsText: {
+      type: String,
+      default: "No results found..."
+    },
+    /**
+     * Used for normalizing source data.
+     * @type {function(node, instanceId): node}
+     */
+    normalizer: {
+      type: Function,
+      default: Qe
+    },
+    /**
+     * By default (`auto`), the menu will open below the control. If there is not
+     * enough space, vue-treeselect will automatically flip the menu.
+     * You can use one of other four options to force the menu to be always opened
+     * to specified direction.
+     * Acceptable values:
+     *   - `"auto"`
+     *   - `"below"`
+     *   - `"bottom"`
+     *   - `"above"`
+     *   - `"top"`
+     */
+    openDirection: {
+      type: String,
+      default: "auto",
+      validator(e) {
+        return O(["auto", "top", "bottom", "above", "below"], e);
+      }
+    },
+    /**
+     * Whether to automatically open the menu when the control is clicked.
+     */
+    openOnClick: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Whether to automatically open the menu when the control is focused.
+     */
+    openOnFocus: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Array of available options.
+     * @type {node[]}
+     */
+    options: {
+      type: Array
+    },
+    /**
+     * Field placeholder, displayed when there's no value.
+     */
+    placeholder: {
+      type: String,
+      default: "Select..."
+    },
+    /**
+     * Applies HTML5 required attribute when needed.
+     */
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Text displayed asking user whether to retry loading children options.
+     */
+    retryText: {
+      type: String,
+      default: "Retry?"
+    },
+    /**
+     * Title for the retry button.
+     */
+    retryTitle: {
+      type: String,
+      default: "Click to retry"
+    },
+    /**
+     * Enable searching feature?
+     */
+    searchable: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Search in ancestor nodes too.
+     */
+    searchNested: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Text tip to prompt for async search.
+     */
+    searchPromptText: {
+      type: String,
+      default: "Type to search..."
+    },
+    /**
+     * Whether to show a children count next to the label of each branch node.
+     */
+    showCount: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Used in conjunction with `showCount` to specify which type of count number should be displayed.
+     * Acceptable values:
+     *   - "ALL_CHILDREN"
+     *   - "ALL_DESCENDANTS"
+     *   - "LEAF_CHILDREN"
+     *   - "LEAF_DESCENDANTS"
+     */
+    showCountOf: {
+      type: String,
+      default: $,
+      validator(e) {
+        return O([$, w, C, L], e);
+      }
+    },
+    /**
+     * Whether to show children count when searching.
+     * Fallbacks to the value of `showCount` when not specified.
+     * @type {boolean}
+     */
+    showCountOnSearch: null,
+    /**
+     * In which order the selected options should be displayed in trigger & sorted in `value` array.
+     * Used for multi-select mode only.
+     * Acceptable values:
+     *   - "ORDER_SELECTED"
+     *   - "LEVEL"
+     *   - "INDEX"
+     */
+    sortValueBy: {
+      type: String,
+      default: ee,
+      validator(e) {
+        return O([ee, te, se], e);
+      }
+    },
+    /**
+     * Tab index of the control.
+     */
+    tabIndex: {
+      type: Number,
+      default: 0
+    },
+    /**
+     * The value of the control.
+     * Should be `id` or `node` object for single-select mode, or an array of `id` or `node` object for multi-select mode.
+     * Its format depends on the `valueFormat` prop.
+     * For most cases, just use `v-model` instead.
+     * @type {?Array}
+     */
+    value: null,
+    /**
+     * Which kind of nodes should be included in the `value` array in multi-select mode.
+     * Acceptable values:
+     *   - "ALL" - Any node that is checked will be included in the `value` array
+     *   - "BRANCH_PRIORITY" (default) - If a branch node is checked, all its descendants will be excluded in the `value` array
+     *   - "LEAF_PRIORITY" - If a branch node is checked, this node itself and its branch descendants will be excluded from the `value` array but its leaf descendants will be included
+     *   - "ALL_WITH_INDETERMINATE" - Any node that is checked will be included in the `value` array, plus indeterminate nodes
+     */
+    valueConsistsOf: {
+      type: String,
+      default: x,
+      validator(e) {
+        return O([B, x, z, F], e);
+      }
+    },
+    /**
+     * Format of `value` prop.
+     * Note that, when set to `"object"`, only `id` & `label` properties are required in each `node` object in `value` prop.
+     * Acceptable values:
+     *   - "id"
+     *   - "object"
+     */
+    valueFormat: {
+      type: String,
+      default: "id"
+    },
+    /**
+     * z-index of the menu.
+     */
+    zIndex: {
+      type: [Number, String],
+      default: 999
+    }
+  },
+  data() {
+    return {
+      trigger: {
+        // Is the control focused?
+        isFocused: !1,
+        // User entered search query - value of the input.
+        searchQuery: ""
+      },
+      menu: {
+        // Is the menu opened?
+        isOpen: !1,
+        // Id of current highlighted option.
+        current: null,
+        // The scroll position before last menu closing.
+        lastScrollPosition: 0,
+        // Which direction to open the menu.
+        placement: "bottom"
+      },
+      forest: {
+        // Normalized options.
+        normalizedOptions: [],
+        // <id, node> map for quick look-up.
+        nodeMap: g(),
+        // <id, checkedState> map, used for multi-select mode.
+        checkedStateMap: g(),
+        // Id list of all selected options.
+        selectedNodeIds: this.extractCheckedNodeIdsFromValue(),
+        // <id, true> map for fast checking:
+        //   if (forest.selectedNodeIds.indexOf(id) !== -1) forest.selectedNodeMap[id] === true
+        selectedNodeMap: g()
+      },
+      // States of root options.
+      rootOptionsStates: k(),
+      localSearch: {
+        // Has user entered any query to search local options?
+        active: !1,
+        // Has any options matched the search query?
+        noResults: !0,
+        // <id, countObject> map for counting matched children/descendants.
+        countMap: g()
+      },
+      // <searchQuery, remoteSearchEntry> map.
+      remoteSearch: g()
+    };
+  },
+  computed: {
+    /* eslint-disable valid-jsdoc */
+    /**
+     * Normalized nodes that have been selected.
+     * @type {node[]}
+     */
+    selectedNodes() {
+      return this.forest.selectedNodeIds.map(this.getNode);
+    },
+    /**
+     * Id list of selected nodes with `sortValueBy` prop applied.
+     * @type {nodeId[]}
+     */
+    internalValue() {
+      let e;
+      if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === B)
+        e = this.forest.selectedNodeIds.slice();
+      else if (this.valueConsistsOf === x)
+        e = this.forest.selectedNodeIds.filter((t) => {
+          const s = this.getNode(t);
+          return s.isRootNode ? !0 : !this.isSelected(s.parentNode);
+        });
+      else if (this.valueConsistsOf === z)
+        e = this.forest.selectedNodeIds.filter((t) => {
+          const s = this.getNode(t);
+          return s.isLeaf ? !0 : s.children.length === 0;
+        });
+      else if (this.valueConsistsOf === F) {
+        const t = [];
+        e = this.forest.selectedNodeIds.slice(), this.selectedNodes.forEach((s) => {
+          s.ancestors.forEach((n) => {
+            O(t, n.id) || O(e, n.id) || t.push(n.id);
+          });
+        }), e.push(...t);
+      }
+      return this.sortValueBy === te ? e.sort((t, s) => ct(this.getNode(t), this.getNode(s))) : this.sortValueBy === se && e.sort((t, s) => xe(this.getNode(t), this.getNode(s))), e;
+    },
+    /**
+     * Has any option been selected?
+     * @type {boolean}
+     */
+    hasValue() {
+      return this.internalValue.length > 0;
+    },
+    /**
+     * Single-select mode?
+     * @type {boolean}
+     */
+    single() {
+      return !this.multiple;
+    },
+    /**
+     * Id list of nodes displayed in the menu. Nodes that are considered NOT visible:
+     *   - descendants of a collapsed branch node
+     *   - in local search mode, nodes that are not matched, unless
+     *       - it's a branch node and has matched descendants
+     *       - it's a leaf node and its parent node is explicitly set to show all children
+     * @type {id[]}
+     */
+    visibleOptionIds() {
+      const e = [];
+      return this.traverseAllNodesByIndex((t) => {
+        if ((!this.localSearch.active || this.shouldOptionBeIncludedInSearchResult(t)) && e.push(t.id), t.isBranch && !this.shouldExpand(t))
+          return !1;
+      }), e;
+    },
+    /**
+     * Has any option should be displayed in the menu?
+     * @type {boolean}
+     */
+    hasVisibleOptions() {
+      return this.visibleOptionIds.length !== 0;
+    },
+    /**
+     * Should show children count when searching?
+     * @type {boolean}
+     */
+    showCountOnSearchComputed() {
+      return typeof this.showCountOnSearch == "boolean" ? this.showCountOnSearch : this.showCount;
+    },
+    /**
+     * Is there any branch node?
+     * @type {boolean}
+     */
+    hasBranchNodes() {
+      return this.forest.normalizedOptions.some((e) => e.isBranch);
+    },
+    shouldFlattenOptions() {
+      return this.localSearch.active && this.flattenSearchResults;
+    }
+    /* eslint-enable valid-jsdoc */
+  },
+  watch: {
+    alwaysOpen(e) {
+      e ? this.openMenu() : this.closeMenu();
+    },
+    branchNodesFirst() {
+      this.initialize();
+    },
+    disabled(e) {
+      e && this.menu.isOpen ? this.closeMenu() : !e && !this.menu.isOpen && this.alwaysOpen && this.openMenu();
+    },
+    flat() {
+      this.initialize();
+    },
+    internalValue(e, t) {
+      V(e, t) && this.$emit("input", this.getValue(), this.getInstanceId());
+    },
+    matchKeys() {
+      this.initialize();
+    },
+    multiple(e) {
+      e && this.buildForestState();
+    },
+    options: {
+      handler() {
+        this.async || (this.initialize(), this.rootOptionsStates.isLoaded = Array.isArray(this.options));
+      },
+      deep: !0,
+      immediate: !0
+    },
+    "trigger.searchQuery"() {
+      this.async ? this.handleRemoteSearch() : this.handleLocalSearch(), this.$emit("search-change", this.trigger.searchQuery, this.getInstanceId());
+    },
+    value() {
+      const e = this.extractCheckedNodeIdsFromValue();
+      V(e, this.internalValue) && this.fixSelectedNodeIds(e);
+    }
+  },
+  methods: {
+    verifyProps() {
+      S(
+        () => this.async ? this.searchable : !0,
+        () => 'For async search mode, the value of "searchable" prop must be true.'
+      ), this.options == null && !this.loadOptions && S(
+        () => !1,
+        () => 'Are you meant to dynamically load options? You need to use "loadOptions" prop.'
+      ), this.flat && S(
+        () => this.multiple,
+        () => 'You are using flat mode. But you forgot to add "multiple=true"?'
+      ), this.flat || [
+        "autoSelectAncestors",
+        "autoSelectDescendants",
+        "autoDeselectAncestors",
+        "autoDeselectDescendants"
+      ].forEach((t) => {
+        S(
+          () => !this[t],
+          () => `"${t}" only applies to flat mode.`
+        );
+      });
+    },
+    resetFlags() {
+      this._blurOnSelect = !1;
+    },
+    initialize() {
+      const e = this.async ? this.getRemoteSearchEntry().options : this.options;
+      if (Array.isArray(e)) {
+        const t = this.forest.nodeMap;
+        this.forest.nodeMap = g(), this.keepDataOfSelectedNodes(t), this.forest.normalizedOptions = this.normalize(E, e, t), this.fixSelectedNodeIds(this.internalValue);
+      } else
+        this.forest.normalizedOptions = [];
+    },
+    getInstanceId() {
+      return this.instanceId == null ? this.id : this.instanceId;
+    },
+    getValue() {
+      if (this.valueFormat === "id")
+        return this.multiple ? this.internalValue.slice() : this.internalValue[0];
+      const e = this.internalValue.map((t) => this.getNode(t).raw);
+      return this.multiple ? e : e[0];
+    },
+    getNode(e) {
+      return S(
+        () => e != null,
+        () => `Invalid node id: ${e}`
+      ), e == null ? null : e in this.forest.nodeMap ? this.forest.nodeMap[e] : this.createFallbackNode(e);
+    },
+    createFallbackNode(e) {
+      const t = this.extractNodeFromValue(e), s = this.enhancedNormalizer(t).label || `${e} (unknown)`, n = {
+        id: e,
+        label: s,
+        ancestors: [],
+        parentNode: E,
+        isFallbackNode: !0,
+        isRootNode: !0,
+        isLeaf: !0,
+        isBranch: !1,
+        isDisabled: !1,
+        isNew: !1,
+        index: [-1],
+        level: 0,
+        raw: t
+      };
+      return this.$set(this.forest.nodeMap, e, n);
+    },
+    extractCheckedNodeIdsFromValue() {
+      return this.value == null ? [] : this.valueFormat === "id" ? this.multiple ? this.value.slice() : [this.value] : (this.multiple ? this.value : [this.value]).map((e) => this.enhancedNormalizer(e)).map((e) => e.id);
+    },
+    extractNodeFromValue(e) {
+      const t = { id: e };
+      if (this.valueFormat === "id")
+        return t;
+      const s = this.multiple ? Array.isArray(this.value) ? this.value : [] : this.value ? [this.value] : [];
+      return Ce(
+        s,
+        (i) => i && this.enhancedNormalizer(i).id === e
+      ) || t;
+    },
+    fixSelectedNodeIds(e) {
+      let t = [];
+      if (this.single || this.flat || this.disableBranchNodes || this.valueConsistsOf === B)
+        t = e;
+      else if (this.valueConsistsOf === x)
+        e.forEach((n) => {
+          t.push(n);
+          const i = this.getNode(n);
+          i.isBranch && this.traverseDescendantsBFS(i, (o) => {
+            t.push(o.id);
+          });
+        });
+      else if (this.valueConsistsOf === z) {
+        const n = g(), i = e.slice();
+        for (; i.length; ) {
+          const o = i.shift(), r = this.getNode(o);
+          t.push(o), !r.isRootNode && (r.parentNode.id in n || (n[r.parentNode.id] = r.parentNode.children.length), --n[r.parentNode.id] === 0 && i.push(r.parentNode.id));
+        }
+      } else if (this.valueConsistsOf === F) {
+        const n = g(), i = e.filter((o) => {
+          const r = this.getNode(o);
+          return r.isLeaf || r.children.length === 0;
+        });
+        for (; i.length; ) {
+          const o = i.shift(), r = this.getNode(o);
+          t.push(o), !r.isRootNode && (r.parentNode.id in n || (n[r.parentNode.id] = r.parentNode.children.length), --n[r.parentNode.id] === 0 && i.push(r.parentNode.id));
+        }
+      }
+      V(this.forest.selectedNodeIds, t) && (this.forest.selectedNodeIds = t), this.buildForestState();
+    },
+    keepDataOfSelectedNodes(e) {
+      this.forest.selectedNodeIds.forEach((t) => {
+        if (!e[t])
+          return;
+        const s = b(_({}, e[t]), {
+          isFallbackNode: !0
+        });
+        this.$set(this.forest.nodeMap, t, s);
+      });
+    },
+    isSelected(e) {
+      return this.forest.selectedNodeMap[e.id] === !0;
+    },
+    traverseDescendantsBFS(e, t) {
+      if (!e.isBranch)
+        return;
+      const s = e.children.slice();
+      for (; s.length; ) {
+        const n = s[0];
+        n.isBranch && s.push(...n.children), t(n), s.shift();
+      }
+    },
+    traverseDescendantsDFS(e, t) {
+      e.isBranch && e.children.forEach((s) => {
+        this.traverseDescendantsDFS(s, t), t(s);
+      });
+    },
+    traverseAllNodesDFS(e) {
+      this.forest.normalizedOptions.forEach((t) => {
+        this.traverseDescendantsDFS(t, e), e(t);
+      });
+    },
+    traverseAllNodesByIndex(e) {
+      const t = (s) => {
+        s.children.forEach((n) => {
+          e(n) !== !1 && n.isBranch && t(n);
+        });
+      };
+      t({ children: this.forest.normalizedOptions });
+    },
+    toggleClickOutsideEvent(e) {
+      e ? document.addEventListener("mousedown", this.handleClickOutside, !1) : document.removeEventListener("mousedown", this.handleClickOutside, !1);
+    },
+    getValueContainer() {
+      return this.$refs.control.$refs["value-container"];
+    },
+    getInput() {
+      return this.getValueContainer().$refs.input;
+    },
+    focusInput() {
+      this.getInput().focus();
+    },
+    blurInput() {
+      this.getInput().blur();
+    },
+    handleMouseDown: N(function(t) {
+      if (t.preventDefault(), t.stopPropagation(), this.disabled)
+        return;
+      this.getValueContainer().$el.contains(t.target) && !this.menu.isOpen && (this.openOnClick || this.trigger.isFocused) && this.openMenu(), this._blurOnSelect ? this.blurInput() : this.focusInput(), this.resetFlags();
+    }),
+    handleClickOutside(e) {
+      this.$refs.wrapper && !this.$refs.wrapper.contains(e.target) && (this.blurInput(), this.closeMenu());
+    },
+    handleLocalSearch() {
+      const { searchQuery: e } = this.trigger, t = () => this.resetHighlightedOptionWhenNecessary(!0);
+      if (!e)
+        return this.localSearch.active = !1, t();
+      this.localSearch.active = !0, this.localSearch.noResults = !0, this.traverseAllNodesDFS((i) => {
+        i.isBranch && (i.isExpandedOnSearch = !1, i.showAllChildrenOnSearch = !1, i.isMatched = !1, i.hasMatchedDescendants = !1, this.$set(this.localSearch.countMap, i.id, {
+          [$]: 0,
+          [w]: 0,
+          [C]: 0,
+          [L]: 0
+        }));
+      });
+      const s = e.trim().toLocaleLowerCase(), n = s.replace(/\s+/g, " ").split(" ");
+      this.traverseAllNodesDFS((i) => {
+        this.searchNested && n.length > 1 ? i.isMatched = n.every(
+          (o) => re(!1, o, i.nestedSearchLabel)
+        ) : i.isMatched = this.matchKeys.some(
+          (o) => re(!this.disableFuzzyMatching, s, i.lowerCased[o])
+        ), i.isMatched && (this.localSearch.noResults = !1, i.ancestors.forEach((o) => this.localSearch.countMap[o.id][w]++), i.isLeaf && i.ancestors.forEach((o) => this.localSearch.countMap[o.id][L]++), i.parentNode !== E && (this.localSearch.countMap[i.parentNode.id][$] += 1, i.isLeaf && (this.localSearch.countMap[i.parentNode.id][C] += 1))), (i.isMatched || i.isBranch && i.isExpandedOnSearch) && i.parentNode !== E && (i.parentNode.isExpandedOnSearch = !0, i.parentNode.hasMatchedDescendants = !0);
+      }), t();
+    },
+    handleRemoteSearch() {
+      const { searchQuery: e } = this.trigger, t = this.getRemoteSearchEntry(), s = () => {
+        this.initialize(), this.resetHighlightedOptionWhenNecessary(!0);
+      };
+      if ((e === "" || this.cacheOptions) && t.isLoaded)
+        return s();
+      this.callLoadOptionsProp({
+        action: lt,
+        args: { searchQuery: e },
+        isPending() {
+          return t.isLoading;
+        },
+        start: () => {
+          t.isLoading = !0, t.isLoaded = !1, t.loadingError = "";
+        },
+        succeed: (n) => {
+          t.isLoaded = !0, t.options = n, this.trigger.searchQuery === e && s();
+        },
+        fail: (n) => {
+          t.loadingError = H(n);
+        },
+        end: () => {
+          t.isLoading = !1;
+        }
+      });
+    },
+    getRemoteSearchEntry() {
+      const { searchQuery: e } = this.trigger, t = this.remoteSearch[e] || b(_({}, k()), {
+        options: []
+      });
+      if (this.$watch(
+        () => t.options,
+        () => {
+          this.trigger.searchQuery === e && this.initialize();
+        },
+        { deep: !0 }
+      ), e === "") {
+        if (Array.isArray(this.defaultOptions))
+          return t.options = this.defaultOptions, t.isLoaded = !0, t;
+        if (this.defaultOptions !== !0)
+          return t.isLoaded = !0, t;
+      }
+      return this.remoteSearch[e] || this.$set(this.remoteSearch, e, t), t;
+    },
+    shouldExpand(e) {
+      return this.localSearch.active ? e.isExpandedOnSearch : e.isExpanded;
+    },
+    shouldOptionBeIncludedInSearchResult(e) {
+      return !!(e.isMatched || e.isBranch && e.hasMatchedDescendants && !this.flattenSearchResults || !e.isRootNode && e.parentNode.showAllChildrenOnSearch);
+    },
+    shouldShowOptionInMenu(e) {
+      return !(this.localSearch.active && !this.shouldOptionBeIncludedInSearchResult(e));
+    },
+    getControl() {
+      return this.$refs.control.$el;
+    },
+    getMenu() {
+      const t = (this.appendToBody ? this.$refs.portal.portalTarget : this).$refs.menu.$refs.menu;
+      return t && t.nodeName !== "#comment" ? t : null;
+    },
+    setCurrentHighlightedOption(e, t = !0) {
+      const s = this.menu.current;
+      if (s != null && s in this.forest.nodeMap && (this.forest.nodeMap[s].isHighlighted = !1), this.menu.current = e.id, e.isHighlighted = !0, this.menu.isOpen && t) {
+        const n = () => {
+          const i = this.getMenu(), o = i.querySelector(`.vue-treeselect__option[data-id="${e.id}"]`);
+          o && Ye(i, o);
+        };
+        this.getMenu() ? n() : this.$nextTick(n);
+      }
+    },
+    resetHighlightedOptionWhenNecessary(e = !1) {
+      const { current: t } = this.menu;
+      (e || t == null || !(t in this.forest.nodeMap) || !this.shouldShowOptionInMenu(this.getNode(t))) && this.highlightFirstOption();
+    },
+    highlightFirstOption() {
+      if (!this.hasVisibleOptions)
+        return;
+      const e = this.visibleOptionIds[0];
+      this.setCurrentHighlightedOption(this.getNode(e));
+    },
+    highlightPrevOption() {
+      if (!this.hasVisibleOptions)
+        return;
+      const e = this.visibleOptionIds.indexOf(this.menu.current) - 1;
+      if (e === -1)
+        return this.highlightLastOption();
+      this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[e]));
+    },
+    highlightNextOption() {
+      if (!this.hasVisibleOptions)
+        return;
+      const e = this.visibleOptionIds.indexOf(this.menu.current) + 1;
+      if (e === this.visibleOptionIds.length)
+        return this.highlightFirstOption();
+      this.setCurrentHighlightedOption(this.getNode(this.visibleOptionIds[e]));
+    },
+    highlightLastOption() {
+      if (!this.hasVisibleOptions)
+        return;
+      const e = Z(this.visibleOptionIds);
+      this.setCurrentHighlightedOption(this.getNode(e));
+    },
+    resetSearchQuery() {
+      this.trigger.searchQuery = "";
+    },
+    closeMenu() {
+      !this.menu.isOpen || !this.disabled && this.alwaysOpen || (this.saveMenuScrollPosition(), this.menu.isOpen = !1, this.toggleClickOutsideEvent(!1), this.resetSearchQuery(), this.$emit("close", this.getValue(), this.getInstanceId()));
+    },
+    openMenu() {
+      this.disabled || this.menu.isOpen || (this.menu.isOpen = !0, this.$nextTick(this.resetHighlightedOptionWhenNecessary), this.$nextTick(this.restoreMenuScrollPosition), !this.options && !this.async && this.loadRootOptions(), this.toggleClickOutsideEvent(!0), this.$emit("open", this.getInstanceId()));
+    },
+    toggleMenu() {
+      this.menu.isOpen ? this.closeMenu() : this.openMenu();
+    },
+    toggleExpanded(e) {
+      let t;
+      this.localSearch.active ? (t = e.isExpandedOnSearch = !e.isExpandedOnSearch, t && (e.showAllChildrenOnSearch = !0)) : t = e.isExpanded = !e.isExpanded, t && !e.childrenStates.isLoaded && this.loadChildrenOptions(e);
+    },
+    buildForestState() {
+      const e = g();
+      this.forest.selectedNodeIds.forEach((s) => {
+        e[s] = !0;
+      }), this.forest.selectedNodeMap = e;
+      const t = g();
+      this.multiple && (this.traverseAllNodesByIndex((s) => {
+        t[s.id] = U;
+      }), this.selectedNodes.forEach((s) => {
+        t[s.id] = Me, !this.flat && !this.disableBranchNodes && s.ancestors.forEach((n) => {
+          this.isSelected(n) || (t[n.id] = Le);
+        });
+      })), this.forest.checkedStateMap = t;
+    },
+    enhancedNormalizer(e) {
+      return _(_({}, e), this.normalizer(e, this.getInstanceId()));
+    },
+    normalize(e, t, s) {
+      let n = t.map((i) => [this.enhancedNormalizer(i), i]).map(([i, o], r) => {
+        this.checkDuplication(i), this.verifyNodeShape(i);
+        const { id: c, label: d, children: a, isDefaultExpanded: m } = i, p = e === E, y = p ? 0 : e.level + 1, R = Array.isArray(a) || a === null, I = !R, X = !!i.isDisabled || !this.flat && !p && e.isDisabled, Be = !!i.isNew, A = this.matchKeys.reduce((u, M) => b(_({}, u), {
+          [M]: ut(i[M]).toLocaleLowerCase()
+        }), {}), ze = p ? A.label : `${e.nestedSearchLabel} ${A.label}`, l = this.$set(this.forest.nodeMap, c, g());
+        if (this.$set(l, "id", c), this.$set(l, "label", d), this.$set(l, "level", y), this.$set(l, "ancestors", p ? [] : [e].concat(e.ancestors)), this.$set(l, "index", (p ? [] : e.index).concat(r)), this.$set(l, "parentNode", e), this.$set(l, "lowerCased", A), this.$set(l, "nestedSearchLabel", ze), this.$set(l, "isDisabled", X), this.$set(l, "isNew", Be), this.$set(l, "isMatched", !1), this.$set(l, "isHighlighted", !1), this.$set(l, "isBranch", R), this.$set(l, "isLeaf", I), this.$set(l, "isRootNode", p), this.$set(l, "raw", o), R) {
+          const u = Array.isArray(a);
+          this.$set(l, "childrenStates", b(_({}, k()), {
+            isLoaded: u
+          })), this.$set(l, "isExpanded", typeof m == "boolean" ? m : y < this.defaultExpandLevel), this.$set(l, "hasMatchedDescendants", !1), this.$set(l, "hasDisabledDescendants", !1), this.$set(l, "isExpandedOnSearch", !1), this.$set(l, "showAllChildrenOnSearch", !1), this.$set(l, "count", {
+            [$]: 0,
+            [w]: 0,
+            [C]: 0,
+            [L]: 0
+          }), this.$set(l, "children", u ? this.normalize(l, a, s) : []), m === !0 && l.ancestors.forEach((M) => {
+            M.isExpanded = !0;
+          }), !u && typeof this.loadOptions != "function" ? S(
+            () => !1,
+            () => 'Unloaded branch node detected. "loadOptions" prop is required to load its children.'
+          ) : !u && l.isExpanded && this.loadChildrenOptions(l);
+        }
+        if (l.ancestors.forEach((u) => u.count[w]++), I && l.ancestors.forEach((u) => u.count[L]++), p || (e.count[$] += 1, I && (e.count[C] += 1), X && (e.hasDisabledDescendants = !0)), s && s[c]) {
+          const u = s[c];
+          l.isMatched = u.isMatched, l.showAllChildrenOnSearch = u.showAllChildrenOnSearch, l.isHighlighted = u.isHighlighted, u.isBranch && l.isBranch && (l.isExpanded = u.isExpanded, l.isExpandedOnSearch = u.isExpandedOnSearch, u.childrenStates.isLoaded && !l.childrenStates.isLoaded ? l.isExpanded = !1 : l.childrenStates = _({}, u.childrenStates));
+        }
+        return l;
+      });
+      if (this.branchNodesFirst) {
+        const i = n.filter((r) => r.isBranch), o = n.filter((r) => r.isLeaf);
+        n = i.concat(o);
+      }
+      return n;
+    },
+    loadRootOptions() {
+      this.callLoadOptionsProp({
+        action: rt,
+        isPending: () => this.rootOptionsStates.isLoading,
+        start: () => {
+          this.rootOptionsStates.isLoading = !0, this.rootOptionsStates.loadingError = "";
+        },
+        succeed: () => {
+          this.rootOptionsStates.isLoaded = !0, this.$nextTick(() => {
+            this.resetHighlightedOptionWhenNecessary(!0);
+          });
+        },
+        fail: (e) => {
+          this.rootOptionsStates.loadingError = H(e);
+        },
+        end: () => {
+          this.rootOptionsStates.isLoading = !1;
+        }
+      });
+    },
+    loadChildrenOptions(e) {
+      const { id: t, raw: s } = e;
+      this.callLoadOptionsProp({
+        action: ot,
+        args: {
+          // We always pass the raw node instead of the normalized node to any
+          // callback provided by the user of this component.
+          // Because the shape of the raw node is more likely to be closing to
+          // what the back-end API service of the application needs.
+          parentNode: s
+        },
+        isPending: () => this.getNode(t).childrenStates.isLoading,
+        start: () => {
+          this.getNode(t).childrenStates.isLoading = !0, this.getNode(t).childrenStates.loadingError = "";
+        },
+        succeed: () => {
+          this.getNode(t).childrenStates.isLoaded = !0;
+        },
+        fail: (n) => {
+          this.getNode(t).childrenStates.loadingError = H(n);
+        },
+        end: () => {
+          this.getNode(t).childrenStates.isLoading = !1;
+        }
+      });
+    },
+    callLoadOptionsProp({ action: e, args: t, isPending: s, start: n, succeed: i, fail: o, end: r }) {
+      if (!this.loadOptions || s())
+        return;
+      n();
+      const c = Ke((a, m) => {
+        a ? o(a) : i(m), r();
+      }), d = this.loadOptions(b(_({
+        id: this.getInstanceId(),
+        instanceId: this.getInstanceId(),
+        action: e
+      }, t), {
+        callback: c
+      }));
+      Oe(d) && d.then(() => {
+        c();
+      }, (a) => {
+        c(a);
+      }).catch((a) => {
+        console.error(a);
+      });
+    },
+    checkDuplication(e) {
+      S(
+        () => !(e.id in this.forest.nodeMap && !this.forest.nodeMap[e.id].isFallbackNode),
+        () => `Detected duplicate presence of node id ${JSON.stringify(e.id)}. Their labels are "${this.forest.nodeMap[e.id].label}" and "${e.label}" respectively.`
+      );
+    },
+    verifyNodeShape(e) {
+      S(
+        () => !(e.children === void 0 && e.isBranch === !0),
+        () => "Are you meant to declare an unloaded branch node? `isBranch: true` is no longer supported, please use `children: null` instead."
+      );
+    },
+    select(e) {
+      if (this.disabled || e.isDisabled)
+        return;
+      this.single && this.clear();
+      const t = this.multiple && !this.flat ? this.forest.checkedStateMap[e.id] === U : !this.isSelected(e);
+      t ? this._selectNode(e) : this._deselectNode(e), this.buildForestState(), t ? this.$emit("select", e.raw, this.getInstanceId()) : this.$emit("deselect", e.raw, this.getInstanceId()), this.localSearch.active && t && (this.single || this.clearOnSelect) && this.resetSearchQuery(), this.single && this.closeOnSelect && (this.closeMenu(), this.searchable && (this._blurOnSelect = !0));
+    },
+    clear() {
+      this.hasValue && (this.single || this.allowClearingDisabled ? this.forest.selectedNodeIds = [] : this.forest.selectedNodeIds = this.forest.selectedNodeIds.filter(
+        (e) => this.getNode(e).isDisabled
+      ), this.buildForestState());
+    },
+    // This is meant to be called only by `select()`.
+    _selectNode(e) {
+      if (this.single || this.disableBranchNodes)
+        return this.addValue(e);
+      if (this.flat) {
+        this.addValue(e), this.autoSelectAncestors ? e.ancestors.forEach((s) => {
+          !this.isSelected(s) && !s.isDisabled && this.addValue(s);
+        }) : this.autoSelectDescendants && this.traverseDescendantsBFS(e, (s) => {
+          !this.isSelected(s) && !s.isDisabled && this.addValue(s);
+        });
+        return;
+      }
+      const t = e.isLeaf || /* node.isBranch && */
+      !e.hasDisabledDescendants || /* node.isBranch && */
+      this.allowSelectingDisabledDescendants;
+      if (t && this.addValue(e), e.isBranch && this.traverseDescendantsBFS(e, (s) => {
+        (!s.isDisabled || this.allowSelectingDisabledDescendants) && this.addValue(s);
+      }), t) {
+        let s = e;
+        for (; (s = s.parentNode) !== E && s.children.every(this.isSelected); )
+          this.addValue(s);
+      }
+    },
+    // This is meant to be called only by `select()`.
+    _deselectNode(e) {
+      if (this.disableBranchNodes)
+        return this.removeValue(e);
+      if (this.flat) {
+        this.removeValue(e), this.autoDeselectAncestors ? e.ancestors.forEach((s) => {
+          this.isSelected(s) && !s.isDisabled && this.removeValue(s);
+        }) : this.autoDeselectDescendants && this.traverseDescendantsBFS(e, (s) => {
+          this.isSelected(s) && !s.isDisabled && this.removeValue(s);
+        });
+        return;
+      }
+      let t = !1;
+      if (e.isBranch && this.traverseDescendantsDFS(e, (s) => {
+        (!s.isDisabled || this.allowSelectingDisabledDescendants) && (this.removeValue(s), t = !0);
+      }), e.isLeaf || /* node.isBranch && */
+      t || /* node.isBranch && */
+      e.children.length === 0) {
+        this.removeValue(e);
+        let s = e;
+        for (; (s = s.parentNode) !== E && this.isSelected(s); )
+          this.removeValue(s);
+      }
+    },
+    addValue(e) {
+      this.forest.selectedNodeIds.push(e.id), this.forest.selectedNodeMap[e.id] = !0;
+    },
+    removeValue(e) {
+      ye(this.forest.selectedNodeIds, e.id), delete this.forest.selectedNodeMap[e.id];
+    },
+    removeLastValue() {
+      if (!this.hasValue)
+        return;
+      if (this.single)
+        return this.clear();
+      const e = Z(this.internalValue), t = this.getNode(e);
+      this.select(t);
+    },
+    saveMenuScrollPosition() {
+      const e = this.getMenu();
+      e && (this.menu.lastScrollPosition = e.scrollTop);
+    },
+    restoreMenuScrollPosition() {
+      const e = this.getMenu();
+      e && (e.scrollTop = this.menu.lastScrollPosition);
+    }
+  },
+  created() {
+    this.verifyProps(), this.resetFlags();
+  },
+  mounted() {
+    this.autoFocus && this.focusInput(), !this.options && !this.async && this.autoLoadRootOptions && this.loadRootOptions(), this.alwaysOpen && this.openMenu(), this.async && this.defaultOptions && this.handleRemoteSearch();
+  },
+  destroyed() {
+    this.toggleClickOutsideEvent(!1);
+  }
+};
+function pt(e) {
+  return typeof e == "string" ? e : e != null && !$e(e) ? JSON.stringify(e) : "";
+}
+const ft = {
+  name: "VueTreeSelectHiddenFields",
+  functional: !0,
+  inject: ["instance"],
+  render(e, t) {
+    const s = arguments[0], {
+      instance: n
+    } = t.injections;
+    if (!n.name || n.disabled || !n.hasValue)
+      return null;
+    let i = n.internalValue.map(pt);
+    return n.multiple && n.joinValues && (i = [i.join(n.delimiter)]), i.map((o, r) => s("input", {
+      attrs: {
+        type: "hidden",
+        name: n.name
+      },
+      domProps: {
+        value: o
+      },
+      key: `hidden-field-${r}`
+    }));
+  }
+};
+let mt, gt;
+const oe = {};
+var _t = /* @__PURE__ */ f(
+  ft,
+  mt,
+  gt,
+  !1,
+  vt,
+  null,
+  null,
+  null
+);
+function vt(e) {
+  for (let t in oe)
+    this[t] = oe[t];
+}
+const St = /* @__PURE__ */ function() {
+  return _t.exports;
+}();
+function Ot(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+function Y() {
+  return Y = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t, s = 1; s < arguments.length; s++)
+      for (var n in t = arguments[s], t)
+        Object.prototype.hasOwnProperty.call(t, n) && (e[n] = t[n]);
+    return e;
+  }, Y.apply(this, arguments);
+}
+var yt = ["attrs", "props", "domProps"], Et = ["class", "style", "directives"], Nt = ["on", "nativeOn"], bt = function(e) {
+  return e.reduce(function(t, s) {
+    for (var n in s)
+      if (!t[n])
+        t[n] = s[n];
+      else if (yt.indexOf(n) !== -1)
+        t[n] = Y({}, t[n], s[n]);
+      else if (Et.indexOf(n) !== -1) {
+        var i = t[n] instanceof Array ? t[n] : [t[n]], o = s[n] instanceof Array ? s[n] : [s[n]];
+        t[n] = [].concat(i, o);
+      } else if (Nt.indexOf(n) !== -1)
+        for (var r in s[n])
+          if (t[n][r]) {
+            var c = t[n][r] instanceof Array ? t[n][r] : [t[n][r]], d = s[n][r] instanceof Array ? s[n][r] : [s[n][r]];
+            t[n][r] = [].concat(c, d);
+          } else
+            t[n][r] = s[n][r];
+      else if (n === "hook")
+        for (var a in s[n])
+          t[n][a] = t[n][a] ? $t(t[n][a], s[n][a]) : s[n][a];
+      else
+        t[n] = s[n];
+    return t;
+  }, {});
+}, $t = function(e, t) {
+  return function() {
+    e && e.apply(this, arguments), t && t.apply(this, arguments);
+  };
+}, wt = bt;
+const D = /* @__PURE__ */ Ot(wt), Ct = [h.ENTER, h.END, h.HOME, h.ARROW_LEFT, h.ARROW_UP, h.ARROW_RIGHT, h.ARROW_DOWN], Lt = {
+  name: "VueTreeSelectInput",
+  inject: ["instance"],
+  data: () => ({
+    inputWidth: ne,
+    value: ""
+  }),
+  computed: {
+    needAutoSize() {
+      const {
+        instance: e
+      } = this;
+      return e.searchable && !e.disabled && e.multiple;
+    },
+    inputStyle() {
+      return {
+        width: this.needAutoSize ? `${this.inputWidth}px` : null
+      };
+    }
+  },
+  watch: {
+    "instance.trigger.searchQuery"(e) {
+      this.value = e;
+    },
+    value() {
+      this.needAutoSize && this.$nextTick(this.updateInputWidth);
+    }
+  },
+  created() {
+    this.debouncedCallback = qe(this.updateSearchQuery, at, {
+      leading: !0,
+      trailing: !0
+    });
+  },
+  methods: {
+    clear() {
+      this.onInput({
+        target: {
+          value: ""
+        }
+      });
+    },
+    focus() {
+      const {
+        instance: e
+      } = this;
+      e.disabled || this.$refs.input && this.$refs.input.focus();
+    },
+    blur() {
+      this.$refs.input && this.$refs.input.blur();
+    },
+    onFocus() {
+      const {
+        instance: e
+      } = this;
+      e.trigger.isFocused = !0, e.openOnFocus && e.openMenu();
+    },
+    onBlur() {
+      const {
+        instance: e
+      } = this, t = e.getMenu();
+      if (t && document.activeElement === t)
+        return this.focus();
+      e.trigger.isFocused = !1, e.closeMenu();
+    },
+    onInput(e) {
+      const {
+        value: t
+      } = e.target;
+      this.value = t, t ? this.debouncedCallback() : (this.debouncedCallback.cancel(), this.updateSearchQuery());
+    },
+    // 用 keyUp 事件存在一个问题，删除输入框最后一个字符也会导致取消选中最后一项
+    onKeyDown(e) {
+      const {
+        instance: t
+      } = this, s = "which" in e ? e.which : (
+        /* istanbul ignore next */
+        e.keyCode
+      );
+      if (!(e.ctrlKey || e.shiftKey || e.altKey || e.metaKey)) {
+        if (!t.menu.isOpen && O(Ct, s))
+          return e.preventDefault(), t.openMenu();
+        switch (s) {
+          case h.BACKSPACE: {
+            t.backspaceRemoves && !this.value.length && t.removeLastValue();
+            break;
+          }
+          case h.ENTER: {
+            if (e.preventDefault(), t.menu.current === null)
+              return;
+            const n = t.getNode(t.menu.current);
+            if (n.isBranch && t.disableBranchNodes)
+              return;
+            t.select(n);
+            break;
+          }
+          case h.ESCAPE: {
+            this.value.length ? this.clear() : t.menu.isOpen && t.closeMenu();
+            break;
+          }
+          case h.END: {
+            e.preventDefault(), t.highlightLastOption();
+            break;
+          }
+          case h.HOME: {
+            e.preventDefault(), t.highlightFirstOption();
+            break;
+          }
+          case h.ARROW_LEFT: {
+            const n = t.getNode(t.menu.current);
+            n.isBranch && t.shouldExpand(n) ? (e.preventDefault(), t.toggleExpanded(n)) : !n.isRootNode && (n.isLeaf || n.isBranch && !t.shouldExpand(n)) && (e.preventDefault(), t.setCurrentHighlightedOption(n.parentNode));
+            break;
+          }
+          case h.ARROW_UP: {
+            e.preventDefault(), t.highlightPrevOption();
+            break;
+          }
+          case h.ARROW_RIGHT: {
+            const n = t.getNode(t.menu.current);
+            n.isBranch && !t.shouldExpand(n) && (e.preventDefault(), t.toggleExpanded(n));
+            break;
+          }
+          case h.ARROW_DOWN: {
+            e.preventDefault(), t.highlightNextOption();
+            break;
+          }
+          case h.DELETE: {
+            t.deleteRemoves && !this.value.length && t.removeLastValue();
+            break;
+          }
+          default:
+            t.openMenu();
+        }
+      }
+    },
+    onMouseDown(e) {
+      this.value.length && e.stopPropagation();
+    },
+    renderInputContainer() {
+      const e = this.$createElement, {
+        instance: t
+      } = this, s = {}, n = [];
+      return t.searchable && !t.disabled && (n.push(this.renderInput()), this.needAutoSize && n.push(this.renderSizer())), t.searchable || q(s, {
+        on: {
+          focus: this.onFocus,
+          blur: this.onBlur,
+          keydown: this.onKeyDown
+        },
+        ref: "input"
+      }), !t.searchable && !t.disabled && q(s, {
+        attrs: {
+          tabIndex: t.tabIndex
+        }
+      }), e("div", D([{
+        class: "vue-treeselect__input-container"
+      }, s]), [n]);
+    },
+    renderInput() {
+      const e = this.$createElement, {
+        instance: t
+      } = this;
+      return e("input", {
+        ref: "input",
+        class: "vue-treeselect__input",
+        attrs: {
+          type: "text",
+          autocomplete: "off",
+          tabIndex: t.tabIndex,
+          required: t.required && !t.hasValue
+        },
+        domProps: {
+          value: this.value
+        },
+        style: this.inputStyle,
+        on: {
+          focus: this.onFocus,
+          input: this.onInput,
+          blur: this.onBlur,
+          keydown: this.onKeyDown,
+          mousedown: this.onMouseDown
+        }
+      });
+    },
+    renderSizer() {
+      const e = this.$createElement;
+      return e("div", {
+        ref: "sizer",
+        class: "vue-treeselect__sizer"
+      }, [this.value]);
+    },
+    updateInputWidth() {
+      this.inputWidth = Math.max(ne, this.$refs.sizer.scrollWidth + 15);
+    },
+    updateSearchQuery() {
+      const {
+        instance: e
+      } = this;
+      e.trigger.searchQuery = this.value;
+    }
+  },
+  render() {
+    return this.renderInputContainer();
+  }
+};
+let Mt, xt;
+const le = {};
+var Tt = /* @__PURE__ */ f(
+  Lt,
+  Mt,
+  xt,
+  !1,
+  Dt,
+  null,
+  null,
+  null
+);
+function Dt(e) {
+  for (let t in le)
+    this[t] = le[t];
+}
+const Te = /* @__PURE__ */ function() {
+  return Tt.exports;
+}(), Rt = {
+  name: "VueTreeSelectPlaceholder",
+  inject: ["instance"],
+  render() {
+    const e = arguments[0], {
+      instance: t
+    } = this, s = {
+      "vue-treeselect__placeholder": !0,
+      "vue-treeselect-helper-zoom-effect-off": !0,
+      "vue-treeselect-helper-hide": t.hasValue || t.trigger.searchQuery
+    };
+    return e("div", {
+      class: s
+    }, [t.placeholder]);
+  }
+};
+let It, At;
+const ae = {};
+var Vt = /* @__PURE__ */ f(
+  Rt,
+  It,
+  At,
+  !1,
+  Bt,
+  null,
+  null,
+  null
+);
+function Bt(e) {
+  for (let t in ae)
+    this[t] = ae[t];
+}
+const De = /* @__PURE__ */ function() {
+  return Vt.exports;
+}(), zt = {
+  name: "VueTreeSelectSingleValue",
+  inject: ["instance"],
+  methods: {
+    renderSingleValueLabel() {
+      const {
+        instance: e
+      } = this, t = e.selectedNodes[0], s = e.$scopedSlots["value-label"];
+      return s ? s({
+        node: t
+      }) : t.label;
+    }
+  },
+  render() {
+    const e = arguments[0], {
+      instance: t,
+      $parent: {
+        renderValueContainer: s
+      }
+    } = this, n = t.hasValue && !t.trigger.searchQuery;
+    return s([n && e("div", {
+      class: "vue-treeselect__single-value"
+    }, [this.renderSingleValueLabel()]), e(De), e(Te, {
+      ref: "input"
+    })]);
+  }
+};
+let Ft, kt;
+const ce = {};
+var Ht = /* @__PURE__ */ f(
+  zt,
+  Ft,
+  kt,
+  !1,
+  Pt,
+  null,
+  null,
+  null
+);
+function Pt(e) {
+  for (let t in ce)
+    this[t] = ce[t];
+}
+const Wt = /* @__PURE__ */ function() {
+  return Ht.exports;
+}();
+var jt = function() {
+  var e = this, t = e.$createElement, s = e._self._c || t;
+  return s("svg", {
+    attrs: {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 348.333 348.333"
+    }
+  }, [s("path", {
+    attrs: {
+      d: "M336.559 68.611L231.016 174.165l105.543 105.549c15.699 15.705 15.699 41.145 0 56.85-7.844 7.844-18.128 11.769-28.407 11.769-10.296 0-20.581-3.919-28.419-11.769L174.167 231.003 68.609 336.563c-7.843 7.844-18.128 11.769-28.416 11.769-10.285 0-20.563-3.919-28.413-11.769-15.699-15.698-15.699-41.139 0-56.85l105.54-105.549L11.774 68.611c-15.699-15.699-15.699-41.145 0-56.844 15.696-15.687 41.127-15.687 56.829 0l105.563 105.554L279.721 11.767c15.705-15.687 41.139-15.687 56.832 0 15.705 15.699 15.705 41.145.006 56.844z"
+    }
+  })]);
+}, Qt = [];
+const Kt = {
+  name: "VueTreeSelectDelete"
+}, ue = {};
+var qt = /* @__PURE__ */ f(
+  Kt,
+  jt,
+  Qt,
+  !1,
+  Ut,
+  null,
+  null,
+  null
+);
+function Ut(e) {
+  for (let t in ue)
+    this[t] = ue[t];
+}
+const Re = /* @__PURE__ */ function() {
+  return qt.exports;
+}(), Yt = {
+  name: "VueTreeSelectMultiValueItem",
+  inject: ["instance"],
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    }
+  },
+  methods: {
+    handleMouseDown: N(function() {
+      const {
+        instance: t,
+        node: s
+      } = this;
+      t.select(s);
+    })
+  },
+  render() {
+    const e = arguments[0], {
+      instance: t,
+      node: s
+    } = this, n = {
+      "vue-treeselect__multi-value-item": !0,
+      "vue-treeselect__multi-value-item-disabled": s.isDisabled,
+      "vue-treeselect__multi-value-item-new": s.isNew
+    }, i = t.$scopedSlots["value-label"], o = i ? i({
+      node: s
+    }) : s.label;
+    return e("div", {
+      class: "vue-treeselect__multi-value-item-container"
+    }, [e("div", {
+      class: n,
+      on: {
+        mousedown: this.handleMouseDown
+      }
+    }, [e("span", {
+      class: "vue-treeselect__multi-value-label"
+    }, [o]), e("span", {
+      class: "vue-treeselect__icon vue-treeselect__value-remove"
+    }, [e(Re)])])]);
+  }
+};
+let Xt, Gt;
+const he = {};
+var Jt = /* @__PURE__ */ f(
+  Yt,
+  Xt,
+  Gt,
+  !1,
+  Zt,
+  null,
+  null,
+  null
+);
+function Zt(e) {
+  for (let t in he)
+    this[t] = he[t];
+}
+const es = /* @__PURE__ */ function() {
+  return Jt.exports;
+}(), ts = {
+  name: "VueTreeSelectMultiValue",
+  inject: ["instance"],
+  methods: {
+    renderMultiValueItems() {
+      const e = this.$createElement, {
+        instance: t
+      } = this;
+      return t.internalValue.slice(0, t.limit).map(t.getNode).map((s) => e(es, {
+        key: `multi-value-item-${s.id}`,
+        attrs: {
+          node: s
+        }
+      }));
+    },
+    renderExceedLimitTip() {
+      const e = this.$createElement, {
+        instance: t
+      } = this, s = t.internalValue.length - t.limit;
+      return s <= 0 ? null : e("div", {
+        class: "vue-treeselect__limit-tip vue-treeselect-helper-zoom-effect-off",
+        key: "exceed-limit-tip"
+      }, [e("span", {
+        class: "vue-treeselect__limit-tip-text"
+      }, [t.limitText(s)])]);
+    }
+  },
+  render() {
+    const e = arguments[0], {
+      renderValueContainer: t
+    } = this.$parent;
+    return t(e("transition-group", D([{
+      class: "vue-treeselect__multi-value"
+    }, {
+      props: {
+        tag: "div",
+        name: "vue-treeselect__multi-value-item--transition",
+        appear: !0
+      }
+    }]), [this.renderMultiValueItems(), this.renderExceedLimitTip(), e(De, {
+      key: "placeholder"
+    }), e(Te, {
+      ref: "input",
+      key: "input"
+    })]));
+  }
+};
+let ss, ns;
+const de = {};
+var is = /* @__PURE__ */ f(
+  ts,
+  ss,
+  ns,
+  !1,
+  rs,
+  null,
+  null,
+  null
+);
+function rs(e) {
+  for (let t in de)
+    this[t] = de[t];
+}
+const os = /* @__PURE__ */ function() {
+  return is.exports;
+}();
+var ls = function() {
+  var e = this, t = e.$createElement, s = e._self._c || t;
+  return s("svg", {
+    attrs: {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 292.362 292.362"
+    }
+  }, [s("path", {
+    attrs: {
+      d: "M286.935 69.377c-3.614-3.617-7.898-5.424-12.848-5.424H18.274c-4.952 0-9.233 1.807-12.85 5.424C1.807 72.998 0 77.279 0 82.228c0 4.948 1.807 9.229 5.424 12.847l127.907 127.907c3.621 3.617 7.902 5.428 12.85 5.428s9.233-1.811 12.847-5.428L286.935 95.074c3.613-3.617 5.427-7.898 5.427-12.847 0-4.948-1.814-9.229-5.427-12.85z"
+    }
+  })]);
+}, as = [];
+const cs = {
+  name: "VueTreeSelectArrow"
+}, pe = {};
+var us = /* @__PURE__ */ f(
+  cs,
+  ls,
+  as,
+  !1,
+  hs,
+  null,
+  null,
+  null
+);
+function hs(e) {
+  for (let t in pe)
+    this[t] = pe[t];
+}
+const Ie = /* @__PURE__ */ function() {
+  return us.exports;
+}(), ds = {
+  name: "VueTreeSelectControl",
+  inject: ["instance"],
+  computed: {
+    /* eslint-disable valid-jsdoc */
+    /**
+     * Should show the "×" button that resets value?
+     * @return {boolean}
+     */
+    shouldShowX() {
+      const {
+        instance: e
+      } = this;
+      return e.clearable && !e.disabled && e.hasValue && (this.hasUndisabledValue || e.allowClearingDisabled);
+    },
+    /**
+     * Should show the arrow button that toggles menu?
+     * @return {boolean}
+     */
+    shouldShowArrow() {
+      const {
+        instance: e
+      } = this;
+      return e.alwaysOpen ? !e.menu.isOpen : !0;
+    },
+    /**
+     * Has any undisabled option been selected?
+     * @type {boolean}
+     */
+    hasUndisabledValue() {
+      const {
+        instance: e
+      } = this;
+      return e.hasValue && e.internalValue.some((t) => !e.getNode(t).isDisabled);
+    }
+    /* eslint-enable valid-jsdoc */
+  },
+  methods: {
+    renderX() {
+      const e = this.$createElement, {
+        instance: t
+      } = this, s = t.multiple ? t.clearAllText : t.clearValueText;
+      return this.shouldShowX ? e("div", {
+        class: "vue-treeselect__x-container",
+        attrs: {
+          title: s
+        },
+        on: {
+          mousedown: this.handleMouseDownOnX
+        }
+      }, [e(Re, {
+        class: "vue-treeselect__x"
+      })]) : null;
+    },
+    renderArrow() {
+      const e = this.$createElement, {
+        instance: t
+      } = this, s = {
+        "vue-treeselect__control-arrow": !0,
+        "vue-treeselect__control-arrow--rotated": t.menu.isOpen
+      };
+      return this.shouldShowArrow ? e("div", {
+        class: "vue-treeselect__control-arrow-container",
+        on: {
+          mousedown: this.handleMouseDownOnArrow
+        }
+      }, [e(Ie, {
+        class: s
+      })]) : null;
+    },
+    handleMouseDownOnX: N(function(t) {
+      t.stopPropagation(), t.preventDefault();
+      const {
+        instance: s
+      } = this, n = s.beforeClearAll(), i = (o) => {
+        o && s.clear();
+      };
+      Oe(n) ? n.then(i) : setTimeout(() => i(n), 0);
+    }),
+    handleMouseDownOnArrow: N(function(t) {
+      t.preventDefault(), t.stopPropagation();
+      const {
+        instance: s
+      } = this;
+      s.focusInput(), s.toggleMenu();
+    }),
+    // This is meant to be called by child `<Value />` component.
+    renderValueContainer(e) {
+      const t = this.$createElement;
+      return t("div", {
+        class: "vue-treeselect__value-container"
+      }, [e]);
+    }
+  },
+  render() {
+    const e = arguments[0], {
+      instance: t
+    } = this, s = t.single ? Wt : os;
+    return e("div", {
+      class: "vue-treeselect__control",
+      on: {
+        mousedown: t.handleMouseDown
+      }
+    }, [e(s, {
+      ref: "value-container"
+    }), this.renderX(), this.renderArrow()]);
+  }
+};
+let ps, fs;
+const fe = {};
+var ms = /* @__PURE__ */ f(
+  ds,
+  ps,
+  fs,
+  !1,
+  gs,
+  null,
+  null,
+  null
+);
+function gs(e) {
+  for (let t in fe)
+    this[t] = fe[t];
+}
+const _s = /* @__PURE__ */ function() {
+  return ms.exports;
+}(), vs = {
+  name: "VueTreeSelectTip",
+  functional: !0,
+  props: {
+    type: {
+      type: String,
+      required: !0
+    },
+    icon: {
+      type: String,
+      required: !0
+    }
+  },
+  render(e, t) {
+    const s = arguments[0], {
+      props: n,
+      children: i
+    } = t;
+    return s("div", {
+      class: `vue-treeselect__tip vue-treeselect__${n.type}-tip`
+    }, [s("div", {
+      class: "vue-treeselect__icon-container"
+    }, [s("span", {
+      class: `vue-treeselect__icon-${n.icon}`
+    })]), s("span", {
+      class: `vue-treeselect__tip-text vue-treeselect__${n.type}-tip-text`
+    }, [i])]);
+  }
+};
+let Ss, Os;
+const me = {};
+var ys = /* @__PURE__ */ f(
+  vs,
+  Ss,
+  Os,
+  !1,
+  Es,
+  null,
+  null,
+  null
+);
+function Es(e) {
+  for (let t in me)
+    this[t] = me[t];
+}
+const v = /* @__PURE__ */ function() {
+  return ys.exports;
+}();
+let P, W, j;
+const Ae = {
+  name: "VueTreeSelectOption",
+  inject: ["instance"],
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    }
+  },
+  computed: {
+    shouldExpand() {
+      const {
+        instance: e,
+        node: t
+      } = this;
+      return t.isBranch && e.shouldExpand(t);
+    },
+    shouldShow() {
+      const {
+        instance: e,
+        node: t
+      } = this;
+      return e.shouldShowOptionInMenu(t);
+    }
+  },
+  methods: {
+    renderOption() {
+      const e = this.$createElement, {
+        instance: t,
+        node: s
+      } = this, n = {
+        "vue-treeselect__option": !0,
+        "vue-treeselect__option--disabled": s.isDisabled,
+        "vue-treeselect__option--selected": t.isSelected(s),
+        "vue-treeselect__option--highlight": s.isHighlighted,
+        "vue-treeselect__option--matched": t.localSearch.active && s.isMatched,
+        "vue-treeselect__option--hide": !this.shouldShow
+      };
+      return e("div", {
+        class: n,
+        on: {
+          mouseenter: this.handleMouseEnterOption
+        },
+        attrs: {
+          "data-id": s.id
+        }
+      }, [this.renderArrow(), this.renderLabelContainer([this.renderCheckboxContainer([this.renderCheckbox()]), this.renderLabel()])]);
+    },
+    renderSubOptionsList() {
+      const e = this.$createElement;
+      return this.shouldExpand ? e("div", {
+        class: "vue-treeselect__list"
+      }, [this.renderSubOptions(), this.renderNoChildrenTip(), this.renderLoadingChildrenTip(), this.renderLoadingChildrenErrorTip()]) : null;
+    },
+    renderArrow() {
+      const e = this.$createElement, {
+        instance: t,
+        node: s
+      } = this;
+      if (t.shouldFlattenOptions && this.shouldShow)
+        return null;
+      if (s.isBranch) {
+        const n = {
+          props: {
+            name: "vue-treeselect__option-arrow--prepare",
+            appear: !0
+          }
+        }, i = {
+          "vue-treeselect__option-arrow": !0,
+          "vue-treeselect__option-arrow--rotated": this.shouldExpand
+        };
+        return e("div", {
+          class: "vue-treeselect__option-arrow-container",
+          on: {
+            mousedown: this.handleMouseDownOnArrow
+          }
+        }, [e("transition", D([{}, n]), [e(Ie, {
+          class: i
+        })])]);
+      }
+      return (
+        /* node.isLeaf && */
+        t.hasBranchNodes ? (P || (P = e("div", {
+          class: "vue-treeselect__option-arrow-placeholder"
+        }, [" "])), P) : null
+      );
+    },
+    renderLabelContainer(e) {
+      const t = this.$createElement;
+      return t("div", {
+        class: "vue-treeselect__label-container",
+        on: {
+          mousedown: this.handleMouseDownOnLabelContainer
+        }
+      }, [e]);
+    },
+    renderCheckboxContainer(e) {
+      const t = this.$createElement, {
+        instance: s,
+        node: n
+      } = this;
+      return s.single || s.disableBranchNodes && n.isBranch ? null : t("div", {
+        class: "vue-treeselect__checkbox-container"
+      }, [e]);
+    },
+    renderCheckbox() {
+      const e = this.$createElement, {
+        instance: t,
+        node: s
+      } = this, n = t.forest.checkedStateMap[s.id], i = {
+        "vue-treeselect__checkbox": !0,
+        "vue-treeselect__checkbox--checked": n === Me,
+        "vue-treeselect__checkbox--indeterminate": n === Le,
+        "vue-treeselect__checkbox--unchecked": n === U,
+        "vue-treeselect__checkbox--disabled": s.isDisabled
+      };
+      return W || (W = e("span", {
+        class: "vue-treeselect__check-mark"
+      })), j || (j = e("span", {
+        class: "vue-treeselect__minus-mark"
+      })), e("span", {
+        class: i
+      }, [W, j]);
+    },
+    renderLabel() {
+      const e = this.$createElement, {
+        instance: t,
+        node: s
+      } = this, n = s.isBranch && (t.localSearch.active ? t.showCountOnSearchComputed : t.showCount), i = n ? t.localSearch.active ? t.localSearch.countMap[s.id][t.showCountOf] : s.count[t.showCountOf] : NaN, o = "vue-treeselect__label", r = "vue-treeselect__count", c = t.$scopedSlots["option-label"];
+      return c ? c({
+        node: s,
+        shouldShowCount: n,
+        count: i,
+        labelClassName: o,
+        countClassName: r
+      }) : e("label", {
+        class: o
+      }, [s.label, n && e("span", {
+        class: r
+      }, ["(", i, ")"])]);
+    },
+    renderSubOptions() {
+      const e = this.$createElement, {
+        node: t
+      } = this;
+      return t.childrenStates.isLoaded ? t.children.map((s) => e(Ae, {
+        attrs: {
+          node: s
+        },
+        key: s.id
+      })) : null;
+    },
+    renderNoChildrenTip() {
+      const e = this.$createElement, {
+        instance: t,
+        node: s
+      } = this;
+      return !s.childrenStates.isLoaded || s.children.length ? null : e(v, {
+        attrs: {
+          type: "no-children",
+          icon: "warning"
+        }
+      }, [t.noChildrenText]);
+    },
+    renderLoadingChildrenTip() {
+      const e = this.$createElement, {
+        instance: t,
+        node: s
+      } = this;
+      return s.childrenStates.isLoading ? e(v, {
+        attrs: {
+          type: "loading",
+          icon: "loader"
+        }
+      }, [t.loadingText]) : null;
+    },
+    renderLoadingChildrenErrorTip() {
+      const e = this.$createElement, {
+        instance: t,
+        node: s
+      } = this;
+      return s.childrenStates.loadingError ? e(v, {
+        attrs: {
+          type: "error",
+          icon: "error"
+        }
+      }, [s.childrenStates.loadingError, e("a", {
+        class: "vue-treeselect__retry",
+        attrs: {
+          title: t.retryTitle
+        },
+        on: {
+          mousedown: this.handleMouseDownOnRetry
+        }
+      }, [t.retryText])]) : null;
+    },
+    handleMouseEnterOption(e) {
+      const {
+        instance: t,
+        node: s
+      } = this;
+      e.target === e.currentTarget && t.setCurrentHighlightedOption(s, !1);
+    },
+    handleMouseDownOnArrow: N(function() {
+      const {
+        instance: t,
+        node: s
+      } = this;
+      t.toggleExpanded(s);
+    }),
+    handleMouseDownOnLabelContainer: N(function() {
+      const {
+        instance: t,
+        node: s
+      } = this;
+      s.isBranch && t.disableBranchNodes ? t.toggleExpanded(s) : t.select(s);
+    }),
+    handleMouseDownOnRetry: N(function() {
+      const {
+        instance: t,
+        node: s
+      } = this;
+      t.loadChildrenOptions(s);
+    })
+  },
+  render() {
+    const e = arguments[0], {
+      node: t
+    } = this, n = {
+      "vue-treeselect__list-item": !0,
+      [`vue-treeselect__indent-level-${this.instance.shouldFlattenOptions ? 0 : t.level}`]: !0
+    }, i = {
+      props: {
+        name: "vue-treeselect__list--transition"
+      }
+    };
+    return e("div", {
+      class: n
+    }, [this.renderOption(), t.isBranch && e("transition", D([{}, i]), [this.renderSubOptionsList()])]);
+  }
+};
+let Ns, bs;
+const ge = {};
+var $s = /* @__PURE__ */ f(
+  Ae,
+  Ns,
+  bs,
+  !1,
+  ws,
+  null,
+  null,
+  null
+);
+function ws(e) {
+  for (let t in ge)
+    this[t] = ge[t];
+}
+const Cs = /* @__PURE__ */ function() {
+  return $s.exports;
+}(), Ls = {
+  top: "top",
+  bottom: "bottom",
+  above: "top",
+  below: "bottom"
+}, Ms = {
+  name: "VueTreeSelectMenu",
+  inject: ["instance"],
+  computed: {
+    menuStyle() {
+      const {
+        instance: e
+      } = this;
+      return {
+        maxHeight: `${e.maxHeight}px`
+      };
+    },
+    menuContainerStyle() {
+      const {
+        instance: e
+      } = this;
+      return {
+        zIndex: e.appendToBody ? null : e.zIndex
+      };
+    }
+  },
+  watch: {
+    "instance.menu.isOpen"(e) {
+      e ? this.$nextTick(this.onMenuOpen) : this.onMenuClose();
+    }
+  },
+  created() {
+    this.menuSizeWatcher = null, this.menuResizeAndScrollEventListeners = null;
+  },
+  mounted() {
+    const {
+      instance: e
+    } = this;
+    e.menu.isOpen && this.$nextTick(this.onMenuOpen);
+  },
+  destroyed() {
+    this.onMenuClose();
+  },
+  methods: {
+    renderMenu() {
+      const e = this.$createElement, {
+        instance: t
+      } = this;
+      return t.menu.isOpen ? e("div", {
+        ref: "menu",
+        class: "vue-treeselect__menu",
+        on: {
+          mousedown: t.handleMouseDown
+        },
+        style: this.menuStyle
+      }, [this.renderBeforeList(), t.async ? this.renderAsyncSearchMenuInner() : t.localSearch.active ? this.renderLocalSearchMenuInner() : this.renderNormalMenuInner(), this.renderAfterList()]) : null;
+    },
+    renderBeforeList() {
+      const {
+        instance: e
+      } = this, t = e.$scopedSlots["before-list"];
+      return t ? t() : null;
+    },
+    renderAfterList() {
+      const {
+        instance: e
+      } = this, t = e.$scopedSlots["after-list"];
+      return t ? t() : null;
+    },
+    renderNormalMenuInner() {
+      const {
+        instance: e
+      } = this;
+      return e.rootOptionsStates.isLoading ? this.renderLoadingOptionsTip() : e.rootOptionsStates.loadingError ? this.renderLoadingRootOptionsErrorTip() : e.rootOptionsStates.isLoaded && e.forest.normalizedOptions.length === 0 ? this.renderNoAvailableOptionsTip() : this.renderOptionList();
+    },
+    renderLocalSearchMenuInner() {
+      const {
+        instance: e
+      } = this;
+      return e.rootOptionsStates.isLoading ? this.renderLoadingOptionsTip() : e.rootOptionsStates.loadingError ? this.renderLoadingRootOptionsErrorTip() : e.rootOptionsStates.isLoaded && e.forest.normalizedOptions.length === 0 ? this.renderNoAvailableOptionsTip() : e.localSearch.noResults ? this.renderNoResultsTip() : this.renderOptionList();
+    },
+    renderAsyncSearchMenuInner() {
+      const {
+        instance: e
+      } = this, t = e.getRemoteSearchEntry(), s = e.trigger.searchQuery === "" && !e.defaultOptions, n = s ? !1 : t.isLoaded && t.options.length === 0;
+      return s ? this.renderSearchPromptTip() : t.isLoading ? this.renderLoadingOptionsTip() : t.loadingError ? this.renderAsyncSearchLoadingErrorTip() : n ? this.renderNoResultsTip() : this.renderOptionList();
+    },
+    renderOptionList() {
+      const e = this.$createElement, {
+        instance: t
+      } = this;
+      return e("div", {
+        class: "vue-treeselect__list"
+      }, [t.forest.normalizedOptions.map((s) => e(Cs, {
+        attrs: {
+          node: s
+        },
+        key: s.id
+      }))]);
+    },
+    renderSearchPromptTip() {
+      const e = this.$createElement, {
+        instance: t
+      } = this;
+      return e(v, {
+        attrs: {
+          type: "search-prompt",
+          icon: "warning"
+        }
+      }, [t.searchPromptText]);
+    },
+    renderLoadingOptionsTip() {
+      const e = this.$createElement, {
+        instance: t
+      } = this;
+      return e(v, {
+        attrs: {
+          type: "loading",
+          icon: "loader"
+        }
+      }, [t.loadingText]);
+    },
+    renderLoadingRootOptionsErrorTip() {
+      const e = this.$createElement, {
+        instance: t
+      } = this;
+      return e(v, {
+        attrs: {
+          type: "error",
+          icon: "error"
+        }
+      }, [t.rootOptionsStates.loadingError, e("a", {
+        class: "vue-treeselect__retry",
+        on: {
+          click: t.loadRootOptions
+        },
+        attrs: {
+          title: t.retryTitle
+        }
+      }, [t.retryText])]);
+    },
+    renderAsyncSearchLoadingErrorTip() {
+      const e = this.$createElement, {
+        instance: t
+      } = this, s = t.getRemoteSearchEntry();
+      return e(v, {
+        attrs: {
+          type: "error",
+          icon: "error"
+        }
+      }, [s.loadingError, e("a", {
+        class: "vue-treeselect__retry",
+        on: {
+          click: t.handleRemoteSearch
+        },
+        attrs: {
+          title: t.retryTitle
+        }
+      }, [t.retryText])]);
+    },
+    renderNoAvailableOptionsTip() {
+      const e = this.$createElement, {
+        instance: t
+      } = this;
+      return e(v, {
+        attrs: {
+          type: "no-options",
+          icon: "warning"
+        }
+      }, [t.noOptionsText]);
+    },
+    renderNoResultsTip() {
+      const e = this.$createElement, {
+        instance: t
+      } = this;
+      return e(v, {
+        attrs: {
+          type: "no-results",
+          icon: "warning"
+        }
+      }, [t.noResultsText]);
+    },
+    onMenuOpen() {
+      this.adjustMenuOpenDirection(), this.setupMenuSizeWatcher(), this.setupMenuResizeAndScrollEventListeners();
+    },
+    onMenuClose() {
+      this.removeMenuSizeWatcher(), this.removeMenuResizeAndScrollEventListeners();
+    },
+    adjustMenuOpenDirection() {
+      const {
+        instance: e
+      } = this;
+      if (!e.menu.isOpen)
+        return;
+      const t = e.getMenu(), s = e.getControl(), n = t.getBoundingClientRect(), i = s.getBoundingClientRect(), o = n.height, r = window.innerHeight, c = i.top, d = window.innerHeight - i.bottom, a = i.top >= 0 && i.top <= r || i.top < 0 && i.bottom > 0, m = d > o + ie, p = c > o + ie;
+      a ? e.openDirection !== "auto" ? e.menu.placement = Ls[e.openDirection] : m || !p ? e.menu.placement = "bottom" : e.menu.placement = "top" : e.closeMenu();
+    },
+    setupMenuSizeWatcher() {
+      const {
+        instance: e
+      } = this, t = e.getMenu();
+      this.menuSizeWatcher || (this.menuSizeWatcher = {
+        remove: Ne(t, this.adjustMenuOpenDirection)
+      });
+    },
+    setupMenuResizeAndScrollEventListeners() {
+      const {
+        instance: e
+      } = this, t = e.getControl();
+      this.menuResizeAndScrollEventListeners || (this.menuResizeAndScrollEventListeners = {
+        remove: be(t, this.adjustMenuOpenDirection)
+      });
+    },
+    removeMenuSizeWatcher() {
+      this.menuSizeWatcher && (this.menuSizeWatcher.remove(), this.menuSizeWatcher = null);
+    },
+    removeMenuResizeAndScrollEventListeners() {
+      this.menuResizeAndScrollEventListeners && (this.menuResizeAndScrollEventListeners.remove(), this.menuResizeAndScrollEventListeners = null);
+    }
+  },
+  render() {
+    const e = arguments[0];
+    return e("div", {
+      ref: "menu-container",
+      class: "vue-treeselect__menu-container",
+      style: this.menuContainerStyle
+    }, [e("transition", {
+      attrs: {
+        name: "vue-treeselect__menu--transition"
+      }
+    }, [this.renderMenu()])]);
+  }
+};
+let xs, Ts;
+const _e = {};
+var Ds = /* @__PURE__ */ f(
+  Ms,
+  xs,
+  Ts,
+  !1,
+  Rs,
+  null,
+  null,
+  null
+);
+function Rs(e) {
+  for (let t in _e)
+    this[t] = _e[t];
+}
+const Ve = /* @__PURE__ */ function() {
+  return Ds.exports;
+}(), Is = {
+  name: "VueTreeSelectPortalTarget",
+  inject: ["instance"],
+  watch: {
+    "instance.menu.isOpen"(e) {
+      e ? this.setupHandlers() : this.removeHandlers();
+    },
+    "instance.menu.placement"() {
+      this.updateMenuContainerOffset();
+    }
+  },
+  created() {
+    this.controlResizeAndScrollEventListeners = null, this.controlSizeWatcher = null;
+  },
+  mounted() {
+    const {
+      instance: e
+    } = this;
+    e.menu.isOpen && this.setupHandlers();
+  },
+  methods: {
+    setupHandlers() {
+      this.updateWidth(), this.updateMenuContainerOffset(), this.setupControlResizeAndScrollEventListeners(), this.setupControlSizeWatcher();
+    },
+    removeHandlers() {
+      this.removeControlResizeAndScrollEventListeners(), this.removeControlSizeWatcher();
+    },
+    setupControlResizeAndScrollEventListeners() {
+      const {
+        instance: e
+      } = this, t = e.getControl();
+      this.controlResizeAndScrollEventListeners || (this.controlResizeAndScrollEventListeners = {
+        remove: be(t, this.updateMenuContainerOffset)
+      });
+    },
+    setupControlSizeWatcher() {
+      const {
+        instance: e
+      } = this, t = e.getControl();
+      this.controlSizeWatcher || (this.controlSizeWatcher = {
+        remove: Ne(t, () => {
+          this.updateWidth(), this.updateMenuContainerOffset();
+        })
+      });
+    },
+    removeControlResizeAndScrollEventListeners() {
+      this.controlResizeAndScrollEventListeners && (this.controlResizeAndScrollEventListeners.remove(), this.controlResizeAndScrollEventListeners = null);
+    },
+    removeControlSizeWatcher() {
+      this.controlSizeWatcher && (this.controlSizeWatcher.remove(), this.controlSizeWatcher = null);
+    },
+    updateWidth() {
+      const {
+        instance: e
+      } = this, t = this.$el, n = e.getControl().getBoundingClientRect();
+      t.style.width = `${n.width}px`;
+    },
+    updateMenuContainerOffset() {
+      const {
+        instance: e
+      } = this, t = e.getControl(), s = this.$el, n = t.getBoundingClientRect(), i = s.getBoundingClientRect(), o = e.menu.placement === "bottom" ? n.height : 0, r = `${Math.round(n.left - i.left)}px`, c = `${Math.round(n.top - i.top + o)}px`, d = this.$refs.menu.$refs["menu-container"].style, m = Ce(["transform", "webkitTransform", "MozTransform", "msTransform"], (p) => p in document.body.style);
+      d[m] = `translate(${r}, ${c})`;
+    }
+  },
+  render() {
+    const e = arguments[0], {
+      instance: t
+    } = this, s = ["vue-treeselect__portal-target", t.wrapperClass], n = {
+      zIndex: t.zIndex
+    };
+    return e("div", {
+      class: s,
+      style: n,
+      attrs: {
+        "data-instance-id": t.getInstanceId()
+      }
+    }, [e(Ve, {
+      ref: "menu"
+    })]);
+  },
+  destroyed() {
+    this.removeHandlers();
+  }
+};
+let Q;
+const As = {
+  name: "VueTreeSelectMenuPortal",
+  created() {
+    this.portalTarget = null;
+  },
+  mounted() {
+    this.setup();
+  },
+  destroyed() {
+    this.teardown();
+  },
+  methods: {
+    setup() {
+      const e = document.createElement("div");
+      document.body.appendChild(e), this.portalTarget = new Ue(_({
+        el: e,
+        parent: this
+      }, Is));
+    },
+    teardown() {
+      document.body.removeChild(this.portalTarget.$el), this.portalTarget.$el.innerHTML = "", this.portalTarget.$destroy(), this.portalTarget = null;
+    }
+  },
+  render() {
+    const e = arguments[0];
+    return Q || (Q = e("div", {
+      class: "vue-treeselect__menu-placeholder"
+    })), Q;
+  }
+};
+let Vs, Bs;
+const ve = {};
+var zs = /* @__PURE__ */ f(
+  As,
+  Vs,
+  Bs,
+  !1,
+  Fs,
+  null,
+  null,
+  null
+);
+function Fs(e) {
+  for (let t in ve)
+    this[t] = ve[t];
+}
+const ks = /* @__PURE__ */ function() {
+  return zs.exports;
+}(), Hs = {
+  name: "VueTreeSelect",
+  mixins: [dt],
+  computed: {
+    wrapperClass() {
+      return {
+        "vue-treeselect": !0,
+        "vue-treeselect--single": this.single,
+        "vue-treeselect--multi": this.multiple,
+        "vue-treeselect--searchable": this.searchable,
+        "vue-treeselect--disabled": this.disabled,
+        "vue-treeselect--focused": this.trigger.isFocused,
+        "vue-treeselect--has-value": this.hasValue,
+        "vue-treeselect--open": this.menu.isOpen,
+        "vue-treeselect--open-above": this.menu.placement === "top",
+        "vue-treeselect--open-below": this.menu.placement === "bottom",
+        "vue-treeselect--branch-nodes-disabled": this.disableBranchNodes,
+        "vue-treeselect--append-to-body": this.appendToBody
+      };
+    }
+  },
+  render() {
+    const e = arguments[0];
+    return e("div", {
+      ref: "wrapper",
+      class: this.wrapperClass
+    }, [e(St), e(_s, {
+      ref: "control"
+    }), this.appendToBody ? e(ks, {
+      ref: "portal"
+    }) : e(Ve, {
+      ref: "menu"
+    })]);
+  }
+};
+let Ps, Ws;
+const Se = {};
+var js = /* @__PURE__ */ f(
+  Hs,
+  Ps,
+  Ws,
+  !1,
+  Qs,
+  null,
+  null,
+  null
+);
+function Qs(e) {
+  for (let t in Se)
+    this[t] = Se[t];
+}
+const Gs = /* @__PURE__ */ function() {
+  return js.exports;
+}();
+export {
+  Gs as default
+};