tiny-essentials 1.18.0 → 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:
@@ -2912,9 +2898,55 @@ __webpack_require__.d(collision_namespaceObject, {
 
 // EXTERNAL MODULE: ./node_modules/buffer/index.js
 var buffer = __webpack_require__(287);
+;// ./src/v1/basics/objChecker.mjs
+/**
+ * Counts the number of elements in an array or the number of properties in an object.
+ *
+ * @param {Array<*>|Record<string | number | symbol, any>} obj - The array or object to count.
+ * @returns {number} - The count of items (array elements or object keys), or `0` if the input is neither an array nor an object.
+ *
+ * @example
+ * countObj([1, 2, 3]); // 3
+ * countObj({ a: 1, b: 2 }); // 2
+ * countObj('not an object'); // 0
+ */
+function countObj(obj) {
+  // Is Array
+  if (Array.isArray(obj)) return obj.length;
+  // Object
+  if (isJsonObject(obj)) return Object.keys(obj).length;
+  // Nothing
+  return 0;
+}
+
+/**
+ * Determines whether a given value is a pure JSON object (plain object).
+ *
+ * A pure object satisfies the following:
+ * - It is not null.
+ * - Its type is "object".
+ * - Its internal [[Class]] is "[object Object]".
+ * - It is not an instance of built-in types like Array, Date, Map, Set, etc.
+ *
+ * This function is useful for strict data validation when you want to ensure
+ * a value is a clean JSON-compatible object, free of class instances or special types.
+ *
+ * @param {unknown} value - The value to test.
+ * @returns {value is Record<string | number | symbol, unknown>} Returns true if the value is a pure object.
+ */
+function isJsonObject(value) {
+  if (value === null || typeof value !== 'object') return false;
+  if (Array.isArray(value)) return false;
+  if (Object.prototype.toString.call(value) !== '[object Object]') return false;
+  return true;
+}
+
 ;// ./src/v1/basics/objFilter.mjs
 
 
+
+
+
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 
 /**
@@ -3107,48 +3139,6 @@ function getCheckObj() {
   return Object.fromEntries(Object.entries(typeValidator.items).map(([key, fn]) => [key, fn]));
 }
 
-/**
- * Counts the number of elements in an array or the number of properties in an object.
- *
- * @param {Array<*>|Record<string|number, any>} obj - The array or object to count.
- * @returns {number} - The count of items (array elements or object keys), or `0` if the input is neither an array nor an object.
- *
- * @example
- * countObj([1, 2, 3]); // 3
- * countObj({ a: 1, b: 2 }); // 2
- * countObj('not an object'); // 0
- */
-function countObj(obj) {
-  // Is Array
-  if (Array.isArray(obj)) return obj.length;
-  // Object
-  if (objType(obj, 'object')) return Object.keys(obj).length;
-  // Nothing
-  return 0;
-}
-
-/**
- * Determines whether a given value is a pure JSON object (plain object).
- *
- * A pure object satisfies the following:
- * - It is not null.
- * - Its type is "object".
- * - Its internal [[Class]] is "[object Object]".
- * - It is not an instance of built-in types like Array, Date, Map, Set, etc.
- *
- * This function is useful for strict data validation when you want to ensure
- * a value is a clean JSON-compatible object, free of class instances or special types.
- *
- * @param {unknown} value - The value to test.
- * @returns {value is Record<string | number | symbol, unknown>} Returns true if the value is a pure object.
- */
-function objFilter_isJsonObject(value) {
-  if (value === null || typeof value !== 'object') return false;
-  if (Array.isArray(value)) return false;
-  if (Object.prototype.toString.call(value) !== '[object Object]') return false;
-  return true;
-}
-
 // Insert obj types
 
 extendObjType([
@@ -3271,7 +3261,7 @@ extendObjType([
   [
     'object',
     /** @param {*} val @returns {val is Record<string | number | symbol, unknown>} */
-    (val) => objFilter_isJsonObject(val),
+    (val) => isJsonObject(val),
   ],
 ]);
 
@@ -3471,404 +3461,6 @@ class ColorSafeStringify {
 
 /* harmony default export */ const libs_ColorSafeStringify = ((/* unused pure expression or super */ null && (ColorSafeStringify)));
 
-;// ./src/v1/basics/html.mjs
-
-
-/////////////////////////////////////////////////////////////////
-
-/**
- * Reads the contents of a file using the specified FileReader method.
- *
- * @param {File} file - The file to be read.
- * @param {'readAsArrayBuffer'|'readAsDataURL'|'readAsText'|'readAsBinaryString'} method -
- *   The FileReader method to use for reading the file.
- * @returns {Promise<any>} - A promise that resolves with the file content, according to the chosen method.
- * @throws {Error} - If an unexpected error occurs while handling the result.
- * @throws {DOMException} - If the FileReader encounters an error while reading the file.
- */
-function readFileBlob(file, method) {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => {
-      try {
-        resolve(reader.result);
-      } catch (error) {
-        reject(error);
-      }
-    };
-    reader.onerror = () => {
-      reject(reader.error);
-    };
-    reader[method](file);
-  });
-}
-
-/**
- * Reads a file as a Base64 string using FileReader, and optionally formats it as a full data URL.
- *
- * Performs strict validation to ensure the result is a valid Base64 string or a proper data URL.
- *
- * @param {File} file - The file to be read.
- * @param {boolean|string} [isDataUrl=false] - If true, returns a full data URL; if false, returns only the Base64 string;
- *   if a string is passed, it is used as the MIME type in the data URL.
- * @returns {Promise<string>} - A promise that resolves with the Base64 string or data URL.
- *
- * @throws {TypeError} - If the result is not a string or if `isDataUrl` is not a valid type.
- * @throws {Error} - If the result does not match the expected data URL format or Base64 structure.
- * @throws {DOMException} - If the FileReader fails to read the file.
- */
-function readBase64Blob(file, isDataUrl = false) {
-  return new Promise((resolve, reject) => {
-    if (typeof isDataUrl !== 'string' && typeof isDataUrl !== 'boolean')
-      reject(new TypeError('The isDataUrl parameter must be a boolean or a string.'));
-    readFileBlob(file, 'readAsDataURL')
-      .then(
-        /**
-         * Ensure that the URL format is correct in the required pattern
-         * @param {string} base64Data
-         */ (base64Data) => {
-          if (typeof base64Data !== 'string')
-            throw new TypeError('Expected file content to be a string.');
-
-          const match = base64Data.match(/^data:(.+);base64,(.*)$/);
-          if (!match || !match[2])
-            throw new Error('Invalid data URL format or missing Base64 content.');
-          const [, mimeType, base64] = match;
-          if (!/^[\w/+]+=*$/.test(base64)) throw new Error('Base64 content is malformed.');
-
-          if (typeof isDataUrl === 'boolean') return resolve(isDataUrl ? base64Data : base64);
-          if (!/^[\w-]+\/[\w.+-]+$/.test(isDataUrl))
-            throw new Error(`Invalid MIME type string: ${isDataUrl}`);
-
-          return resolve(`data:${isDataUrl};base64,${base64}`);
-        },
-      )
-      .catch(reject);
-  });
-}
-
-/**
- * Reads a file and strictly validates its content as proper JSON using FileReader.
- *
- * Performs several checks to ensure the file contains valid, parsable JSON data.
- *
- * @param {File} file - The file to be read. It must contain valid JSON as plain text.
- * @returns {Promise<Record<string|number|symbol, any>|any[]>} - A promise that resolves with the parsed JSON object.
- *
- * @throws {SyntaxError} - If the file content is not valid JSON syntax.
- * @throws {TypeError} - If the result is not a string or does not represent a JSON value.
- * @throws {Error} - If the result is empty or structurally invalid as JSON.
- * @throws {DOMException} - If the FileReader fails to read the file.
- */
-function readJsonBlob(file) {
-  return new Promise((resolve, reject) =>
-    readFileBlob(file, 'readAsText')
-      .then((data) => {
-        if (typeof data !== 'string') throw new TypeError('Expected file content to be a string.');
-        const trimmed = data.trim();
-        if (trimmed.length === 0) throw new Error('File is empty or contains only whitespace.');
-        const parsed = JSON.parse(trimmed);
-        if (typeof parsed !== 'object' || parsed === null)
-          throw new Error('Parsed content is not a valid JSON object or array.');
-        resolve(parsed);
-      })
-      .catch(reject),
-  );
-}
-
-/**
- * Saves a JSON object as a downloadable file.
- * @param {string} filename
- * @param {any} data
- * @param {number} [spaces=2]
- */
-function saveJsonFile(filename, data, spaces = 2) {
-  const json = JSON.stringify(data, null, spaces);
-  const blob = new Blob([json], { type: 'application/json' });
-  const url = URL.createObjectURL(blob);
-
-  const link = document.createElement('a');
-  link.href = url;
-  link.download = filename;
-
-  document.body.appendChild(link);
-  link.click();
-  document.body.removeChild(link);
-
-  URL.revokeObjectURL(url);
-}
-
-/**
- * @typedef {Object} FetchTemplateOptions
- * @property {string} [method="GET"] - HTTP method to use (GET, POST, etc.).
- * @property {any} [body] - Request body (only for methods like POST, PUT).
- * @property {number} [timeout=0] - Timeout in milliseconds (ignored if signal is provided).
- * @property {number} [retries=0] - Number of retry attempts (ignored if signal is provided).
- * @property {Headers|Record<string, *>} [headers={}] - Additional headers.
- * @property {AbortSignal|null} [signal] - External AbortSignal; disables timeout and retries.
- */
-
-/**
- * @param {string} url - The full URL to fetch data from.
- * @param {FetchTemplateOptions} [options] - Optional settings.
- * @returns {Promise<Response>} Result data.
- * @throws {Error} Throws if fetch fails, times out.
- */
-async function fetchTemplate(
-  url,
-  { method = 'GET', body, timeout = 0, retries = 0, headers = {}, signal = null } = {},
-) {
-  if (
-    typeof url !== 'string' ||
-    (!url.startsWith('../') &&
-      !url.startsWith('./') &&
-      !url.startsWith('/') &&
-      !url.startsWith('https://') &&
-      !url.startsWith('http://'))
-  )
-    throw new Error('Invalid URL: must be a valid http or https address.');
-
-  if (typeof method !== 'string' || !method.trim())
-    throw new Error('Invalid method: must be a non-empty string.');
-
-  if (!signal) {
-    if (
-      typeof timeout !== 'number' ||
-      !Number.isFinite(timeout) ||
-      Number.isNaN(timeout) ||
-      timeout < 0
-    )
-      throw new Error('Invalid timeout: must be a positive number.');
-
-    if (
-      typeof retries !== 'number' ||
-      !Number.isFinite(retries) ||
-      Number.isNaN(retries) ||
-      retries < 0
-    )
-      throw new Error('Invalid retries: must be a positive number.');
-  }
-
-  const attempts = signal ? 1 : retries + 1;
-  /** @type {Error|null} */
-  let lastError = null;
-
-  for (let attempt = 0; attempt < attempts; attempt++) {
-    const controller = signal ? null : new AbortController();
-    const localSignal = signal || (controller?.signal ?? null);
-    const timer =
-      !signal && timeout && controller ? setTimeout(() => controller.abort(), timeout) : null;
-
-    try {
-      const response = await fetch(url, {
-        method: method.toUpperCase(),
-        headers: {
-          Accept: 'application/json',
-          ...headers,
-        },
-        body: body !== undefined ? (isJsonObject(body) ? JSON.stringify(body) : body) : undefined,
-        signal: localSignal,
-      });
-
-      if (timer) clearTimeout(timer);
-
-      if (!response.ok) throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
-      return response;
-    } catch (err) {
-      lastError = /** @type {Error} */ (err);
-      if (signal) break; // if an external signal came, it does not retry
-      if (attempt < retries)
-        await new Promise((resolve) => setTimeout(resolve, 300 * (attempt + 1)));
-    }
-  }
-
-  throw new Error(
-    `Failed to fetch JSON from "${url}"${lastError ? `: ${lastError.message}` : '.'}`,
-  );
-}
-
-/**
- * Loads and parses a JSON from a remote URL using Fetch API.
- *
- * @param {string} url - The full URL to fetch JSON from.
- * @param {Object} [options] - Optional settings.
- * @returns {Promise<any[] | Record<string | number | symbol, unknown>>} Parsed JSON object.
- * @throws {Error} Throws if fetch fails, times out, or returns invalid JSON.
- */
-async function fetchJson(url, options) {
-  return new Promise((resolve, reject) => {
-    fetchTemplate(url, options)
-      .then(async (res) => {
-        const contentType = res.headers.get('content-type') || '';
-        if (!contentType.includes('application/json'))
-          throw new Error(`Unexpected content-type: ${contentType}`);
-
-        const data = await res.json();
-
-        if (!Array.isArray(data) && !isJsonObject(data))
-          throw new Error('Received invalid data instead of valid JSON.');
-
-        return resolve(data);
-      })
-      .catch(reject);
-  });
-}
-
-/**
- * Loads a remote file as a Blob using Fetch API.
- *
- * @param {string} url - The full URL to fetch the file from.
- * @param {Object} [options] - Optional fetch options.
- * @param {string[]} [allowedMimeTypes] - Optional list of accepted MIME types (e.g., ['image/jpeg']).
- * @returns {Promise<Blob>} - The fetched file as a Blob.
- * @throws {Error} Throws if fetch fails, response is not ok, or MIME type is not allowed.
- */
-async function fetchBlob(url, allowedMimeTypes, options) {
-  return new Promise((resolve, reject) => {
-    fetchTemplate(url, options)
-      .then(async (res) => {
-        const contentType = res.headers.get('content-type') || '';
-
-        if (
-          Array.isArray(allowedMimeTypes) &&
-          allowedMimeTypes.length > 0 &&
-          !allowedMimeTypes.some((type) => contentType.includes(type))
-        ) {
-          throw new Error(`Blocked MIME type: ${contentType}`);
-        }
-
-        const data = await res.blob();
-        return resolve(data);
-      })
-      .catch(reject);
-  });
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * Installs a script that toggles CSS classes on a given element
- * based on the page's visibility or focus state, and optionally
- * triggers callbacks on visibility changes.
- *
- * @param {Object} [settings={}]
- * @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.
- * @returns {() => void} Function that removes all installed event listeners.
- * @throws {TypeError} If any provided setting is invalid.
- */
-function installWindowHiddenScript({
-  element = document.body,
-  hiddenClass = 'windowHidden',
-  visibleClass = 'windowVisible',
-  onVisible,
-  onHidden,
-} = {}) {
-  if (!(element instanceof Element))
-    throw new TypeError(`"element" must be an instance of Element.`);
-  if (typeof hiddenClass !== 'string') throw new TypeError(`"hiddenClass" must be a string.`);
-  if (typeof visibleClass !== 'string') throw new TypeError(`"visibleClass" must be a string.`);
-  if (onVisible !== undefined && typeof onVisible !== 'function')
-    throw new TypeError(`"onVisible" must be a function if provided.`);
-  if (onHidden !== undefined && typeof onHidden !== 'function')
-    throw new TypeError(`"onHidden" must be a function if provided.`);
-
-  const removeClass = () => {
-    element.classList.remove(hiddenClass);
-    element.classList.remove(visibleClass);
-  };
-
-  /** @type {string|null} */
-  let hiddenProp = null;
-
-  const visibilityEvents = [
-    'visibilitychange',
-    'mozvisibilitychange',
-    'webkitvisibilitychange',
-    'msvisibilitychange',
-  ];
-
-  const visibilityProps = ['hidden', 'mozHidden', 'webkitHidden', 'msHidden'];
-
-  for (let i = 0; i < visibilityProps.length; i++) {
-    if (visibilityProps[i] in document) {
-      hiddenProp = visibilityProps[i];
-      break;
-    }
-  }
-
-  /** @type {(this: any, evt: Event) => void} */
-  const handler = function (evt) {
-    removeClass();
-
-    const type = evt?.type;
-    // @ts-ignore
-    const isHidden = hiddenProp && document[hiddenProp];
-
-    const visibleEvents = ['focus', 'focusin', 'pageshow'];
-    const hiddenEvents = ['blur', 'focusout', 'pagehide'];
-
-    if (visibleEvents.includes(type)) {
-      element.classList.add(visibleClass);
-      onVisible?.();
-    } else if (hiddenEvents.includes(type)) {
-      element.classList.add(hiddenClass);
-      onHidden?.();
-    } else {
-      if (isHidden) {
-        element.classList.add(hiddenClass);
-        onHidden?.();
-      } else {
-        element.classList.add(visibleClass);
-        onVisible?.();
-      }
-    }
-  };
-
-  /** @type {() => void} */
-  let uninstall = () => {};
-
-  if (hiddenProp) {
-    const eventType = visibilityEvents[visibilityProps.indexOf(hiddenProp)];
-    document.addEventListener(eventType, handler);
-    window.addEventListener('focus', handler);
-    window.addEventListener('blur', handler);
-
-    uninstall = () => {
-      document.removeEventListener(eventType, handler);
-      window.removeEventListener('focus', handler);
-      window.removeEventListener('blur', handler);
-      removeClass();
-    };
-  } else if ('onfocusin' in document) {
-    // Fallback for IE9 and older
-    // @ts-ignore
-    document.onfocusin = document.onfocusout = handler;
-    uninstall = () => {
-      // @ts-ignore
-      document.onfocusin = document.onfocusout = null;
-      removeClass();
-    };
-  } else {
-    // Last resort fallback
-    window.onpageshow = window.onpagehide = window.onfocus = window.onblur = handler;
-    uninstall = () => {
-      window.onpageshow = window.onpagehide = window.onfocus = window.onblur = null;
-      removeClass();
-    };
-  }
-
-  // Trigger initial state
-  // @ts-ignore
-  const simulatedEvent = new Event(hiddenProp && document[hiddenProp] ? 'blur' : 'focus');
-  handler(simulatedEvent);
-
-  return uninstall;
-}
-
 ;// ./src/v1/basics/collision.mjs
 /**
  * A direction relative to a rectangle.
@@ -9455,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
@@ -9865,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
 
 
@@ -10223,7 +9811,7 @@ class TinyDragger {
     if (
       options.vibration !== undefined &&
       options.vibration !== false &&
-      !objFilter_isJsonObject(options.vibration)
+      !isJsonObject(options.vibration)
     )
       throw new Error('The "vibration" option must be an object or false.');
 
@@ -10267,7 +9855,7 @@ class TinyDragger {
     const vibrationTemplate = { start: false, end: false, collide: false, move: false };
     this.#vibration = Object.assign(
       vibrationTemplate,
-      objFilter_isJsonObject(options.vibration) ? options.vibration : {},
+      isJsonObject(options.vibration) ? options.vibration : {},
     );
 
     if (typeof options.classDragging === 'string') this.#classDragging = options.classDragging;
@@ -11106,574 +10694,1092 @@ class TinyDragger {
 
 /* harmony default export */ const libs_TinyDragger = ((/* unused pure expression or super */ null && (TinyDragger)));
 
-;// ./src/v1/libs/TinySmartScroller.mjs
-
-
-
-/**
- * Represents the dimensions of a DOM element.
- *
- * @typedef {Object} NodeSizes
- * @property {number} height - The height of the element in pixels.
- * @property {number} width - The width of the element in pixels.
- */
-
+;// ./src/v1/libs/TinyEvents.mjs
 /**
- * A callback function that receives node size change data and optionally returns a modified NodeSizes object.
- *
- * @callback NodeSizesEvent
- * @param {Element} elem - The DOM element whose size is being tracked.
- * @param {{ old: NodeSizes, now: NodeSizes }} sizes - The old and new size measurements of the element.
- * @param {{ old: number, now: number }} elemAmount - The number of matching elements before and after the update.
- * @returns {NodeSizes|undefined} A modified NodeSizes object to override the default measurement, or undefined to use the original.
- */
-
-/**
- * A generic scroll-related event listener callback function.
+ * A generic event listener callback function.
  *
- * @callback ScrollListenersFunc
- * @param {any} payload - The data payload passed when the scroll event is triggered. The type may vary depending on the event.
+ * @callback handler
+ * @param {...any} payload - The data payload passed when the event is triggered.
  * @returns {void}
  */
 
 /**
- * TinySmartScroller is a utility class designed to enhance and manage scroll behaviors within containers or the window.
+ * 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.
  *
- * It enables advanced scroll monitoring, auto-scrolling to bottom, preserving scroll position during DOM changes,
- * and detecting visibility changes of elements. This is particularly useful for dynamic UIs like chat applications,
- * feed viewers, or live content containers.
+ * 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`)
  *
- * Features:
- * - Detects when the scroll reaches the top, bottom, or custom boundaries
- * - Supports automatic scrolling to the bottom unless the user scrolls away
- * - Observes DOM mutations and resizes, and adapts scroll position accordingly
- * - Emits scroll-related events such as 'onScrollBoundary', 'onAutoScroll', and 'onScrollPause'
- * - Includes customizable scroll correction filters for layout shift mitigation
- * - Handles media element load events (e.g. `<img>`, `<iframe>`, `<video>`) to prevent sudden scroll jumps
+ * This class is useful for lightweight, dependency-free publish/subscribe event handling
+ * within modular JavaScript applications.
  *
- * This class is **not framework-dependent** and works with vanilla DOM elements and the window object.
+ * @class
  */
-class TinySmartScroller {
-  static Utils = { ...collision_namespaceObject, TinyHtml: libs_TinyHtml };
+class TinyEvents {
+  /** @type {Map<string, { handler: handler; config: { once: boolean } }[]>} */
+  #listeners = new Map();
 
-  /** @type {WeakMap<Element, NodeSizes>} */
-  #oldSizes = new WeakMap();
-  /** @type {WeakMap<Element, NodeSizes>} */
-  #newSizes = new WeakMap();
+  /** @type {number} */
+  #maxListeners = 10;
 
-  /** @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']);
-
-  /** @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();
+  /** @type {boolean} */
+  #throwMaxListeners = false;
 
   /**
-   * Creates a new instance of TinySmartScroller, attaching scroll and resize observers to manage
-   * automatic scroll behaviors, layout shift correction, and visibility tracking.
+   * Enables or disables throwing an error when the maximum number of listeners is exceeded.
    *
-   * @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.
-   * @param {string[]|Set<string>|null} [options.attributeFilter=['class', 'style', 'src', 'data-*', 'height', 'width']]
-   *     - Which attributes to observe for changes.
+   * @param {boolean} shouldThrow - If true, an error will be thrown when the max is exceeded.
    */
-  constructor(
-    target,
-    {
-      extraScrollBoundary = 0,
-      autoScrollBottom = true,
-      observeMutations = true,
-      preserveScrollOnLayoutShift = true,
-      debounceTime = 100,
-      querySelector = null,
-      attributeFilter = ['class', 'style', 'src', 'data-*', 'height', 'width'],
-    } = {},
-  ) {
-    // === target ===
-    if (!(target instanceof Element || target === window))
-      throw new TypeError(
-        `TinySmartScroller: 'target' must be a DOM Element or 'window', but got ${typeof target}`,
-      );
-    // === extraScrollBoundary ===
-    if (typeof extraScrollBoundary !== 'number' || Number.isNaN(extraScrollBoundary))
-      throw new TypeError(
-        `TinySmartScroller: 'extraScrollBoundary' must be a valid number, received ${extraScrollBoundary}`,
-      );
-    // === autoScrollBottom ===
-    if (typeof autoScrollBottom !== 'boolean')
-      throw new TypeError(
-        `TinySmartScroller: 'autoScrollBottom' must be a boolean, received ${typeof autoScrollBottom}`,
-      );
-    // === observeMutations ===
-    if (typeof observeMutations !== 'boolean')
-      throw new TypeError(
-        `TinySmartScroller: 'observeMutations' must be a boolean, received ${typeof observeMutations}`,
-      );
-    // === preserveScrollOnLayoutShift ===
-    if (typeof preserveScrollOnLayoutShift !== 'boolean')
-      throw new TypeError(
-        `TinySmartScroller: 'preserveScrollOnLayoutShift' must be a boolean, received ${typeof preserveScrollOnLayoutShift}`,
-      );
-    // === debounceTime ===
-    if (typeof debounceTime !== 'number' || debounceTime < 0 || Number.isNaN(debounceTime))
-      throw new TypeError(
-        `TinySmartScroller: 'debounceTime' must be a non-negative number, received ${debounceTime}`,
-      );
-    // === querySelector ===
-    if (querySelector !== null && typeof querySelector !== 'string')
-      throw new TypeError(
-        `TinySmartScroller: 'querySelector' must be a string or null, received ${typeof querySelector}`,
-      );
-    // === attributeFilter ===
-    const isValidAttrList =
-      attributeFilter === null || Array.isArray(attributeFilter) || attributeFilter instanceof Set;
-    if (!isValidAttrList)
-      throw new TypeError(
-        `TinySmartScroller: 'attributeFilter' must be an array, Set, or null. Got ${typeof attributeFilter}`,
-      );
-
-    // Start values
-    this.#target = target instanceof Window ? document.documentElement : target;
-    this.#useWindow = target instanceof Window;
-    this.#autoScrollBottom = autoScrollBottom;
-    this.#observeMutations = observeMutations;
-    this.#preserveScrollOnLayoutShift = preserveScrollOnLayoutShift;
-    this.#debounceTime = debounceTime;
-    this.#extraScrollBoundary = extraScrollBoundary;
-    this.#querySelector = querySelector || '';
-    this.#attributeFilter = new Set(attributeFilter || undefined);
-
-    // Bind scroll
-    /** @type {NodeJS.Timeout} */
-    let timeout;
-    this.#handler = () => {
-      this._scrollDataUpdater();
-      clearTimeout(timeout);
-      timeout = setTimeout(() => this._onScroll(), this.#debounceTime);
-    };
-    (this.#useWindow ? window : this.#target).addEventListener('scroll', this.#handler, {
-      passive: true,
-    });
-
-    // Mutations
-    if (this.#observeMutations) {
-      this._observeMutations();
-      this._observeResizes(this.#target.children);
-    }
-
-    this._scrollDataUpdater();
+  setThrowOnMaxListeners(shouldThrow) {
+    if (typeof shouldThrow !== 'boolean')
+      throw new TypeError('setThrowOnMaxListeners(value): value must be a boolean');
+    this.#throwMaxListeners = shouldThrow;
   }
 
   /**
-   * Returns a size difference callback that only reacts when height changes, filtered by tag name.
+   * Checks whether an error will be thrown when the max listener limit is exceeded.
    *
-   * @param {string[]} filter - List of tag names to allow. If empty, all tags are accepted.
-   * @returns {NodeSizesEvent} A function that compares previous and current height, returning height delta.
+   * @returns {boolean} True if an error will be thrown, false if only a warning is shown.
    */
-  getSimpleOnHeight(filter = []) {
-    if (!Array.isArray(filter))
-      throw new TypeError('getSimpleOnHeight(filter): filter must be an array of tag names');
-    return (elem, sizes, amounts) => {
-      if ((filter.length > 0 && !filter.includes(elem.tagName)) || amounts.now !== amounts.old)
-        return;
-      const oldSize = sizes.old;
-      const newSize = sizes.now;
-      const height = newSize.height - oldSize.height;
-      return { height, width: 0 };
-    };
+  getThrowOnMaxListeners() {
+    return this.#throwMaxListeners;
   }
 
-  /**
-   * Adds a height difference callback to the size filter system.
-   *
-   * @param {string[]} filter - List of tag names to allow.
-   * @returns {NodeSizesEvent} The added size difference callback.
-   */
-  addSimpleOnHeight(filter) {
-    if (!Array.isArray(filter))
-      throw new TypeError('addSimpleOnHeight(filter): filter must be an array of tag names');
-    const result = this.getSimpleOnHeight(filter);
-    this.onSize(result);
-    return result;
-  }
+  ///////////////////////////////////////////////////
 
   /**
-   * Returns a list of all currently tracked load tags.
+   * Internal method to prepend a listener with options.
    *
-   * @returns {string[]} Array of tag names.
+   * @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.
    */
-  getLoadTags() {
-    return Array.from(this.#loadTags);
+  #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 new tag to the set of load tags.
+   * Adds a listener to the beginning of the listeners array for the specified event.
    *
-   * @param {string} tag - The tag name to add (e.g., 'IMG').
+   * @param {string} event - Event name.
+   * @param {handler} handler - The callback function.
    */
-  addLoadTag(tag) {
-    if (typeof tag !== 'string') throw new TypeError('addLoadTag(tag): tag must be a string');
-    this.#loadTags.add(tag.toUpperCase());
+  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);
   }
 
   /**
-   * Removes a tag from the set of load tags.
+   * Adds a one-time listener to the beginning of the listeners array for the specified event.
    *
-   * @param {string} tag - The tag name to remove.
+   * @param {string} event - Event name.
+   * @param {handler} handler - The callback function.
+   * @returns {handler} - The wrapped handler used internally.
    */
-  removeLoadTag(tag) {
-    if (typeof tag !== 'string') throw new TypeError('removeLoadTag(tag): tag must be a string');
-    this.#loadTags.delete(tag.toUpperCase());
+  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;
   }
 
+  ////////////////////////////////////////////////////////////
+
   /**
-   * Checks whether a tag is tracked as a load tag.
+   * Adds a event listener.
    *
-   * @param {string} tag - The tag name to check.
-   * @returns {boolean} True if the tag is being tracked.
+   * @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.
    */
-  hasLoadTag(tag) {
-    if (typeof tag !== 'string') throw new TypeError('hasLoadTag(tag): tag must be a string');
-    return this.#loadTags.has(tag.toUpperCase());
+  #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);
+    }
   }
 
   /**
-   * Clears the set of load tags. If `addDefault` is true, it will reset to the default tags: 'IMG', 'IFRAME', and 'VIDEO'.
+   * Adds a event listener.
    *
-   * @param {boolean} [addDefault=false] - Whether to restore the default tags after clearing.
-   * @throws {TypeError} If `addDefault` is not a boolean.
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - Callback function to be called when event fires.
    */
-  resetLoadTags(addDefault = false) {
-    if (typeof addDefault !== 'boolean')
-      throw new TypeError('resetLoadTags(addDefault): addDefault must be a boolean');
-    this.#loadTags.clear();
-    if (!addDefault) return;
-    this.#loadTags.add('IMG');
-    this.#loadTags.add('IFRAME');
-    this.#loadTags.add('VIDEO');
+  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);
   }
 
   /**
-   * Returns a list of all currently tracked attribute filters.
+   * Registers an event listener that runs only once, then is removed.
    *
-   * @returns {string[]} Array of attribute names.
+   * @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.
    */
-  getAttributeFilters() {
-    return Array.from(this.#attributeFilter);
+  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 an attribute to the filter list.
+   * Adds a event listener.
    *
-   * @param {string} attr - The attribute name to add.
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {handler} handler - Callback function to be called when event fires.
    */
-  addAttributeFilter(attr) {
-    if (typeof attr !== 'string')
-      throw new TypeError('addAttributeFilter(attr): attr must be a string');
-    this.#attributeFilter.add(attr);
+  appendListener(event, handler) {
+    return this.on(event, handler);
   }
 
   /**
-   * Removes an attribute from the filter list.
+   * Registers an event listener that runs only once, then is removed.
    *
-   * @param {string} attr - The attribute name to remove.
+   * @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.
    */
-  removeAttributeFilter(attr) {
-    if (typeof attr !== 'string')
-      throw new TypeError('removeAttributeFilter(attr): attr must be a string');
-    this.#attributeFilter.delete(attr);
+  appendListenerOnce(event, handler) {
+    return this.once(event, handler);
   }
 
+  ///////////////////////////////////////////////
+
   /**
-   * Checks whether a specific attribute is being filtered.
+   * Removes a previously registered event listener.
    *
-   * @param {string} attr - The attribute name to check.
-   * @returns {boolean} True if the attribute is being filtered.
+   * @param {string} event - The name of the event to remove the handler from.
+   * @param {handler} handler - The specific callback function to remove.
    */
-  hasAttributeFilter(attr) {
-    if (typeof attr !== 'string')
-      throw new TypeError('hasAttributeFilter(attr): attr must be a string');
-    return this.#attributeFilter.has(attr);
+  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);
   }
 
   /**
-   * Clears the set of observed attribute filters. If `addDefault` is true, it will reset to the default attributes:
-   * 'class', 'style', 'src', 'data-*', 'height', and 'width'.
+   * Removes all event listeners of a specific type from the element.
    *
-   * @param {boolean} [addDefault=false] - Whether to restore the default attribute filters after clearing.
-   * @throws {TypeError} If `addDefault` is not a boolean.
+   * @param {string} event - The event type to remove (e.g. 'onScrollBoundary').
    */
-  resetAttributeFilters(addDefault = false) {
-    if (typeof addDefault !== 'boolean')
-      throw new TypeError('resetAttributeFilters(addDefault): addDefault must be a boolean');
-    this.#attributeFilter.clear();
-    if (!addDefault) return;
-    ['class', 'style', 'src', 'data-*', 'height', 'width'].forEach((attr) =>
-      this.#attributeFilter.add(attr),
-    );
+  offAll(event) {
+    if (typeof event !== 'string') throw new TypeError('The event name must be a string.');
+    this.#listeners.delete(event);
   }
 
   /**
-   * Registers a custom node size change handler to the internal size filter set.
-   *
-   * @param {NodeSizesEvent} handler - Function that compares old and new sizes.
+   * Removes all event listeners of all types from the element.
    */
-  onSize(handler) {
-    if (this.#destroyed) return;
-    if (typeof handler !== 'function')
-      throw new TypeError('onSize(handler): handler must be a function');
-    this.#sizeFilter.add(handler);
+  offAllTypes() {
+    this.#listeners.clear();
   }
 
+  /////////////////////////////////////////////
+
   /**
-   * Unregisters a previously registered size handler from the internal filter set.
+   * Returns the number of listeners for a given event.
    *
-   * @param {NodeSizesEvent} handler - The handler function to remove.
+   * @param {string} event - The name of the event.
+   * @returns {number} Number of listeners for the event.
    */
-  offSize(handler) {
-    if (this.#destroyed) return;
-    if (typeof handler !== 'function')
-      throw new TypeError('offSize(handler): handler must be a function');
-    this.#sizeFilter.delete(handler);
+  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;
   }
 
   /**
-   * Adds a scroll-related event listener.
+   * Returns a copy of the array of listeners for the specified event.
    *
-   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
-   * @param {ScrollListenersFunc} handler - Callback function to be called when event fires.
+   * @param {string} event - The name of the event.
+   * @returns {handler[]} Array of listener functions.
    */
-  on(event, handler) {
-    if (this.#destroyed) return;
+  listeners(event) {
     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');
+      throw new TypeError('listeners(event): event name must be a string');
 
-    if (!this.#scrollListeners[event]) this.#scrollListeners[event] = [];
-    this.#scrollListeners[event].push(handler);
+    const listeners = this.#listeners.get(event);
+    return Array.isArray(listeners)
+      ? [...listeners]
+          .filter((listener) => !listener.config.once)
+          .map((listener) => listener.handler)
+      : [];
   }
 
   /**
-   * Removes a previously registered scroll-related event listener.
+   * Returns a copy of the array of listeners for the specified event.
    *
-   * @param {string} event - The name of the event to remove the handler from.
-   * @param {ScrollListenersFunc} handler - The specific callback function to remove.
+   * @param {string} event - The name of the event.
+   * @returns {handler[]} Array of listener functions.
    */
-  off(event, handler) {
-    if (this.#destroyed) return;
+  onceListeners(event) {
     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');
+      throw new TypeError('onceListeners(event): event name must be a string');
 
-    const listeners = this.#scrollListeners[event];
-    if (!Array.isArray(listeners)) return;
+    const listeners = this.#listeners.get(event);
+    return Array.isArray(listeners)
+      ? [...listeners]
+          .filter((listener) => listener.config.once)
+          .map((listener) => listener.handler)
+      : [];
+  }
 
-    const index = listeners.indexOf(handler);
-    if (index !== -1) listeners.splice(index, 1);
+  /**
+   * 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) : [];
+  }
 
-    // Optionally clean up empty arrays (optional)
-    if (listeners.length === 0) delete this.#scrollListeners[event];
+  /**
+   * Returns an array of event names for which there are registered listeners.
+   *
+   * @returns {string[]} Array of registered event names.
+   */
+  eventNames() {
+    return [...this.#listeners.keys()];
   }
 
   /**
-   * Checks which elements inside the target are currently visible and updates internal maps.
+   * Emits an event, triggering all registered handlers for that event.
    *
-   * @returns {Map<Element, { oldIsVisible: boolean; isVisible: boolean }>} Visibility comparison results.
+   * @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.
    */
-  _scrollDataUpdater() {
-    const results = new Map();
-    this.#target.querySelectorAll(this.#querySelector || '*').forEach((target) => {
-      const oldIsVisible = this.#newVisibles.get(target) ?? false;
-      this.#oldVisibles.set(target, oldIsVisible);
+  emit(event, ...payload) {
+    if (typeof event !== 'string')
+      throw new TypeError('emit(event, data): event name must be a string');
 
-      const isVisible = libs_TinyHtml.isInContainer(this.#target, target);
-      this.#newVisibles.set(target, isVisible);
+    const listeners = this.#listeners.get(event);
+    if (!Array.isArray(listeners) || listeners.length === 0) return false;
 
-      results.set(target, { oldIsVisible, isVisible });
-    });
-    return results;
+    // Call all listeners with the provided data
+    listeners.forEach((listener) => listener.handler(...payload));
+    return true;
   }
 
+  ///////////////////////////////////
+
   /**
-   * Emits a scroll-related event to all registered listeners.
+   * Sets the maximum number of listeners per event before a warning is shown.
    *
-   * @param {string} event - Event name.
-   * @param {*} [payload] - Optional event data payload.
+   * @param {number} n - The maximum number of listeners.
    */
-  _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));
+  setMaxListeners(n) {
+    if (!Number.isInteger(n) || n < 0)
+      throw new TypeError('setMaxListeners(n): n must be a non-negative integer');
+    this.#maxListeners = n;
   }
 
   /**
-   * Handles scroll events, calculates position-related statuses, and emits appropriate events.
+   * Gets the maximum number of listeners allowed per event.
+   *
+   * @returns {number} The maximum number of listeners.
    */
-  _onScroll() {
-    if (this.#destroyed) return;
-    // Get values
-    const scrollCache = this._scrollDataUpdater();
-    const el = this.#target;
-    const scrollTop = el.scrollTop;
-    const scrollHeight = el.scrollHeight;
-    const clientHeight = el.clientHeight;
+  getMaxListeners() {
+    return this.#maxListeners;
+  }
+}
 
-    // Prepare sroll values
-    const scrollResult = { scrollTop, scrollHeight, clientHeight };
-    let atResult = null;
-    let atCustomResult = null;
+/* harmony default export */ const libs_TinyEvents = (TinyEvents);
 
-    const atTop = scrollTop === 0;
-    const atBottom = scrollTop + clientHeight >= scrollHeight - 1;
+;// ./src/v1/libs/TinySmartScroller.mjs
 
-    const atCustomTop = scrollTop <= 0 + this.#extraScrollBoundary;
-    const atCustomBottom = scrollTop + clientHeight >= scrollHeight - 1 - this.#extraScrollBoundary;
 
-    // Scroll results
-    if (atTop && atBottom) atResult = 'all';
-    else if (atTop) atResult = 'top';
-    else if (atBottom) atResult = 'bottom';
 
-    if (atCustomTop && atCustomBottom) atCustomResult = 'all';
-    else if (atCustomTop) atCustomResult = 'top';
-    else if (atCustomBottom) atCustomResult = 'bottom';
 
-    this.#isAtTop = atTop;
-    this.#isAtBottom = atBottom;
+/**
+ * Represents the dimensions of a DOM element.
+ *
+ * @typedef {Object} NodeSizes
+ * @property {number} height - The height of the element in pixels.
+ * @property {number} width - The width of the element in pixels.
+ */
 
-    this.#isAtCustomTop = atCustomTop;
-    this.#isAtCustomBottom = atCustomBottom;
+/**
+ * A callback function that receives node size change data and optionally returns a modified NodeSizes object.
+ *
+ * @callback NodeSizesEvent
+ * @param {Element} elem - The DOM element whose size is being tracked.
+ * @param {{ old: NodeSizes, now: NodeSizes }} sizes - The old and new size measurements of the element.
+ * @param {{ old: number, now: number }} elemAmount - The number of matching elements before and after the update.
+ * @returns {NodeSizes|undefined} A modified NodeSizes object to override the default measurement, or undefined to use the original.
+ */
 
-    this.#scrollPaused = !(this.#autoScrollBottom && this.#isAtBottom);
+/**
+ * A generic scroll-related event listener callback function.
+ *
+ * @callback ScrollListenersFunc
+ * @param {any} payload - The data payload passed when the scroll event is triggered. The type may vary depending on the event.
+ * @returns {void}
+ */
 
-    this.#lastKnownScrollBottomOffset = scrollHeight - scrollTop - clientHeight;
+/**
+ * TinySmartScroller is a utility class designed to enhance and manage scroll behaviors within containers or the window.
+ *
+ * It enables advanced scroll monitoring, auto-scrolling to bottom, preserving scroll position during DOM changes,
+ * and detecting visibility changes of elements. This is particularly useful for dynamic UIs like chat applications,
+ * feed viewers, or live content containers.
+ *
+ * Features:
+ * - Detects when the scroll reaches the top, bottom, or custom boundaries
+ * - Supports automatic scrolling to the bottom unless the user scrolls away
+ * - Observes DOM mutations and resizes, and adapts scroll position accordingly
+ * - Emits scroll-related events such as 'onScrollBoundary', 'onAutoScroll', and 'onScrollPause'
+ * - Includes customizable scroll correction filters for layout shift mitigation
+ * - Handles media element load events (e.g. `<img>`, `<iframe>`, `<video>`) to prevent sudden scroll jumps
+ *
+ * This class is **not framework-dependent** and works with vanilla DOM elements and the window object.
+ */
+class TinySmartScroller {
+  static Utils = { ...collision_namespaceObject, TinyHtml: libs_TinyHtml };
 
-    // Send results
-    this._emit('onScrollBoundary', { status: atResult, ...scrollResult, scrollCache });
-    this._emit('onExtraScrollBoundary', { status: atCustomResult, ...scrollResult, scrollCache });
+  #events = new libs_TinyEvents();
 
-    if (!this.#scrollPaused) {
-      this._emit('onAutoScroll', { ...scrollResult, scrollCache });
-    } else {
-      this._emit('onScrollPause', { ...scrollResult, scrollCache });
-    }
+  /**
+   * 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);
   }
 
   /**
-   * Attempts to correct the scroll position when layout shifts happen, preserving the user position if needed.
+   * Checks whether an error will be thrown when the max listener limit is exceeded.
    *
-   * @param {Element[]} [targets=[]] - List of elements involved in the size change.
+   * @returns {boolean} True if an error will be thrown, false if only a warning is shown.
    */
-  _fixScroll(targets = []) {
-    if (this.#destroyed) return;
-    // === Validation ===
-    if (!Array.isArray(targets))
-      throw new TypeError('_fixScroll: targets must be an array of Elements');
-
-    // Get Scroll data
-    const prevScrollHeight = this.#target.scrollHeight;
-    const prevScrollTop = this.#target.scrollTop;
-    const prevBottomOffset =
-      this.#target.scrollHeight - this.#target.scrollTop - this.#target.clientHeight;
+  getThrowOnMaxListeners() {
+    return this.#events.getThrowOnMaxListeners();
+  }
 
-    // Get new size
-    const newScrollHeight = this.#target.scrollHeight;
-    const heightDelta = newScrollHeight - prevScrollHeight;
+  /////////////////////////////////////////////////////////////
 
-    /** @type {() => NodeSizes} */
-    const calculateScrollSize = () => {
-      // Run size getter
-      const scrollSize = { height: 0, width: 0 };
-      for (const target of targets) {
-        const tgOs = this.#oldSizes.get(target) || { height: 0, width: 0 };
-        const tgNs = this.#newSizes.get(target) || { height: 0, width: 0 };
-        this.#sizeFilter.forEach((fn) => {
-          /** @type {NodeSizes| undefined} */
-          const sizes = fn(
-            target,
-            { old: tgOs, now: tgNs },
-            { old: this.#elemOldAmount, now: this.#elemAmount },
-          );
+  /**
+   * 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);
+  }
 
-          // Fix size
-          if (this.#newVisibles.get(target) || this.#newVisiblesByTime.get(target)) {
-            if (typeof sizes !== 'undefined' && typeof sizes !== 'object')
-              throw new Error('_fixScroll: size filter must return an object or undefined');
-            if (typeof sizes === 'undefined') return;
-            scrollSize.height = sizes.height;
-            scrollSize.width = sizes.width;
-          }
-        });
-      }
+  /**
+   * 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);
+  }
 
-      // Checker
-      if (typeof scrollSize.height !== 'number' && scrollSize.height < 0)
-        throw new Error('_fixScroll: invalid scrollSize.height value');
-      if (typeof scrollSize.width !== 'number' && scrollSize.width < 0)
-        throw new Error('_fixScroll: invalid scrollSize.width value');
+  //////////////////////////////////////////////////////////////////////
 
-      if (scrollSize.height !== 0 || scrollSize.width !== 0) {
-        for (const target of targets) {
-          this.#newVisiblesByTime.set(target, this.#newVisibles.get(target) ?? false);
-          this.#oldVisiblesByTime.set(target, this.#oldVisibles.get(target) ?? 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);
+  }
 
-      return scrollSize;
-    };
+  /**
+   * 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.
+   * @param {string[]|Set<string>|null} [options.attributeFilter=['class', 'style', 'src', 'data-*', 'height', 'width']]
+   *     - Which attributes to observe for changes.
+   */
+  constructor(
+    target,
+    {
+      extraScrollBoundary = 0,
+      autoScrollBottom = true,
+      observeMutations = true,
+      preserveScrollOnLayoutShift = true,
+      debounceTime = 100,
+      querySelector = null,
+      attributeFilter = ['class', 'style', 'src', 'data-*', 'height', 'width'],
+    } = {},
+  ) {
+    // === target ===
+    if (!(target instanceof Element || target === window))
+      throw new TypeError(
+        `TinySmartScroller: 'target' must be a DOM Element or 'window', but got ${typeof target}`,
+      );
+    // === extraScrollBoundary ===
+    if (typeof extraScrollBoundary !== 'number' || Number.isNaN(extraScrollBoundary))
+      throw new TypeError(
+        `TinySmartScroller: 'extraScrollBoundary' must be a valid number, received ${extraScrollBoundary}`,
+      );
+    // === autoScrollBottom ===
+    if (typeof autoScrollBottom !== 'boolean')
+      throw new TypeError(
+        `TinySmartScroller: 'autoScrollBottom' must be a boolean, received ${typeof autoScrollBottom}`,
+      );
+    // === observeMutations ===
+    if (typeof observeMutations !== 'boolean')
+      throw new TypeError(
+        `TinySmartScroller: 'observeMutations' must be a boolean, received ${typeof observeMutations}`,
+      );
+    // === preserveScrollOnLayoutShift ===
+    if (typeof preserveScrollOnLayoutShift !== 'boolean')
+      throw new TypeError(
+        `TinySmartScroller: 'preserveScrollOnLayoutShift' must be a boolean, received ${typeof preserveScrollOnLayoutShift}`,
+      );
+    // === debounceTime ===
+    if (typeof debounceTime !== 'number' || debounceTime < 0 || Number.isNaN(debounceTime))
+      throw new TypeError(
+        `TinySmartScroller: 'debounceTime' must be a non-negative number, received ${debounceTime}`,
+      );
+    // === querySelector ===
+    if (querySelector !== null && typeof querySelector !== 'string')
+      throw new TypeError(
+        `TinySmartScroller: 'querySelector' must be a string or null, received ${typeof querySelector}`,
+      );
+    // === attributeFilter ===
+    const isValidAttrList =
+      attributeFilter === null || Array.isArray(attributeFilter) || attributeFilter instanceof Set;
+    if (!isValidAttrList)
+      throw new TypeError(
+        `TinySmartScroller: 'attributeFilter' must be an array, Set, or null. Got ${typeof attributeFilter}`,
+      );
+
+    // Start values
+    this.#target = target instanceof Window ? document.documentElement : target;
+    this.#useWindow = target instanceof Window;
+    this.#autoScrollBottom = autoScrollBottom;
+    this.#observeMutations = observeMutations;
+    this.#preserveScrollOnLayoutShift = preserveScrollOnLayoutShift;
+    this.#debounceTime = debounceTime;
+    this.#extraScrollBoundary = extraScrollBoundary;
+    this.#querySelector = querySelector || '';
+    this.#attributeFilter = new Set(attributeFilter || undefined);
+
+    // Bind scroll
+    /** @type {NodeJS.Timeout} */
+    let timeout;
+    this.#handler = () => {
+      this._scrollDataUpdater();
+      clearTimeout(timeout);
+      timeout = setTimeout(() => this._onScroll(), this.#debounceTime);
+    };
+    (this.#useWindow ? window : this.#target).addEventListener('scroll', this.#handler, {
+      passive: true,
+    });
+
+    // Mutations
+    if (this.#observeMutations) {
+      this._observeMutations();
+      this._observeResizes(this.#target.children);
+    }
+
+    this._scrollDataUpdater();
+  }
+
+  /**
+   * Returns a size difference callback that only reacts when height changes, filtered by tag name.
+   *
+   * @param {string[]} filter - List of tag names to allow. If empty, all tags are accepted.
+   * @returns {NodeSizesEvent} A function that compares previous and current height, returning height delta.
+   */
+  getSimpleOnHeight(filter = []) {
+    if (!Array.isArray(filter))
+      throw new TypeError('getSimpleOnHeight(filter): filter must be an array of tag names');
+    return (elem, sizes, amounts) => {
+      if ((filter.length > 0 && !filter.includes(elem.tagName)) || amounts.now !== amounts.old)
+        return;
+      const oldSize = sizes.old;
+      const newSize = sizes.now;
+      const height = newSize.height - oldSize.height;
+      return { height, width: 0 };
+    };
+  }
+
+  /**
+   * Adds a height difference callback to the size filter system.
+   *
+   * @param {string[]} filter - List of tag names to allow.
+   * @returns {NodeSizesEvent} The added size difference callback.
+   */
+  addSimpleOnHeight(filter) {
+    if (!Array.isArray(filter))
+      throw new TypeError('addSimpleOnHeight(filter): filter must be an array of tag names');
+    const result = this.getSimpleOnHeight(filter);
+    this.onSize(result);
+    return result;
+  }
+
+  /**
+   * Returns a list of all currently tracked load tags.
+   *
+   * @returns {string[]} Array of tag names.
+   */
+  getLoadTags() {
+    return Array.from(this.#loadTags);
+  }
+
+  /**
+   * Adds a new tag to the set of load tags.
+   *
+   * @param {string} tag - The tag name to add (e.g., 'IMG').
+   */
+  addLoadTag(tag) {
+    if (typeof tag !== 'string') throw new TypeError('addLoadTag(tag): tag must be a string');
+    this.#loadTags.add(tag.toUpperCase());
+  }
+
+  /**
+   * Removes a tag from the set of load tags.
+   *
+   * @param {string} tag - The tag name to remove.
+   */
+  removeLoadTag(tag) {
+    if (typeof tag !== 'string') throw new TypeError('removeLoadTag(tag): tag must be a string');
+    this.#loadTags.delete(tag.toUpperCase());
+  }
+
+  /**
+   * Checks whether a tag is tracked as a load tag.
+   *
+   * @param {string} tag - The tag name to check.
+   * @returns {boolean} True if the tag is being tracked.
+   */
+  hasLoadTag(tag) {
+    if (typeof tag !== 'string') throw new TypeError('hasLoadTag(tag): tag must be a string');
+    return this.#loadTags.has(tag.toUpperCase());
+  }
+
+  /**
+   * Clears the set of load tags. If `addDefault` is true, it will reset to the default tags: 'IMG', 'IFRAME', and 'VIDEO'.
+   *
+   * @param {boolean} [addDefault=false] - Whether to restore the default tags after clearing.
+   * @throws {TypeError} If `addDefault` is not a boolean.
+   */
+  resetLoadTags(addDefault = false) {
+    if (typeof addDefault !== 'boolean')
+      throw new TypeError('resetLoadTags(addDefault): addDefault must be a boolean');
+    this.#loadTags.clear();
+    if (!addDefault) return;
+    this.#loadTags.add('IMG');
+    this.#loadTags.add('IFRAME');
+    this.#loadTags.add('VIDEO');
+  }
+
+  /**
+   * Returns a list of all currently tracked attribute filters.
+   *
+   * @returns {string[]} Array of attribute names.
+   */
+  getAttributeFilters() {
+    return Array.from(this.#attributeFilter);
+  }
+
+  /**
+   * Adds an attribute to the filter list.
+   *
+   * @param {string} attr - The attribute name to add.
+   */
+  addAttributeFilter(attr) {
+    if (typeof attr !== 'string')
+      throw new TypeError('addAttributeFilter(attr): attr must be a string');
+    this.#attributeFilter.add(attr);
+  }
+
+  /**
+   * Removes an attribute from the filter list.
+   *
+   * @param {string} attr - The attribute name to remove.
+   */
+  removeAttributeFilter(attr) {
+    if (typeof attr !== 'string')
+      throw new TypeError('removeAttributeFilter(attr): attr must be a string');
+    this.#attributeFilter.delete(attr);
+  }
+
+  /**
+   * Checks whether a specific attribute is being filtered.
+   *
+   * @param {string} attr - The attribute name to check.
+   * @returns {boolean} True if the attribute is being filtered.
+   */
+  hasAttributeFilter(attr) {
+    if (typeof attr !== 'string')
+      throw new TypeError('hasAttributeFilter(attr): attr must be a string');
+    return this.#attributeFilter.has(attr);
+  }
+
+  /**
+   * Clears the set of observed attribute filters. If `addDefault` is true, it will reset to the default attributes:
+   * 'class', 'style', 'src', 'data-*', 'height', and 'width'.
+   *
+   * @param {boolean} [addDefault=false] - Whether to restore the default attribute filters after clearing.
+   * @throws {TypeError} If `addDefault` is not a boolean.
+   */
+  resetAttributeFilters(addDefault = false) {
+    if (typeof addDefault !== 'boolean')
+      throw new TypeError('resetAttributeFilters(addDefault): addDefault must be a boolean');
+    this.#attributeFilter.clear();
+    if (!addDefault) return;
+    ['class', 'style', 'src', 'data-*', 'height', 'width'].forEach((attr) =>
+      this.#attributeFilter.add(attr),
+    );
+  }
+
+  /**
+   * Registers a custom node size change handler to the internal size filter set.
+   *
+   * @param {NodeSizesEvent} handler - Function that compares old and new sizes.
+   */
+  onSize(handler) {
+    if (this.#destroyed) return;
+    if (typeof handler !== 'function')
+      throw new TypeError('onSize(handler): handler must be a function');
+    this.#sizeFilter.add(handler);
+  }
+
+  /**
+   * Unregisters a previously registered size handler from the internal filter set.
+   *
+   * @param {NodeSizesEvent} handler - The handler function to remove.
+   */
+  offSize(handler) {
+    if (this.#destroyed) return;
+    if (typeof handler !== 'function')
+      throw new TypeError('offSize(handler): handler must be a function');
+    this.#sizeFilter.delete(handler);
+  }
+
+  /**
+   * Checks which elements inside the target are currently visible and updates internal maps.
+   *
+   * @returns {Map<Element, { oldIsVisible: boolean; isVisible: boolean }>} Visibility comparison results.
+   */
+  _scrollDataUpdater() {
+    const results = new Map();
+    this.#target.querySelectorAll(this.#querySelector || '*').forEach((target) => {
+      const oldIsVisible = this.#newVisibles.get(target) ?? false;
+      this.#oldVisibles.set(target, oldIsVisible);
+
+      const isVisible = libs_TinyHtml.isInContainer(this.#target, target);
+      this.#newVisibles.set(target, isVisible);
+
+      results.set(target, { oldIsVisible, isVisible });
+    });
+    return results;
+  }
+
+  /**
+   * Emits a scroll-related event to all registered listeners.
+   *
+   * @param {string} event - Event name.
+   * @param {*} [payload] - Optional event data payload.
+   * @deprecated - Use emit() instead.
+   */
+  _emit(event, payload) {
+    this.emit(event, payload);
+  }
+
+  /**
+   * Handles scroll events, calculates position-related statuses, and emits appropriate events.
+   */
+  _onScroll() {
+    if (this.#destroyed) return;
+    // Get values
+    const scrollCache = this._scrollDataUpdater();
+    const el = this.#target;
+    const scrollTop = el.scrollTop;
+    const scrollHeight = el.scrollHeight;
+    const clientHeight = el.clientHeight;
+
+    // Prepare sroll values
+    const scrollResult = { scrollTop, scrollHeight, clientHeight };
+    let atResult = null;
+    let atCustomResult = null;
+
+    const atTop = scrollTop === 0;
+    const atBottom = scrollTop + clientHeight >= scrollHeight - 1;
+
+    const atCustomTop = scrollTop <= 0 + this.#extraScrollBoundary;
+    const atCustomBottom = scrollTop + clientHeight >= scrollHeight - 1 - this.#extraScrollBoundary;
+
+    // Scroll results
+    if (atTop && atBottom) atResult = 'all';
+    else if (atTop) atResult = 'top';
+    else if (atBottom) atResult = 'bottom';
+
+    if (atCustomTop && atCustomBottom) atCustomResult = 'all';
+    else if (atCustomTop) atCustomResult = 'top';
+    else if (atCustomBottom) atCustomResult = 'bottom';
+
+    this.#isAtTop = atTop;
+    this.#isAtBottom = atBottom;
+
+    this.#isAtCustomTop = atCustomTop;
+    this.#isAtCustomBottom = atCustomBottom;
+
+    this.#scrollPaused = !(this.#autoScrollBottom && this.#isAtBottom);
+
+    this.#lastKnownScrollBottomOffset = scrollHeight - scrollTop - clientHeight;
+
+    // Send results
+    this.emit('onScrollBoundary', { status: atResult, ...scrollResult, scrollCache });
+    this.emit('onExtraScrollBoundary', { status: atCustomResult, ...scrollResult, scrollCache });
+
+    if (!this.#scrollPaused) {
+      this.emit('onAutoScroll', { ...scrollResult, scrollCache });
+    } else {
+      this.emit('onScrollPause', { ...scrollResult, scrollCache });
+    }
+  }
+
+  /**
+   * Attempts to correct the scroll position when layout shifts happen, preserving the user position if needed.
+   *
+   * @param {Element[]} [targets=[]] - List of elements involved in the size change.
+   */
+  _fixScroll(targets = []) {
+    if (this.#destroyed) return;
+    // === Validation ===
+    if (!Array.isArray(targets))
+      throw new TypeError('_fixScroll: targets must be an array of Elements');
+
+    // Get Scroll data
+    const prevScrollHeight = this.#target.scrollHeight;
+    const prevScrollTop = this.#target.scrollTop;
+    const prevBottomOffset =
+      this.#target.scrollHeight - this.#target.scrollTop - this.#target.clientHeight;
+
+    // Get new size
+    const newScrollHeight = this.#target.scrollHeight;
+    const heightDelta = newScrollHeight - prevScrollHeight;
+
+    /** @type {() => NodeSizes} */
+    const calculateScrollSize = () => {
+      // Run size getter
+      const scrollSize = { height: 0, width: 0 };
+      for (const target of targets) {
+        const tgOs = this.#oldSizes.get(target) || { height: 0, width: 0 };
+        const tgNs = this.#newSizes.get(target) || { height: 0, width: 0 };
+        this.#sizeFilter.forEach((fn) => {
+          /** @type {NodeSizes| undefined} */
+          const sizes = fn(
+            target,
+            { old: tgOs, now: tgNs },
+            { old: this.#elemOldAmount, now: this.#elemAmount },
+          );
+
+          // Fix size
+          if (this.#newVisibles.get(target) || this.#newVisiblesByTime.get(target)) {
+            if (typeof sizes !== 'undefined' && typeof sizes !== 'object')
+              throw new Error('_fixScroll: size filter must return an object or undefined');
+            if (typeof sizes === 'undefined') return;
+            scrollSize.height = sizes.height;
+            scrollSize.width = sizes.width;
+          }
+        });
+      }
+
+      // Checker
+      if (typeof scrollSize.height !== 'number' && scrollSize.height < 0)
+        throw new Error('_fixScroll: invalid scrollSize.height value');
+      if (typeof scrollSize.width !== 'number' && scrollSize.width < 0)
+        throw new Error('_fixScroll: invalid scrollSize.width value');
+
+      if (scrollSize.height !== 0 || scrollSize.width !== 0) {
+        for (const target of targets) {
+          this.#newVisiblesByTime.set(target, this.#newVisibles.get(target) ?? false);
+          this.#oldVisiblesByTime.set(target, this.#oldVisibles.get(target) ?? false);
+        }
+      }
+
+      return scrollSize;
+    };
 
     // Fix scroll size
     if (
@@ -11691,398 +11797,1250 @@ class TinySmartScroller {
         this.#target.scrollLeft = this.#target.scrollLeft + scrollSize.width;
     }
 
-    // Normal stuff
-    else if (!this.#scrollPaused && this.#autoScrollBottom) {
-      calculateScrollSize();
-      this.scrollToBottom();
-    } else if (!this.#autoScrollBottom && !this.#isAtBottom) {
-      calculateScrollSize();
-      this.#target.scrollTop =
-        this.#target.scrollHeight - this.#target.clientHeight - prevBottomOffset;
+    // Normal stuff
+    else if (!this.#scrollPaused && this.#autoScrollBottom) {
+      calculateScrollSize();
+      this.scrollToBottom();
+    } else if (!this.#autoScrollBottom && !this.#isAtBottom) {
+      calculateScrollSize();
+      this.#target.scrollTop =
+        this.#target.scrollHeight - this.#target.clientHeight - prevBottomOffset;
+    }
+  }
+  /**
+   * Sets up a MutationObserver to watch for DOM changes and react accordingly to maintain scroll consistency.
+   */
+  _observeMutations() {
+    this.#mutationObserver = new MutationObserver((mutations) => {
+      if (this.#destroyed) return;
+      this._scrollDataUpdater();
+      this.#elemOldAmount = this.#elemAmount;
+      this.#elemAmount = this.#target.childElementCount;
+
+      mutations.forEach((mutation) => {
+        mutation.addedNodes.forEach((node) => {
+          if (!(node instanceof Element) || node.nodeType !== 1) return;
+
+          this._observeResizes([node]);
+          this._listenLoadEvents(node);
+
+          if (this.#querySelector) {
+            const children = node.querySelectorAll(this.#querySelector);
+            this._observeResizes(children);
+            this._listenLoadEvents(children);
+          }
+        });
+      });
+
+      this._fixScroll();
+    });
+
+    // Install observer
+    this.#mutationObserver.observe(this.#target, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter:
+        this.#attributeFilter.size > 0 ? Array.from(this.#attributeFilter) : undefined,
+    });
+  }
+
+  /**
+   * Adds a ResizeObserver to monitor elements' size changes and trigger layout adjustments.
+   *
+   * @param {NodeListOf<Element>|Element[]|HTMLCollection} elements - Elements to observe.
+   */
+  _observeResizes(elements) {
+    // Add resize observer
+    if (!this.#resizeObserver) {
+      this.#resizeObserver = new ResizeObserver((entries) => {
+        if (this.#destroyed) return;
+        this._scrollDataUpdater();
+        /** @type {Element[]} */
+        const targets = [];
+        for (const entry of entries) {
+          // Target
+          const target = entry.target;
+
+          // Update old size
+          const oldSize = this.#newSizes.get(target);
+          if (oldSize) this.#oldSizes.set(target, oldSize);
+
+          // Set new size
+          const { width, height } = entry.contentRect;
+          this.#newSizes.set(target, { width, height });
+          targets.push(target);
+        }
+
+        // Animation frame
+        this._fixScroll(targets);
+      });
+    }
+
+    // Execute observer
+    Array.from(elements).forEach((el) => {
+      if (!this.#resizeObserver)
+        throw new Error('_observeResizes: ResizeObserver instance is not initialized');
+      this.#resizeObserver.observe(el);
+    });
+  }
+
+  /**
+   * Listens for media/content load events (e.g., images, iframes, videos) to trigger scroll updates.
+   *
+   * @param {NodeListOf<Element>|Element} elements - Target element(s) to listen on.
+   */
+  _listenLoadEvents(elements) {
+    if (this.#destroyed) return;
+    const list = elements instanceof NodeList ? Array.from(elements) : [elements];
+
+    list.forEach((el) => {
+      if (this.#loadTags.has(el.tagName)) {
+        // @ts-ignore
+        if (!el.complete) {
+          el.addEventListener('load', () => {
+            this._scrollDataUpdater();
+            if (!this.#scrollPaused && this.#autoScrollBottom) {
+              this.scrollToBottom();
+            }
+          });
+        }
+      }
+    });
+  }
+
+  /**
+   * Returns the internal scroll container element being monitored.
+   *
+   * @returns {Element} The DOM element used as the scroll container target.
+   */
+  get target() {
+    return this.#target;
+  }
+
+  /**
+   * Returns the previous size of a given element, or undefined if not tracked.
+   *
+   * @param {Element} el - The DOM element to query.
+   * @returns {NodeSizes|null} The old size, or undefined.
+   */
+  getOldSize(el) {
+    return this.#oldSizes.get(el) ?? null;
+  }
+
+  /**
+   * Returns the current size of a given element, or undefined if not tracked.
+   *
+   * @param {Element} el - The DOM element to query.
+   * @returns {NodeSizes|null} The new size, or undefined.
+   */
+  getNewSize(el) {
+    return this.#newSizes.get(el) ?? null;
+  }
+
+  /**
+   * Returns whether the given element was visible in the last scroll update.
+   *
+   * @param {Element} el - The DOM element to check.
+   * @returns {boolean} True if visible, false if not, or undefined if not tracked.
+   */
+  wasVisible(el) {
+    return this.#oldVisibles.get(el) ?? false;
+  }
+
+  /**
+   * Returns whether the given element is currently visible.
+   *
+   * @param {Element} el - The DOM element to check.
+   * @returns {boolean} True if visible, false if not, or undefined if not tracked.
+   */
+  isVisible(el) {
+    return this.#newVisibles.get(el) ?? false;
+  }
+
+  /**
+   * Returns whether the element was visible in the last time-based visibility check.
+   *
+   * @param {Element} el - The DOM element to check.
+   * @returns {boolean} Visibility state from the previous timed check.
+   */
+  wasTimedVisible(el) {
+    return this.#oldVisiblesByTime.get(el) ?? false;
+  }
+
+  /**
+   * Returns whether the element is currently visible in the time-based check.
+   *
+   * @param {Element} el - The DOM element to check.
+   * @returns {boolean} Visibility state from the current timed check.
+   */
+  isTimedVisible(el) {
+    return this.#newVisiblesByTime.get(el) ?? false;
+  }
+
+  /**
+   * Sets the extra scroll boundary margin used when determining if the user is at a "custom" bottom or top.
+   *
+   * @param {number} value - Pixels of additional margin to use.
+   */
+  setExtraScrollBoundary(value) {
+    if (typeof value !== 'number' || Number.isNaN(value))
+      throw new TypeError('setExtraScrollBoundary(value): value must be a valid number');
+    this.#extraScrollBoundary = value;
+  }
+
+  /**
+   * Returns the current extra scroll boundary setting.
+   *
+   * @returns {number}
+   */
+  getExtraScrollBoundary() {
+    return this.#extraScrollBoundary;
+  }
+
+  /**
+   * Returns the last known distance (in pixels) from the bottom of the scroll container.
+   *
+   * @returns {number}
+   */
+  getLastKnownScrollBottomOffset() {
+    return this.#lastKnownScrollBottomOffset;
+  }
+
+  /**
+   * Forces the scroll position to move to the very bottom of the target.
+   */
+  scrollToBottom() {
+    this.#target.scrollTop = this.#target.scrollHeight;
+  }
+
+  /**
+   * Forces the scroll position to move to the very top of the target.
+   */
+  scrollToTop() {
+    this.#target.scrollTop = 0;
+  }
+
+  /**
+   * Checks if the user is within the defined extra scroll boundary from the bottom.
+   *
+   * @returns {boolean}
+   */
+  isUserAtCustomBottom() {
+    return this.#isAtCustomBottom;
+  }
+
+  /**
+   * Checks if the user is within the defined extra scroll boundary from the top.
+   *
+   * @returns {boolean}
+   */
+  isUserAtCustomTop() {
+    return this.#isAtCustomTop;
+  }
+
+  /**
+   * Returns true if the user is currently scrolled to the bottom of the element.
+   *
+   * @returns {boolean}
+   */
+  isUserAtBottom() {
+    return this.#isAtBottom;
+  }
+
+  /**
+   * Returns true if the user is currently scrolled to the top of the element.
+   *
+   * @returns {boolean}
+   */
+  isUserAtTop() {
+    return this.#isAtTop;
+  }
+
+  /**
+   * Returns true if automatic scrolling is currently paused.
+   *
+   * @returns {boolean}
+   */
+  isScrollPaused() {
+    return this.#scrollPaused;
+  }
+
+  /**
+   * Returns whether the target is the window object.
+   *
+   * @returns {boolean} True if the scroll target is window, false otherwise.
+   */
+  isWindow() {
+    return this.#useWindow;
+  }
+
+  /**
+   * Returns whether the instance has been destroyed.
+   *
+   * @returns {boolean} True if the instance is destroyed, false otherwise.
+   */
+  isDestroyed() {
+    return this.#destroyed;
+  }
+
+  /**
+   * Returns whether auto-scroll-to-bottom is enabled.
+   *
+   * @returns {boolean} True if auto-scroll is active, false otherwise.
+   */
+  getAutoScrollBottom() {
+    return this.#autoScrollBottom;
+  }
+
+  /**
+   * Returns whether MutationObserver is enabled.
+   *
+   * @returns {boolean} True if mutation observation is active, false otherwise.
+   */
+  getObserveMutations() {
+    return this.#observeMutations;
+  }
+
+  /**
+   * Returns whether layout shift protection is enabled.
+   *
+   * @returns {boolean} True if scroll preservation is active, false otherwise.
+   */
+  getPreserveScrollOnLayoutShift() {
+    return this.#preserveScrollOnLayoutShift;
+  }
+
+  /**
+   * Returns the debounce delay in milliseconds used for scroll events.
+   *
+   * @returns {number} Debounce delay time.
+   */
+  getDebounceTime() {
+    return this.#debounceTime;
+  }
+
+  /**
+   * Returns the current number of matching elements observed inside the scroll target.
+   *
+   * @returns {number} Current count of matching elements.
+   */
+  getElemAmount() {
+    return this.#elemAmount;
+  }
+
+  /**
+   * Returns the previous known count of matching elements from the last update.
+   *
+   * @returns {number} Previous count of matching elements.
+   */
+  getPrevElemAmount() {
+    return this.#elemOldAmount;
+  }
+
+  /**
+   * Returns the query selector string used to filter observed elements.
+   *
+   * @returns {string} The CSS selector string, or an empty string if none was provided.
+   */
+  getQuerySelector() {
+    return this.#querySelector;
+  }
+
+  /**
+   * Disconnects all listeners, observers, and clears memory structures.
+   * Once destroyed, this instance should no longer be used.
+   */
+  destroy() {
+    if (this.#destroyed) return;
+    this.#destroyed = true;
+
+    // Disconnects MutationObserver
+    if (this.#mutationObserver) {
+      this.#mutationObserver.disconnect();
+      this.#mutationObserver = null;
+    }
+
+    // Disconnect ResizeObserver
+    if (this.#resizeObserver) {
+      this.#resizeObserver.disconnect();
+      this.#resizeObserver = null;
     }
+
+    // Removes scroll listener
+    const target = this.#useWindow ? window : this.#target;
+    if (this.#handler) target.removeEventListener('scroll', this.#handler);
+
+    // Clean the WeakMaps
+    this.#oldSizes = new WeakMap();
+    this.#newSizes = new WeakMap();
+    this.#newVisibles = new WeakMap();
+    this.#oldVisibles = new WeakMap();
+    this.#newVisiblesByTime = new WeakMap();
+    this.#oldVisiblesByTime = new WeakMap();
+
+    // Cleans listeners and filters
+    this.#events.offAllTypes();
+    this.#sizeFilter.clear();
+    this.#loadTags.clear();
   }
+}
+
+/* harmony default export */ const libs_TinySmartScroller = ((/* unused pure expression or super */ null && (TinySmartScroller)));
+
+;// ./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();
+
   /**
-   * Sets up a MutationObserver to watch for DOM changes and react accordingly to maintain scroll consistency.
+   * 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.
    */
-  _observeMutations() {
-    this.#mutationObserver = new MutationObserver((mutations) => {
-      if (this.#destroyed) return;
-      this._scrollDataUpdater();
-      this.#elemOldAmount = this.#elemAmount;
-      this.#elemAmount = this.#target.childElementCount;
+  setThrowOnMaxListeners(shouldThrow) {
+    return this.#events.setThrowOnMaxListeners(shouldThrow);
+  }
 
-      mutations.forEach((mutation) => {
-        mutation.addedNodes.forEach((node) => {
-          if (!(node instanceof Element) || node.nodeType !== 1) return;
+  /**
+   * 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();
+  }
 
-          this._observeResizes([node]);
-          this._listenLoadEvents(node);
+  /////////////////////////////////////////////////////////////
 
-          if (this.#querySelector) {
-            const children = node.querySelectorAll(this.#querySelector);
-            this._observeResizes(children);
-            this._listenLoadEvents(children);
-          }
-        });
-      });
+  /**
+   * 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);
+  }
 
-      this._fixScroll();
-    });
+  /**
+   * 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);
+  }
 
-    // Install observer
-    this.#mutationObserver.observe(this.#target, {
-      childList: true,
-      subtree: true,
-      attributes: true,
-      attributeFilter:
-        this.#attributeFilter.size > 0 ? Array.from(this.#attributeFilter) : undefined,
-    });
+  //////////////////////////////////////////////////////////////////////
+
+  /**
+   * 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);
   }
 
   /**
-   * Adds a ResizeObserver to monitor elements' size changes and trigger layout adjustments.
+   * Registers an event listener that runs only once, then is removed.
    *
-   * @param {NodeListOf<Element>|Element[]|HTMLCollection} elements - Elements to observe.
+   * @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.
    */
-  _observeResizes(elements) {
-    // Add resize observer
-    if (!this.#resizeObserver) {
-      this.#resizeObserver = new ResizeObserver((entries) => {
-        if (this.#destroyed) return;
-        this._scrollDataUpdater();
-        /** @type {Element[]} */
-        const targets = [];
-        for (const entry of entries) {
-          // Target
-          const target = entry.target;
+  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);
+  }
 
-          // Update old size
-          const oldSize = this.#newSizes.get(target);
-          if (oldSize) this.#oldSizes.set(target, oldSize);
+  /**
+   * 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);
+  }
 
-          // Set new size
-          const { width, height } = entry.contentRect;
-          this.#newSizes.set(target, { width, height });
-          targets.push(target);
-        }
+  //////////////////////////////////////////////////////
 
-        // Animation frame
-        this._fixScroll(targets);
-      });
+  /**
+   * 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);
+      }
     }
 
-    // Execute observer
-    Array.from(elements).forEach((el) => {
-      if (!this.#resizeObserver)
-        throw new Error('_observeResizes: ResizeObserver instance is not initialized');
-      this.#resizeObserver.observe(el);
-    });
+    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;
   }
 
   /**
-   * Listens for media/content load events (e.g., images, iframes, videos) to trigger scroll updates.
+   * Recursively deserializes a JSON-compatible value into its original structure.
    *
-   * @param {NodeListOf<Element>|Element} elements - Target element(s) to listen on.
+   * Automatically handles:
+   * - `__undefined__` → `undefined`
+   * - `__null__` → `null`
+   * - Any type registered via `registerJsonType`
+   *
+   * @type {decodeSpecialJson}
    */
-  _listenLoadEvents(elements) {
-    if (this.#destroyed) return;
-    const list = elements instanceof NodeList ? Array.from(elements) : [elements];
+  static decodeSpecialJson(value) {
+    const isJson = isJsonObject(value);
+    if (isJson) {
+      if (value.__undefined__) return undefined;
+      if (value.__null__) return null;
+    }
 
-    list.forEach((el) => {
-      if (this.#loadTags.has(el.tagName)) {
-        // @ts-ignore
-        if (!el.complete) {
-          el.addEventListener('load', () => {
-            this._scrollDataUpdater();
-            if (!this.#scrollPaused && this.#autoScrollBottom) {
-              this.scrollToBottom();
-            }
-          });
+    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);
+
   /**
-   * Returns the internal scroll container element being monitored.
+   * Initializes the TinyLocalStorage instance and sets up cross-tab sync.
    *
-   * @returns {Element} The DOM element used as the scroll container target.
+   * Adds listener for the native `storage` event to support tab synchronization.
    */
-  get target() {
-    return this.#target;
+  constructor() {
+    window.addEventListener('storage', this.#storageEvent);
   }
 
   /**
-   * Returns the previous size of a given element, or undefined if not tracked.
+   * Defines a custom storage interface (e.g. `sessionStorage`).
    *
-   * @param {Element} el - The DOM element to query.
-   * @returns {NodeSizes|null} The old size, or undefined.
+   * @param {Storage} localstorage - A valid Storage object (localStorage or sessionStorage).
    */
-  getOldSize(el) {
-    return this.#oldSizes.get(el) ?? null;
+  setLocalStorage(localstorage) {
+    if (!(localstorage instanceof Storage))
+      throw new Error('Argument must be a valid instance of Storage.');
+    this.#localStorage = localstorage;
   }
 
   /**
-   * Returns the current size of a given element, or undefined if not tracked.
+   * Checks if `localStorage` is supported by the current environment.
    *
-   * @param {Element} el - The DOM element to query.
-   * @returns {NodeSizes|null} The new size, or undefined.
+   * @returns {boolean} True if `localStorage` exists, false otherwise.
    */
-  getNewSize(el) {
-    return this.#newSizes.get(el) ?? null;
+  localStorageExists() {
+    return this.#localStorage instanceof Storage;
   }
 
   /**
-   * Returns whether the given element was visible in the last scroll update.
+   * Automatically serializes nested instances.
    *
-   * @param {Element} el - The DOM element to check.
-   * @returns {boolean} True if visible, false if not, or undefined if not tracked.
+   * @param {string} name - The key under which to store the data.
+   * @param {*} data - The data to be serialized.
+   * @returns {*}
    */
-  wasVisible(el) {
-    return this.#oldVisibles.get(el) ?? false;
+  #setJson(name, data) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    return TinyLocalStorage.encodeSpecialJson(data);
   }
 
   /**
-   * Returns whether the given element is currently visible.
+   * Stores a JSON-compatible value in `localStorage`.
    *
-   * @param {Element} el - The DOM element to check.
-   * @returns {boolean} True if visible, false if not, or undefined if not tracked.
+   * 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.
    */
-  isVisible(el) {
-    return this.#newVisibles.get(el) ?? false;
+  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));
   }
 
   /**
-   * Returns whether the element was visible in the last time-based visibility check.
+   * Retrieves a value from `localStorage`.
    *
-   * @param {Element} el - The DOM element to check.
-   * @returns {boolean} Visibility state from the previous timed check.
+   * 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.
    */
-  wasTimedVisible(el) {
-    return this.#oldVisiblesByTime.get(el) ?? false;
+  #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 };
   }
 
   /**
-   * Returns whether the element is currently visible in the time-based check.
+   * Retrieves and parses a JSON value from `localStorage`.
    *
-   * @param {Element} el - The DOM element to check.
-   * @returns {boolean} Visibility state from the current timed check.
+   * 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.
    */
-  isTimedVisible(el) {
-    return this.#newVisiblesByTime.get(el) ?? false;
+  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;
   }
 
   /**
-   * Sets the extra scroll boundary margin used when determining if the user is at a "custom" bottom or top.
-   *
-   * @param {number} value - Pixels of additional margin to use.
+   * Stores a Date in localStorage.
+   * @param {string} name
+   * @param {Date} data
    */
-  setExtraScrollBoundary(value) {
-    if (typeof value !== 'number' || Number.isNaN(value))
-      throw new TypeError('setExtraScrollBoundary(value): value must be a valid number');
-    this.#extraScrollBoundary = value;
+  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);
   }
 
   /**
-   * Returns the current extra scroll boundary setting.
-   *
-   * @returns {number}
+   * Retrieves a Date from localStorage.
+   * @param {string} name
+   * @returns {Date|null}
    */
-  getExtraScrollBoundary() {
-    return this.#extraScrollBoundary;
+  getDate(name) {
+    const value = this.#getJson(name).decoded;
+    return value instanceof Date ? value : null;
   }
 
   /**
-   * Returns the last known distance (in pixels) from the bottom of the scroll container.
-   *
-   * @returns {number}
+   * Stores a RegExp in localStorage.
+   * @param {string} name
+   * @param {RegExp} data
    */
-  getLastKnownScrollBottomOffset() {
-    return this.#lastKnownScrollBottomOffset;
+  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);
   }
 
   /**
-   * Forces the scroll position to move to the very bottom of the target.
+   * Retrieves a RegExp from localStorage.
+   * @param {string} name
+   * @returns {RegExp|null}
    */
-  scrollToBottom() {
-    this.#target.scrollTop = this.#target.scrollHeight;
+  getRegExp(name) {
+    const value = this.#getJson(name).decoded;
+    return value instanceof RegExp ? value : null;
   }
 
   /**
-   * Forces the scroll position to move to the very top of the target.
+   * Stores a BigInt in localStorage.
+   * @param {string} name
+   * @param {bigint} data
    */
-  scrollToTop() {
-    this.#target.scrollTop = 0;
+  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);
   }
 
   /**
-   * Checks if the user is within the defined extra scroll boundary from the bottom.
-   *
-   * @returns {boolean}
+   * Retrieves a BigInt from localStorage.
+   * @param {string} name
+   * @returns {bigint|null}
    */
-  isUserAtCustomBottom() {
-    return this.#isAtCustomBottom;
+  getBigInt(name) {
+    const value = this.#getJson(name).decoded;
+    return typeof value === 'bigint' ? value : null;
   }
 
   /**
-   * Checks if the user is within the defined extra scroll boundary from the top.
-   *
-   * @returns {boolean}
+   * Stores a Symbol in localStorage.
+   * Only global symbols (`Symbol.for`) will preserve the key.
+   * @param {string} name
+   * @param {symbol} data
    */
-  isUserAtCustomTop() {
-    return this.#isAtCustomTop;
+  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);
   }
 
   /**
-   * Returns true if the user is currently scrolled to the bottom of the element.
-   *
-   * @returns {boolean}
+   * Retrieves a Symbol from localStorage.
+   * @param {string} name
+   * @returns {symbol|null}
    */
-  isUserAtBottom() {
-    return this.#isAtBottom;
+  getSymbol(name) {
+    const value = this.#getJson(name).decoded;
+    return typeof value === 'symbol' ? value : null;
   }
 
   /**
-   * Returns true if the user is currently scrolled to the top of the element.
+   * Retrieves a value from `localStorage`.
    *
-   * @returns {boolean}
+   * @param {string} name - The key to retrieve.
+   * @returns {any} The stored value or null if not found.
    */
-  isUserAtTop() {
-    return this.#isAtTop;
+  getValue(name) {
+    return this.#getJson(name).decoded ?? null;
   }
 
   /**
-   * Returns true if automatic scrolling is currently paused.
+   * Stores a raw string value in `localStorage`.
    *
-   * @returns {boolean}
+   * @param {string} name - The key to use.
+   * @param {any} data - The data to store.
    */
-  isScrollPaused() {
-    return this.#scrollPaused;
+  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);
   }
 
   /**
-   * Returns whether the target is the window object.
+   * Retrieves a raw string value from `localStorage`.
    *
-   * @returns {boolean} True if the scroll target is window, false otherwise.
+   * @param {string} name - The key to retrieve.
+   * @returns {string|null} The stored value or null if not found.
    */
-  isWindow() {
-    return this.#useWindow;
+  getItem(name) {
+    if (typeof name !== 'string' || !name.length)
+      throw new Error('Key must be a non-empty string.');
+    return this.#localStorage.getItem(name);
   }
 
   /**
-   * Returns whether the instance has been destroyed.
+   * Stores a string in `localStorage`, ensuring the data is a valid string.
    *
-   * @returns {boolean} True if the instance is destroyed, false otherwise.
+   * @param {string} name - The key to store the string under.
+   * @param {string} data - The string to store.
    */
-  isDestroyed() {
-    return this.#destroyed;
+  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);
   }
 
   /**
-   * Returns whether auto-scroll-to-bottom is enabled.
+   * Retrieves a string value from `localStorage`.
    *
-   * @returns {boolean} True if auto-scroll is active, false otherwise.
+   * @param {string} name - The key to retrieve.
+   * @returns {string|null} The string if valid, or null.
    */
-  getAutoScrollBottom() {
-    return this.#autoScrollBottom;
+  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;
   }
 
   /**
-   * Returns whether MutationObserver is enabled.
+   * Stores a number value in `localStorage`.
    *
-   * @returns {boolean} True if mutation observation is active, false otherwise.
+   * @param {string} name - The key to use.
+   * @param {number} data - The number to store.
    */
-  getObserveMutations() {
-    return this.#observeMutations;
+  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));
   }
 
   /**
-   * Returns whether layout shift protection is enabled.
+   * Retrieves a number from `localStorage`.
    *
-   * @returns {boolean} True if scroll preservation is active, false otherwise.
+   * @param {string} name - The key to retrieve.
+   * @returns {number|null} The number or null if invalid.
    */
-  getPreserveScrollOnLayoutShift() {
-    return this.#preserveScrollOnLayoutShift;
+  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;
   }
 
   /**
-   * Returns the debounce delay in milliseconds used for scroll events.
+   * Stores a boolean value in `localStorage`.
    *
-   * @returns {number} Debounce delay time.
+   * @param {string} name - The key to use.
+   * @param {boolean} data - The boolean value to store.
    */
-  getDebounceTime() {
-    return this.#debounceTime;
+  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 the current number of matching elements observed inside the scroll target.
+   * Retrieves a boolean value from `localStorage`.
    *
-   * @returns {number} Current count of matching elements.
+   * @param {string} name - The key to retrieve.
+   * @returns {boolean|null} The boolean or null if invalid.
    */
-  getElemAmount() {
-    return this.#elemAmount;
+  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 previous known count of matching elements from the last update.
+   * Removes a value from `localStorage`.
    *
-   * @returns {number} Previous count of matching elements.
+   * @param {string} name - The key to remove.
    */
-  getPrevElemAmount() {
-    return this.#elemOldAmount;
+  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 query selector string used to filter observed elements.
-   *
-   * @returns {string} The CSS selector string, or an empty string if none was provided.
+   * Clears all data from `localStorage`.
    */
-  getQuerySelector() {
-    return this.#querySelector;
+  clearLocalStorage() {
+    this.#localStorage.clear();
   }
 
   /**
-   * Disconnects all listeners, observers, and clears memory structures.
-   * Once destroyed, this instance should no longer be used.
+   * Destroys the storage instance by removing the storage event listener.
    */
   destroy() {
-    if (this.#destroyed) return;
-    this.#destroyed = true;
+    window.removeEventListener('storage', this.#storageEvent);
+    this.#events.offAllTypes();
+  }
+}
 
-    // Disconnects MutationObserver
-    if (this.#mutationObserver) {
-      this.#mutationObserver.disconnect();
-      this.#mutationObserver = null;
-    }
+// First registers
 
-    // Disconnect ResizeObserver
-    if (this.#resizeObserver) {
-      this.#resizeObserver.disconnect();
-      this.#resizeObserver = null;
-    }
+// 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
 
-    // Removes scroll listener
-    const target = this.#useWindow ? window : this.#target;
-    if (this.#handler) target.removeEventListener('scroll', this.#handler);
 
-    // Clean the WeakMaps
-    this.#oldSizes = new WeakMap();
-    this.#newSizes = new WeakMap();
-    this.#newVisibles = new WeakMap();
-    this.#oldVisibles = new WeakMap();
-    this.#newVisiblesByTime = new WeakMap();
-    this.#oldVisiblesByTime = new WeakMap();
 
-    // Cleans listeners and filters
-    this.#scrollListeners = {};
-    this.#sizeFilter.clear();
-    this.#loadTags.clear();
-  }
-}
 
-/* harmony default export */ const libs_TinySmartScroller = ((/* unused pure expression or super */ null && (TinySmartScroller)));
 
-;// ./src/v1/index.mjs
 
 
 
@@ -12193,7 +13151,7 @@ class TinyUploadClicker {
    * @throws {TypeError} If the config is invalid or required options are missing.
    */
   constructor(options) {
-    if (!objFilter_isJsonObject(options))
+    if (!isJsonObject(options))
       throw new TypeError('TinyUploadClicker: "options" must be a valid object.');
 
     this.#config = {
@@ -12259,10 +13217,10 @@ class TinyUploadClicker {
     )
       throw new TypeError('TinyUploadClicker: "onFileLoad" must be a function or null.');
 
-    if (options.inputAttributes !== undefined && !objFilter_isJsonObject(options.inputAttributes))
+    if (options.inputAttributes !== undefined && !isJsonObject(options.inputAttributes))
       throw new TypeError('TinyUploadClicker: "inputAttributes" must be an object.');
 
-    if (options.inputStyles !== undefined && !objFilter_isJsonObject(options.inputStyles))
+    if (options.inputStyles !== undefined && !isJsonObject(options.inputStyles))
       throw new TypeError('TinyUploadClicker: "inputStyles" must be an object.');
 
     this.#boundClick = this.#handleClick.bind(this);