vlite3 0.0.1

package/components/Alert.vue.js

@@ -0,0 +1,84 @@
+import { defineComponent as C, ref as V, computed as a, useSlots as $, openBlock as n, createElementBlock as i, normalizeClass as r, renderSlot as d, createBlock as B, createCommentVNode as o, createElementVNode as g, toDisplayString as v, createTextVNode as N, createVNode as S } from "vue";
+import m from "./Icon.vue.js";
+const j = ["role"], E = {
+  key: 1,
+  class: "text-sm opacity-90 [&_p]:leading-relaxed"
+}, A = /* @__PURE__ */ C({
+  __name: "Alert",
+  props: {
+    title: {},
+    description: {},
+    icon: {},
+    variant: { default: "primary" },
+    closable: { type: Boolean, default: !1 },
+    role: {},
+    class: { default: "" }
+  },
+  emits: ["close"],
+  setup(e, { emit: f }) {
+    const t = e, p = f, c = V(!0), y = () => {
+      c.value = !1, p("close");
+    }, b = a(() => ({
+      primary: "bg-primary-light text-primary border-primary/20",
+      success: "bg-success-light text-success-dark border-success/20",
+      warning: "bg-warning-light text-warning-dark border-warning/20",
+      danger: "bg-danger-light text-danger-dark border-danger/20"
+    })[t.variant]), k = a(() => ({
+      primary: "text-primary",
+      success: "text-success-dark",
+      warning: "text-warning-dark",
+      danger: "text-danger-dark"
+    })[t.variant]), l = a(() => !t.description && !$().default), x = a(() => [
+      "relative w-full rounded-lg border px-4 [&>svg]:absolute [&>svg]:left-4 [&>svg]:text-foreground",
+      l.value ? "py-3" : "pt-4 pb-2",
+      // Icon Position: Center vertically if title only, otherwise top-4
+      l.value ? "[&>svg]:top-1/2 [&>svg]:-translate-y-1/2" : "[&>svg]:top-4 top-4 [&>svg+div]:translate-y-[-3px]",
+      b.value,
+      t.class
+    ].join(" ")), h = a(() => [
+      "font-medium leading-none tracking-tight",
+      l.value ? "" : "mb-1"
+    ].join(" ")), w = a(() => t.role ? t.role : ["danger", "warning"].includes(t.variant) ? "alert" : "status");
+    return (s, u) => c.value ? (n(), i("div", {
+      key: 0,
+      class: r(x.value),
+      role: w.value
+    }, [
+      d(s.$slots, "icon", {}, () => [
+        e.icon ? (n(), B(m, {
+          key: 0,
+          icon: e.icon,
+          class: r(["h-4 w-4", k.value])
+        }, null, 8, ["icon", "class"])) : o("", !0)
+      ]),
+      g("div", {
+        class: r({ "pl-7": e.icon || s.$slots.icon, "pr-6": e.closable })
+      }, [
+        e.title ? (n(), i("h5", {
+          key: 0,
+          class: r(h.value)
+        }, v(e.title), 3)) : o("", !0),
+        e.description || s.$slots.default ? (n(), i("div", E, [
+          d(s.$slots, "default", {}, () => [
+            N(v(e.description), 1)
+          ])
+        ])) : o("", !0)
+      ], 2),
+      e.closable ? (n(), i("button", {
+        key: 0,
+        type: "button",
+        onClick: y,
+        class: r(["absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2", [l.value ? "top-1/2 -translate-y-1/2" : "top-4"]])
+      }, [
+        S(m, {
+          icon: "lucide:x",
+          class: "h-4 w-4"
+        }),
+        u[0] || (u[0] = g("span", { class: "sr-only" }, "Close", -1))
+      ], 2)) : o("", !0)
+    ], 10, j)) : o("", !0);
+  }
+});
+export {
+  A as default
+};

package/components/Alert.vue2.js

@@ -0,0 +1,4 @@
+import f from "./Alert.vue.js";
+export {
+  f as default
+};

package/components/Avatar.vue.d.ts

@@ -0,0 +1,32 @@
+import { AvatarSize, AvatarRounded } from '../types';
+interface Props {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+    size?: AvatarSize;
+    rounded?: AvatarRounded;
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        fallback?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    class: string;
+    src: string;
+    alt: string;
+    size: AvatarSize;
+    rounded: AvatarRounded;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/Avatar.vue.js

@@ -0,0 +1,78 @@
+import { defineComponent as k, ref as c, watch as w, computed as a, openBlock as t, createElementBlock as r, normalizeClass as d, renderSlot as g, toDisplayString as b, createBlock as C } from "vue";
+import _ from "./Icon.vue.js";
+const y = ["src", "alt"], z = { key: 0 }, A = /* @__PURE__ */ k({
+  __name: "Avatar",
+  props: {
+    src: { default: "" },
+    alt: { default: "Avatar" },
+    fallback: {},
+    size: { default: "md" },
+    rounded: { default: "full" },
+    class: { default: "" }
+  },
+  setup(n) {
+    const e = n, s = c(!1), o = c(!1);
+    w(
+      () => e.src,
+      () => {
+        s.value = !1, o.value = !1;
+      }
+    );
+    const f = () => {
+      s.value = !0, o.value = !1;
+    }, i = () => {
+      o.value = !0, s.value = !1;
+    }, m = a(() => e.src && !s.value), u = a(() => {
+      if (e.fallback) return e.fallback;
+      if (!e.alt) return "";
+      const l = e.alt.trim().split(/\s+/);
+      return l.length === 1 ? l[0].slice(0, 2).toUpperCase() : (l[0][0] + l[l.length - 1][0]).toUpperCase();
+    }), x = {
+      xs: "h-6 w-6 text-[10px]",
+      sm: "h-8 w-8 text-xs",
+      md: "h-10 w-10 text-sm",
+      lg: "h-12 w-12 text-base",
+      xl: "h-14 w-14 text-lg",
+      "2xl": "h-16 w-16 text-xl"
+    }, h = {
+      none: "rounded-none",
+      sm: "rounded-sm",
+      md: "rounded-md",
+      lg: "rounded-lg",
+      xl: "rounded-xl",
+      "2xl": "rounded-2xl",
+      full: "rounded-full"
+    }, v = a(() => [
+      "relative flex shrink-0 overflow-hidden bg-muted",
+      x[e.size],
+      h[e.rounded],
+      e.class
+    ].join(" ")), p = a(() => "flex h-full w-full items-center justify-center bg-muted text-muted-foreground font-medium");
+    return (l, j) => (t(), r("div", {
+      class: d(v.value)
+    }, [
+      m.value ? (t(), r("img", {
+        key: 0,
+        src: n.src,
+        alt: n.alt,
+        class: "aspect-square h-full w-full object-cover",
+        onError: f,
+        onLoad: i
+      }, null, 40, y)) : (t(), r("div", {
+        key: 1,
+        class: d(p.value)
+      }, [
+        g(l.$slots, "fallback", {}, () => [
+          u.value ? (t(), r("span", z, b(u.value), 1)) : (t(), C(_, {
+            key: 1,
+            icon: "lucide:user",
+            class: "h-1/2 w-1/2"
+          }))
+        ])
+      ], 2))
+    ], 2));
+  }
+});
+export {
+  A as default
+};

package/components/Avatar.vue2.js

@@ -0,0 +1,4 @@
+import f from "./Avatar.vue.js";
+export {
+  f as default
+};

package/components/AvatarUploader/AvatarUploader.vue.d.ts

@@ -0,0 +1,31 @@
+import { FilePickerValue } from '../FilePicker';
+import { AvatarSize, AvatarRounded } from '../../types';
+export interface Props {
+    modelValue?: string | null;
+    size?: AvatarSize;
+    rounded?: AvatarRounded;
+    editable?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    fallback?: string;
+    alt?: string;
+    maxSize?: number;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+    change: (value: FilePickerValue) => any;
+    error: (error: string) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: (value: string) => any;
+    onChange?: (value: FilePickerValue) => any;
+    onError?: (error: string) => any;
+}>, {
+    disabled: boolean;
+    alt: string;
+    modelValue: string | null;
+    size: AvatarSize;
+    loading: boolean;
+    rounded: AvatarRounded;
+    editable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/components/AvatarUploader/AvatarUploader.vue.js

@@ -0,0 +1,104 @@
+import { defineComponent as w, ref as z, computed as f, openBlock as r, createElementBlock as o, normalizeClass as n, createVNode as l, unref as C, withCtx as p, createElementVNode as A, createCommentVNode as g, withModifiers as B } from "vue";
+import u from "../Icon.vue.js";
+import j from "../FilePicker/FilePicker.vue.js";
+import E from "../Avatar.vue.js";
+const $ = ["onClick"], I = /* @__PURE__ */ w({
+  __name: "AvatarUploader",
+  props: {
+    modelValue: { default: null },
+    size: { default: "xl" },
+    rounded: { default: "full" },
+    editable: { type: Boolean, default: !0 },
+    loading: { type: Boolean, default: !1 },
+    disabled: { type: Boolean, default: !1 },
+    fallback: {},
+    alt: { default: "Avatar" },
+    maxSize: {}
+  },
+  emits: ["update:modelValue", "change", "error"],
+  setup(e, { emit: v }) {
+    const s = e, t = v, i = z(null), c = f(() => i.value || s.modelValue), h = (a) => {
+      if (!a || Array.isArray(a)) {
+        Array.isArray(a) && a.length === 0 && m();
+        return;
+      }
+      a.base64 && (i.value = a.base64, t("update:modelValue", a.base64)), t("change", a);
+    }, y = (a) => {
+      t("error", a);
+    }, m = () => {
+      i.value = null, t("update:modelValue", null), t("change", null);
+    }, k = f(() => [
+      "group relative inline-block",
+      // If rounded is full, we need overflow hidden on the container to clip the overlay
+      s.rounded === "full" ? "rounded-full" : ""
+    ].join(" "));
+    return (a, b) => (r(), o("div", {
+      class: n(k.value)
+    }, [
+      l(C(j), {
+        disabled: !e.editable || e.disabled || e.loading,
+        "return-format": "base64",
+        "file-types": ["image/jpeg", "image/png", "image/webp", "image/gif"],
+        "max-size": e.maxSize,
+        class: "w-auto h-auto block",
+        onChange: b[0] || (b[0] = (d) => h(d)),
+        onError: y
+      }, {
+        trigger: p(({ trigger: d, isLoading: x }) => [
+          A("div", {
+            class: n(["relative cursor-pointer transition-transform active:scale-95", { "cursor-default": !e.editable || e.disabled }]),
+            onClick: (N) => e.editable && !e.disabled ? d() : null
+          }, [
+            l(E, {
+              src: c.value || void 0,
+              fallback: e.fallback,
+              alt: e.alt,
+              size: e.size,
+              rounded: e.rounded,
+              class: "ring-offset-background transition-shadow group-hover:ring-2 group-hover:ring-primary/20"
+            }, null, 8, ["src", "fallback", "alt", "size", "rounded"]),
+            e.loading || x ? (r(), o("div", {
+              key: 0,
+              class: n([
+                "absolute inset-0 flex items-center justify-center bg-black/40 backdrop-blur-[1px] text-white transition-opacity",
+                e.rounded === "full" ? "rounded-full" : "rounded-md"
+              ])
+            }, [
+              l(u, {
+                icon: "lucide:loader-2",
+                class: "animate-spin w-1/3 h-1/3"
+              })
+            ], 2)) : e.editable && !e.disabled ? (r(), o("div", {
+              key: 1,
+              class: n([
+                "absolute inset-0 flex items-center justify-center bg-black/40 text-white opacity-0 transition-opacity duration-200 group-hover:opacity-100",
+                e.rounded === "full" ? "rounded-full" : "rounded-md"
+              ])
+            }, [
+              l(u, {
+                icon: "lucide:camera",
+                class: "w-1/3 h-1/3"
+              })
+            ], 2)) : g("", !0)
+          ], 10, $)
+        ]),
+        _: 1
+      }, 8, ["disabled", "max-size"]),
+      c.value && e.editable && !e.disabled && !e.loading ? (r(), o("button", {
+        key: 0,
+        type: "button",
+        class: "absolute -top-1 -right-1 z-10 p-1 bg-background border border-border rounded-full text-muted-foreground shadow-sm hover:text-destructive hover:border-destructive transition-colors opacity-0 group-hover:opacity-100 scale-75 group-hover:scale-100 duration-200 transform",
+        onClick: B(m, ["stop"]),
+        title: "Remove image"
+      }, [
+        l(u, {
+          icon: "lucide:x",
+          class: "w-3 h-3"
+        })
+      ])) : g("", !0)
+    ], 2));
+  }
+});
+export {
+  I as default
+};

package/components/AvatarUploader/AvatarUploader.vue2.js

@@ -0,0 +1,4 @@
+import f from "./AvatarUploader.vue.js";
+export {
+  f as default
+};

package/components/AvatarUploader/index.d.ts

@@ -0,0 +1,2 @@
+export { default as AvatarUploader } from './AvatarUploader.vue';
+export type { Props as AvatarUploaderProps } from './AvatarUploader.vue';

package/components/Badge.vue.d.ts

@@ -0,0 +1,25 @@
+export type BadgeVariant = 'default' | 'secondary' | 'danger' | 'outline' | 'warning' | 'info' | 'success';
+interface Props {
+    variant?: BadgeVariant;
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    class: string;
+    variant: BadgeVariant;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/Badge.vue.js

@@ -0,0 +1,31 @@
+import { defineComponent as o, computed as a, openBlock as c, createElementBlock as i, normalizeClass as d, renderSlot as u } from "vue";
+const g = /* @__PURE__ */ o({
+  __name: "Badge",
+  props: {
+    variant: { default: "default" },
+    class: { default: "" }
+  },
+  setup(n) {
+    const e = n, t = a(() => [
+      "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+      {
+        default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+        secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        danger: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+        warning: "border-transparent bg-warning text-warning-fg hover:bg-warning/80",
+        info: "border-transparent bg-info text-info-fg hover:bg-info/80",
+        success: "border-transparent bg-success text-success-fg hover:bg-success/80",
+        outline: "text-foreground border-border"
+      }[e.variant],
+      e.class
+    ].join(" "));
+    return (r, s) => (c(), i("div", {
+      class: d(t.value)
+    }, [
+      u(r.$slots, "default")
+    ], 2));
+  }
+});
+export {
+  g as default
+};

package/components/Badge.vue2.js

@@ -0,0 +1,4 @@
+import f from "./Badge.vue.js";
+export {
+  f as default
+};

package/components/Button.vue.d.ts

@@ -0,0 +1,26 @@
+import { ButtonVariant, ButtonSize, ButtonRounded, ButtonProps } from '../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ButtonProps> & Readonly<{}>, {
+    disabled: boolean;
+    type: "button" | "submit" | "reset";
+    class: any;
+    variant: ButtonVariant;
+    size: ButtonSize;
+    loading: boolean;
+    rounded: ButtonRounded;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/Button.vue.js

@@ -0,0 +1,108 @@
+import { defineComponent as m, computed as a, withDirectives as v, openBlock as n, createElementBlock as x, normalizeClass as o, createBlock as l, createCommentVNode as u, renderSlot as y, createTextVNode as p, toDisplayString as w, unref as k } from "vue";
+import c from "./Icon.vue.js";
+import { vRipple as z } from "../directives/vRipple.js";
+const B = ["type", "disabled"], V = /* @__PURE__ */ m({
+  __name: "Button",
+  props: {
+    variant: { default: "primary" },
+    size: { default: "md" },
+    class: { default: "" },
+    disabled: { type: Boolean, default: !1 },
+    loading: { type: Boolean, default: !1 },
+    icon: {},
+    iconRight: {},
+    type: { default: "button" },
+    text: {},
+    rounded: { default: "md" }
+  },
+  setup(e) {
+    const t = e, i = a(() => t.icon && !t.text), g = a(() => {
+      const r = "inline-flex items-center justify-center whitespace-nowrap text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 active:scale-95 cursor-pointer", d = {
+        primary: "bg-primary text-primary-foreground hover:bg-primary/90",
+        "primary-light": "bg-primary-light text-primary-fg-light hover:bg-primary/20",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        danger: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+        "danger-light": "bg-destructive/10 text-destructive hover:bg-destructive/20",
+        warning: "bg-warning text-warning-fg hover:bg-warning/80",
+        "warning-light": "bg-warning-light text-warning-fg-light hover:bg-warning/20",
+        info: "bg-info text-info-fg hover:bg-info/80",
+        "info-light": "bg-info-light text-info-fg-light hover:bg-info/20",
+        success: "bg-success text-success-fg hover:bg-success/80",
+        "success-light": "bg-success-light text-success-fg-light hover:bg-success/20",
+        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground text-foreground",
+        "outline-primary": "border border-primary text-primary hover:bg-primary/10",
+        "outline-danger": "border border-destructive text-destructive hover:bg-destructive/10",
+        "outline-warning": "border border-warning text-warning hover:bg-warning/10",
+        "outline-info": "border border-info text-info hover:bg-info/10",
+        "outline-success": "border border-success text-success hover:bg-success/10",
+        ghost: "hover:bg-accent hover:text-accent-foreground text-foreground",
+        link: "text-primary underline-offset-4 hover:underline"
+      }, f = {
+        xs: "h-6 px-2",
+        md: "h-10 px-4 py-2",
+        sm: "h-9 px-3",
+        lg: "h-11 px-8",
+        xl: "h-12 px-10"
+      }, h = {
+        xs: "h-7 w-7",
+        md: "h-10 w-10",
+        sm: "h-9 w-9",
+        lg: "h-11 w-11",
+        xl: "h-12 w-12"
+      }, b = {
+        none: "rounded-none",
+        sm: "rounded-sm",
+        md: "rounded",
+        lg: "rounded-lg",
+        xl: "rounded-xl",
+        "2xl": "rounded-2xl",
+        full: "rounded-full"
+      };
+      return [
+        r,
+        d[t.variant],
+        b[t.rounded],
+        i.value ? h[t.size] : f[t.size],
+        t.class
+      ].join(" ");
+    }), s = a(() => ({
+      xs: "w-3 h-3",
+      sm: "w-4 h-4",
+      md: "w-4 h-4",
+      lg: "w-4 h-4",
+      xl: "w-4 h-4"
+    })[t.size]);
+    return (r, d) => v((n(), x("button", {
+      type: e.type,
+      class: o(g.value),
+      disabled: e.disabled || e.loading
+    }, [
+      e.loading ? (n(), l(c, {
+        key: 0,
+        icon: "lucide:loader-2",
+        class: o(["mr-2 animate-spin", { "mr-0": i.value, [s.value]: !0 }])
+      }, null, 8, ["class"])) : e.icon ? (n(), l(c, {
+        key: 1,
+        icon: e.icon,
+        class: o({
+          "mr-2": r.$slots.default || e.text,
+          "mx-auto": i.value,
+          [s.value]: !0
+        })
+      }, null, 8, ["icon", "class"])) : u("", !0),
+      y(r.$slots, "default", {}, () => [
+        p(w(e.text), 1)
+      ]),
+      e.iconRight && !e.loading ? (n(), l(c, {
+        key: 2,
+        icon: e.iconRight,
+        class: o([s.value, "ml-2 h-4 w-4"])
+      }, null, 8, ["icon", "class"])) : u("", !0)
+    ], 10, B)), [
+      [k(z)]
+    ]);
+  }
+});
+export {
+  V as default
+};

package/components/Button.vue2.js

@@ -0,0 +1,4 @@
+import f from "./Button.vue.js";
+export {
+  f as default
+};

package/components/ButtonGroup.vue.d.ts

@@ -0,0 +1,29 @@
+import { ButtonGroupDirection, ButtonVariant, ButtonSize } from '../types';
+interface Props {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    direction?: ButtonGroupDirection;
+    attached?: boolean;
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    class: string;
+    attached: boolean;
+    direction: ButtonGroupDirection;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/ButtonGroup.vue.js

@@ -0,0 +1,7 @@
+import o from "./ButtonGroup.vue2.js";
+/* empty css                 */
+import t from "../_virtual/_plugin-vue_export-helper.js";
+const m = /* @__PURE__ */ t(o, [["__scopeId", "data-v-1a20a82d"]]);
+export {
+  m as default
+};

package/components/ButtonGroup.vue2.js

@@ -0,0 +1,33 @@
+import { defineComponent as l, computed as r, openBlock as c, createElementBlock as n, normalizeClass as i, renderSlot as s } from "vue";
+const p = /* @__PURE__ */ l({
+  __name: "ButtonGroup",
+  props: {
+    variant: {},
+    size: {},
+    direction: { default: "horizontal" },
+    attached: { type: Boolean, default: !0 },
+    class: { default: "" }
+  },
+  setup(e) {
+    const t = e, a = r(() => t.direction === "vertical");
+    return (o, u) => (c(), n("div", {
+      role: "group",
+      class: i([
+        "inline-flex",
+        a.value ? "flex-col" : "flex-row",
+        t.class,
+        // Attached Mode logic for Deep Selectors
+        // We target direct children buttons. Assuming standard <button> or .btn class structure if possible, 
+        // but since we wrap `Button`, targeting `button` tag is safe.
+        e.attached ? "attached-group" : "gap-2",
+        // Vertical Attached
+        e.attached && a.value ? "vertical-group" : ""
+      ])
+    }, [
+      s(o.$slots, "default", {}, void 0, !0)
+    ], 2));
+  }
+});
+export {
+  p as default
+};

package/components/CheckBox.vue.d.ts

@@ -0,0 +1,28 @@
+import { CheckboxSize, CheckboxRounded } from '../types';
+interface Props {
+    modelValue?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    label?: string;
+    id?: string;
+    class?: string;
+    size?: CheckboxSize;
+    rounded?: CheckboxRounded;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: boolean) => any;
+    "update:checked": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: (value: boolean) => any;
+    "onUpdate:checked"?: (value: boolean) => any;
+}>, {
+    disabled: boolean;
+    class: string;
+    modelValue: boolean;
+    size: CheckboxSize;
+    rounded: CheckboxRounded;
+    checked: boolean;
+    indeterminate: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;