tiny-essentials 1.28.1 → 1.28.3

package/dist/v1/libs/TinyAfterScrollWatcher.d.mts

@@ -1,12 +1,4 @@
-export default TinyAfterScrollWatcher;
-/**
- * - Function with no arguments and no return value
- */
 export type FnData = (() => void);
-/**
- * A function that handles a scroll event.
- * It receives a standard `Event` object when a scroll occurs.
- */
 export type OnScrollFunc = (ev: Event) => void;
 /**
  * @typedef {(() => void)} FnData - Function with no arguments and no return value
@@ -23,6 +15,11 @@ export type OnScrollFunc = (ev: Event) => void;
  * @template {Element|Window} ScrollElement
  */
 declare class TinyAfterScrollWatcher<ScrollElement extends Element | Window> {
+    #private;
+    lastScrollTime: number | undefined;
+    get scrollTarget(): ScrollElement;
+    get afterScrollQueueSize(): number;
+    get destroyed(): boolean;
     /**
      * @param {ScrollElement} scrollTarget - The element or window to track scrolling on
      * @param {number} [inactivityTime=100] - Time in milliseconds to wait after scroll ends before executing the queue
@@ -30,13 +27,15 @@ declare class TinyAfterScrollWatcher<ScrollElement extends Element | Window> {
      * @throws {TypeError} If inactivityTime is not a positive number
      */
     constructor(scrollTarget: ScrollElement, inactivityTime?: number);
-    get scrollTarget(): ScrollElement;
-    get afterScrollQueueSize(): number;
-    get destroyed(): boolean;
     /**
      * @private
      */
     private _checkTimer;
+    /**
+     * Gets the current inactivity time in milliseconds.
+     * @returns {number}
+     */
+    get inactivityTime(): number;
     /**
      * Sets a new inactivity time.
      * Must be a positive number (in milliseconds).
@@ -44,11 +43,6 @@ declare class TinyAfterScrollWatcher<ScrollElement extends Element | Window> {
      * @throws {Error} If value is not a positive number
      */
     set inactivityTime(value: number);
-    /**
-     * Gets the current inactivity time in milliseconds.
-     * @returns {number}
-     */
-    get inactivityTime(): number;
     /**
      * Adds a function to be executed after scroll has stopped.
      * The scroll is considered "stopped" after the configured inactivity time.
@@ -57,7 +51,6 @@ declare class TinyAfterScrollWatcher<ScrollElement extends Element | Window> {
      * @throws {TypeError} If the argument is not a function.
      */
     doAfterScroll(fn: () => void): void;
-    lastScrollTime: number | undefined;
     /**
      * Registers a function to run once after scrolling has stopped,
      * before any afterScrollQueue functions.
@@ -91,6 +84,6 @@ declare class TinyAfterScrollWatcher<ScrollElement extends Element | Window> {
      * Destroys the watcher by removing internal listeners and clearing data.
      */
     destroy(): void;
-    #private;
 }
+export default TinyAfterScrollWatcher;
 //# sourceMappingURL=TinyAfterScrollWatcher.d.mts.map

package/dist/v1/libs/TinyAnalogClock.d.mts

@@ -1,7 +1,3 @@
-export default TinyAnalogClock;
-/**
- * Configuration object for the Analog Clock.
- */
 export type ClockConfig = {
     /**
      * - The background color of the clock face (e.g., '#ffffff', 'rgb(0,0,0)').
@@ -104,12 +100,7 @@ export type ClockConfig = {
  * @property {number} phM - Minute tick height as a percentage of clock size (0.0 to 1.0).
  */
 declare class TinyAnalogClock {
-    /**
-     * Creates an instance of TinyAnalogClock.
-     * Initializes the DOM structure and starts the animation loop.
-     * @param {Partial<ClockConfig>} [options] - Optional configuration overrides.
-     */
-    constructor(options?: Partial<ClockConfig>);
+    #private;
     /**
      * Gets the current destruction status of the instance.
      *
@@ -122,6 +113,12 @@ declare class TinyAnalogClock {
      * @private
      */
     private _getDate;
+    /**
+     * Creates an instance of TinyAnalogClock.
+     * Initializes the DOM structure and starts the animation loop.
+     * @param {Partial<ClockConfig>} [options] - Optional configuration overrides.
+     */
+    constructor(options?: Partial<ClockConfig>);
     /**
      * Applies the current configuration to the DOM elements (colors, sizes, visibility).
      * @private
@@ -343,6 +340,6 @@ declare class TinyAnalogClock {
      * @returns {void}
      */
     destroy(): void;
-    #private;
 }
+export default TinyAnalogClock;
 //# sourceMappingURL=TinyAnalogClock.d.mts.map

package/dist/v1/libs/TinyArrayComparator.d.mts

@@ -1,8 +1,8 @@
-export default TinyArrayComparator;
 /**
- * Holds the internal tracking variables during the comparison process.
+ * @fileoverview Array comparison utility.
+ * @module TinyArrayComparator
  */
-export type InternalState<ArrayItem extends unknown> = {
+export type InternalState<ArrayItem extends any> = {
     /**
      * - A map storing the hash as the key and the original item as the value.
      */
@@ -12,17 +12,10 @@ export type InternalState<ArrayItem extends unknown> = {
      */
     affectedItems: AffectedItems<ArrayItem>;
 };
-/**
- * The final array that collects added or deleted items.
- */
-export type AffectedItems<ArrayItem extends unknown> = Array<{
+export type AffectedItems<ArrayItem extends any> = Array<{
     item: ArrayItem;
-    status: "added" | "deleted";
+    status: 'added' | 'deleted';
 }>;
-/**
- * @fileoverview Array comparison utility.
- * @module TinyArrayComparator
- */
 /**
  * @template {any} ArrayItem
  * @typedef {Object} InternalState
@@ -39,7 +32,8 @@ export type AffectedItems<ArrayItem extends unknown> = Array<{
  * Compares two arrays efficiently by hashing their items to detect additions and deletions.
  * @template {any} ArrayItem
  */
-declare class TinyArrayComparator<ArrayItem extends unknown> {
+declare class TinyArrayComparator<ArrayItem extends any> {
+    #private;
     /**
      * Generates a simple 32-bit integer hash converted to a base36 string.
      * @param {any} item - The item to be hashed (can be an object, array, string, or number).
@@ -47,10 +41,10 @@ declare class TinyArrayComparator<ArrayItem extends unknown> {
      */
     static generateHash(item: any): string;
     /**
-     * Initializes the comparator with an optional base array.
-     * @param {ArrayItem[]} [oldArray] - The initial state of the array to be stored.
+     * Gets the current base array used for comparisons.
+     * @returns {ArrayItem[]} The current initial state of the array.
      */
-    constructor(oldArray?: ArrayItem[]);
+    get oldArray(): ArrayItem[];
     /**
      * Sets a new base array for future comparisons.
      * @param {ArrayItem[]} oldArray - The initial state of the array.
@@ -58,10 +52,10 @@ declare class TinyArrayComparator<ArrayItem extends unknown> {
      */
     set oldArray(oldArray: ArrayItem[]);
     /**
-     * Gets the current base array used for comparisons.
-     * @returns {ArrayItem[]} The current initial state of the array.
+     * Initializes the comparator with an optional base array.
+     * @param {ArrayItem[]} [oldArray] - The initial state of the array to be stored.
      */
-    get oldArray(): ArrayItem[];
+    constructor(oldArray?: ArrayItem[]);
     /**
      * Proxy to generates a hash converted to a string.
      * @param {ArrayItem} item - The item to be hashed (can be an object, array, string, or number).
@@ -77,6 +71,6 @@ declare class TinyArrayComparator<ArrayItem extends unknown> {
      * @throws {TypeError} Throws an error if the provided value is not an array.
      */
     compare(newArray: ArrayItem[]): AffectedItems<ArrayItem>;
-    #private;
 }
+export default TinyArrayComparator;
 //# sourceMappingURL=TinyArrayComparator.d.mts.map

package/dist/v1/libs/TinyArrayPaginator.d.mts

@@ -1,10 +1,16 @@
-export default TinyArrayPaginator;
 /**
  * A predicate function used to determine whether an item should be included in the filtered results.
  * Works similarly to the callback function of `Array.prototype.filter`.
+ *
+ * @template {any} ArrayItem
+ * @callback GetFilter
+ * @param {ArrayItem} value - The current element being processed in the array.
+ * @param {number} index - The index of the current element within the array.
+ * @param {ArrayItem[]} array - The full array being processed.
+ * @returns {boolean} Returns `true` to include the element in the results, or `false` to exclude it.
  */
-export type GetFilter<ArrayItem extends unknown> = (value: ArrayItem, index: number, array: ArrayItem[]) => boolean;
-export type GetterResult<ArrayItem extends unknown> = {
+export type GetFilter<ArrayItem extends any> = (value: ArrayItem, index: number, array: ArrayItem[]) => boolean;
+export type GetterResult<ArrayItem extends any> = {
     /**
      * - The subset of items for the requested page.
      */
@@ -34,17 +40,6 @@ export type GetterResult<ArrayItem extends unknown> = {
      */
     hasNext: boolean;
 };
-/**
- * A predicate function used to determine whether an item should be included in the filtered results.
- * Works similarly to the callback function of `Array.prototype.filter`.
- *
- * @template {any} ArrayItem
- * @callback GetFilter
- * @param {ArrayItem} value - The current element being processed in the array.
- * @param {number} index - The index of the current element within the array.
- * @param {ArrayItem[]} array - The full array being processed.
- * @returns {boolean} Returns `true` to include the element in the results, or `false` to exclude it.
- */
 /**
  * @template {any} ArrayItem
  * @typedef {Object} GetterResult
@@ -62,29 +57,30 @@ export type GetterResult<ArrayItem extends unknown> = {
  * while keeping the source array safe from direct modifications.
  * @template {any} ArrayItem
  */
-declare class TinyArrayPaginator<ArrayItem extends unknown> {
+declare class TinyArrayPaginator<ArrayItem extends any> {
+    #private;
     /**
-     * Creates a new paginator instance for the given data array.
-     * @param {ArrayItem[]|Set<ArrayItem>} data - The array to be paginated.
-     * @throws {TypeError} If the provided data is not an array.
+     * Gets current stored array.
+     * @returns {ArrayItem[]|Set<ArrayItem>}
      */
-    constructor(data: ArrayItem[] | Set<ArrayItem>);
+    get data(): ArrayItem[] | Set<ArrayItem>;
     /**
      * Replaces the current data array.
      * @param {ArrayItem[]|Set<ArrayItem>} value - The new array to be used as the data source.
      * @throws {TypeError} If the provided value is not an array.
      */
     set data(value: ArrayItem[] | Set<ArrayItem>);
-    /**
-     * Gets current stored array.
-     * @returns {ArrayItem[]|Set<ArrayItem>}
-     */
-    get data(): ArrayItem[] | Set<ArrayItem>;
     /**
      * Gets the total number of items in the current data array.
      * @returns {number} Total number of stored items.
      */
     get size(): number;
+    /**
+     * Creates a new paginator instance for the given data array.
+     * @param {ArrayItem[]|Set<ArrayItem>} data - The array to be paginated.
+     * @throws {TypeError} If the provided data is not an array.
+     */
+    constructor(data: ArrayItem[] | Set<ArrayItem>);
     /**
      * Filters data according to a search query and returns paginated results.
      * @param {Object} settings
@@ -98,8 +94,8 @@ declare class TinyArrayPaginator<ArrayItem extends unknown> {
     get({ page, perPage, filter }: {
         page: number;
         perPage: number;
-        filter?: Record<string, RegExp | ArrayItem> | GetFilter<ArrayItem> | undefined;
+        filter?: Record<string, ArrayItem | RegExp> | GetFilter<ArrayItem>;
     }): GetterResult<ArrayItem>;
-    #private;
 }
+export default TinyArrayPaginator;
 //# sourceMappingURL=TinyArrayPaginator.d.mts.map

package/dist/v1/libs/TinyClassManager/TinyPluginInliner.d.mts

@@ -1,4 +1,3 @@
-export default TinyPluginInliner;
 export type RootReplacement = {
     /**
      * - The directory name to replace (e.g., 'src').
@@ -25,7 +24,7 @@ export type InlinerConfig = {
     /**
      * - Optional customization to remap project import roots.
      */
-    rootReplacement?: RootReplacement | undefined;
+    rootReplacement?: RootReplacement;
 };
 /**
  * @typedef {Object} RootReplacement
@@ -40,12 +39,6 @@ export type InlinerConfig = {
  * @property {RootReplacement} [rootReplacement] - Optional customization to remap project import roots.
  */
 declare class TinyPluginInliner {
-    /**
-     * Creates an instance of the TinyPluginInliner.
-     *
-     * @param {InlinerConfig} config - The configuration object for the build process.
-     */
-    constructor(config: InlinerConfig);
     config: InlinerConfig;
     entryFile: string;
     outDir: string;
@@ -53,6 +46,12 @@ declare class TinyPluginInliner {
     entryDir: string;
     hoistedImports: Set<any>;
     hoistedTypedefs: Set<any>;
+    /**
+     * Creates an instance of the TinyPluginInliner.
+     *
+     * @param {InlinerConfig} config - The configuration object for the build process.
+     */
+    constructor(config: InlinerConfig);
     /**
      * Rewrites all import paths (both standard and inside JSDocs) in a given code string.
      * Handles local path root replacements and NPM package absolute path conversion.
@@ -89,4 +88,5 @@ declare class TinyPluginInliner {
      */
     build(): Promise<void>;
 }
+export default TinyPluginInliner;
 //# sourceMappingURL=TinyPluginInliner.d.mts.map

package/dist/v1/libs/TinyClassManager.cjs

@@ -9,7 +9,7 @@
  * @typedef {Object} PluginDefinition
  * @property {string} name - The unique identifier for the plugin.
  * @property {string[]} [dependencies] - Array of plugin names required before applying this one.
- * @property {function(TBase, AppliedPluginClasses): TExtended} apply - Function that receives the base class and returns the extended class.
+ * @property {(Base: TBase, classes: AppliedPluginClasses) => TExtended} apply - Function that receives the base class and returns the extended class.
  */
 
 /**
@@ -18,8 +18,6 @@
  * @template {T|NewTinyClass} oldT
  */
 class TinyClassManager {
-  /** @typedef {[...oldT[], T]} AppliedPluginClasses */
-
   /**
    * @type {Set<string>}
    * Tracks the names of successfully applied plugins to prevent duplication and check dependencies.
@@ -36,7 +34,7 @@ class TinyClassManager {
   }
 
   /**
-   * @type {AppliedPluginClasses}
+   * @type {[...oldT[], T]}
    * Tracks the classes of successfully applied plugins to prevent duplication and check dependencies.
    */
   // @ts-ignore
@@ -44,7 +42,7 @@ class TinyClassManager {
 
   /**
    * Gets the list of plugin classes currently applied to this instance.
-   * @returns {AppliedPluginClasses} Array of applied plugin classes.
+   * @returns {[...oldT[], T]} Array of applied plugin classes.
    */
   get appliedPluginClasses() {
     if (this.#used) throw new Error(`[TinyClassManager] Cannot get a consumed manager instance.`);
@@ -140,7 +138,7 @@ class TinyClassManager {
    * Applies a plugin to the class chain using a definition object.
    * @deprecated Use {@link insert} instead.
    * @template {NewTinyClass} R
-   * @param {PluginDefinition<T, R, AppliedPluginClasses>} plugin - The plugin module to be integrated.
+   * @param {PluginDefinition<T, R, [...oldT[], T]>} plugin - The plugin module to be integrated.
    * @returns {TinyClassManager<R, T | oldT>} A new manager instance holding the extended class chain.
    * @throws {Error} Throws if instance is already consumed, plugin is duplicate, or dependencies are missing.
    */
@@ -164,7 +162,7 @@ class TinyClassManager {
    * Inserts a plugin directly by passing its apply function.
    * It reads `_tinyDepName` and `_tinyDeps` statically from the returned class.
    * @template {NewTinyClass} R
-   * @param {function(T, AppliedPluginClasses): R} applyFn - Function that receives the base class and returns the extended class.
+   * @param {(ClassItem: T, classes: [...oldT[], T]) => R} applyFn - Function that receives the base class and returns the extended class.
    * @returns {TinyClassManager<R, T | oldT>} A new manager instance holding the extended class chain.
    * @throws {Error} Throws if static properties are missing, instance is consumed, or validation fails.
    */

package/dist/v1/libs/TinyClassManager.d.mts

@@ -1,4 +1,4 @@
-export default TinyClassManager;
+/** @typedef {new (...args: any[]) => any} NewTinyClass */
 export type NewTinyClass = new (...args: any[]) => any;
 export type PluginDefinition<TBase extends NewTinyClass, TExtended extends NewTinyClass, AppliedPluginClasses extends NewTinyClass[]> = {
     /**
@@ -8,13 +8,12 @@ export type PluginDefinition<TBase extends NewTinyClass, TExtended extends NewTi
     /**
      * - Array of plugin names required before applying this one.
      */
-    dependencies?: string[] | undefined;
+    dependencies?: string[];
     /**
      * - Function that receives the base class and returns the extended class.
      */
-    apply: (arg0: TBase, arg1: AppliedPluginClasses) => TExtended;
+    apply: (Base: TBase, classes: AppliedPluginClasses) => TExtended;
 };
-/** @typedef {new (...args: any[]) => any} NewTinyClass */
 /**
  * @template {NewTinyClass} TBase
  * @template {NewTinyClass} TExtended
@@ -22,7 +21,7 @@ export type PluginDefinition<TBase extends NewTinyClass, TExtended extends NewTi
  * @typedef {Object} PluginDefinition
  * @property {string} name - The unique identifier for the plugin.
  * @property {string[]} [dependencies] - Array of plugin names required before applying this one.
- * @property {function(TBase, AppliedPluginClasses): TExtended} apply - Function that receives the base class and returns the extended class.
+ * @property {(Base: TBase, classes: AppliedPluginClasses) => TExtended} apply - Function that receives the base class and returns the extended class.
  */
 /**
  * Manages the composition of a base class with multiple optional plugins (Mixins).
@@ -30,12 +29,7 @@ export type PluginDefinition<TBase extends NewTinyClass, TExtended extends NewTi
  * @template {T|NewTinyClass} oldT
  */
 declare class TinyClassManager<T extends NewTinyClass, oldT extends T | NewTinyClass> {
-    /**
-     * Initializes the manager with a core class.
-     * @param {T} coreClass - The foundational class to be extended.
-     * @param {oldT[]} [oldClasses=[]]
-     */
-    constructor(coreClass: T, oldClasses?: oldT[]);
+    #private;
     /**
      * Gets the list of plugins currently applied to this instance.
      * @returns {string[]} Array of applied plugin names.
@@ -43,7 +37,7 @@ declare class TinyClassManager<T extends NewTinyClass, oldT extends T | NewTinyC
     get appliedPlugins(): string[];
     /**
      * Gets the list of plugin classes currently applied to this instance.
-     * @returns {AppliedPluginClasses} Array of applied plugin classes.
+     * @returns {[...oldT[], T]} Array of applied plugin classes.
      */
     get appliedPluginClasses(): [...oldT[], T];
     /**
@@ -59,11 +53,17 @@ declare class TinyClassManager<T extends NewTinyClass, oldT extends T | NewTinyC
      * Protects the instance from being consumed or reused after transition.
      */
     get used(): boolean;
+    /**
+     * Initializes the manager with a core class.
+     * @param {T} coreClass - The foundational class to be extended.
+     * @param {oldT[]} [oldClasses=[]]
+     */
+    constructor(coreClass: T, oldClasses?: oldT[]);
     /**
      * Applies a plugin to the class chain using a definition object.
      * @deprecated Use {@link insert} instead.
      * @template {NewTinyClass} R
-     * @param {PluginDefinition<T, R, AppliedPluginClasses>} plugin - The plugin module to be integrated.
+     * @param {PluginDefinition<T, R, [...oldT[], T]>} plugin - The plugin module to be integrated.
      * @returns {TinyClassManager<R, T | oldT>} A new manager instance holding the extended class chain.
      * @throws {Error} Throws if instance is already consumed, plugin is duplicate, or dependencies are missing.
      */
@@ -72,17 +72,17 @@ declare class TinyClassManager<T extends NewTinyClass, oldT extends T | NewTinyC
      * Inserts a plugin directly by passing its apply function.
      * It reads `_tinyDepName` and `_tinyDeps` statically from the returned class.
      * @template {NewTinyClass} R
-     * @param {function(T, AppliedPluginClasses): R} applyFn - Function that receives the base class and returns the extended class.
+     * @param {(ClassItem: T, classes: [...oldT[], T]) => R} applyFn - Function that receives the base class and returns the extended class.
      * @returns {TinyClassManager<R, T | oldT>} A new manager instance holding the extended class chain.
      * @throws {Error} Throws if static properties are missing, instance is consumed, or validation fails.
      */
-    insert<R extends NewTinyClass>(applyFn: (arg0: T, arg1: [...oldT[], T]) => R): TinyClassManager<R, T | oldT>;
+    insert<R extends NewTinyClass>(applyFn: (ClassItem: T, classes: [...oldT[], T]) => R): TinyClassManager<R, T | oldT>;
     /**
      * Finalizes the composition and returns the fully built class.
      * @returns {T} The final class representing the last extended version in the chain.
      * @throws {Error} Throws if the manager instance has already been used or finalized.
      */
     build(): T;
-    #private;
 }
+export default TinyClassManager;
 //# sourceMappingURL=TinyClassManager.d.mts.map

package/dist/v1/libs/TinyClassManager.mjs

@@ -6,7 +6,7 @@
  * @typedef {Object} PluginDefinition
  * @property {string} name - The unique identifier for the plugin.
  * @property {string[]} [dependencies] - Array of plugin names required before applying this one.
- * @property {function(TBase, AppliedPluginClasses): TExtended} apply - Function that receives the base class and returns the extended class.
+ * @property {(Base: TBase, classes: AppliedPluginClasses) => TExtended} apply - Function that receives the base class and returns the extended class.
  */
 /**
  * Manages the composition of a base class with multiple optional plugins (Mixins).
@@ -14,7 +14,6 @@
  * @template {T|NewTinyClass} oldT
  */
 class TinyClassManager {
-    /** @typedef {[...oldT[], T]} AppliedPluginClasses */
     /**
      * @type {Set<string>}
      * Tracks the names of successfully applied plugins to prevent duplication and check dependencies.
@@ -30,14 +29,14 @@ class TinyClassManager {
         return [...this.#appliedPlugins];
     }
     /**
-     * @type {AppliedPluginClasses}
+     * @type {[...oldT[], T]}
      * Tracks the classes of successfully applied plugins to prevent duplication and check dependencies.
      */
     // @ts-ignore
     #appliedPluginClasses = [];
     /**
      * Gets the list of plugin classes currently applied to this instance.
-     * @returns {AppliedPluginClasses} Array of applied plugin classes.
+     * @returns {[...oldT[], T]} Array of applied plugin classes.
      */
     get appliedPluginClasses() {
         if (this.#used)
@@ -120,7 +119,7 @@ class TinyClassManager {
      * Applies a plugin to the class chain using a definition object.
      * @deprecated Use {@link insert} instead.
      * @template {NewTinyClass} R
-     * @param {PluginDefinition<T, R, AppliedPluginClasses>} plugin - The plugin module to be integrated.
+     * @param {PluginDefinition<T, R, [...oldT[], T]>} plugin - The plugin module to be integrated.
      * @returns {TinyClassManager<R, T | oldT>} A new manager instance holding the extended class chain.
      * @throws {Error} Throws if instance is already consumed, plugin is duplicate, or dependencies are missing.
      */
@@ -141,7 +140,7 @@ class TinyClassManager {
      * Inserts a plugin directly by passing its apply function.
      * It reads `_tinyDepName` and `_tinyDeps` statically from the returned class.
      * @template {NewTinyClass} R
-     * @param {function(T, AppliedPluginClasses): R} applyFn - Function that receives the base class and returns the extended class.
+     * @param {(ClassItem: T, classes: [...oldT[], T]) => R} applyFn - Function that receives the base class and returns the extended class.
      * @returns {TinyClassManager<R, T | oldT>} A new manager instance holding the extended class chain.
      * @throws {Error} Throws if static properties are missing, instance is consumed, or validation fails.
      */

package/dist/v1/libs/TinyClipboard.d.mts

@@ -1,9 +1,14 @@
-export default TinyClipboard;
 /**
  * Utility class to handle clipboard operations for text and blob data.
  * Supports modern Clipboard API, custom platform, and legacy execCommand fallback.
  */
 declare class TinyClipboard {
+    #private;
+    /**
+     * Constructs a new TinyClipboard instance.
+     * Automatically detects and configures available clipboard APIs.
+     */
+    constructor();
     /**
      * Override the default text copy behavior.
      * This allows you to provide your own clipboard implementation or
@@ -102,7 +107,7 @@ declare class TinyClipboard {
      * @param {string|null} [mimeFormat=null] - The MIME type or prefix to match.
      * @returns {Promise<Array<Blob|string>>} A promise resolving with matching data array.
      */
-    readAllData(type?: "text" | "custom" | null, mimeFormat?: string | null): Promise<Array<Blob | string>>;
+    readAllData(type?: 'text' | 'custom' | null, mimeFormat?: string | null): Promise<Array<Blob | string>>;
     /**
      * Read clipboard data at a specific index or all if null.
      *
@@ -152,6 +157,6 @@ declare class TinyClipboard {
      * @returns {((blob: Blob) => Promise<void>) | null} The current blob copy function or null if unavailable.
      */
     getCopyBlobFunc(): ((blob: Blob) => Promise<void>) | null;
-    #private;
 }
+export default TinyClipboard;
 //# sourceMappingURL=TinyClipboard.d.mts.map

package/dist/v1/libs/TinyColorConverter.d.mts

@@ -1,32 +1,19 @@
-export default TinyColorConverter;
 /**
  * Represents a color in RGBA format.
  * Each element must be a number between 0 and 255.
  * The fourth value represents the alpha (transparency) channel.
+ *
+ * @typedef {number[]} RgbaColor
+ * @property {number} 0 - Red component (0–255)
+ * @property {number} 1 - Green component (0–255)
+ * @property {number} 2 - Blue component (0–255)
+ * @property {number} 3 - Alpha component (0–255)
  */
 export type RgbaColor = number[];
-/**
- * Represents a color in RGB format.
- * Each element must be a number between 0 and 255.
- */
 export type RgbColor = number[];
-/**
- * Represents a color in HSLA format.
- * The fourth value represents the alpha (transparency) channel.
- */
 export type HslaColor = number[];
-/**
- * Represents a color in HSL format.
- */
 export type HslColor = number[];
-/**
- * Represents a hex color.
- */
 export type HexColor = string;
-/**
- * A union type representing various accepted color formats.
- * Can be a hex color string, a numeric value, or an array-based RGB/RGBA representation.
- */
 export type ColorTypes = HexColor | number | RgbColor | RgbaColor;
 export type RgbaResult = {
     /**
@@ -80,17 +67,6 @@ export type HslResult = {
      */
     l: number;
 };
-/**
- * Represents a color in RGBA format.
- * Each element must be a number between 0 and 255.
- * The fourth value represents the alpha (transparency) channel.
- *
- * @typedef {number[]} RgbaColor
- * @property {number} 0 - Red component (0–255)
- * @property {number} 1 - Green component (0–255)
- * @property {number} 2 - Blue component (0–255)
- * @property {number} 3 - Alpha component (0–255)
- */
 /**
  * Represents a color in RGB format.
  * Each element must be a number between 0 and 255.
@@ -156,6 +132,7 @@ export type HslResult = {
  * A class that allows converting colors between all common formats.
  */
 declare class TinyColorConverter {
+    #private;
     /**
      * Generates a smooth gradient of colors based on sine wave patterns.
      *
@@ -392,6 +369,6 @@ declare class TinyColorConverter {
      * @returns {ColorTypes}
      */
     getOriginal(): ColorTypes;
-    #private;
 }
+export default TinyColorConverter;
 //# sourceMappingURL=TinyColorConverter.d.mts.map