origam 0.3.0 → 0.3.3

package/dist/composables/Commons/audio.composable.d.ts

@@ -0,0 +1,523 @@
+import type { IAudioProps } from '@/interfaces';
+export declare function useAudio(props: IAudioProps): {
+    audioData: import("vue").ShallowRef<Uint8Array<ArrayBufferLike> | null, Uint8Array<ArrayBufferLike> | null>;
+    analyser: import("vue").Ref<{
+        fftSize: number;
+        readonly frequencyBinCount: number;
+        maxDecibels: number;
+        minDecibels: number;
+        smoothingTimeConstant: number;
+        getByteFrequencyData: (array: Uint8Array) => void;
+        getByteTimeDomainData: (array: Uint8Array) => void;
+        getFloatFrequencyData: (array: Float32Array) => void;
+        getFloatTimeDomainData: (array: Float32Array) => void;
+        channelCount: number;
+        channelCountMode: ChannelCountMode;
+        channelInterpretation: ChannelInterpretation;
+        readonly context: {
+            readonly audioWorklet: {
+                addModule: (moduleURL: string | URL, options?: WorkletOptions) => Promise<void>;
+            };
+            readonly currentTime: number;
+            readonly destination: {
+                readonly maxChannelCount: number;
+                channelCount: number;
+                channelCountMode: ChannelCountMode;
+                channelInterpretation: ChannelInterpretation;
+                readonly context: /*elided*/ any;
+                readonly numberOfInputs: number;
+                readonly numberOfOutputs: number;
+                connect: {
+                    (destinationNode: AudioNode, output?: number, input?: number): AudioNode;
+                    (destinationParam: AudioParam, output?: number): void;
+                };
+                disconnect: {
+                    (): void;
+                    (output: number): void;
+                    (destinationNode: AudioNode): void;
+                    (destinationNode: AudioNode, output: number): void;
+                    (destinationNode: AudioNode, output: number, input: number): void;
+                    (destinationParam: AudioParam): void;
+                    (destinationParam: AudioParam, output: number): void;
+                };
+                addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean) => void;
+                dispatchEvent: (event: Event) => boolean;
+                removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean) => void;
+            };
+            readonly listener: {
+                readonly forwardX: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly forwardY: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly forwardZ: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly positionX: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly positionY: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly positionZ: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly upX: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly upY: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly upZ: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                setOrientation: (x: number, y: number, z: number, xUp: number, yUp: number, zUp: number) => void;
+                setPosition: (x: number, y: number, z: number) => void;
+            };
+            onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
+            readonly sampleRate: number;
+            readonly state: AudioContextState;
+            createAnalyser: () => AnalyserNode;
+            createBiquadFilter: () => BiquadFilterNode;
+            createBuffer: (numberOfChannels: number, length: number, sampleRate: number) => AudioBuffer;
+            createBufferSource: () => AudioBufferSourceNode;
+            createChannelMerger: (numberOfInputs?: number) => ChannelMergerNode;
+            createChannelSplitter: (numberOfOutputs?: number) => ChannelSplitterNode;
+            createConstantSource: () => ConstantSourceNode;
+            createConvolver: () => ConvolverNode;
+            createDelay: (maxDelayTime?: number) => DelayNode;
+            createDynamicsCompressor: () => DynamicsCompressorNode;
+            createGain: () => GainNode;
+            createIIRFilter: {
+                (feedforward: number[], feedback: number[]): IIRFilterNode;
+                (feedforward: Iterable<number>, feedback: Iterable<number>): IIRFilterNode;
+            };
+            createOscillator: () => OscillatorNode;
+            createPanner: () => PannerNode;
+            createPeriodicWave: {
+                (real: number[] | Float32Array, imag: number[] | Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
+                (real: Iterable<number>, imag: Iterable<number>, constraints?: PeriodicWaveConstraints): PeriodicWave;
+            };
+            createScriptProcessor: (bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number) => ScriptProcessorNode;
+            createStereoPanner: () => StereoPannerNode;
+            createWaveShaper: () => WaveShaperNode;
+            decodeAudioData: (audioData: ArrayBuffer, successCallback?: DecodeSuccessCallback | null, errorCallback?: DecodeErrorCallback | null) => Promise<AudioBuffer>;
+            addEventListener: {
+                <K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        };
+        readonly numberOfInputs: number;
+        readonly numberOfOutputs: number;
+        connect: {
+            (destinationNode: AudioNode, output?: number, input?: number): AudioNode;
+            (destinationParam: AudioParam, output?: number): void;
+        };
+        disconnect: {
+            (): void;
+            (output: number): void;
+            (destinationNode: AudioNode): void;
+            (destinationNode: AudioNode, output: number): void;
+            (destinationNode: AudioNode, output: number, input: number): void;
+            (destinationParam: AudioParam): void;
+            (destinationParam: AudioParam, output: number): void;
+        };
+        addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean) => void;
+        dispatchEvent: (event: Event) => boolean;
+        removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean) => void;
+    } | null, AnalyserNode | {
+        fftSize: number;
+        readonly frequencyBinCount: number;
+        maxDecibels: number;
+        minDecibels: number;
+        smoothingTimeConstant: number;
+        getByteFrequencyData: (array: Uint8Array) => void;
+        getByteTimeDomainData: (array: Uint8Array) => void;
+        getFloatFrequencyData: (array: Float32Array) => void;
+        getFloatTimeDomainData: (array: Float32Array) => void;
+        channelCount: number;
+        channelCountMode: ChannelCountMode;
+        channelInterpretation: ChannelInterpretation;
+        readonly context: {
+            readonly audioWorklet: {
+                addModule: (moduleURL: string | URL, options?: WorkletOptions) => Promise<void>;
+            };
+            readonly currentTime: number;
+            readonly destination: {
+                readonly maxChannelCount: number;
+                channelCount: number;
+                channelCountMode: ChannelCountMode;
+                channelInterpretation: ChannelInterpretation;
+                readonly context: /*elided*/ any;
+                readonly numberOfInputs: number;
+                readonly numberOfOutputs: number;
+                connect: {
+                    (destinationNode: AudioNode, output?: number, input?: number): AudioNode;
+                    (destinationParam: AudioParam, output?: number): void;
+                };
+                disconnect: {
+                    (): void;
+                    (output: number): void;
+                    (destinationNode: AudioNode): void;
+                    (destinationNode: AudioNode, output: number): void;
+                    (destinationNode: AudioNode, output: number, input: number): void;
+                    (destinationParam: AudioParam): void;
+                    (destinationParam: AudioParam, output: number): void;
+                };
+                addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean) => void;
+                dispatchEvent: (event: Event) => boolean;
+                removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean) => void;
+            };
+            readonly listener: {
+                readonly forwardX: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly forwardY: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly forwardZ: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly positionX: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly positionY: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly positionZ: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly upX: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly upY: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                readonly upZ: {
+                    automationRate: AutomationRate;
+                    readonly defaultValue: number;
+                    readonly maxValue: number;
+                    readonly minValue: number;
+                    value: number;
+                    cancelAndHoldAtTime: (cancelTime: number) => AudioParam;
+                    cancelScheduledValues: (cancelTime: number) => AudioParam;
+                    exponentialRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    linearRampToValueAtTime: (value: number, endTime: number) => AudioParam;
+                    setTargetAtTime: (target: number, startTime: number, timeConstant: number) => AudioParam;
+                    setValueAtTime: (value: number, startTime: number) => AudioParam;
+                    setValueCurveAtTime: {
+                        (values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+                        (values: Iterable<number>, startTime: number, duration: number): AudioParam;
+                    };
+                };
+                setOrientation: (x: number, y: number, z: number, xUp: number, yUp: number, zUp: number) => void;
+                setPosition: (x: number, y: number, z: number) => void;
+            };
+            onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
+            readonly sampleRate: number;
+            readonly state: AudioContextState;
+            createAnalyser: () => AnalyserNode;
+            createBiquadFilter: () => BiquadFilterNode;
+            createBuffer: (numberOfChannels: number, length: number, sampleRate: number) => AudioBuffer;
+            createBufferSource: () => AudioBufferSourceNode;
+            createChannelMerger: (numberOfInputs?: number) => ChannelMergerNode;
+            createChannelSplitter: (numberOfOutputs?: number) => ChannelSplitterNode;
+            createConstantSource: () => ConstantSourceNode;
+            createConvolver: () => ConvolverNode;
+            createDelay: (maxDelayTime?: number) => DelayNode;
+            createDynamicsCompressor: () => DynamicsCompressorNode;
+            createGain: () => GainNode;
+            createIIRFilter: {
+                (feedforward: number[], feedback: number[]): IIRFilterNode;
+                (feedforward: Iterable<number>, feedback: Iterable<number>): IIRFilterNode;
+            };
+            createOscillator: () => OscillatorNode;
+            createPanner: () => PannerNode;
+            createPeriodicWave: {
+                (real: number[] | Float32Array, imag: number[] | Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
+                (real: Iterable<number>, imag: Iterable<number>, constraints?: PeriodicWaveConstraints): PeriodicWave;
+            };
+            createScriptProcessor: (bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number) => ScriptProcessorNode;
+            createStereoPanner: () => StereoPannerNode;
+            createWaveShaper: () => WaveShaperNode;
+            decodeAudioData: (audioData: ArrayBuffer, successCallback?: DecodeSuccessCallback | null, errorCallback?: DecodeErrorCallback | null) => Promise<AudioBuffer>;
+            addEventListener: {
+                <K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        };
+        readonly numberOfInputs: number;
+        readonly numberOfOutputs: number;
+        connect: {
+            (destinationNode: AudioNode, output?: number, input?: number): AudioNode;
+            (destinationParam: AudioParam, output?: number): void;
+        };
+        disconnect: {
+            (): void;
+            (output: number): void;
+            (destinationNode: AudioNode): void;
+            (destinationNode: AudioNode, output: number): void;
+            (destinationNode: AudioNode, output: number, input: number): void;
+            (destinationParam: AudioParam): void;
+            (destinationParam: AudioParam, output: number): void;
+        };
+        addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean) => void;
+        dispatchEvent: (event: Event) => boolean;
+        removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean) => void;
+    } | null>;
+    audioRef: import("vue").Ref<any, any>;
+    wasPlayed: import("vue").Ref<boolean, boolean>;
+    isPlaying: import("vue").Ref<boolean, boolean>;
+    onPlay: () => void;
+    onStop: () => void;
+};
+//# sourceMappingURL=audio.composable.d.ts.map

package/dist/composables/Commons/audio.composable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio.composable.d.ts","sourceRoot":"","sources":["../../../src/composables/Commons/audio.composable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAI/C,wBAAgB,QAAQ,CAAE,KAAK,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqD3C"}

package/dist/composables/Commons/border.composable.d.ts

@@ -0,0 +1,8 @@
+import type { IBorderProps } from '@/interfaces';
+import { TDirectionBoth } from "@/types";
+import { Ref } from 'vue';
+export declare function useBorder(props: IBorderProps | Ref<boolean | number | string | TDirectionBoth | Array<TDirectionBoth> | null | undefined>, name?: string): {
+    borderClasses: import("vue").ComputedRef<string[]>;
+    borderStyles: import("vue").ComputedRef<string[]>;
+};
+//# sourceMappingURL=border.composable.d.ts.map

package/dist/composables/Commons/border.composable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"border.composable.d.ts","sourceRoot":"","sources":["../../../src/composables/Commons/border.composable.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAGxC,OAAO,EAAmB,GAAG,EAAE,MAAM,KAAK,CAAA;AAG1C,wBAAgB,SAAS,CAAE,KAAK,EAAE,YAAY,GAAG,GAAG,CAAC,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,IAAI,SAA2B;;;EAyC3K"}

package/dist/composables/Commons/border.composable.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=border.composable.spec.d.ts.map

package/dist/composables/Commons/border.composable.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"border.composable.spec.d.ts","sourceRoot":"","sources":["../../../src/composables/Commons/border.composable.spec.ts"],"names":[],"mappings":""}

package/dist/composables/Commons/calendar.composable.d.ts

@@ -0,0 +1,12 @@
+import type { ICalendarProps, IDay } from "@/interfaces";
+export declare function useCalendar(props: ICalendarProps): {
+    displayValue: import("vue").ComputedRef<unknown>;
+    daysInMonth: import("vue").ComputedRef<IDay[]>;
+    daysInWeek: import("vue").ComputedRef<IDay[]>;
+    genDays: (days: unknown[], today: unknown) => Array<IDay>;
+    model: import("../../types").TVModel<ICalendarProps, "date", unknown[]>;
+    weeksInMonth: import("vue").ComputedRef<unknown[][]>;
+    weekDays: import("vue").ComputedRef<number[] | undefined>;
+    weekNumbers: import("vue").ComputedRef<(number | null)[]>;
+};
+//# sourceMappingURL=calendar.composable.d.ts.map

package/dist/composables/Commons/calendar.composable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar.composable.d.ts","sourceRoot":"","sources":["../../../src/composables/Commons/calendar.composable.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAKxD,wBAAgB,WAAW,CAAE,KAAK,EAAE,cAAc;;;;oBA8FvB,OAAO,EAAE,SAAS,OAAO,KAAG,KAAK,CAAC,IAAI,CAAC;;;;;EA6DjE"}

package/dist/composables/Commons/color.composable.d.ts

@@ -0,0 +1,24 @@
+import type { IColorProps } from "@/interfaces";
+import type { TColor } from '@/types';
+import type { ComputedRef, Ref } from 'vue';
+export declare function useColor(colors: ComputedRef<{
+    background?: TColor;
+    text?: TColor;
+}>): {
+    colorStyles: ComputedRef<string[]>;
+};
+export declare function useBothColor<T extends Record<K, TColor>, K extends string>(bgColorProps: T | Ref<TColor> | ComputedRef<TColor>, colorProps: T | Ref<TColor> | ComputedRef<TColor>, name?: K): {
+    colorStyles: ComputedRef<string[]>;
+};
+export declare function useTextColor<T extends Record<K, TColor>, K extends string>(props: T | Ref<TColor>, name?: K): {
+    textColorStyles: ComputedRef<string[]>;
+};
+export declare function useBackgroundColor<T extends Record<K, TColor>, K extends string>(props: T | Ref<TColor>, name?: K): {
+    backgroundColorStyles: ComputedRef<string[]>;
+};
+export declare function useColorEffect(props: IColorProps, isHover?: Ref<boolean> | ComputedRef<boolean>, isActive?: Ref<boolean> | ComputedRef<boolean>): {
+    colorStyles: ComputedRef<string[]>;
+    color: ComputedRef<TColor>;
+    bgColor: ComputedRef<TColor>;
+};
+//# sourceMappingURL=color.composable.d.ts.map

package/dist/composables/Commons/color.composable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.composable.d.ts","sourceRoot":"","sources":["../../../src/composables/Commons/color.composable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAGrC,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG3C,wBAAgB,QAAQ,CAAE,MAAM,EAAE,WAAW,CAAC;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;;EAgCpF;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,SAAS,MAAM,EAAG,YAAY,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;;EAS5L;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,SAAS,MAAM,EACtE,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,EACtB,IAAI,CAAC,EAAE,CAAC;;EASX;AAED,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,SAAS,MAAM,EAC5E,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,EACtB,IAAI,CAAC,EAAE,CAAC;;EASX;AAED,wBAAgB,cAAc,CAAE,KAAK,EAAE,WAAW,EAAE,OAAO,GAAE,GAAG,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,CAAc,EAAE,QAAQ,GAAE,GAAG,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,CAAc;;;;EAuBxK"}