tiny-essentials 1.14.0 → 1.16.0

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

@@ -0,0 +1,2151 @@
+export default TinyHtml;
+/**
+ * Represents a raw Node 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 TinyNode = Node | TinyHtml | 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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.
+ */
+export type ElementAndWindow = Element | Window;
+/**
+ * A parameter type used for filtering or matching elements.
+ * It can be:
+ * - A string (CSS selector),
+ * - A raw DOM element,
+ * - An array of raw DOM elements,
+ * - A filtering function that receives an index and element,
+ *   and returns true if it matches.
+ */
+export type WinnowRequest = string | Element | Element[] | ((index: number, el: Element) => boolean);
+/**
+ * Elements accepted as constructor values for TinyHtml.
+ * These include common DOM elements and root containers.
+ */
+export type ConstructorElValues = Window | Element | Document;
+/**
+ * The handler function used in event listeners.
+ */
+export type EventRegistryHandle = (e: Event) => any;
+/**
+ * Options passed to `addEventListener` or `removeEventListener`.
+ * Can be a boolean or an object of type `AddEventListenerOptions`.
+ */
+export type EventRegistryOptions = boolean | AddEventListenerOptions;
+/**
+ * Structure describing a registered event callback and its options.
+ */
+export type EventRegistryItem = {
+    /**
+     * - The function to be executed when the event is triggered.
+     */
+    handler: EventRegistryHandle;
+    /**
+     * - Optional configuration passed to the listener.
+     */
+    options?: EventRegistryOptions | undefined;
+};
+/**
+ * Maps event names (e.g., `"click"`, `"keydown"`) to a list of registered handlers and options.
+ */
+export type EventRegistryList = Record<string, EventRegistryItem[]>;
+/**
+ * A key-value store associated with a specific DOM element.
+ * Keys are strings, and values can be of any type.
+ */
+export type ElementDataStore = Record<string, any>;
+/**
+ * Possible directions from which a collision was detected and locked.
+ */
+export type CollisionDirLock = "top" | "bottom" | "left" | "right";
+export type HtmlElBoxSides = {
+    /**
+     * - Total horizontal size (left + right)
+     */
+    x: number;
+    /**
+     * - Total vertical size (top + bottom)
+     */
+    y: number;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+/**
+ * - Primitive types accepted as input values.
+ */
+export type SetValueBase = string | number | Date | boolean | null;
+/**
+ * Types of value extractors supported by TinyHtml._valTypes.
+ */
+export type GetValueTypes = "string" | "date" | "number";
+/**
+ * - A single value or an array of values to be assigned to the input element.
+ */
+export type SetValueList = SetValueBase | SetValueBase[];
+/**
+ * A list of HTML form elements that can have a `.value` property used by TinyHtml.
+ * Includes common input types used in forms.
+ */
+export type InputElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | HTMLOptionElement;
+/**
+ * Possible directions from which a collision was detected and locked.
+ *
+ * @typedef {'top'|'bottom'|'left'|'right'} CollisionDirLock
+ */
+/**
+ * @typedef {Object} HtmlElBoxSides
+ * @property {number} x - Total horizontal size (left + right)
+ * @property {number} y - Total vertical size (top + bottom)
+ * @property {number} left
+ * @property {number} right
+ * @property {number} top
+ * @property {number} bottom
+ */
+/**
+ * @typedef {string | number | Date | boolean | null} SetValueBase - Primitive types accepted as input values.
+ */
+/**
+ * @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
+ */
+/**
+ * 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
+ */
+declare class TinyHtml {
+    /** @typedef {import('../basics/collision.mjs').ObjRect} ObjRect */
+    static Utils: {
+        getElsRelativeCenterOffset(rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect): {
+            x: number;
+            y: number;
+        };
+        getElsCollDirDepth(rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect): {
+            inDir: Dirs | null;
+            dirX: Dirs | null;
+            dirY: Dirs | null;
+            depthX: number;
+            depthY: number;
+        };
+        getElsCollDetails(rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect): {
+            depth: CollData;
+            dirs: CollDirs;
+            isNeg: NegCollDirs;
+        };
+        areElsCollTop: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
+        areElsCollBottom: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
+        areElsCollLeft: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
+        areElsCollRight: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
+        areElsCollPerfTop: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
+        areElsCollPerfBottom: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
+        areElsCollPerfLeft: (rect1: TinyCollision.ObjRect, 
+        /**
+         * @typedef {string | number | Date | boolean | null} SetValueBase - Primitive types accepted as input values.
+         */
+        /**
+         * @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
+         */
+        /**
+         * 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) => boolean;
+        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: (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;
+            overlapTop: number;
+            overlapBottom: number;
+        };
+        getElsCollOverlapPos: ({ overlapLeft, overlapRight, overlapTop, overlapBottom, }?: {
+            overlapLeft?: number | undefined;
+            overlapRight?: number | undefined;
+            overlapTop?: number | undefined;
+            overlapBottom?: number | undefined;
+        }) => {
+            dirX: Dirs;
+            dirY: Dirs;
+        };
+        getRectCenter: (rect: TinyCollision.ObjRect) => {
+            x: number;
+            y: number;
+        };
+    };
+    /**
+     * 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.
+     */
+    static query(selector: string): TinyHtml;
+    /**
+     * Queries the document 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.
+     */
+    static queryAll(selector: string): TinyHtml[];
+    /**
+     * 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.
+     */
+    static getById(selector: string): TinyHtml;
+    /**
+     * 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.
+     */
+    static getByClassName(selector: string): TinyHtml[];
+    /**
+     * 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.
+     */
+    static getByName(selector: string): TinyHtml[];
+    /**
+     * 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.
+     */
+    static getByTagNameNS(localName: string, namespaceURI?: string | null): TinyHtml[];
+    /**
+     * @param {TinyElement|EventTarget|null|(TinyElement|EventTarget|null)[]} elems
+     * @param {string} where
+     * @param {any[]} TheTinyElements
+     * @param {string[]} elemName
+     * @returns {any[]}
+     * @readonly
+     */
+    static readonly _preElemsTemplate(elems: TinyElement | EventTarget | null | (TinyElement | EventTarget | null)[], where: string, TheTinyElements: any[], elemName: string[]): any[];
+    /**
+     * @param {TinyElement|EventTarget|null|(TinyElement|EventTarget|null)[]} elems
+     * @param {string} where
+     * @param {any[]} TheTinyElements
+     * @param {string[]} elemName
+     * @param {boolean} [canNull=false]
+     * @returns {any}
+     * @readonly
+     */
+    static readonly _preElemTemplate(elems: TinyElement | EventTarget | null | (TinyElement | EventTarget | null)[], where: string, TheTinyElements: any[], elemName: string[], canNull?: boolean): any;
+    /**
+     * Ensures the input is returned as an array.
+     * Useful to normalize operations across multiple or single elements.
+     *
+     * @param {TinyElement|TinyElement[]} elems - A single element or array of elements.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {Element[]} - Always returns an array of elements.
+     * @readonly
+     */
+    static readonly _preElems(elems: TinyElement | TinyElement[], where: string): Element[];
+    /**
+     * Ensures the input is returned as an single element.
+     * Useful to normalize operations across multiple or single elements.
+     *
+     * @param {TinyElement|TinyElement[]} elems - A single element or array of elements.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {Element} - Always returns an single element.
+     * @readonly
+     */
+    static readonly _preElem(elems: TinyElement | TinyElement[], where: string): Element;
+    /**
+     * Ensures the input is returned as an array.
+     * Useful to normalize operations across multiple or single nodes.
+     *
+     * @param {TinyNode|TinyNode[]} elems - A single node or array of nodes.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {Node[]} - Always returns an array of nodes.
+     * @readonly
+     */
+    static readonly _preNodeElems(elems: TinyNode | TinyNode[], where: string): Node[];
+    /**
+     * Ensures the input is returned as an single node.
+     * Useful to normalize operations across multiple or single nodes.
+     *
+     * @param {TinyNode|TinyNode[]} elems - A single node or array of nodes.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {Node} - Always returns an single node.
+     * @readonly
+     */
+    static readonly _preNodeElem(elems: TinyNode | TinyNode[], where: string): Node;
+    /**
+     * Ensures the input is returned as an single node.
+     * Useful to normalize operations across multiple or single nodes.
+     *
+     * @param {TinyNode|TinyNode[]} elems - A single node or array of nodes.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {Node|null} - Always returns an single node or null.
+     * @readonly
+     */
+    static readonly _preNodeElemWithNull(elems: TinyNode | TinyNode[], where: string): Node | null;
+    /**
+     * Ensures the input is returned as an array.
+     * Useful to normalize operations across multiple or single html elements.
+     *
+     * @param {TinyElement|TinyElement[]} elems - A single html element or array of html elements.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {HTMLElement[]} - Always returns an array of html elements.
+     * @readonly
+     */
+    static readonly _preHtmlElems(elems: TinyElement | TinyElement[], where: string): HTMLElement[];
+    /**
+     * Ensures the input is returned as an single html element.
+     * Useful to normalize operations across multiple or single html elements.
+     *
+     * @param {TinyElement|TinyElement[]} elems - A single html element or array of html elements.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {HTMLElement} - Always returns an single html element.
+     * @readonly
+     */
+    static readonly _preHtmlElem(elems: TinyElement | TinyElement[], where: string): HTMLElement;
+    /**
+     * Ensures the input is returned as an array.
+     * Useful to normalize operations across multiple or single event target elements.
+     *
+     * @param {TinyInputElement|TinyInputElement[]} elems - A single event target element or array of html elements.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {InputElement[]} - Always returns an array of event target elements.
+     * @readonly
+     */
+    static readonly _preInputElems(elems: TinyInputElement | TinyInputElement[], where: string): InputElement[];
+    /**
+     * Ensures the input is returned as an single event target element.
+     * Useful to normalize operations across multiple or single event target elements.
+     *
+     * @param {TinyInputElement|TinyInputElement[]} elems - A single event target element or array of html elements.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {InputElement} - Always returns an single event target element.
+     * @readonly
+     */
+    static readonly _preInputElem(elems: TinyInputElement | TinyInputElement[], where: string): InputElement;
+    /**
+     * Ensures the input is returned as an array.
+     * Useful to normalize operations across multiple or single event target elements.
+     *
+     * @param {TinyEventTarget|TinyEventTarget[]} elems - A single event target element or array of html elements.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {EventTarget[]} - Always returns an array of event target elements.
+     * @readonly
+     */
+    static readonly _preEventTargetElems(elems: TinyEventTarget | TinyEventTarget[], where: string): EventTarget[];
+    /**
+     * Ensures the input is returned as an single event target element.
+     * Useful to normalize operations across multiple or single event target elements.
+     *
+     * @param {TinyEventTarget|TinyEventTarget[]} elems - A single event target element or array of html elements.
+     * @param {string} where - The method or context name where validation is being called.
+     * @returns {EventTarget} - Always returns an single event target element.
+     * @readonly
+     */
+    static readonly _preEventTargetElem(elems: TinyEventTarget | TinyEventTarget[], where: string): EventTarget;
+    /**
+     * Ensures the input is returned as an array.
+     * Useful to normalize operations across multiple or single element/window elements.
+     *
+     * @param {TinyElementAndWindow|TinyElementAndWindow[]} 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 readonly _preElemsAndWindow(elems: TinyElementAndWindow | TinyElementAndWindow[], where: string): ElementAndWindow[];
+    /**
+     * Ensures the input is returned as an single element/window element.
+     * Useful to normalize operations across multiple or single element/window elements.
+     *
+     * @param {TinyElementAndWindow|TinyElementAndWindow[]} 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 readonly _preElemAndWindow(elems: TinyElementAndWindow | TinyElementAndWindow[], where: string): ElementAndWindow;
+    /**
+     * Normalizes and converts one or more DOM elements (or TinyHtml instances)
+     * into an array of `TinyHtml` instances.
+     *
+     * - If a plain DOM element is passed, it is wrapped into a `TinyHtml` instance.
+     * - If a `TinyHtml` instance is already passed, it is preserved.
+     * - If an array is passed, all elements inside are converted accordingly.
+     *
+     * This ensures consistent access to methods of the `TinyHtml` class regardless
+     * of the input form.
+     *
+     * @param {TinyElement|TinyElement[]} elems - A single element or an array of elements (DOM or TinyHtml).
+     * @returns {TinyHtml[]} An array of TinyHtml instances corresponding to the input elements.
+     */
+    static toTinyElm(elems: TinyElement | TinyElement[]): TinyHtml[];
+    /**
+     * Extracts native `Element` instances from one or more elements,
+     * which can be either raw DOM elements or wrapped in `TinyHtml`.
+     *
+     * - If a `TinyHtml` instance is passed, its internal DOM element is extracted.
+     * - If a raw DOM element is passed, it is returned as-is.
+     * - If an array is passed, each element is processed accordingly.
+     *
+     * This function guarantees that the return value is always an array of
+     * raw `Element` objects, regardless of whether the input was
+     * a mix of `TinyHtml` or native DOM elements.
+     *
+     * @param {TinyElement|TinyElement[]} elems - A single element or an array of elements (DOM or TinyHtml`).
+     * @returns {Element[]} An array of Element instances extracted from the input.
+     */
+    static fromTinyElm(elems: TinyElement | TinyElement[]): Element[];
+    /**
+     * Filters an array of elements based on a selector, function, element, or array of elements.
+     *
+     * @param {TinyElement|TinyElement[]} elems
+     * @param {WinnowRequest} qualifier
+     * @param {string} where - The context/method name using this validation.
+     * @param {boolean} not Whether to invert the result (used for .not())
+     * @returns {Element[]}
+     */
+    static winnow(elems: TinyElement | TinyElement[], qualifier: WinnowRequest, where: string, not?: boolean): Element[];
+    /**
+     * Filters a set of elements by a CSS selector.
+     *
+     * @param {TinyElement|TinyElement[]} elems
+     * @param {string} selector
+     * @param {boolean} not
+     * @returns {Element[]}
+     */
+    static filter(elems: TinyElement | TinyElement[], selector: string, not?: boolean): Element[];
+    /**
+     * Returns only the elements matching the given selector or function.
+     *
+     * @param {TinyElement|TinyElement[]} elems
+     * @param {WinnowRequest} selector
+     * @returns {Element[]}
+     */
+    static filterOnly(elems: TinyElement | TinyElement[], selector: WinnowRequest): Element[];
+    /**
+     * Returns only the elements **not** matching the given selector or function.
+     *
+     * @param {TinyElement|TinyElement[]} elems
+     * @param {WinnowRequest} selector
+     * @returns {Element[]}
+     */
+    static not(elems: TinyElement | TinyElement[], selector: WinnowRequest): Element[];
+    /**
+     * Finds elements matching a selector within a context.
+     *
+     * @param {TinyElement|TinyElement[]} context
+     * @param {string} selector
+     * @returns {Element[]}
+     */
+    static find(context: TinyElement | TinyElement[], selector: string): Element[];
+    /**
+     * Checks if at least one element matches the selector.
+     *
+     * @param {TinyElement|TinyElement[]} elems
+     * @param {WinnowRequest} selector
+     * @returns {boolean}
+     */
+    static is(elems: TinyElement | TinyElement[], selector: WinnowRequest): boolean;
+    /**
+     * Returns elements from the current list that contain the given target(s).
+     * @param {TinyElement|TinyElement[]} roots - A single element or an array of elements (DOM or TinyHtml).
+     * @param {string|TinyElement|TinyElement[]} target - Selector or DOM element(s).
+     * @returns {Element[]} Elements that contain the target.
+     */
+    static has(roots: TinyElement | TinyElement[], target: string | TinyElement | TinyElement[]): Element[];
+    /**
+     * Finds the closest ancestor (including self) that matches the selector.
+     *
+     * @param {TinyElement|TinyElement[]} els - A single element or an array of elements (DOM or TinyHtml).
+     * @param {string|Element} selector - A selector string or DOM element to match.
+     * @param {Element|null} [context] - An optional context to stop searching.
+     * @returns {Element[]}
+     */
+    static closest(els: TinyElement | TinyElement[], selector: string | Element, context?: Element | null): Element[];
+    /**
+     * Compares two DOM elements to determine if they refer to the same node in the document.
+     *
+     * This performs a strict equality check (`===`) between the two elements.
+     *
+     * @param {TinyNode} elem - The first DOM element to compare.
+     * @param {TinyNode} otherElem - The second DOM element to compare.
+     * @returns {boolean} `true` if both elements are the same DOM node; otherwise, `false`.
+     */
+    static isSameDom(elem: TinyNode, otherElem: TinyNode): boolean;
+    /**
+     * Internal data selectors for accessing public or private data stores.
+     *
+     * @type {Record<string, (where: string, elem: TinyElement) => ElementDataStore>}
+     * @readonly
+     */
+    static readonly _dataSelector: Record<string, (where: string, elem: TinyElement) => ElementDataStore>;
+    /**
+     * Retrieves data associated with a DOM element.
+     *
+     * If a `key` is provided, the corresponding value is returned.
+     * If no `key` is given, a shallow copy of all stored data is returned.
+     *
+     * @param {TinyElement} el - The DOM element.
+     * @param {string|null} [key] - The specific key to retrieve from the data store.
+     * @param {boolean} [isPrivate=false] - Whether to access the private data store.
+     * @returns {ElementDataStore|undefined|any} - The stored value, all data, or undefined if the key doesn't exist.
+     */
+    static data(el: TinyElement, key?: string | null, isPrivate?: boolean): ElementDataStore | undefined | any;
+    /**
+     * Stores a value associated with a specific key for a DOM element.
+     *
+     * @param {TinyElement} 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 {void}
+     */
+    static setData(el: TinyElement, key: string, value: any, isPrivate?: boolean): void;
+    /**
+     * Get the sibling element in a given direction.
+     *
+     * @param {TinyNode} el
+     * @param {"previousSibling"|"nextSibling"} direction
+     * @param {string} where
+     * @returns {ChildNode|null}
+     * @readonly
+     */
+    static readonly _getSibling(el: TinyNode, direction: "previousSibling" | "nextSibling", where: string): ChildNode | null;
+    /**
+     * Get all sibling elements excluding the given one.
+     *
+     * @param {Node|null} start
+     * @param {Node|null} [exclude]
+     * @returns {ChildNode[]}
+     * @readonly
+     */
+    static readonly _getSiblings(start: Node | null, exclude?: Node | null): ChildNode[];
+    /**
+     * Traverse DOM in a direction collecting elements.
+     *
+     * @param {TinyNode} el
+     * @param {"parentNode"|"nextSibling"|"previousSibling"} direction
+     * @param {TinyNode|string} [until]
+     * @param {string} [where='domDir']
+     * @returns {ChildNode[]}
+     */
+    static domDir(el: TinyNode, direction: "parentNode" | "nextSibling" | "previousSibling", until?: TinyNode | string, where?: string): ChildNode[];
+    /**
+     * Returns the direct parent node of the given element, excluding document fragments.
+     *
+     * @param {TinyNode} el - The DOM node to find the parent of.
+     * @returns {ParentNode|null} The parent node or null if not found.
+     */
+    static parent(el: TinyNode): ParentNode | null;
+    /**
+     * Returns all ancestor nodes of the given element, optionally stopping before a specific ancestor.
+     *
+     * @param {TinyNode} el - The DOM node to start from.
+     * @param {TinyNode|string} [until] - A node or selector to stop before.
+     * @returns {ChildNode[]} An array of ancestor nodes.
+     */
+    static parents(el: TinyNode, until?: TinyNode | string): ChildNode[];
+    /**
+     * Returns the next sibling of the given element.
+     *
+     * @param {TinyNode} el - The DOM node to start from.
+     * @returns {ChildNode|null} The next sibling or null if none found.
+     */
+    static next(el: TinyNode): ChildNode | null;
+    /**
+     * Returns the previous sibling of the given element.
+     *
+     * @param {TinyNode} el - The DOM node to start from.
+     * @returns {ChildNode|null} The previous sibling or null if none found.
+     */
+    static prev(el: TinyNode): ChildNode | null;
+    /**
+     * Returns all next sibling nodes after the given element.
+     *
+     * @param {TinyNode} el - The DOM node to start from.
+     * @returns {ChildNode[]} An array of next sibling nodes.
+     */
+    static nextAll(el: TinyNode): ChildNode[];
+    /**
+     * Returns all previous sibling nodes before the given element.
+     *
+     * @param {TinyNode} el - The DOM node to start from.
+     * @returns {ChildNode[]} An array of previous sibling nodes.
+     */
+    static prevAll(el: TinyNode): ChildNode[];
+    /**
+     * Returns all next sibling nodes up to (but not including) the node matched by a selector or element.
+     *
+     * @param {TinyNode} el - The DOM node to start from.
+     * @param {TinyNode|string} [until] - A node or selector to stop before.
+     * @returns {ChildNode[]} An array of next sibling nodes.
+     */
+    static nextUntil(el: TinyNode, until?: TinyNode | string): ChildNode[];
+    /**
+     * Returns all previous sibling nodes up to (but not including) the node matched by a selector or element.
+     *
+     * @param {TinyNode} el - The DOM node to start from.
+     * @param {TinyNode|string} [until] - A node or selector to stop before.
+     * @returns {ChildNode[]} An array of previous sibling nodes.
+     */
+    static prevUntil(el: TinyNode, until?: TinyNode | string): ChildNode[];
+    /**
+     * Returns all sibling nodes of the given element, excluding itself.
+     *
+     * @param {TinyNode} el - The DOM node to find siblings of.
+     * @returns {ChildNode[]} An array of sibling nodes.
+     */
+    static siblings(el: TinyNode): ChildNode[];
+    /**
+     * Returns all child nodes of the given element.
+     *
+     * @param {TinyNode} el - The DOM node to get children from.
+     * @returns {ChildNode[]} An array of child nodes.
+     */
+    static children(el: TinyNode): ChildNode[];
+    /**
+     * Returns the contents of the given node. For `<template>` it returns its content; for `<iframe>`, the document.
+     *
+     * @param {TinyNode} el - The DOM node to get contents from.
+     * @returns {(ChildNode|DocumentFragment)[]|Document[]} An array of child nodes or the content document of an iframe.
+     */
+    static contents(el: TinyNode): (ChildNode | DocumentFragment)[] | Document[];
+    /**
+     * Clone each element.
+     * @param {TinyNode|TinyNode[]} el
+     * @param {boolean} [deep=true]
+     * @returns {Node[]}
+     */
+    static clone(el: TinyNode | TinyNode[], deep?: boolean): Node[];
+    static readonly _appendChecker(where: string, ...nodes: (TinyNode | TinyNode[] | string)[]): (Node | string)[];
+    /**
+     * 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 {...(TinyNode | TinyNode[] | string)} children - The child elements or text to append.
+     */
+    static append(el: TinyElement | TinyElement[], ...children: (TinyNode | TinyNode[] | string)[]): void;
+    /**
+     * 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 {...(TinyNode | TinyNode[] | string)} children - The child elements or text to prepend.
+     */
+    static prepend(el: TinyElement | TinyElement[], ...children: (TinyNode | TinyNode[] | string)[]): void;
+    /**
+     * 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 {...(TinyNode | TinyNode[] | string)} children - Elements or text to insert before the target.
+     */
+    static before(el: TinyElement | TinyElement[], ...children: (TinyNode | TinyNode[] | string)[]): void;
+    /**
+     * 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 {...(TinyNode | TinyNode[] | string)} children - Elements or text to insert after the target.
+     */
+    static after(el: TinyElement | TinyElement[], ...children: (TinyNode | TinyNode[] | string)[]): void;
+    /**
+     * Replaces the target element(s) in the DOM with new elements or text.
+     *
+     * @param {TinyElement | TinyElement[]} el - The element(s) to be replaced.
+     * @param {...(TinyNode | TinyNode[] | string)} newNodes - New elements or text to replace the target.
+     */
+    static replaceWith(el: TinyElement | TinyElement[], ...newNodes: (TinyNode | TinyNode[] | string)[]): void;
+    /**
+     * Appends the given element(s) to each target element in sequence.
+     *
+     * @param {TinyNode | TinyNode[]} el - The element(s) to append.
+     * @param {TinyNode | TinyNode[]} targets - Target element(s) where content will be appended.
+     */
+    static appendTo(el: TinyNode | TinyNode[], targets: TinyNode | TinyNode[]): void;
+    /**
+     * Prepends the given element(s) to each target element in sequence.
+     *
+     * @param {TinyElement | TinyElement[]} el - The element(s) to prepend.
+     * @param {TinyElement | TinyElement[]} targets - Target element(s) where content will be prepended.
+     */
+    static prependTo(el: TinyElement | TinyElement[], targets: TinyElement | TinyElement[]): void;
+    /**
+     * Inserts the element before a child of a given target, or before the target itself.
+     *
+     * @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.
+     */
+    static insertBefore(el: TinyNode | TinyNode[], target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): void;
+    /**
+     * Inserts the element after a child of a given target, or after the target itself.
+     *
+     * @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.
+     */
+    static insertAfter(el: TinyNode | TinyNode[], target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): void;
+    /**
+     * 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.
+     * @param {TinyNode | TinyNode[]} targets - The elements to be replaced.
+     */
+    static replaceAll(el: TinyNode | TinyNode[], targets: TinyNode | TinyNode[]): void;
+    /**
+     * Checks whether the given object is a window.
+     * @param {*} obj - The object to test.
+     * @returns {obj is Window} - True if it's a Window.
+     */
+    static isWindow(obj: any): obj is Window;
+    /**
+     * Returns the full computed CSS styles for the given element.
+     *
+     * @param {TinyElement} el - The element to retrieve styles from.
+     * @returns {CSSStyleDeclaration} The computed style object for the element.
+     */
+    static css(el: TinyElement): CSSStyleDeclaration;
+    /**
+     * Returns the value of a specific computed CSS property from the given element as a string.
+     *
+     * @param {TinyElement} el - The element to retrieve the style property from.
+     * @param {string} prop - The name of the CSS property (camelCase or kebab-case).
+     * @returns {string|null} The value of the CSS property as a string, or null if not found or invalid.
+     */
+    static cssString(el: TinyElement, prop: string): string | null;
+    /**
+     * Returns a subset of computed CSS styles based on the given list of properties.
+     *
+     * @param {TinyElement} el - The element to retrieve styles from.
+     * @param {string[]} prop - An array of CSS property names to retrieve.
+     * @returns {Partial<CSSStyleDeclaration>} An object containing the requested styles.
+     */
+    static cssList(el: TinyElement, prop: string[]): Partial<CSSStyleDeclaration>;
+    /**
+     * Returns the computed CSS float value of a property.
+     * @param {TinyElement} el - The element to inspect.
+     * @param {string} prop - The CSS property.
+     * @returns {number} - The parsed float value.
+     */
+    static cssFloat(el: TinyElement, prop: string): number;
+    /**
+     * Returns computed float values of multiple CSS properties.
+     * @param {TinyElement} el - The element to inspect.
+     * @param {string[]} prop - An array of CSS properties.
+     * @returns {Record<string, number>} - Map of property to float value.
+     */
+    static cssFloats(el: TinyElement, prop: string[]): Record<string, number>;
+    /**
+     * Focus the element.
+     *
+     * @param {TinyHtmlElement} el - The element or a selector string.
+     */
+    static focus(el: TinyHtmlElement): void;
+    /**
+     * Blur the element.
+     *
+     * @param {TinyHtmlElement} el - The element or a selector string.
+     */
+    static blur(el: TinyHtmlElement): void;
+    /**
+     * Sets the vertical scroll position of the window.
+     * @param {number} value - Sets the scroll position.
+     */
+    static setWinScrollTop(value: number): void;
+    /**
+     * Sets the horizontal scroll position of the window.
+     * @param {number} value - Sets the scroll position.
+     */
+    static setWinScrollLeft(value: number): void;
+    /**
+     * Gets the vertical scroll position of the window.
+     * @returns {number} - The current scroll top value.
+     */
+    static winScrollTop(): number;
+    /**
+     * Gets the horizontal scroll position of the window.
+     * @returns {number} - The current scroll left value.
+     */
+    static winScrollLeft(): number;
+    /**
+     * Returns the current height of the viewport.
+     * @returns {number} - Viewport height in pixels.
+     */
+    static winInnerHeight(): number;
+    /**
+     * Returns the current width of the viewport.
+     * @returns {number} - Viewport width in pixels.
+     */
+    static winInnerWidth(): number;
+    /**
+     * Gets the width or height of an element based on the box model.
+     * @param {TinyElementAndWindow} 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: TinyElementAndWindow, type: "width" | "height", extra?: "content" | "padding" | "border" | "margin"): number;
+    /**
+     * Sets the height of the element.
+     * @param {TinyHtmlElement} el - Target element.
+     * @param {string|number} value - Height value.
+     * @throws {TypeError} If `value` is neither a string nor number.
+     */
+    static setHeight(el: TinyHtmlElement, value: string | number): void;
+    /**
+     * Sets the width of the element.
+     * @param {TinyHtmlElement} el - Target element.
+     * @param {string|number} value - Width value.
+     * @throws {TypeError} If `value` is neither a string nor number.
+     */
+    static setWidth(el: TinyHtmlElement, value: string | number): void;
+    /**
+     * Returns content box height.
+     * @param {TinyElementAndWindow} el - Target element.
+     * @returns {number}
+     */
+    static height(el: TinyElementAndWindow): number;
+    /**
+     * Returns content box width.
+     * @param {TinyElementAndWindow} el - Target element.
+     * @returns {number}
+     */
+    static width(el: TinyElementAndWindow): number;
+    /**
+     * Returns padding box height.
+     * @param {TinyElementAndWindow} el - Target element.
+     * @returns {number}
+     */
+    static innerHeight(el: TinyElementAndWindow): number;
+    /**
+     * Returns padding box width.
+     * @param {TinyElementAndWindow} el - Target element.
+     * @returns {number}
+     */
+    static innerWidth(el: TinyElementAndWindow): number;
+    /**
+     * Returns outer height of the element, optionally including margin.
+     * @param {TinyElementAndWindow} el - Target element.
+     * @param {boolean} [includeMargin=false] - Whether to include margin.
+     * @returns {number}
+     */
+    static outerHeight(el: TinyElementAndWindow, includeMargin?: boolean): number;
+    /**
+     * Returns outer width of the element, optionally including margin.
+     * @param {TinyElementAndWindow} el - Target element.
+     * @param {boolean} [includeMargin=false] - Whether to include margin.
+     * @returns {number}
+     */
+    static outerWidth(el: TinyElementAndWindow, includeMargin?: boolean): number;
+    /**
+     * Gets the offset of the element relative to the document.
+     * @param {TinyElement} el - Target element.
+     * @returns {{top: number, left: number}}
+     */
+    static offset(el: TinyElement): {
+        top: number;
+        left: number;
+    };
+    /**
+     * Gets the position of the element relative to its offset parent.
+     * @param {TinyHtmlElement} el - Target element.
+     * @returns {{top: number, left: number}}
+     */
+    static position(el: TinyHtmlElement): {
+        top: number;
+        left: number;
+    };
+    /**
+     * Gets the closest positioned ancestor element.
+     * @param {TinyHtmlElement} el - Target element.
+     * @returns {HTMLElement} - Offset parent element.
+     */
+    static offsetParent(el: TinyHtmlElement): HTMLElement;
+    /**
+     * Gets the vertical scroll position.
+     * @param {TinyElementAndWindow} el - Element or window.
+     * @returns {number}
+     */
+    static scrollTop(el: TinyElementAndWindow): number;
+    /**
+     * Gets the horizontal scroll position.
+     * @param {TinyElementAndWindow} el - Element or window.
+     * @returns {number}
+     */
+    static scrollLeft(el: TinyElementAndWindow): number;
+    /**
+     * Sets the vertical scroll position.
+     * @param {TinyElementAndWindow|TinyElementAndWindow[]} el - Element or window.
+     * @param {number} value - Scroll top value.
+     */
+    static setScrollTop(el: TinyElementAndWindow | TinyElementAndWindow[], value: number): void;
+    /**
+     * Sets the horizontal scroll position.
+     * @param {TinyElementAndWindow|TinyElementAndWindow[]} el - Element or window.
+     * @param {number} value - Scroll left value.
+     */
+    static setScrollLeft(el: TinyElementAndWindow | TinyElementAndWindow[], value: number): void;
+    /**
+     * Returns the total border width and individual sides from `border{Side}Width` CSS properties.
+     *
+     * @param {TinyElement} el - The target DOM element.
+     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border widths, and each side individually.
+     */
+    static borderWidth(el: TinyElement): HtmlElBoxSides;
+    /**
+     * Returns the total border size and individual sides from `border{Side}` CSS properties.
+     *
+     * @param {TinyElement} el - The target DOM element.
+     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border sizes, and each side individually.
+     */
+    static border(el: TinyElement): HtmlElBoxSides;
+    /**
+     * Returns the total margin and individual sides from `margin{Side}` CSS properties.
+     *
+     * @param {TinyElement} el - The target DOM element.
+     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) margins, and each side individually.
+     */
+    static margin(el: TinyElement): HtmlElBoxSides;
+    /**
+     * Returns the total padding and individual sides from `padding{Side}` CSS properties.
+     *
+     * @param {TinyElement} el - The target DOM element.
+     * @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[]): void;
+    static removeClass(el: TinyElement | TinyElement[], ...tokens: string[]): void;
+    /**
+     * Replaces an existing class name with a new one.
+     * @param {TinyElement|TinyElement[]} el - Target element.
+     * @param {string} token - The class name to be replaced.
+     * @param {string} newToken - The new class name to apply.
+     * @returns {boolean[]} Whether the replacement was successful.
+     * @throws {TypeError} If either argument is not a string.
+     */
+    static replaceClass(el: TinyElement | TinyElement[], token: string, newToken: string): boolean[];
+    /**
+     * Returns the class name at the specified index.
+     * @param {TinyElement} el - Target element.
+     * @param {number} index - The index of the class name.
+     * @returns {string|null} The class name at the index or null if not found.
+     * @throws {TypeError} If the index is not a number.
+     */
+    static classItem(el: TinyElement, index: number): string | null;
+    /**
+     * Toggles a class name on the element with an optional force boolean.
+     * @param {TinyElement|TinyElement[]} el - Target element.
+     * @param {string} token - The class name to toggle.
+     * @param {boolean} [force] - If true, adds the class; if false, removes it.
+     * @returns {boolean[]} Whether the class is present after the toggle.
+     * @throws {TypeError} If token is not a string or force is not a boolean.
+     */
+    static toggleClass(el: TinyElement | TinyElement[], token: string, force?: boolean): boolean[];
+    /**
+     * Checks if the element contains the given class name.
+     * @param {TinyElement} el - Target element.
+     * @param {string} token - The class name to check.
+     * @returns {boolean} True if the class is present, false otherwise.
+     * @throws {TypeError} If token is not a string.
+     */
+    static hasClass(el: TinyElement, token: string): boolean;
+    /**
+     * Returns the number of classes applied to the element.
+     * @param {TinyElement} el - Target element.
+     * @returns {number} The number of classes.
+     */
+    static classLength(el: TinyElement): number;
+    /**
+     * Returns all class names as an array of strings.
+     * @param {TinyElement} el - Target element.
+     * @returns {string[]} An array of class names.
+     */
+    static classList(el: TinyElement): string[];
+    /**
+     * Returns the tag name of the element.
+     * @param {TinyElement} el - Target element.
+     * @returns {string} The tag name in uppercase.
+     */
+    static tagName(el: TinyElement): string;
+    /**
+     * Returns the ID of the element.
+     * @param {TinyElement} el - Target element.
+     * @returns {string} The element's ID.
+     */
+    static id(el: TinyElement): string;
+    /**
+     * Returns the text content of the element.
+     * @param {TinyElement} el - Target element.
+     * @returns {string|null} The text content or null if none.
+     */
+    static text(el: TinyElement): string | null;
+    /**
+     * Set text content of elements.
+     * @param {TinyElement|TinyElement[]} el
+     * @param {string} value
+     */
+    static setText(el: TinyElement | TinyElement[], value: string): void;
+    /**
+     * Remove all child nodes from each element.
+     * @param {TinyElement|TinyElement[]} el
+     */
+    static empty(el: TinyElement | TinyElement[]): void;
+    /**
+     * Get the innerHTML of the element.
+     * @param {TinyElement|TinyElement[]} el
+     * @returns {string}
+     */
+    static html(el: TinyElement | TinyElement[]): string;
+    /**
+     * Set the innerHTML of each element.
+     * @param {TinyElement|TinyElement[]} el
+     * @param {string} value
+     */
+    static setHtml(el: TinyElement | TinyElement[], value: string): void;
+    /** @readonly */
+    static readonly _valHooks: {
+        option: {
+            /**
+             * @param {HTMLOptionElement} elem
+             * @returns {string|null}
+             */
+            get: (elem: HTMLOptionElement) => string | null;
+        };
+        select: {
+            /**
+             * @param {HTMLSelectElement} elem
+             * @returns {(string | null)[] | string | null}
+             */
+            get: (elem: HTMLSelectElement) => (string | null)[] | string | null;
+            /**
+             * @param {HTMLSelectElement} elem
+             * @param {string[]|string} value
+             */
+            set: (elem: HTMLSelectElement, value: string[] | string) => string[];
+        };
+        radio: {
+            /**
+             * @param {HTMLInputElement} elem
+             * @returns {string}
+             */
+            get(elem: HTMLInputElement): string;
+            /**
+             * @param {HTMLInputElement} elem
+             * @param {string[]} value
+             */
+            set(elem: HTMLInputElement, value: string[]): undefined;
+        };
+        checkbox: {
+            /**
+             * @param {HTMLInputElement} elem
+             * @returns {string}
+             */
+            get(elem: HTMLInputElement): string;
+            /**
+             * @param {HTMLInputElement} elem
+             * @param {boolean} value
+             */
+            set(elem: HTMLInputElement, value: boolean): boolean | undefined;
+        };
+    };
+    /**
+     * 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.
+     * @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.
+     */
+    static setVal(el: TinyInputElement | TinyInputElement[], value: SetValueList | ((el: InputElement, val: SetValueList) => SetValueList)): void;
+    /**
+     * Maps value types to their corresponding getter functions.
+     * Each function extracts a value of a specific type from a compatible HTMLInputElement.
+     * @readonly
+     */
+    static readonly _valTypes: {
+        /**
+         * Gets the string value from any HTMLInputElement.
+         * @type {(elem: HTMLInputElement) => string}
+         */
+        string: (elem: HTMLInputElement) => string;
+        /**
+         * Gets the value as a Date object from supported input types.
+         * Valid only for types: "date", "datetime-local", "month", "time", "week".
+         * Returns `null` if the field is empty or invalid.
+         * @type {(elem: HTMLInputElement & { type: "date" | "datetime-local" | "month" | "time" | "week" }) => Date | null}
+         */
+        date: (elem: HTMLInputElement & {
+            type: "date" | "datetime-local" | "month" | "time" | "week";
+        }) => Date | null;
+        /**
+         * Gets the numeric value from supported input types.
+         * Valid for types: "number", "range", "date", "time".
+         * Returns `NaN` if the value is invalid or empty.
+         * @type {(elem: HTMLInputElement & { type: "number" | "range" | "date" | "time" }) => number}
+         */
+        number: (elem: HTMLInputElement & {
+            type: "number" | "range" | "date" | "time";
+        }) => number;
+    };
+    /**
+     * Gets the value of an input element according to the specified type.
+     *
+     * @param {InputElement} elem - The input element to extract the value from.
+     * @param {GetValueTypes} type - The type of value to retrieve ("string", "date", or "number").
+     * @param {string} where - The context/method name using this validation.
+     * @returns {any} The extracted value, depending on the type.
+     * @throws {Error} If the element is not an HTMLInputElement or if the type handler is invalid.
+     * @readonly
+     */
+    static readonly _getValByType(elem: InputElement, type: GetValueTypes, where: string): any;
+    /**
+     * Retrieves the raw value from the HTML input element.
+     * If a custom value hook exists, it will be used first.
+     *
+     * @param {TinyInputElement} el - Target element.
+     * @param {GetValueTypes} type - The type of value to retrieve ("string", "date", or "number").
+     * @param {string} where - The context/method name using this validation.
+     * @returns {any} The raw value retrieved from the element or hook.
+     * @readonly
+     */
+    static readonly _val(el: TinyInputElement, where: string, type: GetValueTypes): any;
+    /**
+     * Gets the value of the current HTML value element.
+     *
+     * @param {TinyInputElement} el - Target element.
+     * @returns {SetValueList} The normalized value, with carriage returns removed.
+     */
+    static val(el: TinyInputElement): SetValueList;
+    /**
+     * Gets the text of the current HTML value element (for text).
+     *
+     * @param {TinyInputElement} el - Target element.
+     * @returns {string} The text value.
+     * @throws {Error} If the element is not a string value.
+     */
+    static valTxt(el: TinyInputElement): string;
+    /**
+     * Internal helper to get a value from an input expected to return an array.
+     *
+     * @param {TinyInputElement} el - Target element.
+     * @param {string} where - The method name or context using this validation (for error reporting).
+     * @param {GetValueTypes} type - The type of value to retrieve ("string", "date", or "number").
+     * @returns {SetValueBase[]} - The validated value as an array.
+     * @throws {Error} If the returned value is not an array.
+     * @readonly
+     */
+    static readonly _valArr(el: TinyInputElement, where: string, type: GetValueTypes): SetValueBase[];
+    /**
+     * Gets the raw value as a generic array of the current HTML value element (for select).
+     *
+     * @param {TinyInputElement} el - Target element.
+     * @returns {SetValueBase[]} - The value cast as a generic array.
+     * @throws {Error} If the value is not a valid array.
+     */
+    static valArr(el: TinyInputElement): SetValueBase[];
+    /**
+     * Gets the current value parsed as a number (for number/text).
+     *
+     * @param {TinyInputElement} el - Target element.
+     * @returns {number} The numeric value.
+     * @throws {Error} If the element is not a number-compatible input or value is NaN.
+     */
+    static valNb(el: TinyInputElement): number;
+    /**
+     * Gets the current value parsed as a Date (for time/date).
+     *
+     * @param {TinyInputElement} el - Target element.
+     * @returns {Date} The date value.
+     * @throws {Error} If the element is not a date-compatible input.
+     */
+    static valDate(el: TinyInputElement): Date;
+    /**
+     * Checks if the input element is boolean (for checkboxes/radios).
+     *
+     * @param {TinyInputElement} el - Target element.
+     * @returns {boolean} True if the input is considered checked (value === "on"), false otherwise.
+     * @throws {Error} If the element is not a checkbox/radio input.
+     */
+    static valBool(el: TinyInputElement): boolean;
+    /**
+     * Registers an event listener on the specified element.
+     *
+     * @param {TinyEventTarget|TinyEventTarget[]} el - The target to listen on.
+     * @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.
+     */
+    static on(el: TinyEventTarget | TinyEventTarget[], event: string, handler: EventRegistryHandle, options?: EventRegistryOptions): void;
+    /**
+     * Registers an event listener that runs only once, then is removed.
+     *
+     * @param {TinyEventTarget|TinyEventTarget[]} el - The target to listen on.
+     * @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.
+     */
+    static once(el: TinyEventTarget | TinyEventTarget[], event: string, handler: EventRegistryHandle, options?: EventRegistryOptions): void;
+    /**
+     * Removes a specific event listener from an element.
+     *
+     * @param {TinyEventTarget|TinyEventTarget[]} el - The target element.
+     * @param {string} event - The event type.
+     * @param {EventRegistryHandle} handler - The function originally bound to the event.
+     * @param {boolean|EventListenerOptions} [options] - Optional listener options.
+     */
+    static off(el: TinyEventTarget | TinyEventTarget[], event: string, handler: EventRegistryHandle, options?: boolean | EventListenerOptions): void;
+    /**
+     * Removes all event listeners of a specific type from the element.
+     *
+     * @param {TinyEventTarget|TinyEventTarget[]} el - The target element.
+     * @param {string} event - The event type to remove (e.g. 'click').
+     */
+    static offAll(el: TinyEventTarget | TinyEventTarget[], event: string): void;
+    /**
+     * Removes all event listeners of all types from the element.
+     *
+     * @param {TinyEventTarget|TinyEventTarget[]} el - The target element.
+     * @param {((handler: EventListenerOrEventListenerObject, event: string) => boolean)|null} [filterFn=null] -
+     *        Optional filter function to selectively remove specific handlers.
+     */
+    static offAllTypes(el: TinyEventTarget | TinyEventTarget[], filterFn?: ((handler: EventListenerOrEventListenerObject, event: string) => boolean) | null): void;
+    /**
+     * Triggers all handlers associated with a specific event on the given element.
+     *
+     * @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.
+     */
+    static trigger(el: TinyEventTarget | TinyEventTarget[], event: string, payload?: Event | CustomEvent | CustomEventInit): void;
+    /**
+     * Property name normalization similar to jQuery's propFix.
+     * @readonly
+     */
+    static readonly _propFix: {
+        for: string;
+        class: string;
+    };
+    /**
+     * Get an attribute on an element.
+     * @param {TinyElement} el
+     * @param {string} name
+     * @returns {string|null}
+     */
+    static attr(el: TinyElement, name: string): string | null;
+    /**
+     * Set an attribute on an element.
+     * @param {TinyElement|TinyElement[]} el
+     * @param {string} name
+     * @param {string|null} [value=null]
+     */
+    static setAttr(el: TinyElement | TinyElement[], name: string, value?: string | null): void;
+    /**
+     * Remove attribute(s) from an element.
+     * @param {TinyElement|TinyElement[]} el
+     * @param {string} name Space-separated list of attributes.
+     */
+    static removeAttr(el: TinyElement | TinyElement[], name: string): void;
+    /**
+     * Check if an attribute exists on an element.
+     * @param {TinyElement} el
+     * @param {string} name
+     * @returns {boolean}
+     */
+    static hasAttr(el: TinyElement, name: string): boolean;
+    /**
+     * Check if a property exists.
+     * @param {TinyElement} el
+     * @param {string} name
+     * @returns {boolean}
+     */
+    static hasProp(el: TinyElement, name: string): boolean;
+    /**
+     * Set a property on an element.
+     * @param {TinyElement|TinyElement[]} el
+     * @param {string} name
+     */
+    static addProp(el: TinyElement | TinyElement[], name: string): void;
+    /**
+     * Remove a property from an element.
+     * @param {TinyElement|TinyElement[]} el
+     * @param {string} name
+     */
+    static removeProp(el: TinyElement | TinyElement[], name: string): void;
+    /**
+     * Toggle a boolean property.
+     * @param {TinyElement|TinyElement[]} el
+     * @param {string} name
+     * @param {boolean} [force]
+     */
+    static toggleProp(el: TinyElement | TinyElement[], name: string, force?: boolean): void;
+    /**
+     * Removes an element from the DOM.
+     * @param {TinyElement|TinyElement[]} el - The DOM element or selector to remove.
+     */
+    static remove(el: TinyElement | TinyElement[]): void;
+    /**
+     * Returns the index of the first element within its parent or relative to a selector/element.
+     *
+     * @param {TinyElement} el - The element target
+     * @param {string|TinyElement|null} [el2] - Optional target to compare index against.
+     * @returns {number}
+     */
+    static index(el: TinyElement, el2?: string | TinyElement | null): number;
+    /**
+     * Creates a new DOMRect object by copying the base rect and applying optional additional dimensions.
+     *
+     * @param {DOMRect} rect - The base rectangle to be cloned and extended.
+     * @param {Partial<DOMRect>} extraRect - Additional dimensions to apply to the base rect (e.g., extra padding or offset).
+     * @returns {DOMRect} - A new DOMRect object with the combined dimensions.
+     * @readonly
+     */
+    static readonly _getCustomRect(rect: DOMRect, extraRect: Partial<DOMRect>): DOMRect;
+    /**
+     * Determines if two HTML elements are colliding, using a simple bounding box comparison.
+     *
+     * @param {TinyElement} el1 - The first element to compare.
+     * @param {TinyElement} el2 - The second element to compare.
+     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
+     * @returns {boolean} - `true` if the elements are colliding, `false` otherwise.
+     */
+    static isCollWith(el1: TinyElement, el2: TinyElement, extraRect?: Partial<TinyCollision.ObjRect>): boolean;
+    /**
+     * Determines if two HTML elements are colliding using a pixel-perfect collision algorithm.
+     *
+     * @param {TinyElement} el1 - The first element to compare.
+     * @param {TinyElement} el2 - The second element to compare.
+     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
+     * @returns {boolean} - `true` if the elements are colliding with higher precision, `false` otherwise.
+     */
+    static isCollPerfWith(el1: TinyElement, el2: TinyElement, extraRect?: Partial<TinyCollision.ObjRect>): boolean;
+    /**
+     * Determines whether two elements are colliding with a directional lock mechanism.
+     *
+     * This function tracks the direction from which an element (`elem1`) initially collided with another,
+     * and keeps the collision "locked" until the element exits the collision from the same direction.
+     *
+     * - If `isColliding` is true and no lock is stored yet, it saves the direction of entry.
+     * - If `isColliding` is false but a previous lock exists, it checks if the element has exited
+     *   in the same direction it entered to remove the lock.
+     *
+     * @param {boolean} isColliding - Indicates whether `rect1` and `rect2` are currently colliding.
+     * @param {DOMRect} rect1 - The bounding box of the first element.
+     * @param {DOMRect} rect2 - The bounding box of the second element.
+     * @param {Element} elem1 - The element to track collision state for.
+     * @param {CollisionDirLock} lockDirection - The direction from which the collision was first detected.
+     * @returns {boolean} Returns `true` if the element is still considered colliding (locked), otherwise `false`.
+     * @readonly
+     */
+    static readonly _isCollWithLock(isColliding: boolean, rect1: DOMRect, rect2: DOMRect, elem1: Element, lockDirection: CollisionDirLock): boolean;
+    /**
+     * Checks if two DOM elements are colliding on the screen, and locks the collision
+     * until the element exits through the same side it entered.
+     *
+     * @param {TinyElement} el1 - First DOM element (e.g. draggable or moving element).
+     * @param {TinyElement} el2 - Second DOM element (e.g. a container or boundary element).
+     * @param {CollisionDirLock} lockDirection - Direction that must be respected to unlock the collision.
+     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
+     * @returns {boolean} True if collision is still active.
+     */
+    static isCollWithLock(el1: TinyElement, el2: TinyElement, lockDirection: CollisionDirLock, extraRect?: Partial<TinyCollision.ObjRect>): boolean;
+    /**
+     * Checks if two DOM elements are colliding on the screen, and locks the collision
+     * until the element exits through the same side it entered.
+     *
+     * @param {TinyElement} el1 - First DOM element (e.g. draggable or moving element).
+     * @param {TinyElement} el2 - Second DOM element (e.g. a container or boundary element).
+     * @param {CollisionDirLock} lockDirection - Direction that must be respected to unlock the collision.
+     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
+     * @returns {boolean} True if collision is still active.
+     */
+    static isCollPerfWithLock(el1: TinyElement, el2: TinyElement, lockDirection: CollisionDirLock, extraRect?: Partial<TinyCollision.ObjRect>): boolean;
+    /**
+     * Resets all collision locks for a specific element (for all directions).
+     *
+     * @param {TinyElement} el - The element whose locks should be removed.
+     * @returns {boolean} True if at least one lock was removed.
+     */
+    static resetCollLock(el: TinyElement): boolean;
+    /**
+     * Resets the collision lock for a specific element and direction.
+     *
+     * @param {TinyElement} el - The element whose lock should be removed.
+     * @param {CollisionDirLock} direction - The direction to clear the lock from.
+     * @returns {boolean} True if the lock was removed.
+     */
+    static resetCollLockDir(el: TinyElement, direction: CollisionDirLock): boolean;
+    /**
+     * Checks if the given element is at least partially visible in the viewport.
+     *
+     * @param {TinyElement} el - The DOM element to check.
+     * @returns {boolean} True if the element is partially in the viewport, false otherwise.
+     */
+    static isInViewport(el: TinyElement): boolean;
+    /**
+     * Checks if the given element is fully visible in the viewport (top and bottom).
+     *
+     * @param {TinyElement} el - The DOM element to check.
+     * @returns {boolean} True if the element is fully visible in the viewport, false otherwise.
+     */
+    static isScrolledIntoView(el: TinyElement): boolean;
+    /**
+     * 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} el - The element to wrap and manipulate.
+     */
+    constructor(el: ConstructorElValues);
+    /**
+     * Returns the current target held by this instance.
+     *
+     * @returns {ConstructorElValues} - The instance's target element.
+     */
+    get(): ConstructorElValues;
+    /**
+     * Returns the current Element held by this instance.
+     *
+     * @param {string} where - The method name or context calling this.
+     * @returns {ConstructorElValues} - The instance's element.
+     * @readonly
+     */
+    readonly _getElement(where: string): ConstructorElValues;
+    /**
+     * Returns only the elements **not** matching the given selector or function.
+     *
+     * @param {WinnowRequest} selector
+     * @returns {Element[]}
+     */
+    not(selector: WinnowRequest): Element[];
+    /**
+     * Finds elements in your element matching a selector within a context.
+     *
+     * @param {string} selector
+     * @returns {Element[]}
+     */
+    find(selector: string): Element[];
+    /**
+     * Checks if the element matches the selector.
+     *
+     * @param {WinnowRequest} selector
+     * @returns {boolean}
+     */
+    is(selector: WinnowRequest): boolean;
+    /**
+     * Return if the element has the target(s).
+     * @param {string|TinyElement|TinyElement[]} target - Selector or DOM element(s).
+     * @returns {boolean} Elements that contain the target.
+     */
+    has(target: string | TinyElement | TinyElement[]): boolean;
+    /**
+     * Finds the closest ancestor (including self) that matches the selector.
+     *
+     * @param {string|Element} selector - A selector string or DOM element to match.
+     * @param {Element|null} [context] - An optional context to stop searching.
+     * @returns {Element[]}
+     */
+    closest(selector: string | Element, context?: Element | null): Element[];
+    /**
+     * Compares two DOM elements to determine if they refer to the same node in the document.
+     *
+     * This performs a strict equality check (`===`) between the two elements.
+     *
+     * @param {TinyNode} elem - The DOM element to compare.
+     * @returns {boolean} `true` if both elements are the same DOM node; otherwise, `false`.
+     */
+    isSameDom(elem: TinyNode): boolean;
+    /** @type {ElementDataStore} */
+    _data: ElementDataStore;
+    /**
+     * Retrieves data associated with a DOM element.
+     *
+     * If a `key` is provided, the corresponding value is returned.
+     * If no `key` is given, a shallow copy of all stored data is returned.
+     *
+     * @param {string} [key] - The specific key to retrieve from the data store.
+     * @param {boolean} [isPrivate=false] - Whether to access the private data store.
+     * @returns {ElementDataStore|undefined|any} - The stored value, all data, or undefined if the key doesn't exist.
+     */
+    data(key?: string, isPrivate?: boolean): ElementDataStore | undefined | any;
+    /**
+     * Stores a value associated with a specific key for a 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 {void}
+     */
+    setData(key: string, value: any, isPrivate?: boolean): void;
+    /**
+     * Returns the direct parent node of the given element, excluding document fragments.
+     *
+     * @returns {ParentNode|null} The parent node or null if not found.
+     */
+    parent(): ParentNode | null;
+    /**
+     * Returns all ancestor nodes of the given element, optionally stopping before a specific ancestor.
+     *
+     * @param {TinyNode|string} [until] - A node or selector to stop before.
+     * @returns {ChildNode[]} An array of ancestor nodes.
+     */
+    parents(until?: TinyNode | string): ChildNode[];
+    /**
+     * Returns the next sibling of the given element.
+     *
+     * @returns {ChildNode|null} The next sibling or null if none found.
+     */
+    next(): ChildNode | null;
+    /**
+     * Returns the previous sibling of the given element.
+     *
+     * @returns {ChildNode|null} The previous sibling or null if none found.
+     */
+    prev(): ChildNode | null;
+    /**
+     * Returns all next sibling nodes after the given element.
+     *
+     * @returns {ChildNode[]} An array of next sibling nodes.
+     */
+    nextAll(): ChildNode[];
+    /**
+     * Returns all previous sibling nodes before the given element.
+     *
+     * @returns {ChildNode[]} An array of previous sibling nodes.
+     */
+    prevAll(): ChildNode[];
+    /**
+     * Returns all next sibling nodes up to (but not including) the node matched by a selector or element.
+     *
+     * @param {TinyNode|string} [until] - A node or selector to stop before.
+     * @returns {ChildNode[]} An array of next sibling nodes.
+     */
+    nextUntil(until?: TinyNode | string): ChildNode[];
+    /**
+     * Returns all previous sibling nodes up to (but not including) the node matched by a selector or element.
+     *
+     * @param {TinyNode|string} [until] - A node or selector to stop before.
+     * @returns {ChildNode[]} An array of previous sibling nodes.
+     */
+    prevUntil(until?: TinyNode | string): ChildNode[];
+    /**
+     * Returns all sibling nodes of the given element, excluding itself.
+     *
+     * @returns {ChildNode[]} An array of sibling nodes.
+     */
+    siblings(): ChildNode[];
+    /**
+     * Returns all child nodes of the given element.
+     *
+     * @returns {ChildNode[]} An array of child nodes.
+     */
+    children(): ChildNode[];
+    /**
+     * Returns the contents of the given node. For `<template>` it returns its content; for `<iframe>`, the document.
+     *
+     * @returns {(ChildNode|DocumentFragment)[]|Document[]} An array of child nodes or the content document of an iframe.
+     */
+    contents(): (ChildNode | DocumentFragment)[] | Document[];
+    /**
+     * Clone the element.
+     * @param {boolean} [deep=true]
+     * @returns {Node}
+     */
+    clone(deep?: boolean): Node;
+    /**
+     * 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.
+     */
+    append(...children: (TinyNode | TinyNode[] | string)[]): void;
+    /**
+     * 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.
+     */
+    prepend(...children: (TinyNode | TinyNode[] | string)[]): void;
+    /**
+     * 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.
+     */
+    before(...children: (TinyNode | TinyNode[] | string)[]): void;
+    /**
+     * 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.
+     */
+    after(...children: (TinyNode | TinyNode[] | string)[]): void;
+    /**
+     * 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.
+     */
+    replaceWith(...newNodes: (TinyNode | TinyNode[] | string)[]): void;
+    /**
+     * Appends the given element(s) to each target element in sequence.
+     *
+     * @param {TinyNode | TinyNode[]} targets - Target element(s) where content will be appended.
+     */
+    appendTo(targets: TinyNode | TinyNode[]): void;
+    /**
+     * Prepends the given element(s) to each target element in sequence.
+     *
+     * @param {TinyElement | TinyElement[]} targets - Target element(s) where content will be prepended.
+     */
+    prependTo(targets: TinyElement | TinyElement[]): void;
+    /**
+     * 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.
+     */
+    insertBefore(target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): void;
+    /**
+     * 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.
+     */
+    insertAfter(target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): void;
+    /**
+     * 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.
+     */
+    replaceAll(targets: TinyNode | TinyNode[]): void;
+    /**
+     * Returns the full computed CSS styles for the given element.
+     *
+     * @returns {CSSStyleDeclaration} The computed style object for the element.
+     */
+    css(): CSSStyleDeclaration;
+    /**
+     * Returns the value of a specific computed CSS property from the given element as a string.
+     *
+     * @param {string} prop - The name of the CSS property (camelCase or kebab-case).
+     * @returns {string|null} The value of the CSS property as a string, or null if not found or invalid.
+     */
+    cssString(prop: string): string | null;
+    /**
+     * Returns a subset of computed CSS styles based on the given list of properties.
+     *
+     * @param {string[]} prop - An array of CSS property names to retrieve.
+     * @returns {Partial<CSSStyleDeclaration>} An object containing the requested styles.
+     */
+    cssList(prop: string[]): Partial<CSSStyleDeclaration>;
+    /**
+     * Returns the computed CSS float value of a property.
+     * @param {string} prop - The CSS property.
+     * @returns {number} - The parsed float value.
+     */
+    cssFloat(prop: string): number;
+    /**
+     * Returns computed float values of multiple CSS properties.
+     * @param {string[]} prop - An array of CSS properties.
+     * @returns {Record<string, number>} - Map of property to float value.
+     */
+    cssFloats(prop: string[]): Record<string, number>;
+    /**
+     * Focus the element.
+     */
+    focus(): void;
+    /**
+     * Blur the element.
+     */
+    blur(): void;
+    /**
+     * Gets the width or height of an element based on the box model.
+     * @param {"width"|"height"} type - Dimension type.
+     * @param {"content"|"padding"|"border"|"margin"} extra - Box model context.
+     * @returns {number} - Computed dimension.
+     */
+    getDimension(type: "width" | "height", extra: "content" | "padding" | "border" | "margin"): number;
+    /**
+     * Sets the height of the element.
+     * @param {string|number} value - Height value.
+     */
+    setHeight(value: string | number): void;
+    /**
+     * Sets the width of the element.
+     * @param {string|number} value - Width value.
+     */
+    setWidth(value: string | number): void;
+    /**
+     * Returns content box height.
+     * @returns {number}
+     */
+    height(): number;
+    /**
+     * Returns content box width.
+     * @returns {number}
+     */
+    width(): number;
+    /**
+     * Returns padding box height.
+     * @returns {number}
+     */
+    innerHeight(): number;
+    /**
+     * Returns padding box width.
+     * @returns {number}
+     */
+    innerWidth(): number;
+    /**
+     * Returns outer height of the element, optionally including margin.
+     * @param {boolean} [includeMargin=false] - Whether to include margin.
+     * @returns {number}
+     */
+    outerHeight(includeMargin?: boolean): number;
+    /**
+     * Returns outer width of the element, optionally including margin.
+     * @param {boolean} [includeMargin=false] - Whether to include margin.
+     * @returns {number}
+     */
+    outerWidth(includeMargin?: boolean): number;
+    /**
+     * Gets the offset of the element relative to the document.
+     * @returns {{top: number, left: number}}
+     */
+    offset(): {
+        top: number;
+        left: number;
+    };
+    /**
+     * Gets the position of the element relative to its offset parent.
+     * @returns {{top: number, left: number}}
+     */
+    position(): {
+        top: number;
+        left: number;
+    };
+    /**
+     * Gets the closest positioned ancestor element.
+     * @returns {HTMLElement} - Offset parent element.
+     */
+    offsetParent(): HTMLElement;
+    /**
+     * Gets the vertical scroll position.
+     * @returns {number}
+     */
+    scrollTop(): number;
+    /**
+     * Gets the horizontal scroll position.
+     * @returns {number}
+     */
+    scrollLeft(): number;
+    /**
+     * Sets the vertical scroll position.
+     * @param {number} value - Scroll top value.
+     */
+    setScrollTop(value: number): void;
+    /**
+     * Sets the horizontal scroll position.
+     * @param {number} value - Scroll left value.
+     */
+    setScrollLeft(value: number): void;
+    /**
+     * Returns the total border width and individual sides from `border{Side}Width` CSS properties.
+     *
+     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border widths, and each side individually.
+     */
+    borderWidth(): HtmlElBoxSides;
+    /**
+     * Returns the total border size and individual sides from `border{Side}` CSS properties.
+     *
+     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border sizes, and each side individually.
+     */
+    border(): HtmlElBoxSides;
+    /**
+     * Returns the total margin and individual sides from `margin{Side}` CSS properties.
+     *
+     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) margins, and each side individually.
+     */
+    margin(): HtmlElBoxSides;
+    /**
+     * Returns the total padding and individual sides from `padding{Side}` CSS properties.
+     *
+     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) paddings, and each side individually.
+     */
+    padding(): HtmlElBoxSides;
+    addClass(...tokens: string[]): void;
+    removeClass(...tokens: string[]): void;
+    /**
+     * Replaces an existing class name with a new one.
+     * @param {string} token - The class name to be replaced.
+     * @param {string} newToken - The new class name to apply.
+     * @returns {boolean} Whether the replacement was successful.
+     * @throws {TypeError} If either argument is not a string.
+     */
+    replaceClass(token: string, newToken: string): boolean;
+    /**
+     * Returns the class name at the specified index.
+     * @param {number} index - The index of the class name.
+     * @returns {string|null} The class name at the index or null if not found.
+     * @throws {TypeError} If the index is not a number.
+     */
+    classItem(index: number): string | null;
+    /**
+     * Toggles a class name on the element with an optional force boolean.
+     * @param {string} token - The class name to toggle.
+     * @param {boolean} force - If true, adds the class; if false, removes it.
+     * @returns {boolean} Whether the class is present after the toggle.
+     * @throws {TypeError} If token is not a string or force is not a boolean.
+     */
+    toggleClass(token: string, force: boolean): boolean;
+    /**
+     * Checks if the element contains the given class name.
+     * @param {string} token - The class name to check.
+     * @returns {boolean} True if the class is present, false otherwise.
+     * @throws {TypeError} If token is not a string.
+     */
+    hasClass(token: string): boolean;
+    /**
+     * Returns the number of classes applied to the element.
+     * @returns {number} The number of classes.
+     */
+    classLength(): number;
+    /**
+     * Returns all class names as an array of strings.
+     * @returns {string[]} An array of class names.
+     */
+    classList(): string[];
+    /**
+     * Returns the tag name of the element.
+     * @returns {string} The tag name in uppercase.
+     */
+    tagName(): string;
+    /**
+     * Returns the ID of the element.
+     * @returns {string} The element's ID.
+     */
+    id(): string;
+    /**
+     * Returns the text content of the element.
+     * @returns {string|null} The text content or null if none.
+     */
+    text(): string | null;
+    /**
+     * Set text content of the element.
+     * @param {string} value
+     */
+    setText(value: string): void;
+    /**
+     * Remove all child nodes of the element.
+     */
+    empty(): void;
+    /**
+     * Get the innerHTML of the element.
+     * @returns {string}
+     */
+    html(): string;
+    /**
+     * Set the innerHTML of the element.
+     * @param {string} value
+     */
+    setHtml(value: string): void;
+    /**
+     * 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.
+     * @throws {Error} If the computed value is not a valid string or boolean.
+     */
+    setVal(value: SetValueList | ((el: InputElement, val: SetValueList) => SetValueList)): void;
+    /**
+     * Retrieves the raw value from the HTML input element.
+     * If a custom value hook exists, it will be used first.
+     *
+     * @param {GetValueTypes} type - The type of value to retrieve ("string", "date", or "number").
+     * @param {string} where - The context/method name using this validation.
+     * @returns {any} The raw value retrieved from the element or hook.
+     * @readonly
+     */
+    readonly _val(where: string, type: GetValueTypes): any;
+    /**
+     * Gets the value of the current HTML value element.
+     *
+     * @returns {SetValueList} The normalized value, with carriage returns removed.
+     */
+    val(): SetValueList;
+    /**
+     * Gets the text of the current HTML value element (for text).
+     *
+     * @returns {string} The text value.
+     * @throws {Error} If the element is not a string value.
+     */
+    valTxt(): string;
+    /**
+     * Internal helper to get a value from an input expected to return an array.
+     *
+     * @param {string} where - The method name or context using this validation (for error reporting).
+     * @param {GetValueTypes} type - The type of value to retrieve ("string", "date", or "number").
+     * @returns {SetValueBase[]} - The validated value as an array.
+     * @throws {Error} If the returned value is not an array.
+     * @readonly
+     */
+    readonly _valArr(where: string, type: GetValueTypes): SetValueBase[];
+    /**
+     * Gets the raw value as a generic array of the current HTML value element (for select).
+     *
+     * @returns {SetValueBase[]} - The value cast as a generic array.
+     * @throws {Error} If the value is not a valid array.
+     */
+    valArr(): SetValueBase[];
+    /**
+     * Gets the current value parsed as a number (for number/text).
+     *
+     * @returns {number} The numeric value.
+     * @throws {Error} If the element is not a number-compatible input or value is NaN.
+     */
+    valNb(): number;
+    /**
+     * Gets the current value parsed as a Date (for time/date).
+     *
+     * @returns {Date} The date value.
+     * @throws {Error} If the element is not a date-compatible input.
+     */
+    valDate(): Date;
+    /**
+     * Checks if the input element is boolean (for checkboxes/radios).
+     *
+     * @returns {boolean} True if the input is considered checked (value === "on"), false otherwise.
+     * @throws {Error} If the element is not a checkbox/radio input.
+     */
+    valBool(): boolean;
+    /**
+     * Registers an event listener on the specified element.
+     *
+     * @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.
+     */
+    on(event: string, handler: EventRegistryHandle, options?: EventRegistryOptions): void;
+    /**
+     * Registers an event listener that runs only once, then is removed.
+     *
+     * @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.
+     */
+    once(event: string, handler: EventRegistryHandle, options?: EventRegistryOptions): void;
+    /**
+     * Removes a specific event listener from an element.
+     *
+     * @param {string} event - The event type.
+     * @param {EventRegistryHandle} handler - The function originally bound to the event.
+     * @param {boolean|EventListenerOptions} [options] - Optional listener options.
+     */
+    off(event: string, handler: EventRegistryHandle, options?: boolean | EventListenerOptions): void;
+    /**
+     * Removes all event listeners of a specific type from the element.
+     *
+     * @param {string} event - The event type to remove (e.g. 'click').
+     */
+    offAll(event: string): void;
+    /**
+     * Removes all event listeners of all types from the element.
+     *
+     * @param {((handler: EventListenerOrEventListenerObject, event: string) => boolean)|null} [filterFn=null] -
+     *        Optional filter function to selectively remove specific handlers.
+     */
+    offAllTypes(filterFn?: ((handler: EventListenerOrEventListenerObject, event: string) => boolean) | null): void;
+    /**
+     * Triggers all handlers associated with a specific event on the given element.
+     *
+     * @param {string} event - Name of the event to trigger.
+     * @param {Event|CustomEvent|CustomEventInit} [payload] - Optional event object or data to pass.
+     */
+    trigger(event: string, payload?: Event | CustomEvent | CustomEventInit): void;
+    /**
+     * Get an attribute on an element.
+     * @param {string} name
+     * @returns {string|null}
+     */
+    attr(name: string): string | null;
+    /**
+     * Set an attribute on an element.
+     * @param {string} name
+     * @param {string|null} [value=null]
+     */
+    setAttr(name: string, value?: string | null): void;
+    /**
+     * Remove attribute(s) from an element.
+     * @param {string} name Space-separated list of attributes.
+     */
+    removeAttr(name: string): void;
+    /**
+     * Check if an attribute exists on an element.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    hasAttr(name: string): boolean;
+    /**
+     * Check if a property exists.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    hasProp(name: string): boolean;
+    /**
+     * Set a property on an element.
+     * @param {string} name
+     */
+    addProp(name: string): void;
+    /**
+     * Remove a property from an element.
+     * @param {string} name
+     */
+    removeProp(name: string): void;
+    /**
+     * Toggle a boolean property.
+     * @param {string} name
+     * @param {boolean} [force]
+     */
+    toggleProp(name: string, force?: boolean): void;
+    /**
+     * Removes the element from the DOM.
+     */
+    remove(): void;
+    /**
+     * Returns the index of the first element within its parent or relative to a selector/element.
+     *
+     * @param {string|TinyElement|null} [elem] - Optional target to compare index against.
+     * @returns {number}
+     */
+    index(elem?: string | TinyElement | null): number;
+    /**
+     * Determines if two HTML elements are colliding, using a simple bounding box comparison.
+     *
+     * @param {TinyElement} el2 - The second element to compare.
+     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
+     * @returns {boolean} - `true` if the elements are colliding, `false` otherwise.
+     */
+    isCollWith(el2: TinyElement, extraRect?: Partial<TinyCollision.ObjRect>): boolean;
+    /**
+     * Determines if two HTML elements are colliding using a pixel-perfect collision algorithm.
+     *
+     * @param {TinyElement} el2 - The second element to compare.
+     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
+     * @returns {boolean} - `true` if the elements are colliding with higher precision, `false` otherwise.
+     */
+    isCollPerfWith(el2: TinyElement, extraRect?: Partial<TinyCollision.ObjRect>): boolean;
+    /**
+     * Checks if two DOM elements are colliding on the screen, and locks the collision
+     * until the element exits through the same side it entered.
+     *
+     * @param {TinyElement} el2 - Second DOM element (e.g. a container or boundary element).
+     * @param {CollisionDirLock} lockDirection - Direction that must be respected to unlock the collision.
+     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
+     * @returns {boolean} True if collision is still active.
+     */
+    isCollWithLock(el2: TinyElement, lockDirection: CollisionDirLock, extraRect?: Partial<TinyCollision.ObjRect>): boolean;
+    /**
+     * Checks if two DOM elements are colliding on the screen, and locks the collision
+     * until the element exits through the same side it entered.
+     *
+     * @param {TinyElement} el2 - Second DOM element (e.g. a container or boundary element).
+     * @param {CollisionDirLock} lockDirection - Direction that must be respected to unlock the collision.
+     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
+     * @returns {boolean} True if collision is still active.
+     */
+    isCollPerfWithLock(el2: TinyElement, lockDirection: CollisionDirLock, extraRect?: Partial<TinyCollision.ObjRect>): boolean;
+    /**
+     * Resets the collision lock for a specific element.
+     *
+     * This removes any previously stored collision direction for the given element,
+     * effectively unlocking its collision state.
+     *
+     * @returns {boolean} Returns `true` if a lock was removed, `false` if no lock was present.
+     */
+    resetCollLock(): boolean;
+    /**
+     * Resets the collision lock for a specific element and direction.
+     *
+     * @param {CollisionDirLock} direction - The direction to clear the lock from.
+     * @returns {boolean} True if the lock was removed.
+     */
+    resetCollLockDir(direction: CollisionDirLock): boolean;
+    /**
+     * Checks if the given element is at least partially visible in the viewport.
+     *
+     * @returns {boolean} True if the element is partially in the viewport, false otherwise.
+     */
+    isInViewport(): boolean;
+    /**
+     * Checks if the given element is fully visible in the viewport (top and bottom).
+     *
+     * @returns {boolean} True if the element is fully visible in the viewport, false otherwise.
+     */
+    isScrolledIntoView(): boolean;
+    #private;
+}
+import * as TinyCollision from '../basics/collision.mjs';
+//# sourceMappingURL=TinyHtml.d.mts.map