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

package/dist/{isEqual-UsvOwrlY.cjs.map → isEqual-CZxetLzm.cjs.map}

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

package/dist/{isEqual-Dtb2sXUv.js → isEqual-Dc8fNB2J.js}

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { M as isArray, S as isUndefined, f as isSet, v as isError, x as isObjectOrArray } from "./assertIsBoolean-Bv6gL-xe.js";
-import { n as isDate, r as isMap } from "./safeStableStringify-BrOcdX9n.js";
+import { M as isArray, S as isUndefined, f as isSet, v as isError, x as isObjectOrArray } from "./assertIsBoolean-9-huIcIR.js";
+import { n as isDate, r as isMap } from "./safeStableStringify-C5Gc3ZED.js";
 const isRegExp = (value) => {
 	return value instanceof RegExp;
 };
@@ -84,4 +84,4 @@ function isEqual(value, other) {
 	return baseDeepEqual(value, other, void 0, /* @__PURE__ */ new WeakMap());
 }
 export { isRegExp as i, baseDeepEqual as n, isArrayBuffer as r, isEqual as t };
-//# sourceMappingURL=isEqual-Dtb2sXUv.js.map
+//# sourceMappingURL=isEqual-Dc8fNB2J.js.map

package/dist/{isEqual-Dtb2sXUv.js.map → isEqual-Dc8fNB2J.js.map}

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

package/dist/{isFinite-uukWvxJh.cjs → isFinite-0z31xOa2.cjs}

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

package/dist/{isFinite-uukWvxJh.cjs.map → isFinite-0z31xOa2.cjs.map}

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

package/dist/{isFinite-Cz_IFXuV.js → isFinite-CI59vUHt.js}

@@ -2,14 +2,14 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { w as isNumber } from "./assertIsBoolean-Bv6gL-xe.js";
+import { w as isNumber } from "./assertIsBoolean-9-huIcIR.js";
 function isFinite(value) {
 	return isNumber(value) && Number.isFinite(value);
 }
 export { isFinite as t };
-//# sourceMappingURL=isFinite-Cz_IFXuV.js.map
+//# sourceMappingURL=isFinite-CI59vUHt.js.map

package/dist/{isFinite-Cz_IFXuV.js.map → isFinite-CI59vUHt.js.map}

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

package/dist/{isInteger-DPYjliLZ.cjs → isInteger-DUhd-dyt.cjs}

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.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-DPYjliLZ.cjs.map
+//# sourceMappingURL=isInteger-DUhd-dyt.cjs.map

package/dist/{isInteger-DPYjliLZ.cjs.map → isInteger-DUhd-dyt.cjs.map}

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

package/dist/{isInteger-DZ163OQg.js → isInteger-DeN5FIAr.js}

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

package/dist/{isInteger-DZ163OQg.js.map → isInteger-DeN5FIAr.js.map}

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

package/dist/{isPlainObject-CBABRyEX.d.cts → isPlainObject-CjoJH9yk.d.ts}

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================

package/dist/{isPlainObject-Dr8gi89U.d.ts → isPlainObject-DvxdHoAf.d.cts}

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================

package/dist/{isServer-BDShLyVJ.js → isServer-BM5GzRpI.js}

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.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-BDShLyVJ.js.map
+//# sourceMappingURL=isServer-BM5GzRpI.js.map

package/dist/{isServer-BDShLyVJ.js.map → isServer-BM5GzRpI.js.map}

@@ -1 +1 @@
-{"version":3,"file":"isServer-BDShLyVJ.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 * @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 * @returns {boolean}\n *  * ***true**  – Code is executing on the `server`.*\n *  * ***false** – Code is executing in a `browser`.*\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAA0B;CACrC,OAAO,OAAO,WAAW,eAAe,OAAO,aAAa"}
+{"version":3,"file":"isServer-BM5GzRpI.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 * @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 * @returns {boolean}\n *  * ***true**  – Code is executing on the `server`.*\n *  * ***false** – Code is executing in a `browser`.*\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAA0B;CACrC,OAAO,OAAO,WAAW,eAAe,OAAO,aAAa"}

package/dist/{isServer-BzDeYuGg.cjs → isServer-TOmhgOtP.cjs}

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.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-BzDeYuGg.cjs.map
+//# sourceMappingURL=isServer-TOmhgOtP.cjs.map

package/dist/{isServer-BzDeYuGg.cjs.map → isServer-TOmhgOtP.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"isServer-BzDeYuGg.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 * @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 * @returns {boolean}\n *  * ***true**  – Code is executing on the `server`.*\n *  * ***false** – Code is executing in a `browser`.*\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAA0B;CACrC,OAAO,OAAO,WAAW,eAAe,OAAO,aAAa"}
+{"version":3,"file":"isServer-TOmhgOtP.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 * @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 * @returns {boolean}\n *  * ***true**  – Code is executing on the `server`.*\n *  * ***false** – Code is executing in a `browser`.*\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAA0B;CACrC,OAAO,OAAO,WAAW,eAAe,OAAO,aAAa"}

package/dist/{isTypedArray-DuUUA4CL.js → isTypedArray-BPerK072.js}

@@ -2,12 +2,12 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { t as isEmptyValue } from "./isEmptyValue-aGyeClwA.js";
+import { t as isEmptyValue } from "./isEmptyValue-CkiXENcT.js";
 const isNonEmptyValue = (value, options = {}) => {
 	return !isEmptyValue(value, options);
 };
@@ -28,4 +28,4 @@ function isTypedArray(value) {
 	return value != null && typeof value === "object" && typedArrayTags.has(Object.prototype.toString.call(value));
 }
 export { isNonEmptyValue as n, isTypedArray as t };
-//# sourceMappingURL=isTypedArray-DuUUA4CL.js.map
+//# sourceMappingURL=isTypedArray-BPerK072.js.map

package/dist/{isTypedArray-DuUUA4CL.js.map → isTypedArray-BPerK072.js.map}

@@ -1 +1 @@
-{"version":3,"file":"isTypedArray-DuUUA4CL.js","names":[],"sources":["../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.ts"],"sourcesContent":["import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** Whether to check symbol properties when checking empty objects, default: `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicated: `isNonEmptyValue`.***\n * ----------------------------------------------------------\n * **Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items) or generally truthy.**\n * - **Behavior:**\n *    - Returns `true` for:\n *      - Objects **with properties**\n *      - Arrays **with items**\n *      - Non-empty, non-whitespace strings\n *      - Numbers (except `NaN`, includes `0`)\n *      - Functions\n *      - `true`\n *    - Returns `false` for:\n *      - Empty objects (`{}`)\n *      - Empty arrays (`[]`)\n *      - `null` or `undefined`\n *      - Empty strings (`\"\"`) or whitespace-only strings (`\"  \"`)\n *      - `false`\n *      - `NaN`\n *    - Safely handles `null`, `undefined`, and non-object types without throwing.\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n * @example\n * isNonEmptyValue({});\n * // ➔ false\n * isNonEmptyValue([]);\n * // ➔ false\n * isNonEmptyValue({ key: \"value\" });\n * // ➔ true\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: false });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: true });\n * // ➔ true\n * isNonEmptyValue([1, 2, 3]);\n * // ➔ true\n * isNonEmptyValue(NaN);\n * // ➔ false\n * isNonEmptyValue(true);\n * // ➔ true\n * isNonEmptyValue(false);\n * // ➔ false\n * isNonEmptyValue(null);\n * // ➔ false\n * isNonEmptyValue(undefined);\n * // ➔ false\n * isNonEmptyValue(\"\");\n * // ➔ false\n * isNonEmptyValue(\"   \");\n * // ➔ false\n * isNonEmptyValue(0);\n * // ➔ true\n * isNonEmptyValue(-1);\n * // ➔ true\n * isNonEmptyValue(2);\n * // ➔ true\n * isNonEmptyValue(() => {});\n * // ➔ true\n */\nexport const isNonEmptyValue = (\n  value: unknown,\n  options: IsNonEmptyValueOptions = {}\n): boolean => {\n  return !isEmptyValue(value, options);\n};\n","import type { TypedArray } from \"@rzl-zone/ts-types-plus\";\n\nconst typedArrayTags = new Set([\n  \"[object Int8Array]\",\n  \"[object Uint8Array]\",\n  \"[object Uint8ClampedArray]\",\n  \"[object Int16Array]\",\n  \"[object Uint16Array]\",\n  \"[object Int32Array]\",\n  \"[object Uint32Array]\",\n  \"[object Float32Array]\",\n  \"[object Float64Array]\",\n  \"[object BigInt64Array]\",\n  \"[object BigUint64Array]\"\n]);\n\n/** --------------------------------------------------\n * * ***Type guard: `isTypedArray`.***\n * ----------------------------------------------------------\n * **Checks if `value` is classified as a\n * **[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.**\n * - **Behavior:**\n *    - Validates that `value` is a non-null object.\n *    - Uses `Object.prototype.toString` tag matching against known typed array tags.\n *    - Narrows type to **{@link TypedArray | `TypedArray`}** when true.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n * @example\n * isTypedArray(new Uint8Array);          // ➔ true\n * isTypedArray(new Uint8Array());        // ➔ true\n * isTypedArray(new Float32Array());      // ➔ true\n * isTypedArray(new Uint8ClampedArray()); // ➔ true\n * isTypedArray([]);                      // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));       // ➔ false\n */\nexport function isTypedArray(value: unknown): value is TypedArray {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    typedArrayTags.has(Object.prototype.toString.call(value))\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAa,mBACX,OACA,UAAkC,EAAE,KACxB;CACZ,OAAO,CAAC,aAAa,OAAO,QAAQ;;;;;ACzEtC,MAAM,iBAAiB,IAAI,IAAI;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,SAAgB,aAAa,OAAqC;CAChE,OACE,SAAS,QACT,OAAO,UAAU,YACjB,eAAe,IAAI,OAAO,UAAU,SAAS,KAAK,MAAM,CAAC"}
+{"version":3,"file":"isTypedArray-BPerK072.js","names":[],"sources":["../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.ts"],"sourcesContent":["import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** Whether to check symbol properties when checking empty objects, default: `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicated: `isNonEmptyValue`.***\n * ----------------------------------------------------------\n * **Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items) or generally truthy.**\n * - **Behavior:**\n *    - Returns `true` for:\n *      - Objects **with properties**\n *      - Arrays **with items**\n *      - Non-empty, non-whitespace strings\n *      - Numbers (except `NaN`, includes `0`)\n *      - Functions\n *      - `true`\n *    - Returns `false` for:\n *      - Empty objects (`{}`)\n *      - Empty arrays (`[]`)\n *      - `null` or `undefined`\n *      - Empty strings (`\"\"`) or whitespace-only strings (`\"  \"`)\n *      - `false`\n *      - `NaN`\n *    - Safely handles `null`, `undefined`, and non-object types without throwing.\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n * @example\n * isNonEmptyValue({});\n * // ➔ false\n * isNonEmptyValue([]);\n * // ➔ false\n * isNonEmptyValue({ key: \"value\" });\n * // ➔ true\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: false });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: true });\n * // ➔ true\n * isNonEmptyValue([1, 2, 3]);\n * // ➔ true\n * isNonEmptyValue(NaN);\n * // ➔ false\n * isNonEmptyValue(true);\n * // ➔ true\n * isNonEmptyValue(false);\n * // ➔ false\n * isNonEmptyValue(null);\n * // ➔ false\n * isNonEmptyValue(undefined);\n * // ➔ false\n * isNonEmptyValue(\"\");\n * // ➔ false\n * isNonEmptyValue(\"   \");\n * // ➔ false\n * isNonEmptyValue(0);\n * // ➔ true\n * isNonEmptyValue(-1);\n * // ➔ true\n * isNonEmptyValue(2);\n * // ➔ true\n * isNonEmptyValue(() => {});\n * // ➔ true\n */\nexport const isNonEmptyValue = (\n  value: unknown,\n  options: IsNonEmptyValueOptions = {}\n): boolean => {\n  return !isEmptyValue(value, options);\n};\n","import type { TypedArray } from \"@rzl-zone/ts-types-plus\";\n\nconst typedArrayTags = new Set([\n  \"[object Int8Array]\",\n  \"[object Uint8Array]\",\n  \"[object Uint8ClampedArray]\",\n  \"[object Int16Array]\",\n  \"[object Uint16Array]\",\n  \"[object Int32Array]\",\n  \"[object Uint32Array]\",\n  \"[object Float32Array]\",\n  \"[object Float64Array]\",\n  \"[object BigInt64Array]\",\n  \"[object BigUint64Array]\"\n]);\n\n/** --------------------------------------------------\n * * ***Type guard: `isTypedArray`.***\n * ----------------------------------------------------------\n * **Checks if `value` is classified as a\n * **[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.**\n * - **Behavior:**\n *    - Validates that `value` is a non-null object.\n *    - Uses `Object.prototype.toString` tag matching against known typed array tags.\n *    - Narrows type to **{@link TypedArray | `TypedArray`}** when true.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n * @example\n * isTypedArray(new Uint8Array);          // ➔ true\n * isTypedArray(new Uint8Array());        // ➔ true\n * isTypedArray(new Float32Array());      // ➔ true\n * isTypedArray(new Uint8ClampedArray()); // ➔ true\n * isTypedArray([]);                      // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));       // ➔ false\n */\nexport function isTypedArray(value: unknown): value is TypedArray {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    typedArrayTags.has(Object.prototype.toString.call(value))\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAa,mBACX,OACA,UAAkC,EAAE,KACxB;CACZ,OAAO,CAAC,aAAa,OAAO,QAAQ;;;;;ACzEtC,MAAM,iBAAiB,IAAI,IAAI;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,SAAgB,aAAa,OAAqC;CAChE,OACE,SAAS,QACT,OAAO,UAAU,YACjB,eAAe,IAAI,OAAO,UAAU,SAAS,KAAK,MAAM,CAAC"}

package/dist/{isTypedArray-DaYAkyrt.cjs → isTypedArray-pAdBFUDl.cjs}

@@ -2,13 +2,13 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_isEmptyValue = require('./isEmptyValue-Cw6ovu7z.cjs');
+const require_isEmptyValue = require('./isEmptyValue-v6BsHBiu.cjs');
 const isNonEmptyValue = (value, options = {}) => {
 	return !require_isEmptyValue.isEmptyValue(value, options);
 };
@@ -40,4 +40,4 @@ Object.defineProperty(exports, 'isTypedArray', {
     return isTypedArray;
   }
 });
-//# sourceMappingURL=isTypedArray-DaYAkyrt.cjs.map
+//# sourceMappingURL=isTypedArray-pAdBFUDl.cjs.map

package/dist/{isTypedArray-DaYAkyrt.cjs.map → isTypedArray-pAdBFUDl.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"isTypedArray-DaYAkyrt.cjs","names":["isEmptyValue"],"sources":["../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.ts"],"sourcesContent":["import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** Whether to check symbol properties when checking empty objects, default: `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicated: `isNonEmptyValue`.***\n * ----------------------------------------------------------\n * **Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items) or generally truthy.**\n * - **Behavior:**\n *    - Returns `true` for:\n *      - Objects **with properties**\n *      - Arrays **with items**\n *      - Non-empty, non-whitespace strings\n *      - Numbers (except `NaN`, includes `0`)\n *      - Functions\n *      - `true`\n *    - Returns `false` for:\n *      - Empty objects (`{}`)\n *      - Empty arrays (`[]`)\n *      - `null` or `undefined`\n *      - Empty strings (`\"\"`) or whitespace-only strings (`\"  \"`)\n *      - `false`\n *      - `NaN`\n *    - Safely handles `null`, `undefined`, and non-object types without throwing.\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n * @example\n * isNonEmptyValue({});\n * // ➔ false\n * isNonEmptyValue([]);\n * // ➔ false\n * isNonEmptyValue({ key: \"value\" });\n * // ➔ true\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: false });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: true });\n * // ➔ true\n * isNonEmptyValue([1, 2, 3]);\n * // ➔ true\n * isNonEmptyValue(NaN);\n * // ➔ false\n * isNonEmptyValue(true);\n * // ➔ true\n * isNonEmptyValue(false);\n * // ➔ false\n * isNonEmptyValue(null);\n * // ➔ false\n * isNonEmptyValue(undefined);\n * // ➔ false\n * isNonEmptyValue(\"\");\n * // ➔ false\n * isNonEmptyValue(\"   \");\n * // ➔ false\n * isNonEmptyValue(0);\n * // ➔ true\n * isNonEmptyValue(-1);\n * // ➔ true\n * isNonEmptyValue(2);\n * // ➔ true\n * isNonEmptyValue(() => {});\n * // ➔ true\n */\nexport const isNonEmptyValue = (\n  value: unknown,\n  options: IsNonEmptyValueOptions = {}\n): boolean => {\n  return !isEmptyValue(value, options);\n};\n","import type { TypedArray } from \"@rzl-zone/ts-types-plus\";\n\nconst typedArrayTags = new Set([\n  \"[object Int8Array]\",\n  \"[object Uint8Array]\",\n  \"[object Uint8ClampedArray]\",\n  \"[object Int16Array]\",\n  \"[object Uint16Array]\",\n  \"[object Int32Array]\",\n  \"[object Uint32Array]\",\n  \"[object Float32Array]\",\n  \"[object Float64Array]\",\n  \"[object BigInt64Array]\",\n  \"[object BigUint64Array]\"\n]);\n\n/** --------------------------------------------------\n * * ***Type guard: `isTypedArray`.***\n * ----------------------------------------------------------\n * **Checks if `value` is classified as a\n * **[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.**\n * - **Behavior:**\n *    - Validates that `value` is a non-null object.\n *    - Uses `Object.prototype.toString` tag matching against known typed array tags.\n *    - Narrows type to **{@link TypedArray | `TypedArray`}** when true.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n * @example\n * isTypedArray(new Uint8Array);          // ➔ true\n * isTypedArray(new Uint8Array());        // ➔ true\n * isTypedArray(new Float32Array());      // ➔ true\n * isTypedArray(new Uint8ClampedArray()); // ➔ true\n * isTypedArray([]);                      // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));       // ➔ false\n */\nexport function isTypedArray(value: unknown): value is TypedArray {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    typedArrayTags.has(Object.prototype.toString.call(value))\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAa,mBACX,OACA,UAAkC,EAAE,KACxB;CACZ,OAAO,CAACA,kCAAa,OAAO,QAAQ;;;;;ACzEtC,MAAM,iBAAiB,IAAI,IAAI;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,SAAgB,aAAa,OAAqC;CAChE,OACE,SAAS,QACT,OAAO,UAAU,YACjB,eAAe,IAAI,OAAO,UAAU,SAAS,KAAK,MAAM,CAAC"}
+{"version":3,"file":"isTypedArray-pAdBFUDl.cjs","names":["isEmptyValue"],"sources":["../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.ts"],"sourcesContent":["import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** Whether to check symbol properties when checking empty objects, default: `false`.\n   *\n   * @default false\n   */\n  checkSymbols?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicated: `isNonEmptyValue`.***\n * ----------------------------------------------------------\n * **Determines if a value is a **non-empty** object (`{}` with props), **non-empty** array (`[]` with items) or generally truthy.**\n * - **Behavior:**\n *    - Returns `true` for:\n *      - Objects **with properties**\n *      - Arrays **with items**\n *      - Non-empty, non-whitespace strings\n *      - Numbers (except `NaN`, includes `0`)\n *      - Functions\n *      - `true`\n *    - Returns `false` for:\n *      - Empty objects (`{}`)\n *      - Empty arrays (`[]`)\n *      - `null` or `undefined`\n *      - Empty strings (`\"\"`) or whitespace-only strings (`\"  \"`)\n *      - `false`\n *      - `NaN`\n *    - Safely handles `null`, `undefined`, and non-object types without throwing.\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n * @example\n * isNonEmptyValue({});\n * // ➔ false\n * isNonEmptyValue([]);\n * // ➔ false\n * isNonEmptyValue({ key: \"value\" });\n * // ➔ true\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: false });\n * // ➔ false (default `checkSymbols` is `false`)\n * isNonEmptyValue({ [Symbol(\"foo\")]: 123 }, { checkSymbols: true });\n * // ➔ true\n * isNonEmptyValue([1, 2, 3]);\n * // ➔ true\n * isNonEmptyValue(NaN);\n * // ➔ false\n * isNonEmptyValue(true);\n * // ➔ true\n * isNonEmptyValue(false);\n * // ➔ false\n * isNonEmptyValue(null);\n * // ➔ false\n * isNonEmptyValue(undefined);\n * // ➔ false\n * isNonEmptyValue(\"\");\n * // ➔ false\n * isNonEmptyValue(\"   \");\n * // ➔ false\n * isNonEmptyValue(0);\n * // ➔ true\n * isNonEmptyValue(-1);\n * // ➔ true\n * isNonEmptyValue(2);\n * // ➔ true\n * isNonEmptyValue(() => {});\n * // ➔ true\n */\nexport const isNonEmptyValue = (\n  value: unknown,\n  options: IsNonEmptyValueOptions = {}\n): boolean => {\n  return !isEmptyValue(value, options);\n};\n","import type { TypedArray } from \"@rzl-zone/ts-types-plus\";\n\nconst typedArrayTags = new Set([\n  \"[object Int8Array]\",\n  \"[object Uint8Array]\",\n  \"[object Uint8ClampedArray]\",\n  \"[object Int16Array]\",\n  \"[object Uint16Array]\",\n  \"[object Int32Array]\",\n  \"[object Uint32Array]\",\n  \"[object Float32Array]\",\n  \"[object Float64Array]\",\n  \"[object BigInt64Array]\",\n  \"[object BigUint64Array]\"\n]);\n\n/** --------------------------------------------------\n * * ***Type guard: `isTypedArray`.***\n * ----------------------------------------------------------\n * **Checks if `value` is classified as a\n * **[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)**.**\n * - **Behavior:**\n *    - Validates that `value` is a non-null object.\n *    - Uses `Object.prototype.toString` tag matching against known typed array tags.\n *    - Narrows type to **{@link TypedArray | `TypedArray`}** when true.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n * @example\n * isTypedArray(new Uint8Array);          // ➔ true\n * isTypedArray(new Uint8Array());        // ➔ true\n * isTypedArray(new Float32Array());      // ➔ true\n * isTypedArray(new Uint8ClampedArray()); // ➔ true\n * isTypedArray([]);                      // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));       // ➔ false\n */\nexport function isTypedArray(value: unknown): value is TypedArray {\n  return (\n    value != null &&\n    typeof value === \"object\" &&\n    typedArrayTags.has(Object.prototype.toString.call(value))\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAa,mBACX,OACA,UAAkC,EAAE,KACxB;CACZ,OAAO,CAACA,kCAAa,OAAO,QAAQ;;;;;ACzEtC,MAAM,iBAAiB,IAAI,IAAI;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,SAAgB,aAAa,OAAqC;CAChE,OACE,SAAS,QACT,OAAO,UAAU,YACjB,eAAe,IAAI,OAAO,UAAU,SAAS,KAAK,MAAM,CAAC"}

package/dist/{isValidDomain-BxyToAlh.cjs → isValidDomain-BMcr9vTp.cjs}

@@ -2,15 +2,15 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_assertIsBoolean = require('./assertIsBoolean-amRiJHnh.cjs');
-const require_safeStableStringify = require('./safeStableStringify-DRYQ56Dg.cjs');
-const require_punyCode = require('./punyCode-DmTsB7q_.cjs');
+const require_assertIsBoolean = require('./assertIsBoolean-JGpkg5ju.cjs');
+const require_safeStableStringify = require('./safeStableStringify-BiUOLBYo.cjs');
+const require_punyCode = require('./punyCode-5wmummgP.cjs');
 const isURL = (value) => {
 	return value instanceof URL;
 };
@@ -18,7 +18,7 @@ const isURL = (value) => {
 * ========================================================================
 *  @rzl-zone/build-tools
 * ------------------------------------------------------------------------
-*  Version: `0.0.12-beta.0`
+*  Version: `0.0.12`
 *  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`
 * ========================================================================
@@ -1851,4 +1851,4 @@ Object.defineProperty(exports, 'joinLines', {
     return joinLines;
   }
 });
-//# sourceMappingURL=isValidDomain-BxyToAlh.cjs.map
+//# sourceMappingURL=isValidDomain-BMcr9vTp.cjs.map

package/dist/isValidDomain-BMcr9vTp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isValidDomain-BMcr9vTp.cjs","names":["isString","isBoolean","getPreciseType","safeStableStringify","punycodeUtilsJS","ccTldMap","sldMap"],"sources":["../src/predicates/is/isURL.ts","../../build-tools/dist/formatter-Bd8fVs2h.js","../src/predicates/is/_private/data/domain/sldMap.json","../src/predicates/is/_private/data/domain/ccTldMap.json","../src/predicates/is/isValidDomain.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Type guard: `isURL`.***\n * ----------------------------------------------------------\n * **Checks if a value is an instance of the\n * **[`URL`](https://developer.mozilla.org/docs/Web/API/URL)** class.**\n * - **Behavior:**\n *    - Narrows type to `URL` when true.\n *    - Excludes `strings`, `plain-objects`, and `other non-URL values`.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is an instance of `URL`, otherwise `false`.\n * @example\n * isURL(new URL(\"https://example.com\"));\n * // ➔ true\n * isURL(\"https://example.com\");\n * // ➔ false\n */\nexport const isURL = (value: unknown): value is URL => {\n  return value instanceof URL;\n};\n","/*!\n* ========================================================================\n*  @rzl-zone/build-tools\n* ------------------------------------------------------------------------\n*  Version: `0.0.12`\n*  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`\n*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`\n* ========================================================================\n*/\n\nimport pcr from \"picocolors\";\nfunction deepFreeze(value) {\n\tif (typeof value !== \"object\" || value === null) return value;\n\tconst seen = /* @__PURE__ */ new WeakSet();\n\tconst stack = [value];\n\twhile (stack.length) {\n\t\tconst obj = stack.pop();\n\t\tif (seen.has(obj) || Object.isFrozen(obj)) continue;\n\t\tseen.add(obj);\n\t\tif (isMap(obj)) for (const [k, v] of obj) {\n\t\t\tif (typeof k === \"object\" && k !== null) stack.push(k);\n\t\t\tif (typeof v === \"object\" && v !== null) stack.push(v);\n\t\t}\n\t\telse if (isSet(obj)) {\n\t\t\tfor (const v of obj) if (typeof v === \"object\" && v !== null) stack.push(v);\n\t\t} else if (isArray(obj)) {\n\t\t\tfor (const v of obj) if (typeof v === \"object\" && v !== null) stack.push(v);\n\t\t} else {\n\t\t\tconst record = obj;\n\t\t\tfor (const key of Reflect.ownKeys(record)) {\n\t\t\t\tconst v = record[key];\n\t\t\t\tif (typeof v === \"object\" && v !== null) stack.push(v);\n\t\t\t}\n\t\t}\n\t\tObject.freeze(obj);\n\t}\n\treturn value;\n}\nconst isRegExp = (value) => {\n\treturn value instanceof RegExp;\n};\nconst isString = (value) => {\n\treturn typeof value === \"string\";\n};\nfunction isSet(value) {\n\treturn Object.prototype.toString.call(value) === \"[object Set]\" || value instanceof Set;\n}\nfunction isMap(value) {\n\treturn Object.prototype.toString.call(value) === \"[object Map]\" || value instanceof Map;\n}\nfunction isArray(value) {\n\treturn Array.isArray(value);\n}\nconst isNull = (val) => val === null;\nfunction isPlainObject(value) {\n\tif (!isObject(value)) return false;\n\tconst proto = Object.getPrototypeOf(value);\n\treturn proto === Object.prototype || proto === null;\n}\nfunction isObject(value) {\n\treturn typeof value === \"object\" && !isNil(value) && !isArray(value);\n}\nfunction isObjectOrArray(value) {\n\treturn isArray(value) || isObject(value);\n}\nconst isNil = (value) => {\n\treturn value == null;\n};\nconst isBoolean = (value) => {\n\treturn typeof value === \"boolean\";\n};\nconst isUndefined = (value) => {\n\treturn typeof value === \"undefined\";\n};\nconst isFunction = (value) => {\n\treturn typeof value === \"function\";\n};\nconst isNumberObject = (value) => {\n\treturn isObject(value) && Object.prototype.toString.call(value) === \"[object Number]\";\n};\nconst isStringObject = (value) => {\n\treturn isObject(value) && Object.prototype.toString.call(value) === \"[object String]\";\n};\nconst isBooleanObject = (value) => {\n\treturn isObject(value) && Object.prototype.toString.call(value) === \"[object Boolean]\";\n};\nconst isInfinityNumber = (value) => {\n\tif (typeof value === \"number\" || isNumberObject(value)) {\n\t\tconst num = Number(value);\n\t\treturn num === Infinity || num === -Infinity;\n\t}\n\treturn false;\n};\nconst isSymbol = (value) => {\n\treturn typeof value === \"symbol\";\n};\nconst isBigInt = (value) => {\n\treturn typeof value === \"bigint\";\n};\nconst isNaN = (value) => {\n\treturn typeof value === \"number\" ? Number.isNaN(value) : isNumberObject(value) && Number.isNaN(value.valueOf());\n};\nconst isNonEmptyString = (value, options = {}) => {\n\tif (!isString(value)) return false;\n\treturn (options.trim ?? true ? value.trim() : value).length > 0;\n};\nconst isNumber = (value, options = {}) => {\n\tconst includeNaN = isPlainObject(options) && isBoolean(options.includeNaN) ? options.includeNaN : false;\n\tconst aNumber = typeof value === \"number\";\n\treturn includeNaN ? aNumber : aNumber && !Number.isNaN(value);\n};\nconst isError = (error) => {\n\treturn Object.prototype.toString.call(error) === \"[object Error]\" || error instanceof Error;\n};\nconst isDate = (value, options = {}) => {\n\tconst skipInvalidDate = isPlainObject(options) && isBoolean(options.skipInvalidDate) ? options.skipInvalidDate : false;\n\tconst instanceDate = value instanceof Date;\n\tif (skipInvalidDate) return instanceDate;\n\treturn instanceDate && !isNaN(value.getTime());\n};\nconst safeStableStringify = (value, options = {}) => {\n\tconst pretty = options.pretty ?? false;\n\tconst sortKeys = options.sortKeys ?? true;\n\tconst sortArray = options.sortArray ?? false;\n\tconst keepUndefined = options.keepUndefined ?? false;\n\tif (isUndefined(value)) return keepUndefined ? \"undefined\" : \"null\";\n\tconst seen = /* @__PURE__ */ new WeakSet();\n\tconst isPrimitive = (val) => isNull(val) || !isObjectOrArray(val) && !isFunction(val);\n\tconst deepProcess = (val) => {\n\t\tif (isNumberObject(val)) {\n\t\t\tconst valOf = val.valueOf();\n\t\t\treturn isNaN(valOf) || isInfinityNumber(valOf) ? null : valOf;\n\t\t}\n\t\tif (isStringObject(val)) return val.valueOf();\n\t\tif (isBooleanObject(val)) return val.valueOf();\n\t\tif (isFunction(val) || isSymbol(val)) return void 0;\n\t\tif (isBigInt(val)) return val.toString();\n\t\tif (isNaN(val) || isInfinityNumber(val)) return null;\n\t\tif (isUndefined(val)) return keepUndefined ? void 0 : null;\n\t\tif (isObjectOrArray(val)) {\n\t\t\tif (seen.has(val)) return \"[Circular]\";\n\t\t\tseen.add(val);\n\t\t\tif (isDate(val)) return val.toISOString();\n\t\t\tif (isMap(val)) return { map: Array.from(val.entries()).map(([k, v]) => [k, deepProcess(v)]) };\n\t\t\tif (isSet(val)) return { set: Array.from(val.values()).map(deepProcess) };\n\t\t\tif (isArray(val)) {\n\t\t\t\tconst processedArr = val.map(deepProcess);\n\t\t\t\tif (sortArray) {\n\t\t\t\t\tconst primitives = [];\n\t\t\t\t\tconst nonPrimitives = [];\n\t\t\t\t\tfor (const item of processedArr) if (isPrimitive(item)) primitives.push(item);\n\t\t\t\t\telse nonPrimitives.push(item);\n\t\t\t\t\tprimitives.sort((a, b) => {\n\t\t\t\t\t\tif (isNumber(a) && isNumber(b)) return a - b;\n\t\t\t\t\t\treturn String(a).localeCompare(String(b));\n\t\t\t\t\t});\n\t\t\t\t\treturn [...primitives, ...nonPrimitives];\n\t\t\t\t}\n\t\t\t\treturn processedArr;\n\t\t\t}\n\t\t\tconst keys = Object.keys(val);\n\t\t\tif (sortKeys) keys.sort((a, b) => {\n\t\t\t\tconst na = Number(a);\n\t\t\t\tconst nb = Number(b);\n\t\t\t\tif (!isNaN(na) && !isNaN(nb)) return na - nb;\n\t\t\t\treturn a.localeCompare(b);\n\t\t\t});\n\t\t\tconst result = {};\n\t\t\tif (isObject(val)) for (const k of keys) {\n\t\t\t\tconst v = deepProcess(val[k]);\n\t\t\t\tif (!isUndefined(v)) result[k] = v;\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t\treturn val;\n\t};\n\ttry {\n\t\treturn JSON.stringify(deepProcess(value), null, pretty ? 2 : 0);\n\t} catch (err) {\n\t\tconsole.warn(\"Error in safeStableStringify:\", err);\n\t\treturn \"{}\";\n\t}\n};\nconst normalizeSpaces = (value, options = {\n\twithTrim: true,\n\ttrimOnly: false\n}) => {\n\tif (!isNonEmptyString(value)) return \"\";\n\tif (!isPlainObject(options)) options = {};\n\tconst { trimOnly = false, withTrim = true } = options;\n\tif (trimOnly) return value.trim();\n\tif (withTrim) value = value.trim();\n\treturn value.replace(/\\s+/g, \" \");\n};\nconst isStringArray = (v) => isArray(v) && v.every((i) => isString(i));\nconst isStringSet = (v) => isSet(v) && [...v].every((i) => isString(i));\nconst assertValidatePatternArgs = (v, parameterKey = \"pattern\") => {\n\tif (!isString(v) && !isStringArray(v) && !isStringSet(v)) throw new TypeError(`The \\`${parameterKey}\\` argument must be a string, string[] or Set<string>.`);\n};\nconst flattenStrings = (input) => {\n\treturn input.flat(Infinity).filter((v) => typeof v === \"string\");\n};\nconst toStringSet = (pattern, options = {}) => {\n\tconst { withValidationType = true, parameterKey = \"pattern\" } = options;\n\tif (withValidationType) assertValidatePatternArgs(pattern, parameterKey);\n\treturn toObjectSet(pattern);\n};\nconst toObjectSet = (value) => {\n\tif (isSet(value)) return value;\n\treturn new Set(isArray(value) ? value : [value]);\n};\nconst toArray = (value) => {\n\treturn isArray(value) ? value : [value];\n};\nconst hasGlobalRequire = (value) => isObject(value) && isFunction(value.require);\nconst getRuntimeRequire = () => {\n\tif (!hasGlobalRequire(globalThis)) return void 0;\n\treturn globalThis.require;\n};\nconst __runtimeRequire = ((x) => {\n\tconst r = getRuntimeRequire();\n\tif (r) return r;\n\tif (typeof Proxy !== \"undefined\") return new Proxy(x, { get(target, prop) {\n\t\tconst r2 = getRuntimeRequire();\n\t\treturn r2 ? r2[prop] : target[prop];\n\t} });\n\treturn x;\n})(function(id) {\n\tconst r = getRuntimeRequire();\n\tif (r) return r.call(this, id);\n\tthrow new Error(`Calling \\`require\\` for \"${id}\" in an environment that doesn't expose the \\`require\\` function.`);\n});\nconst picocolors = pcr;\nconst NEWLINE = atob(\"Cg==\");\nconst EOL = hasGlobalRequire(globalThis) ? __runtimeRequire(\"node:os\").EOL : NEWLINE;\nfunction plural(count, word, pluralWord) {\n\tif (count === 1) return word;\n\treturn pluralWord ?? `${word}s`;\n}\nfunction padText(value, options = {}) {\n\tconst { start = true, end = true, padOnInvalid = true } = options;\n\tif (!isNonEmptyString(value)) return padOnInvalid ? \" \" : \"\";\n\treturn `${start ? \" \" : \"\"}${value}${end ? \" \" : \"\"}`;\n}\nfunction joinInline(...text) {\n\treturn text.filter(Boolean).join(\" \");\n}\nfunction joinLines(...text) {\n\treturn text.filter(Boolean).join(EOL);\n}\nfunction joinLinesLoose(...text) {\n\treturn text.filter((v) => v !== false && v !== null && v !== void 0).join(EOL);\n}\nfunction formatOptionValue(value, options) {\n\tconst { pretty = false, indent = 2, sortKeys = false, sortArray = false } = options ?? {};\n\tconst indentUnit = \" \".repeat(indent);\n\tfunction formatRecursive(input, depth = 0) {\n\t\tconst currentIndent = indentUnit.repeat(depth);\n\t\tconst nextIndent = indentUnit.repeat(depth + 1);\n\t\tconst joinInline = picocolors.dim(\", \");\n\t\tconst joinPretty = `,${EOL}`;\n\t\tif (isSet(input)) return formatRecursive([...input], depth);\n\t\tif (isMap(input)) return formatRecursive(Object.fromEntries(input), depth);\n\t\tif (isArray(input)) {\n\t\t\tconst arr = sortArray ? [...input].sort() : input;\n\t\t\tif (arr.length === 0) return picocolors.gray(\"[]\");\n\t\t\tif (!pretty) {\n\t\t\t\tconst items = arr.map((v) => formatRecursive(v, depth)).join(joinInline);\n\t\t\t\treturn picocolors.gray(\"[\") + items + picocolors.gray(\"]\");\n\t\t\t}\n\t\t\tconst items = arr.map((v) => nextIndent + formatRecursive(v, depth + 1)).join(joinPretty);\n\t\t\treturn picocolors.gray(`[${EOL}`) + items + EOL + currentIndent + picocolors.gray(\"]\");\n\t\t}\n\t\tif (isPlainObject(input)) {\n\t\t\tlet entries = Object.entries(input);\n\t\t\tif (sortKeys) entries = entries.sort(([a], [b]) => a.localeCompare(b));\n\t\t\tif (entries.length === 0) return picocolors.gray(\"{}\");\n\t\t\tif (!pretty) {\n\t\t\t\tconst props = entries.map(([key, val]) => {\n\t\t\t\t\treturn picocolors.dim(key) + picocolors.gray(\": \") + formatRecursive(val, depth);\n\t\t\t\t}).join(joinInline);\n\t\t\t\treturn picocolors.gray(\"{ \") + props + picocolors.gray(\" }\");\n\t\t\t}\n\t\t\tconst props = entries.map(([key, val]) => {\n\t\t\t\treturn nextIndent + picocolors.dim(key) + picocolors.gray(\": \") + formatRecursive(val, depth + 1);\n\t\t\t}).join(joinPretty);\n\t\t\treturn picocolors.gray(`{${EOL}`) + props + EOL + currentIndent + picocolors.gray(\"}\");\n\t\t}\n\t\tif (isRegExp(input)) return picocolors.greenBright(\"/\") + picocolors.redBright(input.source) + picocolors.greenBright(\"/\") + picocolors.magentaBright(input.flags);\n\t\tif (isString(input)) return picocolors.gray(`\"${input}\"`);\n\t\tif (isNumber(input, { includeNaN: true })) return picocolors.redBright(String(input));\n\t\tif (isBoolean(input)) return picocolors.redBright(String(input));\n\t\tif (isNil(input)) return picocolors.redBright(String(input));\n\t\tif (isObject(input)) return picocolors.cyanBright(Object.prototype.toString.call(input));\n\t\treturn picocolors.cyanBright(String(input));\n\t}\n\treturn formatRecursive(value);\n}\nexport { isString as C, toArray as D, safeStableStringify as E, toObjectSet as O, isSet as S, normalizeSpaces as T, isNonEmptyString as _, joinLines as a, isPlainObject as b, picocolors as c, flattenStrings as d, isArray as f, isNil as g, isFunction as h, joinInline as i, toStringSet as k, plural as l, isError as m, NEWLINE as n, joinLinesLoose as o, isBoolean as p, formatOptionValue as r, padText as s, EOL as t, deepFreeze as u, isNull as v, isUndefined as w, isRegExp as x, isNumber as y };\n//# sourceMappingURL=formatter-Bd8fVs2h.js.map\n","","","import { joinLines, EOL } from \"@rzl-zone/build-tools/utils\";\n\nimport { punycodeUtilsJS } from \"@/urls/utils/punyCode\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\nimport sldMap from \"./_private/data/domain/sldMap.json\";\nimport ccTldMap from \"./_private/data/domain/ccTldMap.json\";\n\nimport { isString } from \"./isString\";\nimport { isBoolean } from \"./isBoolean\";\n\nimport { getPreciseType } from \"../type/getPreciseType\";\n\n/** ---------------------------------------------------------\n * * ***Options for `isValidDomain` predicate.***\n * ---------------------------------------------------------\n * **Customize the behavior of domain validation.**\n */\ntype IsValidDomainOptions = {\n  /** * ***Enable conversion of Unicode domains (IDN) to ASCII (punycode).***\n   *\n   * - Example: `\"пример.рф\"` ➔ `\"xn--e1afmkfd.xn--p1ai\"`\n   * - Allows validating Unicode domains correctly.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  allowUnicode?: boolean;\n\n  /** * ***If `true`, validates **only top-level domains (TLDs)** that are not part of any SLD/second-level domain.***\n   *\n   * - Accepts country-code TLDs like `\"ai\"` or `\"ai.\"` ✅\n   * - Rejects common TLDs that are part of SLDs like `\"com\"` ❌\n   * - Only the final label is checked; subdomains are ignored.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  topLevel?: boolean;\n\n  /** * ***Allow or disallow subdomains.***\n   *\n   * - Example: `\"sub.example.com\"` ✅ if `subdomain` is `true`, ❌ if `false`\n   * - Wildcards and SLDs are considered when evaluating subdomains.\n   * - Default: `true`\n   *\n   * @defaultValue `true`.\n   */\n  subdomain?: boolean;\n\n  /** * ***Allow a wildcard `*` in the left-most label.***\n   *\n   * - Example: `\"*.example.com\"` ✅ if `wildcard` is `true`, ❌ if `false`\n   * - Wildcards are only valid in the first label and require at least one additional label.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  wildcard?: boolean;\n\n  /** * ***Allow a port after the domain.***\n   *\n   * - Example: `\"localhost:3000\"` or `\"example.com:8080\"` ✅ if `allowPort` is `true`\n   * - Validates that the port is a number between `1` and `65535`.\n   * - Does not affect domain validation rules otherwise.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  allowPort?: boolean;\n\n  /** * ***Allow special domains like `localhost`.***\n   *\n   * - Example: `\"localhost\"` ✅ if `allowLocalhost` is `true`\n   * - Works with or without a port if `allowPort` is enabled.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  allowLocalhost?: boolean;\n\n  /** * ***Allow URLs with protocol (`http`/`https`) and automatically extract the hostname.***\n   *\n   * - Example: `\"https://example.com/foo/bar\"` ➔ `\"example.com\"`\n   * - The function will validate only the hostname part and ignore the path, query, and fragment.\n   * - Default: `false`\n   *\n   * @defaultValue `false`.\n   */\n  allowProtocol?: boolean;\n};\n\n/** ---------------------------------------------------------\n * * ***Predicate: `isValidDomain`.***\n * ---------------------------------------------------------\n * **Validates whether a given string is a properly formatted domain name.**\n *\n * - **Supports options for:**\n *    - `allowUnicode` ➔ allows internationalized domain names (IDN) with Unicode characters.\n *    - `topLevel` ➔ validates **only top-level domains (TLDs)**; ignores subdomains and SLDs.\n *    - `subdomain` ➔ allows or disallows subdomains.\n *    - `wildcard` ➔ allows wildcard (`*`) in the left-most label.\n *    - `allowPort` ➔ allows a port number after the domain (e.g., `example.com:8080`).\n *    - `allowLocalhost` ➔ allows the special domain `\"localhost\"`.\n *    - `allowProtocol` ➔ allows a URL with protocol (`http`/`https`) and extracts the hostname.\n *\n * - **Behavior:**\n *    - ✅ Converts Unicode to ASCII (punycode) if `allowUnicode` is `true`.\n *    - ✅ Checks label lengths (≤63 chars), valid characters, and punycode consistency.\n *    - ✅ Validates port if `allowPort` is `true` (must be 1–65535).\n *    - ✅ Accepts `\"localhost\"` if `allowLocalhost` is `true`.\n *    - ✅ Extracts hostname from URLs if `allowProtocol` is `true`.\n *    - ❌ Rejects invalid domains, labels starting/ending with `-`, double dots, malformed TLDs, or invalid port numbers.\n *    - ✅ Handles both standard domains (example.com), URLs with protocols (https://example.com/foo), and IDNs (пример.рф).\n *\n * @param {*} value - The value to validate; only strings are valid domains.\n * @param {IsValidDomainOptions} [options] - Optional configuration for domain validation.\n * @param {boolean} [options.allowUnicode=false] - Enable punycode conversion for Unicode domains.\n * @param {boolean} [options.topLevel=false] - Validate only TLDs (e.g., `ai`, `uk.`); ignores SLDs like `com`.\n * @param {boolean} [options.subdomain=true] - Allow subdomains; set `false` to reject any subdomain.\n * @param {boolean} [options.wildcard=false] - Allow wildcard `*` in the left-most label (e.g., `*.example.com`).\n * @param {boolean} [options.allowPort=false] - Allow port number after domain (e.g., `:3000`); must be 1–65535.\n * @param {boolean} [options.allowLocalhost=false] - Allow special domain `\"localhost\"`.\n * @param {boolean} [options.allowProtocol=false] - Allow URLs with protocol (`http`/`https`) and extract hostname only.\n * @returns {boolean} Returns `true` if the value is a valid domain according to the rules and options; otherwise `false`.\n *\n * @example\n * isValidDomain(\"google.com\");\n * // ➔ true\n * isValidDomain(\"пример.рф\", { allowUnicode: true });\n * // ➔ true\n * isValidDomain(\"sub.example.com\", { subdomain: false });\n * // ➔ false\n * isValidDomain(\"*.example.com\", { wildcard: true });\n * // ➔ true\n * isValidDomain(\"com\", { topLevel: true });\n * // ➔ false (common TLD rejected because it's part of SLD)\n * isValidDomain(\"ai.\", { topLevel: true });\n * // ➔ true (country-code TLD accepted)\n * isValidDomain(\"localhost\", { allowLocalhost: true });\n * // ➔ true\n * isValidDomain(\"localhost:3000\", { allowLocalhost: true, allowPort: true });\n * // ➔ true\n * isValidDomain(\"example.com:8080\", { allowPort: true });\n * // ➔ true\n * isValidDomain(\"https://example.com/foo/bar\", { allowProtocol: true });\n * // ➔ true (protocol stripped and hostname validated)\n * isValidDomain(\"invalid_domain.com\");\n * // ➔ false\n */\nexport function isValidDomain(\n  value: unknown,\n  options: IsValidDomainOptions = {}\n): boolean {\n  if (!isString(value)) return false;\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const {\n    subdomain = true,\n    topLevel = false,\n    wildcard = false,\n    allowUnicode = false,\n    allowPort = false,\n    allowLocalhost = false,\n    allowProtocol = false\n  } = options;\n\n  // Validate Options:\n  const invalid = Object.entries({\n    subdomain,\n    topLevel,\n    wildcard,\n    allowUnicode,\n    allowProtocol,\n    allowPort,\n    allowLocalhost\n  }).filter(([, value]) => !isBoolean(value));\n\n  if (invalid.length) {\n    const msg = invalid\n      .map(([key, value], i) => {\n        return joinLines(\n          `   ${i + 1}. option: \"${key}\"`,\n          \"      expected: boolean\",\n          `      received: ${getPreciseType(value)} (${safeStableStringify(\n            value,\n            {\n              keepUndefined: true\n            }\n          )})`\n        );\n      })\n      .join(EOL);\n\n    throw new TypeError(\n      joinLines(\n        \"\",\n        \"> Invalid options detected in second parameter of `isValidDomain`:\",\n        msg\n      )\n    );\n  }\n  // -----------------\n\n  let _value = value.toLowerCase();\n\n  if (allowProtocol) {\n    try {\n      const url = new URL(value); // use original input\n      if (url.protocol !== \"http:\" && url.protocol !== \"https:\") return false; // reject non-http(s)\n      if (!allowPort && url.port) return false; // reject port if allowPort=false\n      _value = url.hostname.toLowerCase(); // extract only hostname\n\n      // wildcard check\n      const labels = _value.split(\".\");\n      if (labels[0] === \"*\" && !wildcard) return false;\n    } catch {\n      // if parsing fails, leave _value unchanged\n    }\n  }\n\n  if (value.endsWith(\".\")) {\n    _value = _value.slice(0, _value.length - 1);\n  }\n\n  // Handle port\n  let port: string;\n  if (allowPort) {\n    const portMatch = _value.match(/:(\\d{1,5})$/);\n    if (portMatch) {\n      port = portMatch[0];\n      _value = _value.slice(0, -port.length);\n      const portNum = Number(portMatch[1]);\n      if (portNum < 1 || portNum > 65535) return false;\n    }\n  }\n\n  // Allow localhost\n  if (allowLocalhost && _value === \"localhost\") return true;\n\n  if (allowUnicode) {\n    try {\n      _value = punycodeUtilsJS.toASCII(_value);\n    } catch {\n      return false;\n    }\n  }\n\n  if (_value.length > 253) return false;\n\n  const validChars = /^([\\u0E00-\\u0E7Fa-z0-9-._*]+)$/g;\n  if (!validChars.test(_value)) return false;\n\n  if (topLevel) {\n    if (ccTldMap[_value.replace(/\\.$/, \"\") as keyof typeof ccTldMap]) {\n      return true;\n    }\n  }\n\n  const sldRegex = /(.*)\\.(([\\u0E00-\\u0E7Fa-z0-9]+)(\\.[a-z0-9]+))/;\n  const matches = _value.match(sldRegex);\n  // eslint-disable-next-line no-useless-assignment\n  let tld: string | null = null;\n  let labels: string[] | null = null;\n\n  if (matches && matches.length > 2) {\n    if (sldMap[matches[2] as keyof typeof sldMap]) {\n      // eslint-disable-next-line no-useless-assignment\n      tld = matches[2] || null;\n      labels = matches[1]?.split(\".\") || null;\n    }\n  }\n\n  if (!labels) {\n    labels = _value.split(\".\");\n    if (labels.length <= 1) return false;\n\n    tld = labels.pop()!;\n    const tldRegex = /^(?:xn--)?(?!^\\d+$)[\\u0E00-\\u0E7Fa-z0-9]+$/gi;\n    if (!tldRegex.test(tld)) return false;\n  }\n\n  if (subdomain === false && labels.length > 1) return false;\n\n  return labels.every((label, index) => {\n    if (wildcard && index === 0 && label === \"*\" && labels.length > 1) {\n      return true;\n    }\n\n    let validLabelChars = /^([\\u0E00-\\u0E7Fa-zA-Z0-9-_]+)$/g;\n    if (index === labels.length - 1) {\n      validLabelChars = /^([\\u0E00-\\u0E7Fa-zA-Z0-9-]+)$/g;\n    }\n\n    const doubleDashCount = (label.match(/--(--)?/g) || []).length;\n    const xnDashCount = (label.match(/xn--/g) || []).length;\n    if (index === labels.length - 1 && doubleDashCount !== xnDashCount) {\n      return false;\n    }\n\n    return (\n      validLabelChars.test(label) &&\n      label.length < 64 &&\n      !label.startsWith(\"-\") &&\n      !label.endsWith(\"-\")\n    );\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA,MAAa,SAAS,UAAiC;CACrD,OAAO,iBAAiB;;;;;;;;;;;;;;ACiC1B,SAAS,QAAQ,OAAO;CACvB,OAAO,MAAM,QAAQ,MAAM;;AAQ5B,SAAS,SAAS,OAAO;CACxB,OAAO,OAAO,UAAU,YAAY,CAAC,MAAM,MAAM,IAAI,CAAC,QAAQ,MAAM;;AAKrE,MAAM,SAAS,UAAU;CACxB,OAAO,SAAS;;AAQjB,MAAM,cAAc,UAAU;CAC7B,OAAO,OAAO,UAAU;;AA2IzB,MAAM,oBAAoB,UAAU,SAAS,MAAM,IAAI,WAAW,MAAM,QAAQ;AAChF,MAAM,0BAA0B;CAC/B,IAAI,CAAC,iBAAiB,WAAW,EAAE,OAAO,KAAK;CAC/C,OAAO,WAAW;;AAEnB,MAAM,qBAAqB,MAAM;CAChC,MAAM,IAAI,mBAAmB;CAC7B,IAAI,GAAG,OAAO;CACd,IAAI,OAAO,UAAU,aAAa,OAAO,IAAI,MAAM,GAAG,EAAE,IAAI,QAAQ,MAAM;EACzE,MAAM,KAAK,mBAAmB;EAC9B,OAAO,KAAK,GAAG,QAAQ,OAAO;IAC5B,CAAC;CACJ,OAAO;GACL,SAAS,IAAI;CACf,MAAM,IAAI,mBAAmB;CAC7B,IAAI,GAAG,OAAO,EAAE,KAAK,MAAM,GAAG;CAC9B,MAAM,IAAI,MAAM,4BAA4B,GAAG,mEAAmE;EACjH;AAEF,MAAM,UAAU,KAAK,OAAO;AAC5B,MAAM,MAAM,iBAAiB,WAAW,GAAG,iBAAiB,UAAU,CAAC,MAAM;AAa7E,SAAS,UAAU,GAAG,MAAM;CAC3B,OAAO,KAAK,OAAO,QAAQ,CAAC,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/{isValidDomain-CTw5vZFY.js → isValidDomain-CHKOn79-.js}

@@ -2,14 +2,14 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.13.0-beta.2`
+*  Version: `3.13.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { F as isBoolean, T as assertIsPlainObject, k as isString, r as getPreciseType } from "./assertIsBoolean-Bv6gL-xe.js";
-import { t as safeStableStringify } from "./safeStableStringify-BrOcdX9n.js";
-import { t as punycodeUtilsJS } from "./punyCode-BeFYDjj0.js";
+import { F as isBoolean, T as assertIsPlainObject, k as isString, r as getPreciseType } from "./assertIsBoolean-9-huIcIR.js";
+import { t as safeStableStringify } from "./safeStableStringify-C5Gc3ZED.js";
+import { t as punycodeUtilsJS } from "./punyCode-C0ft9dER.js";
 const isURL = (value) => {
 	return value instanceof URL;
 };
@@ -17,7 +17,7 @@ const isURL = (value) => {
 * ========================================================================
 *  @rzl-zone/build-tools
 * ------------------------------------------------------------------------
-*  Version: `0.0.12-beta.0`
+*  Version: `0.0.12`
 *  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`
 * ========================================================================
@@ -1827,4 +1827,4 @@ function isValidDomain(value, options = {}) {
 	});
 }
 export { isURL as i, EOL as n, joinLines as r, isValidDomain as t };
-//# sourceMappingURL=isValidDomain-CTw5vZFY.js.map
+//# sourceMappingURL=isValidDomain-CHKOn79-.js.map