{"version":3,"file":"logger-DMgTNA4q.cjs","names":[],"sources":["../src/predicates/is/isBoolean.ts","../src/predicates/is/isFunction.ts","../src/predicates/is/isNil.ts","../src/predicates/is/isArray.ts","../src/predicates/is/isObject.ts","../src/predicates/is/isPlainObject.ts","../src/predicates/is/isString.ts","../src/predicates/is/isNonEmptyString.ts","../src/predicates/is/isNumberObject.ts","../src/predicates/is/isNaN.ts","../src/predicates/is/isNull.ts","../src/predicates/is/isError.ts","../src/predicates/is/isBuffer.ts","../src/predicates/is/isStringObject.ts","../src/predicates/is/isBooleanObject.ts","../src/predicates/is/isObjectOrArray.ts","../src/predicates/is/isInfinityNumber.ts","../src/predicates/is/isNonEmptyArray.ts","../src/predicates/is/isSet.ts","../src/strings/cases/_private/case.utils.ts","../src/strings/cases/slugify.ts","../src/strings/cases/toDotCase.ts","../src/strings/cases/toCamelCase.ts","../src/strings/cases/toKebabCase.ts","../src/strings/cases/toSnakeCase.ts","../src/strings/cases/toLowerCase.ts","../src/strings/cases/toPascalCase.ts","../src/strings/cases/toPascalCaseSpace.ts","../src/predicates/type/_private/getPreciseType.utils.ts","../src/predicates/type/getPreciseType.ts","../src/assertions/_private/assertIs.ts","../src/assertions/booleans/assertIsBoolean.ts","../src/_private/logger.ts"],"sourcesContent":["/** ----------------------------------------------------------\n * * ***Type guard: `isBoolean`.***\n * -----------------------------------------------------------\n * **Checks if a value is of type **[`boolean`](https://developer.mozilla.org/en-US/docs/Glossary/Boolean/JavaScript)**.**\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a `boolean`, otherwise `false`.\n *\n * ---\n * @example\n * isBoolean(true);\n * // ➔ true\n * isBoolean(false);\n * // ➔ true\n * isBoolean(\"true\");\n * // ➔ false\n */\nexport const isBoolean = (value: unknown): value is boolean => {\n  return typeof value === \"boolean\";\n};\n","import type { AnyFunction } from \"@rzl-zone/ts-types-plus\";\n\n/** ----------------------------------------------------------\n * * ***Type guard: `isFunction`.***\n * -----------------------------------------------------------\n * **Checks if a value is a function.**\n *\n * ---\n * - **Behavior:**\n *     - Uses `typeof value === \"function\"` for strict type checking.\n *     - Safe alternative to `Function` type (doesn't trigger ESLint warning).\n *     - Supports TypeScript type narrowing with `value is (...args: any[]) => any`.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if the value is a function.\n *\n * ---\n * @example\n * isFunction(() => {});\n * // ➔ true\n * isFunction(async () => {});\n * // ➔ true\n * isFunction(null);\n * // ➔ false\n * isFunction({});\n * // ➔ false\n */\nexport const isFunction = (value: unknown): value is AnyFunction => {\n  return typeof value === \"function\";\n};\n","/** ---------------------------------------------------------\n * * ***Type guard: `isNil`.***\n * ----------------------------------------------------------\n * **Checks if a value is **[`null`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/null)** or **[`undefined`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)**.**\n *\n * ---\n * - **Behavior:**\n *     - Narrows type to `null` or `undefined` when true.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is `null` or `undefined`, otherwise `false`.\n *\n * ---\n * @example\n * isNil(null);\n * // ➔ true\n * isNil(undefined);\n * // ➔ true\n * isNil(void 0);\n * // ➔ true\n * isNil(NaN);\n * // ➔ false\n */\nexport const isNil = (value: unknown): value is null | undefined => {\n  return value == null;\n};\n","import type { ArrayFallback } from \"@/_private/types.arrays\";\n\n/** ----------------------------------------------------------\n * * ***Type guard: `isArray`.***\n * -----------------------------------------------------------\n * **Checks if a value is an ***[`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)***.**\n *\n * - **Behavior:**\n *     - Uses ***[`Array.isArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)*** for reliable and safe type checking.\n *     - Supports TypeScript **type narrowing** using `value is T[]`.\n *     - Handles edge cases like `null`, `undefined`, and non-array objects.\n *\n * @template T - The expected type of array elements.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is an `array`, otherwise `false`.\n *\n * @example\n * isArray([1, 2, 3]);\n * // ➔ true\n * isArray([]);\n * // ➔ true\n * isArray(\"hello\");\n * // ➔ false\n * isArray({ key: \"value\" });\n * // ➔ false\n * isArray(null);\n * // ➔ false\n * isArray(undefined);\n * // ➔ false\n */\nexport function isArray(value: []): value is [];\nexport function isArray<T>(value: T): value is ArrayFallback<T>;\nexport function isArray(value: unknown): value is unknown[];\nexport function isArray(value: unknown): boolean {\n  return Array.isArray(value);\n}\n","import type { AnObjectNonArray, IsArray } from \"@rzl-zone/ts-types-plus\";\nimport type { IsHasKeysObject } from \"./_private/_types\";\n\nimport { isNil } from \"./isNil\";\nimport { isArray } from \"./isArray\";\n\ntype IsObject<T> = unknown extends T\n  ? T & Record<PropertyKey, unknown>\n  : T extends object\n    ? T extends AnObjectNonArray\n      ? T\n      : IsHasKeysObject<T> extends false\n        ? T & Record<PropertyKey, unknown>\n        : IsArray<T> extends true\n          ? Exclude<T, unknown[]>\n          : T\n    : never;\n\n/** ---------------------------------------------------------\n * * ***Type guard: `isObject`.***\n * ----------------------------------------------------------\n * **Checks if a value is an **object** (excluding `null` and `arrays`).**\n *\n * ---\n * - #### *Behavior:*\n *      - #### Returns `true` for any non-null object (arrays excluded), including:\n *           - Plain-objects (`{}`, `Object.create(null)`).\n *           - Custom class instances.\n *           - Built-ins:\n *              - `Date`, `RegExp`, `Error`, `URL`, `URLSearchParams`.\n *           - Collections:\n *              - `Map`, `Set`, `WeakMap`, `WeakSet`.\n *           - Binary/typed data:\n *              - `ArrayBuffer`, `DataView`, typed arrays (`Uint8Array`, `Int32Array`, etc.).\n *           - DOM/Node objects:\n *              - `HTMLElement`, `DocumentFragment`, etc.\n *           - Proxies (wrapping any object type).\n *           ---\n *      - #### Returns `false` for:\n *           - `null`.\n *           - Arrays (`[]`, `new Array()`).\n *           - Functions (regular functions, arrow functions, class constructors).\n *           - Primitives:\n *              - `string`, `number`, `boolean`, `symbol`, `bigint`.\n *           - Boxed primitives:\n *              - `new String()`, `new Number()`, `new Boolean()`.\n *           - `undefined` (including `NaN`, which is a primitive number).\n *\n * ---\n * - **Note:**\n *     - If you specifically need to check for ***plain-objects*** only, use ***`isPlainObject` utility function*** instead.\n *     - If you specifically need to check for ***object***, ***plain-objects***, and include ***array***, use ***`isObjectOrArray` utility function*** instead.\n *\n * ---\n * @template T - The type of the value being checked.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a ***plain-objects***, otherwise `false`.\n *\n * ---\n * @example\n * isObject({});\n * // ➔ true\n * isObject(Object.create(null));\n * // ➔ true\n * isObject(new Date());\n * // ➔ true\n * isObject(new Map());\n * // ➔ true\n * isObject(new Uint8Array());\n * // ➔ true\n * isObject(new String(\"x\"));\n * // ➔ true\n * isObject([]);\n * // ➔ false\n * isObject(null);\n * // ➔ false\n * isObject(undefined);\n * // ➔ false\n * isObject(123);\n * // ➔ false\n * isObject(() => {});\n * // ➔ false\n */\nexport function isObject<T extends object>(value: T): value is IsObject<T>;\nexport function isObject(value: unknown): value is Record<PropertyKey, unknown>;\nexport function isObject(value: unknown): boolean {\n  return typeof value === \"object\" && !isNil(value) && !isArray(value);\n}\n","import type { NonPlainObject } from \"@rzl-zone/ts-types-plus\";\n\nimport { isObject } from \"@/predicates/is/isObject\";\nimport type { IsHasKeysObject } from \"./_private/_types\";\n\n/** ----------------------------------------------------------\n * * ***Utility type: `IsPlainObjectResult`.***\n * -----------------------------------------------------------\n * **Represents the inferred type after asserting a value is a **plain object**.**\n *\n * ---\n * - **Behavior:**\n *     - If `T` is `unknown`, the resulting type is `Record<PropertyKey, unknown> & T`.\n *     - If `T` is an object:\n *         - If it is a non-plain object (class instance, built-in object, etc.), the result is `never`.\n *         - If it has no keys (`IsHasKeysObject<T>` checked by **{@link IsHasKeysObject|`IsHasKeysObject`}** is false), the result is `Record<PropertyKey, unknown> & T`.\n *         - Otherwise, the result is `T` itself.\n *     - For any other types, the result is `never`.\n *\n * ---\n * @template T - The input type to be asserted as a plain object.\n *\n * ---\n * @example\n * ```ts\n * type A = IsPlainObjectResult<unknown>;\n * // ➔ Record<PropertyKey, unknown> & unknown\n * type B = IsPlainObjectResult<{}>;\n * // ➔ Record<PropertyKey, unknown> & {}\n * type C = IsPlainObjectResult<{ foo: string }>;\n * // ➔ { foo: string }\n * type D = IsPlainObjectResult<Date>;\n * // ➔ never\n * ```\n */\nexport type IsPlainObjectResult<T> = unknown extends T\n  ? Record<PropertyKey, unknown> & T\n  : T extends object\n    ? T extends NonPlainObject\n      ? never\n      : IsHasKeysObject<T> extends false\n        ? Record<PropertyKey, unknown> & T\n        : T\n    : Extract<T, Record<PropertyKey, unknown>>;\n\n/** ----------------------------------------------------------\n * * ***Type guard: `isPlainObject`.***\n * -----------------------------------------------------------\n * **Checks if a value is a **plain-object**.**\n *\n * - #### A plain object is:\n *      - Created by the `Object` constructor, or.\n *      - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).\n * ---\n * - #### *Behavior:*\n *      - #### Returns `true` for:\n *          - Empty object literals: `{}`.\n *          - Objects with null prototype: `Object.create(null)`.\n *          ---\n *      - #### Returns `false` for:\n *          - Arrays (`[]`, `new Array()`).\n *          - Functions (regular, arrow, or class constructors).\n *          - Built-in objects: `Date`, `RegExp`, `Error`, `Map`, `Set`, `WeakMap`, `WeakSet`.\n *          - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`.\n *          - `null` or `undefined`.\n *          - Symbols.\n *          - Class instances.\n *\n * ---\n * @template T - The type of the value being checked.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if `value` is a `plain-object`, otherwise `false`.\n *\n * ---\n * @example\n * isPlainObject({});\n * // ➔ true\n * isPlainObject(Object.create(null));\n * // ➔ true\n * isPlainObject(null);\n * // ➔ false\n * isPlainObject(() => {});\n * // ➔ false\n * isPlainObject([1, 2, 3]);\n * // ➔ false\n * isPlainObject(new Date());\n * // ➔ false\n * isPlainObject(new MyClass());\n * // ➔ false\n * isPlainObject(new String(\"x\"));\n * // ➔ false\n */\nexport function isPlainObject<T>(value: T): value is IsPlainObjectResult<T>;\nexport function isPlainObject<T>(\n  value: T\n): value is NonNullable<Extract<T, Record<PropertyKey, unknown>>>;\nexport function isPlainObject(value: unknown) {\n  if (!isObject(value)) return false;\n\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n","/** ---------------------------------------------------------\n * * ***Type guard: `isString`.***\n * ----------------------------------------------------------\n * **Checks if a value is of type\n * **[`string`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**.**\n *\n * ---\n * - **Behavior:**\n *     - Narrows type to `string` when true.\n *     - Uses the `typeof` operator for strict checking.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a string, otherwise `false`.\n *\n * ---\n * @example\n * 1. #### Basic Usage:\n *    ```ts\n *    isString(\"hello\");\n *    // ➔ true\n *    isString(123);\n *    // ➔ false\n *    ```\n *    ---\n * 2. #### Usage in type narrowing:\n *    ```ts\n *    const value: unknown = getValue();\n *    if (isString(value)) {\n *      // TypeScript now knows `value` is a string\n *      console.log(value.toUpperCase());\n *    }\n *    ```\n */\nexport const isString = (value: unknown): value is string => {\n  return typeof value === \"string\";\n};\n","import { isString } from \"./isString\";\nimport { isBoolean } from \"./isBoolean\";\nimport { isPlainObject } from \"./isPlainObject\";\n\ntype IsNonEmptyStringOptions = {\n  /** ----------------------------------------------------------\n   * * ***Whether to trim leading and trailing whitespace before checking.***\n   * -----------------------------------------------------------\n   *\n   * @note\n   * Non-boolean values fall back to the default behavior.\n   *\n   * ---\n   * @default true\n   */\n  trim?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Type guard: `isNonEmptyString`.***\n * -----------------------------------------------------------\n * **Checks if a value is a **non-empty string**.**\n *\n * ---\n * @description\n * Determines whether the given `value` is a string containing at least one non-whitespace character, with optional trimming behavior.\n *\n * ---\n * - **Behavior:**\n *     - Ensures the value is a string using ***`isString` utility function***.\n *     - Optionally trims whitespace before checking (`trim` defaults to `true`).\n *     - Narrows type to `string` when true.\n *\n * ---\n * @param {*} value - The value to test.\n * @param {IsNonEmptyStringOptions} [options]\n *        Optional settings (non-plain object values are ignored and replaced with default options).\n * @param {boolean} options.trim\n *        If `true`, trims the string before checking (non-boolean values fall back to the default behavior), defaults: `true`.\n *\n * ---\n * @returns {boolean} Return `true` if `value` is a non-empty string, otherwise `false`.\n *\n * ---\n * @example\n * isNonEmptyString(\"hello\");\n * // ➔ true\n * isNonEmptyString(\"   \", { trim: true });\n * // ➔ false\n * isNonEmptyString(\"   \", { trim: false });\n * // ➔ true\n * isNonEmptyString(\"\");\n * // ➔ false\n * isNonEmptyString(123);\n * // ➔ false\n * isNonEmptyString(undefined);\n * // ➔ false\n * isNonEmptyString(null);\n * // ➔ false\n * isNonEmptyString({});\n * // ➔ false\n * isNonEmptyString([]);\n * // ➔ false\n */\nexport const isNonEmptyString = (\n  value: unknown,\n  options?: IsNonEmptyStringOptions\n): value is string => {\n  if (!isString(value)) return false;\n  if (!isPlainObject(options)) options = {};\n\n  const trim = isBoolean(options.trim) ? options.trim : true;\n\n  const str = trim ? value.trim() : value;\n\n  return str.length > 0;\n};\n","/* eslint-disable @typescript-eslint/no-wrapper-object-types */\nimport { isObject } from \"./isObject\";\n\n/** ----------------------------------------------------\n * * ***Type guard: `isNumberObject`.***\n * -----------------------------------------------------\n * **Checks if a value is a **`Number` object wrapper**\n * (`new Number(...)`), not a primitive number.**\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is a `Number` object.\n *\n * ---\n * @example\n * isNumberObject(new Number(42));\n * // ➔ true\n * isNumberObject(42);\n * // ➔ false\n */\nexport const isNumberObject = (value: unknown): value is Number => {\n  return (\n    isObject(value) &&\n    Object.prototype.toString.call(value) === \"[object Number]\"\n  );\n};\n","import { isNumberObject } from \"./isNumberObject\";\n\n/** ----------------------------------------------------\n * * ***Type guard: `isNaN`.***\n * -----------------------------------------------------\n * **Checks if a value is [`NaN`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN).**\n *\n * ---\n * - **Note:**\n *     - This method is based on\n *       [`Number.isNaN`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN)\n *       and is **not** the same as the global\n *       [`isNaN`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN),\n *       which returns `true` for `undefined` and other non-number values.\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n *\n * ---\n * @example\n * import * as RzlUtilsJs from \"@rzl-zone/utils-js/predicates\";\n *\n * RzlUtilsJs.isNaN(NaN);\n * // ➔ true\n * RzlUtilsJs.isNaN(new Number(NaN));\n * // ➔ true\n * RzlUtilsJs.isNaN(undefined);\n * // ➔ false\n *\n * // This global isNaN:\n * isNaN(undefined);\n * // ➔ true\n */\nexport const isNaN = (value: unknown): boolean => {\n  return typeof value === \"number\"\n    ? Number.isNaN(value)\n    : isNumberObject(value) && Number.isNaN(value.valueOf());\n};\n","/** ---------------------------------------------------------\n * * ***Type guard: `isNull`.***\n * ----------------------------------------------------------\n * **Checks if a value is **[`null`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/null)**.**\n *\n * ---\n * - **Behavior:**\n *     - Narrows type to `null` when true.\n *     - Strictly compares the value against `null`.\n *\n * ---\n * @param {*} val - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is `null`, otherwise `false`.\n *\n * ---\n * @example\n * isNull(null);\n * // ➔ true\n * isNull(0);\n * // ➔ false\n * isNull(undefined);\n * // ➔ false\n */\nexport const isNull = (val: unknown): val is null => val === null;\n","/** ----------------------------------------------------------\n * * ***Type guard: `isError`.***\n * -----------------------------------------------------------\n * **Checks whether the given value is an ****[`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)** object**.**\n *\n * ---\n * - **Behavior:**\n *     - Ensures that the provided value is a valid JavaScript error instance.\n *     - Useful in TypeScript for narrowing types during error handling.\n *\n * ---\n * @param {*} error - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is instance of **[`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)**, else `false`.\n *\n * ---\n * @example\n * isError(new Error(\"Something went wrong\"));\n * // ➔ true\n * isError(\"Error message\");\n * // ➔ false\n * isError(null);\n * // ➔ false\n */\nexport const isError = (error: unknown): error is Error => {\n  return (\n    Object.prototype.toString.call(error) === \"[object Error]\" ||\n    error instanceof Error\n  );\n};\n","/** ---------------------------------------------------------\n * * ***Type guard: `isBuffer`.***\n * ----------------------------------------------------------\n * **Checks if a value is a *****{@link Buffer | `Node.js - Buffer`}***** instance.**\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is a `Buffer`, else `false`.\n *\n * ---\n * @example\n * isBuffer(new Buffer(2));\n * // ➔ true\n * isBuffer(Buffer.alloc(10));\n * // ➔ true\n * isBuffer(Buffer.from('foo'));\n * // ➔ true\n * isBuffer([]);\n * // ➔ false\n * isBuffer('a string');\n * // ➔ false\n * isBuffer(new Uint8Array(1024));\n * // ➔ false\n */\nexport const isBuffer = (value: unknown): value is Buffer => {\n  return (\n    typeof Buffer !== \"undefined\" &&\n    typeof Buffer.isBuffer === \"function\" &&\n    Buffer.isBuffer(value)\n  );\n};\n","/* eslint-disable @typescript-eslint/no-wrapper-object-types */\nimport { isObject } from \"./isObject\";\n\n/** ----------------------------------------------------\n * * ***Type guard: `isStringObject`.***\n * -----------------------------------------------------\n * **Checks if a value is a **`String` object wrapper**\n * (`new String(...)`), not a primitive string.**\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is a `String` object.\n *\n * ---\n * @example\n * isStringObject(new String(\"hello\"));\n * // ➔ true\n * isStringObject(\"hello\");\n * // ➔ false\n */\nexport const isStringObject = (value: unknown): value is String => {\n  return (\n    isObject(value) &&\n    Object.prototype.toString.call(value) === \"[object String]\"\n  );\n};\n","/* eslint-disable @typescript-eslint/no-wrapper-object-types */\nimport { isObject } from \"./isObject\";\n\n/** ----------------------------------------------------\n * * ***Type guard: `isBooleanObject`.***\n * -----------------------------------------------------\n * **Checks if a value is a **`Boolean` object wrapper**\n * (`new Boolean(...)`), not a primitive boolean.**\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {value is Boolean} Returns `true` if `value` is a `Boolean` object.\n *\n * ---\n * @example\n * isBooleanObject(new Boolean(true));\n * // ➔ true\n * isBooleanObject(true);\n * // ➔ false\n */\nexport const isBooleanObject = (value: unknown): value is Boolean => {\n  return (\n    isObject(value) &&\n    Object.prototype.toString.call(value) === \"[object Boolean]\"\n  );\n};\n","import type {\n  AnObjectNonArray,\n  Extends,\n  IsNever,\n  OrArr\n} from \"@rzl-zone/ts-types-plus\";\n\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport type { IsHasKeysObject } from \"./_private/_types\";\n\ntype IsObjectOrArray<T> =\n  OrArr<\n    [IsNever<T>, Extends<T, Record<PropertyKey, unknown>>, Extends<unknown, T>]\n  > extends true\n    ? T & Record<PropertyKey, unknown> & unknown[]\n    : T extends object\n      ? T extends unknown[]\n        ? T\n        : T extends AnObjectNonArray\n          ? T\n          : IsHasKeysObject<T> extends false\n            ? T & Record<PropertyKey, unknown>\n            : T\n      : Extract<T, Record<PropertyKey, unknown> & unknown[]>;\n\n/** ---------------------------------------------------------\n * * ***Type guard: `isObjectOrArray`.***\n * ----------------------------------------------------------\n * **Checks if a value is an **object** or an **array**.**\n *\n * ---\n * - #### *Behavior:*\n *      - #### Returns `true` for:\n *          - Plain objects (`{}`, `Object.create(null)`).\n *          - Custom objects.\n *          - Arrays (`[]`, `[1,2,3]`).\n *      ---\n *      - #### Returns `false` for:\n *          - `null`.\n *          - `undefined`.\n *          - Primitives:\n *             - `string`.\n *             - `number`.\n *             - `boolean`.\n *             - `symbol`.\n *             - `bigint`.\n *          - Functions.\n *\n * ---\n * @template T - The type of the value being checked.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is an `object` or `array`.\n *\n * ---\n * @example\n * isObjectOrArray([1,2,3]);\n * // ➔ true\n * isObjectOrArray({ name: \"Alice\" });\n * // ➔ true\n * isObjectOrArray(null);\n * // ➔ false\n * isObjectOrArray(undefined);\n * // ➔ false\n * isObjectOrArray(\"hello\");\n * // ➔ false\n */\nexport function isObjectOrArray(value: []): value is [];\nexport function isObjectOrArray<T>(value: T): value is IsObjectOrArray<T>;\nexport function isObjectOrArray<T>(value: T): boolean {\n  return isArray(value) || isObject(value);\n}\n","import { isNumberObject } from \"./isNumberObject\";\n\n/** ----------------------------------------------------\n * * ***Type guard: `isInfinityNumber`.***\n * -----------------------------------------------------\n * **Checks if a value is positive or negative\n * [`Infinity`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity).**\n *\n * ---\n * - **Note:**\n *     - This is stricter than the global `isFinite`,\n *       because it only returns `true` for `Infinity` or `-Infinity`,\n *       not other non-finite values.\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is `Infinity` or `-Infinity`, else `false`.\n *\n * ---\n * @example\n * import * as RzlUtilsJs from \"@rzl-zone/utils-js/predicates\";\n *\n * RzlUtilsJs.isInfinityNumber(Infinity);\n * // ➔ true\n * RzlUtilsJs.isInfinityNumber(-Infinity);\n * // ➔ true\n * RzlUtilsJs.isInfinityNumber(new Number(Infinity));\n * // ➔ true\n * RzlUtilsJs.isInfinityNumber(NaN);\n * // ➔ false\n * RzlUtilsJs.isInfinityNumber(123);\n * // ➔ false\n */\nexport const isInfinityNumber = (value: unknown): boolean => {\n  if (typeof value === \"number\" || isNumberObject(value)) {\n    const num = Number(value);\n    return num === Infinity || num === -Infinity;\n  }\n  return false;\n};\n","import type { ArrayFallback } from \"@/_private/types.arrays\";\n\n/** ----------------------------------------------------------\n * * ***Type guard: `isNonEmptyArray`.***\n * -----------------------------------------------------------\n * **Checks if a value is a **non-empty array**.**\n *\n * ---\n * - **Behavior:**\n *     - Ensures the value is an actual array using **[`Array.isArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)**.\n *     - Ensures the array contains at least one item.\n *     - Narrows type to `T[]` (non-empty array) when true.\n *\n * ---\n * @template T - The type of the value being checked.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if value is a non-empty array.\n *\n * ---\n * @example\n * isNonEmptyArray([1, 2, 3]);\n * // ➔ true\n * isNonEmptyArray([]);\n * // ➔ false\n * isNonEmptyArray(null);\n * // ➔ false\n * isNonEmptyArray(\"test\");\n * // ➔ false\n */\nexport function isNonEmptyArray(value: []): value is [];\nexport function isNonEmptyArray<T>(value: T): value is ArrayFallback<T>;\nexport function isNonEmptyArray(value: unknown): value is unknown[];\nexport function isNonEmptyArray(value: unknown): boolean {\n  return Array.isArray(value) && value.length > 0;\n}\n","/** ---------------------------------------------------------\n * * ***Type guard: `isSet`.***\n * ----------------------------------------------------------\n * **Checks if a value is a **[`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/Set)** object.**\n *\n * ---\n * - **Behavior:**\n *     - Narrows type to `Set<T>` when true.\n *     - Excludes `WeakSet`, arrays, plain objects, and other non-Set values.\n *\n * ---\n * @template T - The type of the value being checked.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a `Set`, otherwise `false`.\n *\n * ---\n * @example\n * isSet(new Set);\n * // ➔ true\n * isSet(new WeakSet);\n * // ➔ false\n */\nexport function isSet<T = unknown>(value: Set<T>): value is Set<T>;\nexport function isSet(value: unknown): value is Set<unknown>;\nexport function isSet(value: unknown): boolean {\n  return (\n    Object.prototype.toString.call(value) === \"[object Set]\" ||\n    value instanceof Set\n  );\n}\n","/* eslint-disable @typescript-eslint/no-unused-vars */\nimport type { slugify } from \"../slugify\";\nimport type { toCamelCase } from \"../toCamelCase\";\nimport type { toDotCase } from \"../toDotCase\";\nimport type { toKebabCase } from \"../toKebabCase\";\nimport type { toLowerCase } from \"../toLowerCase\";\nimport type { toPascalCase } from \"../toPascalCase\";\nimport type { toPascalCaseSpace } from \"../toPascalCaseSpace\";\nimport type { toSnakeCase } from \"../toSnakeCase\";\n\nimport { isSet } from \"@/predicates/is/isSet\";\nimport type { StringCollection, StringLike } from \"./case.types\";\n\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isNonEmptyArray } from \"@/predicates/is/isNonEmptyArray\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/**\n * @internal ***Util helper for {@link toCamelCase}, {@link toPascalCaseSpace}, {@link toPascalCase}, {@link toLowerCase}, {@link toKebabCase}, {@link toSnakeCase}, {@link toDotCase} and {@link slugify}.***\n */\nexport const validateCaseInputWordsCase = (\n  input: NonNullable<StringLike>\n): string[] => {\n  let result: string = \"\";\n\n  if (isArray(input)) {\n    result = input\n      .map((x) => (isNonEmptyString(x) ? x.trim() : \"\"))\n      .filter((x) => x.length)\n      .join(\"-\");\n  } else if (isNonEmptyString(input)) {\n    result = input.trim();\n  }\n\n  return result.split(/[^\\p{L}\\p{N}]+/u).filter(Boolean);\n};\n\n/**\n * @internal ***Util helper for {@link toCamelCase}, {@link toPascalCaseSpace}, {@link toPascalCase}, {@link toLowerCase}, {@link toKebabCase}, {@link toSnakeCase}, {@link toDotCase} and {@link slugify}.***\n */\nexport const validateCaseIgnoreWordsCase = (\n  ignoreWord?: StringCollection\n): Set<string> => {\n  const result = new Set<string>([]);\n\n  const normalizeWord = (word: string) =>\n    word\n      .trim()\n      .split(/[^\\p{L}\\p{N}]+/u)\n      .filter(Boolean)\n      .join(\"\");\n\n  if (isNonEmptyString(ignoreWord)) {\n    const clean = normalizeWord(ignoreWord);\n    if (clean) result.add(clean);\n  }\n  if (isNonEmptyArray(ignoreWord)) {\n    ignoreWord.forEach((w) => {\n      if (isNonEmptyString(w)) {\n        const clean = normalizeWord(w);\n        if (clean) result.add(clean);\n      }\n    });\n  }\n  if (isSet(ignoreWord)) {\n    ignoreWord.forEach((w) => {\n      if (isNonEmptyString(w)) {\n        const clean = normalizeWord(w);\n        if (clean) result.add(clean);\n      }\n    });\n  }\n\n  return result;\n};\n","import type { StringCollection, StringLike } from \"./_private/case.types\";\n\nimport { isNonEmptyArray } from \"@/predicates/is/isNonEmptyArray\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport {\n  validateCaseIgnoreWordsCase,\n  validateCaseInputWordsCase\n} from \"./_private/case.utils\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `slugify`.***\n * -----------------------------------------------------------\n * **Slugifies a string (or array of strings) for safe use in URLs, with optionally leaving specific words unchanged.**\n *\n * ---\n * - **Behavior:**\n *     - Accepts a `string` or an `array of strings`:\n *       - If an array is provided, elements are trimmed, empty ones removed,\n *         then joined with `\"-\"` before conversion.\n *     - Splits the input by non-alphanumeric characters\n *       (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).\n *     - The first word is fully lowercase; subsequent words are capitalized.\n *     - Words listed in `ignoreWord` remain unchanged in the output.\n *     - `ignoreWord` is normalized (trimmed, delimiters removed), empty values ignored.\n *     - `ignoreWord` accepts:\n *        - a single string,\n *        - an array of strings, or\n *        - a `Set` of strings.\n *     - Multiple delimiters collapse into one; empty segments ignored.\n *     - Returns `\"\"` if the input is `null`, `undefined`, or empty.\n *\n * ---\n * @param {StringLike} input - The string or array to convert. Returns `\"\"` if empty, `null`, or `undefined`.\n * @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.\n *\n * ---\n * @returns {string} The slugified string.\n *\n * ---\n * @example\n * 1. #### Basic usage:\n *    ```ts\n *    slugify(\"Hello World!\");\n *    // ➔ \"hello-world\"\n *    ```\n *    ---\n * 2. #### Array input is joined before conversion:\n *    ```ts\n *    slugify([\"Join\", \"Words\", \"Here\"]);\n *    // ➔ \"join-words-here\"\n *    ```\n *    ---\n * 3. #### Trims and cleans input:\n *    ```ts\n *    slugify(\" --- Convert to Slug? --- \");\n *    // ➔ \"convert-to-slug\"\n *    ```\n *    ---\n * 4. #### Ignore single word:\n *    ```ts\n *    slugify(\"This URL path\", \"URL\");\n *    // ➔ \"this-URL-path\"\n *    ```\n *    ---\n * 5. #### Ignore multiple words:\n *    ```ts\n *    slugify(\"ignore API and URL\", [\"API\", \"URL\"]);\n *    // ➔ \"ignore-API-and-URL\"\n *    ```\n *    ---\n * 6. #### Ignore using Set:\n *    ```ts\n *    slugify(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n *    // ➔ \"ignore-API-and-URL\"\n *    ```\n *    ---\n * 7. #### Supports emojis and symbols:\n *    ```ts\n *    slugify(\"🔥 Fire_and_ice ❄️\");\n *    // ➔ \"fire-and-ice\"\n *    ```\n *    ---\n * 8. #### Null, Undefined or empty (string or array) input returns empty string:\n *    ```ts\n *    slugify(undefined);\n *    // ➔ \"\"\n */\nexport const slugify = (\n  input: StringLike,\n  ignoreWord?: StringCollection\n): string => {\n  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return \"\";\n\n  const wordsValidated = validateCaseInputWordsCase(input);\n  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);\n\n  // map + join\n  const slug = wordsValidated\n    .map((word) => {\n      if (ignoreWordsValidated.has(word)) return word;\n      return word.toLowerCase();\n    })\n    .join(\"-\");\n\n  // trim hyphens\n  return slug.replace(/^-+|-+$/g, \"\");\n};\n","import type { StringCollection, StringLike } from \"./_private/case.types\";\n\nimport { isNonEmptyArray } from \"@/predicates/is/isNonEmptyArray\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport {\n  validateCaseIgnoreWordsCase,\n  validateCaseInputWordsCase\n} from \"./_private/case.utils\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `toDotCase`.***\n * -----------------------------------------------------------\n * **Converts a string (or array of strings) into `dot.case`, with optionally leaving specific words unchanged.**\n *\n * ---\n * - **Behavior:**\n *     - Accepts a `string` or an `array of strings`:\n *       - If an array is provided, elements are trimmed, empty ones removed,\n *         then joined with `\"-\"` before conversion.\n *     - Splits the input by non-alphanumeric characters\n *       (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).\n *     - The first word is fully lowercase; subsequent words are capitalized.\n *     - Words listed in `ignoreWord` remain unchanged in the output.\n *     - `ignoreWord` is normalized (trimmed, delimiters removed), empty values ignored.\n *     - `ignoreWord` accepts:\n *        - a single string,\n *        - an array of strings, or\n *        - a `Set` of strings.\n *     - Multiple delimiters collapse into one; empty segments ignored.\n *     - Returns `\"\"` if the input is `null`, `undefined`, or empty.\n *\n * ---\n * @param {StringLike} input - The string or array to convert. Returns `\"\"` if empty, `null`, or `undefined`.\n * @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.\n *\n * ---\n * @returns {string} The dot.case formatted string.\n *\n * ---\n * @example\n * 1. #### Basic usage:\n *    ```ts\n *    toDotCase(\"Hello World\");\n *    // ➔ \"hello.world\"\n *    ```\n *    ---\n * 2. #### Array input is joined before conversion:\n *    ```ts\n *    toDotCase([\"Join\", \"Words\", \"Here\"]);\n *    // ➔ \"join.words.here\"\n *    ```\n *    ---\n * 3. #### Handles underscores and hyphens:\n *    ```ts\n *    toDotCase(\"convert-to_dot case\");\n *    // ➔ \"convert.to.dot.case\"\n *    ```\n *    ---\n * 4. #### Multiple delimiters and trimming:\n *    ```ts\n *    toDotCase(\"___Hello--World__ again!!\");\n *    // ➔ \"hello.world.again\"\n *    ```\n *    ---\n * 5. #### Supports emojis and symbols:\n *    ```ts\n *    toDotCase(\"🔥Fire_and-ice❄️\");\n *    // ➔ \"fire.and.ice\"\n *    ```\n *    ---\n * 6. #### Ignore single word:\n *    ```ts\n *    toDotCase(\"this URL path\", \"URL\");\n *    // ➔ \"this.URL.path\"\n *    ```\n *    ---\n * 7. #### Ignore multiple words:\n *    ```ts\n *    toDotCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n *    // ➔ \"ignore.API.and.URL\"\n *    ```\n *    ---\n * 8. #### Ignore using Set:\n *    ```ts\n *    toDotCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n *    // ➔ \"ignore.API.and.URL\"\n *    ```\n *    ---\n * 9. #### Null, Undefined or empty (string or array) input returns empty string:\n *    ```ts\n *    toDotCase(undefined);\n *    // ➔ \"\"\n *    ```\n */\nexport const toDotCase = (\n  input: StringLike,\n  ignoreWord?: StringCollection\n): string => {\n  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return \"\";\n\n  const wordsValidated = validateCaseInputWordsCase(input);\n  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);\n\n  return wordsValidated\n    .map((word) => {\n      if (ignoreWordsValidated.has(word)) return word;\n      return word.toLowerCase();\n    })\n    .join(\".\");\n};\n","import type { StringCollection, StringLike } from \"./_private/case.types\";\n\nimport { isNonEmptyArray } from \"@/predicates/is/isNonEmptyArray\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport {\n  validateCaseIgnoreWordsCase,\n  validateCaseInputWordsCase\n} from \"./_private/case.utils\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `toCamelCase`.***\n * -----------------------------------------------------------\n * **Converts a string (or array of strings) into `camelCase`, with optionally leaving specific words unchanged.**\n *\n * ---\n * - **Behavior:**\n *     - Accepts a `string` or an `array of strings`:\n *       - If an array is provided, elements are trimmed, empty ones removed,\n *         then joined with `\"-\"` before conversion.\n *     - Splits the input by non-alphanumeric characters\n *       (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).\n *     - The first word is fully lowercase; subsequent words are capitalized.\n *     - Words listed in `ignoreWord` remain unchanged in the output.\n *     - `ignoreWord` is normalized (trimmed, delimiters removed), empty values ignored.\n *     - `ignoreWord` accepts:\n *        - a single string,\n *        - an array of strings, or\n *        - a `Set` of strings.\n *     - Multiple delimiters collapse into one; empty segments ignored.\n *     - Returns `\"\"` if the input is `null`, `undefined`, or empty.\n *\n * ---\n * @param {StringLike} input - The string or array to convert. Returns `\"\"` if empty, `null`, or `undefined`.\n * @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.\n *\n * ---\n * @returns {string} The camelCase formatted string.\n *\n * ---\n * @example\n * 1. #### Basic usage:\n *    ```ts\n *    toCamelCase(\"hello world\");\n *    // ➔ \"helloWorld\"\n *    ```\n *    ---\n * 2. #### Array input is joined before conversion:\n *    ```ts\n *    toCamelCase([\"Join\", \"Words\", \"Here\"]);\n *    // ➔ \"joinWordsHere\"\n *    ```\n *    ---\n * 3. #### Supports mixed delimiters:\n *    ```ts\n *    toCamelCase(\"convert_to-camel case\");\n *    // ➔ \"convertToCamelCase\"\n *    ```\n *    ---\n * 4. #### Words in ignoreWord stay unchanged:\n *    ```ts\n *    toCamelCase(\"this URL path will ignore\", \"URL\");\n *    // ➔ \"thisURLPathWillIgnore\"\n *    ```\n *    ---\n * 5. #### Multiple ignored words:\n *    ```ts\n *    toCamelCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n *    // ➔ \"ignoreAPIAndURL\"\n *    ```\n *    ---\n * 6. #### Set can also be used:\n *    ```ts\n *    toCamelCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n *    // ➔ \"ignoreAPIAndURL\"\n *    ```\n *    ---\n * 7. #### Null, Undefined or empty (string or array) input returns empty string:\n *    ```ts\n *    toCamelCase(null);\n *    // ➔ \"\"\n *    ```\n */\nexport const toCamelCase = (\n  input: StringLike,\n  ignoreWord?: StringCollection\n): string => {\n  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return \"\";\n\n  const wordsValidated = validateCaseInputWordsCase(input);\n  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);\n\n  return wordsValidated\n    .map((word, index) => {\n      if (ignoreWordsValidated.has(word)) return word;\n      return index === 0\n        ? word.toLowerCase()\n        : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();\n    })\n    .join(\"\");\n};\n","import type { StringCollection, StringLike } from \"./_private/case.types\";\n\nimport { isNonEmptyArray } from \"@/predicates/is/isNonEmptyArray\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport {\n  validateCaseIgnoreWordsCase,\n  validateCaseInputWordsCase\n} from \"./_private/case.utils\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `toKebabCase`.***\n * -----------------------------------------------------------\n * **Converts a string (or array of strings) into `kebab-case`, with optionally leaving specific words unchanged.**\n *\n * ---\n * - **Behavior:**\n *     - Accepts a `string` or an `array of strings`:\n *       - If an array is provided, elements are trimmed, empty ones removed,\n *         then joined with `\"-\"` before conversion.\n *     - Splits the input by non-alphanumeric characters\n *       (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).\n *     - The first word is fully lowercase; subsequent words are capitalized.\n *     - Words listed in `ignoreWord` remain unchanged in the output.\n *     - `ignoreWord` is normalized (trimmed, delimiters removed), empty values ignored.\n *     - `ignoreWord` accepts:\n *        - a single string,\n *        - an array of strings, or\n *        - a `Set` of strings.\n *     - Multiple delimiters collapse into one; empty segments ignored.\n *     - Returns `\"\"` if the input is `null`, `undefined`, or empty.\n *\n * ---\n * @param {StringLike} input - The string or array to convert. Returns `\"\"` if empty, `null`, or `undefined`.\n * @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.\n *\n * ---\n * @returns {string} The kebab-case formatted string.\n *\n * ---\n * @example\n * 1. #### Basic usage:\n *    ```ts\n *    toKebabCase(\"Hello World\");\n *    // ➔ \"hello-world\"\n *    ```\n *    ---\n * 2. #### Array input is joined before conversion:\n *    ```ts\n *    toKebabCase([\"Join\", \"Words\", \"Here\"]);\n *    // ➔ \"join-words-here\"\n *    ```\n *    ---\n * 3. #### Handles underscores and hyphens:\n *    ```ts\n *    toKebabCase(\"convert_to-kebab case\");\n *    // ➔ \"convert-to-kebab-case\"\n *    ```\n *    ---\n * 4. #### Handles emojis and symbols:\n *    ```ts\n *    toKebabCase(\"🔥fire___and--ice❄️\");\n *    // ➔ \"fire-and-ice\"\n *    ```\n *    ---\n * 5. #### Ignore specific word:\n *    ```ts\n *    toKebabCase(\"ignore URL case\", \"URL\");\n *    // ➔ \"ignore-URL-case\"\n *    ```\n *    ---\n * 6. #### Ignore multiple words:\n *    ```ts\n *    toKebabCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n *    // ➔ \"ignore-API-and-URL\"\n *    ```\n *    ---\n * 7. #### Ignore with Set:\n *    ```ts\n *    toKebabCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n *    // ➔ \"ignore-API-and-URL\"\n *    ```\n *    ---\n * 8. #### Null, Undefined or empty (string or array) input returns empty string:\n *    ```ts\n *    toKebabCase(null);\n *    // ➔ \"\"\n *    ```\n */\nexport const toKebabCase = (\n  input: StringLike,\n  ignoreWord?: StringCollection\n): string => {\n  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return \"\";\n\n  const wordsValidated = validateCaseInputWordsCase(input);\n  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);\n\n  return wordsValidated\n    .map((word) => {\n      if (ignoreWordsValidated.has(word)) return word;\n      return word.toLowerCase();\n    })\n    .join(\"-\");\n};\n","import type { StringCollection, StringLike } from \"./_private/case.types\";\n\nimport { isNonEmptyArray } from \"@/predicates/is/isNonEmptyArray\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport {\n  validateCaseIgnoreWordsCase,\n  validateCaseInputWordsCase\n} from \"./_private/case.utils\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `toSnakeCase`.***\n * -----------------------------------------------------------\n * **Converts a string (or array of strings) into `snake_case`, with optionally leaving specific words unchanged.**\n *\n * ---\n * - **Behavior:**\n *     - Accepts a `string` or an `array of strings`:\n *       - If an array is provided, elements are trimmed, empty ones removed,\n *         then joined with `\"-\"` before conversion.\n *     - Splits the input by non-alphanumeric characters\n *       (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).\n *     - The first word is fully lowercase; subsequent words are capitalized.\n *     - Words listed in `ignoreWord` remain unchanged in the output.\n *     - `ignoreWord` is normalized (trimmed, delimiters removed), empty values ignored.\n *     - `ignoreWord` accepts:\n *        - a single string,\n *        - an array of strings, or\n *        - a `Set` of strings.\n *     - Multiple delimiters collapse into one; empty segments ignored.\n *     - Returns `\"\"` if the input is `null`, `undefined`, or empty.\n *\n * ---\n * @param {StringLike} input - The string or array to convert. Returns `\"\"` if empty, `null`, or `undefined`.\n * @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.\n *\n * ---\n * @returns {string} The snake_case formatted string.\n *\n * ---\n * @example\n * 1. #### Basic usage:\n *      ```ts\n *      toSnakeCase(\"Hello World\");\n *      // ➔ \"hello_world\"\n *      ```\n *      ---\n * 2. #### Array input is joined before conversion:\n *      ```ts\n *      toSnakeCase([\"Join\", \"Words\", \"Here\"]);\n *      // ➔ \"join_words_here\"\n *      ```\n *      ---\n * 3. #### Handles underscores, hyphens, spaces:\n *      ```ts\n *      toSnakeCase(\"convert-to_snake case\");\n *      // ➔ \"convert_to_snake_case\"\n *      ```\n *      ---\n * 4. #### Handles emojis and symbols:\n *      ```ts\n *      toSnakeCase(\"🔥fire___and--ice❄️\");\n *      // ➔ \"fire_and_ice\"\n *      ```\n *      ---\n * 5. #### Ignore specific word:\n *      ```ts\n *      toSnakeCase(\"ignore URL case\", \"URL\");\n *      // ➔ \"ignore_URL_case\"\n *      ```\n *      ---\n * 6. #### Ignore multiple words:\n *      ```ts\n *      toSnakeCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n *      // ➔ \"ignore_API_and_URL\"\n *      ```\n *      ---\n * 7. #### Ignore with Set:\n *      ```ts\n *      toSnakeCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n *      // ➔ \"ignore_API_and_URL\"\n *      ```\n *      ---\n * 8. #### Null, Undefined or empty (string or array) input returns empty string:\n *      ```ts\n *      toSnakeCase(null);\n *      // ➔ \"\"\n *      ```\n */\nexport const toSnakeCase = (\n  input: StringLike,\n  ignoreWord?: StringCollection\n): string => {\n  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return \"\";\n\n  const wordsValidated = validateCaseInputWordsCase(input);\n  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);\n\n  return wordsValidated\n    .map((word) => {\n      if (ignoreWordsValidated.has(word)) return word;\n      return word.toLowerCase();\n    })\n    .join(\"_\");\n};\n","import type { StringCollection, StringLike } from \"./_private/case.types\";\n\nimport { isNonEmptyArray } from \"@/predicates/is/isNonEmptyArray\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport {\n  validateCaseIgnoreWordsCase,\n  validateCaseInputWordsCase\n} from \"./_private/case.utils\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `toLowerCase`.***\n * -----------------------------------------------------------\n * **Converts a string (or array of strings) into `lower case`, with optionally leaving specific words unchanged.**\n *\n * ---\n * - **Behavior:**\n *     - Accepts a `string` or an `array of strings`:\n *       - If an array is provided, elements are trimmed, empty ones removed,\n *         then joined with `\"-\"` before conversion.\n *     - Splits the input by non-alphanumeric characters\n *       (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).\n *     - The first word is fully lowercase; subsequent words are capitalized.\n *     - Words listed in `ignoreWord` remain unchanged in the output.\n *     - `ignoreWord` is normalized (trimmed, delimiters removed), empty values ignored.\n *     - `ignoreWord` accepts:\n *        - a single string,\n *        - an array of strings, or\n *        - a `Set` of strings.\n *     - Multiple delimiters collapse into one; empty segments ignored.\n *     - Returns `\"\"` if the input is `null`, `undefined`, or empty.\n *\n * ---\n * @param {StringLike} input - The string or array to convert. Returns `\"\"` if empty, `null`, or `undefined`.\n * @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.\n *\n * ---\n * @returns {string} The LowerCase formatted string.\n *\n * ---\n * @example\n * 1. #### Basic usage:\n *    ```ts\n *    toLowerCase(\"Hello World\");\n *    // ➔ \"hello world\"\n *    ```\n *    ---\n * 2. #### Array input is joined before conversion:\n *    ```ts\n *    toLowerCase([\"Join\", \"WORLD\", \"Here\"]);\n *    // ➔ \"join words here\"\n *    ```\n *    ---\n * 3. #### Handles underscores and hyphens:\n *    ```ts\n *    toLowerCase(\"convert_to-pascal case\");\n *    // ➔ \"convert to lower case\"\n *    ```\n *    ---\n * 4. #### Trims extra delimiters:\n *    ```ts\n *    toLowerCase(\"___hello--world__ again!!\");\n *    // ➔ \"hello world again\"\n *    ```\n *    ---\n * 5. #### Supports emojis and symbols:\n *    ```ts\n *    toLowerCase(\"🔥fire_and-ice❄️\");\n *    // ➔ \"fire and ice\"\n *    ```\n *    ---\n * 6. #### Ignore single word:\n *    ```ts\n *    toLowerCase(\"this URL path will ignore\", \"URL\");\n *    // ➔ \"this URL path will ignore\"\n *    ```\n *    ---\n * 7. #### Ignore multiple words:\n *    ```ts\n *    toLowerCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n *    // ➔ \"ignore API and URL\"\n *    ```\n *    ---\n * 8. #### Ignore using Set:\n *    ```ts\n *    toLowerCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n *    // ➔ \"ignore API and URL\"\n *    ```\n *    ---\n * 9. #### Null, Undefined or empty (string or array) input returns empty string:\n *    ```ts\n *    toLowerCase(undefined);\n *    // ➔ \"\"\n *    ```\n */\nexport const toLowerCase = (\n  input: StringLike,\n  ignoreWord?: StringCollection\n): string => {\n  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return \"\";\n\n  const wordsValidated = validateCaseInputWordsCase(input);\n  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);\n\n  return wordsValidated\n    .map((word) => {\n      if (ignoreWordsValidated.has(word)) return word;\n      return word.toLowerCase();\n    })\n    .join(\" \");\n};\n","import type { StringCollection, StringLike } from \"./_private/case.types\";\n\nimport { isNonEmptyArray } from \"@/predicates/is/isNonEmptyArray\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport {\n  validateCaseIgnoreWordsCase,\n  validateCaseInputWordsCase\n} from \"./_private/case.utils\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `toPascalCase`.***\n * -----------------------------------------------------------\n * **Converts a string (or array of strings) into `PascalCase`, with optionally leaving specific words unchanged.**\n *\n * ---\n * - **Behavior:**\n *     - Accepts a `string` or an `array of strings`:\n *       - If an array is provided, elements are trimmed, empty ones removed,\n *         then joined with `\"-\"` before conversion.\n *     - Splits the input by non-alphanumeric characters\n *       (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).\n *     - The first word is fully lowercase; subsequent words are capitalized.\n *     - Words listed in `ignoreWord` remain unchanged in the output.\n *     - `ignoreWord` is normalized (trimmed, delimiters removed), empty values ignored.\n *     - `ignoreWord` accepts:\n *        - a single string,\n *        - an array of strings, or\n *        - a `Set` of strings.\n *     - Multiple delimiters collapse into one; empty segments ignored.\n *     - Returns `\"\"` if the input is `null`, `undefined`, or empty.\n *\n * ---\n * @param {StringLike} input - The string or array to convert. Returns `\"\"` if empty, `null`, or `undefined`.\n * @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.\n *\n * ---\n * @returns {string} The PascalCase formatted string.\n *\n * ---\n * @example\n * 1. #### Basic usage:\n *    ```ts\n *    toPascalCase(\"hello world\");\n *    // ➔ \"HelloWorld\"\n *    ```\n *    ---\n * 2. #### Array input is joined before conversion:\n *    ```ts\n *    toPascalCase([\"Join\", \"Words\", \"Here\"]);\n *    // ➔ \"JoinWordsHere\"\n *    ```\n *    ---\n * 3. #### Handles underscores and hyphens:\n *    ```ts\n *    toPascalCase(\"convert_to-pascal case\");\n *    // ➔ \"ConvertToPascalCase\"\n *    ```\n *    ---\n * 4. #### Trims extra delimiters:\n *    ```ts\n *    toPascalCase(\"___hello--world__ again!!\");\n *    // ➔ \"HelloWorldAgain\"\n *    ```\n *    ---\n * 5. #### Supports emojis and symbols:\n *    ```ts\n *    toPascalCase(\"🔥fire_and-ice❄️\");\n *    // ➔ \"FireAndIce\"\n *    ```\n *    ---\n * 6. #### Ignore single word:\n *    ```ts\n *    toPascalCase(\"this URL path will ignore\", \"URL\");\n *    // ➔ \"ThisURLPathWillIgnore\"\n *    ```\n *    ---\n * 7. #### Ignore multiple words:\n *    ```ts\n *    toPascalCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n *    // ➔ \"IgnoreAPIAndURL\"\n *    ```\n *    ---\n * 8. #### Ignore using Set:\n *    ```ts\n *    toPascalCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n *    // ➔ \"IgnoreAPIAndURL\"\n *    ```\n *    ---\n * 9. #### Null, Undefined or empty (string or array) input returns empty string:\n *    ```ts\n *    toPascalCase(undefined);\n *    // ➔ \"\"\n *    ```\n */\nexport const toPascalCase = (\n  input: StringLike,\n  ignoreWord?: StringCollection\n): string => {\n  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return \"\";\n\n  const wordsValidated = validateCaseInputWordsCase(input);\n  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);\n\n  return wordsValidated\n    .map((word) => {\n      if (ignoreWordsValidated.has(word)) return word;\n      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();\n    })\n    .join(\"\");\n};\n","import type { StringCollection, StringLike } from \"./_private/case.types\";\n\nimport { isNonEmptyArray } from \"@/predicates/is/isNonEmptyArray\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport {\n  validateCaseIgnoreWordsCase,\n  validateCaseInputWordsCase\n} from \"./_private/case.utils\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `toPascalCaseSpace`.***\n * -----------------------------------------------------------\n * **Converts a string (or array of strings) into `PascalCaseSpace`, with optionally leaving specific words unchanged.**\n *\n * ---\n * - **Behavior:**\n *     - Accepts a `string` or an `array of strings`:\n *       - If an array is provided, elements are trimmed, empty ones removed,\n *         then joined with `\"-\"` before conversion.\n *     - Splits the input by non-alphanumeric characters\n *       (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).\n *     - The first word is fully lowercase; subsequent words are capitalized.\n *     - Words listed in `ignoreWord` remain unchanged in the output.\n *     - `ignoreWord` is normalized (trimmed, delimiters removed), empty values ignored.\n *     - `ignoreWord` accepts:\n *        - a single string,\n *        - an array of strings, or\n *        - a `Set` of strings.\n *     - Multiple delimiters collapse into one; empty segments ignored.\n *     - Returns `\"\"` if the input is `null`, `undefined`, or empty.\n *\n * ---\n * @param {StringLike} input - The string or array to convert. Returns `\"\"` if empty, `null`, or `undefined`.\n * @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.\n *\n * ---\n * @returns {string} The PascalCaseSpace formatted string.\n *\n * ---\n * @example\n * 1. #### Basic usage:\n *    ```ts\n *    toPascalCaseSpace(\"hello world\");\n *    // ➔ \"Hello World\"\n *    ```\n *    ---\n * 2. #### Array input is joined before conversion:\n *    ```ts\n *    toPascalCaseSpace([\"Join\", \"Words\", \"Here\"]);\n *    // ➔ \"Join Words Here\"\n *    ```\n *    ---\n * 3. #### Handles underscores and hyphens:\n *    ```ts\n *    toPascalCaseSpace(\"convert_to-pascal case\");\n *    // ➔ \"Convert To Pascal Case Space\"\n *    ```\n *    ---\n * 4. #### Trims extra delimiters:\n *    ```ts\n *    toPascalCaseSpace(\"___hello--world__ again!!\");\n *    // ➔ \"Hello World Again\"\n *    ```\n *    ---\n * 5. #### Supports emojis and symbols:\n *    ```ts\n *    toPascalCaseSpace(\"🔥fire_and-ice❄️\");\n *    // ➔ \"Fire And Ice\"\n *    ```\n *    ---\n * 6. #### Ignore single word:\n *    ```ts\n *    toPascalCaseSpace(\"this URL path will ignore\", \"URL\");\n *    // ➔ \"This URL Path Will Ignore\"\n *    ```\n *    ---\n * 7. #### Ignore multiple words:\n *    ```ts\n *    toPascalCaseSpace(\"ignore API and URL\", [\"API\", \"URL\"]);\n *    // ➔ \"Ignore API And URL\"\n *    ```\n *    ---\n * 8. #### Ignore using Set:\n *    ```ts\n *    toPascalCaseSpace(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n *    // ➔ \"Ignore API And URL\"\n *    ```\n *    ---\n * 9. #### Null, Undefined or empty (string or array) input returns empty string:\n *    ```ts\n *    toPascalCaseSpace(undefined);\n *    // ➔ \"\"\n *    ```\n */\nexport const toPascalCaseSpace = (\n  input: StringLike,\n  ignoreWord?: StringCollection\n): string => {\n  if (!isNonEmptyArray(input) && !isNonEmptyString(input)) return \"\";\n\n  const wordsValidated = validateCaseInputWordsCase(input);\n  const ignoreWordsValidated = validateCaseIgnoreWordsCase(ignoreWord);\n\n  return wordsValidated\n    .map((word) => {\n      if (ignoreWordsValidated.has(word)) return word;\n      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();\n    })\n    .join(\" \");\n};\n","import type { AnyString } from \"@rzl-zone/ts-types-plus\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { getPreciseType, GetPreciseTypeOptions } from \"../getPreciseType\";\n\nimport { slugify } from \"@/strings/cases/slugify\";\nimport { toDotCase } from \"@/strings/cases/toDotCase\";\nimport { toCamelCase } from \"@/strings/cases/toCamelCase\";\nimport { toKebabCase } from \"@/strings/cases/toKebabCase\";\nimport { toSnakeCase } from \"@/strings/cases/toSnakeCase\";\nimport { toLowerCase } from \"@/strings/cases/toLowerCase\";\nimport { toPascalCase } from \"@/strings/cases/toPascalCase\";\nimport { toPascalCaseSpace } from \"@/strings/cases/toPascalCaseSpace\";\n\nimport { isNull } from \"@/predicates/is/isNull\";\nimport { isObjectOrArray } from \"@/predicates/is/isObjectOrArray\";\n\nconst FIXES_RAW = {\n  // primitives\n  string: \"String\",\n  number: \"Number\",\n  boolean: \"Boolean\",\n  bigint: \"Bigint\",\n  symbol: \"Symbol\",\n  undefined: \"Undefined\",\n  null: \"Null\",\n  regexp: \"Reg Exp\",\n\n  // reflect / proxy / atomics\n  reflect: \"Reflect\",\n  proxy: \"Proxy\",\n  atomics: \"Atomics\",\n\n  // core / objects\n  array: \"Array\",\n  object: \"Object\",\n  function: \"Function\",\n  arguments: \"Arguments\",\n\n  // functions\n  asyncfunction: \"Async Function\",\n  generatorfunction: \"Generator Function\",\n  asyncgeneratorfunction: \"Async Generator Function\",\n  generator: \"Generator\",\n  promise: \"Promise\",\n\n  // errors\n  evalerror: \"Eval Error\",\n  rangeerror: \"Range Error\",\n  referenceerror: \"Reference Error\",\n  syntaxerror: \"Syntax Error\",\n  typeerror: \"Type Error\",\n  urierror: \"URI Error\",\n  aggregateerror: \"Aggregate Error\",\n  error: \"Error\",\n\n  // typed arrays & binary\n  int8array: \"Int 8 Array\",\n  uint8array: \"Uint 8 Array\",\n  uint8clampedarray: \"Uint 8 Clamped Array\",\n  int16array: \"Int 16 Array\",\n  uint16array: \"Uint 16 Array\",\n  int32array: \"Int 32 Array\",\n  uint32array: \"Uint 32 Array\",\n  float32array: \"Float 32 Array\",\n  float64array: \"Float 64 Array\",\n  bigint64array: \"Big Int 64 Array\",\n  biguint64array: \"Big Uint 64 Array\",\n  arraybuffer: \"Array Buffer\",\n  sharedarraybuffer: \"Shared Array Buffer\",\n  dataview: \"Data View\",\n  arraybufferview: \"Array Buffer View\",\n\n  // collections\n  map: \"Map\",\n  set: \"Set\",\n  weakmap: \"Weak Map\",\n  weakset: \"Weak Set\",\n\n  // iterators (note: toString tag can be \"Map Iterator\" etc.)\n  mapiterator: \"Map Iterator\",\n  weakmapiterator: \"Weak Map Iterator\",\n  setiterator: \"Set Iterator\",\n  weaksetiterator: \"Weak Set Iterator\",\n  arrayiterator: \"Array Iterator\",\n  stringiterator: \"String Iterator\",\n  asynciterator: \"Async Iterator\",\n  iteratorresult: \"Iterator Result\",\n  arrayiteratorresult: \"Array Iterator Result\",\n\n  // streams / fetch / web\n  readablestream: \"Readable Stream\",\n  writablestream: \"Writable Stream\",\n  transformstream: \"Transform Stream\",\n  readablestreamdefaultreader: \"Readable Stream Default Reader\",\n  writablestreamdefaultwriter: \"Writable Stream Default Writer\",\n  readablestreamdefaultcontroller: \"Readable Stream Default Controller\",\n  transformstreamdefaultcontroller: \"Transform Stream Default Controller\",\n  abortcontroller: \"Abort Controller\",\n  abortsignal: \"Abort Signal\",\n  fetch: \"fetch\",\n  request: \"Request\",\n  response: \"Response\",\n  headers: \"Headers\",\n  formdata: \"FormData\",\n  blob: \"Blob\",\n  file: \"File\",\n  filelist: \"FileList\",\n  filereader: \"FileReader\",\n\n  // intl\n  intl: \"Intl\",\n  collator: \"Intl. Collator\",\n  datetimeformat: \"Intl. Date Time Format\",\n  displaynames: \"Intl. Display Names\",\n  listformat: \"Intl. List Format\",\n  locale: \"Intl. Locale\",\n  numberformat: \"Intl. Number Format\",\n  pluralrules: \"Intl. Plural Rules\",\n  relativetimeformat: \"Intl. Relative Time Format\",\n  segmenter: \"Intl. Segmenter\",\n\n  // es2021+\n  weakref: \"Weak Ref\",\n  urlpattern: \"URL Pattern\",\n  structuredclone: \"structured Clone\",\n  finalizationregistry: \"Finalization Registry\",\n\n  // performance / observers\n  performance: \"Performance\",\n  performanceobserver: \"Performance Observer\",\n  performanceentry: \"Performance Entry\",\n  performancemark: \"Performance Mark\",\n  performancemeasure: \"Performance Measure\",\n\n  // webassembly\n  webassembly: \"Web Assembly\",\n  wasmmodule: \"WebAssembly. Module\",\n  wasminstance: \"WebAssembly. Instance\",\n  wasmmemory: \"WebAssembly. Memory\",\n  wasmtable: \"WebAssembly. Table\",\n\n  // node-ish / common hosts\n  buffer: \"Buffer\",\n  process: \"Process\",\n  eventemitter: \"Event Emitter\",\n  stream: \"Stream\",\n  fs: \"fs\",\n  path: \"path\",\n  url: \"URL\",\n  urlsearchparams: \"URL Search Params\",\n\n  // DOM basics\n  node: \"Node\",\n  element: \"Element\",\n  htmlelement: \"HTML Element\",\n  cdatasection: \"CData Section\",\n  svgelement: \"SVG Element\",\n  document: \"Document\",\n  documentfragment: \"Document Fragment\",\n  shadowroot: \"Shadow Root\",\n  nodelist: \"Node List\",\n  htmlcollection: \"HTML Collection\",\n\n  // observers / misc DOM\n  resizeobserver: \"Resize Observer\",\n  mutationobserver: \"Mutation Observer\",\n  intersectionobserver: \"Intersection Observer\",\n\n  // Reflection / Symbolic\n  symboliterator: \"Symbol. Iterator\",\n  symbolasynciterator: \"Symbol. Async Iterator\",\n  symboltostringtag: \"Symbol. To String Tag\",\n  symbolspecies: \"Symbol. Species\",\n  symbolhasinstance: \"Symbol. Has Instance\",\n  symbolisconcatspreadable: \"Symbol. Is Concat Spreadable\",\n  symbolunscopables: \"Symbol. Unscopables\",\n  symbolmatch: \"Symbol. Match\",\n  symbolreplace: \"Symbol. Replace\",\n  symbolsearch: \"Symbol. Search\",\n  symbolsplit: \"Symbol. Split\",\n  symboltoprimitive: \"Symbol. To Primitive\",\n  symbolmatchall: \"Symbol. Match All\",\n  symbolarguments: \"Symbol. Arguments\", // deprecated\n\n  // Numbers & Math\n  math: \"Math\",\n  bigintconstructor: \"Bigint Constructor\",\n  numberconstructor: \"Number Constructor\",\n  stringconstructor: \"String Constructor\",\n  booleanconstructor: \"Boolean Constructor\",\n\n  // URL / Networking (modern web)\n  formdataevent: \"Form Data Event\",\n  customevent: \"Custom Event\",\n  messagechannel: \"Message Channel\",\n  messageport: \"Message Port\",\n  messageevent: \"Message Event\",\n  websocket: \"Web Socket\",\n  eventsource: \"Event Source\",\n\n  // Storage APIs\n  indexeddb: \"IndexedDB\",\n  idbrequest: \"IDB Request\",\n  idbtransaction: \"IDB Transaction\",\n  idbobjectstore: \"IDB Object Store\",\n  idbcursor: \"IDB Cursor\",\n  localstorage: \"Local Storage\",\n  sessionstorage: \"Session Storage\",\n\n  // Navigator / Browser APIs\n  navigator: \"Navigator\",\n  geolocation: \"Geolocation\",\n  clipboard: \"Clipboard\",\n  notification: \"Notification\",\n\n  // Canvas / Graphics\n  canvasrenderingcontext2d: \"Canvas Rendering Context 2D\",\n  offscreencanvas: \"Offscreen Canvas\",\n  webglrenderingcontext: \"WebGL Rendering Context\",\n  webgl2renderingcontext: \"WebGL 2 Rendering Context\",\n  imagebitmaprenderingcontext: \"Image Bitmap Rendering Context\",\n  gpucanvascontext: \"GPU Canvas Context\",\n  imagedata: \"Image Data\",\n  imagebitmap: \"Image Bitmap\",\n\n  // Media\n  mediastream: \"Media Stream\",\n  mediarecorder: \"Media Recorder\",\n  mediastreamtrack: \"Media Stream Track\",\n  audiocontext: \"Audio Context\",\n  audiobuffer: \"Audio Buffer\",\n  audioworklet: \"Audio Worklet\",\n\n  // Workers\n  worker: \"Worker\",\n  sharedworker: \"Shared Worker\",\n  serviceworker: \"Service Worker\",\n  workerglobalscope: \"Worker Global Scope\",\n\n  // Structured Clone / Transferable\n  structuredcloneerror: \"Structured Clone Error\",\n  transferable: \"Transferable\",\n\n  // Testing / Diagnostics\n  report: \"Report\",\n  console: \"Console\",\n  diagnosticreport: \"Diagnostic Report\",\n\n  // Misc\n  domrect: \"DOM Rect\",\n  dompoint: \"DOM Point\",\n  dommatrix: \"DOM Matrix\",\n  domparser: \"DOM Parser\",\n  xmlhttprequest: \"XML HTTP Request\",\n  customelementregistry: \"Custom Element Registry\",\n\n  // additions-ons\n  text: \"Text\",\n  comment: \"Comment\",\n  animation: \"Animation\",\n  documenttype: \"Document Type\",\n  characterdata: \"Character Data\",\n  animationevent: \"Animation Event\",\n  customemmetregistry: \"Custom Emmet Registry\",\n  websocketmessageevent: \"WebSocket Message Event\"\n} as const;\n/** ----------------------------------------------------------\n * * ***Mapping table of JavaScript built-in and environment-specific types.***\n * -----------------------------------------------------------\n * - **Behavior:**\n *     - Maps internal or native type identifiers to **human-readable names** (usually PascalCase).\n *     - Keys are normalized to lowercase and stripped of spaces, dashes, or underscores.\n *     - Extend or modify entries to match your environment or platform.\n *\n * ---\n * - **⚠️ Internal:**\n *     - Used internally by {@link getPreciseType | `getPreciseType`}.\n *     - Not intended for direct use in application code.\n */\nexport const FIXES_RAW_DATA: Readonly<typeof FIXES_RAW> =\n  Object.freeze(FIXES_RAW);\n\nconst TYPE_DATA = [\"-Infinity\", \"Infinity\", \"NaN\"] as const;\n/** ----------------------------------------------------------\n * * ***List of JavaScript special numeric values.***\n * -----------------------------------------------------------\n *\n * - Contains special values recognized by {@link getPreciseType | `getPreciseType`},\n *   such as `\"Infinity\"`, `\"-Infinity\"`, and `\"NaN\"`.\n *\n * ---\n * - **⚠️ Internal:**\n *       - Used by {@link getPreciseType | `getPreciseType`} for numeric edge-case detection.\n */\nexport const SPECIAL_TYPE_DATA: Readonly<typeof TYPE_DATA> =\n  Object.freeze(TYPE_DATA);\n\nconst ACRONYMS = [\n  // Web & Protocols\n  \"URI\",\n  \"URL\",\n  \"URN\",\n  \"HTTP\",\n  \"HTTPS\",\n  \"FTP\",\n  \"FTPS\",\n  \"SFTP\",\n  \"SSH\",\n  \"SMTP\",\n  \"POP3\",\n  \"IMAP\",\n  \"WS\",\n  \"WSS\",\n  \"TCP\",\n  \"UDP\",\n  \"IP\",\n  \"ICMP\",\n  \"ARP\",\n  \"RTP\",\n  \"RTSP\",\n  \"SIP\",\n\n  // Web APIs & Standards\n  \"HTML\",\n  \"XHTML\",\n  \"XML\",\n  \"WBR\",\n  \"CSS\",\n  \"SVG\",\n  \"JSON\",\n  \"JSONP\",\n  \"DOM\",\n  \"IDB\",\n  \"DB\",\n  \"RTC\",\n  \"ICE\",\n  \"TLS\",\n  \"SSL\",\n  \"CORS\",\n  \"WASM\",\n  \"CSR\",\n  \"SSR\",\n  \"PWA\",\n  \"DPI\",\n  \"CDN\",\n\n  // Programming / JS Ecosystem\n  \"JS\",\n  \"TS\",\n  \"JSX\",\n  \"TSX\",\n  \"CLI\",\n  \"API\",\n  \"SDK\",\n  \"UI\",\n  \"UX\",\n  \"OS\",\n  \"ID\",\n  \"UUID\",\n  \"PID\",\n  \"NPM\",\n  \"YARN\",\n  \"ESM\",\n  \"CJS\",\n  \"BOM\",\n  \"MVC\",\n  \"MVVM\",\n  \"ORM\",\n  \"DAO\",\n  \"CRUD\",\n  \"FIFO\",\n  \"LIFO\",\n  \"OOP\",\n  \"FP\",\n  \"REPL\",\n\n  // Data Formats & Types\n  \"CSV\",\n  \"TSV\",\n  \"SQL\",\n  \"YAML\",\n  \"JSON\",\n  \"MD\",\n  \"INI\",\n  \"PDF\",\n  \"XLS\",\n  \"XLSX\",\n  \"RTF\",\n  \"XML\",\n  \"BMP\",\n  \"GIF\",\n  \"PNG\",\n  \"JPEG\",\n  \"WEBP\",\n  \"MP3\",\n  \"MP4\",\n  \"AVI\",\n  \"MOV\",\n  \"FLAC\",\n  \"MKV\",\n  \"WAV\",\n\n  // Common Abbreviations\n  \"URLSearchParams\",\n  \"XHR\",\n  \"2D\",\n  \"3D\",\n  \"GL\",\n  \"WebGL\",\n  \"TTL\",\n  \"UID\",\n  \"GID\",\n  \"MAC\",\n  \"IP\",\n  \"DNS\",\n  \"DHCP\",\n  \"VPN\",\n  \"LAN\",\n  \"WAN\",\n  \"SSID\",\n  \"IoT\",\n  \"API\",\n  \"SDK\",\n  \"CLI\",\n  \"LTS\",\n  \"EOL\",\n\n  // Hardware & Infrastructure\n  \"CPU\",\n  \"GPU\",\n  \"RAM\",\n  \"ROM\",\n  \"SSD\",\n  \"HDD\",\n  \"BIOS\",\n  \"USB\",\n  \"PCI\",\n  \"SATA\",\n  \"DIMM\",\n  \"DDR\",\n  \"VGA\",\n  \"HDMI\",\n  \"KVM\",\n  \"ASIC\",\n  \"FPGA\",\n  \"SoC\",\n  \"NAS\",\n  \"SAN\",\n\n  // Networking\n  \"TCP\",\n  \"UDP\",\n  \"IP\",\n  \"MAC\",\n  \"DNS\",\n  \"DHCP\",\n  \"VPN\",\n  \"LAN\",\n  \"WAN\",\n  \"SSID\",\n  \"NAT\",\n  \"QoS\",\n  \"MPLS\",\n  \"BGP\",\n  \"OSPF\",\n  \"ICMP\",\n  \"IGMP\",\n  \"LLDP\",\n  \"ARP\",\n  \"RARP\",\n\n  // Security\n  \"AES\",\n  \"RSA\",\n  \"OTP\",\n  \"MFA\",\n  \"PKI\",\n  \"VPN\",\n  \"IAM\",\n  \"ACL\",\n  \"CSP\",\n  \"XSS\",\n  \"CSRF\",\n  \"HSTS\",\n  \"WAF\",\n  \"DDoS\",\n  \"IDS\",\n  \"IPS\",\n  \"SOC\",\n  \"SIEM\",\n\n  // Cloud / DevOps / Infrastructure\n  \"AWS\",\n  \"GCP\",\n  \"AZURE\",\n  \"CI\",\n  \"CD\",\n  \"K8S\",\n  \"IaC\",\n  \"PaaS\",\n  \"SaaS\",\n  \"IaaS\",\n  \"API\",\n  \"CLI\",\n  \"SDK\",\n  \"REST\",\n  \"SOAP\",\n  \"JSON-RPC\",\n  \"gRPC\",\n  \"ELB\",\n  \"EKS\",\n  \"AKS\",\n  \"FaaS\",\n  \"CaaS\",\n\n  // User Interface & Tools\n  \"GUI\",\n  \"IDE\",\n  \"FAQ\",\n  \"UX\",\n  \"UI\",\n  \"CLI\",\n  \"API\",\n  \"SDK\",\n  \"LTS\",\n  \"EOL\",\n  \"WYSIWYG\",\n  \"CMS\",\n  \"CRM\",\n\n  // Miscellaneous\n  \"GPS\",\n  \"LED\",\n  \"OLED\",\n  \"LCD\",\n  \"RFID\",\n  \"NFC\",\n  \"CPU\",\n  \"GPU\",\n  \"AI\",\n  \"ML\",\n  \"DL\",\n  \"DB\",\n  \"SQL\",\n  \"NoSQL\",\n  \"ORM\",\n  \"JSON\",\n  \"XML\",\n  \"CSV\",\n  \"HTTP\",\n  \"HTTPS\",\n\n  // Testing & QA\n  \"TDD\",\n  \"BDD\",\n  \"CI\",\n  \"CD\",\n  \"QA\",\n  \"SLA\",\n  \"SLO\",\n  \"MTTR\",\n  \"MTBF\",\n  \"UAT\",\n  \"RPA\",\n\n  // Business & Project Management\n  \"KPI\",\n  \"OKR\",\n  \"ROI\",\n  \"RFP\",\n  \"SLA\",\n  \"CRM\",\n  \"ERP\",\n  \"PMO\",\n  \"SCRUM\",\n  \"KANBAN\",\n\n  // Multimedia & Graphics\n  \"FPS\",\n  \"HDR\",\n  \"VR\",\n  \"AR\",\n  \"3D\",\n  \"2D\",\n  \"MP3\",\n  \"MP4\",\n  \"GIF\",\n  \"PNG\",\n  \"JPEG\",\n  \"SVG\",\n  \"BMP\",\n  \"TIFF\",\n\n  // Operating Systems & File Systems\n  \"POSIX\",\n  \"NTFS\",\n  \"FAT\",\n  \"EXT\",\n  \"EXT4\",\n  \"APFS\",\n  \"HFS\",\n  \"ISO\",\n\n  // Programming Languages & Tools\n  \"HTML\",\n  \"CSS\",\n  \"JS\",\n  \"TS\",\n  \"PHP\",\n  \"SQL\",\n  \"JSON\",\n  \"XML\",\n  \"YAML\",\n  \"BASH\",\n  \"ZSH\",\n  \"JSON\",\n  \"YAML\",\n  \"INI\",\n  \"DOTENV\",\n\n  // Containers & Virtualization\n  \"VM\",\n  \"VMM\",\n  \"VPC\",\n  \"OCI\",\n  \"LXC\",\n  \"Docker\",\n  \"K8S\",\n  \"CRI\",\n  \"CNI\"\n] as const;\n/** ----------------------------------------------------------\n * * ***List of acronyms to keep uppercase in formatted output.***\n * -----------------------------------------------------------\n *\n * - **Behavior:**\n *     - Prevents transformations (like camelCase or kebab-case) from altering\n *       known acronyms such as `HTML`, `URL`, `API`, etc.\n *     - Extend this list if you want more acronyms to remain uppercase.\n *\n * ---\n * - **⚠️ Internal:**\n *       - Used internally by {@link getPreciseType | `getPreciseType`} and related formatters.\n */\nexport const ACRONYMS_DATA: Readonly<typeof ACRONYMS> = Object.freeze(ACRONYMS);\n\n/** ----------------------------------------------------------\n * * ***Type for `FIXES_CASTABLE_TABLE`.***\n * -----------------------------------------------------------\n */\ntype FixesCastableTable = Readonly<Record<string, string>>;\n\n/**\n * @internal Core class utils for `getPreciseType`.\n */\nexport class PreciseType {\n  /**\n   * @internal\n   */\n  private formatCase: GetPreciseTypeOptions[\"formatCase\"] = \"toKebabCase\";\n  /**\n   * @internal\n   */\n  private useAcronyms: GetPreciseTypeOptions[\"useAcronyms\"] = false;\n\n  constructor(params?: GetPreciseTypeOptions) {\n    this.formatCase = params?.formatCase;\n    this.useAcronyms = params?.useAcronyms;\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Normalized lookup table for type mapping.***\n   * -----------------------------------------------------------\n   *\n   * - **Behavior:**\n   *     - Converts all keys from {@link _FIXES_RAW | `FIXES_RAW`} into normalized form\n   *       (lowercased and stripped of separators) for consistent lookup.\n   *     - Values remain the formatted human-readable type names.\n   *\n   * ---\n   * - **⚠️ Internal:**\n   *       - Helper table for {@link getPreciseType | `getPreciseType`} and related matchers.\n   *\n   * ---\n   * @internal ***`Not part of the public API.`***\n   */\n  private static FIXES_CASTABLE_TABLE: FixesCastableTable = Object.freeze(\n    Object.entries(FIXES_RAW_DATA).reduce(\n      (acc, [k, v]) => {\n        acc[PreciseType.normalizeKeyForCase(k)] = v;\n        return acc;\n      },\n      {} as Record<string, string>\n    )\n  ) as Readonly<Record<string, string>>;\n\n  /**\n   * @internal\n   */\n  private determineOptions(options?: GetPreciseTypeOptions) {\n    return {\n      formatCase: options?.formatCase || this.formatCase,\n      useAcronyms: options?.useAcronyms ?? this.useAcronyms\n    };\n  }\n\n  // ------------------------\n  // Helpers for DOM detection\n  // ------------------------\n\n  /**\n   * @internal\n   */\n  private getHtmlElementType(\n    value: unknown,\n    options?: GetPreciseTypeOptions\n  ): string | null {\n    const { formatCase, useAcronyms } = this.determineOptions(options);\n\n    if (typeof HTMLElement === \"undefined\" || !(value instanceof HTMLElement))\n      return null;\n\n    const tagName = value.tagName;\n\n    const DEFAULTS: Record<string, string> = {\n      a: \"Anchor\",\n      abbr: \"Abbreviation\",\n      acronym: \"Acronym\",\n      address: \"Address\",\n      applet: \"Applet\",\n      area: \"Area\",\n      article: \"Article\",\n      aside: \"Aside\",\n      audio: \"Audio\",\n\n      b: \"Bold\",\n      base: \"Base\",\n      basefont: \"Base Font\",\n      bdi: \"BDI\",\n      bdo: \"BDO\",\n      big: \"Big\",\n      blink: \"Blink\",\n      blockquote: \"Blockquote\",\n      body: \"Body\",\n      br: \"Break\",\n      button: \"Button\",\n\n      canvas: \"Canvas\",\n      caption: \"Caption\",\n      center: \"Center\",\n      circle: \"Circle\",\n      cite: \"Cite\",\n      clippath: \"Clip Path\",\n      code: \"Code\",\n      col: \"Column\",\n      colgroup: \"Column Group\",\n\n      data: \"Data\",\n      datalist: \"Datalist\",\n      dd: \"Definition Description\",\n      defs: \"Definitions\",\n      del: \"Deleted Text\",\n      desc: \"Description\",\n      details: \"Details\",\n      dfn: \"Definition\",\n      dialog: \"Dialog\",\n      dir: \"Directory\",\n      div: \"Div\",\n      dl: \"Definition List\",\n      dt: \"Definition Term\",\n\n      ellipse: \"Ellipse\",\n      em: \"Emphasis\",\n      embed: \"Embed\",\n\n      feblend: \"Blend Filter\",\n      fecolormatrix: \"Color Matrix Filter\",\n      fecomponenttransfer: \"Component Transfer Filter\",\n      fecomposite: \"Composite Filter\",\n      feconvolvematrix: \"Convolve Matrix Filter\",\n      fediffuselighting: \"Diffuse Lighting Filter\",\n      fedisplacementmap: \"Displacement Map Filter\",\n      fedistantlight: \"Distant Light Filter\",\n      fedropshadow: \"Drop Shadow Filter\",\n      feflood: \"Flood Filter\",\n      fefunca: \"Function A\",\n      fefuncb: \"Function B\",\n      fefuncg: \"Function G\",\n      fefuncr: \"Function R\",\n      fegaussianblur: \"Gaussian Blur Filter\",\n      feimage: \"Image Filter\",\n      femerge: \"Merge Filter\",\n      femergenode: \"Merge Node Filter\",\n      femorphology: \"Morphology Filter\",\n      feoffset: \"Offset Filter\",\n      fepointlight: \"Point Light Filter\",\n      fespecularlighting: \"Specular Lighting Filter\",\n      fespotlight: \"Spot Light Filter\",\n      fetile: \"Tile Filter\",\n      feturbulence: \"Turbulence Filter\",\n\n      fieldset: \"Fieldset\",\n      figcaption: \"Figcaption\",\n      figure: \"Figure\",\n      filter: \"Filter\",\n      font: \"Font\",\n      footer: \"Footer\",\n      foreignobject: \"Foreign Object\",\n      form: \"Form\",\n      frame: \"Frame\",\n      frameset: \"Frameset\",\n\n      g: \"Group\",\n\n      h1: \"Heading 1\",\n      h2: \"Heading 2\",\n      h3: \"Heading 3\",\n      h4: \"Heading 4\",\n      h5: \"Heading 5\",\n      h6: \"Heading 6\",\n\n      head: \"Head\",\n      header: \"Header\",\n      hr: \"Horizontal Rule\",\n      html: \"HTML\",\n\n      i: \"Italic\",\n      iframe: \"IFrame\",\n      img: \"Image\",\n      input: \"Input\",\n      ins: \"Inserted Text\",\n      isindex: \"Index\",\n\n      kbd: \"Keyboard\",\n      keygen: \"Key Generator\",\n\n      label: \"Label\",\n      legend: \"Legend\",\n      li: \"List Item\",\n      line: \"Line\",\n      lineargradient: \"Linear Gradient\",\n      link: \"Link\",\n      listing: \"Listing\",\n\n      main: \"Main\",\n      map: \"Map\",\n      mark: \"Mark\",\n      marker: \"Marker\",\n      marquee: \"Marquee\",\n      mask: \"Mask\",\n      math: \"Math\",\n      menu: \"Menu\",\n      menuitem: \"Menu Item\",\n      meta: \"Meta\",\n      meter: \"Meter\",\n      mfrac: \"Math Fraction\",\n      mi: \"Math Identifier\",\n      mn: \"Math Number\",\n      mo: \"Math Operator\",\n      mroot: \"Math Root\",\n      mrow: \"Math Row\",\n      ms: \"Math String\",\n      msqrt: \"Math Square Root\",\n      msub: \"Math Subscript\",\n      msubsup: \"Math Subscript Superscript\",\n      msup: \"Math Superscript\",\n      mtext: \"Math Text\",\n      multicol: \"Multicolumn\",\n\n      nav: \"Nav\",\n      nextid: \"Next ID\",\n      nobr: \"No Break\",\n      noembed: \"No Embed\",\n      noframes: \"No Frames\",\n      noscript: \"NoScript\",\n\n      object: \"Object\",\n      ol: \"Ordered List\",\n      optgroup: \"Option Group\",\n      option: \"Option\",\n      output: \"Output\",\n\n      p: \"Paragraph\",\n      param: \"Param\",\n      path: \"Path\",\n      pattern: \"Pattern\",\n      picture: \"Picture\",\n      plaintext: \"Plain Text\",\n      polygon: \"Polygon\",\n      polyline: \"Polyline\",\n      portal: \"Portal\",\n      pre: \"Preformatted\",\n      progress: \"Progress\",\n\n      q: \"Quote\",\n\n      radialgradient: \"Radial Gradient\",\n      rb: \"Ruby Base\",\n      rect: \"Rectangle\",\n      rp: \"RP\",\n      rt: \"RT\",\n      rtc: \"Ruby Text Container\",\n      ruby: \"Ruby\",\n\n      s: \"Strikethrough\",\n      samp: \"Sample\",\n      script: \"Script\",\n      search: \"Search\",\n      section: \"Section\",\n      select: \"Select\",\n      slot: \"Slot\",\n      small: \"Small\",\n      source: \"Source\",\n      spacer: \"Spacer\",\n      span: \"Span\",\n      stop: \"Stop\",\n      strike: \"Strike\",\n      strong: \"Strong\",\n      style: \"Style\",\n      sub: \"Subscript\",\n      summary: \"Summary\",\n      sup: \"Superscript\",\n      svg: \"SVG\",\n      symbol: \"Symbol\",\n\n      table: \"Table\",\n      tbody: \"Table Body\",\n      td: \"Table Data\",\n      template: \"Template\",\n      text: \"SVG Text\",\n      textarea: \"Textarea\",\n      textpath: \"Text Path\",\n      tfoot: \"Table Footer\",\n      th: \"Table Header\",\n      thead: \"Table Head\",\n      time: \"Time\",\n      title: \"Title\",\n      tr: \"Table Row\",\n      track: \"Track\",\n      tspan: \"Text Span\",\n      tt: \"Teletype\",\n\n      u: \"Underline\",\n      ul: \"Unordered List\",\n      use: \"Use\",\n\n      var: \"Variable\",\n      video: \"Video\",\n\n      wbr: \"WBR\",\n\n      xmp: \"XMP\"\n    };\n\n    const normalizeTagName = PreciseType.normalizeKeyForCase(tagName);\n\n    const defaultTagName = DEFAULTS[normalizeTagName];\n    const normalizedName = defaultTagName\n      ?.replace(/^HTML\\s+/i, \"\")\n      .replace(/\\s+Element$/i, \"\");\n\n    const displayName =\n      PreciseType.FIXES_CASTABLE_TABLE[normalizeTagName] ??\n      (normalizedName ? `HTML ${normalizedName} Element` : \"HTML Element\");\n\n    return this.converter(displayName, { formatCase, useAcronyms });\n  }\n\n  /**\n   * @internal\n   */\n  private getCommentNodeType(\n    value: unknown,\n    options?: GetPreciseTypeOptions\n  ): string | null {\n    const { formatCase, useAcronyms } = this.determineOptions(options);\n\n    if (value instanceof Comment) {\n      return this.converter(\n        PreciseType.FIXES_CASTABLE_TABLE[\n          PreciseType.normalizeKeyForCase(\"comment\")\n        ] ?? \"Comment\",\n        { formatCase, useAcronyms }\n      );\n    }\n    return null;\n  }\n\n  /**\n   * @internal\n   */\n  private getTextNodeType(\n    value: unknown,\n    options?: GetPreciseTypeOptions\n  ): string | null {\n    const { formatCase, useAcronyms } = this.determineOptions(options);\n\n    if (value instanceof Text) {\n      return this.converter(\n        PreciseType.FIXES_CASTABLE_TABLE[\n          PreciseType.normalizeKeyForCase(\"text\")\n        ] ?? \"Text\",\n        { formatCase, useAcronyms }\n      );\n    }\n    return null;\n  }\n\n  /**\n   * @internal\n   */\n  private getCDataSectionType(\n    value: unknown,\n    options?: GetPreciseTypeOptions\n  ): string | null {\n    const { formatCase, useAcronyms } = this.determineOptions(options);\n\n    if (value instanceof CDATASection) {\n      return this.converter(\n        PreciseType.FIXES_CASTABLE_TABLE[\n          PreciseType.normalizeKeyForCase(\"cdatasection\")\n        ] ?? \"CDATA Section\",\n        { formatCase, useAcronyms }\n      );\n    }\n\n    return null;\n  }\n\n  /**\n   * @internal\n   */\n  private getOtherNodeType(\n    value: unknown,\n    options?: GetPreciseTypeOptions\n  ): string | null {\n    const { formatCase, useAcronyms } = this.determineOptions(options);\n\n    if (typeof Node !== \"undefined\" && value instanceof Node) {\n      return this.converter(\n        PreciseType.FIXES_CASTABLE_TABLE[\n          PreciseType.normalizeKeyForCase(\"node\")\n        ] ?? \"Node\",\n        { formatCase, useAcronyms }\n      );\n    }\n    return null;\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Retrieves the canonical string representation of a given `Symbol`.***\n   * -----------------------------------------------------------\n   * - **Description:**\n   *     - Converts a JavaScript `Symbol` (including well-known symbols) into a standardized,\n   *       human-readable name string.\n   *     - Maps **well-known symbols** (e.g., `Symbol.iterator`, `Symbol.asyncIterator`, `Symbol.toStringTag`)\n   *       to their corresponding normalized key in {@link PreciseType.castableTable | `castableTable`}.\n   *     - Supports formatted output according to the given `formatCase` and `useAcronyms` options.\n   *     - Falls back to the general `\"Symbol\"` type name if the provided symbol is not recognized.\n   *\n   * ---\n   * - **Example:**\n   *     ```ts\n   *     const precise = new PreciseType();\n   *\n   *     precise.getSymbolName(Symbol.iterator);\n   *     // ➜ \"symbol-iterator\"\n   *\n   *     precise.getSymbolName(Symbol.toStringTag, { formatCase: \"toPascalCase\" });\n   *     // ➜ \"SymbolToStringTag\"\n   *\n   *     precise.getSymbolName(Symbol(\"custom\"));\n   *     // ➜ \"symbol\"\n   *     ```\n   *\n   * ---\n   * - **Options:**\n   *     - `formatCase` ➔ Determines the string case style for the resulting symbol name.\n   *     - `useAcronyms` ➔ Preserves known acronyms (like `URL`, `DOM`, `HTML`) if set to `true`.\n   *\n   * ---\n   * - **⚠️ Internal:**\n   *       - Helper for {@link getPreciseType | `getPreciseType`} that normalizes `Symbol` detection.\n   *       - Not recommended for direct external use.\n   *\n   *\n   * ---\n   * @param value - The `Symbol` instance to analyze.\n   * @param options - Optional settings for case formatting and acronym preservation.\n   *\n   * ---\n   * @returns The formatted symbol name string.\n   *\n   * ---\n   * @internal ***`Not part of the public API.`***\n   */\n  public getSymbolName(value: symbol, options?: GetPreciseTypeOptions): string {\n    const { formatCase, useAcronyms } = this.determineOptions(options);\n\n    // Map Symbol well-known keys to fix name at FIXES_CASTABLE_TABLE\n    const symbolMap = new Map<symbol, string>([\n      [Symbol.iterator, \"symboliterator\"],\n      [Symbol.asyncIterator, \"symbolasynciterator\"],\n      [Symbol.toStringTag, \"symboltostringtag\"],\n      [Symbol.species, \"symbolspecies\"],\n      [Symbol.hasInstance, \"symbolhasinstance\"],\n      [Symbol.isConcatSpreadable, \"symbolisconcatspreadable\"],\n      [Symbol.unscopables, \"symbolunscopables\"],\n      [Symbol.match, \"symbolmatch\"],\n      [Symbol.replace, \"symbolreplace\"],\n      [Symbol.search, \"symbolsearch\"],\n      [Symbol.split, \"symbolsplit\"],\n      [Symbol.toPrimitive, \"symboltoprimitive\"],\n      [Symbol.matchAll, \"symbolmatchall\"]\n    ]);\n\n    const key = symbolMap.get(value);\n    if (key) {\n      return this.converter(\n        PreciseType.FIXES_CASTABLE_TABLE[\n          PreciseType.normalizeKeyForCase(key)\n        ] ?? key,\n        { formatCase, useAcronyms }\n      );\n    }\n\n    // Default fallback for any other symbol\n    return this.converter(\n      PreciseType.FIXES_CASTABLE_TABLE[\n        PreciseType.normalizeKeyForCase(\"symbol\")\n      ] ?? \"Symbol\",\n      { formatCase, useAcronyms }\n    );\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Detects the precise DOM node type of a given value.***\n   * -----------------------------------------------------------\n   * - **Description:**\n   *     - Determines the specific **DOM Node subtype** (e.g., `HTMLDivElement`, `Comment`, `Text`, etc.)\n   *       based on the given input `value`.\n   *     - This method sequentially checks various DOM-related helpers:\n   *       - {@link PreciseType.getHtmlElementType | `getHtmlElementType`}\n   *       - {@link PreciseType.getCommentNodeType | `getCommentNodeType`}\n   *       - {@link PreciseType.getTextNodeType | `getTextNodeType`}\n   *       - {@link PreciseType.getOtherNodeType | `getOtherNodeType`}\n   *     - Returns the first non-null type result found.\n   *     - If no valid DOM node type is detected or an error occurs, it gracefully returns `null`.\n   *\n   * ---\n   * - **Example:**\n   *     ```ts\n   *     const detector = new PreciseType();\n   *     detector.detectDomNodeType(document.createElement(\"div\"));\n   *     // ➜ \"HTMLDivElement\"\n   *\n   *     detector.detectDomNodeType(document.createComment(\"test\"));\n   *     // ➜ \"Comment\"\n   *\n   *     detector.detectDomNodeType(\"not a node\");\n   *     // ➜ null\n   *     ```\n   *\n   * ---\n   * - **Options:**\n   *     - `formatCase` ➔ Controls the output formatting (e.g., `\"toKebabCase\"`, `\"toPascalCase\"`, etc.).\n   *     - `useAcronyms` ➔ Determines if acronyms like `\"HTML\"` or `\"SVG\"` remain uppercase.\n   *\n   * ---\n   * - **⚠️ Internal:**\n   *       - Used internally by {@link getPreciseType | `getPreciseType`} to refine DOM-related type detection.\n   *       - Not intended for direct external use.\n   *\n   *\n   * ---\n   * @param value - The value to be inspected for a DOM node type.\n   * @param options - Optional configuration to adjust case formatting and acronym behavior.\n   *\n   * ---\n   * @returns The detected DOM node type string, or `null` if not applicable.\n   *\n   * ---\n   * @internal ***`Not part of the public API.`***\n   */\n  public detectDomNodeType(\n    value: unknown,\n    options?: GetPreciseTypeOptions\n  ): string | null {\n    const { formatCase, useAcronyms } = this.determineOptions(options);\n\n    try {\n      return (\n        this.getHtmlElementType(value, { formatCase, useAcronyms }) ||\n        this.getCommentNodeType(value, { formatCase, useAcronyms }) ||\n        this.getCDataSectionType(value, { formatCase, useAcronyms }) ||\n        this.getTextNodeType(value, { formatCase, useAcronyms }) ||\n        this.getOtherNodeType(value, { formatCase, useAcronyms })\n      );\n    } catch {\n      return null;\n    }\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Detects whether a given value is a Proxy instance.***\n   * -----------------------------------------------------------\n   * - **Behavior:**\n   *     - Attempts to define and delete a temporary property to trigger potential Proxy traps.\n   *     - Works because most Proxy handlers will throw or behave differently during these operations.\n   *     - Transparent Proxies (without traps) will **not** be detected.\n   *\n   * ---\n   * @description\n   * This method performs a heuristic check — it’s **not foolproof**, but reliably distinguishes\n   * most Proxy-wrapped objects from ordinary ones without using non-standard APIs.\n   *\n   * ---\n   * @param value - The value to inspect.\n   * @returns `true` if the value behaves like a Proxy (throws on property mutation),\n   *          otherwise `false`.\n   *\n   * ---\n   * @example\n   * ```ts\n   * const target = {};\n   * const proxy = new Proxy(target, {});\n   *\n   * console.log(preciseType.isProxy(target)); // false\n   * console.log(preciseType.isProxy(proxy));  // false (transparent proxy)\n   *\n   * const proxyWithTrap = new Proxy(target, {\n   *   set() { throw new Error(\"trap!\"); }\n   * });\n   *\n   * console.log(preciseType.isProxy(proxyWithTrap)); // true\n   * ```\n   *\n   * ---\n   * @note\n   * - Skips built-in native types (like `Array`, `Date`, `Map`, etc.) to prevent false positives.\n   * - This is an **internal heuristic**, not a guaranteed Proxy detector.\n   *\n   * ---\n   * @internal ***`Not part of the public API.`***\n   */\n  public isProxy(value: unknown): boolean {\n    if (isNull(value) || !isObjectOrArray(value)) return false;\n\n    // Exclude built-in types to avoid false positives\n    const tag = Object.prototype.toString.call(value);\n    const skipTags = [\n      \"[object Array]\",\n      \"[object Date]\",\n      \"[object RegExp]\",\n      \"[object Map]\",\n      \"[object Set]\",\n      \"[object WeakMap]\",\n      \"[object WeakSet]\",\n      \"[object Function]\",\n      \"[object Error]\",\n      \"[object Promise]\",\n      \"[object Generator]\",\n      \"[object GeneratorFunction]\",\n      \"[object AsyncFunction]\"\n    ];\n    if (skipTags.includes(tag)) return false;\n\n    try {\n      // Try to define and delete a property; Proxy traps might throw here\n      Reflect.defineProperty(value, \"__proxy_detect__\", {\n        configurable: true,\n        value: 1\n      });\n      Reflect.deleteProperty(value, \"__proxy_detect__\");\n      return false; // If success, it's not Proxy (or proxy without traps on these ops)\n    } catch {\n      return true; // If error, probably Proxy with traps\n    }\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Helper function to convert an input string to a specific casing/format.***\n   * -----------------------------------------------------------\n   * @description\n   * - Chooses the conversion function based on the `formatCase` option.\n   * - Supports multiple casing/formatting functions:\n   *   - `toPascalCaseSpace`.\n   *   - `toPascalCase`.\n   *   - `toCamelCase`.\n   *   - `toKebabCase`.\n   *   - `toSnakeCase`.\n   *   - `toDotCase`.\n   *   - `slugify`.\n   * - Uses `ACRONYMS` as ignored words for certain conversion functions.\n   *\n   * ---\n   * @param {string} input - The string to convert.\n   * @param {GetPreciseTypeOptions[\"formatCase\"]} formatCase - The conversion method to apply.\n   *\n   * ---\n   * @returns {string} The converted string according to the selected format.\n   *\n   * ---\n   * @example\n   * ```ts\n   * converterHelper(\"hello world\", \"toCamelCase\");\n   * // ➔ \"helloWorld\"\n   * ```\n   * ---\n   * @example\n   * ```ts\n   * converterHelper(\"my URL path\", \"slugify\");\n   * // ➔ \"my-URL-path\"\n   * ```\n   *\n   * ---\n   * @internal ***`Not part of the public API.`***\n   */\n  public converter(input: string, options?: GetPreciseTypeOptions): string {\n    const { formatCase, useAcronyms } = this.determineOptions(options);\n\n    const ignoreWord = useAcronyms ? ACRONYMS_DATA : [];\n\n    switch (formatCase) {\n      case \"slugify\":\n        return slugify(input, ignoreWord);\n      case \"toDotCase\":\n        return toDotCase(input, ignoreWord);\n      case \"toCamelCase\":\n        return toCamelCase(input, ignoreWord);\n      case \"toSnakeCase\":\n        return toSnakeCase(input, ignoreWord);\n      case \"toLowerCase\":\n        return toLowerCase(input, ignoreWord);\n      case \"toPascalCase\":\n        return toPascalCase(input, ignoreWord);\n      case \"toPascalCaseSpace\":\n        return toPascalCaseSpace(input, ignoreWord);\n\n      default:\n        return toKebabCase(input, ignoreWord);\n    }\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Normalizes a string key for consistent case-insensitive matching.***\n   * -----------------------------------------------------------\n   * - **Description:**\n   *     - This method removes all **spaces**, **underscores**, and **hyphens** from the given string,\n   *       then converts the result to **lowercase**.\n   *     - Used internally to ensure uniformity in key lookups and matching logic across\n   *       type mapping tables like {@link PreciseType.fixesRaw | `fixesRaw`} and\n   *       {@link PreciseType.castableTable | `castableTable`}.\n   *\n   * ---\n   * - **Example:**\n   *     ```ts\n   *     PreciseType.normalizeKeyForCase(\"Map.Type\");\n   *     // ➔ \"maptype\"\n   *     PreciseType.normalizeKeyForCase(\"Map-Type\");\n   *     // ➔ \"maptype\"\n   *     PreciseType.normalizeKeyForCase(\"Set Type\");\n   *     // ➔ \"settype\"\n   *     PreciseType.normalizeKeyForCase(\"Array_Type\");\n   *     // ➔ \"arraytype\"\n   *     ```\n   *\n   * ---\n   * - **⚠️ Internal:**\n   *       - Helper method used by {@link getPreciseType | `getPreciseType`} and internal mapping constants.\n   *       - Not intended for direct use in user code.\n   *\n   * ---\n   * @param k - The input string key to normalize.\n   *\n   * ---\n   * @returns The normalized lowercase key with all separators removed.\n   *\n   * ---\n   * @internal ***`Not part of the public API.`***\n   */\n  public static normalizeKeyForCase(\n    k: keyof typeof this.fixesRaw | AnyString\n  ): string {\n    return k.replace(/[\\s_\\-.]+/g, \"\").toLowerCase();\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Getting the internal map of type castable relationships used by {@link getPreciseType | `getPreciseType`}.***\n   * -----------------------------------------------------------\n   * - **Description:**\n   *     - Returns an internal static mapping table that defines which primitive or structural types\n   *       can be cast or interpreted as another related type within the internal logic of\n   *       {@link getPreciseType | `getPreciseType`}.\n   *\n   * ---\n   * - **⚠️ Internal:**\n   *       - This is an internal helper of {@link getPreciseType | `getPreciseType`}.\n   *       - Do not modify or rely on this table directly — it is **readonly** and may change without notice.\n   *\n   * ---\n   * @readonly\n   */\n  static get castableTable(): FixesCastableTable {\n    return PreciseType.FIXES_CASTABLE_TABLE;\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Retrieves the internal list of special type cases handled by {@link getPreciseType | `getPreciseType`}.***\n   * -----------------------------------------------------------\n   * - **Description:**\n   *     - Returns an internal readonly list of specific type identifiers that require\n   *       *custom handling* during type detection.\n   *     - These are **exceptional values** or **edge cases** that don’t follow the normal\n   *       JavaScript type resolution flow.\n   *\n   * ---\n   * - **Example Values:**\n   *     - `\"Infinity\"`, `\"-Infinity\"`, `\"NaN\"`, `\"undefined\"`, etc.\n   *\n   * ---\n   * - **⚠️ Internal:**\n   *       - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *       - This property is **readonly** and should not be modified directly.\n   *\n   * ---\n   * @readonly\n   */\n  static get specialType(): Readonly<typeof TYPE_DATA> {\n    return SPECIAL_TYPE_DATA;\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Retrieves the internal mapping of JavaScript built-in and environment-specific\n   * type identifiers to their canonical PascalCase names.***\n   * -----------------------------------------------------------\n   * - **Description:**\n   *     - Provides a mapping table where **keys** represent normalized raw type names\n   *       (as obtained from `Object.prototype.toString.call(value)` or environment checks),\n   *       and **values** represent their **canonical PascalCase equivalents**.\n   *     - This table ensures consistent, human-readable type strings across different environments.\n   *\n   * ---\n   * - **Example Mapping:**\n   *     ```ts\n   *       {\n   *         \"[object Map]\": \"Map\",\n   *         \"[object WeakMap]\": \"WeakMap\",\n   *         \"[object AsyncFunction]\": \"AsyncFunction\",\n   *         \"[object GeneratorFunction]\": \"GeneratorFunction\",\n   *         \"[object BigInt]\": \"BigInt\",\n   *       }\n   *     ```\n   *\n   * ---\n   * - **⚠️ Internal:**\n   *       - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *       - This property is **readonly** and should not be modified directly.\n   *\n   * ---\n   * @readonly\n   */\n  static get fixesRaw(): Readonly<typeof FIXES_RAW> {\n    return FIXES_RAW_DATA;\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Retrieves the internal list of common acronyms that should remain fully uppercase during string formatting.***\n   * -----------------------------------------------------------\n   * - **Description:**\n   *     - This list defines acronyms (e.g., `\"URL\"`, `\"HTTP\"`, `\"HTML\"`, `\"SVG\"`, `\"XML\"`, `\"DOM\"`)\n   *       that will be **preserved in uppercase** when applying case transformations through\n   *       {@link getPreciseType | `getPreciseType`} or any formatting utility using it.\n   *     - Ensures consistency in output for technical identifiers that are conventionally capitalized.\n   *\n   * ---\n   * - **Example:**\n   *     ```ts\n   *       [\"URL\", \"HTTP\", \"HTML\", \"SVG\", \"XML\", \"DOM\"]\n   *     ```\n   *\n   * ---\n   * - **⚠️ Internal:**\n   *       - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *       - This property is **readonly** and not intended for modification.\n   *\n   * ---\n   * @readonly\n   */\n  static get acronymsList(): Readonly<typeof ACRONYMS> {\n    return ACRONYMS_DATA;\n  }\n}\n","import { isNaN } from \"../is/isNaN\";\nimport { isNull } from \"../is/isNull\";\nimport { isError } from \"../is/isError\";\nimport { isObject } from \"../is/isObject\";\nimport { isBuffer } from \"../is/isBuffer\";\nimport { isFunction } from \"../is/isFunction\";\nimport { isPlainObject } from \"../is/isPlainObject\";\nimport { isNumberObject } from \"../is/isNumberObject\";\nimport { isStringObject } from \"../is/isStringObject\";\nimport { isBooleanObject } from \"../is/isBooleanObject\";\nimport { isObjectOrArray } from \"../is/isObjectOrArray\";\nimport { isInfinityNumber } from \"../is/isInfinityNumber\";\n\nimport { ACRONYMS_DATA, PreciseType } from \"./_private/getPreciseType.utils\";\n\n/** ---------------------------------------------------------------------------\n * * ***Options for controlling how {@link getPreciseType | `getPreciseType`} formats and normalizes detected types.***\n * ----------------------------------------------------------------------------\n * These options customize the string transformation behavior and acronym handling\n * when converting JavaScript type names to human-readable strings.\n */\nexport type GetPreciseTypeOptions = {\n  /** -------------------------------------------------------\n   * * ***Specifies the format in which the returned string type should be transformed.***\n   * --------------------------------------------------------\n   * **ℹ️ For special string literals in `SPECIAL_CASES` (`\"-Infinity\" | \"Infinity\" | \"NaN\"`), which will remain unchanged.**\n   *\n   * ---\n   * - #### Supported formats:\n   *    - `\"toKebabCase\"` (default) — words separated by hyphens.\n   *      - ➔ `\"result-example-type\"`.\n   *    - `\"toLowerCase\"` - converts all letters to lowercase.\n   *      - ➔ `\"result example type\"`.\n   *    - `\"toDotCase\"` — words separated by dots.\n   *      - ➔ `\"result.example.type\"`.\n   *    - `\"toCamelCase\"` — first word lowercase, subsequent words capitalized.\n   *      - ➔ `\"resultExampleType\"`.\n   *    - `\"toSnakeCase\"` — words separated by underscores.\n   *      - ➔ `\"result_example_type\"`.\n   *    - `\"toPascalCase\"` — all words capitalized, no spaces.\n   *      - ➔ `\"ResultExampleType\"`.\n   *    - `\"toPascalCaseSpace\"` — all words capitalized with spaces between words.\n   *      - ➔ `\"Result Example Type\"`.\n   *    - `\"slugify\"` — URL-friendly slug (lowercase with hyphens).\n   *      - ➔ `\"result-example-type\"`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * \"toKebabCase\"\n   * ```\n   *\n   * ---\n   * @note\n   * ⚠️ If an invalid value is provided, the function will automatically fallback to the default `\"toKebabCase\"`.\n   */\n  formatCase?:\n    | \"toPascalCaseSpace\"\n    | \"toPascalCase\"\n    | \"toCamelCase\"\n    | \"toKebabCase\"\n    | \"toSnakeCase\"\n    | \"toDotCase\"\n    | \"slugify\"\n    | \"toLowerCase\";\n\n  /** -------------------------------------------------------\n   * * ***Control uppercase preservation of recognized acronyms during formatting.***\n   * --------------------------------------------------------\n   * When enabled (`true`), common technical acronyms (e.g., `\"URL\"`, `\"HTTP\"`, `\"HTML\"`, `\"SVG\"`, `\"XML\"`, `\"DOM\"`)\n   * are preserved in their original uppercase form instead of being lowercased or altered by case-formatting utilities.\n   *\n   * ---\n   * ---\n   * @description\n   * The list of recognized acronyms is defined in {@link AcronymsList | **`AcronymsList`**},\n   * including entries like `\"URL\"`, `\"HTTP\"`, `\"HTML\"`, `\"SVG\"`, `\"XML\"`, `\"DOM\"`, and others.\n   *\n   * ---\n   * - ***Behavior:***\n   *      - #### When `false` (default):\n   *          - Acronyms are treated as normal words and formatted according to the selected `formatCase`.\n   *          - Example:\n   *            - `HTMLDivElement` ➔ `\"html-div-element\"` (with `\"toKebabCase\"`).\n   *            - `DOMParser` ➔ `\"dom-parser\"`.\n   *\n   *      ---\n   *\n   *      - #### When `true`:\n   *          - Acronyms remain uppercase.\n   *          - Example:\n   *            - `HTMLDivElement` ➔ `\"HTML-div-element\"` (with `\"toKebabCase\"`).\n   *            - `DOMParser` ➔ `\"DOM-parser\"`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   *\n   * ---\n   * @note\n   * ⚠️ This option affects **formatting output only**, not the underlying type detection, acronym preservation is applied **after** detecting and formatting the base type name.\n   */\n  useAcronyms?: boolean;\n};\n\n/** ---------------------------------------------------------------------------\n * * ***Type alias for the list of common acronyms preserved in uppercase.***\n * ----------------------------------------------------------------------------\n *\n * Use this type to reference the full set of recognized acronyms\n * used internally by the {@link getPreciseType | **`getPreciseType`**} function for formatting purposes.\n */\nexport type AcronymsList = typeof ACRONYMS_DATA;\n\n/** ----------------------------------------------------------\n * * ***Utility-Predicate: `getPreciseType`.***\n * -----------------------------------------------------------\n * **Returns a detailed and normalized type string for the given value.**\n *\n * ---\n * @description\n * The returned string is human-readable ***toKebabCase*** with spaces ***(by default)*** or formatted according to the `options.formatCase` setting.\n * - **Handles:**\n *     - Primitives (`string`, `number`, `boolean`, `null`, `undefined`, `symbol`, `bigint`).\n *     - Built-in objects (`Array`, `Map`, `Set`, `Error subclasses`, `Typed Arrays`, `etc`).\n *     - Objects created with `Object.create(null)`.\n *     - Objects wrapper (`new String`, `new Number`, `new Boolean`).\n *     - DOM Node type (may not be fully accurate outside the browser environment).\n *     - Generator instances.\n *     - Node.js `Buffer` instances.\n *     - Proxy detection (returns `\"Proxy\"` if detected; detection ***is not 100% accurate***).\n *     - Uses cached mapping table (`FIXES_CASTABLE_TABLE`) for known types to provide consistent naming.\n *     - Falls back to constructor name or `Object.prototype.toString` tag.\n *\n * ---\n * @param {*} value - The value to detect the precise type of.\n * @param {GetPreciseTypeOptions} [options] - Optional configuration.\n * @param {GetPreciseTypeOptions[\"formatCase\"]} [options.formatCase=\"toLowerCase\"]\n *   Specifies how the returned type string should be formatted.\n *      - ⚠️ Special string literals in `SPECIAL_CASES`\n *        (`\"-Infinity\" | \"Infinity\" | \"NaN\"`) will remain\n *        unchanged even if a different `formatCase` is applied.\n * @param {boolean} [options.useAcronyms=false]\n *   Control uppercase preservation of recognized acronyms during formatting.\n *      - When `true`, recognized acronyms such as `\"URL\"`, `\"HTTP\"`, `\"HTML\"`, `\"SVG\"`, `\"XML\"`, and `\"DOM\"`\n *        are preserved in uppercase instead of being lowercased or otherwise transformed.\n *      - When `false` (default), acronyms are formatted like regular words according to `formatCase`.\n *      - ⚠️ This option affects **formatting output only**, not type detection.\n *\n * ---\n * @returns {string} The normalized and formatted type string.\n *\n * ---\n * @example\n * 1. #### Basic Usage:\n *    ```ts\n *    getPreciseType(123);\n *    // ➔ \"number\"\n *    getPreciseType(null);\n *    // ➔ \"null\"\n *    getPreciseType(/regex/);\n *    // ➔ \"reg-exp\"\n *    getPreciseType(/regex/, { formatCase: \"toPascalCase\" });\n *    // ➔ \"RegExp\"\n *    getPreciseType(function* () {}, { formatCase: \"toCamelCase\" });\n *    // ➔ \"generatorFunction\"\n *    getPreciseType(async function () {}, { formatCase: \"toPascalCaseSpace\" });\n *    // ➔ \"Async Function\"\n *    ```\n *    ---\n * 2. #### `SPECIAL_CASES` remain:\n *    ```ts\n *    getPreciseType(NaN, { formatCase: \"toLowerCase\" });\n *    // ➔ \"NaN\"\n *    getPreciseType(Infinity, { formatCase: \"toLowerCase\" });\n *    // ➔ \"Infinity\"\n *    getPreciseType(-Infinity, { formatCase: \"toLowerCase\" });\n *    // ➔ \"-Infinity\"\n *    ```\n *    ---\n * 3. #### `Acronym` usage examples:\n *    ```ts\n *    getPreciseType(new URL(\"https://example.com\"));\n *    // ➔ \"url\"\n *    getPreciseType(new URL(\"https://example.com\"), { useAcronyms: true });\n *    // ➔ \"URL\"\n *    getPreciseType(new URLSearchParams, { formatCase: \"toPascalCase\" });\n *    // ➔ \"UrlSearchParams\"\n *    getPreciseType(new URLSearchParams, { formatCase: \"toPascalCase\", useAcronyms: true });\n *    // ➔ \"URLSearchParams\"\n *    ```\n */\nexport const getPreciseType: (\n  value: unknown,\n  options?: GetPreciseTypeOptions\n) => string = (() => {\n  const cache = new Map<string, PreciseType>();\n  const MAX_CACHE_SIZE = 50;\n\n  return (value: unknown, options: GetPreciseTypeOptions = {}): string => {\n    if (!isPlainObject(options)) options = {};\n\n    // Create a stable cache key\n    const key = JSON.stringify({\n      formatCase: options.formatCase || \"toKebabCase\",\n      useAcronyms: options.useAcronyms ?? false\n    });\n\n    let ClassPrecise = cache.get(key);\n\n    if (!ClassPrecise) {\n      if (cache.size >= MAX_CACHE_SIZE) cache.clear();\n      ClassPrecise = new PreciseType(options);\n      cache.set(key, ClassPrecise);\n    }\n\n    // Handle `null` explicitly because typeof null === \"object\"\n    if (isNull(value)) {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[PreciseType.normalizeKeyForCase(\"null\")] ??\n          \"Null\"\n      );\n    }\n\n    // Handle NaN and Infinity values\n    if (isNaN(value)) return \"NaN\";\n    if (isInfinityNumber(value)) return String(value);\n\n    // Handle wrapper objects like new Number(), new String(), new Boolean(), or BigInt\n    if (typeof BigInt !== \"undefined\" && value === BigInt) {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[\n          PreciseType.normalizeKeyForCase(\"bigint constructor\")\n        ] ?? \"bigint constructor\"\n      );\n    }\n    if (isNumberObject(value) || value === Number) {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[\n          PreciseType.normalizeKeyForCase(\"number constructor\")\n        ] ?? \"number constructor\"\n      );\n    }\n    if (isStringObject(value) || value === String) {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[\n          PreciseType.normalizeKeyForCase(\"string constructor\")\n        ] ?? \"string constructor\"\n      );\n    }\n    if (isBooleanObject(value) || value === Boolean) {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[\n          PreciseType.normalizeKeyForCase(\"boolean constructor\")\n        ] ?? \"boolean constructor\"\n      );\n    }\n\n    // Handle primitive types other than symbol, function, object, or array\n    const prim = typeof value;\n    if (!isObjectOrArray(value) && !isFunction(value) && prim !== \"symbol\") {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[PreciseType.normalizeKeyForCase(prim)] ?? prim\n      );\n    }\n\n    // Handle Symbol types, including special well-known symbols\n    if (prim === \"symbol\") {\n      return ClassPrecise.getSymbolName(value as symbol);\n    }\n\n    // Detect Node.js EventEmitter instances by constructor name\n    if (isObjectOrArray(value) && value.constructor?.name === \"EventEmitter\") {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[\n          PreciseType.normalizeKeyForCase(\"event emitter\")\n        ] ?? \"Event Emitter\"\n      );\n    }\n\n    const domType = ClassPrecise.detectDomNodeType(value);\n    if (domType) return domType;\n\n    // Detect Node.js Buffer instances\n    if (isBuffer(value)) {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[PreciseType.normalizeKeyForCase(\"buffer\")] ??\n          \"Buffer\"\n      );\n    }\n\n    // Detect Proxy objects by attempting to define/delete a property (may throw)\n    if (ClassPrecise.isProxy(value)) {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[PreciseType.normalizeKeyForCase(\"proxy\")] ??\n          \"Proxy\"\n      );\n    }\n\n    // Detect Generator objects by presence of .next and .throw methods\n    if (\n      isObject(value) &&\n      isFunction(value?.next) &&\n      isFunction(value?.throw)\n    ) {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[\n          PreciseType.normalizeKeyForCase(\"generator\")\n        ] ?? \"Generator\"\n      );\n    }\n\n    // Handle Error instances and subclasses, returning their constructor name\n    if (isError(value)) {\n      const ctorName = value.constructor?.name ?? \"Error\";\n      // Try FIXES_CASTABLE_TABLE dictionary with constructor name, else fallback to spaced PascalCase\n      return ClassPrecise.converter(\n        PreciseType.castableTable[PreciseType.normalizeKeyForCase(ctorName)] ??\n          PreciseType.castableTable[\n            PreciseType.normalizeKeyForCase(ctorName.replace(/\\s+/g, \"\"))\n          ] ??\n          ctorName\n      );\n    }\n\n    if (\n      isObjectOrArray(value) &&\n      \"done\" in value &&\n      \"value\" in value &&\n      Object.keys(value).length === 2\n    ) {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[\n          PreciseType.normalizeKeyForCase(\"iterator result\")\n        ] ?? \"iterator result\"\n      );\n    }\n\n    // Handle objects created with `Object.create(null)` which have null prototype\n    if (isNull(Object.getPrototypeOf(value))) {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[PreciseType.normalizeKeyForCase(\"object\")] ??\n          \"Object\"\n      );\n    }\n\n    // Get the internal [[Class]] tag from Object.prototype.toString, e.g. \"Date\", \"Map\"\n    const tag = Object.prototype.toString.call(value).slice(8, -1) || \"Object\";\n\n    // Check if tag has a mapped friendly name in ClassPrecise.FIXES_CASTABLE_TABLE ClassPrecise.dictionary\n    const mapped =\n      PreciseType.castableTable[PreciseType.normalizeKeyForCase(tag)];\n    if (mapped) return ClassPrecise.converter(mapped);\n\n    // Fallback: try to get constructor name and use that if not \"Object\"\n    const ctorName = value?.constructor?.name;\n    if (ctorName && ctorName !== \"Object\") {\n      return ClassPrecise.converter(\n        PreciseType.castableTable[PreciseType.normalizeKeyForCase(ctorName)] ??\n          ctorName\n      );\n    }\n\n    // Final fallback: format the tag string to spaced PascalCase and return\n    return ClassPrecise.converter(tag);\n  };\n})();\n","import type { AnyString, PickStrict, Prettify } from \"@rzl-zone/ts-types-plus\";\n\nimport { isFunction } from \"@/predicates/is/isFunction\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\nimport {\n  type GetPreciseTypeOptions,\n  getPreciseType\n} from \"@/predicates/type/getPreciseType\";\nimport { toKebabCase } from \"@/strings/cases/toKebabCase\";\nimport { PreciseType } from \"@/predicates/type/_private/getPreciseType.utils\";\n\ntype FixedRaw = (typeof PreciseType)[\"fixesRaw\"] & {\n  plainobject: \"plain object\";\n};\ntype RequiredValidType =\n  | Lowercase<FixedRaw[keyof FixedRaw]>\n  | Capitalize<FixedRaw[keyof FixedRaw]>\n  | Uppercase<FixedRaw[keyof FixedRaw]>\n  | AnyString;\n\n/** -----------------------------------------------------------------------------\n * * ***Shape of the object passed to custom error message functions.***\n * ------------------------------------------------------------------------------\n * **This type describes the parameters received when `options.message`\n * is defined as a function in {@link OptionsAssertIs | `OptionsAssertIs`}.**\n *\n * - **Parameter:**\n *      - `currentType` ➔ the actual detected runtime type of the value.\n *      - `validType`   ➔ the required/expected type name that the value must match.\n *\n * @example\n * ```ts\n * const options: OptionsAssertIs = {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got ${currentType}`;\n *   };\n * };\n * ```\n */\nexport type OptionsMessageFunctionAssertIs = {\n  /** ---------------------------------------------------------------------------\n   * * ***The actual runtime type of the value being checked.***\n   * ----------------------------------------------------------------------------\n   * - ***Example:***\n   *      - `\"number\"`, `\"big-int\"`, `\"plain-object\"`, (depends-on `formatCase` options).\n   */\n  currentType: string;\n\n  /** ---------------------------------------------------------------------------\n   * * ***The required/expected type that the value must conform to.***\n   * ----------------------------------------------------------------------------\n   * - ***Example:***\n   *      - `\"boolean\"`, `\"string\"`, `\"big-int\"`, `\"plain-object\"`, (will force format to `kebab-case`).\n   */\n  validType: string;\n};\n\n/** -------------------------------------------------------\n * * ***Custom error-message type for assertions option {@link OptionsAssertIs | `OptionsAssertIs`}.***\n * -------------------------------------------------------\n * - ***Accepts:***\n *      - A static string message.\n *      - A function receiving `{ currentType, validType }` and returning a string.\n */\ntype OptionsMessageAssertIs =\n  | (({ currentType, validType }: OptionsMessageFunctionAssertIs) => string)\n  | string;\n\n/** ---------------------------------------------------------------------------\n * * ***Base options for `assertIs*` functions.***\n * ----------------------------------------------------------------------------\n */\nexport type OptionsAssertIs = Prettify<\n  {\n    /** -----------------------------------------------------------------------\n     * * ***Custom error message for assertion failures.***\n     * ------------------------------------------------------------------------\n     * **This option allows overriding the **default error message** when a value\n     * does not match the required type.**\n     *\n     * - If a **string** is provided:\n     *      - Must be non-empty after trimming.\n     *      - Will be used directly as the error message.\n     * - If a **function** is provided:\n     *      - Receives an object containing:\n     *          - `currentType` ➔ the detected runtime type of the value (depends-on `formatCase` options, e.g., `\"number\"`).\n     *          - `validType`  ➔ the expected type name (with format `kebab-case`, e.g., `\"boolean\"`, `\"big-int\"`, `\"plain-object\"`).\n     *      - **Must** return a **string**:\n     *          - **If** the **returned string is** `empty` or `whitespace`,\n     *            the **default message** will be used instead.\n     *\n     * @example\n     * ```ts\n     * // Static message\n     * { message: \"Must be a boolean!\" }\n     *\n     * // Dynamic message\n     * {\n     *   message: ({ currentType, validType }) => {\n     *     return `Expected ${validType} but got ${currentType}`;\n     *   };\n     * }\n     * ```\n     */\n    message?: OptionsMessageAssertIs;\n\n    /** -----------------------------------------------------------------------\n     * * ***Custom error type for assertion failures.***\n     * ------------------------------------------------------------------------\n     * **This option allows overriding the default error type** that will be thrown\n     * when a value does not match the required type.\n     *\n     * - **Behavior:**\n     *     - Must be one of the standard JavaScript built-in error types:\n     *       `\"Error\" | \"EvalError\" | \"RangeError\" | \"ReferenceError\" | \"SyntaxError\" | \"TypeError\" | \"URIError\"`.\n     *     - **Default:** `\"TypeError\"` if not provided or if an invalid value is passed.\n     *     - The assertion function will **always throw a valid built-in error**, ensuring\n     *       fallback to `TypeError` in case of an unknown or incorrect type.\n     *\n     * @example\n     * ```ts\n     * // Valid: Throw a RangeError instead of TypeError\n     * { errorType: \"RangeError\" }\n     *\n     * // Valid: Throw a ReferenceError\n     * { errorType: \"ReferenceError\" }\n     *\n     * // Invalid value ➔ fallback to TypeError\n     * { errorType: \"SomeUnknownError\" as ErrorType }\n     * ```\n     */\n    errorType?: ErrorType;\n  } & PickStrict<GetPreciseTypeOptions, \"formatCase\" | \"useAcronyms\">,\n  { recursive: false }\n>;\n\ntype ErrorType =\n  | \"Error\"\n  | \"EvalError\"\n  | \"RangeError\"\n  | \"ReferenceError\"\n  | \"SyntaxError\"\n  | \"TypeError\"\n  | \"URIError\";\n\n/** -------------------------------------------------------\n * * ***Throws a JavaScript built-in error based on type.***\n * -------------------------------------------------------\n * **This function asserts and throws a specific built-in error (`ErrorType`) with an optional message.**\n *\n * - **Behavior:**\n *      1. Throws the error corresponding to the `type` argument:\n *          - `\"Error\"` ➔ `Error`.\n *          - `\"EvalError\"` ➔ `EvalError`.\n *          - `\"RangeError\"` ➔ `RangeError`.\n *          - `\"ReferenceError\"` ➔ `ReferenceError`.\n *          - `\"SyntaxError\"` ➔ `SyntaxError`.\n *          - `\"TypeError\"` ➔ `TypeError`.\n *          - `\"URIError\"` ➔ `URIError`.\n *      2. **Default fallback**: If `type` does not match any case, a `TypeError` is thrown.\n * @param {ErrorType} type - The type of error to throw.\n * @param {string} [message] - Optional error message to include in the thrown error.\n * @returns {never} This function never returns; it always throws.\n * @example\n * ```ts\n * // Throw a RangeError with a custom message\n * determineErrorTypeAssertion(\"RangeError\", \"Value out of range!\");\n *\n * // Throw a TypeError with default message\n * determineErrorTypeAssertion(\"TypeError\");\n *\n * // Fallback to TypeError for unknown type (should not occur with proper ErrorType)\n * determineErrorTypeAssertion(\"UnknownType\" as ErrorType, \"Fallback to TypeError\");\n * ```\n * @internal\n */\nconst determineErrorTypeAssertion = (\n  type?: ErrorType,\n  message?: string\n): never => {\n  switch (type) {\n    case \"Error\":\n      throw new Error(message);\n    case \"EvalError\":\n      throw new EvalError(message);\n    case \"RangeError\":\n      throw new RangeError(message);\n    case \"ReferenceError\":\n      throw new ReferenceError(message);\n    case \"SyntaxError\":\n      throw new SyntaxError(message);\n    case \"URIError\":\n      throw new URIError(message);\n    case \"TypeError\":\n      throw new TypeError(message);\n    default:\n      throw new TypeError(message); // default fallback TypeError\n  }\n};\n\ntype ParamsResolveErrorMessageAssertions<T> = {\n  value: T;\n  options?: OptionsAssertIs;\n  requiredValidType: RequiredValidType;\n};\n\n/** ------------------------------------------------------------------------------\n * * ***Resolve a custom error message for type assertions.***\n * -------------------------------------------------------------------------------\n * **Produces the **final error message** used by assertion functions (`assertIs*`).**\n *\n * - **Message resolution follows this order:**\n *      1. **Function message** ➔ If `options.message` is a function, it is invoked with:\n *            - `currentType`: the detected runtime type of `value`.\n *            - `validType`: the required/expected type name.\n *            - If the function returns a non-empty string, it is used, otherwise, the default message is used.\n *      2. **String message** ➔ If `options.message` is a non-empty string, it is used directly.\n *      3. **Fallback** ➔ If no valid message is provided, a default message is generated:\n *          ```ts\n *          \"Parameter input (`value`) must be of type `<validType>`, but received: `<currentType>`.\"\n *          ```\n * @template T - The type of the value being checked.\n * @param {ParamsResolveErrorMessageAssertions<T>} params - Parameters object.\n * @param {ParamsResolveErrorMessageAssertions<T>[\"value\"]} params.value - The value being asserted.\n * @param {ParamsResolveErrorMessageAssertions<T>[\"options\"]} [params.options] - Optional configuration for message and type formatting.\n * @param {ParamsResolveErrorMessageAssertions<T>[\"requiredValidType\"]} [params.requiredValidType] - The required type name that the value should have.\n * @returns A non-empty, trimmed error message string.\n * @example\n * ```ts\n * // 1. Using a static string message\n * const msg = resolveErrorMessageAssertions({\n *   value: 42,\n *   options: { message: \"Must be a boolean!\" },\n *   requiredValidType: \"boolean\"\n * });\n * // ➔ \"Must be a boolean!\"\n *\n * // 2. Using a function to dynamically generate the message\n * const msgFn = resolveErrorMessageAssertions({\n *   value: 42,\n *   options: {\n *     message: ({ currentType, validType }) =>\n *       `Expected ${validType} but got ${currentType}.`\n *   },\n *   requiredValidType: \"boolean\"\n * });\n * // ➔ \"Expected boolean but got number.\"\n *\n * // 3. Without providing a custom message ➔ uses default\n * const defaultMsg = resolveErrorMessageAssertions({\n *   value: 42,\n *   requiredValidType: \"boolean\"\n * });\n * // ➔ \"Parameter input (`value`) must be of type `boolean`, but received: `number`.\"\n * ```\n *\n * @internal\n */\nexport function resolveErrorMessageAssertions<T>(\n  params: ParamsResolveErrorMessageAssertions<T>\n): never {\n  const { requiredValidType, value, options } = params || {};\n\n  const {\n    message,\n    formatCase,\n    useAcronyms,\n    errorType = \"TypeError\"\n  } = isPlainObject(options) ? options : {};\n\n  const validType = toKebabCase(requiredValidType);\n  const currentType = getPreciseType(value, { formatCase, useAcronyms });\n  const messageFnOptions = { currentType, validType };\n\n  const defaultMessage = `Parameter input (\\`value\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n\n  const errorMessage = isFunction(message)\n    ? isNonEmptyString(message(messageFnOptions))\n      ? message(messageFnOptions).trim()\n      : defaultMessage\n    : isNonEmptyString(message)\n      ? message.trim()\n      : defaultMessage;\n\n  return determineErrorTypeAssertion(errorType, errorMessage);\n}\n","import { isBoolean } from \"@/predicates/is/isBoolean\";\nimport {\n  type OptionsAssertIs,\n  resolveErrorMessageAssertions\n} from \"../_private/assertIs\";\n\n/** ---------------------------------------------------------------------------------\n * * ***Type guard assertion: `assertIsBoolean`.***\n * ----------------------------------------------------------------------------------\n * **This function is an **assertion function**.**\n *\n * - **Behavior:**\n *     - Validates that the given `value` is a **boolean**.\n *     - After it returns successfully, TypeScript narrows the type of `value` to `boolean`.\n *     - If `value` is a `boolean` ➔ execution continues normally.\n *     - If `value` is not a `boolean` ➔ throws a built-in error with either:\n *       - A custom error message (`options.message`), or\n *       - A default message including the actual type.\n * - **Error type selection (`options.errorType`):**\n *     - You can override the type of error thrown when validation fails.\n *     - Must be one of the standard JavaScript built-in errors:\n *       - [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) |\n *         [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) |\n *         [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) |\n *         [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) |\n *         [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) |\n *         [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) |\n *         [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError).\n *     - **Default:** `\"TypeError\"` if not provided or invalid.\n *\n * @param {*} value - ***The value to validate.***\n * @param {OptionsAssertIs} [options]\n *  ***Optional configuration:***\n *     - `message`: A custom error message (`string` or `function`).\n *     - `errorType`: A custom built-in JavaScript error type to throw.\n *     - `formatCase`: Controls how detected type names are formatted case in error messages.\n *     - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n *\n * @throws [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) | [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) | [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) | [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) | [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) | [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) | [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError) if the value is not a boolean.\n * @returns {boolean} Narrows `value` to `boolean` if no error is thrown.\n *\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsBoolean(true);\n * // No error, value is boolean\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a boolean\n * assertIsBoolean(\"hello\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `boolean`, but received: `number`.\"\n *\n * // Case 2: The new Boolean() is a Boolean object (constructor), not a primitive boolean\n * assertIsBoolean(new Boolean(true));\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `boolean`, but received: `boolean-constructor`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsBoolean(42, { message: \"Must be boolean!\" });\n * // ➔ TypeError: \"Must be boolean!\"\n *\n * // ❌ Throws RangeError (custom error type)\n * assertIsBoolean(42, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `boolean`, but received: `number`.\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsBoolean(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected boolean but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsBoolean(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected boolean but got (url).\"\n * assertIsBoolean(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected boolean but got (URL).\"\n *\n * // Case 2:\n * assertIsBoolean(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected boolean but got (UrlSearchParams).\"\n * assertIsBoolean(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected boolean but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage example***:\n * ```ts\n * const mixedValue: string | boolean | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `boolean`\n * assertIsBoolean(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be boolean!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `boolean` here\n * const result: boolean = mixedValue; // ➔ Safe type assignment\n * ```\n */\nexport const assertIsBoolean: (\n  value: unknown,\n  options?: OptionsAssertIs\n) => asserts value is boolean = (\n  value: unknown,\n  options?: OptionsAssertIs\n): asserts value is boolean => {\n  if (isBoolean(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"boolean\"\n  });\n};\n","type MessageType = \"warn\" | \"error\" | \"info\";\n\nconst PACKAGE_NAME = \"@rzl-zone/utils-js\";\n\n/** -----------------------------------------------------------------------------\n * * ***Internal Utility: `createMessage`.***\n * ------------------------------------------------------------------------------\n * **Formats a package-scoped message with an optional message type and source.**\n *\n * ---\n * Supported values:\n * - `\"warn\"` ➔ warning message\n * - `\"error\"` ➔ error message\n * - `\"info\"` ➔ informational message\n *\n * ---\n * @param {string} source\n * The utility or API name that generated the message.\n *\n * @param {string} message\n * The message content to format.\n *\n * @param {MessageType} [type]\n * Optional message category to prepend.\n *\n * ---\n * @returns {string}\n * A formatted message string containing:\n * - package name\n * - optional message type\n * - source utility/API name\n * - message content\n *\n * ---\n * @example\n * ```ts\n * createMessage(\n *   \"isNonEmptyString\",\n *   \"Expected a non-empty string.\"\n * );\n * // ➔ \"([@rzl-zone/utils-js] - [isNonEmptyString]) Expected a non-empty string.\"\n *\n * createMessage(\n *   \"isNonEmptyString\",\n *   \"`trim` must be a boolean. Using default value.\",\n *   \"warn\"\n * );\n * // ➔ \"[warn] ([@rzl-zone/utils-js] - [isNonEmptyString]) `trim` must be a boolean. Using default value.\"\n *\n * createMessage(\n *   \"formatEnvPort\",\n *   \"Expected port to be a string.\",\n *   \"error\"\n * );\n * // ➔ \"[error] ([@rzl-zone/utils-js] - [formatEnvPort]) Expected port to be a string.\"\n * ```\n *\n * ---\n * @internal ***`Not part of the public API.`***\n */\nexport function createMessage(\n  source: string,\n  message: string,\n  type?: MessageType\n): string {\n  source = source.trim();\n  message = message.trim();\n\n  const parts = [\n    type && `[${type}]`,\n    `([${PACKAGE_NAME}]`,\n    \"-\",\n    `[${source}])`,\n    message\n  ];\n\n  return parts.filter(Boolean).join(\" \");\n}\n"],"mappings":"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CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;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"}