@rzl-zone/utils-js 3.13.0-beta.3 → 3.13.1-beta.0

package/dist/{assertIsString-Ddz4y81W.js → assertIsString-1iLqxrN0.js}

@@ -2,12 +2,12 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { k as isString, n as resolveErrorMessageAssertions } from "./assertIsBoolean-Clc7Vw4v.js";
+import { k as isString, n as resolveErrorMessageAssertions } from "./assertIsBoolean-DDhQ2D-k.js";
 const assertIsString = (value, options = {}) => {
 	if (isString(value)) return;
 	resolveErrorMessageAssertions({
@@ -17,4 +17,4 @@ const assertIsString = (value, options = {}) => {
 	});
 };
 export { assertIsString as t };
-//# sourceMappingURL=assertIsString-Ddz4y81W.js.map
+//# sourceMappingURL=assertIsString-1iLqxrN0.js.map

package/dist/{assertIsString-Ddz4y81W.js.map → assertIsString-1iLqxrN0.js.map}

@@ -1 +1 @@
-{"version":3,"file":"assertIsString-Ddz4y81W.js","names":[],"sources":["../src/assertions/strings/assertIsString.ts"],"sourcesContent":["import { isString } from \"@/predicates/is/isString\";\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsString`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **primitive-string**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `primitive-string`.\n *    - ✅ If `value` is a `primitive-string` ➔ execution continues normally.\n *    - ❌ If `value` is not a `primitive-string` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n * - **ℹ️ Note:**\n *    - A \"string\" refers strictly to a JavaScript `primitive-string` type (e.g., `\"hello\"`, `\"\"`, `\"123\"`).\n *    - This function excludes `String` objects created with `new String()`.\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`: 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 `string` 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 primitive string.\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsString(\"hello\");\n * // No error, value is string\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a string\n * assertIsString(42);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `string`, but received: `number`.\"\n *\n * // Case 3: The new String() is a String object (constructor), not a primitive string\n * assertIsString(new String(\"abc\"));\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `string`, but received: `string-constructor`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsString(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `string`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsString(123, { message: \"Must be a string!\" });\n * // ➔ TypeError: \"Must be a string!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsString(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected string but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsString(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (url).\"\n * assertIsString(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (URL).\"\n *\n * // Case 2:\n * assertIsString(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (UrlSearchParams).\"\n * assertIsString(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage with generic narrowing***:\n * ```ts\n * const mixedValue: string | boolean | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `string`\n * assertIsString(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be a string!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `string` here\n * const result: string = mixedValue; // ➔ Safe type assignment\n * console.log(result.toUpperCase()); // ➔ Safe to call String.prototype methods\n * ```\n */\nexport const assertIsString: (\n  value: unknown,\n  options?: OptionsAssertIs\n) => asserts value is string = (\n  value: unknown,\n  options: OptionsAssertIs = {}\n): asserts value is string => {\n  if (isString(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"string\"\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyHA,MAAa,kBAIX,OACA,UAA2B,EAAE,KACD;CAC5B,IAAI,SAAS,MAAM,EAAE;CAErB,8BAA8B;EAC5B;EACA;EACA,mBAAmB;EACpB,CAAC"}
+{"version":3,"file":"assertIsString-1iLqxrN0.js","names":[],"sources":["../src/assertions/strings/assertIsString.ts"],"sourcesContent":["import { isString } from \"@/predicates/is/isString\";\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsString`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **primitive-string**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `primitive-string`.\n *    - ✅ If `value` is a `primitive-string` ➔ execution continues normally.\n *    - ❌ If `value` is not a `primitive-string` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n * - **ℹ️ Note:**\n *    - A \"string\" refers strictly to a JavaScript `primitive-string` type (e.g., `\"hello\"`, `\"\"`, `\"123\"`).\n *    - This function excludes `String` objects created with `new String()`.\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`: 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 `string` 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 primitive string.\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsString(\"hello\");\n * // No error, value is string\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a string\n * assertIsString(42);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `string`, but received: `number`.\"\n *\n * // Case 3: The new String() is a String object (constructor), not a primitive string\n * assertIsString(new String(\"abc\"));\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `string`, but received: `string-constructor`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsString(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `string`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsString(123, { message: \"Must be a string!\" });\n * // ➔ TypeError: \"Must be a string!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsString(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected string but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsString(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (url).\"\n * assertIsString(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (URL).\"\n *\n * // Case 2:\n * assertIsString(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (UrlSearchParams).\"\n * assertIsString(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage with generic narrowing***:\n * ```ts\n * const mixedValue: string | boolean | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `string`\n * assertIsString(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be a string!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `string` here\n * const result: string = mixedValue; // ➔ Safe type assignment\n * console.log(result.toUpperCase()); // ➔ Safe to call String.prototype methods\n * ```\n */\nexport const assertIsString: (\n  value: unknown,\n  options?: OptionsAssertIs\n) => asserts value is string = (\n  value: unknown,\n  options: OptionsAssertIs = {}\n): asserts value is string => {\n  if (isString(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"string\"\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyHA,MAAa,kBAIX,OACA,UAA2B,CAAC,MACA;CAC5B,IAAI,SAAS,KAAK,GAAG;CAErB,8BAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}

package/dist/{assertIsString-DxIqUfF1.cjs → assertIsString-DGDLC-XD.cjs}

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_assertIsBoolean = require('./assertIsBoolean-BKcvET7Z.cjs');
+const require_assertIsBoolean = require('./assertIsBoolean-CEx4KbHg.cjs');
 const assertIsString = (value, options = {}) => {
 	if (require_assertIsBoolean.isString(value)) return;
 	require_assertIsBoolean.resolveErrorMessageAssertions({
@@ -23,4 +23,4 @@ Object.defineProperty(exports, 'assertIsString', {
     return assertIsString;
   }
 });
-//# sourceMappingURL=assertIsString-DxIqUfF1.cjs.map
+//# sourceMappingURL=assertIsString-DGDLC-XD.cjs.map

package/dist/{assertIsString-DxIqUfF1.cjs.map → assertIsString-DGDLC-XD.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"assertIsString-DxIqUfF1.cjs","names":["isString"],"sources":["../src/assertions/strings/assertIsString.ts"],"sourcesContent":["import { isString } from \"@/predicates/is/isString\";\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsString`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **primitive-string**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `primitive-string`.\n *    - ✅ If `value` is a `primitive-string` ➔ execution continues normally.\n *    - ❌ If `value` is not a `primitive-string` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n * - **ℹ️ Note:**\n *    - A \"string\" refers strictly to a JavaScript `primitive-string` type (e.g., `\"hello\"`, `\"\"`, `\"123\"`).\n *    - This function excludes `String` objects created with `new String()`.\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`: 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 `string` 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 primitive string.\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsString(\"hello\");\n * // No error, value is string\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a string\n * assertIsString(42);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `string`, but received: `number`.\"\n *\n * // Case 3: The new String() is a String object (constructor), not a primitive string\n * assertIsString(new String(\"abc\"));\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `string`, but received: `string-constructor`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsString(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `string`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsString(123, { message: \"Must be a string!\" });\n * // ➔ TypeError: \"Must be a string!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsString(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected string but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsString(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (url).\"\n * assertIsString(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (URL).\"\n *\n * // Case 2:\n * assertIsString(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (UrlSearchParams).\"\n * assertIsString(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage with generic narrowing***:\n * ```ts\n * const mixedValue: string | boolean | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `string`\n * assertIsString(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be a string!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `string` here\n * const result: string = mixedValue; // ➔ Safe type assignment\n * console.log(result.toUpperCase()); // ➔ Safe to call String.prototype methods\n * ```\n */\nexport const assertIsString: (\n  value: unknown,\n  options?: OptionsAssertIs\n) => asserts value is string = (\n  value: unknown,\n  options: OptionsAssertIs = {}\n): asserts value is string => {\n  if (isString(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"string\"\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyHA,MAAa,kBAIX,OACA,UAA2B,EAAE,KACD;CAC5B,IAAIA,iCAAS,MAAM,EAAE;CAErB,sDAA8B;EAC5B;EACA;EACA,mBAAmB;EACpB,CAAC"}
+{"version":3,"file":"assertIsString-DGDLC-XD.cjs","names":["isString"],"sources":["../src/assertions/strings/assertIsString.ts"],"sourcesContent":["import { isString } from \"@/predicates/is/isString\";\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsString`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **primitive-string**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `primitive-string`.\n *    - ✅ If `value` is a `primitive-string` ➔ execution continues normally.\n *    - ❌ If `value` is not a `primitive-string` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n * - **ℹ️ Note:**\n *    - A \"string\" refers strictly to a JavaScript `primitive-string` type (e.g., `\"hello\"`, `\"\"`, `\"123\"`).\n *    - This function excludes `String` objects created with `new String()`.\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`: 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 `string` 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 primitive string.\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsString(\"hello\");\n * // No error, value is string\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a string\n * assertIsString(42);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `string`, but received: `number`.\"\n *\n * // Case 3: The new String() is a String object (constructor), not a primitive string\n * assertIsString(new String(\"abc\"));\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `string`, but received: `string-constructor`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsString(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `string`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsString(123, { message: \"Must be a string!\" });\n * // ➔ TypeError: \"Must be a string!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsString(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected string but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsString(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (url).\"\n * assertIsString(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (URL).\"\n *\n * // Case 2:\n * assertIsString(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (UrlSearchParams).\"\n * assertIsString(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected string but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage with generic narrowing***:\n * ```ts\n * const mixedValue: string | boolean | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `string`\n * assertIsString(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be a string!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `string` here\n * const result: string = mixedValue; // ➔ Safe type assignment\n * console.log(result.toUpperCase()); // ➔ Safe to call String.prototype methods\n * ```\n */\nexport const assertIsString: (\n  value: unknown,\n  options?: OptionsAssertIs\n) => asserts value is string = (\n  value: unknown,\n  options: OptionsAssertIs = {}\n): asserts value is string => {\n  if (isString(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"string\"\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyHA,MAAa,kBAIX,OACA,UAA2B,CAAC,MACA;CAC5B,IAAIA,iCAAS,KAAK,GAAG;CAErB,sDAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}

package/dist/assertions/index.cjs

@@ -2,17 +2,17 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_assertIsBoolean = require('../assertIsBoolean-BKcvET7Z.cjs');
-const require_isBigInt = require('../isBigInt-BePsmNsm.cjs');
-const require_assertIsArray = require('../assertIsArray-DWsgvahU.cjs');
-const require_assertIsString = require('../assertIsString-DxIqUfF1.cjs');
+const require_assertIsBoolean = require('../assertIsBoolean-CEx4KbHg.cjs');
+const require_isBigInt = require('../isBigInt-CqZNWVtI.cjs');
+const require_assertIsArray = require('../assertIsArray-CqIFmlgj.cjs');
+const require_assertIsString = require('../assertIsString-DGDLC-XD.cjs');
 const assertIsBigInt = (value, options = {}) => {
 	if (require_isBigInt.isBigInt(value)) return;
 	require_assertIsBoolean.resolveErrorMessageAssertions({

package/dist/assertions/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["isBigInt","isNumber","hasOwnProp"],"sources":["../../src/assertions/number/assertIsBigInt.ts","../../src/assertions/number/assertIsNumber.ts"],"sourcesContent":["import { isBigInt } from \"@/predicates/is/isBigInt\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsBigInt`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **bigint**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `bigint`.\n *    - ✅ If `value` is a `bigint` ➔ execution continues normally.\n *    - ❌ If `value` is not a `bigint` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n *  - **ℹ️ Note:**\n *    - A `bigint` refers strictly to the JavaScript `bigint` primitive type (e.g., `123n`, `0n`, `-999999999999999999999n`).\n *    - This excludes `BigInt` objects created with `Object(BigInt(123))`.\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`: 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 `bigint` 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 bigint.\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsBigInt(123n);\n * // No error, value is bigint\n *\n * // ❌ Throws TypeError (default behavior)\n * assertIsBigInt(42);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `bigint`, but received: `number`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsBigInt(\"123\", { message: \"Must be a bigint!\" });\n * // ➔ TypeError: \"Must be a bigint!\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsBigInt(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `bigint`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsBigInt(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected bigint but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsBigInt(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (url).\"\n * assertIsBigInt(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (URL).\"\n *\n * // Case 2:\n * assertIsBigInt(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (UrlSearchParams).\"\n * assertIsBigInt(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage example***:\n * ```ts\n * const mixedValue: string | bigint | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `bigint`\n * assertIsBigInt(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be bigint!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `bigint` here\n * const result: bigint = mixedValue; // ➔ Safe type assignment\n * console.log(result + 100n);        // ➔ Safe to operation\n * ```\n */\nexport const assertIsBigInt: (\n  value: unknown,\n  options?: OptionsAssertIs\n) => asserts value is bigint = (\n  value: unknown,\n  options: OptionsAssertIs = {}\n): asserts value is bigint => {\n  if (isBigInt(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"bigint\"\n  });\n};\n","import { isNumber, type IsNumberOptions } from \"@/predicates/is/isNumber\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\n\ntype OptionsAssertIsNumber = OptionsAssertIs & IsNumberOptions;\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsNumber`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **number**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `number`.\n *    - ✅ If `value` is a `number` ➔ execution continues normally.\n *    - ❌ If `value` is not a `number` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n * - **ℹ️ Note:**\n *    - A `number` refers strictly to the JavaScript `number` primitive type (e.g., `42`, `3.14`, `-1`, `0`).\n *    - This excludes `Number` objects created with `new Number(123)`.\n *    - By default, `NaN` is **not considered** valid, you can allow it with `{ includeNaN: true }`.\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 {OptionsAssertIsNumber} [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 *    - `includeNaN`: Whether to treat `NaN` as valid.\n * @returns {boolean} Narrows `value` to `number` 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 number (or is `NaN` when `includeNaN` is `false`).\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsNumber(123);\n * assertIsNumber(NaN, { includeNaN: true });\n * // No error, value is number\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a number\n * assertIsNumber(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `string`.\"\n *\n * // Case 2: Default option includeNaN is false\n * assertIsNumber(NaN);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `NaN`.\"\n *\n * // Case 3: The new Number() is a Number object (constructor), not a primitive number\n * assertIsNumber(new Number(\"123\"));\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `number-constructor`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsNumber(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `number`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsNumber(\"123\", { message: \"Must be a number!\" });\n * // ➔ TypeError: \"Must be a number!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsNumber(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected number but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsNumber(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (url).\"\n * assertIsNumber(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (URL).\"\n *\n * // Case 2:\n * assertIsNumber(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (UrlSearchParams).\"\n * assertIsNumber(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage example***:\n * ```ts\n * const mixedValue: string | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `number`\n * assertIsNumber(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be number!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `number` here\n * const result: number = mixedValue; // ➔ Safe type assignment\n * console.log(result + 100);         // ➔ Safe to operation\n * ```\n */\nexport const assertIsNumber: (\n  value: unknown,\n  options?: OptionsAssertIsNumber\n) => asserts value is number = (\n  value: unknown,\n  options: OptionsAssertIsNumber = {}\n): asserts value is number => {\n  const includeNaN = hasOwnProp(options, \"includeNaN\")\n    ? options.includeNaN\n    : undefined;\n\n  if (isNumber(value, { includeNaN })) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"number\"\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqHA,MAAa,kBAIX,OACA,UAA2B,EAAE,KACD;CAC5B,IAAIA,0BAAS,MAAM,EAAE;CAErB,sDAA8B;EAC5B;EACA;EACA,mBAAmB;EACpB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACEJ,MAAa,kBAIX,OACA,UAAiC,EAAE,KACP;CAK5B,IAAIC,iCAAS,OAAO,EAAE,YAJHC,mCAAW,SAAS,aAAa,GAChD,QAAQ,aACR,QAE8B,CAAC,EAAE;CAErC,sDAA8B;EAC5B;EACA;EACA,mBAAmB;EACpB,CAAC"}
+{"version":3,"file":"index.cjs","names":["isBigInt","isNumber","hasOwnProp"],"sources":["../../src/assertions/number/assertIsBigInt.ts","../../src/assertions/number/assertIsNumber.ts"],"sourcesContent":["import { isBigInt } from \"@/predicates/is/isBigInt\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsBigInt`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **bigint**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `bigint`.\n *    - ✅ If `value` is a `bigint` ➔ execution continues normally.\n *    - ❌ If `value` is not a `bigint` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n *  - **ℹ️ Note:**\n *    - A `bigint` refers strictly to the JavaScript `bigint` primitive type (e.g., `123n`, `0n`, `-999999999999999999999n`).\n *    - This excludes `BigInt` objects created with `Object(BigInt(123))`.\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`: 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 `bigint` 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 bigint.\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsBigInt(123n);\n * // No error, value is bigint\n *\n * // ❌ Throws TypeError (default behavior)\n * assertIsBigInt(42);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `bigint`, but received: `number`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsBigInt(\"123\", { message: \"Must be a bigint!\" });\n * // ➔ TypeError: \"Must be a bigint!\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsBigInt(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `bigint`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsBigInt(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected bigint but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsBigInt(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (url).\"\n * assertIsBigInt(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (URL).\"\n *\n * // Case 2:\n * assertIsBigInt(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (UrlSearchParams).\"\n * assertIsBigInt(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage example***:\n * ```ts\n * const mixedValue: string | bigint | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `bigint`\n * assertIsBigInt(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be bigint!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `bigint` here\n * const result: bigint = mixedValue; // ➔ Safe type assignment\n * console.log(result + 100n);        // ➔ Safe to operation\n * ```\n */\nexport const assertIsBigInt: (\n  value: unknown,\n  options?: OptionsAssertIs\n) => asserts value is bigint = (\n  value: unknown,\n  options: OptionsAssertIs = {}\n): asserts value is bigint => {\n  if (isBigInt(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"bigint\"\n  });\n};\n","import { isNumber, type IsNumberOptions } from \"@/predicates/is/isNumber\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\n\ntype OptionsAssertIsNumber = OptionsAssertIs & IsNumberOptions;\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsNumber`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **number**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `number`.\n *    - ✅ If `value` is a `number` ➔ execution continues normally.\n *    - ❌ If `value` is not a `number` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n * - **ℹ️ Note:**\n *    - A `number` refers strictly to the JavaScript `number` primitive type (e.g., `42`, `3.14`, `-1`, `0`).\n *    - This excludes `Number` objects created with `new Number(123)`.\n *    - By default, `NaN` is **not considered** valid, you can allow it with `{ includeNaN: true }`.\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 {OptionsAssertIsNumber} [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 *    - `includeNaN`: Whether to treat `NaN` as valid.\n * @returns {boolean} Narrows `value` to `number` 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 number (or is `NaN` when `includeNaN` is `false`).\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsNumber(123);\n * assertIsNumber(NaN, { includeNaN: true });\n * // No error, value is number\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a number\n * assertIsNumber(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `string`.\"\n *\n * // Case 2: Default option includeNaN is false\n * assertIsNumber(NaN);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `NaN`.\"\n *\n * // Case 3: The new Number() is a Number object (constructor), not a primitive number\n * assertIsNumber(new Number(\"123\"));\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `number-constructor`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsNumber(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `number`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsNumber(\"123\", { message: \"Must be a number!\" });\n * // ➔ TypeError: \"Must be a number!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsNumber(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected number but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsNumber(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (url).\"\n * assertIsNumber(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (URL).\"\n *\n * // Case 2:\n * assertIsNumber(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (UrlSearchParams).\"\n * assertIsNumber(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage example***:\n * ```ts\n * const mixedValue: string | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `number`\n * assertIsNumber(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be number!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `number` here\n * const result: number = mixedValue; // ➔ Safe type assignment\n * console.log(result + 100);         // ➔ Safe to operation\n * ```\n */\nexport const assertIsNumber: (\n  value: unknown,\n  options?: OptionsAssertIsNumber\n) => asserts value is number = (\n  value: unknown,\n  options: OptionsAssertIsNumber = {}\n): asserts value is number => {\n  const includeNaN = hasOwnProp(options, \"includeNaN\")\n    ? options.includeNaN\n    : undefined;\n\n  if (isNumber(value, { includeNaN })) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"number\"\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqHA,MAAa,kBAIX,OACA,UAA2B,CAAC,MACA;CAC5B,IAAIA,0BAAS,KAAK,GAAG;CAErB,sDAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACCA,MAAa,kBAIX,OACA,UAAiC,CAAC,MACN;CAK5B,IAAIC,iCAAS,OAAO,EAAE,YAJHC,mCAAW,SAAS,YAAY,IAC/C,QAAQ,aACR,OAE6B,CAAC,GAAG;CAErC,sDAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}

package/dist/assertions/index.d.cts

@@ -2,11 +2,11 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 
-import { a as assertIsBigInt, i as assertIsNumber, n as assertIsPlainObject, o as assertIsBoolean, r as assertIsArray, t as assertIsString } from "../index-CWgiyaU3.cjs";
+import { a as assertIsBigInt, i as assertIsNumber, n as assertIsPlainObject, o as assertIsBoolean, r as assertIsArray, t as assertIsString } from "../index-CJx0EFQ4.cjs";
 export { assertIsArray, assertIsBigInt, assertIsBoolean, assertIsNumber, assertIsPlainObject, assertIsString };

package/dist/assertions/index.d.ts

@@ -2,11 +2,11 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 
-import { a as assertIsBigInt, i as assertIsNumber, n as assertIsPlainObject, o as assertIsBoolean, r as assertIsArray, t as assertIsString } from "../index-C02XatNH.js";
+import { a as assertIsBigInt, i as assertIsNumber, n as assertIsPlainObject, o as assertIsBoolean, r as assertIsArray, t as assertIsString } from "../index-hOCUw-B9.js";
 export { assertIsArray, assertIsBigInt, assertIsBoolean, assertIsNumber, assertIsPlainObject, assertIsString };

package/dist/assertions/index.js

@@ -2,15 +2,15 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { T as assertIsPlainObject, b as hasOwnProp, n as resolveErrorMessageAssertions, t as assertIsBoolean, w as isNumber } from "../assertIsBoolean-Clc7Vw4v.js";
-import { t as isBigInt } from "../isBigInt-Cx4j_cju.js";
-import { t as assertIsArray } from "../assertIsArray-C2rkhR9M.js";
-import { t as assertIsString } from "../assertIsString-Ddz4y81W.js";
+import { T as assertIsPlainObject, b as hasOwnProp, n as resolveErrorMessageAssertions, t as assertIsBoolean, w as isNumber } from "../assertIsBoolean-DDhQ2D-k.js";
+import { t as isBigInt } from "../isBigInt-f6yY2fAV.js";
+import { t as assertIsArray } from "../assertIsArray-DrLORH0Y.js";
+import { t as assertIsString } from "../assertIsString-1iLqxrN0.js";
 const assertIsBigInt = (value, options = {}) => {
 	if (isBigInt(value)) return;
 	resolveErrorMessageAssertions({

package/dist/assertions/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/assertions/number/assertIsBigInt.ts","../../src/assertions/number/assertIsNumber.ts"],"sourcesContent":["import { isBigInt } from \"@/predicates/is/isBigInt\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsBigInt`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **bigint**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `bigint`.\n *    - ✅ If `value` is a `bigint` ➔ execution continues normally.\n *    - ❌ If `value` is not a `bigint` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n *  - **ℹ️ Note:**\n *    - A `bigint` refers strictly to the JavaScript `bigint` primitive type (e.g., `123n`, `0n`, `-999999999999999999999n`).\n *    - This excludes `BigInt` objects created with `Object(BigInt(123))`.\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`: 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 `bigint` 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 bigint.\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsBigInt(123n);\n * // No error, value is bigint\n *\n * // ❌ Throws TypeError (default behavior)\n * assertIsBigInt(42);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `bigint`, but received: `number`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsBigInt(\"123\", { message: \"Must be a bigint!\" });\n * // ➔ TypeError: \"Must be a bigint!\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsBigInt(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `bigint`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsBigInt(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected bigint but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsBigInt(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (url).\"\n * assertIsBigInt(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (URL).\"\n *\n * // Case 2:\n * assertIsBigInt(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (UrlSearchParams).\"\n * assertIsBigInt(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage example***:\n * ```ts\n * const mixedValue: string | bigint | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `bigint`\n * assertIsBigInt(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be bigint!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `bigint` here\n * const result: bigint = mixedValue; // ➔ Safe type assignment\n * console.log(result + 100n);        // ➔ Safe to operation\n * ```\n */\nexport const assertIsBigInt: (\n  value: unknown,\n  options?: OptionsAssertIs\n) => asserts value is bigint = (\n  value: unknown,\n  options: OptionsAssertIs = {}\n): asserts value is bigint => {\n  if (isBigInt(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"bigint\"\n  });\n};\n","import { isNumber, type IsNumberOptions } from \"@/predicates/is/isNumber\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\n\ntype OptionsAssertIsNumber = OptionsAssertIs & IsNumberOptions;\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsNumber`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **number**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `number`.\n *    - ✅ If `value` is a `number` ➔ execution continues normally.\n *    - ❌ If `value` is not a `number` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n * - **ℹ️ Note:**\n *    - A `number` refers strictly to the JavaScript `number` primitive type (e.g., `42`, `3.14`, `-1`, `0`).\n *    - This excludes `Number` objects created with `new Number(123)`.\n *    - By default, `NaN` is **not considered** valid, you can allow it with `{ includeNaN: true }`.\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 {OptionsAssertIsNumber} [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 *    - `includeNaN`: Whether to treat `NaN` as valid.\n * @returns {boolean} Narrows `value` to `number` 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 number (or is `NaN` when `includeNaN` is `false`).\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsNumber(123);\n * assertIsNumber(NaN, { includeNaN: true });\n * // No error, value is number\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a number\n * assertIsNumber(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `string`.\"\n *\n * // Case 2: Default option includeNaN is false\n * assertIsNumber(NaN);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `NaN`.\"\n *\n * // Case 3: The new Number() is a Number object (constructor), not a primitive number\n * assertIsNumber(new Number(\"123\"));\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `number-constructor`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsNumber(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `number`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsNumber(\"123\", { message: \"Must be a number!\" });\n * // ➔ TypeError: \"Must be a number!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsNumber(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected number but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsNumber(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (url).\"\n * assertIsNumber(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (URL).\"\n *\n * // Case 2:\n * assertIsNumber(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (UrlSearchParams).\"\n * assertIsNumber(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage example***:\n * ```ts\n * const mixedValue: string | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `number`\n * assertIsNumber(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be number!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `number` here\n * const result: number = mixedValue; // ➔ Safe type assignment\n * console.log(result + 100);         // ➔ Safe to operation\n * ```\n */\nexport const assertIsNumber: (\n  value: unknown,\n  options?: OptionsAssertIsNumber\n) => asserts value is number = (\n  value: unknown,\n  options: OptionsAssertIsNumber = {}\n): asserts value is number => {\n  const includeNaN = hasOwnProp(options, \"includeNaN\")\n    ? options.includeNaN\n    : undefined;\n\n  if (isNumber(value, { includeNaN })) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"number\"\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqHA,MAAa,kBAIX,OACA,UAA2B,EAAE,KACD;CAC5B,IAAI,SAAS,MAAM,EAAE;CAErB,8BAA8B;EAC5B;EACA;EACA,mBAAmB;EACpB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACEJ,MAAa,kBAIX,OACA,UAAiC,EAAE,KACP;CAK5B,IAAI,SAAS,OAAO,EAAE,YAJH,WAAW,SAAS,aAAa,GAChD,QAAQ,aACR,QAE8B,CAAC,EAAE;CAErC,8BAA8B;EAC5B;EACA;EACA,mBAAmB;EACpB,CAAC"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/assertions/number/assertIsBigInt.ts","../../src/assertions/number/assertIsNumber.ts"],"sourcesContent":["import { isBigInt } from \"@/predicates/is/isBigInt\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsBigInt`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **bigint**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `bigint`.\n *    - ✅ If `value` is a `bigint` ➔ execution continues normally.\n *    - ❌ If `value` is not a `bigint` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n *  - **ℹ️ Note:**\n *    - A `bigint` refers strictly to the JavaScript `bigint` primitive type (e.g., `123n`, `0n`, `-999999999999999999999n`).\n *    - This excludes `BigInt` objects created with `Object(BigInt(123))`.\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`: 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 `bigint` 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 bigint.\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsBigInt(123n);\n * // No error, value is bigint\n *\n * // ❌ Throws TypeError (default behavior)\n * assertIsBigInt(42);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `bigint`, but received: `number`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsBigInt(\"123\", { message: \"Must be a bigint!\" });\n * // ➔ TypeError: \"Must be a bigint!\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsBigInt(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `bigint`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsBigInt(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected bigint but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsBigInt(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (url).\"\n * assertIsBigInt(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (URL).\"\n *\n * // Case 2:\n * assertIsBigInt(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (UrlSearchParams).\"\n * assertIsBigInt(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected bigint but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage example***:\n * ```ts\n * const mixedValue: string | bigint | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `bigint`\n * assertIsBigInt(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be bigint!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `bigint` here\n * const result: bigint = mixedValue; // ➔ Safe type assignment\n * console.log(result + 100n);        // ➔ Safe to operation\n * ```\n */\nexport const assertIsBigInt: (\n  value: unknown,\n  options?: OptionsAssertIs\n) => asserts value is bigint = (\n  value: unknown,\n  options: OptionsAssertIs = {}\n): asserts value is bigint => {\n  if (isBigInt(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"bigint\"\n  });\n};\n","import { isNumber, type IsNumberOptions } from \"@/predicates/is/isNumber\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\n\ntype OptionsAssertIsNumber = OptionsAssertIs & IsNumberOptions;\n\n/** -------------------------------------------------------\n * * ***Type guard assertion: `assertIsNumber`.***\n * -------------------------------------------------------\n * **This function is an **assertion function**.**\n * - **Behavior:**\n *    - Validates that the given `value` is a **number**.\n *    - After it returns successfully, TypeScript narrows the type of `value` to `number`.\n *    - ✅ If `value` is a `number` ➔ execution continues normally.\n *    - ❌ If `value` is not a `number` ➔ throws a built-in error with either:\n *      - A custom error message (`options.message`), or\n *      - A default message including the actual type.\n * - **ℹ️ Note:**\n *    - A `number` refers strictly to the JavaScript `number` primitive type (e.g., `42`, `3.14`, `-1`, `0`).\n *    - This excludes `Number` objects created with `new Number(123)`.\n *    - By default, `NaN` is **not considered** valid, you can allow it with `{ includeNaN: true }`.\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 {OptionsAssertIsNumber} [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 *    - `includeNaN`: Whether to treat `NaN` as valid.\n * @returns {boolean} Narrows `value` to `number` 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 number (or is `NaN` when `includeNaN` is `false`).\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsNumber(123);\n * assertIsNumber(NaN, { includeNaN: true });\n * // No error, value is number\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a number\n * assertIsNumber(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `string`.\"\n *\n * // Case 2: Default option includeNaN is false\n * assertIsNumber(NaN);\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `NaN`.\"\n *\n * // Case 3: The new Number() is a Number object (constructor), not a primitive number\n * assertIsNumber(new Number(\"123\"));\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `number`, but received: `number-constructor`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsNumber(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `number`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsNumber(\"123\", { message: \"Must be a number!\" });\n * // ➔ TypeError: \"Must be a number!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsNumber(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected number but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsNumber(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (url).\"\n * assertIsNumber(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (URL).\"\n *\n * // Case 2:\n * assertIsNumber(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (UrlSearchParams).\"\n * assertIsNumber(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected number but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage example***:\n * ```ts\n * const mixedValue: string | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `number`\n * assertIsNumber(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be number!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `number` here\n * const result: number = mixedValue; // ➔ Safe type assignment\n * console.log(result + 100);         // ➔ Safe to operation\n * ```\n */\nexport const assertIsNumber: (\n  value: unknown,\n  options?: OptionsAssertIsNumber\n) => asserts value is number = (\n  value: unknown,\n  options: OptionsAssertIsNumber = {}\n): asserts value is number => {\n  const includeNaN = hasOwnProp(options, \"includeNaN\")\n    ? options.includeNaN\n    : undefined;\n\n  if (isNumber(value, { includeNaN })) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"number\"\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqHA,MAAa,kBAIX,OACA,UAA2B,CAAC,MACA;CAC5B,IAAI,SAAS,KAAK,GAAG;CAErB,8BAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACCA,MAAa,kBAIX,OACA,UAAiC,CAAC,MACN;CAK5B,IAAI,SAAS,OAAO,EAAE,YAJH,WAAW,SAAS,YAAY,IAC/C,QAAQ,aACR,OAE6B,CAAC,GAAG;CAErC,8BAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}

package/dist/conversions/index.cjs

@@ -2,18 +2,18 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_toStringArrayUnRecursive = require('../toStringArrayUnRecursive-DJ8JBO3N.cjs');
-const require_conversions = require('../conversions-Bu5c_RZ9.cjs');
-const require_safeStableStringify = require('../safeStableStringify-DSwcrPll.cjs');
-const require_parsing = require('../parsing-B6vxp2h8.cjs');
-const require_safeJsonParse = require('../safeJsonParse-DiWBPfaE.cjs');
+const require_toStringArrayUnRecursive = require('../toStringArrayUnRecursive-D-jHROts.cjs');
+const require_conversions = require('../conversions-Bxa01uIl.cjs');
+const require_safeStableStringify = require('../safeStableStringify-4b-E_UHM.cjs');
+const require_parsing = require('../parsing-CuezVd0e.cjs');
+const require_safeJsonParse = require('../safeJsonParse-BznDD3fi.cjs');
 exports.cleanParsedData = require_safeJsonParse.cleanParsedData;
 exports.convertType = require_conversions.convertType;
 exports.dedupeArray = require_conversions.dedupeArray;

package/dist/conversions/index.d.cts

@@ -2,11 +2,11 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 
-import { _ as dedupeArray, a as removeObjectPaths, c as parseCustomDate, d as parseCurrencyString, f as toBooleanLoose, g as filterNilArray, h as toBooleanContent, i as safeStableStringify, l as cleanParsedData, m as toBooleanContentDeep, n as toStringDeep, o as extractDigits, p as toBooleanExplicit, r as toNumberDeep, s as safeJsonParse, t as toStringDeepForce, u as convertType, v as toStringArrayUnRecursive, y as toNumberArrayUnRecursive } from "../index-DC7eXTo_.cjs";
+import { _ as dedupeArray, a as removeObjectPaths, c as parseCustomDate, d as parseCurrencyString, f as toBooleanLoose, g as filterNilArray, h as toBooleanContent, i as safeStableStringify, l as cleanParsedData, m as toBooleanContentDeep, n as toStringDeep, o as extractDigits, p as toBooleanExplicit, r as toNumberDeep, s as safeJsonParse, t as toStringDeepForce, u as convertType, v as toStringArrayUnRecursive, y as toNumberArrayUnRecursive } from "../index-BAeeggeh.cjs";
 export { cleanParsedData, convertType, dedupeArray, extractDigits, filterNilArray, parseCurrencyString, parseCustomDate, removeObjectPaths, safeJsonParse, safeStableStringify, toBooleanContent, toBooleanContentDeep, toBooleanExplicit, toBooleanLoose, toNumberArrayUnRecursive, toNumberDeep, toStringArrayUnRecursive, toStringDeep, toStringDeepForce };

package/dist/conversions/index.d.ts

@@ -2,11 +2,11 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 
-import { _ as dedupeArray, a as removeObjectPaths, c as parseCustomDate, d as parseCurrencyString, f as toBooleanLoose, g as filterNilArray, h as toBooleanContent, i as safeStableStringify, l as cleanParsedData, m as toBooleanContentDeep, n as toStringDeep, o as extractDigits, p as toBooleanExplicit, r as toNumberDeep, s as safeJsonParse, t as toStringDeepForce, u as convertType, v as toStringArrayUnRecursive, y as toNumberArrayUnRecursive } from "../index-BZMwAuLf.js";
+import { _ as dedupeArray, a as removeObjectPaths, c as parseCustomDate, d as parseCurrencyString, f as toBooleanLoose, g as filterNilArray, h as toBooleanContent, i as safeStableStringify, l as cleanParsedData, m as toBooleanContentDeep, n as toStringDeep, o as extractDigits, p as toBooleanExplicit, r as toNumberDeep, s as safeJsonParse, t as toStringDeepForce, u as convertType, v as toStringArrayUnRecursive, y as toNumberArrayUnRecursive } from "../index-BAeeggeh.js";
 export { cleanParsedData, convertType, dedupeArray, extractDigits, filterNilArray, parseCurrencyString, parseCustomDate, removeObjectPaths, safeJsonParse, safeStableStringify, toBooleanContent, toBooleanContentDeep, toBooleanExplicit, toBooleanLoose, toNumberArrayUnRecursive, toNumberDeep, toStringArrayUnRecursive, toStringDeep, toStringDeepForce };

package/dist/conversions/index.js

@@ -2,14 +2,14 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { n as filterNilArray, t as toStringArrayUnRecursive } from "../toStringArrayUnRecursive-DBicbWv8.js";
-import { a as toBooleanLoose, c as toBooleanContent, d as toNumberArrayUnRecursive, i as convertType, l as dedupeArray, n as toNumberDeep, o as toBooleanExplicit, r as removeObjectPaths, s as toBooleanContentDeep, t as toStringDeep, u as toStringDeepForce } from "../conversions-DjfhrQE9.js";
-import { t as safeStableStringify } from "../safeStableStringify-C1SA52w7.js";
-import { t as parseCurrencyString } from "../parsing-CobzHooQ.js";
-import { i as parseCustomDate, n as extractDigits, r as cleanParsedData, t as safeJsonParse } from "../safeJsonParse-bcBYPjeb.js";
+import { n as filterNilArray, t as toStringArrayUnRecursive } from "../toStringArrayUnRecursive-NreW1dyV.js";
+import { a as toBooleanLoose, c as toBooleanContent, d as toNumberArrayUnRecursive, i as convertType, l as dedupeArray, n as toNumberDeep, o as toBooleanExplicit, r as removeObjectPaths, s as toBooleanContentDeep, t as toStringDeep, u as toStringDeepForce } from "../conversions-CA_3PTAH.js";
+import { t as safeStableStringify } from "../safeStableStringify-BLwA1VC-.js";
+import { t as parseCurrencyString } from "../parsing-BYo6U0EG.js";
+import { i as parseCustomDate, n as extractDigits, r as cleanParsedData, t as safeJsonParse } from "../safeJsonParse-D8H3wCv7.js";
 export { cleanParsedData, convertType, dedupeArray, extractDigits, filterNilArray, parseCurrencyString, parseCustomDate, removeObjectPaths, safeJsonParse, safeStableStringify, toBooleanContent, toBooleanContentDeep, toBooleanExplicit, toBooleanLoose, toNumberArrayUnRecursive, toNumberDeep, toStringArrayUnRecursive, toStringDeep, toStringDeepForce };

package/dist/{conversions-Bu5c_RZ9.cjs → conversions-Bxa01uIl.cjs}

@@ -2,22 +2,22 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.3`
+*  Version: `3.13.1-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_assertIsBoolean = require('./assertIsBoolean-BKcvET7Z.cjs');
-const require_isBigInt = require('./isBigInt-BePsmNsm.cjs');
-const require_assertIsArray = require('./assertIsArray-DWsgvahU.cjs');
-const require_assertIsString = require('./assertIsString-DxIqUfF1.cjs');
-const require_isEmptyObject = require('./isEmptyObject-DYypq92-.cjs');
-const require_toStringArrayUnRecursive = require('./toStringArrayUnRecursive-DJ8JBO3N.cjs');
-const require_safeStableStringify = require('./safeStableStringify-DSwcrPll.cjs');
-const require_isEqual = require('./isEqual-Bd7mClU4.cjs');
-const require_isEmptyString = require('./isEmptyString-CzY-9G-x.cjs');
-const require_isTypedArray = require('./isTypedArray-BT7YP1S9.cjs');
+const require_assertIsBoolean = require('./assertIsBoolean-CEx4KbHg.cjs');
+const require_isBigInt = require('./isBigInt-CqZNWVtI.cjs');
+const require_assertIsArray = require('./assertIsArray-CqIFmlgj.cjs');
+const require_assertIsString = require('./assertIsString-DGDLC-XD.cjs');
+const require_isEmptyObject = require('./isEmptyObject-C2lQyFZS.cjs');
+const require_toStringArrayUnRecursive = require('./toStringArrayUnRecursive-D-jHROts.cjs');
+const require_safeStableStringify = require('./safeStableStringify-4b-E_UHM.cjs');
+const require_isEqual = require('./isEqual-D8W3Wizi.cjs');
+const require_isEmptyString = require('./isEmptyString-DNMPmS-H.cjs');
+const require_isTypedArray = require('./isTypedArray-CWlHRz_O.cjs');
 function toNumberArrayUnRecursive(array, options = {}) {
 	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
 	const riv = require_assertIsBoolean.hasOwnProp(options, "removeInvalidValueNumber") ? options.removeInvalidValueNumber : true;
@@ -443,4 +443,4 @@ Object.defineProperty(exports, 'toStringDeepForce', {
     return toStringDeepForce;
   }
 });
-//# sourceMappingURL=conversions-Bu5c_RZ9.cjs.map
+//# sourceMappingURL=conversions-Bxa01uIl.cjs.map