@talex-touch/tuffex 0.3.3

package/dist/lib/form/src/TxFormItem.vue2.js

@@ -0,0 +1,134 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const context = require('./context.js');
+
+const _hoisted_1 = { class: "tx-form-item__content" };
+const _hoisted_2 = {
+  key: 0,
+  class: "tx-form-item__error"
+};
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxFormItem" },
+  __name: "TxFormItem",
+  props: {
+    label: { default: "" },
+    prop: {},
+    rules: {},
+    required: { type: Boolean, default: false },
+    showMessage: { type: Boolean, default: true },
+    inline: { type: Boolean, default: false }
+  },
+  emits: ["validate"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const form = vue.inject(context.TX_FORM_CONTEXT_KEY, null);
+    const errorMessage = vue.ref("");
+    const initialValue = vue.ref(void 0);
+    const fieldValue = vue.computed(() => {
+      if (!form?.model || !props.prop)
+        return void 0;
+      return form.model[props.prop];
+    });
+    const resolvedRules = vue.computed(() => {
+      const local = props.rules;
+      const fromForm = props.prop ? form?.rules?.[props.prop] : void 0;
+      const merged = local ?? fromForm;
+      if (!merged)
+        return [];
+      return Array.isArray(merged) ? merged : [merged];
+    });
+    const isRequired = vue.computed(() => {
+      if (props.required)
+        return true;
+      return resolvedRules.value.some((rule) => rule.required);
+    });
+    const labelText = vue.computed(() => props.label || props.prop || "");
+    function isEmpty(value) {
+      if (value === null || value === void 0 || value === "")
+        return true;
+      if (Array.isArray(value))
+        return value.length === 0;
+      return false;
+    }
+    async function runRule(rule) {
+      const value = fieldValue.value;
+      const message = rule.message || `${labelText.value || "Field"} is invalid`;
+      if (rule.required || props.required) {
+        if (isEmpty(value))
+          return rule.message || `${labelText.value || "Field"} is required`;
+      }
+      if (rule.validator) {
+        const result = await rule.validator(value, rule, form?.model ?? {});
+        if (result === false)
+          return message;
+        if (typeof result === "string")
+          return result;
+      }
+      return null;
+    }
+    async function validate() {
+      for (const rule of resolvedRules.value) {
+        const message = await runRule(rule);
+        if (message) {
+          errorMessage.value = message;
+          emit("validate", false);
+          return false;
+        }
+      }
+      errorMessage.value = "";
+      emit("validate", true);
+      return true;
+    }
+    function clearValidate() {
+      errorMessage.value = "";
+    }
+    function reset() {
+      if (form?.model && props.prop)
+        form.model[props.prop] = initialValue.value;
+      clearValidate();
+    }
+    const itemContext = { prop: props.prop, validate, reset, clearValidate };
+    const labelStyle = vue.computed(() => {
+      if (form?.labelPosition.value === "top")
+        return {};
+      const width = form?.labelWidth.value;
+      if (!width)
+        return {};
+      return {
+        width: typeof width === "number" ? `${width}px` : width
+      };
+    });
+    vue.onMounted(() => {
+      if (form?.model && props.prop)
+        initialValue.value = form.model[props.prop];
+      form?.registerItem(itemContext);
+    });
+    vue.onBeforeUnmount(() => {
+      form?.unregisterItem(itemContext);
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(["tx-form-item", [
+          `tx-form-item--label-${vue.unref(form)?.labelPosition.value ?? "left"}`,
+          { "is-error": !!errorMessage.value, "is-required": isRequired.value, "is-inline": __props.inline }
+        ]])
+      }, [
+        labelText.value ? (vue.openBlock(), vue.createElementBlock("label", {
+          key: 0,
+          class: "tx-form-item__label",
+          style: vue.normalizeStyle(labelStyle.value)
+        }, vue.toDisplayString(labelText.value), 5)) : vue.createCommentVNode("", true),
+        vue.createElementVNode("div", _hoisted_1, [
+          vue.renderSlot(_ctx.$slots, "default", {}, void 0, true),
+          __props.showMessage && errorMessage.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, vue.toDisplayString(errorMessage.value), 1)) : vue.createCommentVNode("", true)
+        ])
+      ], 2);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/form/src/context.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const TX_FORM_CONTEXT_KEY = Symbol("TxFormContext");
+
+exports.TX_FORM_CONTEXT_KEY = TX_FORM_CONTEXT_KEY;

package/dist/lib/fusion/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 TxFusion = require('./src/TxFusion.vue.js');
+
+const Fusion = withInstall.withInstall(TxFusion.default);
+
+exports.TxFusion = TxFusion.default;
+exports.Fusion = Fusion;
+exports.default = Fusion;

package/dist/lib/fusion/src/TxFusion.vue.js

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

package/dist/lib/fusion/src/TxFusion.vue2.js

@@ -0,0 +1,124 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+
+const _hoisted_1 = {
+  class: "tx-fusion__filters",
+  width: "0",
+  height: "0",
+  "aria-hidden": "true"
+};
+const _hoisted_2 = ["stdDeviation"];
+const _hoisted_3 = ["values"];
+const _hoisted_4 = { class: "tx-fusion__blob tx-fusion__blob--a" };
+const _hoisted_5 = { class: "tx-fusion__blob tx-fusion__blob--b" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "TxFusion" },
+  __name: "TxFusion",
+  props: {
+    modelValue: { type: Boolean, default: void 0 },
+    disabled: { type: Boolean, default: false },
+    trigger: { default: "hover" },
+    direction: { default: "x" },
+    gap: { default: 40 },
+    duration: { default: 260 },
+    easing: { default: "cubic-bezier(0.2, 0.8, 0.2, 1)" },
+    blur: { default: 19 },
+    alpha: { default: 29 },
+    alphaOffset: { default: -10 }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const internalActive = vue.ref(false);
+    const active = vue.computed({
+      get: () => typeof props.modelValue === "boolean" ? props.modelValue : internalActive.value,
+      set: (v) => {
+        if (props.disabled)
+          return;
+        if (typeof props.modelValue !== "boolean")
+          internalActive.value = v;
+        emit("update:modelValue", v);
+        emit("change", v);
+      }
+    });
+    const uid = vue.getCurrentInstance()?.uid ?? Math.floor(Math.random() * 1e9);
+    const filterId = `tx-fusion-goo-${uid}`;
+    function onEnter() {
+      if (props.trigger !== "hover")
+        return;
+      active.value = true;
+    }
+    function onLeave() {
+      if (props.trigger !== "hover")
+        return;
+      active.value = false;
+    }
+    function onClick() {
+      if (props.trigger !== "click")
+        return;
+      active.value = !active.value;
+    }
+    const stageStyle = vue.computed(() => {
+      const d = Math.max(0, props.duration);
+      return {
+        "--tx-fusion-duration": `${d}ms`,
+        "--tx-fusion-easing": props.easing,
+        "--tx-fusion-gap": `${props.gap}px`,
+        "--tx-fusion-blur": `${props.blur}px`
+      };
+    });
+    const matrixValues = vue.computed(() => {
+      const a = Number.isFinite(props.alpha) ? props.alpha : 18;
+      const o = Number.isFinite(props.alphaOffset) ? props.alphaOffset : -7;
+      return `1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 ${a} ${o}`;
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(["tx-fusion", { "is-active": active.value, "is-disabled": __props.disabled, "is-dir-y": __props.direction === "y" }]),
+        onMouseenter: onEnter,
+        onMouseleave: onLeave,
+        onClick
+      }, [
+        (vue.openBlock(), vue.createElementBlock("svg", _hoisted_1, [
+          vue.createElementVNode("defs", null, [
+            vue.createElementVNode("filter", { id: filterId }, [
+              vue.createElementVNode("feGaussianBlur", {
+                in: "SourceGraphic",
+                stdDeviation: props.blur,
+                result: "blur"
+              }, null, 8, _hoisted_2),
+              vue.createElementVNode("feColorMatrix", {
+                in: "blur",
+                mode: "matrix",
+                values: matrixValues.value,
+                result: "goo"
+              }, null, 8, _hoisted_3)
+            ])
+          ])
+        ])),
+        vue.createElementVNode("div", {
+          class: "tx-fusion__stage",
+          style: vue.normalizeStyle(stageStyle.value)
+        }, [
+          vue.createElementVNode("div", {
+            class: "tx-fusion__goo",
+            style: vue.normalizeStyle({ filter: `url(#${filterId})` })
+          }, [
+            vue.createElementVNode("div", _hoisted_4, [
+              vue.renderSlot(_ctx.$slots, "a", {}, void 0, true)
+            ]),
+            vue.createElementVNode("div", _hoisted_5, [
+              vue.renderSlot(_ctx.$slots, "b", {}, void 0, true)
+            ])
+          ], 4)
+        ], 4)
+      ], 34);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/glass-surface/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 TxGlassSurface_vue_vue_type_script_setup_true_lang = require('./src/TxGlassSurface.vue.js');
+;/* empty css                         */
+
+const GlassSurface = withInstall.withInstall(TxGlassSurface_vue_vue_type_script_setup_true_lang.default);
+
+exports.TxGlassSurface = TxGlassSurface_vue_vue_type_script_setup_true_lang.default;
+exports.GlassSurface = GlassSurface;
+exports.default = GlassSurface;

package/dist/lib/glass-surface/src/TxGlassSurface.vue.js

@@ -0,0 +1,307 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const env = require('../../utils/env.js');
+
+const _hoisted_1 = {
+  class: "tx-glass-surface__svg",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _hoisted_2 = { class: "tx-glass-surface__content" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "TxGlassSurface"
+  },
+  __name: "TxGlassSurface",
+  props: {
+    width: { default: "200px" },
+    height: { default: "200px" },
+    borderRadius: { default: 20 },
+    borderWidth: { default: 0.07 },
+    brightness: { default: 70 },
+    opacity: { default: 0.93 },
+    blur: { default: 11 },
+    displace: { default: 0.5 },
+    backgroundOpacity: { default: 0 },
+    saturation: { default: 1 },
+    distortionScale: { default: -180 },
+    redOffset: { default: 0 },
+    greenOffset: { default: 10 },
+    blueOffset: { default: 20 },
+    xChannel: { default: "R" },
+    yChannel: { default: "G" },
+    mixBlendMode: { default: "difference" }
+  },
+  setup(__props) {
+    const props = __props;
+    const isDarkMode = vue.ref(false);
+    const containerRef = vue.ref(null);
+    const feImageRef = vue.ref(null);
+    const redChannelRef = vue.ref(null);
+    const greenChannelRef = vue.ref(null);
+    const blueChannelRef = vue.ref(null);
+    const gaussianBlurRef = vue.ref(null);
+    function generateUniqueId() {
+      return Math.random().toString(36).substring(2, 15);
+    }
+    const uniqueId = generateUniqueId();
+    const filterId = `tx-glass-filter-${uniqueId}`;
+    const redGradId = `tx-glass-red-grad-${uniqueId}`;
+    const blueGradId = `tx-glass-blue-grad-${uniqueId}`;
+    let resizeObserver = null;
+    function updateDarkMode() {
+      if (!env.hasWindow())
+        return;
+      const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+      isDarkMode.value = mediaQuery.matches;
+      const handler = (e) => {
+        isDarkMode.value = e.matches;
+      };
+      mediaQuery.addEventListener("change", handler);
+      return () => mediaQuery.removeEventListener("change", handler);
+    }
+    function supportsSVGFilters() {
+      if (!env.hasWindow() || !env.hasNavigator() || !env.hasDocument())
+        return false;
+      const isWebkit = /Safari/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent);
+      const isFirefox = /Firefox/.test(navigator.userAgent);
+      if (isWebkit || isFirefox)
+        return false;
+      const value = `url(#${filterId})`;
+      if (typeof CSS === "undefined" || typeof CSS.supports !== "function")
+        return false;
+      return CSS.supports("backdrop-filter", value) || CSS.supports("-webkit-backdrop-filter", value);
+    }
+    function supportsBackdropFilter() {
+      if (!env.hasWindow())
+        return false;
+      return CSS.supports("backdrop-filter", "blur(10px)");
+    }
+    function generateDisplacementMap() {
+      const rect = containerRef.value?.getBoundingClientRect();
+      const actualWidth = rect?.width || 400;
+      const actualHeight = rect?.height || 200;
+      const edgeSize = Math.min(actualWidth, actualHeight) * (props.borderWidth * 0.5);
+      const svgContent = `
+      <svg viewBox="0 0 ${actualWidth} ${actualHeight}" xmlns="http://www.w3.org/2000/svg">
+        <defs>
+          <linearGradient id="${redGradId}" x1="100%" y1="0%" x2="0%" y2="0%">
+            <stop offset="0%" stop-color="#0000"/>
+            <stop offset="100%" stop-color="red"/>
+          </linearGradient>
+          <linearGradient id="${blueGradId}" x1="0%" y1="0%" x2="0%" y2="100%">
+            <stop offset="0%" stop-color="#0000"/>
+            <stop offset="100%" stop-color="blue"/>
+          </linearGradient>
+        </defs>
+        <rect x="0" y="0" width="${actualWidth}" height="${actualHeight}" fill="black"></rect>
+        <rect x="0" y="0" width="${actualWidth}" height="${actualHeight}" rx="${props.borderRadius}" fill="url(#${redGradId})" />
+        <rect x="0" y="0" width="${actualWidth}" height="${actualHeight}" rx="${props.borderRadius}" fill="url(#${blueGradId})" style="mix-blend-mode: ${props.mixBlendMode}" />
+        <rect x="${edgeSize}" y="${edgeSize}" width="${actualWidth - edgeSize * 2}" height="${actualHeight - edgeSize * 2}" rx="${props.borderRadius}" fill="hsl(0 0% ${props.brightness}% / ${props.opacity})" style="filter:blur(${props.blur}px)" />
+      </svg>
+    `;
+      return `data:image/svg+xml,${encodeURIComponent(svgContent)}`;
+    }
+    function updateDisplacementMap() {
+      if (feImageRef.value) {
+        feImageRef.value.setAttribute("href", generateDisplacementMap());
+      }
+    }
+    function updateFilterElements() {
+      const elements = [
+        { el: redChannelRef.value, offset: props.redOffset },
+        { el: greenChannelRef.value, offset: props.greenOffset },
+        { el: blueChannelRef.value, offset: props.blueOffset }
+      ];
+      for (const { el, offset } of elements) {
+        if (el) {
+          el.setAttribute("scale", (props.distortionScale + offset).toString());
+          el.setAttribute("xChannelSelector", props.xChannel);
+          el.setAttribute("yChannelSelector", props.yChannel);
+        }
+      }
+      if (gaussianBlurRef.value) {
+        gaussianBlurRef.value.setAttribute("stdDeviation", props.displace.toString());
+      }
+    }
+    const containerStyles = vue.computed(() => {
+      const baseStyles = {
+        width: typeof props.width === "number" ? `${props.width}px` : props.width,
+        height: typeof props.height === "number" ? `${props.height}px` : props.height,
+        borderRadius: `${props.borderRadius}px`
+      };
+      const fallbackBlur = Math.max(0, props.blur);
+      const svgSupported = supportsSVGFilters();
+      const backdropFilterSupported = supportsBackdropFilter();
+      if (svgSupported) {
+        return {
+          ...baseStyles,
+          background: isDarkMode.value ? `hsl(0 0% 0% / ${props.backgroundOpacity})` : `hsl(0 0% 100% / ${props.backgroundOpacity})`,
+          backdropFilter: `url(#${filterId}) saturate(${props.saturation})`
+        };
+      }
+      if (isDarkMode.value) {
+        if (!backdropFilterSupported) {
+          return {
+            ...baseStyles,
+            background: "rgba(0, 0, 0, 0.4)",
+            border: "1px solid rgba(255, 255, 255, 0.2)"
+          };
+        }
+        return {
+          ...baseStyles,
+          background: "rgba(255, 255, 255, 0.1)",
+          backdropFilter: `blur(${fallbackBlur}px) saturate(1.8) brightness(1.2)`,
+          WebkitBackdropFilter: `blur(${fallbackBlur}px) saturate(1.8) brightness(1.2)`,
+          border: "1px solid rgba(255, 255, 255, 0.2)"
+        };
+      }
+      if (!backdropFilterSupported) {
+        return {
+          ...baseStyles,
+          background: "rgba(255, 255, 255, 0.4)",
+          border: "1px solid rgba(255, 255, 255, 0.3)"
+        };
+      }
+      return {
+        ...baseStyles,
+        background: "rgba(255, 255, 255, 0.25)",
+        backdropFilter: `blur(${fallbackBlur}px) saturate(1.8) brightness(1.1)`,
+        WebkitBackdropFilter: `blur(${fallbackBlur}px) saturate(1.8) brightness(1.1)`,
+        border: "1px solid rgba(255, 255, 255, 0.3)"
+      };
+    });
+    vue.onMounted(() => {
+      updateDarkMode();
+      vue.nextTick(() => {
+        updateDisplacementMap();
+        updateFilterElements();
+        if (containerRef.value && typeof ResizeObserver !== "undefined") {
+          resizeObserver = new ResizeObserver(() => {
+            setTimeout(updateDisplacementMap, 0);
+          });
+          resizeObserver.observe(containerRef.value);
+        }
+      });
+    });
+    vue.watch(
+      [
+        () => props.width,
+        () => props.height,
+        () => props.borderRadius,
+        () => props.borderWidth,
+        () => props.brightness,
+        () => props.opacity,
+        () => props.blur,
+        () => props.displace,
+        () => props.distortionScale,
+        () => props.redOffset,
+        () => props.greenOffset,
+        () => props.blueOffset,
+        () => props.xChannel,
+        () => props.yChannel,
+        () => props.mixBlendMode
+      ],
+      () => {
+        updateDisplacementMap();
+        updateFilterElements();
+      }
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        ref_key: "containerRef",
+        ref: containerRef,
+        class: "tx-glass-surface",
+        style: vue.normalizeStyle(containerStyles.value)
+      }, [
+        (vue.openBlock(), vue.createElementBlock("svg", _hoisted_1, [
+          vue.createElementVNode("defs", null, [
+            vue.createElementVNode("filter", {
+              id: filterId,
+              "color-interpolation-filters": "sRGB",
+              x: "0%",
+              y: "0%",
+              width: "100%",
+              height: "100%"
+            }, [
+              vue.createElementVNode("feImage", {
+                ref_key: "feImageRef",
+                ref: feImageRef,
+                x: "0",
+                y: "0",
+                width: "100%",
+                height: "100%",
+                preserveAspectRatio: "none",
+                result: "map"
+              }, null, 512),
+              vue.createElementVNode("feDisplacementMap", {
+                ref_key: "redChannelRef",
+                ref: redChannelRef,
+                in: "SourceGraphic",
+                in2: "map",
+                result: "dispRed"
+              }, null, 512),
+              _cache[0] || (_cache[0] = vue.createElementVNode("feColorMatrix", {
+                in: "dispRed",
+                type: "matrix",
+                values: "1 0 0 0 0\n                    0 0 0 0 0\n                    0 0 0 0 0\n                    0 0 0 1 0",
+                result: "red"
+              }, null, -1)),
+              vue.createElementVNode("feDisplacementMap", {
+                ref_key: "greenChannelRef",
+                ref: greenChannelRef,
+                in: "SourceGraphic",
+                in2: "map",
+                result: "dispGreen"
+              }, null, 512),
+              _cache[1] || (_cache[1] = vue.createElementVNode("feColorMatrix", {
+                in: "dispGreen",
+                type: "matrix",
+                values: "0 0 0 0 0\n                    0 1 0 0 0\n                    0 0 0 0 0\n                    0 0 0 1 0",
+                result: "green"
+              }, null, -1)),
+              vue.createElementVNode("feDisplacementMap", {
+                ref_key: "blueChannelRef",
+                ref: blueChannelRef,
+                in: "SourceGraphic",
+                in2: "map",
+                result: "dispBlue"
+              }, null, 512),
+              _cache[2] || (_cache[2] = vue.createElementVNode("feColorMatrix", {
+                in: "dispBlue",
+                type: "matrix",
+                values: "0 0 0 0 0\n                    0 0 0 0 0\n                    0 0 1 0 0\n                    0 0 0 1 0",
+                result: "blue"
+              }, null, -1)),
+              _cache[3] || (_cache[3] = vue.createElementVNode("feBlend", {
+                in: "red",
+                in2: "green",
+                mode: "screen",
+                result: "rg"
+              }, null, -1)),
+              _cache[4] || (_cache[4] = vue.createElementVNode("feBlend", {
+                in: "rg",
+                in2: "blue",
+                mode: "screen",
+                result: "output"
+              }, null, -1)),
+              vue.createElementVNode("feGaussianBlur", {
+                ref_key: "gaussianBlurRef",
+                ref: gaussianBlurRef,
+                in: "output",
+                stdDeviation: "0.7"
+              }, null, 512)
+            ])
+          ])
+        ])),
+        vue.createElementVNode("div", _hoisted_2, [
+          vue.renderSlot(_ctx.$slots, "default")
+        ])
+      ], 4);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/glass-surface/src/TxGlassSurface.vue3.js

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

package/dist/lib/glow-text/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 TxGlowText = require('./src/TxGlowText.vue.js');
+
+const GlowText = withInstall.withInstall(TxGlowText.default);
+
+exports.TxGlowText = TxGlowText.default;
+exports.GlowText = GlowText;
+exports.default = GlowText;

package/dist/lib/glow-text/src/TxGlowText.vue.js

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