@rzl-zone/utils-js 3.10.0 → 3.11.1

package/dist/assertions/index.d.ts

@@ -2,12 +2,14 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.10.0.
+ * Version: 3.11.1.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================
  */
-import{Prettify,PickStrict}from'@rzl-zone/ts-types-plus';import{G as GetPreciseTypeOptions,I as IsNumberOptions,a as IsPlainObjectResult}from'../isPlainObject-BTPjv6zB.js';
+import { Prettify, PickStrict } from '@rzl-zone/ts-types-plus';
+import { G as GetPreciseTypeOptions, I as IsNumberOptions, a as IsPlainObjectResult } from '../isPlainObject-0p3VveWr.js';
+
 /** -------------------------------------------------------
  * * ***Shape of the object passed to custom error message functions.***
  * -------------------------------------------------------
@@ -25,21 +27,22 @@ import{Prettify,PickStrict}from'@rzl-zone/ts-types-plus';import{G as GetPreciseT
  * };
  * ```
  */
-type OptionsMessageFunctionAssertIs={
-/** ---------------------------------------------------------------------------
- * * ***The actual runtime type of the value being checked.***
- * ---------------------------------------------------------------------------
- * - ***Example:***
- *    - `"number"`, `"big-int"`, `"plain-object"`, (depends `formatCase` options).
- */
-currentType:string;
-/** ---------------------------------------------------------------------------
- * * ***The required/expected type that the value must conform to.***
- * ---------------------------------------------------------------------------
- * - ***Example:***
- *    - `"boolean"`, `"string"`, `"big-int"`, `"plain-object"`, (will force format to `kebab-case`).
- */
-validType:string;};
+type OptionsMessageFunctionAssertIs = {
+    /** ---------------------------------------------------------------------------
+     * * ***The actual runtime type of the value being checked.***
+     * ---------------------------------------------------------------------------
+     * - ***Example:***
+     *    - `"number"`, `"big-int"`, `"plain-object"`, (depends `formatCase` options).
+     */
+    currentType: string;
+    /** ---------------------------------------------------------------------------
+     * * ***The required/expected type that the value must conform to.***
+     * ---------------------------------------------------------------------------
+     * - ***Example:***
+     *    - `"boolean"`, `"string"`, `"big-int"`, `"plain-object"`, (will force format to `kebab-case`).
+     */
+    validType: string;
+};
 /** -------------------------------------------------------
  * * ***Custom error-message type for assertions option {@link OptionsAssertIs | `OptionsAssertIs`}.***
  * -------------------------------------------------------
@@ -47,66 +50,71 @@ validType:string;};
  *    - A static string message.
  *    - A function receiving `{ currentType, validType }` and returning a string.
  */
-type OptionsMessageAssertIs=string|(({currentType,validType}:OptionsMessageFunctionAssertIs)=>string);
+type OptionsMessageAssertIs = string | (({ currentType, validType }: OptionsMessageFunctionAssertIs) => string);
 /** ---------------------------------------------------------------------------
  * * ***Base options for `assertIs*` functions.***
  * ---------------------------------------------------------------------------
  */
-type OptionsAssertIs=Prettify<{
-/** -------------------------------------------------------
- * * ***Custom error message for assertion failures.***
- * -------------------------------------------------------
- * **This option allows overriding the **default error message** when a value
- * does not match the required type.**
- * - If a **string** is provided:
- *    - Must be non-empty after trimming.
- *    - Will be used directly as the error message.
- * - If a **function** is provided:
- *    - Receives an object containing:
- *      - `currentType` ➔ the detected runtime type of the value (depends `formatCase` options, e.g., `"number"`).
- *      - `validType`  ➔ the expected type name (with format `kebab-case`, e.g., `"boolean"`, `"big-int"`, `"plain-object"`).
- *    - **Must** return a **string**:
- *      - **If** the **returned string is** `empty` or `whitespace`,
- *        the **default message** will be used instead.
- * @example
- * ```ts
- * // Static message
- * { message: "Must be a boolean!" }
- *
- * // Dynamic message
- * {
- *   message: ({ currentType, validType }) => {
- *     return `Expected ${validType} but got ${currentType}`;
- *   };
- * }
- * ```
- */
-message?:OptionsMessageAssertIs;
-/** -------------------------------------------------------
- * * ***Custom error type for assertion failures.***
- * -------------------------------------------------------
- * **This option allows overriding the default error type** that will be thrown
- * when a value does not match the required type.
- *
- * - **Behavior:**
- *    - Must be one of the standard JavaScript built-in error types:
- *      `"Error" | "EvalError" | "RangeError" | "ReferenceError" | "SyntaxError" | "TypeError" | "URIError"`
- *    - **Default:** `"TypeError"` if not provided or if an invalid value is passed.
- *    - The assertion function will **always throw a valid built-in error**, ensuring
- *   fallback to `TypeError` in case of an unknown or incorrect type.
- * @example
- * ```ts
- * // Valid: Throw a RangeError instead of TypeError
- * { errorType: "RangeError" }
- *
- * // Valid: Throw a ReferenceError
- * { errorType: "ReferenceError" }
- *
- * // Invalid value ➔ fallback to TypeError
- * { errorType: "SomeUnknownError" as ErrorType }
- * ```
- */
-errorType?:ErrorType;}& PickStrict<GetPreciseTypeOptions,"formatCase">,{recursive:true;}>;type ErrorType="Error"|"EvalError"|"RangeError"|"ReferenceError"|"SyntaxError"|"TypeError"|"URIError";
+type OptionsAssertIs = Prettify<{
+    /** -------------------------------------------------------
+     * * ***Custom error message for assertion failures.***
+     * -------------------------------------------------------
+     * **This option allows overriding the **default error message** when a value
+     * does not match the required type.**
+     * - If a **string** is provided:
+     *    - Must be non-empty after trimming.
+     *    - Will be used directly as the error message.
+     * - If a **function** is provided:
+     *    - Receives an object containing:
+     *      - `currentType` ➔ the detected runtime type of the value (depends `formatCase` options, e.g., `"number"`).
+     *      - `validType`  ➔ the expected type name (with format `kebab-case`, e.g., `"boolean"`, `"big-int"`, `"plain-object"`).
+     *    - **Must** return a **string**:
+     *      - **If** the **returned string is** `empty` or `whitespace`,
+     *        the **default message** will be used instead.
+     * @example
+     * ```ts
+     * // Static message
+     * { message: "Must be a boolean!" }
+     *
+     * // Dynamic message
+     * {
+     *   message: ({ currentType, validType }) => {
+     *     return `Expected ${validType} but got ${currentType}`;
+     *   };
+     * }
+     * ```
+     */
+    message?: OptionsMessageAssertIs;
+    /** -------------------------------------------------------
+     * * ***Custom error type for assertion failures.***
+     * -------------------------------------------------------
+     * **This option allows overriding the default error type** that will be thrown
+     * when a value does not match the required type.
+     *
+     * - **Behavior:**
+     *    - Must be one of the standard JavaScript built-in error types:
+     *      `"Error" | "EvalError" | "RangeError" | "ReferenceError" | "SyntaxError" | "TypeError" | "URIError"`
+     *    - **Default:** `"TypeError"` if not provided or if an invalid value is passed.
+     *    - The assertion function will **always throw a valid built-in error**, ensuring
+     *   fallback to `TypeError` in case of an unknown or incorrect type.
+     * @example
+     * ```ts
+     * // Valid: Throw a RangeError instead of TypeError
+     * { errorType: "RangeError" }
+     *
+     * // Valid: Throw a ReferenceError
+     * { errorType: "ReferenceError" }
+     *
+     * // Invalid value ➔ fallback to TypeError
+     * { errorType: "SomeUnknownError" as ErrorType }
+     * ```
+     */
+    errorType?: ErrorType;
+} & PickStrict<GetPreciseTypeOptions, "formatCase" | "useAcronyms">, {
+    recursive: true;
+}>;
+type ErrorType = "Error" | "EvalError" | "RangeError" | "ReferenceError" | "SyntaxError" | "TypeError" | "URIError";
+
 /** -------------------------------------------------------
  * * ***Type guard assertion: `assertIsBoolean`.***
  * -------------------------------------------------------
@@ -134,7 +142,8 @@ errorType?:ErrorType;}& PickStrict<GetPreciseTypeOptions,"formatCase">,{recursiv
  *  ***Optional configuration:***
  *    - `message`: A custom error message (`string` or `function`).
  *    - `errorType`: A custom built-in JavaScript error type to throw.
- *    - `formatCase`: Controls type formatting (from `GetPreciseTypeOptions`).
+ *    - `formatCase`: Controls how detected type names are formatted case in error messages.
+ *    - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.
  * @returns {boolean} Narrows `value` to `boolean` if no error is thrown.
  * @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.
  * @example
@@ -143,40 +152,82 @@ errorType?:ErrorType;}& PickStrict<GetPreciseTypeOptions,"formatCase">,{recursiv
  * assertIsBoolean(true);
  * // No error, value is boolean
  *
- * // ❌ Throws TypeError with default message
- * assertIsBoolean(42);
+ * // ❌ Throws TypeError (default behavior)
+ * // Case 1: Invalid input type — received a string instead of a boolean
+ * assertIsBoolean("hello");
  * // ➔ TypeError: "Parameter input (`value`) must be of type `boolean`, but received: `number`."
  *
- * // ❌ Throws with custom string message
+ * // Case 2: The new Boolean() is a Boolean object (constructor), not a primitive boolean
+ * assertIsBoolean(new Boolean(true));
+ * // ➔ TypeError: "Parameter input (`value`) must be of type `boolean`, but received: `boolean-constructor`."
+ *
+ * // ❌ Throws a TypeError with a custom string static message
  * assertIsBoolean(42, { message: "Must be boolean!" });
  * // ➔ TypeError: "Must be boolean!"
  *
- * // ❌ Throws RangeError instead of TypeError
+ * // ❌ Throws RangeError (custom error type)
  * assertIsBoolean(42, { errorType: "RangeError" });
  * // ➔ RangeError: "Parameter input (`value`) must be of type `boolean`, but received: `number`."
  *
- * // ❌ Throws with custom function message + case formatting
- * assertIsBoolean(123n, {
- *   message: ({ currentType, validType }) => `Expected ${validType} but got (${currentType}).`,
- *   formatCase: "toKebabCase"
+ * // ❌ Throws a TypeError with a custom message function and formatCase
+ * assertIsBoolean(/regex/, {
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ *   formatCase: "toPascalCaseSpace"
+ * });
+ * // ➔ TypeError: "Expected boolean but got (Reg Exp)."
+ *
+ * // ❌ Throws a TypeError with a custom useAcronyms option
+ * // Case 1:
+ * assertIsBoolean(new URL("https://example.com"),{
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
  * });
- * // ➔ TypeError: "Expected boolean but got (big-int)."
+ * // ➔ TypeError: "Expected boolean but got (url)."
+ * assertIsBoolean(new URL("https://example.com"), {
+ *   useAcronyms: true,
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected boolean but got (URL)."
+ *
+ * // Case 2:
+ * assertIsBoolean(new URLSearchParams, {
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected boolean but got (UrlSearchParams)."
+ * assertIsBoolean(new URLSearchParams, {
+ *   useAcronyms: true,
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected boolean but got (URLSearchParams)."
  * ```
  * -------------------------------------------------------
  * ✅ ***Real-world usage example***:
  * ```ts
- * type User = { name: string; email: string };
- * const mixedValue: string | User | boolean | number | undefined = getUserInput();
+ * const mixedValue: string | boolean | number | undefined = getUserInput();
  *
- * // ❌ Throws if not boolean
- * // ⚠️ Code below after this call, will NOT be executed if the error is thrown
- * assertIsBoolean(mixedValue, { message: "Must be boolean!", errorType: "RangeError" });
+ * // Runtime assertion: throws if `mixedValue` is not a `boolean`
+ * assertIsBoolean(mixedValue, {
+ *   errorType: "RangeError",
+ *   message: "Must be boolean!"
+ * });
  *
- * // ✅ After this call, TypeScript knows `mixedValue` is boolean
- * const result: boolean = mixedValue; // ➔ Safe to use
+ * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `boolean` here
+ * const result: boolean = mixedValue; // ➔ Safe type assignment
  * ```
  */
-declare const assertIsBoolean:(value:unknown,options?:OptionsAssertIs)=>asserts value is boolean;
+declare const assertIsBoolean: (value: unknown, options?: OptionsAssertIs) => asserts value is boolean;
+
 /** -------------------------------------------------------
  * * ***Type guard assertion: `assertIsBigInt`.***
  * -------------------------------------------------------
@@ -205,9 +256,10 @@ declare const assertIsBoolean:(value:unknown,options?:OptionsAssertIs)=>asserts
  * @param {*} value - ***The value to validate.***
  * @param {OptionsAssertIs} [options]
  *  ***Optional configuration:***
- *   - `message`: A custom error message (`string` or `function`).
- *   - `errorType`: Built-in JavaScript error type to throw on failure (default `"TypeError"`).
- *   - `formatCase`: Controls type formatting (from `GetPreciseTypeOptions`).
+ *    - `message`: A custom error message (`string` or `function`).
+ *    - `errorType`: Built-in JavaScript error type to throw on failure (default `"TypeError"`).
+ *    - `formatCase`: Controls how detected type names are formatted case in error messages.
+ *    - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.
  * @returns {boolean} Narrows `value` to `bigint` if no error is thrown.
  * @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 bigint.
  * @example
@@ -216,46 +268,79 @@ declare const assertIsBoolean:(value:unknown,options?:OptionsAssertIs)=>asserts
  * assertIsBigInt(123n);
  * // No error, value is bigint
  *
- * // ❌ Throws TypeError with default message
+ * // ❌ Throws TypeError (default behavior)
  * assertIsBigInt(42);
  * // ➔ TypeError: "Parameter input (`value`) must be of type `bigint`, but received: `number`."
  *
- * // ❌ Throws with custom string message
+ * // ❌ Throws a TypeError with a custom string static message
  * assertIsBigInt("123", { message: "Must be a bigint!" });
  * // ➔ TypeError: "Must be a bigint!"
  *
- * // ❌ Throws with custom function message + case formatting
- * assertIsBigInt(42, {
- *   message: ({ currentType, validType }) => `Expected ${validType} but got (${currentType}).`,
- *   formatCase: "toKebabCase"
+ * // ❌ Throws custom error type (e.g., RangeError)
+ * assertIsBigInt(async function () {}, { errorType: "RangeError" });
+ * // ➔ RangeError: "Parameter input (`value`) must be of type `bigint`, but received: `async-function`."
+ *
+ * // ❌ Throws a TypeError with a custom message function and formatCase
+ * assertIsBigInt(/regex/, {
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ *   formatCase: "toPascalCaseSpace"
  * });
- * // ➔ TypeError: "Expected bigint but got (number)."
+ * // ➔ TypeError: "Expected bigint but got (Reg Exp)."
  *
- * // ❌ Throws with custom function message + formatCase showing big-int
- * assertIsBigInt(123, {
- *   message: ({ currentType, validType }) => `Expected ${validType} but got (${currentType}).`,
- *   formatCase: "toKebabCase"
+ * // ❌ Throws a TypeError with a custom useAcronyms option
+ * // Case 1:
+ * assertIsBigInt(new URL("https://example.com"),{
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
  * });
- * // ➔ TypeError: "Expected bigint but got (number)."
+ * // ➔ TypeError: "Expected bigint but got (url)."
+ * assertIsBigInt(new URL("https://example.com"), {
+ *   useAcronyms: true,
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected bigint but got (URL)."
  *
- * // ❌ Throws custom error type (e.g., RangeError)
- * assertIsBigInt(42, { errorType: "RangeError" });
- * // ➔ RangeError: "Parameter input (`value`) must be of type `bigint`, but received: `number`."
+ * // Case 2:
+ * assertIsBigInt(new URLSearchParams, {
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected bigint but got (UrlSearchParams)."
+ * assertIsBigInt(new URLSearchParams, {
+ *   useAcronyms: true,
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected bigint but got (URLSearchParams)."
  * ```
  * -------------------------------------------------------
  * ✅ ***Real-world usage example***:
  * ```ts
  * const mixedValue: string | bigint | undefined = getUserInput();
  *
- * // ❌ Throws if not bigint
- * assertIsBigInt(mixedValue, { message: "Must be a bigint!", errorType: "TypeError" });
+ * // Runtime assertion: throws if `mixedValue` is not a `bigint`
+ * assertIsBigInt(mixedValue, {
+ *   errorType: "RangeError",
+ *   message: "Must be bigint!"
+ * });
  *
- * // ✅ After this call, TypeScript knows `mixedValue` is bigint
- * const result: bigint = mixedValue;
- * console.log(result + 100n);
+ * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `bigint` here
+ * const result: bigint = mixedValue; // ➔ Safe type assignment
+ * console.log(result + 100n);        // ➔ Safe to operation
  * ```
  */
-declare const assertIsBigInt:(value:unknown,options?:OptionsAssertIs)=>asserts value is bigint;type OptionsAssertIsNumber=OptionsAssertIs & IsNumberOptions;
+declare const assertIsBigInt: (value: unknown, options?: OptionsAssertIs) => asserts value is bigint;
+
+type OptionsAssertIsNumber = OptionsAssertIs & IsNumberOptions;
 /** -------------------------------------------------------
  * * ***Type guard assertion: `assertIsNumber`.***
  * -------------------------------------------------------
@@ -285,59 +370,101 @@ declare const assertIsBigInt:(value:unknown,options?:OptionsAssertIs)=>asserts v
  * @param {*} value - ***The value to validate.***
  * @param {OptionsAssertIsNumber} [options]
  *  ***Optional configuration:***
- *   - `message`: A custom error message (`string` or `function`).
- *   - `errorType`: Built-in JavaScript error type to throw on failure (default `"TypeError"`).
- *   - `formatCase`: Controls type formatting (from `GetPreciseTypeOptions`).
- *   - `includeNaN`: Whether to treat `NaN` as valid.
+ *    - `message`: A custom error message (`string` or `function`).
+ *    - `errorType`: Built-in JavaScript error type to throw on failure (default `"TypeError"`).
+ *    - `formatCase`: Controls how detected type names are formatted case in error messages.
+ *    - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.
+ *    - `includeNaN`: Whether to treat `NaN` as valid.
  * @returns {boolean} Narrows `value` to `number` if no error is thrown.
  * @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 number (or is `NaN` when `includeNaN` is `false`).
  * @example
  * ```ts
  * // ✅ Simple usage
  * assertIsNumber(123);
+ * assertIsNumber(NaN, { includeNaN: true });
  * // No error, value is number
  *
- * // ❌ Throws TypeError with default message
+ * // ❌ Throws TypeError (default behavior)
+ * // Case 1: Invalid input type — received a string instead of a number
  * assertIsNumber("42");
  * // ➔ TypeError: "Parameter input (`value`) must be of type `number`, but received: `string`."
  *
- * // ❌ Throws with custom string message
- * assertIsNumber(true, { message: "Must be a number!" });
- * // ➔ TypeError: "Must be a number!"
+ * // Case 2: Default option includeNaN is false
+ * assertIsNumber(NaN);
+ * // ➔ TypeError: "Parameter input (`value`) must be of type `number`, but received: `NaN`."
+ *
+ * // Case 3: The new Number() is a Number object (constructor), not a primitive number
+ * assertIsNumber(new Number("123"));
+ * // ➔ TypeError: "Parameter input (`value`) must be of type `number`, but received: `number-constructor`."
+ *
+ * // ❌ Throws custom error type (e.g., RangeError)
+ * assertIsNumber(async function () {}, { errorType: "RangeError" });
+ * // ➔ RangeError: "Parameter input (`value`) must be of type `number`, but received: `async-function`."
  *
- * // ❌ Throws RangeError instead of TypeError
- * assertIsNumber("42", { errorType: "RangeError" });
- * // ➔ RangeError: "Parameter input (`value`) must be of type `number`, but received: `string`."
+ * // ❌ Throws a TypeError with a custom string static message
+ * assertIsNumber("123", { message: "Must be a number!" });
+ * // ➔ TypeError: "Must be a number!"
  *
- * // ❌ Throws with custom function message + case formatting
- * assertIsNumber("hello", {
- *   message: ({ currentType, validType }) => `Expected ${validType} but got (${currentType}).`,
- *   formatCase: "toKebabCase"
+ * // ❌ Throws a TypeError with a custom message function and formatCase
+ * assertIsNumber(/regex/, {
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ *   formatCase: "toPascalCaseSpace"
  * });
- * // ➔ TypeError: "Expected number but got (string)."
+ * // ➔ TypeError: "Expected number but got (Reg Exp)."
  *
- * // ⚠️ NaN is invalid by default
- * assertIsNumber(NaN);
- * // ➔ TypeError: "Parameter input (`value`) must be of type `number`, but received: `NaN`."
+ * // ❌ Throws a TypeError with a custom useAcronyms option
+ * // Case 1:
+ * assertIsNumber(new URL("https://example.com"),{
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected number but got (url)."
+ * assertIsNumber(new URL("https://example.com"), {
+ *   useAcronyms: true,
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected number but got (URL)."
  *
- * // ✅ Allow NaN explicitly
- * assertIsNumber(NaN, { includeNaN: true });
- * // No error
+ * // Case 2:
+ * assertIsNumber(new URLSearchParams, {
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected number but got (UrlSearchParams)."
+ * assertIsNumber(new URLSearchParams, {
+ *   useAcronyms: true,
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected number but got (URLSearchParams)."
  * ```
  * -------------------------------------------------------
  * ✅ ***Real-world usage example***:
  * ```ts
  * const mixedValue: string | number | undefined = getUserInput();
  *
- * // ❌ Throws if not number
- * assertIsNumber(mixedValue, { message: "Must be a number!", errorType: "RangeError" });
+ * // Runtime assertion: throws if `mixedValue` is not a `number`
+ * assertIsNumber(mixedValue, {
+ *   errorType: "RangeError",
+ *   message: "Must be number!"
+ * });
  *
- * // ✅ After this call, TypeScript knows `mixedValue` is number
- * const result: number = mixedValue; // ➔ Safe to use
- * console.log(result + 100);
+ * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `number` here
+ * const result: number = mixedValue; // ➔ Safe type assignment
+ * console.log(result + 100);         // ➔ Safe to operation
  * ```
  */
-declare const assertIsNumber:(value:unknown,options?:OptionsAssertIsNumber)=>asserts value is number;
+declare const assertIsNumber: (value: unknown, options?: OptionsAssertIsNumber) => asserts value is number;
+
 /** -------------------------------------------------------
  * * ***Type guard assertion: `assertIsArray`.***
  * -------------------------------------------------------
@@ -364,50 +491,95 @@ declare const assertIsNumber:(value:unknown,options?:OptionsAssertIsNumber)=>ass
  * @param {*} value - ***The value to validate.***
  * @param {OptionsAssertIs} [options]
  *  ***Optional configuration:***
- *   - `message`: A custom error message (`string` or `function`).
- *   - `errorType`: Built-in JavaScript error type to throw on failure (default `"TypeError"`).
- *   - `formatCase`: Controls type formatting (from `GetPreciseTypeOptions`).
+ *    - `message`: A custom error message (`string` or `function`).
+ *    - `errorType`: Built-in JavaScript error type to throw on failure (default `"TypeError"`).
+ *    - `formatCase`: Controls how detected type names are formatted case in error messages.
+ *    - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.
  * @returns {boolean} Narrows `value` to an `array` **(generic support)** if no error is thrown.
  * @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 an array.
  * @example
  * ```ts
  * // ✅ Simple usage
- * assertIsArray([1, 2, 3]);
+ * assertIsArray([]);
+ * assertIsArray(["123", 456]);
+ * assertIsArray(Array.from(["abc"]));
  * // No error, value is array
  *
- * // ❌ Throws TypeError with default message
- * assertIsArray({ a: 1 });
- * // ➔ TypeError: "Parameter input (`value`) must be of type `array`, but received: `plain-object`."
+ * // ❌ Throws TypeError (default behavior)
+ * // Case 1: Invalid input type — received a string instead of a array
+ * assertIsArray("42");
+ * // ➔ TypeError: "Parameter input (`value`) must be of type `array`, but received: `string`."
  *
- * // ❌ Throws with custom string message
- * assertIsArray(42, { message: "Must be an array!" });
- * // ➔ TypeError: "Must be an array!"
+ * // ❌ Throws custom error type (e.g., RangeError)
+ * assertIsArray(async function () {}, { errorType: "RangeError" });
+ * // ➔ RangeError: "Parameter input (`value`) must be of type `array`, but received: `async-function`."
+ *
+ * // ❌ Throws a TypeError with a custom string static message
+ * assertIsArray("123", { message: "Must be a array!" });
+ * // ➔ TypeError: "Must be a array!"
  *
- * // ❌ Throws RangeError instead of TypeError
- * assertIsArray(42, { errorType: "RangeError" });
- * // ➔ RangeError: "Parameter input (`value`) must be of type `array`, but received: `number`."
+ * // ❌ Throws a TypeError with a custom message function and formatCase
+ * assertIsArray(/regex/, {
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ *   formatCase: "toPascalCaseSpace"
+ * });
+ * // ➔ TypeError: "Expected array but got (Reg Exp)."
  *
- * // ❌ Throws with custom function message + case formatting
- * assertIsArray(42n, {
- *   message: ({ currentType, validType }) => `Expected ${validType} but got (${currentType}).`,
- *   formatCase: "toKebabCase"
+ * // ❌ Throws a TypeError with a custom useAcronyms option
+ * // Case 1:
+ * assertIsArray(new URL("https://example.com"),{
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected array but got (url)."
+ * assertIsArray(new URL("https://example.com"), {
+ *   useAcronyms: true,
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
  * });
- * // ➔ TypeError: "Expected array but got (big-int)."
+ * // ➔ TypeError: "Expected array but got (URL)."
+ *
+ * // Case 2:
+ * assertIsArray(new URLSearchParams, {
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected array but got (UrlSearchParams)."
+ * assertIsArray(new URLSearchParams, {
+ *   useAcronyms: true,
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected array but got (URLSearchParams)."
  * ```
  * -------------------------------------------------------
- * ✅ ***Real-world usage with generic narrowing***:
+ * ✅ ***Real-world usage example***:
  * ```ts
  * const mixedValue: string | number[] | undefined = getUserInput();
  *
- * // ❌ Throws if not array
- * assertIsArray(mixedValue, { message: "Must be an array!", errorType: "RangeError" });
+ * // Runtime assertion: throws if `mixedValue` is not a `number[]`
+ * assertIsArray(mixedValue, {
+ *   errorType: "RangeError",
+ *   message: "Must be array!"
+ * });
  *
- * // ✅ After this call, TypeScript knows `mixedValue` is narrowed to number[]
- * const result: number[] = mixedValue; // ➔ Safe to use
- * console.log(result.length);
+ * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `number[]` here
+ * const result: number[] = mixedValue; // ➔ Safe type assignment
+ * console.log(result.push(1, 2, 3));   // ➔ Safe to use array methods
  * ```
  */
-declare function assertIsArray<T extends unknown[]>(value:T,options?:OptionsAssertIs):value is Extract<T,unknown[]>;declare function assertIsArray<T extends readonly unknown[]>(value:T,options?:OptionsAssertIs):value is Extract<T,readonly unknown[]>;declare function assertIsArray(value:unknown,options?:OptionsAssertIs):value is unknown[];
+declare function assertIsArray<T extends unknown[]>(value: T, options?: OptionsAssertIs): asserts value is Extract<T, unknown[]>;
+declare function assertIsArray<T extends readonly unknown[]>(value: T, options?: OptionsAssertIs): asserts value is Extract<T, readonly unknown[]>;
+declare function assertIsArray(value: unknown, options?: OptionsAssertIs): asserts value is unknown[];
+
 /** -------------------------------------------------------
  * * ***Type guard assertion: `assertIsPlainObject`.***
  * -------------------------------------------------------
@@ -419,6 +591,20 @@ declare function assertIsArray<T extends unknown[]>(value:T,options?:OptionsAsse
  *    - ❌ If `value` is not a `plain-object` ➔ throws a built-in error with either:
  *      - A custom error message (`options.message`), or
  *      - A default message including the actual type.
+ * - **A valid `plain object` is:**
+ *    - Created by the `Object` constructor, or
+ *    - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).
+ *     - **✅ Returns `undefined` (valid) for:**
+ *         - Empty object literals: `{}`
+ *         - Objects with null prototype: `Object.create(null)`
+ *     - **❌ Returns `throws` for:**
+ *         - Arrays (`[]`, `new Array()`)
+ *         - Functions (regular, arrow, or class constructors)
+ *         - Built-in objects: `Date`, `RegExp`, `Error`, `Map`, `Set`, `WeakMap`, `WeakSet`
+ *         - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`
+ *         - `null` or `undefined`
+ *         - Symbols
+ *         - Class instances
  * - **⚠️ Error type selection (`options.errorType`):**
  *    - You can override the type of error thrown when validation fails.
  *    - Must be one of the standard JavaScript built-in errors:
@@ -434,35 +620,72 @@ declare function assertIsArray<T extends unknown[]>(value:T,options?:OptionsAsse
  * @param {*} value - ***The value to validate.***
  * @param {OptionsAssertIs} [options]
  *  ***Optional configuration:***
- *   - `message`: A custom error message (`string` or `function`).
- *   - `errorType`: Built-in JavaScript error type to throw on failure (default `"TypeError"`).
- *   - `formatCase`: Controls type formatting (from `GetPreciseTypeOptions`).
+ *    - `message`: A custom error message (`string` or `function`).
+ *    - `errorType`: Built-in JavaScript error type to throw on failure (default `"TypeError"`).
+ *    - `formatCase`: Controls how detected type names are formatted case in error messages.
+ *    - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.
  * @returns {boolean} Narrows `value` to a `plain-object` **(generic support)** if no error is thrown.
  * @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.
  * @example
  * ```ts
  * // ✅ Simple usage
  * assertIsPlainObject({ a: 1, b: 2 });
- * // ➔ ok, value is plain object
+ * // No error, value is plain-object
+ *
+ * // ❌ Throws TypeError (default behavior)
+ * // Case 1: Invalid input type — received a string instead of a plain-object
+ * assertIsPlainObject("42");
+ * // ➔ TypeError: "Parameter input (`value`) must be of type `plain-object`, but received: `string`."
  *
- * // ❌ Throws TypeError with default message
- * assertIsPlainObject([1, 2, 3]);
- * // ➔ TypeError: "Parameter input (`value`) must be of type `plain-object`, but received: `array`."
+ * // ❌ Throws custom error type (e.g., RangeError)
+ * assertIsPlainObject(async function () {}, { errorType: "RangeError" });
+ * // ➔ RangeError: "Parameter input (`value`) must be of type `plain-object`, but received: `async-function`."
  *
- * // ❌ Throws with custom string message
- * assertIsPlainObject("hello", { message: "Must be plain object!" });
- * // ➔ TypeError: "Must be plain object!"
+ * // ❌ Throws a TypeError with a custom string static message
+ * assertIsPlainObject("123", { message: "Must be a plain-object!" });
+ * // ➔ TypeError: "Must be a plain-object!"
  *
- * // ❌ Throws RangeError instead of TypeError
- * assertIsPlainObject(42, { errorType: "RangeError" });
- * // ➔ RangeError: "Parameter input (`value`) must be of type `plain-object`, but received: `number`."
+ * // ❌ Throws a TypeError with a custom message function and formatCase
+ * assertIsPlainObject(/regex/, {
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ *   formatCase: "toPascalCaseSpace"
+ * });
+ * // ➔ TypeError: "Expected plain-object but got (Reg Exp)."
  *
- * // ❌ Throws with custom message function + case formatting
- * assertIsPlainObject(42n, {
- *   message: ({ currentType, validType }) => `Expected ${validType} but got (${currentType}).`,
- *   formatCase: "toKebabCase"
+ * // ❌ Throws a TypeError with a custom useAcronyms option
+ * // Case 1:
+ * assertIsPlainObject(new URL("https://example.com"),{
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected plain-object but got (url)."
+ * assertIsPlainObject(new URL("https://example.com"), {
+ *   useAcronyms: true,
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
  * });
- * // ➔ TypeError: "Expected plain-object but got (big-int)."
+ * // ➔ TypeError: "Expected plain-object but got (URL)."
+ *
+ * // Case 2:
+ * assertIsPlainObject(new URLSearchParams, {
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected plain-object but got (UrlSearchParams)."
+ * assertIsPlainObject(new URLSearchParams, {
+ *   useAcronyms: true,
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected plain-object but got (URLSearchParams)."
  * ```
  * -------------------------------------------------------
  * ✅ ***Real-world usage with generic narrowing***:
@@ -470,15 +693,19 @@ declare function assertIsArray<T extends unknown[]>(value:T,options?:OptionsAsse
  * type User = { name: string; email: string };
  * const mixedValue: string | User | boolean | number | undefined = getUserInput();
  *
- * // ❌ Throws if not plain object
- * assertIsPlainObject(mixedValue, { message: "Must be plain object!", errorType: "RangeError" });
+ * // Runtime assertion: throws if `mixedValue` is not a `plain-object`
+ * assertIsPlainObject(mixedValue, {
+ *   errorType: "RangeError",
+ *   message: "Must be plain object!"
+ * });
  *
- * // ✅ After this call, TypeScript knows `mixedValue` is narrowed to User
- * const user: User = mixedValue; // ➔ safe
- * console.log(user.email);       // ➔ type-safe
+ * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `User` here
+ * const user: User = mixedValue; // ➔ Safe type assignment
+ * console.log(user.email);       // ➔ Safe to access object properties
  * ```
  */
-declare function assertIsPlainObject<T>(value:T,options?:OptionsAssertIs):asserts value is IsPlainObjectResult<T>;
+declare function assertIsPlainObject<T>(value: T, options?: OptionsAssertIs): asserts value is IsPlainObjectResult<T>;
+
 /** -------------------------------------------------------
  * * ***Type guard assertion: `assertIsString`.***
  * -------------------------------------------------------
@@ -507,48 +734,93 @@ declare function assertIsPlainObject<T>(value:T,options?:OptionsAssertIs):assert
  * @param {*} value - ***The value to validate.***
  * @param {OptionsAssertIs} [options]
  *  ***Optional configuration:***
- *   - `message`: A custom error message (`string` or `function`).
- *   - `errorType`: Built-in JavaScript error type to throw on failure (default `"TypeError"`).
- *   - `formatCase`: Controls type formatting (from `GetPreciseTypeOptions`).
+ *    - `message`: A custom error message (`string` or `function`).
+ *    - `errorType`: Built-in JavaScript error type to throw on failure (default `"TypeError"`).
+ *    - `formatCase`: Controls how detected type names are formatted case in error messages.
+ *    - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.
  * @returns {boolean} Narrows `value` to `string` if no error is thrown.
  * @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 primitive string.
  * @example
  * ```ts
  * // ✅ Simple usage
  * assertIsString("hello");
- * // ➔ ok value is string, no error
+ * // No error, value is string
  *
- * // ❌ Throws TypeError with default message
+ * // ❌ Throws TypeError (default behavior)
+ * // Case 1: Invalid input type — received a string instead of a string
  * assertIsString(42);
  * // ➔ TypeError: "Parameter input (`value`) must be of type `string`, but received: `number`."
  *
- * // ❌ Throws with custom string message
- * assertIsString(42, { message: "Must be a string!" });
+ * // Case 3: The new String() is a String object (constructor), not a primitive string
+ * assertIsString(new String("abc"));
+ * // ➔ TypeError: "Parameter input (`value`) must be of type `string`, but received: `string-constructor`."
+ *
+ * // ❌ Throws custom error type (e.g., RangeError)
+ * assertIsString(async function () {}, { errorType: "RangeError" });
+ * // ➔ RangeError: "Parameter input (`value`) must be of type `string`, but received: `async-function`."
+ *
+ * // ❌ Throws a TypeError with a custom string static message
+ * assertIsString(123, { message: "Must be a string!" });
  * // ➔ TypeError: "Must be a string!"
  *
- * // ❌ Throws RangeError instead of TypeError
- * assertIsString(42, { errorType: "RangeError" });
- * // ➔ RangeError: "Parameter input (`value`) must be of type `string`, but received: `number`."
+ * // ❌ Throws a TypeError with a custom message function and formatCase
+ * assertIsString(/regex/, {
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ *   formatCase: "toPascalCaseSpace"
+ * });
+ * // ➔ TypeError: "Expected string but got (Reg Exp)."
  *
- * // ❌ Throws with custom message function + case formatting
- * assertIsString(42n, {
- *   message: ({ currentType, validType }) => `Expected ${validType} but got (${currentType}).`,
- *   formatCase: "toKebabCase"
+ * // ❌ Throws a TypeError with a custom useAcronyms option
+ * // Case 1:
+ * assertIsString(new URL("https://example.com"),{
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected string but got (url)."
+ * assertIsString(new URL("https://example.com"), {
+ *   useAcronyms: true,
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
  * });
- * // ➔ TypeError: "Expected string but got (big-int)."
+ * // ➔ TypeError: "Expected string but got (URL)."
+ *
+ * // Case 2:
+ * assertIsString(new URLSearchParams, {
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected string but got (UrlSearchParams)."
+ * assertIsString(new URLSearchParams, {
+ *   useAcronyms: true,
+ *   formatCase: "toPascalCase",
+ *   message: ({ currentType, validType }) => {
+ *     return `Expected ${validType} but got (${currentType}).`
+ *   },
+ * });
+ * // ➔ TypeError: "Expected string but got (URLSearchParams)."
  * ```
  * -------------------------------------------------------
  * ✅ ***Real-world usage with generic narrowing***:
  * ```ts
- * type User = { name: string; email: string };
- * const mixedValue: string | User | undefined = getUserInput();
+ * const mixedValue: string | boolean | undefined = getUserInput();
  *
- * // ❌ Throws if the value is not string
- * assertIsString(mixedValue, { message: "Must be a string!", errorType: "RangeError" });
+ * // Runtime assertion: throws if `mixedValue` is not a `string`
+ * assertIsString(mixedValue, {
+ *   errorType: "RangeError",
+ *   message: "Must be a string!"
+ * });
  *
- * // ✅ After this call, TypeScript knows `mixedValue` is string
- * const result: string = mixedValue; // ➔ safe
- * console.log(result.toUpperCase()); // ➔ type-safe
+ * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `string` here
+ * const result: string = mixedValue; // ➔ Safe type assignment
+ * console.log(result.toUpperCase()); // ➔ Safe to call String.prototype methods
  * ```
  */
-declare const assertIsString:(value:unknown,options?:OptionsAssertIs)=>asserts value is string;export{assertIsArray,assertIsBigInt,assertIsBoolean,assertIsNumber,assertIsPlainObject,assertIsString};
+declare const assertIsString: (value: unknown, options?: OptionsAssertIs) => asserts value is string;
+
+export { assertIsArray, assertIsBigInt, assertIsBoolean, assertIsNumber, assertIsPlainObject, assertIsString };