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

package/dist/isEmptyString-O4TFe1Ao.cjs.map

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

package/dist/isEmptyValue-CFExALXZ.cjs

@@ -0,0 +1,54 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.14.0-beta.0`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+"use strict";
+const require_logger = require('./logger-CUacYy3D.cjs');
+const require_isEmptyString = require('./isEmptyString-O4TFe1Ao.cjs');
+const isEmptyArray = (value) => {
+	if (!require_logger.isArray(value)) return true;
+	return value.length === 0;
+};
+const isEmptyObject = (value, options = {}) => {
+	if (!require_logger.isObject(value)) return true;
+	if (!require_logger.isPlainObject(options)) options = {};
+	const checkSymbols = options.checkSymbols ?? false;
+	require_logger.assertIsBoolean(checkSymbols, { message: ({ currentType, validType }) => require_logger.createMessage("isEmptyObject", `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;
+};
+const isEmptyValue = (value, options = {}) => {
+	if (!require_logger.isPlainObject(options)) options = {};
+	const checkSymbols = options.checkSymbols ?? false;
+	require_logger.assertIsBoolean(checkSymbols, { message: ({ currentType, validType }) => require_logger.createMessage("isEmptyValue", `Parameter \`checkSymbols\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`) });
+	if (require_logger.isNil(value) || value === false || require_logger.isNaN(value)) return true;
+	if (require_logger.isString(value)) return require_isEmptyString.isEmptyString(value);
+	if (require_logger.isArray(value)) return isEmptyArray(value);
+	if (require_logger.isObject(value)) return isEmptyObject(value, { checkSymbols });
+	return false;
+};
+Object.defineProperty(exports, 'isEmptyArray', {
+  enumerable: true,
+  get: function () {
+    return isEmptyArray;
+  }
+});
+Object.defineProperty(exports, 'isEmptyObject', {
+  enumerable: true,
+  get: function () {
+    return isEmptyObject;
+  }
+});
+Object.defineProperty(exports, 'isEmptyValue', {
+  enumerable: true,
+  get: function () {
+    return isEmptyValue;
+  }
+});
+//# sourceMappingURL=isEmptyValue-CFExALXZ.cjs.map

package/dist/isEmptyValue-CFExALXZ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEmptyValue-CFExALXZ.cjs","names":["isArray","isObject","isPlainObject","createMessage","isPlainObject","createMessage","isNil","isNaN","isString","isEmptyString","isArray","isObject"],"sources":["../src/predicates/is/isEmptyArray.ts","../src/predicates/is/isEmptyObject.ts","../src/predicates/is/isEmptyValue.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 *\n * ---\n * - **Behavior:**\n *     - Non-array inputs are considered ***`empty`*** ***(defensive strategy)***.\n *\n * ---\n * @param {*} [value] - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if it's ***not an array*** or ***an empty-array***.\n *\n * ---\n * @example\n * isEmptyArray([]);\n * // ➔ true\n * isEmptyArray([1, 2, 3]);\n * // ➔ false\n * isEmptyArray(\"not an array\");\n * // ➔ true\n * isEmptyArray(null);\n * // ➔ true\n * isEmptyArray(undefined);\n * // ➔ 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 { createMessage } from \"@/_private/logger\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\n\nimport { isObject } from \"./isObject\";\nimport { isPlainObject } from \"./isPlainObject\";\n\ntype IsEmptyObjectOptions = {\n  /** ----------------------------------------------------------\n   * * ***Whether to check for symbol properties in addition to string keys, defaultValue: `false`.***\n   * -----------------------------------------------------------\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 *\n * ---\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 *\n * ---\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 *\n * ---\n * @returns {boolean} Return `true` if the value is considered empty or not an object, false otherwise.\n *\n * ---\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 const isEmptyObject = (\n  value: unknown,\n  options: IsEmptyObjectOptions = {}\n): boolean => {\n  if (!isObject(value)) return true;\n  if (!isPlainObject(options)) options = {};\n\n  const checkSymbols = options.checkSymbols ?? false;\n\n  assertIsBoolean(checkSymbols, {\n    message: ({ currentType, validType }) =>\n      createMessage(\n        \"isEmptyObject\",\n        `Parameter \\`checkSymbols\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\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","import { createMessage } from \"@/_private/logger\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\n\nimport { isNaN } from \"./isNaN\";\nimport { isNil } from \"./isNil\";\nimport { isArray } from \"./isArray\";\nimport { isObject } from \"./isObject\";\nimport { isString } from \"./isString\";\nimport { isEmptyArray } from \"./isEmptyArray\";\nimport { isEmptyObject } from \"./isEmptyObject\";\nimport { isEmptyString } from \"./isEmptyString\";\nimport { isPlainObject } from \"./isPlainObject\";\n\ntype IsEmptyValueOptions = {\n  /** ----------------------------------------------------------\n   * * ***Whether to check symbol properties when checking empty objects.***\n   * ----------------------------------------------------------\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyValue`.***\n * -----------------------------------------------------------\n * **Determines if a value is **`empty`**.**\n *\n * ---\n * - #### *Behavior:*\n *      - #### Covering:\n *           - Empty objects: `{}`.\n *           - Empty arrays: `[]`.\n *           - Empty strings: `\"\"` or whitespace-only (trimmed).\n *           - `null`, `undefined`, `false`, or `NaN`.\n *           ---\n *      - #### Returns **`false`** for:\n *           - Non-empty objects/arrays.\n *           - Non-empty strings.\n *           - Numbers (except `NaN`).\n *           - `Functions`, `true`, `symbols`, `etc`.\n *\n * ---\n * @param {*} value - The value to evaluate.\n * @param {IsEmptyValueOptions} [options] - Optional settings.\n *\n * ---\n * @returns {boolean} Return `true` if the value is considered empty, otherwise `false`.\n *\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  if (!isPlainObject(options)) options = {};\n\n  const checkSymbols = options.checkSymbols ?? false;\n\n  assertIsBoolean(checkSymbols, {\n    message: ({ currentType, validType }) =>\n      createMessage(\n        \"isEmptyValue\",\n        `Parameter \\`checkSymbols\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,gBAAgB,UAA4B;CACvD,IAAI,CAACA,uBAAQ,KAAK,GAAG,OAAO;CAE5B,OAAO,MAAM,WAAW;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACiBA,MAAa,iBACX,OACA,UAAgC,CAAC,MACrB;CACZ,IAAI,CAACC,wBAAS,KAAK,GAAG,OAAO;CAC7B,IAAI,CAACC,6BAAc,OAAO,GAAG,UAAU,CAAC;CAExC,MAAM,eAAe,QAAQ,gBAAgB;CAE7C,+BAAgB,cAAc,EAC5B,UAAU,EAAE,aAAa,gBACvBC,6BACE,iBACA,+FAA+F,UAAU,sBAAsB,YAAY,IAC7I,EACJ,CAAC;CAED,MAAM,YAAY,OAAO,KAAK,KAAK,EAAE,WAAW;CAChD,IAAI,cACF,OAAO,aAAa,OAAO,sBAAsB,KAAK,EAAE,WAAW;CAErE,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACWA,MAAa,gBACX,OACA,UAA+B,CAAC,MACpB;CACZ,IAAI,CAACC,6BAAc,OAAO,GAAG,UAAU,CAAC;CAExC,MAAM,eAAe,QAAQ,gBAAgB;CAE7C,+BAAgB,cAAc,EAC5B,UAAU,EAAE,aAAa,gBACvBC,6BACE,gBACA,+FAA+F,UAAU,sBAAsB,YAAY,IAC7I,EACJ,CAAC;CAED,IAAIC,qBAAM,KAAK,KAAK,UAAU,SAASC,qBAAM,KAAK,GAAG,OAAO;CAC5D,IAAIC,wBAAS,KAAK,GAAG,OAAOC,oCAAc,KAAK;CAC/C,IAAIC,uBAAQ,KAAK,GAAG,OAAO,aAAa,KAAK;CAC7C,IAAIC,wBAAS,KAAK,GAChB,OAAO,cAAc,OAAO,EAAE,aAAa,CAAC;CAG9C,OAAO;AACT"}

package/dist/isEmptyValue-kCjnLjbN.js

@@ -0,0 +1,36 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.14.0-beta.0`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+import { D as isObject, E as isPlainObject, O as isArray, S as isNaN, T as isString, k as isNil, n as assertIsBoolean, t as createMessage } from "./logger-CLWnKRKE.js";
+import { t as isEmptyString } from "./isEmptyString-C9QLWjx2.js";
+const isEmptyArray = (value) => {
+	if (!isArray(value)) return true;
+	return value.length === 0;
+};
+const isEmptyObject = (value, options = {}) => {
+	if (!isObject(value)) return true;
+	if (!isPlainObject(options)) options = {};
+	const checkSymbols = options.checkSymbols ?? false;
+	assertIsBoolean(checkSymbols, { message: ({ currentType, validType }) => createMessage("isEmptyObject", `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;
+};
+const isEmptyValue = (value, options = {}) => {
+	if (!isPlainObject(options)) options = {};
+	const checkSymbols = options.checkSymbols ?? false;
+	assertIsBoolean(checkSymbols, { message: ({ currentType, validType }) => createMessage("isEmptyValue", `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 { isEmptyObject as n, isEmptyArray as r, isEmptyValue as t };
+//# sourceMappingURL=isEmptyValue-kCjnLjbN.js.map

package/dist/isEmptyValue-kCjnLjbN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEmptyValue-kCjnLjbN.js","names":[],"sources":["../src/predicates/is/isEmptyArray.ts","../src/predicates/is/isEmptyObject.ts","../src/predicates/is/isEmptyValue.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 *\n * ---\n * - **Behavior:**\n *     - Non-array inputs are considered ***`empty`*** ***(defensive strategy)***.\n *\n * ---\n * @param {*} [value] - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if it's ***not an array*** or ***an empty-array***.\n *\n * ---\n * @example\n * isEmptyArray([]);\n * // ➔ true\n * isEmptyArray([1, 2, 3]);\n * // ➔ false\n * isEmptyArray(\"not an array\");\n * // ➔ true\n * isEmptyArray(null);\n * // ➔ true\n * isEmptyArray(undefined);\n * // ➔ 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 { createMessage } from \"@/_private/logger\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\n\nimport { isObject } from \"./isObject\";\nimport { isPlainObject } from \"./isPlainObject\";\n\ntype IsEmptyObjectOptions = {\n  /** ----------------------------------------------------------\n   * * ***Whether to check for symbol properties in addition to string keys, defaultValue: `false`.***\n   * -----------------------------------------------------------\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 *\n * ---\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 *\n * ---\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 *\n * ---\n * @returns {boolean} Return `true` if the value is considered empty or not an object, false otherwise.\n *\n * ---\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 const isEmptyObject = (\n  value: unknown,\n  options: IsEmptyObjectOptions = {}\n): boolean => {\n  if (!isObject(value)) return true;\n  if (!isPlainObject(options)) options = {};\n\n  const checkSymbols = options.checkSymbols ?? false;\n\n  assertIsBoolean(checkSymbols, {\n    message: ({ currentType, validType }) =>\n      createMessage(\n        \"isEmptyObject\",\n        `Parameter \\`checkSymbols\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\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","import { createMessage } from \"@/_private/logger\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\n\nimport { isNaN } from \"./isNaN\";\nimport { isNil } from \"./isNil\";\nimport { isArray } from \"./isArray\";\nimport { isObject } from \"./isObject\";\nimport { isString } from \"./isString\";\nimport { isEmptyArray } from \"./isEmptyArray\";\nimport { isEmptyObject } from \"./isEmptyObject\";\nimport { isEmptyString } from \"./isEmptyString\";\nimport { isPlainObject } from \"./isPlainObject\";\n\ntype IsEmptyValueOptions = {\n  /** ----------------------------------------------------------\n   * * ***Whether to check symbol properties when checking empty objects.***\n   * ----------------------------------------------------------\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyValue`.***\n * -----------------------------------------------------------\n * **Determines if a value is **`empty`**.**\n *\n * ---\n * - #### *Behavior:*\n *      - #### Covering:\n *           - Empty objects: `{}`.\n *           - Empty arrays: `[]`.\n *           - Empty strings: `\"\"` or whitespace-only (trimmed).\n *           - `null`, `undefined`, `false`, or `NaN`.\n *           ---\n *      - #### Returns **`false`** for:\n *           - Non-empty objects/arrays.\n *           - Non-empty strings.\n *           - Numbers (except `NaN`).\n *           - `Functions`, `true`, `symbols`, `etc`.\n *\n * ---\n * @param {*} value - The value to evaluate.\n * @param {IsEmptyValueOptions} [options] - Optional settings.\n *\n * ---\n * @returns {boolean} Return `true` if the value is considered empty, otherwise `false`.\n *\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  if (!isPlainObject(options)) options = {};\n\n  const checkSymbols = options.checkSymbols ?? false;\n\n  assertIsBoolean(checkSymbols, {\n    message: ({ currentType, validType }) =>\n      createMessage(\n        \"isEmptyValue\",\n        `Parameter \\`checkSymbols\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,gBAAgB,UAA4B;CACvD,IAAI,CAAC,QAAQ,KAAK,GAAG,OAAO;CAE5B,OAAO,MAAM,WAAW;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACiBA,MAAa,iBACX,OACA,UAAgC,CAAC,MACrB;CACZ,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO;CAC7B,IAAI,CAAC,cAAc,OAAO,GAAG,UAAU,CAAC;CAExC,MAAM,eAAe,QAAQ,gBAAgB;CAE7C,gBAAgB,cAAc,EAC5B,UAAU,EAAE,aAAa,gBACvB,cACE,iBACA,+FAA+F,UAAU,sBAAsB,YAAY,IAC7I,EACJ,CAAC;CAED,MAAM,YAAY,OAAO,KAAK,KAAK,EAAE,WAAW;CAChD,IAAI,cACF,OAAO,aAAa,OAAO,sBAAsB,KAAK,EAAE,WAAW;CAErE,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACWA,MAAa,gBACX,OACA,UAA+B,CAAC,MACpB;CACZ,IAAI,CAAC,cAAc,OAAO,GAAG,UAAU,CAAC;CAExC,MAAM,eAAe,QAAQ,gBAAgB;CAE7C,gBAAgB,cAAc,EAC5B,UAAU,EAAE,aAAa,gBACvB,cACE,gBACA,+FAA+F,UAAU,sBAAsB,YAAY,IAC7I,EACJ,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/{isFinite-DeDaBDr2.cjs → isFinite-B_hHbDpa.cjs}

@@ -2,20 +2,20 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.1`
+*  Version: `3.14.0-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_assertIsBoolean = require('./assertIsBoolean-D41HrTB_.cjs');
-function isFinite(value) {
-	return require_assertIsBoolean.isNumber(value) && Number.isFinite(value);
-}
+const require_isNumber = require('./isNumber-BkzwAe50.cjs');
+const isFinite = (value) => {
+	return require_isNumber.isNumber(value) && Number.isFinite(value);
+};
 Object.defineProperty(exports, 'isFinite', {
   enumerable: true,
   get: function () {
     return isFinite;
   }
 });
-//# sourceMappingURL=isFinite-DeDaBDr2.cjs.map
+//# sourceMappingURL=isFinite-B_hHbDpa.cjs.map

package/dist/isFinite-B_hHbDpa.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFinite-B_hHbDpa.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 *\n * ---\n * @description\n * This function verifies that `value` is a **primitive number** and is **finite**\n * (i.e., not `NaN`, `Infinity`, or `-Infinity`).\n *\n * ---\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 *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is a finite primitive number, else `false`.\n *\n * ---\n * @example\n * 1. #### Strict finite number check (only primitive numbers):\n *    ```ts\n *    import * as RzlUtilsJs from \"@rzl-zone/utils-js/predicates\";\n *\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 *    ---\n *\n * 2. #### Comparison with `global isFinite()`:\n *    ```ts\n *    isFinite(\"3\");\n *    // ➔ true (global coerces string to number)\n *    isFinite(new Number(3));\n *    // ➔ true (object coerced to primitive number)\n *    ```\n */\nexport const isFinite = (value: unknown): value is number => {\n  return isNumber(value) && Number.isFinite(value);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,MAAa,YAAY,UAAoC;CAC3D,OAAOA,0BAAS,KAAK,KAAK,OAAO,SAAS,KAAK;AACjD"}

package/dist/{isFinite-BEJFOv6B.js → isFinite-ZvNhyHlF.js}

@@ -2,14 +2,14 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.1`
+*  Version: `3.14.0-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { w as isNumber } from "./assertIsBoolean-CWUs-I5l.js";
-function isFinite(value) {
+import { t as isNumber } from "./isNumber-BCWD4dW0.js";
+const isFinite = (value) => {
 	return isNumber(value) && Number.isFinite(value);
-}
+};
 export { isFinite as t };
-//# sourceMappingURL=isFinite-BEJFOv6B.js.map
+//# sourceMappingURL=isFinite-ZvNhyHlF.js.map

package/dist/isFinite-ZvNhyHlF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFinite-ZvNhyHlF.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 *\n * ---\n * @description\n * This function verifies that `value` is a **primitive number** and is **finite**\n * (i.e., not `NaN`, `Infinity`, or `-Infinity`).\n *\n * ---\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 *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is a finite primitive number, else `false`.\n *\n * ---\n * @example\n * 1. #### Strict finite number check (only primitive numbers):\n *    ```ts\n *    import * as RzlUtilsJs from \"@rzl-zone/utils-js/predicates\";\n *\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 *    ---\n *\n * 2. #### Comparison with `global isFinite()`:\n *    ```ts\n *    isFinite(\"3\");\n *    // ➔ true (global coerces string to number)\n *    isFinite(new Number(3));\n *    // ➔ true (object coerced to primitive number)\n *    ```\n */\nexport const isFinite = (value: unknown): value is number => {\n  return isNumber(value) && Number.isFinite(value);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,MAAa,YAAY,UAAoC;CAC3D,OAAO,SAAS,KAAK,KAAK,OAAO,SAAS,KAAK;AACjD"}

package/dist/{isInteger-DEDbBGez.js → isInteger-aZgzTTZG.js}

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.1`
+*  Version: `3.14.0-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-function isInteger(value) {
+const isInteger = (value) => {
 	return typeof value === "number" && Number.isInteger(value);
-}
+};
 export { isInteger as t };
-//# sourceMappingURL=isInteger-DEDbBGez.js.map
+//# sourceMappingURL=isInteger-aZgzTTZG.js.map

package/dist/isInteger-aZgzTTZG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isInteger-aZgzTTZG.js","names":[],"sources":["../src/predicates/is/isInteger.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Type guard: `isInteger`.***\n * ----------------------------------------------------------\n * **Checks if a value is an integer number.**\n *\n * ---\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 *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n *\n * ---\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 const isInteger = (value: unknown): value is number => {\n  return typeof value === \"number\" && Number.isInteger(value);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,aAAa,UAAoC;CAC5D,OAAO,OAAO,UAAU,YAAY,OAAO,UAAU,KAAK;AAC5D"}

package/dist/{isInteger-CQLThJOR.cjs → isInteger-dnc6W63Z.cjs}

@@ -2,19 +2,19 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.1`
+*  Version: `3.14.0-beta.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-function isInteger(value) {
+const isInteger = (value) => {
 	return typeof value === "number" && Number.isInteger(value);
-}
+};
 Object.defineProperty(exports, 'isInteger', {
   enumerable: true,
   get: function () {
     return isInteger;
   }
 });
-//# sourceMappingURL=isInteger-CQLThJOR.cjs.map
+//# sourceMappingURL=isInteger-dnc6W63Z.cjs.map

package/dist/isInteger-dnc6W63Z.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isInteger-dnc6W63Z.cjs","names":[],"sources":["../src/predicates/is/isInteger.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Type guard: `isInteger`.***\n * ----------------------------------------------------------\n * **Checks if a value is an integer number.**\n *\n * ---\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 *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n *\n * ---\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 const isInteger = (value: unknown): value is number => {\n  return typeof value === \"number\" && Number.isInteger(value);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,aAAa,UAAoC;CAC5D,OAAO,OAAO,UAAU,YAAY,OAAO,UAAU,KAAK;AAC5D"}

package/dist/isNumber-BCWD4dW0.js

@@ -0,0 +1,20 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.14.0-beta.0`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+import { E as isPlainObject, j as isBoolean, n as assertIsBoolean, t as createMessage } from "./logger-CLWnKRKE.js";
+const isNumber = (value, options = {}) => {
+	if (!isPlainObject(options)) options = {};
+	const includeNaN = isPlainObject(options) && isBoolean(options.includeNaN) ? options.includeNaN : false;
+	assertIsBoolean(includeNaN, { message: ({ currentType, validType }) => errorMsg(`Parameter \`includeNaN\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`) });
+	const aNumber = typeof value === "number";
+	return includeNaN ? aNumber : aNumber && !Number.isNaN(value);
+};
+const errorMsg = (msg) => createMessage("isNumber", msg);
+export { isNumber as t };
+//# sourceMappingURL=isNumber-BCWD4dW0.js.map

package/dist/isNumber-BCWD4dW0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNumber-BCWD4dW0.js","names":[],"sources":["../src/predicates/is/isNumber.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { isFinite } from \"./isFinite\";\n\nimport { createMessage } from \"@/_private/logger\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\n\nimport { isBoolean } from \"./isBoolean\";\nimport { isPlainObject } from \"./isPlainObject\";\n\nexport type IsNumberOptions = {\n  /** ---------------------------------------------------------\n   * * ***If set to `true`, `NaN` will be considered a valid number, defaultValue: `false`.***\n   * ----------------------------------------------------------\n   *\n   * @default false\n   */\n  includeNaN?: boolean;\n};\n\n/** ---------------------------------------------------------\n * * ***Type guard: `isNumber`.***\n * ----------------------------------------------------------\n * **Checks if a value is of type **`number`**.**\n *\n * ---\n * - #### *Behavior:*\n *      - Uses `typeof value === \"number\"`.\n *      - By default, excludes **`NaN`**.\n *      - If `options.includeNaN` is `true`, then **`NaN`** is also considered valid.\n *      - Still considers `Infinity` and `-Infinity` as **numbers** (consistent with JavaScript).\n *\n * ---\n * - #### *Note:*\n *      - To exclude `Infinity` and `-Infinity`, use **{@link isFinite | `isFinite`}** instead.\n *\n * ---\n * @param {*} value - The value to check.\n * @param {IsNumberOptions} [options] - Optional settings.\n * @param {boolean} [options.includeNaN=false]  If `true`, `NaN` will be considered a valid number, defaults to `false`, which excludes `NaN`.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a number (and depending on `includeNaN`, `NaN` is included or excluded).\n *\n * ---\n * @example\n * isNumber(42);\n * // ➔ true\n * isNumber(Infinity);\n * // ➔ true\n * isNumber(-Infinity);\n * // ➔ true\n * isNumber(NaN);\n * // ➔ false (default)\n * isNumber(NaN, { includeNaN: true });\n * // ➔ true\n * isNumber(\"42\");\n * // ➔ false\n */\nexport const isNumber = (\n  value: unknown,\n  options: IsNumberOptions = {}\n): value is number => {\n  if (!isPlainObject(options)) options = {};\n\n  const includeNaN =\n    isPlainObject(options) && isBoolean(options.includeNaN)\n      ? options.includeNaN\n      : false;\n\n  assertIsBoolean(includeNaN, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Parameter \\`includeNaN\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\n  });\n\n  const aNumber = typeof value === \"number\";\n  return includeNaN ? aNumber : aNumber && !Number.isNaN(value);\n};\n\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"isNumber\", msg);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,MAAa,YACX,OACA,UAA2B,CAAC,MACR;CACpB,IAAI,CAAC,cAAc,OAAO,GAAG,UAAU,CAAC;CAExC,MAAM,aACJ,cAAc,OAAO,KAAK,UAAU,QAAQ,UAAU,IAClD,QAAQ,aACR;CAEN,gBAAgB,YAAY,EAC1B,UAAU,EAAE,aAAa,gBACvB,SACE,6FAA6F,UAAU,sBAAsB,YAAY,IAC3I,EACJ,CAAC;CAED,MAAM,UAAU,OAAO,UAAU;CACjC,OAAO,aAAa,UAAU,WAAW,CAAC,OAAO,MAAM,KAAK;AAC9D;;;;AAKA,MAAM,YAAY,QAAgB,cAAc,YAAY,GAAG"}

package/dist/isNumber-BkzwAe50.cjs

@@ -0,0 +1,26 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.14.0-beta.0`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+"use strict";
+const require_logger = require('./logger-CUacYy3D.cjs');
+const isNumber = (value, options = {}) => {
+	if (!require_logger.isPlainObject(options)) options = {};
+	const includeNaN = require_logger.isPlainObject(options) && require_logger.isBoolean(options.includeNaN) ? options.includeNaN : false;
+	require_logger.assertIsBoolean(includeNaN, { message: ({ currentType, validType }) => errorMsg(`Parameter \`includeNaN\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`) });
+	const aNumber = typeof value === "number";
+	return includeNaN ? aNumber : aNumber && !Number.isNaN(value);
+};
+const errorMsg = (msg) => require_logger.createMessage("isNumber", msg);
+Object.defineProperty(exports, 'isNumber', {
+  enumerable: true,
+  get: function () {
+    return isNumber;
+  }
+});
+//# sourceMappingURL=isNumber-BkzwAe50.cjs.map

package/dist/isNumber-BkzwAe50.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNumber-BkzwAe50.cjs","names":["isPlainObject","isBoolean","createMessage"],"sources":["../src/predicates/is/isNumber.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { isFinite } from \"./isFinite\";\n\nimport { createMessage } from \"@/_private/logger\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\n\nimport { isBoolean } from \"./isBoolean\";\nimport { isPlainObject } from \"./isPlainObject\";\n\nexport type IsNumberOptions = {\n  /** ---------------------------------------------------------\n   * * ***If set to `true`, `NaN` will be considered a valid number, defaultValue: `false`.***\n   * ----------------------------------------------------------\n   *\n   * @default false\n   */\n  includeNaN?: boolean;\n};\n\n/** ---------------------------------------------------------\n * * ***Type guard: `isNumber`.***\n * ----------------------------------------------------------\n * **Checks if a value is of type **`number`**.**\n *\n * ---\n * - #### *Behavior:*\n *      - Uses `typeof value === \"number\"`.\n *      - By default, excludes **`NaN`**.\n *      - If `options.includeNaN` is `true`, then **`NaN`** is also considered valid.\n *      - Still considers `Infinity` and `-Infinity` as **numbers** (consistent with JavaScript).\n *\n * ---\n * - #### *Note:*\n *      - To exclude `Infinity` and `-Infinity`, use **{@link isFinite | `isFinite`}** instead.\n *\n * ---\n * @param {*} value - The value to check.\n * @param {IsNumberOptions} [options] - Optional settings.\n * @param {boolean} [options.includeNaN=false]  If `true`, `NaN` will be considered a valid number, defaults to `false`, which excludes `NaN`.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a number (and depending on `includeNaN`, `NaN` is included or excluded).\n *\n * ---\n * @example\n * isNumber(42);\n * // ➔ true\n * isNumber(Infinity);\n * // ➔ true\n * isNumber(-Infinity);\n * // ➔ true\n * isNumber(NaN);\n * // ➔ false (default)\n * isNumber(NaN, { includeNaN: true });\n * // ➔ true\n * isNumber(\"42\");\n * // ➔ false\n */\nexport const isNumber = (\n  value: unknown,\n  options: IsNumberOptions = {}\n): value is number => {\n  if (!isPlainObject(options)) options = {};\n\n  const includeNaN =\n    isPlainObject(options) && isBoolean(options.includeNaN)\n      ? options.includeNaN\n      : false;\n\n  assertIsBoolean(includeNaN, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Parameter \\`includeNaN\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\n  });\n\n  const aNumber = typeof value === \"number\";\n  return includeNaN ? aNumber : aNumber && !Number.isNaN(value);\n};\n\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"isNumber\", msg);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,MAAa,YACX,OACA,UAA2B,CAAC,MACR;CACpB,IAAI,CAACA,6BAAc,OAAO,GAAG,UAAU,CAAC;CAExC,MAAM,aACJA,6BAAc,OAAO,KAAKC,yBAAU,QAAQ,UAAU,IAClD,QAAQ,aACR;CAEN,+BAAgB,YAAY,EAC1B,UAAU,EAAE,aAAa,gBACvB,SACE,6FAA6F,UAAU,sBAAsB,YAAY,IAC3I,EACJ,CAAC;CAED,MAAM,UAAU,OAAO,UAAU;CACjC,OAAO,aAAa,UAAU,WAAW,CAAC,OAAO,MAAM,KAAK;AAC9D;;;;AAKA,MAAM,YAAY,QAAgBC,6BAAc,YAAY,GAAG"}