bitboss-ui 0.0.1

package/dist/bitboss-ui.es.js

@@ -0,0 +1,2409 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { openBlock, createBlock, createVNode, defineComponent, createElementBlock, Fragment, renderList, toDisplayString, normalizeClass, unref, createCommentVNode, computed, renderSlot, toRefs, ref, onMounted, mergeProps, withModifiers, createTextVNode, createElementVNode, getCurrentInstance, watch, nextTick, withCtx, resolveComponent } from "vue";
+function render$1(_ctx, _cache) {
+  return openBlock(), createBlock("svg", {
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 20 20",
+    fill: "currentColor",
+    "aria-hidden": "true"
+  }, [
+    createVNode("path", {
+      "fill-rule": "evenodd",
+      d: "M7.293 14.707a1 1 0 010-1.414L10.586 10 7.293 6.707a1 1 0 011.414-1.414l4 4a1 1 0 010 1.414l-4 4a1 1 0 01-1.414 0z",
+      "clip-rule": "evenodd"
+    })
+  ]);
+}
+const _hoisted_1$6 = { class: "bb-bredcrumbs-container" };
+const _hoisted_2$1 = ["href"];
+const _hoisted_3$1 = {
+  key: 1,
+  class: "bb-bredcrumbs-no-link"
+};
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  __name: "BbBreadcrumbs",
+  props: {
+    breadcrumbs: null,
+    noLinks: { type: Boolean }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$6, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(__props.breadcrumbs, (b, i) => {
+          return openBlock(), createElementBlock("div", {
+            key: i,
+            class: "bb-bredcrumbs-item"
+          }, [
+            i < __props.breadcrumbs.length - 1 && !__props.noLinks ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+              b.href ? (openBlock(), createElementBlock("a", {
+                key: 0,
+                href: b.href,
+                class: "bb-bredcrumbs-link"
+              }, toDisplayString(b.label), 9, _hoisted_2$1)) : (openBlock(), createElementBlock("div", _hoisted_3$1, toDisplayString(b.label), 1))
+            ], 64)) : (openBlock(), createElementBlock("div", {
+              key: 1,
+              class: normalizeClass(["font-bold", {
+                "text-bb-primary": !__props.noLinks
+              }])
+            }, toDisplayString(b.label), 3)),
+            i < __props.breadcrumbs.length - 1 ? (openBlock(), createBlock(unref(render$1), {
+              key: 2,
+              class: "transform-gpu rotate-90 lg:rotate-0 h-4 text-bb-black-500"
+            })) : createCommentVNode("", true)
+          ]);
+        }), 128))
+      ]);
+    };
+  }
+});
+const _hoisted_1$5 = ["checked", "disabled"];
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __name: "BbCheckbox",
+  props: {
+    modelValue: null,
+    checked: { type: [Boolean, Array] },
+    disabled: { type: Boolean }
+  },
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const proxyChecked = computed(() => {
+      if (props.modelValue)
+        return props.modelValue;
+      return props.checked;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("input", {
+        type: "checkbox",
+        checked: unref(proxyChecked),
+        disabled: __props.disabled,
+        onInput: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("update:modelValue", $event.target.checked)),
+        class: "bb-checkbox"
+      }, null, 40, _hoisted_1$5);
+    };
+  }
+});
+const _hoisted_1$4 = ["type"];
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "BbButton",
+  props: {
+    type: null,
+    secondary: { type: Boolean },
+    success: { type: Boolean },
+    warning: { type: Boolean },
+    danger: { type: Boolean },
+    light: { type: Boolean },
+    outline: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const classes = computed(() => ({
+      "bb-btn-primary": !props.secondary && !props.warning && !props.danger && !props.light && !props.outline,
+      "bb-btn-primary-light": !props.secondary && !props.warning && !props.danger && props.light && !props.outline,
+      "bb-btn-primary-outline": !props.secondary && !props.warning && !props.danger && props.outline,
+      "bb-btn-secondary": props.secondary && !props.light && !props.outline,
+      "bb-btn-secondary-light": props.secondary && props.light && !props.outline,
+      "bb-btn-secondary-outline": props.secondary && props.outline,
+      "bb-btn-success": props.success && !props.light && !props.outline,
+      "bb-btn-success-light": props.success && props.light && !props.outline,
+      "bb-btn-success-outline": props.success && props.outline,
+      "bb-btn-warning": props.warning && !props.light && !props.outline,
+      "bb-btn-warning-light": props.warning && props.light && !props.outline,
+      "bb-btn-warning-outline": props.warning && props.outline,
+      "bb-btn-danger": props.danger && !props.light && !props.outline,
+      "bb-btn-danger-light": props.danger && props.light && !props.outline,
+      "bb-btn-danger-outline": props.danger && props.outline
+    }));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        type: __props.type,
+        class: normalizeClass(unref(classes))
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 10, _hoisted_1$4);
+    };
+  }
+});
+const _hoisted_1$3 = ["readonly", "value"];
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "BbInput",
+  props: {
+    modelValue: null,
+    readonly: { type: Boolean }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const { readonly } = toRefs(props);
+    const input = ref(null);
+    const type = ref("text");
+    onMounted(() => {
+      var _a;
+      type.value = (_a = input.value) == null ? void 0 : _a.type;
+      handleBlur();
+    });
+    function handleFocus() {
+      if (type.value == "date")
+        input.value.type = "date";
+    }
+    function handleBlur() {
+      var _a;
+      if (type.value == "date" && !((_a = input.value) == null ? void 0 : _a.value))
+        input.value.type = "text";
+    }
+    function emitValue(event) {
+      let val = event.target.value;
+      if (event.target.type == "number")
+        val = Number(val);
+      emit("update:modelValue", val);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("input", {
+        class: normalizeClass(["bb-input", { readonly: unref(readonly) }]),
+        readonly: unref(readonly),
+        value: __props.modelValue,
+        onInput: emitValue,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        ref_key: "input",
+        ref: input
+      }, null, 42, _hoisted_1$3);
+    };
+  }
+});
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "BbLink",
+  props: {
+    secondary: { type: Boolean },
+    success: { type: Boolean },
+    warning: { type: Boolean },
+    danger: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const classes = {
+      "bb-link-primary": !props.secondary,
+      "bb-link-secondary": props.secondary,
+      "bb-link-success": props.success,
+      "bb-link-warning": props.warning,
+      "bb-link-danger": props.danger
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("a", {
+        class: normalizeClass(classes)
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ]);
+    };
+  }
+});
+const _hoisted_1$2 = ["checked", "disabled"];
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "BbRadio",
+  props: {
+    modelValue: null,
+    checked: { type: [Boolean, Array] },
+    disabled: { type: Boolean }
+  },
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const proxyChecked = computed(() => {
+      if (props.modelValue)
+        return props.modelValue;
+      return props.checked;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("input", {
+        type: "radio",
+        checked: unref(proxyChecked),
+        disabled: __props.disabled,
+        onInput: _cache[0] || (_cache[0] = ($event) => {
+          var _a;
+          return _ctx.$emit("update:modelValue", (_a = $event.target) == null ? void 0 : _a.checked);
+        }),
+        class: "bb-radio"
+      }, null, 40, _hoisted_1$2);
+    };
+  }
+});
+function isNullish(val) {
+  return [null, void 0].indexOf(val) !== -1;
+}
+function useData(props, context, dep) {
+  const { object, valueProp, mode } = toRefs(props);
+  const $this = getCurrentInstance().proxy;
+  const iv = dep.iv;
+  const update = (val) => {
+    iv.value = makeInternal(val);
+    const externalVal = makeExternal(val);
+    context.emit("change", externalVal, $this);
+    context.emit("input", externalVal);
+    context.emit("update:modelValue", externalVal);
+  };
+  const makeExternal = (val) => {
+    if (object.value) {
+      return val;
+    }
+    if (isNullish(val)) {
+      return val;
+    }
+    return !Array.isArray(val) ? val[valueProp.value] : val.map((v) => v[valueProp.value]);
+  };
+  const makeInternal = (val) => {
+    if (isNullish(val)) {
+      return mode.value === "single" ? {} : [];
+    }
+    return val;
+  };
+  return {
+    update
+  };
+}
+function useValue(props, context) {
+  const { value, modelValue, mode, valueProp } = toRefs(props);
+  const iv = ref(mode.value !== "single" ? [] : {});
+  const ev = context.expose !== void 0 ? modelValue : value;
+  const plainValue = computed(() => {
+    return mode.value === "single" ? iv.value[valueProp.value] : iv.value.map((v) => v[valueProp.value]);
+  });
+  const textValue = computed(() => {
+    return mode.value !== "single" ? iv.value.map((v) => v[valueProp.value]).join(",") : iv.value[valueProp.value];
+  });
+  return {
+    iv,
+    internalValue: iv,
+    ev,
+    externalValue: ev,
+    textValue,
+    plainValue
+  };
+}
+function useSearch(props, context, dep) {
+  const { regex } = toRefs(props);
+  const $this = getCurrentInstance().proxy;
+  const isOpen = dep.isOpen;
+  const open = dep.open;
+  const search = ref(null);
+  const input = ref(null);
+  const clearSearch = () => {
+    search.value = "";
+  };
+  const handleSearchInput = (e) => {
+    search.value = e.target.value;
+  };
+  const handleKeypress = (e) => {
+    if (regex && regex.value) {
+      let regexp = regex.value;
+      if (typeof regexp === "string") {
+        regexp = new RegExp(regexp);
+      }
+      if (!e.key.match(regexp)) {
+        e.preventDefault();
+      }
+    }
+  };
+  const handlePaste = (e) => {
+    if (regex && regex.value) {
+      let clipboardData = e.clipboardData || window.clipboardData;
+      let pastedData = clipboardData.getData("Text");
+      let regexp = regex.value;
+      if (typeof regexp === "string") {
+        regexp = new RegExp(regexp);
+      }
+      if (!pastedData.split("").every((c) => !!c.match(regexp))) {
+        e.preventDefault();
+      }
+    }
+    context.emit("paste", e, $this);
+  };
+  watch(search, (val) => {
+    if (!isOpen.value && val) {
+      open();
+    }
+    context.emit("search-change", val, $this);
+  });
+  return {
+    search,
+    input,
+    clearSearch,
+    handleSearchInput,
+    handleKeypress,
+    handlePaste
+  };
+}
+function usePointer$1(props, context, dep) {
+  const { groupSelect, mode, groups, disabledProp } = toRefs(props);
+  const pointer = ref(null);
+  const setPointer = (option) => {
+    if (option === void 0 || option !== null && option[disabledProp.value]) {
+      return;
+    }
+    if (groups.value && option && option.group && (mode.value === "single" || !groupSelect.value)) {
+      return;
+    }
+    pointer.value = option;
+  };
+  const clearPointer = () => {
+    setPointer(null);
+  };
+  return {
+    pointer,
+    setPointer,
+    clearPointer
+  };
+}
+function normalize(str, strict = true) {
+  return strict ? String(str).toLowerCase().trim() : String(str).normalize("NFD").replace(/\p{Diacritic}/gu, "").toLowerCase().trim();
+}
+function isObject(variable) {
+  return Object.prototype.toString.call(variable) === "[object Object]";
+}
+function arraysEqual(array1, array2) {
+  const array2Sorted = array2.slice().sort();
+  return array1.length === array2.length && array1.slice().sort().every(function(value, index2) {
+    return value === array2Sorted[index2];
+  });
+}
+function useOptions(props, context, dep) {
+  const {
+    options,
+    mode,
+    trackBy: trackBy_,
+    limit,
+    hideSelected,
+    createTag,
+    createOption: createOption_,
+    label,
+    appendNewTag,
+    appendNewOption: appendNewOption_,
+    multipleLabel,
+    object,
+    loading,
+    delay,
+    resolveOnLoad,
+    minChars,
+    filterResults,
+    clearOnSearch,
+    clearOnSelect,
+    valueProp,
+    canDeselect,
+    max,
+    strict,
+    closeOnSelect,
+    groups: groupped,
+    reverse,
+    infinite,
+    groupOptions,
+    groupHideEmpty,
+    groupSelect,
+    onCreate,
+    disabledProp,
+    searchStart
+  } = toRefs(props);
+  const $this = getCurrentInstance().proxy;
+  const iv = dep.iv;
+  const ev = dep.ev;
+  const search = dep.search;
+  const clearSearch = dep.clearSearch;
+  const update = dep.update;
+  const pointer = dep.pointer;
+  const clearPointer = dep.clearPointer;
+  const focus = dep.focus;
+  const deactivate = dep.deactivate;
+  const close = dep.close;
+  const ap = ref([]);
+  const ro = ref([]);
+  const resolving = ref(false);
+  const searchWatcher = ref(null);
+  const offset = ref(infinite.value && limit.value === -1 ? 10 : limit.value);
+  const createOption = computed(() => {
+    return createTag.value || createOption_.value || false;
+  });
+  const appendNewOption = computed(() => {
+    if (appendNewTag.value !== void 0) {
+      return appendNewTag.value;
+    } else if (appendNewOption_.value !== void 0) {
+      return appendNewOption_.value;
+    }
+    return true;
+  });
+  const eo = computed(() => {
+    if (groupped.value) {
+      let groups = ro.value || [];
+      let eo2 = [];
+      groups.forEach((group) => {
+        optionsToArray(group[groupOptions.value]).forEach((option) => {
+          eo2.push(Object.assign({}, option, group[disabledProp.value] ? { [disabledProp.value]: true } : {}));
+        });
+      });
+      return eo2;
+    } else {
+      let eo2 = optionsToArray(ro.value || []);
+      if (ap.value.length) {
+        eo2 = eo2.concat(ap.value);
+      }
+      return eo2;
+    }
+  });
+  const fg = computed(() => {
+    if (!groupped.value) {
+      return [];
+    }
+    return filterGroups((ro.value || []).map((group) => {
+      const arrayOptions = optionsToArray(group[groupOptions.value]);
+      return __spreadProps(__spreadValues({}, group), {
+        group: true,
+        [groupOptions.value]: filterOptions(arrayOptions, false).map((o) => Object.assign({}, o, group[disabledProp.value] ? { [disabledProp.value]: true } : {})),
+        __VISIBLE__: filterOptions(arrayOptions).map((o) => Object.assign({}, o, group[disabledProp.value] ? { [disabledProp.value]: true } : {}))
+      });
+    }));
+  });
+  const pfo = computed(() => {
+    let options2 = eo.value;
+    if (reverse.value) {
+      options2 = options2.reverse();
+    }
+    if (createdOption.value.length) {
+      options2 = createdOption.value.concat(options2);
+    }
+    return filterOptions(options2);
+  });
+  const fo = computed(() => {
+    let options2 = pfo.value;
+    if (offset.value > 0) {
+      options2 = options2.slice(0, offset.value);
+    }
+    return options2;
+  });
+  const hasSelected = computed(() => {
+    switch (mode.value) {
+      case "single":
+        return !isNullish(iv.value[valueProp.value]);
+      case "multiple":
+      case "tags":
+        return !isNullish(iv.value) && iv.value.length > 0;
+    }
+  });
+  const multipleLabelText = computed(() => {
+    return multipleLabel !== void 0 && multipleLabel.value !== void 0 ? multipleLabel.value(iv.value, $this) : iv.value && iv.value.length > 1 ? `${iv.value.length} options selected` : `1 option selected`;
+  });
+  const noOptions = computed(() => {
+    return !eo.value.length && !resolving.value && !createdOption.value.length;
+  });
+  const noResults = computed(() => {
+    return eo.value.length > 0 && fo.value.length == 0 && (search.value && groupped.value || !groupped.value);
+  });
+  const createdOption = computed(() => {
+    if (createOption.value === false || !search.value) {
+      return [];
+    }
+    return getOptionByTrackBy(search.value) !== -1 ? [] : [{
+      [valueProp.value]: search.value,
+      [label.value]: search.value,
+      [trackBy.value]: search.value,
+      __CREATE__: true
+    }];
+  });
+  const trackBy = computed(() => {
+    return trackBy_.value || label.value;
+  });
+  const nullValue = computed(() => {
+    switch (mode.value) {
+      case "single":
+        return null;
+      case "multiple":
+      case "tags":
+        return [];
+    }
+  });
+  const busy = computed(() => {
+    return loading.value || resolving.value;
+  });
+  const select = (option) => {
+    if (typeof option !== "object") {
+      option = getOption(option);
+    }
+    switch (mode.value) {
+      case "single":
+        update(option);
+        break;
+      case "multiple":
+      case "tags":
+        update(iv.value.concat(option));
+        break;
+    }
+    context.emit("select", finalValue(option), option, $this);
+  };
+  const deselect = (option) => {
+    if (typeof option !== "object") {
+      option = getOption(option);
+    }
+    switch (mode.value) {
+      case "single":
+        clear();
+        break;
+      case "tags":
+      case "multiple":
+        update(Array.isArray(option) ? iv.value.filter((v) => option.map((o) => o[valueProp.value]).indexOf(v[valueProp.value]) === -1) : iv.value.filter((v) => v[valueProp.value] != option[valueProp.value]));
+        break;
+    }
+    context.emit("deselect", finalValue(option), option, $this);
+  };
+  const finalValue = (option) => {
+    return object.value ? option : option[valueProp.value];
+  };
+  const remove = (option) => {
+    deselect(option);
+  };
+  const handleTagRemove = (option, e) => {
+    if (e.button !== 0) {
+      e.preventDefault();
+      return;
+    }
+    remove(option);
+  };
+  const clear = () => {
+    context.emit("clear", $this);
+    update(nullValue.value);
+  };
+  const isSelected = (option) => {
+    if (option.group !== void 0) {
+      return mode.value === "single" ? false : areAllSelected(option[groupOptions.value]) && option[groupOptions.value].length;
+    }
+    switch (mode.value) {
+      case "single":
+        return !isNullish(iv.value) && iv.value[valueProp.value] == option[valueProp.value];
+      case "tags":
+      case "multiple":
+        return !isNullish(iv.value) && iv.value.map((o) => o[valueProp.value]).indexOf(option[valueProp.value]) !== -1;
+    }
+  };
+  const isDisabled = (option) => {
+    return option[disabledProp.value] === true;
+  };
+  const isMax = () => {
+    if (max === void 0 || max.value === -1 || !hasSelected.value && max.value > 0) {
+      return false;
+    }
+    return iv.value.length >= max.value;
+  };
+  const handleOptionClick = (option) => {
+    if (isDisabled(option)) {
+      return;
+    }
+    if (onCreate && onCreate.value && !isSelected(option) && option.__CREATE__) {
+      option = __spreadValues({}, option);
+      delete option.__CREATE__;
+      option = onCreate.value(option, $this);
+      if (option instanceof Promise) {
+        resolving.value = true;
+        option.then((result) => {
+          resolving.value = false;
+          handleOptionSelect(result);
+        });
+        return;
+      }
+    }
+    handleOptionSelect(option);
+  };
+  const handleOptionSelect = (option) => {
+    if (option.__CREATE__) {
+      option = __spreadValues({}, option);
+      delete option.__CREATE__;
+    }
+    switch (mode.value) {
+      case "single":
+        if (option && isSelected(option)) {
+          if (canDeselect.value) {
+            deselect(option);
+          }
+          return;
+        }
+        if (option) {
+          handleOptionAppend(option);
+        }
+        if (clearOnSelect.value) {
+          clearSearch();
+        }
+        if (closeOnSelect.value) {
+          clearPointer();
+          close();
+        }
+        if (option) {
+          select(option);
+        }
+        break;
+      case "multiple":
+        if (option && isSelected(option)) {
+          deselect(option);
+          return;
+        }
+        if (isMax()) {
+          return;
+        }
+        if (option) {
+          handleOptionAppend(option);
+          select(option);
+        }
+        if (clearOnSelect.value) {
+          clearSearch();
+        }
+        if (hideSelected.value) {
+          clearPointer();
+        }
+        if (closeOnSelect.value) {
+          close();
+        }
+        break;
+      case "tags":
+        if (option && isSelected(option)) {
+          deselect(option);
+          return;
+        }
+        if (isMax()) {
+          return;
+        }
+        if (option) {
+          handleOptionAppend(option);
+        }
+        if (clearOnSelect.value) {
+          clearSearch();
+        }
+        if (option) {
+          select(option);
+        }
+        if (hideSelected.value) {
+          clearPointer();
+        }
+        if (closeOnSelect.value) {
+          close();
+        }
+        break;
+    }
+    if (!closeOnSelect.value) {
+      focus();
+    }
+  };
+  const handleGroupClick = (group) => {
+    if (isDisabled(group) || mode.value === "single" || !groupSelect.value) {
+      return;
+    }
+    switch (mode.value) {
+      case "multiple":
+      case "tags":
+        if (areAllEnabledSelected(group[groupOptions.value])) {
+          deselect(group[groupOptions.value]);
+        } else {
+          select(group[groupOptions.value].filter((o) => iv.value.map((v) => v[valueProp.value]).indexOf(o[valueProp.value]) === -1).filter((o) => !o[disabledProp.value]).filter((o, k) => iv.value.length + 1 + k <= max.value || max.value === -1));
+        }
+        break;
+    }
+    if (closeOnSelect.value) {
+      deactivate();
+    }
+  };
+  const handleOptionAppend = (option) => {
+    if (getOption(option[valueProp.value]) === void 0 && createOption.value) {
+      context.emit("tag", option[valueProp.value], $this);
+      context.emit("option", option[valueProp.value], $this);
+      if (appendNewOption.value) {
+        appendOption(option);
+      }
+      clearSearch();
+    }
+  };
+  const selectAll = () => {
+    if (mode.value === "single") {
+      return;
+    }
+    select(fo.value);
+  };
+  const areAllEnabledSelected = (options2) => {
+    return options2.find((o) => !isSelected(o) && !o[disabledProp.value]) === void 0;
+  };
+  const areAllSelected = (options2) => {
+    return options2.find((o) => !isSelected(o)) === void 0;
+  };
+  const getOption = (val) => {
+    return eo.value[eo.value.map((o) => String(o[valueProp.value])).indexOf(String(val))];
+  };
+  const getOptionByTrackBy = (val, norm) => {
+    return eo.value.map((o) => parseInt(o[trackBy.value]) == o[trackBy.value] ? parseInt(o[trackBy.value]) : o[trackBy.value]).indexOf(parseInt(val) == val ? parseInt(val) : val);
+  };
+  const shouldHideOption = (option) => {
+    return ["tags", "multiple"].indexOf(mode.value) !== -1 && hideSelected.value && isSelected(option);
+  };
+  const appendOption = (option) => {
+    ap.value.push(option);
+  };
+  const filterGroups = (groups) => {
+    return groupHideEmpty.value ? groups.filter((g) => search.value ? g.__VISIBLE__.length : g[groupOptions.value].length) : groups.filter((g) => search.value ? g.__VISIBLE__.length : true);
+  };
+  const filterOptions = (options2, excludeHideSelected = true) => {
+    let fo2 = options2;
+    if (search.value && filterResults.value) {
+      fo2 = fo2.filter((option) => {
+        return searchStart.value ? normalize(option[trackBy.value], strict.value).startsWith(normalize(search.value, strict.value)) : normalize(option[trackBy.value], strict.value).indexOf(normalize(search.value, strict.value)) !== -1;
+      });
+    }
+    if (hideSelected.value && excludeHideSelected) {
+      fo2 = fo2.filter((option) => !shouldHideOption(option));
+    }
+    return fo2;
+  };
+  const optionsToArray = (options2) => {
+    let uo = options2;
+    if (isObject(uo)) {
+      uo = Object.keys(uo).map((key) => {
+        let val = uo[key];
+        return { [valueProp.value]: key, [trackBy.value]: val, [label.value]: val };
+      });
+    }
+    uo = uo.map((val) => {
+      return typeof val === "object" ? val : { [valueProp.value]: val, [trackBy.value]: val, [label.value]: val };
+    });
+    return uo;
+  };
+  const initInternalValue = () => {
+    if (!isNullish(ev.value)) {
+      iv.value = makeInternal(ev.value);
+    }
+  };
+  const resolveOptions = (callback) => {
+    resolving.value = true;
+    return new Promise((resolve, reject) => {
+      options.value(search.value, $this).then((response) => {
+        ro.value = response || [];
+        if (typeof callback == "function") {
+          callback(response);
+        }
+        resolving.value = false;
+      }).catch((e) => {
+        console.error(e);
+        ro.value = [];
+        resolving.value = false;
+      }).finally(() => {
+        resolve();
+      });
+    });
+  };
+  const refreshLabels = () => {
+    if (!hasSelected.value) {
+      return;
+    }
+    if (mode.value === "single") {
+      let option = getOption(iv.value[valueProp.value]);
+      if (option !== void 0) {
+        let newLabel = option[label.value];
+        iv.value[label.value] = newLabel;
+        if (object.value) {
+          ev.value[label.value] = newLabel;
+        }
+      }
+    } else {
+      iv.value.forEach((val, i) => {
+        let option = getOption(iv.value[i][valueProp.value]);
+        if (option !== void 0) {
+          let newLabel = option[label.value];
+          iv.value[i][label.value] = newLabel;
+          if (object.value) {
+            ev.value[i][label.value] = newLabel;
+          }
+        }
+      });
+    }
+  };
+  const refreshOptions = (callback) => {
+    resolveOptions(callback);
+  };
+  const makeInternal = (val) => {
+    if (isNullish(val)) {
+      return mode.value === "single" ? {} : [];
+    }
+    if (object.value) {
+      return val;
+    }
+    return mode.value === "single" ? getOption(val) || {} : val.filter((v) => !!getOption(v)).map((v) => getOption(v));
+  };
+  const initSearchWatcher = () => {
+    searchWatcher.value = watch(search, (query) => {
+      if (query.length < minChars.value || !query && minChars.value !== 0) {
+        return;
+      }
+      resolving.value = true;
+      if (clearOnSearch.value) {
+        ro.value = [];
+      }
+      setTimeout(() => {
+        if (query != search.value) {
+          return;
+        }
+        options.value(search.value, $this).then((response) => {
+          if (query == search.value || !search.value) {
+            ro.value = response;
+            pointer.value = fo.value.filter((o) => o[disabledProp.value] !== true)[0] || null;
+            resolving.value = false;
+          }
+        }).catch((e) => {
+          console.error(e);
+        });
+      }, delay.value);
+    }, { flush: "sync" });
+  };
+  if (mode.value !== "single" && !isNullish(ev.value) && !Array.isArray(ev.value)) {
+    throw new Error(`v-model must be an array when using "${mode.value}" mode`);
+  }
+  if (options && typeof options.value == "function") {
+    if (resolveOnLoad.value) {
+      resolveOptions(initInternalValue);
+    } else if (object.value == true) {
+      initInternalValue();
+    }
+  } else {
+    ro.value = options.value;
+    initInternalValue();
+  }
+  if (delay.value > -1) {
+    initSearchWatcher();
+  }
+  watch(delay, (value, old) => {
+    if (searchWatcher.value) {
+      searchWatcher.value();
+    }
+    if (value >= 0) {
+      initSearchWatcher();
+    }
+  });
+  watch(ev, (newValue) => {
+    if (isNullish(newValue)) {
+      iv.value = makeInternal(newValue);
+      return;
+    }
+    switch (mode.value) {
+      case "single":
+        if (object.value ? newValue[valueProp.value] != iv.value[valueProp.value] : newValue != iv.value[valueProp.value]) {
+          iv.value = makeInternal(newValue);
+        }
+        break;
+      case "multiple":
+      case "tags":
+        if (!arraysEqual(object.value ? newValue.map((o) => o[valueProp.value]) : newValue, iv.value.map((o) => o[valueProp.value]))) {
+          iv.value = makeInternal(newValue);
+        }
+        break;
+    }
+  }, { deep: true });
+  watch(options, (n, o) => {
+    if (typeof props.options === "function") {
+      if (resolveOnLoad.value) {
+        resolveOptions();
+      }
+    } else {
+      ro.value = props.options;
+      if (!Object.keys(iv.value).length) {
+        initInternalValue();
+      }
+      refreshLabels();
+    }
+  });
+  watch(label, refreshLabels);
+  return {
+    pfo,
+    fo,
+    filteredOptions: fo,
+    hasSelected,
+    multipleLabelText,
+    eo,
+    extendedOptions: eo,
+    fg,
+    filteredGroups: fg,
+    noOptions,
+    noResults,
+    resolving,
+    busy,
+    offset,
+    select,
+    deselect,
+    remove,
+    selectAll,
+    clear,
+    isSelected,
+    isDisabled,
+    isMax,
+    getOption,
+    handleOptionClick,
+    handleGroupClick,
+    handleTagRemove,
+    refreshOptions,
+    resolveOptions,
+    refreshLabels
+  };
+}
+function usePointer(props, context, dep) {
+  const {
+    valueProp,
+    showOptions,
+    searchable,
+    groupLabel,
+    groups: groupped,
+    mode,
+    groupSelect,
+    disabledProp
+  } = toRefs(props);
+  const fo = dep.fo;
+  const fg = dep.fg;
+  const handleOptionClick = dep.handleOptionClick;
+  const handleGroupClick = dep.handleGroupClick;
+  const search = dep.search;
+  const pointer = dep.pointer;
+  const setPointer = dep.setPointer;
+  const clearPointer = dep.clearPointer;
+  const multiselect = dep.multiselect;
+  const isOpen = dep.isOpen;
+  const options = computed(() => {
+    return fo.value.filter((o) => !o[disabledProp.value]);
+  });
+  const groups = computed(() => {
+    return fg.value.filter((o) => !o[disabledProp.value]);
+  });
+  const canPointGroups = computed(() => {
+    return mode.value !== "single" && groupSelect.value;
+  });
+  const isPointerGroup = computed(() => {
+    return pointer.value && pointer.value.group;
+  });
+  const currentGroup = computed(() => {
+    return getParentGroup(pointer.value);
+  });
+  const prevGroup = computed(() => {
+    const group = isPointerGroup.value ? pointer.value : getParentGroup(pointer.value);
+    const groupIndex = groups.value.map((g) => g[groupLabel.value]).indexOf(group[groupLabel.value]);
+    let prevGroup2 = groups.value[groupIndex - 1];
+    if (prevGroup2 === void 0) {
+      prevGroup2 = lastGroup.value;
+    }
+    return prevGroup2;
+  });
+  const nextGroup = computed(() => {
+    let nextIndex = groups.value.map((g) => g.label).indexOf(isPointerGroup.value ? pointer.value[groupLabel.value] : getParentGroup(pointer.value)[groupLabel.value]) + 1;
+    if (groups.value.length <= nextIndex) {
+      nextIndex = 0;
+    }
+    return groups.value[nextIndex];
+  });
+  const lastGroup = computed(() => {
+    return [...groups.value].slice(-1)[0];
+  });
+  const currentGroupFirstEnabledOption = computed(() => {
+    return pointer.value.__VISIBLE__.filter((o) => !o[disabledProp.value])[0];
+  });
+  const currentGroupPrevEnabledOption = computed(() => {
+    const options2 = currentGroup.value.__VISIBLE__.filter((o) => !o[disabledProp.value]);
+    return options2[options2.map((o) => o[valueProp.value]).indexOf(pointer.value[valueProp.value]) - 1];
+  });
+  const currentGroupNextEnabledOption = computed(() => {
+    const options2 = getParentGroup(pointer.value).__VISIBLE__.filter((o) => !o[disabledProp.value]);
+    return options2[options2.map((o) => o[valueProp.value]).indexOf(pointer.value[valueProp.value]) + 1];
+  });
+  const prevGroupLastEnabledOption = computed(() => {
+    return [...prevGroup.value.__VISIBLE__.filter((o) => !o[disabledProp.value])].slice(-1)[0];
+  });
+  const lastGroupLastEnabledOption = computed(() => {
+    return [...lastGroup.value.__VISIBLE__.filter((o) => !o[disabledProp.value])].slice(-1)[0];
+  });
+  const isPointed = (option) => {
+    return !!pointer.value && (!option.group && pointer.value[valueProp.value] == option[valueProp.value] || option.group !== void 0 && pointer.value[groupLabel.value] == option[groupLabel.value]) ? true : void 0;
+  };
+  const setPointerFirst = () => {
+    setPointer(options.value[0] || null);
+  };
+  const selectPointer = () => {
+    if (!pointer.value || pointer.value[disabledProp.value] === true) {
+      return;
+    }
+    if (isPointerGroup.value) {
+      handleGroupClick(pointer.value);
+    } else {
+      handleOptionClick(pointer.value);
+    }
+  };
+  const forwardPointer = () => {
+    if (pointer.value === null) {
+      setPointer((groupped.value && canPointGroups.value ? groups.value[0] : options.value[0]) || null);
+    } else if (groupped.value && canPointGroups.value) {
+      let nextPointer = isPointerGroup.value ? currentGroupFirstEnabledOption.value : currentGroupNextEnabledOption.value;
+      if (nextPointer === void 0) {
+        nextPointer = nextGroup.value;
+      }
+      setPointer(nextPointer || null);
+    } else {
+      let next = options.value.map((o) => o[valueProp.value]).indexOf(pointer.value[valueProp.value]) + 1;
+      if (options.value.length <= next) {
+        next = 0;
+      }
+      setPointer(options.value[next] || null);
+    }
+    nextTick(() => {
+      adjustWrapperScrollToPointer();
+    });
+  };
+  const backwardPointer = () => {
+    if (pointer.value === null) {
+      let prevPointer = options.value[options.value.length - 1];
+      if (groupped.value && canPointGroups.value) {
+        prevPointer = lastGroupLastEnabledOption.value;
+        if (prevPointer === void 0) {
+          prevPointer = lastGroup.value;
+        }
+      }
+      setPointer(prevPointer || null);
+    } else if (groupped.value && canPointGroups.value) {
+      let prevPointer = isPointerGroup.value ? prevGroupLastEnabledOption.value : currentGroupPrevEnabledOption.value;
+      if (prevPointer === void 0) {
+        prevPointer = isPointerGroup.value ? prevGroup.value : currentGroup.value;
+      }
+      setPointer(prevPointer || null);
+    } else {
+      let prevIndex = options.value.map((o) => o[valueProp.value]).indexOf(pointer.value[valueProp.value]) - 1;
+      if (prevIndex < 0) {
+        prevIndex = options.value.length - 1;
+      }
+      setPointer(options.value[prevIndex] || null);
+    }
+    nextTick(() => {
+      adjustWrapperScrollToPointer();
+    });
+  };
+  const getParentGroup = (option) => {
+    return groups.value.find((group) => {
+      return group.__VISIBLE__.map((o) => o[valueProp.value]).indexOf(option[valueProp.value]) !== -1;
+    });
+  };
+  const adjustWrapperScrollToPointer = () => {
+    let pointedOption = multiselect.value.querySelector(`[data-pointed]`);
+    if (!pointedOption) {
+      return;
+    }
+    let wrapper = pointedOption.parentElement.parentElement;
+    if (groupped.value) {
+      wrapper = isPointerGroup.value ? pointedOption.parentElement.parentElement.parentElement : pointedOption.parentElement.parentElement.parentElement.parentElement;
+    }
+    if (pointedOption.offsetTop + pointedOption.offsetHeight > wrapper.clientHeight + wrapper.scrollTop) {
+      wrapper.scrollTop = pointedOption.offsetTop + pointedOption.offsetHeight - wrapper.clientHeight;
+    }
+    if (pointedOption.offsetTop < wrapper.scrollTop) {
+      wrapper.scrollTop = pointedOption.offsetTop;
+    }
+  };
+  watch(search, (val) => {
+    if (searchable.value) {
+      if (val.length && showOptions.value) {
+        setPointerFirst();
+      } else {
+        clearPointer();
+      }
+    }
+  });
+  watch(isOpen, (val) => {
+    if (val) {
+      let firstSelected = multiselect.value.querySelectorAll(`[data-selected]`)[0];
+      if (!firstSelected) {
+        return;
+      }
+      let wrapper = firstSelected.parentElement.parentElement;
+      nextTick(() => {
+        if (wrapper.scrollTop > 0) {
+          return;
+        }
+        wrapper.scrollTop = firstSelected.offsetTop;
+      });
+    }
+  });
+  return {
+    pointer,
+    canPointGroups,
+    isPointed,
+    setPointerFirst,
+    selectPointer,
+    forwardPointer,
+    backwardPointer
+  };
+}
+function useDropdown(props, context, dep) {
+  const { disabled } = toRefs(props);
+  const $this = getCurrentInstance().proxy;
+  const isOpen = ref(false);
+  const open = () => {
+    if (isOpen.value || disabled.value) {
+      return;
+    }
+    isOpen.value = true;
+    context.emit("open", $this);
+  };
+  const close = () => {
+    if (!isOpen.value) {
+      return;
+    }
+    isOpen.value = false;
+    context.emit("close", $this);
+  };
+  return {
+    isOpen,
+    open,
+    close
+  };
+}
+function useMultiselect(props, context, dep) {
+  const { searchable, disabled } = toRefs(props);
+  const input = dep.input;
+  const open = dep.open;
+  const close = dep.close;
+  const clearSearch = dep.clearSearch;
+  const isOpen = dep.isOpen;
+  const multiselect = ref(null);
+  const tags = ref(null);
+  const isActive = ref(false);
+  const tabindex = computed(() => {
+    return searchable.value || disabled.value ? -1 : 0;
+  });
+  const blur = () => {
+    if (searchable.value) {
+      input.value.blur();
+    }
+    multiselect.value.blur();
+  };
+  const focus = () => {
+    if (searchable.value && !disabled.value) {
+      input.value.focus();
+    }
+  };
+  const handleFocus = () => {
+    focus();
+  };
+  const activate = () => {
+    if (disabled.value) {
+      return;
+    }
+    isActive.value = true;
+    open();
+  };
+  const deactivate = () => {
+    isActive.value = false;
+    setTimeout(() => {
+      if (!isActive.value) {
+        close();
+        clearSearch();
+      }
+    }, 1);
+  };
+  const handleCaretClick = () => {
+    deactivate();
+    blur();
+  };
+  const handleMousedown = (e) => {
+    if (isOpen.value && (e.target.isEqualNode(multiselect.value) || e.target.isEqualNode(tags.value))) {
+      setTimeout(() => {
+        deactivate();
+      }, 0);
+    } else if (document.activeElement.isEqualNode(multiselect.value) && !isOpen.value) {
+      activate();
+    }
+  };
+  return {
+    multiselect,
+    tags,
+    tabindex,
+    isActive,
+    blur,
+    focus,
+    handleFocus,
+    activate,
+    deactivate,
+    handleCaretClick,
+    handleMousedown
+  };
+}
+function useKeyboard(props, context, dep) {
+  const {
+    mode,
+    addTagOn,
+    openDirection,
+    searchable,
+    showOptions,
+    valueProp,
+    groups: groupped,
+    addOptionOn: addOptionOn_,
+    createTag,
+    createOption: createOption_,
+    reverse
+  } = toRefs(props);
+  const $this = getCurrentInstance().proxy;
+  const iv = dep.iv;
+  const update = dep.update;
+  const search = dep.search;
+  const setPointer = dep.setPointer;
+  const selectPointer = dep.selectPointer;
+  const backwardPointer = dep.backwardPointer;
+  const forwardPointer = dep.forwardPointer;
+  const isOpen = dep.isOpen;
+  const open = dep.open;
+  const blur = dep.blur;
+  const fo = dep.fo;
+  const createOption = computed(() => {
+    return createTag.value || createOption_.value || false;
+  });
+  const addOptionOn = computed(() => {
+    if (addTagOn.value !== void 0) {
+      return addTagOn.value;
+    } else if (addOptionOn_.value !== void 0) {
+      return addOptionOn_.value;
+    }
+    return ["enter"];
+  });
+  const preparePointer = () => {
+    if (mode.value === "tags" && !showOptions.value && createOption.value && searchable.value && !groupped.value) {
+      setPointer(fo.value[fo.value.map((o) => o[valueProp.value]).indexOf(search.value)]);
+    }
+  };
+  const handleKeydown = (e) => {
+    context.emit("keydown", e, $this);
+    switch (e.key) {
+      case "Backspace":
+        if (mode.value === "single") {
+          return;
+        }
+        if (searchable.value && [null, ""].indexOf(search.value) === -1) {
+          return;
+        }
+        if (iv.value.length === 0) {
+          return;
+        }
+        update([...iv.value].slice(0, -1));
+        break;
+      case "Enter":
+        e.preventDefault();
+        if (addOptionOn.value.indexOf("enter") === -1 && createOption.value) {
+          return;
+        }
+        preparePointer();
+        selectPointer();
+        break;
+      case " ":
+        if (!createOption.value && !searchable.value) {
+          e.preventDefault();
+          preparePointer();
+          selectPointer();
+          return;
+        }
+        if (!createOption.value) {
+          return false;
+        }
+        if (addOptionOn.value.indexOf("space") === -1 && createOption.value) {
+          return;
+        }
+        e.preventDefault();
+        preparePointer();
+        selectPointer();
+        break;
+      case "Tab":
+      case ";":
+      case ",":
+        if (addOptionOn.value.indexOf(e.key.toLowerCase()) === -1 || !createOption.value) {
+          return;
+        }
+        preparePointer();
+        selectPointer();
+        e.preventDefault();
+        break;
+      case "Escape":
+        blur();
+        break;
+      case "ArrowUp":
+        e.preventDefault();
+        if (!showOptions.value) {
+          return;
+        }
+        if (!isOpen.value) {
+          open();
+        }
+        backwardPointer();
+        break;
+      case "ArrowDown":
+        e.preventDefault();
+        if (!showOptions.value) {
+          return;
+        }
+        if (!isOpen.value) {
+          open();
+        }
+        forwardPointer();
+        break;
+    }
+  };
+  const handleKeyup = (e) => {
+    context.emit("keyup", e, $this);
+  };
+  return {
+    handleKeydown,
+    handleKeyup,
+    preparePointer
+  };
+}
+function useClasses(props, context, dependencies) {
+  const {
+    classes: classes_,
+    disabled,
+    openDirection,
+    showOptions
+  } = toRefs(props);
+  const isOpen = dependencies.isOpen;
+  const isPointed = dependencies.isPointed;
+  const isSelected = dependencies.isSelected;
+  const isDisabled = dependencies.isDisabled;
+  const isActive = dependencies.isActive;
+  const canPointGroups = dependencies.canPointGroups;
+  const resolving = dependencies.resolving;
+  const fo = dependencies.fo;
+  const classes = computed(() => __spreadValues({
+    container: "multiselect",
+    containerDisabled: "is-disabled",
+    containerOpen: "is-open",
+    containerOpenTop: "is-open-top",
+    containerActive: "is-active",
+    singleLabel: "multiselect-single-label",
+    singleLabelText: "multiselect-single-label-text",
+    multipleLabel: "multiselect-multiple-label",
+    search: "multiselect-search",
+    tags: "multiselect-tags",
+    tag: "multiselect-tag",
+    tagDisabled: "is-disabled",
+    tagRemove: "multiselect-tag-remove",
+    tagRemoveIcon: "multiselect-tag-remove-icon",
+    tagsSearchWrapper: "multiselect-tags-search-wrapper",
+    tagsSearch: "multiselect-tags-search",
+    tagsSearchCopy: "multiselect-tags-search-copy",
+    placeholder: "multiselect-placeholder",
+    caret: "multiselect-caret",
+    caretOpen: "is-open",
+    clear: "multiselect-clear",
+    clearIcon: "multiselect-clear-icon",
+    spinner: "multiselect-spinner",
+    inifinite: "multiselect-inifite",
+    inifiniteSpinner: "multiselect-inifite-spinner",
+    dropdown: "multiselect-dropdown",
+    dropdownTop: "is-top",
+    dropdownHidden: "is-hidden",
+    options: "multiselect-options",
+    optionsTop: "is-top",
+    group: "multiselect-group",
+    groupLabel: "multiselect-group-label",
+    groupLabelPointable: "is-pointable",
+    groupLabelPointed: "is-pointed",
+    groupLabelSelected: "is-selected",
+    groupLabelDisabled: "is-disabled",
+    groupLabelSelectedPointed: "is-selected is-pointed",
+    groupLabelSelectedDisabled: "is-selected is-disabled",
+    groupOptions: "multiselect-group-options",
+    option: "multiselect-option",
+    optionPointed: "is-pointed",
+    optionSelected: "is-selected",
+    optionDisabled: "is-disabled",
+    optionSelectedPointed: "is-selected is-pointed",
+    optionSelectedDisabled: "is-selected is-disabled",
+    noOptions: "multiselect-no-options",
+    noResults: "multiselect-no-results",
+    fakeInput: "multiselect-fake-input",
+    spacer: "multiselect-spacer"
+  }, classes_.value));
+  const showDropdown = computed(() => {
+    return !!(isOpen.value && showOptions.value && (!resolving.value || resolving.value && fo.value.length));
+  });
+  const classList = computed(() => {
+    const c = classes.value;
+    return {
+      container: [c.container].concat(disabled.value ? c.containerDisabled : []).concat(showDropdown.value && openDirection.value === "top" ? c.containerOpenTop : []).concat(showDropdown.value && openDirection.value !== "top" ? c.containerOpen : []).concat(isActive.value ? c.containerActive : []),
+      spacer: c.spacer,
+      singleLabel: c.singleLabel,
+      singleLabelText: c.singleLabelText,
+      multipleLabel: c.multipleLabel,
+      search: c.search,
+      tags: c.tags,
+      tag: [c.tag].concat(disabled.value ? c.tagDisabled : []),
+      tagRemove: c.tagRemove,
+      tagRemoveIcon: c.tagRemoveIcon,
+      tagsSearchWrapper: c.tagsSearchWrapper,
+      tagsSearch: c.tagsSearch,
+      tagsSearchCopy: c.tagsSearchCopy,
+      placeholder: c.placeholder,
+      caret: [c.caret].concat(isOpen.value ? c.caretOpen : []),
+      clear: c.clear,
+      clearIcon: c.clearIcon,
+      spinner: c.spinner,
+      inifinite: c.inifinite,
+      inifiniteSpinner: c.inifiniteSpinner,
+      dropdown: [c.dropdown].concat(openDirection.value === "top" ? c.dropdownTop : []).concat(!isOpen.value || !showOptions.value || !showDropdown.value ? c.dropdownHidden : []),
+      options: [c.options].concat(openDirection.value === "top" ? c.optionsTop : []),
+      group: c.group,
+      groupLabel: (g) => {
+        let groupLabel = [c.groupLabel];
+        if (isPointed(g)) {
+          groupLabel.push(isSelected(g) ? c.groupLabelSelectedPointed : c.groupLabelPointed);
+        } else if (isSelected(g) && canPointGroups.value) {
+          groupLabel.push(isDisabled(g) ? c.groupLabelSelectedDisabled : c.groupLabelSelected);
+        } else if (isDisabled(g)) {
+          groupLabel.push(c.groupLabelDisabled);
+        }
+        if (canPointGroups.value) {
+          groupLabel.push(c.groupLabelPointable);
+        }
+        return groupLabel;
+      },
+      groupOptions: c.groupOptions,
+      option: (o, g) => {
+        let option = [c.option];
+        if (isPointed(o)) {
+          option.push(isSelected(o) ? c.optionSelectedPointed : c.optionPointed);
+        } else if (isSelected(o)) {
+          option.push(isDisabled(o) ? c.optionSelectedDisabled : c.optionSelected);
+        } else if (isDisabled(o) || g && isDisabled(g)) {
+          option.push(c.optionDisabled);
+        }
+        return option;
+      },
+      noOptions: c.noOptions,
+      noResults: c.noResults,
+      fakeInput: c.fakeInput
+    };
+  });
+  return {
+    classList,
+    showDropdown
+  };
+}
+function useScroll$1(props, context, dep) {
+  const {
+    limit,
+    infinite
+  } = toRefs(props);
+  const isOpen = dep.isOpen;
+  const offset = dep.offset;
+  const search = dep.search;
+  const pfo = dep.pfo;
+  const eo = dep.eo;
+  const observer = ref(null);
+  const infiniteLoader = ref(null);
+  const hasMore = computed(() => {
+    return offset.value < pfo.value.length;
+  });
+  const handleIntersectionObserver = (entries) => {
+    const { isIntersecting, target } = entries[0];
+    if (isIntersecting) {
+      const parent = target.offsetParent;
+      const scrollTop = parent.scrollTop;
+      offset.value += limit.value == -1 ? 10 : limit.value;
+      nextTick(() => {
+        parent.scrollTop = scrollTop;
+      });
+    }
+  };
+  const observe = () => {
+    if (isOpen.value && offset.value < pfo.value.length) {
+      observer.value.observe(infiniteLoader.value);
+    } else if (!isOpen.value && observer.value) {
+      observer.value.disconnect();
+    }
+  };
+  watch(isOpen, () => {
+    if (!infinite.value) {
+      return;
+    }
+    observe();
+  });
+  watch(search, () => {
+    if (!infinite.value) {
+      return;
+    }
+    offset.value = limit.value;
+    observe();
+  }, { flush: "post" });
+  watch(eo, () => {
+    if (!infinite.value) {
+      return;
+    }
+    observe();
+  }, { immediate: false, flush: "post" });
+  onMounted(() => {
+    if (window && window.IntersectionObserver) {
+      observer.value = new IntersectionObserver(handleIntersectionObserver);
+    }
+  });
+  return {
+    hasMore,
+    infiniteLoader
+  };
+}
+function useScroll(props, context, dep) {
+  const { placeholder, id, valueProp, label: labelProp, mode, groupLabel } = toRefs(props);
+  const pointer = dep.pointer;
+  const iv = dep.iv;
+  const isSelected = dep.isSelected;
+  const hasSelected = dep.hasSelected;
+  const multipleLabelText = dep.multipleLabelText;
+  const label = ref(null);
+  const ariaOwns = computed(() => {
+    let texts = [];
+    if (id && id.value) {
+      texts.push(id.value);
+    }
+    texts.push("multiselect-options");
+    return texts.join("-");
+  });
+  const ariaActiveDescendant = computed(() => {
+    let texts = [];
+    if (id && id.value) {
+      texts.push(id.value);
+    }
+    texts.push("multiselect-option");
+    if (pointer.value && pointer.value[valueProp.value] !== void 0) {
+      texts.push(pointer.value[valueProp.value]);
+      return texts.join("-");
+    }
+  });
+  const ariaLabel = computed(() => {
+    let texts = [];
+    if (label.value) {
+      texts.push(label.value);
+    }
+    if (placeholder.value && !hasSelected.value) {
+      texts.push(placeholder.value);
+    }
+    if (mode.value === "single" && iv.value && iv.value[labelProp.value] !== void 0) {
+      texts.push(iv.value[labelProp.value]);
+    }
+    if (mode.value === "multiple" && hasSelected.value) {
+      texts.push(multipleLabelText.value);
+    }
+    if (mode.value === "tags" && hasSelected.value) {
+      texts.push(...iv.value.map((v) => v[labelProp.value]));
+    }
+    return texts.join(", ");
+  });
+  const ariaPlaceholder = computed(() => {
+    return ariaLabel.value;
+  });
+  const ariaOptionId = (option) => {
+    let texts = [];
+    if (id && id.value) {
+      texts.push(id.value);
+    }
+    texts.push("multiselect-option");
+    texts.push(option[valueProp.value]);
+    return texts.join("-");
+  };
+  const ariaOptionLabel = (option) => {
+    let texts = [];
+    if (isSelected(option)) {
+      texts.push("\u2713");
+    }
+    texts.push(option[labelProp.value]);
+    return texts.join(" ");
+  };
+  const ariaGroupLabel = (group) => {
+    let texts = [];
+    texts.push(group[groupLabel.value]);
+    return texts.join(" ");
+  };
+  onMounted(() => {
+    if (id && id.value && document && document.querySelector) {
+      let forTag = document.querySelector(`[for="${id.value}"]`);
+      label.value = forTag ? forTag.innerText : null;
+    }
+  });
+  return {
+    ariaOwns,
+    ariaLabel,
+    ariaPlaceholder,
+    ariaActiveDescendant,
+    ariaOptionId,
+    ariaOptionLabel,
+    ariaGroupLabel
+  };
+}
+function resolveDeps(props, context, features, deps = {}) {
+  features.forEach((composable) => {
+    if (composable) {
+      deps = __spreadValues(__spreadValues({}, deps), composable(props, context, deps));
+    }
+  });
+  return deps;
+}
+var script = {
+  name: "Multiselect",
+  emits: [
+    "paste",
+    "open",
+    "close",
+    "select",
+    "deselect",
+    "input",
+    "search-change",
+    "tag",
+    "option",
+    "update:modelValue",
+    "change",
+    "clear",
+    "keydown",
+    "keyup"
+  ],
+  props: {
+    value: {
+      required: false
+    },
+    modelValue: {
+      required: false
+    },
+    options: {
+      type: [Array, Object, Function],
+      required: false,
+      default: () => []
+    },
+    id: {
+      type: [String, Number],
+      required: false
+    },
+    name: {
+      type: [String, Number],
+      required: false,
+      default: "multiselect"
+    },
+    disabled: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    label: {
+      type: String,
+      required: false,
+      default: "label"
+    },
+    trackBy: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    valueProp: {
+      type: String,
+      required: false,
+      default: "value"
+    },
+    placeholder: {
+      type: String,
+      required: false,
+      default: null
+    },
+    mode: {
+      type: String,
+      required: false,
+      default: "single"
+    },
+    searchable: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    limit: {
+      type: Number,
+      required: false,
+      default: -1
+    },
+    hideSelected: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    createTag: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    createOption: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    appendNewTag: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    appendNewOption: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    addTagOn: {
+      type: Array,
+      required: false,
+      default: void 0
+    },
+    addOptionOn: {
+      type: Array,
+      required: false,
+      default: void 0
+    },
+    caret: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    loading: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    noOptionsText: {
+      type: String,
+      required: false,
+      default: "The list is empty"
+    },
+    noResultsText: {
+      type: String,
+      required: false,
+      default: "No results found"
+    },
+    multipleLabel: {
+      type: Function,
+      required: false
+    },
+    object: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    delay: {
+      type: Number,
+      required: false,
+      default: -1
+    },
+    minChars: {
+      type: Number,
+      required: false,
+      default: 0
+    },
+    resolveOnLoad: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    filterResults: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    clearOnSearch: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    clearOnSelect: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    canDeselect: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    canClear: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    max: {
+      type: Number,
+      required: false,
+      default: -1
+    },
+    showOptions: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    required: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    openDirection: {
+      type: String,
+      required: false,
+      default: "bottom"
+    },
+    nativeSupport: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    classes: {
+      type: Object,
+      required: false,
+      default: () => ({})
+    },
+    strict: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    closeOnSelect: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    autocomplete: {
+      type: String,
+      required: false
+    },
+    groups: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    groupLabel: {
+      type: String,
+      required: false,
+      default: "label"
+    },
+    groupOptions: {
+      type: String,
+      required: false,
+      default: "options"
+    },
+    groupHideEmpty: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    groupSelect: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    inputType: {
+      type: String,
+      required: false,
+      default: "text"
+    },
+    attrs: {
+      required: false,
+      type: Object,
+      default: () => ({})
+    },
+    onCreate: {
+      required: false,
+      type: Function
+    },
+    disabledProp: {
+      type: String,
+      required: false,
+      default: "disabled"
+    },
+    searchStart: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    reverse: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    regex: {
+      type: [Object, String, RegExp],
+      required: false,
+      default: void 0
+    },
+    rtl: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    infinite: {
+      type: Boolean,
+      required: false,
+      default: false
+    }
+  },
+  setup(props, context) {
+    return resolveDeps(props, context, [
+      useValue,
+      usePointer$1,
+      useDropdown,
+      useSearch,
+      useData,
+      useMultiselect,
+      useOptions,
+      useScroll$1,
+      usePointer,
+      useKeyboard,
+      useClasses,
+      useScroll
+    ]);
+  }
+};
+const _hoisted_1$1 = ["tabindex", "id", "dir", "aria-owns", "aria-expanded", "aria-label", "aria-placeholder", "aria-activedescendant"];
+const _hoisted_2 = ["type", "modelValue", "value", "autocomplete", "id", "aria-owns", "aria-expanded", "aria-label", "aria-placeholder", "aria-activedescendant"];
+const _hoisted_3 = ["onClick"];
+const _hoisted_4 = ["type", "modelValue", "value", "id", "autocomplete", "aria-owns", "aria-expanded", "aria-label", "aria-placeholder", "aria-activedescendant"];
+const _hoisted_5 = ["innerHTML"];
+const _hoisted_6 = ["innerHTML"];
+const _hoisted_7 = ["id"];
+const _hoisted_8 = ["data-pointed", "onMouseenter", "onClick"];
+const _hoisted_9 = ["innerHTML"];
+const _hoisted_10 = ["aria-label"];
+const _hoisted_11 = ["data-pointed", "data-selected", "id", "aria-label", "onMouseenter", "onClick"];
+const _hoisted_12 = ["innerHTML"];
+const _hoisted_13 = ["id", "aria-label", "data-pointed", "data-selected", "onMouseenter", "onClick"];
+const _hoisted_14 = ["innerHTML"];
+const _hoisted_15 = ["innerHTML"];
+const _hoisted_16 = ["innerHTML"];
+const _hoisted_17 = ["value"];
+const _hoisted_18 = ["name", "value"];
+const _hoisted_19 = ["name", "value"];
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", {
+    ref: "multiselect",
+    tabindex: _ctx.tabindex,
+    class: normalizeClass(_ctx.classList.container),
+    id: $props.searchable ? void 0 : $props.id,
+    dir: $props.rtl ? "rtl" : void 0,
+    "aria-owns": _ctx.ariaOwns,
+    "aria-expanded": _ctx.isOpen,
+    "aria-label": _ctx.ariaLabel,
+    "aria-placeholder": _ctx.ariaPlaceholder,
+    "aria-activedescendant": _ctx.ariaActiveDescendant,
+    onFocusin: _cache[8] || (_cache[8] = (...args) => _ctx.activate && _ctx.activate(...args)),
+    onFocusout: _cache[9] || (_cache[9] = (...args) => _ctx.deactivate && _ctx.deactivate(...args)),
+    onKeydown: _cache[10] || (_cache[10] = (...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args)),
+    onKeyup: _cache[11] || (_cache[11] = (...args) => _ctx.handleKeyup && _ctx.handleKeyup(...args)),
+    onFocus: _cache[12] || (_cache[12] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
+    onMousedown: _cache[13] || (_cache[13] = (...args) => _ctx.handleMousedown && _ctx.handleMousedown(...args)),
+    role: "combobox"
+  }, [
+    createCommentVNode(" Search "),
+    $props.mode !== "tags" && $props.searchable && !$props.disabled ? (openBlock(), createElementBlock("input", mergeProps({
+      key: 0,
+      type: $props.inputType,
+      modelValue: _ctx.search,
+      value: _ctx.search,
+      class: _ctx.classList.search,
+      autocomplete: $props.autocomplete,
+      id: $props.searchable ? $props.id : void 0
+    }, $props.attrs, {
+      "aria-owns": _ctx.ariaOwns,
+      "aria-expanded": _ctx.isOpen,
+      "aria-label": _ctx.ariaLabel,
+      "aria-placeholder": _ctx.ariaPlaceholder,
+      "aria-activedescendant": _ctx.ariaActiveDescendant,
+      onInput: _cache[0] || (_cache[0] = (...args) => _ctx.handleSearchInput && _ctx.handleSearchInput(...args)),
+      onKeypress: _cache[1] || (_cache[1] = (...args) => _ctx.handleKeypress && _ctx.handleKeypress(...args)),
+      onPaste: _cache[2] || (_cache[2] = withModifiers((...args) => _ctx.handlePaste && _ctx.handlePaste(...args), ["stop"])),
+      ref: "input",
+      role: "combobox"
+    }), null, 16, _hoisted_2)) : createCommentVNode("v-if", true),
+    createCommentVNode(" Tags (with search) "),
+    $props.mode == "tags" ? (openBlock(), createElementBlock("div", {
+      key: 1,
+      class: normalizeClass(_ctx.classList.tags)
+    }, [
+      (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.iv, (option, i, key) => {
+        return renderSlot(_ctx.$slots, "tag", {
+          option,
+          handleTagRemove: _ctx.handleTagRemove,
+          disabled: $props.disabled
+        }, () => [
+          (openBlock(), createElementBlock("span", {
+            class: normalizeClass(_ctx.classList.tag),
+            key
+          }, [
+            createTextVNode(toDisplayString(option[$props.label]) + " ", 1),
+            !$props.disabled ? (openBlock(), createElementBlock("span", {
+              key: 0,
+              class: normalizeClass(_ctx.classList.tagRemove),
+              onClick: ($event) => _ctx.handleTagRemove(option, $event)
+            }, [
+              createElementVNode("span", {
+                class: normalizeClass(_ctx.classList.tagRemoveIcon)
+              }, null, 2)
+            ], 10, _hoisted_3)) : createCommentVNode("v-if", true)
+          ], 2))
+        ]);
+      }), 256)),
+      createElementVNode("div", {
+        class: normalizeClass(_ctx.classList.tagsSearchWrapper),
+        ref: "tags"
+      }, [
+        createCommentVNode(" Used for measuring search width "),
+        createElementVNode("span", {
+          class: normalizeClass(_ctx.classList.tagsSearchCopy)
+        }, toDisplayString(_ctx.search), 3),
+        createCommentVNode(" Actual search input "),
+        $props.searchable && !$props.disabled ? (openBlock(), createElementBlock("input", mergeProps({
+          key: 0,
+          type: $props.inputType,
+          modelValue: _ctx.search,
+          value: _ctx.search,
+          class: _ctx.classList.tagsSearch,
+          id: $props.searchable ? $props.id : void 0,
+          autocomplete: $props.autocomplete
+        }, $props.attrs, {
+          "aria-owns": _ctx.ariaOwns,
+          "aria-expanded": _ctx.isOpen,
+          "aria-label": _ctx.ariaLabel,
+          "aria-placeholder": _ctx.ariaPlaceholder,
+          "aria-activedescendant": _ctx.ariaActiveDescendant,
+          onInput: _cache[3] || (_cache[3] = (...args) => _ctx.handleSearchInput && _ctx.handleSearchInput(...args)),
+          onKeypress: _cache[4] || (_cache[4] = (...args) => _ctx.handleKeypress && _ctx.handleKeypress(...args)),
+          onPaste: _cache[5] || (_cache[5] = withModifiers((...args) => _ctx.handlePaste && _ctx.handlePaste(...args), ["stop"])),
+          ref: "input",
+          role: "combobox"
+        }), null, 16, _hoisted_4)) : createCommentVNode("v-if", true)
+      ], 2)
+    ], 2)) : createCommentVNode("v-if", true),
+    createCommentVNode(" Single label "),
+    $props.mode == "single" && _ctx.hasSelected && !_ctx.search && _ctx.iv ? renderSlot(_ctx.$slots, "singlelabel", {
+      key: 2,
+      value: _ctx.iv
+    }, () => [
+      createElementVNode("div", {
+        class: normalizeClass(_ctx.classList.singleLabel)
+      }, [
+        createElementVNode("span", {
+          class: normalizeClass(_ctx.classList.singleLabelText),
+          innerHTML: _ctx.iv[$props.label]
+        }, null, 10, _hoisted_5)
+      ], 2)
+    ]) : createCommentVNode("v-if", true),
+    createCommentVNode(" Multiple label "),
+    $props.mode == "multiple" && _ctx.hasSelected && !_ctx.search ? renderSlot(_ctx.$slots, "multiplelabel", {
+      key: 3,
+      values: _ctx.iv
+    }, () => [
+      createElementVNode("div", {
+        class: normalizeClass(_ctx.classList.multipleLabel),
+        innerHTML: _ctx.multipleLabelText
+      }, null, 10, _hoisted_6)
+    ]) : createCommentVNode("v-if", true),
+    createCommentVNode(" Placeholder "),
+    $props.placeholder && !_ctx.hasSelected && !_ctx.search ? renderSlot(_ctx.$slots, "placeholder", { key: 4 }, () => [
+      createElementVNode("div", {
+        class: normalizeClass(_ctx.classList.placeholder)
+      }, toDisplayString($props.placeholder), 3)
+    ]) : createCommentVNode("v-if", true),
+    createCommentVNode(" Spinner "),
+    $props.loading || _ctx.resolving ? renderSlot(_ctx.$slots, "spinner", { key: 5 }, () => [
+      createElementVNode("span", {
+        class: normalizeClass(_ctx.classList.spinner)
+      }, null, 2)
+    ]) : createCommentVNode("v-if", true),
+    createCommentVNode(" Clear "),
+    _ctx.hasSelected && !$props.disabled && $props.canClear && !_ctx.busy ? renderSlot(_ctx.$slots, "clear", {
+      key: 6,
+      clear: _ctx.clear
+    }, () => [
+      createElementVNode("span", {
+        class: normalizeClass(_ctx.classList.clear),
+        onClick: _cache[6] || (_cache[6] = (...args) => _ctx.clear && _ctx.clear(...args))
+      }, [
+        createElementVNode("span", {
+          class: normalizeClass(_ctx.classList.clearIcon)
+        }, null, 2)
+      ], 2)
+    ]) : createCommentVNode("v-if", true),
+    createCommentVNode(" Caret "),
+    $props.caret && $props.showOptions ? renderSlot(_ctx.$slots, "caret", { key: 7 }, () => [
+      createElementVNode("span", {
+        class: normalizeClass(_ctx.classList.caret),
+        onClick: _cache[7] || (_cache[7] = (...args) => _ctx.handleCaretClick && _ctx.handleCaretClick(...args))
+      }, null, 2)
+    ]) : createCommentVNode("v-if", true),
+    createCommentVNode(" Options "),
+    createElementVNode("div", {
+      class: normalizeClass(_ctx.classList.dropdown),
+      tabindex: "-1"
+    }, [
+      renderSlot(_ctx.$slots, "beforelist", { options: _ctx.fo }),
+      createElementVNode("ul", {
+        class: normalizeClass(_ctx.classList.options),
+        id: _ctx.ariaOwns,
+        role: "listbox"
+      }, [
+        $props.groups ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(_ctx.fg, (group, i, key) => {
+          return openBlock(), createElementBlock("li", {
+            class: normalizeClass(_ctx.classList.group),
+            key
+          }, [
+            createElementVNode("div", {
+              class: normalizeClass(_ctx.classList.groupLabel(group)),
+              "data-pointed": _ctx.isPointed(group),
+              onMouseenter: ($event) => _ctx.setPointer(group),
+              onClick: ($event) => _ctx.handleGroupClick(group),
+              role: "none"
+            }, [
+              renderSlot(_ctx.$slots, "grouplabel", {
+                group,
+                isSelected: _ctx.isSelected,
+                isPointed: _ctx.isPointed
+              }, () => [
+                createElementVNode("span", {
+                  innerHTML: group[$props.groupLabel]
+                }, null, 8, _hoisted_9)
+              ])
+            ], 42, _hoisted_8),
+            createElementVNode("ul", {
+              class: normalizeClass(_ctx.classList.groupOptions),
+              "aria-label": _ctx.ariaGroupLabel(group),
+              role: "group"
+            }, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(group.__VISIBLE__, (option, i2, key2) => {
+                return openBlock(), createElementBlock("li", {
+                  class: normalizeClass(_ctx.classList.option(option, group)),
+                  key: key2,
+                  "data-pointed": _ctx.isPointed(option),
+                  "data-selected": _ctx.isSelected(option) || void 0,
+                  id: _ctx.ariaOptionId(option),
+                  "aria-label": _ctx.ariaOptionLabel(option),
+                  onMouseenter: ($event) => _ctx.setPointer(option),
+                  onClick: ($event) => _ctx.handleOptionClick(option),
+                  role: "option"
+                }, [
+                  renderSlot(_ctx.$slots, "option", {
+                    option,
+                    isSelected: _ctx.isSelected,
+                    isPointed: _ctx.isPointed,
+                    search: _ctx.search
+                  }, () => [
+                    createElementVNode("span", {
+                      innerHTML: option[$props.label]
+                    }, null, 8, _hoisted_12)
+                  ])
+                ], 42, _hoisted_11);
+              }), 128))
+            ], 10, _hoisted_10)
+          ], 2);
+        }), 128)) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(_ctx.fo, (option, i, key) => {
+          return openBlock(), createElementBlock("li", {
+            id: _ctx.ariaOptionId(option),
+            "aria-label": _ctx.ariaOptionLabel(option),
+            class: normalizeClass(_ctx.classList.option(option)),
+            key,
+            "data-pointed": _ctx.isPointed(option),
+            "data-selected": _ctx.isSelected(option) || void 0,
+            onMouseenter: ($event) => _ctx.setPointer(option),
+            onClick: ($event) => _ctx.handleOptionClick(option),
+            role: "option"
+          }, [
+            renderSlot(_ctx.$slots, "option", {
+              option,
+              isSelected: _ctx.isSelected,
+              isPointed: _ctx.isPointed,
+              search: _ctx.search
+            }, () => [
+              createElementVNode("span", {
+                innerHTML: option[$props.label]
+              }, null, 8, _hoisted_14)
+            ])
+          ], 42, _hoisted_13);
+        }), 128))
+      ], 10, _hoisted_7),
+      _ctx.noOptions ? renderSlot(_ctx.$slots, "nooptions", { key: 0 }, () => [
+        createElementVNode("div", {
+          class: normalizeClass(_ctx.classList.noOptions),
+          innerHTML: $props.noOptionsText
+        }, null, 10, _hoisted_15)
+      ]) : createCommentVNode("v-if", true),
+      _ctx.noResults ? renderSlot(_ctx.$slots, "noresults", { key: 1 }, () => [
+        createElementVNode("div", {
+          class: normalizeClass(_ctx.classList.noResults),
+          innerHTML: $props.noResultsText
+        }, null, 10, _hoisted_16)
+      ]) : createCommentVNode("v-if", true),
+      $props.infinite && _ctx.hasMore ? (openBlock(), createElementBlock("div", {
+        key: 2,
+        class: normalizeClass(_ctx.classList.inifinite),
+        ref: "infiniteLoader"
+      }, [
+        renderSlot(_ctx.$slots, "infinite", {}, () => [
+          createElementVNode("span", {
+            class: normalizeClass(_ctx.classList.inifiniteSpinner)
+          }, null, 2)
+        ])
+      ], 2)) : createCommentVNode("v-if", true),
+      renderSlot(_ctx.$slots, "afterlist", { options: _ctx.fo })
+    ], 2),
+    createCommentVNode(" Hacky input element to show HTML5 required warning "),
+    $props.required ? (openBlock(), createElementBlock("input", {
+      key: 8,
+      class: normalizeClass(_ctx.classList.fakeInput),
+      tabindex: "-1",
+      value: _ctx.textValue,
+      required: ""
+    }, null, 10, _hoisted_17)) : createCommentVNode("v-if", true),
+    createCommentVNode(" Native input support "),
+    $props.nativeSupport ? (openBlock(), createElementBlock(Fragment, { key: 9 }, [
+      $props.mode == "single" ? (openBlock(), createElementBlock("input", {
+        key: 0,
+        type: "hidden",
+        name: $props.name,
+        value: _ctx.plainValue !== void 0 ? _ctx.plainValue : ""
+      }, null, 8, _hoisted_18)) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(_ctx.plainValue, (v, i) => {
+        return openBlock(), createElementBlock("input", {
+          type: "hidden",
+          name: `${$props.name}[]`,
+          value: v,
+          key: i
+        }, null, 8, _hoisted_19);
+      }), 128))
+    ], 64)) : createCommentVNode("v-if", true),
+    createCommentVNode(" Create height for empty input "),
+    createElementVNode("div", {
+      class: normalizeClass(_ctx.classList.spacer)
+    }, null, 2)
+  ], 42, _hoisted_1$1);
+}
+script.render = render;
+script.__file = "src/Multiselect.vue";
+const _hoisted_1 = ["onClick"];
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "BbSelect",
+  props: {
+    modelValue: null,
+    disabled: { type: Boolean },
+    noClear: { type: Boolean }
+  },
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const modelValue = toRefs(props).modelValue;
+    const inner = ref(modelValue.value);
+    watch(modelValue, (v) => {
+      inner.value = v;
+    });
+    const select = ref(null);
+    function setFocus() {
+      var _a;
+      (_a = select.value) == null ? void 0 : _a.focus();
+    }
+    function clearSelection(event, nativeClear) {
+      event.preventDefault();
+      event.stopPropagation();
+      nativeClear();
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(script), {
+        class: "bb-select",
+        value: unref(modelValue),
+        disabled: __props.disabled,
+        onChange: _cache[0] || (_cache[0] = (value) => _ctx.$emit("update:modelValue", value)),
+        "onSearch:focus": setFocus,
+        modelValue: inner.value,
+        "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => inner.value = $event),
+        ref_key: "select",
+        ref: select
+      }, {
+        clear: withCtx(({ clear }) => [
+          createElementVNode("span", {
+            class: normalizeClass(["multiselect-clear", {
+              hidden: __props.noClear
+            }]),
+            onClick: (event) => clearSelection(event, clear)
+          }, null, 10, _hoisted_1)
+        ]),
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["value", "disabled", "modelValue"]);
+    };
+  }
+});
+const Components$1 = {
+  BbBreadcrumbs: _sfc_main$7,
+  BbCheckbox: _sfc_main$6,
+  BbButton: _sfc_main$5,
+  BbInput: _sfc_main$4,
+  BbLink: _sfc_main$3,
+  BbRadio: _sfc_main$2,
+  BbSelect: _sfc_main$1
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "InLink",
+  props: {
+    secondary: { type: Boolean },
+    success: { type: Boolean },
+    warning: { type: Boolean },
+    danger: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const classes = {
+      "bb-link-primary": !props.secondary,
+      "bb-link-secondary": props.secondary,
+      "bb-link-success": props.success,
+      "bb-link-warning": props.warning,
+      "bb-link-danger": props.danger
+    };
+    return (_ctx, _cache) => {
+      const _component_Link = resolveComponent("Link");
+      return openBlock(), createBlock(_component_Link, {
+        class: normalizeClass(classes)
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+const Components = {
+  InLink: _sfc_main
+};
+var index = {
+  install: (app, options) => {
+    Object.keys(Components$1).forEach((componentName) => {
+      var _a;
+      if ((options == null ? void 0 : options.components) && !((_a = options == null ? void 0 : options.components) == null ? void 0 : _a.includes(componentName)))
+        return;
+      app.component(componentName, Components$1[componentName]);
+    });
+    if (options == null ? void 0 : options.inertia) {
+      Object.keys(Components).forEach((componentName) => {
+        var _a;
+        if ((options == null ? void 0 : options.components) && !((_a = options == null ? void 0 : options.components) == null ? void 0 : _a.includes(componentName)))
+          return;
+        app.component(componentName, Components[componentName]);
+      });
+    }
+  }
+};
+export { index as default };