{"version":3,"file":"predicates-BktePeml.cjs","names":["isArray","errorMsg","getPreciseType","isEqual","safeStableStringify","createMessage","isEqual","isURL","errorMsg","createMessage","isURL","errorMsg","createMessage","isNonEmptyString","isArray","isPlainObject","errorMsg","createMessage","isNonEmptyString","isArray","isPlainObject","createMessage","isObjectOrArray","createMessage","getPreciseType","isArray","isArray","isEmptyArray","isFunction","isObjectOrArray","isObjectOrArray","isString","isNumber","parseCurrencyString","isDate","isRegExp","isSymbol","isSet","isMap","isArray","isObjectOrArray","isPlainObject","isNil","isBoolean","isNumber","isSymbol","isFunction","isString","isArray","isTypedArray","isMap","isSet","isBuffer","isPlainObject","isString","isEmptyString","isNumber","isNaN","isArray","isEmptyArray","isObjectOrArray","baseDeepEqual","isObjectOrArray","isArray","isUndefined","isFunction","isNil","isObjectOrArray","isFunction","isNonEmptyString","isObject","isNull"],"sources":["../src/predicates/are/areArraysEqual.ts","../src/predicates/are/areObjectsEqual.ts","../src/predicates/are/areURLsEqualPath.ts","../src/predicates/are/areURLsIdentical.ts","../src/predicates/contains/textContainsAll.ts","../src/predicates/contains/textContainsAny.ts","../src/predicates/is/isPropertyKey.ts","../src/predicates/exist/doesKeyExist.ts","../src/predicates/has/arrayHasAnyMatch.ts","../src/predicates/is/isArgument.ts","../src/predicates/is/isLength.ts","../src/predicates/is/isArrayLike.ts","../src/predicates/is/isArrayLikeObject.ts","../src/predicates/is/isCurrencyLike.ts","../src/predicates/is/isDeepEqual.ts","../src/predicates/is/isElement.ts","../src/predicates/is/isEmpty.ts","../src/predicates/is/isEmptyDeep.ts","../src/predicates/is/isEqualWith.ts","../src/predicates/is/isMatchWith.ts","../src/predicates/is/_private/baseIsMatch.ts","../src/predicates/is/isMatch.ts","../src/predicates/is/isNative.ts","../src/predicates/is/isObjectLoose.ts","../src/predicates/is/isSafeInteger.ts","../src/predicates/is/isValidURL.ts","../src/predicates/is/isWeakMap.ts"],"sourcesContent":["import { createMessage } from \"@/_private/logger\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\nimport { isArray } from \"../is/isArray\";\nimport { isEqual } from \"../is/isEqual\";\nimport { getPreciseType } from \"../type/getPreciseType\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `areArraysEqual`.***\n * -----------------------------------------------------------\n * **Compares two arrays deeply to check if they are equal.**\n *\n * ---\n * @description Supports deep comparison of arrays containing nested arrays or objects,\n *  can also ignore the order of elements at all levels by recursively sorting.\n *\n * ---\n * @param {unknown[]} array1\n *   ***The first array to compare, can contain nested arrays or objects.***\n * @param {unknown[]} array2\n *   ***The second array to compare against, should match structure of `array1`.***\n * @param {boolean|undefined} [ignoreOrder=false]\n *   ***Whether to ignore the order of elements when comparing.***\n *    - If `true`, will sort both arrays recursively before comparing, default is `false`.\n *\n * ---\n * @throws **{@link TypeError | `TypeError`}** if `array1` or `array2` are not arrays, or if `ignoreOrder` is not a boolean.\n *\n * ---\n * @returns {boolean}\n *    Returns `true` if both arrays are deeply equal, otherwise `false`.\n *\n * ---\n * @example\n * ```ts\n * areArraysEqual([1, 2, 3], [1, 2, 3]);\n * // ➔ true\n * areArraysEqual([1, 2, 3], [3, 2, 1]);\n * // ➔ false\n * areArraysEqual([1, 2, 3], [3, 2, 1], true);\n * // ➔ true (order ignored)\n * areArraysEqual([{ x: 1 }, { y: 2 }], [{ y: 2 }, { x: 1 }], true);\n * // ➔ true\n * ```\n */\nexport const areArraysEqual = (\n  array1: unknown[],\n  array2: unknown[],\n  ignoreOrder: boolean = false\n): boolean => {\n  if (!(isArray(array1) && isArray(array2))) {\n    throw new TypeError(\n      errorMsg(\n        `Parameters \\`array1\\` and \\`array2\\` property of the \\`options\\` (second parameter) must be of type \\`array\\`, but received: ['array1': \\`${getPreciseType(\n          array1\n        )}\\`, 'array2': \\`${getPreciseType(array2)}\\`].`\n      )\n    );\n  }\n\n  assertIsBoolean(ignoreOrder, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Third parameter \\`ignoreOrder\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\n  });\n\n  if (!isEqual(array1.length, array2.length)) return false;\n\n  /**\n   * Recursively sorts an array (and nested arrays) so that\n   * deep equality checks can ignore order at all levels.\n   *\n   * @param {unknown[]} arr - The array to deep sort.\n   * @returns {unknown[]} A new deeply sorted array.\n   */\n  const deepIgnoreOrder = (arr: unknown[]): unknown[] => {\n    if (!isArray(arr)) return arr;\n\n    // Recursively sort nested arrays\n    const sorted = arr.map((item) => {\n      if (isArray(item)) {\n        return deepIgnoreOrder(item);\n      }\n      return item;\n    });\n\n    // Sort current array level\n    return sorted.sort((a, b) => {\n      const sa = safeStableStringify(a);\n      const sb = safeStableStringify(b);\n      return sa < sb ? -1 : sa > sb ? 1 : 0;\n    });\n  };\n\n  const normalizedArr1 = ignoreOrder ? deepIgnoreOrder(array1) : array1;\n  const normalizedArr2 = ignoreOrder ? deepIgnoreOrder(array2) : array2;\n\n  if (!isEqual(normalizedArr1.length, normalizedArr2.length)) return false;\n\n  return normalizedArr1.every(\n    (item, index) =>\n      safeStableStringify(item) === safeStableStringify(normalizedArr2[index])\n  );\n};\n\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"areArraysEqual\", msg);\n","import { isEqual } from \"../is/isEqual\";\n\n/** ------------------------------------------------------------------\n * * ***Predicate: `areObjectsEqual`.***\n * -------------------------------------------------------------------\n * **Compares two objects for deep equality.**\n *\n * ---\n * @template T1 The type of the first object.\n * @template T2 The type of the second object.\n *\n * ---\n * @param {*} object1 - The first object to compare.\n * @param {*} object2 - The second object to compare.\n *\n * ---\n * @returns {boolean} Return `true` if both objects are deeply equal, otherwise `false`.\n *\n * ---\n * @example\n * areObjectsEqual({ a: 1, b: 2 }, { a: 1, b: 2 });\n * // ➔ true\n * areObjectsEqual({ a: 1 }, { a: 1, b: undefined });\n * // ➔ false\n * areObjectsEqual([1, 2, 3], [1, 2, 3]);\n * // ➔ true\n */\nexport const areObjectsEqual = (\n  object1: unknown,\n  object2: unknown\n): boolean => {\n  return isEqual(object1, object2);\n};\n","import { createMessage } from \"@/_private/logger\";\n\nimport { isURL } from \"../is/isURL\";\n\n/** ------------------------------------------------------------------\n * * ***Predicate: `areURLsEqualPath`.***\n * -------------------------------------------------------------------\n * **Checks if two URLs are the same, ignoring query parameters, this function compares only the protocol, host, and pathname.**\n *\n * ---\n * @param {URL} urlA - The first URL to compare.\n * @param {URL} urlB - The second URL to compare.\n *\n * ---\n * @returns {boolean} Returns `true` if both URLs are the same (ignoring search parameters), otherwise `false`.\n *\n * ---\n * @example\n * 1. #### Same domain, same path, different query:\n *    ```ts\n *    areURLsEqualPath(\n *      new URL(\"https://example.com/page?a=1\"),\n *      new URL(\"https://example.com/page?b=2\")\n *    );\n *    // ➔ true\n *    ```\n *    ---\n * 2. #### Same domain, different path:\n *    ```ts\n *    areURLsEqualPath(\n *      new URL(\"https://example.com/page1\"),\n *      new URL(\"https://example.com/page2\")\n *    );\n *    // ➔ false\n *    ```\n *    ---\n * 3. #### Different protocol:\n *    ```ts\n *    areURLsEqualPath(\n *      new URL(\"http://example.com/page\"),\n *      new URL(\"https://example.com/page\")\n *    );\n *    // ➔ false\n *    ```\n *    ---\n * 4. #### Same protocol, same host, same path (ignores query & hash):\n *    ```ts\n *    areURLsEqualPath(\n *      new URL(\"https://example.com/page#section\"),\n *      new URL(\"https://example.com/page\")\n *    );\n *    // ➔ true\n *    ```\n */\nexport const areURLsEqualPath = (urlA: URL, urlB: URL): boolean => {\n  if (!isURL(urlA) || !isURL(urlB)) {\n    throw new TypeError(\n      errorMsg(\n        \"Parameters `urlA` and `urlB` (first and second parameter) must be instance of URL.\"\n      )\n    );\n  }\n\n  return (\n    urlA.protocol + \"//\" + urlA.host + urlA.pathname ===\n    urlB.protocol + \"//\" + urlB.host + urlB.pathname\n  );\n};\n\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"areURLsEqualPath\", msg);\n","import { createMessage } from \"@/_private/logger\";\n\nimport { isURL } from \"../is/isURL\";\n\n/** ------------------------------------------------------------------\n * * ***Predicate: `areURLsIdentical`.***\n * -------------------------------------------------------------------\n * **Checks if two URLs are exactly the same, including protocol, host, pathname, and query parameters.**\n *\n * ---\n * @param {URL} urlA - The first URL to compare.\n * @param {URL} urlB - The second URL to compare.\n *\n * ---\n * @returns {boolean} Returns `true` if both URLs are identical, otherwise `false`.\n *\n * ---\n * @example\n * 1. #### Identical URLs:\n *    ```ts\n *    areURLsIdentical(\n *      new URL(\"https://example.com/page?a=1\"),\n *      new URL(\"https://example.com/page?a=1\")\n *    );\n *    // ➔ true\n *    ```\n *    ---\n * 2. #### Same path, different query parameter:\n *    ```ts\n *    areURLsIdentical(\n *      new URL(\"https://example.com/page?a=1\"),\n *      new URL(\"https://example.com/page?b=2\")\n *    );\n *    // ➔ false\n *    ```\n *    ---\n * 3. #### Same host & query, but different protocol:\n *    ```ts\n *    areURLsIdentical(\n *      new URL(\"http://example.com/page?a=1\"),\n *      new URL(\"https://example.com/page?a=1\")\n *    );\n *    // ➔ false\n *    ```\n *    ---\n * 4. #### Same everything except trailing slash:\n *    ```ts\n *    areURLsIdentical(\n *      new URL(\"https://example.com/page\"),\n *      new URL(\"https://example.com/page/\")\n *    );\n *    // ➔ false\n *    ```\n */\nexport const areURLsIdentical = (urlA: URL, urlB: URL): boolean => {\n  if (!isURL(urlA) || !isURL(urlB)) {\n    throw new TypeError(\n      errorMsg(\n        \"Parameters `urlA` and `urlB` (first and second parameter) must be instance of URL.\"\n      )\n    );\n  }\n\n  return (\n    urlA.protocol + \"//\" + urlA.host + urlA.pathname + urlA.search ===\n    urlB.protocol + \"//\" + urlB.host + urlB.pathname + urlB.search\n  );\n};\n\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"areURLsIdentical\", msg);\n","import { createMessage } from \"@/_private/logger\";\n\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\n\nimport { isArray } from \"../is/isArray\";\nimport { isPlainObject } from \"../is/isPlainObject\";\nimport { isNonEmptyString } from \"../is/isNonEmptyString\";\n\ntype OptionsTextContainsAll = {\n  /** ----------------------------------------------------------\n   * * ***If `true`, matches whole words only, defaultValue is `false`.***\n   * -----------------------------------------------------------\n   *\n   * @default false\n   */\n  exactMatch?: boolean;\n  /** ----------------------------------------------------------\n   * * ***Optional regex flags (default: `\"i\"` for case-insensitive).***\n   * -----------------------------------------------------------\n   *\n   * @default \"i\"\n   */\n  flags?: string;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `textContainsAll`.***\n * -----------------------------------------------------------\n * **Checks if the given `text` contains all of the specified `searchWords`.**\n *\n * ---\n * - **Behavior:**\n *     - Returns `false` if `text` or `searchWords` is `null`/`undefined`/invalid.\n *     - Uses **regular expressions** for flexible pattern matching.\n *     - **Escapes special characters** to prevent regex injection attacks.\n *     - **Trims input** to avoid false positives with empty spaces.\n *     - **Supports exact word matching** (optional).\n *\n * ---\n * @param {string|null|undefined} text - The string text to search within.\n * @param {string[]|null} [searchWords] - An array of words/phrases to match against the text.\n * @param {OptionsTextContainsAll} [options] - Optional configuration object.\n * @param {OptionsTextContainsAll[\"exactMatch\"]} [options.exactMatch=false] - If `true`, matches whole words only, defaultValue is `false`.\n * @param {OptionsTextContainsAll[\"flags\"]} [options.flags=\"i\"] - Optional regex flags (default: `\"i\"` for case-insensitive).\n *\n * ---\n * @returns {boolean} Return `true` if all `searchWords` are found in `text`, otherwise `false`.\n *\n * ---\n * @example\n * textContainsAll(\"Hello world, WithAI APP\", [\"Hello\", \"world\"]);\n * // ➔ true\n * textContainsAll(\"JavaScript and TypeScript\", [\"Java\", \"Script\"]);\n * // ➔ true\n * textContainsAll(\"Machine Learning\", [\"AI\", \"Learning\"]);\n * // ➔ false\n * textContainsAll(\"open-source\", [\"open\"], { exactMatch: true });\n * // ➔ false (because options `exactMatch=true`)\n * textContainsAll(null, [\"test\"]);\n * // ➔ false (invalid text)\n * textContainsAll(\"Hello\", null);\n * // ➔ false (invalid searchWords)\n */\nexport const textContainsAll = <T extends string>(\n  text?: T | null,\n  searchWords?: T[] | string[] | null,\n  options: OptionsTextContainsAll = {}\n): boolean => {\n  if (!isNonEmptyString(text) || !isArray(searchWords)) return false;\n  if (!isPlainObject(options)) options = {};\n\n  // fallback to default\n  const { exactMatch = false, flags = \"i\" } = options;\n\n  assertIsBoolean(exactMatch, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Parameter \\`exactMatch\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\n  });\n\n  assertIsString(flags, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Parameter \\`flags\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\n  });\n  // Escape special regex characters to prevent unintended behavior\n  const escapeRegex = (str: string) =>\n    str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\n  // Filter out empty search words\n  const validSearchWords = searchWords\n    .filter((word) => isNonEmptyString(word))\n    .map(escapeRegex);\n\n  if (validSearchWords.length === 0) return false;\n\n  // Create regex pattern: Whole word match (`\\bword\\b`) <- is deprecated. if `exactMatch` is true\n  return validSearchWords.every((word) => {\n    const pattern = exactMatch ? `(?<!\\\\S)${word}(?!\\\\S)` : word;\n    return new RegExp(pattern, flags.includes(\"u\") ? flags : flags + \"u\").test(\n      text\n    );\n  });\n};\n\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"textContainsAll\", msg);\n","import { createMessage } from \"@/_private/logger\";\n\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\n\nimport { isArray } from \"../is/isArray\";\nimport { isPlainObject } from \"../is/isPlainObject\";\nimport { isNonEmptyString } from \"../is/isNonEmptyString\";\n\ntype OptionsTextContainsAny = {\n  /** ----------------------------------------------------------\n   * * ***If `true`, matches whole words only, defaultValue is `false`.***\n   * -----------------------------------------------------------\n   *\n   * @default false\n   */\n  exactMatch?: boolean;\n  /** ----------------------------------------------------------\n   * * ***Optional regex flags (default: `\"i\"` for case-insensitive).***\n   * -----------------------------------------------------------\n   * @default \"i\"\n   */\n  flags?: string;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `textContainsAny`.***\n * -----------------------------------------------------------\n * **Checks if the given `text` contains at least one of the specified `searchWords`.**\n *\n * ---\n * - **Behavior:**\n *     - Returns `false` if `text` or `searchWords` is `null`/`undefined`/invalid.\n *     - Uses **regular expressions** for flexible pattern matching.\n *     - **Escapes special characters** to prevent regex injection attacks.\n *     - **Trims input** to avoid false positives with empty spaces.\n *     - **Supports exact word matching** (optional).\n *\n * ---\n * @param {string|null|undefined} text - The string text to search within.\n * @param {string[]|null} [searchWords] - An array of words/phrases to match against the text.\n * @param {OptionsTextContainsAny} [options] - Optional configuration object.\n * @param {OptionsTextContainsAny[\"exactMatch\"]} [options.exactMatch=false] - If `true`, matches whole words only, defaultValue is `false`.\n * @param {OptionsTextContainsAny[\"flags\"]} [options.flags=\"i\"] - Optional regex flags (default: `\"i\"` for case-insensitive).\n *\n * ---\n * @returns {boolean} Return `true` if at least one `searchWord` is found in `text`, otherwise `false`.\n *\n * ---\n * @example\n * textContainsAny(\"Hello world\", [\"hello\", \"test\"]);\n * // ➔ true\n * textContainsAny(\"withAI APP\", [\"chat\", \"ai\"]);\n * // ➔ false\n * textContainsAny(\"TypeScript is great!\", [\"script\", \"java\"]);\n * // ➔ true\n * textContainsAny(\"open-source\", [\"open\"], { exactMatch: true });\n * // ➔ false (because options `exactMatch=true`)\n * textContainsAny(null, [\"test\"]);\n * // ➔ false (invalid text)\n * textContainsAny(\"Hello\", null);\n * // ➔ false (invalid searchWords)\n */\nexport const textContainsAny = <T extends string>(\n  text?: T | null,\n  searchWords?: T[] | string[] | null,\n  options: OptionsTextContainsAny = {}\n): boolean => {\n  if (!isNonEmptyString(text) || !isArray(searchWords)) return false;\n  if (!isPlainObject(options)) options = {};\n\n  // fallback to default\n  const { exactMatch = false, flags = \"i\" } = options;\n\n  assertIsBoolean(exactMatch, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Parameter \\`exactMatch\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\n  });\n\n  assertIsString(flags, {\n    message: ({ currentType, validType }) =>\n      errorMsg(\n        `Parameter \\`flags\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\n  });\n\n  // Escape special regex characters to prevent unintended behavior\n  const escapeRegex = (str: string) =>\n    str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\n  // Filter out empty search words\n  const validSearchWords = searchWords\n    .filter((word) => isNonEmptyString(word))\n    .map(escapeRegex);\n\n  if (validSearchWords.length === 0) return false;\n\n  const pattern = exactMatch\n    ? `(?<!\\\\S)(${validSearchWords.join(\"|\")})(?!\\\\S)`\n    : `(${validSearchWords.join(\"|\")})`;\n\n  return new RegExp(pattern, flags.includes(\"u\") ? flags : flags + \"u\").test(\n    text\n  );\n};\n\n/**\n * @internal ***`Not part of the public API.`***\n */\nconst errorMsg = (msg: string) => createMessage(\"textContainsAny\", msg);\n","/** ----------------------------------------------------------\n * * ***Type guard: `PropertyKey`.***\n * -----------------------------------------------------------\n * **Checks if a value is a valid `PropertyKey`.**\n *\n * ---\n * - #### *Behavior:*\n *      - #### This function ensures the given `value` is one of these types.\n *          - Narrows type to {@link PropertyKey | ***`PropertyKey`***} when true.\n *          - Useful for working with dynamic object keys.\n *          - Strictly rejects `null`, `undefined`, `boolean`, `object`, `function`, etc.\n *          ---\n *      - #### In JavaScript/TypeScript, a **`PropertyKey`** is any of:\n *          - **`string`**.\n *          - **`number`**.\n *          - **`symbol`**.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if `value` is a valid property key, otherwise `false`.\n *\n * ---\n * @example\n * isPropertyKey(\"foo\");\n * // ➔ true\n * isPropertyKey(123);\n * // ➔ true\n * isPropertyKey(Symbol(\"id\"));\n * // ➔ true\n * isPropertyKey({});\n * // ➔ false\n * isPropertyKey(null);\n * // ➔ false\n */\nexport const isPropertyKey = (value: unknown): value is PropertyKey => {\n  const type = typeof value;\n  return type === \"string\" || type === \"number\" || type === \"symbol\";\n};\n","import { createMessage } from \"@/_private/logger\";\n\nimport { isArray } from \"../is/isArray\";\nimport { isPropertyKey } from \"../is/isPropertyKey\";\nimport { isObjectOrArray } from \"../is/isObjectOrArray\";\nimport { getPreciseType } from \"../type/getPreciseType\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `doesKeyExist`.***\n * -----------------------------------------------------------\n * **Recursively checks if a given key exists in an object or array.**\n *\n * ---\n * - **Behavior:**\n *     - **Supports deeply nested objects and arrays**, searching recursively.\n *     - Uses `Object.prototype.hasOwnProperty.call()` to safely check if the\n *       key exists at each level, even if its value is `null` or `undefined`.\n *     - Optimized to return `true` immediately when the key is found (short-circuits).\n *     - Handles edge cases gracefully:\n *       - Returns `false` for `null`, `undefined`, or non-object inputs.\n *       - Returns `false` if key is not found anywhere, even in deeply nested\n *         structures.\n *\n * ---\n * - **Note:**\n *     - This function only checks for **the existence of the key itself**,\n *       not whether its value is non-null or non-undefined.\n *     - If you need to check for both existence and meaningful value, write a stricter function.\n *\n * ---\n * @template T - The type of the input object or array.\n *\n * ---\n * @param {T | Record<string, unknown> | unknown[]} object - The object or array to search.\n * @param {PropertyKey} key - The key to look for (string, number, or symbol).\n *\n * ---\n * @returns {boolean} Returns `true` if the key exists anywhere in the object or array (even with `null` / `undefined` value), otherwise `false`.\n *\n * ---\n * @example\n * 1. #### Basic usage:\n *    ```ts\n *    doesKeyExist({ name: \"John\", age: 30 }, \"age\");\n *    // ➔ true\n *    doesKeyExist({ user: { profile: { email: \"test@example.com\" } } }, \"email\");\n *    // ➔ true\n *    doesKeyExist([{ id: 1 }, { id: 2 }], \"id\");\n *    // ➔ true\n *    doesKeyExist({ a: { b: { c: 10 } } }, \"d\");\n *    // ➔ false\n *    doesKeyExist(null, \"name\");\n *    // ➔ false\n *    doesKeyExist(undefined, \"test\");\n *    // ➔ false\n *    ```\n *    ---\n * 2. #### Key exists even if value is null or undefined:\n *    ```ts\n *    doesKeyExist({ a: null, b: undefined, c: { d: null } }, \"a\");\n *    // ➔ true\n *    doesKeyExist({ a: null, b: undefined, c: { d: null } }, \"b\");\n *    // ➔ true\n *    doesKeyExist({ a: null, b: undefined, c: { d: null } }, \"d\");\n *    // ➔ true\n *    ```\n *    ---\n * 3. #### Invalid usage:\n *    ```ts\n *    doesKeyExist({ a: 1 }, true);\n *    // ➔ Throws TypeError\n *    doesKeyExist({ a: 1 }, [\"not\", \"valid\"]);\n *    // ➔ Throws TypeError\n *    ```\n */\nexport const doesKeyExist = (\n  object: Record<string, unknown> | unknown[],\n  key: PropertyKey\n): boolean => {\n  if (!isObjectOrArray(object)) return false; // Handle null, undefined, and non-objects\n\n  if (!isPropertyKey(key)) {\n    throw new TypeError(\n      createMessage(\n        \"doesKeyExist\",\n        `Second Parameter (\\`key\\`) must be of type \\`string\\`, \\`number\\` or \\`symbol\\`, but received: \\`${getPreciseType(\n          key\n        )}\\`.`\n      )\n    );\n  }\n\n  // Direct match found\n  if (Object.prototype.hasOwnProperty.call(object, key)) return true;\n\n  if (isArray(object)) {\n    // Check each array item recursively\n    return object.some((item) => doesKeyExist(item as unknown[], key));\n  }\n\n  return Object.values(object).some(\n    (value) => isObjectOrArray(value) && doesKeyExist(value, key)\n  );\n};\n","import { isArray } from \"../is/isArray\";\nimport { isEmptyArray } from \"../is/isEmptyArray\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `arrayHasAnyMatch`.***\n * -----------------------------------------------------------\n * **Checks if at least one element from `targetArray` exists in `sourceArray`.**\n *\n * - **Behavior:**\n *     - Uses `Set` for **faster lookup** compared to `Array.prototype.includes()`.\n *     - Supports **any data type** (`number`, `string`, `boolean`, `object`, `array`, `function`, etc.).\n *     - Uses **reference equality** for non-primitive values (object, array, function).\n *     - Returns `false` if either array is missing, empty, or not an array.\n *\n * @template T - The expected type of array elements.\n * @param {T[] | null | undefined} sourceArray - The array to search within.\n * @param {T[] | null | undefined} targetArray - The array containing elements to match.\n *\n * @returns {boolean}\n *  ***Return:***\n *  - `true` if **at least one element from `targetArray` is strictly found\n *  in `sourceArray`**.\n *    - Comparison uses:\n *      - **Value equality** for primitives (`number`, `string`, `boolean`, `null`, `undefined`).\n *      - **Reference equality** for `objects`, `arrays`, and `functions`.\n *  - `false` if:\n *      - No matching elements exist,\n *      - Either array is not provided, not an actual array, or is empty.\n * @example\n * arrayHasAnyMatch([\"apple\", \"banana\", \"cherry\"], [\"banana\", \"grape\"]);\n * // ➔ true\n * arrayHasAnyMatch([\"red\", \"blue\"], [\"green\", \"yellow\"]);\n * // ➔ false\n * arrayHasAnyMatch([1, 2, 3], [3, 4, 5]);\n * // ➔ true\n * arrayHasAnyMatch([], [\"test\"]);\n * // ➔ false\n * arrayHasAnyMatch([\"A\", \"B\", \"C\"], []);\n * // ➔ false\n *\n * const obj = { x: 1 };\n * arrayHasAnyMatch([obj], [obj]);\n * // ➔ true (same reference)\n * arrayHasAnyMatch([{ x: 1 }], [{ x: 1 }]);\n * // ➔ false (different reference)\n *\n * const fn = () => \"hello\";\n * arrayHasAnyMatch([fn], [fn]);\n * // ➔ true\n * arrayHasAnyMatch([() => \"hello\"], [() => \"hello\"]);\n * // ➔ false (different function reference)\n *\n * const arr = [1, 2];\n * arrayHasAnyMatch([arr], [arr]);\n * // ➔ true\n * arrayHasAnyMatch([[1, 2]], [[1, 2]]);\n * // ➔ false (different array object)\n */\nexport const arrayHasAnyMatch = <T>(\n  sourceArray: T[] | null | undefined,\n  targetArray: T[] | null | undefined\n): boolean => {\n  if (\n    !isArray(sourceArray) ||\n    !isArray(targetArray) ||\n    isEmptyArray(sourceArray) ||\n    isEmptyArray(targetArray)\n  ) {\n    return false;\n  }\n\n  // use Set for lookup more faster.\n  const sourceSet = new Set(sourceArray);\n  return targetArray.some((item) => sourceSet.has(item));\n};\n","/** ----------------------------------------------------------\n * * ***Type guard: `isArguments`.***\n * -----------------------------------------------------------\n * **Checks if `value` is likely an `arguments` object.**\n *\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an ***[`IArguments`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments)*** object, else `false`.\n *\n * @example\n * isArguments(function() { return arguments; }());\n * // ➔ true\n * isArguments([1, 2, 3]);\n * // ➔ false\n */\nexport const isArguments = (value: unknown): value is IArguments => {\n  return Object.prototype.toString.call(value) === \"[object Arguments]\";\n};\n","/** ---------------------------------------------------------\n * * ***Predicate: `isLength`.***\n * ----------------------------------------------------------\n * **Checks whether the given value is a **valid array-like length**.**\n *\n * ---\n * - **Behavior:**\n *     - Ensures the value is a **non-negative integer**.\n *     - Ensures the value is **not greater than `Number.MAX_SAFE_INTEGER`**.\n *     - Excludes non-numeric values, `Infinity`, and fractional numbers.\n *\n * ---\n * - **Note:**\n *     - This method is loosely based-on\n *       [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *     - A valid length must be a non-negative integer and **not greater\n *       than `Number.MAX_SAFE_INTEGER`**.\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n *\n * ---\n * @example\n * isLength(3);\n * // ➔ true\n * isLength(Number.MAX_SAFE_INTEGER);\n * // ➔ true\n * isLength(Number.MAX_SAFE_INTEGER + 1);\n * // ➔ false\n * isLength(\"3\");\n * // ➔ false\n * isLength(-1);\n * // ➔ false\n * isLength(3.14);\n * // ➔ false\n * isLength(Infinity);\n * // ➔ false\n * isLength(-Infinity);\n * // ➔ false\n * isLength(Number.MIN_VALUE);\n * // ➔ false\n */\nexport const isLength = (value: unknown): boolean => {\n  return (\n    typeof value === \"number\" &&\n    value > -1 &&\n    Number.isInteger(value) &&\n    value <= Number.MAX_SAFE_INTEGER\n  );\n};\n","import type { AnyFunction } from \"@rzl-zone/ts-types-plus\";\n\nimport { isLength } from \"./isLength\";\nimport { isFunction } from \"./isFunction\";\nimport { isObjectOrArray } from \"./isObjectOrArray\";\n\n/** ----------------------------------------------------\n * * ***Type guard: `isArrayLike`.***\n * -----------------------------------------------------\n * **Checks if `value` is array-like, a value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.**\n *\n * ---\n * @template T - The type of the value being checked.\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n *\n * ---\n * @example\n * isArrayLike([1, 2, 3]);\n * // ➔ true\n * isArrayLike(document.body.children);\n * // ➔ true\n * isArrayLike(noop);\n * // ➔ false\n * isArrayLike('abc');\n * // ➔ false\n */\nexport function isArrayLike<T extends { __anyHack: unknown }>(\n  value: T\n): boolean;\nexport function isArrayLike(\n  value: AnyFunction | null | undefined\n): value is never;\nexport function isArrayLike(value: unknown): value is { length: number };\nexport function isArrayLike(value: unknown) {\n  return (\n    !isFunction(value) && isObjectOrArray(value) && isLength(value?.length)\n  );\n}\n","import type { AnyFunction } from \"@rzl-zone/ts-types-plus\";\n\nimport { isLength } from \"./isLength\";\nimport { isObjectOrArray } from \"./isObjectOrArray\";\n\n/** ----------------------------------------------------\n * * ***Type guard: `isArrayLikeObject`.***\n * -----------------------------------------------------\n * **This method is like ***`isArrayLike` utility function*** except that\n *   it also checks if `value` is an object.**\n *\n * ---\n * @template T - The type of the value being checked.\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is `array-like object`, else `false`.\n *\n * ---\n * @example\n * isArrayLikeObject([1, 2, 3]);\n * // ➔ true\n * isArrayLikeObject(document.body.children);\n * // ➔ true\n * isArrayLikeObject('abc');\n * // ➔ false\n * isArrayLikeObject(noop);\n * // ➔ false\n */\nexport function isArrayLikeObject<T extends { __anyHack: unknown }>(\n  value: T\n): boolean;\nexport function isArrayLikeObject(\n  value: AnyFunction | string | boolean | number | null | undefined\n): value is never;\nexport function isArrayLikeObject(\n  value: unknown\n): value is object & { length: number };\nexport function isArrayLikeObject(value: unknown) {\n  return isObjectOrArray(value) && isLength(value.length);\n}\n","import { isNumber } from \"./isNumber\";\nimport { isString } from \"./isString\";\nimport { parseCurrencyString } from \"@/conversions/currency/parsing\";\n\n/** -----------------------------------------------------------\n * * ***Predicate: `isCurrencyLike`.***\n * ------------------------------------------------------------\n * **Determines if the given `input` can be interpreted as a currency-like number,\n * using the same **multi-locale parsing logic** as ***`parseCurrencyString`***.**\n *\n * ---\n * - **Highlights:**\n *     - *Supports strings or numbers like:*\n *       - `\"15.000,10\"` ***(European)***.\n *       - `\"15,000.10\"` ***(US)***.\n *       - `\"15'000.10\"` ***(Swiss)***.\n *       - `\"15 000,10\"` ***(French)***.\n *       - `\"Rp 15.000,10\"` or `\"$15,000.10\"`.\n *     - Also accepts simple numbers (`15300.95`).\n *\n * ---\n * - **Note:**\n *     - Uses the same core logic as\n *       ***`parseCurrencyString`*** but\n *       just checks if a final parsed float is sensible.\n *\n * ---\n * @param {*} input - The input value to check.\n *\n * ---\n * @returns {boolean} Return `true` if it can be reasonably parsed into a currency-like number, `false` otherwise.\n *\n * ---\n * @example\n * isCurrencyLike(15300.95);\n * // ➔ true\n * isCurrencyLike(\"$15,000.10\");\n * // ➔ true\n * isCurrencyLike(\"(15'000.10)\");\n * // ➔ true\n * isCurrencyLike(\"Rp 15.000,10\");\n * // ➔ true\n * isCurrencyLike(\"\");\n * // ➔ false\n * isCurrencyLike(\"abc\");\n * // ➔ false\n */\nexport const isCurrencyLike = (input: unknown): boolean => {\n  if (!(isString(input) || isNumber(input))) return false;\n\n  const parsed = parseCurrencyString(input.toString());\n  // If parseCurrencyString returns a meaningful number (not just fallback zero for empty/invalid input)\n  if (parsed !== 0) return true;\n\n  // Special case: if input was exactly \"0\", still valid\n  return input.toString().trim() === \"0\";\n};\n","import { isMap } from \"./isMap\";\nimport { isSet } from \"./isSet\";\nimport { isDate } from \"./isDate\";\nimport { isArray } from \"./isArray\";\nimport { isRegExp } from \"./isRegExp\";\nimport { isSymbol } from \"./isSymbol\";\nimport { isObjectOrArray } from \"./isObjectOrArray\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isDeepEqual`.***\n * -----------------------------------------------------------\n * **Performs a deep equality check between two values.**\n *\n * ---\n * - **Behavior:**\n *     - Compares nested `arrays`, `objects`, `Dates`, `RegExp`, `NaN`, `Symbols`,\n *       `Set`, and `Map`.\n *     - Handles special cases:\n *         - `NaN` is considered equal to `NaN`.\n *         - `Date` objects are equal if `.getTime()` is equal.\n *         - `RegExp` objects are equal if `.toString()` is equal.\n *         - `Symbol(\"x\")` and `Symbol(\"x\")` are treated equal if\n *           `.toString()` matches.\n *         - `Set` and `Map` are deeply compared by content (order-insensitive).\n *\n * ---\n * - **Note:**\n *     - Does not support circular references.\n *\n * ---\n * @param {*} a - First value to compare.\n * @param {*} b - Second value to compare.\n *\n * ---\n * @returns {boolean} `true` if both values are deeply equal, otherwise `false`.\n *\n * ---\n * @example\n * 1. #### Primitives:\n *    ```ts\n *    isDeepEqual(1, 1);\n *    // ➔ true\n *    isDeepEqual(NaN, NaN);\n *    // ➔ true\n *    isDeepEqual(\"hello\", \"world\");\n *    // ➔ false\n *    ```\n *    ---\n * 2. #### Objects:\n *    ```ts\n *    isDeepEqual({ x: 1 }, { x: 1 });\n *    // ➔ true\n *    isDeepEqual({ x: 1 }, { y: 1 });\n *    // ➔ false\n *    ```\n *    ---\n * 3. #### Arrays:\n *    ```ts\n *    isDeepEqual([1, 2], [1, 2]);\n *    // ➔ true\n *    isDeepEqual([1, 2], [2, 1]);\n *    // ➔ false\n *    ```\n *    ---\n * 4. #### Dates:\n *    ```ts\n *    isDeepEqual(new Date(123), new Date(123));\n *    // ➔ true\n *    ```\n *    ---\n * 5. #### Sets:\n *    ```ts\n *    isDeepEqual(new Set([1, 2]), new Set([2, 1]));\n *    // ➔ true\n *    ```\n *    ---\n * 6. #### Maps:\n *    ```ts\n *    isDeepEqual(new Map([[\"a\", 1]]), new Map([[\"a\", 1]]));\n *    // ➔ true\n *    ```\n *    ---\n * 7. #### Different types:\n *    ```ts\n *    isDeepEqual(1, \"1\");\n *    // ➔ false\n *    ```\n */\nexport const isDeepEqual = (a: unknown, b: unknown): boolean => {\n  // Handle NaN\n  if (\n    typeof a === \"number\" &&\n    typeof b === \"number\" &&\n    Number.isNaN(a) &&\n    Number.isNaN(b)\n  ) {\n    return true;\n  }\n\n  // Primitive equality\n  if (a === b) return true;\n\n  // Type mismatch\n  if (typeof a !== typeof b) return false;\n\n  // Date\n  if (isDate(a) && isDate(b)) {\n    return a.getTime() === b.getTime();\n  }\n\n  // RegExp\n  if (isRegExp(a) && isRegExp(b)) {\n    return a.toString() === b.toString();\n  }\n\n  // Symbol\n  if (isSymbol(a) && isSymbol(b)) {\n    return a.toString() === b.toString();\n  }\n\n  // Set\n  if (isSet(a) && isSet(b)) {\n    if (a.size !== b.size) return false;\n    const bValues = Array.from(b);\n    const matched = new Set<number>();\n\n    for (const aVal of a) {\n      let found = false;\n      for (let i = 0; i < bValues.length; i++) {\n        if (matched.has(i)) continue;\n        if (isDeepEqual(aVal, bValues[i])) {\n          matched.add(i);\n          found = true;\n          break;\n        }\n      }\n      if (!found) return false;\n    }\n    return true;\n  }\n\n  // Map\n  if (isMap(a) && isMap(b)) {\n    if (a.size !== b.size) return false;\n    const bEntries = Array.from(b);\n    const matched = new Set<number>();\n\n    for (const [aKey, aVal] of a) {\n      let found = false;\n      for (let i = 0; i < bEntries.length; i++) {\n        if (matched.has(i)) continue;\n        const [bKey, bVal] = bEntries[i] ?? [];\n        if (isDeepEqual(aKey, bKey) && isDeepEqual(aVal, bVal)) {\n          matched.add(i);\n          found = true;\n          break;\n        }\n      }\n      if (!found) return false;\n    }\n    return true;\n  }\n\n  // Array\n  if (isArray(a) && isArray(b)) {\n    if (a.length !== b.length) return false;\n    return a.every((item, i) => isDeepEqual(item, b[i]));\n  }\n\n  // Object\n  if (isObjectOrArray(a) && isObjectOrArray(b) && a && b) {\n    if (isArray(a) !== isArray(b)) return false;\n\n    const aKeys = Object.keys(a);\n    const bKeys = Object.keys(b);\n    if (aKeys.length !== bKeys.length) return false;\n\n    return aKeys.every((key) => isDeepEqual(a[key], b[key]));\n  }\n\n  return false;\n};\n","import { isPlainObject } from \"./isPlainObject\";\n\n/** ---------------------------------------------------------\n * * ***Type guard: `isElement`.***\n * ----------------------------------------------------------\n * **Checks if `value` is likely a\n *   **[`DOM Element`](https://developer.mozilla.org/en-US/docs/Web/API/Element)**.**\n *\n * ---\n * @template T - The type of the value being checked.\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is extends instance of **[`Element`](https://developer.mozilla.org/en-US/docs/Web/API/Element)**, else `false`.\n *\n * ---\n * @example\n * isElement(document.body);\n * // ➔ true\n * isElement(document.createElement(\"div\"));\n * // ➔ true\n * isElement('<body>');\n * // ➔ false\n * isElement(document);\n * // ➔ false\n * isElement({ tagName: \"DIV\" });\n * // ➔ false\n */\nexport function isElement(value: []): value is [];\nexport function isElement<T extends Element>(value: T): value is T;\nexport function isElement(value: unknown): value is Element;\nexport function isElement(value: unknown) {\n  return (\n    !!value &&\n    typeof value === \"object\" &&\n    (value as Element)?.nodeType === 1 &&\n    !isPlainObject(value)\n  );\n  // return typeof Element === \"function\" && value instanceof Element;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { List, EmptyObjectOf } from \"./_private/types.isEmpty\";\n\nimport { isNil } from \"./isNil\";\nimport { isMap } from \"./isMap\";\nimport { isSet } from \"./isSet\";\nimport { isArray } from \"./isArray\";\nimport { isBuffer } from \"./isBuffer\";\nimport { isNumber } from \"./isNumber\";\nimport { isSymbol } from \"./isSymbol\";\nimport { isString } from \"./isString\";\nimport { isBoolean } from \"./isBoolean\";\nimport { isFunction } from \"./isFunction\";\nimport { isArguments } from \"./isArgument\";\nimport { isTypedArray } from \"./isTypedArray\";\nimport { isPlainObject } from \"./isPlainObject\";\n\n/** ---------------------------------------------------------\n * * ***Predicate: `isEmpty`.***\n * ----------------------------------------------------------\n * **Checks if `value` is an empty object, collection, map, or set.**\n *\n * ---\n * - **Behavior:**\n *     - **Objects** are empty if they have no own enumerable string keyed properties.\n *     - **Array-like values** (arrays, strings, `arguments`, typed arrays, buffers)\n *       are empty if their `length` is `0`.\n *     - **Maps** and **Sets** are empty if their `size` is `0`.\n *     - **Booleans**, **numbers** (including `NaN`), **symbols**, and `null`/\n *       `undefined` are treated as empty.\n *     - **Functions** are considered empty if they have no own enumerable keys.\n *\n * ---\n * - **Note:**\n *     - For more `Strict`, you can use\n *       ***`isEmptyValue` utility function*** instead.\n *\n * ---\n * @template T - The type of the value being checked.\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n *\n * ----\n * @example\n * isEmpty(null);\n * // ➔ true\n * isEmpty(true);\n * // ➔ true\n * isEmpty(false);\n * // ➔ true\n * isEmpty(1);\n * // ➔ true\n * isEmpty(0);\n * // ➔ true\n * isEmpty(Symbol(\"x\"));\n * // ➔ true\n * isEmpty(() => {});\n * // ➔ true\n * isEmpty(\"\");\n * // ➔ true\n * isEmpty(\"   \");\n * // ➔ false\n * isEmpty([1, 2, 3]);\n * // ➔ false\n * isEmpty({ 'a': 1 });\n * // ➔ false\n */\nexport function isEmpty<T extends { __trapAny: any }>(value?: T): boolean;\nexport function isEmpty(value: string): value is \"\";\nexport function isEmpty(\n  value: Map<any, any> | Set<any> | List<any> | null | undefined\n): boolean;\nexport function isEmpty(value: object): boolean;\nexport function isEmpty<T extends object>(\n  value: T | null | undefined\n): value is EmptyObjectOf<T> | null | undefined;\nexport function isEmpty(value: any): boolean;\nexport function isEmpty(value: unknown) {\n  // null / undefined\n  if (isNil(value)) return true;\n\n  // Boolean, number, symbol\n  if (\n    isBoolean(value) ||\n    isNumber(value, { includeNaN: true }) ||\n    isSymbol(value)\n  )\n    return true;\n\n  // Function ➔ treat like object: check own enumerable keys\n  if (isFunction(value)) {\n    return Object.keys(value).length === 0;\n  }\n\n  // String / Array-like\n  if (\n    isString(value) ||\n    isArray(value) ||\n    isArguments(value) ||\n    isTypedArray(value)\n  ) {\n    return value.length === 0;\n  }\n\n  // Map / Set\n  if (isMap(value) || isSet(value)) {\n    return value.size === 0;\n  }\n\n  // Buffer\n  if (isBuffer(value)) {\n    return value.length === 0;\n  }\n\n  // Object (check own enumerable keys)\n  if (isPlainObject(value)) {\n    return Object.keys(value).length === 0;\n  }\n\n  return false;\n}\n","import { isNaN } from \"./isNaN\";\nimport { isArray } from \"./isArray\";\nimport { isString } from \"./isString\";\nimport { isNumber } from \"./isNumber\";\nimport { isEmptyArray } from \"./isEmptyArray\";\nimport { isEmptyString } from \"./isEmptyString\";\nimport { isObjectOrArray } from \"./isObjectOrArray\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyDeep`.***\n * -----------------------------------------------------------\n * **Recursively checks whether a value is **deeply empty**.**\n *\n * ---\n * - #### *Behavior:*\n *      - #### Returns `true` for:\n *           - Empty objects: `{}`.\n *           - Empty arrays: `[]`.\n *           - Nested empty structures: `{ a: [], b: {} }`.\n *           - Falsy values (except numbers): `null`, `undefined`, `false`, `\"\"`, `NaN`.\n *           ---\n *      - #### Returns `false` for:\n *           - Non-zero numbers.\n *           - Objects or arrays containing non-empty values.\n *           - Non-empty strings, `true`, functions, symbols, etc.\n *\n * ---\n * @param {*} value - The value to deeply check.\n *\n * ---\n * @returns {boolean} `true` if the value is deeply empty, otherwise `false`.\n *\n * ---\n * @example\n * isEmptyDeep({});\n * // ➔ true\n * isEmptyDeep([]);\n * // ➔ true\n * isEmptyDeep({ a: {} });\n * // ➔ true\n * isEmptyDeep([[], {}]);\n * // ➔ true\n * isEmptyDeep({ a: [1] });\n * // ➔ false\n * isEmptyDeep([0]);\n * // ➔ false\n * isEmptyDeep(\"test\");\n * // ➔ false\n * isEmptyDeep(\"\");\n * // ➔ true\n * isEmptyDeep(0);\n * // ➔ false\n * isEmptyDeep(NaN);\n * // ➔ true\n */\nexport const isEmptyDeep = (value: unknown): boolean => {\n  if (isString(value)) return isEmptyString(value);\n  // Number ➔ only NaN counts as empty\n  if (isNumber(value)) return isNaN(value);\n  if (isArray(value)) {\n    return isEmptyArray(value) || value.every(isEmptyDeep);\n  }\n  if (isObjectOrArray(value)) {\n    const keys = Object.keys(value);\n    const symbols = Object.getOwnPropertySymbols(value);\n\n    if (keys.length === 0 && symbols.length === 0) return true;\n\n    return [...keys, ...symbols].every((key) => isEmptyDeep(value[key]));\n  }\n  if (!value) return true;\n\n  return false;\n};\n","import type { CustomizerIsEqualWith } from \"./_private/types.isEqualWith\";\nimport { baseDeepEqual } from \"@/predicates/is/_private/baseDeepEqual\";\n\n/** ----------------------------------------------------\n * * ***Predicate: `isEqualWith`.***\n * -----------------------------------------------------\n * **Performs a deep comparison between two values with support for a\n * customizer function.**\n *\n * ---\n * @description\n * This method is like ***`isEqual` utility function*** except that it\n * accepts a `customizer` which is invoked to compare values.\n *\n * ---\n * - **Behavior:**\n *     - If `customizer` returns `undefined`, the comparison is handled by\n *       the default deep equality algorithm.\n *     - The `customizer` is invoked with up to six arguments:\n *       - `(value, other, indexOrKey, parent, otherParent, stack)`,\n *         see **{@link CustomizerIsEqualWith | `CustomizerIsEqualWith`}**.\n *     - Supports comparing `arrays`, `objects`, `maps`, `sets`, `dates`,\n *       `regexes`, `typed arrays`, `etc`.\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 * @param {CustomizerIsEqualWith} [customizer] The function to customize comparisons.\n *\n * ---\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n *\n * ---\n * @example\n * function isGreeting(value: unknown) {\n *   return typeof value === \"string\" && /^h(?:i|ello)$/.test(value);\n * }\n *\n * function customizer(objValue: unknown, othValue: unknown) {\n *   if (isGreeting(objValue) && isGreeting(othValue)) {\n *     return true;\n *   }\n * }\n *\n * const array = [\"hello\", \"goodbye\"];\n * const other = [\"hi\", \"goodbye\"];\n *\n * isEqualWith(array, other, customizer);\n * // ➔ true\n */\nexport const isEqualWith = (\n  value: unknown,\n  other: unknown,\n  customizer?: CustomizerIsEqualWith\n): boolean => {\n  return baseDeepEqual(value, other, customizer, new WeakMap());\n};\n","import type { CustomizerIsMatchWith } from \"./_private/types.isMatchWith\";\nimport { baseIsMatch } from \"@/predicates/is/_private/baseIsMatch\";\n\n/** ----------------------------------------------------\n * * ***Predicate: `isMatchWith`.***\n * -----------------------------------------------------\n * **Performs a partial deep comparison between `object` and `source`, like `isMatch`, but with a `customizer` function to control comparisons.**\n *\n * ---\n * @description\n * If `customizer` returns a value other than `undefined`, that value is used\n * as the result of the comparison for the current property. Otherwise,\n * the comparison falls back to the default deep equality logic.\n *\n * ---\n * - **Behavior:**\n *     - The `customizer` function is invoked with up to **five** arguments:\n *         - `(objValue, srcValue, keyOrIndex, object, source)`,\n *         see **{@link CustomizerIsMatchWith | `CustomizerIsMatchWith`}**.\n *     - Returning `true` from `customizer` will short-circuit further comparison\n *       for that key.\n *     - Returning `false` will cause `isMatchWith` to return `false` immediately.\n *     - Returning `undefined` allows default comparison to proceed.\n *\n * ---\n * @param {object} value - The object to inspect.\n * @param {object} other - The object of property values to match.\n * @param {CustomizerIsMatchWith} [customizer] - The function to customize comparisons.\n *\n * ---\n * @returns Returns `true` if `object` is a match, else `false`.\n *\n * ---\n * @example\n * function isGreeting(value: unknown) {\n *   return typeof value === 'string' && /^h(?:i|ello)$/.test(value);\n * }\n *\n * function customizer(objValue: unknown, srcValue: unknown) {\n *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n *     return true;\n *   }\n * }\n *\n * const object = { greeting: 'hello' };\n * const source = { greeting: 'hi' };\n *\n * isMatchWith(object, source, customizer);\n * // ➔ true\n */\nexport const isMatchWith = (\n  value: object,\n  other: object,\n  customizer?: CustomizerIsMatchWith\n): boolean => {\n  return baseIsMatch(value, other, customizer);\n};\n","import type { CustomizerIsMatchWith } from \"./types.isMatchWith\";\n\nimport { isArray } from \"../isArray\";\nimport { isUndefined } from \"../isUndefined\";\nimport { isMatchWith } from \"../isMatchWith\";\nimport { isObjectOrArray } from \"../isObjectOrArray\";\n\n// #Private - local\nfunction isSameValue(x: unknown, y: unknown): boolean {\n  return (\n    x === y || (x === 0 && y === 0) || (Number.isNaN(x) && Number.isNaN(y))\n  );\n}\n\n/** -------------------------------------------------------------------\n * * ***Base function (**Internal**) for matching objects with optional customizer.***\n * -------------------------------------------------------------------\n * **Recursively checks whether `object` matches `source`. Supports custom comparison\n * via `customizer`, and handles arrays, objects, and nested structures.**\n *\n * ---\n * @param object\n * - The object to test against the `source`.\n * @param source\n * - The source object to match.\n * @param customizer\n * - Optional function to customize the comparison for each property/value.\n *\n * ---\n * @returns\n * - `true`  ➔ `object` matches `source`.\n * - `false` ➔ `object` does not match `source`.\n *\n * ---\n * @example\n * ```ts\n * const obj = { name: \"Alice\", age: 30 };\n * const src = { name: \"alice\" };\n * const customizer: CustomizerIsMatchWith = (value, other) => {\n *   if (typeof value === \"string\" && typeof other === \"string\") {\n *     return value.toLowerCase() === other.toLowerCase();\n *   }\n * };\n *\n * baseIsMatch(obj, src, customizer);\n * // ➔ true\n * ```\n */\nexport function baseIsMatch(\n  object: unknown,\n  source: unknown,\n  customizer?: CustomizerIsMatchWith\n): boolean {\n  if (object === source) return true;\n\n  if (!isObjectOrArray(source)) {\n    return isSameValue(object, source);\n  }\n\n  if (!isObjectOrArray(object)) {\n    return false;\n  }\n\n  const keys = Reflect.ownKeys(source).filter(\n    (k) => !(isArray(source) && k === \"length\")\n  );\n\n  for (const key of keys) {\n    if (!(key in object)) return false;\n\n    const objValue = object[key];\n    const srcValue = source[key];\n\n    const result = customizer?.(objValue, srcValue, key, object, source);\n    if (!isUndefined(result)) {\n      if (!result) return false;\n      continue; // skip default comparison\n    }\n\n    if (isObjectOrArray(objValue) && isObjectOrArray(srcValue)) {\n      if (!isMatchWith(objValue, srcValue, customizer)) return false;\n    } else {\n      if (!isSameValue(objValue, srcValue)) return false;\n    }\n  }\n\n  return true;\n}\n","import { baseIsMatch } from \"@/predicates/is/_private/baseIsMatch\";\n\n/** ----------------------------------------------------\n * * ***Predicate: `isMatch`.***\n * -----------------------------------------------------\n * **Performs a partial deep comparison between `object` and `source`.**\n *\n * ---\n * @description\n * Determines whether `object` contains equivalent property values from `source`.\n *\n * ---\n * - **Behavior:**\n *     - ✅ Returns `true` if **all properties** in `source` exist in `object` and are deeply equal.\n *     - ❌ Does **not** require `object` and `source` to be the same shape—`object` may have extra properties.\n *     - ⚠️ Arrays are treated as objects: only matching indexed keys are compared.\n *\n * ---\n * - **Remarks:**\n *     - This is functionally equivalent to a partially applied `matches(source)` predicate.\n *     - Special cases:\n *       - An empty array (`[]`) in `source` matches any array in `object`.\n *       - An empty object (`{}`) in `source` matches any object in `object`.\n *\n * ---\n * @param {object} object - The object to inspect.\n * @param {object} source - The object containing property values to match.\n *\n * ---\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n *\n * ---\n * @example\n * const object = { a: 1, b: 2 };\n *\n * isMatch(object, { b: 2 });\n * // ➔ true\n * isMatch(object, { b: 1 });\n * // ➔ false\n * isMatch([1, 2, 3], [1, 2]);\n * // ➔ true (treats arrays as objects with index keys)\n */\nexport const isMatch = (object: object, source: object): boolean => {\n  return baseIsMatch(object, source);\n};\n","import type { AnyFunction } from \"@rzl-zone/ts-types-plus\";\nimport { isFunction } from \"./isFunction\";\n\nconst funcToString = Function.prototype.toString;\nconst reIsNative = /\\{\\s*\\[native code\\]\\s*\\}/;\n\n/** ---------------------------------------------------------\n * * ***Type guard: `isNative`.***\n * ----------------------------------------------------------\n * **Checks if a value is a **pristine native function**.**\n *\n * ---\n * - **Note:**\n *     - This method may not reliably detect native functions when using packages\n *       like `core-js`, as they override native behavior.\n *     - Attempts to detect native functions in such environments may fail or\n *       throw errors.\n *     - This also affects packages like\n *       **[`babel-polyfill`](https://www.npmjs.com/package/babel-polyfill).**\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is a native function, else `false`.\n *\n * ---\n * @example\n * isNative(Array.prototype.push);\n * // ➔ true\n *\n * import * as RzlUtilsJs from \"@rzl-zone/utils-js/predicates\";\n * isNative(RzlUtilsJs);\n * // ➔ false\n */\nexport const isNative = (value: unknown): value is AnyFunction => {\n  if (!isFunction(value)) return false;\n\n  try {\n    const source = funcToString.call(value);\n    return reIsNative.test(source);\n  } catch {\n    return false;\n  }\n};\n","import { isNil } from \"./isNil\";\nimport { isFunction } from \"./isFunction\";\nimport { isObjectOrArray } from \"./isObjectOrArray\";\n\n/** ----------------------------------------------------------\n * * ***Type guard: `isObjectLoose`.***\n * -----------------------------------------------------------\n * **Checks if a value is the\n * [ECMAScript language type ***`Object`***](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types).**\n *\n * ---\n * - #### *Behavior:*\n *      - #### Returns `true` for:\n *           - Plain objects (`{}`).\n *           - Arrays (`[]`).\n *           - Functions.\n *           - Regexes (`/abc/`).\n *           - Boxed primitives:\n *             - `new Number(0)`.\n *             - `new String(\"\")`.\n *             - `new Boolean(false)`.\n *           ---\n *      - #### Returns `false` for:\n *           - `null`.\n *           - `undefined`.\n *           - Primitives:\n *             - `string`.\n *             - `number`.\n *             - `boolean`.\n *             - `symbol`.\n *             - `bigint`.\n * ---\n * - **Note:**\n *     - **For More Strict Object Use ***`isObject`*** or ***`isPlainObject` utility function*** instead.**\n *\n * ---\n * @template T - The type of the value being checked.\n *\n * ---\n * @param {*} value The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n *\n * ---\n * @example\n * isObjectLoose({});\n * // ➔ true\n * isObjectLoose([1, 2, 3]);\n * // ➔ true\n * isObjectLoose(()=> {});\n * // ➔ true\n * isObjectLoose(null);\n * // ➔ false\n * isObjectLoose(undefined);\n * // ➔ false\n */\nexport const isObjectLoose = <T = object>(value: unknown): value is T => {\n  return !isNil(value) && (isObjectOrArray(value) || isFunction(value));\n};\n","/** --------------------------------------------------\n * * ***Type guard: `isSafeInteger`.***\n * ---------------------------------------------------\n * **Checks if `value` is a **[`Safe-Integer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger)**.**\n *\n * ---\n * - #### Behavior:\n *     - Narrows type to `number` when true.\n *     ---\n * - #### An integer is considered *safe* if:\n *     - It is an [`IEEE-754` **double precision number**](https://en.wikipedia.org/wiki/Double-precision_floating-point_format).\n *     - It can be exactly represented without rounding errors.\n *     - It lies within the range **-(2^53 - 1) to 2^53 - 1**.\n *     ---\n * - #### Note:\n *     - This method is based on **{@link Number.isSafeInteger | `Number.isSafeInteger`}**.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Return `true` if `value` is a safe integer, otherwise `false`.\n *\n * ---\n * @example\n * isSafeInteger(3);\n * // ➔ true\n * isSafeInteger(Number.MIN_VALUE);\n * // ➔ false\n * isSafeInteger(Infinity);\n * // ➔ false\n * isSafeInteger('3');\n * // ➔ false\n */\nexport const isSafeInteger = (value: unknown): value is number => {\n  return typeof value === \"number\" && Number.isSafeInteger(value);\n};\n","import { isNonEmptyString } from \"./isNonEmptyString\";\n\n/** ---------------------------------------------------------\n * * ***Predicate: `isValidURL`.***\n * ----------------------------------------------------------\n * **Validates whether a given string is a properly formatted URL.**\n *\n * ---\n * - #### *Behavior:*\n *      - **Ensures that the input is:**\n *          - A non-empty string.\n *          - A valid **[`URL`](https://developer.mozilla.org/docs/Web/API/URL)** with `http://` or `https://` scheme.\n *      - Includes decoding for percent-encoded URLs (e.g., `https%3A%2F%2F...`).\n *      - Rejects invalid strings, unsupported schemes, and malformed domains.\n *\n * ---\n * @param {*} url - The value to validate.\n *\n * ---\n * @returns {boolean} Return `true` if the value is a **valid URL string**, otherwise `false`.\n *\n * ---\n * @example\n * isValidURL(\"https://example.com\");\n * // ➔ true\n * isValidURL(\"ftp://example.com\");\n * // ➔ false\n * isValidURL(\"not-a-url\");\n * // ➔ false\n */\nexport const isValidURL = (url: unknown): boolean => {\n  if (!isNonEmptyString(url)) return false;\n\n  // Attempt to decode the entire URL, including domain and query parameters\n  let decodedUrl: string;\n\n  try {\n    // Decode the URL (to handle cases like https%3A%2F%2F becoming https://)\n    decodedUrl = decodeURIComponent(url);\n  } catch {\n    // If decoding fails, return false as it indicates an invalid encoded URL\n    return false;\n  }\n\n  // Check if the decoded URL starts with http:// or https://\n  if (!decodedUrl.startsWith(\"http://\") && !decodedUrl.startsWith(\"https://\")) {\n    return false;\n  }\n\n  // the original more extra\n  const urlPattern = new RegExp(\n    /^https?:\\/\\/(?:localhost(?::\\d+)?(?:[/?#][^\\s]*)?|(?:www\\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}(?::\\d+)?(?:[/?#][^\\s]*)?)$/\n  );\n\n  // Test the decoded URL against the regex pattern\n  return urlPattern.test(decodedUrl);\n};\n","import { isNull } from \"./isNull\";\nimport { isObject } from \"./isObject\";\n\n/** ---------------------------------------------------------\n * * ***Type guard: `isWeakMap`.***\n * ----------------------------------------------------------\n * **Checks if a value is a **[`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/WeakMap)** object.**\n *\n * ---\n * - **Behavior:**\n *     - Narrows type to `WeakMap<K, V>` when true.\n *     - Excludes `Map`, `arrays`, `plain-objects,` and `other non-WeakMap values`.\n *\n * ---\n * @template K - Keys must be objects.\n * @template V - Type of values stored in the WeakMap.\n *\n * ---\n * @param {*} value - The value to check.\n *\n * ---\n * @returns {boolean} Returns `true` if the value is a `WeakMap`, otherwise `false`.\n *\n * ---\n * @example\n * isWeakMap(new WeakMap);\n * // ➔ true\n * isWeakMap(new Map);\n * // ➔ false\n */\nexport const isWeakMap = <K extends object = object, V = unknown>(\n  value: unknown\n): value is WeakMap<K, V> => {\n  return isObject(value) && !isNull(value) && value instanceof WeakMap;\n};\n"],"mappings":"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"}