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

package/dist/conversions/index.js

@@ -1,25 +1,15 @@
 /*!
- * ====================================================
- * Rzl Utils-JS.
- * ----------------------------------------------------
- * Version: 3.12.0.
- * Author: Rizalvin Dwiky.
- * Repository: https://github.com/rzl-zone/utils-js.
- * ====================================================
- */
-export { convertType, dedupeArray, removeObjectPaths, toBooleanContent, toBooleanContentDeep, toBooleanExplicit, toBooleanLoose, toNumberArrayUnRecursive, toNumberDeep, toStringDeep, toStringDeepForce } from '../chunk-EN7LVZBZ.js';
-import '../chunk-KIDJCMNJ.js';
-export { filterNilArray, toStringArrayUnRecursive } from '../chunk-CFYZC4S6.js';
-import '../chunk-QFFBIOJ4.js';
-export { parseCurrencyString } from '../chunk-5MGEC3YG.js';
-import '../chunk-NODTV4F3.js';
-import '../chunk-TCDOWZQE.js';
-import '../chunk-BKIJBNIE.js';
-export { cleanParsedData, extractDigits, parseCustomDate, safeJsonParse } from '../chunk-YSZC56SZ.js';
-import '../chunk-WYP76WXB.js';
-import '../chunk-SDMPEJ4F.js';
-import '../chunk-HSP6IWZK.js';
-import '../chunk-YWHHVDT4.js';
-export { safeStableStringify } from '../chunk-6VUXD3CF.js';
-import '../chunk-QNKGP5DY.js';
-import '../chunk-CSG4SCL3.js';
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.12.1-beta.1`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+import { n as filterNilArray, t as toStringArrayUnRecursive } from "../toStringArrayUnRecursive-DJGtPsFb.js";
+import { a as toBooleanLoose, c as toBooleanContent, d as toNumberArrayUnRecursive, i as convertType, l as dedupeArray, n as toNumberDeep, o as toBooleanExplicit, r as removeObjectPaths, s as toBooleanContentDeep, t as toStringDeep, u as toStringDeepForce } from "../conversions-BNIh_tCH.js";
+import { t as safeStableStringify } from "../safeStableStringify-CXOZ9Ub8.js";
+import { t as parseCurrencyString } from "../parsing-Cao8b358.js";
+import { i as parseCustomDate, n as extractDigits, r as cleanParsedData, t as safeJsonParse } from "../safeJsonParse-BP38mwlj.js";
+export { cleanParsedData, convertType, dedupeArray, extractDigits, filterNilArray, parseCurrencyString, parseCustomDate, removeObjectPaths, safeJsonParse, safeStableStringify, toBooleanContent, toBooleanContentDeep, toBooleanExplicit, toBooleanLoose, toNumberArrayUnRecursive, toNumberDeep, toStringArrayUnRecursive, toStringDeep, toStringDeepForce };

package/dist/conversions-BNIh_tCH.js

@@ -0,0 +1,380 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.12.1-beta.1`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+import { A as isPlainObject, C as isSymbol, D as isNaN, E as isNull, F as isBoolean, M as isArray, N as isNil, O as isNumberObject, P as isFunction, S as isUndefined, T as assertIsPlainObject, _ as isBuffer, b as hasOwnProp, f as isSet, g as isStringObject, h as isBooleanObject, j as isObject, k as isString, m as isInfinityNumber, r as getPreciseType, t as assertIsBoolean, v as isError, w as isNumber, x as isObjectOrArray, y as isNonEmptyString } from "./assertIsBoolean-DR1SaXPD.js";
+import { t as isBigInt } from "./isBigInt-DKe0M6hp.js";
+import { t as assertIsArray } from "./assertIsArray-bTA3XLjq.js";
+import { t as assertIsString } from "./assertIsString-CEB07_83.js";
+import { n as isEmptyArray, t as isEmptyObject } from "./isEmptyObject-DCipFwxJ.js";
+import { n as filterNilArray } from "./toStringArrayUnRecursive-DJGtPsFb.js";
+import { n as isDate, r as isMap, t as safeStableStringify } from "./safeStableStringify-CXOZ9Ub8.js";
+import { i as isRegExp, t as isEqual } from "./isEqual-BX49cF9m.js";
+import { t as isEmptyString } from "./isEmptyString-BXzKAC2j.js";
+import { n as isNonEmptyValue, t as isTypedArray } from "./isTypedArray-DuNA8tK6.js";
+function toNumberArrayUnRecursive(array, options = {}) {
+	assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const riv = hasOwnProp(options, "removeInvalidValueNumber") ? options.removeInvalidValueNumber : true;
+	assertIsBoolean(riv, { message: ({ currentType, validType }) => `Parameter \`removeInvalidValueNumber\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	if (isArray(array)) {
+		const result = Array.from(array, (x) => {
+			if (isBigInt(x)) return Number(x);
+			const match = String(x).trim().match(/-?\d+(\.\d+)?/);
+			return match ? Number(match[0]) : isNull(x) ? null : void 0;
+		});
+		return riv ? filterNilArray(result) : result;
+	}
+}
+function toStringDeepForce(value, forceToString) {
+	if (!(forceToString === false || forceToString === "stringOrNumber" || forceToString === "primitives" || forceToString === "all")) throw new TypeError(`Second parameter \`forceToString\` must be of type \`false\` or \`string\` with value one of "stringOrNumber" | "primitives" | "all", but received: \`${getPreciseType(forceToString)}\`, with value: \`${safeStableStringify(forceToString, { keepUndefined: true })}\`.`);
+	if (isNaN(value)) return forceToString === "primitives" || forceToString === "all" ? "NaN" : NaN;
+	if (isString(value) || isNumber(value)) return forceToString === "stringOrNumber" || forceToString === "primitives" || forceToString === "all" ? String(value) : value;
+	if (isBoolean(value) || isBigInt(value) || isNil(value)) return forceToString === "primitives" || forceToString === "all" ? String(value) : value;
+	if (isNumberObject(value) || isBooleanObject(value) || isStringObject(value)) return forceToString === "all" ? value.valueOf().toString() : value;
+	if (isSymbol(value)) return forceToString === "all" ? value.toString() : value;
+	if (isFunction(value)) return forceToString === "all" ? value.toString() : value;
+	if (isArray(value)) return value.map((v) => toStringDeepForce(v, forceToString));
+	if (isObjectOrArray(value)) {
+		if (isDate(value)) return forceToString === "all" ? value.toISOString() : value;
+		if (isRegExp(value)) return forceToString === "all" ? value.toString() : value;
+		if (isError(value) || value instanceof Promise) return forceToString === "all" ? value.toString() : value;
+		if (isSet(value)) return forceToString === "all" ? [...value].map((v) => toStringDeepForce(v, forceToString)) : value;
+		if (isMap(value)) return forceToString === "all" ? [...value.entries()].map(([k, v]) => [toStringDeepForce(k, forceToString), toStringDeepForce(v, forceToString)]) : value;
+		const result = {};
+		if (isObject(value)) for (const key of Object.keys(value)) result[key] = toStringDeepForce(value[key], forceToString);
+		return result;
+	}
+	return value;
+}
+const dedupeArray = (inputArray, options = {}) => {
+	assertIsArray(inputArray, { message: ({ currentType, validType }) => `First parameter (\`inputArray\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.` });
+	assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const flatten = hasOwnProp(options, "flatten") ? options.flatten : false;
+	const forceToString = hasOwnProp(options, "forceToString") ? options.forceToString : false;
+	if (!(forceToString === false || forceToString === "stringOrNumber" || forceToString === "primitives" || forceToString === "all")) throw new TypeError(`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(forceToString)}\`, with value: \`${safeStableStringify(forceToString, { keepUndefined: true })}\`.`);
+	assertIsBoolean(flatten, { message: ({ currentType, validType }) => `Parameter \`flatten\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const process = (arr) => {
+		const seen = [];
+		return arr.reduce((acc, item) => {
+			const value = isArray(item) ? process(item) : toStringDeepForce(item, forceToString);
+			if (!seen.some((s) => isEqual(s, value))) {
+				seen.push(value);
+				acc.push(value);
+			}
+			return acc;
+		}, []);
+	};
+	const deepFlatten = (value) => {
+		if (isArray(value)) return value.flatMap(deepFlatten);
+		if (isSet(value)) return [...value].flatMap(deepFlatten);
+		if (isMap(value)) return [...value.values()].flatMap(deepFlatten);
+		return [value];
+	};
+	return flatten ? process(deepFlatten(inputArray)) : process(inputArray);
+};
+const toBooleanContent = (value) => {
+	if (isNil(value)) return false;
+	if (isString(value)) return isNonEmptyString(value);
+	if (isBoolean(value)) return value;
+	if (isNumber(value, { includeNaN: true })) return value !== 0;
+	if (isArray(value) || isObject(value)) return isNonEmptyValue(value);
+	return Boolean(value);
+};
+const toBooleanContentDeep = (value) => {
+	if (isNil(value)) return false;
+	if (isString(value)) return isNonEmptyString(value);
+	if (isBoolean(value)) return value;
+	if (isNumber(value, { includeNaN: true })) return value !== 0;
+	if (isArray(value)) return value.some(toBooleanContentDeep);
+	if (isObject(value)) return Object.values(value).some(toBooleanContentDeep);
+	return false;
+};
+const toBooleanExplicit = (value, options = {}) => {
+	if (isNil(value)) return false;
+	if (!isPlainObject(options)) options = {};
+	const ci = hasOwnProp(options, "caseInsensitive") ? options.caseInsensitive : false;
+	const ts = hasOwnProp(options, "trimString") ? options.trimString : true;
+	const incInd = hasOwnProp(options, "includeIndeterminate") ? options.includeIndeterminate : false;
+	if (!isBoolean(ci) || !isBoolean(ts) || !isBoolean(incInd)) throw new TypeError(`Parameters \`caseInsensitive\`, \`trimString\` and \`includeIndeterminate\` property of the \`options\` (second parameter) expected to be a \`boolean\` type, but received: ['caseInsensitive': \`${getPreciseType(ci)}\`, 'trimString': \`${getPreciseType(ts)}\`, 'includeIndeterminate': \`${getPreciseType(incInd)}\`].`);
+	if (isString(value)) {
+		let normalized = value;
+		if (ts) normalized = normalized.trim();
+		if (ci) normalized = normalized.toLowerCase();
+		const validTrueStrings = [
+			"true",
+			"on",
+			"yes",
+			"1"
+		];
+		if (incInd) validTrueStrings.push("indeterminate");
+		return validTrueStrings.includes(normalized);
+	}
+	if (isNumber(value)) return value === 1;
+	if (isBoolean(value)) return value;
+	return false;
+};
+const toBooleanLoose = (value) => {
+	if (isNil(value)) return false;
+	if (isString(value)) return !isEmptyString(value);
+	if (isBoolean(value)) return value;
+	if (isNumber(value, { includeNaN: true })) return value !== 0;
+	if (isArray(value)) return value.length > 0;
+	return Boolean(value);
+};
+const convertType = (value) => {
+	const predefinedValues = {
+		undefined: void 0,
+		null: null,
+		nan: NaN,
+		true: true,
+		false: false,
+		yes: true,
+		no: false
+	};
+	if (isString(value)) {
+		const normalized = value.trim().toLowerCase();
+		if (Object.prototype.hasOwnProperty.call(predefinedValues, normalized)) return predefinedValues[normalized];
+		const numericString = normalized.replace(/,/g, "");
+		const numberString = Number(numericString);
+		if (!isNaN(numberString) && isNonEmptyString(numericString)) return numberString;
+		return value.trim();
+	}
+	return value;
+};
+const deepCloneSafe = (obj) => {
+	try {
+		if (isFunction(structuredClone)) return structuredClone(obj);
+	} catch {}
+	return JSON.parse(JSON.stringify(obj));
+};
+const deleteNestedKey = (obj, path) => {
+	if (!isObjectOrArray(obj)) return obj;
+	const [currentKey, ...rest] = path;
+	if (isArray(obj)) {
+		for (const item of obj) if (isObjectOrArray(item)) deleteNestedKey(item, path);
+	} else if (isEmptyArray(rest) && isPlainObject(obj) && currentKey) delete obj[currentKey];
+	else if (isPlainObject(obj) && currentKey && isObjectOrArray(obj[currentKey])) deleteNestedKey(obj[currentKey], rest);
+	return obj;
+};
+const deleteExactPathOnce = (obj, path) => {
+	if (!isPlainObject(obj)) return obj;
+	const [currentKey, ...rest] = path;
+	if (rest.length === 0 && currentKey && isPlainObject(obj)) delete obj[currentKey];
+	else if (currentKey && isPlainObject(obj[currentKey])) deleteExactPathOnce(obj[currentKey], rest);
+	return obj;
+};
+function removeObjectPaths(object, keysToDelete, deepClone = true) {
+	if (isEmptyObject(object, { checkSymbols: true })) return {};
+	assertIsArray(keysToDelete, { message: ({ currentType, validType }) => `Second parameter (\`keysToDelete\`) must be of type \`${validType}\` with value of { key: string, deep?: boolean } plain-object, but received: \`${currentType}\`, with value: \`${safeStableStringify(keysToDelete, { keepUndefined: true })}\`.` });
+	if (!keysToDelete.every((k) => isPlainObject(k) && "key" in k)) throw new TypeError(`Each element in Second Parameter (\`keysToDelete\`) must be of type \`plain-object\` with at least a "key" property (optionally "deep"), but received: \`${safeStableStringify(keysToDelete, { keepUndefined: true })}\`.`);
+	let result = deepClone ? deepCloneSafe(object) : object;
+	for (const { key, deep } of keysToDelete) {
+		assertIsString(key, { message: ({ currentType, validType }) => `Parameter \`key\` at Second Parameter (\`keysToDelete\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+		if (!isUndefined(deep) && !isBoolean(deep)) throw new TypeError(`Parameter \`deep\` at Second Parameter (\`keysToDelete\`) ➔ (key: "${key}", deep: ${deep}) must be of type \`boolean\` or \`undefined\`, but received: \`${getPreciseType(deep)}\`.`);
+		const path = key.split(".");
+		result = deep ? deleteNestedKey(result, path) : deleteExactPathOnce(result, path);
+	}
+	return result;
+}
+function toNumberDeep(input, options = {}) {
+	assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const removeEmptyObjects = hasOwnProp(options, "removeEmptyObjects") ? options.removeEmptyObjects : false;
+	const removeEmptyArrays = hasOwnProp(options, "removeEmptyArrays") ? options.removeEmptyArrays : false;
+	function _internal(input, options) {
+		if (isNil(input) || isRegExp(input)) return void 0;
+		const { removeEmptyArrays, removeEmptyObjects, isRoot } = options;
+		if (!isBoolean(removeEmptyObjects) || !isBoolean(removeEmptyArrays)) throw new TypeError(`Parameters \`removeEmptyObjects\` and \`removeEmptyArrays\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['removeEmptyObjects': \`${getPreciseType(removeEmptyObjects)}\`, 'removeEmptyArrays': \`${getPreciseType(removeEmptyArrays)}\`].`);
+		if (isNumber(input) || isBoolean(input) || isNonEmptyString(input)) {
+			const num = Number(input);
+			return isInfinityNumber(num) || isNaN(num) ? void 0 : num;
+		}
+		if (isNumberObject(input) || isStringObject(input) || isBooleanObject(input)) {
+			const valOf = Number(input.valueOf());
+			return isInfinityNumber(valOf) || isNaN(valOf) ? void 0 : valOf;
+		}
+		if (isDate(input, { skipInvalidDate: true })) try {
+			return !isNaN(input.getTime()) ? input.getTime() : 0;
+		} catch {
+			return 0;
+		}
+		if (isBuffer(input)) {
+			const arr = Array.from(input).map((n) => _internal(n, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !isUndefined(item));
+			if (removeEmptyArrays && isEmptyArray(arr)) return void 0;
+			return arr;
+		}
+		if (isTypedArray(input)) if (input instanceof BigInt64Array || input instanceof BigUint64Array) {
+			const newArray = Array.from(input).map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !isUndefined(item));
+			if (removeEmptyArrays && isEmptyArray(newArray)) return void 0;
+			return newArray;
+		} else {
+			const newArray = Array.from(input).map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !isUndefined(item));
+			if (removeEmptyArrays && isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (isSet(input)) {
+			const newArray = Array.from(input).map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !isUndefined(item));
+			if (removeEmptyArrays && isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (isMap(input)) {
+			let newArray = Array.from(input.entries()).map(([k, v]) => {
+				const key = _internal(k, {
+					removeEmptyObjects,
+					removeEmptyArrays,
+					isRoot: false
+				});
+				const value = _internal(v, {
+					removeEmptyObjects,
+					removeEmptyArrays,
+					isRoot: false
+				});
+				return !isUndefined(key) && !isUndefined(value) ? [key, value] : void 0;
+			}).filter((item) => !isUndefined(item));
+			if (removeEmptyArrays) newArray = newArray.filter((v) => !isEmptyArray(v));
+			if (removeEmptyArrays && isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (isArray(input)) {
+			const newArray = input.map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !isUndefined(item));
+			if (removeEmptyArrays && isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (isObject(input)) {
+			const newObject = {};
+			for (const [key, value] of Object.entries(input)) {
+				const convertedValue = _internal(value, {
+					removeEmptyObjects,
+					removeEmptyArrays,
+					isRoot: false
+				});
+				if (!isUndefined(convertedValue)) newObject[key] = convertedValue;
+			}
+			if (removeEmptyObjects && isEmptyObject(newObject)) return isRoot ? {} : void 0;
+			return newObject;
+		}
+	}
+	return _internal(input, {
+		removeEmptyObjects,
+		removeEmptyArrays,
+		isRoot: true
+	});
+}
+function toStringDeep(input, options = {}) {
+	assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const removeEmptyObjects = hasOwnProp(options, "removeEmptyObjects") ? options.removeEmptyObjects : false;
+	const removeEmptyArrays = hasOwnProp(options, "removeEmptyArrays") ? options.removeEmptyArrays : false;
+	function _internal(input, options) {
+		if (isNil(input) || isInfinityNumber(input)) return void 0;
+		const { removeEmptyArrays, removeEmptyObjects, isRoot } = options;
+		if (!isBoolean(removeEmptyObjects) || !isBoolean(removeEmptyArrays)) throw new TypeError(`Parameters \`removeEmptyObjects\` and \`removeEmptyArrays\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['removeEmptyObjects': \`${getPreciseType(removeEmptyObjects)}\`, 'removeEmptyArrays': \`${getPreciseType(removeEmptyArrays)}\`].`);
+		if (isNumber(input) || isString(input) || isBoolean(input)) return String(input);
+		if (isNumberObject(input)) {
+			const valOf = input.valueOf();
+			return isInfinityNumber(valOf) || isNaN(valOf) ? void 0 : valOf.toString();
+		}
+		if (isStringObject(input)) return input.valueOf();
+		if (isBooleanObject(input)) return input.valueOf().toString();
+		if (isDate(input, { skipInvalidDate: true })) try {
+			return input.toISOString();
+		} catch {
+			return input.toString();
+		}
+		if (isRegExp(input)) return input.toString();
+		if (isBuffer(input)) return Array.from(input).map((v) => String(v)).filter((v) => !isUndefined(v));
+		if (isTypedArray(input)) if (input instanceof BigInt64Array || input instanceof BigUint64Array) {
+			const newArray = Array.from(input).map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).map((v) => String(v)).filter((item) => !isUndefined(item));
+			if (removeEmptyArrays && isEmptyArray(newArray)) return void 0;
+			return newArray;
+		} else {
+			const newArray = Array.from(input).map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).map((v) => String(v)).filter((item) => !isUndefined(item));
+			if (removeEmptyArrays && isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (isSet(input)) {
+			const arr = Array.from(input).map((v) => _internal(v, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((v) => !isUndefined(v));
+			if (removeEmptyArrays && isEmptyArray(arr)) return void 0;
+			return arr;
+		}
+		if (isMap(input)) {
+			const arr = Array.from(input.entries()).map(([k, v]) => [_internal(k, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			}), _internal(v, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})]).filter(([k, v]) => !isUndefined(k) && !isUndefined(v));
+			if (removeEmptyArrays && isEmptyArray(arr)) return void 0;
+			return arr;
+		}
+		if (isArray(input)) {
+			let newArray = input.map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !isUndefined(item));
+			if (removeEmptyArrays) newArray = newArray.filter((v) => !(isArray(v) && v.length === 0));
+			if (removeEmptyArrays && isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (isObject(input)) {
+			const newObject = {};
+			for (const [key, value] of Object.entries(input)) {
+				const convertedValue = _internal(value, {
+					removeEmptyObjects,
+					removeEmptyArrays,
+					isRoot: false
+				});
+				if (!isUndefined(convertedValue)) newObject[key] = convertedValue;
+				else if (isArray(value) && !removeEmptyArrays) newObject[key] = [];
+			}
+			if (removeEmptyObjects && Object.keys(newObject).length === 0) return isRoot ? {} : void 0;
+			return newObject;
+		}
+	}
+	return _internal(input, {
+		removeEmptyObjects,
+		removeEmptyArrays,
+		isRoot: true
+	});
+}
+export { toBooleanLoose as a, toBooleanContent as c, toNumberArrayUnRecursive as d, convertType as i, dedupeArray as l, toNumberDeep as n, toBooleanExplicit as o, removeObjectPaths as r, toBooleanContentDeep as s, toStringDeep as t, toStringDeepForce as u };
+//# sourceMappingURL=conversions-BNIh_tCH.js.map

package/dist/conversions-BNIh_tCH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversions-BNIh_tCH.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/** ***Util helper for {@link removeObjectPaths | `removeObjectPaths`}.***\n *\n * @internal\n */\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/** ***Util helper for {@link removeObjectPaths | `removeObjectPaths`}.***\n *\n * @internal\n */\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) && isPlainObject(obj) && currentKey) {\n    delete obj[currentKey];\n  } else if (\n    isPlainObject(obj) &&\n    currentKey &&\n    isObjectOrArray(obj[currentKey])\n  ) {\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/** ***Util helper for {@link removeObjectPaths | `removeObjectPaths`}.***\n *\n * @internal\n */\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 && currentKey && isPlainObject(obj)) {\n    delete obj[currentKey];\n  } else if (currentKey && 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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"}