tiny-essentials 1.21.8 → 1.21.9

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

@@ -1,4 +1,8 @@
 export default TinyHtml;
+/**
+ * Represents a TinyHtml instance with any constructor element values.
+ */
+export type TinyHtmlAny = TinyHtml<ConstructorElValues>;
 /**
  * Callback invoked on each animation frame with the current scroll position,
  * normalized animation time (`0` to `1`), and a completion flag.
@@ -18,37 +22,37 @@ export type Easings = "linear" | "easeInQuad" | "easeOutQuad" | "easeInOutQuad"
  * This type is used to abstract interactions with both plain elements
  * and wrapped elements via the TinyHtml class.
  */
-export type TinyNode = Node | TinyHtml | null;
+export type TinyNode = Node | TinyHtmlAny | null;
 /**
  * Represents a raw DOM element or an instance of TinyHtml.
  * This type is used to abstract interactions with both plain elements
  * and wrapped elements via the TinyHtml class.
  */
-export type TinyElement = Element | TinyHtml;
+export type TinyElement = Element | TinyHtmlAny;
 /**
  * Represents a raw DOM html element or an instance of TinyHtml.
  * This type is used to abstract interactions with both plain elements
  * and wrapped elements via the TinyHtml class.
  */
-export type TinyHtmlElement = HTMLElement | TinyHtml;
+export type TinyHtmlElement = HTMLElement | TinyHtmlAny;
 /**
  * Represents a raw DOM event target element or an instance of TinyHtml.
  * This type is used to abstract interactions with both plain elements
  * and wrapped elements via the TinyHtml class.
  */
-export type TinyEventTarget = EventTarget | TinyHtml;
+export type TinyEventTarget = EventTarget | TinyHtmlAny;
 /**
  * Represents a raw DOM input element or an instance of TinyHtml.
  * This type is used to abstract interactions with both plain elements
  * and wrapped elements via the TinyHtml class.
  */
-export type TinyInputElement = InputElement | TinyHtml;
+export type TinyInputElement = InputElement | TinyHtmlAny;
 /**
  * Represents a raw DOM element/window or an instance of TinyHtml.
  * This type is used to abstract interactions with both plain elements
  * and wrapped elements via the TinyHtml class.
  */
-export type TinyElementAndWindow = ElementAndWindow | TinyHtml;
+export type TinyElementAndWindow = ElementAndWindow | TinyHtmlAny;
 /**
  * Represents a value that can be either a DOM Element or the global Window object.
  * Useful for functions that operate generically on scrollable or measurable targets.
@@ -59,7 +63,7 @@ export type ElementAndWindow = Element | Window;
  * This type is used to abstract interactions with both plain elements
  * and wrapped elements via the TinyHtml class.
  */
-export type TinyElementAndWinAndDoc = ElementAndWinAndDoc | TinyHtml;
+export type TinyElementAndWinAndDoc = ElementAndWinAndDoc | TinyHtmlAny;
 /**
  * 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.
@@ -70,7 +74,7 @@ export type ElementAndWinAndDoc = Element | Window | Document;
  * This type is used to abstract interactions with both plain elements
  * and wrapped elements via the TinyHtml class.
  */
-export type TinyElementWithDoc = ElementWithDoc | TinyHtml;
+export type TinyElementWithDoc = ElementWithDoc | TinyHtmlAny;
 /**
  * Represents a value that can be either a DOM Element, or the document object.
  * Useful for functions that operate generically on measurable targets.
@@ -206,9 +210,10 @@ attributes: Record<string, string>, // All element attributes as key-value pairs
  * Inspired by the jQuery project's open source implementations of element dimension
  * and offset utilities. This class serves as a lightweight alternative using modern DOM APIs.
  *
+ * @template {ConstructorElValues|ConstructorElValues[]|NodeListOf<Element>|HTMLCollectionOf<Element>|NodeListOf<HTMLElement>} TinyHtmlT
  * @class
  */
-declare class TinyHtml {
+declare class TinyHtml<TinyHtmlT extends ConstructorElValues | ConstructorElValues[] | NodeListOf<Element> | HTMLCollectionOf<Element> | NodeListOf<HTMLElement>> {
     /** @typedef {import('../basics/collision.mjs').ObjRect} ObjRect */
     static Utils: {
         getElsRelativeCenterOffset(rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect): {
@@ -237,60 +242,8 @@ declare class TinyHtml {
         areElsCollPerfRight: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
         areElsColliding: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
         areElsPerfColliding: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
-        getElsColliding: (
-        /**
-         * @typedef {'string' | 'date' | 'number'} GetValueTypes
-         * Types of value extractors supported by TinyHtml._valTypes.
-         */
-        /**
-         * @typedef {SetValueBase|SetValueBase[]} SetValueList - A single value or an array of values to be assigned to the input element.
-         */
-        /**
-         * A list of HTML form elements that can have a `.value` property used by TinyHtml.
-         * Includes common input types used in forms.
-         *
-         * @typedef {HTMLInputElement|HTMLSelectElement|HTMLTextAreaElement|HTMLOptionElement} InputElement
-         */
-        /**
-         * Represents a parsed HTML element in JSON-like array form.
-         *
-         * @typedef {[
-         *   tagName: string, // The tag name of the element (e.g., 'div', 'img')
-         *   attributes: Record<string, string>, // All element attributes as key-value pairs
-         *   ...children: (string | HtmlParsed)[] // Text or nested elements
-         * ]} HtmlParsed
-         */
-        /**
-         * TinyHtml is a utility class that provides static and instance-level methods
-         * for precise dimension and position computations on HTML elements.
-         * It mimics some jQuery functionalities while using native browser APIs.
-         *
-         * Inspired by the jQuery project's open source implementations of element dimension
-         * and offset utilities. This class serves as a lightweight alternative using modern DOM APIs.
-         *
-         * @class
-         */
-        rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => string | null;
-        getElsPerfColliding: (rect1: TinyCollision.ObjRect /**
-         * Represents a parsed HTML element in JSON-like array form.
-         *
-         * @typedef {[
-         *   tagName: string, // The tag name of the element (e.g., 'div', 'img')
-         *   attributes: Record<string, string>, // All element attributes as key-value pairs
-         *   ...children: (string | HtmlParsed)[] // Text or nested elements
-         * ]} HtmlParsed
-         */
-        /**
-         * TinyHtml is a utility class that provides static and instance-level methods
-         * for precise dimension and position computations on HTML elements.
-         * It mimics some jQuery functionalities while using native browser APIs.
-         *
-         * Inspired by the jQuery project's open source implementations of element dimension
-         * and offset utilities. This class serves as a lightweight alternative using modern DOM APIs.
-         *
-         * @class
-         */
-        , rect2: TinyCollision.ObjRect) => "top" | "bottom" | "left" | "right" | null;
+        getElsColliding: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => string | null;
+        getElsPerfColliding: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => "top" | "bottom" | "left" | "right" | null;
         getElsCollOverlap: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => {
             overlapLeft: number;
             overlapRight: number;
@@ -332,9 +285,9 @@ declare class TinyHtml {
      *
      * @param {string} url - The URL of the HTML file.
      * @param {RequestInit} [ops] - Optional fetch configuration (e.g., method, headers, cache, etc).
-     * @returns {Promise<TinyHtml[]>} A promise that resolves with the TinyHtml instances.
+     * @returns {Promise<TinyHtml<TinyElement|Text>[]>} A promise that resolves with the TinyHtml instances.
      */
-    static fetchHtmlTinyElems(url: string, ops?: RequestInit): Promise<TinyHtml[]>;
+    static fetchHtmlTinyElems(url: string, ops?: RequestInit): Promise<TinyHtml<TinyElement | Text>[]>;
     /**
      * Converts the content of a <template> to an array of HtmlParsed.
      *
@@ -353,9 +306,9 @@ declare class TinyHtml {
      * Converts the content of a <template> to an array of TinyHtml elements.
      *
      * @param {HTMLTemplateElement} nodes
-     * @returns {TinyHtml[]}
+     * @returns {TinyHtml<Element|Text>[]}
      */
-    static templateToTinyElems(nodes: HTMLTemplateElement): TinyHtml[];
+    static templateToTinyElems(nodes: HTMLTemplateElement): TinyHtml<Element | Text>[];
     /**
      * Parses a full HTML string into a JSON-like structure.
      *
@@ -374,9 +327,9 @@ declare class TinyHtml {
      * Converts a JSON-like HTML structure back to TinyHtml instances.
      *
      * @param {HtmlParsed[]} jsonArray - Parsed JSON format of HTML.
-     * @returns {TinyHtml[]} List of TinyHtml instances.
+     * @returns {TinyHtml<HTMLElement | Text>[]} List of TinyHtml instances.
      */
-    static jsonToTinyElems(jsonArray: HtmlParsed[]): TinyHtml[];
+    static jsonToTinyElems(jsonArray: HtmlParsed[]): TinyHtml<HTMLElement | Text>[];
     /**
      * Creates a new TinyHtml element from a tag name and optional attributes.
      *
@@ -389,19 +342,19 @@ declare class TinyHtml {
      * @param {string} tagName - The HTML tag name (e.g., 'div', 'span', 'button').
      * @param {Record<string, string|null>} [attrs] - Optional key-value pairs representing HTML attributes.
      *                                                If the value is `null`, the attribute will still be set with an empty value.
-     * @returns {TinyHtml} - A new instance of TinyHtml representing the created element.
+     * @returns {TinyHtml<HTMLElement>} - A new instance of TinyHtml representing the created element.
      * @throws {TypeError} - If `tagName` is not a string, or `attrs` is not a plain object when defined.
      */
-    static createFrom(tagName: string, attrs?: Record<string, string | null>): TinyHtml;
+    static createFrom(tagName: string, attrs?: Record<string, string | null>): TinyHtml<HTMLElement>;
     /**
      * 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.
+     * @returns {TinyHtml<HTMLElement>} 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: string, ops?: ElementCreationOptions): TinyHtml;
+    static createElement(tagName: string, ops?: ElementCreationOptions): TinyHtml<HTMLElement>;
     /**
      * Creates a new TinyHtml instance that wraps a DOM TextNode.
      *
@@ -410,56 +363,56 @@ declare class TinyHtml {
      * 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.
+     * @returns {TinyHtml<Text>} A TinyHtml instance wrapping the newly created DOM TextNode.
      * @throws {TypeError} If the provided value is not a string.
      */
-    static createTextNode(value: string): TinyHtml;
+    static createTextNode(value: string): TinyHtml<Text>;
     /**
      * 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.
+     * @returns {TinyHtml<Element>} - A single HTMLElement or TextNode.
      */
-    static createElementFromHTML(htmlString: string): TinyHtml;
+    static createElementFromHTML(htmlString: string): TinyHtml<Element>;
     /**
      * 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.
      * @param {Document|Element} elem - Target element.
-     * @returns {TinyHtml|null} A TinyHtml instance wrapping the matched element.
+     * @returns {TinyHtml<Element>|null} A TinyHtml instance wrapping the matched element.
      */
-    static query(selector: string, elem?: Document | Element): TinyHtml | null;
+    static query(selector: string, elem?: Document | Element): TinyHtml<Element> | null;
     /**
      * 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.
+     * @returns {TinyHtml<NodeListOf<Element>>} An array of TinyHtml instances wrapping the matched elements.
      */
-    static queryAll(selector: string, elem?: Document | Element): TinyHtml;
+    static queryAll(selector: string, elem?: Document | Element): TinyHtml<NodeListOf<Element>>;
     /**
      * 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|null} A TinyHtml instance wrapping the found element.
+     * @returns {TinyHtml<HTMLElement>|null} A TinyHtml instance wrapping the found element.
      */
-    static getById(selector: string): TinyHtml | null;
+    static getById(selector: string): TinyHtml<HTMLElement> | null;
     /**
      * 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.
+     * @returns {TinyHtml<HTMLCollectionOf<Element>>} An array of TinyHtml instances wrapping the found elements.
      */
-    static getByClassName(selector: string, elem?: Document | Element): TinyHtml;
+    static getByClassName(selector: string, elem?: Document | Element): TinyHtml<HTMLCollectionOf<Element>>;
     /**
      * Retrieves all elements with the specified name attribute and wraps them in TinyHtml instances.
      *
      * @param {string} selector - The name attribute to search for.
-     * @returns {TinyHtml} An array of TinyHtml instances wrapping the found elements.
+     * @returns {TinyHtml<NodeListOf<HTMLElement>>} An array of TinyHtml instances wrapping the found elements.
      */
-    static getByName(selector: string): TinyHtml;
+    static getByName(selector: string): TinyHtml<NodeListOf<HTMLElement>>;
     /**
      * Retrieves all elements with the specified local tag name within the given namespace URI,
      * and wraps them in TinyHtml instances.
@@ -467,9 +420,9 @@ declare class 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.
+     * @returns {TinyHtml<HTMLCollectionOf<Element>>} An array of TinyHtml instances wrapping the found elements.
      */
-    static getByTagNameNS(localName: string, namespaceURI?: string | null, elem?: Document | Element): TinyHtml;
+    static getByTagNameNS(localName: string, namespaceURI?: string | null, elem?: Document | Element): TinyHtml<HTMLCollectionOf<Element>>;
     /**
      * Prepares and validates multiple elements against allowed types.
      *
@@ -677,9 +630,9 @@ declare class TinyHtml {
      * of the input form.
      *
      * @param {TinyElement|Text|(TinyElement|Text)[]} elems - A single element or an array of elements (DOM or TinyHtml).
-     * @returns {TinyHtml[]} An array of TinyHtml instances corresponding to the input elements.
+     * @returns {TinyHtml<TinyElement|Text>[]} An array of TinyHtml instances corresponding to the input elements.
      */
-    static toTinyElm(elems: TinyElement | Text | (TinyElement | Text)[]): TinyHtml[];
+    static toTinyElm(elems: TinyElement | Text | (TinyElement | Text)[]): TinyHtml<TinyElement | Text>[];
     /**
      * Extracts native `Element` instances from one or more elements,
      * which can be either raw DOM elements or wrapped in `TinyHtml`.
@@ -795,13 +748,14 @@ declare class TinyHtml {
     /**
      * Stores a value associated with a specific key for a DOM element.
      *
-     * @param {TinyElement} el - The DOM element.
+     * @template {TinyElement} T
+     * @param {T} el - The DOM element.
      * @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 {TinyElement}
+     * @returns {T}
      */
-    static setData(el: TinyElement, key: string, value: any, isPrivate?: boolean): TinyElement;
+    static setData<T extends TinyElement>(el: T, key: string, value: any, isPrivate?: boolean): T;
     /**
      * Get the sibling element in a given direction.
      *
@@ -922,86 +876,96 @@ declare class TinyHtml {
     /**
      * Appends child elements or strings to the end of the target element(s).
      *
-     * @param {TinyElement} el - The target element(s) to receive children.
+     * @template {TinyElement} T
+     * @param {T} el - The target element(s) to receive children.
      * @param {...(TinyNode | TinyNode[] | string)} children - The child elements or text to append.
-     * @returns {TinyElement}
+     * @returns {T}
      */
-    static append(el: TinyElement, ...children: (TinyNode | TinyNode[] | string)[]): TinyElement;
+    static append<T extends TinyElement>(el: T, ...children: (TinyNode | TinyNode[] | string)[]): T;
     /**
      * Prepends child elements or strings to the beginning of the target element(s).
      *
-     * @param {TinyElement} el - The target element(s) to receive children.
+     * @template {TinyElement} T
+     * @param {T} el - The target element(s) to receive children.
      * @param {...(TinyNode | TinyNode[] | string)} children - The child elements or text to prepend.
-     * @returns {TinyElement}
+     * @returns {T}
      */
-    static prepend(el: TinyElement, ...children: (TinyNode | TinyNode[] | string)[]): TinyElement;
+    static prepend<T extends TinyElement>(el: T, ...children: (TinyNode | TinyNode[] | string)[]): T;
     /**
      * Inserts elements or strings immediately before the target element(s) in the DOM.
      *
-     * @param {TinyElement} el - The target element(s) before which new content is inserted.
+     * @template {TinyElement} T
+     * @param {T} 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}
+     * @returns {T}
      */
-    static before(el: TinyElement, ...children: (TinyNode | TinyNode[] | string)[]): TinyElement;
+    static before<T extends TinyElement>(el: T, ...children: (TinyNode | TinyNode[] | string)[]): T;
     /**
      * Inserts elements or strings immediately after the target element(s) in the DOM.
      *
-     * @param {TinyElement} el - The target element(s) after which new content is inserted.
+     * @template {TinyElement} T
+     * @param {T} 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}
+     * @returns {T}
      */
-    static after(el: TinyElement, ...children: (TinyNode | TinyNode[] | string)[]): TinyElement;
+    static after<T extends TinyElement>(el: T, ...children: (TinyNode | TinyNode[] | string)[]): T;
     /**
      * Replaces the target element(s) in the DOM with new elements or text.
      *
-     * @param {TinyElement} el - The element(s) to be replaced.
+     * @template {TinyElement} T
+     * @param {T} el - The element(s) to be replaced.
      * @param {...(TinyNode | TinyNode[] | string)} newNodes - New elements or text to replace the target.
-     * @returns {TinyElement}
+     * @returns {T}
      */
-    static replaceWith(el: TinyElement, ...newNodes: (TinyNode | TinyNode[] | string)[]): TinyElement;
+    static replaceWith<T extends TinyElement>(el: T, ...newNodes: (TinyNode | TinyNode[] | string)[]): T;
     /**
      * Appends the given element(s) to each target element in sequence.
      *
-     * @param {TinyNode | TinyNode[]} el - The element(s) to append.
+     * @template {TinyNode | TinyNode[]} T
+     * @param {T} el - The element(s) to append.
      * @param {TinyNode | TinyNode[]} targets - Target element(s) where content will be appended.
-     * @returns {TinyNode|TinyNode[]}
+     * @returns {T}
      */
-    static appendTo(el: TinyNode | TinyNode[], targets: TinyNode | TinyNode[]): TinyNode | TinyNode[];
+    static appendTo<T extends TinyNode | TinyNode[]>(el: T, targets: TinyNode | TinyNode[]): T;
     /**
      * Prepends the given element(s) to each target element in sequence.
      *
-     * @param {TinyElement | TinyElement[]} el - The element(s) to prepend.
+     * @template {TinyElement | TinyElement[]} T
+     * @param {T} el - The element(s) to prepend.
      * @param {TinyElement | TinyElement[]} targets - Target element(s) where content will be prepended.
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static prependTo(el: TinyElement | TinyElement[], targets: TinyElement | TinyElement[]): TinyElement | TinyElement[];
+    static prependTo<T extends TinyElement | TinyElement[]>(el: T, targets: TinyElement | TinyElement[]): T;
     /**
      * Inserts the element before a child of a given target, or before the target itself.
      *
-     * @param {TinyNode | TinyNode[]} el - The element(s) to insert.
+     * @template {TinyNode | TinyNode[]} T
+     * @param {T} 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[]}
+     * @returns {T}
      */
-    static insertBefore(el: TinyNode | TinyNode[], target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): TinyNode | TinyNode[];
+    static insertBefore<T extends TinyNode | TinyNode[]>(el: T, target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): T;
     /**
      * Inserts the element after a child of a given target, or after the target itself.
      *
-     * @param {TinyNode | TinyNode[]} el - The element(s) to insert.
+     * @template {TinyNode | TinyNode[]} T
+     * @param {T} 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[]}
+     * @returns {T}
      */
-    static insertAfter(el: TinyNode | TinyNode[], target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): TinyNode | TinyNode[];
+    static insertAfter<T extends TinyNode | TinyNode[]>(el: T, target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): T;
     /**
      * Replaces all target elements with the provided element(s).
      * If multiple targets exist, the inserted elements are cloned accordingly.
      *
-     * @param {TinyNode | TinyNode[]} el - The new element(s) to insert.
+     * @template {TinyNode | TinyNode[]} T
+     * @param {T} el - The new element(s) to insert.
      * @param {TinyNode | TinyNode[]} targets - The elements to be replaced.
-     * @returns {TinyNode|TinyNode[]}
+     * @returns {T}
      */
-    static replaceAll(el: TinyNode | TinyNode[], targets: TinyNode | TinyNode[]): TinyNode | TinyNode[];
+    static replaceAll<T extends TinyNode | TinyNode[]>(el: T, targets: TinyNode | TinyNode[]): T;
     /**
      * Checks whether the given object is a window.
      * @param {*} obj - The object to test.
@@ -1097,12 +1061,13 @@ declare class TinyHtml {
      * - If `prop` is a string, the `value` will be applied to that property.
      * - If `prop` is an object, each key-value pair will be applied as a CSS property and value.
      *
-     * @param {TinyHtmlElement|TinyHtmlElement[]} el - The element to inspect.
+     * @template {TinyHtmlElement|TinyHtmlElement[]} T
+     * @param {T} 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[]}
+     * @returns {T}
      */
-    static setStyle(el: TinyHtmlElement | TinyHtmlElement[], prop: string | Object, value?: string | null): TinyHtmlElement | TinyHtmlElement[];
+    static setStyle<T extends TinyHtmlElement | TinyHtmlElement[]>(el: T, prop: string | Object, value?: string | null): T;
     /**
      * Gets the value of a specific inline style property.
      *
@@ -1133,51 +1098,57 @@ declare class TinyHtml {
     /**
      * Removes one or more inline CSS properties from the given element(s).
      *
-     * @param {TinyHtmlElement|TinyHtmlElement[]} el - A single element or an array of elements.
+     * @template {TinyHtmlElement|TinyHtmlElement[]} T
+     * @param {T} 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[]}
+     * @returns {T}
      */
-    static removeStyle(el: TinyHtmlElement | TinyHtmlElement[], prop: string | string[]): TinyHtmlElement | TinyHtmlElement[];
+    static removeStyle<T extends TinyHtmlElement | TinyHtmlElement[]>(el: T, prop: string | string[]): T;
     /**
      * Toggles a CSS property value between two given values.
      *
      * The current computed value is compared to `val1`. If it matches, the property is set to `val2`. Otherwise, it is set to `val1`.
      *
-     * @param {TinyHtmlElement|TinyHtmlElement[]} el - A single element or an array of elements.
+     * @template {TinyHtmlElement|TinyHtmlElement[]} T
+     * @param {T} el - A single element or an array of elements.
      * @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[]}
+     * @returns {T}
      */
-    static toggleStyle(el: TinyHtmlElement | TinyHtmlElement[], prop: string, val1: string, val2: string): TinyHtmlElement | TinyHtmlElement[];
+    static toggleStyle<T extends TinyHtmlElement | TinyHtmlElement[]>(el: T, prop: string, val1: string, val2: string): T;
     /**
      * 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[]}
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el - A single element or an array of elements.
+     * @returns {T}
      */
-    static clearStyle(el: TinyElement | TinyElement[]): TinyElement | TinyElement[];
+    static clearStyle<T extends TinyElement | TinyElement[]>(el: T): T;
     /**
      * Focus the element.
      *
-     * @param {TinyHtmlElement} el - The element or a selector string.
-     * @returns {TinyHtmlElement}
+     * @template {TinyHtmlElement} T
+     * @param {T} el - The element or a selector string.
+     * @returns {T}
      */
-    static focus(el: TinyHtmlElement): TinyHtmlElement;
+    static focus<T extends TinyHtmlElement>(el: T): T;
     /**
      * Blur the element.
      *
-     * @param {TinyHtmlElement} el - The element or a selector string.
-     * @returns {TinyHtmlElement}
+     * @template {TinyHtmlElement} T
+     * @param {T} el - The element or a selector string.
+     * @returns {T}
      */
-    static blur(el: TinyHtmlElement): TinyHtmlElement;
+    static blur<T extends TinyHtmlElement>(el: T): T;
     /**
      * Select the text content of an input or textarea element.
      *
-     * @param {TinyHtml|HTMLInputElement|HTMLTextAreaElement} el - The element or a selector string.
-     * @returns {TinyHtml|HTMLInputElement|HTMLTextAreaElement}
+     * @template {TinyHtmlAny|HTMLInputElement|HTMLTextAreaElement} T
+     * @param {T} el - The element or a selector string.
+     * @returns {T}
      */
-    static select(el: TinyHtml | HTMLInputElement | HTMLTextAreaElement): TinyHtml | HTMLInputElement | HTMLTextAreaElement;
+    static select<T extends TinyHtmlAny | HTMLInputElement | HTMLTextAreaElement>(el: T): T;
     /**
      * Interprets a value as a boolean `true` if it matches a common truthy representation.
      *
@@ -1247,20 +1218,22 @@ declare class TinyHtml {
     static getDimension(el: TinyElementAndWinAndDoc, type: "width" | "height", extra?: "content" | "padding" | "border" | "margin"): number;
     /**
      * Sets the height of the element.
-     * @param {TinyHtmlElement} el - Target element.
+     * @template {TinyHtmlElement} T
+     * @param {T} el - Target element.
      * @param {string|number} value - Height value.
      * @throws {TypeError} If `value` is neither a string nor number.
-     * @returns {TinyHtmlElement}
+     * @returns {T}
      */
-    static setHeight(el: TinyHtmlElement, value: string | number): TinyHtmlElement;
+    static setHeight<T extends TinyHtmlElement>(el: T, value: string | number): T;
     /**
      * Sets the width of the element.
-     * @param {TinyHtmlElement} el - Target element.
+     * @template {TinyHtmlElement} T
+     * @param {T} el - Target element.
      * @param {string|number} value - Width value.
      * @throws {TypeError} If `value` is neither a string nor number.
-     * @returns {TinyHtmlElement}
+     * @returns {T}
      */
-    static setWidth(el: TinyHtmlElement, value: string | number): TinyHtmlElement;
+    static setWidth<T extends TinyHtmlElement>(el: T, value: string | number): T;
     /**
      * Returns content box height.
      * @param {TinyElementAndWinAndDoc} el - Target element.
@@ -1302,12 +1275,13 @@ declare class TinyHtml {
     /**
      * Applies an animation to one or multiple TinyElement instances.
      *
-     * @param {TinyElement|TinyElement[]} el - A single TinyElement or an array of TinyElements to animate.
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} 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[]}
+     * @returns {T}
      */
-    static animate(el: TinyElement | TinyElement[], keyframes: Keyframe[] | PropertyIndexedKeyframes | null, ops?: number | KeyframeAnimationOptions): TinyElement | TinyElement[];
+    static animate<T extends TinyElement | TinyElement[]>(el: T, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, ops?: number | KeyframeAnimationOptions): T;
     /**
      * Gets the offset of the element relative to the document.
      * @param {TinyElement} el - Target element.
@@ -1357,7 +1331,8 @@ declare class TinyHtml {
      *
      * 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.
+     * @template {TinyElementAndWindow|TinyElementAndWindow[]} T
+     * @param {T} 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.
@@ -1365,34 +1340,36 @@ declare class TinyHtml {
      * @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[]}
+     * @returns {T}
      * @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: TinyElementAndWindow | TinyElementAndWindow[], { targetX, targetY, duration, easing, onAnimation }?: {
+    static scrollToXY<T extends TinyElementAndWindow | TinyElementAndWindow[]>(el: T, { targetX, targetY, duration, easing, onAnimation }?: {
         targetX?: number | undefined;
         targetY?: number | undefined;
         duration?: number | undefined;
         easing?: Easings | undefined;
         onAnimation?: OnScrollAnimation | undefined;
-    }): TinyElementAndWindow | TinyElementAndWindow[];
+    }): T;
     /**
      * Sets the vertical scroll position.
-     * @param {TinyElementAndWindow|TinyElementAndWindow[]} el - Element or window.
+     * @template {TinyElementAndWindow|TinyElementAndWindow[]} T
+     * @param {T} el - Element or window.
      * @param {number} value - Scroll top value.
-     * @returns {TinyElementAndWindow|TinyElementAndWindow[]}
+     * @returns {T}
      */
-    static setScrollTop(el: TinyElementAndWindow | TinyElementAndWindow[], value: number): TinyElementAndWindow | TinyElementAndWindow[];
+    static setScrollTop<T extends TinyElementAndWindow | TinyElementAndWindow[]>(el: T, value: number): T;
     /**
      * Sets the horizontal scroll position.
-     * @param {TinyElementAndWindow|TinyElementAndWindow[]} el - Element or window.
+     * @template {TinyElementAndWindow|TinyElementAndWindow[]} T
+     * @param {T} el - Element or window.
      * @param {number} value - Scroll left value.
-     * @returns {TinyElementAndWindow|TinyElementAndWindow[]}
+     * @returns {T}
      */
-    static setScrollLeft(el: TinyElementAndWindow | TinyElementAndWindow[], value: number): TinyElementAndWindow | TinyElementAndWindow[];
+    static setScrollLeft<T extends TinyElementAndWindow | TinyElementAndWindow[]>(el: T, value: number): T;
     /**
      * Returns the total border width and individual sides from `border{Side}Width` CSS properties.
      *
@@ -1421,8 +1398,22 @@ declare class TinyHtml {
      * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) paddings, and each side individually.
      */
     static padding(el: TinyElement): HtmlElBoxSides;
-    static addClass(el: TinyElement | TinyElement[], ...tokens: string[]): (TinyElement | TinyElement[]);
-    static removeClass(el: TinyElement | TinyElement[], ...tokens: string[]): (TinyElement | TinyElement[]);
+    /**
+     * Adds one or more CSS class names to the element.
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
+     * @param {...string} args - One or more class names to add.
+     * @returns {T}
+     */
+    static addClass<T extends TinyElement | TinyElement[]>(el: T, ...args: string[]): T;
+    /**
+     * Removes one or more CSS class names from the element.
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
+     * @param {...string} args - One or more class names to remove.
+     * @returns {T}
+     */
+    static removeClass<T extends TinyElement | TinyElement[]>(el: T, ...args: string[]): T;
     /**
      * Replaces an existing class name with a new one.
      * @param {TinyElement|TinyElement[]} el - Target element.
@@ -1489,11 +1480,12 @@ declare class TinyHtml {
     static toBigInt(el: TinyElement): bigint | null;
     /**
      * Set BigInt content of elements.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {bigint} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static setBigInt(el: TinyElement | TinyElement[], value: bigint): TinyElement | TinyElement[];
+    static setBigInt<T extends TinyElement | TinyElement[]>(el: T, value: bigint): T;
     /**
      * Returns the Date content of the element.
      * @param {TinyElement} el - Target element.
@@ -1502,11 +1494,12 @@ declare class TinyHtml {
     static toDate(el: TinyElement): Date | null;
     /**
      * Set Date content of elements.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {Date} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static setDate(el: TinyElement | TinyElement[], value: Date): TinyElement | TinyElement[];
+    static setDate<T extends TinyElement | TinyElement[]>(el: T, value: Date): T;
     /**
      * Returns the JSON content of the element.
      * @param {TinyElement} el - Target element.
@@ -1515,13 +1508,14 @@ declare class TinyHtml {
     static toJson(el: TinyElement): any | null;
     /**
      * Set JSON content of elements.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {any} value - A JavaScript value, usually an object or array, to be converted.
      * @param {(this: any, key: string, value: any) => any} [replacer] - A function that transforms the results.
      * @param {number|string} [space] - Indentation level or string for formatting.
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static setJson(el: TinyElement | TinyElement[], value: any, replacer?: (this: any, key: string, value: any) => any, space?: number | string): TinyElement | TinyElement[];
+    static setJson<T extends TinyElement | TinyElement[]>(el: T, value: any, replacer?: (this: any, key: string, value: any) => any, space?: number | string): T;
     /**
      * Returns the number content of the element.
      * @param {TinyElement} el - Target element.
@@ -1530,11 +1524,12 @@ declare class TinyHtml {
     static toNumber(el: TinyElement): number | null;
     /**
      * Set number content of elements.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {number} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static setNumber(el: TinyElement | TinyElement[], value: number): TinyElement | TinyElement[];
+    static setNumber<T extends TinyElement | TinyElement[]>(el: T, value: number): T;
     /**
      * Returns the boolean content of the element.
      * @param {TinyElement} el - Target element.
@@ -1543,11 +1538,12 @@ declare class TinyHtml {
     static toBoolean(el: TinyElement): boolean | null;
     /**
      * Set boolean content of elements.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {boolean} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static setBoolean(el: TinyElement | TinyElement[], value: boolean): TinyElement | TinyElement[];
+    static setBoolean<T extends TinyElement | TinyElement[]>(el: T, value: boolean): T;
     /**
      * Returns the string content of the element.
      * @param {TinyElement} el - Target element.
@@ -1556,11 +1552,12 @@ declare class TinyHtml {
     static toString(el: TinyElement): string | null;
     /**
      * Set string content of elements.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {string} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static setString(el: TinyElement | TinyElement[], value: string): TinyElement | TinyElement[];
+    static setString<T extends TinyElement | TinyElement[]>(el: T, value: string): T;
     /**
      * Returns the text content of the element.
      * @param {TinyElement} el - Target element.
@@ -1569,17 +1566,19 @@ declare class TinyHtml {
     static text(el: TinyElement): string | null;
     /**
      * Set text content of elements.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {*} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static setText(el: TinyElement | TinyElement[], value: any): TinyElement | TinyElement[];
+    static setText<T extends TinyElement | TinyElement[]>(el: T, value: any): T;
     /**
      * Remove all child nodes from each element.
-     * @param {TinyElement|TinyElement[]} el
-     * @returns {TinyElement|TinyElement[]}
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
+     * @returns {T}
      */
-    static empty(el: TinyElement | TinyElement[]): TinyElement | TinyElement[];
+    static empty<T extends TinyElement | TinyElement[]>(el: T): T;
     /**
      * Get the innerHTML of the element.
      * @param {TinyElement} el
@@ -1589,11 +1588,12 @@ declare class TinyHtml {
     static html(el: TinyElement, ops?: GetHTMLOptions): string;
     /**
      * Set the innerHTML of each element.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {string} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static setHtml(el: TinyElement | TinyElement[], value: string): TinyElement | TinyElement[];
+    static setHtml<T extends TinyElement | TinyElement[]>(el: T, value: string): T;
     /** @readonly */
     static readonly _valHooks: {
         option: {
@@ -1644,12 +1644,13 @@ declare class TinyHtml {
      * Sets the value of the current HTML value element (input, select, textarea, etc.).
      * Accepts strings, numbers, booleans or arrays of these values, or a callback function that computes them.
      *
-     * @param {TinyInputElement|TinyInputElement[]} el - Target element.
+     * @template {TinyInputElement|TinyInputElement[]} T
+     * @param {T} 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[]}
+     * @returns {T}
      */
-    static setVal(el: TinyInputElement | TinyInputElement[], value: SetValueList | ((el: InputElement, val: SetValueList) => SetValueList)): TinyInputElement | TinyInputElement[];
+    static setVal<T extends TinyInputElement | TinyInputElement[]>(el: T, value: SetValueList | ((el: InputElement, val: SetValueList) => SetValueList)): T;
     /**
      * Maps value types to their corresponding getter functions.
      * Each function extracts a value of a specific type from a compatible HTMLInputElement.
@@ -1796,59 +1797,65 @@ declare class TinyHtml {
     /**
      * Registers an event listener on the specified element.
      *
-     * @param {TinyEventTarget|TinyEventTarget[]} el - The target to listen on.
+     * @template {TinyEventTarget|TinyEventTarget[]} T
+     * @param {T} el - The target to listen on.
      * @param {string|string[]} events - The event type (e.g. 'click', 'keydown').
      * @param {EventListenerOrEventListenerObject|null} handler - The callback function to run on event.
      * @param {EventRegistryOptions} [options] - Optional event listener options.
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {T}
      */
-    static on(el: TinyEventTarget | TinyEventTarget[], events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: EventRegistryOptions): TinyEventTarget | TinyEventTarget[];
+    static on<T extends TinyEventTarget | TinyEventTarget[]>(el: T, events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: EventRegistryOptions): T;
     /**
      * Registers an event listener that runs only once, then is removed.
      *
-     * @param {TinyEventTarget|TinyEventTarget[]} el - The target to listen on.
+     * @template {TinyEventTarget|TinyEventTarget[]} T
+     * @param {T} el - The target to listen on.
      * @param {string|string[]} events - The event type (e.g. 'click', 'keydown').
      * @param {EventListenerOrEventListenerObject} handler - The callback function to run on event.
      * @param {EventRegistryOptions} [options={}] - Optional event listener options.
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {T}
      */
-    static once(el: TinyEventTarget | TinyEventTarget[], events: string | string[], handler: EventListenerOrEventListenerObject, options?: EventRegistryOptions): TinyEventTarget | TinyEventTarget[];
+    static once<T extends TinyEventTarget | TinyEventTarget[]>(el: T, events: string | string[], handler: EventListenerOrEventListenerObject, options?: EventRegistryOptions): T;
     /**
      * Removes a specific event listener from an element.
      *
-     * @param {TinyEventTarget|TinyEventTarget[]} el - The target element.
+     * @template {TinyEventTarget|TinyEventTarget[]} T
+     * @param {T} el - The target element.
      * @param {string|string[]} events - The event type.
      * @param {EventListenerOrEventListenerObject|null} handler - The function originally bound to the event.
      * @param {boolean|EventListenerOptions} [options] - Optional listener options.
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {T}
      */
-    static off(el: TinyEventTarget | TinyEventTarget[], events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): TinyEventTarget | TinyEventTarget[];
+    static off<T extends TinyEventTarget | TinyEventTarget[]>(el: T, events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): T;
     /**
      * Removes all event listeners of a specific type from the element.
      *
-     * @param {TinyEventTarget|TinyEventTarget[]} el - The target element.
+     * @template {TinyEventTarget|TinyEventTarget[]} T
+     * @param {T} el - The target element.
      * @param {string|string[]} events - The event type to remove (e.g. 'click').
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {T}
      */
-    static offAll(el: TinyEventTarget | TinyEventTarget[], events: string | string[]): TinyEventTarget | TinyEventTarget[];
+    static offAll<T extends TinyEventTarget | TinyEventTarget[]>(el: T, events: string | string[]): T;
     /**
      * Removes all event listeners of all types from the element.
      *
-     * @param {TinyEventTarget|TinyEventTarget[]} el - The target element.
+     * @template {TinyEventTarget|TinyEventTarget[]} T
+     * @param {T} el - The target element.
      * @param {((handler: EventListenerOrEventListenerObject|null, event: string) => boolean)|null} [filterFn=null] -
      *        Optional filter function to selectively remove specific handlers.
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {T}
      */
-    static offAllTypes(el: TinyEventTarget | TinyEventTarget[], filterFn?: ((handler: EventListenerOrEventListenerObject | null, event: string) => boolean) | null): TinyEventTarget | TinyEventTarget[];
+    static offAllTypes<T extends TinyEventTarget | TinyEventTarget[]>(el: T, filterFn?: ((handler: EventListenerOrEventListenerObject | null, event: string) => boolean) | null): T;
     /**
      * Triggers all handlers associated with a specific event on the given element.
      *
-     * @param {TinyEventTarget|TinyEventTarget[]} el - Target element where the event should be triggered.
+     * @template {TinyEventTarget|TinyEventTarget[]} T
+     * @param {T} el - Target element where the event should be triggered.
      * @param {string|string[]} events - Name of the event to trigger.
      * @param {Event|CustomEvent|CustomEventInit} [payload] - Optional event object or data to pass.
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {T}
      */
-    static trigger(el: TinyEventTarget | TinyEventTarget[], events: string | string[], payload?: Event | CustomEvent | CustomEventInit): TinyEventTarget | TinyEventTarget[];
+    static trigger<T extends TinyEventTarget | TinyEventTarget[]>(el: T, events: string | string[], payload?: Event | CustomEvent | CustomEventInit): T;
     /**
      * Internal property name normalization map (similar to jQuery's `propFix`).
      * Maps attribute-like names to their JavaScript DOM property equivalents.
@@ -1905,19 +1912,21 @@ declare class TinyHtml {
     static attr(el: TinyElement, name: string): string | null;
     /**
      * Set an attribute on an element.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {string} name
      * @param {string|null} [value=null]
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static setAttr(el: TinyElement | TinyElement[], name: string, value?: string | null): TinyElement | TinyElement[];
+    static setAttr<T extends TinyElement | TinyElement[]>(el: T, name: string, value?: string | null): T;
     /**
      * Remove attribute(s) from an element.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {string} name Space-separated list of attributes.
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static removeAttr(el: TinyElement | TinyElement[], name: string): TinyElement | TinyElement[];
+    static removeAttr<T extends TinyElement | TinyElement[]>(el: T, name: string): T;
     /**
      * Check if an attribute exists on an element.
      * @param {TinyElement} el
@@ -1934,31 +1943,36 @@ declare class TinyHtml {
     static hasProp(el: TinyElement, name: string): boolean;
     /**
      * Set a property on an element.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {string} name
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static addProp(el: TinyElement | TinyElement[], name: string): TinyElement | TinyElement[];
+    static addProp<T extends TinyElement | TinyElement[]>(el: T, name: string): T;
     /**
      * Remove a property from an element.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {string} name
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {T}
      */
-    static removeProp(el: TinyElement | TinyElement[], name: string): TinyElement | TinyElement[];
+    static removeProp<T extends TinyElement | TinyElement[]>(el: T, name: string): T;
     /**
      * Toggle a boolean property.
-     * @param {TinyElement|TinyElement[]} el
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el
      * @param {string} name
      * @param {boolean} [force]
+     * @returns {T}
      */
-    static toggleProp(el: TinyElement | TinyElement[], name: string, force?: boolean): void;
+    static toggleProp<T extends TinyElement | TinyElement[]>(el: T, name: string, force?: boolean): T;
     /**
      * Removes an element from the DOM.
-     * @param {TinyElement|TinyElement[]} el - The DOM element or selector to remove.
-     * @returns {TinyElement|TinyElement[]}
+     * @template {TinyElement|TinyElement[]} T
+     * @param {T} el - The DOM element or selector to remove.
+     * @returns {T}
      */
-    static remove(el: TinyElement | TinyElement[]): TinyElement | TinyElement[];
+    static remove<T extends TinyElement | TinyElement[]>(el: T): T;
     /**
      * Returns the index of the first element within its parent or relative to a selector/element.
      *
@@ -2093,45 +2107,45 @@ declare class TinyHtml {
     /**
      * Creates an instance of TinyHtml for a specific Element.
      * Useful when you want to operate repeatedly on the same element using instance methods.
-     * @param {ConstructorElValues|ConstructorElValues[]|NodeListOf<Element>|HTMLCollectionOf<Element>|NodeListOf<HTMLElement>} el - The element to wrap and manipulate.
+     * @param {TinyHtmlT} el - The element to wrap and manipulate.
      */
-    constructor(el: ConstructorElValues | ConstructorElValues[] | NodeListOf<Element> | HTMLCollectionOf<Element> | NodeListOf<HTMLElement>);
+    constructor(el: TinyHtmlT);
     /**
      * 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.
+     * @returns {TinyHtml<Element>|null} A TinyHtml instance wrapping the matched element.
      */
-    querySelector(selector: string): TinyHtml | null;
+    querySelector(selector: string): TinyHtml<Element> | null;
     /**
      * 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.
+     * @returns {TinyHtml<NodeListOf<Element>>} An array of TinyHtml instances wrapping the matched elements.
      */
-    querySelectorAll(selector: string): TinyHtml;
+    querySelectorAll(selector: string): TinyHtml<NodeListOf<Element>>;
     /**
      * 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.
+     * @returns {TinyHtml<HTMLCollectionOf<Element>>} An array of TinyHtml instances wrapping the found elements.
      */
-    getElementsByClassName(selector: string): TinyHtml;
+    getElementsByClassName(selector: string): TinyHtml<HTMLCollectionOf<Element>>;
     /**
      * 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.
+     * @returns {TinyHtml<HTMLCollectionOf<Element>>} An array of TinyHtml instances wrapping the found elements.
      */
-    getElementsByTagNameNS(localName: string, namespaceURI?: string | null): TinyHtml;
+    getElementsByTagNameNS(localName: string, namespaceURI?: string | null): TinyHtml<HTMLCollectionOf<Element>>;
     /**
      * Iterates over all elements, executing the provided callback on each.
-     * @param {(element: TinyHtml, index: number, items: TinyHtml[]) => void} callback - Function invoked for each element.
-     * @returns {TinyHtml} The current instance for chaining.
+     * @param {(element: TinyHtmlAny, index: number, items: TinyHtmlAny[]) => void} callback - Function invoked for each element.
+     * @returns {this} The current instance for chaining.
      */
-    forEach(callback: (element: TinyHtml, index: number, items: TinyHtml[]) => void): TinyHtml;
+    forEach(callback: (element: TinyHtmlAny, index: number, items: TinyHtmlAny[]) => void): this;
     /**
      * Returns the current target held by this instance.
      *
@@ -2143,9 +2157,9 @@ declare class TinyHtml {
      * Extracts a single DOM element from the internal list at the specified index.
      *
      * @param {number} index - The index of the element to extract.
-     * @returns {TinyHtml} A new TinyHtml instance wrapping the extracted element.
+     * @returns {TinyHtmlAny} A new TinyHtml instance wrapping the extracted element.
      */
-    extract(index: number): TinyHtml;
+    extract(index: number): TinyHtmlAny;
     /**
      * Checks whether the element exists at the given index.
      *
@@ -2248,9 +2262,9 @@ declare class 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 {TinyElement}
+     * @returns {this}
      */
-    setData(key: string, value: any, isPrivate?: boolean): TinyElement;
+    setData(key: string, value: any, isPrivate?: boolean): this;
     /**
      * Returns the direct parent node of the given element, excluding document fragments.
      *
@@ -2330,75 +2344,75 @@ declare class TinyHtml {
      * 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}
+     * @returns {this}
      */
-    append(...children: (TinyNode | TinyNode[] | string)[]): TinyElement;
+    append(...children: (TinyNode | TinyNode[] | string)[]): this;
     /**
      * 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}
+     * @returns {this}
      */
-    prepend(...children: (TinyNode | TinyNode[] | string)[]): TinyElement;
+    prepend(...children: (TinyNode | TinyNode[] | string)[]): this;
     /**
      * 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}
+     * @returns {this}
      */
-    before(...children: (TinyNode | TinyNode[] | string)[]): TinyElement;
+    before(...children: (TinyNode | TinyNode[] | string)[]): this;
     /**
      * 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}
+     * @returns {this}
      */
-    after(...children: (TinyNode | TinyNode[] | string)[]): TinyElement;
+    after(...children: (TinyNode | TinyNode[] | string)[]): this;
     /**
      * 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}
+     * @returns {this}
      */
-    replaceWith(...newNodes: (TinyNode | TinyNode[] | string)[]): TinyElement;
+    replaceWith(...newNodes: (TinyNode | TinyNode[] | string)[]): this;
     /**
      * 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[]}
+     * @returns {this}
      */
-    appendTo(targets: TinyNode | TinyNode[]): TinyNode | TinyNode[];
+    appendTo(targets: TinyNode | TinyNode[]): this;
     /**
      * 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[]}
+     * @returns {this}
      */
-    prependTo(targets: TinyElement | TinyElement[]): TinyElement | TinyElement[];
+    prependTo(targets: TinyElement | TinyElement[]): this;
     /**
      * Inserts the element before a child of a given target, or before the target itself.
      *
      * @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[]}
+     * @returns {this}
      */
-    insertBefore(target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): TinyNode | TinyNode[];
+    insertBefore(target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): this;
     /**
      * Inserts the element after a child of a given target, or after the target itself.
      *
      * @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[]}
+     * @returns {this}
      */
-    insertAfter(target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): TinyNode | TinyNode[];
+    insertAfter(target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): this;
     /**
      * Replaces all target elements with the provided element(s).
      * If multiple targets exist, the inserted elements are cloned accordingly.
      *
      * @param {TinyNode | TinyNode[]} targets - The elements to be replaced.
-     * @returns {TinyNode|TinyNode[]}
+     * @returns {this}
      */
-    replaceAll(targets: TinyNode | TinyNode[]): TinyNode | TinyNode[];
+    replaceAll(targets: TinyNode | TinyNode[]): this;
     /**
      * Returns the number of elements currently stored in the internal element list.
      *
@@ -2445,9 +2459,9 @@ declare class 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[]}
+     * @returns {this}
      */
-    setStyle(prop: string | Object, value?: string | null): TinyHtmlElement | TinyHtmlElement[];
+    setStyle(prop: string | Object, value?: string | null): this;
     /**
      * Gets the value of a specific inline style property.
      *
@@ -2475,9 +2489,9 @@ declare class TinyHtml {
      * 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[]}
+     * @returns {this}
      */
-    removeStyle(prop: string | string[]): TinyHtmlElement | TinyHtmlElement[];
+    removeStyle(prop: string | string[]): this;
     /**
      * Toggles a CSS property value between two given values.
      *
@@ -2486,29 +2500,29 @@ declare class 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[]}
+     * @returns {this}
      */
-    toggleStyle(prop: string, val1: string, val2: string): TinyHtmlElement | TinyHtmlElement[];
+    toggleStyle(prop: string, val1: string, val2: string): this;
     /**
      * Removes all inline styles (`style` attribute) from the given element(s).
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    clearStyle(): TinyElement | TinyElement[];
+    clearStyle(): this;
     /**
      * Focus the element.
-     * @returns {TinyHtmlElement}
+     * @returns {this}
      */
-    focus(): TinyHtmlElement;
+    focus(): this;
     /**
      * Blur the element.
-     * @returns {TinyHtmlElement}
+     * @returns {this}
      */
-    blur(): TinyHtmlElement;
+    blur(): this;
     /**
      * Select the text content of an input or textarea element.
-     * @returns {TinyHtml|HTMLInputElement|HTMLTextAreaElement}
+     * @returns {this}
      */
-    select(): TinyHtml | HTMLInputElement | HTMLTextAreaElement;
+    select(): this;
     /**
      * Gets the width or height of an element based on the box model.
      * @param {"width"|"height"} type - Dimension type.
@@ -2519,15 +2533,15 @@ declare class TinyHtml {
     /**
      * Sets the height of the element.
      * @param {string|number} value - Height value.
-     * @returns {TinyHtmlElement}
+     * @returns {this}
      */
-    setHeight(value: string | number): TinyHtmlElement;
+    setHeight(value: string | number): this;
     /**
      * Sets the width of the element.
      * @param {string|number} value - Width value.
-     * @returns {TinyHtmlElement}
+     * @returns {this}
      */
-    setWidth(value: string | number): TinyHtmlElement;
+    setWidth(value: string | number): this;
     /**
      * Returns content box height.
      * @returns {number}
@@ -2565,9 +2579,9 @@ declare class TinyHtml {
      *
      * @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[]}
+     * @returns {this}
      */
-    animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, ops?: number | KeyframeAnimationOptions): TinyElement | TinyElement[];
+    animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, ops?: number | KeyframeAnimationOptions): this;
     /**
      * Gets the offset of the element relative to the document.
      * @returns {{top: number, left: number}}
@@ -2612,7 +2626,7 @@ declare class TinyHtml {
      * @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[]}
+     * @returns {this}
      */
     scrollToXY({ targetX, targetY, duration, easing, onAnimation }?: {
         targetX?: number | undefined;
@@ -2620,19 +2634,19 @@ declare class TinyHtml {
         duration?: number | undefined;
         easing?: Easings | undefined;
         onAnimation?: OnScrollAnimation | undefined;
-    }): TinyElementAndWindow | TinyElementAndWindow[];
+    }): this;
     /**
      * Sets the vertical scroll position.
      * @param {number} value - Scroll top value.
-     * @returns {TinyElementAndWindow|TinyElementAndWindow[]}
+     * @returns {this}
      */
-    setScrollTop(value: number): TinyElementAndWindow | TinyElementAndWindow[];
+    setScrollTop(value: number): this;
     /**
      * Sets the horizontal scroll position.
      * @param {number} value - Scroll left value.
-     * @returns {TinyElementAndWindow|TinyElementAndWindow[]}
+     * @returns {this}
      */
-    setScrollLeft(value: number): TinyElementAndWindow | TinyElementAndWindow[];
+    setScrollLeft(value: number): this;
     /**
      * Returns the total border width and individual sides from `border{Side}Width` CSS properties.
      *
@@ -2657,8 +2671,18 @@ declare class TinyHtml {
      * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) paddings, and each side individually.
      */
     padding(): HtmlElBoxSides;
-    addClass(...tokens: string[]): (TinyElement | TinyElement[]);
-    removeClass(...tokens: string[]): (TinyElement | TinyElement[]);
+    /**
+     * Adds one or more CSS class names to the element.
+     * @param {...string} args - One or more class names to add.
+     * @returns {this}
+     */
+    addClass(...args: string[]): this;
+    /**
+     * Removes one or more CSS class names from the element.
+     * @param {...string} args - One or more class names to remove.
+     * @returns {this}
+     */
+    removeClass(...args: string[]): this;
     /**
      * Replaces an existing class name with a new one.
      * @param {string} token - The class name to be replaced.
@@ -2717,9 +2741,9 @@ declare class TinyHtml {
     /**
      * Set BigInt content of the element.
      * @param {bigint} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    setBigInt(value: bigint): TinyElement | TinyElement[];
+    setBigInt(value: bigint): this;
     /**
      * Returns the Date content of the element.
      * @returns {Date|null}
@@ -2728,9 +2752,9 @@ declare class TinyHtml {
     /**
      * Set Date content of the element.
      * @param {Date} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    setDate(value: Date): TinyElement | TinyElement[];
+    setDate(value: Date): this;
     /**
      * Returns the JSON content of the element.
      * @returns {any|null}
@@ -2741,9 +2765,9 @@ declare class TinyHtml {
      * @param {any} value - A JavaScript value, usually an object or array, to be converted.
      * @param {(this: any, key: string, value: any) => any} [replacer] - A function that transforms the results.
      * @param {number|string} [space] - Indentation level or string for formatting.
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    setJson(value: any, replacer?: (this: any, key: string, value: any) => any, space?: number | string): TinyElement | TinyElement[];
+    setJson(value: any, replacer?: (this: any, key: string, value: any) => any, space?: number | string): this;
     /**
      * Returns the number content of the element.
      * @returns {number|null} The text content or null if none.
@@ -2752,9 +2776,9 @@ declare class TinyHtml {
     /**
      * Set number content of the element.
      * @param {number} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    setNumber(value: number): TinyElement | TinyElement[];
+    setNumber(value: number): this;
     /**
      * Returns the boolean content of the element.
      * @returns {boolean|null}
@@ -2763,9 +2787,9 @@ declare class TinyHtml {
     /**
      * Set boolean content of the element.
      * @param {boolean} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    setBoolean(value: boolean): TinyElement | TinyElement[];
+    setBoolean(value: boolean): this;
     /**
      * Returns the string content of the element.
      * @returns {string|null} The string content or null if none.
@@ -2774,9 +2798,9 @@ declare class TinyHtml {
     /**
      * Set string content of the element.
      * @param {string} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    setString(value: string): TinyElement | TinyElement[];
+    setString(value: string): this;
     /**
      * Returns the text content of the element.
      * @returns {string|null} The text content or null if none.
@@ -2785,14 +2809,14 @@ declare class TinyHtml {
     /**
      * Set text content of the element.
      * @param {*} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    setText(value: any): TinyElement | TinyElement[];
+    setText(value: any): this;
     /**
      * Remove all child nodes of the element.
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    empty(): TinyElement | TinyElement[];
+    empty(): this;
     /**
      * Get the innerHTML of the element.
      * @param {GetHTMLOptions} [ops]
@@ -2802,18 +2826,18 @@ declare class TinyHtml {
     /**
      * Set the innerHTML of the element.
      * @param {string} value
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    setHtml(value: string): TinyElement | TinyElement[];
+    setHtml(value: string): this;
     /**
      * Sets the value of the current HTML value element (input, select, textarea, etc.).
      * 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[]}
+     * @returns {this}
      * @throws {Error} If the computed value is not a valid string or boolean.
      */
-    setVal(value: SetValueList | ((el: InputElement, val: SetValueList) => SetValueList)): TinyInputElement | TinyInputElement[];
+    setVal(value: SetValueList | ((el: InputElement, val: SetValueList) => SetValueList)): this;
     /**
      * Retrieves the raw value from the HTML input element.
      * If a custom value hook exists, it will be used first.
@@ -2911,50 +2935,50 @@ declare class TinyHtml {
      * @param {string|string[]} events - The event type (e.g. 'click', 'keydown').
      * @param {EventListenerOrEventListenerObject|null} handler - The callback function to run on event.
      * @param {EventRegistryOptions} [options] - Optional event listener options.
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {this}
      */
-    on(events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: EventRegistryOptions): TinyEventTarget | TinyEventTarget[];
+    on(events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: EventRegistryOptions): this;
     /**
      * Registers an event listener that runs only once, then is removed.
      *
      * @param {string|string[]} events - The event type (e.g. 'click', 'keydown').
      * @param {EventListenerOrEventListenerObject} handler - The callback function to run on event.
      * @param {EventRegistryOptions} [options={}] - Optional event listener options.
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {this}
      */
-    once(events: string | string[], handler: EventListenerOrEventListenerObject, options?: EventRegistryOptions): TinyEventTarget | TinyEventTarget[];
+    once(events: string | string[], handler: EventListenerOrEventListenerObject, options?: EventRegistryOptions): this;
     /**
      * Removes a specific event listener from an element.
      *
      * @param {string|string[]} events - The event type.
      * @param {EventListenerOrEventListenerObject|null} handler - The function originally bound to the event.
      * @param {boolean|EventListenerOptions} [options] - Optional listener options.
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {this}
      */
-    off(events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): TinyEventTarget | TinyEventTarget[];
+    off(events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): this;
     /**
      * Removes all event listeners of a specific type from the element.
      *
      * @param {string|string[]} events - The event type to remove (e.g. 'click').
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {this}
      */
-    offAll(events: string | string[]): TinyEventTarget | TinyEventTarget[];
+    offAll(events: string | string[]): this;
     /**
      * Removes all event listeners of all types from the element.
      *
      * @param {((handler: EventListenerOrEventListenerObject|null, event: string) => boolean)|null} [filterFn=null] -
      *        Optional filter function to selectively remove specific handlers.
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {this}
      */
-    offAllTypes(filterFn?: ((handler: EventListenerOrEventListenerObject | null, event: string) => boolean) | null): TinyEventTarget | TinyEventTarget[];
+    offAllTypes(filterFn?: ((handler: EventListenerOrEventListenerObject | null, event: string) => boolean) | null): this;
     /**
      * Triggers all handlers associated with a specific event on the given element.
      *
      * @param {string|string[]} events - Name of the event to trigger.
      * @param {Event|CustomEvent|CustomEventInit} [payload] - Optional event object or data to pass.
-     * @returns {TinyEventTarget|TinyEventTarget[]}
+     * @returns {this}
      */
-    trigger(events: string | string[], payload?: Event | CustomEvent | CustomEventInit): TinyEventTarget | TinyEventTarget[];
+    trigger(events: string | string[], payload?: Event | CustomEvent | CustomEventInit): this;
     /**
      * Get an attribute on an element.
      * @param {string} name
@@ -2965,15 +2989,15 @@ declare class TinyHtml {
      * Set an attribute on an element.
      * @param {string} name
      * @param {string|null} [value=null]
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    setAttr(name: string, value?: string | null): TinyElement | TinyElement[];
+    setAttr(name: string, value?: string | null): this;
     /**
      * Remove attribute(s) from an element.
      * @param {string} name Space-separated list of attributes.
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    removeAttr(name: string): TinyElement | TinyElement[];
+    removeAttr(name: string): this;
     /**
      * Check if an attribute exists on an element.
      * @param {string} name
@@ -2989,26 +3013,27 @@ declare class TinyHtml {
     /**
      * Set a property on an element.
      * @param {string} name
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    addProp(name: string): TinyElement | TinyElement[];
+    addProp(name: string): this;
     /**
      * Remove a property from an element.
      * @param {string} name
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    removeProp(name: string): TinyElement | TinyElement[];
+    removeProp(name: string): this;
     /**
      * Toggle a boolean property.
      * @param {string} name
      * @param {boolean} [force]
+     * @returns {this}
      */
-    toggleProp(name: string, force?: boolean): void;
+    toggleProp(name: string, force?: boolean): this;
     /**
      * Removes the element from the DOM.
-     * @returns {TinyElement|TinyElement[]}
+     * @returns {this}
      */
-    remove(): TinyElement | TinyElement[];
+    remove(): this;
     /**
      * Returns the index of the first element within its parent or relative to a selector/element.
      *