@rzl-zone/utils-js 3.14.0-beta.0 → 3.14.0

package/dist/.references/index.d.cts

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================

package/dist/.references/index.d.ts

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================

package/dist/{AbortError-DVT8lAKn.js → AbortError-CgE6QNOR.js}

@@ -2,12 +2,12 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { w as isNonEmptyString } from "./logger-CLWnKRKE.js";
+import { w as isNonEmptyString } from "./logger-Wxl_Krg6.js";
 var AbortError = class extends Error {
 	constructor(message = "The operation was aborted", options) {
 		super(message);
@@ -17,4 +17,4 @@ var AbortError = class extends Error {
 	}
 };
 export { AbortError as t };
-//# sourceMappingURL=AbortError-DVT8lAKn.js.map
+//# sourceMappingURL=AbortError-CgE6QNOR.js.map

package/dist/{AbortError-DVT8lAKn.js.map → AbortError-CgE6QNOR.js.map}

@@ -1 +1 @@
-{"version":3,"file":"AbortError-DVT8lAKn.js","names":[],"sources":["../src/errors/AbortError.ts"],"sourcesContent":["import { isNonEmptyString } from \"@/predicates\";\n\ntype AbortErrorOptions = {\n  /** -------------------------------------------------------------------\n   * * ***Optional text inserted before `\"AbortError\"`.***\n   * --------------------------------------------------------------------\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @default \"\"\n   */\n  prefix?: string;\n\n  /** -------------------------------------------------------------------\n   * * ***Optional text inserted after `\"AbortError\"`.***\n   * --------------------------------------------------------------------\n   *\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @default \"\"\n   */\n  suffix?: string;\n};\n\n/** ---------------------------------------------------------------------\n * * ***Class: `AbortError`.***\n * ----------------------------------------------------------------------\n * **Custom error type used for cancellation-related operations.**\n *\n * ---\n * - **Behavior:**\n *     - Extends the native ***`Error`*** class.\n *     - Provides a consistent abort error shape across runtimes.\n *     - Useful for Promise-based utilities that support\n *       cancellation via ***`AbortSignal`***.\n *     - Uses `\"AbortError\"` as the base error name.\n *     - Supports optional `prefix` and `suffix`\n *       for contextual error naming.\n *\n * ---\n *\n * @extends Error - Extending `Error` Class.\n *\n * ---\n * @param {string} [message=\"The operation was aborted\"]\n * The error message describing the abort reason.\n *\n * @param {object} [options]\n * Optional configuration object.\n *\n * @param {string} [options.prefix]\n * Optional text inserted before `\"AbortError\"`.\n * Empty strings and whitespace-only values are ignored.\n *\n * @param {string} [options.suffix]\n * Optional text inserted after `\"AbortError\"`.\n * Empty strings and whitespace-only values are ignored.\n *\n * ---\n * @example\n * ```ts\n * throw new AbortError();\n * ```\n *\n * @example\n * ```ts\n * throw new AbortError(\n *   \"Delay cancelled\",\n *   {\n *     prefix: \"Delay\"\n *   }\n * );\n *\n * // Result:\n * // name -> \"DelayAbortError\"\n * ```\n *\n * @example\n * ```ts\n * throw new AbortError(\n *   \"Queue cancelled\",\n *   {\n *     suffix: \":Queue\"\n *   }\n * );\n *\n * // Result:\n * // name \"AbortError:Queue\"\n * ```\n *\n * @example\n * ```ts\n * try {\n *   await delay(\n *     5000,\n *     controller.signal\n *   );\n * } catch (error) {\n *   if (error instanceof AbortError) {\n *     console.log(error.message);\n *   }\n * }\n * ```\n */\nexport class AbortError extends Error {\n  /** ------------------------------------------------------------\n   * * ***Constructor: `AbortError`.***\n   * -------------------------------------------------------------\n   * **Creates a new `AbortError` instance with optional\n   * contextual error name customization.**\n   *\n   * ---\n   * - **Behavior:**\n   *     - Initializes the native ***`Error`*** base class.\n   *     - Uses `\"AbortError\"` as the default error name.\n   *     - Automatically trims `prefix` and `suffix` values.\n   *     - Ignores empty or whitespace-only values.\n   *     - Generates a contextual error name using:\n   *       `prefix + \"AbortError\" + suffix`.\n   *\n   * ---\n   * @param {string} [message=\"The operation was aborted\"]\n   * The error message describing the abort reason.\n   *\n   * @param {AbortErrorOptions} [options]\n   * Optional configuration object.\n   *\n   * @param {string} [options.prefix]\n   * Optional text inserted before `\"AbortError\"`.\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * @param {string} [options.suffix]\n   * Optional text inserted after `\"AbortError\"`.\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @example\n   * ```ts\n   * new AbortError();\n   *\n   * // Result:\n   * // name -> \"AbortError\"\n   * // message -> \"The operation was aborted\"\n   * ```\n   *\n   * @example\n   * ```ts\n   * new AbortError(\n   *   \"Delay cancelled\",\n   *   {\n   *     prefix: \"Delay\"\n   *   }\n   * );\n   *\n   * // Result:\n   * // name -> \"DelayAbortError\"\n   * ```\n   *\n   * @example\n   * ```ts\n   * new AbortError(\n   *   \"Queue cancelled\",\n   *   {\n   *     suffix: \":Queue\"\n   *   }\n   * );\n   *\n   * // Result:\n   * // name -> \"AbortError:Queue\"\n   * ```\n   */\n  constructor(\n    message: string = \"The operation was aborted\",\n    options?: AbortErrorOptions\n  ) {\n    super(message);\n\n    const prefix = isNonEmptyString(options?.prefix)\n      ? `${options.prefix.trim()}`\n      : \"\";\n\n    const suffix = isNonEmptyString(options?.suffix)\n      ? `${options.suffix.trim()}`\n      : \"\";\n\n    this.name = `${prefix}AbortError${suffix}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyGA,IAAa,aAAb,cAAgC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEpC,YACE,UAAkB,6BAClB,SACA;EACA,MAAM,OAAO;EAEb,MAAM,SAAS,iBAAiB,SAAS,MAAM,IAC3C,GAAG,QAAQ,OAAO,KAAK,MACvB;EAEJ,MAAM,SAAS,iBAAiB,SAAS,MAAM,IAC3C,GAAG,QAAQ,OAAO,KAAK,MACvB;EAEJ,KAAK,OAAO,GAAG,OAAO,YAAY;CACpC;AACF"}
+{"version":3,"file":"AbortError-CgE6QNOR.js","names":[],"sources":["../src/errors/AbortError.ts"],"sourcesContent":["import { isNonEmptyString } from \"@/predicates\";\n\ntype AbortErrorOptions = {\n  /** -------------------------------------------------------------------\n   * * ***Optional text inserted before `\"AbortError\"`.***\n   * --------------------------------------------------------------------\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @default \"\"\n   */\n  prefix?: string;\n\n  /** -------------------------------------------------------------------\n   * * ***Optional text inserted after `\"AbortError\"`.***\n   * --------------------------------------------------------------------\n   *\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @default \"\"\n   */\n  suffix?: string;\n};\n\n/** ---------------------------------------------------------------------\n * * ***Class: `AbortError`.***\n * ----------------------------------------------------------------------\n * **Custom error type used for cancellation-related operations.**\n *\n * ---\n * - **Behavior:**\n *     - Extends the native ***`Error`*** class.\n *     - Provides a consistent abort error shape across runtimes.\n *     - Useful for Promise-based utilities that support\n *       cancellation via ***`AbortSignal`***.\n *     - Uses `\"AbortError\"` as the base error name.\n *     - Supports optional `prefix` and `suffix`\n *       for contextual error naming.\n *\n * ---\n *\n * @extends Error - Extending `Error` Class.\n *\n * ---\n * @param {string} [message=\"The operation was aborted\"]\n * The error message describing the abort reason.\n *\n * @param {object} [options]\n * Optional configuration object.\n *\n * @param {string} [options.prefix]\n * Optional text inserted before `\"AbortError\"`.\n * Empty strings and whitespace-only values are ignored.\n *\n * @param {string} [options.suffix]\n * Optional text inserted after `\"AbortError\"`.\n * Empty strings and whitespace-only values are ignored.\n *\n * ---\n * @example\n * ```ts\n * throw new AbortError();\n * ```\n *\n * @example\n * ```ts\n * throw new AbortError(\n *   \"Delay cancelled\",\n *   {\n *     prefix: \"Delay\"\n *   }\n * );\n *\n * // Result:\n * // name -> \"DelayAbortError\"\n * ```\n *\n * @example\n * ```ts\n * throw new AbortError(\n *   \"Queue cancelled\",\n *   {\n *     suffix: \":Queue\"\n *   }\n * );\n *\n * // Result:\n * // name \"AbortError:Queue\"\n * ```\n *\n * @example\n * ```ts\n * try {\n *   await delay(\n *     5000,\n *     controller.signal\n *   );\n * } catch (error) {\n *   if (error instanceof AbortError) {\n *     console.log(error.message);\n *   }\n * }\n * ```\n */\nexport class AbortError extends Error {\n  /** ------------------------------------------------------------\n   * * ***Constructor: `AbortError`.***\n   * -------------------------------------------------------------\n   * **Creates a new `AbortError` instance with optional\n   * contextual error name customization.**\n   *\n   * ---\n   * - **Behavior:**\n   *     - Initializes the native ***`Error`*** base class.\n   *     - Uses `\"AbortError\"` as the default error name.\n   *     - Automatically trims `prefix` and `suffix` values.\n   *     - Ignores empty or whitespace-only values.\n   *     - Generates a contextual error name using:\n   *       `prefix + \"AbortError\" + suffix`.\n   *\n   * ---\n   * @param {string} [message=\"The operation was aborted\"]\n   * The error message describing the abort reason.\n   *\n   * @param {AbortErrorOptions} [options]\n   * Optional configuration object.\n   *\n   * @param {string} [options.prefix]\n   * Optional text inserted before `\"AbortError\"`.\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * @param {string} [options.suffix]\n   * Optional text inserted after `\"AbortError\"`.\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @example\n   * ```ts\n   * new AbortError();\n   *\n   * // Result:\n   * // name -> \"AbortError\"\n   * // message -> \"The operation was aborted\"\n   * ```\n   *\n   * @example\n   * ```ts\n   * new AbortError(\n   *   \"Delay cancelled\",\n   *   {\n   *     prefix: \"Delay\"\n   *   }\n   * );\n   *\n   * // Result:\n   * // name -> \"DelayAbortError\"\n   * ```\n   *\n   * @example\n   * ```ts\n   * new AbortError(\n   *   \"Queue cancelled\",\n   *   {\n   *     suffix: \":Queue\"\n   *   }\n   * );\n   *\n   * // Result:\n   * // name -> \"AbortError:Queue\"\n   * ```\n   */\n  constructor(\n    message: string = \"The operation was aborted\",\n    options?: AbortErrorOptions\n  ) {\n    super(message);\n\n    const prefix = isNonEmptyString(options?.prefix)\n      ? `${options.prefix.trim()}`\n      : \"\";\n\n    const suffix = isNonEmptyString(options?.suffix)\n      ? `${options.suffix.trim()}`\n      : \"\";\n\n    this.name = `${prefix}AbortError${suffix}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyGA,IAAa,aAAb,cAAgC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEpC,YACE,UAAkB,6BAClB,SACA;EACA,MAAM,OAAO;EAEb,MAAM,SAAS,iBAAiB,SAAS,MAAM,IAC3C,GAAG,QAAQ,OAAO,KAAK,MACvB;EAEJ,MAAM,SAAS,iBAAiB,SAAS,MAAM,IAC3C,GAAG,QAAQ,OAAO,KAAK,MACvB;EAEJ,KAAK,OAAO,GAAG,OAAO,YAAY;CACpC;AACF"}

package/dist/{AbortError-DK6kpzbu.cjs → AbortError-D54txsmn.cjs}

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_logger = require('./logger-CUacYy3D.cjs');
+const require_logger = require('./logger-BXg2xufj.cjs');
 var AbortError = class extends Error {
 	constructor(message = "The operation was aborted", options) {
 		super(message);
@@ -23,4 +23,4 @@ Object.defineProperty(exports, 'AbortError', {
     return AbortError;
   }
 });
-//# sourceMappingURL=AbortError-DK6kpzbu.cjs.map
+//# sourceMappingURL=AbortError-D54txsmn.cjs.map

package/dist/{AbortError-DK6kpzbu.cjs.map → AbortError-D54txsmn.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"AbortError-DK6kpzbu.cjs","names":["isNonEmptyString"],"sources":["../src/errors/AbortError.ts"],"sourcesContent":["import { isNonEmptyString } from \"@/predicates\";\n\ntype AbortErrorOptions = {\n  /** -------------------------------------------------------------------\n   * * ***Optional text inserted before `\"AbortError\"`.***\n   * --------------------------------------------------------------------\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @default \"\"\n   */\n  prefix?: string;\n\n  /** -------------------------------------------------------------------\n   * * ***Optional text inserted after `\"AbortError\"`.***\n   * --------------------------------------------------------------------\n   *\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @default \"\"\n   */\n  suffix?: string;\n};\n\n/** ---------------------------------------------------------------------\n * * ***Class: `AbortError`.***\n * ----------------------------------------------------------------------\n * **Custom error type used for cancellation-related operations.**\n *\n * ---\n * - **Behavior:**\n *     - Extends the native ***`Error`*** class.\n *     - Provides a consistent abort error shape across runtimes.\n *     - Useful for Promise-based utilities that support\n *       cancellation via ***`AbortSignal`***.\n *     - Uses `\"AbortError\"` as the base error name.\n *     - Supports optional `prefix` and `suffix`\n *       for contextual error naming.\n *\n * ---\n *\n * @extends Error - Extending `Error` Class.\n *\n * ---\n * @param {string} [message=\"The operation was aborted\"]\n * The error message describing the abort reason.\n *\n * @param {object} [options]\n * Optional configuration object.\n *\n * @param {string} [options.prefix]\n * Optional text inserted before `\"AbortError\"`.\n * Empty strings and whitespace-only values are ignored.\n *\n * @param {string} [options.suffix]\n * Optional text inserted after `\"AbortError\"`.\n * Empty strings and whitespace-only values are ignored.\n *\n * ---\n * @example\n * ```ts\n * throw new AbortError();\n * ```\n *\n * @example\n * ```ts\n * throw new AbortError(\n *   \"Delay cancelled\",\n *   {\n *     prefix: \"Delay\"\n *   }\n * );\n *\n * // Result:\n * // name -> \"DelayAbortError\"\n * ```\n *\n * @example\n * ```ts\n * throw new AbortError(\n *   \"Queue cancelled\",\n *   {\n *     suffix: \":Queue\"\n *   }\n * );\n *\n * // Result:\n * // name \"AbortError:Queue\"\n * ```\n *\n * @example\n * ```ts\n * try {\n *   await delay(\n *     5000,\n *     controller.signal\n *   );\n * } catch (error) {\n *   if (error instanceof AbortError) {\n *     console.log(error.message);\n *   }\n * }\n * ```\n */\nexport class AbortError extends Error {\n  /** ------------------------------------------------------------\n   * * ***Constructor: `AbortError`.***\n   * -------------------------------------------------------------\n   * **Creates a new `AbortError` instance with optional\n   * contextual error name customization.**\n   *\n   * ---\n   * - **Behavior:**\n   *     - Initializes the native ***`Error`*** base class.\n   *     - Uses `\"AbortError\"` as the default error name.\n   *     - Automatically trims `prefix` and `suffix` values.\n   *     - Ignores empty or whitespace-only values.\n   *     - Generates a contextual error name using:\n   *       `prefix + \"AbortError\" + suffix`.\n   *\n   * ---\n   * @param {string} [message=\"The operation was aborted\"]\n   * The error message describing the abort reason.\n   *\n   * @param {AbortErrorOptions} [options]\n   * Optional configuration object.\n   *\n   * @param {string} [options.prefix]\n   * Optional text inserted before `\"AbortError\"`.\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * @param {string} [options.suffix]\n   * Optional text inserted after `\"AbortError\"`.\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @example\n   * ```ts\n   * new AbortError();\n   *\n   * // Result:\n   * // name -> \"AbortError\"\n   * // message -> \"The operation was aborted\"\n   * ```\n   *\n   * @example\n   * ```ts\n   * new AbortError(\n   *   \"Delay cancelled\",\n   *   {\n   *     prefix: \"Delay\"\n   *   }\n   * );\n   *\n   * // Result:\n   * // name -> \"DelayAbortError\"\n   * ```\n   *\n   * @example\n   * ```ts\n   * new AbortError(\n   *   \"Queue cancelled\",\n   *   {\n   *     suffix: \":Queue\"\n   *   }\n   * );\n   *\n   * // Result:\n   * // name -> \"AbortError:Queue\"\n   * ```\n   */\n  constructor(\n    message: string = \"The operation was aborted\",\n    options?: AbortErrorOptions\n  ) {\n    super(message);\n\n    const prefix = isNonEmptyString(options?.prefix)\n      ? `${options.prefix.trim()}`\n      : \"\";\n\n    const suffix = isNonEmptyString(options?.suffix)\n      ? `${options.suffix.trim()}`\n      : \"\";\n\n    this.name = `${prefix}AbortError${suffix}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyGA,IAAa,aAAb,cAAgC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEpC,YACE,UAAkB,6BAClB,SACA;EACA,MAAM,OAAO;EAEb,MAAM,SAASA,gCAAiB,SAAS,MAAM,IAC3C,GAAG,QAAQ,OAAO,KAAK,MACvB;EAEJ,MAAM,SAASA,gCAAiB,SAAS,MAAM,IAC3C,GAAG,QAAQ,OAAO,KAAK,MACvB;EAEJ,KAAK,OAAO,GAAG,OAAO,YAAY;CACpC;AACF"}
+{"version":3,"file":"AbortError-D54txsmn.cjs","names":["isNonEmptyString"],"sources":["../src/errors/AbortError.ts"],"sourcesContent":["import { isNonEmptyString } from \"@/predicates\";\n\ntype AbortErrorOptions = {\n  /** -------------------------------------------------------------------\n   * * ***Optional text inserted before `\"AbortError\"`.***\n   * --------------------------------------------------------------------\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @default \"\"\n   */\n  prefix?: string;\n\n  /** -------------------------------------------------------------------\n   * * ***Optional text inserted after `\"AbortError\"`.***\n   * --------------------------------------------------------------------\n   *\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @default \"\"\n   */\n  suffix?: string;\n};\n\n/** ---------------------------------------------------------------------\n * * ***Class: `AbortError`.***\n * ----------------------------------------------------------------------\n * **Custom error type used for cancellation-related operations.**\n *\n * ---\n * - **Behavior:**\n *     - Extends the native ***`Error`*** class.\n *     - Provides a consistent abort error shape across runtimes.\n *     - Useful for Promise-based utilities that support\n *       cancellation via ***`AbortSignal`***.\n *     - Uses `\"AbortError\"` as the base error name.\n *     - Supports optional `prefix` and `suffix`\n *       for contextual error naming.\n *\n * ---\n *\n * @extends Error - Extending `Error` Class.\n *\n * ---\n * @param {string} [message=\"The operation was aborted\"]\n * The error message describing the abort reason.\n *\n * @param {object} [options]\n * Optional configuration object.\n *\n * @param {string} [options.prefix]\n * Optional text inserted before `\"AbortError\"`.\n * Empty strings and whitespace-only values are ignored.\n *\n * @param {string} [options.suffix]\n * Optional text inserted after `\"AbortError\"`.\n * Empty strings and whitespace-only values are ignored.\n *\n * ---\n * @example\n * ```ts\n * throw new AbortError();\n * ```\n *\n * @example\n * ```ts\n * throw new AbortError(\n *   \"Delay cancelled\",\n *   {\n *     prefix: \"Delay\"\n *   }\n * );\n *\n * // Result:\n * // name -> \"DelayAbortError\"\n * ```\n *\n * @example\n * ```ts\n * throw new AbortError(\n *   \"Queue cancelled\",\n *   {\n *     suffix: \":Queue\"\n *   }\n * );\n *\n * // Result:\n * // name \"AbortError:Queue\"\n * ```\n *\n * @example\n * ```ts\n * try {\n *   await delay(\n *     5000,\n *     controller.signal\n *   );\n * } catch (error) {\n *   if (error instanceof AbortError) {\n *     console.log(error.message);\n *   }\n * }\n * ```\n */\nexport class AbortError extends Error {\n  /** ------------------------------------------------------------\n   * * ***Constructor: `AbortError`.***\n   * -------------------------------------------------------------\n   * **Creates a new `AbortError` instance with optional\n   * contextual error name customization.**\n   *\n   * ---\n   * - **Behavior:**\n   *     - Initializes the native ***`Error`*** base class.\n   *     - Uses `\"AbortError\"` as the default error name.\n   *     - Automatically trims `prefix` and `suffix` values.\n   *     - Ignores empty or whitespace-only values.\n   *     - Generates a contextual error name using:\n   *       `prefix + \"AbortError\" + suffix`.\n   *\n   * ---\n   * @param {string} [message=\"The operation was aborted\"]\n   * The error message describing the abort reason.\n   *\n   * @param {AbortErrorOptions} [options]\n   * Optional configuration object.\n   *\n   * @param {string} [options.prefix]\n   * Optional text inserted before `\"AbortError\"`.\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * @param {string} [options.suffix]\n   * Optional text inserted after `\"AbortError\"`.\n   * Empty strings and whitespace-only values are ignored.\n   *\n   * ---\n   * @example\n   * ```ts\n   * new AbortError();\n   *\n   * // Result:\n   * // name -> \"AbortError\"\n   * // message -> \"The operation was aborted\"\n   * ```\n   *\n   * @example\n   * ```ts\n   * new AbortError(\n   *   \"Delay cancelled\",\n   *   {\n   *     prefix: \"Delay\"\n   *   }\n   * );\n   *\n   * // Result:\n   * // name -> \"DelayAbortError\"\n   * ```\n   *\n   * @example\n   * ```ts\n   * new AbortError(\n   *   \"Queue cancelled\",\n   *   {\n   *     suffix: \":Queue\"\n   *   }\n   * );\n   *\n   * // Result:\n   * // name -> \"AbortError:Queue\"\n   * ```\n   */\n  constructor(\n    message: string = \"The operation was aborted\",\n    options?: AbortErrorOptions\n  ) {\n    super(message);\n\n    const prefix = isNonEmptyString(options?.prefix)\n      ? `${options.prefix.trim()}`\n      : \"\";\n\n    const suffix = isNonEmptyString(options?.suffix)\n      ? `${options.suffix.trim()}`\n      : \"\";\n\n    this.name = `${prefix}AbortError${suffix}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyGA,IAAa,aAAb,cAAgC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEpC,YACE,UAAkB,6BAClB,SACA;EACA,MAAM,OAAO;EAEb,MAAM,SAASA,gCAAiB,SAAS,MAAM,IAC3C,GAAG,QAAQ,OAAO,KAAK,MACvB;EAEJ,MAAM,SAASA,gCAAiB,SAAS,MAAM,IAC3C,GAAG,QAAQ,OAAO,KAAK,MACvB;EAEJ,KAAK,OAAO,GAAG,OAAO,YAAY;CACpC;AACF"}

package/dist/{assertIsArray-CG7L7vlt.js → assertIsArray-DmlqnTiq.js}

@@ -2,12 +2,12 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { O as isArray, r as resolveErrorMessageAssertions } from "./logger-CLWnKRKE.js";
+import { O as isArray, r as resolveErrorMessageAssertions } from "./logger-Wxl_Krg6.js";
 function assertIsArray(value, options) {
 	if (isArray(value)) return;
 	resolveErrorMessageAssertions({
@@ -17,4 +17,4 @@ function assertIsArray(value, options) {
 	});
 }
 export { assertIsArray as t };
-//# sourceMappingURL=assertIsArray-CG7L7vlt.js.map
+//# sourceMappingURL=assertIsArray-DmlqnTiq.js.map

package/dist/{assertIsArray-CG7L7vlt.js.map → assertIsArray-DmlqnTiq.js.map}

@@ -1 +1 @@
-{"version":3,"file":"assertIsArray-CG7L7vlt.js","names":[],"sources":["../src/assertions/objects/assertIsArray.ts"],"sourcesContent":["import type {\n  IsArray,\n  IsReadonlyArray,\n  IsUnknown\n} from \"@rzl-zone/ts-types-plus\";\nimport type { ArrayFallback } from \"@/_private/types.arrays\";\n\nimport { isArray } from \"@/predicates/is/isArray\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype AssertIsArrayResult<T> =\n  IsUnknown<T> extends true\n    ? unknown[] & T\n    : IsReadonlyArray<T> extends true\n      ? T\n      : T extends []\n        ? T\n        : IsArray<T> extends true\n          ? T\n          : Extract<T, unknown[] | [] | readonly []>;\n\n/** --------------------------------------------------------------------------------\n * * ***Type guard assertion: `assertIsArray`.***\n * ---------------------------------------------------------------------------------\n * **This function is an **assertion function**.**\n *\n * - **Behavior:**\n *     - Validates that the given `value` is an **array**.\n *     - After it returns successfully, TypeScript narrows the type of `value` to `array` **(generic support)**.\n *     - If `value` is an `array` ➔ execution continues normally.\n *     - If `value` is not an `array` ➔ throws a built-in error with either:\n *       - A custom error message (`options.message`), or\n *       - A default message including the actual type.\n * - **Error type selection (`options.errorType`):**\n *     - You can override the type of error thrown when validation fails.\n *     - Must be one of the standard JavaScript built-in errors:\n *       - [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) |\n *         [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) |\n *         [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) |\n *         [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) |\n *         [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) |\n *         [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) |\n *         [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError).\n *     - **Default:** `\"TypeError\"` if not provided or invalid.\n *\n * @template T - The input type being asserted.\n * @param {*} value - ***The value to validate.***\n * @param {OptionsAssertIs} [options]\n *  ***Optional configuration:***\n *     - `message`: A custom error message (`string` or `function`).\n *     - `errorType`: Built-in JavaScript error type to throw on failure (default `\"TypeError\"`).\n *     - `formatCase`: Controls how detected type names are formatted case in error messages.\n *     - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n *\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 an array.\n * @returns {boolean} Narrows `value` to an `array` **(generic support)** if no error is thrown.\n *\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsArray([]);\n * assertIsArray([\"123\", 456]);\n * assertIsArray(Array.from([\"abc\"]));\n * // No error, value is array\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a array\n * assertIsArray(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `array`, but received: `string`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsArray(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `array`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsArray(\"123\", { message: \"Must be a array!\" });\n * // ➔ TypeError: \"Must be a array!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsArray(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected array but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsArray(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (url).\"\n * assertIsArray(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (URL).\"\n *\n * // Case 2:\n * assertIsArray(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (UrlSearchParams).\"\n * assertIsArray(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array 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 * assertIsArray(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be array!\"\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.push(1, 2, 3));   // ➔ Safe to use array methods\n * ```\n */\nexport function assertIsArray(\n  value: [],\n  options?: OptionsAssertIs\n): asserts value is [];\nexport function assertIsArray<T>(\n  value: T,\n  options?: OptionsAssertIs\n): asserts value is ArrayFallback<T>;\nexport function assertIsArray(\n  value: unknown,\n  options?: OptionsAssertIs\n): asserts value is unknown[];\nexport function assertIsArray<T>(value: T, options?: OptionsAssertIs) {\n  if (isArray(value)) return;\n\n  resolveErrorMessageAssertions({ value, options, requiredValidType: \"array\" });\n}\n"],"mappings":";;;;;;;;;;;;;AAyJA,SAAgB,cAAiB,OAAU,SAA2B;CACpE,IAAI,QAAQ,KAAK,GAAG;CAEpB,8BAA8B;EAAE;EAAO;EAAS,mBAAmB;CAAQ,CAAC;AAC9E"}
+{"version":3,"file":"assertIsArray-DmlqnTiq.js","names":[],"sources":["../src/assertions/objects/assertIsArray.ts"],"sourcesContent":["import type {\n  IsArray,\n  IsReadonlyArray,\n  IsUnknown\n} from \"@rzl-zone/ts-types-plus\";\nimport type { ArrayFallback } from \"@/_private/types.arrays\";\n\nimport { isArray } from \"@/predicates/is/isArray\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype AssertIsArrayResult<T> =\n  IsUnknown<T> extends true\n    ? unknown[] & T\n    : IsReadonlyArray<T> extends true\n      ? T\n      : T extends []\n        ? T\n        : IsArray<T> extends true\n          ? T\n          : Extract<T, unknown[] | [] | readonly []>;\n\n/** --------------------------------------------------------------------------------\n * * ***Type guard assertion: `assertIsArray`.***\n * ---------------------------------------------------------------------------------\n * **This function is an **assertion function**.**\n *\n * - **Behavior:**\n *     - Validates that the given `value` is an **array**.\n *     - After it returns successfully, TypeScript narrows the type of `value` to `array` **(generic support)**.\n *     - If `value` is an `array` ➔ execution continues normally.\n *     - If `value` is not an `array` ➔ throws a built-in error with either:\n *       - A custom error message (`options.message`), or\n *       - A default message including the actual type.\n * - **Error type selection (`options.errorType`):**\n *     - You can override the type of error thrown when validation fails.\n *     - Must be one of the standard JavaScript built-in errors:\n *       - [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) |\n *         [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) |\n *         [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) |\n *         [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) |\n *         [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) |\n *         [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) |\n *         [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError).\n *     - **Default:** `\"TypeError\"` if not provided or invalid.\n *\n * @template T - The input type being asserted.\n * @param {*} value - ***The value to validate.***\n * @param {OptionsAssertIs} [options]\n *  ***Optional configuration:***\n *     - `message`: A custom error message (`string` or `function`).\n *     - `errorType`: Built-in JavaScript error type to throw on failure (default `\"TypeError\"`).\n *     - `formatCase`: Controls how detected type names are formatted case in error messages.\n *     - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n *\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 an array.\n * @returns {boolean} Narrows `value` to an `array` **(generic support)** if no error is thrown.\n *\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsArray([]);\n * assertIsArray([\"123\", 456]);\n * assertIsArray(Array.from([\"abc\"]));\n * // No error, value is array\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a array\n * assertIsArray(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `array`, but received: `string`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsArray(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `array`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsArray(\"123\", { message: \"Must be a array!\" });\n * // ➔ TypeError: \"Must be a array!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsArray(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected array but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsArray(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (url).\"\n * assertIsArray(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (URL).\"\n *\n * // Case 2:\n * assertIsArray(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (UrlSearchParams).\"\n * assertIsArray(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array 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 * assertIsArray(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be array!\"\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.push(1, 2, 3));   // ➔ Safe to use array methods\n * ```\n */\nexport function assertIsArray(\n  value: [],\n  options?: OptionsAssertIs\n): asserts value is [];\nexport function assertIsArray<T>(\n  value: T,\n  options?: OptionsAssertIs\n): asserts value is ArrayFallback<T>;\nexport function assertIsArray(\n  value: unknown,\n  options?: OptionsAssertIs\n): asserts value is unknown[];\nexport function assertIsArray<T>(value: T, options?: OptionsAssertIs) {\n  if (isArray(value)) return;\n\n  resolveErrorMessageAssertions({ value, options, requiredValidType: \"array\" });\n}\n"],"mappings":";;;;;;;;;;;;;AAyJA,SAAgB,cAAiB,OAAU,SAA2B;CACpE,IAAI,QAAQ,KAAK,GAAG;CAEpB,8BAA8B;EAAE;EAAO;EAAS,mBAAmB;CAAQ,CAAC;AAC9E"}

package/dist/{assertIsArray-CtCRD-_G.cjs → assertIsArray-Xx-zlo6O.cjs}

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_logger = require('./logger-CUacYy3D.cjs');
+const require_logger = require('./logger-BXg2xufj.cjs');
 function assertIsArray(value, options) {
 	if (require_logger.isArray(value)) return;
 	require_logger.resolveErrorMessageAssertions({
@@ -23,4 +23,4 @@ Object.defineProperty(exports, 'assertIsArray', {
     return assertIsArray;
   }
 });
-//# sourceMappingURL=assertIsArray-CtCRD-_G.cjs.map
+//# sourceMappingURL=assertIsArray-Xx-zlo6O.cjs.map

package/dist/{assertIsArray-CtCRD-_G.cjs.map → assertIsArray-Xx-zlo6O.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"assertIsArray-CtCRD-_G.cjs","names":["isArray"],"sources":["../src/assertions/objects/assertIsArray.ts"],"sourcesContent":["import type {\n  IsArray,\n  IsReadonlyArray,\n  IsUnknown\n} from \"@rzl-zone/ts-types-plus\";\nimport type { ArrayFallback } from \"@/_private/types.arrays\";\n\nimport { isArray } from \"@/predicates/is/isArray\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype AssertIsArrayResult<T> =\n  IsUnknown<T> extends true\n    ? unknown[] & T\n    : IsReadonlyArray<T> extends true\n      ? T\n      : T extends []\n        ? T\n        : IsArray<T> extends true\n          ? T\n          : Extract<T, unknown[] | [] | readonly []>;\n\n/** --------------------------------------------------------------------------------\n * * ***Type guard assertion: `assertIsArray`.***\n * ---------------------------------------------------------------------------------\n * **This function is an **assertion function**.**\n *\n * - **Behavior:**\n *     - Validates that the given `value` is an **array**.\n *     - After it returns successfully, TypeScript narrows the type of `value` to `array` **(generic support)**.\n *     - If `value` is an `array` ➔ execution continues normally.\n *     - If `value` is not an `array` ➔ throws a built-in error with either:\n *       - A custom error message (`options.message`), or\n *       - A default message including the actual type.\n * - **Error type selection (`options.errorType`):**\n *     - You can override the type of error thrown when validation fails.\n *     - Must be one of the standard JavaScript built-in errors:\n *       - [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) |\n *         [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) |\n *         [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) |\n *         [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) |\n *         [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) |\n *         [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) |\n *         [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError).\n *     - **Default:** `\"TypeError\"` if not provided or invalid.\n *\n * @template T - The input type being asserted.\n * @param {*} value - ***The value to validate.***\n * @param {OptionsAssertIs} [options]\n *  ***Optional configuration:***\n *     - `message`: A custom error message (`string` or `function`).\n *     - `errorType`: Built-in JavaScript error type to throw on failure (default `\"TypeError\"`).\n *     - `formatCase`: Controls how detected type names are formatted case in error messages.\n *     - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n *\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 an array.\n * @returns {boolean} Narrows `value` to an `array` **(generic support)** if no error is thrown.\n *\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsArray([]);\n * assertIsArray([\"123\", 456]);\n * assertIsArray(Array.from([\"abc\"]));\n * // No error, value is array\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a array\n * assertIsArray(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `array`, but received: `string`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsArray(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `array`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsArray(\"123\", { message: \"Must be a array!\" });\n * // ➔ TypeError: \"Must be a array!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsArray(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected array but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsArray(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (url).\"\n * assertIsArray(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (URL).\"\n *\n * // Case 2:\n * assertIsArray(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (UrlSearchParams).\"\n * assertIsArray(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array 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 * assertIsArray(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be array!\"\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.push(1, 2, 3));   // ➔ Safe to use array methods\n * ```\n */\nexport function assertIsArray(\n  value: [],\n  options?: OptionsAssertIs\n): asserts value is [];\nexport function assertIsArray<T>(\n  value: T,\n  options?: OptionsAssertIs\n): asserts value is ArrayFallback<T>;\nexport function assertIsArray(\n  value: unknown,\n  options?: OptionsAssertIs\n): asserts value is unknown[];\nexport function assertIsArray<T>(value: T, options?: OptionsAssertIs) {\n  if (isArray(value)) return;\n\n  resolveErrorMessageAssertions({ value, options, requiredValidType: \"array\" });\n}\n"],"mappings":";;;;;;;;;;;;;AAyJA,SAAgB,cAAiB,OAAU,SAA2B;CACpE,IAAIA,uBAAQ,KAAK,GAAG;CAEpB,6CAA8B;EAAE;EAAO;EAAS,mBAAmB;CAAQ,CAAC;AAC9E"}
+{"version":3,"file":"assertIsArray-Xx-zlo6O.cjs","names":["isArray"],"sources":["../src/assertions/objects/assertIsArray.ts"],"sourcesContent":["import type {\n  IsArray,\n  IsReadonlyArray,\n  IsUnknown\n} from \"@rzl-zone/ts-types-plus\";\nimport type { ArrayFallback } from \"@/_private/types.arrays\";\n\nimport { isArray } from \"@/predicates/is/isArray\";\n\nimport {\n  resolveErrorMessageAssertions,\n  type OptionsAssertIs\n} from \"../_private/assertIs\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype AssertIsArrayResult<T> =\n  IsUnknown<T> extends true\n    ? unknown[] & T\n    : IsReadonlyArray<T> extends true\n      ? T\n      : T extends []\n        ? T\n        : IsArray<T> extends true\n          ? T\n          : Extract<T, unknown[] | [] | readonly []>;\n\n/** --------------------------------------------------------------------------------\n * * ***Type guard assertion: `assertIsArray`.***\n * ---------------------------------------------------------------------------------\n * **This function is an **assertion function**.**\n *\n * - **Behavior:**\n *     - Validates that the given `value` is an **array**.\n *     - After it returns successfully, TypeScript narrows the type of `value` to `array` **(generic support)**.\n *     - If `value` is an `array` ➔ execution continues normally.\n *     - If `value` is not an `array` ➔ throws a built-in error with either:\n *       - A custom error message (`options.message`), or\n *       - A default message including the actual type.\n * - **Error type selection (`options.errorType`):**\n *     - You can override the type of error thrown when validation fails.\n *     - Must be one of the standard JavaScript built-in errors:\n *       - [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) |\n *         [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) |\n *         [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) |\n *         [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) |\n *         [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) |\n *         [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) |\n *         [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError).\n *     - **Default:** `\"TypeError\"` if not provided or invalid.\n *\n * @template T - The input type being asserted.\n * @param {*} value - ***The value to validate.***\n * @param {OptionsAssertIs} [options]\n *  ***Optional configuration:***\n *     - `message`: A custom error message (`string` or `function`).\n *     - `errorType`: Built-in JavaScript error type to throw on failure (default `\"TypeError\"`).\n *     - `formatCase`: Controls how detected type names are formatted case in error messages.\n *     - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n *\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 an array.\n * @returns {boolean} Narrows `value` to an `array` **(generic support)** if no error is thrown.\n *\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsArray([]);\n * assertIsArray([\"123\", 456]);\n * assertIsArray(Array.from([\"abc\"]));\n * // No error, value is array\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a array\n * assertIsArray(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `array`, but received: `string`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsArray(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `array`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsArray(\"123\", { message: \"Must be a array!\" });\n * // ➔ TypeError: \"Must be a array!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsArray(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected array but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsArray(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (url).\"\n * assertIsArray(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (URL).\"\n *\n * // Case 2:\n * assertIsArray(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array but got (UrlSearchParams).\"\n * assertIsArray(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected array 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 * assertIsArray(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be array!\"\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.push(1, 2, 3));   // ➔ Safe to use array methods\n * ```\n */\nexport function assertIsArray(\n  value: [],\n  options?: OptionsAssertIs\n): asserts value is [];\nexport function assertIsArray<T>(\n  value: T,\n  options?: OptionsAssertIs\n): asserts value is ArrayFallback<T>;\nexport function assertIsArray(\n  value: unknown,\n  options?: OptionsAssertIs\n): asserts value is unknown[];\nexport function assertIsArray<T>(value: T, options?: OptionsAssertIs) {\n  if (isArray(value)) return;\n\n  resolveErrorMessageAssertions({ value, options, requiredValidType: \"array\" });\n}\n"],"mappings":";;;;;;;;;;;;;AAyJA,SAAgB,cAAiB,OAAU,SAA2B;CACpE,IAAIA,uBAAQ,KAAK,GAAG;CAEpB,6CAA8B;EAAE;EAAO;EAAS,mBAAmB;CAAQ,CAAC;AAC9E"}

package/dist/{assertIsPlainObject-j9bDqNLo.js → assertIsPlainObject-CIzDchLs.js}

@@ -2,12 +2,12 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { E as isPlainObject, r as resolveErrorMessageAssertions } from "./logger-CLWnKRKE.js";
+import { E as isPlainObject, r as resolveErrorMessageAssertions } from "./logger-Wxl_Krg6.js";
 function assertIsPlainObject(value, options) {
 	if (isPlainObject(value)) return;
 	resolveErrorMessageAssertions({
@@ -17,4 +17,4 @@ function assertIsPlainObject(value, options) {
 	});
 }
 export { assertIsPlainObject as t };
-//# sourceMappingURL=assertIsPlainObject-j9bDqNLo.js.map
+//# sourceMappingURL=assertIsPlainObject-CIzDchLs.js.map

package/dist/{assertIsPlainObject-j9bDqNLo.js.map → assertIsPlainObject-CIzDchLs.js.map}

@@ -1 +1 @@
-{"version":3,"file":"assertIsPlainObject-j9bDqNLo.js","names":[],"sources":["../src/assertions/objects/assertIsPlainObject.ts"],"sourcesContent":["import {\n  isPlainObject,\n  type IsPlainObjectResult\n} from \"@/predicates/is/isPlainObject\";\nimport {\n  type OptionsAssertIs,\n  resolveErrorMessageAssertions\n} from \"../_private/assertIs\";\n\n/** --------------------------------------------------------------------------------\n * * ***Type guard assertion: `assertIsPlainObject`.***\n * ---------------------------------------------------------------------------------\n * **This function is an **assertion function**.**\n *\n * - **Behavior:**\n *     - Validates that the given `value` is a **plain-object**.\n *     - After it returns successfully, TypeScript narrows the type of `value` to `plain-object` **(generic support)**.\n *     - If `value` is a `plain-object` ➔ execution continues normally.\n *     - If `value` is not a `plain-object` ➔ throws a built-in error with either:\n *       - A custom error message (`options.message`), or\n *       - A default message including the actual type.\n * - **A valid `plain object` is:**\n *     - Created by the `Object` constructor, or\n *     - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).\n *      - **Returns `undefined` (valid) for:**\n *          - Empty object literals: `{}`\n *          - Objects with null prototype: `Object.create(null)`\n *      - **Returns `throws` for:**\n *          - Arrays (`[]`, `new Array()`)\n *          - Functions (regular, arrow, or class constructors)\n *          - Built-in objects: `Date`, `RegExp`, `Error`, `Map`, `Set`, `WeakMap`, `WeakSet`\n *          - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`\n *          - `null` or `undefined`\n *          - Symbols\n *          - Class instances\n * - **Error type selection (`options.errorType`):**\n *     - You can override the type of error thrown when validation fails.\n *     - Must be one of the standard JavaScript built-in errors:\n *       - [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) |\n *         [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) |\n *         [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) |\n *         [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) |\n *         [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) |\n *         [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) |\n *         [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError).\n *     - **Default:** `\"TypeError\"` if not provided or invalid.\n *\n * @template T - The input type being asserted.\n * @param {*} value - ***The value to validate.***\n * @param {OptionsAssertIs} [options]\n *  ***Optional configuration:***\n *     - `message`: A custom error message (`string` or `function`).\n *     - `errorType`: Built-in JavaScript error type to throw on failure (default `\"TypeError\"`).\n *     - `formatCase`: Controls how detected type names are formatted case in error messages.\n *     - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n *\n * @throws [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) | [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) | [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) | [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) | [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) | [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) | [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError) if `value` is not a plain-object.\n * @returns {boolean} Narrows `value` to a `plain-object` **(generic support)** if no error is thrown.\n *\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsPlainObject({ a: 1, b: 2 });\n * // No error, value is plain-object\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a plain-object\n * assertIsPlainObject(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `string`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsPlainObject(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsPlainObject(\"123\", { message: \"Must be a plain-object!\" });\n * // ➔ TypeError: \"Must be a plain-object!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsPlainObject(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected plain-object but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsPlainObject(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (url).\"\n * assertIsPlainObject(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URL).\"\n *\n * // Case 2:\n * assertIsPlainObject(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (UrlSearchParams).\"\n * assertIsPlainObject(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage with generic narrowing***:\n * ```ts\n * type User = { name: string; email: string };\n * const mixedValue: string | User | boolean | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `plain-object`\n * assertIsPlainObject(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be plain object!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `User` here\n * const user: User = mixedValue; // ➔ Safe type assignment\n * console.log(user.email);       // ➔ Safe to access object properties\n * ```\n */\nexport function assertIsPlainObject<T>(\n  value: T,\n  options?: OptionsAssertIs\n): asserts value is IsPlainObjectResult<T> {\n  if (isPlainObject(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"plain object\"\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyIA,SAAgB,oBACd,OACA,SACyC;CACzC,IAAI,cAAc,KAAK,GAAG;CAE1B,8BAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}
+{"version":3,"file":"assertIsPlainObject-CIzDchLs.js","names":[],"sources":["../src/assertions/objects/assertIsPlainObject.ts"],"sourcesContent":["import {\n  isPlainObject,\n  type IsPlainObjectResult\n} from \"@/predicates/is/isPlainObject\";\nimport {\n  type OptionsAssertIs,\n  resolveErrorMessageAssertions\n} from \"../_private/assertIs\";\n\n/** --------------------------------------------------------------------------------\n * * ***Type guard assertion: `assertIsPlainObject`.***\n * ---------------------------------------------------------------------------------\n * **This function is an **assertion function**.**\n *\n * - **Behavior:**\n *     - Validates that the given `value` is a **plain-object**.\n *     - After it returns successfully, TypeScript narrows the type of `value` to `plain-object` **(generic support)**.\n *     - If `value` is a `plain-object` ➔ execution continues normally.\n *     - If `value` is not a `plain-object` ➔ throws a built-in error with either:\n *       - A custom error message (`options.message`), or\n *       - A default message including the actual type.\n * - **A valid `plain object` is:**\n *     - Created by the `Object` constructor, or\n *     - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).\n *      - **Returns `undefined` (valid) for:**\n *          - Empty object literals: `{}`\n *          - Objects with null prototype: `Object.create(null)`\n *      - **Returns `throws` for:**\n *          - Arrays (`[]`, `new Array()`)\n *          - Functions (regular, arrow, or class constructors)\n *          - Built-in objects: `Date`, `RegExp`, `Error`, `Map`, `Set`, `WeakMap`, `WeakSet`\n *          - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`\n *          - `null` or `undefined`\n *          - Symbols\n *          - Class instances\n * - **Error type selection (`options.errorType`):**\n *     - You can override the type of error thrown when validation fails.\n *     - Must be one of the standard JavaScript built-in errors:\n *       - [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) |\n *         [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) |\n *         [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) |\n *         [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) |\n *         [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) |\n *         [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) |\n *         [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError).\n *     - **Default:** `\"TypeError\"` if not provided or invalid.\n *\n * @template T - The input type being asserted.\n * @param {*} value - ***The value to validate.***\n * @param {OptionsAssertIs} [options]\n *  ***Optional configuration:***\n *     - `message`: A custom error message (`string` or `function`).\n *     - `errorType`: Built-in JavaScript error type to throw on failure (default `\"TypeError\"`).\n *     - `formatCase`: Controls how detected type names are formatted case in error messages.\n *     - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n *\n * @throws [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) | [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) | [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) | [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) | [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) | [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) | [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError) if `value` is not a plain-object.\n * @returns {boolean} Narrows `value` to a `plain-object` **(generic support)** if no error is thrown.\n *\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsPlainObject({ a: 1, b: 2 });\n * // No error, value is plain-object\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a plain-object\n * assertIsPlainObject(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `string`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsPlainObject(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsPlainObject(\"123\", { message: \"Must be a plain-object!\" });\n * // ➔ TypeError: \"Must be a plain-object!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsPlainObject(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected plain-object but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsPlainObject(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (url).\"\n * assertIsPlainObject(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URL).\"\n *\n * // Case 2:\n * assertIsPlainObject(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (UrlSearchParams).\"\n * assertIsPlainObject(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage with generic narrowing***:\n * ```ts\n * type User = { name: string; email: string };\n * const mixedValue: string | User | boolean | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `plain-object`\n * assertIsPlainObject(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be plain object!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `User` here\n * const user: User = mixedValue; // ➔ Safe type assignment\n * console.log(user.email);       // ➔ Safe to access object properties\n * ```\n */\nexport function assertIsPlainObject<T>(\n  value: T,\n  options?: OptionsAssertIs\n): asserts value is IsPlainObjectResult<T> {\n  if (isPlainObject(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"plain object\"\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyIA,SAAgB,oBACd,OACA,SACyC;CACzC,IAAI,cAAc,KAAK,GAAG;CAE1B,8BAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}

package/dist/{assertIsPlainObject-DPZLj-Ho.cjs → assertIsPlainObject-DYoxHcW5.cjs}

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_logger = require('./logger-CUacYy3D.cjs');
+const require_logger = require('./logger-BXg2xufj.cjs');
 function assertIsPlainObject(value, options) {
 	if (require_logger.isPlainObject(value)) return;
 	require_logger.resolveErrorMessageAssertions({
@@ -23,4 +23,4 @@ Object.defineProperty(exports, 'assertIsPlainObject', {
     return assertIsPlainObject;
   }
 });
-//# sourceMappingURL=assertIsPlainObject-DPZLj-Ho.cjs.map
+//# sourceMappingURL=assertIsPlainObject-DYoxHcW5.cjs.map

package/dist/{assertIsPlainObject-DPZLj-Ho.cjs.map → assertIsPlainObject-DYoxHcW5.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"assertIsPlainObject-DPZLj-Ho.cjs","names":["isPlainObject"],"sources":["../src/assertions/objects/assertIsPlainObject.ts"],"sourcesContent":["import {\n  isPlainObject,\n  type IsPlainObjectResult\n} from \"@/predicates/is/isPlainObject\";\nimport {\n  type OptionsAssertIs,\n  resolveErrorMessageAssertions\n} from \"../_private/assertIs\";\n\n/** --------------------------------------------------------------------------------\n * * ***Type guard assertion: `assertIsPlainObject`.***\n * ---------------------------------------------------------------------------------\n * **This function is an **assertion function**.**\n *\n * - **Behavior:**\n *     - Validates that the given `value` is a **plain-object**.\n *     - After it returns successfully, TypeScript narrows the type of `value` to `plain-object` **(generic support)**.\n *     - If `value` is a `plain-object` ➔ execution continues normally.\n *     - If `value` is not a `plain-object` ➔ throws a built-in error with either:\n *       - A custom error message (`options.message`), or\n *       - A default message including the actual type.\n * - **A valid `plain object` is:**\n *     - Created by the `Object` constructor, or\n *     - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).\n *      - **Returns `undefined` (valid) for:**\n *          - Empty object literals: `{}`\n *          - Objects with null prototype: `Object.create(null)`\n *      - **Returns `throws` for:**\n *          - Arrays (`[]`, `new Array()`)\n *          - Functions (regular, arrow, or class constructors)\n *          - Built-in objects: `Date`, `RegExp`, `Error`, `Map`, `Set`, `WeakMap`, `WeakSet`\n *          - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`\n *          - `null` or `undefined`\n *          - Symbols\n *          - Class instances\n * - **Error type selection (`options.errorType`):**\n *     - You can override the type of error thrown when validation fails.\n *     - Must be one of the standard JavaScript built-in errors:\n *       - [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) |\n *         [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) |\n *         [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) |\n *         [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) |\n *         [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) |\n *         [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) |\n *         [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError).\n *     - **Default:** `\"TypeError\"` if not provided or invalid.\n *\n * @template T - The input type being asserted.\n * @param {*} value - ***The value to validate.***\n * @param {OptionsAssertIs} [options]\n *  ***Optional configuration:***\n *     - `message`: A custom error message (`string` or `function`).\n *     - `errorType`: Built-in JavaScript error type to throw on failure (default `\"TypeError\"`).\n *     - `formatCase`: Controls how detected type names are formatted case in error messages.\n *     - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n *\n * @throws [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) | [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) | [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) | [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) | [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) | [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) | [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError) if `value` is not a plain-object.\n * @returns {boolean} Narrows `value` to a `plain-object` **(generic support)** if no error is thrown.\n *\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsPlainObject({ a: 1, b: 2 });\n * // No error, value is plain-object\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a plain-object\n * assertIsPlainObject(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `string`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsPlainObject(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsPlainObject(\"123\", { message: \"Must be a plain-object!\" });\n * // ➔ TypeError: \"Must be a plain-object!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsPlainObject(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected plain-object but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsPlainObject(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (url).\"\n * assertIsPlainObject(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URL).\"\n *\n * // Case 2:\n * assertIsPlainObject(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (UrlSearchParams).\"\n * assertIsPlainObject(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage with generic narrowing***:\n * ```ts\n * type User = { name: string; email: string };\n * const mixedValue: string | User | boolean | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `plain-object`\n * assertIsPlainObject(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be plain object!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `User` here\n * const user: User = mixedValue; // ➔ Safe type assignment\n * console.log(user.email);       // ➔ Safe to access object properties\n * ```\n */\nexport function assertIsPlainObject<T>(\n  value: T,\n  options?: OptionsAssertIs\n): asserts value is IsPlainObjectResult<T> {\n  if (isPlainObject(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"plain object\"\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyIA,SAAgB,oBACd,OACA,SACyC;CACzC,IAAIA,6BAAc,KAAK,GAAG;CAE1B,6CAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}
+{"version":3,"file":"assertIsPlainObject-DYoxHcW5.cjs","names":["isPlainObject"],"sources":["../src/assertions/objects/assertIsPlainObject.ts"],"sourcesContent":["import {\n  isPlainObject,\n  type IsPlainObjectResult\n} from \"@/predicates/is/isPlainObject\";\nimport {\n  type OptionsAssertIs,\n  resolveErrorMessageAssertions\n} from \"../_private/assertIs\";\n\n/** --------------------------------------------------------------------------------\n * * ***Type guard assertion: `assertIsPlainObject`.***\n * ---------------------------------------------------------------------------------\n * **This function is an **assertion function**.**\n *\n * - **Behavior:**\n *     - Validates that the given `value` is a **plain-object**.\n *     - After it returns successfully, TypeScript narrows the type of `value` to `plain-object` **(generic support)**.\n *     - If `value` is a `plain-object` ➔ execution continues normally.\n *     - If `value` is not a `plain-object` ➔ throws a built-in error with either:\n *       - A custom error message (`options.message`), or\n *       - A default message including the actual type.\n * - **A valid `plain object` is:**\n *     - Created by the `Object` constructor, or\n *     - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).\n *      - **Returns `undefined` (valid) for:**\n *          - Empty object literals: `{}`\n *          - Objects with null prototype: `Object.create(null)`\n *      - **Returns `throws` for:**\n *          - Arrays (`[]`, `new Array()`)\n *          - Functions (regular, arrow, or class constructors)\n *          - Built-in objects: `Date`, `RegExp`, `Error`, `Map`, `Set`, `WeakMap`, `WeakSet`\n *          - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`\n *          - `null` or `undefined`\n *          - Symbols\n *          - Class instances\n * - **Error type selection (`options.errorType`):**\n *     - You can override the type of error thrown when validation fails.\n *     - Must be one of the standard JavaScript built-in errors:\n *       - [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) |\n *         [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) |\n *         [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) |\n *         [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) |\n *         [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) |\n *         [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) |\n *         [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError).\n *     - **Default:** `\"TypeError\"` if not provided or invalid.\n *\n * @template T - The input type being asserted.\n * @param {*} value - ***The value to validate.***\n * @param {OptionsAssertIs} [options]\n *  ***Optional configuration:***\n *     - `message`: A custom error message (`string` or `function`).\n *     - `errorType`: Built-in JavaScript error type to throw on failure (default `\"TypeError\"`).\n *     - `formatCase`: Controls how detected type names are formatted case in error messages.\n *     - `useAcronyms`: Control uppercase preservation of recognized acronyms during formatting.\n *\n * @throws [`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) | [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) | [`EvalError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) | [`RangeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) | [`ReferenceError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) | [`SyntaxError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) | [`URIError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError) if `value` is not a plain-object.\n * @returns {boolean} Narrows `value` to a `plain-object` **(generic support)** if no error is thrown.\n *\n * @example\n * ```ts\n * // ✅ Simple usage\n * assertIsPlainObject({ a: 1, b: 2 });\n * // No error, value is plain-object\n *\n * // ❌ Throws TypeError (default behavior)\n * // Case 1: Invalid input type — received a string instead of a plain-object\n * assertIsPlainObject(\"42\");\n * // ➔ TypeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `string`.\"\n *\n * // ❌ Throws custom error type (e.g., RangeError)\n * assertIsPlainObject(async function () {}, { errorType: \"RangeError\" });\n * // ➔ RangeError: \"Parameter input (`value`) must be of type `plain-object`, but received: `async-function`.\"\n *\n * // ❌ Throws a TypeError with a custom string static message\n * assertIsPlainObject(\"123\", { message: \"Must be a plain-object!\" });\n * // ➔ TypeError: \"Must be a plain-object!\"\n *\n * // ❌ Throws a TypeError with a custom message function and formatCase\n * assertIsPlainObject(/regex/, {\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n *   formatCase: \"toPascalCaseSpace\"\n * });\n * // ➔ TypeError: \"Expected plain-object but got (Reg Exp).\"\n *\n * // ❌ Throws a TypeError with a custom useAcronyms option\n * // Case 1:\n * assertIsPlainObject(new URL(\"https://example.com\"),{\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (url).\"\n * assertIsPlainObject(new URL(\"https://example.com\"), {\n *   useAcronyms: true,\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URL).\"\n *\n * // Case 2:\n * assertIsPlainObject(new URLSearchParams, {\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (UrlSearchParams).\"\n * assertIsPlainObject(new URLSearchParams, {\n *   useAcronyms: true,\n *   formatCase: \"toPascalCase\",\n *   message: ({ currentType, validType }) => {\n *     return `Expected ${validType} but got (${currentType}).`\n *   },\n * });\n * // ➔ TypeError: \"Expected plain-object but got (URLSearchParams).\"\n * ```\n * -------------------------------------------------------\n * ✅ ***Real-world usage with generic narrowing***:\n * ```ts\n * type User = { name: string; email: string };\n * const mixedValue: string | User | boolean | number | undefined = getUserInput();\n *\n * // Runtime assertion: throws if `mixedValue` is not a `plain-object`\n * assertIsPlainObject(mixedValue, {\n *   errorType: \"RangeError\",\n *   message: \"Must be plain object!\"\n * });\n *\n * // ✅ If no error thrown, TypeScript narrows `mixedValue` to `User` here\n * const user: User = mixedValue; // ➔ Safe type assignment\n * console.log(user.email);       // ➔ Safe to access object properties\n * ```\n */\nexport function assertIsPlainObject<T>(\n  value: T,\n  options?: OptionsAssertIs\n): asserts value is IsPlainObjectResult<T> {\n  if (isPlainObject(value)) return;\n\n  resolveErrorMessageAssertions({\n    value,\n    options,\n    requiredValidType: \"plain object\"\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyIA,SAAgB,oBACd,OACA,SACyC;CACzC,IAAIA,6BAAc,KAAK,GAAG;CAE1B,6CAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}

package/dist/{assertIsString-CjE9kbQ_.cjs → assertIsString-CuPbh3FB.cjs}

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_logger = require('./logger-CUacYy3D.cjs');
+const require_logger = require('./logger-BXg2xufj.cjs');
 const assertIsString = (value, options) => {
 	if (require_logger.isString(value)) return;
 	require_logger.resolveErrorMessageAssertions({
@@ -23,4 +23,4 @@ Object.defineProperty(exports, 'assertIsString', {
     return assertIsString;
   }
 });
-//# sourceMappingURL=assertIsString-CjE9kbQ_.cjs.map
+//# sourceMappingURL=assertIsString-CuPbh3FB.cjs.map

package/dist/{assertIsString-CjE9kbQ_.cjs.map → assertIsString-CuPbh3FB.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"assertIsString-CjE9kbQ_.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 *\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 *\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 *\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 * @returns {boolean} Narrows `value` to `string` if no error is thrown.\n *\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6HA,MAAa,kBAIX,OACA,YAC4B;CAC5B,IAAIA,wBAAS,KAAK,GAAG;CAErB,6CAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}
+{"version":3,"file":"assertIsString-CuPbh3FB.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 *\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 *\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 *\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 * @returns {boolean} Narrows `value` to `string` if no error is thrown.\n *\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6HA,MAAa,kBAIX,OACA,YAC4B;CAC5B,IAAIA,wBAAS,KAAK,GAAG;CAErB,6CAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}

package/dist/{assertIsString-CHIwE12y.js → assertIsString-sgY3ml5f.js}

@@ -2,12 +2,12 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { T as isString, r as resolveErrorMessageAssertions } from "./logger-CLWnKRKE.js";
+import { T as isString, r as resolveErrorMessageAssertions } from "./logger-Wxl_Krg6.js";
 const assertIsString = (value, options) => {
 	if (isString(value)) return;
 	resolveErrorMessageAssertions({
@@ -17,4 +17,4 @@ const assertIsString = (value, options) => {
 	});
 };
 export { assertIsString as t };
-//# sourceMappingURL=assertIsString-CHIwE12y.js.map
+//# sourceMappingURL=assertIsString-sgY3ml5f.js.map

package/dist/{assertIsString-CHIwE12y.js.map → assertIsString-sgY3ml5f.js.map}

@@ -1 +1 @@
-{"version":3,"file":"assertIsString-CHIwE12y.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 *\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 *\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 *\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 * @returns {boolean} Narrows `value` to `string` if no error is thrown.\n *\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6HA,MAAa,kBAIX,OACA,YAC4B;CAC5B,IAAI,SAAS,KAAK,GAAG;CAErB,8BAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}
+{"version":3,"file":"assertIsString-sgY3ml5f.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 *\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 *\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 *\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 * @returns {boolean} Narrows `value` to `string` if no error is thrown.\n *\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6HA,MAAa,kBAIX,OACA,YAC4B;CAC5B,IAAI,SAAS,KAAK,GAAG;CAErB,8BAA8B;EAC5B;EACA;EACA,mBAAmB;CACrB,CAAC;AACH"}

package/dist/assertions/index.cjs

@@ -2,19 +2,19 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.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_logger = require('../logger-CUacYy3D.cjs');
-const require_isBigInt = require('../isBigInt-YgpNKTbA.cjs');
-const require_isNumber = require('../isNumber-BkzwAe50.cjs');
-const require_assertIsArray = require('../assertIsArray-CtCRD-_G.cjs');
-const require_assertIsPlainObject = require('../assertIsPlainObject-DPZLj-Ho.cjs');
-const require_assertIsString = require('../assertIsString-CjE9kbQ_.cjs');
+const require_logger = require('../logger-BXg2xufj.cjs');
+const require_isBigInt = require('../isBigInt-LkCpVJ3E.cjs');
+const require_isNumber = require('../isNumber-CM1vdNcW.cjs');
+const require_assertIsArray = require('../assertIsArray-Xx-zlo6O.cjs');
+const require_assertIsPlainObject = require('../assertIsPlainObject-DYoxHcW5.cjs');
+const require_assertIsString = require('../assertIsString-CuPbh3FB.cjs');
 const assertIsBigInt = (value, options) => {
 	if (require_isBigInt.isBigInt(value)) return;
 	require_logger.resolveErrorMessageAssertions({

package/dist/assertions/index.d.cts

@@ -2,11 +2,11 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.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-BVovC-yK.cjs";
+import { a as assertIsBigInt, i as assertIsNumber, n as assertIsPlainObject, o as assertIsBoolean, r as assertIsArray, t as assertIsString } from "../index-9Ql1W3gt.cjs";
 export { assertIsArray, assertIsBigInt, assertIsBoolean, assertIsNumber, assertIsPlainObject, assertIsString };

package/dist/assertions/index.d.ts

@@ -2,11 +2,11 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.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-jyuOZMX7.js";
+import { a as assertIsBigInt, i as assertIsNumber, n as assertIsPlainObject, o as assertIsBoolean, r as assertIsArray, t as assertIsString } from "../index-DqYMKSmd.js";
 export { assertIsArray, assertIsBigInt, assertIsBoolean, assertIsNumber, assertIsPlainObject, assertIsString };