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

package/dist/isPlainObject-doTI11Ib.d.cts

@@ -1,530 +0,0 @@
-/*!
-* ========================================================================
-*  @rzl-zone/utils-js
-* ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
-*  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(): Readonly<Record<string, string>>;
-  /** ----------------------------------------------------------
-   * * ***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(): readonly ["-Infinity", "Infinity", "NaN"];
-  /** ----------------------------------------------------------
-   * * ***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(): Readonly<{
-    readonly string: "String";
-    readonly number: "Number";
-    readonly boolean: "Boolean";
-    readonly bigint: "Bigint";
-    readonly symbol: "Symbol";
-    readonly undefined: "Undefined";
-    readonly null: "Null";
-    readonly regexp: "Reg Exp";
-    readonly reflect: "Reflect";
-    readonly proxy: "Proxy";
-    readonly atomics: "Atomics";
-    readonly array: "Array";
-    readonly object: "Object";
-    readonly function: "Function";
-    readonly arguments: "Arguments";
-    readonly asyncfunction: "Async Function";
-    readonly generatorfunction: "Generator Function";
-    readonly asyncgeneratorfunction: "Async Generator Function";
-    readonly generator: "Generator";
-    readonly promise: "Promise";
-    readonly evalerror: "Eval Error";
-    readonly rangeerror: "Range Error";
-    readonly referenceerror: "Reference Error";
-    readonly syntaxerror: "Syntax Error";
-    readonly typeerror: "Type Error";
-    readonly urierror: "URI Error";
-    readonly aggregateerror: "Aggregate Error";
-    readonly error: "Error";
-    readonly int8array: "Int 8 Array";
-    readonly uint8array: "Uint 8 Array";
-    readonly uint8clampedarray: "Uint 8 Clamped Array";
-    readonly int16array: "Int 16 Array";
-    readonly uint16array: "Uint 16 Array";
-    readonly int32array: "Int 32 Array";
-    readonly uint32array: "Uint 32 Array";
-    readonly float32array: "Float 32 Array";
-    readonly float64array: "Float 64 Array";
-    readonly bigint64array: "Big Int 64 Array";
-    readonly biguint64array: "Big Uint 64 Array";
-    readonly arraybuffer: "Array Buffer";
-    readonly sharedarraybuffer: "Shared Array Buffer";
-    readonly dataview: "Data View";
-    readonly arraybufferview: "Array Buffer View";
-    readonly map: "Map";
-    readonly set: "Set";
-    readonly weakmap: "Weak Map";
-    readonly weakset: "Weak Set";
-    readonly mapiterator: "Map Iterator";
-    readonly weakmapiterator: "Weak Map Iterator";
-    readonly setiterator: "Set Iterator";
-    readonly weaksetiterator: "Weak Set Iterator";
-    readonly arrayiterator: "Array Iterator";
-    readonly stringiterator: "String Iterator";
-    readonly asynciterator: "Async Iterator";
-    readonly iteratorresult: "Iterator Result";
-    readonly arrayiteratorresult: "Array Iterator Result";
-    readonly readablestream: "Readable Stream";
-    readonly writablestream: "Writable Stream";
-    readonly transformstream: "Transform Stream";
-    readonly readablestreamdefaultreader: "Readable Stream Default Reader";
-    readonly writablestreamdefaultwriter: "Writable Stream Default Writer";
-    readonly readablestreamdefaultcontroller: "Readable Stream Default Controller";
-    readonly transformstreamdefaultcontroller: "Transform Stream Default Controller";
-    readonly abortcontroller: "Abort Controller";
-    readonly abortsignal: "Abort Signal";
-    readonly fetch: "fetch";
-    readonly request: "Request";
-    readonly response: "Response";
-    readonly headers: "Headers";
-    readonly formdata: "FormData";
-    readonly blob: "Blob";
-    readonly file: "File";
-    readonly filelist: "FileList";
-    readonly filereader: "FileReader";
-    readonly intl: "Intl";
-    readonly collator: "Intl. Collator";
-    readonly datetimeformat: "Intl. Date Time Format";
-    readonly displaynames: "Intl. Display Names";
-    readonly listformat: "Intl. List Format";
-    readonly locale: "Intl. Locale";
-    readonly numberformat: "Intl. Number Format";
-    readonly pluralrules: "Intl. Plural Rules";
-    readonly relativetimeformat: "Intl. Relative Time Format";
-    readonly segmenter: "Intl. Segmenter";
-    readonly weakref: "Weak Ref";
-    readonly urlpattern: "URLPattern";
-    readonly structuredclone: "structured Clone";
-    readonly finalizationregistry: "Finalization Registry";
-    readonly performance: "Performance";
-    readonly performanceobserver: "Performance Observer";
-    readonly performanceentry: "Performance Entry";
-    readonly performancemark: "Performance Mark";
-    readonly performancemeasure: "Performance Measure";
-    readonly webassembly: "Web Assembly";
-    readonly wasmmodule: "WebAssembly. Module";
-    readonly wasminstance: "WebAssembly. Instance";
-    readonly wasmmemory: "WebAssembly. Memory";
-    readonly wasmtable: "WebAssembly. Table";
-    readonly buffer: "Buffer";
-    readonly process: "Process";
-    readonly eventemitter: "Event Emitter";
-    readonly stream: "Stream";
-    readonly fs: "fs";
-    readonly path: "path";
-    readonly url: "URL";
-    readonly urlsearchparams: "URL Search Params";
-    readonly node: "Node";
-    readonly element: "Element";
-    readonly htmlelement: "HTML Element";
-    readonly svgelement: "SVG Element";
-    readonly document: "Document";
-    readonly documentfragment: "Document Fragment";
-    readonly shadowroot: "Shadow Root";
-    readonly nodelist: "Node List";
-    readonly htmlcollection: "HTML Collection";
-    readonly resizeobserver: "Resize Observer";
-    readonly mutationobserver: "Mutation Observer";
-    readonly intersectionobserver: "Intersection Observer";
-    readonly symboliterator: "Symbol. Iterator";
-    readonly symbolasynciterator: "Symbol. Async Iterator";
-    readonly symboltostringtag: "Symbol. To String Tag";
-    readonly symbolspecies: "Symbol. Species";
-    readonly symbolhasinstance: "Symbol. Has Instance";
-    readonly symbolisconcatspreadable: "Symbol. Is Concat Spreadable";
-    readonly symbolunscopables: "Symbol. Unscopables";
-    readonly symbolmatch: "Symbol. Match";
-    readonly symbolreplace: "Symbol. Replace";
-    readonly symbolsearch: "Symbol. Search";
-    readonly symbolsplit: "Symbol. Split";
-    readonly symboltoprimitive: "Symbol. To Primitive";
-    readonly symbolmatchall: "Symbol. Match All";
-    readonly symbolarguments: "Symbol. Arguments";
-    readonly math: "Math";
-    readonly bigintconstructor: "Bigint Constructor";
-    readonly numberconstructor: "Number Constructor";
-    readonly stringconstructor: "String Constructor";
-    readonly booleanconstructor: "Boolean Constructor";
-    readonly formdataevent: "Form Data Event";
-    readonly customevent: "Custom Event";
-    readonly messagechannel: "Message Channel";
-    readonly messageport: "Message Port";
-    readonly messageevent: "Message Event";
-    readonly websocket: "Web Socket";
-    readonly eventsource: "Event Source";
-    readonly indexeddb: "IndexedDB";
-    readonly idbrequest: "IDB Request";
-    readonly idbtransaction: "IDB Transaction";
-    readonly idbobjectstore: "IDB Object Store";
-    readonly idbcursor: "IDB Cursor";
-    readonly localstorage: "Local Storage";
-    readonly sessionstorage: "Session Storage";
-    readonly navigator: "Navigator";
-    readonly geolocation: "Geolocation";
-    readonly clipboard: "Clipboard";
-    readonly notification: "Notification";
-    readonly canvas: "Canvas";
-    readonly canvasrenderingcontext2d: "Canvas Rendering Context 2D";
-    readonly offscreencanvas: "Offscreen Canvas";
-    readonly webglrenderingcontext: "WebGL Rendering Context";
-    readonly imagedata: "Image Data";
-    readonly imagebitmap: "Image Bitmap";
-    readonly mediastream: "Media Stream";
-    readonly mediarecorder: "Media Recorder";
-    readonly mediastreamtrack: "Media Stream Track";
-    readonly audiocontext: "Audio Context";
-    readonly audiobuffer: "Audio Buffer";
-    readonly audioworklet: "Audio Worklet";
-    readonly worker: "Worker";
-    readonly sharedworker: "Shared Worker";
-    readonly serviceworker: "Service Worker";
-    readonly workerglobalscope: "Worker Global Scope";
-    readonly structuredcloneerror: "Structured Clone Error";
-    readonly transferable: "Transferable";
-    readonly report: "Report";
-    readonly console: "Console";
-    readonly diagnosticreport: "Diagnostic Report";
-    readonly domrect: "DOM Rect";
-    readonly dompoint: "DOM Point";
-    readonly dommatrix: "DOM Matrix";
-    readonly domparser: "DOM Parser";
-    readonly xmlhttprequest: "XML HTTP Request";
-    readonly customelementregistry: "Custom Element Registry";
-    readonly text: "Text";
-    readonly comment: "Comment";
-    readonly animation: "Animation";
-    readonly documenttype: "Document Type";
-    readonly characterdata: "Character Data";
-    readonly animationevent: "Animation Event";
-    readonly customemmetregistry: "Custom Emmet Registry";
-    readonly websocketmessageevent: "WebSocket Message Event";
-  }>;
-  /** ----------------------------------------------------------
-   * * ***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(): readonly ["URI", "URL", "URN", "HTTP", "HTTPS", "FTP", "FTPS", "SFTP", "SSH", "SMTP", "POP3", "IMAP", "WS", "WSS", "TCP", "UDP", "IP", "ICMP", "ARP", "RTP", "RTSP", "SIP", "HTML", "XHTML", "XML", "WBR", "CSS", "SVG", "JSON", "JSONP", "DOM", "IDB", "DB", "RTC", "ICE", "TLS", "SSL", "CORS", "WASM", "CSR", "SSR", "PWA", "DPI", "CDN", "JS", "TS", "JSX", "TSX", "CLI", "API", "SDK", "UI", "UX", "OS", "ID", "UUID", "PID", "NPM", "YARN", "ESM", "CJS", "BOM", "MVC", "MVVM", "ORM", "DAO", "CRUD", "FIFO", "LIFO", "OOP", "FP", "REPL", "CSV", "TSV", "SQL", "YAML", "JSON", "MD", "INI", "PDF", "XLS", "XLSX", "RTF", "XML", "BMP", "GIF", "PNG", "JPEG", "WEBP", "MP3", "MP4", "AVI", "MOV", "FLAC", "MKV", "WAV", "URLSearchParams", "XHR", "2D", "3D", "GL", "WebGL", "TTL", "UID", "GID", "MAC", "IP", "DNS", "DHCP", "VPN", "LAN", "WAN", "SSID", "IoT", "API", "SDK", "CLI", "LTS", "EOL", "CPU", "GPU", "RAM", "ROM", "SSD", "HDD", "BIOS", "USB", "PCI", "SATA", "DIMM", "DDR", "VGA", "HDMI", "KVM", "ASIC", "FPGA", "SoC", "NAS", "SAN", "TCP", "UDP", "IP", "MAC", "DNS", "DHCP", "VPN", "LAN", "WAN", "SSID", "NAT", "QoS", "MPLS", "BGP", "OSPF", "ICMP", "IGMP", "LLDP", "ARP", "RARP", "AES", "RSA", "OTP", "MFA", "PKI", "VPN", "IAM", "ACL", "CSP", "XSS", "CSRF", "HSTS", "WAF", "DDoS", "IDS", "IPS", "SOC", "SIEM", "AWS", "GCP", "AZURE", "CI", "CD", "K8S", "IaC", "PaaS", "SaaS", "IaaS", "API", "CLI", "SDK", "REST", "SOAP", "JSON-RPC", "gRPC", "ELB", "EKS", "AKS", "FaaS", "CaaS", "GUI", "IDE", "FAQ", "UX", "UI", "CLI", "API", "SDK", "LTS", "EOL", "WYSIWYG", "CMS", "CRM", "GPS", "LED", "OLED", "LCD", "RFID", "NFC", "CPU", "GPU", "AI", "ML", "DL", "DB", "SQL", "NoSQL", "ORM", "JSON", "XML", "CSV", "HTTP", "HTTPS", "TDD", "BDD", "CI", "CD", "QA", "SLA", "SLO", "MTTR", "MTBF", "UAT", "RPA", "KPI", "OKR", "ROI", "RFP", "SLA", "CRM", "ERP", "PMO", "SCRUM", "KANBAN", "FPS", "HDR", "VR", "AR", "3D", "2D", "MP3", "MP4", "GIF", "PNG", "JPEG", "SVG", "BMP", "TIFF", "POSIX", "NTFS", "FAT", "EXT", "EXT4", "APFS", "HFS", "ISO", "HTML", "CSS", "JS", "TS", "PHP", "SQL", "JSON", "XML", "YAML", "BASH", "ZSH", "JSON", "YAML", "INI", "DOTENV", "VM", "VMM", "VPC", "OCI", "LXC", "Docker", "K8S", "CRI", "CNI"];
-}
-/** ---------------------------------------------------------------------------
- * * ***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/isURL-CQiowFq2.js

@@ -1,14 +0,0 @@
-/*!
-* ========================================================================
-*  @rzl-zone/utils-js
-* ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
-*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
-*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
-* ========================================================================
-*/
-const isURL = (value) => {
-	return value instanceof URL;
-};
-export { isURL as t };
-//# sourceMappingURL=isURL-CQiowFq2.js.map

package/dist/isURL-CQiowFq2.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isURL-CQiowFq2.js","names":[],"sources":["../src/predicates/is/isURL.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Type guard: `isURL`.***\n * ----------------------------------------------------------\n * **Checks if a value is an instance of the\n * **[`URL`](https://developer.mozilla.org/docs/Web/API/URL)** class.**\n * - **Behavior:**\n *    - Narrows type to `URL` when true.\n *    - Excludes `strings`, `plain-objects`, and `other non-URL values`.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is an instance of `URL`, otherwise `false`.\n * @example\n * isURL(new URL(\"https://example.com\"));\n * // ➔ true\n * isURL(\"https://example.com\");\n * // ➔ false\n */\nexport const isURL = (value: unknown): value is URL => {\n  return value instanceof URL;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA,MAAa,SAAS,UAAiC;CACrD,OAAO,iBAAiB"}

package/dist/isURL-WZypXsax.cjs

@@ -1,20 +0,0 @@
-/*!
-* ========================================================================
-*  @rzl-zone/utils-js
-* ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
-*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
-*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
-* ========================================================================
-*/
-"use strict";
-const isURL = (value) => {
-	return value instanceof URL;
-};
-Object.defineProperty(exports, 'isURL', {
-  enumerable: true,
-  get: function () {
-    return isURL;
-  }
-});
-//# sourceMappingURL=isURL-WZypXsax.cjs.map

package/dist/isURL-WZypXsax.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isURL-WZypXsax.cjs","names":[],"sources":["../src/predicates/is/isURL.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Type guard: `isURL`.***\n * ----------------------------------------------------------\n * **Checks if a value is an instance of the\n * **[`URL`](https://developer.mozilla.org/docs/Web/API/URL)** class.**\n * - **Behavior:**\n *    - Narrows type to `URL` when true.\n *    - Excludes `strings`, `plain-objects`, and `other non-URL values`.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is an instance of `URL`, otherwise `false`.\n * @example\n * isURL(new URL(\"https://example.com\"));\n * // ➔ true\n * isURL(\"https://example.com\");\n * // ➔ false\n */\nexport const isURL = (value: unknown): value is URL => {\n  return value instanceof URL;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA,MAAa,SAAS,UAAiC;CACrD,OAAO,iBAAiB"}

package/dist/isValidDomain-BSXshgkC.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isValidDomain-BSXshgkC.cjs","names":["isString","isBoolean","getPreciseType","safeStableStringify","punycodeUtilsJS","ccTldMap","sldMap"],"sources":["../src/predicates/is/_private/data/domain/sldMap.json","../src/predicates/is/_private/data/domain/ccTldMap.json","../src/predicates/is/isValidDomain.ts"],"sourcesContent":["","","import { punycodeUtilsJS } from \"@/urls/utils/punyCode\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\nimport sldMap from \"./_private/data/domain/sldMap.json\";\nimport ccTldMap from \"./_private/data/domain/ccTldMap.json\";\n\nimport { isString } from \"./isString\";\nimport { isBoolean } from \"./isBoolean\";\n\nimport { getPreciseType } from \"../type/getPreciseType\";\n\n/** ---------------------------------------------------------\n * * ***Options for `isValidDomain` predicate.***\n * ---------------------------------------------------------\n * **Customize the behavior of domain validation.**\n */\ntype IsValidDomainOptions = {\n  /** * ***Enable conversion of Unicode domains (IDN) to ASCII (punycode).***\n   *\n   * - Example: `\"пример.рф\"` ➔ `\"xn--e1afmkfd.xn--p1ai\"`\n   * - Allows validating Unicode domains correctly.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  allowUnicode?: boolean;\n\n  /** * ***If `true`, validates **only top-level domains (TLDs)** that are not part of any SLD/second-level domain.***\n   *\n   * - Accepts country-code TLDs like `\"ai\"` or `\"ai.\"` ✅\n   * - Rejects common TLDs that are part of SLDs like `\"com\"` ❌\n   * - Only the final label is checked; subdomains are ignored.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  topLevel?: boolean;\n\n  /** * ***Allow or disallow subdomains.***\n   *\n   * - Example: `\"sub.example.com\"` ✅ if `subdomain` is `true`, ❌ if `false`\n   * - Wildcards and SLDs are considered when evaluating subdomains.\n   * - Default: `true`\n   *\n   * @defaultValue `true`.\n   */\n  subdomain?: boolean;\n\n  /** * ***Allow a wildcard `*` in the left-most label.***\n   *\n   * - Example: `\"*.example.com\"` ✅ if `wildcard` is `true`, ❌ if `false`\n   * - Wildcards are only valid in the first label and require at least one additional label.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  wildcard?: boolean;\n\n  /** * ***Allow a port after the domain.***\n   *\n   * - Example: `\"localhost:3000\"` or `\"example.com:8080\"` ✅ if `allowPort` is `true`\n   * - Validates that the port is a number between `1` and `65535`.\n   * - Does not affect domain validation rules otherwise.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  allowPort?: boolean;\n\n  /** * ***Allow special domains like `localhost`.***\n   *\n   * - Example: `\"localhost\"` ✅ if `allowLocalhost` is `true`\n   * - Works with or without a port if `allowPort` is enabled.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  allowLocalhost?: boolean;\n\n  /** * ***Allow URLs with protocol (`http`/`https`) and automatically extract the hostname.***\n   *\n   * - Example: `\"https://example.com/foo/bar\"` ➔ `\"example.com\"`\n   * - The function will validate only the hostname part and ignore the path, query, and fragment.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  allowProtocol?: boolean;\n};\n\n/** ---------------------------------------------------------\n * * ***Predicate: `isValidDomain`.***\n * ---------------------------------------------------------\n * **Validates whether a given string is a properly formatted domain name.**\n *\n * - **Supports options for:**\n *    - `allowUnicode` ➔ allows internationalized domain names (IDN) with Unicode characters.\n *    - `topLevel` ➔ validates **only top-level domains (TLDs)**; ignores subdomains and SLDs.\n *    - `subdomain` ➔ allows or disallows subdomains.\n *    - `wildcard` ➔ allows wildcard (`*`) in the left-most label.\n *    - `allowPort` ➔ allows a port number after the domain (e.g., `example.com:8080`).\n *    - `allowLocalhost` ➔ allows the special domain `\"localhost\"`.\n *    - `allowProtocol` ➔ allows a URL with protocol (`http`/`https`) and extracts the hostname.\n *\n * - **Behavior:**\n *    - ✅ Converts Unicode to ASCII (punycode) if `allowUnicode` is `true`.\n *    - ✅ Checks label lengths (≤63 chars), valid characters, and punycode consistency.\n *    - ✅ Validates port if `allowPort` is `true` (must be 1–65535).\n *    - ✅ Accepts `\"localhost\"` if `allowLocalhost` is `true`.\n *    - ✅ Extracts hostname from URLs if `allowProtocol` is `true`.\n *    - ❌ Rejects invalid domains, labels starting/ending with `-`, double dots, malformed TLDs, or invalid port numbers.\n *    - ✅ Handles both standard domains (example.com), URLs with protocols (https://example.com/foo), and IDNs (пример.рф).\n *\n * @param {*} value - The value to validate; only strings are valid domains.\n * @param {IsValidDomainOptions} [options] - Optional configuration for domain validation.\n * @param {boolean} [options.allowUnicode=false] - Enable punycode conversion for Unicode domains.\n * @param {boolean} [options.topLevel=false] - Validate only TLDs (e.g., `ai`, `uk.`); ignores SLDs like `com`.\n * @param {boolean} [options.subdomain=true] - Allow subdomains; set `false` to reject any subdomain.\n * @param {boolean} [options.wildcard=false] - Allow wildcard `*` in the left-most label (e.g., `*.example.com`).\n * @param {boolean} [options.allowPort=false] - Allow port number after domain (e.g., `:3000`); must be 1–65535.\n * @param {boolean} [options.allowLocalhost=false] - Allow special domain `\"localhost\"`.\n * @param {boolean} [options.allowProtocol=false] - Allow URLs with protocol (`http`/`https`) and extract hostname only.\n * @returns {boolean} Returns `true` if the value is a valid domain according to the rules and options; otherwise `false`.\n *\n * @example\n * isValidDomain(\"google.com\");\n * // ➔ true\n * isValidDomain(\"пример.рф\", { allowUnicode: true });\n * // ➔ true\n * isValidDomain(\"sub.example.com\", { subdomain: false });\n * // ➔ false\n * isValidDomain(\"*.example.com\", { wildcard: true });\n * // ➔ true\n * isValidDomain(\"com\", { topLevel: true });\n * // ➔ false (common TLD rejected because it's part of SLD)\n * isValidDomain(\"ai.\", { topLevel: true });\n * // ➔ true (country-code TLD accepted)\n * isValidDomain(\"localhost\", { allowLocalhost: true });\n * // ➔ true\n * isValidDomain(\"localhost:3000\", { allowLocalhost: true, allowPort: true });\n * // ➔ true\n * isValidDomain(\"example.com:8080\", { allowPort: true });\n * // ➔ true\n * isValidDomain(\"https://example.com/foo/bar\", { allowProtocol: true });\n * // ➔ true (protocol stripped and hostname validated)\n * isValidDomain(\"invalid_domain.com\");\n * // ➔ false\n */\nexport function isValidDomain(\n  value: unknown,\n  options: IsValidDomainOptions = {}\n): boolean {\n  if (!isString(value)) return false;\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const {\n    subdomain = true,\n    topLevel = false,\n    wildcard = false,\n    allowUnicode = false,\n    allowPort = false,\n    allowLocalhost = false,\n    allowProtocol = false\n  } = options;\n\n  // Validate Options:\n  const invalid = Object.entries({\n    subdomain,\n    topLevel,\n    wildcard,\n    allowUnicode,\n    allowProtocol,\n    allowPort,\n    allowLocalhost\n  }).filter(([, value]) => !isBoolean(value));\n\n  if (invalid.length) {\n    const msg = invalid\n      .map(\n        ([key, value], i) =>\n          `   ${i + 1}. option: \"${key}\"\\n` +\n          \"      expected: boolean\\n\" +\n          `      received: ${getPreciseType(value)} (${safeStableStringify(\n            value,\n            {\n              keepUndefined: true\n            }\n          )})`\n      )\n      .join(\"\\n\");\n\n    throw new TypeError(\n      `\\n> Invalid options detected in second parameter of \\`isValidDomain\\`:\\n${msg}`\n    );\n  }\n  // -----------------\n\n  let _value = value.toLowerCase();\n\n  if (allowProtocol) {\n    try {\n      const url = new URL(value); // use original input\n      if (url.protocol !== \"http:\" && url.protocol !== \"https:\") return false; // reject non-http(s)\n      if (!allowPort && url.port) return false; // reject port if allowPort=false\n      _value = url.hostname.toLowerCase(); // extract only hostname\n\n      // wildcard check\n      const labels = _value.split(\".\");\n      if (labels[0] === \"*\" && !wildcard) return false;\n    } catch {\n      // if parsing fails, leave _value unchanged\n    }\n  }\n\n  if (value.endsWith(\".\")) {\n    _value = _value.slice(0, _value.length - 1);\n  }\n\n  // Handle port\n  let port: string;\n  if (allowPort) {\n    const portMatch = _value.match(/:(\\d{1,5})$/);\n    if (portMatch) {\n      port = portMatch[0];\n      _value = _value.slice(0, -port.length);\n      const portNum = Number(portMatch[1]);\n      if (portNum < 1 || portNum > 65535) return false;\n    }\n  }\n\n  // Allow localhost\n  if (allowLocalhost && _value === \"localhost\") return true;\n\n  if (allowUnicode) {\n    try {\n      _value = punycodeUtilsJS.toASCII(_value);\n    } catch {\n      return false;\n    }\n  }\n\n  if (_value.length > 253) return false;\n\n  const validChars = /^([\\u0E00-\\u0E7Fa-z0-9-._*]+)$/g;\n  if (!validChars.test(_value)) return false;\n\n  if (topLevel) {\n    if (ccTldMap[_value.replace(/\\.$/, \"\") as keyof typeof ccTldMap]) {\n      return true;\n    }\n  }\n\n  const sldRegex = /(.*)\\.(([\\u0E00-\\u0E7Fa-z0-9]+)(\\.[a-z0-9]+))/;\n  const matches = _value.match(sldRegex);\n  // eslint-disable-next-line no-useless-assignment\n  let tld: string | null = null;\n  let labels: string[] | null = null;\n\n  if (matches && matches.length > 2) {\n    if (sldMap[matches[2] as keyof typeof sldMap]) {\n      // eslint-disable-next-line no-useless-assignment\n      tld = matches[2] || null;\n      labels = matches[1]?.split(\".\") || null;\n    }\n  }\n\n  if (!labels) {\n    labels = _value.split(\".\");\n    if (labels.length <= 1) return false;\n\n    tld = labels.pop()!;\n    const tldRegex = /^(?:xn--)?(?!^\\d+$)[\\u0E00-\\u0E7Fa-z0-9]+$/gi;\n    if (!tldRegex.test(tld)) return false;\n  }\n\n  if (subdomain === false && labels.length > 1) return false;\n\n  return labels.every((label, index) => {\n    if (wildcard && index === 0 && label === \"*\" && labels.length > 1) {\n      return true;\n    }\n\n    let validLabelChars = /^([\\u0E00-\\u0E7Fa-zA-Z0-9-_]+)$/g;\n    if (index === labels.length - 1) {\n      validLabelChars = /^([\\u0E00-\\u0E7Fa-zA-Z0-9-]+)$/g;\n    }\n\n    const doubleDashCount = (label.match(/--(--)?/g) || []).length;\n    const xnDashCount = (label.match(/xn--/g) || []).length;\n    if (index === labels.length - 1 && doubleDashCount !== xnDashCount) {\n      return false;\n    }\n\n    return (\n      validLabelChars.test(label) &&\n      label.length < 64 &&\n      !label.startsWith(\"-\") &&\n      !label.endsWith(\"-\")\n    );\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}