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

package/dist/isBigInt-BVj0M5pq.cjs.map

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

package/dist/isBigInt-y7s3rsKc.js.map

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

package/dist/isEmptyObject-BsHngDz4.cjs

@@ -1,37 +0,0 @@
-/*!
-* ========================================================================
-*  @rzl-zone/utils-js
-* ------------------------------------------------------------------------
-*  Version: `3.13.1`
-*  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-D41HrTB_.cjs');
-const isEmptyArray = (value) => {
-	if (!require_assertIsBoolean.isArray(value)) return true;
-	return value.length === 0;
-};
-function isEmptyObject(value, options = {}) {
-	if (!require_assertIsBoolean.isObject(value)) return true;
-	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
-	const checkSymbols = require_assertIsBoolean.hasOwnProp(options, "checkSymbols") ? options.checkSymbols : false;
-	require_assertIsBoolean.assertIsBoolean(checkSymbols, { message: ({ currentType, validType }) => `Parameter \`checkSymbols\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
-	const hasNoKeys = Object.keys(value).length === 0;
-	if (checkSymbols) return hasNoKeys && Object.getOwnPropertySymbols(value).length === 0;
-	return hasNoKeys;
-}
-Object.defineProperty(exports, 'isEmptyArray', {
-  enumerable: true,
-  get: function () {
-    return isEmptyArray;
-  }
-});
-Object.defineProperty(exports, 'isEmptyObject', {
-  enumerable: true,
-  get: function () {
-    return isEmptyObject;
-  }
-});
-//# sourceMappingURL=isEmptyObject-BsHngDz4.cjs.map

package/dist/isEmptyObject-BsHngDz4.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isEmptyObject-BsHngDz4.cjs","names":["isArray","isObject","hasOwnProp"],"sources":["../src/predicates/is/isEmptyArray.ts","../src/predicates/is/isEmptyObject.ts"],"sourcesContent":["import { isArray } from \"@/predicates/is/isArray\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyArray`.***\n * ----------------------------------------------------------\n * **Checks whether a given value is an empty array.**\n * - **Behavior:**\n *    - Non-array inputs are considered ***`empty`*** ***(defensive strategy)***.\n * @param {*} [value] - The value to check.\n * @returns {boolean} Returns `true` if it's ***not an array*** or ***an empty-array***.\n * @example\n * isEmptyArray([]);             // ➔ true\n * isEmptyArray([1, 2, 3]);      // ➔ false\n * isEmptyArray(\"not an array\"); // ➔ true\n * isEmptyArray(null);           // ➔ true\n * isEmptyArray(undefined);      // ➔ true\n *\n * if (isEmptyArray(data.items)) {\n *   console.log(\"No items to display.\");\n * }\n */\nexport const isEmptyArray = (value: unknown): boolean => {\n  if (!isArray(value)) return true;\n\n  return value.length === 0;\n};\n","import { isObject } from \"./isObject\";\nimport { hasOwnProp } from \"../has/hasOwnProp\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype IsEmptyObjectOptions = {\n  /** Whether to check for symbol properties in addition to string keys, defaultValue: `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyObject`.***\n * ----------------------------------------------------------\n * **Checks if a value is a plain object with **no own enumerable string-key properties**,\n * and optionally **no own enumerable symbol-key properties** when `checkSymbols` is `true`.**\n * - **Behavior:**\n *    - If the value is **not an object** (e.g. `null`, array, primitive), it is considered empty.\n *    - If `options.checkSymbols` is `true`, **symbol properties** are also checked.\n * @param {*} value - The value to check.\n * @param {IsEmptyObjectOptions} [options] - Optional settings.\n * @param {IsEmptyObjectOptions[\"checkSymbols\"]} [options.checkSymbols=false] - Whether to also check symbol properties.\n * @returns {boolean} Return `true` if the value is considered empty or not an object, false otherwise.\n * @example\n * isEmptyObject({});\n * // ➔ true\n * isEmptyObject({}, { checkSymbols: true });\n * // ➔ true\n * isEmptyObject({ a: 1 });\n * // ➔ false\n * isEmptyObject({ [Symbol('s')]: 1 });\n * // ➔ true\n * isEmptyObject({ [Symbol('s')]: 1 }, { checkSymbols: true });\n * // ➔ false\n * isEmptyObject(null);\n * // ➔ true (not object)\n * isEmptyObject([]);\n * // ➔ true (not plain object)\n * isEmptyObject(123);\n * // ➔ true (not object)\n */\nexport function isEmptyObject(\n  value: unknown,\n  options: IsEmptyObjectOptions = {}\n): boolean {\n  if (!isObject(value)) {\n    return true;\n  }\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const checkSymbols = hasOwnProp(options, \"checkSymbols\")\n    ? options.checkSymbols\n    : false;\n\n  assertIsBoolean(checkSymbols, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`checkSymbols\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const hasNoKeys = Object.keys(value).length === 0;\n  if (checkSymbols) {\n    return hasNoKeys && Object.getOwnPropertySymbols(value).length === 0;\n  }\n  return hasNoKeys;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,gBAAgB,UAA4B;CACvD,IAAI,CAACA,gCAAQ,KAAK,GAAG,OAAO;CAE5B,OAAO,MAAM,WAAW;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACmBA,SAAgB,cACd,OACA,UAAgC,CAAC,GACxB;CACT,IAAI,CAACC,iCAAS,KAAK,GACjB,OAAO;CAGT,4CAAoB,SAAS,EAC3B,UAAU,EAAE,aAAa,gBACvB,oDAAoD,UAAU,sBAAsB,YAAY,KACpG,CAAC;CAED,MAAM,eAAeC,mCAAW,SAAS,cAAc,IACnD,QAAQ,eACR;CAEJ,wCAAgB,cAAc,EAC5B,UAAU,EAAE,aAAa,gBACvB,+FAA+F,UAAU,sBAAsB,YAAY,KAC/I,CAAC;CAED,MAAM,YAAY,OAAO,KAAK,KAAK,EAAE,WAAW;CAChD,IAAI,cACF,OAAO,aAAa,OAAO,sBAAsB,KAAK,EAAE,WAAW;CAErE,OAAO;AACT"}

package/dist/isEmptyObject-DPGR9iPj.js

@@ -1,25 +0,0 @@
-/*!
-* ========================================================================
-*  @rzl-zone/utils-js
-* ------------------------------------------------------------------------
-*  Version: `3.13.1`
-*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
-*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
-* ========================================================================
-*/
-import { M as isArray, T as assertIsPlainObject, b as hasOwnProp, j as isObject, t as assertIsBoolean } from "./assertIsBoolean-CWUs-I5l.js";
-const isEmptyArray = (value) => {
-	if (!isArray(value)) return true;
-	return value.length === 0;
-};
-function isEmptyObject(value, options = {}) {
-	if (!isObject(value)) return true;
-	assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
-	const checkSymbols = hasOwnProp(options, "checkSymbols") ? options.checkSymbols : false;
-	assertIsBoolean(checkSymbols, { message: ({ currentType, validType }) => `Parameter \`checkSymbols\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
-	const hasNoKeys = Object.keys(value).length === 0;
-	if (checkSymbols) return hasNoKeys && Object.getOwnPropertySymbols(value).length === 0;
-	return hasNoKeys;
-}
-export { isEmptyArray as n, isEmptyObject as t };
-//# sourceMappingURL=isEmptyObject-DPGR9iPj.js.map

package/dist/isEmptyObject-DPGR9iPj.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isEmptyObject-DPGR9iPj.js","names":[],"sources":["../src/predicates/is/isEmptyArray.ts","../src/predicates/is/isEmptyObject.ts"],"sourcesContent":["import { isArray } from \"@/predicates/is/isArray\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyArray`.***\n * ----------------------------------------------------------\n * **Checks whether a given value is an empty array.**\n * - **Behavior:**\n *    - Non-array inputs are considered ***`empty`*** ***(defensive strategy)***.\n * @param {*} [value] - The value to check.\n * @returns {boolean} Returns `true` if it's ***not an array*** or ***an empty-array***.\n * @example\n * isEmptyArray([]);             // ➔ true\n * isEmptyArray([1, 2, 3]);      // ➔ false\n * isEmptyArray(\"not an array\"); // ➔ true\n * isEmptyArray(null);           // ➔ true\n * isEmptyArray(undefined);      // ➔ true\n *\n * if (isEmptyArray(data.items)) {\n *   console.log(\"No items to display.\");\n * }\n */\nexport const isEmptyArray = (value: unknown): boolean => {\n  if (!isArray(value)) return true;\n\n  return value.length === 0;\n};\n","import { isObject } from \"./isObject\";\nimport { hasOwnProp } from \"../has/hasOwnProp\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype IsEmptyObjectOptions = {\n  /** Whether to check for symbol properties in addition to string keys, defaultValue: `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyObject`.***\n * ----------------------------------------------------------\n * **Checks if a value is a plain object with **no own enumerable string-key properties**,\n * and optionally **no own enumerable symbol-key properties** when `checkSymbols` is `true`.**\n * - **Behavior:**\n *    - If the value is **not an object** (e.g. `null`, array, primitive), it is considered empty.\n *    - If `options.checkSymbols` is `true`, **symbol properties** are also checked.\n * @param {*} value - The value to check.\n * @param {IsEmptyObjectOptions} [options] - Optional settings.\n * @param {IsEmptyObjectOptions[\"checkSymbols\"]} [options.checkSymbols=false] - Whether to also check symbol properties.\n * @returns {boolean} Return `true` if the value is considered empty or not an object, false otherwise.\n * @example\n * isEmptyObject({});\n * // ➔ true\n * isEmptyObject({}, { checkSymbols: true });\n * // ➔ true\n * isEmptyObject({ a: 1 });\n * // ➔ false\n * isEmptyObject({ [Symbol('s')]: 1 });\n * // ➔ true\n * isEmptyObject({ [Symbol('s')]: 1 }, { checkSymbols: true });\n * // ➔ false\n * isEmptyObject(null);\n * // ➔ true (not object)\n * isEmptyObject([]);\n * // ➔ true (not plain object)\n * isEmptyObject(123);\n * // ➔ true (not object)\n */\nexport function isEmptyObject(\n  value: unknown,\n  options: IsEmptyObjectOptions = {}\n): boolean {\n  if (!isObject(value)) {\n    return true;\n  }\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const checkSymbols = hasOwnProp(options, \"checkSymbols\")\n    ? options.checkSymbols\n    : false;\n\n  assertIsBoolean(checkSymbols, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`checkSymbols\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const hasNoKeys = Object.keys(value).length === 0;\n  if (checkSymbols) {\n    return hasNoKeys && Object.getOwnPropertySymbols(value).length === 0;\n  }\n  return hasNoKeys;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,gBAAgB,UAA4B;CACvD,IAAI,CAAC,QAAQ,KAAK,GAAG,OAAO;CAE5B,OAAO,MAAM,WAAW;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACmBA,SAAgB,cACd,OACA,UAAgC,CAAC,GACxB;CACT,IAAI,CAAC,SAAS,KAAK,GACjB,OAAO;CAGT,oBAAoB,SAAS,EAC3B,UAAU,EAAE,aAAa,gBACvB,oDAAoD,UAAU,sBAAsB,YAAY,KACpG,CAAC;CAED,MAAM,eAAe,WAAW,SAAS,cAAc,IACnD,QAAQ,eACR;CAEJ,gBAAgB,cAAc,EAC5B,UAAU,EAAE,aAAa,gBACvB,+FAA+F,UAAU,sBAAsB,YAAY,KAC/I,CAAC;CAED,MAAM,YAAY,OAAO,KAAK,KAAK,EAAE,WAAW;CAChD,IAAI,cACF,OAAO,aAAa,OAAO,sBAAsB,KAAK,EAAE,WAAW;CAErE,OAAO;AACT"}

package/dist/isEmptyString-BYMz_wt9.js.map

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

package/dist/isEmptyString-C8PYNPgw.cjs.map

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

package/dist/isEmptyValue-BXf7f1jz.cjs

@@ -1,30 +0,0 @@
-/*!
-* ========================================================================
-*  @rzl-zone/utils-js
-* ------------------------------------------------------------------------
-*  Version: `3.13.1`
-*  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-D41HrTB_.cjs');
-const require_isEmptyObject = require('./isEmptyObject-BsHngDz4.cjs');
-const require_isEmptyString = require('./isEmptyString-C8PYNPgw.cjs');
-const isEmptyValue = (value, options = {}) => {
-	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
-	const checkSymbols = require_assertIsBoolean.hasOwnProp(options, "checkSymbols") ? options.checkSymbols : false;
-	require_assertIsBoolean.assertIsBoolean(checkSymbols, { message: ({ currentType, validType }) => `Parameter \`checkSymbols\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
-	if (require_assertIsBoolean.isNil(value) || value === false || require_assertIsBoolean.isNaN(value)) return true;
-	if (require_assertIsBoolean.isString(value)) return require_isEmptyString.isEmptyString(value);
-	if (require_assertIsBoolean.isArray(value)) return require_isEmptyObject.isEmptyArray(value);
-	if (require_assertIsBoolean.isObject(value)) return require_isEmptyObject.isEmptyObject(value, { checkSymbols });
-	return false;
-};
-Object.defineProperty(exports, 'isEmptyValue', {
-  enumerable: true,
-  get: function () {
-    return isEmptyValue;
-  }
-});
-//# sourceMappingURL=isEmptyValue-BXf7f1jz.cjs.map

package/dist/isEmptyValue-BXf7f1jz.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isEmptyValue-BXf7f1jz.cjs","names":["hasOwnProp","isNil","isNaN","isString","isEmptyString","isArray","isEmptyArray","isObject","isEmptyObject"],"sources":["../src/predicates/is/isEmptyValue.ts"],"sourcesContent":["import { isNaN } from \"./isNaN\";\nimport { isNil } from \"./isNil\";\nimport { isArray } from \"./isArray\";\nimport { isObject } from \"./isObject\";\nimport { isString } from \"./isString\";\nimport { isEmptyArray } from \"./isEmptyArray\";\nimport { hasOwnProp } from \"../has/hasOwnProp\";\nimport { isEmptyObject } from \"./isEmptyObject\";\nimport { isEmptyString } from \"./isEmptyString\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype IsEmptyValueOptions = {\n  /** **Whether to check symbol properties when checking empty objects.**\n   * - **DefaultValue:** `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyValue`.***\n * ----------------------------------------------------------\n * **Determines if a value is **`empty`**.**\n * - **Covering:**\n *    - Empty objects: `{}`\n *    - Empty arrays: `[]`\n *    - Empty strings: `\"\"` or whitespace-only (trimmed)\n *    - `null`, `undefined`, `false`, or `NaN`\n * - **Returns **`false`** for:**\n *    - Non-empty objects/arrays\n *    - Non-empty strings\n *    - Numbers (except `NaN`)\n *    - `Functions`, `true`, `symbols`, `etc`.\n * @param {*} value - The value to evaluate.\n * @param {IsEmptyValueOptions} [options] - Optional settings.\n * @returns {boolean} Return `true` if the value is considered empty, otherwise `false`.\n * @example\n * isEmptyValue({});\n * // ➔ true\n * isEmptyValue([]);\n * // ➔ true\n * isEmptyValue({ key: \"value\" });\n * // ➔ false\n * isEmptyValue({ [Symbol(\"foo\")]: 123 });\n * // ➔ true (default `checkSymbols` is `false`)\n * isEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: false });\n * // ➔ true (default `checkSymbols` is `false`)\n * isEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: true });\n * // ➔ false\n * isEmptyValue([1, 2, 3]);\n * // ➔ false\n * isEmptyValue(NaN);\n * // ➔ true\n * isEmptyValue(true);\n * // ➔ false\n * isEmptyValue(false);\n * // ➔ true\n * isEmptyValue(null);\n * // ➔ true\n * isEmptyValue(undefined);\n * // ➔ true\n * isEmptyValue(\"\");\n * // ➔ true\n * isEmptyValue(\"   \");\n * // ➔ true\n * isEmptyValue(0);\n * // ➔ false\n * isEmptyValue(-1);\n * // ➔ false\n * isEmptyValue(2);\n * // ➔ false\n * isEmptyValue(() => {});\n * // ➔ false\n */\nexport const isEmptyValue = (\n  value: unknown,\n  options: IsEmptyValueOptions = {}\n): boolean => {\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const checkSymbols = hasOwnProp(options, \"checkSymbols\")\n    ? options.checkSymbols\n    : false;\n\n  assertIsBoolean(checkSymbols, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`checkSymbols\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  if (isNil(value) || value === false || isNaN(value)) return true;\n  if (isString(value)) return isEmptyString(value);\n  if (isArray(value)) return isEmptyArray(value);\n  if (isObject(value)) {\n    return isEmptyObject(value, { checkSymbols });\n  }\n\n  return false;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EA,MAAa,gBACX,OACA,UAA+B,CAAC,MACpB;CACZ,4CAAoB,SAAS,EAC3B,UAAU,EAAE,aAAa,gBACvB,oDAAoD,UAAU,sBAAsB,YAAY,KACpG,CAAC;CAED,MAAM,eAAeA,mCAAW,SAAS,cAAc,IACnD,QAAQ,eACR;CAEJ,wCAAgB,cAAc,EAC5B,UAAU,EAAE,aAAa,gBACvB,+FAA+F,UAAU,sBAAsB,YAAY,KAC/I,CAAC;CAED,IAAIC,8BAAM,KAAK,KAAK,UAAU,SAASC,8BAAM,KAAK,GAAG,OAAO;CAC5D,IAAIC,iCAAS,KAAK,GAAG,OAAOC,oCAAc,KAAK;CAC/C,IAAIC,gCAAQ,KAAK,GAAG,OAAOC,mCAAa,KAAK;CAC7C,IAAIC,iCAAS,KAAK,GAChB,OAAOC,oCAAc,OAAO,EAAE,aAAa,CAAC;CAG9C,OAAO;AACT"}

package/dist/isEmptyValue-D4OHTB3u.js

@@ -1,24 +0,0 @@
-/*!
-* ========================================================================
-*  @rzl-zone/utils-js
-* ------------------------------------------------------------------------
-*  Version: `3.13.1`
-*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
-*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
-* ========================================================================
-*/
-import { D as isNaN, M as isArray, N as isNil, T as assertIsPlainObject, b as hasOwnProp, j as isObject, k as isString, t as assertIsBoolean } from "./assertIsBoolean-CWUs-I5l.js";
-import { n as isEmptyArray, t as isEmptyObject } from "./isEmptyObject-DPGR9iPj.js";
-import { t as isEmptyString } from "./isEmptyString-BYMz_wt9.js";
-const isEmptyValue = (value, options = {}) => {
-	assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
-	const checkSymbols = hasOwnProp(options, "checkSymbols") ? options.checkSymbols : false;
-	assertIsBoolean(checkSymbols, { message: ({ currentType, validType }) => `Parameter \`checkSymbols\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
-	if (isNil(value) || value === false || isNaN(value)) return true;
-	if (isString(value)) return isEmptyString(value);
-	if (isArray(value)) return isEmptyArray(value);
-	if (isObject(value)) return isEmptyObject(value, { checkSymbols });
-	return false;
-};
-export { isEmptyValue as t };
-//# sourceMappingURL=isEmptyValue-D4OHTB3u.js.map

package/dist/isEmptyValue-D4OHTB3u.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isEmptyValue-D4OHTB3u.js","names":[],"sources":["../src/predicates/is/isEmptyValue.ts"],"sourcesContent":["import { isNaN } from \"./isNaN\";\nimport { isNil } from \"./isNil\";\nimport { isArray } from \"./isArray\";\nimport { isObject } from \"./isObject\";\nimport { isString } from \"./isString\";\nimport { isEmptyArray } from \"./isEmptyArray\";\nimport { hasOwnProp } from \"../has/hasOwnProp\";\nimport { isEmptyObject } from \"./isEmptyObject\";\nimport { isEmptyString } from \"./isEmptyString\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype IsEmptyValueOptions = {\n  /** **Whether to check symbol properties when checking empty objects.**\n   * - **DefaultValue:** `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyValue`.***\n * ----------------------------------------------------------\n * **Determines if a value is **`empty`**.**\n * - **Covering:**\n *    - Empty objects: `{}`\n *    - Empty arrays: `[]`\n *    - Empty strings: `\"\"` or whitespace-only (trimmed)\n *    - `null`, `undefined`, `false`, or `NaN`\n * - **Returns **`false`** for:**\n *    - Non-empty objects/arrays\n *    - Non-empty strings\n *    - Numbers (except `NaN`)\n *    - `Functions`, `true`, `symbols`, `etc`.\n * @param {*} value - The value to evaluate.\n * @param {IsEmptyValueOptions} [options] - Optional settings.\n * @returns {boolean} Return `true` if the value is considered empty, otherwise `false`.\n * @example\n * isEmptyValue({});\n * // ➔ true\n * isEmptyValue([]);\n * // ➔ true\n * isEmptyValue({ key: \"value\" });\n * // ➔ false\n * isEmptyValue({ [Symbol(\"foo\")]: 123 });\n * // ➔ true (default `checkSymbols` is `false`)\n * isEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: false });\n * // ➔ true (default `checkSymbols` is `false`)\n * isEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: true });\n * // ➔ false\n * isEmptyValue([1, 2, 3]);\n * // ➔ false\n * isEmptyValue(NaN);\n * // ➔ true\n * isEmptyValue(true);\n * // ➔ false\n * isEmptyValue(false);\n * // ➔ true\n * isEmptyValue(null);\n * // ➔ true\n * isEmptyValue(undefined);\n * // ➔ true\n * isEmptyValue(\"\");\n * // ➔ true\n * isEmptyValue(\"   \");\n * // ➔ true\n * isEmptyValue(0);\n * // ➔ false\n * isEmptyValue(-1);\n * // ➔ false\n * isEmptyValue(2);\n * // ➔ false\n * isEmptyValue(() => {});\n * // ➔ false\n */\nexport const isEmptyValue = (\n  value: unknown,\n  options: IsEmptyValueOptions = {}\n): boolean => {\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const checkSymbols = hasOwnProp(options, \"checkSymbols\")\n    ? options.checkSymbols\n    : false;\n\n  assertIsBoolean(checkSymbols, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`checkSymbols\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  if (isNil(value) || value === false || isNaN(value)) return true;\n  if (isString(value)) return isEmptyString(value);\n  if (isArray(value)) return isEmptyArray(value);\n  if (isObject(value)) {\n    return isEmptyObject(value, { checkSymbols });\n  }\n\n  return false;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EA,MAAa,gBACX,OACA,UAA+B,CAAC,MACpB;CACZ,oBAAoB,SAAS,EAC3B,UAAU,EAAE,aAAa,gBACvB,oDAAoD,UAAU,sBAAsB,YAAY,KACpG,CAAC;CAED,MAAM,eAAe,WAAW,SAAS,cAAc,IACnD,QAAQ,eACR;CAEJ,gBAAgB,cAAc,EAC5B,UAAU,EAAE,aAAa,gBACvB,+FAA+F,UAAU,sBAAsB,YAAY,KAC/I,CAAC;CAED,IAAI,MAAM,KAAK,KAAK,UAAU,SAAS,MAAM,KAAK,GAAG,OAAO;CAC5D,IAAI,SAAS,KAAK,GAAG,OAAO,cAAc,KAAK;CAC/C,IAAI,QAAQ,KAAK,GAAG,OAAO,aAAa,KAAK;CAC7C,IAAI,SAAS,KAAK,GAChB,OAAO,cAAc,OAAO,EAAE,aAAa,CAAC;CAG9C,OAAO;AACT"}

package/dist/isEqual-DM4S_kWh.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isEqual-DM4S_kWh.js","names":[],"sources":["../src/predicates/is/isRegExp.ts","../src/predicates/is/isArrayBuffer.ts","../src/predicates/is/_private/baseDeepEqual.ts","../src/predicates/is/isEqual.ts"],"sourcesContent":["/** ----------------------------------------------------------\n * * ***Type guard: `isRegExp`.***\n * ----------------------------------------------------------\n * **Checks if a value is a [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp) instance.**\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if value is an instance of **`RegExp`**.\n * @example\n * isRegExp(/abc/);             // ➔ true\n * isRegExp(new RegExp(\"abc\")); // ➔ true\n * isRegExp(\"abc\");             // ➔ false\n */\nexport const isRegExp = (value: unknown): value is RegExp => {\n  return value instanceof RegExp;\n};\n","/** ----------------------------------------------------\n * * ***Type guard: `isArrayBuffer`.***\n * ----------------------------------------------------\n * **Checks if `value` is classified as an `ArrayBuffer` object.**\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is instance of ***[`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)***, else `false`.\n * @example\n * isArrayBuffer(new ArrayBuffer(2));\n * // ➔ true\n * isArrayBuffer(new Array(2));\n * // ➔ false\n */\nexport function isArrayBuffer(value: unknown): value is ArrayBuffer {\n  return value instanceof ArrayBuffer;\n}\n","import type { CustomizerIsEqualWith } from \"./types.isEqualWith\";\n\nimport { isMap } from \"../isMap\";\nimport { isSet } from \"../isSet\";\nimport { isDate } from \"../isDate\";\nimport { isArray } from \"../isArray\";\nimport { isError } from \"../isError\";\nimport { isRegExp } from \"../isRegExp\";\nimport { isUndefined } from \"../isUndefined\";\nimport { isArrayBuffer } from \"../isArrayBuffer\";\nimport { isObjectOrArray } from \"../isObjectOrArray\";\n\n/** -------------------------------------------------------------------\n * * ***Base function (**Internal**) for deep equality comparison with optional customizer.***\n * -------------------------------------------------------------------\n * **Recursively checks whether `value` and `other` are deeply equal. Supports custom comparison\n * via `customizer`, and handles arrays, objects, maps, sets, dates, errors, regexps, typed arrays,\n * and nested structures.**\n * @param value\n * - The value to compare.\n * @param other\n * - The other value to compare against.\n * @param customizer\n * - Optional function to customize the comparison for each property/value.\n * @param seen\n * - WeakMap used internally to track circular references and prevent infinite recursion.\n * @returns\n * - `true`  → `value` and `other` are deeply equal.\n * - `false` → `value` and `other` are not deeply equal.\n * @example\n * ```ts\n * const obj1 = { name: \"Alice\", scores: [1, 2, 3] };\n * const obj2 = { name: \"alice\", scores: [1, 2, 3] };\n * const customizer: CustomizerIsEqualWith = (v, o) => {\n *   if (typeof v === \"string\" && typeof o === \"string\") {\n *     return v.toLowerCase() === o.toLowerCase();\n *   }\n * };\n *\n * baseDeepEqual(obj1, obj2, customizer);\n * // returns true\n * ```\n */\nexport function baseDeepEqual(\n  value: unknown,\n  other: unknown,\n  customizer?: CustomizerIsEqualWith,\n  seen: WeakMap<object, object> = new WeakMap()\n): boolean {\n  // ✅ Strict equality (+0 === -0)\n  if (value === other) return true;\n\n  // ✅ NaN === NaN\n  if (value !== value && other !== other) return true;\n\n  // ❌ Primitives mismatch\n  if (!isObjectOrArray(value) || !isObjectOrArray(other)) {\n    return false;\n  }\n\n  // ✅ Prevent circular recursion\n  if (seen.get(value) === other) return true;\n  seen.set(value, other);\n\n  // ✅ Customizer support\n  const callCustomizer = (\n    v: unknown,\n    o: unknown,\n    key: PropertyKey,\n    valObj: unknown,\n    othObj: unknown\n  ) => {\n    if (customizer) {\n      const result = customizer(v, o, key, valObj, othObj, seen);\n      if (!isUndefined(result)) return result;\n    }\n    return baseDeepEqual(v, o, customizer, seen);\n  };\n\n  // ✅ Handle special instances\n  if (isDate(value) && isDate(other))\n    return value.getTime() === other.getTime();\n\n  if (isRegExp(value) && isRegExp(other))\n    return value.source === other.source && value.flags === other.flags;\n\n  if (isError(value) && isError(other))\n    return value.name === other.name && value.message === other.message;\n\n  if (ArrayBuffer.isView(value) && ArrayBuffer.isView(other)) {\n    const v = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n    const o = new Uint8Array(other.buffer, other.byteOffset, other.byteLength);\n    if (v.length !== o.length) return false;\n    for (let i = 0; i < v.length; i++) if (v[i] !== o[i]) return false;\n    return true;\n  }\n\n  if (isArrayBuffer(value) && isArrayBuffer(other)) {\n    if (value.byteLength !== other.byteLength) return false;\n    const v = new Uint8Array(value),\n      o = new Uint8Array(other);\n    for (let i = 0; i < v.length; i++) if (v[i] !== o[i]) return false;\n    return true;\n  }\n\n  if (isMap(value) && isMap(other)) {\n    if (value.size !== other.size) return false;\n    for (const [k, v] of value) {\n      if (!other.has(k)) return false;\n      if (!baseDeepEqual(v, other.get(k), customizer, seen)) return false;\n    }\n    return true;\n  }\n\n  if (isSet(value) && isSet(other)) {\n    if (value.size !== other.size) return false;\n    for (const v of value) {\n      let matched = false;\n      for (const o of other) {\n        if (baseDeepEqual(v, o, customizer, seen)) {\n          matched = true;\n          break;\n        }\n      }\n      if (!matched) return false;\n    }\n    return true;\n  }\n\n  if (isArray(value) && isArray(other)) {\n    if (value.length !== other.length) return false;\n    for (let i = 0; i < value.length; i++) {\n      if (!callCustomizer(value[i], other[i], i, value, other)) return false;\n    }\n    return true;\n  }\n\n  if (Object.getPrototypeOf(value) !== Object.getPrototypeOf(other)) {\n    return false;\n  }\n\n  const vKeys = Reflect.ownKeys(value);\n  const oKeys = Reflect.ownKeys(other);\n  if (vKeys.length !== oKeys.length) return false;\n\n  for (const key of vKeys) {\n    const vVal = value[key];\n    const oVal = other[key];\n    if (!callCustomizer(vVal, oVal, key, value, other)) return false;\n  }\n\n  return true;\n}\n","import { baseDeepEqual } from \"@/predicates/is/_private/baseDeepEqual\";\n\n/** ----------------------------------------------------\n * * ***Predicate: `isEqual`.***\n * ----------------------------------------------------------\n * **Performs a deep comparison between two values to determine if they are equivalent.**\n * @description\n * Checks whether two values are **deeply equal**, not just reference-equal (`===`).\n * - **✅ This method compares:**\n *   - Arrays and TypedArrays\n *   - ArrayBuffers\n *   - Plain objects (`Object`) ➔ own enumerable properties only\n *   - Booleans, Numbers, Strings, Symbols\n *   - Dates\n *   - Errors\n *   - Maps\n *   - Sets\n *   - Regular expressions\n * - ❌ `Functions` and `DOM nodes` are ***not supported***.\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n * const obj1 = { user: \"fred\" };\n * const obj2 = { user: \"fred\" };\n *\n * isEqual(obj1, obj2);\n * // ➔ true\n * obj1 === obj2;\n * // ➔ false (different references)\n * isEqual([1, 2, 3], [1, 2, 3]);\n * // ➔ true\n * isEqual(new Date(\"2020-01-01\"), new Date(\"2020-01-01\"));\n * // ➔ true\n * isEqual(new Set([1, 2]), new Set([2, 1]));\n * // ➔ true\n * isEqual(/abc/i, new RegExp(\"abc\", \"i\"));\n * // ➔ true\n * isEqual({ a: 1 }, { a: 1, b: undefined });\n * // ➔ false\n */\nexport function isEqual(value: unknown, other: unknown): boolean {\n  return baseDeepEqual(value, other, undefined, new WeakMap());\n}\n"],"mappings":"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"}

package/dist/isEqual-DaPDxMyw.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isEqual-DaPDxMyw.cjs","names":["isObjectOrArray","isUndefined","isDate","isError","isMap","isSet","isArray"],"sources":["../src/predicates/is/isRegExp.ts","../src/predicates/is/isArrayBuffer.ts","../src/predicates/is/_private/baseDeepEqual.ts","../src/predicates/is/isEqual.ts"],"sourcesContent":["/** ----------------------------------------------------------\n * * ***Type guard: `isRegExp`.***\n * ----------------------------------------------------------\n * **Checks if a value is a [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp) instance.**\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if value is an instance of **`RegExp`**.\n * @example\n * isRegExp(/abc/);             // ➔ true\n * isRegExp(new RegExp(\"abc\")); // ➔ true\n * isRegExp(\"abc\");             // ➔ false\n */\nexport const isRegExp = (value: unknown): value is RegExp => {\n  return value instanceof RegExp;\n};\n","/** ----------------------------------------------------\n * * ***Type guard: `isArrayBuffer`.***\n * ----------------------------------------------------\n * **Checks if `value` is classified as an `ArrayBuffer` object.**\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is instance of ***[`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)***, else `false`.\n * @example\n * isArrayBuffer(new ArrayBuffer(2));\n * // ➔ true\n * isArrayBuffer(new Array(2));\n * // ➔ false\n */\nexport function isArrayBuffer(value: unknown): value is ArrayBuffer {\n  return value instanceof ArrayBuffer;\n}\n","import type { CustomizerIsEqualWith } from \"./types.isEqualWith\";\n\nimport { isMap } from \"../isMap\";\nimport { isSet } from \"../isSet\";\nimport { isDate } from \"../isDate\";\nimport { isArray } from \"../isArray\";\nimport { isError } from \"../isError\";\nimport { isRegExp } from \"../isRegExp\";\nimport { isUndefined } from \"../isUndefined\";\nimport { isArrayBuffer } from \"../isArrayBuffer\";\nimport { isObjectOrArray } from \"../isObjectOrArray\";\n\n/** -------------------------------------------------------------------\n * * ***Base function (**Internal**) for deep equality comparison with optional customizer.***\n * -------------------------------------------------------------------\n * **Recursively checks whether `value` and `other` are deeply equal. Supports custom comparison\n * via `customizer`, and handles arrays, objects, maps, sets, dates, errors, regexps, typed arrays,\n * and nested structures.**\n * @param value\n * - The value to compare.\n * @param other\n * - The other value to compare against.\n * @param customizer\n * - Optional function to customize the comparison for each property/value.\n * @param seen\n * - WeakMap used internally to track circular references and prevent infinite recursion.\n * @returns\n * - `true`  → `value` and `other` are deeply equal.\n * - `false` → `value` and `other` are not deeply equal.\n * @example\n * ```ts\n * const obj1 = { name: \"Alice\", scores: [1, 2, 3] };\n * const obj2 = { name: \"alice\", scores: [1, 2, 3] };\n * const customizer: CustomizerIsEqualWith = (v, o) => {\n *   if (typeof v === \"string\" && typeof o === \"string\") {\n *     return v.toLowerCase() === o.toLowerCase();\n *   }\n * };\n *\n * baseDeepEqual(obj1, obj2, customizer);\n * // returns true\n * ```\n */\nexport function baseDeepEqual(\n  value: unknown,\n  other: unknown,\n  customizer?: CustomizerIsEqualWith,\n  seen: WeakMap<object, object> = new WeakMap()\n): boolean {\n  // ✅ Strict equality (+0 === -0)\n  if (value === other) return true;\n\n  // ✅ NaN === NaN\n  if (value !== value && other !== other) return true;\n\n  // ❌ Primitives mismatch\n  if (!isObjectOrArray(value) || !isObjectOrArray(other)) {\n    return false;\n  }\n\n  // ✅ Prevent circular recursion\n  if (seen.get(value) === other) return true;\n  seen.set(value, other);\n\n  // ✅ Customizer support\n  const callCustomizer = (\n    v: unknown,\n    o: unknown,\n    key: PropertyKey,\n    valObj: unknown,\n    othObj: unknown\n  ) => {\n    if (customizer) {\n      const result = customizer(v, o, key, valObj, othObj, seen);\n      if (!isUndefined(result)) return result;\n    }\n    return baseDeepEqual(v, o, customizer, seen);\n  };\n\n  // ✅ Handle special instances\n  if (isDate(value) && isDate(other))\n    return value.getTime() === other.getTime();\n\n  if (isRegExp(value) && isRegExp(other))\n    return value.source === other.source && value.flags === other.flags;\n\n  if (isError(value) && isError(other))\n    return value.name === other.name && value.message === other.message;\n\n  if (ArrayBuffer.isView(value) && ArrayBuffer.isView(other)) {\n    const v = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n    const o = new Uint8Array(other.buffer, other.byteOffset, other.byteLength);\n    if (v.length !== o.length) return false;\n    for (let i = 0; i < v.length; i++) if (v[i] !== o[i]) return false;\n    return true;\n  }\n\n  if (isArrayBuffer(value) && isArrayBuffer(other)) {\n    if (value.byteLength !== other.byteLength) return false;\n    const v = new Uint8Array(value),\n      o = new Uint8Array(other);\n    for (let i = 0; i < v.length; i++) if (v[i] !== o[i]) return false;\n    return true;\n  }\n\n  if (isMap(value) && isMap(other)) {\n    if (value.size !== other.size) return false;\n    for (const [k, v] of value) {\n      if (!other.has(k)) return false;\n      if (!baseDeepEqual(v, other.get(k), customizer, seen)) return false;\n    }\n    return true;\n  }\n\n  if (isSet(value) && isSet(other)) {\n    if (value.size !== other.size) return false;\n    for (const v of value) {\n      let matched = false;\n      for (const o of other) {\n        if (baseDeepEqual(v, o, customizer, seen)) {\n          matched = true;\n          break;\n        }\n      }\n      if (!matched) return false;\n    }\n    return true;\n  }\n\n  if (isArray(value) && isArray(other)) {\n    if (value.length !== other.length) return false;\n    for (let i = 0; i < value.length; i++) {\n      if (!callCustomizer(value[i], other[i], i, value, other)) return false;\n    }\n    return true;\n  }\n\n  if (Object.getPrototypeOf(value) !== Object.getPrototypeOf(other)) {\n    return false;\n  }\n\n  const vKeys = Reflect.ownKeys(value);\n  const oKeys = Reflect.ownKeys(other);\n  if (vKeys.length !== oKeys.length) return false;\n\n  for (const key of vKeys) {\n    const vVal = value[key];\n    const oVal = other[key];\n    if (!callCustomizer(vVal, oVal, key, value, other)) return false;\n  }\n\n  return true;\n}\n","import { baseDeepEqual } from \"@/predicates/is/_private/baseDeepEqual\";\n\n/** ----------------------------------------------------\n * * ***Predicate: `isEqual`.***\n * ----------------------------------------------------------\n * **Performs a deep comparison between two values to determine if they are equivalent.**\n * @description\n * Checks whether two values are **deeply equal**, not just reference-equal (`===`).\n * - **✅ This method compares:**\n *   - Arrays and TypedArrays\n *   - ArrayBuffers\n *   - Plain objects (`Object`) ➔ own enumerable properties only\n *   - Booleans, Numbers, Strings, Symbols\n *   - Dates\n *   - Errors\n *   - Maps\n *   - Sets\n *   - Regular expressions\n * - ❌ `Functions` and `DOM nodes` are ***not supported***.\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n * const obj1 = { user: \"fred\" };\n * const obj2 = { user: \"fred\" };\n *\n * isEqual(obj1, obj2);\n * // ➔ true\n * obj1 === obj2;\n * // ➔ false (different references)\n * isEqual([1, 2, 3], [1, 2, 3]);\n * // ➔ true\n * isEqual(new Date(\"2020-01-01\"), new Date(\"2020-01-01\"));\n * // ➔ true\n * isEqual(new Set([1, 2]), new Set([2, 1]));\n * // ➔ true\n * isEqual(/abc/i, new RegExp(\"abc\", \"i\"));\n * // ➔ true\n * isEqual({ a: 1 }, { a: 1, b: undefined });\n * // ➔ false\n */\nexport function isEqual(value: unknown, other: unknown): boolean {\n  return baseDeepEqual(value, other, undefined, new WeakMap());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAWA,MAAa,YAAY,UAAoC;CAC3D,OAAO,iBAAiB;AAC1B;;;;;;;;;;;;;;;;ACDA,SAAgB,cAAc,OAAsC;CAClE,OAAO,iBAAiB;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC6BA,SAAgB,cACd,OACA,OACA,YACA,uBAAgC,IAAI,QAAQ,GACnC;CAET,IAAI,UAAU,OAAO,OAAO;CAG5B,IAAI,UAAU,SAAS,UAAU,OAAO,OAAO;CAG/C,IAAI,CAACA,wCAAgB,KAAK,KAAK,CAACA,wCAAgB,KAAK,GACnD,OAAO;CAIT,IAAI,KAAK,IAAI,KAAK,MAAM,OAAO,OAAO;CACtC,KAAK,IAAI,OAAO,KAAK;CAGrB,MAAM,kBACJ,GACA,GACA,KACA,QACA,WACG;EACH,IAAI,YAAY;GACd,MAAM,SAAS,WAAW,GAAG,GAAG,KAAK,QAAQ,QAAQ,IAAI;GACzD,IAAI,CAACC,oCAAY,MAAM,GAAG,OAAO;EACnC;EACA,OAAO,cAAc,GAAG,GAAG,YAAY,IAAI;CAC7C;CAGA,IAAIC,mCAAO,KAAK,KAAKA,mCAAO,KAAK,GAC/B,OAAO,MAAM,QAAQ,MAAM,MAAM,QAAQ;CAE3C,IAAI,SAAS,KAAK,KAAK,SAAS,KAAK,GACnC,OAAO,MAAM,WAAW,MAAM,UAAU,MAAM,UAAU,MAAM;CAEhE,IAAIC,gCAAQ,KAAK,KAAKA,gCAAQ,KAAK,GACjC,OAAO,MAAM,SAAS,MAAM,QAAQ,MAAM,YAAY,MAAM;CAE9D,IAAI,YAAY,OAAO,KAAK,KAAK,YAAY,OAAO,KAAK,GAAG;EAC1D,MAAM,IAAI,IAAI,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;EACzE,MAAM,IAAI,IAAI,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;EACzE,IAAI,EAAE,WAAW,EAAE,QAAQ,OAAO;EAClC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO;EAC7D,OAAO;CACT;CAEA,IAAI,cAAc,KAAK,KAAK,cAAc,KAAK,GAAG;EAChD,IAAI,MAAM,eAAe,MAAM,YAAY,OAAO;EAClD,MAAM,IAAI,IAAI,WAAW,KAAK,GAC5B,IAAI,IAAI,WAAW,KAAK;EAC1B,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO;EAC7D,OAAO;CACT;CAEA,IAAIC,kCAAM,KAAK,KAAKA,kCAAM,KAAK,GAAG;EAChC,IAAI,MAAM,SAAS,MAAM,MAAM,OAAO;EACtC,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO;GAC1B,IAAI,CAAC,MAAM,IAAI,CAAC,GAAG,OAAO;GAC1B,IAAI,CAAC,cAAc,GAAG,MAAM,IAAI,CAAC,GAAG,YAAY,IAAI,GAAG,OAAO;EAChE;EACA,OAAO;CACT;CAEA,IAAIC,8BAAM,KAAK,KAAKA,8BAAM,KAAK,GAAG;EAChC,IAAI,MAAM,SAAS,MAAM,MAAM,OAAO;EACtC,KAAK,MAAM,KAAK,OAAO;GACrB,IAAI,UAAU;GACd,KAAK,MAAM,KAAK,OACd,IAAI,cAAc,GAAG,GAAG,YAAY,IAAI,GAAG;IACzC,UAAU;IACV;GACF;GAEF,IAAI,CAAC,SAAS,OAAO;EACvB;EACA,OAAO;CACT;CAEA,IAAIC,gCAAQ,KAAK,KAAKA,gCAAQ,KAAK,GAAG;EACpC,IAAI,MAAM,WAAW,MAAM,QAAQ,OAAO;EAC1C,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAChC,IAAI,CAAC,eAAe,MAAM,IAAI,MAAM,IAAI,GAAG,OAAO,KAAK,GAAG,OAAO;EAEnE,OAAO;CACT;CAEA,IAAI,OAAO,eAAe,KAAK,MAAM,OAAO,eAAe,KAAK,GAC9D,OAAO;CAGT,MAAM,QAAQ,QAAQ,QAAQ,KAAK;CACnC,MAAM,QAAQ,QAAQ,QAAQ,KAAK;CACnC,IAAI,MAAM,WAAW,MAAM,QAAQ,OAAO;CAE1C,KAAK,MAAM,OAAO,OAAO;EACvB,MAAM,OAAO,MAAM;EACnB,MAAM,OAAO,MAAM;EACnB,IAAI,CAAC,eAAe,MAAM,MAAM,KAAK,OAAO,KAAK,GAAG,OAAO;CAC7D;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/GA,SAAgB,QAAQ,OAAgB,OAAyB;CAC/D,OAAO,cAAc,OAAO,OAAO,wBAAW,IAAI,QAAQ,CAAC;AAC7D"}

package/dist/isFinite-BEJFOv6B.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isFinite-BEJFOv6B.js","names":[],"sources":["../src/predicates/is/isFinite.ts"],"sourcesContent":["import { isNumber } from \"./isNumber\";\n\n/** ----------------------------------------------------------\n * * ***Type guard: `isFinite`.***\n * -----------------------------------------------------------\n * **Checks if a value is a finite primitive number.**\n * @description\n * This function verifies that `value` is a **primitive number** and is **finite**\n * (i.e., not `NaN`, `Infinity`, or `-Infinity`).\n * - **Behavior:**\n *    - Behaves like\n *      [`Number.isFinite()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite).\n *    - But also works as a **TypeScript type guard**.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if `value` is a finite primitive number, else `false`.\n * @example\n * import * as RzlUtilsJs from \"@rzl-zone/utils-js/predicates\";\n *\n * // Strict finite number check (only primitive numbers)\n * RzlUtilsJs.isFinite(3);\n * // ➔ true\n * RzlUtilsJs.isFinite(Number.MIN_VALUE);\n * // ➔ true\n * RzlUtilsJs.isFinite(\"3\");\n * // ➔ false (string is not a number)\n * RzlUtilsJs.isFinite(NaN);\n * // ➔ false\n * RzlUtilsJs.isFinite(Infinity);\n * // ➔ false\n * RzlUtilsJs.isFinite(new Number(3));\n * // ➔ false (Number object is not primitive)\n *\n * // Comparison with global isFinite()\n * isFinite(\"3\");\n * // ➔ true (global coerces string to number)\n * isFinite(new Number(3));\n * // ➔ true (object coerced to primitive number)\n */\nexport function isFinite(value: unknown): value is number {\n  return isNumber(value) && Number.isFinite(value);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,SAAS,OAAiC;CACxD,OAAO,SAAS,KAAK,KAAK,OAAO,SAAS,KAAK;AACjD"}

package/dist/isFinite-DeDaBDr2.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isFinite-DeDaBDr2.cjs","names":["isNumber"],"sources":["../src/predicates/is/isFinite.ts"],"sourcesContent":["import { isNumber } from \"./isNumber\";\n\n/** ----------------------------------------------------------\n * * ***Type guard: `isFinite`.***\n * -----------------------------------------------------------\n * **Checks if a value is a finite primitive number.**\n * @description\n * This function verifies that `value` is a **primitive number** and is **finite**\n * (i.e., not `NaN`, `Infinity`, or `-Infinity`).\n * - **Behavior:**\n *    - Behaves like\n *      [`Number.isFinite()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite).\n *    - But also works as a **TypeScript type guard**.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if `value` is a finite primitive number, else `false`.\n * @example\n * import * as RzlUtilsJs from \"@rzl-zone/utils-js/predicates\";\n *\n * // Strict finite number check (only primitive numbers)\n * RzlUtilsJs.isFinite(3);\n * // ➔ true\n * RzlUtilsJs.isFinite(Number.MIN_VALUE);\n * // ➔ true\n * RzlUtilsJs.isFinite(\"3\");\n * // ➔ false (string is not a number)\n * RzlUtilsJs.isFinite(NaN);\n * // ➔ false\n * RzlUtilsJs.isFinite(Infinity);\n * // ➔ false\n * RzlUtilsJs.isFinite(new Number(3));\n * // ➔ false (Number object is not primitive)\n *\n * // Comparison with global isFinite()\n * isFinite(\"3\");\n * // ➔ true (global coerces string to number)\n * isFinite(new Number(3));\n * // ➔ true (object coerced to primitive number)\n */\nexport function isFinite(value: unknown): value is number {\n  return isNumber(value) && Number.isFinite(value);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,SAAS,OAAiC;CACxD,OAAOA,iCAAS,KAAK,KAAK,OAAO,SAAS,KAAK;AACjD"}

package/dist/isInteger-CQLThJOR.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isInteger-CQLThJOR.cjs","names":[],"sources":["../src/predicates/is/isInteger.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Type guard: `isInteger`.***\n * ----------------------------------------------------------\n * **Checks if a value is an integer number.**\n * - **ℹ️ Note:**\n *    - This method is based on\n *      [`Number.isInteger`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger).\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n * @example\n * isInteger(3);\n * // ➔ true\n * isInteger(Number.MIN_VALUE);\n * // ➔ false\n * isInteger(NaN);\n * // ➔ false\n * isInteger(Infinity);\n * // ➔ false\n * isInteger(-Infinity);\n * // ➔ false\n * isInteger('3');\n * // ➔ false\n */\nexport function isInteger(value: unknown): value is number {\n  return typeof value === \"number\" && Number.isInteger(value);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,UAAU,OAAiC;CACzD,OAAO,OAAO,UAAU,YAAY,OAAO,UAAU,KAAK;AAC5D"}

package/dist/isInteger-DEDbBGez.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isInteger-DEDbBGez.js","names":[],"sources":["../src/predicates/is/isInteger.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Type guard: `isInteger`.***\n * ----------------------------------------------------------\n * **Checks if a value is an integer number.**\n * - **ℹ️ Note:**\n *    - This method is based on\n *      [`Number.isInteger`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger).\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n * @example\n * isInteger(3);\n * // ➔ true\n * isInteger(Number.MIN_VALUE);\n * // ➔ false\n * isInteger(NaN);\n * // ➔ false\n * isInteger(Infinity);\n * // ➔ false\n * isInteger(-Infinity);\n * // ➔ false\n * isInteger('3');\n * // ➔ false\n */\nexport function isInteger(value: unknown): value is number {\n  return typeof value === \"number\" && Number.isInteger(value);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,UAAU,OAAiC;CACzD,OAAO,OAAO,UAAU,YAAY,OAAO,UAAU,KAAK;AAC5D"}

package/dist/isPlainObject-BwTkj3G0.d.cts

@@ -1,339 +0,0 @@
-/*!
-* ========================================================================
-*  @rzl-zone/utils-js
-* ------------------------------------------------------------------------
-*  Version: `3.13.1`
-*  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 };