tiny-essentials 1.24.2 → 1.24.3

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

@@ -328,12 +328,16 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
             y: number;
         };
     };
+    /** @type {number} */
+    static "__#private@#version": number;
+    /** @returns {number} */
+    static get version(): number;
     /**
      * Controls whether TinyHtml emits detailed debug output to the console.
      * When enabled, helper methods print structured diagnostics for easier troubleshooting.
      * @type {boolean}
      */
-    static "__#8@#elemDebug": boolean;
+    static "__#private@#elemDebug": boolean;
     /**
      * Enables or disables debug output.
      * @param {boolean} value True to enable debug output; false to disable.
@@ -374,7 +378,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * Flag to determine if element observer should start automatically.
      * @type {boolean}
      */
-    static "__#8@#autoStartElemObserver": boolean;
+    static "__#private@#autoStartElemObserver": boolean;
     /**
      * Set the auto-start flag for the observer.
      * @param {boolean} value
@@ -386,7 +390,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      */
     static get autoStartElemObserver(): boolean;
     /** @type {TinyElementObserver} */
-    static "__#8@#tinyObserver": TinyElementObserver;
+    static "__#private@#tinyObserver": TinyElementObserver;
     /** @returns {TinyElementObserver} */
     static get tinyObserver(): TinyElementObserver;
     /**
@@ -575,9 +579,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @param {string[]} elemName - The list of expected element names for error reporting.
      * @returns {any[]} - A flat array of validated elements.
      * @throws {Error} - If any element is not an instance of one of the allowed types.
-     * @readonly
      */
-    static readonly _preElemsTemplate(elems: TinyElement | EventTarget | null | (TinyElement | EventTarget | null)[], where: string, TheTinyElements: any[], elemName: string[]): any[];
+    static _preElemsTemplate(elems: TinyElement | EventTarget | null | (TinyElement | EventTarget | null)[], where: string, TheTinyElements: any[], elemName: string[]): any[];
     /**
      * Prepares and validates a single element against allowed types.
      *
@@ -588,9 +591,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @param {boolean} [canNull=false] - Whether `null` is allowed as a valid value.
      * @returns {any} - The validated element or `null` if allowed.
      * @throws {Error} - If the element is not valid or if multiple elements are provided.
-     * @readonly
      */
-    static readonly _preElemTemplate(elems: TinyElement | EventTarget | null | (TinyElement | EventTarget | null)[], where: string, TheTinyElements: any[], elemName: string[], canNull?: boolean): any;
+    static _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.
@@ -598,9 +600,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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[];
+    static _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.
@@ -608,9 +609,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _preElem(elems: TinyElement | TinyElement[], where: string): Element;
     /**
      * Ensures the input is returned as an array.
      * Useful to normalize operations across multiple or single nodes.
@@ -618,9 +618,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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[];
+    static _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.
@@ -628,9 +627,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _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.
@@ -638,9 +636,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _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.
@@ -648,9 +645,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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[];
+    static _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.
@@ -658,9 +654,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _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.
@@ -668,9 +663,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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[];
+    static _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.
@@ -678,9 +672,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _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.
@@ -688,9 +681,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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[];
+    static _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.
@@ -698,9 +690,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _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.
@@ -708,9 +699,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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[];
+    static _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.
@@ -718,9 +708,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _preElemAndWindow(elems: TinyElementAndWindow | TinyElementAndWindow[], where: string): ElementAndWindow;
     /**
      * Ensures the input is returned as an array.
      * Useful to normalize operations across multiple or single element/window/document elements.
@@ -728,9 +717,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @param {TinyElementAndWinAndDoc|TinyElementAndWinAndDoc[]} elems - A single element/document/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/document/window elements.
-     * @readonly
      */
-    static readonly _preElemsAndWinAndDoc(elems: TinyElementAndWinAndDoc | TinyElementAndWinAndDoc[], where: string): ElementAndWindow[];
+    static _preElemsAndWinAndDoc(elems: TinyElementAndWinAndDoc | TinyElementAndWinAndDoc[], where: string): ElementAndWindow[];
     /**
      * Ensures the input is returned as an single element/window/document element.
      * Useful to normalize operations across multiple or single element/window/document elements.
@@ -738,9 +726,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @param {TinyElementAndWinAndDoc|TinyElementAndWinAndDoc[]} elems - A single element/document/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/document/window element.
-     * @readonly
      */
-    static readonly _preElemAndWinAndDoc(elems: TinyElementAndWinAndDoc | TinyElementAndWinAndDoc[], where: string): ElementAndWindow;
+    static _preElemAndWinAndDoc(elems: TinyElementAndWinAndDoc | TinyElementAndWinAndDoc[], where: string): ElementAndWindow;
     /**
      * Ensures the input is returned as an array.
      * Useful to normalize operations across multiple or single element with document elements.
@@ -748,9 +735,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @param {TinyElementWithDoc|TinyElementWithDoc[]} elems - A single element with document element or array of html elements.
      * @param {string} where - The method or context name where validation is being called.
      * @returns {ElementWithDoc[]} - Always returns an array of element with document elements.
-     * @readonly
      */
-    static readonly _preElemsWithDoc(elems: TinyElementWithDoc | TinyElementWithDoc[], where: string): ElementWithDoc[];
+    static _preElemsWithDoc(elems: TinyElementWithDoc | TinyElementWithDoc[], where: string): ElementWithDoc[];
     /**
      * Ensures the input is returned as an single element with document element.
      * Useful to normalize operations across multiple or single element with document elements.
@@ -758,9 +744,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @param {TinyElementWithDoc|TinyElementWithDoc[]} 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 {ElementWithDoc} - Always returns an single element/window element.
-     * @readonly
      */
-    static readonly _preElemWithDoc(elems: TinyElementWithDoc | TinyElementWithDoc[], where: string): ElementWithDoc;
+    static _preElemWithDoc(elems: TinyElementWithDoc | TinyElementWithDoc[], where: string): ElementWithDoc;
     /**
      * Normalizes and converts one or more DOM elements (or TinyHtml instances)
      * into an array of `TinyHtml` instances.
@@ -873,9 +858,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * 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>;
+    static _dataSelector: Record<string, (where: string, elem: TinyElement) => ElementDataStore>;
     /**
      * Retrieves data associated with a DOM element.
      *
@@ -925,18 +909,16 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @param {"previousSibling"|"nextSibling"} direction
      * @param {string} where
      * @returns {ChildNode|null}
-     * @readonly
      */
-    static readonly _getSibling(el: TinyNode, direction: "previousSibling" | "nextSibling", where: string): ChildNode | null;
+    static _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[];
+    static _getSiblings(start: Node | null, exclude?: Node | null): ChildNode[];
     /**
      * Traverse DOM in a direction collecting elements.
      *
@@ -1034,7 +1016,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @returns {Node[]}
      */
     static clone(el: TinyNode | TinyNode[], deep?: boolean): Node[];
-    static readonly _appendChecker(where: string, ...nodes: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): (Node | string)[];
+    static _appendChecker(where: string, ...nodes: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): (Node | string)[];
     /**
      * Appends child elements or strings to the end of the target element(s).
      *
@@ -1204,7 +1186,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      *
      * @type {Record<string | symbol, string>}
      */
-    static "__#8@#cssPropAliases": Record<string | symbol, string>;
+    static "__#private@#cssPropAliases": Record<string | symbol, string>;
     /**
      * Public proxy to manage camelCase ➝ kebab-case CSS property aliasing.
      *
@@ -1451,7 +1433,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      */
     static outerWidth(el: TinyElementAndWinAndDoc, includeMargin?: boolean): number;
     /** @type {string} */
-    static "__#8@#defaultDisplay": string;
+    static "__#private@#defaultDisplay": string;
     /**
      * Sets the default display value.
      * @param {string} value
@@ -1487,7 +1469,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      *
      * @type {boolean}
      */
-    static "__#8@#cancelOldStyleFx": boolean;
+    static "__#private@#cancelOldStyleFx": boolean;
     /**
      * Updates the global setting that determines whether old style-based animations
      * are cancelled before new ones start.
@@ -1512,7 +1494,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      *
      * @type {Record<string, number | KeyframeAnimationOptions>}
      */
-    static "__#8@#styleFxSpeeds": Record<string, number | KeyframeAnimationOptions>;
+    static "__#private@#styleFxSpeeds": Record<string, number | KeyframeAnimationOptions>;
     /**
      * Replace the predefined animation speeds.
      * @param {Record<string, number | KeyframeAnimationOptions>} speeds
@@ -1557,12 +1539,12 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * CSS expansion shorthand used by genStyleFx to include margin/padding values.
      * @typedef {['Top', 'Right', 'Bottom', 'Left']}
      */
-    static "__#8@#cssExpand": string[];
+    static "__#private@#cssExpand": string[];
     /**
      * Generate shortcuts
      * @type {Record<string, StyleEffects>}
      */
-    static "__#8@#styleEffects": Record<string, StyleEffects>;
+    static "__#private@#styleEffects": Record<string, StyleEffects>;
     /**
      * Replace the entire styleEffects map with a new one.
      *
@@ -1603,7 +1585,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * Style Effect Inverse Values
      * @type {Record<string, string>}
      */
-    static "__#8@#styleEffectInverse": Record<string, string>;
+    static "__#private@#styleEffectInverse": Record<string, string>;
     /**
      * Replace the style inverse values.
      * @param {Record<string, string>} values
@@ -1648,7 +1630,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * Style Effect Repeat Detector
      * @type {Record<string, StyleEffectsRdFn>}
      */
-    static "__#8@#styleEffectsRd": Record<string, StyleEffectsRdFn>;
+    static "__#private@#styleEffectsRd": Record<string, StyleEffectsRdFn>;
     /**
      * Replace the style effects repeat detectors.
      * @param {Record<string, StyleEffectsRdFn>} detectors
@@ -1695,7 +1677,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      *
      * @type {StyleEffectsProps}
      */
-    static "__#8@#styleEffectsProps": StyleEffectsProps;
+    static "__#private@#styleEffectsProps": StyleEffectsProps;
     /**
      * Replace the entire styleEffectsProps map with a new one.
      *
@@ -1959,7 +1941,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      */
     static padding(el: TinyElement): HtmlElBoxSides;
     /** @type {boolean} */
-    static "__#8@#classCanWhitespace": boolean;
+    static "__#private@#classCanWhitespace": boolean;
     /**
      * Sets the value of classCanWhitespace.
      * @param {boolean} value
@@ -2166,8 +2148,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @returns {T}
      */
     static setHtml<T extends TinyElement | TinyElement[]>(el: T, value: string): T;
-    /** @readonly */
-    static readonly _valHooks: {
+    static _valHooks: {
         option: {
             /**
              * @param {HTMLOptionElement} elem
@@ -2226,9 +2207,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
     /**
      * 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: {
+    static _valTypes: {
         /**
          * Gets the string value from any HTMLInputElement.
          * @type {(elem: HTMLInputElement) => string}
@@ -2261,9 +2241,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _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.
@@ -2272,9 +2251,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _val(el: TinyInputElement, where: string, type: GetValueTypes): any;
     /**
      * Gets the value of the current HTML value element.
      *
@@ -2298,9 +2276,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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[];
+    static _valArr(el: TinyInputElement, where: string, type: GetValueTypes): SetValueBase[];
     /**
      * Gets the raw value as a generic array of the current HTML value element (for select).
      *
@@ -2452,7 +2429,7 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      *
      * @type {Record<string | symbol, string>}
      */
-    static "__#8@#propFix": Record<string | symbol, string>;
+    static "__#private@#propFix": Record<string | symbol, string>;
     /**
      * Public proxy for normalized DOM property names.
      *
@@ -2688,9 +2665,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _getCustomRect(rect: DOMRect, extraRect: Partial<DOMRect>): DOMRect;
     /**
      * Determines if two HTML elements are colliding, using a simple bounding box comparison.
      *
@@ -2725,9 +2701,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    static _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.
@@ -2887,17 +2862,15 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @param {string} where - The method name or context calling this.
      * @param {number} index - The index of the element to retrieve.
      * @returns {ConstructorElValues} - The instance's element.
-     * @readonly
      */
-    readonly _getElement(where: string, index: number): ConstructorElValues;
+    _getElement(where: string, index: number): ConstructorElValues;
     /**
      * Returns the current Elements held by this instance.
      *
      * @param {string} where - The method name or context calling this.
      * @returns {ConstructorElValues[]} - The instance's elements.
-     * @readonly
      */
-    readonly _getElements(where: string): ConstructorElValues[];
+    _getElements(where: string): ConstructorElValues[];
     /**
      * Prepares and validates multiple elements against allowed types.
      *
@@ -2906,9 +2879,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @param {string[]} elemName - The list of expected element names for error reporting.
      * @returns {any[]} - A flat array of validated elements.
      * @throws {Error} - If any element is not an instance of one of the allowed types.
-     * @readonly
      */
-    readonly _preElemsTemplate(where: string, TheTinyElements: any[], elemName: string[]): any[];
+    _preElemsTemplate(where: string, TheTinyElements: any[], elemName: string[]): any[];
     /**
      * Prepares and validates a single element against allowed types.
      *
@@ -2918,162 +2890,144 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @param {boolean} [canNull=false] - Whether `null` is allowed as a valid value.
      * @returns {any} - The validated element or `null` if allowed.
      * @throws {Error} - If the element is not valid or if multiple elements are provided.
-     * @readonly
      */
-    readonly _preElemTemplate(where: string, TheTinyElements: any[], elemName: string[], canNull?: boolean): any;
+    _preElemTemplate(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 {string} where - The method or context name where validation is being called.
      * @returns {Element[]} - Always returns an array of elements.
-     * @readonly
      */
-    readonly _preElems(where: string): Element[];
+    _preElems(where: string): Element[];
     /**
      * Ensures the input is returned as an single element.
      * Useful to normalize operations across multiple or single elements.
      *
      * @param {string} where - The method or context name where validation is being called.
      * @returns {Element} - Always returns an single element.
-     * @readonly
      */
-    readonly _preElem(where: string): Element;
+    _preElem(where: string): Element;
     /**
      * Ensures the input is returned as an array.
      * Useful to normalize operations across multiple or single nodes.
      *
      * @param {string} where - The method or context name where validation is being called.
      * @returns {Node[]} - Always returns an array of nodes.
-     * @readonly
      */
-    readonly _preNodeElems(where: string): Node[];
+    _preNodeElems(where: string): Node[];
     /**
      * Ensures the input is returned as an single node.
      * Useful to normalize operations across multiple or single nodes.
      *
      * @param {string} where - The method or context name where validation is being called.
      * @returns {Node} - Always returns an single node.
-     * @readonly
      */
-    readonly _preNodeElem(where: string): Node;
+    _preNodeElem(where: string): Node;
     /**
      * Ensures the input is returned as an single node.
      * Useful to normalize operations across multiple or single 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
      */
-    readonly _preNodeElemWithNull(where: string): Node | null;
+    _preNodeElemWithNull(where: string): Node | null;
     /**
      * Ensures the input is returned as an array.
      * Useful to normalize operations across multiple or single 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
      */
-    readonly _preHtmlElems(where: string): HTMLElement[];
+    _preHtmlElems(where: string): HTMLElement[];
     /**
      * Ensures the input is returned as an single html element.
      * Useful to normalize operations across multiple or single html elements.
      *
      * @param {string} where - The method or context name where validation is being called.
      * @returns {HTMLElement} - Always returns an single html element.
-     * @readonly
      */
-    readonly _preHtmlElem(where: string): HTMLElement;
+    _preHtmlElem(where: string): HTMLElement;
     /**
      * Ensures the input is returned as an array.
      * Useful to normalize operations across multiple or single event target 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
      */
-    readonly _preInputElems(where: string): InputElement[];
+    _preInputElems(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 {string} where - The method or context name where validation is being called.
      * @returns {InputElement} - Always returns an single event target element.
-     * @readonly
      */
-    readonly _preInputElem(where: string): InputElement;
+    _preInputElem(where: string): InputElement;
     /**
      * Ensures the input is returned as an array.
      * Useful to normalize operations across multiple or single event target 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
      */
-    readonly _preEventTargetElems(where: string): EventTarget[];
+    _preEventTargetElems(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 {string} where - The method or context name where validation is being called.
      * @returns {EventTarget} - Always returns an single event target element.
-     * @readonly
      */
-    readonly _preEventTargetElem(where: string): EventTarget;
+    _preEventTargetElem(where: string): EventTarget;
     /**
      * Ensures the input is returned as an array.
      * Useful to normalize operations across multiple or single element/window 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
      */
-    readonly _preElemsAndWindow(where: string): ElementAndWindow[];
+    _preElemsAndWindow(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 {string} where - The method or context name where validation is being called.
      * @returns {ElementAndWindow} - Always returns an single element/window element.
-     * @readonly
      */
-    readonly _preElemAndWindow(where: string): ElementAndWindow;
+    _preElemAndWindow(where: string): ElementAndWindow;
     /**
      * Ensures the input is returned as an array.
      * Useful to normalize operations across multiple or single element/window/document elements.
      *
      * @param {string} where - The method or context name where validation is being called.
      * @returns {ElementAndWindow[]} - Always returns an array of element/document/window elements.
-     * @readonly
      */
-    readonly _preElemsAndWinAndDoc(where: string): ElementAndWindow[];
+    _preElemsAndWinAndDoc(where: string): ElementAndWindow[];
     /**
      * Ensures the input is returned as an single element/window/document element.
      * Useful to normalize operations across multiple or single element/window/document elements.
      *
      * @param {string} where - The method or context name where validation is being called.
      * @returns {ElementAndWindow} - Always returns an single element/document/window element.
-     * @readonly
      */
-    readonly _preElemAndWinAndDoc(where: string): ElementAndWindow;
+    _preElemAndWinAndDoc(where: string): ElementAndWindow;
     /**
      * Ensures the input is returned as an array.
      * Useful to normalize operations across multiple or single element with document elements.
      *
      * @param {string} where - The method or context name where validation is being called.
      * @returns {ElementWithDoc[]} - Always returns an array of element with document elements.
-     * @readonly
      */
-    readonly _preElemsWithDoc(where: string): ElementWithDoc[];
+    _preElemsWithDoc(where: string): ElementWithDoc[];
     /**
      * Ensures the input is returned as an single element with document element.
      * Useful to normalize operations across multiple or single element with document elements.
      *
      * @param {string} where - The method or context name where validation is being called.
      * @returns {ElementWithDoc} - Always returns an single element/window element.
-     * @readonly
      */
-    readonly _preElemWithDoc(where: string): ElementWithDoc;
+    _preElemWithDoc(where: string): ElementWithDoc;
     /**
      * Returns only the elements **not** matching the given selector or function.
      *
@@ -3850,9 +3804,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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;
+    _val(where: string, type: GetValueTypes): any;
     /**
      * Gets the value of the current HTML value element.
      *
@@ -3873,9 +3826,8 @@ declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
      * @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[];
+    _valArr(where: string, type: GetValueTypes): SetValueBase[];
     /**
      * Gets the raw value as a generic array of the current HTML value element (for select).
      *