tiny-essentials 1.18.1 → 1.19.0

package/dist/v1/TinyEssentials.js

@@ -2888,17 +2888,21 @@ __webpack_require__.d(__webpack_exports__, {
   ColorSafeStringify: () => (/* reexport */ libs_ColorSafeStringify),
   TinyAfterScrollWatcher: () => (/* reexport */ libs_TinyAfterScrollWatcher),
   TinyClipboard: () => (/* reexport */ libs_TinyClipboard),
+  TinyColorConverter: () => (/* reexport */ libs_TinyColorConverter),
   TinyDomReadyManager: () => (/* reexport */ libs_TinyDomReadyManager),
   TinyDragDropDetector: () => (/* reexport */ libs_TinyDragDropDetector),
   TinyDragger: () => (/* reexport */ libs_TinyDragger),
+  TinyEvents: () => (/* reexport */ libs_TinyEvents),
   TinyHtml: () => (/* reexport */ libs_TinyHtml),
   TinyLevelUp: () => (/* reexport */ userLevel),
+  TinyLocalStorage: () => (/* reexport */ libs_TinyLocalStorage),
   TinyNotifications: () => (/* reexport */ libs_TinyNotifications),
   TinyNotifyCenter: () => (/* reexport */ libs_TinyNotifyCenter),
   TinyPromiseQueue: () => (/* reexport */ libs_TinyPromiseQueue),
   TinyRateLimiter: () => (/* reexport */ libs_TinyRateLimiter),
   TinySmartScroller: () => (/* reexport */ libs_TinySmartScroller),
   TinyTextRangeEditor: () => (/* reexport */ libs_TinyTextRangeEditor),
+  TinyTimeout: () => (/* reexport */ libs_TinyTimeout),
   TinyToastNotify: () => (/* reexport */ libs_TinyToastNotify),
   UltraRandomMsgGen: () => (/* reexport */ libs_UltraRandomMsgGen),
   addAiMarkerShortcut: () => (/* reexport */ addAiMarkerShortcut),
@@ -5153,7 +5157,8 @@ class TinyRateLimiter {
    */
   reset(userId) {
     if (false)
-      {}
+      // removed by dead control flow
+{}
     return this.resetUserGroup(userId);
   }
 
@@ -6527,8 +6532,8 @@ async function fetchBlob(url, allowedMimeTypes, options) {
  * @param {Element} [settings.element=document.body] - The element to receive visibility classes.
  * @param {string} [settings.hiddenClass='windowHidden'] - CSS class applied when the page is hidden.
  * @param {string} [settings.visibleClass='windowVisible'] - CSS class applied when the page is visible.
- * @param {() => void} [settings.onVisible] - Callback called when page becomes visible.
- * @param {() => void} [settings.onHidden] - Callback called when page becomes hidden.
+ * @param {(data: { type: string; oldType: string; oldClass: string; }) => void} [settings.onVisible] - Callback called when page becomes visible.
+ * @param {(data: { type: string; oldType: string; oldClass: string; }) => void} [settings.onHidden] - Callback called when page becomes hidden.
  * @returns {() => void} Function that removes all installed event listeners.
  * @throws {TypeError} If any provided setting is invalid.
  */
@@ -6548,6 +6553,8 @@ function installWindowHiddenScript({
   if (onHidden !== undefined && typeof onHidden !== 'function')
     throw new TypeError(`"onHidden" must be a function if provided.`);
 
+  let oldType = '';
+  let oldClass = '';
   const removeClass = () => {
     element.classList.remove(hiddenClass);
     element.classList.remove(visibleClass);
@@ -6585,19 +6592,24 @@ function installWindowHiddenScript({
 
     if (visibleEvents.includes(type)) {
       element.classList.add(visibleClass);
-      onVisible?.();
+      onVisible?.({ type, oldClass, oldType });
+      oldClass = visibleClass;
     } else if (hiddenEvents.includes(type)) {
       element.classList.add(hiddenClass);
-      onHidden?.();
+      onHidden?.({ type, oldClass, oldType });
+      oldClass = hiddenClass;
     } else {
       if (isHidden) {
         element.classList.add(hiddenClass);
-        onHidden?.();
+        onHidden?.({ type, oldClass, oldType });
+        oldClass = hiddenClass;
       } else {
         element.classList.add(visibleClass);
-        onVisible?.();
+        onVisible?.({ type, oldClass, oldType });
+        oldClass = visibleClass;
       }
     }
+    oldType = type;
   };
 
   /** @type {() => void} */
@@ -15694,10 +15706,374 @@ class UltraRandomMsgGen {
 
 /* harmony default export */ const libs_UltraRandomMsgGen = (UltraRandomMsgGen);
 
+;// ./src/v1/libs/TinyEvents.mjs
+/**
+ * A generic event listener callback function.
+ *
+ * @callback handler
+ * @param {...any} payload - The data payload passed when the event is triggered.
+ * @returns {void}
+ */
+
+/**
+ * TinyEvents provides a minimalistic event emitter system similar to Node.js's EventEmitter,
+ * enabling components to subscribe to, emit, and manage events and their listeners.
+ *
+ * Features include:
+ * - Adding/removing event listeners (`on`, `off`, `offAll`, `offAllTypes`)
+ * - One-time listeners (`once`)
+ * - Emitting events (`emit`)
+ * - Listener inspection and limits (`listenerCount`, `listeners`, `eventNames`)
+ * - Maximum listener control (`setMaxListeners`, `getMaxListeners`)
+ *
+ * This class is useful for lightweight, dependency-free publish/subscribe event handling
+ * within modular JavaScript applications.
+ *
+ * @class
+ */
+class TinyEvents {
+  /** @type {Map<string, { handler: handler; config: { once: boolean } }[]>} */
+  #listeners = new Map();
+
+  /** @type {number} */
+  #maxListeners = 10;
+
+  /** @type {boolean} */
+  #throwMaxListeners = false;
+
+  /**
+   * Enables or disables throwing an error when the maximum number of listeners is exceeded.
+   *
+   * @param {boolean} shouldThrow - If true, an error will be thrown when the max is exceeded.
+   */
+  setThrowOnMaxListeners(shouldThrow) {
+    if (typeof shouldThrow !== 'boolean')
+      throw new TypeError('setThrowOnMaxListeners(value): value must be a boolean');
+    this.#throwMaxListeners = shouldThrow;
+  }
+
+  /**
+   * Checks whether an error will be thrown when the max listener limit is exceeded.
+   *
+   * @returns {boolean} True if an error will be thrown, false if only a warning is shown.
+   */
+  getThrowOnMaxListeners() {
+    return this.#throwMaxListeners;
+  }
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * Internal method to prepend a listener with options.
+   *
+   * @param {string} event - Event name.
+   * @param {handler} handler - The callback function.
+   * @param {Object} [settings={}] - Optional settings.
+   * @param {boolean} [settings.once=false] - If the listener should be executed once.
+   */
+  #prepend(event, handler, { once = false } = {}) {
+    let eventData = this.#listeners.get(event);
+    if (!Array.isArray(eventData)) {
+      eventData = [];
+      this.#listeners.set(event, eventData);
+    }
+    eventData.unshift({ handler, config: { once } });
+
+    const max = this.#maxListeners;
+    if (max > 0 && eventData.length > max) {
+      const warnMessage =
+        `Possible memory leak detected. ${eventData.length} "${event}" listeners added. ` +
+        `Use setMaxListeners() to increase limit.`;
+      if (!this.#throwMaxListeners) console.warn(warnMessage);
+      else throw new Error(warnMessage);
+    }
+  }
+
+  /**
+   * Adds a listener to the beginning of the listeners array for the specified event.
+   *
+   * @param {string} event - Event name.
+   * @param {handler} handler - The callback function.
+   */
+  prependListener(event, handler) {
+    if (typeof event !== 'string')
+      throw new TypeError('prepend(event, handler): event name must be a string');
+    if (typeof handler !== 'function')
+      throw new TypeError('prepend(event, handler): handler must be a function');
+    this.#prepend(event, handler);
+  }
+
+  /**
+   * Adds a one-time listener to the beginning of the listeners array for the specified event.
+   *
+   * @param {string} event - Event name.
+   * @param {handler} handler - The callback function.
+   * @returns {handler} - The wrapped handler used internally.
+   */
+  prependListenerOnce(event, handler) {
+    if (typeof event !== 'string')
+      throw new TypeError('prependOnceListener(event, handler): event name must be a string');
+    if (typeof handler !== 'function')
+      throw new TypeError('prependOnceListener(event, handler): handler must be a function');
+
+    /** @type {handler} */
+    const wrapped = (...args) => {
+      this.off(event, wrapped);
+      handler(...args);
+    };
+
+    this.#prepend(event, wrapped, { once: true });
+    return wrapped;
+  }
+
+  ////////////////////////////////////////////////////////////
+
+  /**
+   * Adds a event listener.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - Callback function to be called when event fires.
+   * @param {Object} [settings={}] - Optional settings.
+   * @param {boolean} [settings.once=false] - This is a once event.
+   */
+  #on(event, handler, { once = false } = {}) {
+    let eventData = this.#listeners.get(event);
+    if (!Array.isArray(eventData)) {
+      eventData = [];
+      this.#listeners.set(event, eventData);
+    }
+    eventData.push({ handler, config: { once } });
+    // Warn if listener count exceeds the max allowed
+    const max = this.#maxListeners;
+    if (max > 0 && eventData.length > max) {
+      const warnMessage =
+        `Possible memory leak detected. ${eventData.length} "${event}" listeners added. ` +
+        `Use setMaxListeners() to increase limit.`;
+      if (!this.#throwMaxListeners) console.warn(warnMessage);
+      else throw new Error(warnMessage);
+    }
+  }
+
+  /**
+   * Adds a event listener.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - Callback function to be called when event fires.
+   */
+  on(event, handler) {
+    if (typeof event !== 'string')
+      throw new TypeError('on(event, handler): event name must be a string');
+    if (typeof handler !== 'function')
+      throw new TypeError('on(event, handler): handler must be a function');
+    return this.#on(event, handler);
+  }
+
+  /**
+   * Registers an event listener that runs only once, then is removed.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - The callback function to run on event.
+   * @returns {handler} - The wrapped version of the handler.
+   */
+  once(event, handler) {
+    if (typeof event !== 'string') throw new TypeError('The event name must be a string.');
+    if (typeof handler !== 'function')
+      throw new TypeError('once(event, handler): handler must be a function');
+
+    /** @type {handler} */
+    const wrapped = (e) => {
+      this.off(event, wrapped);
+      if (typeof handler === 'function') handler(e);
+    };
+    this.#on(event, wrapped, { once: true });
+    return wrapped;
+  }
+
+  /**
+   * Adds a event listener.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - Callback function to be called when event fires.
+   */
+  appendListener(event, handler) {
+    return this.on(event, handler);
+  }
+
+  /**
+   * Registers an event listener that runs only once, then is removed.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - The callback function to run on event.
+   * @returns {handler} - The wrapped version of the handler.
+   */
+  appendListenerOnce(event, handler) {
+    return this.once(event, handler);
+  }
+
+  ///////////////////////////////////////////////
+
+  /**
+   * Removes a previously registered event listener.
+   *
+   * @param {string} event - The name of the event to remove the handler from.
+   * @param {handler} handler - The specific callback function to remove.
+   */
+  off(event, handler) {
+    if (typeof event !== 'string')
+      throw new TypeError('off(event, handler): event name must be a string');
+    if (typeof handler !== 'function')
+      throw new TypeError('off(event, handler): handler must be a function');
+
+    const listeners = this.#listeners.get(event);
+    if (!Array.isArray(listeners)) return;
+
+    const index = listeners.findIndex((listener) => listener.handler === handler);
+    if (index !== -1) listeners.splice(index, 1);
+
+    // Optionally clean up empty arrays (optional)
+    if (listeners.length === 0) this.#listeners.delete(event);
+  }
+
+  /**
+   * Removes all event listeners of a specific type from the element.
+   *
+   * @param {string} event - The event type to remove (e.g. 'onScrollBoundary').
+   */
+  offAll(event) {
+    if (typeof event !== 'string') throw new TypeError('The event name must be a string.');
+    this.#listeners.delete(event);
+  }
+
+  /**
+   * Removes all event listeners of all types from the element.
+   */
+  offAllTypes() {
+    this.#listeners.clear();
+  }
+
+  /////////////////////////////////////////////
+
+  /**
+   * Returns the number of listeners for a given event.
+   *
+   * @param {string} event - The name of the event.
+   * @returns {number} Number of listeners for the event.
+   */
+  listenerCount(event) {
+    if (typeof event !== 'string')
+      throw new TypeError('listenerCount(event): event name must be a string');
+
+    const listeners = this.#listeners.get(event);
+    return Array.isArray(listeners) ? listeners.length : 0;
+  }
+
+  /**
+   * Returns a copy of the array of listeners for the specified event.
+   *
+   * @param {string} event - The name of the event.
+   * @returns {handler[]} Array of listener functions.
+   */
+  listeners(event) {
+    if (typeof event !== 'string')
+      throw new TypeError('listeners(event): event name must be a string');
+
+    const listeners = this.#listeners.get(event);
+    return Array.isArray(listeners)
+      ? [...listeners]
+          .filter((listener) => !listener.config.once)
+          .map((listener) => listener.handler)
+      : [];
+  }
+
+  /**
+   * Returns a copy of the array of listeners for the specified event.
+   *
+   * @param {string} event - The name of the event.
+   * @returns {handler[]} Array of listener functions.
+   */
+  onceListeners(event) {
+    if (typeof event !== 'string')
+      throw new TypeError('onceListeners(event): event name must be a string');
+
+    const listeners = this.#listeners.get(event);
+    return Array.isArray(listeners)
+      ? [...listeners]
+          .filter((listener) => listener.config.once)
+          .map((listener) => listener.handler)
+      : [];
+  }
+
+  /**
+   * Returns a copy of the internal listeners array for the specified event,
+   * including wrapper functions like those used by `.once()`.
+   * @param {string | symbol} event - The event name.
+   * @returns {handler[]} An array of raw listener functions.
+   */
+  allListeners(event) {
+    if (typeof event !== 'string')
+      throw new TypeError('allListeners(event): event name must be a string');
+    const listeners = this.#listeners.get(event);
+    return Array.isArray(listeners) ? [...listeners].map((listener) => listener.handler) : [];
+  }
+
+  /**
+   * Returns an array of event names for which there are registered listeners.
+   *
+   * @returns {string[]} Array of registered event names.
+   */
+  eventNames() {
+    return [...this.#listeners.keys()];
+  }
+
+  /**
+   * Emits an event, triggering all registered handlers for that event.
+   *
+   * @param {string} event - The event name to emit.
+   * @param {...any} payload - Optional data to pass to each handler.
+   * @returns {boolean} True if any listeners were called, false otherwise.
+   */
+  emit(event, ...payload) {
+    if (typeof event !== 'string')
+      throw new TypeError('emit(event, data): event name must be a string');
+
+    const listeners = this.#listeners.get(event);
+    if (!Array.isArray(listeners) || listeners.length === 0) return false;
+
+    // Call all listeners with the provided data
+    listeners.forEach((listener) => listener.handler(...payload));
+    return true;
+  }
+
+  ///////////////////////////////////
+
+  /**
+   * Sets the maximum number of listeners per event before a warning is shown.
+   *
+   * @param {number} n - The maximum number of listeners.
+   */
+  setMaxListeners(n) {
+    if (!Number.isInteger(n) || n < 0)
+      throw new TypeError('setMaxListeners(n): n must be a non-negative integer');
+    this.#maxListeners = n;
+  }
+
+  /**
+   * Gets the maximum number of listeners allowed per event.
+   *
+   * @returns {number} The maximum number of listeners.
+   */
+  getMaxListeners() {
+    return this.#maxListeners;
+  }
+}
+
+/* harmony default export */ const libs_TinyEvents = (TinyEvents);
+
 ;// ./src/v1/libs/TinySmartScroller.mjs
 
 
 
+
 /**
  * Represents the dimensions of a DOM element.
  *
@@ -15744,71 +16120,267 @@ class UltraRandomMsgGen {
 class TinySmartScroller {
   static Utils = { ...collision_namespaceObject, TinyHtml: libs_TinyHtml };
 
-  /** @type {WeakMap<Element, NodeSizes>} */
-  #oldSizes = new WeakMap();
-  /** @type {WeakMap<Element, NodeSizes>} */
-  #newSizes = new WeakMap();
-
-  /** @type {WeakMap<Element, boolean>} */
-  #newVisibles = new WeakMap();
-  /** @type {WeakMap<Element, boolean>} */
-  #oldVisibles = new WeakMap();
-
-  /** @type {WeakMap<Element, boolean>} */
-  #newVisiblesByTime = new WeakMap();
-  /** @type {WeakMap<Element, boolean>} */
-  #oldVisiblesByTime = new WeakMap();
-
-  /** @type {Record<string, ScrollListenersFunc[]>} */
-  #scrollListeners = {};
-
-  /** @type {ResizeObserver|null} */
-  #resizeObserver = null;
-  /** @type {MutationObserver|null} */
-  #mutationObserver = null;
-
-  /** @type {Set<string>} */
-  #loadTags = new Set(['IMG', 'IFRAME', 'VIDEO']);
+  #events = new libs_TinyEvents();
 
-  /** @type {null|EventListenerOrEventListenerObject} */
-  #handler = null;
+  /**
+   * Enables or disables throwing an error when the maximum number of listeners is exceeded.
+   *
+   * @param {boolean} shouldThrow - If true, an error will be thrown when the max is exceeded.
+   */
+  setThrowOnMaxListeners(shouldThrow) {
+    return this.#events.setThrowOnMaxListeners(shouldThrow);
+  }
 
-  #isAtBottom = false;
-  #isAtTop = false;
-  #isAtCustomTop = false;
-  #isAtCustomBottom = false;
+  /**
+   * Checks whether an error will be thrown when the max listener limit is exceeded.
+   *
+   * @returns {boolean} True if an error will be thrown, false if only a warning is shown.
+   */
+  getThrowOnMaxListeners() {
+    return this.#events.getThrowOnMaxListeners();
+  }
 
-  #querySelector = '';
-  #useWindow = false;
-  #destroyed = false;
-  #scrollPaused = false;
-  #autoScrollBottom = false;
-  #observeMutations = false;
-  #preserveScrollOnLayoutShift = false;
-  #debounceTime = 0;
-  #elemAmount = 0;
-  #elemOldAmount = 0;
-  #lastKnownScrollBottomOffset = 0;
-  #extraScrollBoundary = 0;
+  /////////////////////////////////////////////////////////////
 
-  /** @type {Set<string>} */
-  #attributeFilter;
+  /**
+   * Adds a listener to the beginning of the listeners array for the specified event.
+   *
+   * @param {string} event - Event name.
+   * @param {ScrollListenersFunc} handler - The callback function.
+   */
+  prependListener(event, handler) {
+    return this.#events.prependListener(event, handler);
+  }
 
-  /** @type {Element} */
-  #target;
+  /**
+   * Adds a one-time listener to the beginning of the listeners array for the specified event.
+   *
+   * @param {string} event - Event name.
+   * @param {ScrollListenersFunc} handler - The callback function.
+   * @returns {ScrollListenersFunc} - The wrapped handler used internally.
+   */
+  prependListenerOnce(event, handler) {
+    return this.#events.prependListenerOnce(event, handler);
+  }
 
-  /** @type {Set<NodeSizesEvent>} */
-  #sizeFilter = new Set();
+  //////////////////////////////////////////////////////////////////////
 
   /**
-   * Creates a new instance of TinySmartScroller, attaching scroll and resize observers to manage
-   * automatic scroll behaviors, layout shift correction, and visibility tracking.
+   * Adds a event listener.
    *
-   * @param {Element|Window} target - The scroll container to monitor. Can be an element or `window`.
-   * @param {Object} [options={}] - Optional settings to configure scroll behavior.
-   * @param {number} [options.extraScrollBoundary=0] - Extra margin in pixels to extend scroll boundary detection.
-   * @param {boolean} [options.autoScrollBottom=true] - Whether to auto-scroll to bottom on layout updates.
-   * @param {boolean} [options.observeMutations=true] - Enables MutationObserver to detect DOM changes.
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {ScrollListenersFunc} handler - Callback function to be called when event fires.
+   */
+  appendListener(event, handler) {
+    return this.#events.appendListener(event, handler);
+  }
+
+  /**
+   * Registers an event listener that runs only once, then is removed.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {ScrollListenersFunc} handler - The callback function to run on event.
+   * @returns {ScrollListenersFunc} - The wrapped version of the handler.
+   */
+  appendListenerOnce(event, handler) {
+    return this.#events.appendListenerOnce(event, handler);
+  }
+
+  /**
+   * Adds a event listener.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {ScrollListenersFunc} handler - Callback function to be called when event fires.
+   */
+  on(event, handler) {
+    return this.#events.on(event, handler);
+  }
+
+  /**
+   * Registers an event listener that runs only once, then is removed.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {ScrollListenersFunc} handler - The callback function to run on event.
+   * @returns {ScrollListenersFunc} - The wrapped version of the handler.
+   */
+  once(event, handler) {
+    return this.#events.once(event, handler);
+  }
+
+  ////////////////////////////////////////////////////////////////////
+
+  /**
+   * Removes a previously registered event listener.
+   *
+   * @param {string} event - The name of the event to remove the handler from.
+   * @param {ScrollListenersFunc} handler - The specific callback function to remove.
+   */
+  off(event, handler) {
+    return this.#events.off(event, handler);
+  }
+
+  /**
+   * Removes all event listeners of a specific type from the element.
+   *
+   * @param {string} event - The event type to remove (e.g. 'onScrollBoundary').
+   */
+  offAll(event) {
+    return this.#events.offAll(event);
+  }
+
+  /**
+   * Removes all event listeners of all types from the element.
+   */
+  offAllTypes() {
+    return this.#events.offAllTypes();
+  }
+
+  ////////////////////////////////////////////////////////////
+
+  /**
+   * Returns the number of listeners for a given event.
+   *
+   * @param {string} event - The name of the event.
+   * @returns {number} Number of listeners for the event.
+   */
+  listenerCount(event) {
+    return this.#events.listenerCount(event);
+  }
+
+  /**
+   * Returns a copy of the array of listeners for the specified event.
+   *
+   * @param {string} event - The name of the event.
+   * @returns {ScrollListenersFunc[]} Array of listener functions.
+   */
+  listeners(event) {
+    return this.#events.listeners(event);
+  }
+
+  /**
+   * Returns a copy of the array of listeners for the specified event.
+   *
+   * @param {string} event - The name of the event.
+   * @returns {ScrollListenersFunc[]} Array of listener functions.
+   */
+  onceListeners(event) {
+    return this.#events.onceListeners(event);
+  }
+
+  /**
+   * Returns a copy of the internal listeners array for the specified event,
+   * including wrapper functions like those used by `.once()`.
+   * @param {string | symbol} event - The event name.
+   * @returns {ScrollListenersFunc[]} An array of raw listener functions.
+   */
+  allListeners(event) {
+    return this.#events.allListeners(event);
+  }
+
+  /**
+   * Returns an array of event names for which there are registered listeners.
+   *
+   * @returns {string[]} Array of registered event names.
+   */
+  eventNames() {
+    return this.#events.eventNames();
+  }
+
+  //////////////////////////////////////////////////////
+
+  /**
+   * Emits an event, triggering all registered handlers for that event.
+   *
+   * @param {string} event - The event name to emit.
+   * @param {...any} payload - Optional data to pass to each handler.
+   * @returns {boolean} True if any listeners were called, false otherwise.
+   */
+  emit(event, ...payload) {
+    return this.#events.emit(event, ...payload);
+  }
+
+  /**
+   * Sets the maximum number of listeners per event before a warning is shown.
+   *
+   * @param {number} n - The maximum number of listeners.
+   */
+  setMaxListeners(n) {
+    return this.#events.setMaxListeners(n);
+  }
+
+  /**
+   * Gets the maximum number of listeners allowed per event.
+   *
+   * @returns {number} The maximum number of listeners.
+   */
+  getMaxListeners() {
+    return this.#events.getMaxListeners();
+  }
+
+  ///////////////////////////////////////////////////
+
+  /** @type {WeakMap<Element, NodeSizes>} */
+  #oldSizes = new WeakMap();
+  /** @type {WeakMap<Element, NodeSizes>} */
+  #newSizes = new WeakMap();
+
+  /** @type {WeakMap<Element, boolean>} */
+  #newVisibles = new WeakMap();
+  /** @type {WeakMap<Element, boolean>} */
+  #oldVisibles = new WeakMap();
+
+  /** @type {WeakMap<Element, boolean>} */
+  #newVisiblesByTime = new WeakMap();
+  /** @type {WeakMap<Element, boolean>} */
+  #oldVisiblesByTime = new WeakMap();
+
+  /** @type {ResizeObserver|null} */
+  #resizeObserver = null;
+  /** @type {MutationObserver|null} */
+  #mutationObserver = null;
+
+  /** @type {Set<string>} */
+  #loadTags = new Set(['IMG', 'IFRAME', 'VIDEO']);
+
+  /** @type {null|EventListenerOrEventListenerObject} */
+  #handler = null;
+
+  #isAtBottom = false;
+  #isAtTop = false;
+  #isAtCustomTop = false;
+  #isAtCustomBottom = false;
+
+  #querySelector = '';
+  #useWindow = false;
+  #destroyed = false;
+  #scrollPaused = false;
+  #autoScrollBottom = false;
+  #observeMutations = false;
+  #preserveScrollOnLayoutShift = false;
+  #debounceTime = 0;
+  #elemAmount = 0;
+  #elemOldAmount = 0;
+  #lastKnownScrollBottomOffset = 0;
+  #extraScrollBoundary = 0;
+
+  /** @type {Set<string>} */
+  #attributeFilter;
+
+  /** @type {Element} */
+  #target;
+
+  /** @type {Set<NodeSizesEvent>} */
+  #sizeFilter = new Set();
+
+  /**
+   * Creates a new instance of TinySmartScroller, attaching scroll and resize observers to manage
+   * automatic scroll behaviors, layout shift correction, and visibility tracking.
+   *
+   * @param {Element|Window} target - The scroll container to monitor. Can be an element or `window`.
+   * @param {Object} [options={}] - Optional settings to configure scroll behavior.
+   * @param {number} [options.extraScrollBoundary=0] - Extra margin in pixels to extend scroll boundary detection.
+   * @param {boolean} [options.autoScrollBottom=true] - Whether to auto-scroll to bottom on layout updates.
+   * @param {boolean} [options.observeMutations=true] - Enables MutationObserver to detect DOM changes.
    * @param {boolean} [options.preserveScrollOnLayoutShift=true] - Prevents scroll jumps when layout changes.
    * @param {number} [options.debounceTime=100] - Debounce time in milliseconds for scroll events.
    * @param {string|null} [options.querySelector=null] - Optional CSS selector to filter observed child nodes.
@@ -16075,46 +16647,6 @@ class TinySmartScroller {
     this.#sizeFilter.delete(handler);
   }
 
-  /**
-   * Adds a scroll-related event listener.
-   *
-   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
-   * @param {ScrollListenersFunc} handler - Callback function to be called when event fires.
-   */
-  on(event, handler) {
-    if (this.#destroyed) return;
-    if (typeof event !== 'string')
-      throw new TypeError('on(event, handler): event name must be a string');
-    if (typeof handler !== 'function')
-      throw new TypeError('on(event, handler): handler must be a function');
-
-    if (!this.#scrollListeners[event]) this.#scrollListeners[event] = [];
-    this.#scrollListeners[event].push(handler);
-  }
-
-  /**
-   * Removes a previously registered scroll-related event listener.
-   *
-   * @param {string} event - The name of the event to remove the handler from.
-   * @param {ScrollListenersFunc} handler - The specific callback function to remove.
-   */
-  off(event, handler) {
-    if (this.#destroyed) return;
-    if (typeof event !== 'string')
-      throw new TypeError('off(event, handler): event name must be a string');
-    if (typeof handler !== 'function')
-      throw new TypeError('off(event, handler): handler must be a function');
-
-    const listeners = this.#scrollListeners[event];
-    if (!Array.isArray(listeners)) return;
-
-    const index = listeners.indexOf(handler);
-    if (index !== -1) listeners.splice(index, 1);
-
-    // Optionally clean up empty arrays (optional)
-    if (listeners.length === 0) delete this.#scrollListeners[event];
-  }
-
   /**
    * Checks which elements inside the target are currently visible and updates internal maps.
    *
@@ -16139,12 +16671,10 @@ class TinySmartScroller {
    *
    * @param {string} event - Event name.
    * @param {*} [payload] - Optional event data payload.
+   * @deprecated - Use emit() instead.
    */
   _emit(event, payload) {
-    if (this.#destroyed) return;
-    if (typeof event !== 'string')
-      throw new TypeError('_emit(event, payload): event name must be a string');
-    (this.#scrollListeners[event] || []).forEach((fn) => fn(payload));
+    this.emit(event, payload);
   }
 
   /**
@@ -16190,13 +16720,13 @@ class TinySmartScroller {
     this.#lastKnownScrollBottomOffset = scrollHeight - scrollTop - clientHeight;
 
     // Send results
-    this._emit('onScrollBoundary', { status: atResult, ...scrollResult, scrollCache });
-    this._emit('onExtraScrollBoundary', { status: atCustomResult, ...scrollResult, scrollCache });
+    this.emit('onScrollBoundary', { status: atResult, ...scrollResult, scrollCache });
+    this.emit('onExtraScrollBoundary', { status: atCustomResult, ...scrollResult, scrollCache });
 
     if (!this.#scrollPaused) {
-      this._emit('onAutoScroll', { ...scrollResult, scrollCache });
+      this.emit('onAutoScroll', { ...scrollResult, scrollCache });
     } else {
-      this._emit('onScrollPause', { ...scrollResult, scrollCache });
+      this.emit('onScrollPause', { ...scrollResult, scrollCache });
     }
   }
 
@@ -16662,7 +17192,7 @@ class TinySmartScroller {
     this.#oldVisiblesByTime = new WeakMap();
 
     // Cleans listeners and filters
-    this.#scrollListeners = {};
+    this.#events.offAllTypes();
     this.#sizeFilter.clear();
     this.#loadTags.clear();
   }
@@ -17031,522 +17561,2141 @@ class TinyTextRangeEditor {
   }
 
   /**
-   * Wraps the current selection with a tag, optionally including attributes.
+   * Wraps the current selection with a tag, optionally including attributes.
+   *
+   * @param {string} tagName - The tag name (e.g., `b`, `color`, etc.).
+   * @param {Record<string,string> | string[]} [attributes={}] - Optional attributes for the opening tag.
+   *   - If an object: key-value pairs (e.g., `{ color: "red" }` → `color="red"`).
+   *   - If an array: boolean attributes (e.g., `["disabled", "readonly"]`).
+   *
+   * @returns {TinyTextRangeEditor}
+   */
+  wrapWithTag(tagName, attributes = {}) {
+    if (typeof tagName !== 'string') throw new TypeError('tagName must be a string.');
+    const attrStr = this._insertAttr(attributes);
+    const openTag = attrStr
+      ? `${this.#openTag}${tagName} ${attrStr}${this.#closeTag}`
+      : `${this.#openTag}${tagName}${this.#closeTag}`;
+    const closeTag = `${this.#openTag}/${tagName}${this.#closeTag}`;
+    this.surroundSelection(openTag, closeTag);
+    return this;
+  }
+
+  /**
+   * Inserts a tag with optional inner content.
+   * @param {string} tagName - The tag to insert.
+   * @param {string} [content=''] - Optional content between tags.
+   * @param {Record<string,string> | string[]} [attributes={}] - Optional attributes or list of empty attributes.
+   * @returns {TinyTextRangeEditor}
+   */
+  insertTag(tagName, content = '', attributes = {}) {
+    if (typeof tagName !== 'string') throw new TypeError('tagName must be a string.');
+    if (typeof content !== 'string') throw new TypeError('content must be a string.');
+
+    const attrStr = this._insertAttr(attributes);
+    const open = attrStr
+      ? `${this.#openTag}${tagName} ${attrStr}${this.#closeTag}`
+      : `${this.#openTag}${tagName}${this.#closeTag}`;
+    const close = `${this.#openTag}/${tagName}${this.#closeTag}`;
+
+    this.insertText(`${open}${content}${close}`);
+    return this;
+  }
+
+  /**
+   * Inserts a self-closing tag.
+   * @param {string} tagName - The tag name.
+   * @param {Record<string,string> | string[]} [attributes={}] - Optional attributes or list of empty attributes.
+   * @returns {TinyTextRangeEditor}
+   */
+  insertSelfClosingTag(tagName, attributes = {}) {
+    if (typeof tagName !== 'string') throw new TypeError('tagName must be a string.');
+
+    const attrStr = this._insertAttr(attributes);
+    const tag = attrStr
+      ? `${this.#openTag}${tagName} ${attrStr}${this.#closeTag}`
+      : `${this.#openTag}${tagName}${this.#closeTag}`;
+
+    this.insertText(tag);
+    return this;
+  }
+
+  /**
+   * Toggles a tag around the current selection.
+   * Supports tags with attributes. If already wrapped, it unwraps.
+   * @param {string} tagName - The tag to toggle.
+   * @param {Record<string,string> | string[]} [attributes={}] - Optional attributes to apply when wrapping.
+   * @returns {TinyTextRangeEditor}
+   */
+  toggleTag(tagName, attributes = {}) {
+    if (typeof tagName !== 'string') throw new TypeError('tagName must be a string.');
+    const selected = this.getSelectedText();
+
+    // Regex: opening tag with optional attributes, and closing tag
+    const openRegex = new RegExp(`^\\[${tagName}(\\s+[^\\]]*)?\\]`);
+    const closeRegex = new RegExp(`\\[/${tagName}\\]$`);
+
+    const hasOpen = openRegex.test(selected);
+    const hasClose = closeRegex.test(selected);
+
+    if (hasOpen && hasClose) {
+      const unwrapped = selected
+        .replace(openRegex, '') // remove opening tag
+        .replace(closeRegex, ''); // remove closing tag
+      this.insertText(unwrapped);
+    } else {
+      const attrStr = this._insertAttr(attributes);
+      const open = attrStr
+        ? `${this.#openTag}${tagName} ${attrStr}${this.#closeTag}`
+        : `${this.#openTag}${tagName}${this.#closeTag}`;
+      const close = `${this.#openTag}/${tagName}${this.#closeTag}`;
+      this.insertText(`${open}${selected}${close}`);
+    }
+
+    return this;
+  }
+}
+
+/* harmony default export */ const libs_TinyTextRangeEditor = (TinyTextRangeEditor);
+
+;// ./src/v1/libs/TinyClipboard.mjs
+/**
+ * Utility class to handle clipboard operations for text and blob data.
+ * Supports modern Clipboard API, custom platform, and legacy execCommand fallback.
+ */
+class TinyClipboard {
+  /**
+   * Indicates whether the legacy `document.execCommand()` API is available.
+   * Used as a fallback for clipboard operations when modern APIs are not supported.
+   *
+   * @type {boolean}
+   */
+  #existExecCommand = false;
+
+  /**
+   * Indicates whether the modern Clipboard API (`navigator.clipboard`) is available.
+   *
+   * @type {boolean}
+   */
+  #existNavigator = false;
+
+  /**
+   * Function used to copy plain text to the clipboard.
+   * Can be overridden using `setCopyText()`.
+   *
+   * @type {((text: string) => Promise<void>) | null}
+   */
+  #copyText = null;
+
+  /**
+   * Function used to copy a Blob (binary data) to the clipboard.
+   * Can be overridden using `setCopyBlob()`.
+   *
+   * @type {((blob: Blob) => Promise<void>) | null}
+   */
+  #copyBlob = null;
+
+  /**
+   * Constructs a new TinyClipboard instance.
+   * Automatically detects and configures available clipboard APIs.
+   */
+  constructor() {
+    // Whether the Clipboard API is available.
+    if (typeof navigator.clipboard !== 'undefined' && navigator.clipboard !== null) {
+      this.#existNavigator = true;
+      this.#copyText = (text) => navigator.clipboard.writeText(text);
+      this.#copyBlob = (blob) =>
+        navigator.clipboard.write([
+          new ClipboardItem({
+            [blob.type]: blob,
+          }),
+        ]);
+    }
+
+    /**
+     * @type {boolean}
+     * Whether the legacy execCommand API is available.
+     */
+    this.#existExecCommand =
+      typeof document.execCommand !== 'undefined' && document.execCommand !== null;
+  }
+
+  /**
+   * Override the default text copy behavior.
+   * This allows you to provide your own clipboard implementation or
+   * integrate with external systems like Capacitor or Electron.
+   *
+   * @param {(text: string) => Promise<void>} callback - The function to use for copying text.
+   * @throws {TypeError} If the callback is not a function.
+   */
+  setCopyText(callback) {
+    if (typeof callback !== 'function')
+      throw new TypeError('setCopyText expected a function that returns Promise<void>.');
+    this.#copyText = callback;
+  }
+
+  /**
+   * Override the default blob copy behavior.
+   * This allows you to provide a custom clipboard handling method for blob data.
+   *
+   * @param {(blob: Blob) => Promise<void>} callback - The function to use for copying blob data.
+   * @throws {TypeError} If the callback is not a function.
+   */
+  setCopyBlob(callback) {
+    if (typeof callback !== 'function')
+      throw new TypeError('setCopyBlob expected a function that returns Promise<void>.');
+    this.#copyBlob = callback;
+  }
+
+  /**
+   * Copy a plain text string to the clipboard.
+   * Uses modern or legacy fallback.
+   *
+   * @param {string} text - The text string to be copied.
+   * @returns {Promise<void>} A promise resolving when the text is copied or boolean for legacy.
+   */
+  copyText(text) {
+    if (typeof text !== 'string') throw new TypeError('copyText expected a string.');
+    // Clipboard API
+    if (this.#copyText) return this.#copyText(text);
+    // Classic API
+    else if (this.#existExecCommand) {
+      const host = document.body;
+      const copyInput = document.createElement('input');
+      copyInput.style.position = 'fixed';
+      copyInput.style.opacity = '0';
+      copyInput.value = text;
+      host.append(copyInput);
+
+      copyInput.select();
+      copyInput.setSelectionRange(0, 99999);
+      document.execCommand('Copy');
+      copyInput.remove();
+      return new Promise((resolve) => resolve(undefined));
+    }
+    throw new Error('Clipboard API not found!');
+  }
+
+  /**
+   * Copy a Blob (binary data) to the clipboard.
+   *
+   * @param {Blob} blob - The blob object to copy.
+   * @returns {Promise<void>} A promise that resolves when the blob is copied or null on fallback.
+   */
+  copyBlob(blob) {
+    if (!(blob instanceof Blob)) throw new TypeError('copyBlob expected a Blob instance.');
+    return new Promise((resolve, reject) => {
+      if (this.#copyBlob) {
+        return this.#copyBlob(blob).then(resolve).catch(reject);
+      }
+      throw new Error('Clipboard API not found!');
+    });
+  }
+
+  /**
+   * Internal: Handle getting blob data from a clipboard item.
+   *
+   * @private
+   * @param {string} type - The MIME type to fetch.
+   * @param {ClipboardItem} clipboardItem - Clipboard item instance.
+   * @returns {Promise<Blob>} A promise that resolves with the Blob.
+   */
+  _handleBlob(type, clipboardItem) {
+    return clipboardItem.getType(type);
+  }
+
+  /**
+   * Internal: Handle getting plain text from a clipboard item.
+   *
+   * @private
+   * @param {string} type - The MIME type (should be 'text/plain').
+   * @param {ClipboardItem} clipboardItem - Clipboard item instance.
+   * @returns {Promise<string>} A promise that resolves with the text content.
+   */
+  _handleText(type, clipboardItem) {
+    return this._handleBlob(type, clipboardItem).then((blob) => blob.text());
+  }
+
+  /**
+   * Read clipboard data based on filters like type, mime, index.
+   *
+   * @param {number|null} [index=0] - Item index or null for all.
+   * @param {'text'|'custom'|null} [type=null] - Data type to filter.
+   * @param {string|null} [mimeFormat=null] - MIME type or prefix.
+   * @param {boolean} [fixValue=false] - If true, exact match on MIME type.
+   * @returns {Promise<Blob|string|Array<Blob|string>|null>} A promise resolving with matching data.
+   */
+  _readData(index = 0, type = null, mimeFormat = null, fixValue = false) {
+    return new Promise((resolve, reject) => {
+      this._read(index)
+        .then((items) => {
+          if (!items) return resolve(null);
+          /** @type {Array<Blob|string>} */
+          const finalResult = [];
+
+          // Complete task
+          let continueLoop = true;
+
+          /**
+           * @param {string} mimeType
+           * @param {ClipboardItem} item
+           */
+          const completeTask = async (mimeType, item) => {
+            if (!continueLoop) return;
+            // Custom
+            if (
+              (type === null || type === 'custom') &&
+              typeof mimeFormat === 'string' &&
+              ((!fixValue && mimeType.startsWith(mimeFormat)) ||
+                (fixValue && mimeType === mimeFormat))
+            ) {
+              continueLoop = false;
+              const result = await this._handleBlob(mimeType, item);
+              if (result) finalResult.push(result);
+            }
+
+            // Text
+            else if ((type === null || type === 'text') && mimeType === 'text/plain') {
+              continueLoop = false;
+              const result = await this._handleText(mimeType, item);
+              if (result) finalResult.push(result);
+            }
+
+            // Blob
+            else if (type === null) {
+              continueLoop = false;
+              const result = await this._handleBlob(mimeType, item);
+              if (result) finalResult.push(result);
+            }
+          };
+
+          /** @type {Promise<void>[]} */
+          const promises = [];
+
+          /**
+           * Read Item
+           * @param {ClipboardItem | ClipboardItems} item
+           */
+          const readItem = (item) => {
+            if (!(item instanceof ClipboardItem))
+              throw new Error('Expected ClipboardItem when reading data.');
+            for (const tIndex in item.types) promises.push(completeTask(item.types[tIndex], item));
+          };
+
+          // Specific Item
+          if (
+            typeof index === 'number' &&
+            !Number.isNaN(index) &&
+            Number.isFinite(index) &&
+            index > -1
+          ) {
+            readItem(items);
+            Promise.all(promises)
+              .then(() => {
+                if (finalResult[0]) resolve(finalResult[0]);
+                else resolve(null);
+              })
+              .catch(reject);
+          }
+
+          // All
+          else if (Array.isArray(items)) {
+            for (const tIndex in items) readItem(items[tIndex]);
+            Promise.all(promises)
+              .then(() => resolve(finalResult))
+              .catch(reject);
+          }
+        })
+        // Fail
+        .catch(reject);
+    });
+  }
+
+  /**
+   * Read plain text from the clipboard (single item by index).
+   *
+   * @param {number} [index=0] - The index of the clipboard item to read.
+   * @returns {Promise<string|null>} A promise that resolves to the clipboard text or null.
+   */
+  async readText(index = 0) {
+    const value = await this._readData(index, 'text');
+    if (typeof value !== 'string') throw new Error('Failed to read text: expected string result.');
+    return value;
+  }
+
+  /**
+   * Read custom clipboard data based on MIME type from a specific index.
+   *
+   * @param {string|null} [mimeFormat=null] - MIME prefix to match (e.g., "image/").
+   * @param {boolean} [fixValue=false] - If true, matches exact MIME instead of prefix.
+   * @param {number} [index=0] - Clipboard item index.
+   * @returns {Promise<Blob|null>} A promise resolving with a blob or null.
+   */
+  async readCustom(mimeFormat = null, fixValue = false, index = 0) {
+    const value = await this._readData(index, 'custom', mimeFormat, fixValue);
+    if (!(value instanceof Blob)) throw new Error('Failed to read custom data: expected Blob.');
+    return value;
+  }
+
+  /**
+   * Read all available plain text entries from the clipboard.
+   *
+   * @returns {Promise<string[]>} A promise resolving to an array of strings or null.
+   */
+  async readAllTexts() {
+    const values = await this._readData(null, 'text');
+    if (!Array.isArray(values))
+      throw new Error('Expected array of strings when reading all texts.');
+    if (!values.every((value) => typeof value === 'string'))
+      throw new Error('Some values returned were not strings.');
+    return values;
+  }
+
+  /**
+   * Read all clipboard data matching a specific custom MIME type.
+   *
+   * @param {string|null} [mimeFormat=null] - MIME prefix or exact type.
+   * @param {boolean} [fixValue=false] - Match prefix or exact MIME.
+   * @returns {Promise<Blob[]>} A promise resolving with array of Blobs or null.
+   */
+  async readAllCustom(mimeFormat = null, fixValue = false) {
+    const values = await this._readData(null, 'custom', mimeFormat, fixValue);
+    if (!Array.isArray(values))
+      throw new Error('Expected array of blobs when reading all custom items.');
+    if (!values.every((value) => value instanceof Blob))
+      throw new Error('Some values returned were not Blob instances.');
+    return values;
+  }
+
+  /**
+   * Read all clipboard data as Blob or text depending on type.
+   *
+   * @param {'text'|'custom'|null} [type=null] - The type of data to retrieve.
+   * @param {string|null} [mimeFormat=null] - The MIME type or prefix to match.
+   * @returns {Promise<Array<Blob|string>>} A promise resolving with matching data array.
+   */
+  async readAllData(type = null, mimeFormat = null) {
+    const value = await this._readData(null, type, mimeFormat);
+    if (!Array.isArray(value)) throw new Error('Expected array result when reading all data.');
+    return value;
+  }
+
+  /**
+   * Read clipboard data at a specific index or all if null.
+   *
+   * @param {number|null} index - Index of the item to retrieve or null to get all.
+   * @returns {Promise<ClipboardItem|ClipboardItems|null>} A promise resolving with a clipboard item or array of items.
+   */
+  _read(index) {
+    return new Promise((resolve, reject) => {
+      if (!this.#existNavigator) reject(new Error('Clipboard API not found!'));
+      navigator.clipboard
+        .read()
+        .then((items) => {
+          // Index is number
+          if (typeof index === 'number') {
+            if (Number.isNaN(index) || !Number.isFinite(index) || index < 0)
+              throw new Error(`Invalid index value: ${index}`);
+            if (items[index]) resolve(items[index]);
+            // Not found
+            else resolve(null);
+          }
+          // Get All
+          resolve(items);
+        })
+        .catch(reject);
+    });
+  }
+
+  /**
+   * Read clipboard data at a specific index.
+   *
+   * @param {number} index - Index of the item to retrieve
+   * @returns {Promise<ClipboardItem|null>} A promise resolving with a clipboard item.
+   */
+  async readIndex(index) {
+    const value = await this._read(index);
+    if (value !== null && !(value instanceof ClipboardItem))
+      throw new Error(`Value at index ${index} is not a ClipboardItem.`);
+    return value;
+  }
+
+  /**
+   * Read all clipboard content without any filters.
+   *
+   * @returns {Promise<ClipboardItems>} A promise resolving with all clipboard items.
+   */
+  async readAll() {
+    const value = await this._read(null);
+    if (!Array.isArray(value)) throw new Error('Expected array result from clipboard read.');
+    for (const item of value) {
+      if (!(item instanceof ClipboardItem))
+        throw new Error('Invalid item type found in clipboard result.');
+    }
+    return value;
+  }
+
+  /**
+   * Returns whether the legacy `document.execCommand()` API is available.
+   * This can be used to determine if a fallback clipboard method is usable.
+   *
+   * @returns {boolean} True if `document.execCommand` is available.
+   */
+  isExecCommandAvailable() {
+    return this.#existExecCommand;
+  }
+
+  /**
+   * Returns whether the modern Clipboard API (`navigator.clipboard`) is available.
+   * Useful to know if full clipboard features can be accessed.
+   *
+   * @returns {boolean} True if `navigator.clipboard` is available.
+   */
+  isNavigatorClipboardAvailable() {
+    return this.#existNavigator;
+  }
+
+  /**
+   * Returns the function used to copy plain text to the clipboard.
+   * This function may be built-in or set manually via `setCopyText`.
+   *
+   * @returns {((text: string) => Promise<void>) | null} The current text copy function or null if unavailable.
+   */
+  getCopyTextFunc() {
+    return this.#copyText;
+  }
+
+  /**
+   * Returns the function used to copy Blob (binary data) to the clipboard.
+   * This function may be built-in or set manually via `setCopyBlob`.
+   *
+   * @returns {((blob: Blob) => Promise<void>) | null} The current blob copy function or null if unavailable.
+   */
+  getCopyBlobFunc() {
+    return this.#copyBlob;
+  }
+}
+
+/* harmony default export */ const libs_TinyClipboard = (TinyClipboard);
+
+;// ./src/v1/libs/TinyColorConverter.mjs
+/**
+ * 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.
+ *
+ * @typedef {number[]} RgbColor
+ * @property {number} 0 - Red component (0–255)
+ * @property {number} 1 - Green component (0–255)
+ * @property {number} 2 - Blue component (0–255)
+ */
+
+/**
+ * Represents a color in HSLA format.
+ * The fourth value represents the alpha (transparency) channel.
+ *
+ * @typedef {number[]} HslaColor
+ * @property {number} 0 - Hue (0–360)
+ * @property {number} 1 - Saturation (0–100)
+ * @property {number} 2 - Lightness (0–100)
+ * @property {number} 3 - Alpha component (0–255)
+ */
+
+/**
+ * Represents a color in HSL format.
+ *
+ * @typedef {number[]} HslColor
+ * @property {number} 0 - Hue (0–360)
+ * @property {number} 1 - Saturation (0–100)
+ * @property {number} 2 - Lightness (0–100)
+ */
+
+/**
+ * Represents a hex color.
+ *
+ * @typedef {string} HexColor
+ */
+
+/**
+ * A union type representing various accepted color formats.
+ * Can be a hex color string, a numeric value, or an array-based RGB/RGBA representation.
+ *
+ * @typedef {HexColor | number | RgbColor | RgbaColor} ColorTypes
+ */
+
+/**
+ * @typedef {Object} RgbaResult
+ * @property {number} r - Red component (0–255)
+ * @property {number} g - Green component (0–255)
+ * @property {number} b - Blue component (0–255)
+ * @property {number} a - Alpha component (0–255)
+ */
+
+/**
+ * @typedef {Object} RgbResult
+ * @property {number} r - Red component (0–255)
+ * @property {number} g - Green component (0–255)
+ * @property {number} b - Blue component (0–255)
+ */
+
+/**
+ * @typedef {Object} HexResult
+ * @property {string} hex - Hex color
+ */
+
+/**
+ * @typedef {Object} HslResult
+ * @property {number} h - Hue (0–360)
+ * @property {number} s - Saturation (0–100)
+ * @property {number} l - Lightness (0–100)
+ */
+
+/**
+ * A class that allows converting colors between all common formats.
+ */
+class TinyColorConverter {
+  /**
+   * Generates a smooth gradient of colors based on sine wave patterns.
+   *
+   * @see {@link https://www.npmjs.com/package/rainbow-colors-array} Code Reference
+   * @param {number} [len=24] - The number of colors to generate.
+   * @param {'rgb'|'hex'|'hsl'} [type='rgb'] - The format of the colors returned: `'rgb'`, `'hex'`, or `'hsl'`.
+   * @param {boolean} [pastel=false] - If true, generates pastel tones by adjusting the intensity and offset.
+   * @returns {Array<RgbResult|HexResult|HslResult>} An array of color values in the selected format:
+   */
+  static _rca(len, type, pastel) {
+    let eq1 = 127;
+    let eq2 = 128;
+    if (len === undefined) {
+      len = 24;
+    }
+    if (type === undefined) {
+      type = 'rgb';
+    }
+    if (pastel === true) {
+      eq1 = 55;
+      eq2 = 200;
+    }
+    const frequency = (Math.PI * 2) / len;
+
+    const cvparr = [];
+    for (let i = 0; i < len; ++i) {
+      const red = Math.sin(frequency * i + 2) * eq1 + eq2;
+      const green = Math.sin(frequency * i + 0) * eq1 + eq2;
+      const blue = Math.sin(frequency * i + 4) * eq1 + eq2;
+
+      switch (type) {
+        case 'hex':
+          cvparr.push({ hex: this.rgbToHex(Math.round(red), Math.round(green), Math.round(blue)) });
+          break;
+        case 'rgb':
+          cvparr.push({ r: red, g: green, b: blue });
+          break;
+        case 'hsl':
+          const [h, s, l] = this.rgbaToHsl(Math.round(red), Math.round(green), Math.round(blue));
+          cvparr.push({ h, s, l });
+          break;
+      }
+    }
+
+    return cvparr;
+  }
+
+  /**
+   * Generates a smooth gradient of colors based on sine wave patterns.
+   *
+   * @param {number} [len=24] - The number of colors to generate.
+   * @param {boolean} [pastel=false] - If true, generates pastel tones by adjusting the intensity and offset.
+   * @returns {RgbResult[]} An array of rgb color values.
+   */
+  static rcaRgb(len, pastel) {
+    return /** @type {RgbResult[]} */ (TinyColorConverter._rca(len, 'rgb', pastel));
+  }
+
+  /**
+   * Generates a smooth gradient of colors based on sine wave patterns.
+   *
+   * @param {number} [len=24] - The number of colors to generate.
+   * @param {boolean} [pastel=false] - If true, generates pastel tones by adjusting the intensity and offset.
+   * @returns {HslResult[]} An array of hsl color values.
+   */
+  static rcaHsl(len, pastel) {
+    return /** @type {HslResult[]} */ (TinyColorConverter._rca(len, 'hsl', pastel));
+  }
+
+  /**
+   * Generates a smooth gradient of colors based on sine wave patterns.
+   *
+   * @param {number} [len=24] - The number of colors to generate.
+   * @param {boolean} [pastel=false] - If true, generates pastel tones by adjusting the intensity and offset.
+   * @returns {HexResult[]} An array of hex color values.
+   */
+  static rcaHex(len, pastel) {
+    return /** @type {HexResult[]} */ (TinyColorConverter._rca(len, 'hex', pastel));
+  }
+
+  /**
+   * Generates a random color in hexadecimal format.
+   *
+   * @returns {HexColor} A hex color string (e.g. `#a3e5f2`).
+   */
+  static randomColor() {
+    const hex = Math.floor(Math.random() * 0x1000000).toString(16);
+    return `#${hex.padStart(6, '0')}`;
+  }
+
+  /**
+   * Parses input into RGBA array.
+   * @param {ColorTypes} input
+   * @param {boolean} isHsl
+   * @returns {RgbaColor}
+   */
+  static parseInput(input, isHsl) {
+    if (typeof input === 'string') {
+      input = input.trim().toLowerCase();
+      if (input.startsWith('#')) return this.hexToRgba(input);
+      if (input.startsWith('rgb')) return this.rgbStringToRgbaArray(input);
+      if (input.startsWith('hsl')) return this.hslStringToRgbaArray(input);
+    }
+    if (typeof input === 'number') return this.intToRgba(input);
+    if (
+      Array.isArray(input) &&
+      (input.length === 3 || input.length === 4) &&
+      input.every((item) => typeof item === 'number')
+    ) {
+      if (isHsl) {
+        const [h, s, l, a2] = input;
+        if (h <= 360 && s <= 100 && l <= 100) return this.hslToRgba(h, s, l, a2);
+      }
+      return [...input, 1].slice(0, 4);
+    }
+
+    throw new Error('Unsupported color format.');
+  }
+
+  // HSL Color
+
+  /**
+   * Converts hsl to integer.
+   * @param {number} h - Hue (0–360)
+   * @param {number} s - Saturation (0–100)
+   * @param {number} l - Lightness (0–100)
+   * @returns {number}
+   */
+  static hslToInt(h, s, l) {
+    const [r, g, b] = TinyColorConverter.hslToRgba(h, s, l);
+    return TinyColorConverter.rgbToInt(r, g, b);
+  }
+
+  /**
+   * Converts hsl to hex.
+   * @param {number} h - Hue (0–360)
+   * @param {number} s - Saturation (0–100)
+   * @param {number} l - Lightness (0–100)
+   * @returns {HexColor}
+   */
+  static hslToHex(h, s, l) {
+    const [r, g, b] = TinyColorConverter.hslToRgba(h, s, l);
+    return TinyColorConverter.rgbToHex(r, g, b);
+  }
+
+  /**
+   * Converts hsl(a) string to RGBA array.
+   * @param {string} hsl
+   * @returns {RgbaColor}
+   */
+  static hslStringToRgbaArray(hsl) {
+    const match = hsl.match(/[\d.]+/g)?.map(Number);
+    if (!match || match.length < 3) return [0, 0, 0, 1];
+    const [h, s, l, a = 1] = match;
+    return this.hslToRgba(h, s, l, a);
+  }
+
+  /**
+   * Converts HSL or HSLA to RGBA.
+   * @param {number} h - Hue (0–360)
+   * @param {number} s - Saturation (0–100)
+   * @param {number} l - Lightness (0–100)
+   * @param {number} [a=1] - Alpha (0–1)
+   * @returns {RgbaColor}
+   */
+  static hslToRgba(h, s, l, a = 1) {
+    s /= 100;
+    l /= 100;
+    /** @type {(n: number) => number} */
+    const k = (n) => (n + h / 30) % 12;
+    const a_ = s * Math.min(l, 1 - l);
+    /** @type {(n: number) => number} */
+    const f = (n) => l - a_ * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+    return [Math.round(f(0) * 255), Math.round(f(8) * 255), Math.round(f(4) * 255), a];
+  }
+
+  /**
+   * Converts HSL or HSLA to RGB.
+   * @param {number} h - Hue (0–360)
+   * @param {number} s - Saturation (0–100)
+   * @param {number} l - Lightness (0–100)
+   * @param {number} [a=1] - Alpha (0–1)
+   * @returns {RgbColor}
+   */
+  static hslToRgb(h, s, l, a = 1) {
+    return TinyColorConverter.hslToRgba(h, s, l, a).slice(0, 3);
+  }
+
+  // Hex Color
+
+  /**
+   * Converts hex to integer.
+   * @param {HexColor} hex
+   * @returns {number}
+   */
+  static hexToInt(hex) {
+    return parseInt(hex.replace(/^#/, ''), 16);
+  }
+
+  /**
+   * Converts hex string to HSL array.
+   * @param {HexColor} hex
+   * @returns {HslColor}
+   */
+  static hexToHsl(hex) {
+    const [r, g, b, a] = TinyColorConverter.hexToRgba(hex);
+    return TinyColorConverter.rgbaToHsl(r, g, b, a);
+  }
+
+  /**
+   * Converts hex string to HSL array.
+   * @param {HexColor} hex
+   * @returns {HslaColor}
+   */
+  static hexToHsla(hex) {
+    const [r, g, b, a] = TinyColorConverter.hexToRgba(hex);
+    return TinyColorConverter.rgbaToHsla(r, g, b, a);
+  }
+
+  /**
+   * Converts hex string to RGBA array.
+   * @param {HexColor} hex
+   * @returns {RgbaColor}
+   */
+  static hexToRgba(hex) {
+    hex = hex.replace(/^#/, '');
+    if (hex.length === 3)
+      hex = hex
+        .split('')
+        .map((c) => c + c)
+        .join('');
+    const intVal = parseInt(hex, 16);
+    const r = (intVal >> 16) & 255;
+    const g = (intVal >> 8) & 255;
+    const b = intVal & 255;
+    return [r, g, b, 1];
+  }
+
+  /**
+   * Converts HEX to RGB.
+   * @param {HexColor} hex
+   * @returns {RgbColor}
+   */
+  static hexToRgb(hex) {
+    return this.hexToRgba(hex).slice(0, 3);
+  }
+
+  // RGBA Color
+
+  /**
+   * Converts RGB to HEX.
+   * @param {number} r
+   * @param {number} g
+   * @param {number} b
+   * @returns {HexColor}
+   */
+  static rgbToHex(r, g, b) {
+    return '#' + [r, g, b].map((v) => v.toString(16).padStart(2, '0')).join('');
+  }
+
+  /**
+   * Converts RGB to integer.
+   * @param {number} r
+   * @param {number} g
+   * @param {number} b
+   * @returns {number}
+   */
+  static rgbToInt(r, g, b) {
+    return (r << 16) | (g << 8) | b;
+  }
+
+  /**
+   * Converts RGBA to HSLA.
+   * @param {number} r
+   * @param {number} g
+   * @param {number} b
+   * @param {number} [a=1]
+   * @returns {HslaColor}
+   */
+  static rgbaToHsla(r, g, b, a = 1) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    let h = 0,
+      s = 0,
+      l = (max + min) / 2;
+    const d = max - min;
+
+    if (d !== 0) {
+      s = d / (1 - Math.abs(2 * l - 1));
+      switch (max) {
+        case r:
+          h = (g - b) / d + (g < b ? 6 : 0);
+          break;
+        case g:
+          h = (b - r) / d + 2;
+          break;
+        case b:
+          h = (r - g) / d + 4;
+          break;
+      }
+      h *= 60;
+    }
+
+    return [Math.round(h), Math.round(s * 100), Math.round(l * 100), a];
+  }
+
+  /**
+   * Converts RGBA to HSL.
+   * @param {number} r
+   * @param {number} g
+   * @param {number} b
+   * @param {number} [a=1]
+   * @returns {HslColor}
+   */
+  static rgbaToHsl(r, g, b, a) {
+    return this.rgbaToHsla(r, g, b, a).slice(0, 3);
+  }
+
+  /**
+   * Converts rgb(a) string to RGBA array.
+   * @param {string} rgb
+   * @returns {RgbaColor}
+   */
+  static rgbStringToRgbaArray(rgb) {
+    const match = rgb.match(/[\d.]+/g)?.map(Number);
+    if (!match) return [];
+    return [...match, 1].slice(0, 4);
+  }
+
+  // Integer Color
+
+  /**
+   * Converts integer color to HSL.
+   * @param {number} int
+   * @returns {HslColor}
+   */
+  static intToHsl(int) {
+    const [r, g, b, a] = TinyColorConverter.intToRgba(int);
+    return TinyColorConverter.rgbaToHsl(r, g, b, a);
+  }
+
+  /**
+   * Converts integer color to HSL.
+   * @param {number} int
+   * @returns {HslaColor}
+   */
+  static intToHsla(int) {
+    const [r, g, b, a] = TinyColorConverter.intToRgba(int);
+    return TinyColorConverter.rgbaToHsla(r, g, b, a);
+  }
+
+  /**
+   * Converts integer color to hex.
+   * @param {number} int
+   * @returns {HexColor}
+   */
+  static intToHex(int) {
+    return '#' + int.toString(16).padStart(6, '0');
+  }
+
+  /**
+   * Converts an integer (0xRRGGBB) to RGBA.
+   * @param {number} value
+   * @returns {RgbaColor}
+   */
+  static intToRgba(value) {
+    const r = (value >> 16) & 255;
+    const g = (value >> 8) & 255;
+    const b = value & 255;
+    return [r, g, b, 1];
+  }
+
+  // Class Script
+
+  /** @type {ColorTypes} */
+  #original = '#000000';
+  /** @type {RgbaColor} */
+  #rgba = [0, 0, 0, 0];
+
+  #checkIsHsl;
+
+  /**
+   * @param {ColorTypes|null} [input=null] - Any valid color (hex, rgb string, rgba string, hsl(a), css name, array or int).
+   * @param {boolean} [checkIsHsl=false]
+   */
+  constructor(input = null, checkIsHsl = false) {
+    this.#checkIsHsl = checkIsHsl;
+    if (typeof input !== 'undefined' && input !== null) this.setColor(input);
+  }
+
+  /**
+   * @param {ColorTypes} input - Any valid color (hex, rgb string, rgba string, hsl(a), css name, array or int).
+   */
+  setColor(input) {
+    this.#original = input;
+    const isHsl =
+      this.#checkIsHsl &&
+      Array.isArray(input) &&
+      input[0] <= 360 &&
+      input[1] <= 100 &&
+      input[2] <= 100;
+    this.#rgba = TinyColorConverter.parseInput(input, isHsl);
+  }
+
+  /**
+   * Returns HSLA array.
+   * @returns {HslaColor}
+   */
+  toHslaArray() {
+    const [r, g, b, a] = this.#rgba;
+    return TinyColorConverter.rgbaToHsla(r, g, b, a);
+  }
+
+  /**
+   * Returns RGB string.
+   * @returns {string}
+   */
+  toHslString() {
+    const [r, g, b] = this.#rgba;
+    const [h, s, l] = TinyColorConverter.rgbaToHsl(r, g, b);
+    return `hsl(${h}, ${s}%, ${l}%)`;
+  }
+
+  /**
+   * Returns RGBA string.
+   * @returns {string}
+   */
+  toHslaString() {
+    const [r, g, b, a] = this.#rgba;
+    const [h, s, l, a2] = TinyColorConverter.rgbaToHsla(r, g, b, a);
+    return `hsla(${h}, ${s}%, ${l}%, ${a2 ?? 1})`;
+  }
+
+  /**
+   * Returns RGBA array.
+   * @returns {RgbaColor}
+   */
+  toRgbaArray() {
+    return [...this.#rgba];
+  }
+
+  /**
+   * Returns RGB string.
+   * @returns {string}
+   */
+  toRgbString() {
+    const [r, g, b] = this.#rgba;
+    return `rgb(${r}, ${g}, ${b})`;
+  }
+
+  /**
+   * Returns RGBA string.
+   * @returns {string}
+   */
+  toRgbaString() {
+    const [r, g, b, a] = this.#rgba;
+    return `rgba(${r}, ${g}, ${b}, ${a ?? 1})`;
+  }
+
+  /**
+   * Returns hex color.
+   * @returns {HexColor}
+   */
+  toHex() {
+    const [r, g, b] = this.#rgba;
+    return TinyColorConverter.rgbToHex(r, g, b);
+  }
+
+  /**
+   * Returns color as integer.
+   * @returns {number}
+   */
+  toInt() {
+    const [r, g, b] = this.#rgba;
+    return TinyColorConverter.rgbToInt(r, g, b);
+  }
+
+  /**
+   * Returns the original input.
+   * @returns {ColorTypes}
+   */
+  getOriginal() {
+    return this.#original;
+  }
+}
+
+/* harmony default export */ const libs_TinyColorConverter = (TinyColorConverter);
+
+;// ./src/v1/libs/TinyTimeout.mjs
+/**
+ * A utility class to manage dynamically adjusted timeouts based on how often
+ * each unique ID is triggered. Also provides polling support for asynchronous conditions.
+ */
+class TinyTimeout {
+  /** @type {boolean} Whether this instance has been destroyed. */
+  #isDestroyed = false;
+
+  /** @type {boolean} Whether to allow auto-updating an ID's timeout config if `value` changes. */
+  #allowAutoConfigChange;
+
+  /** @type {number} The interval time (ms) used to decrement cooldown counters. */
+  #cooldownWatcherTime;
+
+  /** @type {NodeJS.Timeout|null} Reference to the internal cooldown interval. */
+  #cooldownWatcher = null;
+
+  /**
+   * Internal map that keeps track of how many times each ID has been triggered,
+   * along with the base multiplier used to calculate delays.
+   *
+   * @type {Map<string, { value: number, now: number }>}
+   */
+  #timeoutFixer = new Map();
+
+  /**
+   * Creates a new instance of TinyTimeout.
+   *
+   * @param {Object} [options={}] Optional configuration object.
+   * @param {number} [options.cooldownWatcherTime=5000] Interval in milliseconds for reducing `now` counters.
+   * @param {boolean} [options.allowAutoConfigChange=false] Whether to allow auto value changes for existing IDs.
+   */
+  constructor({ cooldownWatcherTime = 5000, allowAutoConfigChange = false } = {}) {
+    if (!Number.isFinite(cooldownWatcherTime) || cooldownWatcherTime <= 0)
+      throw new TypeError(`Expected 'cooldownWatcherTime' to be a positive number.`);
+    if (typeof allowAutoConfigChange !== 'boolean')
+      throw new TypeError(`Expected 'allowAutoConfigChange' to be a boolean.`);
+    this.#cooldownWatcherTime = cooldownWatcherTime;
+    this.#allowAutoConfigChange = allowAutoConfigChange;
+    this.setCooldownWatcherTime(cooldownWatcherTime);
+  }
+
+  /**
+   * Whether this instance has been destroyed and is no longer usable.
+   *
+   * @returns {boolean}
+   */
+  isDestroyed() {
+    return this.#isDestroyed;
+  }
+
+  /**
+   * Whether auto config change is enabled.
+   *
+   * @returns {boolean}
+   */
+  getAllowAutoConfigChange() {
+    return this.#allowAutoConfigChange;
+  }
+
+  /**
+   * Gets the interval time used for cooldown decrementing.
+   *
+   * @returns {number}
+   */
+  getCooldownWatcherTime() {
+    return this.#cooldownWatcherTime;
+  }
+
+  /**
+   * Sets whether to allow auto-updating an ID's timeout config if `value` changes.
+   *
+   * @param {boolean} value
+   */
+  setAllowAutoConfigChange(value) {
+    if (typeof value !== 'boolean') throw new TypeError(`Expected 'value' to be a boolean.`);
+    this.#allowAutoConfigChange = value;
+  }
+
+  /**
+   * Sets the cooldown watcher interval time.
+   * Automatically resets the interval if it was already running.
+   *
+   * @param {number} value
+   */
+  setCooldownWatcherTime(value) {
+    if (this.#isDestroyed) throw new Error('TinyTimeout has been destroyed.');
+    if (!Number.isFinite(value) || value <= 0)
+      throw new TypeError(`Expected 'value' to be a positive number.`);
+
+    this.#cooldownWatcherTime = value;
+
+    if (this.#cooldownWatcher) clearInterval(this.#cooldownWatcher);
+    this.#cooldownWatcher = setInterval(() => {
+      this.#timeoutFixer.forEach((data) => {
+        if (data.now > 0) data.now--;
+      });
+    }, this.#cooldownWatcherTime);
+  }
+
+  /**
+   * Schedules a callback using a dynamically adjusted timeout based on usage frequency.
+   * The more often an ID is triggered, the longer the timeout becomes,
+   * scaled by the provided `value`. Optionally, the delay can be limited by `limit`.
+   *
+   * @param {string} id - A unique identifier to track timeout usage.
+   * @param {Function} callback - The function to execute after the delay.
+   * @param {number} value - Base delay multiplier in milliseconds.
+   * @param {number|null} [limit=null] - Optional maximum delay cap.
+   * @returns {number} Handle to the scheduled timeout.
+   * @throws {Error} Throws if the instance has been destroyed or arguments are invalid.
+   */
+  set(id, callback, value, limit = null) {
+    if (this.#isDestroyed) throw new Error('TinyTimeout has been destroyed.');
+    if (typeof id !== 'string' || id.trim() === '')
+      throw new TypeError(`Expected 'id' to be a non-empty string.`);
+    if (typeof callback !== 'function')
+      throw new TypeError(`Expected 'callback' to be a function.`);
+    if (!Number.isFinite(value) || value < 0)
+      throw new TypeError(`Expected 'value' to be a non-negative number.`);
+    if (limit !== null && (!Number.isFinite(limit) || limit < 0))
+      throw new TypeError(`Expected 'limit' to be null or a non-negative number.`);
+
+    let entry = this.#timeoutFixer.get(id);
+    if (!entry || (this.#allowAutoConfigChange && value !== entry.value)) {
+      entry = { value, now: 0 };
+      this.#timeoutFixer.set(id, entry);
+    }
+
+    const delay = entry.value * entry.now;
+    entry.now++;
+
+    return setTimeout(callback, typeof limit === 'number' ? Math.min(delay, limit) : delay);
+  }
+
+  /**
+   * Waits until a provided function returns `true`, checking repeatedly at the defined interval.
+   * Useful for polling asynchronous conditions.
+   *
+   * @param {() => boolean} getValue - A function that returns `true` when the condition is met.
+   * @param {number} [checkInterval=100] - How often (in ms) to check the condition.
+   * @returns {Promise<void>} Resolves when the condition is met.
+   * @throws {TypeError} If arguments are invalid.
+   */
+  static waitForTrue(getValue, checkInterval = 100) {
+    if (typeof getValue !== 'function')
+      throw new TypeError(`Expected 'getValue' to be a function.`);
+    if (!Number.isFinite(checkInterval) || checkInterval <= 0)
+      throw new TypeError(`Expected 'checkInterval' to be a positive number.`);
+
+    return new Promise((resolve) => {
+      const interval = setInterval(() => {
+        if (getValue()) {
+          clearInterval(interval);
+          resolve();
+        }
+      }, checkInterval);
+    });
+  }
+
+  /**
+   * Instance version of `waitForTrue`, which defaults to using the instance's
+   * cooldownWatcherTime if not explicitly provided.
+   *
+   * @param {() => boolean} getValue - A function that returns `true` when the condition is met.
+   * @param {number|null} [checkInterval=100] - How often (in ms) to check the condition.
+   * @returns {Promise<void>} Resolves when the condition is met.
+   * @throws {Error} If the instance is destroyed or arguments are invalid.
+   */
+  waitForTrue(getValue, checkInterval = 100) {
+    if (this.#isDestroyed) throw new Error('TinyTimeout has been destroyed.');
+    if (typeof getValue !== 'function')
+      throw new TypeError(`Expected 'getValue' to be a function.`);
+    if (checkInterval !== null && (!Number.isFinite(checkInterval) || checkInterval <= 0))
+      throw new TypeError(`Expected 'checkInterval' to be null or a positive number.`);
+    return TinyTimeout.waitForTrue(getValue, checkInterval ?? this.#cooldownWatcherTime);
+  }
+
+  /**
+   * Cleans up all internal references and stops the cooldown watcher.
+   * After calling this, the instance becomes unusable.
+   */
+  destroy() {
+    if (this.#isDestroyed) return;
+    this.#isDestroyed = true;
+    if (this.#cooldownWatcher) clearInterval(this.#cooldownWatcher);
+    this.#cooldownWatcher = null;
+    this.#timeoutFixer.clear();
+  }
+}
+
+/* harmony default export */ const libs_TinyTimeout = (TinyTimeout);
+
+;// ./src/v1/libs/TinyLocalStorage.mjs
+
+
+
+/** @type {Map<any, EncodeFn>} */
+const customEncoders = new Map();
+
+/** @type {Map<any, DecodeFn>} */
+const customDecoders = new Map();
+
+/**
+ * A function that encodes a value into a serializable JSON-compatible format.
+ *
+ * @callback EncodeFn
+ * @param {any} value - The value to encode.
+ * @param {encodeSpecialJson} encodeSpecialJson - Recursive encoder helper.
+ * @returns {any} The encoded value.
+ */
+
+/**
+ * An object that defines how to check and decode a specific serialized type.
+ *
+ * @typedef {Object} DecodeFn
+ * @property {(value: any) => any} check - Checks if the value matches the custom encoded structure.
+ * @property {(value: any, decodeSpecialJson: decodeSpecialJson) => any} decode - Decodes the structure back into its original form.
+ */
+
+/**
+ * Encodes extended JSON-compatible structures recursively.
+ * @callback encodeSpecialJson
+ * @param {any} value
+ * @returns {any}
+ */
+
+/**
+ * Decodes extended JSON-compatible structures recursively.
+ * @callback decodeSpecialJson
+ * @param {any} value
+ * @returns {any}
+ */
+
+/**
+ * Represents a value that can be safely stored and restored using JSON in `localStorage`,
+ * including structures like arrays, plain objects, Map and Set.
+ *
+ * - `Record<string|number|symbol, any>` → plain object (e.g., `{ key: value }`)
+ * - `any[]` → array of any JSON-serializable values
+ * - `Map<string|number|symbol, any>` → converted to `{ __map__: true, data: [[k, v], ...] }`
+ * - `Set<any>` → converted to `{ __set__: true, data: [v1, v2, ...] }`
+ *
+ * These conversions allow complex structures to be restored after JSON serialization.
+ *
+ * @typedef {(Record<string|number|symbol, any> | any[] | Map<string|number|symbol, any> | Set<any>)} LocalStorageJsonValue
+ */
+
+/**
+ * A powerful wrapper for Web Storage (`localStorage` or `sessionStorage`) that supports
+ * type-safe methods and full JSON-like structure encoding and decoding.
+ *
+ * `TinyLocalStorage` allows storing and retrieving complex types such as:
+ * - `Map`, `Set`
+ * - `Date`, `RegExp`
+ * - `BigInt`, `Symbol`
+ * - `undefined`, `null`
+ * - Plain objects and arrays
+ *
+ * Includes:
+ * - Type-specific `set` and `get` methods (`setDate`, `getBool`, etc.)
+ * - `getValue()` to retrieve any structure regardless of type
+ * - Auto-encoding/decoding with support for custom types via `registerJsonType`
+ * - Built-in event system (`TinyEvents`) to listen for changes
+ * - Optional fallback values on decoding errors
+ *
+ * Supports registering and unregistering custom types via:
+ * - `registerJsonType(...)`
+ * - `deleteJsonType(...)`
+ *
+ * This class is suitable for applications that require structured persistence in the browser.
+ */
+class TinyLocalStorage {
+  /** @typedef {import('./TinyEvents.mjs').handler} handler */
+
+  #events = new libs_TinyEvents();
+
+  /**
+   * Enables or disables throwing an error when the maximum number of listeners is exceeded.
+   *
+   * @param {boolean} shouldThrow - If true, an error will be thrown when the max is exceeded.
+   */
+  setThrowOnMaxListeners(shouldThrow) {
+    return this.#events.setThrowOnMaxListeners(shouldThrow);
+  }
+
+  /**
+   * Checks whether an error will be thrown when the max listener limit is exceeded.
+   *
+   * @returns {boolean} True if an error will be thrown, false if only a warning is shown.
+   */
+  getThrowOnMaxListeners() {
+    return this.#events.getThrowOnMaxListeners();
+  }
+
+  /////////////////////////////////////////////////////////////
+
+  /**
+   * Adds a listener to the beginning of the listeners array for the specified event.
+   *
+   * @param {string} event - Event name.
+   * @param {handler} handler - The callback function.
+   */
+  prependListener(event, handler) {
+    return this.#events.prependListener(event, handler);
+  }
+
+  /**
+   * Adds a one-time listener to the beginning of the listeners array for the specified event.
+   *
+   * @param {string} event - Event name.
+   * @param {handler} handler - The callback function.
+   * @returns {handler} - The wrapped handler used internally.
+   */
+  prependListenerOnce(event, handler) {
+    return this.#events.prependListenerOnce(event, handler);
+  }
+
+  //////////////////////////////////////////////////////////////////////
+
+  /**
+   * Adds a event listener.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - Callback function to be called when event fires.
+   */
+  appendListener(event, handler) {
+    return this.#events.appendListener(event, handler);
+  }
+
+  /**
+   * Registers an event listener that runs only once, then is removed.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - The callback function to run on event.
+   * @returns {handler} - The wrapped version of the handler.
+   */
+  appendListenerOnce(event, handler) {
+    return this.#events.appendListenerOnce(event, handler);
+  }
+
+  /**
+   * Adds a event listener.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - Callback function to be called when event fires.
+   */
+  on(event, handler) {
+    return this.#events.on(event, handler);
+  }
+
+  /**
+   * Registers an event listener that runs only once, then is removed.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - The callback function to run on event.
+   * @returns {handler} - The wrapped version of the handler.
+   */
+  once(event, handler) {
+    return this.#events.once(event, handler);
+  }
+
+  ////////////////////////////////////////////////////////////////////
+
+  /**
+   * Removes a previously registered event listener.
    *
-   * @param {string} tagName - The tag name (e.g., `b`, `color`, etc.).
-   * @param {Record<string,string> | string[]} [attributes={}] - Optional attributes for the opening tag.
-   *   - If an object: key-value pairs (e.g., `{ color: "red" }` → `color="red"`).
-   *   - If an array: boolean attributes (e.g., `["disabled", "readonly"]`).
+   * @param {string} event - The name of the event to remove the handler from.
+   * @param {handler} handler - The specific callback function to remove.
+   */
+  off(event, handler) {
+    return this.#events.off(event, handler);
+  }
+
+  /**
+   * Removes all event listeners of a specific type from the element.
    *
-   * @returns {TinyTextRangeEditor}
+   * @param {string} event - The event type to remove (e.g. 'onScrollBoundary').
    */
-  wrapWithTag(tagName, attributes = {}) {
-    if (typeof tagName !== 'string') throw new TypeError('tagName must be a string.');
-    const attrStr = this._insertAttr(attributes);
-    const openTag = attrStr
-      ? `${this.#openTag}${tagName} ${attrStr}${this.#closeTag}`
-      : `${this.#openTag}${tagName}${this.#closeTag}`;
-    const closeTag = `${this.#openTag}/${tagName}${this.#closeTag}`;
-    this.surroundSelection(openTag, closeTag);
-    return this;
+  offAll(event) {
+    return this.#events.offAll(event);
   }
 
   /**
-   * Inserts a tag with optional inner content.
-   * @param {string} tagName - The tag to insert.
-   * @param {string} [content=''] - Optional content between tags.
-   * @param {Record<string,string> | string[]} [attributes={}] - Optional attributes or list of empty attributes.
-   * @returns {TinyTextRangeEditor}
+   * Removes all event listeners of all types from the element.
    */
-  insertTag(tagName, content = '', attributes = {}) {
-    if (typeof tagName !== 'string') throw new TypeError('tagName must be a string.');
-    if (typeof content !== 'string') throw new TypeError('content must be a string.');
+  offAllTypes() {
+    return this.#events.offAllTypes();
+  }
 
-    const attrStr = this._insertAttr(attributes);
-    const open = attrStr
-      ? `${this.#openTag}${tagName} ${attrStr}${this.#closeTag}`
-      : `${this.#openTag}${tagName}${this.#closeTag}`;
-    const close = `${this.#openTag}/${tagName}${this.#closeTag}`;
+  ////////////////////////////////////////////////////////////
 
-    this.insertText(`${open}${content}${close}`);
-    return this;
+  /**
+   * Returns the number of listeners for a given event.
+   *
+   * @param {string} event - The name of the event.
+   * @returns {number} Number of listeners for the event.
+   */
+  listenerCount(event) {
+    return this.#events.listenerCount(event);
   }
 
   /**
-   * Inserts a self-closing tag.
-   * @param {string} tagName - The tag name.
-   * @param {Record<string,string> | string[]} [attributes={}] - Optional attributes or list of empty attributes.
-   * @returns {TinyTextRangeEditor}
+   * Returns a copy of the array of listeners for the specified event.
+   *
+   * @param {string} event - The name of the event.
+   * @returns {handler[]} Array of listener functions.
    */
-  insertSelfClosingTag(tagName, attributes = {}) {
-    if (typeof tagName !== 'string') throw new TypeError('tagName must be a string.');
+  listeners(event) {
+    return this.#events.listeners(event);
+  }
 
-    const attrStr = this._insertAttr(attributes);
-    const tag = attrStr
-      ? `${this.#openTag}${tagName} ${attrStr}${this.#closeTag}`
-      : `${this.#openTag}${tagName}${this.#closeTag}`;
+  /**
+   * Returns a copy of the array of listeners for the specified event.
+   *
+   * @param {string} event - The name of the event.
+   * @returns {handler[]} Array of listener functions.
+   */
+  onceListeners(event) {
+    return this.#events.onceListeners(event);
+  }
 
-    this.insertText(tag);
-    return this;
+  /**
+   * Returns a copy of the internal listeners array for the specified event,
+   * including wrapper functions like those used by `.once()`.
+   * @param {string | symbol} event - The event name.
+   * @returns {handler[]} An array of raw listener functions.
+   */
+  allListeners(event) {
+    return this.#events.allListeners(event);
   }
 
   /**
-   * Toggles a tag around the current selection.
-   * Supports tags with attributes. If already wrapped, it unwraps.
-   * @param {string} tagName - The tag to toggle.
-   * @param {Record<string,string> | string[]} [attributes={}] - Optional attributes to apply when wrapping.
-   * @returns {TinyTextRangeEditor}
+   * Returns an array of event names for which there are registered listeners.
+   *
+   * @returns {string[]} Array of registered event names.
    */
-  toggleTag(tagName, attributes = {}) {
-    if (typeof tagName !== 'string') throw new TypeError('tagName must be a string.');
-    const selected = this.getSelectedText();
+  eventNames() {
+    return this.#events.eventNames();
+  }
 
-    // Regex: opening tag with optional attributes, and closing tag
-    const openRegex = new RegExp(`^\\[${tagName}(\\s+[^\\]]*)?\\]`);
-    const closeRegex = new RegExp(`\\[/${tagName}\\]$`);
+  //////////////////////////////////////////////////////
 
-    const hasOpen = openRegex.test(selected);
-    const hasClose = closeRegex.test(selected);
+  /**
+   * Emits an event, triggering all registered handlers for that event.
+   *
+   * @param {string} event - The event name to emit.
+   * @param {...any} payload - Optional data to pass to each handler.
+   * @returns {boolean} True if any listeners were called, false otherwise.
+   */
+  emit(event, ...payload) {
+    return this.#events.emit(event, ...payload);
+  }
 
-    if (hasOpen && hasClose) {
-      const unwrapped = selected
-        .replace(openRegex, '') // remove opening tag
-        .replace(closeRegex, ''); // remove closing tag
-      this.insertText(unwrapped);
-    } else {
-      const attrStr = this._insertAttr(attributes);
-      const open = attrStr
-        ? `${this.#openTag}${tagName} ${attrStr}${this.#closeTag}`
-        : `${this.#openTag}${tagName}${this.#closeTag}`;
-      const close = `${this.#openTag}/${tagName}${this.#closeTag}`;
-      this.insertText(`${open}${selected}${close}`);
-    }
+  /**
+   * Sets the maximum number of listeners per event before a warning is shown.
+   *
+   * @param {number} n - The maximum number of listeners.
+   */
+  setMaxListeners(n) {
+    return this.#events.setMaxListeners(n);
+  }
 
-    return this;
+  /**
+   * Gets the maximum number of listeners allowed per event.
+   *
+   * @returns {number} The maximum number of listeners.
+   */
+  getMaxListeners() {
+    return this.#events.getMaxListeners();
   }
-}
 
-/* harmony default export */ const libs_TinyTextRangeEditor = (TinyTextRangeEditor);
+  ///////////////////////////////////////////////////
 
-;// ./src/v1/libs/TinyClipboard.mjs
-/**
- * Utility class to handle clipboard operations for text and blob data.
- * Supports modern Clipboard API, custom platform, and legacy execCommand fallback.
- */
-class TinyClipboard {
   /**
-   * Indicates whether the legacy `document.execCommand()` API is available.
-   * Used as a fallback for clipboard operations when modern APIs are not supported.
+   * Registers a new JSON-serializable type with its encoder and decoder.
    *
-   * @type {boolean}
+   * @param {any} type - The type or primitive type name (e.g. `"bigint"`, `"symbol"`, etc).
+   * @param {EncodeFn} encodeFn - The function that encodes the value.
+   * @param {DecodeFn} decodeFn - An object with `check` and `decode` methods for restoring the value.
    */
-  #existExecCommand = false;
+  static registerJsonType(type, encodeFn, decodeFn) {
+    customEncoders.set(type, encodeFn);
+    customDecoders.set(type, decodeFn);
+  }
 
   /**
-   * Indicates whether the modern Clipboard API (`navigator.clipboard`) is available.
+   * Removes a previously registered custom type from the encoding/decoding system.
    *
-   * @type {boolean}
+   * @param {string} type - The primitive name or constructor reference used in registration.
    */
-  #existNavigator = false;
+  static deleteJsonType(type) {
+    customEncoders.delete(type);
+    customDecoders.delete(type);
+  }
+
+  //////////////////////////////////////////////////////
 
   /**
-   * Function used to copy plain text to the clipboard.
-   * Can be overridden using `setCopyText()`.
+   * Recursively serializes a value to a JSON-compatible format.
    *
-   * @type {((text: string) => Promise<void>) | null}
+   * This includes custom types (via `registerJsonType`), plus support for:
+   * - `undefined` → `{ __undefined__: true }`
+   * - `null` → `{ __null__: true }`
+   *
+   * @type {encodeSpecialJson}
    */
-  #copyText = null;
+  static encodeSpecialJson(value) {
+    if (typeof value === 'undefined') return { __undefined__: true };
+    if (value === null) return { __null__: true };
+    for (const [type, encoder] of customEncoders.entries()) {
+      if ((typeof type !== 'string' && value instanceof type) || typeof value === type) {
+        return encoder(value, TinyLocalStorage.encodeSpecialJson);
+      }
+    }
+
+    if (Array.isArray(value)) {
+      return value.map(TinyLocalStorage.encodeSpecialJson);
+    }
+
+    if (isJsonObject(value)) {
+      const encoded = {};
+      for (const key in value) {
+        // @ts-ignore
+        encoded[key] = TinyLocalStorage.encodeSpecialJson(value[key]);
+      }
+      return encoded;
+    }
+
+    return value;
+  }
 
   /**
-   * Function used to copy a Blob (binary data) to the clipboard.
-   * Can be overridden using `setCopyBlob()`.
+   * Recursively deserializes a JSON-compatible value into its original structure.
    *
-   * @type {((blob: Blob) => Promise<void>) | null}
+   * Automatically handles:
+   * - `__undefined__` → `undefined`
+   * - `__null__` → `null`
+   * - Any type registered via `registerJsonType`
+   *
+   * @type {decodeSpecialJson}
    */
-  #copyBlob = null;
+  static decodeSpecialJson(value) {
+    const isJson = isJsonObject(value);
+    if (isJson) {
+      if (value.__undefined__) return undefined;
+      if (value.__null__) return null;
+    }
+
+    if (Array.isArray(value)) {
+      return value.map(TinyLocalStorage.decodeSpecialJson);
+    }
+
+    if (isJson) {
+      for (const [type, decoder] of customDecoders.entries()) {
+        if (decoder.check && decoder.check(value)) {
+          return decoder.decode(value, TinyLocalStorage.decodeSpecialJson);
+        }
+      }
+
+      const decoded = {};
+      for (const key in value) {
+        // @ts-ignore
+        decoded[key] = TinyLocalStorage.decodeSpecialJson(value[key]);
+      }
+      return decoded;
+    }
+
+    return value;
+  }
+
+  //////////////////////////////////////////////////////
+
+  /** @type {Storage} */
+  #localStorage = window.localStorage;
+
+  /** @type {(ev: StorageEvent) => any} */
+  #storageEvent = (ev) => this.emit('storage', ev);
 
   /**
-   * Constructs a new TinyClipboard instance.
-   * Automatically detects and configures available clipboard APIs.
+   * Initializes the TinyLocalStorage instance and sets up cross-tab sync.
+   *
+   * Adds listener for the native `storage` event to support tab synchronization.
    */
   constructor() {
-    // Whether the Clipboard API is available.
-    if (typeof navigator.clipboard !== 'undefined' && navigator.clipboard !== null) {
-      this.#existNavigator = true;
-      this.#copyText = (text) => navigator.clipboard.writeText(text);
-      this.#copyBlob = (blob) =>
-        navigator.clipboard.write([
-          new ClipboardItem({
-            [blob.type]: blob,
-          }),
-        ]);
-    }
+    window.addEventListener('storage', this.#storageEvent);
+  }
 
-    /**
-     * @type {boolean}
-     * Whether the legacy execCommand API is available.
-     */
-    this.#existExecCommand =
-      typeof document.execCommand !== 'undefined' && document.execCommand !== null;
+  /**
+   * Defines a custom storage interface (e.g. `sessionStorage`).
+   *
+   * @param {Storage} localstorage - A valid Storage object (localStorage or sessionStorage).
+   */
+  setLocalStorage(localstorage) {
+    if (!(localstorage instanceof Storage))
+      throw new Error('Argument must be a valid instance of Storage.');
+    this.#localStorage = localstorage;
   }
 
   /**
-   * Override the default text copy behavior.
-   * This allows you to provide your own clipboard implementation or
-   * integrate with external systems like Capacitor or Electron.
+   * Checks if `localStorage` is supported by the current environment.
    *
-   * @param {(text: string) => Promise<void>} callback - The function to use for copying text.
-   * @throws {TypeError} If the callback is not a function.
+   * @returns {boolean} True if `localStorage` exists, false otherwise.
    */
-  setCopyText(callback) {
-    if (typeof callback !== 'function')
-      throw new TypeError('setCopyText expected a function that returns Promise<void>.');
-    this.#copyText = callback;
+  localStorageExists() {
+    return this.#localStorage instanceof Storage;
   }
 
   /**
-   * Override the default blob copy behavior.
-   * This allows you to provide a custom clipboard handling method for blob data.
+   * Automatically serializes nested instances.
    *
-   * @param {(blob: Blob) => Promise<void>} callback - The function to use for copying blob data.
-   * @throws {TypeError} If the callback is not a function.
+   * @param {string} name - The key under which to store the data.
+   * @param {*} data - The data to be serialized.
+   * @returns {*}
    */
-  setCopyBlob(callback) {
-    if (typeof callback !== 'function')
-      throw new TypeError('setCopyBlob expected a function that returns Promise<void>.');
-    this.#copyBlob = callback;
+  #setJson(name, data) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    return TinyLocalStorage.encodeSpecialJson(data);
   }
 
   /**
-   * Copy a plain text string to the clipboard.
-   * Uses modern or legacy fallback.
+   * Stores a JSON-compatible value in `localStorage`.
    *
-   * @param {string} text - The text string to be copied.
-   * @returns {Promise<void>} A promise resolving when the text is copied or boolean for legacy.
+   * Automatically serializes nested `Map` and `Set` instances.
+   *
+   * @param {string} name - The key under which to store the data.
+   * @param {LocalStorageJsonValue} data - The data to be serialized and stored.
    */
-  copyText(text) {
-    if (typeof text !== 'string') throw new TypeError('copyText expected a string.');
-    // Clipboard API
-    if (this.#copyText) return this.#copyText(text);
-    // Classic API
-    else if (this.#existExecCommand) {
-      const host = document.body;
-      const copyInput = document.createElement('input');
-      copyInput.style.position = 'fixed';
-      copyInput.style.opacity = '0';
-      copyInput.value = text;
-      host.append(copyInput);
+  setJson(name, data) {
+    if (
+      !isJsonObject(data) &&
+      !Array.isArray(data) &&
+      !(data instanceof Map) &&
+      !(data instanceof Set)
+    ) {
+      throw new Error('The storage value is not a valid JSON-compatible structure.');
+    }
+    const encoded = this.#setJson(name, data);
+    this.emit('setJson', name, data);
+    this.#localStorage.setItem(name, JSON.stringify(encoded));
+  }
 
-      copyInput.select();
-      copyInput.setSelectionRange(0, 99999);
-      document.execCommand('Copy');
-      copyInput.remove();
-      return new Promise((resolve) => resolve(undefined));
+  /**
+   * Retrieves a value from `localStorage`.
+   *
+   * Automatically restores nested instances.
+   *
+   * @param {string} name - The key to retrieve.
+   * @param {'array'|'obj'|'map'|'set'|'null'} [defaultData] - Default fallback format if value is invalid.
+   * @returns {{ decoded: any, fallback: any }} The parsed object or fallback.
+   */
+  #getJson(name, defaultData) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+
+    const raw = this.#localStorage.getItem(name);
+    const fallbackTypes = {
+      obj: () => ({}),
+      array: () => [],
+      map: () => new Map(),
+      set: () => new Set(),
+    };
+
+    const fallback =
+      // @ts-ignore
+      typeof fallbackTypes[defaultData] === 'function' ? fallbackTypes[defaultData]() : null;
+
+    let parsed;
+
+    try {
+      // @ts-ignore
+      parsed = JSON.parse(raw);
+    } catch {
+      // @ts-ignore
+      return fallback;
     }
-    throw new Error('Clipboard API not found!');
+
+    return { decoded: TinyLocalStorage.decodeSpecialJson(parsed), fallback };
   }
 
   /**
-   * Copy a Blob (binary data) to the clipboard.
+   * Retrieves and parses a JSON value from `localStorage`.
    *
-   * @param {Blob} blob - The blob object to copy.
-   * @returns {Promise<void>} A promise that resolves when the blob is copied or null on fallback.
+   * Automatically restores nested `Map` and `Set` instances.
+   *
+   * @param {string} name - The key to retrieve.
+   * @param {'array'|'obj'|'map'|'set'|'null'} [defaultData] - Default fallback format if value is invalid.
+   * @returns {LocalStorageJsonValue|null} The parsed object or fallback.
    */
-  copyBlob(blob) {
-    if (!(blob instanceof Blob)) throw new TypeError('copyBlob expected a Blob instance.');
-    return new Promise((resolve, reject) => {
-      if (this.#copyBlob) {
-        return this.#copyBlob(blob).then(resolve).catch(reject);
-      }
-      throw new Error('Clipboard API not found!');
-    });
+  getJson(name, defaultData) {
+    const { decoded, fallback } = this.#getJson(name, defaultData);
+    if (
+      decoded instanceof Map ||
+      decoded instanceof Set ||
+      Array.isArray(decoded) ||
+      isJsonObject(decoded)
+    )
+      return decoded;
+    return fallback;
   }
 
   /**
-   * Internal: Handle getting blob data from a clipboard item.
-   *
-   * @private
-   * @param {string} type - The MIME type to fetch.
-   * @param {ClipboardItem} clipboardItem - Clipboard item instance.
-   * @returns {Promise<Blob>} A promise that resolves with the Blob.
+   * Stores a Date in localStorage.
+   * @param {string} name
+   * @param {Date} data
    */
-  _handleBlob(type, clipboardItem) {
-    return clipboardItem.getType(type);
+  setDate(name, data) {
+    if (!(data instanceof Date)) throw new Error('Value must be a Date.');
+    const encoded = this.#setJson(name, data);
+    this.#localStorage.setItem(name, JSON.stringify(encoded));
+    this.emit('setDate', name, data);
   }
 
   /**
-   * Internal: Handle getting plain text from a clipboard item.
-   *
-   * @private
-   * @param {string} type - The MIME type (should be 'text/plain').
-   * @param {ClipboardItem} clipboardItem - Clipboard item instance.
-   * @returns {Promise<string>} A promise that resolves with the text content.
+   * Retrieves a Date from localStorage.
+   * @param {string} name
+   * @returns {Date|null}
    */
-  _handleText(type, clipboardItem) {
-    return this._handleBlob(type, clipboardItem).then((blob) => blob.text());
+  getDate(name) {
+    const value = this.#getJson(name).decoded;
+    return value instanceof Date ? value : null;
   }
 
   /**
-   * Read clipboard data based on filters like type, mime, index.
-   *
-   * @param {number|null} [index=0] - Item index or null for all.
-   * @param {'text'|'custom'|null} [type=null] - Data type to filter.
-   * @param {string|null} [mimeFormat=null] - MIME type or prefix.
-   * @param {boolean} [fixValue=false] - If true, exact match on MIME type.
-   * @returns {Promise<Blob|string|Array<Blob|string>|null>} A promise resolving with matching data.
+   * Stores a RegExp in localStorage.
+   * @param {string} name
+   * @param {RegExp} data
    */
-  _readData(index = 0, type = null, mimeFormat = null, fixValue = false) {
-    return new Promise((resolve, reject) => {
-      this._read(index)
-        .then((items) => {
-          if (!items) return resolve(null);
-          /** @type {Array<Blob|string>} */
-          const finalResult = [];
-
-          // Complete task
-          let continueLoop = true;
-
-          /**
-           * @param {string} mimeType
-           * @param {ClipboardItem} item
-           */
-          const completeTask = async (mimeType, item) => {
-            if (!continueLoop) return;
-            // Custom
-            if (
-              (type === null || type === 'custom') &&
-              typeof mimeFormat === 'string' &&
-              ((!fixValue && mimeType.startsWith(mimeFormat)) ||
-                (fixValue && mimeType === mimeFormat))
-            ) {
-              continueLoop = false;
-              const result = await this._handleBlob(mimeType, item);
-              if (result) finalResult.push(result);
-            }
-
-            // Text
-            else if ((type === null || type === 'text') && mimeType === 'text/plain') {
-              continueLoop = false;
-              const result = await this._handleText(mimeType, item);
-              if (result) finalResult.push(result);
-            }
-
-            // Blob
-            else if (type === null) {
-              continueLoop = false;
-              const result = await this._handleBlob(mimeType, item);
-              if (result) finalResult.push(result);
-            }
-          };
+  setRegExp(name, data) {
+    if (!(data instanceof RegExp)) throw new Error('Value must be a RegExp.');
+    const encoded = this.#setJson(name, data);
+    this.#localStorage.setItem(name, JSON.stringify(encoded));
+    this.emit('setRegExp', name, data);
+  }
 
-          /** @type {Promise<void>[]} */
-          const promises = [];
+  /**
+   * Retrieves a RegExp from localStorage.
+   * @param {string} name
+   * @returns {RegExp|null}
+   */
+  getRegExp(name) {
+    const value = this.#getJson(name).decoded;
+    return value instanceof RegExp ? value : null;
+  }
 
-          /**
-           * Read Item
-           * @param {ClipboardItem | ClipboardItems} item
-           */
-          const readItem = (item) => {
-            if (!(item instanceof ClipboardItem))
-              throw new Error('Expected ClipboardItem when reading data.');
-            for (const tIndex in item.types) promises.push(completeTask(item.types[tIndex], item));
-          };
+  /**
+   * Stores a BigInt in localStorage.
+   * @param {string} name
+   * @param {bigint} data
+   */
+  setBigInt(name, data) {
+    if (typeof data !== 'bigint') throw new Error('Value must be a BigInt.');
+    const encoded = this.#setJson(name, data);
+    this.#localStorage.setItem(name, JSON.stringify(encoded));
+    this.emit('setBigInt', name, data);
+  }
 
-          // Specific Item
-          if (
-            typeof index === 'number' &&
-            !Number.isNaN(index) &&
-            Number.isFinite(index) &&
-            index > -1
-          ) {
-            readItem(items);
-            Promise.all(promises)
-              .then(() => {
-                if (finalResult[0]) resolve(finalResult[0]);
-                else resolve(null);
-              })
-              .catch(reject);
-          }
+  /**
+   * Retrieves a BigInt from localStorage.
+   * @param {string} name
+   * @returns {bigint|null}
+   */
+  getBigInt(name) {
+    const value = this.#getJson(name).decoded;
+    return typeof value === 'bigint' ? value : null;
+  }
 
-          // All
-          else if (Array.isArray(items)) {
-            for (const tIndex in items) readItem(items[tIndex]);
-            Promise.all(promises)
-              .then(() => resolve(finalResult))
-              .catch(reject);
-          }
-        })
-        // Fail
-        .catch(reject);
-    });
+  /**
+   * Stores a Symbol in localStorage.
+   * Only global symbols (`Symbol.for`) will preserve the key.
+   * @param {string} name
+   * @param {symbol} data
+   */
+  setSymbol(name, data) {
+    if (typeof data !== 'symbol') throw new Error('Value must be a Symbol.');
+    const encoded = this.#setJson(name, data);
+    this.#localStorage.setItem(name, JSON.stringify(encoded));
+    this.emit('setSymbol', name, data);
   }
 
   /**
-   * Read plain text from the clipboard (single item by index).
-   *
-   * @param {number} [index=0] - The index of the clipboard item to read.
-   * @returns {Promise<string|null>} A promise that resolves to the clipboard text or null.
+   * Retrieves a Symbol from localStorage.
+   * @param {string} name
+   * @returns {symbol|null}
    */
-  async readText(index = 0) {
-    const value = await this._readData(index, 'text');
-    if (typeof value !== 'string') throw new Error('Failed to read text: expected string result.');
-    return value;
+  getSymbol(name) {
+    const value = this.#getJson(name).decoded;
+    return typeof value === 'symbol' ? value : null;
   }
 
   /**
-   * Read custom clipboard data based on MIME type from a specific index.
+   * Retrieves a value from `localStorage`.
    *
-   * @param {string|null} [mimeFormat=null] - MIME prefix to match (e.g., "image/").
-   * @param {boolean} [fixValue=false] - If true, matches exact MIME instead of prefix.
-   * @param {number} [index=0] - Clipboard item index.
-   * @returns {Promise<Blob|null>} A promise resolving with a blob or null.
+   * @param {string} name - The key to retrieve.
+   * @returns {any} The stored value or null if not found.
    */
-  async readCustom(mimeFormat = null, fixValue = false, index = 0) {
-    const value = await this._readData(index, 'custom', mimeFormat, fixValue);
-    if (!(value instanceof Blob)) throw new Error('Failed to read custom data: expected Blob.');
-    return value;
+  getValue(name) {
+    return this.#getJson(name).decoded ?? null;
   }
 
   /**
-   * Read all available plain text entries from the clipboard.
+   * Stores a raw string value in `localStorage`.
    *
-   * @returns {Promise<string[]>} A promise resolving to an array of strings or null.
+   * @param {string} name - The key to use.
+   * @param {any} data - The data to store.
    */
-  async readAllTexts() {
-    const values = await this._readData(null, 'text');
-    if (!Array.isArray(values))
-      throw new Error('Expected array of strings when reading all texts.');
-    if (!values.every((value) => typeof value === 'string'))
-      throw new Error('Some values returned were not strings.');
-    return values;
+  setItem(name, data) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    this.emit('setItem', name, data);
+    return this.#localStorage.setItem(name, data);
   }
 
   /**
-   * Read all clipboard data matching a specific custom MIME type.
+   * Retrieves a raw string value from `localStorage`.
    *
-   * @param {string|null} [mimeFormat=null] - MIME prefix or exact type.
-   * @param {boolean} [fixValue=false] - Match prefix or exact MIME.
-   * @returns {Promise<Blob[]>} A promise resolving with array of Blobs or null.
+   * @param {string} name - The key to retrieve.
+   * @returns {string|null} The stored value or null if not found.
    */
-  async readAllCustom(mimeFormat = null, fixValue = false) {
-    const values = await this._readData(null, 'custom', mimeFormat, fixValue);
-    if (!Array.isArray(values))
-      throw new Error('Expected array of blobs when reading all custom items.');
-    if (!values.every((value) => value instanceof Blob))
-      throw new Error('Some values returned were not Blob instances.');
-    return values;
+  getItem(name) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    return this.#localStorage.getItem(name);
   }
 
   /**
-   * Read all clipboard data as Blob or text depending on type.
+   * Stores a string in `localStorage`, ensuring the data is a valid string.
    *
-   * @param {'text'|'custom'|null} [type=null] - The type of data to retrieve.
-   * @param {string|null} [mimeFormat=null] - The MIME type or prefix to match.
-   * @returns {Promise<Array<Blob|string>>} A promise resolving with matching data array.
+   * @param {string} name - The key to store the string under.
+   * @param {string} data - The string to store.
    */
-  async readAllData(type = null, mimeFormat = null) {
-    const value = await this._readData(null, type, mimeFormat);
-    if (!Array.isArray(value)) throw new Error('Expected array result when reading all data.');
-    return value;
+  setString(name, data) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    if (typeof data !== 'string') throw new Error('Value must be a string.');
+
+    this.emit('setString', name, data);
+    return this.#localStorage.setItem(name, data);
   }
 
   /**
-   * Read clipboard data at a specific index or all if null.
+   * Retrieves a string value from `localStorage`.
    *
-   * @param {number|null} index - Index of the item to retrieve or null to get all.
-   * @returns {Promise<ClipboardItem|ClipboardItems|null>} A promise resolving with a clipboard item or array of items.
+   * @param {string} name - The key to retrieve.
+   * @returns {string|null} The string if valid, or null.
    */
-  _read(index) {
-    return new Promise((resolve, reject) => {
-      if (!this.#existNavigator) reject(new Error('Clipboard API not found!'));
-      navigator.clipboard
-        .read()
-        .then((items) => {
-          // Index is number
-          if (typeof index === 'number') {
-            if (Number.isNaN(index) || !Number.isFinite(index) || index < 0)
-              throw new Error(`Invalid index value: ${index}`);
-            if (items[index]) resolve(items[index]);
-            // Not found
-            else resolve(null);
-          }
-          // Get All
-          resolve(items);
-        })
-        .catch(reject);
-    });
+  getString(name) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    let value = this.#localStorage.getItem(name);
+    if (typeof value === 'string') return value;
+    return null;
   }
 
   /**
-   * Read clipboard data at a specific index.
+   * Stores a number value in `localStorage`.
    *
-   * @param {number} index - Index of the item to retrieve
-   * @returns {Promise<ClipboardItem|null>} A promise resolving with a clipboard item.
+   * @param {string} name - The key to use.
+   * @param {number} data - The number to store.
    */
-  async readIndex(index) {
-    const value = await this._read(index);
-    if (value !== null && !(value instanceof ClipboardItem))
-      throw new Error(`Value at index ${index} is not a ClipboardItem.`);
-    return value;
+  setNumber(name, data) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    if (typeof data !== 'number') throw new Error('Value must be a number.');
+    this.emit('setNumber', name, data);
+    return this.#localStorage.setItem(name, String(data));
   }
 
   /**
-   * Read all clipboard content without any filters.
+   * Retrieves a number from `localStorage`.
    *
-   * @returns {Promise<ClipboardItems>} A promise resolving with all clipboard items.
+   * @param {string} name - The key to retrieve.
+   * @returns {number|null} The number or null if invalid.
    */
-  async readAll() {
-    const value = await this._read(null);
-    if (!Array.isArray(value)) throw new Error('Expected array result from clipboard read.');
-    for (const item of value) {
-      if (!(item instanceof ClipboardItem))
-        throw new Error('Invalid item type found in clipboard result.');
+  getNumber(name) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+
+    /** @type {number|string|null} */
+    let number = this.#localStorage.getItem(name);
+    if (typeof number === 'number') return number;
+    if (typeof number === 'string' && number.length > 0) {
+      number = parseFloat(number);
+      if (!Number.isNaN(number)) return number;
     }
-    return value;
+    return null;
   }
 
   /**
-   * Returns whether the legacy `document.execCommand()` API is available.
-   * This can be used to determine if a fallback clipboard method is usable.
+   * Stores a boolean value in `localStorage`.
    *
-   * @returns {boolean} True if `document.execCommand` is available.
+   * @param {string} name - The key to use.
+   * @param {boolean} data - The boolean value to store.
    */
-  isExecCommandAvailable() {
-    return this.#existExecCommand;
+  setBool(name, data) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    if (typeof data !== 'boolean') throw new Error('Value must be a boolean.');
+    this.emit('setBool', name, data);
+    return this.#localStorage.setItem(name, String(data));
   }
 
   /**
-   * Returns whether the modern Clipboard API (`navigator.clipboard`) is available.
-   * Useful to know if full clipboard features can be accessed.
+   * Retrieves a boolean value from `localStorage`.
    *
-   * @returns {boolean} True if `navigator.clipboard` is available.
+   * @param {string} name - The key to retrieve.
+   * @returns {boolean|null} The boolean or null if invalid.
    */
-  isNavigatorClipboardAvailable() {
-    return this.#existNavigator;
+  getBool(name) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+
+    const value = this.#localStorage.getItem(name);
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'string') {
+      if (value === 'true') return true;
+      if (value === 'false') return false;
+    }
+
+    return null;
   }
 
   /**
-   * Returns the function used to copy plain text to the clipboard.
-   * This function may be built-in or set manually via `setCopyText`.
+   * Removes a value from `localStorage`.
    *
-   * @returns {((text: string) => Promise<void>) | null} The current text copy function or null if unavailable.
+   * @param {string} name - The key to remove.
    */
-  getCopyTextFunc() {
-    return this.#copyText;
+  removeItem(name) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+
+    this.emit('removeItem', name);
+    return this.#localStorage.removeItem(name);
   }
 
   /**
-   * Returns the function used to copy Blob (binary data) to the clipboard.
-   * This function may be built-in or set manually via `setCopyBlob`.
-   *
-   * @returns {((blob: Blob) => Promise<void>) | null} The current blob copy function or null if unavailable.
+   * Clears all data from `localStorage`.
    */
-  getCopyBlobFunc() {
-    return this.#copyBlob;
+  clearLocalStorage() {
+    this.#localStorage.clear();
+  }
+
+  /**
+   * Destroys the storage instance by removing the storage event listener.
+   */
+  destroy() {
+    window.removeEventListener('storage', this.#storageEvent);
+    this.#events.offAllTypes();
   }
 }
 
-/* harmony default export */ const libs_TinyClipboard = (TinyClipboard);
+// First registers
+
+// Map
+TinyLocalStorage.registerJsonType(
+  Map,
+  (value, encodeSpecialJson) => ({
+    __map__: true,
+    data: Array.from(value.entries()).map(([k, v]) => [k, encodeSpecialJson(v)]),
+  }),
+  {
+    check: (value) => value.__map__,
+    /** @param {{ data: any[] }} value */
+    decode: (value, decodeSpecialJson) =>
+      new Map(value.data.map(([k, v]) => [k, decodeSpecialJson(v)])),
+  },
+);
+
+// Set
+TinyLocalStorage.registerJsonType(
+  Set,
+  (value, encodeSpecialJson) => ({
+    __set__: true,
+    data: Array.from(value).map(encodeSpecialJson),
+  }),
+  {
+    check: (value) => value.__set__,
+    decode: (value, decodeSpecialJson) => new Set(value.data.map(decodeSpecialJson)),
+  },
+);
+
+// Date
+TinyLocalStorage.registerJsonType(
+  Date,
+  (value) => ({
+    __date__: true,
+    value: value.toISOString(),
+  }),
+  {
+    check: (value) => value.__date__,
+    decode: (value) => new Date(value.value),
+  },
+);
+
+// Regex
+TinyLocalStorage.registerJsonType(
+  RegExp,
+  (value) => ({
+    __regexp__: true,
+    source: value.source,
+    flags: value.flags,
+  }),
+  {
+    check: (value) => value.__regexp__,
+    decode: (value) => new RegExp(value.source, value.flags),
+  },
+);
+
+// Big Int
+TinyLocalStorage.registerJsonType(
+  'bigint',
+  (value) => ({
+    __bigint__: true,
+    value: value.toString(),
+  }),
+  {
+    check: (value) => value.__bigint__,
+    decode: (value) => BigInt(value.value),
+  },
+);
+
+// Symbol
+TinyLocalStorage.registerJsonType(
+  'symbol',
+  (value) => ({
+    __symbol__: true,
+    key: Symbol.keyFor(value) ?? value.description ?? null,
+  }),
+  {
+    check: (value) => value.__symbol__,
+    decode: (value) => {
+      const key = value.key;
+      return key != null ? Symbol.for(key) : Symbol();
+    },
+  },
+);
+
+/* harmony default export */ const libs_TinyLocalStorage = (TinyLocalStorage);
 
 ;// ./src/v1/index.mjs
 
@@ -17580,6 +19729,10 @@ class TinyClipboard {
 
 
 
+
+
+
+