tiny-essentials 1.27.1 → 1.28.1

package/dist/v1/basics/mediaContent.cjs

@@ -104,6 +104,22 @@
 
 //////////////////////////////////////////////////////////////////
 
+const checkString = (/** @type {string} */ val, /** @type {string} */ name) => {
+  if (typeof val !== 'string')
+    throw new TypeError(`Expected "${name}" to be a string, but received ${typeof val}.`);
+};
+const checkFunction = (/** @type {Function} */ val, /** @type {string} */ name) => {
+  if (typeof val !== 'function')
+    throw new TypeError(`Expected "${name}" to be a function, but received ${typeof val}.`);
+};
+const checkObject = (/** @type {Object<string, any> | null} */ val, /** @type {string} */ name) => {
+  if (typeof val !== 'object' || val === null || Array.isArray(val)) {
+    throw new TypeError(
+      `Expected "${name}" to be a plain object, but received ${val === null ? 'null' : Array.isArray(val) ? 'array' : typeof val}.`,
+    );
+  }
+};
+
 /** @type {Map<string, number>} */
 const _blobCounter = new Map();
 
@@ -145,6 +161,11 @@ class MediaLoadingError extends Error {
    * @param {LoadingErrorStage} stage - The stage where the error occurred.
    */
   constructor(message, url, stage) {
+    checkString(message, 'message');
+    checkString(url, 'url');
+    if (typeof stage !== 'string')
+      throw new TypeError(`Expected "stage" to be a string, but received ${typeof stage}.`);
+
     super(message);
     this.name = 'MediaLoadingError';
     this.url = url;
@@ -159,6 +180,8 @@ class MediaLoadingError extends Error {
  * @private
  */
 const generateSimpleHash = async (str) => {
+  checkString(str, 'str');
+
   const msgUint8 = new TextEncoder().encode(str);
   const hashBuffer = await crypto.subtle.digest('SHA-1', msgUint8);
   const hashArray = Array.from(new Uint8Array(hashBuffer));
@@ -174,9 +197,15 @@ const generateSimpleHash = async (str) => {
  * @param {Uint8Array|string} data
  * @param {string} format
  * @returns {string} The generated Blob URL or original string if already valid.
- * @private
  */
 const convertToBlobUrl = (data, format = 'image/jpeg') => {
+  if (!(data instanceof Uint8Array) && typeof data !== 'string') {
+    throw new TypeError(
+      `Expected "data" to be an instance of Uint8Array or a string, but received ${typeof data}.`,
+    );
+  }
+  checkString(format, 'format');
+
   const createBlobCounter = (/** @type {Blob} */ blob) => {
     const url = URL.createObjectURL(blob);
     const blobUrlUsage = _blobCounter.get(url);
@@ -205,10 +234,11 @@ const convertToBlobUrl = (data, format = 'image/jpeg') => {
  * Asynchronous helper to convert a Blob URL back to Base64 (Date URL) at export time.
  * @param {string} url
  * @returns {Promise<string>}
- * @private
  */
 const blobUrlToBase64 = async (url) => {
-  if (typeof url !== 'string' || !url.startsWith('blob:')) return url;
+  checkString(url, 'url');
+
+  if (!url.startsWith('blob:')) return url;
   try {
     const response = await fetch(url);
     const blob = await response.blob();
@@ -227,9 +257,10 @@ const blobUrlToBase64 = async (url) => {
 /**
  * Safely revokes Blob URLs to prevent memory leaks from createObjectURL.
  * @param {MediaContent} content
- * @private
  */
 const revokeContentUrls = (content) => {
+  checkObject(content, 'content');
+
   if (content && Array.isArray(content.picture)) {
     content.picture.forEach((pic) => {
       if (typeof pic.data === 'string' && pic.data.startsWith('blob:')) {
@@ -248,7 +279,9 @@ const revokeContentUrls = (content) => {
  * @param {boolean} isPartial - If true, properties can be undefined.
  */
 const validateMediaContent = (common, isPartial) => {
-  // Helper to check if the property can be ignored in partial mode
+  checkObject(common, 'common');
+  if (typeof isPartial !== 'boolean') throw new TypeError('Expected "isPartial" to be a boolean.');
+
   const isUndefinedAllowed = (/** @type {any} */ v) => isPartial && typeof v === 'undefined';
 
   const isString = (/** @type {string | null | undefined} */ v) =>
@@ -293,6 +326,8 @@ const validateMediaContent = (common, isPartial) => {
     !isArray(
       common.picture,
       (value) =>
+        value &&
+        typeof value === 'object' &&
         (typeof value.description === 'undefined' || typeof value.description === 'string') &&
         (typeof value.name === 'undefined' || typeof value.name === 'string') &&
         (typeof value.type === 'undefined' || typeof value.type === 'string') &&
@@ -351,10 +386,8 @@ const valMediaContentMetadataPartial = (common) => validateMediaContent(common,
  */
 const extractMediaId3Tags = async (url, parseFile) => {
   // Argument Validation
-  if (typeof url !== 'string')
-    throw new TypeError(`Expected url to be a string, but received ${typeof url}.`);
-  if (typeof parseFile !== 'function')
-    throw new TypeError(`Expected parseFile to be a function, but received ${typeof parseFile}.`);
+  checkString(url, 'url');
+  checkFunction(parseFile, 'parseFile');
 
   try {
     // 1. Download the file from the provided URL
@@ -459,11 +492,20 @@ const parseMediaMetadata = async (
   if (typeof source !== 'string' && !(source instanceof HTMLMediaElement))
     throw new TypeError('Source must be a string or an HTMLMediaElement.');
 
+  checkObject(defaultMetadata, 'defaultMetadata');
+  checkObject(metadata, 'metadata');
+  checkFunction(parseFile, 'parseFile');
+  checkObject(callbacks, 'callbacks');
+
   if (callbacks.onProgress && typeof callbacks.onProgress !== 'function')
     throw new TypeError('callbacks.onProgress must be a function.');
   if (callbacks.onError && typeof callbacks.onError !== 'function')
     throw new TypeError('callbacks.onError must be a function.');
 
+  if (typeof unknownArtist !== 'string' && typeof unknownArtist !== 'function') {
+    throw new TypeError('unknownArtist must be a string or a function returning a string.');
+  }
+
   /** @type {HTMLMediaElement} */
   let audio;
   /** @type {string} */

package/dist/v1/basics/mediaContent.d.mts

@@ -1,90 +1,3 @@
-/**
- * @typedef {string|(() => string)} UnknownArtistGetter
- */
-/**
- * Represents an image attachment template.
- * @template {Uint8Array|string} PictureData
- * @typedef {Object} IPictureTemplate
- * @property {string} format - The MIME type of the image (e.g., 'image/jpeg').
- * @property {PictureData} data - The raw binary data of the image.
- * @property {string} [description] - An optional textual description of the image.
- * @property {string} [type] - The specific type of picture (e.g., 'cover', 'front', 'back').
- * @property {string} [name] - The filename associated with the image.
- */
-/**
- * Represents an image attachment, such as album art.
- * @typedef {IPictureTemplate<string>} IPicture
- */
-/**
- * A numeric structure representing track or disk indexing.
- * @typedef {{no: number|null, of: number|null}} MediaNumber
- */
-/**
- * This metadata structure is modeled template.
- *
- * @template {IPictureTemplate<Uint8Array|string>} IPictureContent
- * @typedef {Object} ContentMetadataTemplate
- * @property {string|null} title - The title of the track.
- * @property {string|null} album - The name of the album.
- * @property {string|null} albumartist - The primary artist of the album.
- * @property {string[]} albumartists - An array of artists associated with the album.
- * @property {string[]} genre - An array of genres associated with the track.
- * @property {string[]} label - The record label.
- * @property {string[]} composer - The composer of the track.
- * @property {number|null} year - The release year.
- * @property {string|null} artist - The primary artist of the track.
- * @property {string[]} artists - An array of artists associated with the track.
- * @property {MediaNumber} disk - Disk information containing the current disk number and total disks.
- * @property {MediaNumber} track - Track information containing the current track number and total tracks.
- * @property {IPictureContent[]} [picture] - An array of picture objects containing album art.
- */
-/**
- * This metadata structure is modeled after the standard output of the
- * `music-metadata@11.13.0` npm package.
- *
- * @typedef {ContentMetadataTemplate<IPicture>} MediaContentMetadata
- */
-/**
- * The core properties required for any content item within the media system.
- * @typedef {Object} MediaContentBase
- * @property {string} id - Unique identifier.
- * @property {string} title - Name of the track/message.
- * @property {string} artist - Artist or speaker name.
- * @property {number} duration - Duration in milliseconds.
- * @property {string} url - Source URL/Path.
- * @property {number} [weight=1] - Probability multiplier for random selection mode.
- */
-/**
- * The final content object used within the media, combining
- * core playback properties with rich metadata.
- *
- * @typedef {MediaContentBase & MediaContentMetadata} MediaContent
- */
-/**
- * A promise that resolves to an object containing the extracted metadata.
- * @callback ParseMediaContentMetadata
- * @param {Blob} data - The raw file blob.
- * @returns {Promise<{ common: Partial<ContentMetadataTemplate<IPictureTemplate<Uint8Array|string>>> }>} A promise resolving to the common metadata properties.
- */
-/**
- * @typedef {Object} LoadingMediaProgress
- * @property {'loading'|'success'} status - The current status of the operation.
- * @property {LoadingProgressStage} stage - The current execution stage.
- * @property {ProgressEvent<EventTarget>} [event] - The current loading event.
- * @property {string} url - The URL being processed.
- */
-/**
- * @typedef {'INITIALIZING'|'DOWNLOADING'|'METADATA_LOADED'|'EXTRACTING_ID3'|'COMPLETE'} LoadingProgressStage
- */
-/**
- * @typedef {'INITIALIZING'|'DOWNLOADING'|'METADATA'|'ID3'|'UNKNOWN'} LoadingErrorStage
- */
-/**
- * @typedef {Object} MediaLoadingErrorData
- * @property {Error} error - The original error object.
- * @property {string} url - The URL that failed.
- * @property {LoadingErrorStage} stage - The stage where it failed.
- */
 /** @type {Map<string, number>} */
 export const _blobCounter: Map<string, number>;
 export function getMediaContentBase(): MediaContentBase;

package/dist/v1/basics/mediaContent.mjs

@@ -87,6 +87,19 @@
  * @property {LoadingErrorStage} stage - The stage where it failed.
  */
 //////////////////////////////////////////////////////////////////
+const checkString = (/** @type {string} */ val, /** @type {string} */ name) => {
+    if (typeof val !== 'string')
+        throw new TypeError(`Expected "${name}" to be a string, but received ${typeof val}.`);
+};
+const checkFunction = (/** @type {Function} */ val, /** @type {string} */ name) => {
+    if (typeof val !== 'function')
+        throw new TypeError(`Expected "${name}" to be a function, but received ${typeof val}.`);
+};
+const checkObject = (/** @type {Object<string, any> | null} */ val, /** @type {string} */ name) => {
+    if (typeof val !== 'object' || val === null || Array.isArray(val)) {
+        throw new TypeError(`Expected "${name}" to be a plain object, but received ${val === null ? 'null' : Array.isArray(val) ? 'array' : typeof val}.`);
+    }
+};
 /** @type {Map<string, number>} */
 export const _blobCounter = new Map();
 /** @returns {MediaContentBase} */
@@ -125,6 +138,10 @@ export class MediaLoadingError extends Error {
      * @param {LoadingErrorStage} stage - The stage where the error occurred.
      */
     constructor(message, url, stage) {
+        checkString(message, 'message');
+        checkString(url, 'url');
+        if (typeof stage !== 'string')
+            throw new TypeError(`Expected "stage" to be a string, but received ${typeof stage}.`);
         super(message);
         this.name = 'MediaLoadingError';
         this.url = url;
@@ -138,6 +155,7 @@ export class MediaLoadingError extends Error {
  * @private
  */
 export const generateSimpleHash = async (str) => {
+    checkString(str, 'str');
     const msgUint8 = new TextEncoder().encode(str);
     const hashBuffer = await crypto.subtle.digest('SHA-1', msgUint8);
     const hashArray = Array.from(new Uint8Array(hashBuffer));
@@ -152,9 +170,12 @@ export const generateSimpleHash = async (str) => {
  * @param {Uint8Array|string} data
  * @param {string} format
  * @returns {string} The generated Blob URL or original string if already valid.
- * @private
  */
 export const convertToBlobUrl = (data, format = 'image/jpeg') => {
+    if (!(data instanceof Uint8Array) && typeof data !== 'string') {
+        throw new TypeError(`Expected "data" to be an instance of Uint8Array or a string, but received ${typeof data}.`);
+    }
+    checkString(format, 'format');
     const createBlobCounter = (/** @type {Blob} */ blob) => {
         const url = URL.createObjectURL(blob);
         const blobUrlUsage = _blobCounter.get(url);
@@ -182,10 +203,10 @@ export const convertToBlobUrl = (data, format = 'image/jpeg') => {
  * Asynchronous helper to convert a Blob URL back to Base64 (Date URL) at export time.
  * @param {string} url
  * @returns {Promise<string>}
- * @private
  */
 export const blobUrlToBase64 = async (url) => {
-    if (typeof url !== 'string' || !url.startsWith('blob:'))
+    checkString(url, 'url');
+    if (!url.startsWith('blob:'))
         return url;
     try {
         const response = await fetch(url);
@@ -205,9 +226,9 @@ export const blobUrlToBase64 = async (url) => {
 /**
  * Safely revokes Blob URLs to prevent memory leaks from createObjectURL.
  * @param {MediaContent} content
- * @private
  */
 export const revokeContentUrls = (content) => {
+    checkObject(content, 'content');
     if (content && Array.isArray(content.picture)) {
         content.picture.forEach((pic) => {
             if (typeof pic.data === 'string' && pic.data.startsWith('blob:')) {
@@ -228,7 +249,9 @@ export const revokeContentUrls = (content) => {
  * @param {boolean} isPartial - If true, properties can be undefined.
  */
 const validateMediaContent = (common, isPartial) => {
-    // Helper to check if the property can be ignored in partial mode
+    checkObject(common, 'common');
+    if (typeof isPartial !== 'boolean')
+        throw new TypeError('Expected "isPartial" to be a boolean.');
     const isUndefinedAllowed = (/** @type {any} */ v) => isPartial && typeof v === 'undefined';
     const isString = (/** @type {string | null | undefined} */ v) => isUndefinedAllowed(v) || typeof v === 'string' || v === null;
     const isNumber = (/** @type {number | null | undefined}} */ v) => isUndefinedAllowed(v) || typeof v === 'number' || v === null;
@@ -263,7 +286,9 @@ const validateMediaContent = (common, isPartial) => {
         throw new TypeError('Invalid metadata: "composer" must be an array of string.');
     if (!isArray(common.artists, (value) => typeof value === 'string'))
         throw new TypeError('Invalid metadata: "artists" must be an array of string.');
-    if (!isArray(common.picture, (value) => (typeof value.description === 'undefined' || typeof value.description === 'string') &&
+    if (!isArray(common.picture, (value) => value &&
+        typeof value === 'object' &&
+        (typeof value.description === 'undefined' || typeof value.description === 'string') &&
         (typeof value.name === 'undefined' || typeof value.name === 'string') &&
         (typeof value.type === 'undefined' || typeof value.type === 'string') &&
         typeof value.format === 'string' &&
@@ -313,10 +338,8 @@ export const valMediaContentMetadataPartial = (common) => validateMediaContent(c
  */
 export const extractMediaId3Tags = async (url, parseFile) => {
     // Argument Validation
-    if (typeof url !== 'string')
-        throw new TypeError(`Expected url to be a string, but received ${typeof url}.`);
-    if (typeof parseFile !== 'function')
-        throw new TypeError(`Expected parseFile to be a function, but received ${typeof parseFile}.`);
+    checkString(url, 'url');
+    checkFunction(parseFile, 'parseFile');
     try {
         // 1. Download the file from the provided URL
         const response = await fetch(url);
@@ -405,10 +428,17 @@ export const parseMediaMetadata = async (source, defaultMetadata = {}, metadata
     // Argument Validation
     if (typeof source !== 'string' && !(source instanceof HTMLMediaElement))
         throw new TypeError('Source must be a string or an HTMLMediaElement.');
+    checkObject(defaultMetadata, 'defaultMetadata');
+    checkObject(metadata, 'metadata');
+    checkFunction(parseFile, 'parseFile');
+    checkObject(callbacks, 'callbacks');
     if (callbacks.onProgress && typeof callbacks.onProgress !== 'function')
         throw new TypeError('callbacks.onProgress must be a function.');
     if (callbacks.onError && typeof callbacks.onError !== 'function')
         throw new TypeError('callbacks.onError must be a function.');
+    if (typeof unknownArtist !== 'string' && typeof unknownArtist !== 'function') {
+        throw new TypeError('unknownArtist must be a string or a function returning a string.');
+    }
     /** @type {HTMLMediaElement} */
     let audio;
     /** @type {string} */

package/dist/v1/basics/objChecker.cjs

@@ -4,20 +4,22 @@
  * Counts the number of elements in an array or the number of properties in an object.
  *
  * @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.
+ * @returns {number} - The count of items (array elements or object keys).
+ * @throws {TypeError} If the input is neither an array nor a pure object.
  *
  * @example
  * countObj([1, 2, 3]); // 3
  * countObj({ a: 1, b: 2 }); // 2
- * countObj('not an object'); // 0
+ * countObj('not an object'); // Throws TypeError
  */
 function countObj(obj) {
+  if (!Array.isArray(obj) && !isJsonObject(obj))
+    throw new TypeError('Argument must be either an Array or a pure JSON Object.');
+
   // Is Array
   if (Array.isArray(obj)) return obj.length;
   // Object
-  if (isJsonObject(obj)) return Object.keys(obj).length;
-  // Nothing
-  return 0;
+  return Object.keys(obj).length;
 }
 
 /**

package/dist/v1/basics/objChecker.d.mts

@@ -2,12 +2,13 @@
  * Counts the number of elements in an array or the number of properties in an object.
  *
  * @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.
+ * @returns {number} - The count of items (array elements or object keys).
+ * @throws {TypeError} If the input is neither an array nor a pure object.
  *
  * @example
  * countObj([1, 2, 3]); // 3
  * countObj({ a: 1, b: 2 }); // 2
- * countObj('not an object'); // 0
+ * countObj('not an object'); // Throws TypeError
  */
 export function countObj(obj: Array<any> | Record<string | number | symbol, any>): number;
 /**

package/dist/v1/basics/objChecker.mjs

@@ -2,22 +2,22 @@
  * Counts the number of elements in an array or the number of properties in an object.
  *
  * @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.
+ * @returns {number} - The count of items (array elements or object keys).
+ * @throws {TypeError} If the input is neither an array nor a pure object.
  *
  * @example
  * countObj([1, 2, 3]); // 3
  * countObj({ a: 1, b: 2 }); // 2
- * countObj('not an object'); // 0
+ * countObj('not an object'); // Throws TypeError
  */
 export function countObj(obj) {
+    if (!Array.isArray(obj) && !isJsonObject(obj))
+        throw new TypeError('Argument must be either an Array or a pure JSON Object.');
     // Is Array
     if (Array.isArray(obj))
         return obj.length;
     // Object
-    if (isJsonObject(obj))
-        return Object.keys(obj).length;
-    // Nothing
-    return 0;
+    return Object.keys(obj).length;
 }
 /**
  * Determines whether a given value is a pure JSON object (plain object).

package/dist/v1/basics/objFilter.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-var buffer = require('buffer');
 var objChecker = require('./objChecker.cjs');
 
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
@@ -34,26 +33,48 @@ const typeValidator = {
  * 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.
+ * - 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
+ * htmlElement2: val => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement
  * });
  *
  * @example
  * extendObjType([
- *   ['alpha', val => typeof val === 'string'],
- *   ['beta', val => Array.isArray(val)]
+ * ['alpha', val => typeof val === 'string'],
+ * ['beta', val => Array.isArray(val)]
  * ]);
  */
 function extendObjType(newItems, index) {
+  if (typeof newItems !== 'object' || newItems === null) {
+    throw new TypeError("Argument 'newItems' must be an object or an array.");
+  }
+
+  if (typeof index !== 'undefined' && typeof index !== 'number') {
+    throw new TypeError("Argument 'index' must be a number.");
+  }
+
   const added = [];
 
   const entries = Array.isArray(newItems) ? newItems : Object.entries(newItems);
-  for (const [key, fn] of entries) {
+
+  for (const entry of entries) {
+    if (!Array.isArray(entry) || entry.length < 2) {
+      throw new TypeError("Each item in 'newItems' array must be a [key, function] pair.");
+    }
+
+    const [key, fn] = entry;
+
+    if (typeof key !== 'string') {
+      throw new TypeError('Validator key must be a string.');
+    }
+    if (typeof fn !== 'function') {
+      throw new TypeError(`Validator for key '${key}' must be a function.`);
+    }
+
     if (!typeValidator.items.hasOwnProperty(key)) {
       // @ts-ignore
       typeValidator.items[key] = fn;
@@ -87,10 +108,17 @@ function extendObjType(newItems, index) {
  *
  * @example
  * reorderObjTypeOrder([
- *   'string', 'number', 'array', 'object'
+ * 'string', 'number', 'array', 'object'
  * ]);
  */
 function reorderObjTypeOrder(newOrder) {
+  if (!Array.isArray(newOrder)) {
+    throw new TypeError("Argument 'newOrder' must be an array of strings.");
+  }
+  if (!newOrder.every((item) => typeof item === 'string')) {
+    throw new TypeError("All elements in 'newOrder' must be strings.");
+  }
+
   const currentOrder = [...typeValidator.order]; // shallow clone
 
   // All keys in newOrder must exist in currentOrder
@@ -148,7 +176,7 @@ const getType = (val) => {
  * @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`.
+ * the type string if no type is provided, or `null` if the object is `undefined`.
  *
  * @example
  * objType([], 'array'); // true
@@ -158,6 +186,10 @@ const getType = (val) => {
  */
 function objType(obj, type) {
   if (typeof obj === 'undefined') return null;
+  if (typeof type !== 'undefined' && typeof type !== 'string') {
+    throw new TypeError("Argument 'type' must be a string.");
+  }
+
   const result = getType(obj);
   if (typeof type === 'string') return result === type.toLowerCase();
   return result;
@@ -245,16 +277,6 @@ extendObjType([
   ],
 ]);
 
-if (!isBrowser) {
-  extendObjType([
-    [
-      'buffer',
-      /** @param {*} val @returns {val is Buffer} */
-      (val) => typeof buffer.Buffer !== 'undefined' && buffer.Buffer.isBuffer(val),
-    ],
-  ]);
-}
-
 if (isBrowser) {
   extendObjType([
     [

package/dist/v1/basics/objFilter.d.mts

@@ -7,19 +7,19 @@
  * 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.
+ * - 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
+ * htmlElement2: val => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement
  * });
  *
  * @example
  * extendObjType([
- *   ['alpha', val => typeof val === 'string'],
- *   ['beta', val => Array.isArray(val)]
+ * ['alpha', val => typeof val === 'string'],
+ * ['beta', val => Array.isArray(val)]
  * ]);
  */
 export function extendObjType(newItems: ExtendObjType | ExtendObjTypeArray, index?: number): string[];
@@ -33,7 +33,7 @@ export function extendObjType(newItems: ExtendObjType | ExtendObjTypeArray, inde
  *
  * @example
  * reorderObjTypeOrder([
- *   'string', 'number', 'array', 'object'
+ * 'string', 'number', 'array', 'object'
  * ]);
  */
 export function reorderObjTypeOrder(newOrder: string[]): boolean;
@@ -50,7 +50,7 @@ export function cloneObjTypeOrder(): 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`.
+ * the type string if no type is provided, or `null` if the object is `undefined`.
  *
  * @example
  * objType([], 'array'); // true