tiny-essentials 1.17.1 → 1.18.1

package/dist/v1/TinyBasicsEs.js

@@ -2530,207 +2530,11 @@ function formatDayTimer(seconds) {
   return formatCustomTimer(seconds, 'days', '{days}d {hours}:{minutes}:{seconds}');
 }
 
-// EXTERNAL MODULE: ./node_modules/buffer/index.js
-var buffer = __webpack_require__(287);
-;// ./src/v1/basics/objFilter.mjs
-
-
-const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-
-/**
- * An object containing type validation functions and their evaluation order.
- *
- * Each item in `typeValidator.items` is a function that receives any value
- * and returns a boolean indicating whether the value matches the corresponding type.
- *
- * The `order` array defines the priority in which types should be checked,
- * which can be useful for functions that infer types in a consistent manner.
- *
- */
-const typeValidator = {
-  items: {},
-  /**
-   * Evaluation order of the type checkers.
-   * @type {string[]}
-   * */
-  order: [],
-};
-
-/** @typedef {Object.<string, (val: any) => *>} ExtendObjType */
-/** @typedef {Array<[string, (val: any) => *]>} ExtendObjTypeArray */
-
-/**
- * Adds new type checkers to the typeValidator without overwriting existing ones.
- *
- * Accepts either an object with named functions or an array of [key, fn] arrays.
- * If no index is provided, the type is inserted just before 'object' (if it exists), or at the end.
- *
- * @param {ExtendObjType|ExtendObjTypeArray} newItems
- *        - New type validators to be added.
- * @param {number} [index] - Optional. Position at which to insert each new type. Ignored if the type already exists.
- * @returns {string[]} - A list of successfully added type names.
- *
- * @example
- * extendObjType({
- *   htmlElement2: val => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement
- * });
- *
- * @example
- * extendObjType([
- *   ['alpha', val => typeof val === 'string'],
- *   ['beta', val => Array.isArray(val)]
- * ]);
- */
-function extendObjType(newItems, index) {
-  const added = [];
-
-  const entries = Array.isArray(newItems) ? newItems : Object.entries(newItems);
-  for (const [key, fn] of entries) {
-    if (!typeValidator.items.hasOwnProperty(key)) {
-      // @ts-ignore
-      typeValidator.items[key] = fn;
-
-      let insertAt = typeof index === 'number' ? index : -1; // Default to -1 if index isn't provided
-
-      // Default to before 'object', or to the end
-      if (insertAt === -1) {
-        const objectIndex = typeValidator.order.indexOf('object');
-        insertAt = objectIndex > -1 ? objectIndex : typeValidator.order.length;
-      }
-
-      // Ensure insertAt is a valid number and not out of bounds
-      insertAt = Math.min(Math.max(0, insertAt), typeValidator.order.length);
-
-      typeValidator.order.splice(insertAt, 0, key);
-      added.push(key);
-    }
-  }
-
-  return added;
-}
-
-/**
- * Reorders the typeValidator.order array according to a custom new order.
- * All values in the new order must already exist in the current order.
- * The function does not mutate the original array structure directly.
- *
- * @param {string[]} newOrder - The new order of type names.
- * @returns {boolean} - Returns true if the reorder was successful, false if invalid keys were found.
- *
- * @example
- * reorderObjTypeOrder([
- *   'string', 'number', 'array', 'object'
- * ]);
- */
-function reorderObjTypeOrder(newOrder) {
-  const currentOrder = [...typeValidator.order]; // shallow clone
-
-  // All keys in newOrder must exist in currentOrder
-  const isValid = newOrder.every((type) => currentOrder.includes(type));
-
-  if (!isValid) return false;
-
-  // Reassign only if valid
-  typeValidator.order = newOrder.slice(); // assign shallow copy
-  return true;
-}
-
-/**
- * Returns a cloned version of the `typeValidator.order` array.
- * The cloned array will not be affected by future changes to the original `order`.
- *
- * @returns {string[]} - A new array with the same values as `typeValidator.order`.
- */
-function cloneObjTypeOrder() {
-  return [...typeValidator.order]; // Creates a shallow copy of the array
-}
-
-/**
- * Returns the detected type name of a given value based on predefined type validators.
- *
- * This function uses `getType` with a predefined `typeValidator` to determine or compare types safely.
- * in the specified `typeValidator.order`. The first matching type is returned.
- *
- * If `val` is `null`, it immediately returns `'null'`.
- * If no match is found, it returns `'unknown'`.
- *
- * @param {any} val - The value whose type should be determined.
- * @returns {string} - The type name of the value (e.g., "array", "date", "map"), or "unknown" if no match is found.
- *
- * @example
- * getType([]); // "array"
- * getType(null); // "null"
- * getType(new Set()); // "set"
- * getType(() => {}); // "unknown"
- */
-const getType = (val) => {
-  if (val === null) return 'null';
-  // @ts-ignore
-  for (const name of typeValidator.order) {
-    // @ts-ignore
-    if (typeof typeValidator.items[name] !== 'function' || typeValidator.items[name](val))
-      return name;
-  }
-  return 'unknown';
-};
-
-/**
- * Checks the type of a given object or returns its type as a string.
- *
- * @param {*} obj - The object to check or identify.
- * @param {string} [type] - Optional. If provided, checks whether the object matches this type (e.g., "object", "array", "string").
- * @returns {boolean|string|null} - Returns `true` if the type matches, `false` if not,
- *                                   the type string if no type is provided, or `null` if the object is `undefined`.
- *
- * @example
- * objType([], 'array'); // true
- * objType({}, 'object'); // true
- * objType('hello'); // "string"
- * objType(undefined); // null
- */
-function objType(obj, type) {
-  if (typeof obj === 'undefined') return null;
-  const result = getType(obj);
-  if (typeof type === 'string') return result === type.toLowerCase();
-  return result;
-}
-
-/**
- * Checks the type of a given object and returns the validation value if a known type is detected.
- *
- * @param {*} obj - The object to check or identify.
- * @returns {{ valid:*; type: string | null }} - Returns the type result.
- */
-function checkObj(obj) {
-  /** @type {{ valid:*; type: string | null }} */
-  const data = { valid: null, type: null };
-  for (const name of typeValidator.order) {
-    // @ts-ignore
-    if (typeof typeValidator.items[name] === 'function') {
-      // @ts-ignore
-      const result = typeValidator.items[name](obj);
-      if (result) {
-        data.valid = result;
-        data.type = name;
-        break;
-      }
-    }
-  }
-  return data;
-}
-
-/**
- * Creates a clone of the functions from the `typeValidator` object.
- * It returns a new object where the keys are the same and the values are the cloned functions.
- */
-function getCheckObj() {
-  return Object.fromEntries(Object.entries(typeValidator.items).map(([key, fn]) => [key, fn]));
-}
-
+;// ./src/v1/basics/objChecker.mjs
 /**
  * Counts the number of elements in an array or the number of properties in an object.
  *
- * @param {Array<*>|Record<string|number, any>} obj - The array or object to count.
+ * @param {Array<*>|Record<string | number | symbol, any>} obj - The array or object to count.
  * @returns {number} - The count of items (array elements or object keys), or `0` if the input is neither an array nor an object.
  *
  * @example
@@ -2742,7 +2546,7 @@ function countObj(obj) {
   // Is Array
   if (Array.isArray(obj)) return obj.length;
   // Object
-  if (objType(obj, 'object')) return Object.keys(obj).length;
+  if (isJsonObject(obj)) return Object.keys(obj).length;
   // Nothing
   return 0;
 }
@@ -2769,132 +2573,6 @@ function isJsonObject(value) {
   return true;
 }
 
-// Insert obj types
-
-extendObjType([
-  [
-    'undefined',
-    /** @param {*} val @returns {val is undefined} */
-    (val) => typeof val === 'undefined',
-  ],
-  [
-    'null',
-    /** @param {*} val @returns {val is null} */
-    (val) => val === null,
-  ],
-  [
-    'boolean',
-    /** @param {*} val @returns {val is boolean} */
-    (val) => typeof val === 'boolean',
-  ],
-  [
-    'number',
-    /** @param {*} val @returns {val is number} */
-    (val) => typeof val === 'number' && !Number.isNaN(val),
-  ],
-  [
-    'bigint',
-    /** @param {*} val @returns {val is bigint} */
-    (val) => typeof val === 'bigint',
-  ],
-  [
-    'string',
-    /** @param {*} val @returns {val is string} */
-    (val) => typeof val === 'string',
-  ],
-  [
-    'symbol',
-    /** @param {*} val @returns {val is symbol} */
-    (val) => typeof val === 'symbol',
-  ],
-  [
-    'function',
-    /** @param {*} val @returns {val is Function} */
-    (val) => typeof val === 'function',
-  ],
-  [
-    'array',
-    /** @param {*} val @returns {val is any[]} */
-    (val) => Array.isArray(val),
-  ],
-]);
-
-if (!isBrowser) {
-  extendObjType([
-    [
-      'buffer',
-      /** @param {*} val @returns {val is Buffer} */
-      (val) => typeof buffer/* Buffer */.hp !== 'undefined' && buffer/* Buffer */.hp.isBuffer(val),
-    ],
-  ]);
-}
-
-if (isBrowser) {
-  extendObjType([
-    [
-      'file',
-      /** @param {*} val @returns {val is File} */
-      (val) => typeof File !== 'undefined' && val instanceof File,
-    ],
-  ]);
-}
-
-extendObjType([
-  [
-    'date',
-    /** @param {*} val @returns {val is Date} */
-    (val) => val instanceof Date,
-  ],
-  [
-    'regexp',
-    /** @param {*} val @returns {val is RegExp} */
-    (val) => val instanceof RegExp,
-  ],
-  [
-    'map',
-    /** @param {*} val @returns {val is Map<unknown, unknown>} */
-    (val) => val instanceof Map,
-  ],
-  [
-    'set',
-    /** @param {*} val @returns {val is Set<unknown>} */
-    (val) => val instanceof Set,
-  ],
-  [
-    'weakmap',
-    /** @param {*} val @returns {val is WeakMap<unknown, unknown>} */
-    (val) => val instanceof WeakMap,
-  ],
-  [
-    'weakset',
-    /** @param {*} val @returns {val is WeakSet<unknown>} */
-    (val) => val instanceof WeakSet,
-  ],
-  [
-    'promise',
-    /** @param {*} val @returns {val is Promise<unknown>} */
-    (val) => val instanceof Promise,
-  ],
-]);
-
-if (isBrowser) {
-  extendObjType([
-    [
-      'htmlelement',
-      /** @param {*} val @returns {val is HTMLElement} */
-      (val) => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement,
-    ],
-  ]);
-}
-
-extendObjType([
-  [
-    'object',
-    /** @param {*} val @returns {val is Record<string | number | symbol, unknown>} */
-    (val) => isJsonObject(val),
-  ],
-]);
-
 ;// ./src/v1/basics/html.mjs
 
 
@@ -3764,22 +3442,37 @@ const {
  * 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.
  *
- * @typedef {Element|Window} ElementAndWindow
+ * @typedef {Element|Window} ElementAndWindow
+ */
+
+/**
+ * Represents a raw DOM element/window/document or an instance of TinyHtml.
+ * This type is used to abstract interactions with both plain elements
+ * and wrapped elements via the TinyHtml class.
+ *
+ * @typedef {ElementAndWinAndDoc|TinyHtml} TinyElementAndWinAndDoc
+ */
+
+/**
+ * Represents a value that can be either a DOM Element, or the global Window object, or the document object.
+ * Useful for functions that operate generically on scrollable or measurable targets.
+ *
+ * @typedef {Element|Window|Document} ElementAndWinAndDoc
  */
 
 /**
- * Represents a raw DOM element/window/document or an instance of TinyHtml.
+ * Represents a raw DOM element with document or an instance of TinyHtml.
  * This type is used to abstract interactions with both plain elements
  * and wrapped elements via the TinyHtml class.
  *
- * @typedef {ElementAndWinAndDoc|TinyHtml} TinyElementAndWinAndDoc
+ * @typedef {ElementWithDoc|TinyHtml} TinyElementWithDoc
  */
 
 /**
- * Represents a value that can be either a DOM Element, or the global Window object, or the document object.
- * Useful for functions that operate generically on scrollable or measurable targets.
+ * Represents a value that can be either a DOM Element, or the document object.
+ * Useful for functions that operate generically on measurable targets.
  *
- * @typedef {Element|Window|Document} ElementAndWinAndDoc
+ * @typedef {Element|Document} ElementWithDoc
  */
 
 /**
@@ -3801,12 +3494,6 @@ const {
  * @typedef {Window|Element|Document|Text} ConstructorElValues
  */
 
-/**
- * The handler function used in event listeners.
- *
- * @typedef {(e: Event) => any} EventRegistryHandle
- */
-
 /**
  * Options passed to `addEventListener` or `removeEventListener`.
  * Can be a boolean or an object of type `AddEventListenerOptions`.
@@ -3818,7 +3505,7 @@ const {
  * Structure describing a registered event callback and its options.
  *
  * @typedef {Object} EventRegistryItem
- * @property {EventRegistryHandle} handler - The function to be executed when the event is triggered.
+ * @property {EventListenerOrEventListenerObject|null} handler - The function to be executed when the event is triggered.
  * @property {EventRegistryOptions} [options] - Optional configuration passed to the listener.
  */
 
@@ -4377,9 +4064,9 @@ class TinyHtml_TinyHtml {
    * Ensures the input is returned as an array.
    * Useful to normalize operations across multiple or single element/window/document elements.
    *
-   * @param {TinyElementAndWinAndDoc|TinyElementAndWinAndDoc[]} elems - A single element/window element or array of html elements.
+   * @param {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/window elements.
+   * @returns {ElementAndWindow[]} - Always returns an array of element/document/window elements.
    * @readonly
    */
   static _preElemsAndWinAndDoc(elems, where) {
@@ -4396,9 +4083,9 @@ class TinyHtml_TinyHtml {
    * Ensures the input is returned as an single element/window/document element.
    * Useful to normalize operations across multiple or single element/window/document elements.
    *
-   * @param {TinyElementAndWinAndDoc|TinyElementAndWinAndDoc[]} elems - A single element/window element or array of html elements.
+   * @param {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/window element.
+   * @returns {ElementAndWindow} - Always returns an single element/document/window element.
    * @readonly
    */
   static _preElemAndWinAndDoc(elems, where) {
@@ -4412,6 +4099,32 @@ class TinyHtml_TinyHtml {
     return result;
   }
 
+  /**
+   * Ensures the input is returned as an array.
+   * Useful to normalize operations across multiple or single element with document elements.
+   *
+   * @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 _preElemsWithDoc(elems, where) {
+    return TinyHtml_TinyHtml._preElemsTemplate(elems, where, [Element, Document], ['Element', 'Document']);
+  }
+
+  /**
+   * 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 {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 _preElemWithDoc(elems, where) {
+    return TinyHtml_TinyHtml._preElemTemplate(elems, where, [Element, Document], ['Element', 'Document']);
+  }
+
   /**
    * Normalizes and converts one or more DOM elements (or TinyHtml instances)
    * into an array of `TinyHtml` instances.
@@ -7671,12 +7384,120 @@ class TinyHtml_TinyHtml {
 
   ////////////////////////////////////////////
 
+  /**
+   * Registers a listener for the "paste" event to extract files and text from the clipboard (e.g., when the user presses Ctrl+V).
+   *
+   * This method allows reacting to pasted content by providing separate callbacks for files and plain text.
+   * Useful for building file upload areas, rich-text editors, or input enhancements.
+   *
+   * @param {TinyElementWithDoc|TinyElementWithDoc[]} el - The target element(s) where the "paste" event will be listened.
+   * @param {Object} [settings={}] - Optional callbacks to handle clipboard content.
+   * @param {(data: DataTransferItem, file: File) => void} [settings.onFilePaste] - Called for each file pasted from the clipboard (e.g., images).
+   * @param {(data: DataTransferItem, text: string) => void} [settings.onTextPaste] - Called when plain text is pasted from the clipboard.
+   * @returns {EventListenerOrEventListenerObject} The internal "paste" event handler used.
+   */
+  static listenForPaste(el, { onFilePaste, onTextPaste } = {}) {
+    if (typeof onFilePaste !== 'undefined' && typeof onFilePaste !== 'function')
+      throw new TypeError('onFilePaste must be a function.');
+    if (typeof onTextPaste !== 'undefined' && typeof onTextPaste !== 'function')
+      throw new TypeError('onTextPaste must be a function.');
+
+    /** @type {EventListenerOrEventListenerObject} */
+    const pasteEvent = (event) => {
+      if (!(event instanceof ClipboardEvent)) return;
+      const items = event.clipboardData?.items || [];
+      for (const item of items) {
+        if (item.kind === 'file') {
+          if (typeof onFilePaste === 'function') {
+            const file = item.getAsFile();
+            if (file) onFilePaste(item, file);
+          }
+        } else if (item.kind === 'string') {
+          if (typeof onTextPaste === 'function')
+            item.getAsString((text) => onTextPaste(item, text));
+        }
+      }
+    };
+
+    TinyHtml_TinyHtml._preElemsWithDoc(el, 'listenForPaste').forEach((elem) =>
+      TinyHtml_TinyHtml.on(elem, 'paste', pasteEvent),
+    );
+    return pasteEvent;
+  }
+
+  /**
+   * Registers a listener for the "paste" event to extract files and text from the clipboard (e.g., when the user presses Ctrl+V).
+   *
+   * This method allows reacting to pasted content by providing separate callbacks for files and plain text.
+   * Useful for building file upload areas, rich-text editors, or input enhancements.
+   *
+   * @param {Object} [settings={}] - Optional callbacks to handle clipboard content.
+   * @param {(data: DataTransferItem, file: File) => void} [settings.onFilePaste] - Called for each file pasted from the clipboard (e.g., images).
+   * @param {(data: DataTransferItem, text: string) => void} [settings.onTextPaste] - Called when plain text is pasted from the clipboard.
+   * @returns {EventListenerOrEventListenerObject} The internal "paste" event handler used.
+   */
+  listenForPaste({ onFilePaste, onTextPaste } = {}) {
+    return TinyHtml_TinyHtml.listenForPaste(this, { onFilePaste, onTextPaste });
+  }
+
+  /**
+   * Checks if the element has a listener for a specific event.
+   *
+   * @param {TinyEventTarget} el - The element to check.
+   * @param {string} event - The event name to check.
+   * @returns {boolean}
+   */
+  static hasEventListener(el, event) {
+    const elem = TinyHtml_TinyHtml._preEventTargetElem(el, 'hasEventListener');
+    if (!__eventRegistry.has(elem)) return false;
+    const events = __eventRegistry.get(elem);
+    return !!(events && Array.isArray(events[event]) && events[event].length > 0);
+  }
+
+  /**
+   * Checks if the element has a listener for a specific event.
+   *
+   * @param {string} event - The event name to check.
+   * @returns {boolean}
+   */
+  hasEventListener(event) {
+    return TinyHtml_TinyHtml.hasEventListener(this, event);
+  }
+
+  /**
+   * Checks if the element has the exact handler registered for a specific event.
+   *
+   * @param {TinyEventTarget} el - The element to check.
+   * @param {string} event - The event name to check.
+   * @param {EventListenerOrEventListenerObject} handler - The handler function to check.
+   * @returns {boolean}
+   */
+  static hasExactEventListener(el, event, handler) {
+    const elem = TinyHtml_TinyHtml._preEventTargetElem(el, 'hasExactEventListener');
+    if (typeof handler !== 'function') throw new TypeError('The "handler" must be a function.');
+    if (!__eventRegistry.has(elem)) return false;
+    const events = __eventRegistry.get(elem);
+    if (!events || !Array.isArray(events[event])) return false;
+    return events[event].some((item) => item.handler === handler);
+  }
+
+  /**
+   * Checks if the element has the exact handler registered for a specific event.
+   *
+   * @param {string} event - The event name to check.
+   * @param {EventListenerOrEventListenerObject} handler - The handler function to check.
+   * @returns {boolean}
+   */
+  hasExactEventListener(event, handler) {
+    return TinyHtml_TinyHtml.hasExactEventListener(this, event, handler);
+  }
+
   /**
    * 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 {EventListenerOrEventListenerObject|null} handler - The callback function to run on event.
    * @param {EventRegistryOptions} [options] - Optional event listener options.
    * @returns {TinyEventTarget|TinyEventTarget[]}
    */
@@ -7698,7 +7519,7 @@ class TinyHtml_TinyHtml {
    * 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 {EventListenerOrEventListenerObject|null} handler - The callback function to run on event.
    * @param {EventRegistryOptions} [options] - Optional event listener options.
    * @returns {TinyEventTarget|TinyEventTarget[]}
    */
@@ -7711,17 +7532,17 @@ class TinyHtml_TinyHtml {
    *
    * @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 {EventListenerOrEventListenerObject} handler - The callback function to run on event.
    * @param {EventRegistryOptions} [options={}] - Optional event listener options.
    * @returns {TinyEventTarget|TinyEventTarget[]}
    */
   static once(el, event, handler, options = {}) {
     if (typeof event !== 'string') throw new TypeError('The event name must be a string.');
     TinyHtml_TinyHtml._preEventTargetElems(el, 'once').forEach((elem) => {
-      /** @type {EventRegistryHandle} e */
+      /** @type {EventListenerOrEventListenerObject} */
       const wrapped = (e) => {
         TinyHtml_TinyHtml.off(elem, event, wrapped);
-        handler(e);
+        if (typeof handler === 'function') handler(e);
       };
 
       TinyHtml_TinyHtml.on(
@@ -7738,7 +7559,7 @@ class TinyHtml_TinyHtml {
    * 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 {EventListenerOrEventListenerObject} handler - The callback function to run on event.
    * @param {EventRegistryOptions} [options={}] - Optional event listener options.
    * @returns {TinyEventTarget|TinyEventTarget[]}
    */
@@ -7751,7 +7572,7 @@ class TinyHtml_TinyHtml {
    *
    * @param {TinyEventTarget|TinyEventTarget[]} el - The target element.
    * @param {string} event - The event type.
-   * @param {EventRegistryHandle} handler - The function originally bound to the event.
+   * @param {EventListenerOrEventListenerObject|null} handler - The function originally bound to the event.
    * @param {boolean|EventListenerOptions} [options] - Optional listener options.
    * @returns {TinyEventTarget|TinyEventTarget[]}
    */
@@ -7773,7 +7594,7 @@ class TinyHtml_TinyHtml {
    * 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 {EventListenerOrEventListenerObject|null} handler - The function originally bound to the event.
    * @param {boolean|EventListenerOptions} [options] - Optional listener options.
    * @returns {TinyEventTarget|TinyEventTarget[]}
    */
@@ -7816,7 +7637,7 @@ class TinyHtml_TinyHtml {
    * 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] -
+   * @param {((handler: EventListenerOrEventListenerObject|null, event: string) => boolean)|null} [filterFn=null] -
    *        Optional filter function to selectively remove specific handlers.
    * @returns {TinyEventTarget|TinyEventTarget[]}
    */
@@ -7843,7 +7664,7 @@ class TinyHtml_TinyHtml {
   /**
    * Removes all event listeners of all types from the element.
    *
-   * @param {((handler: EventListenerOrEventListenerObject, event: string) => boolean)|null} [filterFn=null] -
+   * @param {((handler: EventListenerOrEventListenerObject|null, event: string) => boolean)|null} [filterFn=null] -
    *        Optional filter function to selectively remove specific handlers.
    * @returns {TinyEventTarget|TinyEventTarget[]}
    */
@@ -8648,94 +8469,420 @@ function areHtmlElsPerfColliding(elem1, elem2) {
   return TinyHtml.isCollPerfWith(elem1, elem2);
 }
 
-///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+
+/**
+ * @typedef {import('../libs/TinyHtml.mjs').HtmlElBoxSides} HtmlElBoxSides
+ */
+
+/**
+ * Returns the total border width and individual sides from `border{Side}Width` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border widths, and each side individually.
+ * @deprecated - Use TinyHtml.borderWidth instead.
+ */
+const getHtmlElBordersWidth = (el) => {
+  return libs_TinyHtml.borderWidth(el);
+};
+
+/**
+ * Returns the total border size and individual sides from `border{Side}` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border sizes, and each side individually.
+ * @deprecated - Use TinyHtml.border instead.
+ */
+const getHtmlElBorders = (el) => {
+  return libs_TinyHtml.border(el);
+};
+
+/**
+ * Returns the total margin and individual sides from `margin{Side}` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) margins, and each side individually.
+ * @deprecated - Use TinyHtml.margin instead.
+ */
+const getHtmlElMargin = (el) => {
+  return libs_TinyHtml.margin(el);
+};
+
+/**
+ * Returns the total padding and individual sides from `padding{Side}` CSS properties.
+ *
+ * @param {Element} el - The target DOM element.
+ * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) paddings, and each side individually.
+ * @deprecated - Use TinyHtml.padding instead.
+ */
+const getHtmlElPadding = (el) => {
+  return libs_TinyHtml.padding(el);
+};
+
+/////////////////////////////////////////////////////////////
+
+// The new version will receive great modifications, the deprecated code has been preserved for non-glitch designs that are using the original code.
+
+/**
+ * Checks if the given element is at least partially visible in the viewport.
+ *
+ * @param {HTMLElement} element - The DOM element to check.
+ * @returns {boolean} True if the element is partially in the viewport, false otherwise.
+ * @deprecated - Use TinyHtml.isInViewport instead.
+ */
+function isInViewport(element) {
+  const elementTop = element.offsetTop;
+  const elementBottom = elementTop + element.offsetHeight;
+
+  const viewportTop = window.scrollY;
+  const viewportBottom = viewportTop + window.innerHeight;
+
+  return elementBottom > viewportTop && elementTop < viewportBottom;
+}
+
+/**
+ * Checks if the given element is fully visible in the viewport (top and bottom).
+ *
+ * @param {HTMLElement} element - The DOM element to check.
+ * @returns {boolean} True if the element is fully visible in the viewport, false otherwise.
+ * @deprecated - Use TinyHtml.isScrolledIntoView instead.
+ */
+function isScrolledIntoView(element) {
+  const viewportTop = window.scrollY;
+  const viewportBottom = viewportTop + window.innerHeight;
+
+  const elemTop = element.offsetTop;
+  const elemBottom = elemTop + element.offsetHeight;
+
+  return elemBottom <= viewportBottom && elemTop >= viewportTop;
+}
+
+// EXTERNAL MODULE: ./node_modules/buffer/index.js
+var buffer = __webpack_require__(287);
+;// ./src/v1/basics/objFilter.mjs
+
+
+
+
+
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+
+/**
+ * An object containing type validation functions and their evaluation order.
+ *
+ * Each item in `typeValidator.items` is a function that receives any value
+ * and returns a boolean indicating whether the value matches the corresponding type.
+ *
+ * The `order` array defines the priority in which types should be checked,
+ * which can be useful for functions that infer types in a consistent manner.
+ *
+ */
+const typeValidator = {
+  items: {},
+  /**
+   * Evaluation order of the type checkers.
+   * @type {string[]}
+   * */
+  order: [],
+};
+
+/** @typedef {Object.<string, (val: any) => *>} ExtendObjType */
+/** @typedef {Array<[string, (val: any) => *]>} ExtendObjTypeArray */
+
+/**
+ * Adds new type checkers to the typeValidator without overwriting existing ones.
+ *
+ * Accepts either an object with named functions or an array of [key, fn] arrays.
+ * If no index is provided, the type is inserted just before 'object' (if it exists), or at the end.
+ *
+ * @param {ExtendObjType|ExtendObjTypeArray} newItems
+ *        - New type validators to be added.
+ * @param {number} [index] - Optional. Position at which to insert each new type. Ignored if the type already exists.
+ * @returns {string[]} - A list of successfully added type names.
+ *
+ * @example
+ * extendObjType({
+ *   htmlElement2: val => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement
+ * });
+ *
+ * @example
+ * extendObjType([
+ *   ['alpha', val => typeof val === 'string'],
+ *   ['beta', val => Array.isArray(val)]
+ * ]);
+ */
+function extendObjType(newItems, index) {
+  const added = [];
+
+  const entries = Array.isArray(newItems) ? newItems : Object.entries(newItems);
+  for (const [key, fn] of entries) {
+    if (!typeValidator.items.hasOwnProperty(key)) {
+      // @ts-ignore
+      typeValidator.items[key] = fn;
+
+      let insertAt = typeof index === 'number' ? index : -1; // Default to -1 if index isn't provided
+
+      // Default to before 'object', or to the end
+      if (insertAt === -1) {
+        const objectIndex = typeValidator.order.indexOf('object');
+        insertAt = objectIndex > -1 ? objectIndex : typeValidator.order.length;
+      }
+
+      // Ensure insertAt is a valid number and not out of bounds
+      insertAt = Math.min(Math.max(0, insertAt), typeValidator.order.length);
+
+      typeValidator.order.splice(insertAt, 0, key);
+      added.push(key);
+    }
+  }
+
+  return added;
+}
+
+/**
+ * Reorders the typeValidator.order array according to a custom new order.
+ * All values in the new order must already exist in the current order.
+ * The function does not mutate the original array structure directly.
+ *
+ * @param {string[]} newOrder - The new order of type names.
+ * @returns {boolean} - Returns true if the reorder was successful, false if invalid keys were found.
+ *
+ * @example
+ * reorderObjTypeOrder([
+ *   'string', 'number', 'array', 'object'
+ * ]);
+ */
+function reorderObjTypeOrder(newOrder) {
+  const currentOrder = [...typeValidator.order]; // shallow clone
+
+  // All keys in newOrder must exist in currentOrder
+  const isValid = newOrder.every((type) => currentOrder.includes(type));
+
+  if (!isValid) return false;
 
-/**
- * @typedef {import('../libs/TinyHtml.mjs').HtmlElBoxSides} HtmlElBoxSides
- */
+  // Reassign only if valid
+  typeValidator.order = newOrder.slice(); // assign shallow copy
+  return true;
+}
 
 /**
- * Returns the total border width and individual sides from `border{Side}Width` CSS properties.
+ * Returns a cloned version of the `typeValidator.order` array.
+ * The cloned array will not be affected by future changes to the original `order`.
  *
- * @param {Element} el - The target DOM element.
- * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border widths, and each side individually.
- * @deprecated - Use TinyHtml.borderWidth instead.
+ * @returns {string[]} - A new array with the same values as `typeValidator.order`.
  */
-const getHtmlElBordersWidth = (el) => {
-  return libs_TinyHtml.borderWidth(el);
-};
+function cloneObjTypeOrder() {
+  return [...typeValidator.order]; // Creates a shallow copy of the array
+}
 
 /**
- * Returns the total border size and individual sides from `border{Side}` CSS properties.
+ * Returns the detected type name of a given value based on predefined type validators.
  *
- * @param {Element} el - The target DOM element.
- * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border sizes, and each side individually.
- * @deprecated - Use TinyHtml.border instead.
+ * This function uses `getType` with a predefined `typeValidator` to determine or compare types safely.
+ * in the specified `typeValidator.order`. The first matching type is returned.
+ *
+ * If `val` is `null`, it immediately returns `'null'`.
+ * If no match is found, it returns `'unknown'`.
+ *
+ * @param {any} val - The value whose type should be determined.
+ * @returns {string} - The type name of the value (e.g., "array", "date", "map"), or "unknown" if no match is found.
+ *
+ * @example
+ * getType([]); // "array"
+ * getType(null); // "null"
+ * getType(new Set()); // "set"
+ * getType(() => {}); // "unknown"
  */
-const getHtmlElBorders = (el) => {
-  return libs_TinyHtml.border(el);
+const getType = (val) => {
+  if (val === null) return 'null';
+  // @ts-ignore
+  for (const name of typeValidator.order) {
+    // @ts-ignore
+    if (typeof typeValidator.items[name] !== 'function' || typeValidator.items[name](val))
+      return name;
+  }
+  return 'unknown';
 };
 
 /**
- * Returns the total margin and individual sides from `margin{Side}` CSS properties.
+ * Checks the type of a given object or returns its type as a string.
  *
- * @param {Element} el - The target DOM element.
- * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) margins, and each side individually.
- * @deprecated - Use TinyHtml.margin instead.
+ * @param {*} obj - The object to check or identify.
+ * @param {string} [type] - Optional. If provided, checks whether the object matches this type (e.g., "object", "array", "string").
+ * @returns {boolean|string|null} - Returns `true` if the type matches, `false` if not,
+ *                                   the type string if no type is provided, or `null` if the object is `undefined`.
+ *
+ * @example
+ * objType([], 'array'); // true
+ * objType({}, 'object'); // true
+ * objType('hello'); // "string"
+ * objType(undefined); // null
  */
-const getHtmlElMargin = (el) => {
-  return libs_TinyHtml.margin(el);
-};
+function objType(obj, type) {
+  if (typeof obj === 'undefined') return null;
+  const result = getType(obj);
+  if (typeof type === 'string') return result === type.toLowerCase();
+  return result;
+}
 
 /**
- * Returns the total padding and individual sides from `padding{Side}` CSS properties.
+ * Checks the type of a given object and returns the validation value if a known type is detected.
  *
- * @param {Element} el - The target DOM element.
- * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) paddings, and each side individually.
- * @deprecated - Use TinyHtml.padding instead.
+ * @param {*} obj - The object to check or identify.
+ * @returns {{ valid:*; type: string | null }} - Returns the type result.
  */
-const getHtmlElPadding = (el) => {
-  return libs_TinyHtml.padding(el);
-};
-
-/////////////////////////////////////////////////////////////
-
-// The new version will receive great modifications, the deprecated code has been preserved for non-glitch designs that are using the original code.
+function checkObj(obj) {
+  /** @type {{ valid:*; type: string | null }} */
+  const data = { valid: null, type: null };
+  for (const name of typeValidator.order) {
+    // @ts-ignore
+    if (typeof typeValidator.items[name] === 'function') {
+      // @ts-ignore
+      const result = typeValidator.items[name](obj);
+      if (result) {
+        data.valid = result;
+        data.type = name;
+        break;
+      }
+    }
+  }
+  return data;
+}
 
 /**
- * Checks if the given element is at least partially visible in the viewport.
- *
- * @param {HTMLElement} element - The DOM element to check.
- * @returns {boolean} True if the element is partially in the viewport, false otherwise.
- * @deprecated - Use TinyHtml.isInViewport instead.
+ * Creates a clone of the functions from the `typeValidator` object.
+ * It returns a new object where the keys are the same and the values are the cloned functions.
  */
-function isInViewport(element) {
-  const elementTop = element.offsetTop;
-  const elementBottom = elementTop + element.offsetHeight;
+function getCheckObj() {
+  return Object.fromEntries(Object.entries(typeValidator.items).map(([key, fn]) => [key, fn]));
+}
 
-  const viewportTop = window.scrollY;
-  const viewportBottom = viewportTop + window.innerHeight;
+// Insert obj types
 
-  return elementBottom > viewportTop && elementTop < viewportBottom;
+extendObjType([
+  [
+    'undefined',
+    /** @param {*} val @returns {val is undefined} */
+    (val) => typeof val === 'undefined',
+  ],
+  [
+    'null',
+    /** @param {*} val @returns {val is null} */
+    (val) => val === null,
+  ],
+  [
+    'boolean',
+    /** @param {*} val @returns {val is boolean} */
+    (val) => typeof val === 'boolean',
+  ],
+  [
+    'number',
+    /** @param {*} val @returns {val is number} */
+    (val) => typeof val === 'number' && !Number.isNaN(val),
+  ],
+  [
+    'bigint',
+    /** @param {*} val @returns {val is bigint} */
+    (val) => typeof val === 'bigint',
+  ],
+  [
+    'string',
+    /** @param {*} val @returns {val is string} */
+    (val) => typeof val === 'string',
+  ],
+  [
+    'symbol',
+    /** @param {*} val @returns {val is symbol} */
+    (val) => typeof val === 'symbol',
+  ],
+  [
+    'function',
+    /** @param {*} val @returns {val is Function} */
+    (val) => typeof val === 'function',
+  ],
+  [
+    'array',
+    /** @param {*} val @returns {val is any[]} */
+    (val) => Array.isArray(val),
+  ],
+]);
+
+if (!isBrowser) {
+  extendObjType([
+    [
+      'buffer',
+      /** @param {*} val @returns {val is Buffer} */
+      (val) => typeof buffer/* Buffer */.hp !== 'undefined' && buffer/* Buffer */.hp.isBuffer(val),
+    ],
+  ]);
 }
 
-/**
- * Checks if the given element is fully visible in the viewport (top and bottom).
- *
- * @param {HTMLElement} element - The DOM element to check.
- * @returns {boolean} True if the element is fully visible in the viewport, false otherwise.
- * @deprecated - Use TinyHtml.isScrolledIntoView instead.
- */
-function isScrolledIntoView(element) {
-  const viewportTop = window.scrollY;
-  const viewportBottom = viewportTop + window.innerHeight;
+if (isBrowser) {
+  extendObjType([
+    [
+      'file',
+      /** @param {*} val @returns {val is File} */
+      (val) => typeof File !== 'undefined' && val instanceof File,
+    ],
+  ]);
+}
 
-  const elemTop = element.offsetTop;
-  const elemBottom = elemTop + element.offsetHeight;
+extendObjType([
+  [
+    'date',
+    /** @param {*} val @returns {val is Date} */
+    (val) => val instanceof Date,
+  ],
+  [
+    'regexp',
+    /** @param {*} val @returns {val is RegExp} */
+    (val) => val instanceof RegExp,
+  ],
+  [
+    'map',
+    /** @param {*} val @returns {val is Map<unknown, unknown>} */
+    (val) => val instanceof Map,
+  ],
+  [
+    'set',
+    /** @param {*} val @returns {val is Set<unknown>} */
+    (val) => val instanceof Set,
+  ],
+  [
+    'weakmap',
+    /** @param {*} val @returns {val is WeakMap<unknown, unknown>} */
+    (val) => val instanceof WeakMap,
+  ],
+  [
+    'weakset',
+    /** @param {*} val @returns {val is WeakSet<unknown>} */
+    (val) => val instanceof WeakSet,
+  ],
+  [
+    'promise',
+    /** @param {*} val @returns {val is Promise<unknown>} */
+    (val) => val instanceof Promise,
+  ],
+]);
 
-  return elemBottom <= viewportBottom && elemTop >= viewportTop;
+if (isBrowser) {
+  extendObjType([
+    [
+      'htmlelement',
+      /** @param {*} val @returns {val is HTMLElement} */
+      (val) => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement,
+    ],
+  ]);
 }
 
+extendObjType([
+  [
+    'object',
+    /** @param {*} val @returns {val is Record<string | number | symbol, unknown>} */
+    (val) => isJsonObject(val),
+  ],
+]);
+
 ;// ./src/v1/basics/fullScreen.mjs
 /**
  * Checks if the document is currently in fullscreen mode.
@@ -9172,6 +9319,7 @@ export default KeyPressHandler;
 
 
 
+
 })();
 
 window.TinyBasicsEs = __webpack_exports__;