tiny-essentials 1.18.1 → 1.19.0

package/dist/v1/TinyUploadClicker.js

@@ -1,13 +1,6 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 133:
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ }),
-
 /***/ 251:
 /***/ ((__unused_webpack_module, exports) => {
 
@@ -1924,13 +1917,6 @@ var hexSliceLookupTable = (function () {
 })()
 
 
-/***/ }),
-
-/***/ 370:
-/***/ (() => {
-
-/* (ignored) */
-
 /***/ }),
 
 /***/ 526:
@@ -9061,8 +9047,6 @@ function isScrolledIntoView(element) {
   return elemBottom <= viewportBottom && elemTop >= viewportTop;
 }
 
-// EXTERNAL MODULE: fs (ignored)
-var fs_ignored_ = __webpack_require__(133);
 // EXTERNAL MODULE: ./node_modules/path-browserify/index.js
 var path_browserify = __webpack_require__(975);
 ;// ./src/v1/fileManager/normalFuncs.mjs
@@ -9471,8 +9455,6 @@ function renameFilePadNumbers(dirPath, totalDigits = 3, extensions = []) {
   );
 }
 
-// EXTERNAL MODULE: fs/promises (ignored)
-var promises_ignored_ = __webpack_require__(370);
 ;// ./src/v1/fileManager/asyncFuncs.mjs
 
 
@@ -10712,10 +10694,374 @@ class TinyDragger {
 
 /* harmony default export */ const libs_TinyDragger = ((/* unused pure expression or super */ null && (TinyDragger)));
 
+;// ./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.
  *
@@ -10762,52 +11108,248 @@ class TinyDragger {
 class TinySmartScroller {
   static Utils = { ...collision_namespaceObject, TinyHtml: libs_TinyHtml };
 
-  /** @type {WeakMap<Element, NodeSizes>} */
-  #oldSizes = new WeakMap();
-  /** @type {WeakMap<Element, NodeSizes>} */
-  #newSizes = new WeakMap();
+  #events = new libs_TinyEvents();
 
-  /** @type {WeakMap<Element, boolean>} */
-  #newVisibles = new WeakMap();
-  /** @type {WeakMap<Element, boolean>} */
-  #oldVisibles = new WeakMap();
+  /**
+   * 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);
+  }
 
-  /** @type {WeakMap<Element, boolean>} */
-  #newVisiblesByTime = new WeakMap();
-  /** @type {WeakMap<Element, boolean>} */
-  #oldVisiblesByTime = new WeakMap();
+  /**
+   * 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();
+  }
 
-  /** @type {Record<string, ScrollListenersFunc[]>} */
-  #scrollListeners = {};
+  /////////////////////////////////////////////////////////////
 
-  /** @type {ResizeObserver|null} */
-  #resizeObserver = null;
-  /** @type {MutationObserver|null} */
-  #mutationObserver = null;
+  /**
+   * 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 {Set<string>} */
-  #loadTags = new Set(['IMG', 'IFRAME', 'VIDEO']);
+  /**
+   * 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 {null|EventListenerOrEventListenerObject} */
-  #handler = null;
+  //////////////////////////////////////////////////////////////////////
 
-  #isAtBottom = false;
-  #isAtTop = false;
-  #isAtCustomTop = false;
-  #isAtCustomBottom = false;
+  /**
+   * 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.
+   */
+  appendListener(event, handler) {
+    return this.#events.appendListener(event, handler);
+  }
 
-  #querySelector = '';
-  #useWindow = false;
-  #destroyed = false;
-  #scrollPaused = false;
-  #autoScrollBottom = false;
-  #observeMutations = false;
-  #preserveScrollOnLayoutShift = false;
-  #debounceTime = 0;
-  #elemAmount = 0;
-  #elemOldAmount = 0;
-  #lastKnownScrollBottomOffset = 0;
-  #extraScrollBoundary = 0;
+  /**
+   * 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;
@@ -11093,46 +11635,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.
    *
@@ -11157,12 +11659,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);
   }
 
   /**
@@ -11208,13 +11708,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 });
     }
   }
 
@@ -11680,7 +12180,7 @@ class TinySmartScroller {
     this.#oldVisiblesByTime = new WeakMap();
 
     // Cleans listeners and filters
-    this.#scrollListeners = {};
+    this.#events.offAllTypes();
     this.#sizeFilter.clear();
     this.#loadTags.clear();
   }
@@ -11688,7 +12188,858 @@ class TinySmartScroller {
 
 /* harmony default export */ const libs_TinySmartScroller = ((/* unused pure expression or super */ null && (TinySmartScroller)));
 
-;// ./src/v1/index.mjs
+;// ./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} 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.
+   *
+   * @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 {handler[]} 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 {handler[]} 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 {handler[]} 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();
+  }
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * Registers a new JSON-serializable type with its encoder and decoder.
+   *
+   * @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.
+   */
+  static registerJsonType(type, encodeFn, decodeFn) {
+    customEncoders.set(type, encodeFn);
+    customDecoders.set(type, decodeFn);
+  }
+
+  /**
+   * Removes a previously registered custom type from the encoding/decoding system.
+   *
+   * @param {string} type - The primitive name or constructor reference used in registration.
+   */
+  static deleteJsonType(type) {
+    customEncoders.delete(type);
+    customDecoders.delete(type);
+  }
+
+  //////////////////////////////////////////////////////
+
+  /**
+   * Recursively serializes a value to a JSON-compatible format.
+   *
+   * This includes custom types (via `registerJsonType`), plus support for:
+   * - `undefined` → `{ __undefined__: true }`
+   * - `null` → `{ __null__: true }`
+   *
+   * @type {encodeSpecialJson}
+   */
+  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;
+  }
+
+  /**
+   * Recursively deserializes a JSON-compatible value into its original structure.
+   *
+   * Automatically handles:
+   * - `__undefined__` → `undefined`
+   * - `__null__` → `null`
+   * - Any type registered via `registerJsonType`
+   *
+   * @type {decodeSpecialJson}
+   */
+  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);
+
+  /**
+   * Initializes the TinyLocalStorage instance and sets up cross-tab sync.
+   *
+   * Adds listener for the native `storage` event to support tab synchronization.
+   */
+  constructor() {
+    window.addEventListener('storage', this.#storageEvent);
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Checks if `localStorage` is supported by the current environment.
+   *
+   * @returns {boolean} True if `localStorage` exists, false otherwise.
+   */
+  localStorageExists() {
+    return this.#localStorage instanceof Storage;
+  }
+
+  /**
+   * Automatically serializes nested instances.
+   *
+   * @param {string} name - The key under which to store the data.
+   * @param {*} data - The data to be serialized.
+   * @returns {*}
+   */
+  #setJson(name, data) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    return TinyLocalStorage.encodeSpecialJson(data);
+  }
+
+  /**
+   * Stores a JSON-compatible value in `localStorage`.
+   *
+   * 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.
+   */
+  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));
+  }
+
+  /**
+   * 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;
+    }
+
+    return { decoded: TinyLocalStorage.decodeSpecialJson(parsed), fallback };
+  }
+
+  /**
+   * Retrieves and parses a JSON value from `localStorage`.
+   *
+   * 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.
+   */
+  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;
+  }
+
+  /**
+   * Stores a Date in localStorage.
+   * @param {string} name
+   * @param {Date} data
+   */
+  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);
+  }
+
+  /**
+   * Retrieves a Date from localStorage.
+   * @param {string} name
+   * @returns {Date|null}
+   */
+  getDate(name) {
+    const value = this.#getJson(name).decoded;
+    return value instanceof Date ? value : null;
+  }
+
+  /**
+   * Stores a RegExp in localStorage.
+   * @param {string} name
+   * @param {RegExp} data
+   */
+  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);
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * 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);
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * 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);
+  }
+
+  /**
+   * Retrieves a Symbol from localStorage.
+   * @param {string} name
+   * @returns {symbol|null}
+   */
+  getSymbol(name) {
+    const value = this.#getJson(name).decoded;
+    return typeof value === 'symbol' ? value : null;
+  }
+
+  /**
+   * Retrieves a value from `localStorage`.
+   *
+   * @param {string} name - The key to retrieve.
+   * @returns {any} The stored value or null if not found.
+   */
+  getValue(name) {
+    return this.#getJson(name).decoded ?? null;
+  }
+
+  /**
+   * Stores a raw string value in `localStorage`.
+   *
+   * @param {string} name - The key to use.
+   * @param {any} data - The data to store.
+   */
+  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);
+  }
+
+  /**
+   * Retrieves a raw string value from `localStorage`.
+   *
+   * @param {string} name - The key to retrieve.
+   * @returns {string|null} The stored value or null if not found.
+   */
+  getItem(name) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    return this.#localStorage.getItem(name);
+  }
+
+  /**
+   * Stores a string in `localStorage`, ensuring the data is a valid string.
+   *
+   * @param {string} name - The key to store the string under.
+   * @param {string} data - The string to store.
+   */
+  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);
+  }
+
+  /**
+   * Retrieves a string value from `localStorage`.
+   *
+   * @param {string} name - The key to retrieve.
+   * @returns {string|null} The string if valid, or null.
+   */
+  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;
+  }
+
+  /**
+   * Stores a number value in `localStorage`.
+   *
+   * @param {string} name - The key to use.
+   * @param {number} data - The number to store.
+   */
+  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));
+  }
+
+  /**
+   * Retrieves a number from `localStorage`.
+   *
+   * @param {string} name - The key to retrieve.
+   * @returns {number|null} The number or null if invalid.
+   */
+  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 null;
+  }
+
+  /**
+   * Stores a boolean value in `localStorage`.
+   *
+   * @param {string} name - The key to use.
+   * @param {boolean} data - The boolean value to store.
+   */
+  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));
+  }
+
+  /**
+   * Retrieves a boolean value from `localStorage`.
+   *
+   * @param {string} name - The key to retrieve.
+   * @returns {boolean|null} The boolean or null if invalid.
+   */
+  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;
+  }
+
+  /**
+   * Removes a value from `localStorage`.
+   *
+   * @param {string} name - The key to remove.
+   */
+  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);
+  }
+
+  /**
+   * Clears all data from `localStorage`.
+   */
+  clearLocalStorage() {
+    this.#localStorage.clear();
+  }
+
+  /**
+   * Destroys the storage instance by removing the storage event listener.
+   */
+  destroy() {
+    window.removeEventListener('storage', this.#storageEvent);
+    this.#events.offAllTypes();
+  }
+}
+
+// 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 = ((/* unused pure expression or super */ null && (TinyLocalStorage)));
+
+;// ./src/v1/index.mjs
+
+
+
+