@1337exp/taoui 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1742 @@
+import { defineComponent, openBlock, createElementBlock, normalizeClass, createCommentVNode, toDisplayString, createElementVNode, renderSlot, computed, normalizeStyle, watch, onBeforeUnmount, createBlock, Teleport, createVNode, Transition, withCtx, withModifiers, Fragment, renderList, ref, createTextVNode, resolveDynamicComponent, useCssVars, nextTick, onMounted, reactive, onBeforeMount, withDirectives, vModelText, onUnmounted, resolveComponent, mergeProps } from "vue";
+const _hoisted_1$h = ["type", "disabled"];
+const _hoisted_2$f = {
+  key: 0,
+  class: "tao-button__loader"
+};
+const _hoisted_3$9 = {
+  key: 1,
+  class: "tao-button__icon"
+};
+const _hoisted_4$6 = { class: "tao-button__content" };
+const _sfc_main$q = /* @__PURE__ */ defineComponent({
+  __name: "TaoButton",
+  props: {
+    type: { default: "button" },
+    size: { default: "medium" },
+    variant: { default: "primary" },
+    disabled: { type: Boolean, default: false },
+    loading: { type: Boolean, default: false },
+    block: { type: Boolean, default: false },
+    icon: { default: "" }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    function handleClick(event) {
+      if (!props.disabled && !props.loading) {
+        emit("click", event);
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        class: normalizeClass(["tao-button", [
+          `tao-button--${__props.size}`,
+          `tao-button--${__props.variant}`,
+          {
+            "tao-button--disabled": __props.disabled,
+            "tao-button--loading": __props.loading,
+            "tao-button--block": __props.block,
+            "tao-button--icon": !!__props.icon
+          }
+        ]]),
+        type: __props.type,
+        disabled: __props.disabled || __props.loading,
+        onClick: handleClick
+      }, [
+        __props.loading ? (openBlock(), createElementBlock("span", _hoisted_2$f)) : createCommentVNode("", true),
+        __props.icon ? (openBlock(), createElementBlock("span", _hoisted_3$9, toDisplayString(__props.icon), 1)) : createCommentVNode("", true),
+        createElementVNode("span", _hoisted_4$6, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ])
+      ], 10, _hoisted_1$h);
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const TaoButton = /* @__PURE__ */ _export_sfc(_sfc_main$q, [["__scopeId", "data-v-0e8431c3"]]);
+const _sfc_main$p = /* @__PURE__ */ defineComponent({
+  __name: "TaoBlock",
+  props: {
+    padding: { default: 16 },
+    radius: { default: 8 },
+    shadow: { type: Boolean, default: true },
+    hover: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const paddingStyle = computed(() => {
+      if (Array.isArray(props.padding)) {
+        return {
+          padding: `${props.padding.map((p) => `${p}px`).join(" ")}`
+        };
+      }
+      return { padding: `${props.padding}px` };
+    });
+    const radiusStyle = computed(() => ({
+      borderRadius: `${props.radius}px`
+    }));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tao-block", { "tao-block--shadow": __props.shadow, "tao-block--hover": __props.hover }]),
+        style: normalizeStyle([paddingStyle.value, radiusStyle.value])
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+const TaoBlock = /* @__PURE__ */ _export_sfc(_sfc_main$p, [["__scopeId", "data-v-4d014dd0"]]);
+const _hoisted_1$g = { class: "tao-input-wrapper" };
+const _hoisted_2$e = {
+  key: 0,
+  class: "tao-input__label"
+};
+const _hoisted_3$8 = ["type", "value", "placeholder", "disabled"];
+const _hoisted_4$5 = {
+  key: 1,
+  class: "tao-input__error"
+};
+const _sfc_main$o = /* @__PURE__ */ defineComponent({
+  __name: "TaoInput",
+  props: {
+    modelValue: {},
+    type: { default: "text" },
+    placeholder: { default: "" },
+    disabled: { type: Boolean, default: false },
+    error: { type: Boolean, default: false },
+    errorMessage: { default: "" },
+    label: { default: "" }
+  },
+  emits: ["update:modelValue", "blur", "focus"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    function handleInput(event) {
+      const target = event.target;
+      emit("update:modelValue", target.value);
+    }
+    function handleBlur(event) {
+      emit("blur", event);
+    }
+    function handleFocus(event) {
+      emit("focus", event);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$g, [
+        __props.label ? (openBlock(), createElementBlock("label", _hoisted_2$e, toDisplayString(__props.label), 1)) : createCommentVNode("", true),
+        createElementVNode("input", {
+          class: normalizeClass(["tao-input", { "tao-input--error": __props.error }]),
+          type: __props.type,
+          value: __props.modelValue,
+          placeholder: __props.placeholder,
+          disabled: __props.disabled,
+          onInput: handleInput,
+          onBlur: handleBlur,
+          onFocus: handleFocus
+        }, null, 42, _hoisted_3$8),
+        __props.error && __props.errorMessage ? (openBlock(), createElementBlock("span", _hoisted_4$5, toDisplayString(__props.errorMessage), 1)) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const TaoInput = /* @__PURE__ */ _export_sfc(_sfc_main$o, [["__scopeId", "data-v-c742d574"]]);
+const _hoisted_1$f = {
+  key: 0,
+  class: "tao-card__cover"
+};
+const _hoisted_2$d = {
+  key: 0,
+  class: "tao-card__header-title"
+};
+const _hoisted_3$7 = { key: 0 };
+const _hoisted_4$4 = {
+  key: 2,
+  class: "tao-card__title-block"
+};
+const _hoisted_5$2 = {
+  key: 0,
+  class: "tao-card__title"
+};
+const _hoisted_6$1 = {
+  key: 1,
+  class: "tao-card__sub"
+};
+const _hoisted_7 = {
+  key: 3,
+  class: "tao-card__body"
+};
+const _hoisted_8 = {
+  key: 4,
+  class: "tao-card__footer"
+};
+const _sfc_main$n = /* @__PURE__ */ defineComponent({
+  __name: "TaoCard",
+  props: {
+    padding: { default: 20 },
+    radius: { default: 8 },
+    shadow: { type: Boolean, default: true },
+    shadowBottomOnly: { type: Boolean, default: false },
+    hover: { type: Boolean, default: false },
+    active: { type: Boolean, default: false },
+    overflow: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const paddingStyle = computed(() => {
+      if (Array.isArray(props.padding)) {
+        return { padding: `${props.padding.map((p) => `${p}px`).join(" ")}` };
+      }
+      return { padding: `${props.padding}px` };
+    });
+    const radiusStyle = computed(() => ({ borderRadius: `${props.radius}px` }));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tao-card", {
+          "tao-card--shadow": __props.shadow && !__props.shadowBottomOnly,
+          "tao-card--shadow-bottom": __props.shadowBottomOnly,
+          "tao-card--hover": __props.hover,
+          "tao-card--active": __props.active,
+          "tao-card--overflow": __props.overflow
+        }]),
+        style: normalizeStyle(radiusStyle.value)
+      }, [
+        _ctx.$slots.cover ? (openBlock(), createElementBlock("div", _hoisted_1$f, [
+          renderSlot(_ctx.$slots, "cover", {}, void 0, true)
+        ])) : createCommentVNode("", true),
+        createElementVNode("div", {
+          class: "tao-card__content",
+          style: normalizeStyle(paddingStyle.value)
+        }, [
+          _ctx.$slots.headerTitle ? (openBlock(), createElementBlock("h2", _hoisted_2$d, [
+            renderSlot(_ctx.$slots, "headerTitle", {}, void 0, true)
+          ])) : createCommentVNode("", true),
+          _ctx.$slots.header || _ctx.$slots.headerSecondary ? (openBlock(), createElementBlock("div", {
+            key: 1,
+            class: normalizeClass(["tao-card__header", { "tao-card__header--between": _ctx.$slots.headerSecondary }])
+          }, [
+            createElementVNode("span", null, [
+              renderSlot(_ctx.$slots, "header", {}, void 0, true)
+            ]),
+            _ctx.$slots.headerSecondary ? (openBlock(), createElementBlock("span", _hoisted_3$7, [
+              renderSlot(_ctx.$slots, "headerSecondary", {}, void 0, true)
+            ])) : createCommentVNode("", true)
+          ], 2)) : createCommentVNode("", true),
+          _ctx.$slots.title || _ctx.$slots.sub ? (openBlock(), createElementBlock("div", _hoisted_4$4, [
+            _ctx.$slots.title ? (openBlock(), createElementBlock("h2", _hoisted_5$2, [
+              renderSlot(_ctx.$slots, "title", {}, void 0, true)
+            ])) : createCommentVNode("", true),
+            _ctx.$slots.sub ? (openBlock(), createElementBlock("div", _hoisted_6$1, [
+              renderSlot(_ctx.$slots, "sub", {}, void 0, true)
+            ])) : createCommentVNode("", true)
+          ])) : createCommentVNode("", true),
+          _ctx.$slots.default ? (openBlock(), createElementBlock("div", _hoisted_7, [
+            renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ])) : createCommentVNode("", true),
+          _ctx.$slots.footer ? (openBlock(), createElementBlock("div", _hoisted_8, [
+            renderSlot(_ctx.$slots, "footer", {}, void 0, true)
+          ])) : createCommentVNode("", true)
+        ], 4)
+      ], 6);
+    };
+  }
+});
+const TaoCard = /* @__PURE__ */ _export_sfc(_sfc_main$n, [["__scopeId", "data-v-b752c7cb"]]);
+const _hoisted_1$e = { class: "tao-modal" };
+const _hoisted_2$c = {
+  key: 0,
+  class: "tao-modal__header"
+};
+const _hoisted_3$6 = { class: "tao-modal__title" };
+const _hoisted_4$3 = { class: "tao-modal__content" };
+const _hoisted_5$1 = {
+  key: 1,
+  class: "tao-modal__footer"
+};
+const _sfc_main$m = /* @__PURE__ */ defineComponent({
+  __name: "TaoModal",
+  props: {
+    modelValue: { type: Boolean },
+    title: { default: "" },
+    closable: { type: Boolean, default: true }
+  },
+  emits: ["update:modelValue", "close"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    function close() {
+      emit("update:modelValue", false);
+      emit("close");
+    }
+    let previousOverflow = "";
+    function lockBodyScroll() {
+      previousOverflow = document.body.style.overflow;
+      document.body.style.overflow = "hidden";
+    }
+    function unlockBodyScroll() {
+      document.body.style.overflow = previousOverflow;
+    }
+    watch(
+      () => props.modelValue,
+      (isOpen) => {
+        if (isOpen) {
+          lockBodyScroll();
+        } else {
+          unlockBodyScroll();
+        }
+      },
+      { immediate: true }
+    );
+    onBeforeUnmount(() => {
+      if (props.modelValue) {
+        unlockBodyScroll();
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Teleport, { to: "body" }, [
+        createVNode(Transition, { name: "tao-modal-fade" }, {
+          default: withCtx(() => [
+            __props.modelValue ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "tao-modal-overlay",
+              onClick: _cache[0] || (_cache[0] = withModifiers(($event) => __props.closable && close(), ["self"]))
+            }, [
+              createElementVNode("div", _hoisted_1$e, [
+                __props.title || _ctx.$slots.header ? (openBlock(), createElementBlock("div", _hoisted_2$c, [
+                  renderSlot(_ctx.$slots, "header", {}, () => [
+                    createElementVNode("h2", _hoisted_3$6, toDisplayString(__props.title), 1)
+                  ], true),
+                  __props.closable ? (openBlock(), createElementBlock("button", {
+                    key: 0,
+                    class: "tao-modal__close",
+                    onClick: close
+                  }, "×")) : createCommentVNode("", true)
+                ])) : createCommentVNode("", true),
+                createElementVNode("div", _hoisted_4$3, [
+                  renderSlot(_ctx.$slots, "default", {}, void 0, true)
+                ]),
+                _ctx.$slots.footer ? (openBlock(), createElementBlock("div", _hoisted_5$1, [
+                  renderSlot(_ctx.$slots, "footer", {}, void 0, true)
+                ])) : createCommentVNode("", true)
+              ])
+            ])) : createCommentVNode("", true)
+          ]),
+          _: 3
+        })
+      ]);
+    };
+  }
+});
+const TaoModal = /* @__PURE__ */ _export_sfc(_sfc_main$m, [["__scopeId", "data-v-4746b5a3"]]);
+const _hoisted_1$d = { class: "tao-tabs" };
+const _hoisted_2$b = { class: "tao-tabs__list" };
+const _hoisted_3$5 = ["onClick"];
+const _hoisted_4$2 = { key: 0 };
+const _hoisted_5 = { key: 1 };
+const _hoisted_6 = { class: "tao-tabs__content" };
+const _sfc_main$l = /* @__PURE__ */ defineComponent({
+  __name: "TaoTabs",
+  props: {
+    tabs: {},
+    modelValue: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    function selectTab(key) {
+      const tab = props.tabs.find((t) => t.key === key);
+      if (tab && !tab.disabled) {
+        emit("update:modelValue", key);
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$d, [
+        createElementVNode("ul", _hoisted_2$b, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.tabs, (tab) => {
+            return openBlock(), createElementBlock("li", {
+              key: tab.key,
+              class: normalizeClass({ active: tab.key === __props.modelValue, disabled: tab.disabled }),
+              onClick: ($event) => selectTab(tab.key)
+            }, [
+              _ctx.$slots.label ? (openBlock(), createElementBlock("a", _hoisted_4$2, [
+                renderSlot(_ctx.$slots, "label", {
+                  text: tab.label,
+                  value: tab.key
+                }, void 0, true)
+              ])) : (openBlock(), createElementBlock("a", _hoisted_5, toDisplayString(tab.label), 1))
+            ], 10, _hoisted_3$5);
+          }), 128))
+        ]),
+        createElementVNode("div", _hoisted_6, [
+          renderSlot(_ctx.$slots, "default", { activeTab: __props.modelValue }, void 0, true)
+        ])
+      ]);
+    };
+  }
+});
+const TaoTabs = /* @__PURE__ */ _export_sfc(_sfc_main$l, [["__scopeId", "data-v-90a6a489"]]);
+const _sfc_main$k = /* @__PURE__ */ defineComponent({
+  __name: "TaoTooltip",
+  props: {
+    content: {},
+    position: { default: "top" }
+  },
+  setup(__props) {
+    const showTooltip = ref(false);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "tao-tooltip-wrapper",
+        onMouseenter: _cache[0] || (_cache[0] = ($event) => showTooltip.value = true),
+        onMouseleave: _cache[1] || (_cache[1] = ($event) => showTooltip.value = false)
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true),
+        createVNode(Transition, { name: "tao-tooltip-fade" }, {
+          default: withCtx(() => [
+            showTooltip.value ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: normalizeClass(["tao-tooltip", [`tao-tooltip--${__props.position}`]])
+            }, toDisplayString(__props.content), 3)) : createCommentVNode("", true)
+          ]),
+          _: 1
+        })
+      ], 32);
+    };
+  }
+});
+const TaoTooltip = /* @__PURE__ */ _export_sfc(_sfc_main$k, [["__scopeId", "data-v-a22f010b"]]);
+const _hoisted_1$c = { class: "tao-spoiler" };
+const _hoisted_2$a = {
+  key: 0,
+  class: "tao-spoiler__title"
+};
+const _hoisted_3$4 = {
+  key: 0,
+  class: "tao-spoiler__content"
+};
+const _hoisted_4$1 = { class: "tao-spoiler__content-inner" };
+const _sfc_main$j = /* @__PURE__ */ defineComponent({
+  __name: "TaoSpoiler",
+  props: {
+    title: { default: "" },
+    defaultOpen: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const isOpen = ref(props.defaultOpen);
+    function toggle() {
+      isOpen.value = !isOpen.value;
+    }
+    function onBeforeEnter(el) {
+      el.style.height = "0";
+    }
+    function onEnter(el) {
+      const element = el;
+      requestAnimationFrame(() => {
+        element.style.height = `${element.scrollHeight}px`;
+      });
+    }
+    function onAfterEnter(el) {
+      el.style.height = "auto";
+    }
+    function onLeave(el) {
+      const element = el;
+      element.style.height = `${element.scrollHeight}px`;
+      requestAnimationFrame(() => {
+        element.style.height = "0";
+      });
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$c, [
+        createElementVNode("button", {
+          class: "tao-spoiler__header",
+          onClick: toggle
+        }, [
+          createElementVNode("span", {
+            class: normalizeClass(["tao-spoiler__icon", { "tao-spoiler__icon--open": isOpen.value }])
+          }, "▶", 2),
+          __props.title || _ctx.$slots.title ? (openBlock(), createElementBlock("span", _hoisted_2$a, [
+            renderSlot(_ctx.$slots, "title", {}, () => [
+              createTextVNode(toDisplayString(__props.title), 1)
+            ], true)
+          ])) : createCommentVNode("", true)
+        ]),
+        createVNode(Transition, {
+          name: "tao-spoiler-slide",
+          onBeforeEnter,
+          onEnter,
+          onAfterEnter,
+          onLeave
+        }, {
+          default: withCtx(() => [
+            isOpen.value ? (openBlock(), createElementBlock("div", _hoisted_3$4, [
+              createElementVNode("div", _hoisted_4$1, [
+                renderSlot(_ctx.$slots, "default", {}, void 0, true)
+              ])
+            ])) : createCommentVNode("", true)
+          ]),
+          _: 3
+        })
+      ]);
+    };
+  }
+});
+const TaoSpoiler = /* @__PURE__ */ _export_sfc(_sfc_main$j, [["__scopeId", "data-v-061480fb"]]);
+const _hoisted_1$b = { class: "tao-copy" };
+const _sfc_main$i = /* @__PURE__ */ defineComponent({
+  __name: "TaoCopy",
+  props: {
+    text: {},
+    successMessage: { default: "Скопировано!" }
+  },
+  setup(__props) {
+    const props = __props;
+    const copied = ref(false);
+    let timeoutId;
+    async function copy() {
+      try {
+        await navigator.clipboard.writeText(props.text);
+        copied.value = true;
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => {
+          copied.value = false;
+        }, 2e3);
+      } catch (err) {
+        console.error("Failed to copy:", err);
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$b, [
+        renderSlot(_ctx.$slots, "default", {
+          copy,
+          copied: copied.value
+        }, () => [
+          createElementVNode("button", {
+            class: normalizeClass(["tao-copy__button", { "tao-copy__button--copied": copied.value }]),
+            onClick: copy
+          }, toDisplayString(copied.value ? __props.successMessage : "Копировать"), 3)
+        ], true)
+      ]);
+    };
+  }
+});
+const TaoCopy = /* @__PURE__ */ _export_sfc(_sfc_main$i, [["__scopeId", "data-v-810f1bc7"]]);
+const _sfc_main$h = /* @__PURE__ */ defineComponent({
+  __name: "TaoContainer",
+  props: {
+    size: { default: "wide" },
+    free: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tao-container", [`tao-container--${__props.size}`, { "tao-container--center": !__props.free }]])
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 2);
+    };
+  }
+});
+const TaoContainer = /* @__PURE__ */ _export_sfc(_sfc_main$h, [["__scopeId", "data-v-e2ebdf8f"]]);
+const _sfc_main$g = /* @__PURE__ */ defineComponent({
+  __name: "TaoFlex",
+  props: {
+    tag: { default: "div" },
+    justify: { default: "flex-start" },
+    align: { default: "stretch" },
+    direction: { default: "row" },
+    wrap: { default: "nowrap" },
+    gap: { default: "0px" }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(__props.tag), {
+        style: normalizeStyle({
+          display: "flex",
+          justifyContent: __props.justify,
+          alignItems: __props.align,
+          flexDirection: __props.direction,
+          flexWrap: __props.wrap,
+          gap: __props.gap
+        })
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["style"]);
+    };
+  }
+});
+const _sfc_main$f = /* @__PURE__ */ defineComponent({
+  __name: "TaoSpace",
+  props: {
+    block: { type: Boolean, default: false },
+    expand: { type: Boolean, default: false },
+    vertical: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tao-space", { "tao-space--vertical": props.vertical }]),
+        style: normalizeStyle([props.block ? "display: flex; flex-wrap: initial;" : "", props.expand ? "width: 100%" : ""])
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+const TaoSpace = /* @__PURE__ */ _export_sfc(_sfc_main$f, [["__scopeId", "data-v-4190f6ba"]]);
+const _hoisted_1$a = { class: "tao-icon" };
+const _sfc_main$e = /* @__PURE__ */ defineComponent({
+  __name: "TaoIcon",
+  props: {
+    name: {},
+    margin: { default: "0px" },
+    size: {},
+    invert: { type: Boolean }
+  },
+  setup(__props) {
+    useCssVars((_ctx) => ({
+      "v2b130076": props.margin
+    }));
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("span", _hoisted_1$a, [
+        renderSlot(_ctx.$slots, "prefix", {}, void 0, true),
+        createElementVNode("i", {
+          class: normalizeClass(["tao-icon__value", [`icon-${props.name}`, { "tao-icon__value--invert": props.invert }]]),
+          style: normalizeStyle(props.size ? `font-size: ${props.size}px` : "")
+        }, null, 6),
+        renderSlot(_ctx.$slots, "postfix", {}, void 0, true)
+      ]);
+    };
+  }
+});
+const TaoIcon = /* @__PURE__ */ _export_sfc(_sfc_main$e, [["__scopeId", "data-v-b561364f"]]);
+const _sfc_main$d = /* @__PURE__ */ defineComponent({
+  __name: "TaoLoader",
+  props: {
+    color: { default: "var(--tao-color-accent)" },
+    size: { default: 80 },
+    inline: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    useCssVars((_ctx) => ({
+      "v052ed61b": positions.value.first,
+      "v05f388d2": positions.value.third,
+      "bdfc57e2": positions.value.fourth,
+      "v50ec8284": positions.value.animationDistance
+    }));
+    const props = __props;
+    const normalizedSize = computed(() => {
+      if (typeof props.size === "number") {
+        return `${props.size}px`;
+      }
+      return props.size;
+    });
+    const dotSizeNumber = computed(() => {
+      const baseSize = typeof props.size === "number" ? props.size : parseInt(props.size, 10) || 80;
+      return baseSize * 0.1625;
+    });
+    const dotSize = computed(() => `${dotSizeNumber.value}px`);
+    const positions = computed(() => {
+      const baseSize = typeof props.size === "number" ? props.size : parseInt(props.size, 10) || 80;
+      return {
+        first: `${baseSize * 0.1}px`,
+        third: `${baseSize * 0.4}px`,
+        fourth: `${baseSize * 0.7}px`,
+        animationDistance: `${baseSize * 0.3}px`
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tao-loader", { "tao-loader--inline": props.inline }])
+      }, [
+        createElementVNode("div", {
+          class: "tao-loader__ellipsis",
+          style: normalizeStyle({ width: normalizedSize.value, height: dotSize.value, marginLeft: `-${dotSizeNumber.value / 2}px` })
+        }, [
+          createElementVNode("div", {
+            style: normalizeStyle({ background: props.color, width: dotSize.value, height: dotSize.value })
+          }, null, 4),
+          createElementVNode("div", {
+            style: normalizeStyle({ background: props.color, width: dotSize.value, height: dotSize.value })
+          }, null, 4),
+          createElementVNode("div", {
+            style: normalizeStyle({ background: props.color, width: dotSize.value, height: dotSize.value })
+          }, null, 4),
+          createElementVNode("div", {
+            style: normalizeStyle({ background: props.color, width: dotSize.value, height: dotSize.value })
+          }, null, 4)
+        ], 4)
+      ], 2);
+    };
+  }
+});
+const TaoLoader = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["__scopeId", "data-v-3a29f095"]]);
+const _hoisted_1$9 = { class: "tao-image" };
+const _hoisted_2$9 = ["src", "alt"];
+const _sfc_main$c = /* @__PURE__ */ defineComponent({
+  __name: "TaoImage",
+  props: {
+    src: { default: "" },
+    alt: { default: "" },
+    pixelated: { type: Boolean, default: false }
+  },
+  emits: ["load", "error"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const isLoaded = ref(false);
+    function handleLoad() {
+      isLoaded.value = true;
+      emit("load");
+    }
+    function handleError() {
+      isLoaded.value = false;
+      emit("error");
+    }
+    watch(() => props.src, () => {
+      isLoaded.value = false;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$9, [
+        __props.src ? (openBlock(), createElementBlock("img", {
+          key: 0,
+          class: normalizeClass({ "tao-image__img--hidden": !isLoaded.value, "tao-image__img--pixelated": props.pixelated }),
+          src: __props.src,
+          alt: __props.alt,
+          draggable: "false",
+          onLoad: handleLoad,
+          onError: handleError
+        }, null, 42, _hoisted_2$9)) : renderSlot(_ctx.$slots, "default", {}, () => [
+          _cache[0] || (_cache[0] = createElementVNode("div", { class: "tao-image__placeholder" }, "No image available", -1))
+        ], true, 1)
+      ]);
+    };
+  }
+});
+const TaoImage = /* @__PURE__ */ _export_sfc(_sfc_main$c, [["__scopeId", "data-v-8272e203"]]);
+const _hoisted_1$8 = ["checked", "disabled"];
+const _hoisted_2$8 = {
+  key: 0,
+  class: "tao-checkbox__label"
+};
+const _hoisted_3$3 = {
+  key: 1,
+  class: "tao-checkbox__label"
+};
+const _sfc_main$b = /* @__PURE__ */ defineComponent({
+  __name: "TaoCheckbox",
+  props: {
+    value: { type: Boolean, default: void 0 },
+    modelValue: { type: Boolean, default: void 0 },
+    label: { default: "" },
+    disabled: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const isChecked = computed({
+      get: () => {
+        if (props.modelValue !== void 0) {
+          return props.modelValue;
+        }
+        return props.value;
+      },
+      set: (value) => {
+        if (props.modelValue !== void 0) {
+          emit("update:modelValue", value);
+        }
+        emit("change", value);
+      }
+    });
+    function onInputChange(event) {
+      if (props.disabled) {
+        return;
+      }
+      const target = event.target;
+      isChecked.value = target.checked;
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", {
+        class: normalizeClass(["tao-checkbox", { "tao-checkbox--disabled": props.disabled }])
+      }, [
+        renderSlot(_ctx.$slots, "pre", {
+          text: props.label
+        }, void 0, true),
+        createElementVNode("input", {
+          class: "tao-checkbox__input",
+          type: "checkbox",
+          checked: isChecked.value,
+          disabled: props.disabled,
+          onChange: onInputChange
+        }, null, 40, _hoisted_1$8),
+        _cache[0] || (_cache[0] = createElementVNode("span", { class: "tao-checkbox__box" }, null, -1)),
+        props.label ? (openBlock(), createElementBlock("span", _hoisted_2$8, toDisplayString(props.label), 1)) : (openBlock(), createElementBlock("span", _hoisted_3$3, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ])),
+        renderSlot(_ctx.$slots, "post", {
+          text: props.label
+        }, void 0, true)
+      ], 2);
+    };
+  }
+});
+const TaoCheckbox = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__scopeId", "data-v-0ece6da0"]]);
+const _sfc_main$a = /* @__PURE__ */ defineComponent({
+  __name: "TaoTag",
+  props: {
+    type: { default: "" },
+    color: {},
+    background: {},
+    borderColor: {},
+    pointer: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const style = computed(() => ({
+      color: props.color || "",
+      background: props.background || "",
+      "border-color": props.borderColor || ""
+    }));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tao-tag", [props.pointer && "tao-tag--pointer", props.type ? `tao-tag--${props.type}` : ""]]),
+        style: normalizeStyle(style.value)
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+const TaoTag = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["__scopeId", "data-v-f615cf3c"]]);
+const _hoisted_1$7 = {
+  key: 1,
+  class: "tao-divider-text"
+};
+const _hoisted_2$7 = { class: "tao-divider-text__value" };
+const _hoisted_3$2 = {
+  key: 2,
+  class: "tao-divider-line"
+};
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  __name: "TaoDivider",
+  props: {
+    variant: { default: "line" },
+    size: { default: "medium" }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return __props.variant === "gap" ? (openBlock(), createElementBlock("div", {
+        key: 0,
+        class: normalizeClass(["tao-divider-gap", `tao-divider-gap--${__props.size}`])
+      }, null, 2)) : __props.variant === "text" ? (openBlock(), createElementBlock("div", _hoisted_1$7, [
+        _cache[0] || (_cache[0] = createElementVNode("span", { class: "tao-divider-text__line tao-divider-text__line--left" }, null, -1)),
+        createElementVNode("span", _hoisted_2$7, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _cache[1] || (_cache[1] = createElementVNode("span", { class: "tao-divider-text__line tao-divider-text__line--right" }, null, -1))
+      ])) : (openBlock(), createElementBlock("div", _hoisted_3$2));
+    };
+  }
+});
+const TaoDivider = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["__scopeId", "data-v-9db02640"]]);
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  __name: "TaoAnimatedBorder",
+  props: {
+    borderWidth: { default: 3 },
+    speed: { default: 6 },
+    glow: { default: 16 },
+    light: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tao-animated-border", { "tao-animated-border--light": __props.light }]),
+        style: normalizeStyle({
+          "--tao-animated-border-width": `${__props.borderWidth}px`,
+          "--tao-animated-border-speed": `${__props.speed}s`,
+          "--tao-animated-border-glow": `${__props.glow}px`
+        })
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+const TaoAnimatedBorder = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["__scopeId", "data-v-4ca22c09"]]);
+const _hoisted_1$6 = {
+  key: 0,
+  class: "tao-textarea tao-textarea--dummy"
+};
+const _hoisted_2$6 = ["placeholder", "spellcheck", "autocomplete", "minlength", "maxlength", "disabled", "rows", "value"];
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  __name: "TaoTextarea",
+  props: {
+    placeholder: { default: "" },
+    spellcheck: { type: Boolean, default: true },
+    autocomplete: { default: "" },
+    minlength: { default: 0 },
+    maxlength: { default: void 0 },
+    disabled: { type: Boolean, default: false },
+    noSpace: { type: Boolean, default: false },
+    dummy: { type: Boolean, default: false },
+    rows: { default: 3 },
+    resize: { type: Boolean, default: true },
+    modelValue: { default: "" },
+    noBorder: { type: Boolean, default: false },
+    noBackground: { type: Boolean, default: false },
+    autoFocus: { type: Boolean, default: false },
+    borderInverse: { type: Boolean, default: false },
+    textCenter: { type: Boolean, default: false },
+    submitOnEnter: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "change", "focus", "blur", "keydown"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const textareaRef = ref(null);
+    function onInput(e) {
+      const target = e.target;
+      emit("update:modelValue", target.value);
+      autoResize();
+    }
+    function onChange(e) {
+      emit("change", e.target.value);
+    }
+    function onFocus(e) {
+      emit("focus", e);
+    }
+    function onBlur(e) {
+      emit("blur", e);
+    }
+    function onKeydown(event) {
+      var _a;
+      emit("keydown", event);
+      if (props.submitOnEnter && event.key === "Enter" && !event.shiftKey) {
+        (_a = textareaRef.value) == null ? void 0 : _a.blur();
+        event.preventDefault();
+        return;
+      }
+      if (props.noSpace && event.key === " ") {
+        event.preventDefault();
+      }
+    }
+    function autoResize() {
+      const textarea = textareaRef.value;
+      if (!textarea) {
+        return;
+      }
+      textarea.style.height = "auto";
+      textarea.style.height = `${Math.min(textarea.scrollHeight, 500)}px`;
+    }
+    watch(() => props.modelValue, () => {
+      nextTick(autoResize);
+    });
+    onMounted(() => {
+      var _a;
+      if (props.autoFocus) {
+        (_a = textareaRef.value) == null ? void 0 : _a.focus();
+      }
+      nextTick(autoResize);
+    });
+    return (_ctx, _cache) => {
+      return props.dummy ? (openBlock(), createElementBlock("span", _hoisted_1$6, toDisplayString(props.modelValue), 1)) : (openBlock(), createElementBlock("textarea", {
+        key: 1,
+        ref_key: "textareaRef",
+        ref: textareaRef,
+        class: normalizeClass(["tao-textarea", {
+          "tao-textarea--inverse": props.borderInverse,
+          "tao-textarea--center": props.textCenter,
+          "tao-textarea--no-border": props.noBorder,
+          "tao-textarea--no-background": props.noBackground,
+          "tao-textarea--no-resize": !props.resize
+        }]),
+        placeholder: props.placeholder,
+        spellcheck: props.spellcheck,
+        autocomplete: props.autocomplete,
+        minlength: props.minlength,
+        maxlength: props.maxlength,
+        disabled: props.disabled,
+        rows: props.rows,
+        value: props.modelValue,
+        draggable: "false",
+        onInput,
+        onChange,
+        onFocus,
+        onBlur,
+        onKeydown
+      }, null, 42, _hoisted_2$6));
+    };
+  }
+});
+const TaoTextarea = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__scopeId", "data-v-a56ad167"]]);
+const _hoisted_1$5 = ["tabindex"];
+const _hoisted_2$5 = { class: "tao-scroll-top__content" };
+const RIPPLE_DURATION = 750;
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __name: "TaoScrollTop",
+  props: {
+    size: { default: 40 },
+    right: { default: 24 },
+    bottom: { default: 24 },
+    zIndex: { default: 1e3 },
+    boundary: { default: 300 },
+    hasOutline: { type: Boolean, default: true },
+    tabindex: { default: 0 }
+  },
+  setup(__props) {
+    const props = __props;
+    const fmtProp = (value, unit = "px") => typeof value === "number" ? value + unit : value;
+    let prevPos = 0;
+    let activeBack = false;
+    const mainStyle = reactive({
+      width: fmtProp(props.size),
+      height: fmtProp(props.size),
+      right: fmtProp(props.right),
+      bottom: fmtProp(props.bottom),
+      zIndex: props.zIndex
+    });
+    const rippleStyle = reactive({
+      top: fmtProp(-1 * props.size),
+      left: fmtProp(-1 * props.size),
+      width: "200%",
+      height: "200%"
+    });
+    const isActive = ref(false);
+    const isRippleActive = ref(false);
+    function getScrollValue() {
+      if (typeof window.pageYOffset !== "undefined") {
+        return window.pageYOffset;
+      }
+      if (typeof document.compatMode !== "undefined" && document.compatMode !== "BackCompat") {
+        return document.documentElement.scrollTop;
+      }
+      return document.body.scrollTop;
+    }
+    function goToTop() {
+      const c = getScrollValue();
+      if (c > 0) {
+        window.requestAnimationFrame(goToTop);
+        window.scrollTo(0, c - Math.max(10, c / 8));
+      }
+    }
+    function onScroll() {
+      const pY = getScrollValue();
+      const tooFar = pY > props.boundary;
+      const goBack = prevPos > pY;
+      if (activeBack) {
+        if (!goBack && pY - prevPos > 15) {
+          activeBack = false;
+        }
+      } else {
+        activeBack = prevPos - pY >= 20;
+        if (activeBack && pY - props.boundary < 150) {
+          activeBack = false;
+        }
+      }
+      prevPos = pY;
+      isActive.value = tooFar && activeBack;
+    }
+    function onClick(e) {
+      if (!isRippleActive.value) {
+        const elTarget = e.currentTarget;
+        if (elTarget) {
+          const rect = elTarget.getBoundingClientRect();
+          const top = e.clientY - rect.top;
+          const left = e.clientX - rect.left;
+          rippleStyle.top = fmtProp(top - props.size);
+          rippleStyle.left = fmtProp(left - props.size);
+        }
+        isRippleActive.value = true;
+        setTimeout(() => {
+          isRippleActive.value = false;
+        }, RIPPLE_DURATION);
+      }
+      goToTop();
+    }
+    onBeforeMount(() => {
+      window.addEventListener("scroll", onScroll);
+    });
+    onBeforeUnmount(() => {
+      window.removeEventListener("scroll", onScroll);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, { name: "tao-scroll-top-fade" }, {
+        default: withCtx(() => [
+          isActive.value ? (openBlock(), createElementBlock("button", {
+            key: 0,
+            style: normalizeStyle(mainStyle),
+            tabindex: props.tabindex,
+            class: normalizeClass(["tao-scroll-top", { "tao-scroll-top--no-outline": !props.hasOutline }]),
+            "aria-label": "Scroll to top",
+            onClick: withModifiers(onClick, ["prevent"])
+          }, [
+            createElementVNode("div", _hoisted_2$5, [
+              createElementVNode("div", {
+                class: normalizeClass([{ "tao-scroll-top__ripple--active": isRippleActive.value }, "tao-scroll-top__ripple"]),
+                style: normalizeStyle(rippleStyle)
+              }, null, 6),
+              renderSlot(_ctx.$slots, "default", {}, () => [
+                _cache[0] || (_cache[0] = createElementVNode("svg", {
+                  class: "tao-scroll-top__icon",
+                  viewBox: "0 0 24 24",
+                  width: "16",
+                  height: "16",
+                  fill: "currentColor"
+                }, [
+                  createElementVNode("path", { d: "M12 6l-7 7 1.4 1.4L12 8.8l5.6 5.6L19 13z" })
+                ], -1))
+              ], true)
+            ])
+          ], 14, _hoisted_1$5)) : createCommentVNode("", true)
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+const TaoScrollTop = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-a6b96e61"]]);
+const _hoisted_1$4 = { class: "tao-progress" };
+const _hoisted_2$4 = {
+  key: 0,
+  class: "tao-progress__side"
+};
+const _hoisted_3$1 = { class: "tao-progress__side" };
+const _hoisted_4 = {
+  key: 0,
+  class: "tao-progress__percentage"
+};
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "TaoProgress",
+  props: {
+    min: { default: 200 },
+    max: { default: 400 },
+    progress: { default: 0 },
+    height: { default: 8 },
+    showPercentage: { type: Boolean, default: false },
+    animated: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$4, [
+        createElementVNode("div", {
+          class: "tao-progress__container",
+          style: normalizeStyle({ minWidth: `${__props.min}px`, maxWidth: `${__props.max}px` })
+        }, [
+          _ctx.$slots.left ? (openBlock(), createElementBlock("div", _hoisted_2$4, [
+            renderSlot(_ctx.$slots, "left", {}, void 0, true)
+          ])) : createCommentVNode("", true),
+          createElementVNode("div", {
+            class: "tao-progress__track",
+            style: normalizeStyle({ height: `${__props.height}px` })
+          }, [
+            createElementVNode("div", {
+              class: normalizeClass(["tao-progress__fill", { "tao-progress__fill--animated": __props.animated }]),
+              style: normalizeStyle({ width: `${__props.progress}%` })
+            }, null, 6)
+          ], 4),
+          createElementVNode("div", _hoisted_3$1, [
+            __props.showPercentage ? (openBlock(), createElementBlock("span", _hoisted_4, toDisplayString(__props.progress) + "%", 1)) : createCommentVNode("", true),
+            renderSlot(_ctx.$slots, "right", {}, void 0, true)
+          ])
+        ], 4)
+      ]);
+    };
+  }
+});
+const TaoProgress = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__scopeId", "data-v-3780642d"]]);
+const _hoisted_1$3 = ["placeholder"];
+const _hoisted_2$3 = {
+  key: 1,
+  class: "tao-slider__value"
+};
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "TaoSlider",
+  props: {
+    min: { default: 0 },
+    max: { default: 100 },
+    step: { default: 1 },
+    showValue: { type: Boolean, default: false },
+    placeholder: { default: "" },
+    modelValue: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    function packModelValue(value) {
+      return typeof props.modelValue === "string" ? `${value}` : value;
+    }
+    function unpackModelValue() {
+      return typeof props.modelValue === "string" ? parseFloat(props.modelValue) : props.modelValue;
+    }
+    const trackRef = ref(null);
+    const isDragging = ref(false);
+    const shadowInputRef = ref(null);
+    const shadowModel = ref("0");
+    const showShadowModel = ref(false);
+    const progressPercent = computed(() => {
+      const range = props.max - props.min;
+      return (unpackModelValue() - props.min) / range * 100;
+    });
+    function clampValue(v) {
+      return Math.min(Math.max(v, props.min), props.max);
+    }
+    function calculateValue(event) {
+      if (!trackRef.value) {
+        return props.min;
+      }
+      const rect = trackRef.value.getBoundingClientRect();
+      const clientX = "touches" in event ? event.touches[0].clientX : event.clientX;
+      const x = Math.min(Math.max(clientX - rect.left, 0), rect.width);
+      const ratio = x / rect.width;
+      const v = Math.round(props.min + ratio * (props.max - props.min));
+      return clampValue(Math.round((v - props.min) / props.step) * props.step + props.min);
+    }
+    function handleMove(event) {
+      emit("update:modelValue", packModelValue(calculateValue(event)));
+    }
+    function onMouseUp(event) {
+      const evBtn = "touches" in event ? void 0 : event.button;
+      if (typeof evBtn !== "undefined" && evBtn !== 0 || showShadowModel.value) {
+        return;
+      }
+      isDragging.value = false;
+    }
+    function onMouseDown(event) {
+      const evBtn = "touches" in event ? void 0 : event.button;
+      if (typeof evBtn !== "undefined" && evBtn !== 0 || showShadowModel.value) {
+        return;
+      }
+      isDragging.value = true;
+      handleMove(event);
+      event.preventDefault();
+    }
+    function onMouseMove(event) {
+      if (!isDragging.value) {
+        return;
+      }
+      handleMove(event);
+    }
+    function onBlurShadowModel() {
+      if (shadowModel.value) {
+        const newValue = packModelValue(clampValue(parseFloat(shadowModel.value) || 0));
+        shadowModel.value = `${newValue}`;
+        emit("update:modelValue", newValue);
+      }
+      showShadowModel.value = false;
+    }
+    function onShadowKeydown(event) {
+      var _a;
+      if (event.key === "Enter") {
+        (_a = shadowInputRef.value) == null ? void 0 : _a.blur();
+      }
+    }
+    function onContextMenu() {
+      if (props.showValue) {
+        shadowModel.value = `${props.modelValue}`;
+        showShadowModel.value = true;
+        requestAnimationFrame(() => {
+          var _a;
+          return (_a = shadowInputRef.value) == null ? void 0 : _a.focus();
+        });
+      }
+    }
+    onMounted(() => {
+      window.addEventListener("mouseleave", onMouseUp);
+      window.addEventListener("mouseup", onMouseUp);
+      window.addEventListener("mousemove", onMouseMove);
+      window.addEventListener("touchend", onMouseUp);
+      window.addEventListener("touchmove", onMouseMove);
+    });
+    onBeforeUnmount(() => {
+      window.removeEventListener("mouseleave", onMouseUp);
+      window.removeEventListener("mouseup", onMouseUp);
+      window.removeEventListener("mousemove", onMouseMove);
+      window.removeEventListener("touchend", onMouseUp);
+      window.removeEventListener("touchmove", onMouseMove);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "trackRef",
+        ref: trackRef,
+        class: normalizeClass(["tao-slider", { "tao-slider--show-value": __props.showValue }]),
+        onContextmenu: withModifiers(onContextMenu, ["prevent"]),
+        onMousedown: onMouseDown,
+        onTouchstart: onMouseDown
+      }, [
+        _cache[2] || (_cache[2] = createElementVNode("div", { class: "tao-slider__track" }, null, -1)),
+        createElementVNode("div", {
+          class: "tao-slider__fill",
+          style: normalizeStyle({ width: `${progressPercent.value}%` })
+        }, null, 4),
+        createElementVNode("div", {
+          class: "tao-slider__thumb",
+          style: normalizeStyle({ left: `${progressPercent.value}%` })
+        }, null, 4),
+        showShadowModel.value ? withDirectives((openBlock(), createElementBlock("input", {
+          key: 0,
+          ref_key: "shadowInputRef",
+          ref: shadowInputRef,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => shadowModel.value = $event),
+          type: "number",
+          inputmode: "numeric",
+          placeholder: __props.placeholder,
+          class: "tao-slider__shadow-input",
+          onBlur: onBlurShadowModel,
+          onKeydown: onShadowKeydown,
+          onMousedown: _cache[1] || (_cache[1] = withModifiers(() => {
+          }, ["stop"]))
+        }, null, 40, _hoisted_1$3)), [
+          [vModelText, shadowModel.value]
+        ]) : __props.showValue ? (openBlock(), createElementBlock("div", _hoisted_2$3, [
+          renderSlot(_ctx.$slots, "pre-value", {}, void 0, true),
+          createTextVNode(toDisplayString(__props.modelValue), 1),
+          renderSlot(_ctx.$slots, "post-value", {}, void 0, true)
+        ])) : createCommentVNode("", true)
+      ], 34);
+    };
+  }
+});
+const TaoSlider = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-9f531a81"]]);
+const _hoisted_1$2 = { class: "tao-file-drop" };
+const _hoisted_2$2 = ["accept", "multiple"];
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "TaoFileDrop",
+  props: {
+    modelValue: { default: () => [] },
+    size: { default: "medium" },
+    accept: { default: "*" },
+    multiple: { type: Boolean, default: false },
+    showClear: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "files", "clear-request"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const isDragging = ref(false);
+    const fileInput = ref(null);
+    function handleDragOver(event) {
+      event.preventDefault();
+      isDragging.value = true;
+    }
+    function handleDragLeave() {
+      isDragging.value = false;
+    }
+    function handleDrop(event) {
+      var _a;
+      event.preventDefault();
+      isDragging.value = false;
+      const files = (_a = event.dataTransfer) == null ? void 0 : _a.files;
+      if (files && files.length > 0) {
+        processFiles(files);
+      }
+    }
+    function handleFileSelect(event) {
+      const input = event.target;
+      if (input.files && input.files.length > 0) {
+        processFiles(input.files);
+      }
+    }
+    function requestClear() {
+      emit("clear-request");
+    }
+    function triggerFileInput() {
+      var _a;
+      (_a = fileInput.value) == null ? void 0 : _a.click();
+    }
+    function processFiles(fileList) {
+      const files = Array.from(fileList);
+      const result = !props.multiple && files.length > 1 ? [files[0]] : files;
+      emit("update:modelValue", result);
+      emit("files", result);
+      const el = fileInput.value;
+      if (el) {
+        el.type = "text";
+        el.type = "file";
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$2, [
+        __props.showClear && __props.modelValue.length ? (openBlock(), createElementBlock("button", {
+          key: 0,
+          type: "button",
+          class: "tao-file-drop__clear",
+          onClick: requestClear
+        }, " ✕ ")) : createCommentVNode("", true),
+        createElementVNode("div", {
+          class: normalizeClass(["tao-file-drop__zone", [`tao-file-drop__zone--${__props.size}`, { "tao-file-drop__zone--dragging": isDragging.value }]]),
+          onDragover: handleDragOver,
+          onDragleave: handleDragLeave,
+          onDrop: handleDrop,
+          onClick: triggerFileInput
+        }, [
+          renderSlot(_ctx.$slots, "default", {}, () => [
+            _cache[0] || (_cache[0] = createTextVNode("Drag & drop your file(s) here or click to select", -1))
+          ], true),
+          createElementVNode("input", {
+            ref_key: "fileInput",
+            ref: fileInput,
+            type: "file",
+            hidden: "",
+            accept: __props.accept,
+            multiple: __props.multiple,
+            onChange: handleFileSelect
+          }, null, 40, _hoisted_2$2)
+        ], 34)
+      ]);
+    };
+  }
+});
+const TaoFileDrop = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-db5ffca4"]]);
+const _hoisted_1$1 = { key: 1 };
+const _hoisted_2$1 = ["onClick"];
+const _hoisted_3 = { key: 1 };
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "TaoDropdownMenu",
+  props: {
+    actions: { default: () => [] }
+  },
+  emits: ["selected"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    let animationFrameId = 0;
+    const menuRef = ref(null);
+    const listRef = ref(null);
+    const isOpen = ref(false);
+    const listPosition = reactive({ top: "0", left: "0" });
+    function updatePosition() {
+      const elMenu = menuRef.value;
+      const elList = listRef.value;
+      if (elMenu && elList && isOpen.value) {
+        const rect = elMenu.getBoundingClientRect();
+        const rectList = elList.getBoundingClientRect();
+        let px = rect.right;
+        let py = rect.top;
+        if (px + rectList.width > window.innerWidth) {
+          px = rect.left - rectList.width;
+        }
+        if (py + rectList.height > window.innerHeight) {
+          py = rect.bottom - rectList.height;
+        }
+        listPosition.top = `${py + window.scrollY}px`;
+        listPosition.left = `${px}px`;
+      }
+    }
+    function toggleMenu() {
+      isOpen.value = !isOpen.value;
+      if (isOpen.value) {
+        animationFrameId = requestAnimationFrame(function render() {
+          updatePosition();
+          animationFrameId = requestAnimationFrame(render);
+        });
+      } else {
+        cancelAnimationFrame(animationFrameId);
+      }
+    }
+    function closeMenu(event) {
+      if (menuRef.value && !menuRef.value.contains(event.target)) {
+        isOpen.value = false;
+      }
+    }
+    function emitAction(id) {
+      isOpen.value = false;
+      emit("selected", id);
+    }
+    function onWinScroll() {
+      isOpen.value = false;
+    }
+    onMounted(() => {
+      document.addEventListener("click", closeMenu);
+      window.addEventListener("scroll", onWinScroll);
+    });
+    onUnmounted(() => {
+      document.removeEventListener("click", closeMenu);
+      window.removeEventListener("scroll", onWinScroll);
+      cancelAnimationFrame(animationFrameId);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "menuRef",
+        ref: menuRef,
+        class: "tao-dropdown-menu"
+      }, [
+        createElementVNode("div", {
+          class: "tao-dropdown-menu__button",
+          onClick: toggleMenu
+        }, [
+          _ctx.$slots.button ? renderSlot(_ctx.$slots, "button", {}, void 0, true, 0) : (openBlock(), createElementBlock("span", _hoisted_1$1, "⋮"))
+        ]),
+        (openBlock(), createBlock(Teleport, { to: "body" }, [
+          isOpen.value ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            ref_key: "listRef",
+            ref: listRef,
+            class: "tao-dropdown-menu__list",
+            style: normalizeStyle(listPosition)
+          }, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.actions, (action) => {
+              return openBlock(), createElementBlock("div", {
+                key: action.id,
+                class: "tao-dropdown-menu__item",
+                onClick: ($event) => emitAction(action.id)
+              }, [
+                _ctx.$slots.item ? renderSlot(_ctx.$slots, "item", {
+                  id: action.id,
+                  ico: action.ico,
+                  text: action.name
+                }, void 0, true, 0) : (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(action.name), 1))
+              ], 8, _hoisted_2$1);
+            }), 128))
+          ], 4)) : createCommentVNode("", true)
+        ]))
+      ], 512);
+    };
+  }
+});
+const TaoDropdownMenu = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-d54be7aa"]]);
+const _hoisted_1 = { class: "tao-pin-code" };
+const _hoisted_2 = ["value", "placeholder", "type", "inputmode", "pattern", "onInput", "onKeydown", "onFocus"];
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "TaoPinCode",
+  props: {
+    length: {},
+    hidden: { type: Boolean, default: false },
+    placeholder: { default: "" },
+    modelValue: {},
+    numbersOnly: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "change", "active", "blur"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    let lastPinCode = NaN;
+    const numbers = ref([]);
+    const inputRefs = ref([]);
+    const activeNumber = ref(-1);
+    function emitChange() {
+      const s = numbers.value.map((e) => e ? e : "0").join("");
+      const curPinCode = parseFloat(s);
+      if (lastPinCode !== curPinCode) {
+        lastPinCode = curPinCode;
+        emit("change", curPinCode);
+      }
+      emit("update:modelValue", s);
+    }
+    function emitBlur() {
+      activeNumber.value = -1;
+      emit("blur");
+    }
+    function init() {
+      numbers.value = [...Array(props.length)].map(() => "");
+      inputRefs.value = [];
+      activeNumber.value = -1;
+    }
+    function mutation(v, index) {
+      var _a, _b;
+      numbers.value = [...numbers.value];
+      if (v.length > 1) {
+        v = v[v.length - 1] ?? "";
+      }
+      if (props.numbersOnly && v && !/^[0-9]$/.test(v)) {
+        numbers.value[index] = numbers.value[index] ?? "";
+        return;
+      }
+      numbers.value[index] = v;
+      const getNextIdx = () => {
+        if (numbers.value.length >= index + 1) {
+          return numbers.value.findIndex((e) => e === "");
+        }
+        return index + 1;
+      };
+      const nextIndex = getNextIdx();
+      if (nextIndex !== -1 && !numbers.value[nextIndex]) {
+        const el = inputRefs.value[nextIndex];
+        if (el) {
+          el.focus();
+        } else {
+          (_a = inputRefs.value[index]) == null ? void 0 : _a.blur();
+          emitBlur();
+        }
+      } else {
+        (_b = inputRefs.value[index]) == null ? void 0 : _b.blur();
+        emitBlur();
+      }
+      emitChange();
+    }
+    function onFocus(index) {
+      numbers.value = [...numbers.value];
+      numbers.value[index] = "";
+      activeNumber.value = index;
+      emitChange();
+      emit("active", inputRefs.value[index], index);
+    }
+    function onChange(e, index) {
+      const v = e.target.value;
+      mutation(v, index);
+    }
+    function onKeydown(event, index) {
+      if (event.key !== "Backspace") {
+        return;
+      }
+      if (!numbers.value[index] && index > 0) {
+        event.preventDefault();
+        numbers.value = [...numbers.value];
+        numbers.value[index - 1] = "";
+        const prevEl = inputRefs.value[index - 1];
+        prevEl == null ? void 0 : prevEl.focus();
+        activeNumber.value = index - 1;
+        emitChange();
+      }
+    }
+    watch(() => props.modelValue, (v) => {
+      if (!v.length) {
+        init();
+        emitChange();
+      }
+    });
+    init();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(numbers.value, (num, index) => {
+          return openBlock(), createElementBlock("input", {
+            key: index,
+            ref_for: true,
+            ref: (el) => inputRefs.value[index] = el,
+            class: normalizeClass(["tao-pin-code__value", { "tao-pin-code__value--active": activeNumber.value === index }]),
+            value: num,
+            placeholder: __props.placeholder,
+            type: __props.hidden ? "password" : "text",
+            inputmode: __props.numbersOnly ? "numeric" : "text",
+            pattern: __props.numbersOnly ? "[0-9]" : void 0,
+            maxlength: "1",
+            onInput: ($event) => onChange($event, index),
+            onKeydown: ($event) => onKeydown($event, index),
+            onFocus: ($event) => onFocus(index)
+          }, null, 42, _hoisted_2);
+        }), 128))
+      ]);
+    };
+  }
+});
+const TaoPinCode = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-b8c7bf2c"]]);
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TaoLink",
+  props: {
+    to: { default: void 0 },
+    asNewTab: { type: Boolean, default: false },
+    private: { type: Boolean, default: false },
+    exactPath: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const linkComponent = computed(() => {
+      const resolved = resolveComponent("NuxtLink");
+      return typeof resolved === "string" ? "a" : resolved;
+    });
+    const linkProps = computed(() => {
+      const target = props.asNewTab ? "_blank" : void 0;
+      const rel = props.private && "noopener noreferrer" || props.asNewTab && "noopener" || void 0;
+      if (linkComponent.value === "a") {
+        return {
+          href: typeof props.to === "string" ? props.to : void 0,
+          target,
+          rel
+        };
+      }
+      return {
+        to: props.to,
+        target,
+        rel,
+        exactPath: props.exactPath
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(linkComponent.value), mergeProps(linkProps.value, { draggable: "false" }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+const components = [
+  TaoButton,
+  TaoBlock,
+  TaoInput,
+  TaoCard,
+  TaoModal,
+  TaoTabs,
+  TaoTooltip,
+  TaoSpoiler,
+  TaoCopy,
+  TaoContainer,
+  _sfc_main$g,
+  TaoSpace,
+  TaoIcon,
+  TaoLoader,
+  TaoImage,
+  TaoCheckbox,
+  TaoTag,
+  TaoDivider,
+  TaoAnimatedBorder,
+  TaoTextarea,
+  TaoScrollTop,
+  TaoProgress,
+  TaoSlider,
+  TaoFileDrop,
+  TaoDropdownMenu,
+  TaoPinCode,
+  _sfc_main
+];
+const TaoUI = {
+  install(app) {
+    components.forEach((component) => {
+      app.component(component.name, component);
+    });
+  }
+};
+export {
+  TaoAnimatedBorder,
+  TaoBlock,
+  TaoButton,
+  TaoCard,
+  TaoCheckbox,
+  TaoContainer,
+  TaoCopy,
+  TaoDivider,
+  TaoDropdownMenu,
+  TaoFileDrop,
+  _sfc_main$g as TaoFlex,
+  TaoIcon,
+  TaoImage,
+  TaoInput,
+  _sfc_main as TaoLink,
+  TaoLoader,
+  TaoModal,
+  TaoPinCode,
+  TaoProgress,
+  TaoScrollTop,
+  TaoSlider,
+  TaoSpace,
+  TaoSpoiler,
+  TaoTabs,
+  TaoTag,
+  TaoTextarea,
+  TaoTooltip,
+  TaoUI,
+  TaoUI as default
+};
+//# sourceMappingURL=index.mjs.map