{"version":3,"file":"isTypedArray-CnRfcdD7.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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"}