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

package/dist/{index-BqkYm8qT.d.cts → index-lI0b7iUz.d.cts}

@@ -2,22 +2,30 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.1-beta.0`
+*  Version: `3.14.0-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 
-import { Extends, FixNeverArrayRecursive, IfNonEmptyArray, NullToUndefined } from "@rzl-zone/ts-types-plus";
-/** ---------------------------------
+import { T as NullToUndefined, d as IfNonEmptyArray, l as FixNeverArrayRecursive, s as Extends } from "./index-DZHiYYR7.cjs";
+/** -------------------------------------------------------------------------------------
 * * ***Utility: `getRandomItem`.***
-* ---------------------------------
+* --------------------------------------------------------------------------------------
 * **Function to get a random element from a given array.**
+*
+* ---
 * @template T - The type of the input array.
+*
+* ---
 * @param {*} array - The input array, can be `null`, `undefined`, or an empty array.
+*
+* ---
 * @returns
 * - If `array` is a non-empty tuple, returns one of its elements.
 * - If `array` is empty, `null`, or `undefined`, returns `undefined`.
+*
+* ---
 * @example
 * getRandomItem([]);
 * // ➔ undefined
@@ -45,24 +53,38 @@ declare function getRandomItem(array: []): undefined;
 declare function getRandomItem<T extends readonly unknown[]>(array: T): T extends never[][] ? undefined : number extends T["length"] ? NullToUndefined<FixNeverArrayRecursive<T[number]>> : IfNonEmptyArray<T, NullToUndefined<FixNeverArrayRecursive<T[number]>>, undefined>;
 declare function getRandomItem<T extends readonly unknown[] | undefined | null>(array: T): T extends readonly unknown[] ? NullToUndefined<FixNeverArrayRecursive<T[number]>> | undefined : undefined;
 declare function getRandomItem<T>(array: T): unknown extends T ? unknown : Extends<any[] | readonly any[], T> extends true ? Extract<T, unknown[] | readonly unknown[]>[number] | undefined : Extends<any[], T> extends true ? Extract<T, unknown[] | readonly unknown[]>[number] | undefined : Extends<readonly any[], T> extends true ? Extract<T, unknown[] | readonly unknown[]>[number] | undefined : undefined;
-/** -----------------------------------------------------------------------
+/** -----------------------------------------------------------------------------------------------------
 * * ***Utility: `randomInt`.***
-* ------------------------------------------------------------------------
+* ------------------------------------------------------------------------------------------------------
 * **Generates a random integer within a specified range (inclusive).**
+*
+* ---
 * - **Generates a random integer between `min` and `max` (inclusive), with safety constraints:**
-*    - `min` will be forced to be at least `1`.
-*    - `max` will be capped at `Number.MAX_SAFE_INTEGER`.
+*     - `min` will be forced to be at least `1`.
+*     - `max` will be capped at `Number.MAX_SAFE_INTEGER`.
+*
+* ---
 * @param {number} min - The minimum value (inclusive), must be an integer.
 * @param {number} max - The maximum value (inclusive), must be an integer.
+*
+* ---
 * @returns {number} A random integer N where `min ≤ N ≤ max`.
+*
+* ---
 * @throws **{@link TypeError | `TypeError`}** if:
 * - `min` or `max` is not an integer, or value is `Number.MIN_VALUE`.
 * - `min` is greater than `max`.
+*
+* ---
 * @example
-* randomInt(1, 10);   // ➔ returns 1 up-to 10 (random)
-* randomInt(50, 100); // ➔ returns 50 up-to 100 (random)
-* randomInt(5, 5);    // ➔ always returns 5 (exact)
-* randomInt(-5, 3);   // ➔ always returns ≥ 1, since min is adjusted (exact)
+* randomInt(1, 10);
+* // ➔ returns 1 up-to 10 (random)
+* randomInt(50, 100);
+* // ➔ returns 50 up-to 100 (random)
+* randomInt(5, 5);
+* // ➔ always returns 5 (exact)
+* randomInt(-5, 3);
+* // ➔ always returns ≥ 1, since min is adjusted (exact)
 * randomInt(1, Number.MAX_SAFE_INTEGER + 10000);
 * // ➔ still safely capped at MAX_SAFE_INTEGER
 * randomInt(Number.MIN_VALUE, 3);
@@ -70,17 +92,23 @@ declare function getRandomItem<T>(array: T): unknown extends T ? unknown : Exten
 */
 declare const randomInt: (min: number, max: number) => number;
 type OptionsRandomIntByLength = {
-  /** * Minimum length of the random number, the `allowed minimal value` `integer` is `1` `and not bigger than value of` `maxLength`, defaultValue: `1`.
+  /** -----------------------------------------------------------------------------------
+  * * ***Minimum length of the random number, the `allowed minimal value` `integer` is `1` `and not bigger than value of` `maxLength`, defaultValue: `1`.***
+  * ------------------------------------------------------------------------------------
   *
   * @default 1
   */
   minLength?: number;
-  /** * Maximum length of the random number, the `allowed maximal value` `integer` is `16`, defaultValue: `16`.
+  /** -----------------------------------------------------------------------------------
+  * * ***Maximum length of the random number, the `allowed maximal value` `integer` is `16`, defaultValue: `16`.***
+  * ------------------------------------------------------------------------------------
   *
   * @default 16
   */
   maxLength?: number;
-  /** * If true, prevents the result from being zero, defaultValue: `false`.
+  /** -----------------------------------------------------------------------------------
+  * * ***If true, prevents the result from being zero, defaultValue: `false`.***
+  * ------------------------------------------------------------------------------------
   *
   * @default false
   */
@@ -90,78 +118,107 @@ type OptionsRandomIntByLength = {
 * * ***Utility: `randomIntByLength`.***
 * -----------------------------------------------------------------------------
 * **Generates a random integer within a specified range of digit lengths.**
+*
+* ---
 * @description
 * This function allows generating random integers that strictly conform to a specified minimum and
 * maximum digit length, it is useful for scenarios such as generating realistic-looking IDs, codes,
 * or random test data.
+*
+* ---
 * - **The function ensures:**
-*    - `minLength` is at least 1 and not greater than `maxLength`.
-*    - `maxLength` is no more than 16 (due to JavaScript's `Number.MAX_SAFE_INTEGER`).
-*    - If `avoidZero` is `true`, ensures that `0` is never returned.
+*     - `minLength` is at least 1 and not greater than `maxLength`.
+*     - `maxLength` is no more than 16 (due to JavaScript's `Number.MAX_SAFE_INTEGER`).
+*     - If `avoidZero` is `true`, ensures that `0` is never returned.
+*
+* ---
 * @param {OptionsRandomIntByLength} [options] - Configuration options.
 * @param {OptionsRandomIntByLength["minLength"]} [options.minLength=1] - Minimum number of digits (must be ≥ `1` and ≤ `maxLength`).
 * @param {OptionsRandomIntByLength["maxLength"]} [options.maxLength=16] - Maximum number of digits (must be ≤ `16`).
 * @param {OptionsRandomIntByLength["avoidZero"]} [options.avoidZero=false] - If true, will ensure the result is never zero.
-* @returns {number} A randomly generated integer within the specified constraints.
+*
+* ---
 * @throws **{@link TypeError | `TypeError`}** if parameters are invalid, such as:
-* - `minLength` < `1`
-* - `maxLength` > `16`
-* - `minLength` > `maxLength`
-* - non-integer values for `minLength` or `maxLength`
+* - `minLength` < `1`.
+* - `maxLength` > `16`.
+* - `minLength` > `maxLength`.
+* - non-integer values for `minLength` or `maxLength`.
+*
+* ---
+* @returns {number} A randomly generated integer within the specified constraints.
+*
+* ---
 * @example
 * randomIntByLength({ minLength: 3, maxLength: 5 });
-* // ➔ `4829` (random), `192` (random) or `71492` (random).
+* // ➔ `xxx` (random int), `xxxx` (random int) or `xxxxx` (random int).
 * randomIntByLength({ minLength: 4, maxLength: 4 });
-* // ➔ `5930` (exact 4 digits)
-* randomIntByLength({ avoidZero: true });
-* // ➔ never 0
+* // ➔ `xxxx` (exact 4 digits int)
+* randomIntByLength({ avoidZero: true }); // never 0
 */
 declare const randomIntByLength: (options?: OptionsRandomIntByLength) => number;
 type OptionsRandomStr = {
-  /** ***Ensures no whitespace characters in the generated string, defaultValue: `true`.***
+  /** -----------------------------------------------------------------------------------
+  * * ***Ensures no whitespace characters in the generated string, defaultValue: `true`.***
+  * ------------------------------------------------------------------------------------
   *
   * @default true
   */
   avoidWhiteSpace?: boolean;
-  /** ***Custom characters to replace the default number set if `type` is `"number"`, defaultValue: `undefined`.***
+  /** -----------------------------------------------------------------------------------
+  * * ***Custom characters to replace the default number set if `type` is `"number"`, defaultValue: `undefined`.***
+  * ------------------------------------------------------------------------------------
   *
   * @default undefined
   */
   replaceGenInt?: string;
-  /** ***Custom characters to replace the default string set if `type` is `"string"`, defaultValue: `undefined`.***
+  /** -----------------------------------------------------------------------------------
+  * * ***Custom characters to replace the default string set if `type` is `"string"`, defaultValue: `undefined`.***
+  * ------------------------------------------------------------------------------------
   *
   * @default undefined
   */
   replaceGenStr?: string;
-  /** ***Additional characters to include in the generated string, defaultValue: `undefined`.***
+  /** -----------------------------------------------------------------------------------
+  * * ***Additional characters to include in the generated string, defaultValue: `undefined`.***
+  * ------------------------------------------------------------------------------------
   *
   * @default undefined
   */
   addChar?: string;
-  /** ***Minimum length of the generated string (1 to 5000), defaultValue: `40`.***
+  /** -----------------------------------------------------------------------------------
+  * * ***Minimum length of the generated string (1 to 5000), defaultValue: `40`.***
+  * ------------------------------------------------------------------------------------
   *
   * @default 40
   */
   minLength?: number;
-  /** ***Maximum length of the generated string (1 to 5000), defaultValue: `40`.***
+  /** -----------------------------------------------------------------------------------
+  * * ***Maximum length of the generated string (1 to 5000), defaultValue: `40`.***
+  * ------------------------------------------------------------------------------------
   *
   * @default 40
   */
   maxLength?: number;
-  /** ***Type of output: `"string"` or `"number"`, defaultValue: `"string"`.***
+  /** -----------------------------------------------------------------------------------
+  * * ***Type of output: `"string"` or `"number"`, defaultValue: `"string"`.***
+  * ------------------------------------------------------------------------------------
   *
   * @default "string"
   */
   type?: "string" | "number";
 };
-/** ---------------------------------------------------------------------------------
+/** -----------------------------------------------------------------------------------
 * * ***Utility: `randomStr`.***
-* ---------------------------------------------------------------------------------
+* ------------------------------------------------------------------------------------
 * **Generates a random alphanumeric string or number with a specified length range.**
+*
+* ---
 * @description
 * This function allows you to generate random strings or numbers with fully
 * customizable options, such as length range, character sets, inclusion of
 * additional characters, and whether to avoid whitespace.
+*
+* ---
 * @param {OptionsRandomStr} [options] - Configuration options for generating the string.
 * @param {OptionsRandomStr["minLength"]} [options.minLength=40] - Minimum length of the generated string (must be `≥` `1`).
 * @param {OptionsRandomStr["maxLength"]} [options.maxLength=40] - Maximum length of the generated string (must be `≤` `5000`).
@@ -170,8 +227,14 @@ type OptionsRandomStr = {
 * @param {OptionsRandomStr["replaceGenStr"]} [options.replaceGenStr] - A custom character set to use when `type` is `"string"`.
 * @param {OptionsRandomStr["replaceGenInt"]} [options.replaceGenInt] - A custom character set to use when `type` is `"number"`.
 * @param {OptionsRandomStr["addChar"]} [options.addChar] - Additional characters to always include in the character set.
-* @returns {string} The randomly generated string or numeric string of the desired length.
+*
+* ---
 * @throws **{@link TypeError | `TypeError`}** if provided options are invalid (such as minLength > maxLength, invalid type, or empty character set).
+*
+* ---
+* @returns {string} The randomly generated string or numeric string of the desired length.
+*
+* ---
 * @example
 * randomStr();
 * // ➔ Generates a 40-character random alphanumeric string
@@ -185,42 +248,63 @@ type OptionsRandomStr = {
 * // ➔ Guaranteed to include !@# in the set
 */
 declare const randomStr: (options?: OptionsRandomStr) => string;
-/**
-* Configuration options for `randomUUID()`.
+/** ---------------------------------------------------------
+* * ***Configuration options for `randomUUID()`.***
+* ----------------------------------------------------------
 */
 type OptionsRandomUUID = {
-  /**
-  * Specifies which UUID version to generate.
+  /** ---------------------------------------------------------
+  * * ***Specifies which UUID version to generate.***
+  * ----------------------------------------------------------
   *
-  * - `"v4"` — Fully random UUID (RFC 4122). No timestamp, no ordering guarantees.
-  * - `"v7"` — Time-ordered UUID (RFC 9562). Uses Unix timestamp + randomness.
+  * - `"v4"` — Fully random UUID (RFC 4122), no timestamp, no ordering guarantees.
+  * - `"v7"` — Time-ordered UUID (RFC 9562), uses Unix timestamp + randomness.
   *
-  * @default "v4"
+  * ---
+  * @default
+  * ```ts
+  * "v4"
+  * ```
   *
+  * ---
   * @example
-  * // Random v4 UUID
-  * randomUUID({ version: "v4" }); // ➔ "3ec0de5a-b8a9-4ffb-a62a-fcc76851e9c2"
-  *
-  * @example
-  * // Time-ordered v7 UUID
-  * randomUUID({ version: "v7" }); // ➔ "0199f3f6-3c5e-744b-affa-46b2cfd496f8"
+  * 1. #### Random `v4` UUID:
+  *    ```ts
+  *    randomUUID({ version: "v4" });
+  *    // ➔ "xxxxxxxx-xxxx-4xxx-xxxx-xxxxxxxxxxxx"
+  *    ```
+  *    ---
+  * 2. #### Time-ordered `v7` UUID:
+  *    ```ts
+  *    randomUUID({ version: "v7" });
+  *    // ➔ "xxxxxxxx-xxxx-7xxx-xxxx-xxxxxxxxxxxx"
+  *    ```
   */
   version?: "v4" | "v7";
-  /**
-  * Enables monotonic sequencing for UUID v7.
+  /** ---------------------------------------------------------
+  * * ***Enables monotonic sequencing for UUID v7.***
+  *  ----------------------------------------------------------
   *
   * - Guarantees that multiple UUIDs generated within the same millisecond
   *   are strictly non-decreasing (lexicographically and timestamp-wise).
-  * - Only valid when `version === "v7"`. Using with `v4` will throw a `TypeError`.
+  * - Only valid when `version === "v7"`, using with `v4` will throw a `TypeError`.
   * - Useful for database inserts, logs, or any system where order matters.
   *
-  * @default false
+  * ---
+  * @default
+  * ```ts
+  * false
+  * ```
   *
+  * ---
   * @example
-  * // Monotonic v7 UUIDs
-  * const a = randomUUID({ version: "v7", monotonic: true });
-  * const b = randomUUID({ version: "v7", monotonic: true });
-  * console.log(a < b); // true, guaranteed
+  * - #### Monotonic `v7` UUIDs:
+  *   ```ts
+  *   const a = randomUUID({ version: "v7", monotonic: true });
+  *   const b = randomUUID({ version: "v7", monotonic: true });
+  *   console.log(a < b);
+  *   // ➔ true (guaranteed)
+  *   ```
   */
   monotonic?: boolean;
 };
@@ -229,112 +313,137 @@ type OptionsRandomUUID = {
 * ------------------------------------------------------------------------
 * **Generates a UUID string according to the specified version and options.**
 *
-* - **Supported versions**:
-*    - **`"v4"` (default)** ➔ Fully random UUID, RFC 4122 compliant.
-*        - Uses `crypto.randomUUID()` if available.
-*        - Falls back to `crypto.getRandomValues()` or `Math.random()`
-*          if needed.
-*    - **`"v7"`** ➔ Time-ordered UUID, RFC 9562 compliant.
-*        - Timestamp (Unix ms, 48 bits) + 80 bits randomness.
-*        - Good for database indexing / sorting.
-*    - **`"v7"` + `monotonic: true`** ➔ Ensures strictly non-decreasing UUIDs
-*      for multiple calls in the same millisecond (per-process).
-*
-* - **Behavior / Safety Notes**:
-*    - **v4**: Fully random; probability of duplicates is astronomically low.
-*    - **v7**: Time-ordered; collisions extremely unlikely unless same ms + random repeat.
-*    - **Monotonic v7**: Guaranteed ordering per-process if multiple UUIDs are generated
-*      in the same millisecond.
-*    - **All versions**: Fallback safely if `crypto` APIs are unavailable.
+* ---
+* - #### Supported versions:
+*     - #### **`"v4"` *(default)*** ➔ Fully random UUID, RFC 4122 compliant.
+*          - Uses `crypto.randomUUID()` if available.
+*          - Falls back to `crypto.getRandomValues()` or `Math.random()`
+*            if needed.
+*          ---
+*     - #### **`"v7"`** ➔ Time-ordered UUID, RFC 9562 compliant.
+*          - Timestamp (Unix ms, 48 bits) + 80 bits randomness.
+*          - Good for database indexing / sorting.
+*          ---
+*     - #### **`"v7"` + `monotonic: true`** ➔ Ensures strictly non-decreasing UUIDs
+*          for multiple calls in the same millisecond (per-process).
 *
+* ---
+* - #### Behavior / Safety Notes:
+*     - **v4**: Fully random; probability of duplicates is astronomically low.
+*     - **v7**: Time-ordered; collisions extremely unlikely unless same ms + random repeat.
+*     - **Monotonic v7**: Guaranteed ordering per-process if multiple UUIDs are generated
+*       in the same millisecond.
+*     - **All versions**: Fallback safely if `crypto` APIs are unavailable.
+*
+* ---
 * @param {object} [options] - Optional settings object.
 * @param {"v4" | "v7"} [options.version="v4"] - UUID version to generate.
-* @param {boolean} [options.monotonic=false] - For v7 only: generate monotonic UUIDs
+* @param {boolean} [options.monotonic=false] - ***For v7 only***, generate monotonic UUIDs
 *                                              to maintain strict lexicographic order
 *                                              when generating multiple UUIDs within the same ms.
 *
-* @returns {string} A 36-character UUID string compliant with the selected version.
-*
 * @throws **{@link TypeError | `TypeError`}** if:
-* - `options` is not a plain object.
 * - `options.version` is provided but not a string.
 * - `options.monotonic` is provided but not a boolean.
 * - `monotonic: true` is used with `version` other than `"v7"`.
-* @throws **{@link RangeError | `RangeError`}** if `options.version` is provided but not `"v4"` or `"v7"`.
-*
-* @example
-* // Default (v4)
-* const id = randomUUID();
-* // ➔ "3b12f1df-5232-4804-897e-917bf397618a"
 *
-* @example
-* // Explicit v4
-* const id4 = randomUUID({ version: "v4" });
-*
-* @example
-* // Time-ordered v7
-* const id7 = randomUUID({ version: "v7" });
-* // ➔ "018f48d2-84c1-7ccd-b5a3-2f9463b3a889"
-*
-* @example
-* // Monotonic v7
-* const a = randomUUID({ version: "v7", monotonic: true });
-* const b = randomUUID({ version: "v7", monotonic: true });
-* // a < b lexicographically (guaranteed)
+* ---
+* @returns {string} A 36-character UUID string compliant with the selected version.
 *
-* @example
-* // Throws TypeError
-* randomUUID("v4" as any); // options must be object
-* randomUUID({ version: 123 as any }); // version must be string
-* randomUUID({ version: "v4", monotonic: true } as any); // monotonic only for v7
+* @throws **{@link RangeError | `RangeError`}** if `options.version` is provided but not `"v4"` or `"v7"`.
 *
 * @example
-* // Throws RangeError
-* randomUUID({ version: "v1" as any }); // unsupported version
+* 1. #### Default (v4):
+*    ```ts
+*    const id = randomUUID();
+*    // ➔ "xxxxxxxx-xxxx-4xxx-xxxx-xxxxxxxxxxxx"
+*    ```
+*    ---
+* 2. #### Explicit `v4`:
+*    ```ts
+*    const id4 = randomUUID({ version: "v4" });
+*    // ➔ "xxxxxxxx-xxxx-4xxx-xxxx-xxxxxxxxxxxx"
+*    ```
+*    ---
+* 3. #### Time-ordered `v7`:
+*    ```ts
+*    const id7 = randomUUID({ version: "v7" });
+*    // ➔ "xxxxxxxx-xxxx-7xxx-xxxx-xxxxxxxxxxxx"
+*    ```
+*    ---
+* 4. #### Monotonic `v7`:
+*    ```ts
+*    const a = randomUUID({ version: "v7", monotonic: true });
+*    const b = randomUUID({ version: "v7", monotonic: true });
+*    // a < b lexicographically (guaranteed)
+*    ```
+* ---
+* - #### *Throws:*
+*      - #### `TypeError`:
+*        ```ts
+*        randomUUID({ version: 123 as any });
+*        // version must be string
+*        randomUUID({ version: "v4", monotonic: true } as any);
+*        // monotonic only for v7
+*        ```
+*        ---
+*      - #### `RangeError`:
+*        ```ts
+*        randomUUID({ version: "v1" as any });
+*        // unsupported version
+*        ```
 */
 declare function randomUUID(options?: OptionsRandomUUID): string;
-/**
-* --------------------------------------------------
+/** ------------------------------------------------------------------------------------
 * * ***Utility: `noop`.***
-* --------------------------------------------------
+* -------------------------------------------------------------------------------------
 * **A no-operation function that performs no action.**
 *
+* ---
 * @description
 * Commonly used as a **placeholder**, **default callback**, or **stub function**.
 *
+* ---
 * - **Behavior**:
-*    - Does not return any meaningful value (`void`).
-*    - Safely callable in any context without side effects.
+*     - Does not return any meaningful value (`void`).
+*     - Safely callable in any context without side effects.
 *
+* ---
 * @remarks
 * Although this function returns `void`, it implicitly results in `undefined`,
 * but the return value should never be relied upon.
 *
+* ---
 * @example
-* **1. Basic usage** — does nothing and returns undefined implicitly:
-* ```
-* import { noop } from "@rzl-zone/utils-js/generators";
+* 1.  #### **Basic usage** — does nothing and returns undefined implicitly:
+*     ```
+*     import { noop } from "@rzl-zone/utils-js/generators";
 *
-* noop(); // ➔ no effect (void)
-* ```
-* @example
-* **2. Using with type-checking helpers:**
-* ```ts
-* import { noop } from "@rzl-zone/utils-js/generators";
-* import { isFunction, isUndefined } from "@rzl-zone/utils-js/predicates";
-*
-* isFunction(noop);    // ➔ true  — `noop` is a function
-* isUndefined(noop()); // ➔ true  — calling `noop()` returns `undefined`
-* isFunction(noop());  // ➔ false — the return value is `undefined`, not a function
-* ```
-* @example
-* **3. As a default callback:**
-* ```ts
-* import { noop } from "@rzl-zone/utils-js/generators";
+*     noop();
+*     // ➔ no effect (void)
+*     ```
+*     ---
+* 2.  #### **Using with type-checking helpers:**
+*     ```ts
+*     import { noop } from "@rzl-zone/utils-js/generators";
+*     import { isFunction, isUndefined } from "@rzl-zone/utils-js/predicates";
+*
+*     isFunction(noop);
+*     // ➔ true (`noop` is a function)
+*     isUndefined(noop());
+*     // ➔ true (calling `noop()` returns `undefined`)
+*     isFunction(noop());
+*     // ➔ false (the return value is `undefined`, not a function)
+*     ```
+*     ---
+* 3.  #### **As a default callback:**
+*     ```ts
+*     import { noop } from "@rzl-zone/utils-js/generators";
 *
-* const callback = noop;
-* callback(); // ➔ no effect (void)
-* ```
+*     const callback = noop;
+*     callback();
+*     // ➔ no effect (void)
+*     ```
 */
 declare const noop: () => void;
 export { randomInt as a, randomIntByLength as i, randomUUID as n, getRandomItem as o, randomStr as r, noop as t };

package/dist/{isBigInt-f6yY2fAV.js → isBigInt-Cez32M69.js}

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.1-beta.0`
+*  Version: `3.14.0-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
@@ -11,4 +11,4 @@ const isBigInt = (value) => {
 	return typeof value === "bigint";
 };
 export { isBigInt as t };
-//# sourceMappingURL=isBigInt-f6yY2fAV.js.map
+//# sourceMappingURL=isBigInt-Cez32M69.js.map

package/dist/isBigInt-Cez32M69.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBigInt-Cez32M69.js","names":[],"sources":["../src/predicates/is/isBigInt.ts"],"sourcesContent":["/** ----------------------------------------------------------\n * * ***Type guard: `isBigInt`.***\n * -----------------------------------------------------------\n * **Checks if a value is of type **[`BigInt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt)**.**\n *\n * ---\n * - **Behavior:**\n *     - Uses `typeof value === \"bigint\"` for strict type checking.\n *     - Supports TypeScript type narrowing with `value is bigint`.\n *     - Returns `false` for `BigInt` object (object-wrapped), e.g:\n *       - `Object(BigInt(123))`.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if value is a primitive bigint.\n *\n * ---\n * @example\n * isBigInt(123n);\n * // ➔ true\n * isBigInt(BigInt(123));\n * // ➔ true\n * isBigInt(\"123\");\n * // ➔ false\n * isBigInt(Object(BigInt(1)));\n * // ➔ false\n */\nexport const isBigInt = (value: unknown): value is bigint => {\n  return typeof value === \"bigint\";\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,YAAY,UAAoC;CAC3D,OAAO,OAAO,UAAU;AAC1B"}

package/dist/{isBigInt-CqZNWVtI.cjs → isBigInt-YgpNKTbA.cjs}

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.1-beta.0`
+*  Version: `3.14.0-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
@@ -17,4 +17,4 @@ Object.defineProperty(exports, 'isBigInt', {
     return isBigInt;
   }
 });
-//# sourceMappingURL=isBigInt-CqZNWVtI.cjs.map
+//# sourceMappingURL=isBigInt-YgpNKTbA.cjs.map

package/dist/isBigInt-YgpNKTbA.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBigInt-YgpNKTbA.cjs","names":[],"sources":["../src/predicates/is/isBigInt.ts"],"sourcesContent":["/** ----------------------------------------------------------\n * * ***Type guard: `isBigInt`.***\n * -----------------------------------------------------------\n * **Checks if a value is of type **[`BigInt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt)**.**\n *\n * ---\n * - **Behavior:**\n *     - Uses `typeof value === \"bigint\"` for strict type checking.\n *     - Supports TypeScript type narrowing with `value is bigint`.\n *     - Returns `false` for `BigInt` object (object-wrapped), e.g:\n *       - `Object(BigInt(123))`.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if value is a primitive bigint.\n *\n * ---\n * @example\n * isBigInt(123n);\n * // ➔ true\n * isBigInt(BigInt(123));\n * // ➔ true\n * isBigInt(\"123\");\n * // ➔ false\n * isBigInt(Object(BigInt(1)));\n * // ➔ false\n */\nexport const isBigInt = (value: unknown): value is bigint => {\n  return typeof value === \"bigint\";\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,YAAY,UAAoC;CAC3D,OAAO,OAAO,UAAU;AAC1B"}

package/dist/{isEmptyString-Ga77_3Q1.js → isEmptyString-C9QLWjx2.js}

@@ -2,14 +2,14 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.1-beta.0`
+*  Version: `3.14.0-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { y as isNonEmptyString } from "./assertIsBoolean-DDhQ2D-k.js";
-const isEmptyString = (value, options = {}) => {
+import { w as isNonEmptyString } from "./logger-CLWnKRKE.js";
+const isEmptyString = (value, options) => {
 	return !isNonEmptyString(value, options);
 };
 export { isEmptyString as t };
-//# sourceMappingURL=isEmptyString-Ga77_3Q1.js.map
+//# sourceMappingURL=isEmptyString-C9QLWjx2.js.map

package/dist/isEmptyString-C9QLWjx2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEmptyString-C9QLWjx2.js","names":[],"sources":["../src/predicates/is/isEmptyString.ts"],"sourcesContent":["import { isNonEmptyString } from \"./isNonEmptyString\";\n\ntype IsEmptyStringOptions = {\n  /** ----------------------------------------------------------\n   * * ***Whether to trim leading and trailing whitespace before checking.***\n   * -----------------------------------------------------------\n   *\n   * @note\n   * Non-boolean values fall back to the default behavior.\n   *\n   * ---\n   * @default true\n   */\n  trim?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyString`.***\n * -----------------------------------------------------------\n * **Checks whether a given value is an **empty-string**.**\n *\n * ---\n * - **Behavior:**\n *     - Considers `\"\"` and whitespace-only strings as\n *       empty (if `trim` is enabled, which is the default).\n *     - Non-string inputs are also considered empty.\n *\n * ---\n * @param {*} value - The value to check.\n * @param {IsEmptyStringOptions} [options]\n *        Optional settings (non-plain object values are ignored and replaced with default options).\n * @param {IsEmptyStringOptions[\"trim\"]} [options.trim=true]\n *        If `true`, trims the string before checking (non-boolean values fall back to the default behavior), defaults: `true`.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is string not a string or value string is considered empty.\n *\n * ---\n * @example\n * isEmptyString(\"\");\n * // ➔ true\n * isEmptyString(\"   \");\n * // ➔ true (default trims)\n * isEmptyString(\"   \", { trim: false });\n * // ➔ false\n * isEmptyString(\"hello\");\n * // ➔ false\n * isEmptyString(undefined);\n * // ➔ true\n * isEmptyString(null);\n * // ➔ true\n * isEmptyString(123 as any);\n * // ➔ true\n *\n * // Used in validation\n * if (isEmptyString(form.name)) {\n *   throw new Error(\"Name cannot be empty.\");\n * }\n */\nexport const isEmptyString = (\n  value: unknown,\n  options?: IsEmptyStringOptions\n): boolean => {\n  return !isNonEmptyString(value, options);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,MAAa,iBACX,OACA,YACY;CACZ,OAAO,CAAC,iBAAiB,OAAO,OAAO;AACzC"}

package/dist/{isEmptyString-DNMPmS-H.cjs → isEmptyString-O4TFe1Ao.cjs}

@@ -2,15 +2,15 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.1-beta.0`
+*  Version: `3.14.0-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_assertIsBoolean = require('./assertIsBoolean-CEx4KbHg.cjs');
-const isEmptyString = (value, options = {}) => {
-	return !require_assertIsBoolean.isNonEmptyString(value, options);
+const require_logger = require('./logger-CUacYy3D.cjs');
+const isEmptyString = (value, options) => {
+	return !require_logger.isNonEmptyString(value, options);
 };
 Object.defineProperty(exports, 'isEmptyString', {
   enumerable: true,
@@ -18,4 +18,4 @@ Object.defineProperty(exports, 'isEmptyString', {
     return isEmptyString;
   }
 });
-//# sourceMappingURL=isEmptyString-DNMPmS-H.cjs.map
+//# sourceMappingURL=isEmptyString-O4TFe1Ao.cjs.map