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

package/dist/isPlainObject-DTJVV2Kf.d.ts

@@ -1,536 +0,0 @@
-/*!
- * ====================================================
- * Rzl Utils-JS.
- * ----------------------------------------------------
- * Version: 3.12.0.
- * Author: Rizalvin Dwiky.
- * Repository: https://github.com/rzl-zone/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 { type AcronymsList as A, type GetPreciseTypeOptions as G, type IsNumberOptions as I, type IsPlainObjectResult as a, isPlainObject as b, type ArrayFallback as c, type IsHasKeysObject as d, getPreciseType as g, isNumber as i };