@rzl-zone/utils-js 3.12.1-beta.0 → 3.12.1-beta.1

package/dist/conversions-CBs8-REq.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"conversions-CBs8-REq.cjs","names":["hasOwnProp","isArray","isBigInt","isNull","filterNilArray","getPreciseType","safeStableStringify","isNaN","isString","isNumber","isBoolean","isBigInt","isNil","isNumberObject","isBooleanObject","isStringObject","isSymbol","isFunction","isArray","isObjectOrArray","isDate","isRegExp","isError","isSet","isMap","isObject","hasOwnProp","getPreciseType","safeStableStringify","isArray","isEqual","isSet","isMap","isNil","isString","isNonEmptyString","isBoolean","isNumber","isArray","isObject","isNonEmptyValue","isNil","isString","isNonEmptyString","isBoolean","isNumber","isArray","isObject","isNil","isPlainObject","hasOwnProp","isBoolean","getPreciseType","isString","isNumber","isNil","isString","isEmptyString","isBoolean","isNumber","isArray","isString","isNaN","isNonEmptyString","isFunction","isObjectOrArray","isArray","isEmptyArray","isPlainObject","isPlainObject","isEmptyObject","safeStableStringify","isPlainObject","isUndefined","isBoolean","getPreciseType","hasOwnProp","isNil","isRegExp","isBoolean","getPreciseType","isNumber","isNonEmptyString","isInfinityNumber","isNaN","isNumberObject","isStringObject","isBooleanObject","isDate","isBuffer","isUndefined","isEmptyArray","isTypedArray","isSet","isMap","isArray","isObject","isEmptyObject","hasOwnProp","isNil","isInfinityNumber","isBoolean","getPreciseType","isNumber","isString","isNumberObject","isNaN","isStringObject","isBooleanObject","isDate","isRegExp","isBuffer","isUndefined","isTypedArray","isEmptyArray","isSet","isMap","isArray","isObject"],"sources":["../src/conversions/arrays/casts/toNumberArrayUnRecursive.ts","../src/conversions/values/toStringDeepForce.ts","../src/conversions/arrays/transforms/dedupeArray.ts","../src/conversions/boolean/toBooleanContent.ts","../src/conversions/boolean/toBooleanContentDeep.ts","../src/conversions/boolean/toBooleanExplicit.ts","../src/conversions/boolean/toBooleanLoose.ts","../src/conversions/data-type/convert.ts","../src/conversions/object/_private/utils/deepCloneSafe.ts","../src/conversions/object/_private/utils/deleteNestedKey.ts","../src/conversions/object/_private/utils/deleteExactPathOnce.ts","../src/conversions/object/removeObjectPaths.ts","../src/conversions/values/toNumberDeep.ts","../src/conversions/values/toStringDeep.ts"],"sourcesContent":["import type {\n  NormalizeInputToNumberArrayUnRecursive,\n  ToNumberArrayUnRecursiveOptions,\n  ToNumberArrayUnRecursiveReturn\n} from \"./toNumberArrayUnRecursive.types\";\n\nimport { isNull } from \"@/predicates/is/isNull\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isBigInt } from \"@/predicates/is/isBigInt\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport { filterNilArray } from \"../transforms/filterNilArray\";\n\n/** -------------------------------------------------------\n * * ***Utility: `toNumberArrayUnRecursive`.***\n * -------------------------------------------------------\n * **Converts a flat array of strings, numbers, nulls, or undefineds into numbers.**\n * - **Behavior:**\n *    - Only supports **flat arrays** (non-recursive).\n *    - Valid inputs: `string`, `number`, `null`, `undefined`.\n *    - `BigInt` will be converted to `number`.\n *    - Other values ➔ coerced into `undefined`.\n *    - Invalid values can be **removed** (`removeInvalidValueNumber: true`) or **kept** (`false`).\n * - **ℹ️ Note:**\n *    - _For recursive / nested arrays, use ***`toNumberDeep` utility function*** instead._\n * @template T - Element type of the input array.\n * @template R - Whether invalid values should be removed (`true`) or kept (`false`).\n * @param {Array<T> | readonly T[] | null | undefined} [array] - The array to convert, returns `undefined` if not an array.\n * @param {ToNumberArrayUnRecursiveOptions<RemoveInvalidValue>} [options] - Options to control transformation behavior, defaults to `{ removeInvalidValueNumber: true }`.\n * @returns {ToNumberArrayUnRecursiveReturn<NormalizeInput<T>, RemoveInvalidValue>} A new array of string representations, with invalid values optionally removed.\n * @example\n * ```ts\n * toNumberArrayUnRecursive(['1', 2, '3']);\n * // ➔ [1, 2, 3]\n * toNumberArrayUnRecursive([1, null, undefined, 'abc']);\n * // ➔ [1]\n * toNumberArrayUnRecursive(['1', null, undefined, 'abc'], {\n *   removeInvalidValueNumber: false\n * });\n * // ➔ [1, null, undefined, undefined]\n * toNumberArrayUnRecursive(null);      // ➔ undefined\n * toNumberArrayUnRecursive(undefined); // ➔ undefined\n * toNumberArrayUnRecursive(1);         // ➔ undefined\n * ```\n */\nexport function toNumberArrayUnRecursive(\n  array?: null | undefined,\n  options?: ToNumberArrayUnRecursiveOptions<boolean>\n): undefined;\nexport function toNumberArrayUnRecursive(\n  array?: Array<never>,\n  options?: ToNumberArrayUnRecursiveOptions<boolean>\n): [];\nexport function toNumberArrayUnRecursive<T, R extends boolean = true>(\n  array?: Array<T> | readonly T[] | null,\n  options?: ToNumberArrayUnRecursiveOptions<R>\n): ToNumberArrayUnRecursiveReturn<NormalizeInputToNumberArrayUnRecursive<T>, R>;\nexport function toNumberArrayUnRecursive<T = unknown>(\n  array?: T,\n  options?: ToNumberArrayUnRecursiveOptions<boolean>\n): undefined;\nexport function toNumberArrayUnRecursive<T>(\n  array?: Array<T> | readonly T[] | null,\n  options: ToNumberArrayUnRecursiveOptions<boolean> = {}\n) {\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const riv = hasOwnProp(options, \"removeInvalidValueNumber\")\n    ? options.removeInvalidValueNumber\n    : true;\n\n  assertIsBoolean(riv, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`removeInvalidValueNumber\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  if (isArray(array)) {\n    const result = Array.from(array, (x) => {\n      if (isBigInt(x)) return Number(x);\n\n      const str = String(x).trim();\n      const match = str.match(/-?\\d+(\\.\\d+)?/);\n      // const match = str.match(/^-?\\d+(\\.\\d+)?$/); // ➔ full string match, stricter\n      return match ? Number(match[0]) : isNull(x) ? null : undefined;\n    });\n\n    return riv ? filterNilArray(result) : result;\n  }\n\n  return undefined;\n}\n","import { isMap } from \"@/predicates/is/isMap\";\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isDate } from \"@/predicates/is/isDate\";\nimport { isError } from \"@/predicates/is/isError\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isBigInt } from \"@/predicates/is/isBigInt\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isRegExp } from \"@/predicates/is/isRegExp\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isSymbol } from \"@/predicates/is/isSymbol\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isFunction } from \"@/predicates/is/isFunction\";\nimport { isNumberObject } from \"@/predicates/is/isNumberObject\";\nimport { isStringObject } from \"@/predicates/is/isStringObject\";\nimport { isBooleanObject } from \"@/predicates/is/isBooleanObject\";\nimport { isObjectOrArray } from \"@/predicates/is/isObjectOrArray\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { safeStableStringify } from \"../stringify/safeStableStringify\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `toStringDeepForce`.***\n * ---------------------------------------------\n * **Recursively converts a value into a string based on the `forceToString` options.**\n * - **Rules `forceToString` options:**\n *    - `\"stringOrNumber\"`: Converts strings and numbers to strings.\n *    - `\"primitives\"`: Converts all primitives (number, string, boolean, bigint, undefined, null, NaN) to strings.\n *    - `\"all\"`: Converts everything, including symbols, functions, Dates, RegExp, Maps, Sets, Errors, Promises,\n *       boxed primitives box (new Number, new String, new Boolean), and deeply all object properties, to strings.\n *    - `false`: Leaves everything unchanged.\n * - **Special behaviors:**\n *    - `NaN` ➔ `\"NaN\"` only in `\"primitives\"` or `\"all\"` mode.\n *    - `Date` ➔ ISO string only in `\"all\"` mode.\n *    -  ***Primitives Boxed*** (`new Number`, `new String`, `new Boolean`):\n *       - For `new String` we convert everything to string (behavior JS of new String):\n *         - `new String(\"hi\")` ➔ `.valueOf()` ➔ `\"hi\"`.\n *         - `new String(true)` ➔ `.valueOf()` ➔ `\"true\"`.\n *       - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to string:\n *         - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `true.toString()` ➔ `\"true\"`.\n *         - Special behavior JS of new Boolean, return `false` **(convert to string: `\"false\"`)**\n *           for `false`, (`0` / `-0`), `\"\"` (empty-string), `null`, `undefined`, `NaN`, otherwise\n *           `true` **(convert to string: `\"true\"`)**.\n *       - For `new Number`:\n *         - `new Number(42)` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `\"42\"`.\n *         - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ➔ `NaN.toString()` ➔ `\"NaN\"`.\n *         - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number) ➔ `0.toString()` ➔ `\"0\"`.\n *         - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ➔ `NaN.toString()` ➔ `\"NaN\"`.\n *         - `new Number(Infinity)` ➔ `Infinity` ➔ `Infinity` ➔ `Infinity.toString()` ➔ `\"Infinity\"`.\n *         - `new Number(-Infinity)` ➔ `-Infinity` ➔ `-Infinity` ➔ `-Infinity.toString()` ➔ `\"-Infinity\"`.\n *    - `RegExp` ➔ Source string (e.g. `/abc/i`) only in `\"all\"` mode.\n *    - `Symbol` ➔ `Symbol(description)` string only in `\"all\"` mode.\n *    - `Map` ➔ Array of [key, value] pairs with keys/values stringified deeply (only in `\"all\"` mode).\n *    - `Set` ➔ Array of values stringified deeply (only in `\"all\"` mode).\n *    - `Function` ➔ Source code string (e.g. `\"() => 1\"`) only in `\"all\"` mode.\n *    - `Error`, `Promise` ➔ Stringified via `.toString()` only in `\"all\"` mode.\n * @param {*} value\n * * ***The value to process.***\n *    - ***Can be anything:***\n *        - `primitive`.\n *        - `array`.\n *        - `object`.\n *        - `function`.\n *        - `etc`.\n * @param {false | \"stringOrNumber\" | \"primitives\" | \"all\"} forceToString - ***The mode of string conversion.***\n * @returns {unknown} A new value with the conversion applied based on `forceToString`.\n * @example\n * toStringDeepForce(42, \"stringOrNumber\");\n * // ➔ \"42\"\n * toStringDeepForce(true, \"primitives\");\n * // ➔ \"true\"\n * toStringDeepForce(null, \"primitives\");\n * // ➔ \"null\"\n * toStringDeepForce(Symbol(\"x\"), \"all\");\n * // ➔ \"Symbol(x)\"\n * toStringDeepForce(new String(\"hi\"), \"all\");\n * // ➔ \"hi\"\n * toStringDeepForce(new Number(42), \"all\");\n * // ➔ \"42\"\n * toStringDeepForce(new Boolean(true), \"all\");\n * // ➔ \"true\"\n * toStringDeepForce({ a: 1, b: [2, NaN] }, \"primitives\");\n * // ➔ { a: \"1\", b: [\"2\", \"NaN\"] }\n * toStringDeepForce(new Date(\"2025-01-01\"), \"all\");\n * // ➔ \"2025-01-01T00:00:00.000Z\"\n * toStringDeepForce(() => 1, \"all\");\n * // ➔ \"() => 1\"\n * toStringDeepForce(/abc/i, \"all\");\n * // ➔ \"/abc/i\"\n * toStringDeepForce(new Map([[\"a\", 1], [\"b\", 2]]), \"all\");\n * // ➔ [[\"a\", \"1\"], [\"b\", \"2\"]]\n * toStringDeepForce(new Set([1, 2, 3]), \"all\");\n * // ➔ [\"1\", \"2\", \"3\"]\n * toStringDeepForce(new Error(\"Oops\"), \"all\");\n * // ➔ \"Error: Oops\"\n * toStringDeepForce(Promise.resolve(1), \"all\");\n * // ➔ \"[object Promise]\"\n * toStringDeepForce({ func: () => 123 }, \"all\");\n * // ➔ { func: \"() => 123\" }\n * toStringDeepForce([1, \"a\", { b: 2 }], false);\n * // ➔ [1, \"a\", { b: 2 }]\n */\nexport function toStringDeepForce<T>(\n  value: unknown,\n  forceToString: false | \"stringOrNumber\" | \"primitives\" | \"all\"\n): T;\nexport function toStringDeepForce(\n  value: unknown,\n  forceToString: false | \"stringOrNumber\" | \"primitives\" | \"all\"\n) {\n  if (\n    !(\n      forceToString === false ||\n      forceToString === \"stringOrNumber\" ||\n      forceToString === \"primitives\" ||\n      forceToString === \"all\"\n    )\n  ) {\n    throw new TypeError(\n      `Second parameter \\`forceToString\\` must be of type \\`false\\` or \\`string\\` with value one of \"stringOrNumber\" | \"primitives\" | \"all\", but received: \\`${getPreciseType(\n        forceToString\n      )}\\`, with value: \\`${safeStableStringify(forceToString, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  // NaN special\n  if (isNaN(value)) {\n    return forceToString === \"primitives\" || forceToString === \"all\"\n      ? \"NaN\"\n      : NaN;\n  }\n\n  // string or number\n  if (isString(value) || isNumber(value)) {\n    return forceToString === \"stringOrNumber\" ||\n      forceToString === \"primitives\" ||\n      forceToString === \"all\"\n      ? String(value)\n      : value;\n  }\n\n  // other primitives\n  if (isBoolean(value) || isBigInt(value) || isNil(value)) {\n    return forceToString === \"primitives\" || forceToString === \"all\"\n      ? String(value)\n      : value;\n  }\n\n  // boxed primitives box (new Number, new String, new Boolean)\n  if (\n    isNumberObject(value) ||\n    isBooleanObject(value) ||\n    isStringObject(value)\n  ) {\n    return forceToString === \"all\" ? value.valueOf().toString() : value;\n  }\n\n  // symbol\n  if (isSymbol(value)) {\n    return forceToString === \"all\" ? value.toString() : value;\n  }\n\n  // function: only convert on \"all\"\n  if (isFunction(value)) {\n    return forceToString === \"all\" ? value.toString() : value;\n  }\n\n  // array\n  if (isArray(value)) {\n    return value.map((v) => toStringDeepForce(v, forceToString));\n  }\n\n  // objects\n  if (isObjectOrArray(value)) {\n    if (isDate(value)) {\n      return forceToString === \"all\" ? value.toISOString() : value;\n    }\n    if (isRegExp(value)) {\n      return forceToString === \"all\" ? value.toString() : value;\n    }\n    if (isError(value) || value instanceof Promise) {\n      return forceToString === \"all\" ? value.toString() : value;\n    }\n\n    if (isSet(value)) {\n      return forceToString === \"all\"\n        ? [...value].map((v) => toStringDeepForce(v, forceToString))\n        : value;\n    }\n\n    if (isMap(value)) {\n      return forceToString === \"all\"\n        ? [...value.entries()].map(([k, v]) => [\n            toStringDeepForce(k, forceToString),\n            toStringDeepForce(v, forceToString)\n          ])\n        : value;\n    }\n\n    const result: Record<string, unknown> = {};\n    if (isObject(value)) {\n      for (const key of Object.keys(value)) {\n        result[key] = toStringDeepForce(value[key], forceToString);\n      }\n    }\n    return result;\n  }\n\n  return value;\n}\n","import type {\n  DedupeArrayOptions,\n  DedupeResult,\n  ForceToStringOptions\n} from \"./_private/dedupeArray.types\";\n\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isMap } from \"@/predicates/is/isMap\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isEqual } from \"@/predicates/is/isEqual\";\n\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\nimport { assertIsArray } from \"@/assertions/objects/assertIsArray\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport { toStringDeepForce } from \"@/conversions/values/toStringDeepForce\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `dedupeArray`.***\n * ---------------------------------------------\n * **Deduplicates values in an array (with optional flattening and deep stringification).**\n * - Supports various modes for converting values to strings before deduplication:\n *    - `\"stringOrNumber\"`: Converts strings and numbers to strings.\n *    - `\"primitives\"`: Converts all primitives (string, number, boolean, bigint, null, undefined, NaN) to strings.\n *    - `\"all\"`: Converts all values (primitives, objects, Maps, Sets, Symbols, RegExp, Dates, Errors, Promises, functions)\n *   to strings, including nested object properties.\n *    - `false` (default): No conversion applied.\n * - Options:\n *    - `forceToString`: Enables string conversion for comparison, default is `false`.\n *    - `flatten`: If true, deeply flattens arrays, Maps, and Sets before deduplication, default is `false`.\n * @template ForceToString - `forceToString` mode.\n * @template Flattening - `flatten` mode.\n * @param {unknown[]} inputArray - The array to deduplicate, can be deeply nested and contain any mix of types.\n * @param {DedupeArrayOptions<ForceToString, Flattening>|undefined} [options] - Options to control string conversion.\n * @returns {DedupeResult<ForceToString, Flattening>} Deduplicated array with optional transformations.\n * @throws **{@link TypeError | `TypeError`}** if the input is not an array, or options is not an object, or if `forceToString` is invalid.\n * @example\n * ```ts\n * dedupeArray([\"apple\", \"banana\", \"apple\"]);\n * // ➔ [\"apple\", \"banana\"]\n * dedupeArray([[1, 2], [1, 2]], { flatten: true });\n * // ➔ [1, 2]\n * dedupeArray([new Set([1, 2]), new Set([2, 3])], { flatten: true });\n * // ➔ [1, 2, 3]\n * dedupeArray([1, \"1\", 2, \"2\"], {\n *    forceToString: \"stringOrNumber\"\n * }); // ➔ [\"1\", \"2\"]\n * dedupeArray([true, \"true\", false, undefined], {\n *    forceToString: \"primitives\"\n * }); // ➔ [\"true\", \"false\", \"undefined\"]\n * dedupeArray([1, \"1\", { a: 1 }], {\n *    forceToString: \"all\"\n * }); // ➔ [\"1\", { a: \"1\" }]\n * dedupeArray([1, 1, [2, 2, [3, 3]]]);\n * // ➔ [1, [2, [3]]]\n * dedupeArray([null, undefined, null]);\n * // ➔ [null, undefined]\n * dedupeArray([[], [[]], [[[]]], [[]], [[[]]]]);\n * // ➔ [[], [[]], [[[]]]]\n * const fn = () => 1;\n * dedupeArray([fn, fn, () => 1]);\n * // ➔ [fn, () => 1] cause: ref () => 1 and fn is different but ref const `fn` and `fn` is same ref.\n * dedupeArray([Symbol(\"x\"), Symbol(\"x\")]);\n * // ➔ [Symbol(\"x\")] (symbols are same by identity, so dedupe\n * dedupeArray([NaN, NaN, 1, \"1\"]);\n * // ➔ [NaN, 1, \"1\"]\n * dedupeArray([NaN, NaN, 1, \"1\"], {\n *    forceToString: \"primitives\"\n * }); // ➔ [\"NaN\", \"1\"]\n * dedupeArray([new Date(\"2025-01-01\"), new Date(\"2025-01-01\")]);\n * // ➔ [Date(\"2025-01-01\")] (same time, deduped)\n * dedupeArray([new Date(\"2025-01-01\"), new Date(\"2025-01-01\")], {\n *    forceToString: \"all\"\n * }); // ➔ [\"2025-01-01T00:00:00.000Z\"]\n * dedupeArray([/abc/, /abc/], {\n *    forceToString: \"all\"\n * }); // ➔ [\"/abc/\"]\n * dedupeArray([new Map(), new Set(), new Error(\"err\")], {\n *    forceToString: \"all\"\n * }); // ➔ [\"[object Map]\", \"[object Set]\", \"Error: err\"]\n * dedupeArray([Promise.resolve(1), Promise.resolve(1)], {\n *    forceToString: \"all\"\n * }); // ➔ [\"[object Promise]\"]\n * dedupeArray([{ a: 1 }, { a: 1 }, { a: 2 }], {\n *    forceToString: \"primitives\"\n * }); // ➔ [{ a: \"1\" }, { a: \"2\" }]\n * dedupeArray([{ a: { b: 1 } }, { a: { b: 1 } }], {\n *    forceToString: \"all\"\n * }); // ➔ [{ a: { b: \"1\" } }]\n * dedupeArray(\"not an array\");\n * // ➔ Throws TypeError\n * dedupeArray([1, 2, 3], {\n *    forceToString: \"invalid\"\n * }); // ➔ Throws TypeError\n * ```\n */\nexport const dedupeArray = <\n  ForceToString extends ForceToStringOptions = false,\n  Flattening extends boolean = false\n>(\n  inputArray: unknown[],\n  options: DedupeArrayOptions<ForceToString, Flattening> = {}\n): DedupeResult<ForceToString, Flattening> => {\n  assertIsArray(inputArray, {\n    message: ({ currentType, validType }) =>\n      `First parameter (\\`inputArray\\`) must be of type \\`${validType}\\` (array literal or instance), but received: \\`${currentType}\\`.`\n  });\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const flatten = hasOwnProp(options, \"flatten\") ? options.flatten : false;\n  const forceToString = hasOwnProp(options, \"forceToString\")\n    ? options.forceToString\n    : false;\n\n  if (\n    !(\n      forceToString === false ||\n      forceToString === \"stringOrNumber\" ||\n      forceToString === \"primitives\" ||\n      forceToString === \"all\"\n    )\n  ) {\n    throw new TypeError(\n      `Parameter \\`forceToString\\` property of the \\`options\\` (second parameter) must be of type \\`false\\` or \\`string\\` with value one of \"stringOrNumber\" | \"primitives\" | \"all\", but received: \\`${getPreciseType(\n        forceToString\n      )}\\`, with value: \\`${safeStableStringify(forceToString, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  assertIsBoolean(flatten, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`flatten\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const process = (arr: unknown[]): unknown[] => {\n    const seen: unknown[] = [];\n    return arr.reduce<unknown[]>((acc, item) => {\n      const value = isArray(item)\n        ? process(item)\n        : toStringDeepForce(item, forceToString);\n\n      if (!seen.some((s) => isEqual(s, value))) {\n        seen.push(value);\n        acc.push(value);\n      }\n      return acc;\n    }, []);\n  };\n\n  const deepFlatten = (value: unknown): unknown[] => {\n    if (isArray(value)) {\n      return value.flatMap(deepFlatten);\n    }\n\n    if (isSet(value)) {\n      return [...value].flatMap(deepFlatten);\n    }\n\n    if (isMap(value)) {\n      return [...value.values()].flatMap(deepFlatten);\n    }\n\n    return [value];\n  };\n\n  return (\n    flatten ? process(deepFlatten(inputArray)) : process(inputArray)\n  ) as DedupeResult<ForceToString, Flattening>;\n};\n","import { isNil } from \"@/predicates/is/isNil\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isNonEmptyValue } from \"@/predicates/is/isNonEmptyValue\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** ---------------------------------\n * * ***Utility: `toBooleanContent`.***\n * ---------------------------------------------\n * **Converts a given value into a boolean (***strict***).**\n * - **This is stricter than normal JS coercion:**\n *    - `null` and `undefined` return `false`.\n *    - Empty strings return `false`, non-empty strings return `true`.\n *    - Numbers: `0` is `false`, others `true`.\n *    - Booleans returned as-is.\n *    - Arrays: `[]` is `false`, non-empty is `true`.\n *    - Objects: `{}` is `false`, object with keys is `true`.\n * @param {*} value - The value to be converted.\n * @returns {boolean} Return `true` if the value is considered non-empty, otherwise `false`.\n * @example\n * toBooleanContent(null);      // ➔ false\n * toBooleanContent(undefined); // ➔ false\n * toBooleanContent(\"\");        // ➔ false\n * toBooleanContent(\"  \");      // ➔ false\n * toBooleanContent(\"abc\");     // ➔ true\n * toBooleanContent(\" asd \");   // ➔ true\n * toBooleanContent(0);         // ➔ false\n * toBooleanContent(42);        // ➔ true\n * toBooleanContent(NaN);       // ➔ true\n * toBooleanContent([]);        // ➔ false\n * toBooleanContent([1]);       // ➔ true\n * toBooleanContent({});        // ➔ false\n * toBooleanContent({ a: 1 });  // ➔ true\n * toBooleanContent({[Symbol(\"key\")]: 123}); // ➔ false\n */\nexport const toBooleanContent = (value: unknown): boolean => {\n  if (isNil(value)) return false;\n  if (isString(value)) return isNonEmptyString(value);\n  if (isBoolean(value)) return value;\n  if (isNumber(value, { includeNaN: true })) return value !== 0;\n  if (isArray(value) || isObject(value)) return isNonEmptyValue(value);\n  return Boolean(value);\n};\n","import { isNil } from \"@/predicates/is/isNil\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** -------------------------------------------------\n * * ***Utility: `toBooleanContentDeep`.***\n * ---------------------------------------------\n * **This function does a deep inspection to determine if the input\n * contains any meaningful / non-empty value.**\n * @description\n * It is stricter than JavaScript's normal truthy checks because it looks *inside*\n * nested arrays & objects (recursively checks).\n * - **Rules:**\n *    - `null` and `undefined` return `false`\n *    - Empty strings `\"\"` return `false`\n *    - `0` returns `false`\n *    - Empty arrays `[]` or empty objects `{}` return `false`\n *    - Checks deeply nested arrays/objects — if any value inside is \"non-empty\", returns `true`\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if the value or anything nested inside is non-empty, otherwise `false`.\n * @example\n * toBooleanContentDeep(null);          // ➔ false\n * toBooleanContentDeep(\"\");            // ➔ false\n * toBooleanContentDeep(0);             // ➔ false\n * toBooleanContentDeep([]);            // ➔ false\n * toBooleanContentDeep({});            // ➔ false\n * toBooleanContentDeep([[], {}]);      // ➔ false\n * toBooleanContentDeep(\"abc\");         // ➔ true\n * toBooleanContentDeep(42);            // ➔ true\n * toBooleanContentDeep(NaN);           // ➔ true\n * toBooleanContentDeep([0, \"\", 5]);    // ➔ true\n * toBooleanContentDeep([NaN, \"\", 0]);  // ➔ true\n * toBooleanContentDeep([0, \"\", null]); // ➔ false\n * toBooleanContentDeep({ a: 0 });      // ➔ false\n * toBooleanContentDeep({ a: 1 });      // ➔ true\n * toBooleanContentDeep({ a: { b: [] }});  // ➔ false\n * toBooleanContentDeep({ a: { b: \"x\" }}); // ➔ true\n * toBooleanContentDeep({[Symbol(\"key\")]: 123}); // ➔false\n */\nexport const toBooleanContentDeep = (value: unknown): boolean => {\n  if (isNil(value)) return false;\n  if (isString(value)) return isNonEmptyString(value);\n  if (isBoolean(value)) return value;\n  if (isNumber(value, { includeNaN: true })) return value !== 0;\n  if (isArray(value)) return value.some(toBooleanContentDeep);\n  if (isObject(value)) return Object.values(value).some(toBooleanContentDeep);\n\n  return false;\n};\n","import { isNil } from \"@/predicates/is/isNil\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\n\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\ntype ToBooleanExplicitOptions = {\n  /** Whether string comparison ignores case, _defaultValue: `false`_.\n   *\n   * @default false\n   */\n  caseInsensitive?: boolean;\n  /** Whether to trim whitespace before comparison, _defaultValue: `true`_.\n   *\n   * @default true\n   */\n  trimString?: boolean;\n  /** Whether to consider the string `\"indeterminate\"` as `true`, _defaultValue: `false`_.\n   *\n   * @default false\n   */\n  includeIndeterminate?: boolean;\n};\n\n/** ---------------------------------\n * * ***Utility: `toBooleanExplicit`.***\n * ---------------------------------------------\n * **Converts a value into a strict boolean.**\n * - **Behavior:**\n *    - It supports various common string representations of truthy values,\n *      including `\"true\"`, `\"on\"`, `\"yes\"`, `\"1\"`, the number `1`, the boolean `true`,\n *      and optionally the string `\"indeterminate\"` if enabled.\n * - **ℹ️ Note:**\n *    - Any other value, including `undefined`, `null`, `false`, `0`, and\n *      unrecognized strings will return `false`.\n *    - Supports optional `caseInsensitive` and `trimString` to customize\n *      string normalization.\n * @param {*} value - The value to convert.\n * @param {ToBooleanExplicitOptions} [options] - Options for conversion behavior.\n * @param {ToBooleanExplicitOptions[\"caseInsensitive\"]} [options.caseInsensitive=false] - Whether string comparison ignores case, default: `false`.\n * @param {ToBooleanExplicitOptions[\"trimString\"]} [options.trimString=true] - Whether to trim whitespace before comparison, default: `true`.\n * @param {ToBooleanExplicitOptions[\"includeIndeterminate\"]} [options.includeIndeterminate=false] - If `true`, the string `\"indeterminate\"` is considered a truthy value, defaults to `false`.\n * @returns {boolean} Return `true` if the value matches a truthy representation, otherwise `false`.\n * @throws **{@link TypeError | `TypeError`}** if any option provided is not a boolean.\n * @example\n * toBooleanExplicit(1);\n * // ➔ true\n * toBooleanExplicit(true);\n * // ➔ true\n * toBooleanExplicit(\"on\");\n * // ➔ true\n * toBooleanExplicit(\"1\");\n * // ➔ true\n * toBooleanExplicit(0);\n * // ➔ false\n * toBooleanExplicit(\"off\");\n * // ➔ false\n * toBooleanExplicit(\"Yes\");\n * // ➔ false (caseInsensitive is false by default)\n * toBooleanExplicit(\" yes \");\n * // ➔ true (whitespace trimmed by default)\n * toBooleanExplicit(\"YES\", { caseInsensitive: true });\n * // ➔ true\n * toBooleanExplicit(\"YES\", { caseInsensitive: false });\n * // ➔ false\n * toBooleanExplicit(\" YES \", { trimString: false });\n * // ➔ false (whitespace not trimmed)\n * toBooleanExplicit(\" YES \", { trimString: true, caseInsensitive: true });\n * // ➔ true\n * toBooleanExplicit(\" YES \", { trimString: true, caseInsensitive: false });\n * // ➔ false\n * toBooleanExplicit(\"indeterminate\");\n * // ➔ false (default)\n * toBooleanExplicit(\"indeterminate\", { includeIndeterminate: true });\n * // ➔ true\n */\nexport const toBooleanExplicit = (\n  value: unknown,\n  options: ToBooleanExplicitOptions = {}\n): boolean => {\n  if (isNil(value)) return false;\n\n  if (!isPlainObject(options)) options = {};\n\n  const ci = hasOwnProp(options, \"caseInsensitive\")\n    ? options.caseInsensitive\n    : false;\n  const ts = hasOwnProp(options, \"trimString\") ? options.trimString : true;\n  const incInd = hasOwnProp(options, \"includeIndeterminate\")\n    ? options.includeIndeterminate\n    : false;\n\n  if (!isBoolean(ci) || !isBoolean(ts) || !isBoolean(incInd)) {\n    throw new TypeError(\n      `Parameters \\`caseInsensitive\\`, \\`trimString\\` and \\`includeIndeterminate\\` property of the \\`options\\` (second parameter) expected to be a \\`boolean\\` type, but received: ['caseInsensitive': \\`${getPreciseType(\n        ci\n      )}\\`, 'trimString': \\`${getPreciseType(\n        ts\n      )}\\`, 'includeIndeterminate': \\`${getPreciseType(incInd)}\\`].`\n    );\n  }\n\n  if (isString(value)) {\n    let normalized = value;\n    if (ts) normalized = normalized.trim();\n    if (ci) normalized = normalized.toLowerCase();\n\n    const validTrueStrings = [\"true\", \"on\", \"yes\", \"1\"];\n    if (incInd) validTrueStrings.push(\"indeterminate\");\n\n    return validTrueStrings.includes(normalized);\n  }\n\n  if (isNumber(value)) return value === 1;\n  if (isBoolean(value)) return value;\n\n  return false;\n};\n","import { isNil } from \"@/predicates/is/isNil\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isEmptyString } from \"@/predicates/is/isEmptyString\";\n\n/** ---------------------------------\n * * ***Utility: `toBooleanLoose`.***\n * ---------------------------------------------\n * **Converts a given value into a boolean (loose).**\n * - **This follows JavaScript's typical truthy/falsy rules with some tweaks:**\n *    - `null` and `undefined` return `false`.\n *    - Empty strings return `false`, non-empty strings return `true`.\n *    - Numbers: `0` is `false`, others `true`.\n *    - Booleans returned as-is.\n *    - Arrays: `[]` is `false`, non-empty is `true`.\n *    - Other objects: uses `Boolean(value)`, so `{}` is `true`.\n * @param {*} value - The value to be converted.\n * @returns {boolean} Return `true` if the value is truthy, otherwise `false`.\n * @example\n * toBooleanLoose(null);     // ➔ false\n * toBooleanLoose(\"\");       // ➔ false\n * toBooleanLoose(\"abc\");    // ➔ true\n * toBooleanLoose(0);        // ➔ false\n * toBooleanLoose(42);       // ➔ true\n * toBooleanLoose([]);       // ➔ false\n * toBooleanLoose([1]);      // ➔ true\n * toBooleanLoose({});       // ➔ true\n * toBooleanLoose({ a: 1 }); // ➔ true\n */\nexport const toBooleanLoose = (value: unknown): boolean => {\n  if (isNil(value)) return false;\n  if (isString(value)) return !isEmptyString(value);\n  if (isBoolean(value)) return value;\n  if (isNumber(value, { includeNaN: true })) return value !== 0;\n  if (isArray(value)) return value.length > 0;\n  return Boolean(value);\n};\n","import { isNaN } from \"@/predicates/is/isNaN\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `convertType`.***\n * ---------------------------------------------\n * **Converts a value from a string to its corresponding JavaScript primitive type.**\n * - **Supported conversions for string inputs (case-insensitive, trimmed):**\n *    - `\"true\"`           ➔ `true` (***boolean***).\n *    - `\"false\"`          ➔ `false` (***boolean***).\n *    - `\"null\"`           ➔ `null` (***null***).\n *    - `\"yes\"`            ➔ `true` (***boolean***).\n *    - `\"no\"`             ➔ `false` (***boolean***).\n *    - `\"nan\"` or `\"NaN\"` ➔ `NaN` (***number***).\n *    - `\"undefined\"`      ➔ `undefined` (***undefined***).\n * - Numeric strings with optional thousands separators (e.g. `\"3,567,890.14\"`) ➔ `3567890.14` ***as a `number` type***.\n * - Strings containing only whitespace are converted to empty string `\"\"`.\n * - Non-string inputs are returned unchanged.\n * - Strings not matching any special case are trimmed and returned as-is.\n * @param {*} value - The value to convert, usually a string or other type.\n * @returns {*} The converted JavaScript primitive (***`boolean`***, ***`number`***, ***`null`***, ***`undefined`***, ***`NaN`***) or the original value if no conversion applies.\n * @example\n * convertType(\"true\");          // ➔ true\n * convertType(\" 42 \");          // ➔ 42\n * convertType(\"FALSE\");         // ➔ false\n * convertType(\" null \");        // ➔ null\n * convertType(\"   \");           // ➔ \"\"\n * convertType(\" Hello World \"); // ➔ \"Hello World\"\n * convertType(\"NaN\");           // ➔ NaN\n * convertType(100);             // ➔ 100\n * convertType(NaN);             // ➔ NaN\n * convertType({});              // ➔ {}\n */\nexport const convertType = (value: unknown): unknown => {\n  const predefinedValues: Record<string, unknown> = {\n    undefined: undefined,\n    null: null,\n    nan: NaN,\n    true: true,\n    false: false,\n    yes: true,\n    no: false\n  };\n\n  if (isString(value)) {\n    const normalized = value.trim().toLowerCase();\n\n    if (Object.prototype.hasOwnProperty.call(predefinedValues, normalized)) {\n      return predefinedValues[normalized];\n    }\n\n    // Support numbers with thousand separators\n    const numericString = normalized.replace(/,/g, \"\");\n\n    const numberString = Number(numericString);\n    if (!isNaN(numberString) && isNonEmptyString(numericString)) {\n      return numberString;\n    }\n\n    return value.trim();\n  }\n\n  return value;\n};\n","import { isFunction } from \"@/predicates/is/isFunction\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { removeObjectPaths } from \"../../removeObjectPaths\";\n\n/** @private ***Util helper for {@link removeObjectPaths | `removeObjectPaths`}.*** */\nexport const deepCloneSafe = <U>(obj: U): U => {\n  try {\n    if (isFunction(structuredClone)) {\n      return structuredClone(obj);\n    }\n    // eslint-disable-next-line no-empty\n  } catch {}\n  return JSON.parse(JSON.stringify(obj));\n};\n","import { isArray } from \"@/predicates/is/isArray\";\nimport { isEmptyArray } from \"@/predicates/is/isEmptyArray\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { isObjectOrArray } from \"@/predicates/is/isObjectOrArray\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { removeObjectPaths } from \"../../removeObjectPaths\";\n\n/** @private ***Util helper for {@link removeObjectPaths | `removeObjectPaths`}.*** */\nexport const deleteNestedKey = <T extends Record<string, unknown> | unknown[]>(\n  obj: T,\n  path: string[]\n): T => {\n  if (!isObjectOrArray(obj)) return obj;\n\n  const [currentKey, ...rest] = path;\n\n  if (isArray(obj)) {\n    for (const item of obj) {\n      // recursive pass same path\n      if (isObjectOrArray(item)) deleteNestedKey(item, path);\n    }\n  } else if (isEmptyArray(rest)) {\n    if (isPlainObject(obj)) delete obj[currentKey];\n  } else if (isPlainObject(obj) && isObjectOrArray(obj[currentKey])) {\n    deleteNestedKey(obj[currentKey], rest);\n  }\n\n  return obj;\n};\n","import { isPlainObject } from \"@/predicates/is/isPlainObject\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { removeObjectPaths } from \"../../removeObjectPaths\";\n\n/** @private ***Util helper for {@link removeObjectPaths | `removeObjectPaths`}.*** */\nexport const deleteExactPathOnce = <T extends Record<string, unknown>>(\n  obj: T,\n  path: string[]\n): T => {\n  if (!isPlainObject(obj)) return obj;\n\n  const [currentKey, ...rest] = path;\n\n  if (rest.length === 0) {\n    if (isPlainObject(obj)) delete obj[currentKey];\n  } else if (isPlainObject(obj[currentKey])) {\n    deleteExactPathOnce(obj[currentKey], rest);\n  }\n\n  return obj;\n};\n","import type {\n  ConfigRemoveObjectPaths,\n  ResultRemoveObjectPaths\n} from \"./_private/removeObjectPaths.types\";\n\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\nimport { isEmptyObject } from \"@/predicates/is/isEmptyObject\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\nimport { assertIsArray } from \"@/assertions/objects/assertIsArray\";\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\n\nimport { deepCloneSafe } from \"./_private/utils/deepCloneSafe\";\nimport { deleteNestedKey } from \"./_private/utils/deleteNestedKey\";\nimport { safeStableStringify } from \"../stringify/safeStableStringify\";\nimport { deleteExactPathOnce } from \"./_private/utils/deleteExactPathOnce\";\n\n/** ------------------------------------------------------------------------\n * * ***Utility: `removeObjectPaths`.***\n * ------------------------------------------------------------------------\n * **Deletes multiple keys (shallow or deeply nested) from an object.**\n * - **Features:**\n *    - Removes one or more keys from an object based on their paths (supports dot notation for nested properties).\n *    - Can delete deeply from all matching nested levels (even inside arrays) when `deep: true`.\n *    - By default does **not mutate** the original object. Clones it first.\n *   Set `deepClone = false` to mutate in place (useful for performance on large data).\n *    - Ensures type safety on `key` paths via `DotPath<T>`, reducing accidental invalid paths.\n * - **Behavior:**\n *    - When `deep: false` (default), only deletes the direct property at the specified path.\n *    - When `deep: true`, searches deeply and recursively deletes the key from all levels,\n *   including inside arrays of objects (applies the *same* path repeatedly).\n *    - Skips deletion if the specified path does not exist — no error is thrown.\n * - **Edge Handling:**\n *    - If `object` is `null` or not an object, returns an empty object.\n *    - If `keysToDelete` is not an array of `{ key, deep? }` objects, throws a `TypeError`.\n *    - Ignores invalid intermediate paths (will skip those branches without throwing).\n * @template T - The shape of the input object, used for type-safe dot paths.\n * @param {Record<string, unknown>} object - ***The object to remove keys from, must be an object or will return `{}`.***\n * @param {ConfigRemoveObjectPaths<T>[]} keysToDelete\n *  ***An array of instructions:***\n *   - `key`: A string path using dot notation (e.g. `\"user.profile.name\"`).\n *   - `deep`: If `true`, will recursively remove all instances of the key path at any depth, defaultValue: `false`.\n * @param {boolean|undefined} [deepClone=true]\n *  ***Whether to deep clone the original object before modifying.***\n *   - `true` (default): returns a *new object* with the specified keys removed.\n *   - `false`: modifies the original object in place and returns it.\n * @returns {Partial<T>}\n *   - A new object with specified keys removed if `deepClone` is `true`.\n *   - The *same mutated object* if `deepClone` is `false`.\n * @throws **{@link TypeError | `TypeError`}** if `keysToDelete` is not an array of `{ key, deep? }` objects.\n * @example\n * // Shallow deletion\n * removeObjectPaths(\n *   { a: 1, b: 2, c: { d: 3 } },\n *   [{ key: \"b\" }]\n * );\n * // ➔ { a: 1, c: { d: 3 } }\n *\n * // Nested deletion (shallow, removes only exact path)\n * removeObjectPaths(\n *   { user: { profile: { name: \"Alice\", age: 30 } } },\n *   [{ key: \"user.profile.age\" }]\n * );\n * // ➔ { user: { profile: { name: \"Alice\" } } }\n *\n * // Deep deletion (recursively removes key from all levels and arrays)\n * removeObjectPaths(\n *   { items: [{ price: 10 }, { price: 20, details: { price: 30 } }] },\n *   [{ key: \"price\", deep: true }]\n * );\n * // ➔ { items: [{}, { details: {} }] }\n *\n * // Without cloning: mutates original object\n * const obj = { x: 1, y: 2 };\n * removeObjectPaths(obj, [{ key: \"y\" }], false);\n * console.log(obj); // ➔ { x: 1 }\n *\n * // No matching path — returns unchanged object\n * removeObjectPaths({}, [{ key: \"a\" }]);\n * // ➔ {}\n *\n * // 🚫 Invalid usage — `keysToDelete` is not an array\n * removeObjectPaths({}, \"a\");\n * // ➔ throws TypeError\n *\n * // 🚫 Invalid usage — missing `key` property in array element\n * removeObjectPaths({}, [{ deep: true }]);\n * // ➔ throws TypeError\n */\nexport function removeObjectPaths<\n  T extends Record<string, unknown>,\n  K extends ConfigRemoveObjectPaths<T>[]\n>(\n  object: T,\n  keysToDelete: K,\n  deepClone: boolean = true\n): ResultRemoveObjectPaths<T, K> {\n  if (isEmptyObject(object, { checkSymbols: true }))\n    return {} as ResultRemoveObjectPaths<T, K>;\n\n  assertIsArray(keysToDelete, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`keysToDelete\\`) must be of type \\`${validType}\\` with value of { key: string, deep?: boolean } plain-object, but received: \\`${currentType}\\`, with value: \\`${safeStableStringify(\n        keysToDelete,\n        { keepUndefined: true }\n      )}\\`.`\n  });\n\n  if (!keysToDelete.every((k) => isPlainObject(k) && \"key\" in k)) {\n    throw new TypeError(\n      `Each element in Second Parameter (\\`keysToDelete\\`) must be of type \\`plain-object\\` with at least a \"key\" property (optionally \"deep\"), but received: \\`${safeStableStringify(\n        keysToDelete,\n        { keepUndefined: true }\n      )}\\`.`\n    );\n  }\n\n  let result = deepClone ? deepCloneSafe(object) : object;\n\n  for (const { key, deep } of keysToDelete) {\n    assertIsString(key, {\n      message: ({ currentType, validType }) =>\n        `Parameter \\`key\\` at Second Parameter (\\`keysToDelete\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n    });\n\n    if (!isUndefined(deep) && !isBoolean(deep)) {\n      throw new TypeError(\n        `Parameter \\`deep\\` at Second Parameter (\\`keysToDelete\\`) ➔ (key: \"${key}\", deep: ${deep}) must be of type \\`boolean\\` or \\`undefined\\`, but received: \\`${getPreciseType(\n          deep\n        )}\\`.`\n      );\n    }\n\n    const path = key.split(\".\");\n    result = deep\n      ? deleteNestedKey(result, path)\n      : deleteExactPathOnce(result, path);\n  }\n\n  return result as ResultRemoveObjectPaths<T, K>;\n}\n","import type {\n  ConvertedDeepNumber,\n  ToNumberDeepOptions\n} from \"./_private/toNumberDeep.types\";\n\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isMap } from \"@/predicates/is/isMap\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isDate } from \"@/predicates/is/isDate\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isBuffer } from \"@/predicates/is/isBuffer\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isRegExp } from \"@/predicates/is/isRegExp\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\nimport { isEmptyArray } from \"@/predicates/is/isEmptyArray\";\nimport { isTypedArray } from \"@/predicates/is/isTypedArray\";\nimport { isEmptyObject } from \"@/predicates/is/isEmptyObject\";\nimport { isNumberObject } from \"@/predicates/is/isNumberObject\";\nimport { isStringObject } from \"@/predicates/is/isStringObject\";\nimport { isBooleanObject } from \"@/predicates/is/isBooleanObject\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isInfinityNumber } from \"@/predicates/is/isInfinityNumber\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\n/** --------------------------------------------------\n * * ***Utility: `toNumberDeep`.***\n * ---------------------------------------------------\n * **Converts deeply nested arrays, objects, buffers, sets, maps, or typed arrays into numbers while preserving structure.**\n * - **Features:**\n *    - Converts numeric strings, number to numbers:\n *      - `3.5` ➔ `3.5`.\n *      - `\"3.5\"` ➔ `3.5`.\n *    - Converts boolean to number:\n *      - `true` ➔ `1`.\n *      - `false` ➔ `0`.\n *    - Converts Date to getTime (timestamp) `Date ➔ number`, if invalid Date value will return `0`:\n *      - `new Date(\"invalid\")` ➔ `0`.\n *      - `new Date(\"11-09-2025 22:04:11\")` ➔ `1762700651000`.\n *    - Converts `Buffer`, `TypedArray`, `Set`, `Map`, and `arrays` recursively to `arrays of numbers`.\n *    - Converts boxed primitives box into their primitive equivalents then convert to number:\n *      - For `new String` we convert everything to number (behavior JS of new String):\n *        - `new String(123)` ➔ `.valueOf()` ➔ `\"123\"` ➔ `Number(\"123\")` ➔ `123`.\n *        - `new String(\"123\")` ➔ `.valueOf()` ➔ `\"123\"` ➔ `Number(\"123\")` ➔ `123`.\n *        - `new String(true)` ➔ `.valueOf()` ➔ `\"true\"` ➔ `Number(true)` ➔ `1`.\n *        - `new String(false)` ➔ `.valueOf()` ➔ `\"false\"` ➔ `Number(false)` ➔ `0`.\n *        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:\n *          - `new String(\"hi\")` ➔ `.valueOf()` ➔ `\"hi\"` ➔ `Number(\"hi\")` ➔ `NaN` ***(remove)***.\n *          - `new String(()=>{})` ➔ `.valueOf()` ➔ `\"()=>{}\"` ➔ `Number(\"()=>{}\")` ➔ `NaN` ***(remove)***.\n *      - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to number:\n *        - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `Number(true)` ➔ `1`.\n *        - `new Boolean(false)` ➔ `.valueOf()` ➔ `false` ➔ `Number(false)` ➔ `0`.\n *        - Special behavior JS of new Boolean, return `false` **(convert to number: `0`)**\n *          for `false`, (`0` / `-0`), `\"\"` (empty-string),\n *          `null`, `undefined`, `NaN`, otherwise `true` **(convert to number: `1`)**.\n *      - For `new Number`:\n *        - `new Number(42)` ➔ `.valueOf()` ➔ `42`.\n *        - `new Number(\"42\")` ➔ `.valueOf()` ➔ `42`.\n *        - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number).\n *        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:\n *          - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.\n *          - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.\n *          - `new Number(Infinity)` ➔ `.valueOf()` ➔ `Infinity` ***(remove)***.\n *          - `new Number(-Infinity)` ➔ `.valueOf()` ➔ `-Infinity` ***(remove)***.\n *    - Recursively processes `nested objects`, `arrays`, `buffers`, `sets`, `maps`, and `typed arrays`.\n *    - Removes `empty-string`, `non-numeric strings`.\n *    - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.\n *    - Removes `unsupported` types like `functions` , `RegExp`, `symbols`, and `BigInt`.\n *    - Can optionally remove empty arrays (`[]`) and/or empty objects (`{}`) **recursively**.\n * @template T - The input type.\n * @template RemoveEmptyObjects - Whether to remove empty objects.\n * @template RemoveEmptyArrays - Whether to remove empty arrays.\n * @param {*} input - The input value to convert.\n * @param {ToNumberDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>} [options] - Conversion options.\n * @returns {ConvertedDeepNumber<T, RemoveEmptyObjects, RemoveEmptyArrays>|undefined} The converted value, return `undefined` if the input is entirely empty or filtered out by options.\n * @example\n * ```ts\n * toNumberDeep(\"123\");\n * // ➔ 123\n * toNumberDeep(\"abc\");\n * // ➔ undefined\n * toNumberDeep([NaN, \"10\", \"xyz\"]);\n * // ➔ [10]\n * toNumberDeep({ a: \"1\", b: [null, \"2\"] });\n * // ➔ { a: 1, b: [2] }\n * toNumberDeep(Buffer.from([0, 1, 2]));\n * // ➔ [0, 1, 2]\n * toNumberDeep(new Set([\"1\", \"2\"]));\n * // ➔ [1, 2]\n * toNumberDeep(new Map([[\"a\", \"1\"], [\"b\", \"2\"]]));\n * // ➔ [[\"a\", 1], [\"b\", 2]]\n * toNumberDeep(new Int16Array([1, 2, 3]));\n * // ➔ [1, 2, 3]\n * toNumberDeep(new Date(\"2025-08-16T00:00:00Z\"));\n * // ➔ 1755552000000\n * toNumberDeep({ a: {}, b: [] }, { removeEmptyObjects: true });\n * // ➔ { b: [] }\n * toNumberDeep({ a: {}, b: [] }, { removeEmptyArrays: true });\n * // ➔ { a: {} }\n * toNumberDeep({ x: {}, y: [], z: [{ a: {}, b: [] }] }, {\n *    removeEmptyObjects: true, removeEmptyArrays: true\n * });\n * // ➔ { z: [] }\n * ```\n */\nexport function toNumberDeep(\n  input?: null | undefined,\n  options?: ToNumberDeepOptions<boolean, boolean>\n): undefined;\nexport function toNumberDeep<\n  T,\n  RemoveEmptyObjects extends boolean = false,\n  RemoveEmptyArrays extends boolean = false\n>(\n  input: T,\n  options?: ToNumberDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>\n): ConvertedDeepNumber<T, RemoveEmptyObjects, RemoveEmptyArrays>;\nexport function toNumberDeep<\n  T,\n  RemoveEmptyObjects extends boolean = false,\n  RemoveEmptyArrays extends boolean = false\n>(\n  input: T,\n  options: ToNumberDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays> = {}\n) {\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const removeEmptyObjects = hasOwnProp(options, \"removeEmptyObjects\")\n    ? options.removeEmptyObjects\n    : false;\n  const removeEmptyArrays = hasOwnProp(options, \"removeEmptyArrays\")\n    ? options.removeEmptyArrays\n    : false;\n\n  function _internal<\n    T,\n    RemoveEmptyObjects extends boolean,\n    RemoveEmptyArrays extends boolean\n  >(\n    input: T,\n    options: Required<\n      ToNumberDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>\n    > & {\n      isRoot: boolean;\n    }\n  ): unknown {\n    if (isNil(input) || isRegExp(input)) return undefined;\n\n    const { removeEmptyArrays, removeEmptyObjects, isRoot } = options;\n\n    if (!isBoolean(removeEmptyObjects) || !isBoolean(removeEmptyArrays)) {\n      throw new TypeError(\n        `Parameters \\`removeEmptyObjects\\` and \\`removeEmptyArrays\\` property of the \\`options\\` (second parameter) must be of type \\`boolean\\`, but received: ['removeEmptyObjects': \\`${getPreciseType(\n          removeEmptyObjects\n        )}\\`, 'removeEmptyArrays': \\`${getPreciseType(removeEmptyArrays)}\\`].`\n      );\n    }\n\n    // primitive boolean, numbers, or numeric strings\n    if (isNumber(input) || isBoolean(input) || isNonEmptyString(input)) {\n      const num = Number(input);\n      return isInfinityNumber(num) || isNaN(num) ? undefined : num;\n    }\n\n    if (\n      isNumberObject(input) ||\n      isStringObject(input) ||\n      isBooleanObject(input)\n    ) {\n      const valOf = Number(input.valueOf());\n      return isInfinityNumber(valOf) || isNaN(valOf) ? undefined : valOf;\n    }\n\n    if (isDate(input, { skipInvalidDate: true })) {\n      try {\n        return !isNaN(input.getTime()) ? input.getTime() : 0;\n      } catch {\n        return 0;\n      }\n    }\n\n    if (isBuffer(input)) {\n      const arr = Array.from(input)\n        .map((n) =>\n          _internal(n, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          })\n        )\n        .filter((item) => !isUndefined(item));\n      if (removeEmptyArrays && isEmptyArray(arr)) return undefined;\n      return arr;\n    }\n\n    if (isTypedArray(input)) {\n      // If BigInt TypedArray\n      if (input instanceof BigInt64Array || input instanceof BigUint64Array) {\n        const newArray = Array.from(input)\n          .map((item) =>\n            _internal(item, {\n              removeEmptyObjects,\n              removeEmptyArrays,\n              isRoot: false\n            })\n          )\n          .filter((item) => !isUndefined(item));\n\n        if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n        return newArray;\n      } else {\n        // All TypedArray based of number\n        const newArray = Array.from(input)\n          .map((item) =>\n            _internal(item, {\n              removeEmptyObjects,\n              removeEmptyArrays,\n              isRoot: false\n            })\n          )\n          .filter((item) => !isUndefined(item));\n\n        if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n        return newArray;\n      }\n    }\n\n    if (isSet(input)) {\n      const newArray = Array.from(input)\n        .map((item) =>\n          _internal(item, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          })\n        )\n        .filter((item) => !isUndefined(item));\n\n      if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n      return newArray;\n    }\n\n    if (isMap(input)) {\n      let newArray = Array.from(input.entries())\n        .map(([k, v]) => {\n          const key = _internal(k, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          });\n          const value = _internal(v, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          });\n          return !isUndefined(key) && !isUndefined(value)\n            ? [key, value]\n            : undefined;\n        })\n        .filter((item) => !isUndefined(item));\n\n      // remove empty arrays recursively\n      if (removeEmptyArrays) {\n        newArray = newArray.filter((v) => !isEmptyArray(v));\n      }\n\n      if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n      return newArray;\n    }\n\n    if (isArray(input)) {\n      const newArray = input\n        .map((item) =>\n          _internal(item, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          })\n        )\n        .filter((item) => !isUndefined(item));\n\n      if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n      return newArray;\n    }\n\n    if (isObject(input)) {\n      const newObject: Record<string, unknown> = {};\n\n      for (const [key, value] of Object.entries(input)) {\n        const convertedValue = _internal(value, {\n          removeEmptyObjects,\n          removeEmptyArrays,\n          isRoot: false\n        });\n        if (!isUndefined(convertedValue)) {\n          newObject[key] = convertedValue;\n        }\n      }\n\n      if (removeEmptyObjects && isEmptyObject(newObject)) {\n        return isRoot ? {} : undefined;\n      }\n\n      return newObject;\n    }\n\n    return undefined;\n  }\n\n  return _internal(input, {\n    removeEmptyObjects,\n    removeEmptyArrays,\n    isRoot: true\n  });\n}\n","import type {\n  ConvertedDeepString,\n  ToStringDeepOptions\n} from \"./_private/toStringDeep.types\";\n\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isMap } from \"@/predicates/is/isMap\";\nimport { isDate } from \"@/predicates/is/isDate\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isBuffer } from \"@/predicates/is/isBuffer\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isRegExp } from \"@/predicates/is/isRegExp\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\nimport { isEmptyArray } from \"@/predicates/is/isEmptyArray\";\nimport { isTypedArray } from \"@/predicates/is/isTypedArray\";\nimport { isNumberObject } from \"@/predicates/is/isNumberObject\";\nimport { isStringObject } from \"@/predicates/is/isStringObject\";\nimport { isBooleanObject } from \"@/predicates/is/isBooleanObject\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isInfinityNumber } from \"@/predicates/is/isInfinityNumber\";\n\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\n/** --------------------------------------------------\n * * ***Utility: `toStringDeep`.***\n * ---------------------------------------------------\n * **Converts all values in an array, object, Set, Map, or deeply nested structure to string.**\n * - **Features:**\n *    - Converts numbers and strings to string:\n *      - `3.5` ➔ `\"3.5\"`.\n *      - `\"3.5\"` ➔ `\"3.5\"`.\n *    - Converts boolean to string:\n *      - `true` ➔ `\"true\"`.\n *      - `false` ➔ `\"false\"`.\n *    - Converts Date to ISO string (`Date ➔ string`).\n *    - Converts RegExp to string (e.g., `/abc/ ➔ \"/abc/\"`).\n *    - Converts `Buffer`, `TypedArray`, `Set`, `Map`, and `arrays` recursively to `arrays of strings`.\n *    - Converts boxed primitives box into their primitive equivalents then convert to string:\n *      - For `new String` we convert everything to string (behavior JS of new String):\n *        - `new String(\"hi\")` ➔ `.valueOf()` ➔ `\"hi\"`.\n *        - `new String(true)` ➔ `.valueOf()` ➔ `\"true\"`.\n *      - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to string:\n *        - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `true.toString()` ➔ `\"true\"`.\n *        - Special behavior JS of new Boolean, return `false` **(convert to string: `\"false\"`)**\n *          for `false`, (`0` / `-0`), `\"\"` (empty-string), `null`, `undefined`, `NaN`, otherwise\n *          `true` **(convert to string: `\"true\"`)**.\n *      - For `new Number`:\n *        - `new Number(42)` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `\"42\"`.\n *        - `new Number(\"42\")` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `\"42\"`.\n *        - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number) ➔ `0.toString()` ➔ `\"0\"`.\n *        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:\n *          - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.\n *          - `new Number(\"abc\")` ➔ `.valueOf()` ➔ `NaN`  ***(remove)***.\n *          - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.\n *          - `new Number(Infinity)` ➔ `.valueOf()` ➔ `Infinity` ***(remove)***.\n *          - `new Number(-Infinity)` ➔ `.valueOf()` ➔ `-Infinity` ***(remove)***.\n *    - Recursively processes `nested objects`, `arrays`, `buffers`, `sets`, `maps`, and `typed arrays`.\n *    - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.\n *    - Removes `unsupported` types like `functions`, `symbols`, and `BigInt`.\n *    - Can optionally remove empty arrays (`[]`) and/or empty objects (`{}`) **recursively**.\n * @template T - The input data type (`primitive`, `object`, `array`, `Set`, `Map`, or `any nested combination`).\n * @template RemoveEmptyObjects - If `true`, empty objects `{}` will be removed recursively.\n * @template RemoveEmptyArrays - If `true`, empty arrays `[]` will be removed recursively (including arrays nested in `objects` / `arrays` / `Sets` / `Maps`).\n * @param {*} input - The data to convert.\n * @param {ToStringDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>} [options] - Conversion options.\n * @returns {ConvertedDeepString<T, RemoveEmptyObjects, RemoveEmptyArrays>|undefined}\n * The transformed data, or `undefined` if the entire structure becomes empty after processing.\n * @example\n * ```ts\n * // Simple array conversion\n * toStringDeep([1, \"2\", 3]);\n * // ➔ [\"1\", \"2\", \"3\"]\n *\n * // Simple top-level conversion\n * toStringDeep(123);\n * // ➔ \"123\"\n * toStringDeep(\"123\");\n * // ➔ \"123\"\n * toStringDeep(true);\n * // ➔ \"true\"\n * toStringDeep(false);\n * // ➔ \"false\"\n *\n * // Nested arrays\n * toStringDeep([1, [\"2\", [3, [null, \"4\", true, false]]]]);\n * // ➔ [\"1\", [\"2\", [\"3\", [\"4\", \"true\", \"false\"]]]]\n *\n * // Object with nested values\n * toStringDeep({ a: 1, b: \"2\", c: { d: 3, e: null, f: true, g: false } });\n * // ➔ { a: \"1\", b: \"2\", c: { d: \"3\", f: \"true\", g: \"false\" } }\n *\n * // Removing empty objects\n * toStringDeep({ a: {}, b: \"1\" }, { removeEmptyObjects: true });\n * // ➔ { b: \"1\" }\n *\n * // Removing empty arrays recursively\n * toStringDeep([\"1\", [], { a: [] }], { removeEmptyArrays: true });\n * // ➔ [\"1\", { a: [] }]\n *\n * // Removing both empty objects and arrays recursively\n * toStringDeep({ a: {}, b: [], c: [{ d: {}, e: [] }, \"1\"] }, {\n *   removeEmptyObjects: true,\n *   removeEmptyArrays: true\n * });\n * // ➔ { c: [\"1\"] }\n *\n * // Fully empty structure becomes undefined\n * toStringDeep([null, undefined, {}], {\n *   removeEmptyObjects: true,\n *   removeEmptyArrays: true\n * });\n * // ➔ undefined\n * ```\n */\nexport function toStringDeep(\n  input?: null | undefined,\n  options?: ToStringDeepOptions<boolean, boolean>\n): undefined;\nexport function toStringDeep<\n  T,\n  RemoveEmptyObjects extends boolean = false,\n  RemoveEmptyArrays extends boolean = false\n>(\n  input: T,\n  options?: ToStringDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>\n): ConvertedDeepString<T, RemoveEmptyObjects, RemoveEmptyArrays>;\nexport function toStringDeep<\n  T,\n  RemoveEmptyObjects extends boolean = false,\n  RemoveEmptyArrays extends boolean = false\n>(\n  input: T,\n  options: ToStringDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays> = {}\n) {\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const removeEmptyObjects = hasOwnProp(options, \"removeEmptyObjects\")\n    ? options.removeEmptyObjects\n    : false;\n  const removeEmptyArrays = hasOwnProp(options, \"removeEmptyArrays\")\n    ? options.removeEmptyArrays\n    : false;\n\n  function _internal<\n    T,\n    RemoveEmptyObjects extends boolean,\n    RemoveEmptyArrays extends boolean\n  >(\n    input: T,\n    options: Required<\n      ToStringDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>\n    > & {\n      isRoot: boolean;\n    }\n  ): unknown {\n    if (isNil(input) || isInfinityNumber(input)) return undefined;\n\n    const { removeEmptyArrays, removeEmptyObjects, isRoot } = options;\n\n    if (!isBoolean(removeEmptyObjects) || !isBoolean(removeEmptyArrays)) {\n      throw new TypeError(\n        `Parameters \\`removeEmptyObjects\\` and \\`removeEmptyArrays\\` property of the \\`options\\` (second parameter) must be of type \\`boolean\\`, but received: ['removeEmptyObjects': \\`${getPreciseType(\n          removeEmptyObjects\n        )}\\`, 'removeEmptyArrays': \\`${getPreciseType(removeEmptyArrays)}\\`].`\n      );\n    }\n\n    if (isNumber(input) || isString(input) || isBoolean(input))\n      return String(input);\n\n    if (isNumberObject(input)) {\n      const valOf = input.valueOf();\n      return isInfinityNumber(valOf) || isNaN(valOf)\n        ? undefined\n        : valOf.toString();\n    }\n    if (isStringObject(input)) return input.valueOf();\n    if (isBooleanObject(input)) return input.valueOf().toString();\n\n    if (isDate(input, { skipInvalidDate: true })) {\n      try {\n        return input.toISOString();\n      } catch {\n        return input.toString();\n      }\n    }\n\n    if (isRegExp(input)) return input.toString();\n\n    if (isBuffer(input)) {\n      return Array.from(input)\n        .map((v) => String(v))\n        .filter((v) => !isUndefined(v));\n    }\n\n    if (isTypedArray(input)) {\n      // If BigInt TypedArray\n      if (input instanceof BigInt64Array || input instanceof BigUint64Array) {\n        const newArray = Array.from(input)\n          .map((item) =>\n            _internal(item, {\n              removeEmptyObjects,\n              removeEmptyArrays,\n              isRoot: false\n            })\n          )\n          .map((v) => String(v))\n          .filter((item) => !isUndefined(item));\n\n        if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n        return newArray;\n      } else {\n        // All TypedArray based of number\n        const newArray = Array.from(input)\n          .map((item) =>\n            _internal(item, {\n              removeEmptyObjects,\n              removeEmptyArrays,\n              isRoot: false\n            })\n          )\n          .map((v) => String(v))\n          .filter((item) => !isUndefined(item));\n\n        if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n        return newArray;\n      }\n    }\n\n    if (isSet(input)) {\n      const arr = Array.from(input)\n        .map((v) =>\n          _internal(v, { removeEmptyObjects, removeEmptyArrays, isRoot: false })\n        )\n        .filter((v) => !isUndefined(v));\n      if (removeEmptyArrays && isEmptyArray(arr)) return undefined;\n      return arr;\n    }\n\n    // Map ➔ array of [key, value]\n    if (isMap(input)) {\n      const arr = Array.from(input.entries())\n        .map(([k, v]) => [\n          _internal(k, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          }),\n          _internal(v, { removeEmptyObjects, removeEmptyArrays, isRoot: false })\n        ])\n        .filter(([k, v]) => !isUndefined(k) && !isUndefined(v));\n      if (removeEmptyArrays && isEmptyArray(arr)) return undefined;\n      return arr;\n    }\n\n    if (isArray(input)) {\n      let newArray = input\n        .map((item) =>\n          _internal(item, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          })\n        )\n        .filter((item) => !isUndefined(item));\n\n      // remove empty arrays recursively\n      if (removeEmptyArrays) {\n        newArray = newArray.filter((v) => !(isArray(v) && v.length === 0));\n      }\n\n      if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n      return newArray;\n    }\n\n    if (isObject(input)) {\n      const newObject: Record<string, unknown> = {};\n\n      for (const [key, value] of Object.entries(input)) {\n        const convertedValue = _internal(value, {\n          removeEmptyObjects,\n          removeEmptyArrays,\n          isRoot: false\n        });\n\n        if (!isUndefined(convertedValue)) {\n          newObject[key] = convertedValue;\n        } else if (isArray(value) && !removeEmptyArrays) {\n          // preserve empty array property\n          newObject[key] = [];\n        }\n      }\n\n      if (removeEmptyObjects && Object.keys(newObject).length === 0) {\n        return isRoot ? {} : undefined;\n      }\n\n      return newObject;\n    }\n\n    return undefined;\n  }\n\n  return _internal(input, {\n    removeEmptyObjects,\n    removeEmptyArrays,\n    isRoot: true\n  });\n}\n"],"mappings":"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"}

package/dist/conversions-EMJa3g-D.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"conversions-EMJa3g-D.js","names":[],"sources":["../src/conversions/arrays/casts/toNumberArrayUnRecursive.ts","../src/conversions/values/toStringDeepForce.ts","../src/conversions/arrays/transforms/dedupeArray.ts","../src/conversions/boolean/toBooleanContent.ts","../src/conversions/boolean/toBooleanContentDeep.ts","../src/conversions/boolean/toBooleanExplicit.ts","../src/conversions/boolean/toBooleanLoose.ts","../src/conversions/data-type/convert.ts","../src/conversions/object/_private/utils/deepCloneSafe.ts","../src/conversions/object/_private/utils/deleteNestedKey.ts","../src/conversions/object/_private/utils/deleteExactPathOnce.ts","../src/conversions/object/removeObjectPaths.ts","../src/conversions/values/toNumberDeep.ts","../src/conversions/values/toStringDeep.ts"],"sourcesContent":["import type {\n  NormalizeInputToNumberArrayUnRecursive,\n  ToNumberArrayUnRecursiveOptions,\n  ToNumberArrayUnRecursiveReturn\n} from \"./toNumberArrayUnRecursive.types\";\n\nimport { isNull } from \"@/predicates/is/isNull\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isBigInt } from \"@/predicates/is/isBigInt\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport { filterNilArray } from \"../transforms/filterNilArray\";\n\n/** -------------------------------------------------------\n * * ***Utility: `toNumberArrayUnRecursive`.***\n * -------------------------------------------------------\n * **Converts a flat array of strings, numbers, nulls, or undefineds into numbers.**\n * - **Behavior:**\n *    - Only supports **flat arrays** (non-recursive).\n *    - Valid inputs: `string`, `number`, `null`, `undefined`.\n *    - `BigInt` will be converted to `number`.\n *    - Other values ➔ coerced into `undefined`.\n *    - Invalid values can be **removed** (`removeInvalidValueNumber: true`) or **kept** (`false`).\n * - **ℹ️ Note:**\n *    - _For recursive / nested arrays, use ***`toNumberDeep` utility function*** instead._\n * @template T - Element type of the input array.\n * @template R - Whether invalid values should be removed (`true`) or kept (`false`).\n * @param {Array<T> | readonly T[] | null | undefined} [array] - The array to convert, returns `undefined` if not an array.\n * @param {ToNumberArrayUnRecursiveOptions<RemoveInvalidValue>} [options] - Options to control transformation behavior, defaults to `{ removeInvalidValueNumber: true }`.\n * @returns {ToNumberArrayUnRecursiveReturn<NormalizeInput<T>, RemoveInvalidValue>} A new array of string representations, with invalid values optionally removed.\n * @example\n * ```ts\n * toNumberArrayUnRecursive(['1', 2, '3']);\n * // ➔ [1, 2, 3]\n * toNumberArrayUnRecursive([1, null, undefined, 'abc']);\n * // ➔ [1]\n * toNumberArrayUnRecursive(['1', null, undefined, 'abc'], {\n *   removeInvalidValueNumber: false\n * });\n * // ➔ [1, null, undefined, undefined]\n * toNumberArrayUnRecursive(null);      // ➔ undefined\n * toNumberArrayUnRecursive(undefined); // ➔ undefined\n * toNumberArrayUnRecursive(1);         // ➔ undefined\n * ```\n */\nexport function toNumberArrayUnRecursive(\n  array?: null | undefined,\n  options?: ToNumberArrayUnRecursiveOptions<boolean>\n): undefined;\nexport function toNumberArrayUnRecursive(\n  array?: Array<never>,\n  options?: ToNumberArrayUnRecursiveOptions<boolean>\n): [];\nexport function toNumberArrayUnRecursive<T, R extends boolean = true>(\n  array?: Array<T> | readonly T[] | null,\n  options?: ToNumberArrayUnRecursiveOptions<R>\n): ToNumberArrayUnRecursiveReturn<NormalizeInputToNumberArrayUnRecursive<T>, R>;\nexport function toNumberArrayUnRecursive<T = unknown>(\n  array?: T,\n  options?: ToNumberArrayUnRecursiveOptions<boolean>\n): undefined;\nexport function toNumberArrayUnRecursive<T>(\n  array?: Array<T> | readonly T[] | null,\n  options: ToNumberArrayUnRecursiveOptions<boolean> = {}\n) {\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const riv = hasOwnProp(options, \"removeInvalidValueNumber\")\n    ? options.removeInvalidValueNumber\n    : true;\n\n  assertIsBoolean(riv, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`removeInvalidValueNumber\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  if (isArray(array)) {\n    const result = Array.from(array, (x) => {\n      if (isBigInt(x)) return Number(x);\n\n      const str = String(x).trim();\n      const match = str.match(/-?\\d+(\\.\\d+)?/);\n      // const match = str.match(/^-?\\d+(\\.\\d+)?$/); // ➔ full string match, stricter\n      return match ? Number(match[0]) : isNull(x) ? null : undefined;\n    });\n\n    return riv ? filterNilArray(result) : result;\n  }\n\n  return undefined;\n}\n","import { isMap } from \"@/predicates/is/isMap\";\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isDate } from \"@/predicates/is/isDate\";\nimport { isError } from \"@/predicates/is/isError\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isBigInt } from \"@/predicates/is/isBigInt\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isRegExp } from \"@/predicates/is/isRegExp\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isSymbol } from \"@/predicates/is/isSymbol\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isFunction } from \"@/predicates/is/isFunction\";\nimport { isNumberObject } from \"@/predicates/is/isNumberObject\";\nimport { isStringObject } from \"@/predicates/is/isStringObject\";\nimport { isBooleanObject } from \"@/predicates/is/isBooleanObject\";\nimport { isObjectOrArray } from \"@/predicates/is/isObjectOrArray\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { safeStableStringify } from \"../stringify/safeStableStringify\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `toStringDeepForce`.***\n * ---------------------------------------------\n * **Recursively converts a value into a string based on the `forceToString` options.**\n * - **Rules `forceToString` options:**\n *    - `\"stringOrNumber\"`: Converts strings and numbers to strings.\n *    - `\"primitives\"`: Converts all primitives (number, string, boolean, bigint, undefined, null, NaN) to strings.\n *    - `\"all\"`: Converts everything, including symbols, functions, Dates, RegExp, Maps, Sets, Errors, Promises,\n *       boxed primitives box (new Number, new String, new Boolean), and deeply all object properties, to strings.\n *    - `false`: Leaves everything unchanged.\n * - **Special behaviors:**\n *    - `NaN` ➔ `\"NaN\"` only in `\"primitives\"` or `\"all\"` mode.\n *    - `Date` ➔ ISO string only in `\"all\"` mode.\n *    -  ***Primitives Boxed*** (`new Number`, `new String`, `new Boolean`):\n *       - For `new String` we convert everything to string (behavior JS of new String):\n *         - `new String(\"hi\")` ➔ `.valueOf()` ➔ `\"hi\"`.\n *         - `new String(true)` ➔ `.valueOf()` ➔ `\"true\"`.\n *       - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to string:\n *         - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `true.toString()` ➔ `\"true\"`.\n *         - Special behavior JS of new Boolean, return `false` **(convert to string: `\"false\"`)**\n *           for `false`, (`0` / `-0`), `\"\"` (empty-string), `null`, `undefined`, `NaN`, otherwise\n *           `true` **(convert to string: `\"true\"`)**.\n *       - For `new Number`:\n *         - `new Number(42)` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `\"42\"`.\n *         - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ➔ `NaN.toString()` ➔ `\"NaN\"`.\n *         - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number) ➔ `0.toString()` ➔ `\"0\"`.\n *         - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ➔ `NaN.toString()` ➔ `\"NaN\"`.\n *         - `new Number(Infinity)` ➔ `Infinity` ➔ `Infinity` ➔ `Infinity.toString()` ➔ `\"Infinity\"`.\n *         - `new Number(-Infinity)` ➔ `-Infinity` ➔ `-Infinity` ➔ `-Infinity.toString()` ➔ `\"-Infinity\"`.\n *    - `RegExp` ➔ Source string (e.g. `/abc/i`) only in `\"all\"` mode.\n *    - `Symbol` ➔ `Symbol(description)` string only in `\"all\"` mode.\n *    - `Map` ➔ Array of [key, value] pairs with keys/values stringified deeply (only in `\"all\"` mode).\n *    - `Set` ➔ Array of values stringified deeply (only in `\"all\"` mode).\n *    - `Function` ➔ Source code string (e.g. `\"() => 1\"`) only in `\"all\"` mode.\n *    - `Error`, `Promise` ➔ Stringified via `.toString()` only in `\"all\"` mode.\n * @param {*} value\n * * ***The value to process.***\n *    - ***Can be anything:***\n *        - `primitive`.\n *        - `array`.\n *        - `object`.\n *        - `function`.\n *        - `etc`.\n * @param {false | \"stringOrNumber\" | \"primitives\" | \"all\"} forceToString - ***The mode of string conversion.***\n * @returns {unknown} A new value with the conversion applied based on `forceToString`.\n * @example\n * toStringDeepForce(42, \"stringOrNumber\");\n * // ➔ \"42\"\n * toStringDeepForce(true, \"primitives\");\n * // ➔ \"true\"\n * toStringDeepForce(null, \"primitives\");\n * // ➔ \"null\"\n * toStringDeepForce(Symbol(\"x\"), \"all\");\n * // ➔ \"Symbol(x)\"\n * toStringDeepForce(new String(\"hi\"), \"all\");\n * // ➔ \"hi\"\n * toStringDeepForce(new Number(42), \"all\");\n * // ➔ \"42\"\n * toStringDeepForce(new Boolean(true), \"all\");\n * // ➔ \"true\"\n * toStringDeepForce({ a: 1, b: [2, NaN] }, \"primitives\");\n * // ➔ { a: \"1\", b: [\"2\", \"NaN\"] }\n * toStringDeepForce(new Date(\"2025-01-01\"), \"all\");\n * // ➔ \"2025-01-01T00:00:00.000Z\"\n * toStringDeepForce(() => 1, \"all\");\n * // ➔ \"() => 1\"\n * toStringDeepForce(/abc/i, \"all\");\n * // ➔ \"/abc/i\"\n * toStringDeepForce(new Map([[\"a\", 1], [\"b\", 2]]), \"all\");\n * // ➔ [[\"a\", \"1\"], [\"b\", \"2\"]]\n * toStringDeepForce(new Set([1, 2, 3]), \"all\");\n * // ➔ [\"1\", \"2\", \"3\"]\n * toStringDeepForce(new Error(\"Oops\"), \"all\");\n * // ➔ \"Error: Oops\"\n * toStringDeepForce(Promise.resolve(1), \"all\");\n * // ➔ \"[object Promise]\"\n * toStringDeepForce({ func: () => 123 }, \"all\");\n * // ➔ { func: \"() => 123\" }\n * toStringDeepForce([1, \"a\", { b: 2 }], false);\n * // ➔ [1, \"a\", { b: 2 }]\n */\nexport function toStringDeepForce<T>(\n  value: unknown,\n  forceToString: false | \"stringOrNumber\" | \"primitives\" | \"all\"\n): T;\nexport function toStringDeepForce(\n  value: unknown,\n  forceToString: false | \"stringOrNumber\" | \"primitives\" | \"all\"\n) {\n  if (\n    !(\n      forceToString === false ||\n      forceToString === \"stringOrNumber\" ||\n      forceToString === \"primitives\" ||\n      forceToString === \"all\"\n    )\n  ) {\n    throw new TypeError(\n      `Second parameter \\`forceToString\\` must be of type \\`false\\` or \\`string\\` with value one of \"stringOrNumber\" | \"primitives\" | \"all\", but received: \\`${getPreciseType(\n        forceToString\n      )}\\`, with value: \\`${safeStableStringify(forceToString, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  // NaN special\n  if (isNaN(value)) {\n    return forceToString === \"primitives\" || forceToString === \"all\"\n      ? \"NaN\"\n      : NaN;\n  }\n\n  // string or number\n  if (isString(value) || isNumber(value)) {\n    return forceToString === \"stringOrNumber\" ||\n      forceToString === \"primitives\" ||\n      forceToString === \"all\"\n      ? String(value)\n      : value;\n  }\n\n  // other primitives\n  if (isBoolean(value) || isBigInt(value) || isNil(value)) {\n    return forceToString === \"primitives\" || forceToString === \"all\"\n      ? String(value)\n      : value;\n  }\n\n  // boxed primitives box (new Number, new String, new Boolean)\n  if (\n    isNumberObject(value) ||\n    isBooleanObject(value) ||\n    isStringObject(value)\n  ) {\n    return forceToString === \"all\" ? value.valueOf().toString() : value;\n  }\n\n  // symbol\n  if (isSymbol(value)) {\n    return forceToString === \"all\" ? value.toString() : value;\n  }\n\n  // function: only convert on \"all\"\n  if (isFunction(value)) {\n    return forceToString === \"all\" ? value.toString() : value;\n  }\n\n  // array\n  if (isArray(value)) {\n    return value.map((v) => toStringDeepForce(v, forceToString));\n  }\n\n  // objects\n  if (isObjectOrArray(value)) {\n    if (isDate(value)) {\n      return forceToString === \"all\" ? value.toISOString() : value;\n    }\n    if (isRegExp(value)) {\n      return forceToString === \"all\" ? value.toString() : value;\n    }\n    if (isError(value) || value instanceof Promise) {\n      return forceToString === \"all\" ? value.toString() : value;\n    }\n\n    if (isSet(value)) {\n      return forceToString === \"all\"\n        ? [...value].map((v) => toStringDeepForce(v, forceToString))\n        : value;\n    }\n\n    if (isMap(value)) {\n      return forceToString === \"all\"\n        ? [...value.entries()].map(([k, v]) => [\n            toStringDeepForce(k, forceToString),\n            toStringDeepForce(v, forceToString)\n          ])\n        : value;\n    }\n\n    const result: Record<string, unknown> = {};\n    if (isObject(value)) {\n      for (const key of Object.keys(value)) {\n        result[key] = toStringDeepForce(value[key], forceToString);\n      }\n    }\n    return result;\n  }\n\n  return value;\n}\n","import type {\n  DedupeArrayOptions,\n  DedupeResult,\n  ForceToStringOptions\n} from \"./_private/dedupeArray.types\";\n\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isMap } from \"@/predicates/is/isMap\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isEqual } from \"@/predicates/is/isEqual\";\n\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\nimport { assertIsArray } from \"@/assertions/objects/assertIsArray\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport { toStringDeepForce } from \"@/conversions/values/toStringDeepForce\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `dedupeArray`.***\n * ---------------------------------------------\n * **Deduplicates values in an array (with optional flattening and deep stringification).**\n * - Supports various modes for converting values to strings before deduplication:\n *    - `\"stringOrNumber\"`: Converts strings and numbers to strings.\n *    - `\"primitives\"`: Converts all primitives (string, number, boolean, bigint, null, undefined, NaN) to strings.\n *    - `\"all\"`: Converts all values (primitives, objects, Maps, Sets, Symbols, RegExp, Dates, Errors, Promises, functions)\n *   to strings, including nested object properties.\n *    - `false` (default): No conversion applied.\n * - Options:\n *    - `forceToString`: Enables string conversion for comparison, default is `false`.\n *    - `flatten`: If true, deeply flattens arrays, Maps, and Sets before deduplication, default is `false`.\n * @template ForceToString - `forceToString` mode.\n * @template Flattening - `flatten` mode.\n * @param {unknown[]} inputArray - The array to deduplicate, can be deeply nested and contain any mix of types.\n * @param {DedupeArrayOptions<ForceToString, Flattening>|undefined} [options] - Options to control string conversion.\n * @returns {DedupeResult<ForceToString, Flattening>} Deduplicated array with optional transformations.\n * @throws **{@link TypeError | `TypeError`}** if the input is not an array, or options is not an object, or if `forceToString` is invalid.\n * @example\n * ```ts\n * dedupeArray([\"apple\", \"banana\", \"apple\"]);\n * // ➔ [\"apple\", \"banana\"]\n * dedupeArray([[1, 2], [1, 2]], { flatten: true });\n * // ➔ [1, 2]\n * dedupeArray([new Set([1, 2]), new Set([2, 3])], { flatten: true });\n * // ➔ [1, 2, 3]\n * dedupeArray([1, \"1\", 2, \"2\"], {\n *    forceToString: \"stringOrNumber\"\n * }); // ➔ [\"1\", \"2\"]\n * dedupeArray([true, \"true\", false, undefined], {\n *    forceToString: \"primitives\"\n * }); // ➔ [\"true\", \"false\", \"undefined\"]\n * dedupeArray([1, \"1\", { a: 1 }], {\n *    forceToString: \"all\"\n * }); // ➔ [\"1\", { a: \"1\" }]\n * dedupeArray([1, 1, [2, 2, [3, 3]]]);\n * // ➔ [1, [2, [3]]]\n * dedupeArray([null, undefined, null]);\n * // ➔ [null, undefined]\n * dedupeArray([[], [[]], [[[]]], [[]], [[[]]]]);\n * // ➔ [[], [[]], [[[]]]]\n * const fn = () => 1;\n * dedupeArray([fn, fn, () => 1]);\n * // ➔ [fn, () => 1] cause: ref () => 1 and fn is different but ref const `fn` and `fn` is same ref.\n * dedupeArray([Symbol(\"x\"), Symbol(\"x\")]);\n * // ➔ [Symbol(\"x\")] (symbols are same by identity, so dedupe\n * dedupeArray([NaN, NaN, 1, \"1\"]);\n * // ➔ [NaN, 1, \"1\"]\n * dedupeArray([NaN, NaN, 1, \"1\"], {\n *    forceToString: \"primitives\"\n * }); // ➔ [\"NaN\", \"1\"]\n * dedupeArray([new Date(\"2025-01-01\"), new Date(\"2025-01-01\")]);\n * // ➔ [Date(\"2025-01-01\")] (same time, deduped)\n * dedupeArray([new Date(\"2025-01-01\"), new Date(\"2025-01-01\")], {\n *    forceToString: \"all\"\n * }); // ➔ [\"2025-01-01T00:00:00.000Z\"]\n * dedupeArray([/abc/, /abc/], {\n *    forceToString: \"all\"\n * }); // ➔ [\"/abc/\"]\n * dedupeArray([new Map(), new Set(), new Error(\"err\")], {\n *    forceToString: \"all\"\n * }); // ➔ [\"[object Map]\", \"[object Set]\", \"Error: err\"]\n * dedupeArray([Promise.resolve(1), Promise.resolve(1)], {\n *    forceToString: \"all\"\n * }); // ➔ [\"[object Promise]\"]\n * dedupeArray([{ a: 1 }, { a: 1 }, { a: 2 }], {\n *    forceToString: \"primitives\"\n * }); // ➔ [{ a: \"1\" }, { a: \"2\" }]\n * dedupeArray([{ a: { b: 1 } }, { a: { b: 1 } }], {\n *    forceToString: \"all\"\n * }); // ➔ [{ a: { b: \"1\" } }]\n * dedupeArray(\"not an array\");\n * // ➔ Throws TypeError\n * dedupeArray([1, 2, 3], {\n *    forceToString: \"invalid\"\n * }); // ➔ Throws TypeError\n * ```\n */\nexport const dedupeArray = <\n  ForceToString extends ForceToStringOptions = false,\n  Flattening extends boolean = false\n>(\n  inputArray: unknown[],\n  options: DedupeArrayOptions<ForceToString, Flattening> = {}\n): DedupeResult<ForceToString, Flattening> => {\n  assertIsArray(inputArray, {\n    message: ({ currentType, validType }) =>\n      `First parameter (\\`inputArray\\`) must be of type \\`${validType}\\` (array literal or instance), but received: \\`${currentType}\\`.`\n  });\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const flatten = hasOwnProp(options, \"flatten\") ? options.flatten : false;\n  const forceToString = hasOwnProp(options, \"forceToString\")\n    ? options.forceToString\n    : false;\n\n  if (\n    !(\n      forceToString === false ||\n      forceToString === \"stringOrNumber\" ||\n      forceToString === \"primitives\" ||\n      forceToString === \"all\"\n    )\n  ) {\n    throw new TypeError(\n      `Parameter \\`forceToString\\` property of the \\`options\\` (second parameter) must be of type \\`false\\` or \\`string\\` with value one of \"stringOrNumber\" | \"primitives\" | \"all\", but received: \\`${getPreciseType(\n        forceToString\n      )}\\`, with value: \\`${safeStableStringify(forceToString, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  assertIsBoolean(flatten, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`flatten\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const process = (arr: unknown[]): unknown[] => {\n    const seen: unknown[] = [];\n    return arr.reduce<unknown[]>((acc, item) => {\n      const value = isArray(item)\n        ? process(item)\n        : toStringDeepForce(item, forceToString);\n\n      if (!seen.some((s) => isEqual(s, value))) {\n        seen.push(value);\n        acc.push(value);\n      }\n      return acc;\n    }, []);\n  };\n\n  const deepFlatten = (value: unknown): unknown[] => {\n    if (isArray(value)) {\n      return value.flatMap(deepFlatten);\n    }\n\n    if (isSet(value)) {\n      return [...value].flatMap(deepFlatten);\n    }\n\n    if (isMap(value)) {\n      return [...value.values()].flatMap(deepFlatten);\n    }\n\n    return [value];\n  };\n\n  return (\n    flatten ? process(deepFlatten(inputArray)) : process(inputArray)\n  ) as DedupeResult<ForceToString, Flattening>;\n};\n","import { isNil } from \"@/predicates/is/isNil\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isNonEmptyValue } from \"@/predicates/is/isNonEmptyValue\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** ---------------------------------\n * * ***Utility: `toBooleanContent`.***\n * ---------------------------------------------\n * **Converts a given value into a boolean (***strict***).**\n * - **This is stricter than normal JS coercion:**\n *    - `null` and `undefined` return `false`.\n *    - Empty strings return `false`, non-empty strings return `true`.\n *    - Numbers: `0` is `false`, others `true`.\n *    - Booleans returned as-is.\n *    - Arrays: `[]` is `false`, non-empty is `true`.\n *    - Objects: `{}` is `false`, object with keys is `true`.\n * @param {*} value - The value to be converted.\n * @returns {boolean} Return `true` if the value is considered non-empty, otherwise `false`.\n * @example\n * toBooleanContent(null);      // ➔ false\n * toBooleanContent(undefined); // ➔ false\n * toBooleanContent(\"\");        // ➔ false\n * toBooleanContent(\"  \");      // ➔ false\n * toBooleanContent(\"abc\");     // ➔ true\n * toBooleanContent(\" asd \");   // ➔ true\n * toBooleanContent(0);         // ➔ false\n * toBooleanContent(42);        // ➔ true\n * toBooleanContent(NaN);       // ➔ true\n * toBooleanContent([]);        // ➔ false\n * toBooleanContent([1]);       // ➔ true\n * toBooleanContent({});        // ➔ false\n * toBooleanContent({ a: 1 });  // ➔ true\n * toBooleanContent({[Symbol(\"key\")]: 123}); // ➔ false\n */\nexport const toBooleanContent = (value: unknown): boolean => {\n  if (isNil(value)) return false;\n  if (isString(value)) return isNonEmptyString(value);\n  if (isBoolean(value)) return value;\n  if (isNumber(value, { includeNaN: true })) return value !== 0;\n  if (isArray(value) || isObject(value)) return isNonEmptyValue(value);\n  return Boolean(value);\n};\n","import { isNil } from \"@/predicates/is/isNil\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** -------------------------------------------------\n * * ***Utility: `toBooleanContentDeep`.***\n * ---------------------------------------------\n * **This function does a deep inspection to determine if the input\n * contains any meaningful / non-empty value.**\n * @description\n * It is stricter than JavaScript's normal truthy checks because it looks *inside*\n * nested arrays & objects (recursively checks).\n * - **Rules:**\n *    - `null` and `undefined` return `false`\n *    - Empty strings `\"\"` return `false`\n *    - `0` returns `false`\n *    - Empty arrays `[]` or empty objects `{}` return `false`\n *    - Checks deeply nested arrays/objects — if any value inside is \"non-empty\", returns `true`\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if the value or anything nested inside is non-empty, otherwise `false`.\n * @example\n * toBooleanContentDeep(null);          // ➔ false\n * toBooleanContentDeep(\"\");            // ➔ false\n * toBooleanContentDeep(0);             // ➔ false\n * toBooleanContentDeep([]);            // ➔ false\n * toBooleanContentDeep({});            // ➔ false\n * toBooleanContentDeep([[], {}]);      // ➔ false\n * toBooleanContentDeep(\"abc\");         // ➔ true\n * toBooleanContentDeep(42);            // ➔ true\n * toBooleanContentDeep(NaN);           // ➔ true\n * toBooleanContentDeep([0, \"\", 5]);    // ➔ true\n * toBooleanContentDeep([NaN, \"\", 0]);  // ➔ true\n * toBooleanContentDeep([0, \"\", null]); // ➔ false\n * toBooleanContentDeep({ a: 0 });      // ➔ false\n * toBooleanContentDeep({ a: 1 });      // ➔ true\n * toBooleanContentDeep({ a: { b: [] }});  // ➔ false\n * toBooleanContentDeep({ a: { b: \"x\" }}); // ➔ true\n * toBooleanContentDeep({[Symbol(\"key\")]: 123}); // ➔false\n */\nexport const toBooleanContentDeep = (value: unknown): boolean => {\n  if (isNil(value)) return false;\n  if (isString(value)) return isNonEmptyString(value);\n  if (isBoolean(value)) return value;\n  if (isNumber(value, { includeNaN: true })) return value !== 0;\n  if (isArray(value)) return value.some(toBooleanContentDeep);\n  if (isObject(value)) return Object.values(value).some(toBooleanContentDeep);\n\n  return false;\n};\n","import { isNil } from \"@/predicates/is/isNil\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\n\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\ntype ToBooleanExplicitOptions = {\n  /** Whether string comparison ignores case, _defaultValue: `false`_.\n   *\n   * @default false\n   */\n  caseInsensitive?: boolean;\n  /** Whether to trim whitespace before comparison, _defaultValue: `true`_.\n   *\n   * @default true\n   */\n  trimString?: boolean;\n  /** Whether to consider the string `\"indeterminate\"` as `true`, _defaultValue: `false`_.\n   *\n   * @default false\n   */\n  includeIndeterminate?: boolean;\n};\n\n/** ---------------------------------\n * * ***Utility: `toBooleanExplicit`.***\n * ---------------------------------------------\n * **Converts a value into a strict boolean.**\n * - **Behavior:**\n *    - It supports various common string representations of truthy values,\n *      including `\"true\"`, `\"on\"`, `\"yes\"`, `\"1\"`, the number `1`, the boolean `true`,\n *      and optionally the string `\"indeterminate\"` if enabled.\n * - **ℹ️ Note:**\n *    - Any other value, including `undefined`, `null`, `false`, `0`, and\n *      unrecognized strings will return `false`.\n *    - Supports optional `caseInsensitive` and `trimString` to customize\n *      string normalization.\n * @param {*} value - The value to convert.\n * @param {ToBooleanExplicitOptions} [options] - Options for conversion behavior.\n * @param {ToBooleanExplicitOptions[\"caseInsensitive\"]} [options.caseInsensitive=false] - Whether string comparison ignores case, default: `false`.\n * @param {ToBooleanExplicitOptions[\"trimString\"]} [options.trimString=true] - Whether to trim whitespace before comparison, default: `true`.\n * @param {ToBooleanExplicitOptions[\"includeIndeterminate\"]} [options.includeIndeterminate=false] - If `true`, the string `\"indeterminate\"` is considered a truthy value, defaults to `false`.\n * @returns {boolean} Return `true` if the value matches a truthy representation, otherwise `false`.\n * @throws **{@link TypeError | `TypeError`}** if any option provided is not a boolean.\n * @example\n * toBooleanExplicit(1);\n * // ➔ true\n * toBooleanExplicit(true);\n * // ➔ true\n * toBooleanExplicit(\"on\");\n * // ➔ true\n * toBooleanExplicit(\"1\");\n * // ➔ true\n * toBooleanExplicit(0);\n * // ➔ false\n * toBooleanExplicit(\"off\");\n * // ➔ false\n * toBooleanExplicit(\"Yes\");\n * // ➔ false (caseInsensitive is false by default)\n * toBooleanExplicit(\" yes \");\n * // ➔ true (whitespace trimmed by default)\n * toBooleanExplicit(\"YES\", { caseInsensitive: true });\n * // ➔ true\n * toBooleanExplicit(\"YES\", { caseInsensitive: false });\n * // ➔ false\n * toBooleanExplicit(\" YES \", { trimString: false });\n * // ➔ false (whitespace not trimmed)\n * toBooleanExplicit(\" YES \", { trimString: true, caseInsensitive: true });\n * // ➔ true\n * toBooleanExplicit(\" YES \", { trimString: true, caseInsensitive: false });\n * // ➔ false\n * toBooleanExplicit(\"indeterminate\");\n * // ➔ false (default)\n * toBooleanExplicit(\"indeterminate\", { includeIndeterminate: true });\n * // ➔ true\n */\nexport const toBooleanExplicit = (\n  value: unknown,\n  options: ToBooleanExplicitOptions = {}\n): boolean => {\n  if (isNil(value)) return false;\n\n  if (!isPlainObject(options)) options = {};\n\n  const ci = hasOwnProp(options, \"caseInsensitive\")\n    ? options.caseInsensitive\n    : false;\n  const ts = hasOwnProp(options, \"trimString\") ? options.trimString : true;\n  const incInd = hasOwnProp(options, \"includeIndeterminate\")\n    ? options.includeIndeterminate\n    : false;\n\n  if (!isBoolean(ci) || !isBoolean(ts) || !isBoolean(incInd)) {\n    throw new TypeError(\n      `Parameters \\`caseInsensitive\\`, \\`trimString\\` and \\`includeIndeterminate\\` property of the \\`options\\` (second parameter) expected to be a \\`boolean\\` type, but received: ['caseInsensitive': \\`${getPreciseType(\n        ci\n      )}\\`, 'trimString': \\`${getPreciseType(\n        ts\n      )}\\`, 'includeIndeterminate': \\`${getPreciseType(incInd)}\\`].`\n    );\n  }\n\n  if (isString(value)) {\n    let normalized = value;\n    if (ts) normalized = normalized.trim();\n    if (ci) normalized = normalized.toLowerCase();\n\n    const validTrueStrings = [\"true\", \"on\", \"yes\", \"1\"];\n    if (incInd) validTrueStrings.push(\"indeterminate\");\n\n    return validTrueStrings.includes(normalized);\n  }\n\n  if (isNumber(value)) return value === 1;\n  if (isBoolean(value)) return value;\n\n  return false;\n};\n","import { isNil } from \"@/predicates/is/isNil\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isEmptyString } from \"@/predicates/is/isEmptyString\";\n\n/** ---------------------------------\n * * ***Utility: `toBooleanLoose`.***\n * ---------------------------------------------\n * **Converts a given value into a boolean (loose).**\n * - **This follows JavaScript's typical truthy/falsy rules with some tweaks:**\n *    - `null` and `undefined` return `false`.\n *    - Empty strings return `false`, non-empty strings return `true`.\n *    - Numbers: `0` is `false`, others `true`.\n *    - Booleans returned as-is.\n *    - Arrays: `[]` is `false`, non-empty is `true`.\n *    - Other objects: uses `Boolean(value)`, so `{}` is `true`.\n * @param {*} value - The value to be converted.\n * @returns {boolean} Return `true` if the value is truthy, otherwise `false`.\n * @example\n * toBooleanLoose(null);     // ➔ false\n * toBooleanLoose(\"\");       // ➔ false\n * toBooleanLoose(\"abc\");    // ➔ true\n * toBooleanLoose(0);        // ➔ false\n * toBooleanLoose(42);       // ➔ true\n * toBooleanLoose([]);       // ➔ false\n * toBooleanLoose([1]);      // ➔ true\n * toBooleanLoose({});       // ➔ true\n * toBooleanLoose({ a: 1 }); // ➔ true\n */\nexport const toBooleanLoose = (value: unknown): boolean => {\n  if (isNil(value)) return false;\n  if (isString(value)) return !isEmptyString(value);\n  if (isBoolean(value)) return value;\n  if (isNumber(value, { includeNaN: true })) return value !== 0;\n  if (isArray(value)) return value.length > 0;\n  return Boolean(value);\n};\n","import { isNaN } from \"@/predicates/is/isNaN\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `convertType`.***\n * ---------------------------------------------\n * **Converts a value from a string to its corresponding JavaScript primitive type.**\n * - **Supported conversions for string inputs (case-insensitive, trimmed):**\n *    - `\"true\"`           ➔ `true` (***boolean***).\n *    - `\"false\"`          ➔ `false` (***boolean***).\n *    - `\"null\"`           ➔ `null` (***null***).\n *    - `\"yes\"`            ➔ `true` (***boolean***).\n *    - `\"no\"`             ➔ `false` (***boolean***).\n *    - `\"nan\"` or `\"NaN\"` ➔ `NaN` (***number***).\n *    - `\"undefined\"`      ➔ `undefined` (***undefined***).\n * - Numeric strings with optional thousands separators (e.g. `\"3,567,890.14\"`) ➔ `3567890.14` ***as a `number` type***.\n * - Strings containing only whitespace are converted to empty string `\"\"`.\n * - Non-string inputs are returned unchanged.\n * - Strings not matching any special case are trimmed and returned as-is.\n * @param {*} value - The value to convert, usually a string or other type.\n * @returns {*} The converted JavaScript primitive (***`boolean`***, ***`number`***, ***`null`***, ***`undefined`***, ***`NaN`***) or the original value if no conversion applies.\n * @example\n * convertType(\"true\");          // ➔ true\n * convertType(\" 42 \");          // ➔ 42\n * convertType(\"FALSE\");         // ➔ false\n * convertType(\" null \");        // ➔ null\n * convertType(\"   \");           // ➔ \"\"\n * convertType(\" Hello World \"); // ➔ \"Hello World\"\n * convertType(\"NaN\");           // ➔ NaN\n * convertType(100);             // ➔ 100\n * convertType(NaN);             // ➔ NaN\n * convertType({});              // ➔ {}\n */\nexport const convertType = (value: unknown): unknown => {\n  const predefinedValues: Record<string, unknown> = {\n    undefined: undefined,\n    null: null,\n    nan: NaN,\n    true: true,\n    false: false,\n    yes: true,\n    no: false\n  };\n\n  if (isString(value)) {\n    const normalized = value.trim().toLowerCase();\n\n    if (Object.prototype.hasOwnProperty.call(predefinedValues, normalized)) {\n      return predefinedValues[normalized];\n    }\n\n    // Support numbers with thousand separators\n    const numericString = normalized.replace(/,/g, \"\");\n\n    const numberString = Number(numericString);\n    if (!isNaN(numberString) && isNonEmptyString(numericString)) {\n      return numberString;\n    }\n\n    return value.trim();\n  }\n\n  return value;\n};\n","import { isFunction } from \"@/predicates/is/isFunction\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { removeObjectPaths } from \"../../removeObjectPaths\";\n\n/** @private ***Util helper for {@link removeObjectPaths | `removeObjectPaths`}.*** */\nexport const deepCloneSafe = <U>(obj: U): U => {\n  try {\n    if (isFunction(structuredClone)) {\n      return structuredClone(obj);\n    }\n    // eslint-disable-next-line no-empty\n  } catch {}\n  return JSON.parse(JSON.stringify(obj));\n};\n","import { isArray } from \"@/predicates/is/isArray\";\nimport { isEmptyArray } from \"@/predicates/is/isEmptyArray\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { isObjectOrArray } from \"@/predicates/is/isObjectOrArray\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { removeObjectPaths } from \"../../removeObjectPaths\";\n\n/** @private ***Util helper for {@link removeObjectPaths | `removeObjectPaths`}.*** */\nexport const deleteNestedKey = <T extends Record<string, unknown> | unknown[]>(\n  obj: T,\n  path: string[]\n): T => {\n  if (!isObjectOrArray(obj)) return obj;\n\n  const [currentKey, ...rest] = path;\n\n  if (isArray(obj)) {\n    for (const item of obj) {\n      // recursive pass same path\n      if (isObjectOrArray(item)) deleteNestedKey(item, path);\n    }\n  } else if (isEmptyArray(rest)) {\n    if (isPlainObject(obj)) delete obj[currentKey];\n  } else if (isPlainObject(obj) && isObjectOrArray(obj[currentKey])) {\n    deleteNestedKey(obj[currentKey], rest);\n  }\n\n  return obj;\n};\n","import { isPlainObject } from \"@/predicates/is/isPlainObject\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { removeObjectPaths } from \"../../removeObjectPaths\";\n\n/** @private ***Util helper for {@link removeObjectPaths | `removeObjectPaths`}.*** */\nexport const deleteExactPathOnce = <T extends Record<string, unknown>>(\n  obj: T,\n  path: string[]\n): T => {\n  if (!isPlainObject(obj)) return obj;\n\n  const [currentKey, ...rest] = path;\n\n  if (rest.length === 0) {\n    if (isPlainObject(obj)) delete obj[currentKey];\n  } else if (isPlainObject(obj[currentKey])) {\n    deleteExactPathOnce(obj[currentKey], rest);\n  }\n\n  return obj;\n};\n","import type {\n  ConfigRemoveObjectPaths,\n  ResultRemoveObjectPaths\n} from \"./_private/removeObjectPaths.types\";\n\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\nimport { isEmptyObject } from \"@/predicates/is/isEmptyObject\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\nimport { assertIsArray } from \"@/assertions/objects/assertIsArray\";\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\n\nimport { deepCloneSafe } from \"./_private/utils/deepCloneSafe\";\nimport { deleteNestedKey } from \"./_private/utils/deleteNestedKey\";\nimport { safeStableStringify } from \"../stringify/safeStableStringify\";\nimport { deleteExactPathOnce } from \"./_private/utils/deleteExactPathOnce\";\n\n/** ------------------------------------------------------------------------\n * * ***Utility: `removeObjectPaths`.***\n * ------------------------------------------------------------------------\n * **Deletes multiple keys (shallow or deeply nested) from an object.**\n * - **Features:**\n *    - Removes one or more keys from an object based on their paths (supports dot notation for nested properties).\n *    - Can delete deeply from all matching nested levels (even inside arrays) when `deep: true`.\n *    - By default does **not mutate** the original object. Clones it first.\n *   Set `deepClone = false` to mutate in place (useful for performance on large data).\n *    - Ensures type safety on `key` paths via `DotPath<T>`, reducing accidental invalid paths.\n * - **Behavior:**\n *    - When `deep: false` (default), only deletes the direct property at the specified path.\n *    - When `deep: true`, searches deeply and recursively deletes the key from all levels,\n *   including inside arrays of objects (applies the *same* path repeatedly).\n *    - Skips deletion if the specified path does not exist — no error is thrown.\n * - **Edge Handling:**\n *    - If `object` is `null` or not an object, returns an empty object.\n *    - If `keysToDelete` is not an array of `{ key, deep? }` objects, throws a `TypeError`.\n *    - Ignores invalid intermediate paths (will skip those branches without throwing).\n * @template T - The shape of the input object, used for type-safe dot paths.\n * @param {Record<string, unknown>} object - ***The object to remove keys from, must be an object or will return `{}`.***\n * @param {ConfigRemoveObjectPaths<T>[]} keysToDelete\n *  ***An array of instructions:***\n *   - `key`: A string path using dot notation (e.g. `\"user.profile.name\"`).\n *   - `deep`: If `true`, will recursively remove all instances of the key path at any depth, defaultValue: `false`.\n * @param {boolean|undefined} [deepClone=true]\n *  ***Whether to deep clone the original object before modifying.***\n *   - `true` (default): returns a *new object* with the specified keys removed.\n *   - `false`: modifies the original object in place and returns it.\n * @returns {Partial<T>}\n *   - A new object with specified keys removed if `deepClone` is `true`.\n *   - The *same mutated object* if `deepClone` is `false`.\n * @throws **{@link TypeError | `TypeError`}** if `keysToDelete` is not an array of `{ key, deep? }` objects.\n * @example\n * // Shallow deletion\n * removeObjectPaths(\n *   { a: 1, b: 2, c: { d: 3 } },\n *   [{ key: \"b\" }]\n * );\n * // ➔ { a: 1, c: { d: 3 } }\n *\n * // Nested deletion (shallow, removes only exact path)\n * removeObjectPaths(\n *   { user: { profile: { name: \"Alice\", age: 30 } } },\n *   [{ key: \"user.profile.age\" }]\n * );\n * // ➔ { user: { profile: { name: \"Alice\" } } }\n *\n * // Deep deletion (recursively removes key from all levels and arrays)\n * removeObjectPaths(\n *   { items: [{ price: 10 }, { price: 20, details: { price: 30 } }] },\n *   [{ key: \"price\", deep: true }]\n * );\n * // ➔ { items: [{}, { details: {} }] }\n *\n * // Without cloning: mutates original object\n * const obj = { x: 1, y: 2 };\n * removeObjectPaths(obj, [{ key: \"y\" }], false);\n * console.log(obj); // ➔ { x: 1 }\n *\n * // No matching path — returns unchanged object\n * removeObjectPaths({}, [{ key: \"a\" }]);\n * // ➔ {}\n *\n * // 🚫 Invalid usage — `keysToDelete` is not an array\n * removeObjectPaths({}, \"a\");\n * // ➔ throws TypeError\n *\n * // 🚫 Invalid usage — missing `key` property in array element\n * removeObjectPaths({}, [{ deep: true }]);\n * // ➔ throws TypeError\n */\nexport function removeObjectPaths<\n  T extends Record<string, unknown>,\n  K extends ConfigRemoveObjectPaths<T>[]\n>(\n  object: T,\n  keysToDelete: K,\n  deepClone: boolean = true\n): ResultRemoveObjectPaths<T, K> {\n  if (isEmptyObject(object, { checkSymbols: true }))\n    return {} as ResultRemoveObjectPaths<T, K>;\n\n  assertIsArray(keysToDelete, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`keysToDelete\\`) must be of type \\`${validType}\\` with value of { key: string, deep?: boolean } plain-object, but received: \\`${currentType}\\`, with value: \\`${safeStableStringify(\n        keysToDelete,\n        { keepUndefined: true }\n      )}\\`.`\n  });\n\n  if (!keysToDelete.every((k) => isPlainObject(k) && \"key\" in k)) {\n    throw new TypeError(\n      `Each element in Second Parameter (\\`keysToDelete\\`) must be of type \\`plain-object\\` with at least a \"key\" property (optionally \"deep\"), but received: \\`${safeStableStringify(\n        keysToDelete,\n        { keepUndefined: true }\n      )}\\`.`\n    );\n  }\n\n  let result = deepClone ? deepCloneSafe(object) : object;\n\n  for (const { key, deep } of keysToDelete) {\n    assertIsString(key, {\n      message: ({ currentType, validType }) =>\n        `Parameter \\`key\\` at Second Parameter (\\`keysToDelete\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n    });\n\n    if (!isUndefined(deep) && !isBoolean(deep)) {\n      throw new TypeError(\n        `Parameter \\`deep\\` at Second Parameter (\\`keysToDelete\\`) ➔ (key: \"${key}\", deep: ${deep}) must be of type \\`boolean\\` or \\`undefined\\`, but received: \\`${getPreciseType(\n          deep\n        )}\\`.`\n      );\n    }\n\n    const path = key.split(\".\");\n    result = deep\n      ? deleteNestedKey(result, path)\n      : deleteExactPathOnce(result, path);\n  }\n\n  return result as ResultRemoveObjectPaths<T, K>;\n}\n","import type {\n  ConvertedDeepNumber,\n  ToNumberDeepOptions\n} from \"./_private/toNumberDeep.types\";\n\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isMap } from \"@/predicates/is/isMap\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isDate } from \"@/predicates/is/isDate\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isBuffer } from \"@/predicates/is/isBuffer\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isRegExp } from \"@/predicates/is/isRegExp\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\nimport { isEmptyArray } from \"@/predicates/is/isEmptyArray\";\nimport { isTypedArray } from \"@/predicates/is/isTypedArray\";\nimport { isEmptyObject } from \"@/predicates/is/isEmptyObject\";\nimport { isNumberObject } from \"@/predicates/is/isNumberObject\";\nimport { isStringObject } from \"@/predicates/is/isStringObject\";\nimport { isBooleanObject } from \"@/predicates/is/isBooleanObject\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isInfinityNumber } from \"@/predicates/is/isInfinityNumber\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\n/** --------------------------------------------------\n * * ***Utility: `toNumberDeep`.***\n * ---------------------------------------------------\n * **Converts deeply nested arrays, objects, buffers, sets, maps, or typed arrays into numbers while preserving structure.**\n * - **Features:**\n *    - Converts numeric strings, number to numbers:\n *      - `3.5` ➔ `3.5`.\n *      - `\"3.5\"` ➔ `3.5`.\n *    - Converts boolean to number:\n *      - `true` ➔ `1`.\n *      - `false` ➔ `0`.\n *    - Converts Date to getTime (timestamp) `Date ➔ number`, if invalid Date value will return `0`:\n *      - `new Date(\"invalid\")` ➔ `0`.\n *      - `new Date(\"11-09-2025 22:04:11\")` ➔ `1762700651000`.\n *    - Converts `Buffer`, `TypedArray`, `Set`, `Map`, and `arrays` recursively to `arrays of numbers`.\n *    - Converts boxed primitives box into their primitive equivalents then convert to number:\n *      - For `new String` we convert everything to number (behavior JS of new String):\n *        - `new String(123)` ➔ `.valueOf()` ➔ `\"123\"` ➔ `Number(\"123\")` ➔ `123`.\n *        - `new String(\"123\")` ➔ `.valueOf()` ➔ `\"123\"` ➔ `Number(\"123\")` ➔ `123`.\n *        - `new String(true)` ➔ `.valueOf()` ➔ `\"true\"` ➔ `Number(true)` ➔ `1`.\n *        - `new String(false)` ➔ `.valueOf()` ➔ `\"false\"` ➔ `Number(false)` ➔ `0`.\n *        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:\n *          - `new String(\"hi\")` ➔ `.valueOf()` ➔ `\"hi\"` ➔ `Number(\"hi\")` ➔ `NaN` ***(remove)***.\n *          - `new String(()=>{})` ➔ `.valueOf()` ➔ `\"()=>{}\"` ➔ `Number(\"()=>{}\")` ➔ `NaN` ***(remove)***.\n *      - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to number:\n *        - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `Number(true)` ➔ `1`.\n *        - `new Boolean(false)` ➔ `.valueOf()` ➔ `false` ➔ `Number(false)` ➔ `0`.\n *        - Special behavior JS of new Boolean, return `false` **(convert to number: `0`)**\n *          for `false`, (`0` / `-0`), `\"\"` (empty-string),\n *          `null`, `undefined`, `NaN`, otherwise `true` **(convert to number: `1`)**.\n *      - For `new Number`:\n *        - `new Number(42)` ➔ `.valueOf()` ➔ `42`.\n *        - `new Number(\"42\")` ➔ `.valueOf()` ➔ `42`.\n *        - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number).\n *        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:\n *          - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.\n *          - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.\n *          - `new Number(Infinity)` ➔ `.valueOf()` ➔ `Infinity` ***(remove)***.\n *          - `new Number(-Infinity)` ➔ `.valueOf()` ➔ `-Infinity` ***(remove)***.\n *    - Recursively processes `nested objects`, `arrays`, `buffers`, `sets`, `maps`, and `typed arrays`.\n *    - Removes `empty-string`, `non-numeric strings`.\n *    - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.\n *    - Removes `unsupported` types like `functions` , `RegExp`, `symbols`, and `BigInt`.\n *    - Can optionally remove empty arrays (`[]`) and/or empty objects (`{}`) **recursively**.\n * @template T - The input type.\n * @template RemoveEmptyObjects - Whether to remove empty objects.\n * @template RemoveEmptyArrays - Whether to remove empty arrays.\n * @param {*} input - The input value to convert.\n * @param {ToNumberDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>} [options] - Conversion options.\n * @returns {ConvertedDeepNumber<T, RemoveEmptyObjects, RemoveEmptyArrays>|undefined} The converted value, return `undefined` if the input is entirely empty or filtered out by options.\n * @example\n * ```ts\n * toNumberDeep(\"123\");\n * // ➔ 123\n * toNumberDeep(\"abc\");\n * // ➔ undefined\n * toNumberDeep([NaN, \"10\", \"xyz\"]);\n * // ➔ [10]\n * toNumberDeep({ a: \"1\", b: [null, \"2\"] });\n * // ➔ { a: 1, b: [2] }\n * toNumberDeep(Buffer.from([0, 1, 2]));\n * // ➔ [0, 1, 2]\n * toNumberDeep(new Set([\"1\", \"2\"]));\n * // ➔ [1, 2]\n * toNumberDeep(new Map([[\"a\", \"1\"], [\"b\", \"2\"]]));\n * // ➔ [[\"a\", 1], [\"b\", 2]]\n * toNumberDeep(new Int16Array([1, 2, 3]));\n * // ➔ [1, 2, 3]\n * toNumberDeep(new Date(\"2025-08-16T00:00:00Z\"));\n * // ➔ 1755552000000\n * toNumberDeep({ a: {}, b: [] }, { removeEmptyObjects: true });\n * // ➔ { b: [] }\n * toNumberDeep({ a: {}, b: [] }, { removeEmptyArrays: true });\n * // ➔ { a: {} }\n * toNumberDeep({ x: {}, y: [], z: [{ a: {}, b: [] }] }, {\n *    removeEmptyObjects: true, removeEmptyArrays: true\n * });\n * // ➔ { z: [] }\n * ```\n */\nexport function toNumberDeep(\n  input?: null | undefined,\n  options?: ToNumberDeepOptions<boolean, boolean>\n): undefined;\nexport function toNumberDeep<\n  T,\n  RemoveEmptyObjects extends boolean = false,\n  RemoveEmptyArrays extends boolean = false\n>(\n  input: T,\n  options?: ToNumberDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>\n): ConvertedDeepNumber<T, RemoveEmptyObjects, RemoveEmptyArrays>;\nexport function toNumberDeep<\n  T,\n  RemoveEmptyObjects extends boolean = false,\n  RemoveEmptyArrays extends boolean = false\n>(\n  input: T,\n  options: ToNumberDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays> = {}\n) {\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const removeEmptyObjects = hasOwnProp(options, \"removeEmptyObjects\")\n    ? options.removeEmptyObjects\n    : false;\n  const removeEmptyArrays = hasOwnProp(options, \"removeEmptyArrays\")\n    ? options.removeEmptyArrays\n    : false;\n\n  function _internal<\n    T,\n    RemoveEmptyObjects extends boolean,\n    RemoveEmptyArrays extends boolean\n  >(\n    input: T,\n    options: Required<\n      ToNumberDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>\n    > & {\n      isRoot: boolean;\n    }\n  ): unknown {\n    if (isNil(input) || isRegExp(input)) return undefined;\n\n    const { removeEmptyArrays, removeEmptyObjects, isRoot } = options;\n\n    if (!isBoolean(removeEmptyObjects) || !isBoolean(removeEmptyArrays)) {\n      throw new TypeError(\n        `Parameters \\`removeEmptyObjects\\` and \\`removeEmptyArrays\\` property of the \\`options\\` (second parameter) must be of type \\`boolean\\`, but received: ['removeEmptyObjects': \\`${getPreciseType(\n          removeEmptyObjects\n        )}\\`, 'removeEmptyArrays': \\`${getPreciseType(removeEmptyArrays)}\\`].`\n      );\n    }\n\n    // primitive boolean, numbers, or numeric strings\n    if (isNumber(input) || isBoolean(input) || isNonEmptyString(input)) {\n      const num = Number(input);\n      return isInfinityNumber(num) || isNaN(num) ? undefined : num;\n    }\n\n    if (\n      isNumberObject(input) ||\n      isStringObject(input) ||\n      isBooleanObject(input)\n    ) {\n      const valOf = Number(input.valueOf());\n      return isInfinityNumber(valOf) || isNaN(valOf) ? undefined : valOf;\n    }\n\n    if (isDate(input, { skipInvalidDate: true })) {\n      try {\n        return !isNaN(input.getTime()) ? input.getTime() : 0;\n      } catch {\n        return 0;\n      }\n    }\n\n    if (isBuffer(input)) {\n      const arr = Array.from(input)\n        .map((n) =>\n          _internal(n, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          })\n        )\n        .filter((item) => !isUndefined(item));\n      if (removeEmptyArrays && isEmptyArray(arr)) return undefined;\n      return arr;\n    }\n\n    if (isTypedArray(input)) {\n      // If BigInt TypedArray\n      if (input instanceof BigInt64Array || input instanceof BigUint64Array) {\n        const newArray = Array.from(input)\n          .map((item) =>\n            _internal(item, {\n              removeEmptyObjects,\n              removeEmptyArrays,\n              isRoot: false\n            })\n          )\n          .filter((item) => !isUndefined(item));\n\n        if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n        return newArray;\n      } else {\n        // All TypedArray based of number\n        const newArray = Array.from(input)\n          .map((item) =>\n            _internal(item, {\n              removeEmptyObjects,\n              removeEmptyArrays,\n              isRoot: false\n            })\n          )\n          .filter((item) => !isUndefined(item));\n\n        if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n        return newArray;\n      }\n    }\n\n    if (isSet(input)) {\n      const newArray = Array.from(input)\n        .map((item) =>\n          _internal(item, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          })\n        )\n        .filter((item) => !isUndefined(item));\n\n      if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n      return newArray;\n    }\n\n    if (isMap(input)) {\n      let newArray = Array.from(input.entries())\n        .map(([k, v]) => {\n          const key = _internal(k, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          });\n          const value = _internal(v, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          });\n          return !isUndefined(key) && !isUndefined(value)\n            ? [key, value]\n            : undefined;\n        })\n        .filter((item) => !isUndefined(item));\n\n      // remove empty arrays recursively\n      if (removeEmptyArrays) {\n        newArray = newArray.filter((v) => !isEmptyArray(v));\n      }\n\n      if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n      return newArray;\n    }\n\n    if (isArray(input)) {\n      const newArray = input\n        .map((item) =>\n          _internal(item, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          })\n        )\n        .filter((item) => !isUndefined(item));\n\n      if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n      return newArray;\n    }\n\n    if (isObject(input)) {\n      const newObject: Record<string, unknown> = {};\n\n      for (const [key, value] of Object.entries(input)) {\n        const convertedValue = _internal(value, {\n          removeEmptyObjects,\n          removeEmptyArrays,\n          isRoot: false\n        });\n        if (!isUndefined(convertedValue)) {\n          newObject[key] = convertedValue;\n        }\n      }\n\n      if (removeEmptyObjects && isEmptyObject(newObject)) {\n        return isRoot ? {} : undefined;\n      }\n\n      return newObject;\n    }\n\n    return undefined;\n  }\n\n  return _internal(input, {\n    removeEmptyObjects,\n    removeEmptyArrays,\n    isRoot: true\n  });\n}\n","import type {\n  ConvertedDeepString,\n  ToStringDeepOptions\n} from \"./_private/toStringDeep.types\";\n\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isMap } from \"@/predicates/is/isMap\";\nimport { isDate } from \"@/predicates/is/isDate\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isBuffer } from \"@/predicates/is/isBuffer\";\nimport { isObject } from \"@/predicates/is/isObject\";\nimport { isRegExp } from \"@/predicates/is/isRegExp\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\nimport { isEmptyArray } from \"@/predicates/is/isEmptyArray\";\nimport { isTypedArray } from \"@/predicates/is/isTypedArray\";\nimport { isNumberObject } from \"@/predicates/is/isNumberObject\";\nimport { isStringObject } from \"@/predicates/is/isStringObject\";\nimport { isBooleanObject } from \"@/predicates/is/isBooleanObject\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isInfinityNumber } from \"@/predicates/is/isInfinityNumber\";\n\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\n/** --------------------------------------------------\n * * ***Utility: `toStringDeep`.***\n * ---------------------------------------------------\n * **Converts all values in an array, object, Set, Map, or deeply nested structure to string.**\n * - **Features:**\n *    - Converts numbers and strings to string:\n *      - `3.5` ➔ `\"3.5\"`.\n *      - `\"3.5\"` ➔ `\"3.5\"`.\n *    - Converts boolean to string:\n *      - `true` ➔ `\"true\"`.\n *      - `false` ➔ `\"false\"`.\n *    - Converts Date to ISO string (`Date ➔ string`).\n *    - Converts RegExp to string (e.g., `/abc/ ➔ \"/abc/\"`).\n *    - Converts `Buffer`, `TypedArray`, `Set`, `Map`, and `arrays` recursively to `arrays of strings`.\n *    - Converts boxed primitives box into their primitive equivalents then convert to string:\n *      - For `new String` we convert everything to string (behavior JS of new String):\n *        - `new String(\"hi\")` ➔ `.valueOf()` ➔ `\"hi\"`.\n *        - `new String(true)` ➔ `.valueOf()` ➔ `\"true\"`.\n *      - For `new Boolean` we convert to boolean (behavior JS of new Boolean) then convert to string:\n *        - `new Boolean(true)` ➔ `.valueOf()` ➔ `true` ➔ `true.toString()` ➔ `\"true\"`.\n *        - Special behavior JS of new Boolean, return `false` **(convert to string: `\"false\"`)**\n *          for `false`, (`0` / `-0`), `\"\"` (empty-string), `null`, `undefined`, `NaN`, otherwise\n *          `true` **(convert to string: `\"true\"`)**.\n *      - For `new Number`:\n *        - `new Number(42)` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `\"42\"`.\n *        - `new Number(\"42\")` ➔ `.valueOf()` ➔ `42` ➔ `42.toString()` ➔ `\"42\"`.\n *        - `new Number(null)` ➔ `.valueOf()` ➔ `0` (`null` is `0` behavior JS of new Number) ➔ `0.toString()` ➔ `\"0\"`.\n *        - If result from `valueOf()` is `NaN` or `Infinity` ***(will removing)***:\n *          - `new Number(NaN)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.\n *          - `new Number(\"abc\")` ➔ `.valueOf()` ➔ `NaN`  ***(remove)***.\n *          - `new Number(undefined)` ➔ `.valueOf()` ➔ `NaN` ***(remove)***.\n *          - `new Number(Infinity)` ➔ `.valueOf()` ➔ `Infinity` ***(remove)***.\n *          - `new Number(-Infinity)` ➔ `.valueOf()` ➔ `-Infinity` ***(remove)***.\n *    - Recursively processes `nested objects`, `arrays`, `buffers`, `sets`, `maps`, and `typed arrays`.\n *    - Removes `null`, `undefined`, `NaN`, `Infinity`, `-Infinity`.\n *    - Removes `unsupported` types like `functions`, `symbols`, and `BigInt`.\n *    - Can optionally remove empty arrays (`[]`) and/or empty objects (`{}`) **recursively**.\n * @template T - The input data type (`primitive`, `object`, `array`, `Set`, `Map`, or `any nested combination`).\n * @template RemoveEmptyObjects - If `true`, empty objects `{}` will be removed recursively.\n * @template RemoveEmptyArrays - If `true`, empty arrays `[]` will be removed recursively (including arrays nested in `objects` / `arrays` / `Sets` / `Maps`).\n * @param {*} input - The data to convert.\n * @param {ToStringDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>} [options] - Conversion options.\n * @returns {ConvertedDeepString<T, RemoveEmptyObjects, RemoveEmptyArrays>|undefined}\n * The transformed data, or `undefined` if the entire structure becomes empty after processing.\n * @example\n * ```ts\n * // Simple array conversion\n * toStringDeep([1, \"2\", 3]);\n * // ➔ [\"1\", \"2\", \"3\"]\n *\n * // Simple top-level conversion\n * toStringDeep(123);\n * // ➔ \"123\"\n * toStringDeep(\"123\");\n * // ➔ \"123\"\n * toStringDeep(true);\n * // ➔ \"true\"\n * toStringDeep(false);\n * // ➔ \"false\"\n *\n * // Nested arrays\n * toStringDeep([1, [\"2\", [3, [null, \"4\", true, false]]]]);\n * // ➔ [\"1\", [\"2\", [\"3\", [\"4\", \"true\", \"false\"]]]]\n *\n * // Object with nested values\n * toStringDeep({ a: 1, b: \"2\", c: { d: 3, e: null, f: true, g: false } });\n * // ➔ { a: \"1\", b: \"2\", c: { d: \"3\", f: \"true\", g: \"false\" } }\n *\n * // Removing empty objects\n * toStringDeep({ a: {}, b: \"1\" }, { removeEmptyObjects: true });\n * // ➔ { b: \"1\" }\n *\n * // Removing empty arrays recursively\n * toStringDeep([\"1\", [], { a: [] }], { removeEmptyArrays: true });\n * // ➔ [\"1\", { a: [] }]\n *\n * // Removing both empty objects and arrays recursively\n * toStringDeep({ a: {}, b: [], c: [{ d: {}, e: [] }, \"1\"] }, {\n *   removeEmptyObjects: true,\n *   removeEmptyArrays: true\n * });\n * // ➔ { c: [\"1\"] }\n *\n * // Fully empty structure becomes undefined\n * toStringDeep([null, undefined, {}], {\n *   removeEmptyObjects: true,\n *   removeEmptyArrays: true\n * });\n * // ➔ undefined\n * ```\n */\nexport function toStringDeep(\n  input?: null | undefined,\n  options?: ToStringDeepOptions<boolean, boolean>\n): undefined;\nexport function toStringDeep<\n  T,\n  RemoveEmptyObjects extends boolean = false,\n  RemoveEmptyArrays extends boolean = false\n>(\n  input: T,\n  options?: ToStringDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>\n): ConvertedDeepString<T, RemoveEmptyObjects, RemoveEmptyArrays>;\nexport function toStringDeep<\n  T,\n  RemoveEmptyObjects extends boolean = false,\n  RemoveEmptyArrays extends boolean = false\n>(\n  input: T,\n  options: ToStringDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays> = {}\n) {\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const removeEmptyObjects = hasOwnProp(options, \"removeEmptyObjects\")\n    ? options.removeEmptyObjects\n    : false;\n  const removeEmptyArrays = hasOwnProp(options, \"removeEmptyArrays\")\n    ? options.removeEmptyArrays\n    : false;\n\n  function _internal<\n    T,\n    RemoveEmptyObjects extends boolean,\n    RemoveEmptyArrays extends boolean\n  >(\n    input: T,\n    options: Required<\n      ToStringDeepOptions<RemoveEmptyObjects, RemoveEmptyArrays>\n    > & {\n      isRoot: boolean;\n    }\n  ): unknown {\n    if (isNil(input) || isInfinityNumber(input)) return undefined;\n\n    const { removeEmptyArrays, removeEmptyObjects, isRoot } = options;\n\n    if (!isBoolean(removeEmptyObjects) || !isBoolean(removeEmptyArrays)) {\n      throw new TypeError(\n        `Parameters \\`removeEmptyObjects\\` and \\`removeEmptyArrays\\` property of the \\`options\\` (second parameter) must be of type \\`boolean\\`, but received: ['removeEmptyObjects': \\`${getPreciseType(\n          removeEmptyObjects\n        )}\\`, 'removeEmptyArrays': \\`${getPreciseType(removeEmptyArrays)}\\`].`\n      );\n    }\n\n    if (isNumber(input) || isString(input) || isBoolean(input))\n      return String(input);\n\n    if (isNumberObject(input)) {\n      const valOf = input.valueOf();\n      return isInfinityNumber(valOf) || isNaN(valOf)\n        ? undefined\n        : valOf.toString();\n    }\n    if (isStringObject(input)) return input.valueOf();\n    if (isBooleanObject(input)) return input.valueOf().toString();\n\n    if (isDate(input, { skipInvalidDate: true })) {\n      try {\n        return input.toISOString();\n      } catch {\n        return input.toString();\n      }\n    }\n\n    if (isRegExp(input)) return input.toString();\n\n    if (isBuffer(input)) {\n      return Array.from(input)\n        .map((v) => String(v))\n        .filter((v) => !isUndefined(v));\n    }\n\n    if (isTypedArray(input)) {\n      // If BigInt TypedArray\n      if (input instanceof BigInt64Array || input instanceof BigUint64Array) {\n        const newArray = Array.from(input)\n          .map((item) =>\n            _internal(item, {\n              removeEmptyObjects,\n              removeEmptyArrays,\n              isRoot: false\n            })\n          )\n          .map((v) => String(v))\n          .filter((item) => !isUndefined(item));\n\n        if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n        return newArray;\n      } else {\n        // All TypedArray based of number\n        const newArray = Array.from(input)\n          .map((item) =>\n            _internal(item, {\n              removeEmptyObjects,\n              removeEmptyArrays,\n              isRoot: false\n            })\n          )\n          .map((v) => String(v))\n          .filter((item) => !isUndefined(item));\n\n        if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n        return newArray;\n      }\n    }\n\n    if (isSet(input)) {\n      const arr = Array.from(input)\n        .map((v) =>\n          _internal(v, { removeEmptyObjects, removeEmptyArrays, isRoot: false })\n        )\n        .filter((v) => !isUndefined(v));\n      if (removeEmptyArrays && isEmptyArray(arr)) return undefined;\n      return arr;\n    }\n\n    // Map ➔ array of [key, value]\n    if (isMap(input)) {\n      const arr = Array.from(input.entries())\n        .map(([k, v]) => [\n          _internal(k, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          }),\n          _internal(v, { removeEmptyObjects, removeEmptyArrays, isRoot: false })\n        ])\n        .filter(([k, v]) => !isUndefined(k) && !isUndefined(v));\n      if (removeEmptyArrays && isEmptyArray(arr)) return undefined;\n      return arr;\n    }\n\n    if (isArray(input)) {\n      let newArray = input\n        .map((item) =>\n          _internal(item, {\n            removeEmptyObjects,\n            removeEmptyArrays,\n            isRoot: false\n          })\n        )\n        .filter((item) => !isUndefined(item));\n\n      // remove empty arrays recursively\n      if (removeEmptyArrays) {\n        newArray = newArray.filter((v) => !(isArray(v) && v.length === 0));\n      }\n\n      if (removeEmptyArrays && isEmptyArray(newArray)) return undefined;\n      return newArray;\n    }\n\n    if (isObject(input)) {\n      const newObject: Record<string, unknown> = {};\n\n      for (const [key, value] of Object.entries(input)) {\n        const convertedValue = _internal(value, {\n          removeEmptyObjects,\n          removeEmptyArrays,\n          isRoot: false\n        });\n\n        if (!isUndefined(convertedValue)) {\n          newObject[key] = convertedValue;\n        } else if (isArray(value) && !removeEmptyArrays) {\n          // preserve empty array property\n          newObject[key] = [];\n        }\n      }\n\n      if (removeEmptyObjects && Object.keys(newObject).length === 0) {\n        return isRoot ? {} : undefined;\n      }\n\n      return newObject;\n    }\n\n    return undefined;\n  }\n\n  return _internal(input, {\n    removeEmptyObjects,\n    removeEmptyArrays,\n    isRoot: true\n  });\n}\n"],"mappings":"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"}

package/dist/formatEnvPort-DpIXzPAZ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatEnvPort-DpIXzPAZ.js","names":[],"sources":["../src/urls/_private/NormalizePathnameError.ts","../src/urls/pathname/normalizePathname.ts","../src/urls/utils/formatEnvPort.ts"],"sourcesContent":["import { isFunction } from \"@/predicates/is/isFunction\";\n\n/** ---------------------------------\n * * ***Custom Error for Pathname Normalization Failures***\n * --------------------------------- */\nexport class NormalizePathnameError extends Error {\n  /** * ***The original error that triggered this normalization failure.***\n   *\n   * **Always available for backward compatibility.**\n   */\n  public readonly originalError: Error;\n\n  constructor(message: string, originalError: Error) {\n    // Pass a `cause` option if the runtime supports it (ignored by older engines).\n    super(message, isFunction(Error) ? { cause: originalError } : undefined);\n\n    this.name = \"NormalizePathnameError\";\n    this.originalError = originalError;\n\n    // Preserve stack trace when available (Node.js & modern browsers).\n    if (isFunction(Error.captureStackTrace)) {\n      Error.captureStackTrace(this, NormalizePathnameError);\n    } else {\n      // Fallback for very old environments.\n      this.stack = new Error(message).stack;\n    }\n  }\n\n  /** * ***Safe JSON representation for logging or IPC.*** */\n  toJSON() {\n    return {\n      name: this.name,\n      message: this.message,\n      stack: this.stack,\n      originalError: {\n        name: this.originalError.name,\n        message: this.originalError.message,\n        stack: this.originalError.stack\n      }\n    };\n  }\n}\n","import type { OverrideTypes, Prettify } from \"@rzl-zone/ts-types-plus\";\n\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isNull } from \"@/predicates/is/isNull\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isError } from \"@/predicates/is/isError\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isValidDomain } from \"@/predicates/is/isValidDomain\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport { removeSpaces } from \"@/strings/sanitizations/removeSpaces\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\nimport { NormalizePathnameError } from \"../_private/NormalizePathnameError\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\n\n/** Options when `keepNullable` is false (default).\n *\n * Returns `defaultPath` if `pathname` is empty or invalid.\n */\ntype UnKeepNullableOptions = {\n  /** * ***Fallback value returned if `pathname` is empty-string or invalid.***\n   *\n   * Must be a **`non-empty string`**, defaultValue: `\"/\"`.\n   *\n   * @defaultValue `\"/\"`.\n   */\n  defaultPath?: string;\n\n  /** * ***Whether to preserve `null` or `undefined`, defaultValue: `false`.***\n   *\n   * @defaultValue `false`.\n   */\n  keepNullable?: false;\n};\n\n/** Options when `keepNullable` is true.\n *\n * Preserves `null` or `undefined` instead of returning `defaultPath`.\n */\ntype KeepNullableOptions = {\n  /** * ***Fallback path is ignored when `keepNullable` is true **(except if\n   * `pathname` is empty-string or invalid, even this `true`)**,\n   * defaultValue: `\"/\"`.***\n   *\n   * @defaultValue `\"/\"`.\n   */\n  defaultPath?: string;\n\n  /** * ***Preserve `null` or `undefined` as-is if `true` (defaultValue: `false`).***\n   *\n   * - ***⚠️ Notes:***\n   *      - Keep returning `defaultPath` if `pathname` is empty-string, even this `true`.\n   *\n   * **Must be `true` in this type.**\n   */\n  keepNullable?: true;\n};\n\ntype MainNormalizePathnameOptions = {\n  /** --------------------------------------------------------\n   * * ***Preserve trailing slash at the end of the normalized pathname, defaultValue: `false`.***\n   * --------------------------------------------------------\n   *\n   * @defaultValue `false`\n   */\n  keepTrailingSlash?: boolean;\n\n  /** --------------------------------------------------------\n   * * ***Allow special localhost domain at the beginning of the pathname.***\n   * --------------------------------------------------------\n   * @description\n   * If `true`, the first segment of the pathname that is `/localhost` or `localhost`\n   * (with or without a port, e.g., `localhost:3000`) will be treated as a special domain\n   * and **removed** from the normalized pathname.\n   *\n   * - **Examples (`localhostDomain: true`)**:\n   *    - `\"/localhost/path\"` ➔ `\"/path\"`\n   *    - `\"localhost:3000/path\"` ➔ `\"/path\"`\n   *    - `\"localhost\"` ➔ `\"/\"` (entire path removed)\n   *\n   * - Only the **first path segment** is affected. Any subsequent occurrences of `\"localhost\"`\n   *   will remain intact.\n   *\n   * @defaultValue `false`\n   */\n  localhostDomain?: boolean;\n\n  /**\n   * --------------------------------------------------------\n   * * ***Custom list of file extensions that prevent the first path segment from being treated as a domain.***\n   * --------------------------------------------------------\n   *\n   * **Description:**\n   * - The first segment of a pathname is often interpreted as a domain (e.g., `example.com`).\n   * - If this first segment ends with any of the extensions listed here, it will **not** be considered a domain,\n   *   and will instead be preserved as part of the relative path.\n   * - This is useful for cases where filenames appear at the start of a path and you want them treated as relative paths,\n   *   such as `\"image.png?version=2\"` or `\"archive.tar.gz#download\"`.\n   * - Only the **first path segment** is affected; all other segments are processed normally.\n   * - **Ignored** if:\n   *    1. The pathname starts with a full URL protocol (`http://` or `https://`), e.g., `\"https://example.com/file.png\"`.\n   *    2. The first path segment is already a valid domain, e.g., `\"example.com/image.png\"`.\n   *\n   * **Type & Validation:**\n   * - Must be a `Set<string>` or `string[]`.\n   * - Each string **must include the leading dot**, e.g., `.png`, `.tar.gz`.\n   * - Multi-part extensions (like `.tar.gz`, `.tar.bz`) are supported.\n   * - Throws a **TypeError** if:\n   *    1. The type is not a `Set<string>` or `string[]`.\n   *    2. Any string in the array/set is empty.\n   *    3. Any string does not start with a dot (`.`).\n   *\n   * **Usage Notes:**\n   * - Only applied when the first segment is otherwise domain-like **and** pathname is relative or domain-like without protocol.\n   * - Query strings (`?x=1`) and hash fragments (`#section`) are preserved.\n   *\n   * **Examples (relative paths, option active):**\n   * ```ts\n   * normalizePathname(\"image.png?version=2\", {\n   *   ignoreDomainExtensions: [\".png\", \".jpg\"]\n   * });\n   * // ➔ \"/image.png?version=2\"\n   *\n   * normalizePathname(\"archive.tar.gz#download\", {\n   *   ignoreDomainExtensions: new Set([\".tar.gz\"])\n   * });\n   * // ➔ \"/archive.tar.gz#download\"\n   *\n   * normalizePathname(\"script.js?module=true#top\", {\n   *   ignoreDomainExtensions: [\".js\"]\n   * });\n   * // ➔ \"/script.js?module=true#top\"\n   * ```\n   *\n   * **Examples (full URL or explicit domain - option ignored):**\n   * ```ts\n   * normalizePathname(\"https://example.com/image.png?version=2\", {\n   *   ignoreDomainExtensions: [\".png\"]\n   * });\n   * // ➔ \"/image.png?version=2\"  // URL is parsed normally; ignoreDomainExtensions has no effect\n   *\n   * normalizePathname(\"example.com/script.js?module=true#top\", {\n   *   ignoreDomainExtensions: [\".js\"]\n   * });\n   * // ➔ \"/script.js?module=true#top\"  // domain recognized; option ignored\n   * ```\n   *\n   * **Notes:**\n   * - Only the **first path segment** is checked.\n   * - Prevents false-positive domain stripping for filenames that look like domains.\n   * - Throws **TypeError** if invalid type or invalid string is provided.\n   *\n   * @defaultValue `undefined` (feature inactive if not provided)\n   */\n  ignoreDomainExtensions?: Set<string> | string[];\n};\n\n/** Options for main `normalizePathname`.\n *\n * Combines `UnKeepNullableOptions` or `KeepNullableOptions` with trailing slash control.\n */\ntype NormalizePathnameOptions = Prettify<\n  MainNormalizePathnameOptions & (UnKeepNullableOptions | KeepNullableOptions)\n>;\n\ntype NormalizePathnameOptionsKeepNullableTrue = MainNormalizePathnameOptions &\n  KeepNullableOptions;\ntype NormalizePathnameOptionsKeepNullableFalse = MainNormalizePathnameOptions &\n  UnKeepNullableOptions;\n\ntype ResUnKeepNullable<T> = T extends undefined\n  ? string\n  : T extends null\n    ? string\n    : T extends null | undefined\n      ? string\n      : string;\n\ntype ResKeepNullable<T> = T extends string\n  ? string\n  : T extends undefined\n    ? undefined\n    : T extends null\n      ? null\n      : T extends null | undefined\n        ? null | undefined\n        : string | null | undefined;\n\n/** --------------------------------------------------------\n * * ***Utility: `normalizePathname`.***\n * --------------------------------------------------------\n *\n * - **Description:**\n *    Normalizes any pathname or URL string to a clean, predictable format.\n *    Useful for routing, file paths, and URL handling.\n *    - Handles:\n *      - Leading/trailing spaces\n *      - Internal spaces in path segments\n *      - Redundant slashes (`//`)\n *      - Full URLs vs relative paths\n *      - Query (`?`) and hash (`#`) preservation\n *      - Unicode & emoji characters\n *      - Optional nullable preservation (`keepNullable`)\n *      - Optional trailing slash preservation (`keepTrailingSlash`)\n *      - Optional removal of localhost first segment (`localhostDomain`)\n *      - Prevention of false-positive domain stripping (`ignoreDomainExtensions`)\n *\n * - **Key Steps Internally:**\n *    1. Validate `options` (plain object, correct types)\n *    2. Validate `defaultPath` (non-empty string if `keepNullable` is false)\n *    3. Validate `ignoreDomainExtensions` (Set<string> | string[], each starts with `.`)\n *    4. Handle nullable:\n *       - Returns `null` / `undefined` if `keepNullable: true`\n *       - Otherwise uses `defaultPath`\n *    5. Trim spaces, remove internal spaces\n *    6. If full URL: parse using `URL` constructor\n *    7. If relative path or domain-like:\n *       - Remove `localhost`/`localhost:port` if `localhostDomain`\n *       - Remove first segment if domain-like and **not** in `ignoreDomainExtensions`\n *    8. Normalize slashes\n *    9. Ensure leading slash\n *    10. Handle trailing slash\n *    11. Decode Unicode safely\n *    12. Return normalized pathname + search + hash\n *\n * - **Error Handling:**\n *    - **TypeError**:\n *       - `defaultPath` invalid (non-string or empty) when `keepNullable: false`\n *       - `keepNullable`, `keepTrailingSlash`, `localhostDomain` not boolean\n *       - `ignoreDomainExtensions` invalid\n *    - **NormalizePathnameError** (extends ***Error***):\n *       - Invalid URL parsing\n *       - Unexpected normalization errors\n *\n * - **Options:**\n *    ```ts\n *    {\n *      // fallback if invalid path, default: \"/\"\n *      defaultPath?: string;\n *      // preserve null/undefined, default: false\n *      keepNullable?: boolean;\n *      // preserve trailing slash, default: false\n *      keepTrailingSlash?: boolean;\n *      // remove localhost:port first segment, default: false\n *      localhostDomain?: boolean;\n *      // prevent domain stripping, default: undefined\n *      ignoreDomainExtensions?: Set<string> | string[];\n *    }\n *    ```\n *\n * @example\n * // Basic path cleaning\n * normalizePathname(\"   /foo//bar  \");\n * // ➔ \"/foo/bar\"\n *\n * // Trailing slash control\n * normalizePathname(\"/api//v1//user//\", { keepTrailingSlash: true });\n * // ➔ \"/api/v1/user/\"\n * normalizePathname(\"/api//v1//user//\", { keepTrailingSlash: false });\n * // ➔ \"/api/v1/user\"\n *\n * // Full URL normalization\n * normalizePathname(\"https://example.com//path///to/resource?x=1#hash\");\n * // ➔ \"/path/to/resource?x=1#hash\"\n *\n * // Null/undefined preservation\n * normalizePathname(null, { keepNullable: true });\n * // ➔ null\n * normalizePathname(undefined, { keepNullable: true });\n * // ➔ undefined\n *\n * // Default fallback\n * normalizePathname(\"\", { defaultPath: \"/home\" });\n * // ➔ \"/home\"\n *\n * // Localhost removal\n * normalizePathname(\"localhost:3000/path/to/resource\", { localhostDomain: true });\n * // ➔ \"/path/to/resource\"\n *\n * // Prevent false-positive domain stripping\n * normalizePathname(\"archive.tar.gz#download\", { ignoreDomainExtensions: [\".tar.gz\"] });\n * // ➔ \"/archive.tar.gz#download\"\n * normalizePathname(\"image.png?version=2\", { ignoreDomainExtensions: [\".png\"] });\n * // ➔ \"/image.png?version=2\"\n *\n * // Emojis and Unicode\n * normalizePathname(\"🔥//deep//path///🚀\");\n * // ➔ \"/🔥/deep/path/🚀\"\n *\n * // Query-only or hash-only\n * normalizePathname(\"?page=2\");\n * // ➔ \"/?page=2\"\n * normalizePathname(\"#section3\");\n * // ➔ \"/#section3\"\n *\n * // Complex nested paths\n * normalizePathname(\"   //nested///folder//file.txt  \");\n * // ➔ \"/nested/folder/file.txt\"\n *\n * // Invalid URL triggers error\n * try {\n *   normalizePathname(\"http://\");\n * } catch (e) {\n *   // console.log(e);\n * }\n *\n * // First segment is domain but ignored due to extension\n * normalizePathname(\"example.tar.bz/file\", { ignoreDomainExtensions: [\".tar.bz\"] });\n * // ➔ \"/example.tar.bz/file\"\n */\nexport function normalizePathname<T>(\n  pathname: T,\n  options?: NormalizePathnameOptionsKeepNullableFalse\n): ResUnKeepNullable<T>;\nexport function normalizePathname<T>(\n  pathname: T,\n  options?: NormalizePathnameOptionsKeepNullableTrue\n): ResKeepNullable<T>;\nexport function normalizePathname(\n  pathname: unknown,\n  options: NormalizePathnameOptions = {\n    defaultPath: \"/\",\n    keepNullable: false\n  }\n): string | null | undefined {\n  assertIsPlainObject(options, {\n    message({ currentType, validType }) {\n      return `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n\n  const {\n    defaultPath = \"/\",\n    keepNullable = false,\n    keepTrailingSlash = false,\n    localhostDomain = false,\n    ignoreDomainExtensions = undefined\n  } = options;\n\n  // Validate defaultPath\n  if (!isNonEmptyString(defaultPath)) {\n    throw new TypeError(\n      `Parameter \\`defaultPath\\` property of the \\`options\\` (second parameter) must be of type \\`string\\` and not empty-string, but received: \\`${getPreciseType(\n        defaultPath\n      )}\\`, with value: \\`${safeStableStringify(defaultPath, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  assertIsBoolean(keepNullable, {\n    message({ currentType, validType }) {\n      return `Parameter \\`keepNullable\\` property of the \\`options\\` (second parameter)  must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n  assertIsBoolean(keepTrailingSlash, {\n    message({ currentType, validType }) {\n      return `Parameter \\`keepTrailingSlash\\` property of the \\`options\\` (second parameter)  must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n  assertIsBoolean(localhostDomain, {\n    message({ currentType, validType }) {\n      return `Parameter \\`localhostDomain\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n\n  let ignoreDomainExtsSet: Set<string> | undefined;\n\n  if (!isUndefined(ignoreDomainExtensions)) {\n    if (!isSet(ignoreDomainExtensions) && !isArray(ignoreDomainExtensions)) {\n      throw new TypeError(\n        `Parameter \\`ignoreDomainExtensions\\` must be of type a \\`Set<string>\\` or \\`string[]\\`, but received: \\`${getPreciseType(\n          ignoreDomainExtensions\n        )}\\`.`\n      );\n    }\n\n    ignoreDomainExtsSet = isSet(ignoreDomainExtensions)\n      ? ignoreDomainExtensions\n      : new Set(ignoreDomainExtensions);\n\n    // validation every ext\n    let idx = 0;\n    for (const ext of ignoreDomainExtsSet) {\n      if (!isNonEmptyString(ext)) {\n        throw new TypeError(\n          `Parameter \\`ignoreDomainExtensions[${idx}]\\` must be a \\`string\\` and \\`non-empty string\\`, but received: \\`${safeStableStringify(\n            ext,\n            { keepUndefined: true }\n          )}\\`.`\n        );\n      }\n      if (!ext.startsWith(\".\")) {\n        throw new TypeError(\n          `Parameter \\`ignoreDomainExtensions[${idx}]\\` must start with a dot (.), but received: ${safeStableStringify(\n            ext,\n            { keepUndefined: true }\n          )}`\n        );\n      }\n      idx++;\n    }\n  }\n\n  try {\n    if (keepNullable && (isNil(pathname) || !isString(pathname))) {\n      if (isNull(pathname)) return null;\n      return undefined;\n    }\n\n    // If the pathname is invalid (null, undefined, or an empty string), return the default value, only if `keepNullable` is false\n    let currentPathName: string = isNonEmptyString(pathname)\n      ? pathname\n      : defaultPath;\n\n    // Trim spaces from the string (only trim leading and trailing spaces)\n    currentPathName = removeSpaces(currentPathName, { trimOnly: true }).replace(\n      /\\s+/g,\n      \"\"\n    ); // remove all space\n\n    currentPathName = stripLeadingDomain(currentPathName, {\n      keepTrailingSlash,\n      localhostDomain,\n      ignoreDomainExtensions: ignoreDomainExtsSet\n    });\n\n    let _pathName: string = currentPathName;\n    let search = \"\";\n    let hash = \"\";\n\n    // relative path: extract search/hash manually\n    const searchIndex = currentPathName.indexOf(\"?\");\n    const hashIndex = currentPathName.indexOf(\"#\");\n\n    if (searchIndex !== -1) {\n      search = currentPathName.slice(\n        searchIndex,\n        hashIndex !== -1 ? hashIndex : undefined\n      );\n    }\n    if (hashIndex !== -1) {\n      hash = currentPathName.slice(hashIndex);\n    }\n\n    const endIndex = Math.min(\n      searchIndex !== -1 ? searchIndex : currentPathName.length,\n      hashIndex !== -1 ? hashIndex : currentPathName.length\n    );\n    _pathName = currentPathName.slice(0, endIndex);\n\n    // Normalize slashes\n    _pathName = \"/\" + _pathName.replace(/^\\/+/, \"\").replace(/\\/{2,}/g, \"/\");\n\n    // Trailing slash\n    // if (keepTrailingSlash && _pathName !== \"/\") {\n    // _pathName += \"/\"\n    // } else\n    if (!keepTrailingSlash && _pathName !== \"/\") {\n      _pathName = _pathName.replace(/\\/+$/, \"\");\n    }\n\n    // Decode Unicode safely\n    _pathName = decodeUnicodeSequences(_pathName);\n    search = decodeUnicodeSequences(search);\n    hash = decodeUnicodeSequences(hash);\n\n    return _pathName + search + hash;\n  } catch (error) {\n    // Handle any errors that occur during processing\n    throwError(error);\n  }\n}\n\n// --- Internal Helper Utils ----\n\n/** @internal */\nconst decodeUnicodeSequences = (str: string): string => {\n  return str.replace(/(?:%(?:[0-9A-F]{2})){2,}/gi, (match) => {\n    try {\n      const decoded = decodeURIComponent(match);\n      // eslint-disable-next-line no-control-regex\n      if (/^[\\u0000-\\u007F]+$/.test(decoded)) return match;\n      // eslint-enable-next-line no-control-regex\n      return decoded;\n    } catch {\n      return match;\n    }\n  });\n};\n/** @internal */\nconst stripLeadingDomain = (\n  path: string,\n  options: OverrideTypes<\n    MainNormalizePathnameOptions,\n    { ignoreDomainExtensions?: Set<string> }\n  >\n): string => {\n  let currentPath = path;\n\n  const { ignoreDomainExtensions, localhostDomain } = options;\n\n  // Full URL (protocol) -> only normalize path, ignore ignoreDomainExtensions\n  if (/^https?:\\/\\//i.test(currentPath)) {\n    try {\n      const url = new URL(currentPath);\n      currentPath =\n        url.pathname.replace(/^\\/+/, \"\").replace(/\\/{2,}/g, \"/\") +\n        url.search +\n        url.hash;\n\n      return ensureLeadingSlash(currentPath);\n    } catch (error) {\n      // fallback: keep as-is\n      // Handle any errors that occur during processing\n      throwError(error);\n    }\n  }\n\n  // relative path: remove leading slash\n  if (currentPath.startsWith(\"/\")) {\n    currentPath = currentPath.replace(/\\/{2,}/g, \"/\").slice(1);\n  }\n\n  // take first segment\n  const segments = currentPath.split(\"/\");\n  const firstPart = segments[0];\n  const domainPart = firstPart.split(\":\")[0];\n\n  const isDomain = isValidDomain(domainPart, {\n    subdomain: true,\n    allowUnicode: true,\n    wildcard: true,\n    allowLocalhost: localhostDomain,\n    allowPort: true,\n    allowProtocol: true,\n    topLevel: false\n  });\n\n  // ignoreDomainExtensions only applies for relative/non-protocol paths\n  let hasIgnoredExtension = false;\n  if (ignoreDomainExtensions) {\n    for (const ext of ignoreDomainExtensions) {\n      if (firstPart.endsWith(ext)) {\n        hasIgnoredExtension = true;\n        break;\n      }\n    }\n  }\n\n  if (isDomain && !hasIgnoredExtension) {\n    segments.shift(); // remove first segment\n  }\n\n  return ensureLeadingSlash(segments.join(\"/\"));\n};\n/** @internal */\nconst ensureLeadingSlash = (path: string): string => {\n  if (!path.startsWith(\"/\")) path = \"/\" + path;\n  return path;\n};\n/** @internal */\nconst throwError = (error: unknown): never => {\n  // Handle any errors that occur during processing\n  const err = isError(error)\n    ? error\n    : new Error(\"Unknown error from function `normalizePathname()`.\");\n  throw new NormalizePathnameError(\n    `Failed to normalize pathname in function \\`normalizePathname()\\`: ${err.message}`,\n    err\n  );\n};\n","import { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isEmptyString } from \"@/predicates/is/isEmptyString\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype FormatEnvPortOptions = {\n  /** Add prefix with a colon, defaultValue: `false`.\n   *\n   * @default false\n   */\n  prefixColon?: boolean;\n};\n\n/** -----------------------------------------------\n * * ***Utility: `formatEnvPort`.***\n * -----------------------------------------------\n * **Retrieves and formats an environment port variable.**\n * - **Behavior:**\n *    - Extracts only digits from the input.\n *    - If no digits found, returns an empty string.\n *    - By default does NOT prefix with a colon.\n *      - Use `{ prefixColon: true }` to prefix with a colon.\n * @param {string | null | undefined} envVar The environment variable string.\n * @param {FormatEnvPortOptions} [options] Optional object: `{ prefixColon?: boolean }`.\n * @returns {string} A string like `\":8080\"` or `\"8080\"`, or `\"\"` if no digits.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not an object or `prefixColon` is not boolean.\n * @example\n * formatEnvPort(\"port:8080\");\n * // ➔ \"8080\"\n * formatEnvPort(\"port:8080\", { prefixColon: true });\n * // ➔ \":8080\"\n */\nexport const formatEnvPort = (\n  envVar: string | null | undefined,\n  options: FormatEnvPortOptions = {}\n): string => {\n  if (!isNonEmptyString(envVar)) return \"\"; // Handle empty string case\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const prefixColon = hasOwnProp(options, \"prefixColon\")\n    ? options.prefixColon\n    : false;\n\n  if (!isBoolean(prefixColon)) {\n    throw new TypeError(\n      `Parameter \\`prefixColon\\` property of the \\`options\\` (second parameter) must be of type \\`boolean\\`, but received: \\`${getPreciseType(\n        prefixColon\n      )}\\`.`\n    );\n  }\n\n  const digitsOnly = envVar.replace(/\\D+/g, \"\");\n  if (isEmptyString(digitsOnly)) return \"\";\n\n  return prefixColon ? `:${digitsOnly}` : digitsOnly;\n};\n"],"mappings":"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"}

package/dist/formatEnvPort-hHNvOim-.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatEnvPort-hHNvOim-.cjs","names":["isFunction","isNonEmptyString","getPreciseType","safeStableStringify","isUndefined","isSet","isArray","isNil","isString","isNull","removeSpaces","isValidDomain","isError","isNonEmptyString","hasOwnProp","isBoolean","getPreciseType","isEmptyString"],"sources":["../src/urls/_private/NormalizePathnameError.ts","../src/urls/pathname/normalizePathname.ts","../src/urls/utils/formatEnvPort.ts"],"sourcesContent":["import { isFunction } from \"@/predicates/is/isFunction\";\n\n/** ---------------------------------\n * * ***Custom Error for Pathname Normalization Failures***\n * --------------------------------- */\nexport class NormalizePathnameError extends Error {\n  /** * ***The original error that triggered this normalization failure.***\n   *\n   * **Always available for backward compatibility.**\n   */\n  public readonly originalError: Error;\n\n  constructor(message: string, originalError: Error) {\n    // Pass a `cause` option if the runtime supports it (ignored by older engines).\n    super(message, isFunction(Error) ? { cause: originalError } : undefined);\n\n    this.name = \"NormalizePathnameError\";\n    this.originalError = originalError;\n\n    // Preserve stack trace when available (Node.js & modern browsers).\n    if (isFunction(Error.captureStackTrace)) {\n      Error.captureStackTrace(this, NormalizePathnameError);\n    } else {\n      // Fallback for very old environments.\n      this.stack = new Error(message).stack;\n    }\n  }\n\n  /** * ***Safe JSON representation for logging or IPC.*** */\n  toJSON() {\n    return {\n      name: this.name,\n      message: this.message,\n      stack: this.stack,\n      originalError: {\n        name: this.originalError.name,\n        message: this.originalError.message,\n        stack: this.originalError.stack\n      }\n    };\n  }\n}\n","import type { OverrideTypes, Prettify } from \"@rzl-zone/ts-types-plus\";\n\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isNull } from \"@/predicates/is/isNull\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isError } from \"@/predicates/is/isError\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isValidDomain } from \"@/predicates/is/isValidDomain\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport { removeSpaces } from \"@/strings/sanitizations/removeSpaces\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\nimport { NormalizePathnameError } from \"../_private/NormalizePathnameError\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\n\n/** Options when `keepNullable` is false (default).\n *\n * Returns `defaultPath` if `pathname` is empty or invalid.\n */\ntype UnKeepNullableOptions = {\n  /** * ***Fallback value returned if `pathname` is empty-string or invalid.***\n   *\n   * Must be a **`non-empty string`**, defaultValue: `\"/\"`.\n   *\n   * @defaultValue `\"/\"`.\n   */\n  defaultPath?: string;\n\n  /** * ***Whether to preserve `null` or `undefined`, defaultValue: `false`.***\n   *\n   * @defaultValue `false`.\n   */\n  keepNullable?: false;\n};\n\n/** Options when `keepNullable` is true.\n *\n * Preserves `null` or `undefined` instead of returning `defaultPath`.\n */\ntype KeepNullableOptions = {\n  /** * ***Fallback path is ignored when `keepNullable` is true **(except if\n   * `pathname` is empty-string or invalid, even this `true`)**,\n   * defaultValue: `\"/\"`.***\n   *\n   * @defaultValue `\"/\"`.\n   */\n  defaultPath?: string;\n\n  /** * ***Preserve `null` or `undefined` as-is if `true` (defaultValue: `false`).***\n   *\n   * - ***⚠️ Notes:***\n   *      - Keep returning `defaultPath` if `pathname` is empty-string, even this `true`.\n   *\n   * **Must be `true` in this type.**\n   */\n  keepNullable?: true;\n};\n\ntype MainNormalizePathnameOptions = {\n  /** --------------------------------------------------------\n   * * ***Preserve trailing slash at the end of the normalized pathname, defaultValue: `false`.***\n   * --------------------------------------------------------\n   *\n   * @defaultValue `false`\n   */\n  keepTrailingSlash?: boolean;\n\n  /** --------------------------------------------------------\n   * * ***Allow special localhost domain at the beginning of the pathname.***\n   * --------------------------------------------------------\n   * @description\n   * If `true`, the first segment of the pathname that is `/localhost` or `localhost`\n   * (with or without a port, e.g., `localhost:3000`) will be treated as a special domain\n   * and **removed** from the normalized pathname.\n   *\n   * - **Examples (`localhostDomain: true`)**:\n   *    - `\"/localhost/path\"` ➔ `\"/path\"`\n   *    - `\"localhost:3000/path\"` ➔ `\"/path\"`\n   *    - `\"localhost\"` ➔ `\"/\"` (entire path removed)\n   *\n   * - Only the **first path segment** is affected. Any subsequent occurrences of `\"localhost\"`\n   *   will remain intact.\n   *\n   * @defaultValue `false`\n   */\n  localhostDomain?: boolean;\n\n  /**\n   * --------------------------------------------------------\n   * * ***Custom list of file extensions that prevent the first path segment from being treated as a domain.***\n   * --------------------------------------------------------\n   *\n   * **Description:**\n   * - The first segment of a pathname is often interpreted as a domain (e.g., `example.com`).\n   * - If this first segment ends with any of the extensions listed here, it will **not** be considered a domain,\n   *   and will instead be preserved as part of the relative path.\n   * - This is useful for cases where filenames appear at the start of a path and you want them treated as relative paths,\n   *   such as `\"image.png?version=2\"` or `\"archive.tar.gz#download\"`.\n   * - Only the **first path segment** is affected; all other segments are processed normally.\n   * - **Ignored** if:\n   *    1. The pathname starts with a full URL protocol (`http://` or `https://`), e.g., `\"https://example.com/file.png\"`.\n   *    2. The first path segment is already a valid domain, e.g., `\"example.com/image.png\"`.\n   *\n   * **Type & Validation:**\n   * - Must be a `Set<string>` or `string[]`.\n   * - Each string **must include the leading dot**, e.g., `.png`, `.tar.gz`.\n   * - Multi-part extensions (like `.tar.gz`, `.tar.bz`) are supported.\n   * - Throws a **TypeError** if:\n   *    1. The type is not a `Set<string>` or `string[]`.\n   *    2. Any string in the array/set is empty.\n   *    3. Any string does not start with a dot (`.`).\n   *\n   * **Usage Notes:**\n   * - Only applied when the first segment is otherwise domain-like **and** pathname is relative or domain-like without protocol.\n   * - Query strings (`?x=1`) and hash fragments (`#section`) are preserved.\n   *\n   * **Examples (relative paths, option active):**\n   * ```ts\n   * normalizePathname(\"image.png?version=2\", {\n   *   ignoreDomainExtensions: [\".png\", \".jpg\"]\n   * });\n   * // ➔ \"/image.png?version=2\"\n   *\n   * normalizePathname(\"archive.tar.gz#download\", {\n   *   ignoreDomainExtensions: new Set([\".tar.gz\"])\n   * });\n   * // ➔ \"/archive.tar.gz#download\"\n   *\n   * normalizePathname(\"script.js?module=true#top\", {\n   *   ignoreDomainExtensions: [\".js\"]\n   * });\n   * // ➔ \"/script.js?module=true#top\"\n   * ```\n   *\n   * **Examples (full URL or explicit domain - option ignored):**\n   * ```ts\n   * normalizePathname(\"https://example.com/image.png?version=2\", {\n   *   ignoreDomainExtensions: [\".png\"]\n   * });\n   * // ➔ \"/image.png?version=2\"  // URL is parsed normally; ignoreDomainExtensions has no effect\n   *\n   * normalizePathname(\"example.com/script.js?module=true#top\", {\n   *   ignoreDomainExtensions: [\".js\"]\n   * });\n   * // ➔ \"/script.js?module=true#top\"  // domain recognized; option ignored\n   * ```\n   *\n   * **Notes:**\n   * - Only the **first path segment** is checked.\n   * - Prevents false-positive domain stripping for filenames that look like domains.\n   * - Throws **TypeError** if invalid type or invalid string is provided.\n   *\n   * @defaultValue `undefined` (feature inactive if not provided)\n   */\n  ignoreDomainExtensions?: Set<string> | string[];\n};\n\n/** Options for main `normalizePathname`.\n *\n * Combines `UnKeepNullableOptions` or `KeepNullableOptions` with trailing slash control.\n */\ntype NormalizePathnameOptions = Prettify<\n  MainNormalizePathnameOptions & (UnKeepNullableOptions | KeepNullableOptions)\n>;\n\ntype NormalizePathnameOptionsKeepNullableTrue = MainNormalizePathnameOptions &\n  KeepNullableOptions;\ntype NormalizePathnameOptionsKeepNullableFalse = MainNormalizePathnameOptions &\n  UnKeepNullableOptions;\n\ntype ResUnKeepNullable<T> = T extends undefined\n  ? string\n  : T extends null\n    ? string\n    : T extends null | undefined\n      ? string\n      : string;\n\ntype ResKeepNullable<T> = T extends string\n  ? string\n  : T extends undefined\n    ? undefined\n    : T extends null\n      ? null\n      : T extends null | undefined\n        ? null | undefined\n        : string | null | undefined;\n\n/** --------------------------------------------------------\n * * ***Utility: `normalizePathname`.***\n * --------------------------------------------------------\n *\n * - **Description:**\n *    Normalizes any pathname or URL string to a clean, predictable format.\n *    Useful for routing, file paths, and URL handling.\n *    - Handles:\n *      - Leading/trailing spaces\n *      - Internal spaces in path segments\n *      - Redundant slashes (`//`)\n *      - Full URLs vs relative paths\n *      - Query (`?`) and hash (`#`) preservation\n *      - Unicode & emoji characters\n *      - Optional nullable preservation (`keepNullable`)\n *      - Optional trailing slash preservation (`keepTrailingSlash`)\n *      - Optional removal of localhost first segment (`localhostDomain`)\n *      - Prevention of false-positive domain stripping (`ignoreDomainExtensions`)\n *\n * - **Key Steps Internally:**\n *    1. Validate `options` (plain object, correct types)\n *    2. Validate `defaultPath` (non-empty string if `keepNullable` is false)\n *    3. Validate `ignoreDomainExtensions` (Set<string> | string[], each starts with `.`)\n *    4. Handle nullable:\n *       - Returns `null` / `undefined` if `keepNullable: true`\n *       - Otherwise uses `defaultPath`\n *    5. Trim spaces, remove internal spaces\n *    6. If full URL: parse using `URL` constructor\n *    7. If relative path or domain-like:\n *       - Remove `localhost`/`localhost:port` if `localhostDomain`\n *       - Remove first segment if domain-like and **not** in `ignoreDomainExtensions`\n *    8. Normalize slashes\n *    9. Ensure leading slash\n *    10. Handle trailing slash\n *    11. Decode Unicode safely\n *    12. Return normalized pathname + search + hash\n *\n * - **Error Handling:**\n *    - **TypeError**:\n *       - `defaultPath` invalid (non-string or empty) when `keepNullable: false`\n *       - `keepNullable`, `keepTrailingSlash`, `localhostDomain` not boolean\n *       - `ignoreDomainExtensions` invalid\n *    - **NormalizePathnameError** (extends ***Error***):\n *       - Invalid URL parsing\n *       - Unexpected normalization errors\n *\n * - **Options:**\n *    ```ts\n *    {\n *      // fallback if invalid path, default: \"/\"\n *      defaultPath?: string;\n *      // preserve null/undefined, default: false\n *      keepNullable?: boolean;\n *      // preserve trailing slash, default: false\n *      keepTrailingSlash?: boolean;\n *      // remove localhost:port first segment, default: false\n *      localhostDomain?: boolean;\n *      // prevent domain stripping, default: undefined\n *      ignoreDomainExtensions?: Set<string> | string[];\n *    }\n *    ```\n *\n * @example\n * // Basic path cleaning\n * normalizePathname(\"   /foo//bar  \");\n * // ➔ \"/foo/bar\"\n *\n * // Trailing slash control\n * normalizePathname(\"/api//v1//user//\", { keepTrailingSlash: true });\n * // ➔ \"/api/v1/user/\"\n * normalizePathname(\"/api//v1//user//\", { keepTrailingSlash: false });\n * // ➔ \"/api/v1/user\"\n *\n * // Full URL normalization\n * normalizePathname(\"https://example.com//path///to/resource?x=1#hash\");\n * // ➔ \"/path/to/resource?x=1#hash\"\n *\n * // Null/undefined preservation\n * normalizePathname(null, { keepNullable: true });\n * // ➔ null\n * normalizePathname(undefined, { keepNullable: true });\n * // ➔ undefined\n *\n * // Default fallback\n * normalizePathname(\"\", { defaultPath: \"/home\" });\n * // ➔ \"/home\"\n *\n * // Localhost removal\n * normalizePathname(\"localhost:3000/path/to/resource\", { localhostDomain: true });\n * // ➔ \"/path/to/resource\"\n *\n * // Prevent false-positive domain stripping\n * normalizePathname(\"archive.tar.gz#download\", { ignoreDomainExtensions: [\".tar.gz\"] });\n * // ➔ \"/archive.tar.gz#download\"\n * normalizePathname(\"image.png?version=2\", { ignoreDomainExtensions: [\".png\"] });\n * // ➔ \"/image.png?version=2\"\n *\n * // Emojis and Unicode\n * normalizePathname(\"🔥//deep//path///🚀\");\n * // ➔ \"/🔥/deep/path/🚀\"\n *\n * // Query-only or hash-only\n * normalizePathname(\"?page=2\");\n * // ➔ \"/?page=2\"\n * normalizePathname(\"#section3\");\n * // ➔ \"/#section3\"\n *\n * // Complex nested paths\n * normalizePathname(\"   //nested///folder//file.txt  \");\n * // ➔ \"/nested/folder/file.txt\"\n *\n * // Invalid URL triggers error\n * try {\n *   normalizePathname(\"http://\");\n * } catch (e) {\n *   // console.log(e);\n * }\n *\n * // First segment is domain but ignored due to extension\n * normalizePathname(\"example.tar.bz/file\", { ignoreDomainExtensions: [\".tar.bz\"] });\n * // ➔ \"/example.tar.bz/file\"\n */\nexport function normalizePathname<T>(\n  pathname: T,\n  options?: NormalizePathnameOptionsKeepNullableFalse\n): ResUnKeepNullable<T>;\nexport function normalizePathname<T>(\n  pathname: T,\n  options?: NormalizePathnameOptionsKeepNullableTrue\n): ResKeepNullable<T>;\nexport function normalizePathname(\n  pathname: unknown,\n  options: NormalizePathnameOptions = {\n    defaultPath: \"/\",\n    keepNullable: false\n  }\n): string | null | undefined {\n  assertIsPlainObject(options, {\n    message({ currentType, validType }) {\n      return `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n\n  const {\n    defaultPath = \"/\",\n    keepNullable = false,\n    keepTrailingSlash = false,\n    localhostDomain = false,\n    ignoreDomainExtensions = undefined\n  } = options;\n\n  // Validate defaultPath\n  if (!isNonEmptyString(defaultPath)) {\n    throw new TypeError(\n      `Parameter \\`defaultPath\\` property of the \\`options\\` (second parameter) must be of type \\`string\\` and not empty-string, but received: \\`${getPreciseType(\n        defaultPath\n      )}\\`, with value: \\`${safeStableStringify(defaultPath, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  assertIsBoolean(keepNullable, {\n    message({ currentType, validType }) {\n      return `Parameter \\`keepNullable\\` property of the \\`options\\` (second parameter)  must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n  assertIsBoolean(keepTrailingSlash, {\n    message({ currentType, validType }) {\n      return `Parameter \\`keepTrailingSlash\\` property of the \\`options\\` (second parameter)  must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n  assertIsBoolean(localhostDomain, {\n    message({ currentType, validType }) {\n      return `Parameter \\`localhostDomain\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n\n  let ignoreDomainExtsSet: Set<string> | undefined;\n\n  if (!isUndefined(ignoreDomainExtensions)) {\n    if (!isSet(ignoreDomainExtensions) && !isArray(ignoreDomainExtensions)) {\n      throw new TypeError(\n        `Parameter \\`ignoreDomainExtensions\\` must be of type a \\`Set<string>\\` or \\`string[]\\`, but received: \\`${getPreciseType(\n          ignoreDomainExtensions\n        )}\\`.`\n      );\n    }\n\n    ignoreDomainExtsSet = isSet(ignoreDomainExtensions)\n      ? ignoreDomainExtensions\n      : new Set(ignoreDomainExtensions);\n\n    // validation every ext\n    let idx = 0;\n    for (const ext of ignoreDomainExtsSet) {\n      if (!isNonEmptyString(ext)) {\n        throw new TypeError(\n          `Parameter \\`ignoreDomainExtensions[${idx}]\\` must be a \\`string\\` and \\`non-empty string\\`, but received: \\`${safeStableStringify(\n            ext,\n            { keepUndefined: true }\n          )}\\`.`\n        );\n      }\n      if (!ext.startsWith(\".\")) {\n        throw new TypeError(\n          `Parameter \\`ignoreDomainExtensions[${idx}]\\` must start with a dot (.), but received: ${safeStableStringify(\n            ext,\n            { keepUndefined: true }\n          )}`\n        );\n      }\n      idx++;\n    }\n  }\n\n  try {\n    if (keepNullable && (isNil(pathname) || !isString(pathname))) {\n      if (isNull(pathname)) return null;\n      return undefined;\n    }\n\n    // If the pathname is invalid (null, undefined, or an empty string), return the default value, only if `keepNullable` is false\n    let currentPathName: string = isNonEmptyString(pathname)\n      ? pathname\n      : defaultPath;\n\n    // Trim spaces from the string (only trim leading and trailing spaces)\n    currentPathName = removeSpaces(currentPathName, { trimOnly: true }).replace(\n      /\\s+/g,\n      \"\"\n    ); // remove all space\n\n    currentPathName = stripLeadingDomain(currentPathName, {\n      keepTrailingSlash,\n      localhostDomain,\n      ignoreDomainExtensions: ignoreDomainExtsSet\n    });\n\n    let _pathName: string = currentPathName;\n    let search = \"\";\n    let hash = \"\";\n\n    // relative path: extract search/hash manually\n    const searchIndex = currentPathName.indexOf(\"?\");\n    const hashIndex = currentPathName.indexOf(\"#\");\n\n    if (searchIndex !== -1) {\n      search = currentPathName.slice(\n        searchIndex,\n        hashIndex !== -1 ? hashIndex : undefined\n      );\n    }\n    if (hashIndex !== -1) {\n      hash = currentPathName.slice(hashIndex);\n    }\n\n    const endIndex = Math.min(\n      searchIndex !== -1 ? searchIndex : currentPathName.length,\n      hashIndex !== -1 ? hashIndex : currentPathName.length\n    );\n    _pathName = currentPathName.slice(0, endIndex);\n\n    // Normalize slashes\n    _pathName = \"/\" + _pathName.replace(/^\\/+/, \"\").replace(/\\/{2,}/g, \"/\");\n\n    // Trailing slash\n    // if (keepTrailingSlash && _pathName !== \"/\") {\n    // _pathName += \"/\"\n    // } else\n    if (!keepTrailingSlash && _pathName !== \"/\") {\n      _pathName = _pathName.replace(/\\/+$/, \"\");\n    }\n\n    // Decode Unicode safely\n    _pathName = decodeUnicodeSequences(_pathName);\n    search = decodeUnicodeSequences(search);\n    hash = decodeUnicodeSequences(hash);\n\n    return _pathName + search + hash;\n  } catch (error) {\n    // Handle any errors that occur during processing\n    throwError(error);\n  }\n}\n\n// --- Internal Helper Utils ----\n\n/** @internal */\nconst decodeUnicodeSequences = (str: string): string => {\n  return str.replace(/(?:%(?:[0-9A-F]{2})){2,}/gi, (match) => {\n    try {\n      const decoded = decodeURIComponent(match);\n      // eslint-disable-next-line no-control-regex\n      if (/^[\\u0000-\\u007F]+$/.test(decoded)) return match;\n      // eslint-enable-next-line no-control-regex\n      return decoded;\n    } catch {\n      return match;\n    }\n  });\n};\n/** @internal */\nconst stripLeadingDomain = (\n  path: string,\n  options: OverrideTypes<\n    MainNormalizePathnameOptions,\n    { ignoreDomainExtensions?: Set<string> }\n  >\n): string => {\n  let currentPath = path;\n\n  const { ignoreDomainExtensions, localhostDomain } = options;\n\n  // Full URL (protocol) -> only normalize path, ignore ignoreDomainExtensions\n  if (/^https?:\\/\\//i.test(currentPath)) {\n    try {\n      const url = new URL(currentPath);\n      currentPath =\n        url.pathname.replace(/^\\/+/, \"\").replace(/\\/{2,}/g, \"/\") +\n        url.search +\n        url.hash;\n\n      return ensureLeadingSlash(currentPath);\n    } catch (error) {\n      // fallback: keep as-is\n      // Handle any errors that occur during processing\n      throwError(error);\n    }\n  }\n\n  // relative path: remove leading slash\n  if (currentPath.startsWith(\"/\")) {\n    currentPath = currentPath.replace(/\\/{2,}/g, \"/\").slice(1);\n  }\n\n  // take first segment\n  const segments = currentPath.split(\"/\");\n  const firstPart = segments[0];\n  const domainPart = firstPart.split(\":\")[0];\n\n  const isDomain = isValidDomain(domainPart, {\n    subdomain: true,\n    allowUnicode: true,\n    wildcard: true,\n    allowLocalhost: localhostDomain,\n    allowPort: true,\n    allowProtocol: true,\n    topLevel: false\n  });\n\n  // ignoreDomainExtensions only applies for relative/non-protocol paths\n  let hasIgnoredExtension = false;\n  if (ignoreDomainExtensions) {\n    for (const ext of ignoreDomainExtensions) {\n      if (firstPart.endsWith(ext)) {\n        hasIgnoredExtension = true;\n        break;\n      }\n    }\n  }\n\n  if (isDomain && !hasIgnoredExtension) {\n    segments.shift(); // remove first segment\n  }\n\n  return ensureLeadingSlash(segments.join(\"/\"));\n};\n/** @internal */\nconst ensureLeadingSlash = (path: string): string => {\n  if (!path.startsWith(\"/\")) path = \"/\" + path;\n  return path;\n};\n/** @internal */\nconst throwError = (error: unknown): never => {\n  // Handle any errors that occur during processing\n  const err = isError(error)\n    ? error\n    : new Error(\"Unknown error from function `normalizePathname()`.\");\n  throw new NormalizePathnameError(\n    `Failed to normalize pathname in function \\`normalizePathname()\\`: ${err.message}`,\n    err\n  );\n};\n","import { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isEmptyString } from \"@/predicates/is/isEmptyString\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype FormatEnvPortOptions = {\n  /** Add prefix with a colon, defaultValue: `false`.\n   *\n   * @default false\n   */\n  prefixColon?: boolean;\n};\n\n/** -----------------------------------------------\n * * ***Utility: `formatEnvPort`.***\n * -----------------------------------------------\n * **Retrieves and formats an environment port variable.**\n * - **Behavior:**\n *    - Extracts only digits from the input.\n *    - If no digits found, returns an empty string.\n *    - By default does NOT prefix with a colon.\n *      - Use `{ prefixColon: true }` to prefix with a colon.\n * @param {string | null | undefined} envVar The environment variable string.\n * @param {FormatEnvPortOptions} [options] Optional object: `{ prefixColon?: boolean }`.\n * @returns {string} A string like `\":8080\"` or `\"8080\"`, or `\"\"` if no digits.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not an object or `prefixColon` is not boolean.\n * @example\n * formatEnvPort(\"port:8080\");\n * // ➔ \"8080\"\n * formatEnvPort(\"port:8080\", { prefixColon: true });\n * // ➔ \":8080\"\n */\nexport const formatEnvPort = (\n  envVar: string | null | undefined,\n  options: FormatEnvPortOptions = {}\n): string => {\n  if (!isNonEmptyString(envVar)) return \"\"; // Handle empty string case\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const prefixColon = hasOwnProp(options, \"prefixColon\")\n    ? options.prefixColon\n    : false;\n\n  if (!isBoolean(prefixColon)) {\n    throw new TypeError(\n      `Parameter \\`prefixColon\\` property of the \\`options\\` (second parameter) must be of type \\`boolean\\`, but received: \\`${getPreciseType(\n        prefixColon\n      )}\\`.`\n    );\n  }\n\n  const digitsOnly = envVar.replace(/\\D+/g, \"\");\n  if (isEmptyString(digitsOnly)) return \"\";\n\n  return prefixColon ? `:${digitsOnly}` : digitsOnly;\n};\n"],"mappings":"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"}