@talex-touch/tuffex 0.3.3

package/dist/lib/tabs/src/TxTabs.vue2.js

@@ -0,0 +1,497 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const TxAutoSizer_vue_vue_type_script_setup_true_lang = require('../../auto-sizer/src/TxAutoSizer.vue.js');
+const TxTabHeader = require('./TxTabHeader.vue.js');
+const TxTabItem = require('./TxTabItem.vue.js');
+
+const qualifiedName = ["TxTabItem", "TxTabItemGroup", "TxTabHeader"];
+const _sfc_main = vue.defineComponent({
+  name: "TxTabs",
+  props: {
+    modelValue: String,
+    defaultValue: String,
+    placement: { type: String, default: "left" },
+    offset: { type: Number, default: 0 },
+    navMinWidth: { type: Number, default: 220 },
+    navMaxWidth: { type: Number, default: 320 },
+    contentPadding: { type: Number, default: 12 },
+    contentScrollable: { type: Boolean, default: true },
+    autoHeight: { type: Boolean, default: false },
+    autoWidth: { type: Boolean, default: false },
+    indicatorVariant: { type: String, default: "line" },
+    indicatorMotion: { type: String, default: "stretch" },
+    indicatorMotionStrength: { type: Number, default: 1 },
+    autoHeightDurationMs: { type: Number, default: 250 },
+    autoHeightEasing: { type: String, default: "ease" },
+    animation: { type: Object, default: void 0 }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(props, { slots, emit, expose }) {
+    const activeNode = vue.ref();
+    const slotWrapper = vue.ref();
+    const autoSizerRef = vue.ref();
+    const placement = vue.computed(() => {
+      const v = props.placement;
+      return v === "left" || v === "right" || v === "top" || v === "bottom" ? v : "left";
+    });
+    const isVertical = vue.computed(() => placement.value === "left" || placement.value === "right");
+    const indicatorVariant = vue.computed(() => {
+      const v = props.indicatorVariant;
+      if (v === "line" || v === "pill" || v === "block" || v === "dot" || v === "outline")
+        return v;
+      return "line";
+    });
+    const indicatorMotion = vue.computed(() => {
+      const v = props.indicatorMotion;
+      if (v === "stretch" || v === "warp" || v === "glide" || v === "snap" || v === "spring")
+        return v;
+      return "stretch";
+    });
+    const indicatorMotionStrength = vue.computed(() => {
+      return typeof props.indicatorMotionStrength === "number" ? Math.max(0, props.indicatorMotionStrength) : 1;
+    });
+    function getNodeName(vnode) {
+      return vnode?.props?.name ?? "";
+    }
+    function setActive(vnode) {
+      activeNode.value = vnode;
+      emit("update:modelValue", getNodeName(vnode));
+      emit("change", getNodeName(vnode));
+    }
+    const animationSize = vue.computed(() => {
+      const raw = props.animation?.size;
+      if (typeof raw === "boolean") {
+        return {
+          enabled: raw,
+          durationMs: props.autoHeightDurationMs,
+          easing: props.autoHeightEasing
+        };
+      }
+      if (raw && typeof raw === "object") {
+        return {
+          enabled: raw.enabled !== false,
+          durationMs: typeof raw.durationMs === "number" ? raw.durationMs : props.autoHeightDurationMs,
+          easing: typeof raw.easing === "string" ? raw.easing : props.autoHeightEasing
+        };
+      }
+      return {
+        enabled: !!(props.autoHeight || props.autoWidth),
+        durationMs: props.autoHeightDurationMs,
+        easing: props.autoHeightEasing
+      };
+    });
+    const animationIndicator = vue.computed(() => {
+      const raw = props.animation?.indicator;
+      if (typeof raw === "boolean") {
+        return {
+          enabled: raw,
+          durationMs: 180,
+          easing: "cubic-bezier(0.34, 1.56, 0.64, 1)"
+        };
+      }
+      if (raw && typeof raw === "object") {
+        return {
+          enabled: raw.enabled !== false,
+          durationMs: typeof raw.durationMs === "number" ? raw.durationMs : 180,
+          easing: typeof raw.easing === "string" ? raw.easing : "cubic-bezier(0.34, 1.56, 0.64, 1)"
+        };
+      }
+      return {
+        enabled: true,
+        durationMs: 180,
+        easing: "cubic-bezier(0.34, 1.56, 0.64, 1)"
+      };
+    });
+    const animationNav = vue.computed(() => {
+      const raw = props.animation?.nav;
+      if (typeof raw === "boolean") {
+        return {
+          enabled: raw,
+          durationMs: 220,
+          easing: "ease"
+        };
+      }
+      if (raw && typeof raw === "object") {
+        return {
+          enabled: raw.enabled !== false,
+          durationMs: typeof raw.durationMs === "number" ? raw.durationMs : 220,
+          easing: typeof raw.easing === "string" ? raw.easing : "ease"
+        };
+      }
+      return {
+        enabled: true,
+        durationMs: 220,
+        easing: "ease"
+      };
+    });
+    const animationContent = vue.computed(() => {
+      const raw = props.animation?.content;
+      if (typeof raw === "boolean")
+        return { enabled: raw };
+      if (raw && typeof raw === "object")
+        return { enabled: raw.enabled !== false };
+      return { enabled: true };
+    });
+    const widthAnimEnabled = vue.computed(() => {
+      return animationSize.value.enabled && !!props.autoWidth;
+    });
+    const heightAnimEnabled = vue.computed(() => {
+      return animationSize.value.enabled && (!!props.autoHeight || !props.contentScrollable);
+    });
+    const contentScrollable = vue.computed(() => {
+      return props.contentScrollable && !heightAnimEnabled.value;
+    });
+    const sizeAnimEnabled = vue.computed(() => {
+      return widthAnimEnabled.value || heightAnimEnabled.value;
+    });
+    async function runAutoHeight(action) {
+      if (!sizeAnimEnabled.value) {
+        action();
+        return;
+      }
+      const api = autoSizerRef.value;
+      if (api?.flip) {
+        await api.flip(async () => {
+          action();
+        });
+        return;
+      }
+      action();
+      api?.refresh?.();
+    }
+    async function exposedFlip(action) {
+      const api = autoSizerRef.value;
+      if (api?.flip)
+        return api.flip(action);
+      return action();
+    }
+    async function exposedAction(fn, optionsOrDetect) {
+      const api = autoSizerRef.value;
+      if (api?.action)
+        return api.action(fn, optionsOrDetect);
+      await fn(void 0);
+      return { changedKeys: [] };
+    }
+    expose({
+      refresh: () => autoSizerRef.value?.refresh?.(),
+      flip: exposedFlip,
+      action: exposedAction,
+      size: () => autoSizerRef.value?.size?.value
+    });
+    function findByName(name) {
+      const nodes = slots.default?.() ?? [];
+      return nodes.find((n) => n?.props?.name === name);
+    }
+    const pointerElRef = vue.ref(null);
+    const pointerInnerElRef = vue.ref(null);
+    const navElRef = vue.ref(null);
+    const navInnerElRef = vue.ref(null);
+    const contentRootElRef = vue.ref(null);
+    let pointerAnimTimer = null;
+    vue.onBeforeUnmount(() => {
+      if (pointerAnimTimer != null)
+        window.clearTimeout(pointerAnimTimer);
+      pointerAnimTimer = null;
+    });
+    vue.watch(
+      () => [contentRootElRef.value, sizeAnimEnabled.value],
+      ([el, enabled]) => {
+      },
+      { immediate: true }
+    );
+    function playPointerAnim() {
+      const el = pointerInnerElRef.value;
+      if (!el)
+        return;
+      const motions = ["stretch", "warp", "glide", "snap", "spring"];
+      for (const m of motions) {
+        el.classList.remove(`tx-tabs__pointer--motion-${m}-x`);
+        el.classList.remove(`tx-tabs__pointer--motion-${m}-y`);
+      }
+      const cls = isVertical.value ? `tx-tabs__pointer--motion-${indicatorMotion.value}-y` : `tx-tabs__pointer--motion-${indicatorMotion.value}-x`;
+      void el.offsetWidth;
+      el.classList.add(cls);
+      if (pointerAnimTimer != null)
+        window.clearTimeout(pointerAnimTimer);
+      pointerAnimTimer = window.setTimeout(() => {
+        el.classList.remove(cls);
+        pointerAnimTimer = null;
+      }, Math.max(120, (animationIndicator.value?.durationMs ?? 180) + 120));
+    }
+    function applyPointerFor(vnodeOrEl) {
+      const pointerEl = pointerElRef.value;
+      const nodeEl = vnodeOrEl?.el ?? vnodeOrEl;
+      const navInnerEl = navInnerElRef.value;
+      if (!pointerEl || !nodeEl || !navInnerEl)
+        return;
+      const nodeRect = nodeEl.getBoundingClientRect();
+      const navInnerRect = navInnerEl.getBoundingClientRect();
+      const diff = props.offset || 0;
+      pointerEl.style.opacity = "1";
+      pointerEl.style.width = "";
+      pointerEl.style.height = "";
+      const variant = indicatorVariant.value;
+      if (isVertical.value) {
+        const topBase = nodeRect.top - navInnerRect.top + navInnerEl.scrollTop;
+        const leftBase = nodeRect.left - navInnerRect.left + navInnerEl.scrollLeft;
+        const navInnerWidth = navInnerEl.clientWidth;
+        if (variant === "block" || variant === "outline") {
+          pointerEl.style.transform = `translate3d(${leftBase}px, ${topBase}px, 0)`;
+          pointerEl.style.width = `${nodeRect.width}px`;
+          pointerEl.style.height = `${nodeRect.height}px`;
+        } else if (variant === "dot") {
+          const top = topBase + nodeRect.height * 0.5 - 4;
+          const x = placement.value === "right" ? navInnerWidth - 8 - 8 : 8;
+          pointerEl.style.transform = `translate3d(${x}px, ${top}px, 0)`;
+          pointerEl.style.height = `8px`;
+          pointerEl.style.width = `8px`;
+        } else {
+          const top = topBase + nodeRect.height * 0.2 + diff;
+          const thickness = variant === "pill" ? 6 : 3;
+          const x = placement.value === "right" ? navInnerWidth - thickness : 0;
+          pointerEl.style.transform = `translate3d(${x}px, ${top}px, 0)`;
+          pointerEl.style.width = `${thickness}px`;
+          pointerEl.style.height = `${nodeRect.height * 0.6}px`;
+        }
+      } else {
+        const topBase = nodeRect.top - navInnerRect.top + navInnerEl.scrollTop;
+        const leftBase = nodeRect.left - navInnerRect.left + navInnerEl.scrollLeft;
+        const navInnerHeight = navInnerEl.clientHeight;
+        if (variant === "block" || variant === "outline") {
+          pointerEl.style.transform = `translate3d(${leftBase}px, ${topBase}px, 0)`;
+          pointerEl.style.width = `${nodeRect.width}px`;
+          pointerEl.style.height = `${nodeRect.height}px`;
+        } else if (variant === "dot") {
+          const left = leftBase + nodeRect.width * 0.5 - 4;
+          const y = placement.value === "bottom" ? 8 : navInnerHeight - 8 - 8;
+          pointerEl.style.transform = `translate3d(${left}px, ${y}px, 0)`;
+          pointerEl.style.width = `8px`;
+          pointerEl.style.height = `8px`;
+        } else {
+          const left = leftBase + nodeRect.width * 0.2 + diff;
+          const thickness = variant === "pill" ? 6 : 3;
+          const y = placement.value === "bottom" ? 0 : navInnerHeight - thickness;
+          pointerEl.style.transform = `translate3d(${left}px, ${y}px, 0)`;
+          pointerEl.style.width = `${nodeRect.width * 0.6}px`;
+          pointerEl.style.height = `${thickness}px`;
+        }
+      }
+      playPointerAnim();
+    }
+    function createTab(vnode) {
+      const tab = vue.h(TxTabItem.default, {
+        ...vnode.props,
+        active: activeNode.value?.props?.name === vnode.props?.name,
+        onClick: () => {
+          if (vnode.props?.disabled)
+            return;
+          const el = slotWrapper.value?.el;
+          if (el) {
+            if (animationContent.value.enabled)
+              el.classList.remove("tx-tabs-zoom");
+            void runAutoHeight(() => setActive(vnode)).then(() => {
+              vue.nextTick(() => {
+                applyPointerFor(tab);
+                if (animationContent.value.enabled)
+                  el.classList.add("tx-tabs-zoom");
+              });
+            });
+          }
+        }
+      });
+      const isDefault = !!vnode.props?.activation;
+      if (!activeNode.value && isDefault) {
+        setActive(vnode);
+        vue.nextTick(() => applyPointerFor(tab));
+      }
+      return tab;
+    }
+    function renderTabs() {
+      let tabHeader = null;
+      const nodes = slots.default?.() ?? [];
+      const filtered = nodes.filter((slot) => {
+        const type = slot?.type;
+        return type && typeof type === "object" && "name" in type && type.name && qualifiedName.includes(type.name);
+      }).map((child) => {
+        const childName = child?.type?.name;
+        if (childName === "TxTabHeader") {
+          tabHeader = child;
+          return null;
+        }
+        if (childName === "TxTabItemGroup") {
+          return vue.h("div", { class: "tx-tabs__group" }, [
+            vue.h("div", { class: "tx-tabs__group-name" }, child.props?.name),
+            child.children && typeof child.children === "object" && "default" in child.children && typeof child.children.default === "function" ? child.children.default?.()?.map(createTab) : []
+          ]);
+        }
+        return createTab(child);
+      }).filter(Boolean);
+      return [filtered, tabHeader];
+    }
+    function renderContent(tabHeader) {
+      if (!activeNode.value) {
+        return vue.h("div", { class: "tx-tabs__empty" }, "No tab selected");
+      }
+      const contentWrapper = vue.h("div", { class: "tx-tabs__content-wrapper" }, activeNode.value.children?.default?.());
+      const content = contentScrollable.value ? vue.h("div", { class: "tx-tabs__content-scroll" }, [contentWrapper]) : contentWrapper;
+      if (tabHeader) {
+        const headerVNode = vue.h(
+          TxTabHeader.default,
+          { ...tabHeader.props, node: activeNode.value },
+          tabHeader.children
+        );
+        return [headerVNode, content];
+      }
+      return content;
+    }
+    vue.watch(
+      () => props.modelValue,
+      (val) => {
+        if (!val)
+          return;
+        const node = findByName(val);
+        if (node) {
+          void runAutoHeight(() => {
+            activeNode.value = node;
+          }).then(() => {
+            vue.nextTick(() => {
+              const el = navInnerElRef.value?.querySelector(".tx-tab-item.is-active");
+              applyPointerFor(el);
+            });
+          });
+        }
+      },
+      { immediate: true }
+    );
+    vue.watch(
+      () => props.defaultValue,
+      (val) => {
+        if (!val || props.modelValue)
+          return;
+        const node = findByName(val);
+        if (node) {
+          void runAutoHeight(() => setActive(node)).then(() => {
+            vue.nextTick(() => {
+              const el = navInnerElRef.value?.querySelector(".tx-tab-item.is-active");
+              applyPointerFor(el);
+            });
+          });
+        }
+      },
+      { immediate: true }
+    );
+    return () => {
+      const [tabs, tabHeader] = renderTabs();
+      const navRightSlot = slots["nav-right"]?.();
+      const pointer = vue.h(
+        "div",
+        {
+          ref: pointerElRef,
+          class: "tx-tabs__pointer"
+        },
+        [
+          vue.h("div", {
+            ref: pointerInnerElRef,
+            class: "tx-tabs__pointer-inner"
+          })
+        ]
+      );
+      const selectSlot = vue.h(
+        "div",
+        {
+          ref: (el) => contentRootElRef.value = el,
+          class: ["tx-tabs__select-slot", { "tx-tabs-zoom": animationContent.value.enabled }]
+        },
+        renderContent(tabHeader)
+      );
+      slotWrapper.value = selectSlot;
+      const outerClass = contentScrollable.value ? "tx-tabs__auto-sizer tx-tabs__auto-sizer--fill" : "tx-tabs__auto-sizer overflow-hidden";
+      const content = vue.h(
+        TxAutoSizer_vue_vue_type_script_setup_true_lang.default,
+        {
+          ref: (el) => autoSizerRef.value = el,
+          width: widthAnimEnabled.value,
+          height: heightAnimEnabled.value,
+          durationMs: animationSize.value.durationMs,
+          easing: animationSize.value.easing,
+          outerClass
+        },
+        {
+          default: () => selectSlot
+        }
+      );
+      const navStyle = isVertical.value ? {
+        minWidth: `${props.navMinWidth}px`,
+        maxWidth: `${props.navMaxWidth}px`
+      } : void 0;
+      const nav = vue.h(
+        "div",
+        {
+          ref: (el) => navElRef.value = el,
+          class: "tx-tabs__nav",
+          style: navStyle
+        },
+        [
+          vue.h(
+            "div",
+            {
+              class: "tx-tabs__nav-bar"
+            },
+            [
+              vue.h(
+                "div",
+                {
+                  ref: (el) => navInnerElRef.value = el,
+                  class: "tx-tabs__nav-inner"
+                },
+                [...tabs, pointer]
+              ),
+              navRightSlot ? vue.h("div", { class: "tx-tabs__nav-extra" }, navRightSlot) : null
+            ]
+          )
+        ]
+      );
+      const main = vue.h(
+        "div",
+        {
+          class: "tx-tabs__main",
+          style: { padding: `${props.contentPadding}px` }
+        },
+        [content]
+      );
+      const reverse = placement.value === "right" || placement.value === "bottom";
+      const children = reverse ? [main, nav] : [nav, main];
+      return vue.h(
+        "div",
+        {
+          class: [
+            "tx-tabs",
+            `tx-tabs--${placement.value}`,
+            `tx-tabs--indicator-${indicatorVariant.value}`,
+            `tx-tabs--motion-${indicatorMotion.value}`,
+            {
+              "tx-tabs--auto-height": heightAnimEnabled.value,
+              "tx-tabs--auto-width": !!props.autoWidth,
+              "tx-tabs--indicator-anim": animationIndicator.value.enabled,
+              "tx-tabs--nav-anim": animationNav.value.enabled,
+              "tx-tabs--content-anim": animationContent.value.enabled
+            }
+          ],
+          style: {
+            "--tx-tabs-indicator-duration": `${animationIndicator.value.durationMs}ms`,
+            "--tx-tabs-indicator-easing": animationIndicator.value.easing,
+            "--tx-tabs-indicator-strength": `${indicatorMotionStrength.value}`,
+            "--tx-tabs-nav-duration": `${animationNav.value.durationMs}ms`,
+            "--tx-tabs-nav-easing": animationNav.value.easing
+          }
+        },
+        children
+      );
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/tag/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../utils/withInstall.js');
+const TxTag_vue_vue_type_script_setup_true_lang = require('./src/TxTag.vue.js');
+;/* empty css                */
+
+const Tag = withInstall.withInstall(TxTag_vue_vue_type_script_setup_true_lang.default);
+
+exports.TxTag = TxTag_vue_vue_type_script_setup_true_lang.default;
+exports.Tag = Tag;
+exports.default = Tag;

package/dist/lib/tag/src/TxTag.vue.js

@@ -0,0 +1,108 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+const _hoisted_1 = { class: "tx-tag__content" };
+const _hoisted_2 = ["disabled"];
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "TxTag"
+  },
+  __name: "TxTag",
+  props: {
+    label: { default: "" },
+    icon: { default: "" },
+    color: { default: "var(--tx-color-primary)" },
+    background: { default: "" },
+    border: { default: "" },
+    size: { default: "sm" },
+    closable: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false }
+  },
+  emits: ["close", "click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const safeLabel = vue.computed(() => {
+      return props.label ?? "";
+    });
+    const safeColor = vue.computed(() => {
+      return props.color || "var(--tx-color-primary)";
+    });
+    const resolvedBackground = vue.computed(() => {
+      if (props.background)
+        return props.background;
+      return `color-mix(in srgb, ${safeColor.value} 12%, transparent)`;
+    });
+    const resolvedBorder = vue.computed(() => {
+      if (props.border)
+        return props.border;
+      return `color-mix(in srgb, ${safeColor.value} 32%, transparent)`;
+    });
+    const styleVars = vue.computed(() => ({
+      "--tx-tag-color": safeColor.value,
+      "--tx-tag-bg": resolvedBackground.value,
+      "--tx-tag-border": resolvedBorder.value
+    }));
+    function handleClick(event) {
+      if (props.disabled)
+        return;
+      emit("click", event);
+    }
+    function handleClose(event) {
+      event.stopPropagation();
+      if (props.disabled)
+        return;
+      emit("close");
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("span", {
+        class: vue.normalizeClass(["tx-tag", [
+          `tx-tag--${__props.size}`,
+          {
+            "tx-tag--closable": __props.closable,
+            "tx-tag--disabled": __props.disabled
+          }
+        ]]),
+        style: vue.normalizeStyle(styleVars.value),
+        role: "status",
+        onClick: handleClick
+      }, [
+        __props.icon ? (vue.openBlock(), vue.createElementBlock("i", {
+          key: 0,
+          class: vue.normalizeClass([__props.icon, "tx-tag__icon"]),
+          "aria-hidden": "true"
+        }, null, 2)) : vue.createCommentVNode("", true),
+        vue.createElementVNode("span", _hoisted_1, [
+          vue.renderSlot(_ctx.$slots, "default", {}, () => [
+            vue.createTextVNode(vue.toDisplayString(safeLabel.value), 1)
+          ])
+        ]),
+        __props.closable ? (vue.openBlock(), vue.createElementBlock("button", {
+          key: 1,
+          type: "button",
+          class: "tx-tag__close",
+          disabled: __props.disabled,
+          "aria-label": "Remove tag",
+          onClick: handleClose
+        }, [..._cache[0] || (_cache[0] = [
+          vue.createElementVNode("svg", {
+            viewBox: "0 0 24 24",
+            width: "12",
+            height: "12",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-width": "2",
+            "stroke-linecap": "round"
+          }, [
+            vue.createElementVNode("path", { d: "M18 6L6 18M6 6l12 12" })
+          ], -1)
+        ])], 8, _hoisted_2)) : vue.createCommentVNode("", true)
+      ], 6);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/tag/src/TxTag.vue3.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxTag_vue_vue_type_script_setup_true_lang = require('./TxTag.vue.js');
+;/* empty css            */
+
+
+
+exports.default = TxTag_vue_vue_type_script_setup_true_lang.default;

package/dist/lib/tag-input/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../utils/withInstall.js');
+const TxTagInput = require('./src/TxTagInput.vue.js');
+
+const TagInput = withInstall.withInstall(TxTagInput.default);
+
+exports.TxTagInput = TxTagInput.default;
+exports.TagInput = TagInput;
+exports.default = TagInput;

package/dist/lib/tag-input/src/TxTagInput.vue.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxTagInput_vue_vue_type_script_setup_true_lang = require('./TxTagInput.vue2.js');
+;/* empty css                 */
+const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
+
+const TxTagInput = /* @__PURE__ */ _pluginVue_exportHelper.default(TxTagInput_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-c2c207bb"]]);
+
+exports.default = TxTagInput;