tiny-essentials 1.16.2 → 1.17.1

package/dist/v1/TinyEssentials.js

@@ -2896,7 +2896,9 @@ __webpack_require__.d(__webpack_exports__, {
   TinyNotifyCenter: () => (/* reexport */ libs_TinyNotifyCenter),
   TinyPromiseQueue: () => (/* reexport */ libs_TinyPromiseQueue),
   TinyRateLimiter: () => (/* reexport */ libs_TinyRateLimiter),
+  TinySmartScroller: () => (/* reexport */ libs_TinySmartScroller),
   TinyToastNotify: () => (/* reexport */ libs_TinyToastNotify),
+  UltraRandomMsgGen: () => (/* reexport */ libs_UltraRandomMsgGen),
   addAiMarkerShortcut: () => (/* reexport */ addAiMarkerShortcut),
   areElsCollBottom: () => (/* reexport */ areElsCollBottom),
   areElsCollLeft: () => (/* reexport */ areElsCollLeft),
@@ -6363,20 +6365,22 @@ function saveJsonFile(filename, data, spaces = 2) {
 }
 
 /**
- * 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.
- * @param {string} [options.method="GET"] - HTTP method to use (GET, POST, etc.).
- * @param {any} [options.body] - Request body (only for methods like POST, PUT).
- * @param {number} [options.timeout=0] - Timeout in milliseconds (ignored if signal is provided).
- * @param {number} [options.retries=0] - Number of retry attempts (ignored if signal is provided).
- * @param {Headers|Record<string, *>} [options.headers={}] - Additional headers.
- * @param {AbortSignal|null} [options.signal] - External AbortSignal; disables timeout and retries.
- * @returns {Promise<*>} Parsed JSON object.
- * @throws {Error} Throws if fetch fails, times out, or returns invalid JSON.
+ * @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 fetchJson(
+async function fetchTemplate(
   url,
   { method = 'GET', body, timeout = 0, retries = 0, headers = {}, signal = null } = {},
 ) {
@@ -6435,17 +6439,7 @@ async function fetchJson(
       if (timer) clearTimeout(timer);
 
       if (!response.ok) throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
-
-      const contentType = response.headers.get('content-type') || '';
-      if (!contentType.includes('application/json'))
-        throw new Error(`Unexpected content-type: ${contentType}`);
-
-      const data = await response.json();
-
-      if (!Array.isArray(data) && !isJsonObject(data))
-        throw new Error('Received invalid data instead of valid JSON.');
-
-      return data;
+      return response;
     } catch (err) {
       lastError = /** @type {Error} */ (err);
       if (signal) break; // if an external signal came, it does not retry
@@ -6459,6 +6453,63 @@ async function fetchJson(
   );
 }
 
+/**
+ * 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);
+  });
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -6990,6 +7041,19 @@ const {
   areElsCollRight: TinyHtml_areElsCollRight,
 } = collision_namespaceObject;
 
+/**
+ * Callback invoked on each animation frame with the current scroll position,
+ * normalized animation time (`0` to `1`), and a completion flag.
+ *
+ * @typedef {(progress: { x: number, y: number, isComplete: boolean, time: number }) => void} OnScrollAnimation
+ */
+
+/**
+ * A list of supported easing function names for smooth animations.
+ *
+ * @typedef {'linear' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic'} Easings
+ */
+
 /**
  * Represents a raw Node element or an instance of TinyHtml.
  * This type is used to abstract interactions with both plain elements
@@ -7045,6 +7109,21 @@ const {
  * @typedef {Element|Window} ElementAndWindow
  */
 
+/**
+ * Represents a raw DOM element/window/document or an instance of TinyHtml.
+ * This type is used to abstract interactions with both plain elements
+ * and wrapped elements via the TinyHtml class.
+ *
+ * @typedef {ElementAndWinAndDoc|TinyHtml} TinyElementAndWinAndDoc
+ */
+
+/**
+ * Represents a value that can be either a DOM Element, or the global Window object, or the document object.
+ * Useful for functions that operate generically on scrollable or measurable targets.
+ *
+ * @typedef {Element|Window|Document} ElementAndWinAndDoc
+ */
+
 /**
  * A parameter type used for filtering or matching elements.
  * It can be:
@@ -7061,7 +7140,7 @@ const {
  * Elements accepted as constructor values for TinyHtml.
  * These include common DOM elements and root containers.
  *
- * @typedef {Window|Element|Document} ConstructorElValues
+ * @typedef {Window|Element|Document|Text} ConstructorElValues
  */
 
 /**
@@ -7182,40 +7261,114 @@ class TinyHtml_TinyHtml {
 
   static Utils = { ...collision_namespaceObject };
 
+  /**
+   * Creates a new DOM element with the specified tag name and options, then wraps it in a TinyHtml instance.
+   *
+   * @param {string} tagName - The tag name of the element to create (e.g., 'div', 'span').
+   * @param {ElementCreationOptions} ops - Optional settings for creating the element.
+   * @returns {TinyHtml} A TinyHtml instance wrapping the newly created DOM element.
+   * @throws {TypeError} If tagName is not a string or ops is not an object.
+   */
+  static createElement(tagName, ops) {
+    if (typeof tagName !== 'string')
+      throw new TypeError(`[TinyHtml] createElement(): The tagName must be a string.`);
+    if (typeof ops !== 'undefined' && typeof ops !== 'object')
+      throw new TypeError(`[TinyHtml] createElement(): The ops must be a object.`);
+    return new TinyHtml_TinyHtml(document.createElement(tagName, ops));
+  }
+
+  /**
+   * Creates a new TinyHtml instance that wraps a DOM TextNode.
+   *
+   * This method is useful when you want to insert raw text content into the DOM
+   * without it being interpreted as HTML. The returned instance behaves like any
+   * other TinyHtml element and can be appended or manipulated as needed.
+   *
+   * @param {string} value - The plain text content to be wrapped in a TextNode.
+   * @returns {TinyHtml} A TinyHtml instance wrapping the newly created DOM TextNode.
+   * @throws {TypeError} If the provided value is not a string.
+   */
+  static createTextNode(value) {
+    if (typeof value !== 'string')
+      throw new TypeError(`[TinyHtml] createTextNode(): The value must be a string.`);
+    return new TinyHtml_TinyHtml(document.createTextNode(value));
+  }
+
+  /**
+   * Creates an HTMLElement or TextNode from an HTML string.
+   * Supports both elements and plain text.
+   *
+   * @param {string} htmlString - The HTML string to convert.
+   * @returns {TinyHtml} - A single HTMLElement or TextNode.
+   */
+  static createElementFromHTML(htmlString) {
+    const template = document.createElement('template');
+    htmlString = htmlString.trim();
+
+    // If it's only text (e.g., no "<" tag), return a TextNode
+    if (!htmlString.startsWith('<')) {
+      return TinyHtml_TinyHtml.createTextNode(htmlString);
+    }
+
+    template.innerHTML = htmlString;
+    if (!(template.content.firstChild instanceof Element)) throw new Error('');
+    return new TinyHtml_TinyHtml(template.content.firstChild);
+  }
+
   /**
    * Queries the document for the first element matching the CSS selector and wraps it in a TinyHtml instance.
    *
    * @param {string} selector - A valid CSS selector string.
-   * @returns {TinyHtml} A TinyHtml instance wrapping the matched element.
-   * @throws {Error} If no element matches the selector.
+   * @param {Document|Element} elem - Target element.
+   * @returns {TinyHtml|null} A TinyHtml instance wrapping the matched element.
    */
-  static query(selector) {
-    const newEl = document.querySelector(selector);
-    if (!newEl) throw new Error(`[TinyHtml] query(): No element found for selector "${selector}".`);
+  static query(selector, elem = document) {
+    const newEl = elem.querySelector(selector);
+    if (!newEl) return null;
     return new TinyHtml_TinyHtml(newEl);
   }
 
+  /**
+   * Queries the element for the first element matching the CSS selector and wraps it in a TinyHtml instance.
+   *
+   * @param {string} selector - A valid CSS selector string.
+   * @returns {TinyHtml|null} A TinyHtml instance wrapping the matched element.
+   */
+  querySelector(selector) {
+    return TinyHtml_TinyHtml.query(selector, TinyHtml_TinyHtml._preElem(this, 'query'));
+  }
+
   /**
    * Queries the document for all elements matching the CSS selector and wraps them in TinyHtml instances.
    *
    * @param {string} selector - A valid CSS selector string.
+   * @param {Document|Element} elem - Target element.
    * @returns {TinyHtml[]} An array of TinyHtml instances wrapping the matched elements.
    */
-  static queryAll(selector) {
-    const newEls = document.querySelectorAll(selector);
+  static queryAll(selector, elem = document) {
+    const newEls = elem.querySelectorAll(selector);
     return TinyHtml_TinyHtml.toTinyElm([...newEls]);
   }
 
+  /**
+   * Queries the element for all elements matching the CSS selector and wraps them in TinyHtml instances.
+   *
+   * @param {string} selector - A valid CSS selector string.
+   * @returns {TinyHtml[]} An array of TinyHtml instances wrapping the matched elements.
+   */
+  querySelectorAll(selector) {
+    return TinyHtml_TinyHtml.queryAll(selector, TinyHtml_TinyHtml._preElem(this, 'queryAll'));
+  }
+
   /**
    * Retrieves an element by its ID and wraps it in a TinyHtml instance.
    *
    * @param {string} selector - The ID of the element to retrieve.
-   * @returns {TinyHtml} A TinyHtml instance wrapping the found element.
-   * @throws {Error} If no element is found with the specified ID.
+   * @returns {TinyHtml|null} A TinyHtml instance wrapping the found element.
    */
   static getById(selector) {
     const newEl = document.getElementById(selector);
-    if (!newEl) throw new Error(`[TinyHtml] getById(): No element found with ID "${selector}".`);
+    if (!newEl) return null;
     return new TinyHtml_TinyHtml(newEl);
   }
 
@@ -7223,13 +7376,24 @@ class TinyHtml_TinyHtml {
    * Retrieves all elements with the specified class name and wraps them in TinyHtml instances.
    *
    * @param {string} selector - The class name to search for.
+   * @param {Document|Element} elem - Target element.
    * @returns {TinyHtml[]} An array of TinyHtml instances wrapping the found elements.
    */
-  static getByClassName(selector) {
-    const newEls = document.getElementsByClassName(selector);
+  static getByClassName(selector, elem = document) {
+    const newEls = elem.getElementsByClassName(selector);
     return TinyHtml_TinyHtml.toTinyElm([...newEls]);
   }
 
+  /**
+   * Retrieves all elements with the specified class name and wraps them in TinyHtml instances.
+   *
+   * @param {string} selector - The class name to search for.
+   * @returns {TinyHtml[]} An array of TinyHtml instances wrapping the found elements.
+   */
+  getElementsByClassName(selector) {
+    return TinyHtml_TinyHtml.getByClassName(selector, TinyHtml_TinyHtml._preElem(this, 'getByClassName'));
+  }
+
   /**
    * Retrieves all elements with the specified name attribute and wraps them in TinyHtml instances.
    *
@@ -7247,13 +7411,30 @@ class TinyHtml_TinyHtml {
    *
    * @param {string} localName - The local name (tag) of the elements to search for.
    * @param {string|null} [namespaceURI='http://www.w3.org/1999/xhtml'] - The namespace URI to search within.
+   * @param {Document|Element} elem - Target element.
    * @returns {TinyHtml[]} An array of TinyHtml instances wrapping the found elements.
    */
-  static getByTagNameNS(localName, namespaceURI = 'http://www.w3.org/1999/xhtml') {
-    const newEls = document.getElementsByTagNameNS(namespaceURI, localName);
+  static getByTagNameNS(localName, namespaceURI = 'http://www.w3.org/1999/xhtml', elem = document) {
+    const newEls = elem.getElementsByTagNameNS(namespaceURI, localName);
     return TinyHtml_TinyHtml.toTinyElm([...newEls]);
   }
 
+  /**
+   * Retrieves all elements with the specified local tag name within the given namespace URI,
+   * and wraps them in TinyHtml instances.
+   *
+   * @param {string} localName - The local name (tag) of the elements to search for.
+   * @param {string|null} [namespaceURI='http://www.w3.org/1999/xhtml'] - The namespace URI to search within.
+   * @returns {TinyHtml[]} An array of TinyHtml instances wrapping the found elements.
+   */
+  getElementsByTagNameNS(localName, namespaceURI = 'http://www.w3.org/1999/xhtml') {
+    return TinyHtml_TinyHtml.getByTagNameNS(
+      localName,
+      namespaceURI,
+      TinyHtml_TinyHtml._preElem(this, 'getByTagNameNS'),
+    );
+  }
+
   //////////////////////////////////////////////////////////////////
 
   /**
@@ -7534,6 +7715,45 @@ class TinyHtml_TinyHtml {
     return TinyHtml_TinyHtml._preElemTemplate(elems, where, [Element, Window], ['Element', 'Window']);
   }
 
+  /**
+   * Ensures the input is returned as an array.
+   * Useful to normalize operations across multiple or single element/window/document elements.
+   *
+   * @param {TinyElementAndWinAndDoc|TinyElementAndWinAndDoc[]} elems - A single element/window element or array of html elements.
+   * @param {string} where - The method or context name where validation is being called.
+   * @returns {ElementAndWindow[]} - Always returns an array of element/window elements.
+   * @readonly
+   */
+  static _preElemsAndWinAndDoc(elems, where) {
+    const result = TinyHtml_TinyHtml._preElemsTemplate(
+      elems,
+      where,
+      [Element, Window, Document],
+      ['Element', 'Window', 'Document'],
+    );
+    return result.map((elem) => (!(elem instanceof Document) ? elem : elem.documentElement));
+  }
+
+  /**
+   * Ensures the input is returned as an single element/window/document element.
+   * Useful to normalize operations across multiple or single element/window/document elements.
+   *
+   * @param {TinyElementAndWinAndDoc|TinyElementAndWinAndDoc[]} elems - A single element/window element or array of html elements.
+   * @param {string} where - The method or context name where validation is being called.
+   * @returns {ElementAndWindow} - Always returns an single element/window element.
+   * @readonly
+   */
+  static _preElemAndWinAndDoc(elems, where) {
+    const result = TinyHtml_TinyHtml._preElemTemplate(
+      elems,
+      where,
+      [Element, Window, Document],
+      ['Element', 'Window', 'Document'],
+    );
+    if (result instanceof Document) return result.documentElement;
+    return result;
+  }
+
   /**
    * Normalizes and converts one or more DOM elements (or TinyHtml instances)
    * into an array of `TinyHtml` instances.
@@ -7880,12 +8100,13 @@ class TinyHtml_TinyHtml {
    * @param {string} key - The key under which the data will be stored.
    * @param {any} value - The value to store.
    * @param {boolean} [isPrivate=false] - Whether to store the data in the private store.
-   * @returns {void}
+   * @returns {TinyElement}
    */
   static setData(el, key, value, isPrivate = false) {
     const data = TinyHtml_TinyHtml._dataSelector[!isPrivate ? 'public' : 'private']('setData', el);
     if (typeof key !== 'string') throw new TypeError('The key must be a string.');
     data[key] = value;
+    return el;
   }
 
   /**
@@ -7894,7 +8115,7 @@ class TinyHtml_TinyHtml {
    * @param {string} key - The key under which the data will be stored.
    * @param {any} value - The value to store.
    * @param {boolean} [isPrivate=false] - Whether to store the data in the private store.
-   * @returns {void}
+   * @returns {TinyElement}
    */
   setData(key, value, isPrivate = false) {
     return TinyHtml_TinyHtml.setData(this, key, value, isPrivate);
@@ -8241,18 +8462,21 @@ class TinyHtml_TinyHtml {
   /**
    * Appends child elements or strings to the end of the target element(s).
    *
-   * @param {TinyElement | TinyElement[]} el - The target element(s) to receive children.
+   * @param {TinyElement} el - The target element(s) to receive children.
    * @param {...(TinyNode | TinyNode[] | string)} children - The child elements or text to append.
+   * @returns {TinyElement}
    */
   static append(el, ...children) {
     const elem = TinyHtml_TinyHtml._preElem(el, 'append');
     elem.append(...TinyHtml_TinyHtml._appendChecker('append', ...children));
+    return el;
   }
 
   /**
    * Appends child elements or strings to the end of the target element(s).
    *
    * @param {...(TinyNode | TinyNode[] | string)} children - The child elements or text to append.
+   * @returns {TinyElement}
    */
   append(...children) {
     return TinyHtml_TinyHtml.append(this, ...children);
@@ -8261,18 +8485,21 @@ class TinyHtml_TinyHtml {
   /**
    * Prepends child elements or strings to the beginning of the target element(s).
    *
-   * @param {TinyElement | TinyElement[]} el - The target element(s) to receive children.
+   * @param {TinyElement} el - The target element(s) to receive children.
    * @param {...(TinyNode | TinyNode[] | string)} children - The child elements or text to prepend.
+   * @returns {TinyElement}
    */
   static prepend(el, ...children) {
     const elem = TinyHtml_TinyHtml._preElem(el, 'prepend');
     elem.prepend(...TinyHtml_TinyHtml._appendChecker('prepend', ...children));
+    return el;
   }
 
   /**
    * Prepends child elements or strings to the beginning of the target element(s).
    *
    * @param {...(TinyNode | TinyNode[] | string)} children - The child elements or text to prepend.
+   * @returns {TinyElement}
    */
   prepend(...children) {
     return TinyHtml_TinyHtml.prepend(this, ...children);
@@ -8281,18 +8508,21 @@ class TinyHtml_TinyHtml {
   /**
    * Inserts elements or strings immediately before the target element(s) in the DOM.
    *
-   * @param {TinyElement | TinyElement[]} el - The target element(s) before which new content is inserted.
+   * @param {TinyElement} el - The target element(s) before which new content is inserted.
    * @param {...(TinyNode | TinyNode[] | string)} children - Elements or text to insert before the target.
+   * @returns {TinyElement}
    */
   static before(el, ...children) {
     const elem = TinyHtml_TinyHtml._preElem(el, 'before');
     elem.before(...TinyHtml_TinyHtml._appendChecker('before', ...children));
+    return el;
   }
 
   /**
    * Inserts elements or strings immediately before the target element(s) in the DOM.
    *
    * @param {...(TinyNode | TinyNode[] | string)} children - Elements or text to insert before the target.
+   * @returns {TinyElement}
    */
   before(...children) {
     return TinyHtml_TinyHtml.before(this, ...children);
@@ -8301,18 +8531,21 @@ class TinyHtml_TinyHtml {
   /**
    * Inserts elements or strings immediately after the target element(s) in the DOM.
    *
-   * @param {TinyElement | TinyElement[]} el - The target element(s) after which new content is inserted.
+   * @param {TinyElement} el - The target element(s) after which new content is inserted.
    * @param {...(TinyNode | TinyNode[] | string)} children - Elements or text to insert after the target.
+   * @returns {TinyElement}
    */
   static after(el, ...children) {
     const elem = TinyHtml_TinyHtml._preElem(el, 'after');
     elem.after(...TinyHtml_TinyHtml._appendChecker('after', ...children));
+    return el;
   }
 
   /**
    * Inserts elements or strings immediately after the target element(s) in the DOM.
    *
    * @param {...(TinyNode | TinyNode[] | string)} children - Elements or text to insert after the target.
+   * @returns {TinyElement}
    */
   after(...children) {
     return TinyHtml_TinyHtml.after(this, ...children);
@@ -8321,18 +8554,21 @@ class TinyHtml_TinyHtml {
   /**
    * Replaces the target element(s) in the DOM with new elements or text.
    *
-   * @param {TinyElement | TinyElement[]} el - The element(s) to be replaced.
+   * @param {TinyElement} el - The element(s) to be replaced.
    * @param {...(TinyNode | TinyNode[] | string)} newNodes - New elements or text to replace the target.
+   * @returns {TinyElement}
    */
   static replaceWith(el, ...newNodes) {
     const elem = TinyHtml_TinyHtml._preElem(el, 'replaceWith');
     elem.replaceWith(...TinyHtml_TinyHtml._appendChecker('replaceWith', ...newNodes));
+    return el;
   }
 
   /**
    * Replaces the target element(s) in the DOM with new elements or text.
    *
    * @param {...(TinyNode | TinyNode[] | string)} newNodes - New elements or text to replace the target.
+   * @returns {TinyElement}
    */
   replaceWith(...newNodes) {
     return TinyHtml_TinyHtml.replaceWith(this, ...newNodes);
@@ -8343,6 +8579,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {TinyNode | TinyNode[]} el - The element(s) to append.
    * @param {TinyNode | TinyNode[]} targets - Target element(s) where content will be appended.
+   * @returns {TinyNode|TinyNode[]}
    */
   static appendTo(el, targets) {
     const elems = TinyHtml_TinyHtml._preNodeElems(el, 'appendTo');
@@ -8352,12 +8589,14 @@ class TinyHtml_TinyHtml {
         target.appendChild(i === tars.length - 1 ? elem : elem.cloneNode(true)),
       );
     });
+    return el;
   }
 
   /**
    * Appends the given element(s) to each target element in sequence.
    *
    * @param {TinyNode | TinyNode[]} targets - Target element(s) where content will be appended.
+   * @returns {TinyNode|TinyNode[]}
    */
   appendTo(targets) {
     return TinyHtml_TinyHtml.appendTo(this, targets);
@@ -8368,6 +8607,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {TinyElement | TinyElement[]} el - The element(s) to prepend.
    * @param {TinyElement | TinyElement[]} targets - Target element(s) where content will be prepended.
+   * @returns {TinyElement|TinyElement[]}
    */
   static prependTo(el, targets) {
     const elems = TinyHtml_TinyHtml._preElems(el, 'prependTo');
@@ -8378,12 +8618,14 @@ class TinyHtml_TinyHtml {
         .reverse()
         .forEach((elem) => target.prepend(i === tars.length - 1 ? elem : elem.cloneNode(true)));
     });
+    return el;
   }
 
   /**
    * Prepends the given element(s) to each target element in sequence.
    *
    * @param {TinyElement | TinyElement[]} targets - Target element(s) where content will be prepended.
+   * @returns {TinyElement|TinyElement[]}
    */
   prependTo(targets) {
     return TinyHtml_TinyHtml.prependTo(this, targets);
@@ -8395,6 +8637,7 @@ class TinyHtml_TinyHtml {
    * @param {TinyNode | TinyNode[]} el - The element(s) to insert.
    * @param {TinyNode | TinyNode[]} target - The reference element where insertion happens.
    * @param {TinyNode | TinyNode[] | null} [child=null] - Optional child to insert before, defaults to target.
+   * @returns {TinyNode|TinyNode[]}
    */
   static insertBefore(el, target, child = null) {
     const elem = TinyHtml_TinyHtml._preNodeElem(el, 'insertBefore');
@@ -8402,6 +8645,7 @@ class TinyHtml_TinyHtml {
     const childNode = TinyHtml_TinyHtml._preNodeElemWithNull(child, 'insertBefore');
     if (!targ.parentNode) throw new Error('');
     targ.parentNode.insertBefore(elem, childNode || targ);
+    return el;
   }
 
   /**
@@ -8409,6 +8653,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {TinyNode | TinyNode[]} target - The reference element where insertion happens.
    * @param {TinyNode | TinyNode[] | null} [child=null] - Optional child to insert before, defaults to target.
+   * @returns {TinyNode|TinyNode[]}
    */
   insertBefore(target, child) {
     return TinyHtml_TinyHtml.insertBefore(this, target, child);
@@ -8420,6 +8665,7 @@ class TinyHtml_TinyHtml {
    * @param {TinyNode | TinyNode[]} el - The element(s) to insert.
    * @param {TinyNode | TinyNode[]} target - The reference element where insertion happens.
    * @param {TinyNode | TinyNode[] | null} [child=null] - Optional child to insert after, defaults to target.
+   * @returns {TinyNode|TinyNode[]}
    */
   static insertAfter(el, target, child = null) {
     const elem = TinyHtml_TinyHtml._preNodeElem(el, 'insertAfter');
@@ -8427,6 +8673,7 @@ class TinyHtml_TinyHtml {
     const childNode = TinyHtml_TinyHtml._preNodeElemWithNull(child, 'insertBefore');
     if (!targ.parentNode) throw new Error('');
     targ.parentNode.insertBefore(elem, childNode || targ.nextSibling);
+    return el;
   }
 
   /**
@@ -8434,6 +8681,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {TinyNode | TinyNode[]} target - The reference element where insertion happens.
    * @param {TinyNode | TinyNode[] | null} [child=null] - Optional child to insert after, defaults to target.
+   * @returns {TinyNode|TinyNode[]}
    */
   insertAfter(target, child) {
     return TinyHtml_TinyHtml.insertAfter(this, target, child);
@@ -8445,6 +8693,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {TinyNode | TinyNode[]} el - The new element(s) to insert.
    * @param {TinyNode | TinyNode[]} targets - The elements to be replaced.
+   * @returns {TinyNode|TinyNode[]}
    */
   static replaceAll(el, targets) {
     const elems = TinyHtml_TinyHtml._preNodeElems(el, 'replaceAll');
@@ -8456,6 +8705,7 @@ class TinyHtml_TinyHtml {
           parent.replaceChild(i === tars.length - 1 ? elem : elem.cloneNode(true), target);
       });
     });
+    return el;
   }
 
   /**
@@ -8463,6 +8713,7 @@ class TinyHtml_TinyHtml {
    * If multiple targets exist, the inserted elements are cloned accordingly.
    *
    * @param {TinyNode | TinyNode[]} targets - The elements to be replaced.
+   * @returns {TinyNode|TinyNode[]}
    */
   replaceAll(targets) {
     return TinyHtml_TinyHtml.replaceAll(this, targets);
@@ -8486,7 +8737,12 @@ class TinyHtml_TinyHtml {
       throw new Error(
         `[TinyHtml] You are trying to put a TinyHtml inside another TinyHtml in constructor.`,
       );
-    if (!(el instanceof Element) && !(el instanceof Window) && !(el instanceof Document))
+    if (
+      !(el instanceof Element) &&
+      !(el instanceof Window) &&
+      !(el instanceof Document) &&
+      !(el instanceof Text)
+    )
       throw new Error(`[TinyHtml] Invalid Target in constructor.`);
     this.#el = el;
   }
@@ -8936,6 +9192,7 @@ class TinyHtml_TinyHtml {
    * @param {TinyHtmlElement|TinyHtmlElement[]} el - The element to inspect.
    * @param {string|Object} prop - The property name or an object with key-value pairs
    * @param {string|null} [value=null] - The value to set (if `prop` is a string)
+   * @returns {TinyHtmlElement|TinyHtmlElement[]}
    */
   static setStyle(el, prop, value = null) {
     TinyHtml_TinyHtml._preHtmlElems(el, 'setStyle').forEach((elem) => {
@@ -8948,6 +9205,7 @@ class TinyHtml_TinyHtml {
         }
       } else elem.style.setProperty(TinyHtml_TinyHtml.toStyleKc(prop), value);
     });
+    return el;
   }
 
   /**
@@ -8958,6 +9216,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {string|Object} prop - The property name or an object with key-value pairs
    * @param {string|null} [value=null] - The value to set (if `prop` is a string)
+   * @returns {TinyHtmlElement|TinyHtmlElement[]}
    */
   setStyle(prop, value) {
     return TinyHtml_TinyHtml.setStyle(this, prop, value);
@@ -9053,6 +9312,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {TinyHtmlElement|TinyHtmlElement[]} el - A single element or an array of elements.
    * @param {string|string[]} prop - A property name or an array of property names to remove.
+   * @returns {TinyHtmlElement|TinyHtmlElement[]}
    */
   static removeStyle(el, prop) {
     TinyHtml_TinyHtml._preHtmlElems(el, 'removeStyle').forEach((elem) => {
@@ -9062,12 +9322,14 @@ class TinyHtml_TinyHtml {
         }
       } else elem.style.removeProperty(TinyHtml_TinyHtml.toStyleKc(prop));
     });
+    return el;
   }
 
   /**
    * Removes one or more inline CSS properties from the given element(s).
    *
    * @param {string|string[]} prop - A property name or an array of property names to remove.
+   * @returns {TinyHtmlElement|TinyHtmlElement[]}
    */
   removeStyle(prop) {
     return TinyHtml_TinyHtml.removeStyle(this, prop);
@@ -9082,6 +9344,7 @@ class TinyHtml_TinyHtml {
    * @param {string} prop - The CSS property to toggle.
    * @param {string} val1 - The first value (used as "current" check).
    * @param {string} val2 - The second value (used as the "alternative").
+   * @returns {TinyHtmlElement|TinyHtmlElement[]}
    */
   static toggleStyle(el, prop, val1, val2) {
     TinyHtml_TinyHtml._preHtmlElems(el, 'toggleStyle').forEach((elem) => {
@@ -9089,6 +9352,7 @@ class TinyHtml_TinyHtml {
       const newVal = current === TinyHtml_TinyHtml.toStyleKc(val1) ? val2 : val1;
       TinyHtml_TinyHtml.setStyle(elem, prop, newVal);
     });
+    return el;
   }
 
   /**
@@ -9099,6 +9363,7 @@ class TinyHtml_TinyHtml {
    * @param {string} prop - The CSS property to toggle.
    * @param {string} val1 - The first value (used as "current" check).
    * @param {string} val2 - The second value (used as the "alternative").
+   * @returns {TinyHtmlElement|TinyHtmlElement[]}
    */
   toggleStyle(prop, val1, val2) {
     return TinyHtml_TinyHtml.toggleStyle(this, prop, val1, val2);
@@ -9108,14 +9373,16 @@ class TinyHtml_TinyHtml {
    * Removes all inline styles (`style` attribute) from the given element(s).
    *
    * @param {TinyElement|TinyElement[]} el - A single element or an array of elements.
+   * @returns {TinyElement|TinyElement[]}
    */
   static clearStyle(el) {
     TinyHtml_TinyHtml._preElems(el, 'clearStyle').forEach((elem) => elem.removeAttribute('style'));
+    return el;
   }
 
   /**
    * Removes all inline styles (`style` attribute) from the given element(s).
-   *
+   * @returns {TinyElement|TinyElement[]}
    */
   clearStyle() {
     return TinyHtml_TinyHtml.clearStyle(this);
@@ -9127,14 +9394,17 @@ class TinyHtml_TinyHtml {
    * Focus the element.
    *
    * @param {TinyHtmlElement} el - The element or a selector string.
+   * @returns {TinyHtmlElement}
    */
   static focus(el) {
     const elem = TinyHtml_TinyHtml._preHtmlElem(el, 'focus');
     elem.focus();
+    return el;
   }
 
   /**
    * Focus the element.
+   * @returns {TinyHtmlElement}
    */
   focus() {
     return TinyHtml_TinyHtml.focus(this);
@@ -9144,19 +9414,46 @@ class TinyHtml_TinyHtml {
    * Blur the element.
    *
    * @param {TinyHtmlElement} el - The element or a selector string.
+   * @returns {TinyHtmlElement}
    */
   static blur(el) {
     const elem = TinyHtml_TinyHtml._preHtmlElem(el, 'blur');
     elem.blur();
+    return el;
   }
 
   /**
    * Blur the element.
+   * @returns {TinyHtmlElement}
    */
   blur() {
     return TinyHtml_TinyHtml.blur(this);
   }
 
+  /**
+   * Interprets a value as a boolean `true` if it matches a common truthy representation.
+   *
+   * This method checks if the input is any of the common forms used to represent `true`,
+   * such as the string `'true'`, `'1'`, `'on'`, the boolean `true`, or the number `1`.
+   *
+   * @param {string|boolean|number} [value] - The value to interpret as boolean.
+   * @returns {boolean} `true` if the value represents a truthy state, otherwise `false`.
+   */
+  static boolCheck(value) {
+    if (
+      typeof value !== 'undefined' &&
+      (value === 'true' ||
+        value === '1' ||
+        value === true ||
+        value === 'on' ||
+        (typeof value === 'number' && value > 0))
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
   //////////////////////////////////////////////////////////////////////
 
   /**
@@ -9165,7 +9462,7 @@ class TinyHtml_TinyHtml {
    */
   static setWinScrollTop(value) {
     if (typeof value !== 'number') throw new TypeError('The value must be a number.');
-    window.scrollTo({ top: value });
+    TinyHtml_TinyHtml.setScrollTop(window, value);
   }
 
   /**
@@ -9174,7 +9471,7 @@ class TinyHtml_TinyHtml {
    */
   static setWinScrollLeft(value) {
     if (typeof value !== 'number') throw new TypeError('The value must be a number.');
-    window.scrollTo({ left: value });
+    TinyHtml_TinyHtml.setScrollLeft(window, value);
   }
 
   /**
@@ -9209,16 +9506,40 @@ class TinyHtml_TinyHtml {
     return window.innerWidth || document.documentElement.clientWidth;
   }
 
+  /**
+   * Checks if the page is currently scrolled to the very top.
+   *
+   * This method compares the current vertical scroll position with the total document height.
+   * It's useful for detecting if the user has reached the top of the page.
+   *
+   * @returns {boolean} `true` if the page is scrolled to the top, otherwise `false`.
+   */
+  static isPageTop() {
+    return window.scrollY === 0;
+  }
+
+  /**
+   * Checks if the page is currently scrolled to the very bottom.
+   *
+   * This method uses the `scrollY` and `innerHeight` properties to determine if the
+   * user has reached the end of the document.
+   *
+   * @returns {boolean} `true` if the page is scrolled to the bottom, otherwise `false`.
+   */
+  static isPageBottom() {
+    return window.innerHeight + window.scrollY >= document.body.offsetHeight;
+  }
+
   /**
    * Gets the width or height of an element based on the box model.
-   * @param {TinyElementAndWindow} el - The element or window.
+   * @param {TinyElementAndWinAndDoc} el - The element or window.
    * @param {"width"|"height"} type - Dimension type.
    * @param {"content"|"padding"|"border"|"margin"} [extra='content'] - Box model context.
    * @returns {number} - Computed dimension.
    * @throws {TypeError} If `type` or `extra` is not a string.
    */
   static getDimension(el, type, extra = 'content') {
-    const elem = TinyHtml_TinyHtml._preElemAndWindow(el, 'getDimension');
+    const elem = TinyHtml_TinyHtml._preElemAndWinAndDoc(el, 'getDimension');
     if (typeof type !== 'string') throw new TypeError('The type must be a string.');
     if (typeof extra !== 'string') throw new TypeError('The extra must be a string.');
 
@@ -9306,17 +9627,20 @@ class TinyHtml_TinyHtml {
    * @param {TinyHtmlElement} el - Target element.
    * @param {string|number} value - Height value.
    * @throws {TypeError} If `value` is neither a string nor number.
+   * @returns {TinyHtmlElement}
    */
   static setHeight(el, value) {
     const elem = TinyHtml_TinyHtml._preHtmlElem(el, 'setHeight');
     if (typeof value !== 'number' && typeof value !== 'string')
       throw new TypeError('The value must be a string or number.');
     elem.style.height = typeof value === 'number' ? `${value}px` : value;
+    return el;
   }
 
   /**
    * Sets the height of the element.
    * @param {string|number} value - Height value.
+   * @returns {TinyHtmlElement}
    */
   setHeight(value) {
     return TinyHtml_TinyHtml.setHeight(this, value);
@@ -9327,17 +9651,20 @@ class TinyHtml_TinyHtml {
    * @param {TinyHtmlElement} el - Target element.
    * @param {string|number} value - Width value.
    * @throws {TypeError} If `value` is neither a string nor number.
+   * @returns {TinyHtmlElement}
    */
   static setWidth(el, value) {
     const elem = TinyHtml_TinyHtml._preHtmlElem(el, 'setWidth');
     if (typeof value !== 'number' && typeof value !== 'string')
       throw new TypeError('The value must be a string or number.');
     elem.style.width = typeof value === 'number' ? `${value}px` : value;
+    return el;
   }
 
   /**
    * Sets the width of the element.
    * @param {string|number} value - Width value.
+   * @returns {TinyHtmlElement}
    */
   setWidth(value) {
     return TinyHtml_TinyHtml.setWidth(this, value);
@@ -9345,11 +9672,11 @@ class TinyHtml_TinyHtml {
 
   /**
    * Returns content box height.
-   * @param {TinyElementAndWindow} el - Target element.
+   * @param {TinyElementAndWinAndDoc} el - Target element.
    * @returns {number}
    */
   static height(el) {
-    const elem = TinyHtml_TinyHtml._preElemAndWindow(el, 'height');
+    const elem = TinyHtml_TinyHtml._preElemAndWinAndDoc(el, 'height');
     return TinyHtml_TinyHtml.getDimension(elem, 'height', 'content');
   }
 
@@ -9363,11 +9690,11 @@ class TinyHtml_TinyHtml {
 
   /**
    * Returns content box width.
-   * @param {TinyElementAndWindow} el - Target element.
+   * @param {TinyElementAndWinAndDoc} el - Target element.
    * @returns {number}
    */
   static width(el) {
-    const elem = TinyHtml_TinyHtml._preElemAndWindow(el, 'width');
+    const elem = TinyHtml_TinyHtml._preElemAndWinAndDoc(el, 'width');
     return TinyHtml_TinyHtml.getDimension(elem, 'width', 'content');
   }
 
@@ -9381,11 +9708,11 @@ class TinyHtml_TinyHtml {
 
   /**
    * Returns padding box height.
-   * @param {TinyElementAndWindow} el - Target element.
+   * @param {TinyElementAndWinAndDoc} el - Target element.
    * @returns {number}
    */
   static innerHeight(el) {
-    const elem = TinyHtml_TinyHtml._preElemAndWindow(el, 'innerHeight');
+    const elem = TinyHtml_TinyHtml._preElemAndWinAndDoc(el, 'innerHeight');
     return TinyHtml_TinyHtml.getDimension(elem, 'height', 'padding');
   }
 
@@ -9399,11 +9726,11 @@ class TinyHtml_TinyHtml {
 
   /**
    * Returns padding box width.
-   * @param {TinyElementAndWindow} el - Target element.
+   * @param {TinyElementAndWinAndDoc} el - Target element.
    * @returns {number}
    */
   static innerWidth(el) {
-    const elem = TinyHtml_TinyHtml._preElemAndWindow(el, 'innerWidth');
+    const elem = TinyHtml_TinyHtml._preElemAndWinAndDoc(el, 'innerWidth');
     return TinyHtml_TinyHtml.getDimension(elem, 'width', 'padding');
   }
 
@@ -9417,14 +9744,14 @@ class TinyHtml_TinyHtml {
 
   /**
    * Returns outer height of the element, optionally including margin.
-   * @param {TinyElementAndWindow} el - Target element.
+   * @param {TinyElementAndWinAndDoc} el - Target element.
    * @param {boolean} [includeMargin=false] - Whether to include margin.
    * @returns {number}
    */
   static outerHeight(el, includeMargin = false) {
     if (typeof includeMargin !== 'boolean')
       throw new TypeError('The "includeMargin" must be a boolean.');
-    const elem = TinyHtml_TinyHtml._preElemAndWindow(el, 'outerHeight');
+    const elem = TinyHtml_TinyHtml._preElemAndWinAndDoc(el, 'outerHeight');
     return TinyHtml_TinyHtml.getDimension(elem, 'height', includeMargin ? 'margin' : 'border');
   }
 
@@ -9439,14 +9766,14 @@ class TinyHtml_TinyHtml {
 
   /**
    * Returns outer width of the element, optionally including margin.
-   * @param {TinyElementAndWindow} el - Target element.
+   * @param {TinyElementAndWinAndDoc} el - Target element.
    * @param {boolean} [includeMargin=false] - Whether to include margin.
    * @returns {number}
    */
   static outerWidth(el, includeMargin = false) {
     if (typeof includeMargin !== 'boolean')
       throw new TypeError('The "includeMargin" must be a boolean.');
-    const elem = TinyHtml_TinyHtml._preElemAndWindow(el, 'outerWidth');
+    const elem = TinyHtml_TinyHtml._preElemAndWinAndDoc(el, 'outerWidth');
     return TinyHtml_TinyHtml.getDimension(elem, 'width', includeMargin ? 'margin' : 'border');
   }
 
@@ -9461,6 +9788,30 @@ class TinyHtml_TinyHtml {
 
   //////////////////////////////////////////////////
 
+  /**
+   * Applies an animation to one or multiple TinyElement instances.
+   *
+   * @param {TinyElement|TinyElement[]} el - A single TinyElement or an array of TinyElements to animate.
+   * @param {Keyframe[] | PropertyIndexedKeyframes | null} keyframes - The keyframes used to define the animation.
+   * @param {number | KeyframeAnimationOptions} [ops] - Timing or configuration options for the animation.
+   * @returns {TinyElement|TinyElement[]}
+   */
+  static animate(el, keyframes, ops) {
+    TinyHtml_TinyHtml._preElems(el, 'animate').forEach((elem) => elem.animate(keyframes, ops));
+    return el;
+  }
+
+  /**
+   * Applies an animation to one or multiple TinyElement instances.
+   *
+   * @param {Keyframe[] | PropertyIndexedKeyframes | null} keyframes - The keyframes used to define the animation.
+   * @param {number | KeyframeAnimationOptions} [ops] - Timing or configuration options for the animation.
+   * @returns {TinyElement|TinyElement[]}
+   */
+  animate(keyframes, ops) {
+    return TinyHtml_TinyHtml.animate(this, keyframes, ops);
+  }
+
   /**
    * Gets the offset of the element relative to the document.
    * @param {TinyElement} el - Target element.
@@ -9615,28 +9966,152 @@ class TinyHtml_TinyHtml {
     return TinyHtml_TinyHtml.scrollLeft(this);
   }
 
+  /**
+   * Collection of easing functions used for scroll and animation calculations.
+   * Each function receives a normalized time value (`t` from 0 to 1) and returns the eased progress.
+   *
+   * @type {Record<string, (t: number) => number>}
+   */
+  static easings = {
+    linear: (t) => t,
+    easeInQuad: (t) => t * t,
+    easeOutQuad: (t) => t * (2 - t),
+    easeInOutQuad: (t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t),
+    easeInCubic: (t) => t * t * t,
+    easeOutCubic: (t) => --t * t * t + 1,
+    easeInOutCubic: (t) => (t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1),
+  };
+
+  /**
+   * Smoothly scrolls one or more elements (or the window) to the specified X and Y coordinates
+   * using a custom duration and easing function.
+   *
+   * If `duration` or a valid `easing` is not provided, the scroll will be performed immediately.
+   *
+   * @param {TinyElementAndWindow | TinyElementAndWindow[]} el - A single element, array of elements, or the window to scroll.
+   * @param {Object} [settings={}] - Configuration object for the scroll animation.
+   * @param {number} [settings.targetX] - The horizontal scroll target in pixels.
+   * @param {number} [settings.targetY] - The vertical scroll target in pixels.
+   * @param {number} [settings.duration] - The duration of the animation in milliseconds.
+   * @param {Easings} [settings.easing] - The easing function name to use for the scroll animation.
+   * @param {OnScrollAnimation} [settings.onAnimation] - Optional callback invoked on each animation
+   *   frame with the current scroll position, normalized animation time (`0` to `1`), and a completion flag.
+   * @returns {TinyElementAndWindow|TinyElementAndWindow[]}
+   * @throws {TypeError} If `el` is not a valid element, array, or window.
+   * @throws {TypeError} If `targetX` or `targetY` is defined but not a number.
+   * @throws {TypeError} If `duration` is defined but not a number.
+   * @throws {TypeError} If `easing` is defined but not a valid easing function name.
+   * @throws {TypeError} If `onAnimation` is defined but not a function.
+   */
+  static scrollToXY(el, { targetX, targetY, duration, easing, onAnimation } = {}) {
+    if (targetX !== undefined && typeof targetX !== 'number')
+      throw new TypeError('`targetX` must be a number if provided.');
+    if (targetY !== undefined && typeof targetY !== 'number')
+      throw new TypeError('`targetY` must be a number if provided.');
+    if (duration !== undefined && typeof duration !== 'number')
+      throw new TypeError('`duration` must be a number if provided.');
+    if (easing !== undefined && typeof easing !== 'string')
+      throw new TypeError('`easing` must be a string if provided.');
+    if (easing !== undefined && typeof TinyHtml_TinyHtml.easings[easing] !== 'function')
+      throw new TypeError(`Unknown easing function: "${easing}".`);
+    if (onAnimation !== undefined && typeof onAnimation !== 'function')
+      throw new TypeError('`onAnimation` must be a function if provided.');
+
+    /**
+     * Performs an instant scroll to the given coordinates.
+     *
+     * @param {ElementAndWindow} elem - The element or window to scroll.
+     * @param {number} newX - The final horizontal scroll position.
+     * @param {number} newY - The final vertical scroll position.
+     * @param {number} time - Normalized progress value.
+     */
+    const executeScroll = (elem, newX, newY, time) => {
+      if (elem instanceof Window) {
+        window.scrollTo(newX, newY);
+      } else if (elem.nodeType === 9) {
+        // @ts-ignore
+        elem.defaultView.scrollTo(newX, newY);
+      } else {
+        const startX = elem instanceof Window ? window.scrollX : elem.scrollLeft;
+        const startY = elem instanceof Window ? window.scrollY : elem.scrollTop;
+        if (startX !== newX) elem.scrollLeft = newX;
+        if (startY !== newY) elem.scrollTop = newY;
+      }
+      if (typeof onAnimation === 'function')
+        onAnimation({ x: newX, y: newY, isComplete: time >= 1, time });
+    };
+
+    TinyHtml_TinyHtml._preElemsAndWindow(el, 'scrollToXY').forEach((elem) => {
+      const startX = elem instanceof Window ? window.scrollX : elem.scrollLeft;
+      const startY = elem instanceof Window ? window.scrollY : elem.scrollTop;
+      const targX = targetX ?? startX;
+      const targY = targetY ?? startY;
+
+      const changeX = targX - startX;
+      const changeY = targY - startY;
+
+      const ease = (typeof easing === 'string' && TinyHtml_TinyHtml.easings[easing]) || null;
+      if (typeof duration !== 'number' || typeof ease !== 'function')
+        return executeScroll(elem, targX, targY, 1);
+      const startTime = performance.now();
+      const dur = duration ?? 0;
+
+      /**
+       * Animates the scroll position based on easing and time.
+       *
+       * @param {number} currentTime - Timestamp provided by requestAnimationFrame.
+       */
+      function animateScroll(currentTime) {
+        if (typeof ease !== 'function') return;
+        const time = Math.min(1, (currentTime - startTime) / dur);
+        const easedTime = ease(time);
+
+        const newX = startX + changeX * easedTime;
+        const newY = startY + changeY * easedTime;
+        executeScroll(elem, newX, newY, time);
+
+        if (time < 1) requestAnimationFrame(animateScroll);
+      }
+
+      requestAnimationFrame(animateScroll);
+    });
+    return el;
+  }
+
+  /**
+   * Smoothly scrolls one or more elements (or the window) to the specified X and Y coordinates
+   * using a custom duration and easing function.
+   *
+   * If `duration` or a valid `easing` is not provided, the scroll will be performed immediately.
+   *
+   * @param {Object} [settings={}] - Configuration object for the scroll animation.
+   * @param {number} [settings.targetX] - The horizontal scroll target in pixels.
+   * @param {number} [settings.targetY] - The vertical scroll target in pixels.
+   * @param {number} [settings.duration] - The duration of the animation in milliseconds.
+   * @param {Easings} [settings.easing] - The easing function name to use for the scroll animation.
+   * @param {OnScrollAnimation} [settings.onAnimation] - Optional callback invoked on each animation
+   *   frame with the current scroll position, normalized animation time (`0` to `1`), and a completion flag.
+   * @returns {TinyElementAndWindow|TinyElementAndWindow[]}
+   */
+  scrollToXY({ targetX, targetY, duration, easing, onAnimation } = {}) {
+    return TinyHtml_TinyHtml.scrollToXY(this, { targetX, targetY, duration, easing, onAnimation });
+  }
+
   /**
    * Sets the vertical scroll position.
    * @param {TinyElementAndWindow|TinyElementAndWindow[]} el - Element or window.
    * @param {number} value - Scroll top value.
+   * @returns {TinyElementAndWindow|TinyElementAndWindow[]}
    */
   static setScrollTop(el, value) {
     if (typeof value !== 'number') throw new TypeError('ScrollTop value must be a number.');
-    TinyHtml_TinyHtml._preElemsAndWindow(el, 'setScrollTop').forEach((elem) => {
-      if (TinyHtml_TinyHtml.isWindow(elem)) {
-        elem.scrollTo(elem.pageXOffset, value);
-      } else if (elem.nodeType === 9) {
-        // @ts-ignore
-        elem.defaultView.scrollTo(elem.defaultView.pageXOffset, value);
-      } else {
-        elem.scrollTop = value;
-      }
-    });
+    return TinyHtml_TinyHtml.scrollToXY(el, { targetY: value });
   }
 
   /**
    * Sets the vertical scroll position.
    * @param {number} value - Scroll top value.
+   * @returns {TinyElementAndWindow|TinyElementAndWindow[]}
    */
   setScrollTop(value) {
     return TinyHtml_TinyHtml.setScrollTop(this, value);
@@ -9646,24 +10121,17 @@ class TinyHtml_TinyHtml {
    * Sets the horizontal scroll position.
    * @param {TinyElementAndWindow|TinyElementAndWindow[]} el - Element or window.
    * @param {number} value - Scroll left value.
+   * @returns {TinyElementAndWindow|TinyElementAndWindow[]}
    */
   static setScrollLeft(el, value) {
     if (typeof value !== 'number') throw new TypeError('ScrollLeft value must be a number.');
-    TinyHtml_TinyHtml._preElemsAndWindow(el, 'setScrollLeft').forEach((elem) => {
-      if (TinyHtml_TinyHtml.isWindow(elem)) {
-        elem.scrollTo(value, elem.pageYOffset);
-      } else if (elem.nodeType === 9) {
-        // @ts-ignore
-        elem.defaultView.scrollTo(value, elem.defaultView.pageYOffset);
-      } else {
-        elem.scrollLeft = value;
-      }
-    });
+    return TinyHtml_TinyHtml.scrollToXY(el, { targetX: value });
   }
 
   /**
    * Sets the horizontal scroll position.
    * @param {number} value - Scroll left value.
+   * @returns {TinyElementAndWindow|TinyElementAndWindow[]}
    */
   setScrollLeft(value) {
     return TinyHtml_TinyHtml.setScrollLeft(this, value);
@@ -9794,15 +10262,16 @@ class TinyHtml_TinyHtml {
 
   /**
    * Adds one or more CSS class names to the element.
-   * @type {(el: TinyElement|TinyElement[], ...tokens: string[]) => void} - One or more class names to add.
+   * @type {(el: TinyElement|TinyElement[], ...tokens: string[]) => (TinyElement|TinyElement[])} - One or more class names to add.
    */
   static addClass(el, ...args) {
     TinyHtml_TinyHtml._preElems(el, 'addClass').forEach((elem) => elem.classList.add(...args));
+    return el;
   }
 
   /**
    * Adds one or more CSS class names to the element.
-   * @type {(...tokens: string[]) => void} - One or more class names to add.
+   * @type {(...tokens: string[]) => (TinyElement|TinyElement[])} - One or more class names to add.
    */
   addClass(...args) {
     return TinyHtml_TinyHtml.addClass(this, ...args);
@@ -9810,15 +10279,16 @@ class TinyHtml_TinyHtml {
 
   /**
    * Removes one or more CSS class names from the element.
-   * @type {(el: TinyElement|TinyElement[], ...tokens: string[]) => void} - One or more class names to remove.
+   * @type {(el: TinyElement|TinyElement[], ...tokens: string[]) => (TinyElement|TinyElement[])} - One or more class names to remove.
    */
   static removeClass(el, ...args) {
     TinyHtml_TinyHtml._preElems(el, 'removeClass').forEach((elem) => elem.classList.remove(...args));
+    return el;
   }
 
   /**
    * Removes one or more CSS class names from the element.
-   * @type {(...tokens: string[]) => void} - One or more class names to remove.
+   * @type {(...tokens: string[]) => (TinyElement|TinyElement[])} - One or more class names to remove.
    */
   removeClass(...args) {
     return TinyHtml_TinyHtml.removeClass(this, ...args);
@@ -10028,15 +10498,18 @@ class TinyHtml_TinyHtml {
    * Set text content of elements.
    * @param {TinyElement|TinyElement[]} el
    * @param {string} value
+   * @returns {TinyElement|TinyElement[]}
    */
   static setText(el, value) {
     if (typeof value !== 'string') throw new Error('Value is not a valid string.');
     TinyHtml_TinyHtml._preElems(el, 'setText').forEach((el) => (el.textContent = value));
+    return el;
   }
 
   /**
    * Set text content of the element.
    * @param {string} value
+   * @returns {TinyElement|TinyElement[]}
    */
   setText(value) {
     return TinyHtml_TinyHtml.setText(this, value);
@@ -10045,13 +10518,16 @@ class TinyHtml_TinyHtml {
   /**
    * Remove all child nodes from each element.
    * @param {TinyElement|TinyElement[]} el
+   * @returns {TinyElement|TinyElement[]}
    */
   static empty(el) {
     TinyHtml_TinyHtml._preElems(el, 'empty').forEach((el) => (el.textContent = ''));
+    return el;
   }
 
   /**
    * Remove all child nodes of the element.
+   * @returns {TinyElement|TinyElement[]}
    */
   empty() {
     return TinyHtml_TinyHtml.empty(this);
@@ -10059,35 +10535,40 @@ class TinyHtml_TinyHtml {
 
   /**
    * Get the innerHTML of the element.
-   * @param {TinyElement|TinyElement[]} el
+   * @param {TinyElement} el
+   * @param {GetHTMLOptions} [ops]
    * @returns {string}
    */
-  static html(el) {
+  static html(el, ops) {
     const elem = TinyHtml_TinyHtml._preElem(el, 'html');
-    return elem.innerHTML;
+    return elem.getHTML(ops);
   }
 
   /**
    * Get the innerHTML of the element.
+   * @param {GetHTMLOptions} [ops]
    * @returns {string}
    */
-  html() {
-    return TinyHtml_TinyHtml.html(this);
+  html(ops) {
+    return TinyHtml_TinyHtml.html(this, ops);
   }
 
   /**
    * Set the innerHTML of each element.
    * @param {TinyElement|TinyElement[]} el
    * @param {string} value
+   * @returns {TinyElement|TinyElement[]}
    */
   static setHtml(el, value) {
     if (typeof value !== 'string') throw new Error('Value is not a valid string.');
     TinyHtml_TinyHtml._preElems(el, 'setHtml').forEach((el) => (el.innerHTML = value));
+    return el;
   }
 
   /**
    * Set the innerHTML of the element.
    * @param {string} value
+   * @returns {TinyElement|TinyElement[]}
    */
   setHtml(value) {
     return TinyHtml_TinyHtml.setHtml(this, value);
@@ -10221,6 +10702,7 @@ class TinyHtml_TinyHtml {
    * @param {TinyInputElement|TinyInputElement[]} el - Target element.
    * @param {SetValueList|((el: InputElement, val: SetValueList) => SetValueList)} value - The value to assign or a function that returns it.
    * @throws {Error} If the computed value is not a valid string or boolean.
+   * @returns {TinyInputElement|TinyInputElement[]}
    */
   static setVal(el, value) {
     TinyHtml_TinyHtml._preInputElems(el, 'setVal').forEach((elem) => {
@@ -10260,6 +10742,7 @@ class TinyHtml_TinyHtml {
         if (typeof valToSet === 'string') elem.value = valToSet;
       }
     });
+    return el;
   }
 
   /**
@@ -10267,6 +10750,7 @@ class TinyHtml_TinyHtml {
    * Accepts strings, numbers, booleans or arrays of these values, or a callback function that computes them.
    *
    * @param {SetValueList|((el: InputElement, val: SetValueList) => SetValueList)} value - The value to assign or a function that returns it.
+   * @returns {TinyInputElement|TinyInputElement[]}
    * @throws {Error} If the computed value is not a valid string or boolean.
    */
   setVal(value) {
@@ -10536,6 +11020,7 @@ class TinyHtml_TinyHtml {
    * @param {string} event - The event type (e.g. 'click', 'keydown').
    * @param {EventRegistryHandle} handler - The callback function to run on event.
    * @param {EventRegistryOptions} [options] - Optional event listener options.
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   static on(el, event, handler, options) {
     if (typeof event !== 'string') throw new TypeError('The event name must be a string.');
@@ -10548,6 +11033,7 @@ class TinyHtml_TinyHtml {
       if (!Array.isArray(events[event])) events[event] = [];
       events[event].push({ handler, options });
     });
+    return el;
   }
 
   /**
@@ -10556,6 +11042,7 @@ class TinyHtml_TinyHtml {
    * @param {string} event - The event type (e.g. 'click', 'keydown').
    * @param {EventRegistryHandle} handler - The callback function to run on event.
    * @param {EventRegistryOptions} [options] - Optional event listener options.
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   on(event, handler, options) {
     return TinyHtml_TinyHtml.on(this, event, handler, options);
@@ -10568,6 +11055,7 @@ class TinyHtml_TinyHtml {
    * @param {string} event - The event type (e.g. 'click', 'keydown').
    * @param {EventRegistryHandle} handler - The callback function to run on event.
    * @param {EventRegistryOptions} [options={}] - Optional event listener options.
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   static once(el, event, handler, options = {}) {
     if (typeof event !== 'string') throw new TypeError('The event name must be a string.');
@@ -10585,6 +11073,7 @@ class TinyHtml_TinyHtml {
         typeof options === 'boolean' ? options : { ...options, once: true },
       );
     });
+    return el;
   }
 
   /**
@@ -10593,6 +11082,7 @@ class TinyHtml_TinyHtml {
    * @param {string} event - The event type (e.g. 'click', 'keydown').
    * @param {EventRegistryHandle} handler - The callback function to run on event.
    * @param {EventRegistryOptions} [options={}] - Optional event listener options.
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   once(event, handler, options = {}) {
     return TinyHtml_TinyHtml.once(this, event, handler, options);
@@ -10605,6 +11095,7 @@ class TinyHtml_TinyHtml {
    * @param {string} event - The event type.
    * @param {EventRegistryHandle} handler - The function originally bound to the event.
    * @param {boolean|EventListenerOptions} [options] - Optional listener options.
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   static off(el, event, handler, options) {
     if (typeof event !== 'string') throw new TypeError('The event name must be a string.');
@@ -10617,6 +11108,7 @@ class TinyHtml_TinyHtml {
         if (events[event].length === 0) delete events[event];
       }
     });
+    return el;
   }
 
   /**
@@ -10625,6 +11117,7 @@ class TinyHtml_TinyHtml {
    * @param {string} event - The event type.
    * @param {EventRegistryHandle} handler - The function originally bound to the event.
    * @param {boolean|EventListenerOptions} [options] - Optional listener options.
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   off(event, handler, options) {
     return TinyHtml_TinyHtml.off(this, event, handler, options);
@@ -10635,6 +11128,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {TinyEventTarget|TinyEventTarget[]} el - The target element.
    * @param {string} event - The event type to remove (e.g. 'click').
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   static offAll(el, event) {
     if (typeof event !== 'string') throw new TypeError('The event name must be a string.');
@@ -10647,12 +11141,14 @@ class TinyHtml_TinyHtml {
         delete events[event];
       }
     });
+    return el;
   }
 
   /**
    * Removes all event listeners of a specific type from the element.
    *
    * @param {string} event - The event type to remove (e.g. 'click').
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   offAll(event) {
     return TinyHtml_TinyHtml.offAll(this, event);
@@ -10664,6 +11160,7 @@ class TinyHtml_TinyHtml {
    * @param {TinyEventTarget|TinyEventTarget[]} el - The target element.
    * @param {((handler: EventListenerOrEventListenerObject, event: string) => boolean)|null} [filterFn=null] -
    *        Optional filter function to selectively remove specific handlers.
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   static offAllTypes(el, filterFn = null) {
     if (filterFn !== null && typeof filterFn !== 'function')
@@ -10682,6 +11179,7 @@ class TinyHtml_TinyHtml {
 
       __eventRegistry.delete(elem);
     });
+    return el;
   }
 
   /**
@@ -10689,6 +11187,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {((handler: EventListenerOrEventListenerObject, event: string) => boolean)|null} [filterFn=null] -
    *        Optional filter function to selectively remove specific handlers.
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   offAllTypes(filterFn = null) {
     return TinyHtml_TinyHtml.offAllTypes(this, filterFn);
@@ -10700,6 +11199,7 @@ class TinyHtml_TinyHtml {
    * @param {TinyEventTarget|TinyEventTarget[]} el - Target element where the event should be triggered.
    * @param {string} event - Name of the event to trigger.
    * @param {Event|CustomEvent|CustomEventInit} [payload] - Optional event object or data to pass.
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   static trigger(el, event, payload = {}) {
     if (typeof event !== 'string') throw new TypeError('The event name must be a string.');
@@ -10715,6 +11215,7 @@ class TinyHtml_TinyHtml {
 
       elem.dispatchEvent(evt);
     });
+    return el;
   }
 
   /**
@@ -10722,6 +11223,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {string} event - Name of the event to trigger.
    * @param {Event|CustomEvent|CustomEventInit} [payload] - Optional event object or data to pass.
+   * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   trigger(event, payload = {}) {
     return TinyHtml_TinyHtml.trigger(this, event, payload);
@@ -10764,6 +11266,7 @@ class TinyHtml_TinyHtml {
    * @param {TinyElement|TinyElement[]} el
    * @param {string} name
    * @param {string|null} [value=null]
+   * @returns {TinyElement|TinyElement[]}
    */
   static setAttr(el, name, value = null) {
     if (typeof name !== 'string') throw new TypeError('The "name" must be a string.');
@@ -10773,12 +11276,14 @@ class TinyHtml_TinyHtml {
       if (value === null) elem.removeAttribute(name);
       else elem.setAttribute(name, value);
     });
+    return el;
   }
 
   /**
    * Set an attribute on an element.
    * @param {string} name
    * @param {string|null} [value=null]
+   * @returns {TinyElement|TinyElement[]}
    */
   setAttr(name, value) {
     return TinyHtml_TinyHtml.setAttr(this, name, value);
@@ -10788,15 +11293,18 @@ class TinyHtml_TinyHtml {
    * Remove attribute(s) from an element.
    * @param {TinyElement|TinyElement[]} el
    * @param {string} name Space-separated list of attributes.
+   * @returns {TinyElement|TinyElement[]}
    */
   static removeAttr(el, name) {
     if (typeof name !== 'string') throw new TypeError('The "name" must be a string.');
     TinyHtml_TinyHtml._preElems(el, 'removeAttr').forEach((elem) => elem.removeAttribute(name));
+    return el;
   }
 
   /**
    * Remove attribute(s) from an element.
    * @param {string} name Space-separated list of attributes.
+   * @returns {TinyElement|TinyElement[]}
    */
   removeAttr(name) {
     return TinyHtml_TinyHtml.removeAttr(this, name);
@@ -10851,6 +11359,7 @@ class TinyHtml_TinyHtml {
    * Set a property on an element.
    * @param {TinyElement|TinyElement[]} el
    * @param {string} name
+   * @returns {TinyElement|TinyElement[]}
    */
   static addProp(el, name) {
     if (typeof name !== 'string') throw new TypeError('The "name" must be a string.');
@@ -10860,11 +11369,13 @@ class TinyHtml_TinyHtml {
       // @ts-ignore
       elem[name] = true;
     });
+    return el;
   }
 
   /**
    * Set a property on an element.
    * @param {string} name
+   * @returns {TinyElement|TinyElement[]}
    */
   addProp(name) {
     return TinyHtml_TinyHtml.addProp(this, name);
@@ -10874,6 +11385,7 @@ class TinyHtml_TinyHtml {
    * Remove a property from an element.
    * @param {TinyElement|TinyElement[]} el
    * @param {string} name
+   * @returns {TinyElement|TinyElement[]}
    */
   static removeProp(el, name) {
     if (typeof name !== 'string') throw new TypeError('The "name" must be a string.');
@@ -10883,11 +11395,13 @@ class TinyHtml_TinyHtml {
       // @ts-ignore
       elem[name] = false;
     });
+    return el;
   }
 
   /**
    * Remove a property from an element.
    * @param {string} name
+   * @returns {TinyElement|TinyElement[]}
    */
   removeProp(name) {
     return TinyHtml_TinyHtml.removeProp(this, name);
@@ -10928,13 +11442,16 @@ class TinyHtml_TinyHtml {
   /**
    * Removes an element from the DOM.
    * @param {TinyElement|TinyElement[]} el - The DOM element or selector to remove.
+   * @returns {TinyElement|TinyElement[]}
    */
   static remove(el) {
     TinyHtml_TinyHtml._preElems(el, 'remove').forEach((elem) => elem.remove());
+    return el;
   }
 
   /**
    * Removes the element from the DOM.
+   * @returns {TinyElement|TinyElement[]}
    */
   remove() {
     return TinyHtml_TinyHtml.remove(this);
@@ -11278,6 +11795,14 @@ class TinyHtml_TinyHtml {
    */
   static isInViewport(el) {
     const elem = TinyHtml_TinyHtml._preElem(el, 'isInViewport');
+    if (
+      !elem.checkVisibility({
+        contentVisibilityAuto: false,
+        opacityProperty: false,
+        visibilityProperty: false,
+      })
+    )
+      return false;
     const elementTop = TinyHtml_TinyHtml.offset(elem).top;
     const elementBottom = elementTop + TinyHtml_TinyHtml.outerHeight(elem);
 
@@ -11304,6 +11829,14 @@ class TinyHtml_TinyHtml {
    */
   static isScrolledIntoView(el) {
     const elem = TinyHtml_TinyHtml._preElem(el, 'isScrolledIntoView');
+    if (
+      !elem.checkVisibility({
+        contentVisibilityAuto: false,
+        opacityProperty: false,
+        visibilityProperty: false,
+      })
+    )
+      return false;
     const docViewTop = TinyHtml_TinyHtml.scrollTop(window);
     const docViewBottom = docViewTop + TinyHtml_TinyHtml.height(window);
 
@@ -11321,33 +11854,138 @@ class TinyHtml_TinyHtml {
   isScrolledIntoView() {
     return TinyHtml_TinyHtml.isScrolledIntoView(this);
   }
-}
 
-/* harmony default export */ const libs_TinyHtml = (TinyHtml_TinyHtml);
+  /**
+   * Checks if the given element is at least partially visible within the boundaries of a container.
+   *
+   * @param {TinyElement} el - The DOM element to check.
+   * @param {TinyElement} cont - The container element acting as the viewport.
+   * @returns {boolean} True if the element is partially visible within the container, false otherwise.
+   */
+  static isInContainer(el, cont) {
+    const elem = TinyHtml_TinyHtml._preElem(el, 'isInContainer');
+    const container = TinyHtml_TinyHtml._preElem(cont, 'isInContainer');
 
-;// ./src/v1/basics/html_deprecated.mjs
+    if (
+      !elem.checkVisibility({
+        contentVisibilityAuto: false,
+        opacityProperty: false,
+        visibilityProperty: false,
+      })
+    )
+      return false;
+    const elemRect = elem.getBoundingClientRect();
+    const containerRect = container.getBoundingClientRect();
 
+    const verticallyVisible =
+      elemRect.bottom > containerRect.top && elemRect.top < containerRect.bottom;
 
-/**
- * Checks if two DOM elements are colliding on the screen.
- *
- * @param {Element} elem1 - First DOM element.
- * @param {Element} elem2 - Second DOM element.
- * @returns {boolean} - Returns true if the elements are colliding.
- * @deprecated - Use TinyHtml.isCollWith instead.
- */
-function areHtmlElsColliding(elem1, elem2) {
-  return libs_TinyHtml.isCollWith(elem1, elem2);
-}
+    const horizontallyVisible =
+      elemRect.right > containerRect.left && elemRect.left < containerRect.right;
 
-/**
- * Checks if two DOM elements are colliding on the screen.
- *
- * @param {Element} elem1 - First DOM element.
- * @param {Element} elem2 - Second DOM element.
- * @returns {boolean} - Returns true if the elements are colliding.
- * @deprecated - Use TinyHtml.isCollPerfWith instead.
- */
+    return verticallyVisible && horizontallyVisible;
+  }
+
+  /**
+   * Checks if the given element is at least partially visible within the boundaries of a container.
+   *
+   * @param {TinyElement} cont - The container element acting as the viewport.
+   * @returns {boolean} True if the element is partially visible within the container, false otherwise.
+   */
+  isInContainer(cont) {
+    return TinyHtml_TinyHtml.isInContainer(this, cont);
+  }
+
+  /**
+   * Checks if the given element is fully visible within the boundaries of a container (top and bottom).
+   *
+   * @param {TinyElement} el - The DOM element to check.
+   * @param {TinyElement} cont - The container element acting as the viewport.
+   * @returns {boolean} True if the element is fully visible within the container, false otherwise.
+   */
+  static isFullyInContainer(el, cont) {
+    const elem = TinyHtml_TinyHtml._preElem(el, 'isScrolledIntoView');
+    const container = TinyHtml_TinyHtml._preElem(cont, 'isInContainer');
+
+    if (
+      !elem.checkVisibility({
+        contentVisibilityAuto: false,
+        opacityProperty: false,
+        visibilityProperty: false,
+      })
+    )
+      return false;
+    const elemRect = elem.getBoundingClientRect();
+    const containerRect = container.getBoundingClientRect();
+
+    const isFullyVisible =
+      elemRect.top >= containerRect.top &&
+      elemRect.bottom <= containerRect.bottom &&
+      elemRect.left >= containerRect.left &&
+      elemRect.right <= containerRect.right;
+
+    return isFullyVisible;
+  }
+
+  /**
+   * Checks if the given element is fully visible within the boundaries of a container (top and bottom).
+   *
+   * @param {TinyElement} cont - The container element acting as the viewport.
+   * @returns {boolean} True if the element is fully visible within the container, false otherwise.
+   */
+  isFullyInContainer(cont) {
+    return TinyHtml_TinyHtml.isFullyInContainer(this, cont);
+  }
+
+  /**
+   * Checks if an element has scrollable content.
+   *
+   * @param {TinyElement} el - The DOM element to check.
+   * @returns {{ v: boolean, h: boolean }} - True if scroll is needed in that direction.
+   */
+  static hasScroll(el) {
+    const elem = TinyHtml_TinyHtml._preElem(el, 'hasScroll');
+    return {
+      v: elem.scrollHeight > elem.clientHeight,
+      h: elem.scrollWidth > elem.clientWidth,
+    };
+  }
+
+  /**
+   * Checks if an element has scrollable content.
+   *
+   * @returns {{ v: boolean, h: boolean }} - True if scroll is needed in that direction.
+   */
+  hasScroll() {
+    return TinyHtml_TinyHtml.hasScroll(this);
+  }
+}
+
+/* harmony default export */ const libs_TinyHtml = (TinyHtml_TinyHtml);
+
+;// ./src/v1/basics/html_deprecated.mjs
+
+
+/**
+ * Checks if two DOM elements are colliding on the screen.
+ *
+ * @param {Element} elem1 - First DOM element.
+ * @param {Element} elem2 - Second DOM element.
+ * @returns {boolean} - Returns true if the elements are colliding.
+ * @deprecated - Use TinyHtml.isCollWith instead.
+ */
+function areHtmlElsColliding(elem1, elem2) {
+  return libs_TinyHtml.isCollWith(elem1, elem2);
+}
+
+/**
+ * Checks if two DOM elements are colliding on the screen.
+ *
+ * @param {Element} elem1 - First DOM element.
+ * @param {Element} elem2 - Second DOM element.
+ * @returns {boolean} - Returns true if the elements are colliding.
+ * @deprecated - Use TinyHtml.isCollPerfWith instead.
+ */
 function areHtmlElsPerfColliding(elem1, elem2) {
   return TinyHtml.isCollPerfWith(elem1, elem2);
 }
@@ -13951,7 +14589,1941 @@ class TinyAfterScrollWatcher {
 
 /* harmony default export */ const libs_TinyAfterScrollWatcher = (TinyAfterScrollWatcher);
 
-;// ./src/v1/index.mjs
+;// ./src/v1/libs/UltraRandomMsgGen.mjs
+const defaultWords = [
+  'lorem',
+  'ipsum',
+  'dolor',
+  'sit',
+  'amet',
+  'consectetur',
+  'adipiscing',
+  'elit',
+  'sed',
+  'do',
+  'eiusmod',
+  'tempor',
+  'incididunt',
+  'ut',
+  'labore',
+  'et',
+  'dolore',
+  'magna',
+  'aliqua',
+];
+const defaultEmojis = [
+  '😂',
+  '🌈',
+  '🤖',
+  '💥',
+  '🐸',
+  '🍕',
+  '🦄',
+  '🧠',
+  '🧬',
+  '🚀',
+  '🫠',
+  '💫',
+  '🍩',
+  '👾',
+  '🎉',
+  '🥴',
+  '🐙',
+  '🧃',
+  '🪐',
+  '🎈',
+  '🧸',
+  '👻',
+  '🥳',
+  '🍭',
+  '💖',
+  '😺',
+  '🌮',
+  '🪅',
+  '🎮',
+  '🥓',
+  '🍮',
+];
+
+const defaultNouns = [
+  'pudding',
+  'bean',
+  'snuggle',
+  'bloop',
+  'jelly',
+  'unicorn',
+  'floof',
+  'giggle',
+  'bubble',
+  'muffin',
+  'puff',
+  'pickle',
+  'goblin',
+  'waffle',
+  'sprinkle',
+  'cupcake',
+  'fizzle',
+  'marshmallow',
+  'duckling',
+  'sock',
+  'cloud',
+  'teacup',
+  'nugget',
+  'gnome',
+  'hug',
+  'moonbean',
+  'crayon',
+  'jiggle',
+  'glitter',
+  'carrot',
+  'goober',
+];
+
+const defaultVerbs = [
+  'wiggles',
+  'bounces',
+  'flies',
+  'splats',
+  'scoots',
+  'giggles',
+  'wigglesnacks',
+  'twirls',
+  'boops',
+  'pops',
+  'sings',
+  'hugs',
+  'floats',
+  'glows',
+  'flaps',
+  'mlems',
+  'dances',
+  'puddles',
+  'nomnoms',
+  'wigglejumps',
+  'sniffs',
+  'tumbles',
+  'slides',
+  'chirps',
+  'burps',
+  'sparkles',
+  'waddles',
+  'rambles',
+  'blinks',
+  'mews',
+];
+
+const defaultAdjectives = [
+  'fluffy',
+  'silly',
+  'yummy',
+  'squishy',
+  'wobbly',
+  'magical',
+  'tiny',
+  'sleepy',
+  'wiggly',
+  'bubbly',
+  'glittery',
+  'fuzzy',
+  'jiggly',
+  'sparkly',
+  'giggly',
+  'crunchy',
+  'goofy',
+  'soft',
+  'mushy',
+  'sweet',
+  'loopy',
+  'floaty',
+  'bonkers',
+  'chewy',
+  'ticklish',
+  'dreamy',
+  'pastel',
+  'cozy',
+  'teensy',
+  'grumbly',
+];
+
+const defaultTemplates = [
+  // 🧁 Tiny
+  'Boop!',
+  'Wiggle achieved.',
+  'Oops, {noun} everywhere!',
+  'Tiny {adj} {noun}, big {adj} {noun}.',
+  'Snuggle initiated with a {adj} {noun}.',
+  '{adj} vibes only, powered by {noun}.',
+  'No {noun}, no {noun}.',
+  'Bounce first, {verb} later.',
+  'Mlem. {verb}. {noun}.',
+  '{noun} go brrr and {verb}.',
+  'Why not? {noun} did. Then {noun} followed.',
+
+  // 🍬 Simple
+  'A {adj} {noun} just {verb} near the {adj} window.',
+  'That {adj} {noun} stole my {noun}!',
+  'Look, a {adj} {noun} trying to {verb} again!',
+  'Every {noun} deserves a {adj} nap.',
+  'The {adj} {noun} is my {adj} spirit animal.',
+  'Someone call the {noun}, it’s {verb}ing and {verb}ing again!',
+  'Don’t touch the {adj} {noun}. It {verb}s loudly.',
+  '{noun} forgot how {noun}s work and just {verb}ed.',
+
+  // 🍩 Averages
+  'There once was a {adj} {noun} who loved to {verb} with a {adj} {noun} all day.',
+  'Apparently, {noun}s are banned from {verb}ing and {verb}ing in the {noun} library.',
+  'That {adj} noise? Just a {noun} learning to {verb} on a {adj} {noun}.',
+  'I saw a {adj} {noun} {verb} so hard, it became a {adj} muffin.',
+  'The {adj} {noun} met a {adj} pickle and everything {verb}ed.',
+  '{noun}s are like {noun}: {adj}, unpredictable, and wiggly.',
+  'Don’t judge a {adj} {noun} by its ability to {verb}, or by its {adj} hat.',
+  'All I wanted was peace, but a {adj} {noun} with a {adj} {noun} had other plans.',
+
+  // 🍓 Giants
+  'One {adj} morning, a {adj} {noun} decided it was finally time to {verb}, but halfway through, it tripped on a {noun} and turned into a {adj} marshmallow.',
+  'I tried to be {adj} today, but then a {noun} {verb}ed across my {noun} and typed “asdfgh{noun}” repeatedly.',
+  'If you think you’ve seen everything, wait until a {adj} {noun} {verb}s on a {noun} wearing {adj} socks with tiny {noun}s.',
+  'No one ever believed the stories about the ancient {adj} {noun} who could {verb} with such {adj} grace that entire {noun}s turned pink out of embarrassment.',
+  'A curious {adj} {noun} wandered into a {noun} shop, not knowing that its destiny involved twelve {adj} {noun}s, one rubber {noun}, and a suspiciously quiet {adj} llama.',
+
+  // 🍒 Giants and narratives
+  'In a land where every {adj} {noun} was made of pudding and the sky was {adj} whipped cream, one brave {adj} {noun} set out to discover the legendary Spoon of {noun}s, facing obstacles like bouncing {noun}s, sassy {noun}s, and the Great Wobble of the {noun}.',
+  'Once upon a {adj} time, long before the {noun}s learned to {verb}, there existed a tiny {adj} {noun} who dreamed of swimming in a pool made entirely of {adj} glitter pudding while {verb}ing off-key lullabies to passing {noun}s with monocles.',
+  'The Council of {noun}s gathered in {adj} secret when the sacred {adj} {noun} started to {verb} uncontrollably, threatening the entire {adj} dessert-based civilization with spontaneous {noun} jiggles and uncontainable {noun} fits across the {noun}.',
+
+  // ☎️ Chats and chats
+  'Hey... do you ever wonder if {noun}s dream of {noun}s?',
+  'Okay but hear me out: what if the {adj} {noun} could actually {verb} backwards?',
+  'Can we talk about the {noun} that just {verb}ed and vanished?',
+  'So I was talking to a {noun}, and it told me to stop being {adj}. Rude.',
+  'Not to alarm you, but there’s a {adj} {noun} behind you doing the {verb}.',
+  'Why does this {noun} keep staring at me like I owe it pudding?',
+  'Is this a safe space to admit I accidentally {verb}ed a {noun}?',
+  'I just walked into the room and someone shouted “{adj} {noun}!” — what did I miss?',
+  'Wait... we were supposed to bring a {noun}? No one told me!',
+  'Okay but what if the {adj} {noun} has feelings too?',
+  'Be honest, do I look like a {noun} that forgot how to {verb}?',
+  'If I say "oops", do I still have to explain why the {noun} is glowing?',
+  'I don’t know what’s going on but I brought snacks and a confused {noun}.',
+  'Do you think pudding knows it’s pudding? Just a thought.',
+  'Is this about the time I {verb}ed the {adj} {noun} by accident? Because I can explain.',
+
+  // 🌀 Confusions, unexpected entrances, lost people
+  'Wait, are we talking about {noun}s or am I on the wrong chat again?',
+  'What is this group even about? I just saw "pudding" and joined.',
+  'Hi! I have no idea what’s happening but I’m here and I brought a {noun}.',
+  'I blinked and now there’s a {adj} {noun} in charge of everything.',
+  'Can someone please explain why the {noun} is floating and chanting?',
+  'Okay who gave the {noun} access to glitter and emotional support pickles?',
+  'I came for a calm discussion and now there’s a {adj} battle between {noun}s.',
+  'Not sure if I’m early, late, or inside a {noun} dream.',
+  'I was gone for 3 minutes and now someone’s riding a {noun} into the pudding realm.',
+  'This isn’t the pudding appreciation group, is it? ...oh no.',
+  'So... who summoned the {adj} {noun} this time? Be honest.',
+  'I came here for vibes and stayed for the {noun}s.',
+  'Does anyone else hear faint giggling or is that just the {adj} {noun} again?',
+  'I feel like I missed step one, two, and also three of this conversation.',
+  'All I asked was “what’s up?” and now I’m emotionally attached to a {noun}.',
+
+  // 💬 More interactive chat style
+  'Me: "I’ll be normal today." Also me: *{verb}s into a meeting riding a {adj} {noun}*',
+  '"It’s just pudding," they said. "It can’t hurt you," they said. They were wrong.',
+  'I said one nice thing to a {noun} and now it follows me everywhere.',
+  'Can we take a moment to appreciate how the {adj} {noun} is just vibing?',
+  'Who put a tiny hat on the {noun}? Because that’s adorable.',
+  'My life has been different ever since the {noun} started {verb}ing.',
+  'Raise your hand if you’ve ever been personally attacked by a {adj} {noun}.',
+  '"Don’t be weird," they said. So I became a {noun} instead.',
+  'Do {noun}s have feelings? Asking for a {adj} friend.',
+  'I trusted the {noun} and all I got was a glitter-covered sock.',
+  'Plot twist: the {adj} {noun} was inside us all along.',
+
+  // Mini cute explosions and chaos
+  'The {adj} {noun} {verb} and {verb} all over the {adj} {noun}!',
+  'Oops! {noun}s {verb}ed into the {adj} {noun} while {verb}ing crazily.',
+  '{adj}, {adj}, and more {adj} {noun}s just {verb}ed by!',
+  'Why does the {adj} {noun} keep {verb}ing and {verb}ing without stopping?',
+  'Look! A {adj} {noun}, a {adj} {noun}, and a {noun} all {verb}ing together!',
+  'Sometimes, the {noun} just {verb}s, then {verb}s again, and never stops being {adj}.',
+
+  // Phrases with repetition and multiple spaces for chaos
+  '{noun}, {noun}, and {noun} — all {verb}ing and {verb}ing in a {adj} {noun}.',
+  'I saw a {adj} {noun} {verb}, then another {noun} {verb}ing with a {adj} {noun}.',
+  'The {noun} {verb}s {verb} while the {adj} {noun} {verb}s and the {noun} just {verb}s.',
+  'Can a {adj} {noun} {verb} {verb} without a {adj} {noun} watching?',
+
+  // Phrases with interactions and breaks for fun
+  'Whoa! The {adj} {noun} just {verb}ed... and then {verb}ed again!',
+  'Hey... did you see that {adj} {noun} {verb} over there?',
+  'Umm, the {noun} is {verb}ing but also {verb}ing and {verb}ing!',
+  'Lol! {noun}s {verb} so {adj}ly, it’s impossible not to giggle.',
+
+  // Mini exaggerated and cute dialogues
+  '"Hey! What’s up?" asked the {adj} {noun}, who {verb}ed loudly.',
+  '"I’m just a {adj} {noun} trying to {verb}, you know?"',
+  '"Did you see the {adj} {noun} that just {verb}ed in the pudding?"',
+  '"No way! The {noun} {verb}s better than me!"',
+  '"Wait, the {adj} {noun} said it would {verb}, but it {verb}ed instead!"',
+
+  // Extensive, crazy and fun narrative phrases
+  'Once upon a {adj} {noun}, a group of {adj} {noun}s {verb}ed through the {adj} forest, singing {adj} songs and eating {noun}s made of pudding.',
+  'The legend tells of a {adj} {noun} who could {verb} faster than any {noun} ever seen, leaving trails of {adj} sparkles behind.',
+  'Every day, the {adj} {noun} would {verb} around the {adj} meadow, trying to convince the {noun}s to join the grand pudding party.',
+  'No one knows why the {adj} {noun} suddenly {verb}ed and then {verb}ed again, but everyone agrees it was the cutest thing they ever saw.',
+  'In the kingdom of {adj} {noun}s, only the bravest {noun} dared to {verb} the giant pudding monster, armed with nothing but {adj} smiles and jellybeans.',
+
+  // Total cases with many placeholders
+  '{adj} {noun} {verb} {verb} {verb} {noun} {verb} {adj} {noun} {verb} {noun}!',
+  '{noun} {noun} {verb} {adj} {noun} and then {verb} {verb} the {adj} {noun}.',
+  '{verb} the {adj} {noun}, then {verb} the {noun} while {verb}ing {adj}ly.',
+  'Can the {adj} {noun} {verb} and {verb} the {adj} {noun} at the same time?',
+  '{noun} {verb} {noun} {verb}, but the {adj} {noun} {verb}s better.',
+
+  // Frases with cute interjections and silly sounds
+  'Boop! The {adj} {noun} just {verb}ed in the pudding.',
+  'Bloop bloop, the {noun} is {verb}ing all over again!',
+  'Mlem mlem, a {adj} {noun} {verb}s quietly in the corner.',
+  'Splat! {noun} {verb}ed right on the {adj} {noun}.',
+  'Yum! A {adj} {noun} just {verb}ed in my mouth.',
+
+  // Phrases with silly questions
+  'Do {noun}s really {verb} when nobody’s watching?',
+  'Why does the {adj} {noun} always {verb} at midnight?',
+  'Can a {noun} be too {adj} to {verb} properly?',
+  'Is it normal for a {adj} {noun} to {verb} three times in a row?',
+  'Who taught the {noun} to {verb} like that?',
+
+  // Frases of confusion and fun surprises
+  'Wait, did the {adj} {noun} just {verb} itself?',
+  'I can’t believe the {noun} {verb}ed into a {adj} {noun}!',
+  'Suddenly, a {adj} {noun} appeared and started to {verb} wildly.',
+  'That {noun} was {verb}ing so {adj}ly it broke the pudding meter.',
+  'Everyone’s talking about the {adj} {noun} that {verb}ed out of nowhere.',
+];
+
+/**
+ * @typedef {'mixed'|'readable'|'chaotic'|'natural'} RandomMsgModes
+ * Defines how the message content is generated:
+ * - `mixed`: Combines readable words, gibberish, symbols, emojis, etc.
+ * - `readable`: Focuses on human-readable words only.
+ * - `chaotic`: Pure chaos, mostly gibberish and symbols.
+ * - `natural`: Uses structured grammar templates to form silly but proper sentences.
+ */
+
+/**
+ * @typedef {'inline'|'end'|'none'} EmojiPlacement
+ * Controls where emojis are placed:
+ * - `inline`: Emojis may appear throughout the text.
+ * - `end`: Emojis appear at the end of lines.
+ * - `none`: No emojis will be used.
+ */
+
+/**
+ * @typedef {Object} MsgGenConfig
+ * Configuration object for customizing message generation.
+ *
+ * @property {number} minLength - Minimum total length (in characters) of the final generated text.
+ * @property {number} maxLength - Maximum total length (in characters) of the final generated text.
+ * @property {boolean} readable - Whether to favor readable word-like strings.
+ * @property {boolean} useEmojis - Whether emojis are allowed in the generated content.
+ * @property {boolean} includeNumbers - Whether random numbers can appear in the text.
+ * @property {boolean} includeSymbols - Whether random symbols (e.g., !@#) are included.
+ * @property {boolean} allowWeirdSpacing - Enables fun spacing effects (e.g., extra spaces, newlines, uppercase words).
+ *
+ * @property {string[]} emojiSet - List of emojis to choose from. Overrides default set if provided.
+ * @property {string[]} wordSet - List of base words used in readable and mixed modes.
+ *
+ * @property {RandomMsgModes} mode - Determines the overall generation strategy (`mixed`, `readable`, `chaotic`, or `natural`).
+ *
+ * @property {Object} grammar - Grammar configuration used when `mode` is set to `'natural'`.
+ * @property {string[]} grammar.templates - Sentence templates using placeholders (`{noun}`, `{verb}`, `{adj}`).
+ * @property {string[]} grammar.nouns - List of nouns to insert into `{noun}` placeholders.
+ * @property {string[]} grammar.verbs - List of verbs to insert into `{verb}` placeholders.
+ * @property {string[]} grammar.adjectives - List of adjectives to insert into `{adj}` placeholders.
+ *
+ * @property {boolean} repeatWords - If false, avoids repeating the same word within a single generation.
+ * @property {EmojiPlacement} emojiPlacement - Controls how emojis are placed in the text.
+ *
+ * @property {Object} [paragraphs] - Optional paragraph configuration.
+ * @property {number} paragraphs.min - Minimum number of paragraphs to generate.
+ * @property {number} paragraphs.max - Maximum number of paragraphs to generate.
+ *
+ * @property {Object} line - Configuration for line-based generation.
+ * @property {number} line.minLength - Minimum number of characters per line.
+ * @property {number} line.maxLength - Maximum number of characters per line.
+ * @property {number} line.emojiChance - Probability (0 to 1) that a line will end with an emoji when allowed.
+ */
+
+/**
+ * UltraRandomMsgGen - Phrase templates and word lists
+ *
+ * Portions of the templates, word sets, and phrase structures
+ * were generated and expanded by ChatGPT (OpenAI).
+ *
+ * This content was crafted to produce innocent, playful, and diverse
+ * random messages focused on a pudding-themed, whimsical style.
+ *
+ * @class
+ */
+class UltraRandomMsgGen {
+  /** @type {string[]} */
+  static defaultWords = defaultWords;
+  /** @type {string[]} */
+  static defaultEmojis = defaultEmojis;
+  /** @type {string[]} */
+  static defaultNouns = defaultNouns;
+  /** @type {string[]} */
+  static defaultVerbs = defaultVerbs;
+  /** @type {string[]} */
+  static defaultAdjectives = defaultAdjectives;
+  /** @type {string[]} */
+  static defaultTemplates = defaultTemplates;
+
+  /** @type {MsgGenConfig} */
+  config = {
+    minLength: 10,
+    maxLength: 300,
+    readable: true,
+    useEmojis: true,
+    includeNumbers: true,
+    includeSymbols: true,
+    allowWeirdSpacing: false,
+    emojiSet: [],
+    wordSet: [],
+    mode: 'mixed', // 'mixed', 'readable', 'chaotic'
+    grammar: {
+      templates: [],
+      nouns: [],
+      verbs: [],
+      adjectives: [],
+    },
+    repeatWords: true,
+    emojiPlacement: 'inline', // 'inline' | 'end' | 'none'
+    line: {
+      minLength: 20,
+      maxLength: 120,
+      emojiChance: 0.3, // 30% chance per line
+    },
+  };
+
+  /**
+   * Creates an instance of UltraRandomMsgGen.
+   *
+   * @param {Object} [config={}] - Configuration object to customize the generator.
+   * @param {number} [config.minLength=10] - Minimum total length (in characters) of generated text.
+   * @param {number} [config.maxLength=300] - Maximum total length (in characters) of generated text.
+   * @param {boolean} [config.readable=true] - Whether to generate readable words or random strings.
+   * @param {boolean} [config.useEmojis=true] - Whether to include emojis in the generated text.
+   * @param {boolean} [config.includeNumbers=true] - Whether to include numbers randomly.
+   * @param {boolean} [config.includeSymbols=true] - Whether to include symbols randomly.
+   * @param {boolean} [config.allowWeirdSpacing=false] - Whether to allow weird spacing (newlines, extra spaces, uppercase).
+   * @param {string[]} [config.emojiSet] - Array of emojis to use (defaults to internal emoji set).
+   * @param {string[]} [config.wordSet] - Array of words to use (defaults to internal word set).
+   * @param {RandomMsgModes} [config.mode='mixed'] - Mode of text generation.
+   * @param {Object} [config.grammar] - Grammar configuration with templates and word categories.
+   * @param {string[]} [config.grammar.templates] - Array of string templates with placeholders for generating sentences.
+   * @param {string[]} [config.grammar.nouns] - Array of noun strings for template substitution.
+   * @param {string[]} [config.grammar.verbs] - Array of verb strings for template substitution.
+   * @param {string[]} [config.grammar.adjectives] - Array of adjective strings for template substitution.
+   * @param {boolean} [config.repeatWords=true] - Whether to allow repeating words in the output.
+   * @param {EmojiPlacement} [config.emojiPlacement='inline'] - Placement mode for emojis in generated text.
+   * @param {Object} [config.paragraphs] - Paragraph configuration object or null for single block text.
+   * @param {number} [config.paragraphs.min] - Minimum number of paragraphs to generate.
+   * @param {number} [config.paragraphs.max] - Maximum number of paragraphs to generate.
+   * @param {Object} [config.line] - Line configuration for generated text.
+   * @param {number} [config.line.minLength=20] - Minimum length (characters) per line.
+   * @param {number} [config.line.maxLength=120] - Maximum length (characters) per line.
+   * @param {number} [config.line.emojiChance=0.3] - Probability (0–1) of placing emoji per line.
+   */
+  constructor(config = {}) {
+    this.symbols = '!@#$%^&*()-_=+[]{}|;:,.<>?/\\~'.split('');
+
+    const {
+      minLength,
+      maxLength,
+      readable,
+      useEmojis,
+      includeNumbers,
+      includeSymbols,
+      allowWeirdSpacing,
+      emojiSet,
+      wordSet,
+      mode,
+      grammar,
+      repeatWords,
+      emojiPlacement,
+      paragraphs,
+      line,
+    } = config;
+
+    // Validations
+    if (minLength !== undefined && (!Number.isInteger(minLength) || minLength < 1)) {
+      throw new TypeError('config.minLength must be an integer >= 1');
+    }
+
+    if (maxLength !== undefined && (!Number.isInteger(maxLength) || maxLength < 1)) {
+      throw new TypeError('config.maxLength must be an integer >= 1');
+    }
+
+    if (minLength !== undefined && maxLength !== undefined && minLength > maxLength) {
+      throw new RangeError('config.minLength cannot be greater than config.maxLength');
+    }
+
+    if (readable !== undefined && typeof readable !== 'boolean') {
+      throw new TypeError('config.readable must be a boolean');
+    }
+
+    if (useEmojis !== undefined && typeof useEmojis !== 'boolean') {
+      throw new TypeError('config.useEmojis must be a boolean');
+    }
+
+    if (includeNumbers !== undefined && typeof includeNumbers !== 'boolean') {
+      throw new TypeError('config.includeNumbers must be a boolean');
+    }
+
+    if (includeSymbols !== undefined && typeof includeSymbols !== 'boolean') {
+      throw new TypeError('config.includeSymbols must be a boolean');
+    }
+
+    if (allowWeirdSpacing !== undefined && typeof allowWeirdSpacing !== 'boolean') {
+      throw new TypeError('config.allowWeirdSpacing must be a boolean');
+    }
+
+    if (emojiSet !== undefined && !Array.isArray(emojiSet)) {
+      throw new TypeError('config.emojiSet must be an array of strings');
+    }
+
+    if (wordSet !== undefined && !Array.isArray(wordSet)) {
+      throw new TypeError('config.wordSet must be an array of strings');
+    }
+
+    if (mode !== undefined && !['mixed', 'readable', 'chaotic', 'natural'].includes(mode)) {
+      throw new RangeError('config.mode must be one of: "mixed", "readable", "chaotic", "natural');
+    }
+
+    if (grammar !== undefined) {
+      if (typeof grammar !== 'object' || grammar === null) {
+        throw new TypeError('config.grammar must be an object');
+      }
+      const { templates, nouns, verbs, adjectives } = grammar;
+      if (templates !== undefined && !Array.isArray(templates)) {
+        throw new TypeError('config.grammar.templates must be an array of strings');
+      }
+      if (nouns !== undefined && !Array.isArray(nouns)) {
+        throw new TypeError('config.grammar.nouns must be an array of strings');
+      }
+      if (verbs !== undefined && !Array.isArray(verbs)) {
+        throw new TypeError('config.grammar.verbs must be an array of strings');
+      }
+      if (adjectives !== undefined && !Array.isArray(adjectives)) {
+        throw new TypeError('config.grammar.adjectives must be an array of strings');
+      }
+    }
+
+    if (repeatWords !== undefined && typeof repeatWords !== 'boolean') {
+      throw new TypeError('config.repeatWords must be a boolean');
+    }
+
+    if (emojiPlacement !== undefined && !['inline', 'end', 'none'].includes(emojiPlacement)) {
+      throw new RangeError('config.emojiPlacement must be one of: "inline", "end", "none"');
+    }
+
+    if (paragraphs !== undefined) {
+      if (typeof paragraphs !== 'object') {
+        throw new TypeError('config.paragraphs must be an object or null');
+      }
+      const { min, max } = paragraphs;
+      if (min !== undefined && (!Number.isInteger(min) || min < 1)) {
+        throw new TypeError('config.paragraphs.min must be an integer >= 1');
+      }
+      if (max !== undefined && (!Number.isInteger(max) || max < 1)) {
+        throw new TypeError('config.paragraphs.max must be an integer >= 1');
+      }
+      if (min !== undefined && max !== undefined && min > max) {
+        throw new RangeError('config.paragraphs.min cannot be greater than config.paragraphs.max');
+      }
+    }
+
+    if (line !== undefined) {
+      if (typeof line !== 'object' || line === null) {
+        throw new TypeError('config.line must be an object');
+      }
+      const { minLength: lineMin, maxLength: lineMax, emojiChance } = line;
+      if (lineMin !== undefined && (!Number.isInteger(lineMin) || lineMin < 1)) {
+        throw new TypeError('config.line.minLength must be an integer >= 1');
+      }
+      if (lineMax !== undefined && (!Number.isInteger(lineMax) || lineMax < 1)) {
+        throw new TypeError('config.line.maxLength must be an integer >= 1');
+      }
+      if (lineMin !== undefined && lineMax !== undefined && lineMin > lineMax) {
+        throw new RangeError('config.line.minLength cannot be greater than config.line.maxLength');
+      }
+      if (
+        emojiChance !== undefined &&
+        (typeof emojiChance !== 'number' || emojiChance < 0 || emojiChance > 1)
+      ) {
+        throw new RangeError('config.line.emojiChance must be a number between 0 and 1');
+      }
+    }
+
+    this.config.emojiSet = [...defaultEmojis];
+    this.config.wordSet = [...defaultWords];
+
+    this.config.grammar.templates = [...defaultTemplates];
+    this.config.grammar.nouns = [...defaultNouns];
+    this.config.grammar.verbs = [...defaultVerbs];
+    this.config.grammar.adjectives = [...defaultAdjectives];
+    Object.assign(this.config, config);
+  }
+
+  /**
+   * Merges new configuration values into the current instance.
+   * @param {Object} newConfig - Object with one or more configuration overrides.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  configure(newConfig = {}) {
+    Object.assign(this.config, newConfig);
+    return this;
+  }
+
+  /**
+   * Replaces the entire list of grammar templates.
+   * @param {...string[]} templates - One or more arrays or strings containing sentence templates.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  setGrammarTemplates(...templates) {
+    this.config.grammar.templates = templates.flat();
+    return this;
+  }
+
+  /**
+   * Adds new grammar templates to the existing list.
+   * @param {...string[]} templates - One or more arrays or strings containing sentence templates.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  addGrammarTemplates(...templates) {
+    this.config.grammar.templates.push(...templates.flat());
+    return this;
+  }
+
+  /**
+   * Replaces the list of noun words used in grammar templates.
+   * @param {...string[]} nouns - One or more arrays or strings of nouns.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  setGrammarNouns(...nouns) {
+    this.config.grammar.nouns = nouns.flat();
+    return this;
+  }
+
+  /**
+   * Adds noun words to the existing list used in grammar templates.
+   * @param {...string[]} nouns - One or more arrays or strings of nouns.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  addGrammarNouns(...nouns) {
+    this.config.grammar.nouns.push(...nouns.flat());
+    return this;
+  }
+
+  /**
+   * Replaces the list of verb words used in grammar templates.
+   * @param {...string[]} verbs - One or more arrays or strings of verbs.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  setGrammarVerbs(...verbs) {
+    this.config.grammar.verbs = verbs.flat();
+    return this;
+  }
+
+  /**
+   * Adds verb words to the existing list used in grammar templates.
+   * @param {...string[]} verbs - One or more arrays or strings of verbs.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  addGrammarVerbs(...verbs) {
+    this.config.grammar.verbs.push(...verbs.flat());
+    return this;
+  }
+
+  /**
+   * Replaces the list of adjective words used in grammar templates.
+   * @param {...string[]} adjectives - One or more arrays or strings of adjectives.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  setGrammarAdjectives(...adjectives) {
+    this.config.grammar.adjectives = adjectives.flat();
+    return this;
+  }
+
+  /**
+   * Adds adjective words to the existing list used in grammar templates.
+   * @param {...string[]} adjectives - One or more arrays or strings of adjectives.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  addGrammarAdjectives(...adjectives) {
+    this.config.grammar.adjectives.push(...adjectives.flat());
+    return this;
+  }
+
+  /**
+   * Removes specific grammar templates from the current list.
+   * @param {...string[]} templates - One or more arrays or strings of templates to remove.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  removeGrammarTemplates(...templates) {
+    const removeSet = new Set(templates.flat());
+    this.config.grammar.templates = this.config.grammar.templates.filter((t) => !removeSet.has(t));
+    return this;
+  }
+
+  /**
+   * Removes specific noun words from the grammar noun list.
+   * @param {...string[]} nouns - One or more arrays or strings of nouns to remove.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  removeGrammarNouns(...nouns) {
+    const removeSet = new Set(nouns.flat());
+    this.config.grammar.nouns = this.config.grammar.nouns.filter((n) => !removeSet.has(n));
+    return this;
+  }
+
+  /**
+   * Removes specific verb words from the grammar verb list.
+   * @param {...string[]} verbs - One or more arrays or strings of verbs to remove.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  removeGrammarVerbs(...verbs) {
+    const removeSet = new Set(verbs.flat());
+    this.config.grammar.verbs = this.config.grammar.verbs.filter((v) => !removeSet.has(v));
+    return this;
+  }
+
+  /**
+   * Removes specific adjective words from the grammar adjective list.
+   * @param {...string[]} adjectives - One or more arrays or strings of adjectives to remove.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  removeGrammarAdjectives(...adjectives) {
+    const removeSet = new Set(adjectives.flat());
+    this.config.grammar.adjectives = this.config.grammar.adjectives.filter(
+      (a) => !removeSet.has(a),
+    );
+    return this;
+  }
+
+  /**
+   * Replaces the entire word set used in readable/mixed modes.
+   * @param {...string[]} words - One or more arrays or strings of words.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  setWords(...words) {
+    this.config.wordSet = words.flat();
+    return this;
+  }
+
+  /**
+   * Adds new words to the word set used in readable/mixed modes.
+   * @param {...string[]} words - One or more arrays or strings of words.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  addWords(...words) {
+    this.config.wordSet.push(...words.flat());
+    return this;
+  }
+
+  /**
+   * Removes specific words from the word set.
+   * @param {...string[]} words - Words to be removed.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  removeWords(...words) {
+    const removeSet = new Set(words.flat());
+    this.config.wordSet = this.config.wordSet.filter((word) => !removeSet.has(word));
+    return this;
+  }
+
+  /**
+   * Replaces the emoji set used in generated output.
+   * @param {...string[]} emojis - One or more arrays or strings of emojis.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  setEmojis(...emojis) {
+    this.config.emojiSet = emojis.flat();
+    return this;
+  }
+
+  /**
+   * Adds new emojis to the emoji set.
+   * @param {...string[]} emojis - One or more arrays or strings of emojis.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  addEmojis(...emojis) {
+    this.config.emojiSet.push(...emojis.flat());
+    return this;
+  }
+
+  /**
+   * Removes specific emojis from the emoji set.
+   * @param {...string[]} emojis - Emojis to be removed.
+   * @returns {UltraRandomMsgGen} - The instance for chaining.
+   */
+  removeEmojis(...emojis) {
+    const removeSet = new Set(emojis.flat());
+    this.config.emojiSet = this.config.emojiSet.filter((emoji) => !removeSet.has(emoji));
+    return this;
+  }
+
+  /**
+   * Returns a random item from an array.
+   * @private
+   * @param {string[]} array - Array to pick from.
+   * @returns {string} - Random item from array.
+   */
+  _getRandomItem(array) {
+    return array[Math.floor(Math.random() * array.length)];
+  }
+
+  /**
+   * Generates a single random content chunk based on the mode and settings.
+   * @private
+   * @returns {string} - A chunk (word, emoji, symbol, number, etc.).
+   */
+  _generateChunk() {
+    const {
+      wordSet,
+      emojiSet,
+      includeNumbers,
+      includeSymbols,
+      useEmojis,
+      readable,
+      mode,
+      emojiPlacement,
+    } = this.config;
+
+    if (mode === 'natural') {
+      return this._generateNaturalSentence();
+    }
+
+    const pools = [];
+
+    if (readable || mode === 'readable' || mode === 'mixed') {
+      pools.push(this._getRandomItem(wordSet));
+    }
+
+    if (mode === 'chaotic' || mode === 'mixed') {
+      pools.push(Math.random().toString(36).slice(2));
+    }
+
+    if (includeNumbers) {
+      pools.push(Math.floor(Math.random() * 99999).toString());
+    }
+
+    if (includeSymbols) {
+      pools.push(this._getRandomItem(this.symbols));
+    }
+
+    if (emojiPlacement === 'inline' && useEmojis && emojiSet.length) {
+      pools.push(this._getRandomItem(emojiSet));
+    }
+
+    return this._getRandomItem(pools);
+  }
+
+  /**
+   * Generates a natural sentence by replacing placeholders in a template.
+   * @private
+   * @returns {string} - A generated sentence.
+   */
+  _generateNaturalSentence() {
+    const { templates, nouns, verbs, adjectives } = this.config.grammar;
+
+    let template = this._getRandomItem(templates);
+
+    return template
+      .replace(/{noun}/g, () => this._getRandomItem(nouns))
+      .replace(/{verb}/g, () => this._getRandomItem(verbs))
+      .replace(/{adj}/g, () => this._getRandomItem(adjectives));
+  }
+
+  /**
+   * Generates a single line of text with target length and rules.
+   * @private
+   * @param {number} targetLength - Target character length for the line.
+   * @param {Set<string>} [seenWords] - Set of already used words (for avoiding repeats).
+   * @returns {string} - A generated line.
+   */
+  _generateLine(targetLength, seenWords) {
+    const { allowWeirdSpacing, repeatWords, readable, emojiSet, useEmojis, emojiPlacement, line } =
+      this.config;
+
+    const parts = [];
+    seenWords ??= new Set();
+
+    while (parts.join(' ').length < targetLength) {
+      let chunk = this._generateChunk();
+
+      if (!repeatWords && seenWords.has(chunk)) continue;
+      seenWords.add(chunk);
+
+      if (allowWeirdSpacing) {
+        if (Math.random() < 0.1) chunk = '\n' + chunk;
+        if (Math.random() < 0.1) chunk = '   ' + chunk;
+        if (Math.random() < 0.05) chunk = chunk.toUpperCase();
+      }
+
+      parts.push(chunk);
+    }
+
+    let lineText = parts.join(readable ? ' ' : '');
+
+    if (
+      emojiPlacement === 'end' &&
+      useEmojis &&
+      emojiSet.length &&
+      Math.random() < (line?.emojiChance || 0)
+    ) {
+      lineText += ' ' + this._getRandomItem(emojiSet);
+    }
+
+    return lineText;
+  }
+
+  /**
+   * Generates lines to form a paragraph based on total length.
+   * @private
+   * @param {number} totalLength - Total target character count for the paragraph.
+   * @returns {string[]} - Array of lines that form the paragraph.
+   */
+  _generateParagraphLines(totalLength) {
+    const { line } = this.config;
+    const lines = [];
+    const seenWords = new Set();
+    let currentTotal = 0;
+
+    while (currentTotal < totalLength) {
+      const lineLength = Math.floor(
+        Math.random() * (line.maxLength - line.minLength + 1) + line.minLength,
+      );
+
+      const adjustedLength = Math.min(lineLength, totalLength - currentTotal);
+
+      lines.push(this._generateLine(adjustedLength, seenWords));
+      currentTotal += adjustedLength;
+    }
+
+    return lines;
+  }
+
+  /**
+   * Generates the final random message, which can be a paragraph or block of lines.
+   * Uses full configuration rules (grammar, symbols, emojis, etc).
+   * @returns {string} - A full generated message.
+   */
+  generate() {
+    const { minLength, maxLength, paragraphs } = this.config;
+
+    const totalLength = Math.floor(Math.random() * (maxLength - minLength + 1)) + minLength;
+
+    if (paragraphs && typeof paragraphs === 'object') {
+      const paraCount =
+        Math.floor(Math.random() * (paragraphs.max - paragraphs.min + 1)) + paragraphs.min;
+      const approxLength = Math.floor(totalLength / paraCount);
+      const paragraphsArray = [];
+
+      for (let i = 0; i < paraCount; i++) {
+        const lines = this._generateParagraphLines(approxLength);
+        paragraphsArray.push(lines.join('\n'));
+      }
+
+      return paragraphsArray.join('\n\n');
+    }
+
+    return this._generateParagraphLines(totalLength).join('\n');
+  }
+}
+
+/* harmony default export */ const libs_UltraRandomMsgGen = (UltraRandomMsgGen);
+
+;// ./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.
+ */
+
+/**
+ * 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.
+ *
+ * @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}
+ */
+
+/**
+ * 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 };
+
+  /** @type {WeakMap<Element, NodeSizes>} */
+  #oldSizes = new WeakMap();
+  /** @type {WeakMap<Element, NodeSizes>} */
+  #newSizes = new WeakMap();
+
+  /** @type {WeakMap<Element, boolean>} */
+  #newVisibles = new WeakMap();
+  /** @type {WeakMap<Element, boolean>} */
+  #oldVisibles = new WeakMap();
+
+  /** @type {WeakMap<Element, boolean>} */
+  #newVisiblesByTime = new WeakMap();
+  /** @type {WeakMap<Element, boolean>} */
+  #oldVisiblesByTime = new WeakMap();
+
+  /** @type {Record<string, ScrollListenersFunc[]>} */
+  #scrollListeners = {};
+
+  /** @type {ResizeObserver|null} */
+  #resizeObserver = null;
+  /** @type {MutationObserver|null} */
+  #mutationObserver = null;
+
+  /** @type {Set<string>} */
+  #loadTags = new Set(['IMG', 'IFRAME', 'VIDEO']);
+
+  /** @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);
+  }
+
+  /**
+   * Adds a scroll-related event listener.
+   *
+   * @param {string} event - Event name, such as 'onScrollBoundary' or 'onAutoScroll'.
+   * @param {ScrollListenersFunc} handler - Callback function to be called when event fires.
+   */
+  on(event, handler) {
+    if (this.#destroyed) return;
+    if (typeof event !== 'string')
+      throw new TypeError('on(event, handler): event name must be a string');
+    if (typeof handler !== 'function')
+      throw new TypeError('on(event, handler): handler must be a function');
+
+    if (!this.#scrollListeners[event]) this.#scrollListeners[event] = [];
+    this.#scrollListeners[event].push(handler);
+  }
+
+  /**
+   * Removes a previously registered scroll-related event listener.
+   *
+   * @param {string} event - The name of the event to remove the handler from.
+   * @param {ScrollListenersFunc} handler - The specific callback function to remove.
+   */
+  off(event, handler) {
+    if (this.#destroyed) return;
+    if (typeof event !== 'string')
+      throw new TypeError('off(event, handler): event name must be a string');
+    if (typeof handler !== 'function')
+      throw new TypeError('off(event, handler): handler must be a function');
+
+    const listeners = this.#scrollListeners[event];
+    if (!Array.isArray(listeners)) return;
+
+    const index = listeners.indexOf(handler);
+    if (index !== -1) listeners.splice(index, 1);
+
+    // Optionally clean up empty arrays (optional)
+    if (listeners.length === 0) delete this.#scrollListeners[event];
+  }
+
+  /**
+   * Checks which elements inside the target are currently visible and updates internal maps.
+   *
+   * @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.
+   */
+  _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));
+  }
+
+  /**
+   * 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 (
+      this.#elemOldAmount > 0 &&
+      libs_TinyHtml.hasScroll(this.#target).v &&
+      this.#autoScrollBottom &&
+      this.#preserveScrollOnLayoutShift &&
+      !this.#isAtBottom &&
+      !this.#isAtTop
+    ) {
+      const scrollSize = calculateScrollSize();
+      // Complete
+      this.#target.scrollTop = prevScrollTop + heightDelta + scrollSize.height;
+      if (scrollSize.width > 0)
+        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;
+    }
+  }
+  /**
+   * 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.#scrollListeners = {};
+    this.#sizeFilter.clear();
+    this.#loadTags.clear();
+  }
+}
+
+/* harmony default export */ const libs_TinySmartScroller = (TinySmartScroller);
+
+;// ./src/v1/index.mjs
+
+