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

package/dist/isPlainObject-Dr8gi89U.d.ts

@@ -0,0 +1,339 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.13.0-beta.2`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+
+import { IsNever, NonPlainObject } from "@rzl-zone/ts-types-plus";
+declare class PreciseType {
+  constructor(params?: GetPreciseTypeOptions);
+  /** ----------------------------------------------------------
+  * * ***Getting the internal map of type castable relationships used by {@link getPreciseType | `getPreciseType`}.***
+  * ----------------------------------------------------------
+  *
+  * - **Description:**
+  *    - Returns an internal static mapping table that defines which primitive or structural types
+  *      can be cast or interpreted as another related type within the internal logic of
+  *      {@link getPreciseType | `getPreciseType`}.
+  *
+  * - **⚠️ Internal:**
+  *    - This is an internal helper of {@link getPreciseType | `getPreciseType`}.
+  *    - Do not modify or rely on this table directly — it is **readonly** and may change without notice.
+  *
+  * @readonly
+  */
+  static get castableTable(): typeof PreciseType.FIXES_CASTABLE_TABLE;
+  /** ----------------------------------------------------------
+  * * ***Retrieves the internal list of special type cases handled by {@link getPreciseType | `getPreciseType`}.***
+  * ----------------------------------------------------------
+  *
+  * - **Description:**
+  *    - Returns an internal readonly list of specific type identifiers that require
+  *      *custom handling* during type detection.
+  *    - These are **exceptional values** or **edge cases** that don’t follow the normal
+  *      JavaScript type resolution flow.
+  *
+  * - **Example Values:**
+  *    - `"Infinity"`, `"-Infinity"`, `"NaN"`, `"undefined"`, etc.
+  *
+  * - **⚠️ Internal:**
+  *    - Used internally by {@link getPreciseType | `getPreciseType`}.
+  *    - This property is **readonly** and should not be modified directly.
+  *
+  * @readonly
+  */
+  static get specialType(): typeof this.SPECIAL_TYPE;
+  /** ----------------------------------------------------------
+  * * ***Retrieves the internal mapping of JavaScript built-in and environment-specific
+  * type identifiers to their canonical PascalCase names.***
+  * ----------------------------------------------------------
+  *
+  * - **Description:**
+  *    - Provides a mapping table where **keys** represent normalized raw type names
+  *      (as obtained from `Object.prototype.toString.call(value)` or environment checks),
+  *      and **values** represent their **canonical PascalCase equivalents**.
+  *    - This table ensures consistent, human-readable type strings across different environments.
+  *
+  * - **Example Mapping:**
+  *    ```ts
+  *      {
+  *        "[object Map]": "Map",
+  *        "[object WeakMap]": "WeakMap",
+  *        "[object AsyncFunction]": "AsyncFunction",
+  *        "[object GeneratorFunction]": "GeneratorFunction",
+  *        "[object BigInt]": "BigInt",
+  *      }
+  *    ```
+  *
+  * - **⚠️ Internal:**
+  *    - Used internally by {@link getPreciseType | `getPreciseType`}.
+  *    - This property is **readonly** and should not be modified directly.
+  *
+  * @readonly
+  */
+  static get fixesRaw(): typeof this.FIXES_RAW;
+  /** ----------------------------------------------------------
+  * * ***Retrieves the internal list of common acronyms that should remain fully uppercase during string formatting.***
+  * ----------------------------------------------------------
+  *
+  * - **Description:**
+  *    - This list defines acronyms (e.g., `"URL"`, `"HTTP"`, `"HTML"`, `"SVG"`, `"XML"`, `"DOM"`)
+  *      that will be **preserved in uppercase** when applying case transformations through
+  *      {@link getPreciseType | `getPreciseType`} or any formatting utility using it.
+  *    - Ensures consistency in output for technical identifiers that are conventionally capitalized.
+  *
+  * - **Example:**
+  *    ```ts
+  *      ["URL", "HTTP", "HTML", "SVG", "XML", "DOM"]
+  *    ```
+  *
+  * - **⚠️ Internal:**
+  *     - Used internally by {@link getPreciseType | `getPreciseType`}.
+  *     - This property is **readonly** and not intended for modification.
+  *
+  * @readonly
+  */
+  static get acronymsList(): typeof this.ACRONYMS;
+}
+/** ---------------------------------------------------------------------------
+* * ***Options for controlling how {@link getPreciseType | `getPreciseType`} formats and normalizes detected types.***
+* ---------------------------------------------------------------------------
+* These options customize the string transformation behavior and acronym handling
+* when converting JavaScript type names to human-readable strings.
+*/
+type GetPreciseTypeOptions = {
+  /** -------------------------------------------------------
+  * * ***Specifies the format in which the returned string type should be transformed.***
+  * -------------------------------------------------------
+  * **ℹ️ For special string literals in `SPECIAL_CASES` (`"-Infinity" | "Infinity" | "NaN"`), which will remain unchanged.**
+  * @default "toKebabCase"
+  * @description
+  * Supported formats:
+  * - `"toKebabCase"` (default) — words separated by hyphens.
+  *   - ➔ `"result-example-type"`
+  * - `"toLowerCase"` - converts all letters to lowercase.
+  *   - ➔ `"result example type"`
+  * - `"toDotCase"` — words separated by dots.
+  *   - ➔ `"result.example.type"`
+  * - `"toCamelCase"` — first word lowercase, subsequent words capitalized.
+  *   - ➔ `"resultExampleType"`
+  * - `"toSnakeCase"` — words separated by underscores.
+  *   - ➔ `"result_example_type"`
+  * - `"toPascalCase"` — all words capitalized, no spaces.
+  *   - ➔ `"ResultExampleType"`
+  * - `"toPascalCaseSpace"` — all words capitalized with spaces between words.
+  *   - ➔ `"Result Example Type"`
+  * - `"slugify"` — URL-friendly slug (lowercase with hyphens).
+  *   - ➔ `"result-example-type"`
+  * @note
+  * ⚠️ If an invalid value is provided, the function will automatically fallback to the default `"toKebabCase"`.
+  */
+  formatCase?: "toPascalCaseSpace" | "toPascalCase" | "toCamelCase" | "toKebabCase" | "toSnakeCase" | "toDotCase" | "slugify" | "toLowerCase";
+  /** -------------------------------------------------------
+  * * ***Control uppercase preservation of recognized acronyms during formatting.***
+  * -------------------------------------------------------
+  * When enabled (`true`), common technical acronyms (e.g., `"URL"`, `"HTTP"`, `"HTML"`, `"SVG"`, `"XML"`, `"DOM"`)
+  * are preserved in their original uppercase form instead of being lowercased or altered by case-formatting utilities.
+  *
+  *
+  * - **When `false` (default):**
+  *    - Acronyms are treated as normal words and formatted according to the selected `formatCase`.
+  *    - Example:
+  *      - `HTMLDivElement` ➔ `"html-div-element"` (with `"toKebabCase"`)
+  *      - `DOMParser` ➔ `"dom-parser"`
+  * - **When `true`:**
+  *    - Acronyms remain uppercase.
+  *    - Example:
+  *      - `HTMLDivElement` ➔ `"HTML-div-element"` (with `"toKebabCase"`)
+  *      - `DOMParser` ➔ `"DOM-parser"`
+  *
+  * @default false
+  * @description
+  * The list of recognized acronyms is defined in {@link AcronymsList | **`AcronymsList`**},
+  * including entries like `"URL"`, `"HTTP"`, `"HTML"`, `"SVG"`, `"XML"`, `"DOM"`, and others.
+  *
+  * ⚠️ This option affects **formatting output only**, not the underlying type detection, acronym preservation is applied **after** detecting and formatting the base type name.
+  */
+  useAcronyms?: boolean;
+};
+/** ---------------------------------------------------------------------------
+* * ***Type alias for the list of common acronyms preserved in uppercase.***
+* ---------------------------------------------------------------------------
+*
+* Use this type to reference the full set of recognized acronyms
+* used internally by the {@link getPreciseType | **`getPreciseType`**} function for formatting purposes.
+*/
+type AcronymsList = (typeof PreciseType)["acronymsList"];
+/** ----------------------------------------------------------
+* * ***Utility-Predicate: `getPreciseType`.***
+* ----------------------------------------------------------
+* **Returns a detailed and normalized type string for the given value.**
+* @description
+* The returned string is human-readable ***toKebabCase*** with spaces ***(by default)*** or formatted according to the `options.formatCase` setting.
+* - **Handles:**
+*    - Primitives (`string`, `number`, `boolean`, `null`, `undefined`, `symbol`, `bigint`)
+*    - Built-in objects (`Array`, `Map`, `Set`, `Error subclasses`, `Typed Arrays`, `etc`)
+*    - Objects created with `Object.create(null)`
+*    - Objects wrapper (`new String`, `new Number`, `new Boolean`)
+*    - DOM Node type (may not be fully accurate outside the browser environment)
+*    - Generator instances
+*    - Node.js `Buffer` instances
+*    - Proxy detection (returns `"Proxy"` if detected; detection ***is not 100% accurate***)
+*    - Uses cached mapping table (`FIXES_CASTABLE_TABLE`) for known types to provide consistent naming
+*    - Falls back to constructor name or `Object.prototype.toString` tag
+* @param {*} value - The value to detect the precise type of
+* @param {GetPreciseTypeOptions} [options] - Optional configuration
+* @param {GetPreciseTypeOptions["formatCase"]} [options.formatCase="toLowerCase"]
+*   Specifies how the returned type string should be formatted.
+*      - ⚠️ Special string literals in `SPECIAL_CASES`
+*        (`"-Infinity" | "Infinity" | "NaN"`) will remain
+*        unchanged even if a different `formatCase` is applied.
+* @param {boolean} [options.useAcronyms=false]
+*   Control uppercase preservation of recognized acronyms during formatting.
+*      - When `true`, recognized acronyms such as `"URL"`, `"HTTP"`, `"HTML"`, `"SVG"`, `"XML"`, and `"DOM"`
+*        are preserved in uppercase instead of being lowercased or otherwise transformed.
+*      - When `false` (default), acronyms are formatted like regular words according to `formatCase`.
+*      - ⚠️ This option affects **formatting output only**, not type detection.
+*
+* @returns {string} The normalized and formatted type string
+* @example
+* getPreciseType(123);     // ➔ "number"
+* getPreciseType(null);    // ➔ "null"
+* getPreciseType(/regex/); // ➔ "reg-exp"
+* getPreciseType(/regex/, { formatCase: "toPascalCase" });
+* // ➔ "RegExp"
+* getPreciseType(function* () {}, { formatCase: "toCamelCase" });
+* // ➔ "generatorFunction"
+* getPreciseType(async function () {}, { formatCase: "toPascalCaseSpace" });
+* // ➔ "Async Function"
+*
+* // (SPECIAL_CASES remain)
+* getPreciseType(NaN, { formatCase: "toLowerCase" });
+* // ➔ "NaN"
+* getPreciseType(Infinity, { formatCase: "toLowerCase" });
+* // ➔ "Infinity"
+* getPreciseType(-Infinity, { formatCase: "toLowerCase" });
+* // ➔ "-Infinity"
+*
+* // Acronym usage examples:
+* getPreciseType(new URL("https://example.com"));
+* // ➔ "url"
+* getPreciseType(new URL("https://example.com"), { useAcronyms: true });
+* // ➔ "URL"
+*
+* getPreciseType(new URLSearchParams, { formatCase: "toPascalCase" });
+* // ➔ "UrlSearchParams"
+* getPreciseType(new URLSearchParams, { formatCase: "toPascalCase", useAcronyms: true });
+* // ➔ "URLSearchParams"
+*/
+declare const getPreciseType: (value: unknown, options?: GetPreciseTypeOptions) => string;
+type IsNumberOptions = {
+  /** If set to `true`, `NaN` will be considered a valid number, defaultValue: `false`.
+  *
+  * @default false
+  */
+  includeNaN?: boolean;
+};
+/** ---------------------------------------------------------
+* * ***Type guard: `isNumber`.***
+* ----------------------------------------------------------
+* **Checks if a value is of type **`number`**.**
+* - **Behavior:**
+*    - Uses `typeof value === "number"`.
+*    - By default, excludes **`NaN`**.
+*    - If `options.includeNaN` is `true`, then **`NaN`** is also considered valid.
+*    - Still considers `Infinity` and `-Infinity` as **numbers** (consistent with JavaScript).
+* - **ℹ️ Note:**
+*    - To exclude `Infinity` and `-Infinity`, use **{@link isFinite | `isFinite`}** instead.
+* @param {*} value - The value to check.
+* @param {IsNumberOptions} [options] - Optional settings.
+* @param {boolean} [options.includeNaN=false]  If `true`, `NaN` will be considered a valid number, defaults to `false`, which excludes `NaN`.
+* @returns {boolean} Returns `true` if the value is a number (and depending on `includeNaN`, `NaN` is included or excluded).
+* @example
+* isNumber(42);
+* // ➔ true
+* isNumber(Infinity);
+* // ➔ true
+* isNumber(-Infinity);
+* // ➔ true
+* isNumber(NaN);
+* // ➔ false (default)
+* isNumber(NaN, { includeNaN: true });
+* // ➔ true
+* isNumber("42");
+* // ➔ false
+*/
+declare const isNumber: (value: unknown, options?: IsNumberOptions) => value is number;
+type ArrayFallback<T> = IsNever<Extract<T, unknown[] | readonly unknown[]>> extends true ? T & unknown[] : Extract<T, unknown[] | readonly unknown[]>;
+type IsHasKeysObject<T> = keyof T extends never ? false : true;
+/** ----------------------------------------------------------
+* * ***Utility type: `IsPlainObjectResult`.***
+* ----------------------------------------------------------
+* **Represents the inferred type after asserting a value is a **plain object**.**
+* - **Behavior:**
+*    - If `T` is `unknown`, the resulting type is `Record<PropertyKey, unknown> & T`.
+*    - If `T` is an object:
+*        - If it is a non-plain object (class instance, built-in object, etc.), the result is `never`.
+*        - If it has no keys (`IsHasKeysObject<T>` checked by **{@link IsHasKeysObject|`IsHasKeysObject`}** is false), the result is `Record<PropertyKey, unknown> & T`.
+*        - Otherwise, the result is `T` itself.
+*    - For any other types, the result is `never`.
+* @template T - The input type to be asserted as a plain object.
+* @example
+* ```ts
+* type A = IsPlainObjectResult<unknown>;
+* // ➔ Record<PropertyKey, unknown> & unknown
+* type B = IsPlainObjectResult<{}>;
+* // ➔ Record<PropertyKey, unknown> & {}
+* type C = IsPlainObjectResult<{ foo: string }>;
+* // ➔ { foo: string }
+* type D = IsPlainObjectResult<Date>;
+* // ➔ never
+* ```
+*/
+type IsPlainObjectResult<T> = unknown extends T ? Record<PropertyKey, unknown> & T : T extends object ? T extends NonPlainObject ? never : IsHasKeysObject<T> extends false ? Record<PropertyKey, unknown> & T : T : Extract<T, Record<PropertyKey, unknown>>;
+/** ----------------------------------------------------------
+* * ***Type guard: `isPlainObject`.***
+* ----------------------------------------------------------
+* **Checks if a value is a **plain-object**.**
+* - **A plain object is:**
+*    - Created by the `Object` constructor, or
+*    - Has a `[[Prototype]]` of `null` (e.g. `Object.create(null)`).
+* - **✅ Returns `true` for:**
+*    - Empty object literals: `{}`
+*    - Objects with null prototype: `Object.create(null)`
+* - **❌ Returns `false` for:**
+*    - Arrays (`[]`, `new Array()`)
+*    - Functions (regular, arrow, or class constructors)
+*    - Built-in objects: `Date`, `RegExp`, `Error`, `Map`, `Set`, `WeakMap`, `WeakSet`
+*    - Boxed primitives: `new String()`, `new Number()`, `new Boolean()`
+*    - `null` or `undefined`
+*    - Symbols
+*    - Class instances
+* @template T - The type of the value being checked.
+* @param {*} value - The value to check.
+* @returns {boolean} Return `true` if `value` is a `plain-object`, otherwise `false`.
+* @example
+* isPlainObject({});
+* // ➔ true
+* isPlainObject(Object.create(null));
+* // ➔ true
+* isPlainObject(null);
+* // ➔ false
+* isPlainObject(() => {});
+* // ➔ false
+* isPlainObject([1, 2, 3]);
+* // ➔ false
+* isPlainObject(new Date());
+* // ➔ false
+* isPlainObject(new MyClass());
+* // ➔ false
+* isPlainObject(new String("x"));
+* // ➔ false
+*/
+declare function isPlainObject<T>(value: T): value is IsPlainObjectResult<T>;
+declare function isPlainObject<T>(value: T): value is NonNullable<Extract<T, Record<PropertyKey, unknown>>>;
+export { IsNumberOptions as a, GetPreciseTypeOptions as c, ArrayFallback as i, getPreciseType as l, isPlainObject as n, isNumber as o, IsHasKeysObject as r, AcronymsList as s, IsPlainObjectResult as t };

package/dist/{isServer-D1TXfOs3.js → isServer-BDShLyVJ.js}

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
+*  Version: `3.13.0-beta.2`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
@@ -11,4 +11,4 @@ const isServer = () => {
 	return typeof window === "undefined" || typeof document === "undefined";
 };
 export { isServer as t };
-//# sourceMappingURL=isServer-D1TXfOs3.js.map
+//# sourceMappingURL=isServer-BDShLyVJ.js.map

package/dist/{isServer-D1TXfOs3.js.map → isServer-BDShLyVJ.js.map}

@@ -1 +1 @@
-{"version":3,"file":"isServer-D1TXfOs3.js","names":[],"sources":["../src/predicates/is/isServer.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Environment Predicate: `isServer`.***\n * ---------------------------------------------------------\n * **Detects whether the current code is executing in a\n * **non-browser JavaScript runtime** (server-side) rather\n * than in a web browser.**\n * @description\n * It simply checks for the absence of key browser globals like\n * [**`window`**](https://developer.mozilla.org/docs/Web/API/Window/window) and\n * [**`document`**](https://developer.mozilla.org/docs/Web/API/Window/document).\n *  - *If those globals aren’t present, we treat the runtime as a server environment.*\n * @returns {boolean}\n *  * ***true**  – Code is executing on the `server`.*\n *  * ***false** – Code is executing in a `browser`.*\n * @example\n * if (isServer()) {\n *   console.log(\"Running on a server-side runtime\");\n * } else {\n *   console.log(\"Running in a browser\");\n * }\n */\nexport const isServer = (): boolean => {\n  return typeof window === \"undefined\" || typeof document === \"undefined\";\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAA0B;CACrC,OAAO,OAAO,WAAW,eAAe,OAAO,aAAa"}
+{"version":3,"file":"isServer-BDShLyVJ.js","names":[],"sources":["../src/predicates/is/isServer.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Environment Predicate: `isServer`.***\n * ---------------------------------------------------------\n * **Detects whether the current code is executing in a\n * **non-browser JavaScript runtime** (server-side) rather\n * than in a web browser.**\n * @description\n * It simply checks for the absence of key browser globals like\n * [**`window`**](https://developer.mozilla.org/docs/Web/API/Window/window) and\n * [**`document`**](https://developer.mozilla.org/docs/Web/API/Window/document).\n *  - *If those globals aren’t present, we treat the runtime as a server environment.*\n * @returns {boolean}\n *  * ***true**  – Code is executing on the `server`.*\n *  * ***false** – Code is executing in a `browser`.*\n * @example\n * if (isServer()) {\n *   console.log(\"Running on a server-side runtime\");\n * } else {\n *   console.log(\"Running in a browser\");\n * }\n */\nexport const isServer = (): boolean => {\n  return typeof window === \"undefined\" || typeof document === \"undefined\";\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAA0B;CACrC,OAAO,OAAO,WAAW,eAAe,OAAO,aAAa"}

package/dist/{isServer-q-QLFCqE.cjs → isServer-BzDeYuGg.cjs}

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
+*  Version: `3.13.0-beta.2`
 *  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, 'isServer', {
     return isServer;
   }
 });
-//# sourceMappingURL=isServer-q-QLFCqE.cjs.map
+//# sourceMappingURL=isServer-BzDeYuGg.cjs.map

package/dist/{isServer-q-QLFCqE.cjs.map → isServer-BzDeYuGg.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"isServer-q-QLFCqE.cjs","names":[],"sources":["../src/predicates/is/isServer.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Environment Predicate: `isServer`.***\n * ---------------------------------------------------------\n * **Detects whether the current code is executing in a\n * **non-browser JavaScript runtime** (server-side) rather\n * than in a web browser.**\n * @description\n * It simply checks for the absence of key browser globals like\n * [**`window`**](https://developer.mozilla.org/docs/Web/API/Window/window) and\n * [**`document`**](https://developer.mozilla.org/docs/Web/API/Window/document).\n *  - *If those globals aren’t present, we treat the runtime as a server environment.*\n * @returns {boolean}\n *  * ***true**  – Code is executing on the `server`.*\n *  * ***false** – Code is executing in a `browser`.*\n * @example\n * if (isServer()) {\n *   console.log(\"Running on a server-side runtime\");\n * } else {\n *   console.log(\"Running in a browser\");\n * }\n */\nexport const isServer = (): boolean => {\n  return typeof window === \"undefined\" || typeof document === \"undefined\";\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAA0B;CACrC,OAAO,OAAO,WAAW,eAAe,OAAO,aAAa"}
+{"version":3,"file":"isServer-BzDeYuGg.cjs","names":[],"sources":["../src/predicates/is/isServer.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Environment Predicate: `isServer`.***\n * ---------------------------------------------------------\n * **Detects whether the current code is executing in a\n * **non-browser JavaScript runtime** (server-side) rather\n * than in a web browser.**\n * @description\n * It simply checks for the absence of key browser globals like\n * [**`window`**](https://developer.mozilla.org/docs/Web/API/Window/window) and\n * [**`document`**](https://developer.mozilla.org/docs/Web/API/Window/document).\n *  - *If those globals aren’t present, we treat the runtime as a server environment.*\n * @returns {boolean}\n *  * ***true**  – Code is executing on the `server`.*\n *  * ***false** – Code is executing in a `browser`.*\n * @example\n * if (isServer()) {\n *   console.log(\"Running on a server-side runtime\");\n * } else {\n *   console.log(\"Running in a browser\");\n * }\n */\nexport const isServer = (): boolean => {\n  return typeof window === \"undefined\" || typeof document === \"undefined\";\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAA0B;CACrC,OAAO,OAAO,WAAW,eAAe,OAAO,aAAa"}

package/dist/{isTypedArray-DiCoqffZ.cjs → isTypedArray-DaYAkyrt.cjs}

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
+*  Version: `3.13.0-beta.2`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_isEmptyValue = require('./isEmptyValue-DMSMFTU8.cjs');
+const require_isEmptyValue = require('./isEmptyValue-Cw6ovu7z.cjs');
 const isNonEmptyValue = (value, options = {}) => {
 	return !require_isEmptyValue.isEmptyValue(value, options);
 };
@@ -40,4 +40,4 @@ Object.defineProperty(exports, 'isTypedArray', {
     return isTypedArray;
   }
 });
-//# sourceMappingURL=isTypedArray-DiCoqffZ.cjs.map
+//# sourceMappingURL=isTypedArray-DaYAkyrt.cjs.map

package/dist/{isTypedArray-DiCoqffZ.cjs.map → isTypedArray-DaYAkyrt.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"isTypedArray-DiCoqffZ.cjs","names":["isEmptyValue"],"sources":["../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.ts"],"sourcesContent":["import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** Whether to check symbol properties when checking empty objects, default: `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicated: `isNonEmptyValue`.***\n * ----------------------------------------------------------\n * **Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items) or generally truthy.**\n * - **Behavior:**\n *    - Returns `true` for:\n *      - Objects **with properties**\n *      - Arrays **with items**\n *      - Non-empty, non-whitespace strings\n *      - Numbers (except `NaN`, includes `0`)\n *      - Functions\n *      - `true`\n *    - Returns `false` for:\n *      - Empty objects (`{}`)\n *      - Empty arrays (`[]`)\n *      - `null` or `undefined`\n *      - Empty strings (`\"\"`) or whitespace-only strings (`\"  \"`)\n *      - `false`\n *      - `NaN`\n *    - Safely handles `null`, `undefined`, and non-object types without throwing.\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n * @example\n * isNonEmptyValue({});\n * // ➔ false\n * isNonEmptyValue([]);\n * // ➔ false\n * isNonEmptyValue({ key: \"value\" });\n * // ➔ true\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: false });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: true });\n * // ➔ true\n * isNonEmptyValue([1, 2, 3]);\n * // ➔ true\n * isNonEmptyValue(NaN);\n * // ➔ false\n * isNonEmptyValue(true);\n * // ➔ true\n * isNonEmptyValue(false);\n * // ➔ false\n * isNonEmptyValue(null);\n * // ➔ false\n * isNonEmptyValue(undefined);\n * // ➔ false\n * isNonEmptyValue(\"\");\n * // ➔ false\n * isNonEmptyValue(\"   \");\n * // ➔ false\n * isNonEmptyValue(0);\n * // ➔ true\n * isNonEmptyValue(-1);\n * // ➔ true\n * isNonEmptyValue(2);\n * // ➔ true\n * isNonEmptyValue(() => {});\n * // ➔ true\n */\nexport const isNonEmptyValue = (\n  value: unknown,\n  options: IsNonEmptyValueOptions = {}\n): boolean => {\n  return !isEmptyValue(value, options);\n};\n","import type { TypedArray } from \"@rzl-zone/ts-types-plus\";\n\nconst typedArrayTags = new Set([\n  \"[object Int8Array]\",\n  \"[object Uint8Array]\",\n  \"[object Uint8ClampedArray]\",\n  \"[object Int16Array]\",\n  \"[object Uint16Array]\",\n  \"[object Int32Array]\",\n  \"[object Uint32Array]\",\n  \"[object Float32Array]\",\n  \"[object Float64Array]\",\n  \"[object BigInt64Array]\",\n  \"[object BigUint64Array]\"\n]);\n\n/** --------------------------------------------------\n * * ***Type guard: `isTypedArray`.***\n * ----------------------------------------------------------\n * **Checks if `value` is classified as a\n * **[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.**\n * - **Behavior:**\n *    - Validates that `value` is a non-null object.\n *    - Uses `Object.prototype.toString` tag matching against known typed array tags.\n *    - Narrows type to **{@link TypedArray | `TypedArray`}** when true.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n * @example\n * isTypedArray(new Uint8Array);          // ➔ true\n * isTypedArray(new Uint8Array());        // ➔ true\n * isTypedArray(new Float32Array());      // ➔ true\n * isTypedArray(new Uint8ClampedArray()); // ➔ true\n * isTypedArray([]);                      // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));       // ➔ false\n */\nexport function isTypedArray(value: unknown): value is TypedArray {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    typedArrayTags.has(Object.prototype.toString.call(value))\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAa,mBACX,OACA,UAAkC,EAAE,KACxB;CACZ,OAAO,CAACA,kCAAa,OAAO,QAAQ;;;;;ACzEtC,MAAM,iBAAiB,IAAI,IAAI;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,SAAgB,aAAa,OAAqC;CAChE,OACE,SAAS,QACT,OAAO,UAAU,YACjB,eAAe,IAAI,OAAO,UAAU,SAAS,KAAK,MAAM,CAAC"}
+{"version":3,"file":"isTypedArray-DaYAkyrt.cjs","names":["isEmptyValue"],"sources":["../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.ts"],"sourcesContent":["import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** Whether to check symbol properties when checking empty objects, default: `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicated: `isNonEmptyValue`.***\n * ----------------------------------------------------------\n * **Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items) or generally truthy.**\n * - **Behavior:**\n *    - Returns `true` for:\n *      - Objects **with properties**\n *      - Arrays **with items**\n *      - Non-empty, non-whitespace strings\n *      - Numbers (except `NaN`, includes `0`)\n *      - Functions\n *      - `true`\n *    - Returns `false` for:\n *      - Empty objects (`{}`)\n *      - Empty arrays (`[]`)\n *      - `null` or `undefined`\n *      - Empty strings (`\"\"`) or whitespace-only strings (`\"  \"`)\n *      - `false`\n *      - `NaN`\n *    - Safely handles `null`, `undefined`, and non-object types without throwing.\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n * @example\n * isNonEmptyValue({});\n * // ➔ false\n * isNonEmptyValue([]);\n * // ➔ false\n * isNonEmptyValue({ key: \"value\" });\n * // ➔ true\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: false });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: true });\n * // ➔ true\n * isNonEmptyValue([1, 2, 3]);\n * // ➔ true\n * isNonEmptyValue(NaN);\n * // ➔ false\n * isNonEmptyValue(true);\n * // ➔ true\n * isNonEmptyValue(false);\n * // ➔ false\n * isNonEmptyValue(null);\n * // ➔ false\n * isNonEmptyValue(undefined);\n * // ➔ false\n * isNonEmptyValue(\"\");\n * // ➔ false\n * isNonEmptyValue(\"   \");\n * // ➔ false\n * isNonEmptyValue(0);\n * // ➔ true\n * isNonEmptyValue(-1);\n * // ➔ true\n * isNonEmptyValue(2);\n * // ➔ true\n * isNonEmptyValue(() => {});\n * // ➔ true\n */\nexport const isNonEmptyValue = (\n  value: unknown,\n  options: IsNonEmptyValueOptions = {}\n): boolean => {\n  return !isEmptyValue(value, options);\n};\n","import type { TypedArray } from \"@rzl-zone/ts-types-plus\";\n\nconst typedArrayTags = new Set([\n  \"[object Int8Array]\",\n  \"[object Uint8Array]\",\n  \"[object Uint8ClampedArray]\",\n  \"[object Int16Array]\",\n  \"[object Uint16Array]\",\n  \"[object Int32Array]\",\n  \"[object Uint32Array]\",\n  \"[object Float32Array]\",\n  \"[object Float64Array]\",\n  \"[object BigInt64Array]\",\n  \"[object BigUint64Array]\"\n]);\n\n/** --------------------------------------------------\n * * ***Type guard: `isTypedArray`.***\n * ----------------------------------------------------------\n * **Checks if `value` is classified as a\n * **[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.**\n * - **Behavior:**\n *    - Validates that `value` is a non-null object.\n *    - Uses `Object.prototype.toString` tag matching against known typed array tags.\n *    - Narrows type to **{@link TypedArray | `TypedArray`}** when true.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n * @example\n * isTypedArray(new Uint8Array);          // ➔ true\n * isTypedArray(new Uint8Array());        // ➔ true\n * isTypedArray(new Float32Array());      // ➔ true\n * isTypedArray(new Uint8ClampedArray()); // ➔ true\n * isTypedArray([]);                      // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));       // ➔ false\n */\nexport function isTypedArray(value: unknown): value is TypedArray {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    typedArrayTags.has(Object.prototype.toString.call(value))\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAa,mBACX,OACA,UAAkC,EAAE,KACxB;CACZ,OAAO,CAACA,kCAAa,OAAO,QAAQ;;;;;ACzEtC,MAAM,iBAAiB,IAAI,IAAI;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,SAAgB,aAAa,OAAqC;CAChE,OACE,SAAS,QACT,OAAO,UAAU,YACjB,eAAe,IAAI,OAAO,UAAU,SAAS,KAAK,MAAM,CAAC"}

package/dist/{isTypedArray-47R0wdrc.js → isTypedArray-DuUUA4CL.js}

@@ -2,12 +2,12 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
+*  Version: `3.13.0-beta.2`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { t as isEmptyValue } from "./isEmptyValue-fjnfQnt5.js";
+import { t as isEmptyValue } from "./isEmptyValue-aGyeClwA.js";
 const isNonEmptyValue = (value, options = {}) => {
 	return !isEmptyValue(value, options);
 };
@@ -28,4 +28,4 @@ function isTypedArray(value) {
 	return value != null && typeof value === "object" && typedArrayTags.has(Object.prototype.toString.call(value));
 }
 export { isNonEmptyValue as n, isTypedArray as t };
-//# sourceMappingURL=isTypedArray-47R0wdrc.js.map
+//# sourceMappingURL=isTypedArray-DuUUA4CL.js.map

package/dist/{isTypedArray-47R0wdrc.js.map → isTypedArray-DuUUA4CL.js.map}

@@ -1 +1 @@
-{"version":3,"file":"isTypedArray-47R0wdrc.js","names":[],"sources":["../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.ts"],"sourcesContent":["import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** Whether to check symbol properties when checking empty objects, default: `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicated: `isNonEmptyValue`.***\n * ----------------------------------------------------------\n * **Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items) or generally truthy.**\n * - **Behavior:**\n *    - Returns `true` for:\n *      - Objects **with properties**\n *      - Arrays **with items**\n *      - Non-empty, non-whitespace strings\n *      - Numbers (except `NaN`, includes `0`)\n *      - Functions\n *      - `true`\n *    - Returns `false` for:\n *      - Empty objects (`{}`)\n *      - Empty arrays (`[]`)\n *      - `null` or `undefined`\n *      - Empty strings (`\"\"`) or whitespace-only strings (`\"  \"`)\n *      - `false`\n *      - `NaN`\n *    - Safely handles `null`, `undefined`, and non-object types without throwing.\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n * @example\n * isNonEmptyValue({});\n * // ➔ false\n * isNonEmptyValue([]);\n * // ➔ false\n * isNonEmptyValue({ key: \"value\" });\n * // ➔ true\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: false });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: true });\n * // ➔ true\n * isNonEmptyValue([1, 2, 3]);\n * // ➔ true\n * isNonEmptyValue(NaN);\n * // ➔ false\n * isNonEmptyValue(true);\n * // ➔ true\n * isNonEmptyValue(false);\n * // ➔ false\n * isNonEmptyValue(null);\n * // ➔ false\n * isNonEmptyValue(undefined);\n * // ➔ false\n * isNonEmptyValue(\"\");\n * // ➔ false\n * isNonEmptyValue(\"   \");\n * // ➔ false\n * isNonEmptyValue(0);\n * // ➔ true\n * isNonEmptyValue(-1);\n * // ➔ true\n * isNonEmptyValue(2);\n * // ➔ true\n * isNonEmptyValue(() => {});\n * // ➔ true\n */\nexport const isNonEmptyValue = (\n  value: unknown,\n  options: IsNonEmptyValueOptions = {}\n): boolean => {\n  return !isEmptyValue(value, options);\n};\n","import type { TypedArray } from \"@rzl-zone/ts-types-plus\";\n\nconst typedArrayTags = new Set([\n  \"[object Int8Array]\",\n  \"[object Uint8Array]\",\n  \"[object Uint8ClampedArray]\",\n  \"[object Int16Array]\",\n  \"[object Uint16Array]\",\n  \"[object Int32Array]\",\n  \"[object Uint32Array]\",\n  \"[object Float32Array]\",\n  \"[object Float64Array]\",\n  \"[object BigInt64Array]\",\n  \"[object BigUint64Array]\"\n]);\n\n/** --------------------------------------------------\n * * ***Type guard: `isTypedArray`.***\n * ----------------------------------------------------------\n * **Checks if `value` is classified as a\n * **[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.**\n * - **Behavior:**\n *    - Validates that `value` is a non-null object.\n *    - Uses `Object.prototype.toString` tag matching against known typed array tags.\n *    - Narrows type to **{@link TypedArray | `TypedArray`}** when true.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n * @example\n * isTypedArray(new Uint8Array);          // ➔ true\n * isTypedArray(new Uint8Array());        // ➔ true\n * isTypedArray(new Float32Array());      // ➔ true\n * isTypedArray(new Uint8ClampedArray()); // ➔ true\n * isTypedArray([]);                      // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));       // ➔ false\n */\nexport function isTypedArray(value: unknown): value is TypedArray {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    typedArrayTags.has(Object.prototype.toString.call(value))\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAa,mBACX,OACA,UAAkC,EAAE,KACxB;CACZ,OAAO,CAAC,aAAa,OAAO,QAAQ;;;;;ACzEtC,MAAM,iBAAiB,IAAI,IAAI;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,SAAgB,aAAa,OAAqC;CAChE,OACE,SAAS,QACT,OAAO,UAAU,YACjB,eAAe,IAAI,OAAO,UAAU,SAAS,KAAK,MAAM,CAAC"}
+{"version":3,"file":"isTypedArray-DuUUA4CL.js","names":[],"sources":["../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.ts"],"sourcesContent":["import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** Whether to check symbol properties when checking empty objects, default: `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicated: `isNonEmptyValue`.***\n * ----------------------------------------------------------\n * **Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items) or generally truthy.**\n * - **Behavior:**\n *    - Returns `true` for:\n *      - Objects **with properties**\n *      - Arrays **with items**\n *      - Non-empty, non-whitespace strings\n *      - Numbers (except `NaN`, includes `0`)\n *      - Functions\n *      - `true`\n *    - Returns `false` for:\n *      - Empty objects (`{}`)\n *      - Empty arrays (`[]`)\n *      - `null` or `undefined`\n *      - Empty strings (`\"\"`) or whitespace-only strings (`\"  \"`)\n *      - `false`\n *      - `NaN`\n *    - Safely handles `null`, `undefined`, and non-object types without throwing.\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n * @example\n * isNonEmptyValue({});\n * // ➔ false\n * isNonEmptyValue([]);\n * // ➔ false\n * isNonEmptyValue({ key: \"value\" });\n * // ➔ true\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: false });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: true });\n * // ➔ true\n * isNonEmptyValue([1, 2, 3]);\n * // ➔ true\n * isNonEmptyValue(NaN);\n * // ➔ false\n * isNonEmptyValue(true);\n * // ➔ true\n * isNonEmptyValue(false);\n * // ➔ false\n * isNonEmptyValue(null);\n * // ➔ false\n * isNonEmptyValue(undefined);\n * // ➔ false\n * isNonEmptyValue(\"\");\n * // ➔ false\n * isNonEmptyValue(\"   \");\n * // ➔ false\n * isNonEmptyValue(0);\n * // ➔ true\n * isNonEmptyValue(-1);\n * // ➔ true\n * isNonEmptyValue(2);\n * // ➔ true\n * isNonEmptyValue(() => {});\n * // ➔ true\n */\nexport const isNonEmptyValue = (\n  value: unknown,\n  options: IsNonEmptyValueOptions = {}\n): boolean => {\n  return !isEmptyValue(value, options);\n};\n","import type { TypedArray } from \"@rzl-zone/ts-types-plus\";\n\nconst typedArrayTags = new Set([\n  \"[object Int8Array]\",\n  \"[object Uint8Array]\",\n  \"[object Uint8ClampedArray]\",\n  \"[object Int16Array]\",\n  \"[object Uint16Array]\",\n  \"[object Int32Array]\",\n  \"[object Uint32Array]\",\n  \"[object Float32Array]\",\n  \"[object Float64Array]\",\n  \"[object BigInt64Array]\",\n  \"[object BigUint64Array]\"\n]);\n\n/** --------------------------------------------------\n * * ***Type guard: `isTypedArray`.***\n * ----------------------------------------------------------\n * **Checks if `value` is classified as a\n * **[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.**\n * - **Behavior:**\n *    - Validates that `value` is a non-null object.\n *    - Uses `Object.prototype.toString` tag matching against known typed array tags.\n *    - Narrows type to **{@link TypedArray | `TypedArray`}** when true.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n * @example\n * isTypedArray(new Uint8Array);          // ➔ true\n * isTypedArray(new Uint8Array());        // ➔ true\n * isTypedArray(new Float32Array());      // ➔ true\n * isTypedArray(new Uint8ClampedArray()); // ➔ true\n * isTypedArray([]);                      // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));       // ➔ false\n */\nexport function isTypedArray(value: unknown): value is TypedArray {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    typedArrayTags.has(Object.prototype.toString.call(value))\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAa,mBACX,OACA,UAAkC,EAAE,KACxB;CACZ,OAAO,CAAC,aAAa,OAAO,QAAQ;;;;;ACzEtC,MAAM,iBAAiB,IAAI,IAAI;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,SAAgB,aAAa,OAAqC;CAChE,OACE,SAAS,QACT,OAAO,UAAU,YACjB,eAAe,IAAI,OAAO,UAAU,SAAS,KAAK,MAAM,CAAC"}

package/dist/{isValidDomain-BSXshgkC.cjs → isValidDomain-BxyToAlh.cjs}

@@ -2,15 +2,62 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
+*  Version: `3.13.0-beta.2`
 *  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-DozdtbNi.cjs');
-const require_safeStableStringify = require('./safeStableStringify-Cc62pfRp.cjs');
-const require_punyCode = require('./punyCode-CTWXVVFo.cjs');
+const require_assertIsBoolean = require('./assertIsBoolean-amRiJHnh.cjs');
+const require_safeStableStringify = require('./safeStableStringify-DRYQ56Dg.cjs');
+const require_punyCode = require('./punyCode-DmTsB7q_.cjs');
+const isURL = (value) => {
+	return value instanceof URL;
+};
+/*!
+* ========================================================================
+*  @rzl-zone/build-tools
+* ------------------------------------------------------------------------
+*  Version: `0.0.12-beta.0`
+*  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`
+* ========================================================================
+*/
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isObject(value) {
+	return typeof value === "object" && !isNil(value) && !isArray(value);
+}
+const isNil = (value) => {
+	return value == null;
+};
+const isFunction = (value) => {
+	return typeof value === "function";
+};
+const hasGlobalRequire = (value) => isObject(value) && isFunction(value.require);
+const getRuntimeRequire = () => {
+	if (!hasGlobalRequire(globalThis)) return void 0;
+	return globalThis.require;
+};
+const __runtimeRequire = ((x) => {
+	const r = getRuntimeRequire();
+	if (r) return r;
+	if (typeof Proxy !== "undefined") return new Proxy(x, { get(target, prop) {
+		const r2 = getRuntimeRequire();
+		return r2 ? r2[prop] : target[prop];
+	} });
+	return x;
+})(function(id) {
+	const r = getRuntimeRequire();
+	if (r) return r.call(this, id);
+	throw new Error(`Calling \`require\` for "${id}" in an environment that doesn't expose the \`require\` function.`);
+});
+const NEWLINE = atob("Cg==");
+const EOL = hasGlobalRequire(globalThis) ? __runtimeRequire("node:os").EOL : NEWLINE;
+function joinLines(...text) {
+	return text.filter(Boolean).join(EOL);
+}
 var sldMap_default = {
 	"com.ac": true,
 	"net.ac": true,
@@ -1719,9 +1766,10 @@ function isValidDomain(value, options = {}) {
 		allowLocalhost
 	}).filter(([, value]) => !require_assertIsBoolean.isBoolean(value));
 	if (invalid.length) {
-		const msg = invalid.map(([key, value], i) => `   ${i + 1}. option: "${key}"\n      expected: boolean
-      received: ${require_assertIsBoolean.getPreciseType(value)} (${require_safeStableStringify.safeStableStringify(value, { keepUndefined: true })})`).join("\n");
-		throw new TypeError(`\n> Invalid options detected in second parameter of \`isValidDomain\`:\n${msg}`);
+		const msg = invalid.map(([key, value], i) => {
+			return joinLines(`   ${i + 1}. option: "${key}"`, "      expected: boolean", `      received: ${require_assertIsBoolean.getPreciseType(value)} (${require_safeStableStringify.safeStableStringify(value, { keepUndefined: true })})`);
+		}).join(EOL);
+		throw new TypeError(joinLines("", "> Invalid options detected in second parameter of `isValidDomain`:", msg));
 	}
 	let _value = value.toLowerCase();
 	if (allowProtocol) try {
@@ -1779,10 +1827,28 @@ function isValidDomain(value, options = {}) {
 		return validLabelChars.test(label) && label.length < 64 && !label.startsWith("-") && !label.endsWith("-");
 	});
 }
+Object.defineProperty(exports, 'EOL', {
+  enumerable: true,
+  get: function () {
+    return EOL;
+  }
+});
+Object.defineProperty(exports, 'isURL', {
+  enumerable: true,
+  get: function () {
+    return isURL;
+  }
+});
 Object.defineProperty(exports, 'isValidDomain', {
   enumerable: true,
   get: function () {
     return isValidDomain;
   }
 });
-//# sourceMappingURL=isValidDomain-BSXshgkC.cjs.map
+Object.defineProperty(exports, 'joinLines', {
+  enumerable: true,
+  get: function () {
+    return joinLines;
+  }
+});
+//# sourceMappingURL=isValidDomain-BxyToAlh.cjs.map