npm - @rzl-zone/utils-js - Versions diffs - 3.14.0-beta.0 → 3.14.0 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (196) hide show

package/dist/{isEmptyString-C9QLWjx2.js → isEmptyString-B6ubItgT.js} RENAMED Viewed

@@ -2,14 +2,14 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { w as isNonEmptyString } from "./logger-CLWnKRKE.js";
+import { w as isNonEmptyString } from "./logger-Wxl_Krg6.js";
 const isEmptyString = (value, options) => {
 	return !isNonEmptyString(value, options);
 };
 export { isEmptyString as t };
-//# sourceMappingURL=isEmptyString-C9QLWjx2.js.map
+//# sourceMappingURL=isEmptyString-B6ubItgT.js.map

package/dist/{isEmptyString-C9QLWjx2.js.map → isEmptyString-B6ubItgT.js.map} RENAMED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"isEmptyString-~~C9QLWjx2~~.js","names":[],"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,CAAC,iBAAiB,OAAO,OAAO;AACzC"}
1	+ {"version":3,"file":"isEmptyString-B6ubItgT.js","names":[],"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,CAAC,iBAAiB,OAAO,OAAO;AACzC"}

package/dist/{isEmptyString-O4TFe1Ao.cjs → isEmptyString-Csc5Sf_W.cjs} RENAMED Viewed

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.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_logger = require('./logger-BXg2xufj.cjs');
 const isEmptyString = (value, options) => {
 	return !require_logger.isNonEmptyString(value, options);
 };
@@ -18,4 +18,4 @@ Object.defineProperty(exports, 'isEmptyString', {
     return isEmptyString;
   }
 });
-//# sourceMappingURL=isEmptyString-O4TFe1Ao.cjs.map
+//# sourceMappingURL=isEmptyString-Csc5Sf_W.cjs.map

package/dist/{isEmptyString-O4TFe1Ao.cjs.map → isEmptyString-Csc5Sf_W.cjs.map} RENAMED Viewed

	@@ -1 +1 @@
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"}
1	+ {"version":3,"file":"isEmptyString-Csc5Sf_W.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-kCjnLjbN.js → isEmptyValue-h97JT4pD.js} RENAMED Viewed

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.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";
+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-Wxl_Krg6.js";
+import { t as isEmptyString } from "./isEmptyString-B6ubItgT.js";
 const isEmptyArray = (value) => {
 	if (!isArray(value)) return true;
 	return value.length === 0;
@@ -33,4 +33,4 @@ const isEmptyValue = (value, options = {}) => {
 	return false;
 };
 export { isEmptyObject as n, isEmptyArray as r, isEmptyValue as t };
-//# sourceMappingURL=isEmptyValue-kCjnLjbN.js.map
+//# sourceMappingURL=isEmptyValue-h97JT4pD.js.map

package/dist/{isEmptyValue-kCjnLjbN.js.map → isEmptyValue-h97JT4pD.js.map} RENAMED Viewed

	@@ -1 +1 @@
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"}
1	+ {"version":3,"file":"isEmptyValue-h97JT4pD.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/{isEmptyValue-CFExALXZ.cjs → isEmptyValue-qNOhUBFE.cjs} RENAMED Viewed

@@ -2,14 +2,14 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.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 require_logger = require('./logger-BXg2xufj.cjs');
+const require_isEmptyString = require('./isEmptyString-Csc5Sf_W.cjs');
 const isEmptyArray = (value) => {
 	if (!require_logger.isArray(value)) return true;
 	return value.length === 0;
@@ -51,4 +51,4 @@ Object.defineProperty(exports, 'isEmptyValue', {
     return isEmptyValue;
   }
 });
-//# sourceMappingURL=isEmptyValue-CFExALXZ.cjs.map
+//# sourceMappingURL=isEmptyValue-qNOhUBFE.cjs.map

package/dist/{isEmptyValue-CFExALXZ.cjs.map → isEmptyValue-qNOhUBFE.cjs.map} RENAMED Viewed

	@@ -1 +1 @@
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"}
1	+ {"version":3,"file":"isEmptyValue-qNOhUBFE.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/{isFinite-B_hHbDpa.cjs → isFinite-CKeuVXbD.cjs} RENAMED Viewed

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

package/dist/{isFinite-B_hHbDpa.cjs.map → isFinite-CKeuVXbD.cjs.map} RENAMED Viewed

	@@ -1 +1 @@
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"}
1	+ {"version":3,"file":"isFinite-CKeuVXbD.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-ZvNhyHlF.js → isFinite-CzYYv-mQ.js} RENAMED Viewed

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

package/dist/{isFinite-ZvNhyHlF.js.map → isFinite-CzYYv-mQ.js.map} RENAMED Viewed

	@@ -1 +1 @@
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"}
1	+ {"version":3,"file":"isFinite-CzYYv-mQ.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-aZgzTTZG.js → isInteger-BtA3flbk.js} RENAMED Viewed

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

package/dist/{isInteger-aZgzTTZG.js.map → isInteger-BtA3flbk.js.map} RENAMED Viewed

	@@ -1 +1 @@
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"}
1	+ {"version":3,"file":"isInteger-BtA3flbk.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-dnc6W63Z.cjs → isInteger-iTok9NaH.cjs} RENAMED Viewed

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
@@ -17,4 +17,4 @@ Object.defineProperty(exports, 'isInteger', {
     return isInteger;
   }
 });
-//# sourceMappingURL=isInteger-dnc6W63Z.cjs.map
+//# sourceMappingURL=isInteger-iTok9NaH.cjs.map

package/dist/{isInteger-dnc6W63Z.cjs.map → isInteger-iTok9NaH.cjs.map} RENAMED Viewed

	@@ -1 +1 @@
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"}
1	+ {"version":3,"file":"isInteger-iTok9NaH.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 → isNumber-C1mOuBuA.js} RENAMED Viewed

@@ -2,12 +2,12 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.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";
+import { E as isPlainObject, j as isBoolean, n as assertIsBoolean, t as createMessage } from "./logger-Wxl_Krg6.js";
 const isNumber = (value, options = {}) => {
 	if (!isPlainObject(options)) options = {};
 	const includeNaN = isPlainObject(options) && isBoolean(options.includeNaN) ? options.includeNaN : false;
@@ -17,4 +17,4 @@ const isNumber = (value, options = {}) => {
 };
 const errorMsg = (msg) => createMessage("isNumber", msg);
 export { isNumber as t };
-//# sourceMappingURL=isNumber-BCWD4dW0.js.map
+//# sourceMappingURL=isNumber-C1mOuBuA.js.map

package/dist/{isNumber-BCWD4dW0.js.map → isNumber-C1mOuBuA.js.map} RENAMED Viewed

	@@ -1 +1 @@
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"}
1	+ {"version":3,"file":"isNumber-C1mOuBuA.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 → isNumber-CM1vdNcW.cjs} RENAMED Viewed

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.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_logger = require('./logger-BXg2xufj.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;
@@ -23,4 +23,4 @@ Object.defineProperty(exports, 'isNumber', {
     return isNumber;
   }
 });
-//# sourceMappingURL=isNumber-BkzwAe50.cjs.map
+//# sourceMappingURL=isNumber-CM1vdNcW.cjs.map

package/dist/{isNumber-BkzwAe50.cjs.map → isNumber-CM1vdNcW.cjs.map} RENAMED Viewed

	@@ -1 +1 @@
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"}
1	+ {"version":3,"file":"isNumber-CM1vdNcW.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"}

package/dist/{isPlainObject-CJvRG4Je.d.ts → isPlainObject-DQoM4DGQ.d.ts} RENAMED Viewed

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { C as NonPlainObject, _ as IsNever } from "./index-DZHiYYR7.js";
+import { C as NonPlainObject, _ as IsNever } from "./index-or0oP9i2.js";
 declare const ACRONYMS: readonly ["URI", "URL", "URN", "HTTP", "HTTPS", "FTP", "FTPS", "SFTP", "SSH", "SMTP", "POP3", "IMAP", "WS", "WSS", "TCP", "UDP", "IP", "ICMP", "ARP", "RTP", "RTSP", "SIP", "HTML", "XHTML", "XML", "WBR", "CSS", "SVG", "JSON", "JSONP", "DOM", "IDB", "DB", "RTC", "ICE", "TLS", "SSL", "CORS", "WASM", "CSR", "SSR", "PWA", "DPI", "CDN", "JS", "TS", "JSX", "TSX", "CLI", "API", "SDK", "UI", "UX", "OS", "ID", "UUID", "PID", "NPM", "YARN", "ESM", "CJS", "BOM", "MVC", "MVVM", "ORM", "DAO", "CRUD", "FIFO", "LIFO", "OOP", "FP", "REPL", "CSV", "TSV", "SQL", "YAML", "JSON", "MD", "INI", "PDF", "XLS", "XLSX", "RTF", "XML", "BMP", "GIF", "PNG", "JPEG", "WEBP", "MP3", "MP4", "AVI", "MOV", "FLAC", "MKV", "WAV", "URLSearchParams", "XHR", "2D", "3D", "GL", "WebGL", "TTL", "UID", "GID", "MAC", "IP", "DNS", "DHCP", "VPN", "LAN", "WAN", "SSID", "IoT", "API", "SDK", "CLI", "LTS", "EOL", "CPU", "GPU", "RAM", "ROM", "SSD", "HDD", "BIOS", "USB", "PCI", "SATA", "DIMM", "DDR", "VGA", "HDMI", "KVM", "ASIC", "FPGA", "SoC", "NAS", "SAN", "TCP", "UDP", "IP", "MAC", "DNS", "DHCP", "VPN", "LAN", "WAN", "SSID", "NAT", "QoS", "MPLS", "BGP", "OSPF", "ICMP", "IGMP", "LLDP", "ARP", "RARP", "AES", "RSA", "OTP", "MFA", "PKI", "VPN", "IAM", "ACL", "CSP", "XSS", "CSRF", "HSTS", "WAF", "DDoS", "IDS", "IPS", "SOC", "SIEM", "AWS", "GCP", "AZURE", "CI", "CD", "K8S", "IaC", "PaaS", "SaaS", "IaaS", "API", "CLI", "SDK", "REST", "SOAP", "JSON-RPC", "gRPC", "ELB", "EKS", "AKS", "FaaS", "CaaS", "GUI", "IDE", "FAQ", "UX", "UI", "CLI", "API", "SDK", "LTS", "EOL", "WYSIWYG", "CMS", "CRM", "GPS", "LED", "OLED", "LCD", "RFID", "NFC", "CPU", "GPU", "AI", "ML", "DL", "DB", "SQL", "NoSQL", "ORM", "JSON", "XML", "CSV", "HTTP", "HTTPS", "TDD", "BDD", "CI", "CD", "QA", "SLA", "SLO", "MTTR", "MTBF", "UAT", "RPA", "KPI", "OKR", "ROI", "RFP", "SLA", "CRM", "ERP", "PMO", "SCRUM", "KANBAN", "FPS", "HDR", "VR", "AR", "3D", "2D", "MP3", "MP4", "GIF", "PNG", "JPEG", "SVG", "BMP", "TIFF", "POSIX", "NTFS", "FAT", "EXT", "EXT4", "APFS", "HFS", "ISO", "HTML", "CSS", "JS", "TS", "PHP", "SQL", "JSON", "XML", "YAML", "BASH", "ZSH", "JSON", "YAML", "INI", "DOTENV", "VM", "VMM", "VPC", "OCI", "LXC", "Docker", "K8S", "CRI", "CNI"];
 /** ----------------------------------------------------------
 * * ***List of acronyms to keep uppercase in formatted output.***

package/dist/{isPlainObject-CAe_ElKO.d.cts → isPlainObject-Y__iykWN.d.cts} RENAMED Viewed

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { C as NonPlainObject, _ as IsNever } from "./index-DZHiYYR7.cjs";
+import { C as NonPlainObject, _ as IsNever } from "./index-or0oP9i2.cjs";
 declare const ACRONYMS: readonly ["URI", "URL", "URN", "HTTP", "HTTPS", "FTP", "FTPS", "SFTP", "SSH", "SMTP", "POP3", "IMAP", "WS", "WSS", "TCP", "UDP", "IP", "ICMP", "ARP", "RTP", "RTSP", "SIP", "HTML", "XHTML", "XML", "WBR", "CSS", "SVG", "JSON", "JSONP", "DOM", "IDB", "DB", "RTC", "ICE", "TLS", "SSL", "CORS", "WASM", "CSR", "SSR", "PWA", "DPI", "CDN", "JS", "TS", "JSX", "TSX", "CLI", "API", "SDK", "UI", "UX", "OS", "ID", "UUID", "PID", "NPM", "YARN", "ESM", "CJS", "BOM", "MVC", "MVVM", "ORM", "DAO", "CRUD", "FIFO", "LIFO", "OOP", "FP", "REPL", "CSV", "TSV", "SQL", "YAML", "JSON", "MD", "INI", "PDF", "XLS", "XLSX", "RTF", "XML", "BMP", "GIF", "PNG", "JPEG", "WEBP", "MP3", "MP4", "AVI", "MOV", "FLAC", "MKV", "WAV", "URLSearchParams", "XHR", "2D", "3D", "GL", "WebGL", "TTL", "UID", "GID", "MAC", "IP", "DNS", "DHCP", "VPN", "LAN", "WAN", "SSID", "IoT", "API", "SDK", "CLI", "LTS", "EOL", "CPU", "GPU", "RAM", "ROM", "SSD", "HDD", "BIOS", "USB", "PCI", "SATA", "DIMM", "DDR", "VGA", "HDMI", "KVM", "ASIC", "FPGA", "SoC", "NAS", "SAN", "TCP", "UDP", "IP", "MAC", "DNS", "DHCP", "VPN", "LAN", "WAN", "SSID", "NAT", "QoS", "MPLS", "BGP", "OSPF", "ICMP", "IGMP", "LLDP", "ARP", "RARP", "AES", "RSA", "OTP", "MFA", "PKI", "VPN", "IAM", "ACL", "CSP", "XSS", "CSRF", "HSTS", "WAF", "DDoS", "IDS", "IPS", "SOC", "SIEM", "AWS", "GCP", "AZURE", "CI", "CD", "K8S", "IaC", "PaaS", "SaaS", "IaaS", "API", "CLI", "SDK", "REST", "SOAP", "JSON-RPC", "gRPC", "ELB", "EKS", "AKS", "FaaS", "CaaS", "GUI", "IDE", "FAQ", "UX", "UI", "CLI", "API", "SDK", "LTS", "EOL", "WYSIWYG", "CMS", "CRM", "GPS", "LED", "OLED", "LCD", "RFID", "NFC", "CPU", "GPU", "AI", "ML", "DL", "DB", "SQL", "NoSQL", "ORM", "JSON", "XML", "CSV", "HTTP", "HTTPS", "TDD", "BDD", "CI", "CD", "QA", "SLA", "SLO", "MTTR", "MTBF", "UAT", "RPA", "KPI", "OKR", "ROI", "RFP", "SLA", "CRM", "ERP", "PMO", "SCRUM", "KANBAN", "FPS", "HDR", "VR", "AR", "3D", "2D", "MP3", "MP4", "GIF", "PNG", "JPEG", "SVG", "BMP", "TIFF", "POSIX", "NTFS", "FAT", "EXT", "EXT4", "APFS", "HFS", "ISO", "HTML", "CSS", "JS", "TS", "PHP", "SQL", "JSON", "XML", "YAML", "BASH", "ZSH", "JSON", "YAML", "INI", "DOTENV", "VM", "VMM", "VPC", "OCI", "LXC", "Docker", "K8S", "CRI", "CNI"];
 /** ----------------------------------------------------------
 * * ***List of acronyms to keep uppercase in formatted output.***

package/dist/{isServer-DhFaedeT.cjs → isServer-CWlp2R2N.cjs} RENAMED Viewed

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
@@ -17,4 +17,4 @@ Object.defineProperty(exports, 'isServer', {
     return isServer;
   }
 });
-//# sourceMappingURL=isServer-DhFaedeT.cjs.map
+//# sourceMappingURL=isServer-CWlp2R2N.cjs.map

package/dist/{isServer-DhFaedeT.cjs.map → isServer-CWlp2R2N.cjs.map} RENAMED Viewed

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

package/dist/{isServer-CQzrX5e0.js → isServer-Drgyboev.js} RENAMED Viewed

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

package/dist/{isServer-CQzrX5e0.js.map → isServer-Drgyboev.js.map} RENAMED Viewed

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

package/dist/{isTypedArray-DxsPKrLh.js → isTypedArray-BY8CIj3k.js} RENAMED Viewed

@@ -2,14 +2,14 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { O as isArray, b as isError, g as isObjectOrArray, p as isSet } from "./logger-CLWnKRKE.js";
-import { t as isEmptyValue } from "./isEmptyValue-kCjnLjbN.js";
-import { a as isMap, i as isDate, r as isUndefined } from "./safeStableStringify-DfwxmiWn.js";
+import { O as isArray, b as isError, g as isObjectOrArray, p as isSet } from "./logger-Wxl_Krg6.js";
+import { t as isEmptyValue } from "./isEmptyValue-h97JT4pD.js";
+import { a as isMap, i as isDate, r as isUndefined } from "./safeStableStringify-CDSYnLUz.js";
 const isRegExp = (value) => {
 	return value instanceof RegExp;
 };
@@ -104,4 +104,4 @@ const isTypedArray = (value) => {
 	return value != null && typeof value === "object" && typedArrayTags.has(Object.prototype.toString.call(value));
 };
 export { isArrayBuffer as a, baseDeepEqual as i, isNonEmptyValue as n, isRegExp as o, isEqual as r, isTypedArray as t };
-//# sourceMappingURL=isTypedArray-DxsPKrLh.js.map
+//# sourceMappingURL=isTypedArray-BY8CIj3k.js.map