brutx-ui-vue 0.3.1 → 0.4.1

package/dist/brutx-ui-vue.css

@@ -1 +1 @@
-.tree-expand-enter-active[data-v-0c30ee85],.tree-expand-leave-active[data-v-0c30ee85]{transition:opacity .15s ease,grid-template-rows .2s ease;overflow:hidden;display:grid;grid-template-rows:1fr}.tree-expand-enter-from[data-v-0c30ee85],.tree-expand-leave-to[data-v-0c30ee85]{opacity:0;grid-template-rows:0fr}
+.tree-expand-enter-active[data-v-0c30ee85],.tree-expand-leave-active[data-v-0c30ee85]{transition:opacity .15s ease,grid-template-rows .2s ease;overflow:hidden;display:grid;grid-template-rows:1fr}.tree-expand-enter-from[data-v-0c30ee85],.tree-expand-leave-to[data-v-0c30ee85]{opacity:0;grid-template-rows:0fr}.glitch-text[data-v-aeb97c2b]:before,.glitch-text[data-v-aeb97c2b]:after{display:none;content:attr(data-text);position:absolute;top:0;left:0;width:100%;height:100%;background:transparent;clip-path:inset(0 0 0 0)}.glitch-text.is-glitching[data-v-aeb97c2b]:before,.glitch-text.is-glitching[data-v-aeb97c2b]:after{display:block}.glitch-text.is-glitching[data-v-aeb97c2b]:before{left:2px;text-shadow:-2px 0 var(--brutal-destructive, #EF476F);animation:glitch-anim-1-aeb97c2b var(--glitch-duration, .3s) infinite linear alternate-reverse}.glitch-text.is-glitching[data-v-aeb97c2b]:after{left:-2px;text-shadow:-2px 0 var(--brutal-info, #4A90D9);animation:glitch-anim-2-aeb97c2b var(--glitch-duration, .3s) infinite linear alternate-reverse}@keyframes glitch-anim-1-aeb97c2b{0%{clip-path:inset(20% 0 70% 0);transform:skew(-5deg)}20%{clip-path:inset(60% 0 10% 0);transform:skew(5deg)}40%{clip-path:inset(40% 0 50% 0);transform:skew(-2deg)}60%{clip-path:inset(80% 0 5% 0);transform:skew(3deg)}80%{clip-path:inset(10% 0 85% 0);transform:skew(-4deg)}to{clip-path:inset(50% 0 35% 0);transform:skew(1deg)}}@keyframes glitch-anim-2-aeb97c2b{0%{clip-path:inset(10% 0 85% 0);transform:skew(4deg)}25%{clip-path:inset(40% 0 45% 0);transform:skew(-3deg)}50%{clip-path:inset(70% 0 15% 0);transform:skew(5deg)}75%{clip-path:inset(25% 0 60% 0);transform:skew(-2deg)}to{clip-path:inset(90% 0 2% 0);transform:skew(3deg)}}@media(prefers-reduced-motion:reduce){.glitch-text[data-v-aeb97c2b]:before,.glitch-text[data-v-aeb97c2b]:after,.glitch-text.is-glitching[data-v-aeb97c2b]:before,.glitch-text.is-glitching[data-v-aeb97c2b]:after{display:none!important;animation:none!important}}@keyframes input-shake-7eeb0be8{0%,to{transform:translate(0)}15%,45%,75%{transform:translate(-6px)}30%,60%,90%{transform:translate(6px)}}[data-v-7eeb0be8] .animate-shake{animation:input-shake-7eeb0be8 .35s ease-in-out}@keyframes bounce-short-7eeb0be8{0%,to{transform:translateY(0)}50%{transform:translateY(-4px)}}[data-v-7eeb0be8] .animate-bounce-short{animation:bounce-short-7eeb0be8 .4s ease-in-out 2}@keyframes fade-in-7eeb0be8{0%{opacity:0;transform:translateY(-2px)}to{opacity:1;transform:translateY(0)}}[data-v-7eeb0be8] .animate-fade-in{animation:fade-in-7eeb0be8 .2s ease-out forwards}@media(prefers-reduced-motion:reduce){[data-v-7eeb0be8] .animate-shake,[data-v-7eeb0be8] .animate-bounce-short,[data-v-7eeb0be8] .animate-fade-in{animation:none!important;transform:none!important}}

package/dist/components/card-3d/Card3D.vue.d.ts

@@ -0,0 +1,42 @@
+import { VariantProps } from 'class-variance-authority';
+import { card3dVariants } from './card-3d-variants';
+type Card3DVariantProps = VariantProps<typeof card3dVariants>;
+interface Card3DProps {
+    maxRotation?: number;
+    perspective?: number;
+    scale?: number;
+    shadowOffset?: number;
+    shadow?: NonNullable<Card3DVariantProps['shadow']>;
+    disabled?: boolean;
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        cardRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Card3DProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Card3DProps> & Readonly<{}>, {
+    class: string;
+    disabled: boolean;
+    scale: number;
+    shadow: NonNullable<Card3DVariantProps["shadow"]>;
+    maxRotation: number;
+    perspective: number;
+    shadowOffset: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    cardRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=Card3D.vue.d.ts.map

package/dist/components/card-3d/Card3D.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Card3D.vue.d.ts","sourceRoot":"","sources":["../../../src/components/card-3d/Card3D.vue"],"names":[],"mappings":"AAwIA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAG5D,OAAO,EAAE,cAAc,EAAwB,MAAM,oBAAoB,CAAA;AAEzE,KAAK,kBAAkB,GAAG,YAAY,CAAC,OAAO,cAAc,CAAC,CAAA;AAE7D,UAAU,WAAW;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,MAAM,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAA;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;CACjB;AAgHD,iBAAS,cAAc;WAwCT,OAAO,IAA6B;;yBAXrB,GAAG;;;;;;EAgB/B;AAiBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;WAhLT,MAAM;cADH,OAAO;WAHV,MAAM;YAEL,WAAW,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;iBAJpC,MAAM;iBACN,MAAM;kBAEL,MAAM;;;kBA4LvB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/card-3d/card-3d-variants.d.ts

@@ -0,0 +1,5 @@
+export declare const card3dVariants: (props?: ({
+    shadow?: "default" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const card3dShadowVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+//# sourceMappingURL=card-3d-variants.d.ts.map

package/dist/components/card-3d/card-3d-variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"card-3d-variants.d.ts","sourceRoot":"","sources":["../../../src/components/card-3d/card-3d-variants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;8EAoB1B,CAAA;AAED,eAAO,MAAM,oBAAoB,oFAShC,CAAA"}

package/dist/components/card-3d/card-3d.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=card-3d.test.d.ts.map

package/dist/components/card-3d/card-3d.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"card-3d.test.d.ts","sourceRoot":"","sources":["../../../src/components/card-3d/card-3d.test.ts"],"names":[],"mappings":""}

package/dist/components/glitch-text/GlitchText.vue.d.ts

@@ -0,0 +1,41 @@
+import { VariantProps } from 'class-variance-authority';
+import { glitchTextVariants } from './glitch-text-variants';
+type GlitchTextVariantProps = VariantProps<typeof glitchTextVariants>;
+interface GlitchTextProps {
+    text?: string;
+    trigger?: 'hover' | 'click' | 'autoplay' | 'none';
+    interval?: number;
+    speed?: NonNullable<GlitchTextVariantProps['speed']>;
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        elementRef: HTMLSpanElement;
+    };
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<GlitchTextProps, {
+    play: () => void;
+    stop: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<GlitchTextProps> & Readonly<{}>, {
+    class: string;
+    speed: NonNullable<GlitchTextVariantProps["speed"]>;
+    text: string;
+    trigger: "hover" | "click" | "autoplay" | "none";
+    interval: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    elementRef: HTMLSpanElement;
+}, HTMLSpanElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=GlitchText.vue.d.ts.map

package/dist/components/glitch-text/GlitchText.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlitchText.vue.d.ts","sourceRoot":"","sources":["../../../src/components/glitch-text/GlitchText.vue"],"names":[],"mappings":"AAsOA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAG5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAE3D,KAAK,sBAAsB,GAAG,YAAY,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAErE,UAAU,eAAe;IACrB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,CAAA;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,WAAW,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC,CAAA;IACpD,KAAK,CAAC,EAAE,MAAM,CAAA;CACjB;AAuHD,iBAAS,cAAc;WAuCT,OAAO,IAA6B;;yBAXrB,GAAG;;;;;;EAgB/B;AAeD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;WApLT,MAAM;WADN,WAAW,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;UAH7C,MAAM;aACH,OAAO,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM;cACtC,MAAM;;;mBAgMnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/glitch-text/glitch-text-variants.d.ts

@@ -0,0 +1,4 @@
+export declare const glitchTextVariants: (props?: ({
+    speed?: "slow" | "medium" | "fast" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+//# sourceMappingURL=glitch-text-variants.d.ts.map

package/dist/components/glitch-text/glitch-text-variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glitch-text-variants.d.ts","sourceRoot":"","sources":["../../../src/components/glitch-text/glitch-text-variants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB;;8EAmB9B,CAAA"}

package/dist/components/glitch-text/glitch-text.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=glitch-text.test.d.ts.map

package/dist/components/glitch-text/glitch-text.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glitch-text.test.d.ts","sourceRoot":"","sources":["../../../src/components/glitch-text/glitch-text.test.ts"],"names":[],"mappings":""}

package/dist/components/hardcore-input/HardcoreInput.vue.d.ts

@@ -0,0 +1,51 @@
+interface HardcoreInputProps {
+    modelValue?: string;
+    sound?: boolean;
+    rules?: Array<(val: string) => boolean | string>;
+    shakeOnError?: boolean;
+    type?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    validateOn?: 'input' | 'blur' | 'submit';
+    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<HardcoreInputProps, {
+    validate: () => void;
+    validationState: import('vue').Ref<"default" | "success" | "error", "default" | "success" | "error">;
+    errorMessage: import('vue').Ref<string, string>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    validationChange: (state: "default" | "success" | "error", message?: string | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<HardcoreInputProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onValidationChange?: ((state: "default" | "success" | "error", message?: string | undefined) => any) | undefined;
+}>, {
+    class: string;
+    disabled: boolean;
+    type: string;
+    placeholder: string;
+    modelValue: string;
+    readonly: boolean;
+    sound: boolean;
+    rules: Array<(val: string) => boolean | string>;
+    shakeOnError: boolean;
+    validateOn: "input" | "blur" | "submit";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=HardcoreInput.vue.d.ts.map

package/dist/components/hardcore-input/HardcoreInput.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HardcoreInput.vue.d.ts","sourceRoot":"","sources":["../../../src/components/hardcore-input/HardcoreInput.vue"],"names":[],"mappings":"AAmRA,UAAU,kBAAkB;IACxB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,GAAG,MAAM,CAAC,CAAA;IAChD,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;IACxC,KAAK,CAAC,EAAE,MAAM,CAAA;CACjB;AA0KD,iBAAS,cAAc;WA0KT,OAAO,IAA6B;;yBAVrB,GAAG;;;;EAe/B;AAmBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;WA9WT,MAAM;cAHH,OAAO;UAFX,MAAM;iBACC,MAAM;gBALP,MAAM;cAOR,OAAO;WANV,OAAO;WACP,KAAK,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,GAAG,MAAM,CAAC;kBACjC,OAAO;gBAKT,OAAO,GAAG,MAAM,GAAG,QAAQ;wFAyX1C,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/hardcore-input/hardcore-input-variants.d.ts

@@ -0,0 +1,5 @@
+export declare const hardcoreInputVariants: (props?: ({
+    validationState?: "default" | "success" | "error" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const hardcoreInputFaceVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+//# sourceMappingURL=hardcore-input-variants.d.ts.map

package/dist/components/hardcore-input/hardcore-input-variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hardcore-input-variants.d.ts","sourceRoot":"","sources":["../../../src/components/hardcore-input/hardcore-input-variants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qBAAqB;;8EA0BjC,CAAA;AAED,eAAO,MAAM,yBAAyB,oFAUrC,CAAA"}

package/dist/components/hardcore-input/hardcore-input.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hardcore-input.test.d.ts.map

package/dist/components/hardcore-input/hardcore-input.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hardcore-input.test.d.ts","sourceRoot":"","sources":["../../../src/components/hardcore-input/hardcore-input.test.ts"],"names":[],"mappings":""}

package/dist/components/scratch-card/ScratchCard.vue.d.ts

@@ -0,0 +1,46 @@
+interface ScratchCardProps {
+    percentage?: number;
+    brushRadius?: number;
+    overlayColor?: string;
+    fadeDuration?: number;
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        containerRef: HTMLDivElement;
+        canvasRef: HTMLCanvasElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ScratchCardProps, {
+    isRevealed: import('vue').Ref<boolean, boolean>;
+    revealAll: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    progress: (percent: number) => any;
+    completed: () => any;
+}, string, import('vue').PublicProps, Readonly<ScratchCardProps> & Readonly<{
+    onProgress?: ((percent: number) => any) | undefined;
+    onCompleted?: (() => any) | undefined;
+}>, {
+    class: string;
+    percentage: number;
+    brushRadius: number;
+    fadeDuration: number;
+    overlayColor: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+    canvasRef: HTMLCanvasElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=ScratchCard.vue.d.ts.map

package/dist/components/scratch-card/ScratchCard.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScratchCard.vue.d.ts","sourceRoot":"","sources":["../../../src/components/scratch-card/ScratchCard.vue"],"names":[],"mappings":"AAiJA,UAAU,gBAAgB;IACtB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,MAAM,CAAA;CACjB;AA8GD,iBAAS,cAAc;WAqDT,OAAO,IAA6B;;yBAZrB,GAAG;;;;;;;EAiB/B;AAuBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;WAjMT,MAAM;gBAJD,MAAM;iBACL,MAAM;kBAEL,MAAM;kBADN,MAAM;;;;kBA8MvB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/scratch-card/scratch-card-variants.d.ts

@@ -0,0 +1,2 @@
+export declare const scratchCardVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+//# sourceMappingURL=scratch-card-variants.d.ts.map

package/dist/components/scratch-card/scratch-card-variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-card-variants.d.ts","sourceRoot":"","sources":["../../../src/components/scratch-card/scratch-card-variants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,oFAQ/B,CAAA"}

package/dist/components/scratch-card/scratch-card.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=scratch-card.test.d.ts.map

package/dist/components/scratch-card/scratch-card.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-card.test.d.ts","sourceRoot":"","sources":["../../../src/components/scratch-card/scratch-card.test.ts"],"names":[],"mappings":""}

package/dist/components/sketchy-chart/SketchyChart.vue.d.ts

@@ -0,0 +1,24 @@
+interface ChartDataItem {
+    label: string;
+    value: number;
+}
+interface SketchyChartProps {
+    type?: 'line' | 'bar';
+    data?: ChartDataItem[];
+    sketchiness?: number;
+    grid?: boolean;
+    width?: number;
+    height?: number;
+    class?: string;
+}
+declare const _default: import('vue').DefineComponent<SketchyChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SketchyChartProps> & Readonly<{}>, {
+    class: string;
+    type: "line" | "bar";
+    height: number;
+    width: number;
+    data: ChartDataItem[];
+    grid: boolean;
+    sketchiness: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=SketchyChart.vue.d.ts.map

package/dist/components/sketchy-chart/SketchyChart.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SketchyChart.vue.d.ts","sourceRoot":"","sources":["../../../src/components/sketchy-chart/SketchyChart.vue"],"names":[],"mappings":"AAwTA,UAAU,aAAa;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CAChB;AAED,UAAU,iBAAiB;IACvB,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;IACrB,IAAI,CAAC,EAAE,aAAa,EAAE,CAAA;IACtB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;CACjB;;WADW,MAAM;UANP,MAAM,GAAG,KAAK;YAKZ,MAAM;WADP,MAAM;UAHP,aAAa,EAAE;UAEf,OAAO;iBADA,MAAM;;AAqVxB,wBAQG"}

package/dist/components/sketchy-chart/sketchy-chart-variants.d.ts

@@ -0,0 +1,2 @@
+export declare const sketchyChartVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+//# sourceMappingURL=sketchy-chart-variants.d.ts.map

package/dist/components/sketchy-chart/sketchy-chart-variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sketchy-chart-variants.d.ts","sourceRoot":"","sources":["../../../src/components/sketchy-chart/sketchy-chart-variants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,oFAOhC,CAAA"}

package/dist/components/sketchy-chart/sketchy-chart.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sketchy-chart.test.d.ts.map

package/dist/components/sketchy-chart/sketchy-chart.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sketchy-chart.test.d.ts","sourceRoot":"","sources":["../../../src/components/sketchy-chart/sketchy-chart.test.ts"],"names":[],"mappings":""}

package/dist/composables/useAudioEngine.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+export declare function useAudioEngine(enabled: Ref<boolean>): {
+    playSound: (type: "type" | "success" | "fail") => void;
+    dispose: () => void;
+};
+//# sourceMappingURL=useAudioEngine.d.ts.map

package/dist/composables/useAudioEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAudioEngine.d.ts","sourceRoot":"","sources":["../../src/composables/useAudioEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAsBnC,wBAAgB,cAAc,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC;sBAcvB,MAAM,GAAG,SAAS,GAAG,MAAM;;EAoDvD"}

package/dist/composables/useCanvasInteraction.d.ts

@@ -0,0 +1,262 @@
+import { Ref } from 'vue';
+interface UseCanvasInteractionOptions {
+    containerRef: Ref<HTMLDivElement | null>;
+    canvasRef: Ref<HTMLCanvasElement | null>;
+    brushRadius: Ref<number>;
+    percentage: Ref<number>;
+    fadeDuration: Ref<number>;
+    prefersReducedMotion: Ref<boolean>;
+    onProgress: (percent: number) => void;
+    onCompleted: () => void;
+    drawOverlay: (ctx: CanvasRenderingContext2D, width: number, height: number) => void;
+}
+export declare function useCanvasInteraction(options: UseCanvasInteractionOptions): {
+    ctx: Ref<{
+        readonly canvas: HTMLCanvasElement;
+        globalAlpha: number;
+        globalCompositeOperation: GlobalCompositeOperation;
+        drawImage: {
+            (image: CanvasImageSource, dx: number, dy: number): void;
+            (image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
+            (image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
+        };
+        beginPath: () => void;
+        clip: {
+            (fillRule?: CanvasFillRule): void;
+            (path: Path2D, fillRule?: CanvasFillRule): void;
+        };
+        fill: {
+            (fillRule?: CanvasFillRule): void;
+            (path: Path2D, fillRule?: CanvasFillRule): void;
+        };
+        isPointInPath: {
+            (x: number, y: number, fillRule?: CanvasFillRule): boolean;
+            (path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;
+        };
+        isPointInStroke: {
+            (x: number, y: number): boolean;
+            (path: Path2D, x: number, y: number): boolean;
+        };
+        stroke: {
+            (): void;
+            (path: Path2D): void;
+        };
+        fillStyle: string | {
+            addColorStop: (offset: number, color: string) => void;
+        } | {
+            setTransform: (transform?: DOMMatrix2DInit) => void;
+        };
+        strokeStyle: string | {
+            addColorStop: (offset: number, color: string) => void;
+        } | {
+            setTransform: (transform?: DOMMatrix2DInit) => void;
+        };
+        createConicGradient: (startAngle: number, x: number, y: number) => CanvasGradient;
+        createLinearGradient: (x0: number, y0: number, x1: number, y1: number) => CanvasGradient;
+        createPattern: (image: CanvasImageSource, repetition: string | null) => CanvasPattern | null;
+        createRadialGradient: (x0: number, y0: number, r0: number, x1: number, y1: number, r1: number) => CanvasGradient;
+        filter: string;
+        createImageData: {
+            (sw: number, sh: number, settings?: ImageDataSettings): ImageData;
+            (imageData: ImageData): ImageData;
+        };
+        getImageData: (sx: number, sy: number, sw: number, sh: number, settings?: ImageDataSettings) => ImageData;
+        putImageData: {
+            (imageData: ImageData, dx: number, dy: number): void;
+            (imageData: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
+        };
+        imageSmoothingEnabled: boolean;
+        imageSmoothingQuality: ImageSmoothingQuality;
+        arc: (x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean) => void;
+        arcTo: (x1: number, y1: number, x2: number, y2: number, radius: number) => void;
+        bezierCurveTo: (cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number) => void;
+        closePath: () => void;
+        ellipse: (x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean) => void;
+        lineTo: (x: number, y: number) => void;
+        moveTo: (x: number, y: number) => void;
+        quadraticCurveTo: (cpx: number, cpy: number, x: number, y: number) => void;
+        rect: (x: number, y: number, w: number, h: number) => void;
+        roundRect: {
+            (x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | (number | DOMPointInit)[]): void;
+            (x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | Iterable<number | DOMPointInit>): void;
+        };
+        lineCap: CanvasLineCap;
+        lineDashOffset: number;
+        lineJoin: CanvasLineJoin;
+        lineWidth: number;
+        miterLimit: number;
+        getLineDash: () => number[];
+        setLineDash: {
+            (segments: number[]): void;
+            (segments: Iterable<number>): void;
+        };
+        clearRect: (x: number, y: number, w: number, h: number) => void;
+        fillRect: (x: number, y: number, w: number, h: number) => void;
+        strokeRect: (x: number, y: number, w: number, h: number) => void;
+        getContextAttributes: () => CanvasRenderingContext2DSettings;
+        shadowBlur: number;
+        shadowColor: string;
+        shadowOffsetX: number;
+        shadowOffsetY: number;
+        isContextLost: () => boolean;
+        reset: () => void;
+        restore: () => void;
+        save: () => void;
+        fillText: (text: string, x: number, y: number, maxWidth?: number) => void;
+        measureText: (text: string) => TextMetrics;
+        strokeText: (text: string, x: number, y: number, maxWidth?: number) => void;
+        direction: CanvasDirection;
+        font: string;
+        fontKerning: CanvasFontKerning;
+        fontStretch: CanvasFontStretch;
+        fontVariantCaps: CanvasFontVariantCaps;
+        letterSpacing: string;
+        textAlign: CanvasTextAlign;
+        textBaseline: CanvasTextBaseline;
+        textRendering: CanvasTextRendering;
+        wordSpacing: string;
+        getTransform: () => DOMMatrix;
+        resetTransform: () => void;
+        rotate: (angle: number) => void;
+        scale: (x: number, y: number) => void;
+        setTransform: {
+            (a: number, b: number, c: number, d: number, e: number, f: number): void;
+            (transform?: DOMMatrix2DInit): void;
+        };
+        transform: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+        translate: (x: number, y: number) => void;
+        drawFocusIfNeeded: {
+            (element: Element): void;
+            (path: Path2D, element: Element): void;
+        };
+    } | null, CanvasRenderingContext2D | {
+        readonly canvas: HTMLCanvasElement;
+        globalAlpha: number;
+        globalCompositeOperation: GlobalCompositeOperation;
+        drawImage: {
+            (image: CanvasImageSource, dx: number, dy: number): void;
+            (image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
+            (image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
+        };
+        beginPath: () => void;
+        clip: {
+            (fillRule?: CanvasFillRule): void;
+            (path: Path2D, fillRule?: CanvasFillRule): void;
+        };
+        fill: {
+            (fillRule?: CanvasFillRule): void;
+            (path: Path2D, fillRule?: CanvasFillRule): void;
+        };
+        isPointInPath: {
+            (x: number, y: number, fillRule?: CanvasFillRule): boolean;
+            (path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;
+        };
+        isPointInStroke: {
+            (x: number, y: number): boolean;
+            (path: Path2D, x: number, y: number): boolean;
+        };
+        stroke: {
+            (): void;
+            (path: Path2D): void;
+        };
+        fillStyle: string | {
+            addColorStop: (offset: number, color: string) => void;
+        } | {
+            setTransform: (transform?: DOMMatrix2DInit) => void;
+        };
+        strokeStyle: string | {
+            addColorStop: (offset: number, color: string) => void;
+        } | {
+            setTransform: (transform?: DOMMatrix2DInit) => void;
+        };
+        createConicGradient: (startAngle: number, x: number, y: number) => CanvasGradient;
+        createLinearGradient: (x0: number, y0: number, x1: number, y1: number) => CanvasGradient;
+        createPattern: (image: CanvasImageSource, repetition: string | null) => CanvasPattern | null;
+        createRadialGradient: (x0: number, y0: number, r0: number, x1: number, y1: number, r1: number) => CanvasGradient;
+        filter: string;
+        createImageData: {
+            (sw: number, sh: number, settings?: ImageDataSettings): ImageData;
+            (imageData: ImageData): ImageData;
+        };
+        getImageData: (sx: number, sy: number, sw: number, sh: number, settings?: ImageDataSettings) => ImageData;
+        putImageData: {
+            (imageData: ImageData, dx: number, dy: number): void;
+            (imageData: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
+        };
+        imageSmoothingEnabled: boolean;
+        imageSmoothingQuality: ImageSmoothingQuality;
+        arc: (x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean) => void;
+        arcTo: (x1: number, y1: number, x2: number, y2: number, radius: number) => void;
+        bezierCurveTo: (cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number) => void;
+        closePath: () => void;
+        ellipse: (x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean) => void;
+        lineTo: (x: number, y: number) => void;
+        moveTo: (x: number, y: number) => void;
+        quadraticCurveTo: (cpx: number, cpy: number, x: number, y: number) => void;
+        rect: (x: number, y: number, w: number, h: number) => void;
+        roundRect: {
+            (x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | (number | DOMPointInit)[]): void;
+            (x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | Iterable<number | DOMPointInit>): void;
+        };
+        lineCap: CanvasLineCap;
+        lineDashOffset: number;
+        lineJoin: CanvasLineJoin;
+        lineWidth: number;
+        miterLimit: number;
+        getLineDash: () => number[];
+        setLineDash: {
+            (segments: number[]): void;
+            (segments: Iterable<number>): void;
+        };
+        clearRect: (x: number, y: number, w: number, h: number) => void;
+        fillRect: (x: number, y: number, w: number, h: number) => void;
+        strokeRect: (x: number, y: number, w: number, h: number) => void;
+        getContextAttributes: () => CanvasRenderingContext2DSettings;
+        shadowBlur: number;
+        shadowColor: string;
+        shadowOffsetX: number;
+        shadowOffsetY: number;
+        isContextLost: () => boolean;
+        reset: () => void;
+        restore: () => void;
+        save: () => void;
+        fillText: (text: string, x: number, y: number, maxWidth?: number) => void;
+        measureText: (text: string) => TextMetrics;
+        strokeText: (text: string, x: number, y: number, maxWidth?: number) => void;
+        direction: CanvasDirection;
+        font: string;
+        fontKerning: CanvasFontKerning;
+        fontStretch: CanvasFontStretch;
+        fontVariantCaps: CanvasFontVariantCaps;
+        letterSpacing: string;
+        textAlign: CanvasTextAlign;
+        textBaseline: CanvasTextBaseline;
+        textRendering: CanvasTextRendering;
+        wordSpacing: string;
+        getTransform: () => DOMMatrix;
+        resetTransform: () => void;
+        rotate: (angle: number) => void;
+        scale: (x: number, y: number) => void;
+        setTransform: {
+            (a: number, b: number, c: number, d: number, e: number, f: number): void;
+            (transform?: DOMMatrix2DInit): void;
+        };
+        transform: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+        translate: (x: number, y: number) => void;
+        drawFocusIfNeeded: {
+            (element: Element): void;
+            (path: Path2D, element: Element): void;
+        };
+    } | null>;
+    isRevealed: Ref<boolean, boolean>;
+    revealAll: () => void;
+    syncCanvasSize: () => void;
+    handlePointerDown: (e: PointerEvent) => void;
+    handlePointerMove: (e: PointerEvent) => void;
+    handlePointerUp: () => void;
+    handleTouchStart: (e: TouchEvent) => void;
+    handleTouchMove: (e: TouchEvent) => void;
+    handleTouchEnd: () => void;
+};
+export {};
+//# sourceMappingURL=useCanvasInteraction.d.ts.map

package/dist/composables/useCanvasInteraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasInteraction.d.ts","sourceRoot":"","sources":["../../src/composables/useCanvasInteraction.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAM3D,UAAU,2BAA2B;IACjC,YAAY,EAAE,GAAG,CAAC,cAAc,GAAG,IAAI,CAAC,CAAA;IACxC,SAAS,EAAE,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAA;IACxC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACxB,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACvB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACzB,oBAAoB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAClC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACrC,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,WAAW,EAAE,CAAC,GAAG,EAAE,wBAAwB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;CACtF;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAsHvC,YAAY;2BAKZ,YAAY;;0BAYb,UAAU;yBAQX,UAAU;;EAyCzC"}

package/dist/composables/useReducedMotion.d.ts

@@ -0,0 +1,2 @@
+export declare function useReducedMotion(): import('vue').Ref<boolean, boolean>;
+//# sourceMappingURL=useReducedMotion.d.ts.map

package/dist/composables/useReducedMotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReducedMotion.d.ts","sourceRoot":"","sources":["../../src/composables/useReducedMotion.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,wCAqB/B"}

package/dist/index.d.ts

@@ -211,4 +211,17 @@ export { useLocale, provideLocale } from './composables/useLocale';
 export type { TranslateFunction } from './composables/useLocale';
 export { zhCN, en, mergeLocale } from './locales';
 export type { Locale, CommandLocale, ComboboxLocale, PaginationLocale, CarouselLocale, SpinnerLocale, SubmitButtonLocale, CopyToClipboardLocale, BeforeAfterLocale, AuthCardLocale, WaitlistPageLocale, DashboardShellLocale, BrutalistHeroLocale, SaaSPricingLocale, ToastLocale, DialogLocale, SheetLocale, BreadcrumbLocale, TreeViewLocale, StepperLocale, EmptyStateLocale } from './locales/types';
+export { default as Card3D } from './components/card-3d/Card3D.vue';
+export { card3dVariants, card3dShadowVariants } from './components/card-3d/card-3d-variants';
+export { default as GlitchText } from './components/glitch-text/GlitchText.vue';
+export { glitchTextVariants } from './components/glitch-text/glitch-text-variants';
+export { default as ScratchCard } from './components/scratch-card/ScratchCard.vue';
+export { scratchCardVariants } from './components/scratch-card/scratch-card-variants';
+export { default as SketchyChart } from './components/sketchy-chart/SketchyChart.vue';
+export { sketchyChartVariants } from './components/sketchy-chart/sketchy-chart-variants';
+export { default as HardcoreInput } from './components/hardcore-input/HardcoreInput.vue';
+export { hardcoreInputVariants, hardcoreInputFaceVariants } from './components/hardcore-input/hardcore-input-variants';
+export { useReducedMotion } from './composables/useReducedMotion';
+export { useAudioEngine } from './composables/useAudioEngine';
+export { useCanvasInteraction } from './composables/useCanvasInteraction';
 //# sourceMappingURL=index.d.ts.map