@rzl-zone/utils-js 3.13.0-beta.2 → 3.13.0

package/dist/{assertIsBoolean-Bv6gL-xe.js.map → assertIsBoolean-9-huIcIR.js.map}

@@ -1 +1 @@
-{"version":3,"file":"assertIsBoolean-Bv6gL-xe.js","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/isNumberObject.ts","../src/predicates/is/isNaN.ts","../src/predicates/is/isNull.ts","../src/assertions/objects/assertIsPlainObject.ts","../src/predicates/is/isNumber.ts","../src/predicates/is/isSymbol.ts","../src/predicates/is/isUndefined.ts","../src/predicates/is/isObjectOrArray.ts","../src/predicates/has/hasOwnProp.ts","../src/predicates/is/isNonEmptyString.ts","../src/predicates/is/isError.ts","../src/predicates/is/isBuffer.ts","../src/predicates/is/isStringObject.ts","../src/predicates/is/isBooleanObject.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"],"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 * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a `boolean`, otherwise `false`.\n * @example\n * isBoolean(true);   // ➔ true\n * isBoolean(false);  // ➔ true\n * isBoolean(\"true\"); // ➔ 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 * - **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 * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if the value is a function.\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 * - **Behavior:**\n *    - Narrows type to `null` or `undefined` when true.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is `null` or `undefined`, otherwise `false`.\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 function 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 * - **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 * @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 * @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 * - **✅ Returns `true` for any non-null object (arrays excluded), including:**\n *    - Plain-objects (`{}`, `Object.create(null)`)\n *    - Custom class instances\n *    - Built-ins: `Date`, `RegExp`, `Error`, `URL`, `URLSearchParams`\n *    - Collections: `Map`, `Set`, `WeakMap`, `WeakSet`\n *    - Binary/typed data: `ArrayBuffer`, `DataView`, typed arrays (`Uint8Array`, `Int32Array`, etc.)\n *    - DOM/Node objects: `HTMLElement`, `DocumentFragment`, etc.\n *    - Proxies (wrapping any object type)\n * - **❌ Returns `false` for:**\n *    - `null`\n *    - Arrays (`[]`, `new Array()`)\n *    - Functions (regular functions, arrow functions, class constructors)\n *    - Primitives: `string`, `number`, `boolean`, `symbol`, `bigint`\n *    - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`\n *    - `undefined` (including `NaN`, which is a primitive number)\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 * @template T - The type of the value being checked.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a ***plain-objects***, otherwise `false`.\n * @example\n * isObject({});                  // ➔ true\n * isObject(Object.create(null)); // ➔ true\n * isObject(new Date());          // ➔ true\n * isObject(new Map());           // ➔ true\n * isObject(new Uint8Array());    // ➔ true\n * isObject(new String(\"x\"));     // ➔ true\n * isObject([]);                  // ➔ false\n * isObject(null);                // ➔ false\n * isObject(undefined);           // ➔ false\n * isObject(123);                 // ➔ false\n * isObject(() => {});            // ➔ 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 * - **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 * @template T - The input type to be asserted as a plain object.\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 * - **A plain object is:**\n *    - Created by the `Object` constructor, or\n *    - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).\n * - **✅ Returns `true` for:**\n *    - Empty object literals: `{}`\n *    - Objects with null prototype: `Object.create(null)`\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 * @template T - The type of the value being checked.\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if `value` is a `plain-object`, otherwise `false`.\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 * - **Behavior:**\n *    - Narrows type to `string` when true.\n *    - Uses the `typeof` operator for strict checking.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a string, otherwise `false`.\n * @example\n * isString(\"hello\"); // ➔ true\n * isString(123);     // ➔ false\n *\n * // Usage in type narrowing\n * const value: unknown = getValue();\n * if (isString(value)) {\n *   // TypeScript now knows `value` is a string\n *   console.log(value.toUpperCase());\n * }\n */\nexport const isString = (value: unknown): value is string => {\n  return typeof value === \"string\";\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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a `Number` object.\n * @example\n * isNumberObject(new Number(42));\n * // ➔ true\n * isNumberObject(42);\n * // ➔ false\n */\nexport function 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 * - **ℹ️ 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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\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 function 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 * - **Behavior:**\n *    - Narrows type to `null` when true.\n *    - Strictly compares the value against `null`.\n * @param {*} val - The value to check.\n * @returns {boolean} Returns `true` if the value is `null`, otherwise `false`.\n * @example\n * isNull(null);      // ➔ true\n * isNull(0);         // ➔ false\n * isNull(undefined); // ➔ false\n */\nexport const isNull = (val: unknown): val is null => val === null;\n","import {\n  isPlainObject,\n  type IsPlainObjectResult\n} from \"@/predicates/is/isPlainObject\";\nimport {\n  type OptionsAssertIs,\n  resolveErrorMessageAssertions\n} from \"../_private/assertIs\";\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsPlainObject`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **plain-object**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `plain-object` **(generic support)**.\n *    - ✅ If `value` is a `plain-object` ➔ execution continues normally.\n *    - ❌ If `value` is not a `plain-object` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n * - **A valid `plain object` is:**\n *    - Created by the `Object` constructor, or\n *    - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).\n *     - **✅ Returns `undefined` (valid) for:**\n *         - Empty object literals: `{}`\n *         - Objects with null prototype: `Object.create(null)`\n *     - **❌ Returns `throws` 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 * - **⚠️ 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 * @template T - The input type being asserted.\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`: Built-in JavaScript error type to throw on failure (default `\"TypeError\"`).\n *    - `formatCase`: Controls how detected type names are formatted case in error messages.\n *    - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n * @returns {boolean} Narrows `value` to a `plain-object` **(generic support)** if no error is thrown.\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 `value` is not a plain-object.\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsPlainObject({ a: 1, b: 2 });\n * // No error, value is plain-object\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a plain-object\n * assertIsPlainObject(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `string`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsPlainObject(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsPlainObject(\"123\", { message: \"Must be a plain-object!\" });\n * // ➔ TypeError: \"Must be a plain-object!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsPlainObject(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected plain-object but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsPlainObject(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (url).\"\n * assertIsPlainObject(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URL).\"\n *\n * // Case 2:\n * assertIsPlainObject(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (UrlSearchParams).\"\n * assertIsPlainObject(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage with generic narrowing***:\n * ```ts\n * type User = { name: string; email: string };\n * const mixedValue: string | User | boolean | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `plain-object`\n * assertIsPlainObject(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be plain object!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `User` here\n * const user: User = mixedValue; // ➔ Safe type assignment\n * console.log(user.email);       // ➔ Safe to access object properties\n * ```\n */\nexport function assertIsPlainObject<T>(\n  value: T,\n  options: OptionsAssertIs = {}\n): asserts value is IsPlainObjectResult<T> {\n  if (isPlainObject(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"plain object\"\n  });\n}\n","// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { isFinite } from \"./isFinite\";\n\nimport { isBoolean } from \"./isBoolean\";\nimport { isPlainObject } from \"./isPlainObject\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nexport type IsNumberOptions = {\n  /** If set to `true`, `NaN` will be considered a valid number, defaultValue: `false`.\n   *\n   * @default false\n   */\n  includeNaN?: boolean;\n};\n\n/** ---------------------------------------------------------\n * * ***Type guard: `isNumber`.***\n * ----------------------------------------------------------\n * **Checks if a value is of type **`number`**.**\n * - **Behavior:**\n *    - Uses `typeof value === \"number\"`.\n *    - By default, excludes **`NaN`**.\n *    - If `options.includeNaN` is `true`, then **`NaN`** is also considered valid.\n *    - Still considers `Infinity` and `-Infinity` as **numbers** (consistent with JavaScript).\n * - **ℹ️ Note:**\n *    - To exclude `Infinity` and `-Infinity`, use **{@link isFinite | `isFinite`}** instead.\n * @param {*} value - The value to check.\n * @param {IsNumberOptions} [options] - Optional settings.\n * @param {boolean} [options.includeNaN=false]  If `true`, `NaN` will be considered a valid number, defaults to `false`, which excludes `NaN`.\n * @returns {boolean} Returns `true` if the value is a number (and depending on `includeNaN`, `NaN` is included or excluded).\n * @example\n * isNumber(42);\n * // ➔ true\n * isNumber(Infinity);\n * // ➔ true\n * isNumber(-Infinity);\n * // ➔ true\n * isNumber(NaN);\n * // ➔ false (default)\n * isNumber(NaN, { includeNaN: true });\n * // ➔ true\n * isNumber(\"42\");\n * // ➔ false\n */\nexport const isNumber = (\n  value: unknown,\n  options: IsNumberOptions = {}\n): value is number => {\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const includeNaN =\n    isPlainObject(options) && isBoolean(options.includeNaN)\n      ? options.includeNaN\n      : false;\n\n  assertIsBoolean(includeNaN, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`includeNaN\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const aNumber = typeof value === \"number\";\n  return includeNaN ? aNumber : aNumber && !Number.isNaN(value);\n};\n","/** ----------------------------------------------------------\n * * ***Type guard: `isSymbol`.***\n * ----------------------------------------------------------\n * **Checks if a value is of type\n * **[`symbol`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/Symbol)**.**\n * - **Behavior:**\n *    - Narrows type to `symbol` when true.\n *    - Uses the `typeof` operator for strict checking.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a symbol, otherwise `false`.\n * @example\n * isSymbol(Symbol(\"id\"));   // ➔ true\n * isSymbol(\"not a symbol\"); // ➔ false\n * isSymbol(123);            // ➔ false\n * isSymbol(undefined);      // ➔ false\n */\nexport const isSymbol = (value: unknown): value is symbol => {\n  return typeof value === \"symbol\";\n};\n","/** ---------------------------------------------------------\n * * ***Type guard: `isUndefined`.***\n * ----------------------------------------------------------\n * **Checks if a value is\n * **[`undefined`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)**.**\n * - **Behavior:**\n *    - Narrows type to `undefined` when true.\n *    - Excludes `null`, `objects`, `arrays`, `strings`, `numbers`, and\n *      `all other values`.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is `undefined`, otherwise `false`.\n * @example\n * isUndefined(undefined); // ➔ true\n * isUndefined([]);        // ➔ false\n * isUndefined(123);       // ➔ false\n * isUndefined(null);      // ➔ false\n * isUndefined(\"abc\");     // ➔ false\n */\nexport const isUndefined = (value: unknown): value is undefined => {\n  return typeof value === \"undefined\";\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 * - **✅ Returns `true` for:**\n *    - Plain objects (`{}`, `Object.create(null)`)\n *    - Custom objects\n *    - Arrays (`[]`, `[1,2,3]`)\n * - **❌ Returns `false` for:**\n *    - `null`\n *    - `undefined`\n *    - Primitives:\n *        - `string`\n *        - `number`\n *        - `boolean`\n *        - `symbol`\n *        - `bigint`\n *    - Functions\n * @template T - The type of the value being checked.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is an `object` or `array`.\n * @example\n * isObjectOrArray([1,2,3]);           // ➔ true\n * isObjectOrArray({ name: \"Alice\" }); // ➔ true\n * isObjectOrArray(null);              // ➔ false\n * isObjectOrArray(undefined);         // ➔ false\n * isObjectOrArray(\"hello\");           // ➔ 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 type {\n  AnyFunction,\n  AnyString,\n  IsAny,\n  IsStringLiteral\n} from \"@rzl-zone/ts-types-plus\";\nimport type {\n  DeepRequiredSymbolHasOwnProp,\n  GuardedHasOwnProp,\n  HasOwnPropOptions,\n  NestedKeyOfHasOwnProp,\n  SmartDetectArrayFuncHasOwnProp,\n  SmartDetectUnknownKeyHasOwnProp,\n  NumericKeyHasOwnPropMapped,\n  NumericKeyOfHasOwnProp,\n  SmartDetectStringHasOwnProp\n} from \"./hasOwnProp.types\";\n\nimport { isNaN } from \"../is/isNaN\";\nimport { isNull } from \"../is/isNull\";\nimport { isString } from \"../is/isString\";\nimport { isNumber } from \"../is/isNumber\";\nimport { isSymbol } from \"../is/isSymbol\";\nimport { isFunction } from \"../is/isFunction\";\nimport { isUndefined } from \"../is/isUndefined\";\nimport { isObjectOrArray } from \"../is/isObjectOrArray\";\nimport { type IsPlainObjectResult } from \"../is/isPlainObject\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\n// ------------------- HAS OWN PROP OVERLOADS -------------------\n\n/** -------------------------------------------------------\n * * ***Predicate: `hasOwnProp`.***\n * -------------------------------------------------------\n * **A **type-safe** replacement for `Object.prototype.hasOwnProperty` with runtime validation and **TypeScript-aware type narrowing**.**\n * - #### Supported Targets:\n *    - **Plain objects** ➔ `{ foo: \"bar\" }`.\n *    - **Arrays** ➔ `[ { id: 1 }, { id: 2 } ]`.\n *    - **Strings** ➔ `\"hello\"` (as array-like objects with `.length`, index, etc.).\n *    - **Functions** ➔ callable objects with extra props.\n *    - **Symbols** ➔ own property symbols.\n * - #### Key Advantages over `in` or `obj.hasOwnProperty(key)`:\n *    - Supports **dot/bracket path notation** (e.g. `\"user.address.city\"`, `\"addresses[0].zip\"`).\n *    - Handles **symbol** keys safely.\n *    - **Narrows** the type of `obj` in TypeScript (stronger type safety).\n *    - Configurable handling of **`undefined`** and **`null`**.\n * - #### Runtime Behavior:\n *    - ***✅ Returns `true` if:***\n *        - Value `obj` is an object/array/string/function **and** the property\n *          exists **and**, it passes the `options` checks.\n *    - ***❌ Returns `false` if:***\n *        - Value `obj` is not a valid type.\n *        - The property does not exist.\n *        - The value is `undefined` and `discardUndefined: true` (**default**).\n *        - The value is `null` and `discardNull: true`.\n *        - The `key` (after trimming) is an **empty string** ➔ treated as **invalid**.\n * - #### TypeScript Behavior:\n *    - ***Inside an `if (hasOwnProp(...)) {}` block:***\n *      - The property is **guaranteed to exist**.\n *      - Depending on `options`, the property type is narrowed to exclude\n *        `undefined` and/or `null`.\n * - #### ⚠️ Caveats:\n *    - ***Empty keys are invalid:***\n *        - If the `key` string is empty (`\"\"`) after trimming whitespace or other characters,\n *          it will **not** be considered a valid property and always returns `false`.\n *    - ***Arrays are limited by TypeScript inference:***\n *        - Checking index `[0]` only narrows **that specific index**, not the rest, example:\n *          1. `hasOwnProp(users, \"[0].id\")` does **not** imply `users[1].id` exists.\n *              - 👉 For different indices, use **optional chaining** (`users[1]?.id`).\n *    - ***Autocomplete limitation for array indices:***\n *        - Autocompletion for `[index]` is only supported up to **25** (`[0]` ➔ `[24]`).\n *        - This limit is intentional for **performance and safety:**\n *          1. Generating infinite union types for all possible indices would cause\n *            **TypeScript IntelliSense to hang or crash**.\n *              - ℹ️ You can still check higher indices manually (e.g. `\"[999].id\"`),\n *                but they will not show up in IntelliSense suggestions.\n * @param {HasOwnPropOptions} [options] - ***Optional configuration object.***\n * @param {HasOwnPropOptions[\"discardUndefined\"]} [options.discardUndefined=true]\n *  ***If `true`, properties with `undefined` values are treated as **missing**, default: `true`.***\n * @param {HasOwnPropOptions[\"discardNull\"]} [options.discardNull=false]\n *  ***If `true`, properties with `null` values are treated as **missing**, default: `false`.***\n * @param {*} obj ***The `object`, `array`, `string`, `function`, or `other value` to check against.***\n * @param {PropertyKey} key\n *  ***The property key to check, can be:***\n *    - `string` (supports dot/bracket paths, e.g. `\"user.address.city\"`, `\"[0].id\"`).\n *    - `number` (array-like index).\n *    - `symbol` (own property symbols).\n * @returns {boolean} Return `true` if the property exists (and passes `options`), otherwise `false`.\n * @example\n *\n * - #### ✅ Objects:\n * ```ts\n *    const obj: { name?: string | null } = {};\n *\n *    if (hasOwnProp(obj, \"name\")) {\n *      // obj is now ➔ { name: string | null }\n *      console.log(obj.name); // string | null\n *    }\n *\n *    if (hasOwnProp(obj, \"name\", { discardUndefined: true, discardNull: true })) {\n *      // obj is now ➔ { name: string }\n *      console.log(obj.name.toUpperCase()); // safe\n *    }\n * ```\n * - #### ✅ Arrays:\n * ```ts\n *    const users = [{ id: 1 }, { id: 2 }];\n *\n *    if (hasOwnProp(users, \"[1].id\")) {\n *      // ➔ users[1].id is guaranteed to exist\n *      console.log(users[1].id); // number\n *    }\n *\n *    // ⚠️ Caveat: narrowing only applies to checked index\n *    if (hasOwnProp(users, \"[0].id\")) {\n *      console.log(users[0].id); // ✅ safe\n *      console.log(users[1].id); // ❌ not guaranteed!\n *    }\n *\n *    // 👉 Solution: optional chaining\n *    console.log(users[1]?.id); // ➔ safe, even without narrowing\n * ```\n *\n * - #### ✅ Symbols:\n * ```ts\n *    const secret = Symbol(\"secret\");\n *    const obj2 = { [secret]: 42 };\n *\n *    if (hasOwnProp(obj2, secret)) {\n *      console.log(obj2[secret] + 1); // ➔ 43\n *    }\n * ```\n * - #### ✅ Strings:\n * ```ts\n *    if (hasOwnProp(\"hello\", \"length\")) {\n *      console.log(\"hello\".length); // ➔ 5\n *    }\n *\n *    if (hasOwnProp(\"hello\", 1)) {\n *      console.log(\"hello\"[1]); // ➔ \"e\"\n *    }\n * ```\n * - #### ✅ Functions:\n * ```ts\n *    function fn() {}\n *    fn.extra = 123;\n *\n *    if (hasOwnProp(fn, \"extra\")) {\n *      console.log(fn.extra); // ➔ 123\n *    }\n * ```\n * - #### ❌ Empty key:\n * ```ts\n *    const obj = { a: 1 };\n *\n *    hasOwnProp(obj, \"\");    // ➔ false (invalid key)\n *    hasOwnProp(obj, \"   \"); // ➔ false (trimmed to empty)\n * ```\n */\nexport function hasOwnProp<Obj>(\n  obj: IsAny<Obj> extends true ? Obj : never,\n  key: PropertyKey,\n  options?: HasOwnPropOptions<boolean, boolean>\n  /** @ts-expect-error we force `any` to `unknown` at result */\n): obj is unknown;\n\nexport function hasOwnProp<Obj extends null | undefined>(\n  obj: Obj,\n  key: PropertyKey,\n  options?: HasOwnPropOptions<boolean, boolean>\n): false;\n\nexport function hasOwnProp<\n  Obj extends object | AnyFunction,\n  Key extends NestedKeyOfHasOwnProp<Obj>,\n  DiscardUndefined extends boolean = true,\n  DiscardNull extends boolean = false\n>(\n  obj: Obj | null | undefined,\n  key: Key,\n  options?: HasOwnPropOptions<DiscardUndefined, DiscardNull>\n  /** @ts-expect-error we force to override recursive type result */\n): obj is GuardedHasOwnProp<Obj, Key, DiscardUndefined, DiscardNull>;\n\nexport function hasOwnProp<\n  Obj extends object,\n  Num extends NumericKeyOfHasOwnProp<Obj>,\n  DiscardUndefined extends boolean = true,\n  DiscardNull extends boolean = false\n>(\n  obj: Obj | null | undefined,\n  key: Num,\n  options?: HasOwnPropOptions<DiscardUndefined, DiscardNull>\n  /** @ts-expect-error we force to override recursive type result */\n): obj is NumericKeyHasOwnPropMapped<Obj, Num, DiscardUndefined, DiscardNull>;\n\nexport function hasOwnProp<\n  Obj extends object | AnyFunction,\n  Sym extends symbol,\n  DiscardUndefined extends boolean = true,\n  DiscardNull extends boolean = false\n>(\n  obj: Obj | null | undefined,\n  key: Sym,\n  options?: HasOwnPropOptions<DiscardUndefined, DiscardNull>\n  /** @ts-expect-error we force to override recursive type result */\n): obj is DeepRequiredSymbolHasOwnProp<Obj, Sym, DiscardUndefined, DiscardNull>;\n\nexport function hasOwnProp<\n  Obj extends string | null | undefined,\n  Key extends string | number\n>(\n  obj: Obj | null | undefined,\n  key: Key,\n  options?: HasOwnPropOptions<boolean, boolean>\n  /** @ts-expect-error we force to override recursive type result */\n): obj is IsStringLiteral<SmartDetectStringHasOwnProp<Obj, Key>> extends true\n  ? AnyString | SmartDetectStringHasOwnProp<Obj, Key>\n  : SmartDetectStringHasOwnProp<Obj, Key>;\n\nexport function hasOwnProp<\n  Obj extends unknown[] | AnyFunction,\n  Key extends PropertyKey\n>(\n  obj: Obj,\n  key: Key,\n  options?: HasOwnPropOptions<boolean, boolean>\n): obj is SmartDetectArrayFuncHasOwnProp<Obj, Key>;\n\nexport function hasOwnProp<\n  Obj extends unknown | AnyFunction,\n  Key extends PropertyKey,\n  DiscardUndefined extends boolean = true,\n  DiscardNull extends boolean = false\n>(\n  obj: Obj,\n  key:\n    | Key\n    | \"length\"\n    | (IsPlainObjectResult<Obj> extends never ? never : keyof Obj),\n  options?: HasOwnPropOptions<DiscardUndefined, DiscardNull>\n  /** @ts-expect-error we force to override recursive type result */\n): obj is SmartDetectUnknownKeyHasOwnProp<\n  Obj,\n  Key,\n  DiscardUndefined,\n  DiscardNull\n>;\n\n// ------------------- IMPLEMENTATION -------------------\nexport function hasOwnProp(\n  obj: unknown,\n  key: PropertyKey,\n  options: HasOwnPropOptions<boolean, boolean> = {}\n): unknown {\n  if (!isString(obj) && !isObjectOrArray(obj) && !isFunction(obj)) return false;\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Third parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  // defaults: undef ➔ true, null ➔ false\n  const discardUndefined =\n    options.discardUndefined === undefined ? true : options.discardUndefined;\n  const discardNull =\n    options.discardNull === undefined ? false : options.discardNull;\n\n  assertIsBoolean(discardUndefined, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`discardUndefined\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  assertIsBoolean(discardNull, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`discardNull\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  // Parse key ➔ path\n  const path: (string | number | symbol)[] = [];\n  //todo: keep use manually check for length string value for avoid Maximum infinity loop function.!!!\n  if (\n    (isString(key) && key.trim().length > 0) ||\n    isNumber(key, { includeNaN: true })\n  ) {\n    const strKey = isNumber(key, { includeNaN: true }) ? String(key) : key;\n    strKey.split(\".\").forEach((k) => {\n      const bracketMatch = k.match(/^\\[(\\d+)\\]$/);\n      const symbolMatch = k.match(/^Symbol\\((.+)\\)$/);\n      if (bracketMatch) path.push(Number(bracketMatch[1]));\n      else if (symbolMatch) path.push(Symbol.for(symbolMatch[1]));\n      else if (!isNaN(Number(k))) path.push(Number(k));\n      else path.push(k);\n    });\n  } else if (isSymbol(key)) {\n    path.push(key);\n  } else {\n    return false;\n  }\n\n  // Traverse\n  let current: unknown =\n    isString(obj) && obj.trim().length > 0 ? Object(obj) : obj;\n  for (const k of path) {\n    if (\n      (isString(k) && k.trim().length > 0) ||\n      isNumber(k, { includeNaN: true })\n    ) {\n      if (\n        isNull(current) ||\n        !Object.prototype.hasOwnProperty.call(current, k)\n      ) {\n        return false;\n      }\n      current = (current as Record<PropertyKey, unknown>)[k];\n    } else if (isSymbol(k)) {\n      if (\n        isNull(current) ||\n        (typeof current !== \"object\" && !isFunction(current))\n      ) {\n        return false;\n      }\n      const symbols = Object.getOwnPropertySymbols(current);\n      const matched = symbols.find(\n        (s) => s === k || s.description === k.description\n      );\n      if (!matched) return false;\n      current = (current as Record<PropertyKey, unknown>)[matched];\n    } else {\n      return false;\n    }\n  }\n  // early fail for undefined if requested\n  if (discardUndefined && isUndefined(current)) return false;\n\n  // final null check (only if requested)\n  if (discardNull && isNull(current)) return false;\n\n  return true;\n}\n","import { isString } from \"./isString\";\nimport { hasOwnProp } from \"../has/hasOwnProp\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype IsNonEmptyStringOptions = {\n  /** Whether to trim the string before checking, defaultValue: `true`.\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 * @description\n * Determines whether the given `value` is a string containing at least one non-whitespace character, with optional trimming behavior.\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 * @param {*} value - The value to test.\n * @param {IsNonEmptyStringOptions} [options] - Optional settings.\n * @param {boolean} options.trim - If `true`, trims the string before checking, defaults: `true`.\n * @returns {boolean} Return `true` if `value` is a non-empty string, otherwise `false`.\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\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const trim = hasOwnProp(options, \"trim\") ? options.trim : true;\n\n  assertIsBoolean(trim, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`trim\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const str = trim ? value.trim() : value;\n\n  return str.length > 0;\n};\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 * - **Behavior:**\n *    - Ensures that the provided value is a valid JavaScript error instance.\n *    - Useful in TypeScript for narrowing types during error handling.\n * @param {*} error - The value to check.\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 * @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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a `Buffer`, else `false`.\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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a `String` object.\n * @example\n * isStringObject(new String(\"hello\"));\n * // ➔ true\n * isStringObject(\"hello\");\n * // ➔ false\n */\nexport function 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 * @param {*} value The value to check.\n * @returns {value is Boolean} Returns `true` if `value` is a `Boolean` object.\n * @example\n * isBooleanObject(new Boolean(true));\n * // ➔ true\n * isBooleanObject(true);\n * // ➔ false\n */\nexport function isBooleanObject(value: unknown): value is Boolean {\n  return (\n    isObject(value) &&\n    Object.prototype.toString.call(value) === \"[object Boolean]\"\n  );\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 * - **ℹ️ 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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `Infinity` or `-Infinity`, else `false`.\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 function 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 * - **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 * @template T - The type of the value being checked.\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if value is a non-empty array.\n * @example\n * isNonEmptyArray([1, 2, 3]); // ➔ true\n * isNonEmptyArray([]);        // ➔ false\n * isNonEmptyArray(null);      // ➔ false\n * isNonEmptyArray(\"test\");    // ➔ 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 * - **Behavior:**\n *    - Narrows type to `Set<T>` when true.\n *    - Excludes `WeakSet`, arrays, plain objects, and other non-Set values.\n * @template T - The type of the value being checked.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a `Set`, otherwise `false`.\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 * - **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 * @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 * @returns {string} The slugified string.\n * @example\n * // Basic usage\n * slugify(\"Hello World!\");\n * // ➔ \"hello-world\"\n *\n * // Array input is joined before conversion\n * slugify([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"join-words-here\"\n *\n * // Trims and cleans input\n * slugify(\" --- Convert to Slug? --- \");\n * // ➔ \"convert-to-slug\"\n *\n * // Ignore single word\n * slugify(\"This URL path\", \"URL\");\n * // ➔ \"this-URL-path\"\n *\n * // Ignore multiple words\n * slugify(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignore-API-and-URL\"\n *\n * // Ignore using Set\n * slugify(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignore-API-and-URL\"\n *\n * // Supports emojis and symbols\n * slugify(\"🔥 Fire_and_ice ❄️\");\n * // ➔ \"fire-and-ice\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\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 * - **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 * @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 * @returns {string} The dot.case formatted string.\n * @example\n * // Basic usage\n * toDotCase(\"Hello World\");\n * // ➔ \"hello.world\"\n *\n * // Array input is joined before conversion\n * toDotCase([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"join.words.here\"\n *\n * // Handles underscores and hyphens\n * toDotCase(\"convert-to_dot case\");\n * // ➔ \"convert.to.dot.case\"\n *\n * // Multiple delimiters and trimming\n * toDotCase(\"___Hello--World__ again!!\");\n * // ➔ \"hello.world.again\"\n *\n * // Supports emojis and symbols\n * toDotCase(\"🔥Fire_and-ice❄️\");\n * // ➔ \"fire.and.ice\"\n *\n * // Ignore single word\n * toDotCase(\"this URL path\", \"URL\");\n * // ➔ \"this.URL.path\"\n *\n * // Ignore multiple words\n * toDotCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignore.API.and.URL\"\n *\n * // Ignore using Set\n * toDotCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignore.API.and.URL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toDotCase(undefined);\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 * - **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 * @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 * @returns {string} The camelCase formatted string.\n * @example\n * // Basic usage\n * toCamelCase(\"hello world\");\n * // ➔ \"helloWorld\"\n *\n * // Array input is joined before conversion\n * toCamelCase([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"joinWordsHere\"\n *\n * // Supports mixed delimiters\n * toCamelCase(\"convert_to-camel case\");\n * // ➔ \"convertToCamelCase\"\n *\n * // Words in ignoreWord stay unchanged\n * toCamelCase(\"this URL path will ignore\", \"URL\");\n * // ➔ \"thisURLPathWillIgnore\"\n *\n * // Multiple ignored words\n * toCamelCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignoreAPIAndURL\"\n *\n * // Set can also be used\n * toCamelCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignoreAPIAndURL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toCamelCase(null);\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 * - **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 * @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 * @returns {string} The kebab-case formatted string.\n * @example\n * // Basic usage\n * toKebabCase(\"Hello World\");\n * // ➔ \"hello-world\"\n *\n * // Array input is joined before conversion\n * toKebabCase([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"join-words-here\"\n *\n * // Handles underscores and hyphens\n * toKebabCase(\"convert_to-kebab case\");\n * // ➔ \"convert-to-kebab-case\"\n *\n * // Handles emojis and symbols\n * toKebabCase(\"🔥fire___and--ice❄️\");\n * // ➔ \"fire-and-ice\"\n *\n * // Ignore specific word\n * toKebabCase(\"ignore URL case\", \"URL\");\n * // ➔ \"ignore-URL-case\"\n *\n * // Ignore multiple words\n * toKebabCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignore-API-and-URL\"\n *\n * // Ignore with Set\n * toKebabCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignore-API-and-URL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toKebabCase(null);\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 * - **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 * @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 * @returns {string} The snake_case formatted string.\n * @example\n * // Basic usage\n * toSnakeCase(\"Hello World\");\n * // ➔ \"hello_world\"\n *\n * // Array input is joined before conversion\n * toSnakeCase([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"join_words_here\"\n *\n * // Handles underscores, hyphens, spaces\n * toSnakeCase(\"convert-to_snake case\");\n * // ➔ \"convert_to_snake_case\"\n *\n * // Handles emojis and symbols\n * toSnakeCase(\"🔥fire___and--ice❄️\");\n * // ➔ \"fire_and_ice\"\n *\n * // Ignore specific word\n * toSnakeCase(\"ignore URL case\", \"URL\");\n * // ➔ \"ignore_URL_case\"\n *\n * // Ignore multiple words\n * toSnakeCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignore_API_and_URL\"\n *\n * // Ignore with Set\n * toSnakeCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignore_API_and_URL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toSnakeCase(null);\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 * - **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 * @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 * @returns {string} The LowerCase formatted string.\n * @example\n * // Basic usage\n * toLowerCase(\"Hello World\");\n * // ➔ \"hello world\"\n *\n * // Array input is joined before conversion\n * toLowerCase([\"Join\", \"WORLD\", \"Here\"]);\n * // ➔ \"join words here\"\n *\n * // Handles underscores and hyphens\n * toLowerCase(\"convert_to-pascal case\");\n * // ➔ \"convert to lower case\"\n *\n * // Trims extra delimiters\n * toLowerCase(\"___hello--world__ again!!\");\n * // ➔ \"hello world again\"\n *\n * // Supports emojis and symbols\n * toLowerCase(\"🔥fire_and-ice❄️\");\n * // ➔ \"fire and ice\"\n *\n * // Ignore single word\n * toLowerCase(\"this URL path will ignore\", \"URL\");\n * // ➔ \"this URL path will ignore\"\n *\n * // Ignore multiple words\n * toLowerCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignore API and URL\"\n *\n * // Ignore using Set\n * toLowerCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignore API and URL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toLowerCase(undefined);\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 * - **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 * @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 * @returns {string} The PascalCase formatted string.\n * @example\n * // Basic usage\n * toPascalCase(\"hello world\");\n * // ➔ \"HelloWorld\"\n *\n * // Array input is joined before conversion\n * toPascalCase([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"JoinWordsHere\"\n *\n * // Handles underscores and hyphens\n * toPascalCase(\"convert_to-pascal case\");\n * // ➔ \"ConvertToPascalCase\"\n *\n * // Trims extra delimiters\n * toPascalCase(\"___hello--world__ again!!\");\n * // ➔ \"HelloWorldAgain\"\n *\n * // Supports emojis and symbols\n * toPascalCase(\"🔥fire_and-ice❄️\");\n * // ➔ \"FireAndIce\"\n *\n * // Ignore single word\n * toPascalCase(\"this URL path will ignore\", \"URL\");\n * // ➔ \"ThisURLPathWillIgnore\"\n *\n * // Ignore multiple words\n * toPascalCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"IgnoreAPIAndURL\"\n *\n * // Ignore using Set\n * toPascalCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"IgnoreAPIAndURL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toPascalCase(undefined);\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 * - **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 * @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 * @returns {string} The PascalCaseSpace formatted string.\n * @example\n * // Basic usage\n * toPascalCaseSpace(\"hello world\");\n * // ➔ \"Hello World\"\n *\n * // Array input is joined before conversion\n * toPascalCaseSpace([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"Join Words Here\"\n *\n * // Handles underscores and hyphens\n * toPascalCaseSpace(\"convert_to-pascal case\");\n * // ➔ \"Convert To Pascal Case Space\"\n *\n * // Trims extra delimiters\n * toPascalCaseSpace(\"___hello--world__ again!!\");\n * // ➔ \"Hello World Again\"\n *\n * // Supports emojis and symbols\n * toPascalCaseSpace(\"🔥fire_and-ice❄️\");\n * // ➔ \"Fire And Ice\"\n *\n * // Ignore single word\n * toPascalCaseSpace(\"this URL path will ignore\", \"URL\");\n * // ➔ \"This URL Path Will Ignore\"\n *\n * // Ignore multiple words\n * toPascalCaseSpace(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"Ignore API And URL\"\n *\n * // Ignore using Set\n * toPascalCaseSpace(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"Ignore API And URL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toPascalCaseSpace(undefined);\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\nexport class PreciseType {\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   * - **⚠️ Internal:**\n   *    - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *    - Not intended for direct use in application code.\n   *\n   * @internal\n   */\n  private static readonly FIXES_RAW = Object.freeze({\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: \"URLPattern\",\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    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    canvas: \"Canvas\",\n    canvasrenderingcontext2d: \"Canvas Rendering Context 2D\",\n    offscreencanvas: \"Offscreen Canvas\",\n    webglrenderingcontext: \"WebGL Rendering 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  /** ----------------------------------------------------------\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   * - **⚠️ Internal:**\n   *    - Used by {@link getPreciseType | `getPreciseType`} for numeric edge-case detection.\n   *\n   * @internal\n   */\n  private static readonly SPECIAL_TYPE = Object.freeze([\n    \"-Infinity\",\n    \"Infinity\",\n    \"NaN\"\n  ] as const);\n\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   * - **⚠️ Internal:**\n   *    - Used internally by {@link getPreciseType | `getPreciseType`} and related formatters.\n   *\n   * @internal\n   */\n  private static readonly ACRONYMS = Object.freeze([\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  /** ----------------------------------------------------------\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   * - **⚠️ Internal:**\n   *    - Helper table for {@link getPreciseType | `getPreciseType`} and related matchers.\n   *\n   * @internal\n   */\n  private static readonly FIXES_CASTABLE_TABLE = Object.freeze(\n    Object.entries(PreciseType.FIXES_RAW).reduce(\n      (acc, [k, v]) => {\n        acc[PreciseType.normalizeKeyForCase(k)] = v;\n        return acc;\n      },\n      {} as Record<string, string>\n    )\n  );\n\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   * @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      address: \"Address\",\n      area: \"Area\",\n      article: \"Article\",\n      aside: \"Aside\",\n      audio: \"Audio\",\n      b: \"Bold\",\n      base: \"Base\",\n      bdi: \"BDI\",\n      bdo: \"BDO\",\n      blockquote: \"Blockquote\",\n      body: \"Body\",\n      br: \"Break\",\n      button: \"Button\",\n      canvas: \"Canvas\",\n      caption: \"Caption\",\n      cite: \"Cite\",\n      code: \"Code\",\n      col: \"Column\",\n      colgroup: \"Column Group\",\n      data: \"Data\",\n      datalist: \"Datalist\",\n      dd: \"Definition Description\",\n      del: \"Deleted Text\",\n      details: \"Details\",\n      dfn: \"Definition\",\n      dialog: \"Dialog\",\n      div: \"Div\",\n      dl: \"Definition List\",\n      dt: \"Definition Term\",\n      em: \"Emphasis\",\n      embed: \"Embed\",\n      fieldset: \"Fieldset\",\n      figcaption: \"Figcaption\",\n      figure: \"Figure\",\n      footer: \"Footer\",\n      form: \"Form\",\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      head: \"Head\",\n      header: \"Header\",\n      hr: \"Horizontal Rule\",\n      html: \"HTML\",\n      i: \"Italic\",\n      iframe: \"IFrame\",\n      img: \"Image\",\n      input: \"Input\",\n      ins: \"Inserted Text\",\n      kbd: \"Keyboard\",\n      label: \"Label\",\n      legend: \"Legend\",\n      li: \"List Item\",\n      link: \"Link\",\n      main: \"Main\",\n      map: \"Map\",\n      mark: \"Mark\",\n      meta: \"Meta\",\n      meter: \"Meter\",\n      nav: \"Nav\",\n      noscript: \"NoScript\",\n      object: \"Object\",\n      ol: \"Ordered List\",\n      optgroup: \"Option Group\",\n      option: \"Option\",\n      output: \"Output\",\n      p: \"Paragraph\",\n      param: \"Param\",\n      picture: \"Picture\",\n      pre: \"Preformatted\",\n      progress: \"Progress\",\n      q: \"Quote\",\n      rp: \"RP\",\n      rt: \"RT\",\n      ruby: \"Ruby\",\n      s: \"Strikethrough\",\n      samp: \"Sample\",\n      script: \"Script\",\n      section: \"Section\",\n      select: \"Select\",\n      small: \"Small\",\n      source: \"Source\",\n      span: \"Span\",\n      strong: \"Strong\",\n      style: \"Style\",\n      sub: \"Subscript\",\n      summary: \"Summary\",\n      sup: \"Superscript\",\n      table: \"Table\",\n      tbody: \"Table Body\",\n      td: \"Table Data\",\n      template: \"Template\",\n      textarea: \"Textarea\",\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      u: \"Underline\",\n      ul: \"Unordered List\",\n      var: \"Variable\",\n      video: \"Video\",\n      wbr: \"WBR\"\n    };\n\n    const displayName =\n      PreciseType.FIXES_CASTABLE_TABLE[\n        PreciseType.normalizeKeyForCase(tagName)\n      ] ??\n      (DEFAULTS[tagName]\n        ? `HTML ${DEFAULTS[tagName]} Element`\n        : \"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 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   *\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   * - **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   * - **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   * - **⚠️ Internal:**\n   *    - Helper for {@link getPreciseType | `getPreciseType`} that normalizes `Symbol` detection.\n   *    - Not recommended for direct external use.\n   *\n   * @param value - The `Symbol` instance to analyze.\n   * @param options - Optional settings for case formatting and acronym preservation.\n   * @returns The formatted symbol name string.\n   *\n   * @internal\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   *\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   * - **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   * - **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   * - **⚠️ Internal:**\n   *    - Used internally by {@link getPreciseType | `getPreciseType`} to refine DOM-related type detection.\n   *    - Not intended for direct external use.\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   * @returns The detected DOM node type string, or `null` if not applicable.\n   *\n   * @internal\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.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   *\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   * @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   * @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   * @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   * @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   * @internal\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   *\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   * @param {string} input - The string to convert.\n   * @param {GetPreciseTypeOptions[\"formatCase\"]} formatCase - The conversion method to apply.\n   * @returns {string} The converted string according to the selected format.\n   *\n   * @example\n   * converterHelper(\"hello world\", \"toCamelCase\");\n   * // ➔ \"helloWorld\"\n   *\n   * @example\n   * converterHelper(\"my URL path\", \"slugify\");\n   * // ➔ \"my-URL-path\"\n   *\n   * @internal\n   */\n  public converter(input: string, options?: GetPreciseTypeOptions): string {\n    const { formatCase, useAcronyms } = this.determineOptions(options);\n\n    const ignoreWord = useAcronyms ? PreciseType.ACRONYMS : [];\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   *\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   * - **Example:**\n   *    ```ts\n   *    PreciseType.normalizeKeyForCase(\"Map.Type\");   // ➔ \"maptype\"\n   *    PreciseType.normalizeKeyForCase(\"Map-Type\");   // ➔ \"maptype\"\n   *    PreciseType.normalizeKeyForCase(\"Set Type\");   // ➔ \"settype\"\n   *    PreciseType.normalizeKeyForCase(\"Array_Type\"); // ➔ \"arraytype\"\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   * @param k - The input string key to normalize.\n   * @returns The normalized lowercase key with all separators removed.\n   *\n   * @internal\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   *\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   * - **⚠️ 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   * @readonly\n   */\n  static get castableTable(): typeof PreciseType.FIXES_CASTABLE_TABLE {\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   *\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   * - **Example Values:**\n   *    - `\"Infinity\"`, `\"-Infinity\"`, `\"NaN\"`, `\"undefined\"`, etc.\n   *\n   * - **⚠️ Internal:**\n   *    - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *    - This property is **readonly** and should not be modified directly.\n   *\n   * @readonly\n   */\n  static get specialType(): typeof this.SPECIAL_TYPE {\n    return this.SPECIAL_TYPE;\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   *\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   * - **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   * - **⚠️ Internal:**\n   *    - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *    - This property is **readonly** and should not be modified directly.\n   *\n   * @readonly\n   */\n  static get fixesRaw(): typeof this.FIXES_RAW {\n    return this.FIXES_RAW;\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Retrieves the internal list of common acronyms that should remain fully uppercase during string formatting.***\n   * ----------------------------------------------------------\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   * - **Example:**\n   *    ```ts\n   *      [\"URL\", \"HTTP\", \"HTML\", \"SVG\", \"XML\", \"DOM\"]\n   *    ```\n   *\n   * - **⚠️ Internal:**\n   *     - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *     - This property is **readonly** and not intended for modification.\n   *\n   * @readonly\n   */\n  static get acronymsList(): typeof this.ACRONYMS {\n    return this.ACRONYMS;\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 { 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   * @default \"toKebabCase\"\n   * @description\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   * @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   * - **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   * - **When `true`:**\n   *    - Acronyms remain uppercase.\n   *    - Example:\n   *      - `HTMLDivElement` ➔ `\"HTML-div-element\"` (with `\"toKebabCase\"`)\n   *      - `DOMParser` ➔ `\"DOM-parser\"`\n   *\n   * @default false\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   * ⚠️ 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 PreciseType)[\"acronymsList\"];\n\n/** ----------------------------------------------------------\n * * ***Utility-Predicate: `getPreciseType`.***\n * ----------------------------------------------------------\n * **Returns a detailed and normalized type string for the given value.**\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 * @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 * @returns {string} The normalized and formatted type string\n * @example\n * getPreciseType(123);     // ➔ \"number\"\n * getPreciseType(null);    // ➔ \"null\"\n * getPreciseType(/regex/); // ➔ \"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 * // (SPECIAL_CASES remain)\n * getPreciseType(NaN, { formatCase: \"toLowerCase\" });\n * // ➔ \"NaN\"\n * getPreciseType(Infinity, { formatCase: \"toLowerCase\" });\n * // ➔ \"Infinity\"\n * getPreciseType(-Infinity, { formatCase: \"toLowerCase\" });\n * // ➔ \"-Infinity\"\n *\n * // Acronym usage examples:\n * getPreciseType(new URL(\"https://example.com\"));\n * // ➔ \"url\"\n * getPreciseType(new URL(\"https://example.com\"), { useAcronyms: true });\n * // ➔ \"URL\"\n *\n * getPreciseType(new URLSearchParams, { formatCase: \"toPascalCase\" });\n * // ➔ \"UrlSearchParams\"\n * getPreciseType(new URLSearchParams, { formatCase: \"toPascalCase\", useAcronyms: true });\n * // ➔ \"URLSearchParams\"\n */\nexport const getPreciseType: (\n  value: unknown,\n  options?: GetPreciseTypeOptions\n) => string = (() => {\n  const cache = new Map<string, PreciseType>();\n  const MAX_CACHE_SIZE = 25;\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 * - **Parameter:**\n *    - `currentType` ➔ the actual detected runtime type of the value.\n *    - `validType`   ➔ the required/expected type name that the value must match.\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 `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     * - 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 `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     * @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     * @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: true }\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 * - **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 * - **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 * - **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 * @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 * @returns {boolean} Narrows `value` to `boolean` if no error is thrown.\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 * @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"],"mappings":"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B;EAGnB,sBAAsB;EACtB,cAAc;EAGd,QAAQ;EACR,SAAS;EACT,kBAAkB;EAGlB,SAAS;EACT,UAAU;EACV,WAAW;EACX,WAAW;EACX,gBAAgB;EAChB,uBAAuB;EAGvB,MAAM;EACN,SAAS;EACT,WAAW;EACX,cAAc;EACd,eAAe;EACf,gBAAgB;EAChB,qBAAqB;EACrB,uBAAuB;EACxB,CAAU;;;;;;;;;;;;;CAcX,OAAwB,eAAe,OAAO,OAAO;EACnD;EACA;EACA;EACD,CAAU;;;;;;;;;;;;;;;CAgBX,OAAwB,WAAW,OAAO,OAAO;EAE/C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAU;;;;;;;;;;;;;;;CAgBX,OAAwB,uBAAuB,OAAO,OACpD,OAAO,QAAQ,YAAY,UAAU,CAAC,QACnC,KAAK,CAAC,GAAG,OAAO;EACf,IAAI,YAAY,oBAAoB,EAAE,IAAI;EAC1C,OAAO;IAET,EAAE,CACH,CACF;;;;CAKD,AAAQ,aAAkD;;;;CAI1D,AAAQ,cAAoD;CAE5D,YAAY,QAAgC;EAC1C,KAAK,aAAa,QAAQ;EAC1B,KAAK,cAAc,QAAQ;;;;;CAM7B,AAAQ,iBAAiB,SAAiC;EACxD,OAAO;GACL,YAAY,SAAS,cAAc,KAAK;GACxC,aAAa,SAAS,eAAe,KAAK;GAC3C;;;;;CAUH,AAAQ,mBACN,OACA,SACe;EACf,MAAM,EAAE,YAAY,gBAAgB,KAAK,iBAAiB,QAAQ;EAElE,IAAI,OAAO,gBAAgB,eAAe,EAAE,iBAAiB,cAC3D,OAAO;EAET,MAAM,UAAU,MAAM;EAEtB,MAAM,WAAmC;GACvC,GAAG;GACH,MAAM;GACN,SAAS;GACT,MAAM;GACN,SAAS;GACT,OAAO;GACP,OAAO;GACP,GAAG;GACH,MAAM;GACN,KAAK;GACL,KAAK;GACL,YAAY;GACZ,MAAM;GACN,IAAI;GACJ,QAAQ;GACR,QAAQ;GACR,SAAS;GACT,MAAM;GACN,MAAM;GACN,KAAK;GACL,UAAU;GACV,MAAM;GACN,UAAU;GACV,IAAI;GACJ,KAAK;GACL,SAAS;GACT,KAAK;GACL,QAAQ;GACR,KAAK;GACL,IAAI;GACJ,IAAI;GACJ,IAAI;GACJ,OAAO;GACP,UAAU;GACV,YAAY;GACZ,QAAQ;GACR,QAAQ;GACR,MAAM;GACN,IAAI;GACJ,IAAI;GACJ,IAAI;GACJ,IAAI;GACJ,IAAI;GACJ,IAAI;GACJ,MAAM;GACN,QAAQ;GACR,IAAI;GACJ,MAAM;GACN,GAAG;GACH,QAAQ;GACR,KAAK;GACL,OAAO;GACP,KAAK;GACL,KAAK;GACL,OAAO;GACP,QAAQ;GACR,IAAI;GACJ,MAAM;GACN,MAAM;GACN,KAAK;GACL,MAAM;GACN,MAAM;GACN,OAAO;GACP,KAAK;GACL,UAAU;GACV,QAAQ;GACR,IAAI;GACJ,UAAU;GACV,QAAQ;GACR,QAAQ;GACR,GAAG;GACH,OAAO;GACP,SAAS;GACT,KAAK;GACL,UAAU;GACV,GAAG;GACH,IAAI;GACJ,IAAI;GACJ,MAAM;GACN,GAAG;GACH,MAAM;GACN,QAAQ;GACR,SAAS;GACT,QAAQ;GACR,OAAO;GACP,QAAQ;GACR,MAAM;GACN,QAAQ;GACR,OAAO;GACP,KAAK;GACL,SAAS;GACT,KAAK;GACL,OAAO;GACP,OAAO;GACP,IAAI;GACJ,UAAU;GACV,UAAU;GACV,OAAO;GACP,IAAI;GACJ,OAAO;GACP,MAAM;GACN,OAAO;GACP,IAAI;GACJ,OAAO;GACP,GAAG;GACH,IAAI;GACJ,KAAK;GACL,OAAO;GACP,KAAK;GACN;EAED,MAAM,cACJ,YAAY,qBACV,YAAY,oBAAoB,QAAQ,MAEzC,SAAS,WACN,QAAQ,SAAS,SAAS,YAC1B;EAEN,OAAO,KAAK,UAAU,aAAa;GAAE;GAAY;GAAa,CAAC;;;;;CAMjE,AAAQ,mBACN,OACA,SACe;EACf,MAAM,EAAE,YAAY,gBAAgB,KAAK,iBAAiB,QAAQ;EAElE,IAAI,iBAAiB,SACnB,OAAO,KAAK,UACV,YAAY,qBACV,YAAY,oBAAoB,UAAU,KACvC,WACL;GAAE;GAAY;GAAa,CAC5B;EAEH,OAAO;;;;;CAMT,AAAQ,gBACN,OACA,SACe;EACf,MAAM,EAAE,YAAY,gBAAgB,KAAK,iBAAiB,QAAQ;EAElE,IAAI,iBAAiB,MACnB,OAAO,KAAK,UACV,YAAY,qBACV,YAAY,oBAAoB,OAAO,KACpC,QACL;GAAE;GAAY;GAAa,CAC5B;EAEH,OAAO;;;;;CAMT,AAAQ,iBACN,OACA,SACe;EACf,MAAM,EAAE,YAAY,gBAAgB,KAAK,iBAAiB,QAAQ;EAElE,IAAI,OAAO,SAAS,eAAe,iBAAiB,MAClD,OAAO,KAAK,UACV,YAAY,qBACV,YAAY,oBAAoB,OAAO,KACpC,QACL;GAAE;GAAY;GAAa,CAC5B;EAEH,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CT,AAAO,cAAc,OAAe,SAAyC;EAC3E,MAAM,EAAE,YAAY,gBAAgB,KAAK,iBAAiB,QAAQ;EAmBlE,MAAM,MAAM,IAhBU,IAAoB;GACxC,CAAC,OAAO,UAAU,iBAAiB;GACnC,CAAC,OAAO,eAAe,sBAAsB;GAC7C,CAAC,OAAO,aAAa,oBAAoB;GACzC,CAAC,OAAO,SAAS,gBAAgB;GACjC,CAAC,OAAO,aAAa,oBAAoB;GACzC,CAAC,OAAO,oBAAoB,2BAA2B;GACvD,CAAC,OAAO,aAAa,oBAAoB;GACzC,CAAC,OAAO,OAAO,cAAc;GAC7B,CAAC,OAAO,SAAS,gBAAgB;GACjC,CAAC,OAAO,QAAQ,eAAe;GAC/B,CAAC,OAAO,OAAO,cAAc;GAC7B,CAAC,OAAO,aAAa,oBAAoB;GACzC,CAAC,OAAO,UAAU,iBAAiB;GACpC,CAEoB,CAAC,IAAI,MAAM;EAChC,IAAI,KACF,OAAO,KAAK,UACV,YAAY,qBACV,YAAY,oBAAoB,IAAI,KACjC,KACL;GAAE;GAAY;GAAa,CAC5B;EAIH,OAAO,KAAK,UACV,YAAY,qBACV,YAAY,oBAAoB,SAAS,KACtC,UACL;GAAE;GAAY;GAAa,CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CH,AAAO,kBACL,OACA,SACe;EACf,MAAM,EAAE,YAAY,gBAAgB,KAAK,iBAAiB,QAAQ;EAElE,IAAI;GACF,OACE,KAAK,mBAAmB,OAAO;IAAE;IAAY;IAAa,CAAC,IAC3D,KAAK,mBAAmB,OAAO;IAAE;IAAY;IAAa,CAAC,IAC3D,KAAK,gBAAgB,OAAO;IAAE;IAAY;IAAa,CAAC,IACxD,KAAK,iBAAiB,OAAO;IAAE;IAAY;IAAa,CAAC;UAErD;GACN,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CX,AAAO,QAAQ,OAAyB;EACtC,IAAI,OAAO,MAAM,IAAI,CAAC,gBAAgB,MAAM,EAAE,OAAO;EAGrD,MAAM,MAAM,OAAO,UAAU,SAAS,KAAK,MAAM;EAgBjD,IAAI;GAdF;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GAEU,CAAC,SAAS,IAAI,EAAE,OAAO;EAEnC,IAAI;GAEF,QAAQ,eAAe,OAAO,oBAAoB;IAChD,cAAc;IACd,OAAO;IACR,CAAC;GACF,QAAQ,eAAe,OAAO,mBAAmB;GACjD,OAAO;UACD;GACN,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCX,AAAO,UAAU,OAAe,SAAyC;EACvE,MAAM,EAAE,YAAY,gBAAgB,KAAK,iBAAiB,QAAQ;EAElE,MAAM,aAAa,cAAc,YAAY,WAAW,EAAE;EAE1D,QAAQ,YAAR;GACE,KAAK,WACH,OAAO,QAAQ,OAAO,WAAW;GACnC,KAAK,aACH,OAAO,UAAU,OAAO,WAAW;GACrC,KAAK,eACH,OAAO,YAAY,OAAO,WAAW;GACvC,KAAK,eACH,OAAO,YAAY,OAAO,WAAW;GACvC,KAAK,eACH,OAAO,YAAY,OAAO,WAAW;GACvC,KAAK,gBACH,OAAO,aAAa,OAAO,WAAW;GACxC,KAAK,qBACH,OAAO,kBAAkB,OAAO,WAAW;GAE7C,SACE,OAAO,YAAY,OAAO,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC3C,OAAc,oBACZ,GACQ;EACR,OAAO,EAAE,QAAQ,cAAc,GAAG,CAAC,aAAa;;;;;;;;;;;;;;;;;CAkBlD,WAAW,gBAAyD;EAClE,OAAO,YAAY;;;;;;;;;;;;;;;;;;;;;CAsBrB,WAAW,cAAwC;EACjD,OAAO,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Bd,WAAW,WAAkC;EAC3C,OAAO,KAAK;;;;;;;;;;;;;;;;;;;;;;;CAwBd,WAAW,eAAqC;EAC9C,OAAO,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AChnChB,MAAa,wBAGQ;CACnB,MAAM,wBAAQ,IAAI,KAA0B;CAC5C,MAAM,iBAAiB;CAEvB,QAAQ,OAAgB,UAAiC,EAAE,KAAa;EACtE,IAAI,CAAC,cAAc,QAAQ,EAAE,UAAU,EAAE;EAGzC,MAAM,MAAM,KAAK,UAAU;GACzB,YAAY,QAAQ,cAAc;GAClC,aAAa,QAAQ,eAAe;GACrC,CAAC;EAEF,IAAI,eAAe,MAAM,IAAI,IAAI;EAEjC,IAAI,CAAC,cAAc;GACjB,IAAI,MAAM,QAAQ,gBAAgB,MAAM,OAAO;GAC/C,eAAe,IAAI,YAAY,QAAQ;GACvC,MAAM,IAAI,KAAK,aAAa;;EAI9B,IAAI,OAAO,MAAM,EACf,OAAO,aAAa,UAClB,YAAY,cAAc,YAAY,oBAAoB,OAAO,KAC/D,OACH;EAIH,IAAI,MAAM,MAAM,EAAE,OAAO;EACzB,IAAI,iBAAiB,MAAM,EAAE,OAAO,OAAO,MAAM;EAGjD,IAAI,OAAO,WAAW,eAAe,UAAU,QAC7C,OAAO,aAAa,UAClB,YAAY,cACV,YAAY,oBAAoB,qBAAqB,KAClD,qBACN;EAEH,IAAI,eAAe,MAAM,IAAI,UAAU,QACrC,OAAO,aAAa,UAClB,YAAY,cACV,YAAY,oBAAoB,qBAAqB,KAClD,qBACN;EAEH,IAAI,eAAe,MAAM,IAAI,UAAU,QACrC,OAAO,aAAa,UAClB,YAAY,cACV,YAAY,oBAAoB,qBAAqB,KAClD,qBACN;EAEH,IAAI,gBAAgB,MAAM,IAAI,UAAU,SACtC,OAAO,aAAa,UAClB,YAAY,cACV,YAAY,oBAAoB,sBAAsB,KACnD,sBACN;EAIH,MAAM,OAAO,OAAO;EACpB,IAAI,CAAC,gBAAgB,MAAM,IAAI,CAAC,WAAW,MAAM,IAAI,SAAS,UAC5D,OAAO,aAAa,UAClB,YAAY,cAAc,YAAY,oBAAoB,KAAK,KAAK,KACrE;EAIH,IAAI,SAAS,UACX,OAAO,aAAa,cAAc,MAAgB;EAIpD,IAAI,gBAAgB,MAAM,IAAI,MAAM,aAAa,SAAS,gBACxD,OAAO,aAAa,UAClB,YAAY,cACV,YAAY,oBAAoB,gBAAgB,KAC7C,gBACN;EAGH,MAAM,UAAU,aAAa,kBAAkB,MAAM;EACrD,IAAI,SAAS,OAAO;EAGpB,IAAI,SAAS,MAAM,EACjB,OAAO,aAAa,UAClB,YAAY,cAAc,YAAY,oBAAoB,SAAS,KACjE,SACH;EAIH,IAAI,aAAa,QAAQ,MAAM,EAC7B,OAAO,aAAa,UAClB,YAAY,cAAc,YAAY,oBAAoB,QAAQ,KAChE,QACH;EAIH,IACE,SAAS,MAAM,IACf,WAAW,OAAO,KAAK,IACvB,WAAW,OAAO,MAAM,EAExB,OAAO,aAAa,UAClB,YAAY,cACV,YAAY,oBAAoB,YAAY,KACzC,YACN;EAIH,IAAI,QAAQ,MAAM,EAAE;GAClB,MAAM,WAAW,MAAM,aAAa,QAAQ;GAE5C,OAAO,aAAa,UAClB,YAAY,cAAc,YAAY,oBAAoB,SAAS,KACjE,YAAY,cACV,YAAY,oBAAoB,SAAS,QAAQ,QAAQ,GAAG,CAAC,KAE/D,SACH;;EAGH,IACE,gBAAgB,MAAM,IACtB,UAAU,SACV,WAAW,SACX,OAAO,KAAK,MAAM,CAAC,WAAW,GAE9B,OAAO,aAAa,UAClB,YAAY,cACV,YAAY,oBAAoB,kBAAkB,KAC/C,kBACN;EAIH,IAAI,OAAO,OAAO,eAAe,MAAM,CAAC,EACtC,OAAO,aAAa,UAClB,YAAY,cAAc,YAAY,oBAAoB,SAAS,KACjE,SACH;EAIH,MAAM,MAAM,OAAO,UAAU,SAAS,KAAK,MAAM,CAAC,MAAM,GAAG,GAAG,IAAI;EAGlE,MAAM,SACJ,YAAY,cAAc,YAAY,oBAAoB,IAAI;EAChE,IAAI,QAAQ,OAAO,aAAa,UAAU,OAAO;EAGjD,MAAM,WAAW,OAAO,aAAa;EACrC,IAAI,YAAY,aAAa,UAC3B,OAAO,aAAa,UAClB,YAAY,cAAc,YAAY,oBAAoB,SAAS,KACjE,SACH;EAIH,OAAO,aAAa,UAAU,IAAI;;IAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/JJ,MAAM,+BACJ,MACA,YACU;CACV,QAAQ,MAAR;EACE,KAAK,SACH,MAAM,IAAI,MAAM,QAAQ;EAC1B,KAAK,aACH,MAAM,IAAI,UAAU,QAAQ;EAC9B,KAAK,cACH,MAAM,IAAI,WAAW,QAAQ;EAC/B,KAAK,kBACH,MAAM,IAAI,eAAe,QAAQ;EACnC,KAAK,eACH,MAAM,IAAI,YAAY,QAAQ;EAChC,KAAK,YACH,MAAM,IAAI,SAAS,QAAQ;EAC7B,KAAK,aACH,MAAM,IAAI,UAAU,QAAQ;EAC9B,SACE,MAAM,IAAI,UAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DlC,SAAgB,8BACd,QACO;CACP,MAAM,EAAE,mBAAmB,OAAO,YAAY,UAAU,EAAE;CAE1D,MAAM,EACJ,SACA,YACA,aACA,YAAY,gBACV,cAAc,QAAQ,GAAG,UAAU,EAAE;CAEzC,MAAM,YAAY,YAAY,kBAAkB;CAChD,MAAM,cAAc,eAAe,OAAO;EAAE;EAAY;EAAa,CAAC;CACtE,MAAM,mBAAmB;EAAE;EAAa;EAAW;CAEnD,MAAM,iBAAiB,iDAAiD,UAAU,sBAAsB,YAAY;CAUpH,OAAO,4BAA4B,WARd,WAAW,QAAQ,GACpC,iBAAiB,QAAQ,iBAAiB,CAAC,GACzC,QAAQ,iBAAiB,CAAC,MAAM,GAChC,iBACF,iBAAiB,QAAQ,GACvB,QAAQ,MAAM,GACd,eAEqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClK7D,MAAa,mBAIX,OACA,UAA2B,EAAE,KACA;CAC7B,IAAI,UAAU,MAAM,EAAE;CAEtB,8BAA8B;EAC5B;EACA;EACA,mBAAmB;EACpB,CAAC"}
+{"version":3,"file":"assertIsBoolean-9-huIcIR.js","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/isNumberObject.ts","../src/predicates/is/isNaN.ts","../src/predicates/is/isNull.ts","../src/assertions/objects/assertIsPlainObject.ts","../src/predicates/is/isNumber.ts","../src/predicates/is/isSymbol.ts","../src/predicates/is/isUndefined.ts","../src/predicates/is/isObjectOrArray.ts","../src/predicates/has/hasOwnProp.ts","../src/predicates/is/isNonEmptyString.ts","../src/predicates/is/isError.ts","../src/predicates/is/isBuffer.ts","../src/predicates/is/isStringObject.ts","../src/predicates/is/isBooleanObject.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"],"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 * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a `boolean`, otherwise `false`.\n * @example\n * isBoolean(true);   // ➔ true\n * isBoolean(false);  // ➔ true\n * isBoolean(\"true\"); // ➔ 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 * - **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 * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if the value is a function.\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 * - **Behavior:**\n *    - Narrows type to `null` or `undefined` when true.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is `null` or `undefined`, otherwise `false`.\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 function 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 * - **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 * @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 * @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 * - **✅ Returns `true` for any non-null object (arrays excluded), including:**\n *    - Plain-objects (`{}`, `Object.create(null)`)\n *    - Custom class instances\n *    - Built-ins: `Date`, `RegExp`, `Error`, `URL`, `URLSearchParams`\n *    - Collections: `Map`, `Set`, `WeakMap`, `WeakSet`\n *    - Binary/typed data: `ArrayBuffer`, `DataView`, typed arrays (`Uint8Array`, `Int32Array`, etc.)\n *    - DOM/Node objects: `HTMLElement`, `DocumentFragment`, etc.\n *    - Proxies (wrapping any object type)\n * - **❌ Returns `false` for:**\n *    - `null`\n *    - Arrays (`[]`, `new Array()`)\n *    - Functions (regular functions, arrow functions, class constructors)\n *    - Primitives: `string`, `number`, `boolean`, `symbol`, `bigint`\n *    - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`\n *    - `undefined` (including `NaN`, which is a primitive number)\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 * @template T - The type of the value being checked.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a ***plain-objects***, otherwise `false`.\n * @example\n * isObject({});                  // ➔ true\n * isObject(Object.create(null)); // ➔ true\n * isObject(new Date());          // ➔ true\n * isObject(new Map());           // ➔ true\n * isObject(new Uint8Array());    // ➔ true\n * isObject(new String(\"x\"));     // ➔ true\n * isObject([]);                  // ➔ false\n * isObject(null);                // ➔ false\n * isObject(undefined);           // ➔ false\n * isObject(123);                 // ➔ false\n * isObject(() => {});            // ➔ 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 * - **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 * @template T - The input type to be asserted as a plain object.\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 * - **A plain object is:**\n *    - Created by the `Object` constructor, or\n *    - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).\n * - **✅ Returns `true` for:**\n *    - Empty object literals: `{}`\n *    - Objects with null prototype: `Object.create(null)`\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 * @template T - The type of the value being checked.\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if `value` is a `plain-object`, otherwise `false`.\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 * - **Behavior:**\n *    - Narrows type to `string` when true.\n *    - Uses the `typeof` operator for strict checking.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a string, otherwise `false`.\n * @example\n * isString(\"hello\"); // ➔ true\n * isString(123);     // ➔ false\n *\n * // Usage in type narrowing\n * const value: unknown = getValue();\n * if (isString(value)) {\n *   // TypeScript now knows `value` is a string\n *   console.log(value.toUpperCase());\n * }\n */\nexport const isString = (value: unknown): value is string => {\n  return typeof value === \"string\";\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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a `Number` object.\n * @example\n * isNumberObject(new Number(42));\n * // ➔ true\n * isNumberObject(42);\n * // ➔ false\n */\nexport function 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 * - **ℹ️ 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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\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 function 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 * - **Behavior:**\n *    - Narrows type to `null` when true.\n *    - Strictly compares the value against `null`.\n * @param {*} val - The value to check.\n * @returns {boolean} Returns `true` if the value is `null`, otherwise `false`.\n * @example\n * isNull(null);      // ➔ true\n * isNull(0);         // ➔ false\n * isNull(undefined); // ➔ false\n */\nexport const isNull = (val: unknown): val is null => val === null;\n","import {\n  isPlainObject,\n  type IsPlainObjectResult\n} from \"@/predicates/is/isPlainObject\";\nimport {\n  type OptionsAssertIs,\n  resolveErrorMessageAssertions\n} from \"../_private/assertIs\";\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsPlainObject`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **plain-object**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `plain-object` **(generic support)**.\n *    - ✅ If `value` is a `plain-object` ➔ execution continues normally.\n *    - ❌ If `value` is not a `plain-object` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n * - **A valid `plain object` is:**\n *    - Created by the `Object` constructor, or\n *    - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).\n *     - **✅ Returns `undefined` (valid) for:**\n *         - Empty object literals: `{}`\n *         - Objects with null prototype: `Object.create(null)`\n *     - **❌ Returns `throws` 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 * - **⚠️ 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 * @template T - The input type being asserted.\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`: Built-in JavaScript error type to throw on failure (default `\"TypeError\"`).\n *    - `formatCase`: Controls how detected type names are formatted case in error messages.\n *    - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n * @returns {boolean} Narrows `value` to a `plain-object` **(generic support)** if no error is thrown.\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 `value` is not a plain-object.\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsPlainObject({ a: 1, b: 2 });\n * // No error, value is plain-object\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a plain-object\n * assertIsPlainObject(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `string`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsPlainObject(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsPlainObject(\"123\", { message: \"Must be a plain-object!\" });\n * // ➔ TypeError: \"Must be a plain-object!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsPlainObject(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected plain-object but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsPlainObject(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (url).\"\n * assertIsPlainObject(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URL).\"\n *\n * // Case 2:\n * assertIsPlainObject(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (UrlSearchParams).\"\n * assertIsPlainObject(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage with generic narrowing***:\n * ```ts\n * type User = { name: string; email: string };\n * const mixedValue: string | User | boolean | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `plain-object`\n * assertIsPlainObject(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be plain object!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `User` here\n * const user: User = mixedValue; // ➔ Safe type assignment\n * console.log(user.email);       // ➔ Safe to access object properties\n * ```\n */\nexport function assertIsPlainObject<T>(\n  value: T,\n  options: OptionsAssertIs = {}\n): asserts value is IsPlainObjectResult<T> {\n  if (isPlainObject(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"plain object\"\n  });\n}\n","// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { isFinite } from \"./isFinite\";\n\nimport { isBoolean } from \"./isBoolean\";\nimport { isPlainObject } from \"./isPlainObject\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nexport type IsNumberOptions = {\n  /** If set to `true`, `NaN` will be considered a valid number, defaultValue: `false`.\n   *\n   * @default false\n   */\n  includeNaN?: boolean;\n};\n\n/** ---------------------------------------------------------\n * * ***Type guard: `isNumber`.***\n * ----------------------------------------------------------\n * **Checks if a value is of type **`number`**.**\n * - **Behavior:**\n *    - Uses `typeof value === \"number\"`.\n *    - By default, excludes **`NaN`**.\n *    - If `options.includeNaN` is `true`, then **`NaN`** is also considered valid.\n *    - Still considers `Infinity` and `-Infinity` as **numbers** (consistent with JavaScript).\n * - **ℹ️ Note:**\n *    - To exclude `Infinity` and `-Infinity`, use **{@link isFinite | `isFinite`}** instead.\n * @param {*} value - The value to check.\n * @param {IsNumberOptions} [options] - Optional settings.\n * @param {boolean} [options.includeNaN=false]  If `true`, `NaN` will be considered a valid number, defaults to `false`, which excludes `NaN`.\n * @returns {boolean} Returns `true` if the value is a number (and depending on `includeNaN`, `NaN` is included or excluded).\n * @example\n * isNumber(42);\n * // ➔ true\n * isNumber(Infinity);\n * // ➔ true\n * isNumber(-Infinity);\n * // ➔ true\n * isNumber(NaN);\n * // ➔ false (default)\n * isNumber(NaN, { includeNaN: true });\n * // ➔ true\n * isNumber(\"42\");\n * // ➔ false\n */\nexport const isNumber = (\n  value: unknown,\n  options: IsNumberOptions = {}\n): value is number => {\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const includeNaN =\n    isPlainObject(options) && isBoolean(options.includeNaN)\n      ? options.includeNaN\n      : false;\n\n  assertIsBoolean(includeNaN, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`includeNaN\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const aNumber = typeof value === \"number\";\n  return includeNaN ? aNumber : aNumber && !Number.isNaN(value);\n};\n","/** ----------------------------------------------------------\n * * ***Type guard: `isSymbol`.***\n * ----------------------------------------------------------\n * **Checks if a value is of type\n * **[`symbol`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/Symbol)**.**\n * - **Behavior:**\n *    - Narrows type to `symbol` when true.\n *    - Uses the `typeof` operator for strict checking.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a symbol, otherwise `false`.\n * @example\n * isSymbol(Symbol(\"id\"));   // ➔ true\n * isSymbol(\"not a symbol\"); // ➔ false\n * isSymbol(123);            // ➔ false\n * isSymbol(undefined);      // ➔ false\n */\nexport const isSymbol = (value: unknown): value is symbol => {\n  return typeof value === \"symbol\";\n};\n","/** ---------------------------------------------------------\n * * ***Type guard: `isUndefined`.***\n * ----------------------------------------------------------\n * **Checks if a value is\n * **[`undefined`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)**.**\n * - **Behavior:**\n *    - Narrows type to `undefined` when true.\n *    - Excludes `null`, `objects`, `arrays`, `strings`, `numbers`, and\n *      `all other values`.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is `undefined`, otherwise `false`.\n * @example\n * isUndefined(undefined); // ➔ true\n * isUndefined([]);        // ➔ false\n * isUndefined(123);       // ➔ false\n * isUndefined(null);      // ➔ false\n * isUndefined(\"abc\");     // ➔ false\n */\nexport const isUndefined = (value: unknown): value is undefined => {\n  return typeof value === \"undefined\";\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 * - **✅ Returns `true` for:**\n *    - Plain objects (`{}`, `Object.create(null)`)\n *    - Custom objects\n *    - Arrays (`[]`, `[1,2,3]`)\n * - **❌ Returns `false` for:**\n *    - `null`\n *    - `undefined`\n *    - Primitives:\n *        - `string`\n *        - `number`\n *        - `boolean`\n *        - `symbol`\n *        - `bigint`\n *    - Functions\n * @template T - The type of the value being checked.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is an `object` or `array`.\n * @example\n * isObjectOrArray([1,2,3]);           // ➔ true\n * isObjectOrArray({ name: \"Alice\" }); // ➔ true\n * isObjectOrArray(null);              // ➔ false\n * isObjectOrArray(undefined);         // ➔ false\n * isObjectOrArray(\"hello\");           // ➔ 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 type {\n  AnyFunction,\n  AnyString,\n  IsAny,\n  IsStringLiteral\n} from \"@rzl-zone/ts-types-plus\";\nimport type {\n  DeepRequiredSymbolHasOwnProp,\n  GuardedHasOwnProp,\n  HasOwnPropOptions,\n  NestedKeyOfHasOwnProp,\n  SmartDetectArrayFuncHasOwnProp,\n  SmartDetectUnknownKeyHasOwnProp,\n  NumericKeyHasOwnPropMapped,\n  NumericKeyOfHasOwnProp,\n  SmartDetectStringHasOwnProp\n} from \"./hasOwnProp.types\";\n\nimport { isNaN } from \"../is/isNaN\";\nimport { isNull } from \"../is/isNull\";\nimport { isString } from \"../is/isString\";\nimport { isNumber } from \"../is/isNumber\";\nimport { isSymbol } from \"../is/isSymbol\";\nimport { isFunction } from \"../is/isFunction\";\nimport { isUndefined } from \"../is/isUndefined\";\nimport { isObjectOrArray } from \"../is/isObjectOrArray\";\nimport { type IsPlainObjectResult } from \"../is/isPlainObject\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\n// ------------------- HAS OWN PROP OVERLOADS -------------------\n\n/** -------------------------------------------------------\n * * ***Predicate: `hasOwnProp`.***\n * -------------------------------------------------------\n * **A **type-safe** replacement for `Object.prototype.hasOwnProperty` with runtime validation and **TypeScript-aware type narrowing**.**\n * - #### Supported Targets:\n *    - **Plain objects** ➔ `{ foo: \"bar\" }`.\n *    - **Arrays** ➔ `[ { id: 1 }, { id: 2 } ]`.\n *    - **Strings** ➔ `\"hello\"` (as array-like objects with `.length`, index, etc.).\n *    - **Functions** ➔ callable objects with extra props.\n *    - **Symbols** ➔ own property symbols.\n * - #### Key Advantages over `in` or `obj.hasOwnProperty(key)`:\n *    - Supports **dot/bracket path notation** (e.g. `\"user.address.city\"`, `\"addresses[0].zip\"`).\n *    - Handles **symbol** keys safely.\n *    - **Narrows** the type of `obj` in TypeScript (stronger type safety).\n *    - Configurable handling of **`undefined`** and **`null`**.\n * - #### Runtime Behavior:\n *    - ***✅ Returns `true` if:***\n *        - Value `obj` is an object/array/string/function **and** the property\n *          exists **and**, it passes the `options` checks.\n *    - ***❌ Returns `false` if:***\n *        - Value `obj` is not a valid type.\n *        - The property does not exist.\n *        - The value is `undefined` and `discardUndefined: true` (**default**).\n *        - The value is `null` and `discardNull: true`.\n *        - The `key` (after trimming) is an **empty string** ➔ treated as **invalid**.\n * - #### TypeScript Behavior:\n *    - ***Inside an `if (hasOwnProp(...)) {}` block:***\n *      - The property is **guaranteed to exist**.\n *      - Depending on `options`, the property type is narrowed to exclude\n *        `undefined` and/or `null`.\n * - #### ⚠️ Caveats:\n *    - ***Empty keys are invalid:***\n *        - If the `key` string is empty (`\"\"`) after trimming whitespace or other characters,\n *          it will **not** be considered a valid property and always returns `false`.\n *    - ***Arrays are limited by TypeScript inference:***\n *        - Checking index `[0]` only narrows **that specific index**, not the rest, example:\n *          1. `hasOwnProp(users, \"[0].id\")` does **not** imply `users[1].id` exists.\n *              - 👉 For different indices, use **optional chaining** (`users[1]?.id`).\n *    - ***Autocomplete limitation for array indices:***\n *        - Autocompletion for `[index]` is only supported up to **25** (`[0]` ➔ `[24]`).\n *        - This limit is intentional for **performance and safety:**\n *          1. Generating infinite union types for all possible indices would cause\n *            **TypeScript IntelliSense to hang or crash**.\n *              - ℹ️ You can still check higher indices manually (e.g. `\"[999].id\"`),\n *                but they will not show up in IntelliSense suggestions.\n * @param {HasOwnPropOptions} [options] - ***Optional configuration object.***\n * @param {HasOwnPropOptions[\"discardUndefined\"]} [options.discardUndefined=true]\n *  ***If `true`, properties with `undefined` values are treated as **missing**, default: `true`.***\n * @param {HasOwnPropOptions[\"discardNull\"]} [options.discardNull=false]\n *  ***If `true`, properties with `null` values are treated as **missing**, default: `false`.***\n * @param {*} obj ***The `object`, `array`, `string`, `function`, or `other value` to check against.***\n * @param {PropertyKey} key\n *  ***The property key to check, can be:***\n *    - `string` (supports dot/bracket paths, e.g. `\"user.address.city\"`, `\"[0].id\"`).\n *    - `number` (array-like index).\n *    - `symbol` (own property symbols).\n * @returns {boolean} Return `true` if the property exists (and passes `options`), otherwise `false`.\n * @example\n *\n * - #### ✅ Objects:\n * ```ts\n *    const obj: { name?: string | null } = {};\n *\n *    if (hasOwnProp(obj, \"name\")) {\n *      // obj is now ➔ { name: string | null }\n *      console.log(obj.name); // string | null\n *    }\n *\n *    if (hasOwnProp(obj, \"name\", { discardUndefined: true, discardNull: true })) {\n *      // obj is now ➔ { name: string }\n *      console.log(obj.name.toUpperCase()); // safe\n *    }\n * ```\n * - #### ✅ Arrays:\n * ```ts\n *    const users = [{ id: 1 }, { id: 2 }];\n *\n *    if (hasOwnProp(users, \"[1].id\")) {\n *      // ➔ users[1].id is guaranteed to exist\n *      console.log(users[1].id); // number\n *    }\n *\n *    // ⚠️ Caveat: narrowing only applies to checked index\n *    if (hasOwnProp(users, \"[0].id\")) {\n *      console.log(users[0].id); // ✅ safe\n *      console.log(users[1].id); // ❌ not guaranteed!\n *    }\n *\n *    // 👉 Solution: optional chaining\n *    console.log(users[1]?.id); // ➔ safe, even without narrowing\n * ```\n *\n * - #### ✅ Symbols:\n * ```ts\n *    const secret = Symbol(\"secret\");\n *    const obj2 = { [secret]: 42 };\n *\n *    if (hasOwnProp(obj2, secret)) {\n *      console.log(obj2[secret] + 1); // ➔ 43\n *    }\n * ```\n * - #### ✅ Strings:\n * ```ts\n *    if (hasOwnProp(\"hello\", \"length\")) {\n *      console.log(\"hello\".length); // ➔ 5\n *    }\n *\n *    if (hasOwnProp(\"hello\", 1)) {\n *      console.log(\"hello\"[1]); // ➔ \"e\"\n *    }\n * ```\n * - #### ✅ Functions:\n * ```ts\n *    function fn() {}\n *    fn.extra = 123;\n *\n *    if (hasOwnProp(fn, \"extra\")) {\n *      console.log(fn.extra); // ➔ 123\n *    }\n * ```\n * - #### ❌ Empty key:\n * ```ts\n *    const obj = { a: 1 };\n *\n *    hasOwnProp(obj, \"\");    // ➔ false (invalid key)\n *    hasOwnProp(obj, \"   \"); // ➔ false (trimmed to empty)\n * ```\n */\nexport function hasOwnProp<Obj>(\n  obj: IsAny<Obj> extends true ? Obj : never,\n  key: PropertyKey,\n  options?: HasOwnPropOptions<boolean, boolean>\n  /** @ts-expect-error we force `any` to `unknown` at result */\n): obj is unknown;\n\nexport function hasOwnProp<Obj extends null | undefined>(\n  obj: Obj,\n  key: PropertyKey,\n  options?: HasOwnPropOptions<boolean, boolean>\n): false;\n\nexport function hasOwnProp<\n  Obj extends object | AnyFunction,\n  Key extends NestedKeyOfHasOwnProp<Obj>,\n  DiscardUndefined extends boolean = true,\n  DiscardNull extends boolean = false\n>(\n  obj: Obj | null | undefined,\n  key: Key,\n  options?: HasOwnPropOptions<DiscardUndefined, DiscardNull>\n  /** @ts-expect-error we force to override recursive type result */\n): obj is GuardedHasOwnProp<Obj, Key, DiscardUndefined, DiscardNull>;\n\nexport function hasOwnProp<\n  Obj extends object,\n  Num extends NumericKeyOfHasOwnProp<Obj>,\n  DiscardUndefined extends boolean = true,\n  DiscardNull extends boolean = false\n>(\n  obj: Obj | null | undefined,\n  key: Num,\n  options?: HasOwnPropOptions<DiscardUndefined, DiscardNull>\n  /** @ts-expect-error we force to override recursive type result */\n): obj is NumericKeyHasOwnPropMapped<Obj, Num, DiscardUndefined, DiscardNull>;\n\nexport function hasOwnProp<\n  Obj extends object | AnyFunction,\n  Sym extends symbol,\n  DiscardUndefined extends boolean = true,\n  DiscardNull extends boolean = false\n>(\n  obj: Obj | null | undefined,\n  key: Sym,\n  options?: HasOwnPropOptions<DiscardUndefined, DiscardNull>\n  /** @ts-expect-error we force to override recursive type result */\n): obj is DeepRequiredSymbolHasOwnProp<Obj, Sym, DiscardUndefined, DiscardNull>;\n\nexport function hasOwnProp<\n  Obj extends string | null | undefined,\n  Key extends string | number\n>(\n  obj: Obj | null | undefined,\n  key: Key,\n  options?: HasOwnPropOptions<boolean, boolean>\n  /** @ts-expect-error we force to override recursive type result */\n): obj is IsStringLiteral<SmartDetectStringHasOwnProp<Obj, Key>> extends true\n  ? AnyString | SmartDetectStringHasOwnProp<Obj, Key>\n  : SmartDetectStringHasOwnProp<Obj, Key>;\n\nexport function hasOwnProp<\n  Obj extends unknown[] | AnyFunction,\n  Key extends PropertyKey\n>(\n  obj: Obj,\n  key: Key,\n  options?: HasOwnPropOptions<boolean, boolean>\n): obj is SmartDetectArrayFuncHasOwnProp<Obj, Key>;\n\nexport function hasOwnProp<\n  Obj extends unknown | AnyFunction,\n  Key extends PropertyKey,\n  DiscardUndefined extends boolean = true,\n  DiscardNull extends boolean = false\n>(\n  obj: Obj,\n  key:\n    | Key\n    | \"length\"\n    | (IsPlainObjectResult<Obj> extends never ? never : keyof Obj),\n  options?: HasOwnPropOptions<DiscardUndefined, DiscardNull>\n  /** @ts-expect-error we force to override recursive type result */\n): obj is SmartDetectUnknownKeyHasOwnProp<\n  Obj,\n  Key,\n  DiscardUndefined,\n  DiscardNull\n>;\n\n// ------------------- IMPLEMENTATION -------------------\nexport function hasOwnProp(\n  obj: unknown,\n  key: PropertyKey,\n  options: HasOwnPropOptions<boolean, boolean> = {}\n): unknown {\n  if (!isString(obj) && !isObjectOrArray(obj) && !isFunction(obj)) return false;\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Third parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  // defaults: undef ➔ true, null ➔ false\n  const discardUndefined =\n    options.discardUndefined === undefined ? true : options.discardUndefined;\n  const discardNull =\n    options.discardNull === undefined ? false : options.discardNull;\n\n  assertIsBoolean(discardUndefined, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`discardUndefined\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  assertIsBoolean(discardNull, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`discardNull\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  // Parse key ➔ path\n  const path: (string | number | symbol)[] = [];\n  //todo: keep use manually check for length string value for avoid Maximum infinity loop function.!!!\n  if (\n    (isString(key) && key.trim().length > 0) ||\n    isNumber(key, { includeNaN: true })\n  ) {\n    const strKey = isNumber(key, { includeNaN: true }) ? String(key) : key;\n    strKey.split(\".\").forEach((k) => {\n      const bracketMatch = k.match(/^\\[(\\d+)\\]$/);\n      const symbolMatch = k.match(/^Symbol\\((.+)\\)$/);\n      if (bracketMatch) path.push(Number(bracketMatch[1]));\n      else if (symbolMatch) path.push(Symbol.for(symbolMatch[1]));\n      else if (!isNaN(Number(k))) path.push(Number(k));\n      else path.push(k);\n    });\n  } else if (isSymbol(key)) {\n    path.push(key);\n  } else {\n    return false;\n  }\n\n  // Traverse\n  let current: unknown =\n    isString(obj) && obj.trim().length > 0 ? Object(obj) : obj;\n  for (const k of path) {\n    if (\n      (isString(k) && k.trim().length > 0) ||\n      isNumber(k, { includeNaN: true })\n    ) {\n      if (\n        isNull(current) ||\n        !Object.prototype.hasOwnProperty.call(current, k)\n      ) {\n        return false;\n      }\n      current = (current as Record<PropertyKey, unknown>)[k];\n    } else if (isSymbol(k)) {\n      if (\n        isNull(current) ||\n        (typeof current !== \"object\" && !isFunction(current))\n      ) {\n        return false;\n      }\n      const symbols = Object.getOwnPropertySymbols(current);\n      const matched = symbols.find(\n        (s) => s === k || s.description === k.description\n      );\n      if (!matched) return false;\n      current = (current as Record<PropertyKey, unknown>)[matched];\n    } else {\n      return false;\n    }\n  }\n  // early fail for undefined if requested\n  if (discardUndefined && isUndefined(current)) return false;\n\n  // final null check (only if requested)\n  if (discardNull && isNull(current)) return false;\n\n  return true;\n}\n","import { isString } from \"./isString\";\nimport { hasOwnProp } from \"../has/hasOwnProp\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype IsNonEmptyStringOptions = {\n  /** Whether to trim the string before checking, defaultValue: `true`.\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 * @description\n * Determines whether the given `value` is a string containing at least one non-whitespace character, with optional trimming behavior.\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 * @param {*} value - The value to test.\n * @param {IsNonEmptyStringOptions} [options] - Optional settings.\n * @param {boolean} options.trim - If `true`, trims the string before checking, defaults: `true`.\n * @returns {boolean} Return `true` if `value` is a non-empty string, otherwise `false`.\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\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const trim = hasOwnProp(options, \"trim\") ? options.trim : true;\n\n  assertIsBoolean(trim, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`trim\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const str = trim ? value.trim() : value;\n\n  return str.length > 0;\n};\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 * - **Behavior:**\n *    - Ensures that the provided value is a valid JavaScript error instance.\n *    - Useful in TypeScript for narrowing types during error handling.\n * @param {*} error - The value to check.\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 * @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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a `Buffer`, else `false`.\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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a `String` object.\n * @example\n * isStringObject(new String(\"hello\"));\n * // ➔ true\n * isStringObject(\"hello\");\n * // ➔ false\n */\nexport function 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 * @param {*} value The value to check.\n * @returns {value is Boolean} Returns `true` if `value` is a `Boolean` object.\n * @example\n * isBooleanObject(new Boolean(true));\n * // ➔ true\n * isBooleanObject(true);\n * // ➔ false\n */\nexport function isBooleanObject(value: unknown): value is Boolean {\n  return (\n    isObject(value) &&\n    Object.prototype.toString.call(value) === \"[object Boolean]\"\n  );\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 * - **ℹ️ 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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `Infinity` or `-Infinity`, else `false`.\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 function 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 * - **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 * @template T - The type of the value being checked.\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if value is a non-empty array.\n * @example\n * isNonEmptyArray([1, 2, 3]); // ➔ true\n * isNonEmptyArray([]);        // ➔ false\n * isNonEmptyArray(null);      // ➔ false\n * isNonEmptyArray(\"test\");    // ➔ 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 * - **Behavior:**\n *    - Narrows type to `Set<T>` when true.\n *    - Excludes `WeakSet`, arrays, plain objects, and other non-Set values.\n * @template T - The type of the value being checked.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a `Set`, otherwise `false`.\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 * - **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 * @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 * @returns {string} The slugified string.\n * @example\n * // Basic usage\n * slugify(\"Hello World!\");\n * // ➔ \"hello-world\"\n *\n * // Array input is joined before conversion\n * slugify([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"join-words-here\"\n *\n * // Trims and cleans input\n * slugify(\" --- Convert to Slug? --- \");\n * // ➔ \"convert-to-slug\"\n *\n * // Ignore single word\n * slugify(\"This URL path\", \"URL\");\n * // ➔ \"this-URL-path\"\n *\n * // Ignore multiple words\n * slugify(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignore-API-and-URL\"\n *\n * // Ignore using Set\n * slugify(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignore-API-and-URL\"\n *\n * // Supports emojis and symbols\n * slugify(\"🔥 Fire_and_ice ❄️\");\n * // ➔ \"fire-and-ice\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\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 * - **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 * @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 * @returns {string} The dot.case formatted string.\n * @example\n * // Basic usage\n * toDotCase(\"Hello World\");\n * // ➔ \"hello.world\"\n *\n * // Array input is joined before conversion\n * toDotCase([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"join.words.here\"\n *\n * // Handles underscores and hyphens\n * toDotCase(\"convert-to_dot case\");\n * // ➔ \"convert.to.dot.case\"\n *\n * // Multiple delimiters and trimming\n * toDotCase(\"___Hello--World__ again!!\");\n * // ➔ \"hello.world.again\"\n *\n * // Supports emojis and symbols\n * toDotCase(\"🔥Fire_and-ice❄️\");\n * // ➔ \"fire.and.ice\"\n *\n * // Ignore single word\n * toDotCase(\"this URL path\", \"URL\");\n * // ➔ \"this.URL.path\"\n *\n * // Ignore multiple words\n * toDotCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignore.API.and.URL\"\n *\n * // Ignore using Set\n * toDotCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignore.API.and.URL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toDotCase(undefined);\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 * - **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 * @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 * @returns {string} The camelCase formatted string.\n * @example\n * // Basic usage\n * toCamelCase(\"hello world\");\n * // ➔ \"helloWorld\"\n *\n * // Array input is joined before conversion\n * toCamelCase([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"joinWordsHere\"\n *\n * // Supports mixed delimiters\n * toCamelCase(\"convert_to-camel case\");\n * // ➔ \"convertToCamelCase\"\n *\n * // Words in ignoreWord stay unchanged\n * toCamelCase(\"this URL path will ignore\", \"URL\");\n * // ➔ \"thisURLPathWillIgnore\"\n *\n * // Multiple ignored words\n * toCamelCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignoreAPIAndURL\"\n *\n * // Set can also be used\n * toCamelCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignoreAPIAndURL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toCamelCase(null);\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 * - **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 * @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 * @returns {string} The kebab-case formatted string.\n * @example\n * // Basic usage\n * toKebabCase(\"Hello World\");\n * // ➔ \"hello-world\"\n *\n * // Array input is joined before conversion\n * toKebabCase([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"join-words-here\"\n *\n * // Handles underscores and hyphens\n * toKebabCase(\"convert_to-kebab case\");\n * // ➔ \"convert-to-kebab-case\"\n *\n * // Handles emojis and symbols\n * toKebabCase(\"🔥fire___and--ice❄️\");\n * // ➔ \"fire-and-ice\"\n *\n * // Ignore specific word\n * toKebabCase(\"ignore URL case\", \"URL\");\n * // ➔ \"ignore-URL-case\"\n *\n * // Ignore multiple words\n * toKebabCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignore-API-and-URL\"\n *\n * // Ignore with Set\n * toKebabCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignore-API-and-URL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toKebabCase(null);\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 * - **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 * @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 * @returns {string} The snake_case formatted string.\n * @example\n * // Basic usage\n * toSnakeCase(\"Hello World\");\n * // ➔ \"hello_world\"\n *\n * // Array input is joined before conversion\n * toSnakeCase([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"join_words_here\"\n *\n * // Handles underscores, hyphens, spaces\n * toSnakeCase(\"convert-to_snake case\");\n * // ➔ \"convert_to_snake_case\"\n *\n * // Handles emojis and symbols\n * toSnakeCase(\"🔥fire___and--ice❄️\");\n * // ➔ \"fire_and_ice\"\n *\n * // Ignore specific word\n * toSnakeCase(\"ignore URL case\", \"URL\");\n * // ➔ \"ignore_URL_case\"\n *\n * // Ignore multiple words\n * toSnakeCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignore_API_and_URL\"\n *\n * // Ignore with Set\n * toSnakeCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignore_API_and_URL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toSnakeCase(null);\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 * - **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 * @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 * @returns {string} The LowerCase formatted string.\n * @example\n * // Basic usage\n * toLowerCase(\"Hello World\");\n * // ➔ \"hello world\"\n *\n * // Array input is joined before conversion\n * toLowerCase([\"Join\", \"WORLD\", \"Here\"]);\n * // ➔ \"join words here\"\n *\n * // Handles underscores and hyphens\n * toLowerCase(\"convert_to-pascal case\");\n * // ➔ \"convert to lower case\"\n *\n * // Trims extra delimiters\n * toLowerCase(\"___hello--world__ again!!\");\n * // ➔ \"hello world again\"\n *\n * // Supports emojis and symbols\n * toLowerCase(\"🔥fire_and-ice❄️\");\n * // ➔ \"fire and ice\"\n *\n * // Ignore single word\n * toLowerCase(\"this URL path will ignore\", \"URL\");\n * // ➔ \"this URL path will ignore\"\n *\n * // Ignore multiple words\n * toLowerCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"ignore API and URL\"\n *\n * // Ignore using Set\n * toLowerCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"ignore API and URL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toLowerCase(undefined);\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 * - **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 * @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 * @returns {string} The PascalCase formatted string.\n * @example\n * // Basic usage\n * toPascalCase(\"hello world\");\n * // ➔ \"HelloWorld\"\n *\n * // Array input is joined before conversion\n * toPascalCase([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"JoinWordsHere\"\n *\n * // Handles underscores and hyphens\n * toPascalCase(\"convert_to-pascal case\");\n * // ➔ \"ConvertToPascalCase\"\n *\n * // Trims extra delimiters\n * toPascalCase(\"___hello--world__ again!!\");\n * // ➔ \"HelloWorldAgain\"\n *\n * // Supports emojis and symbols\n * toPascalCase(\"🔥fire_and-ice❄️\");\n * // ➔ \"FireAndIce\"\n *\n * // Ignore single word\n * toPascalCase(\"this URL path will ignore\", \"URL\");\n * // ➔ \"ThisURLPathWillIgnore\"\n *\n * // Ignore multiple words\n * toPascalCase(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"IgnoreAPIAndURL\"\n *\n * // Ignore using Set\n * toPascalCase(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"IgnoreAPIAndURL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toPascalCase(undefined);\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 * - **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 * @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 * @returns {string} The PascalCaseSpace formatted string.\n * @example\n * // Basic usage\n * toPascalCaseSpace(\"hello world\");\n * // ➔ \"Hello World\"\n *\n * // Array input is joined before conversion\n * toPascalCaseSpace([\"Join\", \"Words\", \"Here\"]);\n * // ➔ \"Join Words Here\"\n *\n * // Handles underscores and hyphens\n * toPascalCaseSpace(\"convert_to-pascal case\");\n * // ➔ \"Convert To Pascal Case Space\"\n *\n * // Trims extra delimiters\n * toPascalCaseSpace(\"___hello--world__ again!!\");\n * // ➔ \"Hello World Again\"\n *\n * // Supports emojis and symbols\n * toPascalCaseSpace(\"🔥fire_and-ice❄️\");\n * // ➔ \"Fire And Ice\"\n *\n * // Ignore single word\n * toPascalCaseSpace(\"this URL path will ignore\", \"URL\");\n * // ➔ \"This URL Path Will Ignore\"\n *\n * // Ignore multiple words\n * toPascalCaseSpace(\"ignore API and URL\", [\"API\", \"URL\"]);\n * // ➔ \"Ignore API And URL\"\n *\n * // Ignore using Set\n * toPascalCaseSpace(\"ignore API and URL\", new Set([\"API\", \"URL\"]));\n * // ➔ \"Ignore API And URL\"\n *\n * // Null, Undefined or empty (string or array) input returns empty string\n * toPascalCaseSpace(undefined);\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\nexport class PreciseType {\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   * - **⚠️ Internal:**\n   *    - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *    - Not intended for direct use in application code.\n   *\n   * @internal\n   */\n  private static readonly FIXES_RAW = Object.freeze({\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: \"URLPattern\",\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    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    canvas: \"Canvas\",\n    canvasrenderingcontext2d: \"Canvas Rendering Context 2D\",\n    offscreencanvas: \"Offscreen Canvas\",\n    webglrenderingcontext: \"WebGL Rendering 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  /** ----------------------------------------------------------\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   * - **⚠️ Internal:**\n   *    - Used by {@link getPreciseType | `getPreciseType`} for numeric edge-case detection.\n   *\n   * @internal\n   */\n  private static readonly SPECIAL_TYPE = Object.freeze([\n    \"-Infinity\",\n    \"Infinity\",\n    \"NaN\"\n  ] as const);\n\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   * - **⚠️ Internal:**\n   *    - Used internally by {@link getPreciseType | `getPreciseType`} and related formatters.\n   *\n   * @internal\n   */\n  private static readonly ACRONYMS = Object.freeze([\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  /** ----------------------------------------------------------\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   * - **⚠️ Internal:**\n   *    - Helper table for {@link getPreciseType | `getPreciseType`} and related matchers.\n   *\n   * @internal\n   */\n  private static readonly FIXES_CASTABLE_TABLE = Object.freeze(\n    Object.entries(PreciseType.FIXES_RAW).reduce(\n      (acc, [k, v]) => {\n        acc[PreciseType.normalizeKeyForCase(k)] = v;\n        return acc;\n      },\n      {} as Record<string, string>\n    )\n  );\n\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   * @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      address: \"Address\",\n      area: \"Area\",\n      article: \"Article\",\n      aside: \"Aside\",\n      audio: \"Audio\",\n      b: \"Bold\",\n      base: \"Base\",\n      bdi: \"BDI\",\n      bdo: \"BDO\",\n      blockquote: \"Blockquote\",\n      body: \"Body\",\n      br: \"Break\",\n      button: \"Button\",\n      canvas: \"Canvas\",\n      caption: \"Caption\",\n      cite: \"Cite\",\n      code: \"Code\",\n      col: \"Column\",\n      colgroup: \"Column Group\",\n      data: \"Data\",\n      datalist: \"Datalist\",\n      dd: \"Definition Description\",\n      del: \"Deleted Text\",\n      details: \"Details\",\n      dfn: \"Definition\",\n      dialog: \"Dialog\",\n      div: \"Div\",\n      dl: \"Definition List\",\n      dt: \"Definition Term\",\n      em: \"Emphasis\",\n      embed: \"Embed\",\n      fieldset: \"Fieldset\",\n      figcaption: \"Figcaption\",\n      figure: \"Figure\",\n      footer: \"Footer\",\n      form: \"Form\",\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      head: \"Head\",\n      header: \"Header\",\n      hr: \"Horizontal Rule\",\n      html: \"HTML\",\n      i: \"Italic\",\n      iframe: \"IFrame\",\n      img: \"Image\",\n      input: \"Input\",\n      ins: \"Inserted Text\",\n      kbd: \"Keyboard\",\n      label: \"Label\",\n      legend: \"Legend\",\n      li: \"List Item\",\n      link: \"Link\",\n      main: \"Main\",\n      map: \"Map\",\n      mark: \"Mark\",\n      meta: \"Meta\",\n      meter: \"Meter\",\n      nav: \"Nav\",\n      noscript: \"NoScript\",\n      object: \"Object\",\n      ol: \"Ordered List\",\n      optgroup: \"Option Group\",\n      option: \"Option\",\n      output: \"Output\",\n      p: \"Paragraph\",\n      param: \"Param\",\n      picture: \"Picture\",\n      pre: \"Preformatted\",\n      progress: \"Progress\",\n      q: \"Quote\",\n      rp: \"RP\",\n      rt: \"RT\",\n      ruby: \"Ruby\",\n      s: \"Strikethrough\",\n      samp: \"Sample\",\n      script: \"Script\",\n      section: \"Section\",\n      select: \"Select\",\n      small: \"Small\",\n      source: \"Source\",\n      span: \"Span\",\n      strong: \"Strong\",\n      style: \"Style\",\n      sub: \"Subscript\",\n      summary: \"Summary\",\n      sup: \"Superscript\",\n      table: \"Table\",\n      tbody: \"Table Body\",\n      td: \"Table Data\",\n      template: \"Template\",\n      textarea: \"Textarea\",\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      u: \"Underline\",\n      ul: \"Unordered List\",\n      var: \"Variable\",\n      video: \"Video\",\n      wbr: \"WBR\"\n    };\n\n    const displayName =\n      PreciseType.FIXES_CASTABLE_TABLE[\n        PreciseType.normalizeKeyForCase(tagName)\n      ] ??\n      (DEFAULTS[tagName]\n        ? `HTML ${DEFAULTS[tagName]} Element`\n        : \"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 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   *\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   * - **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   * - **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   * - **⚠️ Internal:**\n   *    - Helper for {@link getPreciseType | `getPreciseType`} that normalizes `Symbol` detection.\n   *    - Not recommended for direct external use.\n   *\n   * @param value - The `Symbol` instance to analyze.\n   * @param options - Optional settings for case formatting and acronym preservation.\n   * @returns The formatted symbol name string.\n   *\n   * @internal\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   *\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   * - **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   * - **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   * - **⚠️ Internal:**\n   *    - Used internally by {@link getPreciseType | `getPreciseType`} to refine DOM-related type detection.\n   *    - Not intended for direct external use.\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   * @returns The detected DOM node type string, or `null` if not applicable.\n   *\n   * @internal\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.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   *\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   * @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   * @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   * @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   * @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   * @internal\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   *\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   * @param {string} input - The string to convert.\n   * @param {GetPreciseTypeOptions[\"formatCase\"]} formatCase - The conversion method to apply.\n   * @returns {string} The converted string according to the selected format.\n   *\n   * @example\n   * converterHelper(\"hello world\", \"toCamelCase\");\n   * // ➔ \"helloWorld\"\n   *\n   * @example\n   * converterHelper(\"my URL path\", \"slugify\");\n   * // ➔ \"my-URL-path\"\n   *\n   * @internal\n   */\n  public converter(input: string, options?: GetPreciseTypeOptions): string {\n    const { formatCase, useAcronyms } = this.determineOptions(options);\n\n    const ignoreWord = useAcronyms ? PreciseType.ACRONYMS : [];\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   *\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   * - **Example:**\n   *    ```ts\n   *    PreciseType.normalizeKeyForCase(\"Map.Type\");   // ➔ \"maptype\"\n   *    PreciseType.normalizeKeyForCase(\"Map-Type\");   // ➔ \"maptype\"\n   *    PreciseType.normalizeKeyForCase(\"Set Type\");   // ➔ \"settype\"\n   *    PreciseType.normalizeKeyForCase(\"Array_Type\"); // ➔ \"arraytype\"\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   * @param k - The input string key to normalize.\n   * @returns The normalized lowercase key with all separators removed.\n   *\n   * @internal\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   *\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   * - **⚠️ 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   * @readonly\n   */\n  static get castableTable(): typeof PreciseType.FIXES_CASTABLE_TABLE {\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   *\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   * - **Example Values:**\n   *    - `\"Infinity\"`, `\"-Infinity\"`, `\"NaN\"`, `\"undefined\"`, etc.\n   *\n   * - **⚠️ Internal:**\n   *    - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *    - This property is **readonly** and should not be modified directly.\n   *\n   * @readonly\n   */\n  static get specialType(): typeof this.SPECIAL_TYPE {\n    return this.SPECIAL_TYPE;\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   *\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   * - **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   * - **⚠️ Internal:**\n   *    - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *    - This property is **readonly** and should not be modified directly.\n   *\n   * @readonly\n   */\n  static get fixesRaw(): typeof this.FIXES_RAW {\n    return this.FIXES_RAW;\n  }\n\n  /** ----------------------------------------------------------\n   * * ***Retrieves the internal list of common acronyms that should remain fully uppercase during string formatting.***\n   * ----------------------------------------------------------\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   * - **Example:**\n   *    ```ts\n   *      [\"URL\", \"HTTP\", \"HTML\", \"SVG\", \"XML\", \"DOM\"]\n   *    ```\n   *\n   * - **⚠️ Internal:**\n   *     - Used internally by {@link getPreciseType | `getPreciseType`}.\n   *     - This property is **readonly** and not intended for modification.\n   *\n   * @readonly\n   */\n  static get acronymsList(): typeof this.ACRONYMS {\n    return this.ACRONYMS;\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 { 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   * @default \"toKebabCase\"\n   * @description\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   * @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   * - **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   * - **When `true`:**\n   *    - Acronyms remain uppercase.\n   *    - Example:\n   *      - `HTMLDivElement` ➔ `\"HTML-div-element\"` (with `\"toKebabCase\"`)\n   *      - `DOMParser` ➔ `\"DOM-parser\"`\n   *\n   * @default false\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   * ⚠️ 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 PreciseType)[\"acronymsList\"];\n\n/** ----------------------------------------------------------\n * * ***Utility-Predicate: `getPreciseType`.***\n * ----------------------------------------------------------\n * **Returns a detailed and normalized type string for the given value.**\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 * @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 * @returns {string} The normalized and formatted type string\n * @example\n * getPreciseType(123);     // ➔ \"number\"\n * getPreciseType(null);    // ➔ \"null\"\n * getPreciseType(/regex/); // ➔ \"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 * // (SPECIAL_CASES remain)\n * getPreciseType(NaN, { formatCase: \"toLowerCase\" });\n * // ➔ \"NaN\"\n * getPreciseType(Infinity, { formatCase: \"toLowerCase\" });\n * // ➔ \"Infinity\"\n * getPreciseType(-Infinity, { formatCase: \"toLowerCase\" });\n * // ➔ \"-Infinity\"\n *\n * // Acronym usage examples:\n * getPreciseType(new URL(\"https://example.com\"));\n * // ➔ \"url\"\n * getPreciseType(new URL(\"https://example.com\"), { useAcronyms: true });\n * // ➔ \"URL\"\n *\n * getPreciseType(new URLSearchParams, { formatCase: \"toPascalCase\" });\n * // ➔ \"UrlSearchParams\"\n * getPreciseType(new URLSearchParams, { formatCase: \"toPascalCase\", useAcronyms: true });\n * // ➔ \"URLSearchParams\"\n */\nexport const getPreciseType: (\n  value: unknown,\n  options?: GetPreciseTypeOptions\n) => string = (() => {\n  const cache = new Map<string, PreciseType>();\n  const MAX_CACHE_SIZE = 25;\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 * - **Parameter:**\n *    - `currentType` ➔ the actual detected runtime type of the value.\n *    - `validType`   ➔ the required/expected type name that the value must match.\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 `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     * - 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 `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     * @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     * @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: true }\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 * - **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 * - **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 * - **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 * @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 * @returns {boolean} Narrows `value` to `boolean` if no error is thrown.\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 * @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"],"mappings":"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B;EAGnB,sBAAsB;EACtB,cAAc;EAGd,QAAQ;EACR,SAAS;EACT,kBAAkB;EAGlB,SAAS;EACT,UAAU;EACV,WAAW;EACX,WAAW;EACX,gBAAgB;EAChB,uBAAuB;EAGvB,MAAM;EACN,SAAS;EACT,WAAW;EACX,cAAc;EACd,eAAe;EACf,gBAAgB;EAChB,qBAAqB;EACrB,uBAAuB;EACxB,CAAU;;;;;;;;;;;;;CAcX,OAAwB,eAAe,OAAO,OAAO;EACnD;EACA;EACA;EACD,CAAU;;;;;;;;;;;;;;;CAgBX,OAAwB,WAAW,OAAO,OAAO;EAE/C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAU;;;;;;;;;;;;;;;CAgBX,OAAwB,uBAAuB,OAAO,OACpD,OAAO,QAAQ,YAAY,UAAU,CAAC,QACnC,KAAK,CAAC,GAAG,OAAO;EACf,IAAI,YAAY,oBAAoB,EAAE,IAAI;EAC1C,OAAO;IAET,EAAE,CACH,CACF;;;;CAKD,AAAQ,aAAkD;;;;CAI1D,AAAQ,cAAoD;CAE5D,YAAY,QAAgC;EAC1C,KAAK,aAAa,QAAQ;EAC1B,KAAK,cAAc,QAAQ;;;;;CAM7B,AAAQ,iBAAiB,SAAiC;EACxD,OAAO;GACL,YAAY,SAAS,cAAc,KAAK;GACxC,aAAa,SAAS,eAAe,KAAK;GAC3C;;;;;CAUH,AAAQ,mBACN,OACA,SACe;EACf,MAAM,EAAE,YAAY,gBAAgB,KAAK,iBAAiB,QAAQ;EAElE,IAAI,OAAO,gBAAgB,eAAe,EAAE,iBAAiB,cAC3D,OAAO;EAET,MAAM,UAAU,MAAM;EAEtB,MAAM,WAAmC;GACvC,GAAG;GACH,MAAM;GACN,SAAS;GACT,MAAM;GACN,SAAS;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"}