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

package/dist/predicates-ZmZpelMh.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"predicates-ZmZpelMh.cjs","names":["isArray","getPreciseType","isEqual","safeStableStringify","isEqual","isURL","isURL","isNonEmptyString","isArray","isNonEmptyString","isArray","isObjectOrArray","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 { isArray } from \"../is/isArray\";\nimport { isEqual } from \"../is/isEqual\";\nimport { getPreciseType } from \"../type/getPreciseType\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `areArraysEqual`.***\n * ----------------------------------------------------------\n * **Compares two arrays deeply to check if they are equal.**\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 * @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 * @returns {boolean}\n *    Returns `true` if both arrays are deeply equal, otherwise `false`.\n * @throws **{@link TypeError | `TypeError`}** if `array1` or `array2` are not arrays, or if `ignoreOrder` is not a boolean.\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      `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  assertIsBoolean(ignoreOrder, {\n    message: ({ currentType, validType }) =>\n      `Third parameter \\`ignoreOrder\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\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","import { isEqual } from \"../is/isEqual\";\n\n/** ---------------------------------\n * * ***Predicate: `areObjectsEqual`.***\n * ---------------------------------\n * **Compares two objects for deep equality.**\n * @template T1 The type of the first object.\n * @template T2 The type of the second object.\n * @param {*} object1 - The first object to compare.\n * @param {*} object2 - The second object to compare.\n * @returns {boolean} Return `true` if both objects are deeply equal, otherwise `false`.\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 { 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 * @param {URL} urlA - The first URL to compare.\n * @param {URL} urlB - The second URL to compare.\n * @returns {boolean} Returns `true` if both URLs are the same (ignoring search parameters), otherwise `false`.\n * @example\n * // Same domain, same path, different query -> true\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 * // Same domain, different path -> false\n * areURLsEqualPath(\n *   new URL(\"https://example.com/page1\"),\n *   new URL(\"https://example.com/page2\")\n * );\n * // ➔ false\n *\n * // Different protocol -> false\n * areURLsEqualPath(\n *   new URL(\"http://example.com/page\"),\n *   new URL(\"https://example.com/page\")\n * );\n * // ➔ false\n *\n * // Same protocol, same host, same path (ignores query & hash) -> true\n * areURLsEqualPath(\n *   new URL(\"https://example.com/page#section\"),\n *   new URL(\"https://example.com/page\")\n * );\n * // ➔ true\n */\nexport const areURLsEqualPath = (urlA: URL, urlB: URL): boolean => {\n  if (!isURL(urlA) || !isURL(urlB)) {\n    throw new TypeError(\n      \"Parameters `urlA` and `urlB` (first and second parameter) must be instance of URL.\"\n    );\n  }\n\n  return (\n    urlA.protocol + \"//\" + urlA.host + urlA.pathname ===\n    urlB.protocol + \"//\" + urlB.host + urlB.pathname\n  );\n};\n","import { 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 * @param {URL} urlA - The first URL to compare.\n * @param {URL} urlB - The second URL to compare.\n * @returns {boolean} Returns `true` if both URLs are identical, otherwise `false`.\n * @example\n * // Identical URLs -> true\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 * // Same path, different query parameter -> false\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 * // Same host & query, but different protocol -> false\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 * // Same everything except trailing slash -> false\n * areURLsIdentical(\n *   new URL(\"https://example.com/page\"),\n *   new URL(\"https://example.com/page/\")\n * );\n * // ➔ false\n */\nexport const areURLsIdentical = (urlA: URL, urlB: URL): boolean => {\n  if (!isURL(urlA) || !isURL(urlB)) {\n    throw new TypeError(\n      \"Parameters `urlA` and `urlB` (first and second parameter) must be instance of URL.\"\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","import { isArray } from \"../is/isArray\";\nimport { isNonEmptyString } from \"../is/isNonEmptyString\";\n\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype OptionsTextContainsAll = {\n  /** If `true`, matches whole words only, defaultValue is `false`.\n   *\n   * @default false\n   */\n  exactMatch?: boolean;\n  /** Optional regex flags (default: `\"i\"` for case-insensitive).\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 * - **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 * @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 * @returns {boolean} Return `true` if all `searchWords` are found in `text`, otherwise `false`.\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)) {\n    return false;\n  }\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Third parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  // fallback to default\n  const { exactMatch = false, flags = \"i\" } = options;\n\n  assertIsBoolean(exactMatch, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`exactMatch\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  assertIsString(flags, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`flags\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\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","import { isArray } from \"../is/isArray\";\nimport { isNonEmptyString } from \"../is/isNonEmptyString\";\n\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype OptionsTextContainsAny = {\n  /** If `true`, matches whole words only, defaultValue is `false`.\n   *\n   * @default false\n   */\n  exactMatch?: boolean;\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 * - **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 * @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 * @returns {boolean} Return `true` if at least one `searchWord` is found in `text`, otherwise `false`.\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)) {\n    return false;\n  }\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Third parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  // fallback to default\n  const { exactMatch = false, flags = \"i\" } = options;\n\n  assertIsBoolean(exactMatch, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`exactMatch\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  assertIsString(flags, {\n    message: ({ currentType, validType }) =>\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  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 * * ***Type guard: `PropertyKey`.***\n * ----------------------------------------------------------\n * **Checks if a value is a valid `PropertyKey`.**\n * - **In JavaScript/TypeScript, a **`PropertyKey`** is any of:**\n *    - **`string`**\n *    - **`number`**\n *    - **`symbol`**\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 * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if `value` is a valid property key, otherwise `false`.\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 function isPropertyKey(value: unknown): value is PropertyKey {\n  const type = typeof value;\n  return type === \"string\" || type === \"number\" || type === \"symbol\";\n}\n","import { 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 * - **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 * - **ℹ️ 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 * @template T - The type of the input object or array.\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 * @returns {boolean} Returns `true` if the key exists anywhere in the object or array (even with `null` / `undefined` value), otherwise `false`.\n * @example\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 * // Key exists even if value is null or undefined:\n * doesKeyExist({ a: null, b: undefined, c: { d: null } }, \"a\"); // ➔ true\n * doesKeyExist({ a: null, b: undefined, c: { d: null } }, \"b\"); // ➔ true\n * doesKeyExist({ a: null, b: undefined, c: { d: null } }, \"d\"); // ➔ true\n *\n * doesKeyExist({ a: 1 }, true);\n * // ➔ ❌ Throws TypeError\n * doesKeyExist({ a: 1 }, [\"not\", \"valid\"]);\n * // ➔ ❌ Throws TypeError\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      `Second Parameter (\\`key\\`) must be of type \\`string\\`, \\`number\\` or \\`symbol\\`, but received: \\`${getPreciseType(\n        key\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 * - **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 * @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 * @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 * @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 * @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 * - **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 * - **ℹ️ 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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\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 function 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 * @template T - The type of the value being checked.\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\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\";\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 * @template T - The type of the value being checked.\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `array-like object`, else `false`.\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 * - **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 * - **ℹ️ Note:**\n *    - Uses the same core logic as\n *      ***`parseCurrencyString`*** but\n *      just checks if a final parsed float is sensible.\n * @param {*} input - The input value to check.\n * @returns {boolean} Return `true` if it can be reasonably parsed into a currency-like number, `false` otherwise.\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 * - **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 * - **ℹ️ Note:**\n *    - Does not support circular references.\n * @param {*} a - First value to compare.\n * @param {*} b - Second value to compare.\n * @returns {boolean} `true` if both values are deeply equal, otherwise `false`.\n * @example\n * // ✅ Primitives\n * isDeepEqual(1, 1);\n * // ➔ true\n * isDeepEqual(NaN, NaN);\n * // ➔ true\n * isDeepEqual(\"hello\", \"world\");\n * // ➔ false\n *\n * // ✅ Objects\n * isDeepEqual({ x: 1 }, { x: 1 });\n * // ➔ true\n * isDeepEqual({ x: 1 }, { y: 1 });\n * // ➔ false\n *\n * // ✅ Arrays\n * isDeepEqual([1, 2], [1, 2]);\n * // ➔ true\n * isDeepEqual([1, 2], [2, 1]);\n * // ➔ false\n *\n * // ✅ Dates\n * isDeepEqual(new Date(123), new Date(123));\n * // ➔ true\n *\n * // ✅ Sets\n * isDeepEqual(new Set([1, 2]), new Set([2, 1]));\n * // ➔ true\n *\n * // ✅ Maps\n * isDeepEqual(new Map([[\"a\", 1]]), new Map([[\"a\", 1]]));\n * // ➔ true\n *\n * // ❌ Different types\n * isDeepEqual(1, \"1\");\n * // ➔ false\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 * @template T - The type of the value being checked.\n * @param {*} value The value to check.\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 * @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 * - **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 * - **ℹ️ Note:**\n *    - For more `Strict`, you can use\n *      ***`isEmptyValue` utility function*** instead.\n * @template T - The type of the value being checked.\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is empty, else `false`.\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 * - **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 * - **Returns `false` for:**\n *    - Non-zero numbers\n *    - Objects or arrays containing non-empty values\n *    - Non-empty strings, `true`, functions, symbols, etc.\n * @param {*} value - The value to deeply check.\n * @returns {boolean} `true` if the value is deeply empty, otherwise `false`.\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 * @description\n * This method is like ***`isEqual` utility function*** except that it\n * accepts a `customizer` which is invoked to compare values.\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 * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {CustomizerIsEqualWith} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\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 function 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 * @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 * - **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 * @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 * @returns Returns `true` if `object` is a match, else `false`.\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 function 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 * @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 * @returns\n * - `true`  → `object` matches `source`.\n * - `false` → `object` does not match `source`.\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 * // returns 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 * @description\n * Determines whether `object` contains equivalent property values from `source`.\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 * - **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 * @param {object} object - The object to inspect.\n * @param {object} source - The object containing property values to match.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\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 function 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 * - **ℹ️ 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 * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function, else `false`.\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 function 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 * - **✅ 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 * - **❌ Returns `false` for:**\n *    - `null`\n *    - `undefined`\n *    - Primitives:\n *      - `string`\n *      - `number`\n *      - `boolean`\n *      - `symbol`\n *      - `bigint`\n * - **ℹ️ Note:**\n *    - **For More Strict Object Use ***`isObject`*** or ***`isPlainObject` utility function*** instead.**\n * @template T - The type of the value being checked.\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\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 function 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 * - **Behavior:**\n *    - Narrows type to `number` when true.\n * - **An integer is considered *safe* if:**\n *    - It is an `IEEE-754` **double precision number**.\n *    - It can be exactly represented without rounding errors.\n *    - It lies within the range **-(2^53 - 1) to 2^53 - 1**.\n * - **Note:**\n *    - This method is based on **{@link Number.isSafeInteger | `Number.isSafeInteger`}**.\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if `value` is a safe integer, otherwise `false`.\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 function 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 * - **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 * - **Behavior:**\n *    - ✅ Includes decoding for percent-encoded URLs (e.g., `https%3A%2F%2F...`).\n *    - ❌ Rejects invalid strings, unsupported schemes, and malformed domains.\n * @param {*} url - The value to validate.\n * @returns {boolean} Return `true` if the value is a **valid URL string**, otherwise `false`.\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 * - **Behavior:**\n *    - Narrows type to `WeakMap<K, V>` when true.\n *    - Excludes `Map`, `arrays`, `plain-objects,` and `other non-WeakMap values`.\n * @template K - Keys must be objects.\n * @template V - Type of values stored in the WeakMap.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a `WeakMap`, otherwise `false`.\n * @example\n * isWeakMap(new WeakMap);\n * // ➔ true\n * isWeakMap(new Map);\n * // ➔ false\n */\nexport function 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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"}

package/dist/punyCode-COTqgXMJ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"punyCode-COTqgXMJ.js","names":[],"sources":["../src/urls/utils/punyCode.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Constants for `Punycode-UtilsJS` algorithm.***\n * ---------------------------------------------------------\n * These constants are used internally for encoding and decoding.\n *\n * Unicode domain names to ASCII (`Punycode-UtilsJS`) and vice versa.\n */\n\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\n\n/**\n * Constant `maxInt` for validate.\n */\nconst maxInt = 2147483647;\n\n/**\n * Bootstring parameters for `Punycode-UtilsJS`.\n */\nconst base = 36,\n  tMin = 1,\n  tMax = 26,\n  skew = 38,\n  damp = 700;\n\n/**\n * Initial bias and code point.\n */\nconst initialBias = 72,\n  initialN = 128,\n  delimiter = \"-\";\n\n/**\n * Regular expressions used internally.\n * Matches `Punycode-UtilsJS` prefix.\n */\nconst regexPunycode = /^xn--/;\n/**\n * Regular expressions used internally.\n * Matches non-ASCII chars.\n */\nconst regexNonASCII = /[^\\0-\\x7F]/;\n/**\n * Regular expressions used internally.\n * Matches domain label separators.\n */\nconst regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g;\n\n/**\n * Error messages used internally.\n */\nconst errors: Record<string, string> = {\n  overflow: \"Overflow: input needs wider integers to process\",\n  \"not-basic\": \"Illegal input >= 0x80 (not a basic code point)\",\n  \"invalid-input\": \"Invalid input\"\n};\n\n/**\n * Aliases of `Math.floor`.\n */\nconst floor = Math.floor;\n/** \n * Aliases of `String.fromCharCode`.\n\n*/\nconst stringFromCharCode = String.fromCharCode;\n\n/** ---------------------------------------------------------\n * * ***Throws a RangeError with a predefined error message.***\n * ---------------------------------------------------------\n *\n * @param type - Key of the error type to throw.\n */\nfunction error(type: keyof typeof errors): never {\n  throw new RangeError(errors[type]);\n}\n\n/** ---------------------------------------------------------\n * * ***Maps an array using a callback function.***\n * ---------------------------------------------------------\n *\n * @param array - Array to transform.\n * @param fn - Function to apply to each element.\n * @returns Transformed array.\n */\nfunction map<T, U>(array: T[], fn: (v: T) => U): U[] {\n  const result: U[] = [];\n  let length = array.length;\n  while (length--) {\n    if (array[length]) {\n      result[length] = fn(array[length]!);\n    }\n  }\n  return result;\n}\n\n/** ---------------------------------------------------------\n * * ***Maps a domain name using a callback on each label.***\n * ---------------------------------------------------------\n *\n * Handles email-like domains (local@domain).\n * @param domain - Domain string to process.\n * @param fn - Function applied to each domain label.\n * @returns Transformed domain string.\n */\nfunction mapDomain(domain: string, fn: (v: string) => string): string {\n  const parts = domain.split(\"@\");\n  let result = \"\";\n  if (parts.length > 1) {\n    result = parts[0] + \"@\";\n    if (parts[1]) domain = parts[1];\n  }\n  domain = domain.replace(regexSeparators, \"\\x2E\");\n  const labels = domain.split(\".\");\n  return result + map(labels, fn).join(\".\");\n}\n\n/** ---------------------------------------------------------\n * * ***Converts a UCS-2 encoded string to an array of Unicode code points.***\n * ---------------------------------------------------------\n *\n * @param input - String to decode.\n * @returns Array of Unicode code points.\n */\nfunction ucs2decode(input: string): number[] {\n  assertIsString(input, {\n    message: ({ currentType, validType }) =>\n      `Utils \\`punycodeUtilsJS.ucs2.decode\\`, parameter \\`input\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const output: number[] = [];\n  let counter = 0;\n  const length = input.length;\n  while (counter < length) {\n    const value = input.charCodeAt(counter++);\n    if (value >= 0xd800 && value <= 0xdbff && counter < length) {\n      const extra = input.charCodeAt(counter++);\n      if ((extra & 0xfc00) === 0xdc00)\n        output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);\n      else {\n        output.push(value);\n        counter--;\n      }\n    } else output.push(value);\n  }\n  return output;\n}\n\n/** ---------------------------------------------------------\n * * ***Encodes an array of Unicode code points to a string.***\n * ---------------------------------------------------------\n *\n * @param points - Array of Unicode code points.\n * @returns Encoded string.\n */\nconst ucs2encode = (points: number[]): string => {\n  if (\n    !Array.isArray(points) ||\n    !points.every((p) => typeof p === \"number\" && Number.isFinite(p))\n  ) {\n    throw new TypeError(\n      `Utils \\`punycodeUtilsJS.ucs2.encode\\`, parameter \\`points\\` must be an array of numbers, but received: \\`${getPreciseType(\n        points\n      )}\\`.`\n    );\n  }\n\n  return String.fromCodePoint(...points);\n};\n\n/** ---------------------------------------------------------\n * * ***Converts a basic code point to its digit value for `Punycode-UtilsJS`.***\n * ---------------------------------------------------------\n *\n * @param codePoint - Unicode code point.\n * @returns Digit value.\n */\nfunction basicToDigit(codePoint: number): number {\n  if (codePoint >= 0x30 && codePoint < 0x3a) return 26 + (codePoint - 0x30);\n  if (codePoint >= 0x41 && codePoint < 0x5b) return codePoint - 0x41;\n  if (codePoint >= 0x61 && codePoint < 0x7b) return codePoint - 0x61;\n  return base;\n}\n\n/** ---------------------------------------------------------\n * * ***Converts a digit to a basic code point for `Punycode-UtilsJS`.***\n * ---------------------------------------------------------\n *\n * @param digit - Numeric value.\n * @param flag - Bias flag (0 or 1).\n * @returns Code point.\n */\nfunction digitToBasic(digit: number, flag: number): number {\n  return digit + 22 + 75 * (digit < 26 ? 1 : 0) - Number(flag !== 0) * 32;\n}\n\n/** ---------------------------------------------------------\n * * ***Bias adaptation function for `Punycode-UtilsJS` encoding/decoding.***\n * ---------------------------------------------------------\n *\n * @param delta - Delta value.\n * @param numPoints - Number of code points.\n * @param firstTime - Indicates first adaptation.\n * @returns Adapted bias.\n */\nfunction adapt(delta: number, numPoints: number, firstTime: boolean): number {\n  let k = 0;\n  delta = firstTime ? floor(delta / damp) : delta >> 1;\n  delta += floor(delta / numPoints);\n  while (delta > ((base - tMin) * tMax) >> 1) {\n    delta = floor(delta / (base - tMin));\n    k += base;\n  }\n  return floor(k + ((base - tMin + 1) * delta) / (delta + skew));\n}\n\n/** ---------------------------------------------------------\n * * ***Decodes a `Punycode-UtilsJS` string to Unicode.***\n * ---------------------------------------------------------\n *\n * @param input - `Punycode-UtilsJS` string.\n * @returns Decoded Unicode string.\n */\nfunction decode(input: string): string {\n  assertIsString(input, {\n    message: ({ currentType, validType }) =>\n      `Utils \\`punycodeUtilsJS.decode\\`, parameter \\`input\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const output: number[] = [];\n  const inputLength = input.length;\n  let i = 0,\n    n = initialN,\n    bias = initialBias;\n\n  let basic = input.lastIndexOf(delimiter);\n  if (basic < 0) basic = 0;\n\n  for (let j = 0; j < basic; j++) {\n    if (input.charCodeAt(j) >= 0x80) error(\"not-basic\");\n    output.push(input.charCodeAt(j));\n  }\n\n  for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {\n    const oldi = i;\n    let w = 1;\n    for (let k = base; ; k += base) {\n      if (index >= inputLength) error(\"invalid-input\");\n      const digit = basicToDigit(input.charCodeAt(index++));\n      if (digit >= base) error(\"invalid-input\");\n      if (digit > floor((maxInt - i) / w)) error(\"overflow\");\n      i += digit * w;\n      const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n      if (digit < t) break;\n      const baseMinusT = base - t;\n      if (w > floor(maxInt / baseMinusT)) error(\"overflow\");\n      w *= baseMinusT;\n    }\n    const out = output.length + 1;\n    bias = adapt(i - oldi, out, oldi === 0);\n    if (floor(i / out) > maxInt - n) error(\"overflow\");\n    n += floor(i / out);\n    i %= out;\n    output.splice(i++, 0, n);\n  }\n  return String.fromCodePoint(...output);\n}\n\n/** ---------------------------------------------------------\n * * ***Encodes a Unicode string to `Punycode-UtilsJS`.***\n * ---------------------------------------------------------\n *\n * @param input - Unicode string.\n * @returns `Punycode-UtilsJS` string.\n */\nfunction encode(input: string): string {\n  assertIsString(input, {\n    message: ({ currentType, validType }) =>\n      `Utils \\`punycodeUtilsJS.encode\\`, parameter \\`input\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const output: string[] = [];\n  const points = ucs2decode(input);\n  const inputLength = points.length;\n  let n = initialN,\n    delta = 0,\n    bias = initialBias;\n\n  for (const cp of points) if (cp < 0x80) output.push(stringFromCharCode(cp));\n  const basicLength = output.length;\n  let handledCPCount = basicLength;\n  if (basicLength) output.push(delimiter);\n\n  while (handledCPCount < inputLength) {\n    let m = maxInt;\n    for (const cp of points) if (cp >= n && cp < m) m = cp;\n\n    const handledCPCountPlusOne = handledCPCount + 1;\n    if (m - n > floor((maxInt - delta) / handledCPCountPlusOne))\n      error(\"overflow\");\n    delta += (m - n) * handledCPCountPlusOne;\n    n = m;\n\n    for (const cp of points) {\n      if (cp < n) delta++;\n      if (cp === n) {\n        let q = delta;\n        for (let k = base; ; k += base) {\n          const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n          if (q < t) break;\n          output.push(\n            stringFromCharCode(digitToBasic(t + ((q - t) % (base - t)), 0))\n          );\n          q = floor((q - t) / (base - t));\n        }\n        output.push(stringFromCharCode(digitToBasic(q, 0)));\n        bias = adapt(\n          delta,\n          handledCPCountPlusOne,\n          handledCPCount === basicLength\n        );\n        delta = 0;\n        handledCPCount++;\n      }\n    }\n    delta++;\n    n++;\n  }\n\n  return output.join(\"\");\n}\n\n/** ---------------------------------------------------------\n * * ***Converts `Punycode-UtilsJS` to Unicode for domain names.***\n * ---------------------------------------------------------\n *\n * @param input - Domain or label.\n * @returns Unicode string.\n */\nfunction toUnicode(input: string): string {\n  assertIsString(input, {\n    message: ({ currentType, validType }) =>\n      `Utils \\`punycodeUtilsJS.toUnicode\\`, parameter \\`input\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  return mapDomain(input, (str) =>\n    regexPunycode.test(str) ? decode(str.slice(4).toLowerCase()) : str\n  );\n}\n\n/** ---------------------------------------------------------\n * * ***Converts Unicode to ASCII (`Punycode-UtilsJS`) for domain names.***\n * ---------------------------------------------------------\n *\n * @param input - Domain or label.\n * @returns ASCII string.\n */\nfunction toASCII(input: string): string {\n  assertIsString(input, {\n    message: ({ currentType, validType }) =>\n      `Utils \\`punycodeUtilsJS.toASCII\\`, parameter \\`input\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  return mapDomain(input, (str) =>\n    regexNonASCII.test(str) ? \"xn--\" + encode(str) : str\n  );\n}\n\ntype PunycodeUtilsJS = {\n  /** ---------------------------------------------------------\n   * * ***Version of the `Punycode-UtilsJS` implementation.***\n   * ---------------------------------------------------------\n   *\n   * @example\n   * console.log(punycodeUtilsJS.version); // \"1.0.0\"\n   */\n  version: string;\n  /** ---------------------------------------------------------\n   * * ***UCS-2 utility functions.***\n   * ---------------------------------------------------------\n   */\n  ucs2: {\n    /** ---------------------------------------------------------\n     * * ***Decodes a UCS-2 encoded string to an array of Unicode code points.***\n     * ---------------------------------------------------------\n     *\n     * @param input - The UCS-2 string to decode.\n     * @returns Array of Unicode code points.\n     * @example\n     * punycodeUtilsJS.ucs2.decode(\"𐍈\");\n     * // ➔ [66376]\n     */\n    decode: (input: string) => number[];\n    /** ---------------------------------------------------------\n     * * ***Encodes an array of Unicode code points to a UCS-2 string.***\n     * ---------------------------------------------------------\n     *\n     * @param points - Array of Unicode code points.\n     * @returns Encoded string.\n     * @example\n     * punycodeUtilsJS.ucs2.encode([66376]);\n     * // ➔ \"𐍈\"\n     */\n    encode: (points: number[]) => string;\n  };\n  /** ---------------------------------------------------------\n   * * ***Decodes a `Punycode-UtilsJS` string to a Unicode string.***\n   * ---------------------------------------------------------\n   *\n   * @param input - The `Punycode-UtilsJS` string to decode.\n   * @returns Decoded Unicode string.\n   * @example\n   * punycodeUtilsJS.decode(\"xn--fsq\");\n   * // ➔ \"ü\"\n   */\n  decode: (input: string) => string;\n  /** ---------------------------------------------------------\n   * * ***Encodes a Unicode string to `Punycode-UtilsJS`.***\n   * ---------------------------------------------------------\n   *\n   * @param input - Unicode string to encode.\n   * @returns `Punycode-UtilsJS` string.\n   * @example\n   * punycodeUtilsJS.encode(\"ü\");\n   * // ➔ \"xn--fsq\"\n   */\n  encode: (input: string) => string;\n  /** ---------------------------------------------------------\n   * * ***Converts a Unicode domain or label to ASCII (`Punycode-UtilsJS`).***\n   * ---------------------------------------------------------\n   *\n   * @param input - Domain or label string.\n   * @returns ASCII string suitable for DNS.\n   * @example\n   * punycodeUtilsJS.toASCII(\"пример.рф\");\n   * // ➔ \"xn--e1afmkfd.xn--p1ai\"\n   */\n  toASCII: (input: string) => string;\n  /** ---------------------------------------------------------\n   * * ***Converts an ASCII (`Punycode-UtilsJS`) domain or label to Unicode.***\n   * ---------------------------------------------------------\n   *\n   * @param input - ASCII string (with xn-- prefix if needed).\n   * @returns Unicode string.\n   * @example\n   * punycodeUtilsJS.toUnicode(\"xn--e1afmkfd.xn--p1ai\");\n   * // ➔ \"пример.рф\"\n   */\n  toUnicode: (input: string) => string;\n};\n\n/** ---------------------------------------------------------\n * * ***`Punycode-UtilsJS` object exposing all API functions and version.***\n * ---------------------------------------------------------\n * Provides encoding and decoding of Unicode domain names to ASCII (`Punycode-UtilsJS`)\n * and vice versa.\n *\n * - Useful for IDN (Internationalized Domain Names) support.\n */\nconst punycodeUtilsJS: PunycodeUtilsJS = {\n  version: \"1.0.0\",\n  ucs2: {\n    decode: ucs2decode,\n    encode: ucs2encode\n  },\n  decode: decode,\n  encode: encode,\n  toASCII: toASCII,\n  toUnicode: toUnicode\n};\n\n/**\n * Export individual functions.\n */\nexport { punycodeUtilsJS };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAcA,MAAM,SAAS;;;;AAKf,MAAM,OAAO,IACX,OAAO,GACP,OAAO,IACP,OAAO,IACP,OAAO;;;;AAKT,MAAM,cAAc,IAClB,WAAW,KACX,YAAY;;;;;AAMd,MAAM,gBAAgB;;;;;AAKtB,MAAM,gBAAgB;;;;;AAKtB,MAAM,kBAAkB;;;;AAKxB,MAAM,SAAiC;CACrC,UAAU;CACV,aAAa;CACb,iBAAiB;AACnB;;;;AAKA,MAAM,QAAQ,KAAK;;;;;AAKnB,MAAM,qBAAqB,OAAO;;;;;;;AAQlC,SAAS,MAAM,MAAkC;CAC/C,MAAM,IAAI,WAAW,OAAO,KAAK;AACnC;;;;;;;;;AAUA,SAAS,IAAU,OAAY,IAAsB;CACnD,MAAM,SAAc,CAAC;CACrB,IAAI,SAAS,MAAM;CACnB,OAAO,UACL,IAAI,MAAM,SACR,OAAO,UAAU,GAAG,MAAM,OAAQ;CAGtC,OAAO;AACT;;;;;;;;;;AAWA,SAAS,UAAU,QAAgB,IAAmC;CACpE,MAAM,QAAQ,OAAO,MAAM,GAAG;CAC9B,IAAI,SAAS;CACb,IAAI,MAAM,SAAS,GAAG;EACpB,SAAS,MAAM,KAAK;EACpB,IAAI,MAAM,IAAI,SAAS,MAAM;CAC/B;CACA,SAAS,OAAO,QAAQ,iBAAiB,GAAM;CAC/C,MAAM,SAAS,OAAO,MAAM,GAAG;CAC/B,OAAO,SAAS,IAAI,QAAQ,EAAE,EAAE,KAAK,GAAG;AAC1C;;;;;;;;AASA,SAAS,WAAW,OAAyB;CAC3C,eAAe,OAAO,EACpB,UAAU,EAAE,aAAa,gBACvB,gFAAgF,UAAU,sBAAsB,YAAY,KAChI,CAAC;CAED,MAAM,SAAmB,CAAC;CAC1B,IAAI,UAAU;CACd,MAAM,SAAS,MAAM;CACrB,OAAO,UAAU,QAAQ;EACvB,MAAM,QAAQ,MAAM,WAAW,SAAS;EACxC,IAAI,SAAS,SAAU,SAAS,SAAU,UAAU,QAAQ;GAC1D,MAAM,QAAQ,MAAM,WAAW,SAAS;GACxC,KAAK,QAAQ,WAAY,OACvB,OAAO,OAAO,QAAQ,SAAU,OAAO,QAAQ,QAAS,KAAO;QAC5D;IACH,OAAO,KAAK,KAAK;IACjB;GACF;EACF,OAAO,OAAO,KAAK,KAAK;CAC1B;CACA,OAAO;AACT;;;;;;;;AASA,MAAM,cAAc,WAA6B;CAC/C,IACE,CAAC,MAAM,QAAQ,MAAM,KACrB,CAAC,OAAO,OAAO,MAAM,OAAO,MAAM,YAAY,OAAO,SAAS,CAAC,CAAC,GAEhE,MAAM,IAAI,UACR,4GAA4G,eAC1G,MACF,EAAE,IACJ;CAGF,OAAO,OAAO,cAAc,GAAG,MAAM;AACvC;;;;;;;;AASA,SAAS,aAAa,WAA2B;CAC/C,IAAI,aAAa,MAAQ,YAAY,IAAM,OAAO,MAAM,YAAY;CACpE,IAAI,aAAa,MAAQ,YAAY,IAAM,OAAO,YAAY;CAC9D,IAAI,aAAa,MAAQ,YAAY,KAAM,OAAO,YAAY;CAC9D,OAAO;AACT;;;;;;;;;AAUA,SAAS,aAAa,OAAe,MAAsB;CACzD,OAAO,QAAQ,KAAK,MAAM,QAAQ,KAAK,IAAI,KAAK,OAAO,SAAS,CAAC,IAAI;AACvE;;;;;;;;;;AAWA,SAAS,MAAM,OAAe,WAAmB,WAA4B;CAC3E,IAAI,IAAI;CACR,QAAQ,YAAY,MAAM,QAAQ,IAAI,IAAI,SAAS;CACnD,SAAS,MAAM,QAAQ,SAAS;CAChC,OAAO,QAAQ,KAA6B;EAC1C,QAAQ,MAAM,SAAS,OAAO,KAAK;EACnC,KAAK;CACP;CACA,OAAO,MAAM,IAAM,KAAmB,SAAU,QAAQ,KAAK;AAC/D;;;;;;;;AASA,SAAS,OAAO,OAAuB;CACrC,eAAe,OAAO,EACpB,UAAU,EAAE,aAAa,gBACvB,2EAA2E,UAAU,sBAAsB,YAAY,KAC3H,CAAC;CAED,MAAM,SAAmB,CAAC;CAC1B,MAAM,cAAc,MAAM;CAC1B,IAAI,IAAI,GACN,IAAI,UACJ,OAAO;CAET,IAAI,QAAQ,MAAM,YAAY,SAAS;CACvC,IAAI,QAAQ,GAAG,QAAQ;CAEvB,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;EAC9B,IAAI,MAAM,WAAW,CAAC,KAAK,KAAM,MAAM,WAAW;EAClD,OAAO,KAAK,MAAM,WAAW,CAAC,CAAC;CACjC;CAEA,KAAK,IAAI,QAAQ,QAAQ,IAAI,QAAQ,IAAI,GAAG,QAAQ,cAAe;EACjE,MAAM,OAAO;EACb,IAAI,IAAI;EACR,KAAK,IAAI,IAAI,OAAQ,KAAK,MAAM;GAC9B,IAAI,SAAS,aAAa,MAAM,eAAe;GAC/C,MAAM,QAAQ,aAAa,MAAM,WAAW,OAAO,CAAC;GACpD,IAAI,SAAS,MAAM,MAAM,eAAe;GACxC,IAAI,QAAQ,OAAO,SAAS,KAAK,CAAC,GAAG,MAAM,UAAU;GACrD,KAAK,QAAQ;GACb,MAAM,IAAI,KAAK,OAAO,OAAO,KAAK,OAAO,OAAO,OAAO,IAAI;GAC3D,IAAI,QAAQ,GAAG;GACf,MAAM,aAAa,OAAO;GAC1B,IAAI,IAAI,MAAM,SAAS,UAAU,GAAG,MAAM,UAAU;GACpD,KAAK;EACP;EACA,MAAM,MAAM,OAAO,SAAS;EAC5B,OAAO,MAAM,IAAI,MAAM,KAAK,SAAS,CAAC;EACtC,IAAI,MAAM,IAAI,GAAG,IAAI,SAAS,GAAG,MAAM,UAAU;EACjD,KAAK,MAAM,IAAI,GAAG;EAClB,KAAK;EACL,OAAO,OAAO,KAAK,GAAG,CAAC;CACzB;CACA,OAAO,OAAO,cAAc,GAAG,MAAM;AACvC;;;;;;;;AASA,SAAS,OAAO,OAAuB;CACrC,eAAe,OAAO,EACpB,UAAU,EAAE,aAAa,gBACvB,2EAA2E,UAAU,sBAAsB,YAAY,KAC3H,CAAC;CAED,MAAM,SAAmB,CAAC;CAC1B,MAAM,SAAS,WAAW,KAAK;CAC/B,MAAM,cAAc,OAAO;CAC3B,IAAI,IAAI,UACN,QAAQ,GACR,OAAO;CAET,KAAK,MAAM,MAAM,QAAQ,IAAI,KAAK,KAAM,OAAO,KAAK,mBAAmB,EAAE,CAAC;CAC1E,MAAM,cAAc,OAAO;CAC3B,IAAI,iBAAiB;CACrB,IAAI,aAAa,OAAO,KAAK,SAAS;CAEtC,OAAO,iBAAiB,aAAa;EACnC,IAAI,IAAI;EACR,KAAK,MAAM,MAAM,QAAQ,IAAI,MAAM,KAAK,KAAK,GAAG,IAAI;EAEpD,MAAM,wBAAwB,iBAAiB;EAC/C,IAAI,IAAI,IAAI,OAAO,SAAS,SAAS,qBAAqB,GACxD,MAAM,UAAU;EAClB,UAAU,IAAI,KAAK;EACnB,IAAI;EAEJ,KAAK,MAAM,MAAM,QAAQ;GACvB,IAAI,KAAK,GAAG;GACZ,IAAI,OAAO,GAAG;IACZ,IAAI,IAAI;IACR,KAAK,IAAI,IAAI,OAAQ,KAAK,MAAM;KAC9B,MAAM,IAAI,KAAK,OAAO,OAAO,KAAK,OAAO,OAAO,OAAO,IAAI;KAC3D,IAAI,IAAI,GAAG;KACX,OAAO,KACL,mBAAmB,aAAa,KAAM,IAAI,MAAM,OAAO,IAAK,CAAC,CAAC,CAChE;KACA,IAAI,OAAO,IAAI,MAAM,OAAO,EAAE;IAChC;IACA,OAAO,KAAK,mBAAmB,aAAa,GAAG,CAAC,CAAC,CAAC;IAClD,OAAO,MACL,OACA,uBACA,mBAAmB,WACrB;IACA,QAAQ;IACR;GACF;EACF;EACA;EACA;CACF;CAEA,OAAO,OAAO,KAAK,EAAE;AACvB;;;;;;;;AASA,SAAS,UAAU,OAAuB;CACxC,eAAe,OAAO,EACpB,UAAU,EAAE,aAAa,gBACvB,8EAA8E,UAAU,sBAAsB,YAAY,KAC9H,CAAC;CAED,OAAO,UAAU,QAAQ,QACvB,cAAc,KAAK,GAAG,IAAI,OAAO,IAAI,MAAM,CAAC,EAAE,YAAY,CAAC,IAAI,GACjE;AACF;;;;;;;;AASA,SAAS,QAAQ,OAAuB;CACtC,eAAe,OAAO,EACpB,UAAU,EAAE,aAAa,gBACvB,4EAA4E,UAAU,sBAAsB,YAAY,KAC5H,CAAC;CAED,OAAO,UAAU,QAAQ,QACvB,cAAc,KAAK,GAAG,IAAI,SAAS,OAAO,GAAG,IAAI,GACnD;AACF;;;;;;;;;AA6FA,MAAM,kBAAmC;CACvC,SAAS;CACT,MAAM;EACJ,QAAQ;EACR,QAAQ;CACV;CACQ;CACA;CACC;CACE;AACb"}

package/dist/punyCode-WZ6-GaTM.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"punyCode-WZ6-GaTM.cjs","names":["getPreciseType"],"sources":["../src/urls/utils/punyCode.ts"],"sourcesContent":["/** ---------------------------------------------------------\n * * ***Constants for `Punycode-UtilsJS` algorithm.***\n * ---------------------------------------------------------\n * These constants are used internally for encoding and decoding.\n *\n * Unicode domain names to ASCII (`Punycode-UtilsJS`) and vice versa.\n */\n\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\n\n/**\n * Constant `maxInt` for validate.\n */\nconst maxInt = 2147483647;\n\n/**\n * Bootstring parameters for `Punycode-UtilsJS`.\n */\nconst base = 36,\n  tMin = 1,\n  tMax = 26,\n  skew = 38,\n  damp = 700;\n\n/**\n * Initial bias and code point.\n */\nconst initialBias = 72,\n  initialN = 128,\n  delimiter = \"-\";\n\n/**\n * Regular expressions used internally.\n * Matches `Punycode-UtilsJS` prefix.\n */\nconst regexPunycode = /^xn--/;\n/**\n * Regular expressions used internally.\n * Matches non-ASCII chars.\n */\nconst regexNonASCII = /[^\\0-\\x7F]/;\n/**\n * Regular expressions used internally.\n * Matches domain label separators.\n */\nconst regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g;\n\n/**\n * Error messages used internally.\n */\nconst errors: Record<string, string> = {\n  overflow: \"Overflow: input needs wider integers to process\",\n  \"not-basic\": \"Illegal input >= 0x80 (not a basic code point)\",\n  \"invalid-input\": \"Invalid input\"\n};\n\n/**\n * Aliases of `Math.floor`.\n */\nconst floor = Math.floor;\n/** \n * Aliases of `String.fromCharCode`.\n\n*/\nconst stringFromCharCode = String.fromCharCode;\n\n/** ---------------------------------------------------------\n * * ***Throws a RangeError with a predefined error message.***\n * ---------------------------------------------------------\n *\n * @param type - Key of the error type to throw.\n */\nfunction error(type: keyof typeof errors): never {\n  throw new RangeError(errors[type]);\n}\n\n/** ---------------------------------------------------------\n * * ***Maps an array using a callback function.***\n * ---------------------------------------------------------\n *\n * @param array - Array to transform.\n * @param fn - Function to apply to each element.\n * @returns Transformed array.\n */\nfunction map<T, U>(array: T[], fn: (v: T) => U): U[] {\n  const result: U[] = [];\n  let length = array.length;\n  while (length--) {\n    if (array[length]) {\n      result[length] = fn(array[length]!);\n    }\n  }\n  return result;\n}\n\n/** ---------------------------------------------------------\n * * ***Maps a domain name using a callback on each label.***\n * ---------------------------------------------------------\n *\n * Handles email-like domains (local@domain).\n * @param domain - Domain string to process.\n * @param fn - Function applied to each domain label.\n * @returns Transformed domain string.\n */\nfunction mapDomain(domain: string, fn: (v: string) => string): string {\n  const parts = domain.split(\"@\");\n  let result = \"\";\n  if (parts.length > 1) {\n    result = parts[0] + \"@\";\n    if (parts[1]) domain = parts[1];\n  }\n  domain = domain.replace(regexSeparators, \"\\x2E\");\n  const labels = domain.split(\".\");\n  return result + map(labels, fn).join(\".\");\n}\n\n/** ---------------------------------------------------------\n * * ***Converts a UCS-2 encoded string to an array of Unicode code points.***\n * ---------------------------------------------------------\n *\n * @param input - String to decode.\n * @returns Array of Unicode code points.\n */\nfunction ucs2decode(input: string): number[] {\n  assertIsString(input, {\n    message: ({ currentType, validType }) =>\n      `Utils \\`punycodeUtilsJS.ucs2.decode\\`, parameter \\`input\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const output: number[] = [];\n  let counter = 0;\n  const length = input.length;\n  while (counter < length) {\n    const value = input.charCodeAt(counter++);\n    if (value >= 0xd800 && value <= 0xdbff && counter < length) {\n      const extra = input.charCodeAt(counter++);\n      if ((extra & 0xfc00) === 0xdc00)\n        output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);\n      else {\n        output.push(value);\n        counter--;\n      }\n    } else output.push(value);\n  }\n  return output;\n}\n\n/** ---------------------------------------------------------\n * * ***Encodes an array of Unicode code points to a string.***\n * ---------------------------------------------------------\n *\n * @param points - Array of Unicode code points.\n * @returns Encoded string.\n */\nconst ucs2encode = (points: number[]): string => {\n  if (\n    !Array.isArray(points) ||\n    !points.every((p) => typeof p === \"number\" && Number.isFinite(p))\n  ) {\n    throw new TypeError(\n      `Utils \\`punycodeUtilsJS.ucs2.encode\\`, parameter \\`points\\` must be an array of numbers, but received: \\`${getPreciseType(\n        points\n      )}\\`.`\n    );\n  }\n\n  return String.fromCodePoint(...points);\n};\n\n/** ---------------------------------------------------------\n * * ***Converts a basic code point to its digit value for `Punycode-UtilsJS`.***\n * ---------------------------------------------------------\n *\n * @param codePoint - Unicode code point.\n * @returns Digit value.\n */\nfunction basicToDigit(codePoint: number): number {\n  if (codePoint >= 0x30 && codePoint < 0x3a) return 26 + (codePoint - 0x30);\n  if (codePoint >= 0x41 && codePoint < 0x5b) return codePoint - 0x41;\n  if (codePoint >= 0x61 && codePoint < 0x7b) return codePoint - 0x61;\n  return base;\n}\n\n/** ---------------------------------------------------------\n * * ***Converts a digit to a basic code point for `Punycode-UtilsJS`.***\n * ---------------------------------------------------------\n *\n * @param digit - Numeric value.\n * @param flag - Bias flag (0 or 1).\n * @returns Code point.\n */\nfunction digitToBasic(digit: number, flag: number): number {\n  return digit + 22 + 75 * (digit < 26 ? 1 : 0) - Number(flag !== 0) * 32;\n}\n\n/** ---------------------------------------------------------\n * * ***Bias adaptation function for `Punycode-UtilsJS` encoding/decoding.***\n * ---------------------------------------------------------\n *\n * @param delta - Delta value.\n * @param numPoints - Number of code points.\n * @param firstTime - Indicates first adaptation.\n * @returns Adapted bias.\n */\nfunction adapt(delta: number, numPoints: number, firstTime: boolean): number {\n  let k = 0;\n  delta = firstTime ? floor(delta / damp) : delta >> 1;\n  delta += floor(delta / numPoints);\n  while (delta > ((base - tMin) * tMax) >> 1) {\n    delta = floor(delta / (base - tMin));\n    k += base;\n  }\n  return floor(k + ((base - tMin + 1) * delta) / (delta + skew));\n}\n\n/** ---------------------------------------------------------\n * * ***Decodes a `Punycode-UtilsJS` string to Unicode.***\n * ---------------------------------------------------------\n *\n * @param input - `Punycode-UtilsJS` string.\n * @returns Decoded Unicode string.\n */\nfunction decode(input: string): string {\n  assertIsString(input, {\n    message: ({ currentType, validType }) =>\n      `Utils \\`punycodeUtilsJS.decode\\`, parameter \\`input\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const output: number[] = [];\n  const inputLength = input.length;\n  let i = 0,\n    n = initialN,\n    bias = initialBias;\n\n  let basic = input.lastIndexOf(delimiter);\n  if (basic < 0) basic = 0;\n\n  for (let j = 0; j < basic; j++) {\n    if (input.charCodeAt(j) >= 0x80) error(\"not-basic\");\n    output.push(input.charCodeAt(j));\n  }\n\n  for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {\n    const oldi = i;\n    let w = 1;\n    for (let k = base; ; k += base) {\n      if (index >= inputLength) error(\"invalid-input\");\n      const digit = basicToDigit(input.charCodeAt(index++));\n      if (digit >= base) error(\"invalid-input\");\n      if (digit > floor((maxInt - i) / w)) error(\"overflow\");\n      i += digit * w;\n      const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n      if (digit < t) break;\n      const baseMinusT = base - t;\n      if (w > floor(maxInt / baseMinusT)) error(\"overflow\");\n      w *= baseMinusT;\n    }\n    const out = output.length + 1;\n    bias = adapt(i - oldi, out, oldi === 0);\n    if (floor(i / out) > maxInt - n) error(\"overflow\");\n    n += floor(i / out);\n    i %= out;\n    output.splice(i++, 0, n);\n  }\n  return String.fromCodePoint(...output);\n}\n\n/** ---------------------------------------------------------\n * * ***Encodes a Unicode string to `Punycode-UtilsJS`.***\n * ---------------------------------------------------------\n *\n * @param input - Unicode string.\n * @returns `Punycode-UtilsJS` string.\n */\nfunction encode(input: string): string {\n  assertIsString(input, {\n    message: ({ currentType, validType }) =>\n      `Utils \\`punycodeUtilsJS.encode\\`, parameter \\`input\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const output: string[] = [];\n  const points = ucs2decode(input);\n  const inputLength = points.length;\n  let n = initialN,\n    delta = 0,\n    bias = initialBias;\n\n  for (const cp of points) if (cp < 0x80) output.push(stringFromCharCode(cp));\n  const basicLength = output.length;\n  let handledCPCount = basicLength;\n  if (basicLength) output.push(delimiter);\n\n  while (handledCPCount < inputLength) {\n    let m = maxInt;\n    for (const cp of points) if (cp >= n && cp < m) m = cp;\n\n    const handledCPCountPlusOne = handledCPCount + 1;\n    if (m - n > floor((maxInt - delta) / handledCPCountPlusOne))\n      error(\"overflow\");\n    delta += (m - n) * handledCPCountPlusOne;\n    n = m;\n\n    for (const cp of points) {\n      if (cp < n) delta++;\n      if (cp === n) {\n        let q = delta;\n        for (let k = base; ; k += base) {\n          const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n          if (q < t) break;\n          output.push(\n            stringFromCharCode(digitToBasic(t + ((q - t) % (base - t)), 0))\n          );\n          q = floor((q - t) / (base - t));\n        }\n        output.push(stringFromCharCode(digitToBasic(q, 0)));\n        bias = adapt(\n          delta,\n          handledCPCountPlusOne,\n          handledCPCount === basicLength\n        );\n        delta = 0;\n        handledCPCount++;\n      }\n    }\n    delta++;\n    n++;\n  }\n\n  return output.join(\"\");\n}\n\n/** ---------------------------------------------------------\n * * ***Converts `Punycode-UtilsJS` to Unicode for domain names.***\n * ---------------------------------------------------------\n *\n * @param input - Domain or label.\n * @returns Unicode string.\n */\nfunction toUnicode(input: string): string {\n  assertIsString(input, {\n    message: ({ currentType, validType }) =>\n      `Utils \\`punycodeUtilsJS.toUnicode\\`, parameter \\`input\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  return mapDomain(input, (str) =>\n    regexPunycode.test(str) ? decode(str.slice(4).toLowerCase()) : str\n  );\n}\n\n/** ---------------------------------------------------------\n * * ***Converts Unicode to ASCII (`Punycode-UtilsJS`) for domain names.***\n * ---------------------------------------------------------\n *\n * @param input - Domain or label.\n * @returns ASCII string.\n */\nfunction toASCII(input: string): string {\n  assertIsString(input, {\n    message: ({ currentType, validType }) =>\n      `Utils \\`punycodeUtilsJS.toASCII\\`, parameter \\`input\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  return mapDomain(input, (str) =>\n    regexNonASCII.test(str) ? \"xn--\" + encode(str) : str\n  );\n}\n\ntype PunycodeUtilsJS = {\n  /** ---------------------------------------------------------\n   * * ***Version of the `Punycode-UtilsJS` implementation.***\n   * ---------------------------------------------------------\n   *\n   * @example\n   * console.log(punycodeUtilsJS.version); // \"1.0.0\"\n   */\n  version: string;\n  /** ---------------------------------------------------------\n   * * ***UCS-2 utility functions.***\n   * ---------------------------------------------------------\n   */\n  ucs2: {\n    /** ---------------------------------------------------------\n     * * ***Decodes a UCS-2 encoded string to an array of Unicode code points.***\n     * ---------------------------------------------------------\n     *\n     * @param input - The UCS-2 string to decode.\n     * @returns Array of Unicode code points.\n     * @example\n     * punycodeUtilsJS.ucs2.decode(\"𐍈\");\n     * // ➔ [66376]\n     */\n    decode: (input: string) => number[];\n    /** ---------------------------------------------------------\n     * * ***Encodes an array of Unicode code points to a UCS-2 string.***\n     * ---------------------------------------------------------\n     *\n     * @param points - Array of Unicode code points.\n     * @returns Encoded string.\n     * @example\n     * punycodeUtilsJS.ucs2.encode([66376]);\n     * // ➔ \"𐍈\"\n     */\n    encode: (points: number[]) => string;\n  };\n  /** ---------------------------------------------------------\n   * * ***Decodes a `Punycode-UtilsJS` string to a Unicode string.***\n   * ---------------------------------------------------------\n   *\n   * @param input - The `Punycode-UtilsJS` string to decode.\n   * @returns Decoded Unicode string.\n   * @example\n   * punycodeUtilsJS.decode(\"xn--fsq\");\n   * // ➔ \"ü\"\n   */\n  decode: (input: string) => string;\n  /** ---------------------------------------------------------\n   * * ***Encodes a Unicode string to `Punycode-UtilsJS`.***\n   * ---------------------------------------------------------\n   *\n   * @param input - Unicode string to encode.\n   * @returns `Punycode-UtilsJS` string.\n   * @example\n   * punycodeUtilsJS.encode(\"ü\");\n   * // ➔ \"xn--fsq\"\n   */\n  encode: (input: string) => string;\n  /** ---------------------------------------------------------\n   * * ***Converts a Unicode domain or label to ASCII (`Punycode-UtilsJS`).***\n   * ---------------------------------------------------------\n   *\n   * @param input - Domain or label string.\n   * @returns ASCII string suitable for DNS.\n   * @example\n   * punycodeUtilsJS.toASCII(\"пример.рф\");\n   * // ➔ \"xn--e1afmkfd.xn--p1ai\"\n   */\n  toASCII: (input: string) => string;\n  /** ---------------------------------------------------------\n   * * ***Converts an ASCII (`Punycode-UtilsJS`) domain or label to Unicode.***\n   * ---------------------------------------------------------\n   *\n   * @param input - ASCII string (with xn-- prefix if needed).\n   * @returns Unicode string.\n   * @example\n   * punycodeUtilsJS.toUnicode(\"xn--e1afmkfd.xn--p1ai\");\n   * // ➔ \"пример.рф\"\n   */\n  toUnicode: (input: string) => string;\n};\n\n/** ---------------------------------------------------------\n * * ***`Punycode-UtilsJS` object exposing all API functions and version.***\n * ---------------------------------------------------------\n * Provides encoding and decoding of Unicode domain names to ASCII (`Punycode-UtilsJS`)\n * and vice versa.\n *\n * - Useful for IDN (Internationalized Domain Names) support.\n */\nconst punycodeUtilsJS: PunycodeUtilsJS = {\n  version: \"1.0.0\",\n  ucs2: {\n    decode: ucs2decode,\n    encode: ucs2encode\n  },\n  decode: decode,\n  encode: encode,\n  toASCII: toASCII,\n  toUnicode: toUnicode\n};\n\n/**\n * Export individual functions.\n */\nexport { punycodeUtilsJS };\n"],"mappings":"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"}

package/dist/removeSpaces-BeGkktUl.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"removeSpaces-BeGkktUl.cjs","names":["isNonEmptyString","isNonEmptyString","isPlainObject"],"sources":["../src/strings/sanitizations/normalizeString.ts","../src/strings/sanitizations/removeSpaces.ts"],"sourcesContent":["import { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `normalizeString`.***\n * ----------------------------------------------------------\n * **Normalizes a string by ensuring it is a valid string and trimming whitespace.**\n * - **Behavior:**\n *    - If the input is `undefined`, `null`, or an `empty string` after trimming,\n *      it returns an empty string `(\"\")`.\n * @param {string | undefined | null} input - The input string to be normalize. If `null` or `undefined`, returns an empty string.\n * @returns {string} A trimmed string or an empty string if the input is invalid.\n * @example\n * normalizeString(\"   Hello World   \");\n * // ➔ \"Hello World\"\n * normalizeString(\"   Hello    World   \");\n * // ➔ \"Hello    World\"\n * normalizeString(\"\");\n * // ➔ \"\"\n * normalizeString(null);\n * // ➔ \"\"\n * normalizeString(undefined);\n * // ➔ \"\"\n */\nexport const normalizeString = (input: string | null | undefined): string => {\n  return isNonEmptyString(input) ? input.trim() : \"\";\n};\n","import { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\ntype RemoveSpacesOptions = {\n  /** If `true`, only trims the string, defaultValue: `false`.\n   *\n   * @default false\n   */\n  trimOnly?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Utility: `removeSpaces`.***\n * ----------------------------------------------------------\n * **Removes all spaces from a string or trims only, based on the options provided.**\n * - **Behavior:**\n *    - If `trimOnly` is `true`, the string is simply trimmed.\n *    - Otherwise, removes **all spaces**, tabs, newlines, etc.\n *    - If the input is `null` or `undefined`, returns an empty string `(\"\")`.\n * @param {string | null | undefined} value - The input string to be processed. If `null` or `undefined`, returns an empty string.\n * @param {RemoveSpacesOptions} [options] - The options object.\n * @param {RemoveSpacesOptions[\"trimOnly\"]} [options.trimOnly=false] - If `true`, only trims the string without removing spaces inside.\n * @returns {string} The processed string.\n * @example\n * removeSpaces(\"  Hello   World  \");\n * // ➔ \"HelloWorld\"\n * removeSpaces(\"  Hello   World  \", { trimOnly: true });\n * // ➔ \"Hello   World\"\n * removeSpaces(null);\n * // ➔ \"\"\n */\nexport const removeSpaces = (\n  value: string | null | undefined,\n  options: RemoveSpacesOptions = {\n    trimOnly: false\n  }\n): string => {\n  if (!isNonEmptyString(value)) return \"\";\n\n  if (!isPlainObject(options)) {\n    options = {};\n  }\n\n  const { trimOnly = false } = options;\n\n  if (trimOnly) return value.trim();\n\n  // Remove all spaces (including tabs, newlines, etc.)\n  return value.replace(/\\s+/g, \"\");\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,mBAAmB,UAA6C;CAC3E,OAAOA,yCAAiB,KAAK,IAAI,MAAM,KAAK,IAAI;AAClD;;;;;;;;;;;;;;;;;;;;;;;;ACMA,MAAa,gBACX,OACA,UAA+B,EAC7B,UAAU,MACZ,MACW;CACX,IAAI,CAACC,yCAAiB,KAAK,GAAG,OAAO;CAErC,IAAI,CAACC,sCAAc,OAAO,GACxB,UAAU,CAAC;CAGb,MAAM,EAAE,WAAW,UAAU;CAE7B,IAAI,UAAU,OAAO,MAAM,KAAK;CAGhC,OAAO,MAAM,QAAQ,QAAQ,EAAE;AACjC"}

package/dist/removeSpaces-CQJvw1yU.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"removeSpaces-CQJvw1yU.js","names":[],"sources":["../src/strings/sanitizations/normalizeString.ts","../src/strings/sanitizations/removeSpaces.ts"],"sourcesContent":["import { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `normalizeString`.***\n * ----------------------------------------------------------\n * **Normalizes a string by ensuring it is a valid string and trimming whitespace.**\n * - **Behavior:**\n *    - If the input is `undefined`, `null`, or an `empty string` after trimming,\n *      it returns an empty string `(\"\")`.\n * @param {string | undefined | null} input - The input string to be normalize. If `null` or `undefined`, returns an empty string.\n * @returns {string} A trimmed string or an empty string if the input is invalid.\n * @example\n * normalizeString(\"   Hello World   \");\n * // ➔ \"Hello World\"\n * normalizeString(\"   Hello    World   \");\n * // ➔ \"Hello    World\"\n * normalizeString(\"\");\n * // ➔ \"\"\n * normalizeString(null);\n * // ➔ \"\"\n * normalizeString(undefined);\n * // ➔ \"\"\n */\nexport const normalizeString = (input: string | null | undefined): string => {\n  return isNonEmptyString(input) ? input.trim() : \"\";\n};\n","import { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\ntype RemoveSpacesOptions = {\n  /** If `true`, only trims the string, defaultValue: `false`.\n   *\n   * @default false\n   */\n  trimOnly?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Utility: `removeSpaces`.***\n * ----------------------------------------------------------\n * **Removes all spaces from a string or trims only, based on the options provided.**\n * - **Behavior:**\n *    - If `trimOnly` is `true`, the string is simply trimmed.\n *    - Otherwise, removes **all spaces**, tabs, newlines, etc.\n *    - If the input is `null` or `undefined`, returns an empty string `(\"\")`.\n * @param {string | null | undefined} value - The input string to be processed. If `null` or `undefined`, returns an empty string.\n * @param {RemoveSpacesOptions} [options] - The options object.\n * @param {RemoveSpacesOptions[\"trimOnly\"]} [options.trimOnly=false] - If `true`, only trims the string without removing spaces inside.\n * @returns {string} The processed string.\n * @example\n * removeSpaces(\"  Hello   World  \");\n * // ➔ \"HelloWorld\"\n * removeSpaces(\"  Hello   World  \", { trimOnly: true });\n * // ➔ \"Hello   World\"\n * removeSpaces(null);\n * // ➔ \"\"\n */\nexport const removeSpaces = (\n  value: string | null | undefined,\n  options: RemoveSpacesOptions = {\n    trimOnly: false\n  }\n): string => {\n  if (!isNonEmptyString(value)) return \"\";\n\n  if (!isPlainObject(options)) {\n    options = {};\n  }\n\n  const { trimOnly = false } = options;\n\n  if (trimOnly) return value.trim();\n\n  // Remove all spaces (including tabs, newlines, etc.)\n  return value.replace(/\\s+/g, \"\");\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,mBAAmB,UAA6C;CAC3E,OAAO,iBAAiB,KAAK,IAAI,MAAM,KAAK,IAAI;AAClD;;;;;;;;;;;;;;;;;;;;;;;;ACMA,MAAa,gBACX,OACA,UAA+B,EAC7B,UAAU,MACZ,MACW;CACX,IAAI,CAAC,iBAAiB,KAAK,GAAG,OAAO;CAErC,IAAI,CAAC,cAAc,OAAO,GACxB,UAAU,CAAC;CAGb,MAAM,EAAE,WAAW,UAAU;CAE7B,IAAI,UAAU,OAAO,MAAM,KAAK;CAGhC,OAAO,MAAM,QAAQ,QAAQ,EAAE;AACjC"}

package/dist/safeJsonParse-BznDD3fi.cjs

@@ -1,208 +0,0 @@
-/*!
-* ========================================================================
-*  @rzl-zone/utils-js
-* ------------------------------------------------------------------------
-*  Version: `3.13.1-beta.0`
-*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
-*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
-* ========================================================================
-*/
-"use strict";
-const require_assertIsBoolean = require('./assertIsBoolean-CEx4KbHg.cjs');
-const require_isEmptyObject = require('./isEmptyObject-C2lQyFZS.cjs');
-const require_safeStableStringify = require('./safeStableStringify-4b-E_UHM.cjs');
-const require_noop = require('./noop-CkwxErJ2.cjs');
-const parseCustomDate = (dateString, format) => {
-	if (!require_assertIsBoolean.isNonEmptyString(dateString) || !require_assertIsBoolean.isNonEmptyString(format)) throw new TypeError(`Parameter \`dateString\` and \`format\` must be of type \`string\` and not empty-string, but received: "['dateString': \`${require_assertIsBoolean.getPreciseType(dateString)}\` - (current value: \`${require_safeStableStringify.safeStableStringify(dateString, { keepUndefined: true })}\`), 'format': \`${require_assertIsBoolean.getPreciseType(format)}\` - (current value: \`${require_safeStableStringify.safeStableStringify(format, { keepUndefined: true })}\`)]".`);
-	const dateParts = dateString.split(/[-/]/).map(Number);
-	if (dateParts.length !== 3 || dateParts.some(isNaN)) return null;
-	let day, month, year;
-	if (format === "DD/MM/YYYY") [day, month, year] = dateParts;
-	else if (format === "MM/DD/YYYY") [month, day, year] = dateParts;
-	else return null;
-	if (month) month -= 1;
-	const date = year && month && day ? new Date(year, month, day) : void 0;
-	if (!date || date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) return null;
-	return date;
-};
-const validateJsonParsingOptions = (optionsValue = {}) => {
-	require_assertIsBoolean.assertIsPlainObject(optionsValue, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
-	const convertBooleans = require_assertIsBoolean.hasOwnProp(optionsValue, "convertBooleans") ? optionsValue.convertBooleans : false;
-	const convertDates = require_assertIsBoolean.hasOwnProp(optionsValue, "convertDates") ? optionsValue.convertDates : false;
-	const convertNumbers = require_assertIsBoolean.hasOwnProp(optionsValue, "convertNumbers") ? optionsValue.convertNumbers : false;
-	const loggingOnFail = require_assertIsBoolean.hasOwnProp(optionsValue, "loggingOnFail") ? optionsValue.loggingOnFail : false;
-	const removeEmptyArrays = require_assertIsBoolean.hasOwnProp(optionsValue, "removeEmptyArrays") ? optionsValue.removeEmptyArrays : false;
-	const removeEmptyObjects = require_assertIsBoolean.hasOwnProp(optionsValue, "removeEmptyObjects") ? optionsValue.removeEmptyObjects : false;
-	const removeNulls = require_assertIsBoolean.hasOwnProp(optionsValue, "removeNulls") ? optionsValue.removeNulls : false;
-	const removeUndefined = require_assertIsBoolean.hasOwnProp(optionsValue, "removeUndefined") ? optionsValue.removeUndefined : false;
-	const strictMode = require_assertIsBoolean.hasOwnProp(optionsValue, "strictMode") ? optionsValue.strictMode : false;
-	const checkSymbols = require_assertIsBoolean.hasOwnProp(optionsValue, "checkSymbols") ? optionsValue.checkSymbols : false;
-	const convertNaN = require_assertIsBoolean.hasOwnProp(optionsValue, "convertNaN") ? optionsValue.convertNaN : false;
-	const customDateFormats = require_assertIsBoolean.hasOwnProp(optionsValue, "customDateFormats") ? optionsValue.customDateFormats : [];
-	const onError = require_assertIsBoolean.hasOwnProp(optionsValue, "onError") ? optionsValue.onError : require_noop.noop;
-	if (!(require_assertIsBoolean.isBoolean(convertBooleans) && require_assertIsBoolean.isBoolean(convertDates) && require_assertIsBoolean.isBoolean(convertNumbers) && require_assertIsBoolean.isBoolean(convertNaN) && require_assertIsBoolean.isBoolean(checkSymbols) && require_assertIsBoolean.isBoolean(loggingOnFail) && require_assertIsBoolean.isBoolean(removeEmptyArrays) && require_assertIsBoolean.isBoolean(removeEmptyObjects) && require_assertIsBoolean.isBoolean(removeNulls) && require_assertIsBoolean.isBoolean(removeUndefined) && require_assertIsBoolean.isBoolean(strictMode) && require_assertIsBoolean.isArray(customDateFormats) && require_assertIsBoolean.isFunction(onError))) throw new TypeError(`Invalid \`options\` parameter (second argument): \`convertBooleans\`, \`convertDates\`, \`convertNumbers\`, \`loggingOnFail\`, \`removeEmptyArrays\`, \`removeEmptyObjects\`, \`removeNulls\`, \`removeUndefined\`, \`strictMode\` expected to be a \`boolean\` type, \`customDateFormats\` expected to be a \`array\` type and \`onError\` expected to be a \`void function\` type. But received: ['convertBooleans': \`${require_assertIsBoolean.getPreciseType(convertBooleans)}\`, 'convertDates': \`${require_assertIsBoolean.getPreciseType(convertDates)}\`, 'convertNumbers': \`${require_assertIsBoolean.getPreciseType(convertNumbers)}\`, 'loggingOnFail': \`${require_assertIsBoolean.getPreciseType(loggingOnFail)}\`, 'removeEmptyArrays': \`${require_assertIsBoolean.getPreciseType(removeEmptyArrays)}\`, 'removeEmptyObjects': \`${require_assertIsBoolean.getPreciseType(removeEmptyObjects)}\`, 'removeNulls': \`${require_assertIsBoolean.getPreciseType(removeNulls)}\`, 'removeUndefined': \`${require_assertIsBoolean.getPreciseType(removeUndefined)}\`, 'strictMode': \`${require_assertIsBoolean.getPreciseType(strictMode)}\`, 'customDateFormats': \`${require_assertIsBoolean.getPreciseType(customDateFormats)}\`, 'onError': \`${require_assertIsBoolean.getPreciseType(onError)}\`].`);
-	return {
-		convertBooleans,
-		convertDates,
-		convertNumbers,
-		convertNaN,
-		loggingOnFail,
-		removeEmptyArrays,
-		removeEmptyObjects,
-		removeNulls,
-		removeUndefined,
-		strictMode,
-		customDateFormats,
-		onError,
-		checkSymbols
-	};
-};
-const cleanParsedData = (data, options = {}) => {
-	const validOptions = validateJsonParsingOptions(options);
-	if (require_assertIsBoolean.isNull(data)) return validOptions.removeNulls ? void 0 : null;
-	if (require_assertIsBoolean.isUndefined(data)) return validOptions.removeUndefined ? void 0 : void 0;
-	if (require_assertIsBoolean.isString(data)) {
-		const trimmed = data.trim();
-		if (validOptions.convertNaN && trimmed === "NaN") return NaN;
-		if (validOptions.convertNumbers && !isNaN(Number(trimmed))) return Number(trimmed);
-		if (validOptions.convertBooleans) {
-			if (trimmed === "true") return true;
-			if (trimmed === "false") return false;
-		}
-		if (validOptions.convertDates) {
-			if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(trimmed)) return new Date(trimmed);
-			if (validOptions.customDateFormats?.length) for (const format of validOptions.customDateFormats) {
-				const date = parseCustomDate(trimmed, format);
-				if (date) return date;
-			}
-		}
-		return validOptions.strictMode ? void 0 : trimmed;
-	}
-	if (require_assertIsBoolean.isArray(data)) {
-		const cleanedArray = data.map((item) => cleanParsedData(item, validOptions)).filter((item) => !require_assertIsBoolean.isUndefined(item));
-		return validOptions.removeEmptyArrays && require_isEmptyObject.isEmptyArray(cleanedArray) ? void 0 : cleanedArray;
-	}
-	if (require_assertIsBoolean.isObject(data)) {
-		const cleanedObject = {};
-		for (const key in data) if (Object.prototype.hasOwnProperty.call(data, key)) {
-			const cleanedValue = cleanParsedData(data[key], validOptions);
-			if (!require_assertIsBoolean.isUndefined(cleanedValue)) cleanedObject[key] = cleanedValue;
-		}
-		return validOptions.removeEmptyObjects && require_isEmptyObject.isEmptyObject(cleanedObject, { checkSymbols: validOptions.checkSymbols }) ? void 0 : cleanedObject;
-	}
-	return validOptions.strictMode ? void 0 : data;
-};
-const extractDigits = (value) => {
-	if (!require_assertIsBoolean.isString(value) && !require_assertIsBoolean.isNumber(value)) return 0;
-	const cleaned = String(value).trim().replace(/[^0-9]/g, "");
-	return Number(cleaned) || 0;
-};
-function fixSingleQuotesEscapeBackslash(input) {
-	const validEscapes = new Set([
-		"\\",
-		"\"",
-		"/",
-		"b",
-		"f",
-		"n",
-		"r",
-		"t",
-		"u"
-	]);
-	let output = "";
-	let inSingleQuote = false;
-	let inDoubleQuote = false;
-	let escapeNext = false;
-	for (let i = 0; i < input.length; i++) {
-		const c = input[i] || "";
-		if (escapeNext) {
-			if (inSingleQuote) if (c === "'") output += "'";
-			else if (validEscapes.has(c)) if (c === "\\") output += "\\\\";
-			else if (c === "\"") output += "\\\"";
-			else output += "\\" + c;
-			else output += "\\\\" + c;
-			else if (inDoubleQuote) if (c === "\"") output += "\\\"";
-			else if (validEscapes.has(c)) output += "\\" + c;
-			else output += "\\\\" + c;
-			else output += "\\" + c;
-			escapeNext = false;
-			continue;
-		}
-		if (c === "\\") {
-			escapeNext = true;
-			continue;
-		}
-		if (!inSingleQuote && !inDoubleQuote) {
-			if (c === "'") {
-				output += "\"";
-				inSingleQuote = true;
-				continue;
-			}
-			if (c === "\"") {
-				output += "\"";
-				inDoubleQuote = true;
-				continue;
-			}
-		} else if (inSingleQuote) {
-			if (c === "'") {
-				output += "\"";
-				inSingleQuote = false;
-				continue;
-			}
-		} else if (inDoubleQuote) {
-			if (c === "\"") {
-				output += "\"";
-				inDoubleQuote = false;
-				continue;
-			}
-		}
-		output += c;
-	}
-	return output;
-}
-//! implement main function
-function safeJsonParse(value, options = {}) {
-	if (require_assertIsBoolean.isNull(value)) return null;
-	const validOptions = validateJsonParsingOptions(options);
-	if (validOptions.convertNaN && (require_assertIsBoolean.isNaN(value) || require_assertIsBoolean.isNonEmptyString(value) && value === "NaN")) return NaN;
-	if (validOptions.convertNumbers && !require_assertIsBoolean.isNaN(Number(value)) && require_assertIsBoolean.isNumber(extractDigits(value))) return Number(value);
-	if (!require_assertIsBoolean.isString(value)) return void 0;
-	try {
-		let normalized = fixSingleQuotesEscapeBackslash(value);
-		if (validOptions.removeUndefined) normalized = normalized.replace(/,\s*"[^"]*"\s*:\s*undefined(?=\s*[},])/g, "").replace(/"[^"]*"\s*:\s*undefined\s*(,)?/g, "");
-		else normalized = normalized.replace(/:\s*undefined(?=\s*[,}])/g, ":null");
-		if (validOptions.convertNaN) normalized = normalized.replace(/:\s*NaN(?=\s*[,}])/g, ":\"NaN\"");
-		else normalized = normalized.replace(/:\s*NaN(?=\s*[,}])/g, ":\"NaN\"").replace(/,\s*"[^"]*"\s*:\s*NaN(?=\s*[},])/g, "").replace(/"[^"]*"\s*:\s*NaN\s*(,)?/g, "");
-		normalized = normalized.replace(/,(\s*[}\]])/g, "$1");
-		return cleanParsedData(JSON.parse(normalized), validOptions);
-	} catch (error) {
-		if (validOptions.loggingOnFail) console.error("Failed to parsing at `safeJsonParse`:", error);
-		validOptions.onError(require_assertIsBoolean.isError(error) ? new Error(error.message.replace(/^JSON\.parse:/, "Failed to parsing")) : new Error(String(error)));
-		return;
-	}
-}
-Object.defineProperty(exports, 'cleanParsedData', {
-  enumerable: true,
-  get: function () {
-    return cleanParsedData;
-  }
-});
-Object.defineProperty(exports, 'extractDigits', {
-  enumerable: true,
-  get: function () {
-    return extractDigits;
-  }
-});
-Object.defineProperty(exports, 'parseCustomDate', {
-  enumerable: true,
-  get: function () {
-    return parseCustomDate;
-  }
-});
-Object.defineProperty(exports, 'safeJsonParse', {
-  enumerable: true,
-  get: function () {
-    return safeJsonParse;
-  }
-});
-//# sourceMappingURL=safeJsonParse-BznDD3fi.cjs.map

package/dist/safeJsonParse-BznDD3fi.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"safeJsonParse-BznDD3fi.cjs","names":["isNonEmptyString","getPreciseType","safeStableStringify","hasOwnProp","noop","isBoolean","isArray","isFunction","getPreciseType","isNull","isUndefined","isString","isArray","isEmptyArray","isObject","isEmptyObject","isString","isNumber","isNull","isNaN","isNonEmptyString","isNumber","isString","isError"],"sources":["../src/conversions/json/parseCustomDate.ts","../src/conversions/json/_private/utils/validateJsonParsingOptions.ts","../src/conversions/json/cleanParsedData.ts","../src/conversions/numerics/extractDigits.ts","../src/conversions/json/_private/utils/fixSingleQuotesEscapeBackslash.ts","../src/conversions/json/safeJsonParse.ts"],"sourcesContent":["import { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\nimport { safeStableStringify } from \"../stringify/safeStableStringify\";\n\n/** --------------------------------------------------\n * * ***Utility: `parseCustomDate`.***\n * ---------------------------------------------\n * **Parses custom date formats like \"DD/MM/YYYY\" or \"MM/DD/YYYY\".**\n * @param {string} dateString - Date string to parse.\n * @param {string} format - Date format to match.\n * @returns {Date | null} Returns a `Date` object if valid, otherwise `null`.\n * @throws **{@link TypeError | `TypeError`}** if `dateString` **(first parameter)** and `format` **(second parameter)** is not a string or empty-string.\n * @example\n * // Valid: European format (DD/MM/YYYY)\n * const date1 = parseCustomDate(\"03/09/2025\", \"DD/MM/YYYY\");\n * console.log(date1); // ➔ Date { Wed Sep 03 2025 ... }\n *\n * // Valid: US format (MM/DD/YYYY)\n * const date2 = parseCustomDate(\"09/03/2025\", \"MM/DD/YYYY\");\n * console.log(date2); // ➔ Date { Wed Sep 03 2025 ... }\n *\n * // Invalid: wrong format\n * const date3 = parseCustomDate(\"2025-09-03\", \"DD/MM/YYYY\");\n * console.log(date3); // ➔ null\n *\n * // Invalid: non-date string\n * const date4 = parseCustomDate(\"hello\", \"DD/MM/YYYY\");\n * console.log(date4); // ➔ null\n *\n * // Throws: wrong parameter types or empty-string\n * parseCustomDate(123, \"DD/MM/YYYY\");\n * // ➔ TypeError: Parameter `dateString` and `format` must be of type `string`...\n */\nexport const parseCustomDate = (\n  dateString: string,\n  format: string\n): Date | null => {\n  if (!isNonEmptyString(dateString) || !isNonEmptyString(format)) {\n    throw new TypeError(\n      `Parameter \\`dateString\\` and \\`format\\` must be of type \\`string\\` and not empty-string, but received: \"['dateString': \\`${getPreciseType(\n        dateString\n      )}\\` - (current value: \\`${safeStableStringify(dateString, {\n        keepUndefined: true\n      })}\\`), 'format': \\`${getPreciseType(\n        format\n      )}\\` - (current value: \\`${safeStableStringify(format, {\n        keepUndefined: true\n      })}\\`)]\".`\n    );\n  }\n\n  const dateParts = dateString.split(/[-/]/).map(Number);\n  if (dateParts.length !== 3 || dateParts.some(isNaN)) return null;\n\n  let day: number | undefined,\n    month: number | undefined,\n    year: number | undefined;\n\n  if (format === \"DD/MM/YYYY\") {\n    [day, month, year] = dateParts;\n  } else if (format === \"MM/DD/YYYY\") {\n    [month, day, year] = dateParts;\n  } else {\n    return null;\n  }\n\n  if (month) month -= 1;\n  const date = year && month && day ? new Date(year, month, day) : undefined;\n\n  if (\n    !date ||\n    date.getFullYear() !== year ||\n    date.getMonth() !== month ||\n    date.getDate() !== day\n  ) {\n    return null;\n  }\n\n  return date;\n};\n","import type { Prettify } from \"@rzl-zone/ts-types-plus\";\n\nimport type { ParseParsedDataOptions } from \"../types/ParseParsedDataOptions\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { cleanParsedData } from \"../../cleanParsedData\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { parseCustomDate } from \"../../parseCustomDate\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { safeJsonParse } from \"../../safeJsonParse\";\n\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isFunction } from \"@/predicates/is/isFunction\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\nimport { noop } from \"@/generators/utils/noop\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype ValidatedParsedDataOptions = Prettify<Required<ParseParsedDataOptions>>;\n\n/** * ***Private Helper for Options Validation Function: {@link cleanParsedData | `cleanParsedData`}, {@link parseCustomDate | `parseCustomDate`} and {@link safeJsonParse | `safeJsonParse`}.***\n *\n * @internal\n */\nexport const validateJsonParsingOptions = (\n  optionsValue: ParseParsedDataOptions = {}\n): ValidatedParsedDataOptions => {\n  assertIsPlainObject(optionsValue, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const convertBooleans = hasOwnProp(optionsValue, \"convertBooleans\")\n    ? optionsValue.convertBooleans\n    : false;\n  const convertDates = hasOwnProp(optionsValue, \"convertDates\")\n    ? optionsValue.convertDates\n    : false;\n  const convertNumbers = hasOwnProp(optionsValue, \"convertNumbers\")\n    ? optionsValue.convertNumbers\n    : false;\n  const loggingOnFail = hasOwnProp(optionsValue, \"loggingOnFail\")\n    ? optionsValue.loggingOnFail\n    : false;\n  const removeEmptyArrays = hasOwnProp(optionsValue, \"removeEmptyArrays\")\n    ? optionsValue.removeEmptyArrays\n    : false;\n  const removeEmptyObjects = hasOwnProp(optionsValue, \"removeEmptyObjects\")\n    ? optionsValue.removeEmptyObjects\n    : false;\n  const removeNulls = hasOwnProp(optionsValue, \"removeNulls\")\n    ? optionsValue.removeNulls\n    : false;\n  const removeUndefined = hasOwnProp(optionsValue, \"removeUndefined\")\n    ? optionsValue.removeUndefined\n    : false;\n  const strictMode = hasOwnProp(optionsValue, \"strictMode\")\n    ? optionsValue.strictMode\n    : false;\n  const checkSymbols = hasOwnProp(optionsValue, \"checkSymbols\")\n    ? optionsValue.checkSymbols\n    : false;\n  const convertNaN = hasOwnProp(optionsValue, \"convertNaN\")\n    ? optionsValue.convertNaN\n    : false;\n\n  const customDateFormats = hasOwnProp(optionsValue, \"customDateFormats\")\n    ? optionsValue.customDateFormats\n    : [];\n  const onError = hasOwnProp(optionsValue, \"onError\")\n    ? optionsValue.onError\n    : noop;\n\n  if (\n    !(\n      isBoolean(convertBooleans) &&\n      isBoolean(convertDates) &&\n      isBoolean(convertNumbers) &&\n      isBoolean(convertNaN) &&\n      isBoolean(checkSymbols) &&\n      isBoolean(loggingOnFail) &&\n      isBoolean(removeEmptyArrays) &&\n      isBoolean(removeEmptyObjects) &&\n      isBoolean(removeNulls) &&\n      isBoolean(removeUndefined) &&\n      isBoolean(strictMode) &&\n      isArray(customDateFormats) &&\n      isFunction(onError)\n    )\n  ) {\n    throw new TypeError(\n      `Invalid \\`options\\` parameter (second argument): \\`convertBooleans\\`, \\`convertDates\\`, \\`convertNumbers\\`, \\`loggingOnFail\\`, \\`removeEmptyArrays\\`, \\`removeEmptyObjects\\`, \\`removeNulls\\`, \\`removeUndefined\\`, \\`strictMode\\` expected to be a \\`boolean\\` type, \\`customDateFormats\\` expected to be a \\`array\\` type and \\`onError\\` expected to be a \\`void function\\` type. But received: ['convertBooleans': \\`${getPreciseType(\n        convertBooleans\n      )}\\`, 'convertDates': \\`${getPreciseType(\n        convertDates\n      )}\\`, 'convertNumbers': \\`${getPreciseType(\n        convertNumbers\n      )}\\`, 'loggingOnFail': \\`${getPreciseType(\n        loggingOnFail\n      )}\\`, 'removeEmptyArrays': \\`${getPreciseType(\n        removeEmptyArrays\n      )}\\`, 'removeEmptyObjects': \\`${getPreciseType(\n        removeEmptyObjects\n      )}\\`, 'removeNulls': \\`${getPreciseType(\n        removeNulls\n      )}\\`, 'removeUndefined': \\`${getPreciseType(\n        removeUndefined\n      )}\\`, 'strictMode': \\`${getPreciseType(\n        strictMode\n      )}\\`, 'customDateFormats': \\`${getPreciseType(\n        customDateFormats\n      )}\\`, 'onError': \\`${getPreciseType(onError)}\\`].`\n    );\n  }\n\n  return {\n    convertBooleans,\n    convertDates,\n    convertNumbers,\n    convertNaN,\n    loggingOnFail,\n    removeEmptyArrays,\n    removeEmptyObjects,\n    removeNulls,\n    removeUndefined,\n    strictMode,\n    customDateFormats,\n    onError,\n    checkSymbols\n  };\n};\n","import type { ParseParsedDataOptions } from \"./_private/types/ParseParsedDataOptions\";\n\nimport { isNull } from \"@/predicates/is/isNull\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\nimport { isEmptyArray } from \"@/predicates/is/isEmptyArray\";\nimport { isEmptyObject } from \"@/predicates/is/isEmptyObject\";\n\nimport { parseCustomDate } from \"./parseCustomDate\";\nimport { validateJsonParsingOptions } from \"./_private/utils/validateJsonParsingOptions\";\n\n/** --------------------------------------------------\n * * ***Utility: `cleanParsedData`.***\n * ---------------------------------------------\n * **Cleans parsed JSON data based on provided options.**\n * @template T - Expected output type.\n * @param {*} data - The parsed JSON data.\n * @param {ParseParsedDataOptions} [options] - The cleaning options.\n * @returns {T | null | undefined} The cleaned data.\n * - ***⚠️ Notice:*** _If data is JSON string, we recommend use ***`safeJsonParse` utility function*** for more safe._\n * - ***⚠️ Note:*** _If using **`convertDates`** **options**, result may contain Date objects, you may need type assertions in strict TypeScript settings._\n * @example\n * ```ts\n * // 1: Convert numbers and remove nulls\n * const result = cleanParsedData({ age: \"25\", name: null }, {\n *    convertNumbers: true,\n *    removeNulls: true\n * });\n * console.log(result); // ➔ { age: 25 }\n * // 2: Convert boolean strings\n * const result = cleanParsedData({ isActive: \"true\" }, {\n *    convertBooleans: true\n * });\n * console.log(result); // ➔ { isActive: true }\n * ```\n */\nexport const cleanParsedData = <T = unknown>(\n  data: T,\n  options: ParseParsedDataOptions = {}\n): T | undefined | null => {\n  const validOptions = validateJsonParsingOptions(options);\n\n  if (isNull(data)) return validOptions.removeNulls ? undefined : null;\n  if (isUndefined(data))\n    return validOptions.removeUndefined ? undefined : undefined;\n\n  if (isString(data)) {\n    const trimmed = data.trim();\n\n    if (validOptions.convertNaN && trimmed === \"NaN\") return NaN as T;\n\n    if (validOptions.convertNumbers && !isNaN(Number(trimmed))) {\n      return Number(trimmed) as T;\n    }\n\n    if (validOptions.convertBooleans) {\n      if (trimmed === \"true\") return true as T;\n      if (trimmed === \"false\") return false as T;\n    }\n\n    if (validOptions.convertDates) {\n      if (/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$/.test(trimmed)) {\n        return new Date(trimmed) as T;\n      }\n\n      if (validOptions.customDateFormats?.length) {\n        for (const format of validOptions.customDateFormats) {\n          const date = parseCustomDate(trimmed, format);\n          if (date) return date as T;\n        }\n      }\n    }\n\n    return validOptions.strictMode ? undefined : (trimmed as T);\n  }\n\n  if (isArray(data)) {\n    const cleanedArray = data\n      .map((item) => cleanParsedData(item, validOptions))\n      .filter((item) => !isUndefined(item));\n\n    return validOptions.removeEmptyArrays && isEmptyArray(cleanedArray)\n      ? undefined\n      : (cleanedArray as T);\n  }\n\n  if (isObject(data)) {\n    const cleanedObject: Record<string, unknown> = {};\n\n    for (const key in data) {\n      if (Object.prototype.hasOwnProperty.call(data, key)) {\n        const cleanedValue = cleanParsedData(data[key], validOptions);\n        if (!isUndefined(cleanedValue)) {\n          cleanedObject[key] = cleanedValue;\n        }\n      }\n    }\n\n    return validOptions.removeEmptyObjects &&\n      isEmptyObject(cleanedObject, { checkSymbols: validOptions.checkSymbols })\n      ? undefined\n      : (cleanedObject as T);\n  }\n\n  return validOptions.strictMode ? undefined : data;\n};\n","import { isNumber } from \"@/predicates/is/isNumber\";\nimport { isString } from \"@/predicates/is/isString\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `extractDigits`.***\n * ---------------------------------------------\n * **Extracts digits from a string or number input.**\n * - **Behavior:**\n *    - Converts the input to a string, trims whitespace, and removes any characters that are not digits (`0-9`).\n *    - Returns the cleaned numeric value as a `number`.\n *    - If the input is a `null`, `undefined`, results in no digits, or not a `string` (or empty-string) or `number`, it safely return `0`.\n * @param {*} [value]\n *    **The value to process.**\n *    - Accepts a string, number, `null`, or `undefined`.\n * @returns {number} The numeric value after extracting digits (returns `0` if input is invalid or contains no digits).\n * @example\n * extractDigits(12345);       // ➔ 12345\n * extractDigits(\"9A8B7C6X1\"); // ➔ 98761\n * extractDigits(\"123abc456\"); // ➔ 123456\n * extractDigits(\"$1,234.56\"); // ➔ 123456\n * extractDigits(NaN);         // ➔ 0\n * extractDigits(null);        // ➔ 0\n * extractDigits(undefined);   // ➔ 0\n * extractDigits(Infinity);    // ➔ 0\n * extractDigits(-Infinity);   // ➔ 0\n * extractDigits({});          // ➔ 0\n * extractDigits([]);          // ➔ 0\n * extractDigits(\"\");          // ➔ 0\n * extractDigits(\" \");         // ➔ 0\n * extractDigits(\"abc\");       // ➔ 0\n * extractDigits(\"   00a  \");  // ➔ 0\n */\nexport const extractDigits = (value: unknown): number => {\n  if (!isString(value) && !isNumber(value)) return 0;\n\n  const cleaned = String(value)\n    .trim()\n    .replace(/[^0-9]/g, \"\");\n\n  return Number(cleaned) || 0;\n};\n","/* eslint-disable quotes */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { safeJsonParse } from \"../../safeJsonParse\";\n\n/** * ***Util Helper for {@link safeJsonParse | `safeJsonParse`}.***\n *\n * @internal\n */\nexport function fixSingleQuotesEscapeBackslash(input: string): string {\n  const validEscapes = new Set([\"\\\\\", '\"', \"/\", \"b\", \"f\", \"n\", \"r\", \"t\", \"u\"]);\n\n  let output = \"\";\n  let inSingleQuote = false;\n  let inDoubleQuote = false;\n  let escapeNext = false;\n\n  for (let i = 0; i < input.length; i++) {\n    const c = input[i] || \"\";\n\n    if (escapeNext) {\n      if (inSingleQuote) {\n        if (c === \"'\") {\n          output += \"'\";\n        } else if (validEscapes.has(c)) {\n          if (c === \"\\\\\") {\n            output += \"\\\\\\\\\";\n          } else if (c === '\"') {\n            output += '\\\\\"';\n          } else {\n            output += \"\\\\\" + c;\n          }\n        } else {\n          output += \"\\\\\\\\\" + c;\n        }\n      } else if (inDoubleQuote) {\n        if (c === '\"') {\n          output += '\\\\\"';\n        } else if (validEscapes.has(c)) {\n          output += \"\\\\\" + c;\n        } else {\n          output += \"\\\\\\\\\" + c;\n        }\n      } else {\n        output += \"\\\\\" + c;\n      }\n      escapeNext = false;\n      continue;\n    }\n\n    if (c === \"\\\\\") {\n      escapeNext = true;\n      continue;\n    }\n\n    if (!inSingleQuote && !inDoubleQuote) {\n      if (c === \"'\") {\n        output += '\"';\n        inSingleQuote = true;\n        continue;\n      }\n      if (c === '\"') {\n        output += '\"';\n        inDoubleQuote = true;\n        continue;\n      }\n    } else if (inSingleQuote) {\n      if (c === \"'\") {\n        output += '\"';\n        inSingleQuote = false;\n        continue;\n      }\n    } else if (inDoubleQuote) {\n      if (c === '\"') {\n        output += '\"';\n        inDoubleQuote = false;\n        continue;\n      }\n    }\n\n    output += c;\n  }\n\n  return output;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { IsAny } from \"@rzl-zone/ts-types-plus\";\nimport type { ParseParsedDataOptions } from \"./_private/types/ParseParsedDataOptions\";\nimport type {\n  SafeJsonParseResult,\n  UnknownValue\n} from \"./_private/types/safeJsonParse\";\n\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isNull } from \"@/predicates/is/isNull\";\nimport { isError } from \"@/predicates/is/isError\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\nimport { cleanParsedData } from \"./cleanParsedData\";\nimport { extractDigits } from \"../numerics/extractDigits\";\nimport { validateJsonParsingOptions } from \"./_private/utils/validateJsonParsingOptions\";\nimport { fixSingleQuotesEscapeBackslash } from \"./_private/utils/fixSingleQuotesEscapeBackslash\";\n\n/** --------------------------------------------------\n * * ***Utility: `safeJsonParse`.***\n * ---------------------------------------------\n * **Safely parses JSON while handling errors and applying transformations.**\n * - **Supports generics** to ensure accurate return type inference.\n *    - Always provide both `<TData, TInput>` for best results.\n *    - ℹ️ ***Scroll down for full generic behavior explanation.***\n * - Automatically parses valid JSON strings into `objects`, `arrays`, `numbers`, etc.\n * - Supports data transformation via options (e.g., convert strings to `numbers`, `booleans`, or `dates`).\n * - **Returns:**\n *    1. `null` ➔ if input is explicitly `null`.\n *    2. `undefined` ➔ if input is `undefined`, not a `string`, or if parsing fails.\n *    3. Parsed and cleaned result (`TData`) ➔ if input is a valid JSON string.\n * - ⚠️ **JSON.stringify note**:\n *    - _If the input JSON string was created using `JSON.stringify()`, any properties with `undefined`\n *      values would have been automatically removed or converted to `null` depending on the serializer, example:_\n *      ```ts\n *      JSON.stringify({ a: undefined, b: 1 }); // ➔ '{\"b\":1}'\n *      JSON.parse('{\"a\": undefined, \"b\": 1}')  // ❌ invalid JSON\n *      ```\n *      _Therefore, if you see `undefined` in raw input, it will likely throw unless pre-cleaned or replaced with `null`._\n *\n *      ```ts\n *      safeJsonParse('{\"name\": \"John\", \"score\": undefined}');\n *      // result ➔ { name: \"John\", score: null } <- because `undefined` is not valid JSON, gets replaced to null.\n *      ```\n * - ℹ️ **Additionally:**\n *    - This function normalizes single quotes (`'`) to double quotes (`\"`) before parsing,\n *      so JSON strings using single quotes will be converted to valid JSON format, example:\n *      ```ts\n *      safeJsonParse(\"{'name': 'John', 'age': 30}\");\n *      // result ➔ { name: \"John\", age: 30 }\n *\n *      safeJsonParse(\"{'string\\\\'s': 'abc', \\\"quote's\\\": 'It\\\\'s awesome!', 'aNumber\\\\'s': 123, 'keyWith\\\\'Backslash\\\\'s': 'value\\\\'s'}\");\n *      // result ➔ { \"string's\": \"abc\", \"quote's\": \"It's awesome!\", \"aNumber's\": 123, \"keyWith'Backslash's\": \"value's\" }\n *      ```\n * @template TData - The expected output type after parsing and cleaning.\n * @template TInput - The input value type, used for advanced type inference and return typing.\n * @param {TInput} [value] - The JSON string or value to parse.\n * @param {ParseParsedDataOptions} [options] - Options to clean, convert types, enable strict mode,\n *   support custom date formats, enable logging, or handle errors via callback.\n * @returns {SafeJsonParseResult<TData, TInput>} Parsed and optionally cleaned result, or `null`/`undefined`.\n * @throws **{@link TypeError | `TypeError`}** if `options` is provided but not a valid object.\n * @example\n * 1. ***Basic parse with number & boolean conversion:***\n *  ```ts\n *    const result = safeJsonParse(30);\n *    // result ➔ undefined\n *    const result = safeJsonParse(30, {\n *      convertNumbers: true\n *    });\n *    // result ➔ 30\n *\n *    const result = safeJsonParse('{\"age\": \"30\", \"isActive\": \"true\"}', {\n *      convertNumbers: true,\n *      convertBooleans: true\n *    });\n *    // result ➔ { age: 30, isActive: true }\n *  ```\n * 2. ***Handling `undefined` in input string (manually written, not JSON.stringify):***\n *  ```ts\n *    const result = safeJsonParse('{\"score\": undefined}');\n *    // result ➔ { score: null } <- because `undefined` is not valid JSON, gets replaced\n *  ```\n *\n * 3. ***Handling `NaN` in input string (manually written, not JSON.stringify):***\n *  ```ts\n *    const value = NaN; // <- value is NaN or \"NaN\";\n *    const result = safeJsonParse(value);\n *    // result ➔ undefined <- will return as undefined, because options `convertNaN` is false (default),\n *    const result2 = safeJsonParse(value, { convertNaN: true });\n *    // result2 ➔ NaN <- will return as undefined because options `convertNaN` is false,\n *\n *    const result4 = safeJsonParse('{\"strNan\": \"NaN\", \"pureNan\": NaN}');\n *    // NaN will convert to string (NaN ➔ \"NaN\") because options `convertNaN` is false (default),\n *    // result4 ➔ { strNan: \"NaN\", pureNan: \"NaN\" }\n *\n *    const result3 = safeJsonParse('{\"strNan\": \"NaN\", \"pureNan\": NaN}', {\n *      convertNaN: true\n *    });\n *    // String \"NaN\" will convert to NaN (\"NaN\" ➔ NaN) because options `convertNaN` is true,\n *    // result3 ➔ { strNan: NaN, pureNan: NaN }\n *  ```\n *\n * 4. ***Strict mode (removes invalid values):***\n *  ```ts\n *    const result = safeJsonParse('{\"name\": \"   \", \"score\": \"99abc\"}', {\n *      convertNumbers: true,\n *      strictMode: true\n *    });\n *    // result ➔ {}\n *\n *    const result2 = safeJsonParse('{\"name\": \"   \", \"score\": undefined}');\n *    // result2 ➔ { name: \"\",score: null }\n *  ```\n *\n * 5. ***Custom date format parsing:***\n *  ```ts\n *    const result = safeJsonParse('{\"birthday\": \"25/12/2000\"}', {\n *      convertDates: true,\n *      customDateFormats: [\"DD/MM/YYYY\"]\n *    });\n *    // result ➔ { birthday: new Date(\"2000-12-25T00:00:00.000Z\") }\n *  ```\n *\n * 6. ***Invalid JSON with custom error handling:***\n *  ```ts\n *    safeJsonParse(\"{invalid}\", {\n *      loggingOnFail: true,\n *      onError: (err) => console.log(\"Custom handler:\", err.message)\n *    });\n *    // ➔ Logs parsing error and invokes handler\n *  ```\n *\n * 7. ***Null or non-string input returns null/undefined (default options):***\n *  ```ts\n *    safeJsonParse(123); // ➔ undefined\n *    safeJsonParse(null); // ➔ null\n *    safeJsonParse(undefined); // ➔ undefined\n *  ```\n *\n * 8. ***Generic usage: Provide both output and input type to ensure correct return typing:***\n *  ```ts\n *    type UserType = { name: string };\n *\n *    const obj = JSON.stringify({\n *      name: \"John\"\n *    });\n *\n *    const toParse = isAuth() ? obj : null;\n *    const toParse2 = isAuth() ? obj : undefined;\n *\n *    // * `Without Generic`:\n *      const parsed = safeJsonParse(toParse);\n *      //- runtime: { name: \"John\" } | undefined | null\n *      //- type: Record<string, unknown> | undefined | null\n *      const parsed2 = safeJsonParse(toParse);\n *      //- runtime: { name: \"John\" } | undefined\n *      //- type: Record<string, unknown> | undefined\n *\n *    // * `With Generic`:\n *      const parsed = safeJsonParse<UserType>(toParse);\n *      //- runtime: { name: \"John\" } | undefined | null\n *      //- type: undefined  <- (⚠️ unexpected!)\n *      const parsed2 = safeJsonParse<UserType>(toParse);\n *      //- runtime: { name: \"John\" } | undefined\n *      //- type: undefined  <- (⚠️ unexpected!)\n *      const parsed = safeJsonParse<UserType, typeof toParse>(toParse);\n *      //- runtime: { name: \"John\" } | null | undefined\n *      //- type: UserType | null | undefined\n *      const parsed2 = safeJsonParse<UserType, typeof toParse>(toParse);\n *      //- runtime: { name: \"John\" } | undefined\n *      //- type: UserType | undefined\n *  ```\n * @note\n * ⚠️ **Generic Behavior:**\n * - This function supports advanced generic inference for clean, type-safe return values.\n * - If only the first generic (`TData`) is provided and the second (`TInput`) is omitted,\n *   then `TInput` defaults to `undefined`, resulting in a return type of `undefined`.\n * - To ensure correct return typing, **always pass both generics** when `value` is dynamic,\n *   nullable, or unioned: `safeJsonParse<TData, typeof value>(value)`.\n * - This makes the returned type exactly match your expectation: `TData | null | undefined`.\n */\nexport function safeJsonParse<\n  TData extends Record<string, any> = Record<string, unknown>,\n  TInput extends UnknownValue = UnknownValue\n>(\n  value: TInput,\n  options?: ParseParsedDataOptions\n): IsAny<TInput> extends true ? TData | null | undefined : undefined;\nexport function safeJsonParse<\n  TData extends Record<string, any> = Record<string, unknown>,\n  TInput extends string | null | undefined | unknown = undefined\n>(\n  value: TInput,\n  options?: ParseParsedDataOptions\n): SafeJsonParseResult<TData, TInput>;\n//! implement main function\nexport function safeJsonParse<TData extends Record<string, unknown>>(\n  value: unknown,\n  options: ParseParsedDataOptions = {}\n) {\n  if (isNull(value)) return null;\n  const validOptions = validateJsonParsingOptions(options);\n\n  if (\n    validOptions.convertNaN &&\n    (isNaN(value) || (isNonEmptyString(value) && value === \"NaN\"))\n  ) {\n    return NaN;\n  }\n  if (\n    validOptions.convertNumbers &&\n    !isNaN(Number(value)) &&\n    isNumber(extractDigits(value))\n  ) {\n    return Number(value);\n  }\n\n  if (!isString(value)) return undefined;\n\n  try {\n    // First, normalize all single quotes to double quotes\n    let normalized = fixSingleQuotesEscapeBackslash(value);\n\n    if (validOptions.removeUndefined) {\n      normalized = normalized\n        .replace(/,\\s*\"[^\"]*\"\\s*:\\s*undefined(?=\\s*[},])/g, \"\")\n        // ➔ remove , \"key\": undefined\n        .replace(/\"[^\"]*\"\\s*:\\s*undefined\\s*(,)?/g, \"\");\n      // ➔ remove \"key\": undefined\n    } else {\n      normalized = normalized.replace(/:\\s*undefined(?=\\s*[,}])/g, \":null\");\n      // ➔ replace :undefined with :null\n    }\n\n    if (validOptions.convertNaN) {\n      // eslint-disable-next-line quotes\n      normalized = normalized.replace(/:\\s*NaN(?=\\s*[,}])/g, ':\"NaN\"');\n      // ➔ convert :NaN to :\"NaN\"\n    } else {\n      normalized = normalized\n        // eslint-disable-next-line quotes\n        .replace(/:\\s*NaN(?=\\s*[,}])/g, ':\"NaN\"')\n        // ➔ convert :NaN to :\"NaN\"\n        .replace(/,\\s*\"[^\"]*\"\\s*:\\s*NaN(?=\\s*[},])/g, \"\")\n        // ➔ remove , \"key\": NaN\n        .replace(/\"[^\"]*\"\\s*:\\s*NaN\\s*(,)?/g, \"\");\n      // ➔ remove \"key\": NaN\n    }\n\n    normalized = normalized.replace(/,(\\s*[}\\]])/g, \"$1\");\n    // ➔ remove trailing comma before } or ]\n\n    const parsed = JSON.parse(normalized);\n    return cleanParsedData<TData>(parsed, validOptions);\n  } catch (error) {\n    if (validOptions.loggingOnFail) {\n      console.error(\"Failed to parsing at `safeJsonParse`:\", error);\n    }\n\n    validOptions.onError(\n      isError(error)\n        ? new Error(error.message.replace(/^JSON\\.parse:/, \"Failed to parsing\"))\n        : new Error(String(error))\n    );\n\n    return undefined;\n  }\n}\n"],"mappings":"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"}