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

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

@@ -1 +1 @@
-{"version":3,"file":"isTypedArray-DxsPKrLh.js","names":[],"sources":["../src/predicates/is/isRegExp.ts","../src/predicates/is/isArrayBuffer.ts","../src/predicates/is/_private/baseDeepEqual.ts","../src/predicates/is/isEqual.ts","../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.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 *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if value is an instance of **`RegExp`**.\n *\n * ---\n * @example\n * isRegExp(/abc/);\n * // ➔ true\n * isRegExp(new RegExp(\"abc\"));\n * // ➔ true\n * isRegExp(\"abc\");\n * // ➔ 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 *\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 *\n * @example\n * isArrayBuffer(new ArrayBuffer(2));\n * // ➔ true\n * isArrayBuffer(new Array(2));\n * // ➔ false\n */\nexport const 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 *\n * ---\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 *\n * ---\n * @returns\n * - `true`  ➔ `value` and `other` are deeply equal.\n * - `false` ➔ `value` and `other` are not deeply equal.\n *\n * ---\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 * // ➔ 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 *\n * ---\n * @description\n * Checks whether two values are **deeply equal**, not just reference-equal (`===`).\n *\n * ---\n * - #### *Behavior:*\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 *\n * ---\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n *\n * ---\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n *\n * ---\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 const isEqual = (value: unknown, other: unknown): boolean => {\n  return baseDeepEqual(value, other, undefined, new WeakMap());\n};\n","import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** ----------------------------------------------------------\n   * * ***Whether to check symbol properties when checking empty objects, default: `false`.***\n   * -----------------------------------------------------------\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 *\n * ---\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 *           ---\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 *\n * ---\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n *\n * ---\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n *\n * ---\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: 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 *\n * ---\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 *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n *\n * ---\n * @example\n * isTypedArray(new Uint8Array);\n * // ➔ true\n * isTypedArray(new Uint8Array());\n * // ➔ true\n * isTypedArray(new Float32Array());\n * // ➔ true\n * isTypedArray(new Uint8ClampedArray());\n * // ➔ true\n * isTypedArray([]);\n * // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));\n * // ➔ false\n */\nexport const 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":"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"}
+{"version":3,"file":"isTypedArray-BY8CIj3k.js","names":[],"sources":["../src/predicates/is/isRegExp.ts","../src/predicates/is/isArrayBuffer.ts","../src/predicates/is/_private/baseDeepEqual.ts","../src/predicates/is/isEqual.ts","../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.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 *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if value is an instance of **`RegExp`**.\n *\n * ---\n * @example\n * isRegExp(/abc/);\n * // ➔ true\n * isRegExp(new RegExp(\"abc\"));\n * // ➔ true\n * isRegExp(\"abc\");\n * // ➔ 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 *\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 *\n * @example\n * isArrayBuffer(new ArrayBuffer(2));\n * // ➔ true\n * isArrayBuffer(new Array(2));\n * // ➔ false\n */\nexport const 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 *\n * ---\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 *\n * ---\n * @returns\n * - `true`  ➔ `value` and `other` are deeply equal.\n * - `false` ➔ `value` and `other` are not deeply equal.\n *\n * ---\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 * // ➔ 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 *\n * ---\n * @description\n * Checks whether two values are **deeply equal**, not just reference-equal (`===`).\n *\n * ---\n * - #### *Behavior:*\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 *\n * ---\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n *\n * ---\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n *\n * ---\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 const isEqual = (value: unknown, other: unknown): boolean => {\n  return baseDeepEqual(value, other, undefined, new WeakMap());\n};\n","import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** ----------------------------------------------------------\n   * * ***Whether to check symbol properties when checking empty objects, default: `false`.***\n   * -----------------------------------------------------------\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 *\n * ---\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 *           ---\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 *\n * ---\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n *\n * ---\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n *\n * ---\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: 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 *\n * ---\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 *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n *\n * ---\n * @example\n * isTypedArray(new Uint8Array);\n * // ➔ true\n * isTypedArray(new Uint8Array());\n * // ➔ true\n * isTypedArray(new Float32Array());\n * // ➔ true\n * isTypedArray(new Uint8ClampedArray());\n * // ➔ true\n * isTypedArray([]);\n * // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));\n * // ➔ false\n */\nexport const 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":"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"}

package/dist/{isTypedArray-DjADSu8q.cjs → isTypedArray-DspIjxdk.cjs}

@@ -2,15 +2,15 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_logger = require('./logger-CUacYy3D.cjs');
-const require_isEmptyValue = require('./isEmptyValue-CFExALXZ.cjs');
-const require_safeStableStringify = require('./safeStableStringify-C5HHKUdn.cjs');
+const require_logger = require('./logger-BXg2xufj.cjs');
+const require_isEmptyValue = require('./isEmptyValue-qNOhUBFE.cjs');
+const require_safeStableStringify = require('./safeStableStringify-MuBiT-4B.cjs');
 const isRegExp = (value) => {
 	return value instanceof RegExp;
 };
@@ -140,4 +140,4 @@ Object.defineProperty(exports, 'isTypedArray', {
     return isTypedArray;
   }
 });
-//# sourceMappingURL=isTypedArray-DjADSu8q.cjs.map
+//# sourceMappingURL=isTypedArray-DspIjxdk.cjs.map

package/dist/{isTypedArray-DjADSu8q.cjs.map → isTypedArray-DspIjxdk.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"isTypedArray-DjADSu8q.cjs","names":["isObjectOrArray","isUndefined","isDate","isError","isMap","isSet","isArray","isEmptyValue"],"sources":["../src/predicates/is/isRegExp.ts","../src/predicates/is/isArrayBuffer.ts","../src/predicates/is/_private/baseDeepEqual.ts","../src/predicates/is/isEqual.ts","../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.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 *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if value is an instance of **`RegExp`**.\n *\n * ---\n * @example\n * isRegExp(/abc/);\n * // ➔ true\n * isRegExp(new RegExp(\"abc\"));\n * // ➔ true\n * isRegExp(\"abc\");\n * // ➔ 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 *\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 *\n * @example\n * isArrayBuffer(new ArrayBuffer(2));\n * // ➔ true\n * isArrayBuffer(new Array(2));\n * // ➔ false\n */\nexport const 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 *\n * ---\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 *\n * ---\n * @returns\n * - `true`  ➔ `value` and `other` are deeply equal.\n * - `false` ➔ `value` and `other` are not deeply equal.\n *\n * ---\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 * // ➔ 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 *\n * ---\n * @description\n * Checks whether two values are **deeply equal**, not just reference-equal (`===`).\n *\n * ---\n * - #### *Behavior:*\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 *\n * ---\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n *\n * ---\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n *\n * ---\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 const isEqual = (value: unknown, other: unknown): boolean => {\n  return baseDeepEqual(value, other, undefined, new WeakMap());\n};\n","import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** ----------------------------------------------------------\n   * * ***Whether to check symbol properties when checking empty objects, default: `false`.***\n   * -----------------------------------------------------------\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 *\n * ---\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 *           ---\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 *\n * ---\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n *\n * ---\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n *\n * ---\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: 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 *\n * ---\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 *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n *\n * ---\n * @example\n * isTypedArray(new Uint8Array);\n * // ➔ true\n * isTypedArray(new Uint8Array());\n * // ➔ true\n * isTypedArray(new Float32Array());\n * // ➔ true\n * isTypedArray(new Uint8ClampedArray());\n * // ➔ true\n * isTypedArray([]);\n * // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));\n * // ➔ false\n */\nexport const 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,YAAY,UAAoC;CAC3D,OAAO,iBAAiB;AAC1B;;;;;;;;;;;;;;;;;;ACRA,MAAa,iBAAiB,UAAyC;CACrE,OAAO,iBAAiB;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACiCA,SAAgB,cACd,OACA,OACA,YACA,uBAAgC,IAAI,QAAQ,GACnC;CAET,IAAI,UAAU,OAAO,OAAO;CAG5B,IAAI,UAAU,SAAS,UAAU,OAAO,OAAO;CAG/C,IAAI,CAACA,+BAAgB,KAAK,KAAK,CAACA,+BAAgB,KAAK,GACnD,OAAO;CAIT,IAAI,KAAK,IAAI,KAAK,MAAM,OAAO,OAAO;CACtC,KAAK,IAAI,OAAO,KAAK;CAGrB,MAAM,kBACJ,GACA,GACA,KACA,QACA,WACG;EACH,IAAI,YAAY;GACd,MAAM,SAAS,WAAW,GAAG,GAAG,KAAK,QAAQ,QAAQ,IAAI;GACzD,IAAI,CAACC,wCAAY,MAAM,GAAG,OAAO;EACnC;EACA,OAAO,cAAc,GAAG,GAAG,YAAY,IAAI;CAC7C;CAGA,IAAIC,mCAAO,KAAK,KAAKA,mCAAO,KAAK,GAC/B,OAAO,MAAM,QAAQ,MAAM,MAAM,QAAQ;CAE3C,IAAI,SAAS,KAAK,KAAK,SAAS,KAAK,GACnC,OAAO,MAAM,WAAW,MAAM,UAAU,MAAM,UAAU,MAAM;CAEhE,IAAIC,uBAAQ,KAAK,KAAKA,uBAAQ,KAAK,GACjC,OAAO,MAAM,SAAS,MAAM,QAAQ,MAAM,YAAY,MAAM;CAE9D,IAAI,YAAY,OAAO,KAAK,KAAK,YAAY,OAAO,KAAK,GAAG;EAC1D,MAAM,IAAI,IAAI,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;EACzE,MAAM,IAAI,IAAI,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;EACzE,IAAI,EAAE,WAAW,EAAE,QAAQ,OAAO;EAClC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO;EAC7D,OAAO;CACT;CAEA,IAAI,cAAc,KAAK,KAAK,cAAc,KAAK,GAAG;EAChD,IAAI,MAAM,eAAe,MAAM,YAAY,OAAO;EAClD,MAAM,IAAI,IAAI,WAAW,KAAK,GAC5B,IAAI,IAAI,WAAW,KAAK;EAC1B,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO;EAC7D,OAAO;CACT;CAEA,IAAIC,kCAAM,KAAK,KAAKA,kCAAM,KAAK,GAAG;EAChC,IAAI,MAAM,SAAS,MAAM,MAAM,OAAO;EACtC,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO;GAC1B,IAAI,CAAC,MAAM,IAAI,CAAC,GAAG,OAAO;GAC1B,IAAI,CAAC,cAAc,GAAG,MAAM,IAAI,CAAC,GAAG,YAAY,IAAI,GAAG,OAAO;EAChE;EACA,OAAO;CACT;CAEA,IAAIC,qBAAM,KAAK,KAAKA,qBAAM,KAAK,GAAG;EAChC,IAAI,MAAM,SAAS,MAAM,MAAM,OAAO;EACtC,KAAK,MAAM,KAAK,OAAO;GACrB,IAAI,UAAU;GACd,KAAK,MAAM,KAAK,OACd,IAAI,cAAc,GAAG,GAAG,YAAY,IAAI,GAAG;IACzC,UAAU;IACV;GACF;GAEF,IAAI,CAAC,SAAS,OAAO;EACvB;EACA,OAAO;CACT;CAEA,IAAIC,uBAAQ,KAAK,KAAKA,uBAAQ,KAAK,GAAG;EACpC,IAAI,MAAM,WAAW,MAAM,QAAQ,OAAO;EAC1C,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAChC,IAAI,CAAC,eAAe,MAAM,IAAI,MAAM,IAAI,GAAG,OAAO,KAAK,GAAG,OAAO;EAEnE,OAAO;CACT;CAEA,IAAI,OAAO,eAAe,KAAK,MAAM,OAAO,eAAe,KAAK,GAC9D,OAAO;CAGT,MAAM,QAAQ,QAAQ,QAAQ,KAAK;CACnC,MAAM,QAAQ,QAAQ,QAAQ,KAAK;CACnC,IAAI,MAAM,WAAW,MAAM,QAAQ,OAAO;CAE1C,KAAK,MAAM,OAAO,OAAO;EACvB,MAAM,OAAO,MAAM;EACnB,MAAM,OAAO,MAAM;EACnB,IAAI,CAAC,eAAe,MAAM,MAAM,KAAK,OAAO,KAAK,GAAG,OAAO;CAC7D;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC1GA,MAAa,WAAW,OAAgB,UAA4B;CAClE,OAAO,cAAc,OAAO,OAAO,wBAAW,IAAI,QAAQ,CAAC;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC0BA,MAAa,mBACX,OACA,UAAkC,CAAC,MACvB;CACZ,OAAO,CAACC,kCAAa,OAAO,OAAO;AACrC;;;;ACnFA,MAAM,iBAAiB,IAAI,IAAI;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCD,MAAa,gBAAgB,UAAwC;CACnE,OACE,SAAS,QACT,OAAO,UAAU,YACjB,eAAe,IAAI,OAAO,UAAU,SAAS,KAAK,KAAK,CAAC;AAE5D"}
+{"version":3,"file":"isTypedArray-DspIjxdk.cjs","names":["isObjectOrArray","isUndefined","isDate","isError","isMap","isSet","isArray","isEmptyValue"],"sources":["../src/predicates/is/isRegExp.ts","../src/predicates/is/isArrayBuffer.ts","../src/predicates/is/_private/baseDeepEqual.ts","../src/predicates/is/isEqual.ts","../src/predicates/is/isNonEmptyValue.ts","../src/predicates/is/isTypedArray.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 *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if value is an instance of **`RegExp`**.\n *\n * ---\n * @example\n * isRegExp(/abc/);\n * // ➔ true\n * isRegExp(new RegExp(\"abc\"));\n * // ➔ true\n * isRegExp(\"abc\");\n * // ➔ 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 *\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 *\n * @example\n * isArrayBuffer(new ArrayBuffer(2));\n * // ➔ true\n * isArrayBuffer(new Array(2));\n * // ➔ false\n */\nexport const 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 *\n * ---\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 *\n * ---\n * @returns\n * - `true`  ➔ `value` and `other` are deeply equal.\n * - `false` ➔ `value` and `other` are not deeply equal.\n *\n * ---\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 * // ➔ 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 *\n * ---\n * @description\n * Checks whether two values are **deeply equal**, not just reference-equal (`===`).\n *\n * ---\n * - #### *Behavior:*\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 *\n * ---\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n *\n * ---\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n *\n * ---\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 const isEqual = (value: unknown, other: unknown): boolean => {\n  return baseDeepEqual(value, other, undefined, new WeakMap());\n};\n","import { isEmptyValue } from \"./isEmptyValue\";\n\ntype IsNonEmptyValueOptions = {\n  /** ----------------------------------------------------------\n   * * ***Whether to check symbol properties when checking empty objects, default: `false`.***\n   * -----------------------------------------------------------\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 *\n * ---\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 *           ---\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 *\n * ---\n * @param {*} value - The value to evaluate.\n * @param {IsNonEmptyValueOptions} [options] - Optional settings.\n *\n * ---\n * @returns {boolean} Return `true` if the value is considered non-empty/truthy, otherwise `false`.\n *\n * ---\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: 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 *\n * ---\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 *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a typed array, otherwise `false`.\n *\n * ---\n * @example\n * isTypedArray(new Uint8Array);\n * // ➔ true\n * isTypedArray(new Uint8Array());\n * // ➔ true\n * isTypedArray(new Float32Array());\n * // ➔ true\n * isTypedArray(new Uint8ClampedArray());\n * // ➔ true\n * isTypedArray([]);\n * // ➔ false\n * isTypedArray(Buffer.from(\"hi\"));\n * // ➔ false\n */\nexport const 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":"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"}

package/dist/{isValidDomain-CDtNOhMc.js → isValidDomain-BPfJEkFk.js}

@@ -2,16 +2,16 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { T as isString, i as getPreciseType, j as isBoolean, t as createMessage } from "./logger-CLWnKRKE.js";
-import { t as assertIsPlainObject } from "./assertIsPlainObject-j9bDqNLo.js";
-import { t as safeStableStringify } from "./safeStableStringify-DfwxmiWn.js";
-import { n as joinLines, t as EOL } from "./formatter-ekJQF_bA-xLD9mGk4.js";
-import { t as punycodeUtilsJS } from "./punyCode-Deb1Mrkc.js";
+import { T as isString, i as getPreciseType, j as isBoolean, t as createMessage } from "./logger-Wxl_Krg6.js";
+import { t as assertIsPlainObject } from "./assertIsPlainObject-CIzDchLs.js";
+import { t as safeStableStringify } from "./safeStableStringify-CDSYnLUz.js";
+import { n as joinLines, t as EOL } from "./formatter-BFgV1HhV-BtIJs2H2.js";
+import { t as punycodeUtilsJS } from "./punyCode-DsuJbWCl.js";
 const isURL = (value) => {
 	return value instanceof URL;
 };
@@ -1786,4 +1786,4 @@ const isValidDomain = (value, options = {}) => {
 };
 const errorMsg = (msg) => createMessage("isValidDomain", msg);
 export { isURL as n, isValidDomain as t };
-//# sourceMappingURL=isValidDomain-CDtNOhMc.js.map
+//# sourceMappingURL=isValidDomain-BPfJEkFk.js.map

package/dist/{isValidDomain-CDtNOhMc.js.map → isValidDomain-BPfJEkFk.js.map}

@@ -1 +1 @@
-{"version":3,"file":"isValidDomain-CDtNOhMc.js","names":["ccTldMap","sldMap"],"sources":["../src/predicates/is/isURL.ts","../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 *\n * ---\n * - **Behavior:**\n *     - Narrows type to `URL` when true.\n *     - Excludes `strings`, `plain-objects`, and `other non-URL values`.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is an instance of `URL`, otherwise `false`.\n *\n * ---\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","","","import { joinLines, EOL } from \"@rzl-zone/build-tools/utils\";\n\nimport { createMessage } from \"@/_private/logger\";\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  /** ---------------------------------------------------------\n   * * ***Enable conversion of Unicode domains (IDN) to ASCII (punycode).***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"пример.рф\"` ➔ `\"xn--e1afmkfd.xn--p1ai\"`.\n   * - Allows validating Unicode domains correctly.\n   * - Default: `false`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowUnicode?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***If `true`, validates **only top-level domains (TLDs)** that are not part of any SLD/second-level domain.***\n   * ----------------------------------------------------------\n   *\n   * - Behavior:\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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  topLevel?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow or disallow subdomains.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"sub.example.com\"` ✅ if `subdomain` is `true`, ❌ if `false`.\n   * - Wildcards and SLDs are considered when evaluating subdomains.\n   * - Default: `true`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * true\n   * ```\n   */\n  subdomain?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow a wildcard `*` in the left-most label.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"*.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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  wildcard?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow a port after the domain.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowPort?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow special domains like `localhost`.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"localhost\"` ✅ if `allowLocalhost` is `true`.\n   * - Works with or without a port if `allowPort` is enabled.\n   * - Default: `false`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowLocalhost?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow URLs with protocol (`http`/`https`) and automatically extract the hostname.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\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 * ---\n * - #### *Behavior:*\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 *     - 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 * ---\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 *\n * ---\n * @returns {boolean} Returns `true` if the value is a valid domain according to the rules and options; otherwise `false`.\n *\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 const isValidDomain = (\n  value: unknown,\n  options: IsValidDomainOptions = {}\n): boolean => {\n  if (!isString(value)) return false;\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\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      errorMsg(\n        joinLines(\"\", \"> Invalid options detected in second parameter:\", msg)\n      )\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\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"isValidDomain\", msg);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,SAAS,UAAiC;CACrD,OAAO,iBAAiB;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"isValidDomain-BPfJEkFk.js","names":["ccTldMap","sldMap"],"sources":["../src/predicates/is/isURL.ts","../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 *\n * ---\n * - **Behavior:**\n *     - Narrows type to `URL` when true.\n *     - Excludes `strings`, `plain-objects`, and `other non-URL values`.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is an instance of `URL`, otherwise `false`.\n *\n * ---\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","","","import { joinLines, EOL } from \"@rzl-zone/build-tools/utils\";\n\nimport { createMessage } from \"@/_private/logger\";\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  /** ---------------------------------------------------------\n   * * ***Enable conversion of Unicode domains (IDN) to ASCII (punycode).***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"пример.рф\"` ➔ `\"xn--e1afmkfd.xn--p1ai\"`.\n   * - Allows validating Unicode domains correctly.\n   * - Default: `false`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowUnicode?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***If `true`, validates **only top-level domains (TLDs)** that are not part of any SLD/second-level domain.***\n   * ----------------------------------------------------------\n   *\n   * - Behavior:\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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  topLevel?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow or disallow subdomains.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"sub.example.com\"` ✅ if `subdomain` is `true`, ❌ if `false`.\n   * - Wildcards and SLDs are considered when evaluating subdomains.\n   * - Default: `true`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * true\n   * ```\n   */\n  subdomain?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow a wildcard `*` in the left-most label.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"*.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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  wildcard?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow a port after the domain.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowPort?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow special domains like `localhost`.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"localhost\"` ✅ if `allowLocalhost` is `true`.\n   * - Works with or without a port if `allowPort` is enabled.\n   * - Default: `false`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowLocalhost?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow URLs with protocol (`http`/`https`) and automatically extract the hostname.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\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 * ---\n * - #### *Behavior:*\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 *     - 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 * ---\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 *\n * ---\n * @returns {boolean} Returns `true` if the value is a valid domain according to the rules and options; otherwise `false`.\n *\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 const isValidDomain = (\n  value: unknown,\n  options: IsValidDomainOptions = {}\n): boolean => {\n  if (!isString(value)) return false;\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\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      errorMsg(\n        joinLines(\"\", \"> Invalid options detected in second parameter:\", msg)\n      )\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\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"isValidDomain\", msg);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,SAAS,UAAiC;CACrD,OAAO,iBAAiB;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/{isValidDomain-D_x7uNIu.cjs → isValidDomain-DUUCoKtD.cjs}

@@ -2,17 +2,17 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.14.0-beta.0`
+*  Version: `3.14.0`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
 "use strict";
-const require_logger = require('./logger-CUacYy3D.cjs');
-const require_assertIsPlainObject = require('./assertIsPlainObject-DPZLj-Ho.cjs');
-const require_safeStableStringify = require('./safeStableStringify-C5HHKUdn.cjs');
-const require_formatter_ekJQF_bA = require('./formatter-ekJQF_bA-BepnCBkQ.cjs');
-const require_punyCode = require('./punyCode-DHTLhGdD.cjs');
+const require_logger = require('./logger-BXg2xufj.cjs');
+const require_assertIsPlainObject = require('./assertIsPlainObject-DYoxHcW5.cjs');
+const require_safeStableStringify = require('./safeStableStringify-MuBiT-4B.cjs');
+const require_formatter_BFgV1HhV = require('./formatter-BFgV1HhV-DyybWSuj.cjs');
+const require_punyCode = require('./punyCode-B_VPjG0d.cjs');
 const isURL = (value) => {
 	return value instanceof URL;
 };
@@ -1725,9 +1725,9 @@ const isValidDomain = (value, options = {}) => {
 	}).filter(([, value]) => !require_logger.isBoolean(value));
 	if (invalid.length) {
 		const msg = invalid.map(([key, value], i) => {
-			return require_formatter_ekJQF_bA.joinLines(`   ${i + 1}. option: "${key}"`, "      expected: boolean", `      received: ${require_logger.getPreciseType(value)} (${require_safeStableStringify.safeStableStringify(value, { keepUndefined: true })})`);
-		}).join(require_formatter_ekJQF_bA.EOL);
-		throw new TypeError(errorMsg(require_formatter_ekJQF_bA.joinLines("", "> Invalid options detected in second parameter:", msg)));
+			return require_formatter_BFgV1HhV.joinLines(`   ${i + 1}. option: "${key}"`, "      expected: boolean", `      received: ${require_logger.getPreciseType(value)} (${require_safeStableStringify.safeStableStringify(value, { keepUndefined: true })})`);
+		}).join(require_formatter_BFgV1HhV.EOL);
+		throw new TypeError(errorMsg(require_formatter_BFgV1HhV.joinLines("", "> Invalid options detected in second parameter:", msg)));
 	}
 	let _value = value.toLowerCase();
 	if (allowProtocol) try {
@@ -1798,4 +1798,4 @@ Object.defineProperty(exports, 'isValidDomain', {
     return isValidDomain;
   }
 });
-//# sourceMappingURL=isValidDomain-D_x7uNIu.cjs.map
+//# sourceMappingURL=isValidDomain-DUUCoKtD.cjs.map

package/dist/{isValidDomain-D_x7uNIu.cjs.map → isValidDomain-DUUCoKtD.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"isValidDomain-D_x7uNIu.cjs","names":["isString","isBoolean","joinLines","getPreciseType","safeStableStringify","EOL","punycodeUtilsJS","ccTldMap","sldMap","createMessage"],"sources":["../src/predicates/is/isURL.ts","../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 *\n * ---\n * - **Behavior:**\n *     - Narrows type to `URL` when true.\n *     - Excludes `strings`, `plain-objects`, and `other non-URL values`.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is an instance of `URL`, otherwise `false`.\n *\n * ---\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","","","import { joinLines, EOL } from \"@rzl-zone/build-tools/utils\";\n\nimport { createMessage } from \"@/_private/logger\";\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  /** ---------------------------------------------------------\n   * * ***Enable conversion of Unicode domains (IDN) to ASCII (punycode).***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"пример.рф\"` ➔ `\"xn--e1afmkfd.xn--p1ai\"`.\n   * - Allows validating Unicode domains correctly.\n   * - Default: `false`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowUnicode?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***If `true`, validates **only top-level domains (TLDs)** that are not part of any SLD/second-level domain.***\n   * ----------------------------------------------------------\n   *\n   * - Behavior:\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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  topLevel?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow or disallow subdomains.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"sub.example.com\"` ✅ if `subdomain` is `true`, ❌ if `false`.\n   * - Wildcards and SLDs are considered when evaluating subdomains.\n   * - Default: `true`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * true\n   * ```\n   */\n  subdomain?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow a wildcard `*` in the left-most label.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"*.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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  wildcard?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow a port after the domain.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowPort?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow special domains like `localhost`.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"localhost\"` ✅ if `allowLocalhost` is `true`.\n   * - Works with or without a port if `allowPort` is enabled.\n   * - Default: `false`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowLocalhost?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow URLs with protocol (`http`/`https`) and automatically extract the hostname.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\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 * ---\n * - #### *Behavior:*\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 *     - 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 * ---\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 *\n * ---\n * @returns {boolean} Returns `true` if the value is a valid domain according to the rules and options; otherwise `false`.\n *\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 const isValidDomain = (\n  value: unknown,\n  options: IsValidDomainOptions = {}\n): boolean => {\n  if (!isString(value)) return false;\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\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      errorMsg(\n        joinLines(\"\", \"> Invalid options detected in second parameter:\", msg)\n      )\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\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"isValidDomain\", msg);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,SAAS,UAAiC;CACrD,OAAO,iBAAiB;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"isValidDomain-DUUCoKtD.cjs","names":["isString","isBoolean","joinLines","getPreciseType","safeStableStringify","EOL","punycodeUtilsJS","ccTldMap","sldMap","createMessage"],"sources":["../src/predicates/is/isURL.ts","../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 *\n * ---\n * - **Behavior:**\n *     - Narrows type to `URL` when true.\n *     - Excludes `strings`, `plain-objects`, and `other non-URL values`.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is an instance of `URL`, otherwise `false`.\n *\n * ---\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","","","import { joinLines, EOL } from \"@rzl-zone/build-tools/utils\";\n\nimport { createMessage } from \"@/_private/logger\";\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  /** ---------------------------------------------------------\n   * * ***Enable conversion of Unicode domains (IDN) to ASCII (punycode).***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"пример.рф\"` ➔ `\"xn--e1afmkfd.xn--p1ai\"`.\n   * - Allows validating Unicode domains correctly.\n   * - Default: `false`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowUnicode?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***If `true`, validates **only top-level domains (TLDs)** that are not part of any SLD/second-level domain.***\n   * ----------------------------------------------------------\n   *\n   * - Behavior:\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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  topLevel?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow or disallow subdomains.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"sub.example.com\"` ✅ if `subdomain` is `true`, ❌ if `false`.\n   * - Wildcards and SLDs are considered when evaluating subdomains.\n   * - Default: `true`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * true\n   * ```\n   */\n  subdomain?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow a wildcard `*` in the left-most label.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"*.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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  wildcard?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow a port after the domain.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowPort?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow special domains like `localhost`.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"localhost\"` ✅ if `allowLocalhost` is `true`.\n   * - Works with or without a port if `allowPort` is enabled.\n   * - Default: `false`.\n   *\n   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\n   */\n  allowLocalhost?: boolean;\n\n  /** ---------------------------------------------------------\n   * * ***Allow URLs with protocol (`http`/`https`) and automatically extract the hostname.***\n   * ----------------------------------------------------------\n   *\n   * - Example:\n   *     - `\"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   * ---\n   * @default\n   * ```ts\n   * false\n   * ```\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 * ---\n * - #### *Behavior:*\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 *     - 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 * ---\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 *\n * ---\n * @returns {boolean} Returns `true` if the value is a valid domain according to the rules and options; otherwise `false`.\n *\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 const isValidDomain = (\n  value: unknown,\n  options: IsValidDomainOptions = {}\n): boolean => {\n  if (!isString(value)) return false;\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\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      errorMsg(\n        joinLines(\"\", \"> Invalid options detected in second parameter:\", msg)\n      )\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\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"isValidDomain\", msg);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,SAAS,UAAiC;CACrD,OAAO,iBAAiB;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/{logger-CUacYy3D.cjs → logger-BXg2xufj.cjs}

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