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

package/dist/conversions-D_Kh0a_C.cjs

@@ -0,0 +1,446 @@
+/*!
+* ========================================================================
+*  @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`
+* ========================================================================
+*/
+"use strict";
+const require_assertIsBoolean = require('./assertIsBoolean-C8WEXVr2.cjs');
+const require_isBigInt = require('./isBigInt-C4krUeAw.cjs');
+const require_assertIsArray = require('./assertIsArray-DJXkjHZs.cjs');
+const require_assertIsString = require('./assertIsString-BiHQSrB2.cjs');
+const require_isEmptyObject = require('./isEmptyObject-ZkSwRC_D.cjs');
+const require_toStringArrayUnRecursive = require('./toStringArrayUnRecursive-C4zYCja7.cjs');
+const require_safeStableStringify = require('./safeStableStringify-CJtP89qn.cjs');
+const require_isEqual = require('./isEqual-BvumA3RA.cjs');
+const require_isEmptyString = require('./isEmptyString-UiiUsSQj.cjs');
+const require_isTypedArray = require('./isTypedArray-TJptiw2b.cjs');
+function toNumberArrayUnRecursive(array, options = {}) {
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const riv = require_assertIsBoolean.hasOwnProp(options, "removeInvalidValueNumber") ? options.removeInvalidValueNumber : true;
+	require_assertIsBoolean.assertIsBoolean(riv, { message: ({ currentType, validType }) => `Parameter \`removeInvalidValueNumber\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	if (require_assertIsBoolean.isArray(array)) {
+		const result = Array.from(array, (x) => {
+			if (require_isBigInt.isBigInt(x)) return Number(x);
+			const match = String(x).trim().match(/-?\d+(\.\d+)?/);
+			return match ? Number(match[0]) : require_assertIsBoolean.isNull(x) ? null : void 0;
+		});
+		return riv ? require_toStringArrayUnRecursive.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: \`${require_assertIsBoolean.getPreciseType(forceToString)}\`, with value: \`${require_safeStableStringify.safeStableStringify(forceToString, { keepUndefined: true })}\`.`);
+	if (require_assertIsBoolean.isNaN(value)) return forceToString === "primitives" || forceToString === "all" ? "NaN" : NaN;
+	if (require_assertIsBoolean.isString(value) || require_assertIsBoolean.isNumber(value)) return forceToString === "stringOrNumber" || forceToString === "primitives" || forceToString === "all" ? String(value) : value;
+	if (require_assertIsBoolean.isBoolean(value) || require_isBigInt.isBigInt(value) || require_assertIsBoolean.isNil(value)) return forceToString === "primitives" || forceToString === "all" ? String(value) : value;
+	if (require_assertIsBoolean.isNumberObject(value) || require_assertIsBoolean.isBooleanObject(value) || require_assertIsBoolean.isStringObject(value)) return forceToString === "all" ? value.valueOf().toString() : value;
+	if (require_assertIsBoolean.isSymbol(value)) return forceToString === "all" ? value.toString() : value;
+	if (require_assertIsBoolean.isFunction(value)) return forceToString === "all" ? value.toString() : value;
+	if (require_assertIsBoolean.isArray(value)) return value.map((v) => toStringDeepForce(v, forceToString));
+	if (require_assertIsBoolean.isObjectOrArray(value)) {
+		if (require_safeStableStringify.isDate(value)) return forceToString === "all" ? value.toISOString() : value;
+		if (require_isEqual.isRegExp(value)) return forceToString === "all" ? value.toString() : value;
+		if (require_assertIsBoolean.isError(value) || value instanceof Promise) return forceToString === "all" ? value.toString() : value;
+		if (require_assertIsBoolean.isSet(value)) return forceToString === "all" ? [...value].map((v) => toStringDeepForce(v, forceToString)) : value;
+		if (require_safeStableStringify.isMap(value)) return forceToString === "all" ? [...value.entries()].map(([k, v]) => [toStringDeepForce(k, forceToString), toStringDeepForce(v, forceToString)]) : value;
+		const result = {};
+		if (require_assertIsBoolean.isObject(value)) for (const key of Object.keys(value)) result[key] = toStringDeepForce(value[key], forceToString);
+		return result;
+	}
+	return value;
+}
+const dedupeArray = (inputArray, options = {}) => {
+	require_assertIsArray.assertIsArray(inputArray, { message: ({ currentType, validType }) => `First parameter (\`inputArray\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.` });
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const flatten = require_assertIsBoolean.hasOwnProp(options, "flatten") ? options.flatten : false;
+	const forceToString = require_assertIsBoolean.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: \`${require_assertIsBoolean.getPreciseType(forceToString)}\`, with value: \`${require_safeStableStringify.safeStableStringify(forceToString, { keepUndefined: true })}\`.`);
+	require_assertIsBoolean.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 = require_assertIsBoolean.isArray(item) ? process(item) : toStringDeepForce(item, forceToString);
+			if (!seen.some((s) => require_isEqual.isEqual(s, value))) {
+				seen.push(value);
+				acc.push(value);
+			}
+			return acc;
+		}, []);
+	};
+	const deepFlatten = (value) => {
+		if (require_assertIsBoolean.isArray(value)) return value.flatMap(deepFlatten);
+		if (require_assertIsBoolean.isSet(value)) return [...value].flatMap(deepFlatten);
+		if (require_safeStableStringify.isMap(value)) return [...value.values()].flatMap(deepFlatten);
+		return [value];
+	};
+	return flatten ? process(deepFlatten(inputArray)) : process(inputArray);
+};
+const toBooleanContent = (value) => {
+	if (require_assertIsBoolean.isNil(value)) return false;
+	if (require_assertIsBoolean.isString(value)) return require_assertIsBoolean.isNonEmptyString(value);
+	if (require_assertIsBoolean.isBoolean(value)) return value;
+	if (require_assertIsBoolean.isNumber(value, { includeNaN: true })) return value !== 0;
+	if (require_assertIsBoolean.isArray(value) || require_assertIsBoolean.isObject(value)) return require_isTypedArray.isNonEmptyValue(value);
+	return Boolean(value);
+};
+const toBooleanContentDeep = (value) => {
+	if (require_assertIsBoolean.isNil(value)) return false;
+	if (require_assertIsBoolean.isString(value)) return require_assertIsBoolean.isNonEmptyString(value);
+	if (require_assertIsBoolean.isBoolean(value)) return value;
+	if (require_assertIsBoolean.isNumber(value, { includeNaN: true })) return value !== 0;
+	if (require_assertIsBoolean.isArray(value)) return value.some(toBooleanContentDeep);
+	if (require_assertIsBoolean.isObject(value)) return Object.values(value).some(toBooleanContentDeep);
+	return false;
+};
+const toBooleanExplicit = (value, options = {}) => {
+	if (require_assertIsBoolean.isNil(value)) return false;
+	if (!require_assertIsBoolean.isPlainObject(options)) options = {};
+	const ci = require_assertIsBoolean.hasOwnProp(options, "caseInsensitive") ? options.caseInsensitive : false;
+	const ts = require_assertIsBoolean.hasOwnProp(options, "trimString") ? options.trimString : true;
+	const incInd = require_assertIsBoolean.hasOwnProp(options, "includeIndeterminate") ? options.includeIndeterminate : false;
+	if (!require_assertIsBoolean.isBoolean(ci) || !require_assertIsBoolean.isBoolean(ts) || !require_assertIsBoolean.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': \`${require_assertIsBoolean.getPreciseType(ci)}\`, 'trimString': \`${require_assertIsBoolean.getPreciseType(ts)}\`, 'includeIndeterminate': \`${require_assertIsBoolean.getPreciseType(incInd)}\`].`);
+	if (require_assertIsBoolean.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 (require_assertIsBoolean.isNumber(value)) return value === 1;
+	if (require_assertIsBoolean.isBoolean(value)) return value;
+	return false;
+};
+const toBooleanLoose = (value) => {
+	if (require_assertIsBoolean.isNil(value)) return false;
+	if (require_assertIsBoolean.isString(value)) return !require_isEmptyString.isEmptyString(value);
+	if (require_assertIsBoolean.isBoolean(value)) return value;
+	if (require_assertIsBoolean.isNumber(value, { includeNaN: true })) return value !== 0;
+	if (require_assertIsBoolean.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 (require_assertIsBoolean.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 (!require_assertIsBoolean.isNaN(numberString) && require_assertIsBoolean.isNonEmptyString(numericString)) return numberString;
+		return value.trim();
+	}
+	return value;
+};
+const deepCloneSafe = (obj) => {
+	try {
+		if (require_assertIsBoolean.isFunction(structuredClone)) return structuredClone(obj);
+	} catch {}
+	return JSON.parse(JSON.stringify(obj));
+};
+const deleteNestedKey = (obj, path) => {
+	if (!require_assertIsBoolean.isObjectOrArray(obj)) return obj;
+	const [currentKey, ...rest] = path;
+	if (require_assertIsBoolean.isArray(obj)) {
+		for (const item of obj) if (require_assertIsBoolean.isObjectOrArray(item)) deleteNestedKey(item, path);
+	} else if (require_isEmptyObject.isEmptyArray(rest) && require_assertIsBoolean.isPlainObject(obj) && currentKey) delete obj[currentKey];
+	else if (require_assertIsBoolean.isPlainObject(obj) && currentKey && require_assertIsBoolean.isObjectOrArray(obj[currentKey])) deleteNestedKey(obj[currentKey], rest);
+	return obj;
+};
+const deleteExactPathOnce = (obj, path) => {
+	if (!require_assertIsBoolean.isPlainObject(obj)) return obj;
+	const [currentKey, ...rest] = path;
+	if (rest.length === 0 && currentKey && require_assertIsBoolean.isPlainObject(obj)) delete obj[currentKey];
+	else if (currentKey && require_assertIsBoolean.isPlainObject(obj[currentKey])) deleteExactPathOnce(obj[currentKey], rest);
+	return obj;
+};
+function removeObjectPaths(object, keysToDelete, deepClone = true) {
+	if (require_isEmptyObject.isEmptyObject(object, { checkSymbols: true })) return {};
+	require_assertIsArray.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: \`${require_safeStableStringify.safeStableStringify(keysToDelete, { keepUndefined: true })}\`.` });
+	if (!keysToDelete.every((k) => require_assertIsBoolean.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: \`${require_safeStableStringify.safeStableStringify(keysToDelete, { keepUndefined: true })}\`.`);
+	let result = deepClone ? deepCloneSafe(object) : object;
+	for (const { key, deep } of keysToDelete) {
+		require_assertIsString.assertIsString(key, { message: ({ currentType, validType }) => `Parameter \`key\` at Second Parameter (\`keysToDelete\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+		if (!require_assertIsBoolean.isUndefined(deep) && !require_assertIsBoolean.isBoolean(deep)) throw new TypeError(`Parameter \`deep\` at Second Parameter (\`keysToDelete\`) ➔ (key: "${key}", deep: ${deep}) must be of type \`boolean\` or \`undefined\`, but received: \`${require_assertIsBoolean.getPreciseType(deep)}\`.`);
+		const path = key.split(".");
+		result = deep ? deleteNestedKey(result, path) : deleteExactPathOnce(result, path);
+	}
+	return result;
+}
+function toNumberDeep(input, options = {}) {
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const removeEmptyObjects = require_assertIsBoolean.hasOwnProp(options, "removeEmptyObjects") ? options.removeEmptyObjects : false;
+	const removeEmptyArrays = require_assertIsBoolean.hasOwnProp(options, "removeEmptyArrays") ? options.removeEmptyArrays : false;
+	function _internal(input, options) {
+		if (require_assertIsBoolean.isNil(input) || require_isEqual.isRegExp(input)) return void 0;
+		const { removeEmptyArrays, removeEmptyObjects, isRoot } = options;
+		if (!require_assertIsBoolean.isBoolean(removeEmptyObjects) || !require_assertIsBoolean.isBoolean(removeEmptyArrays)) throw new TypeError(`Parameters \`removeEmptyObjects\` and \`removeEmptyArrays\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['removeEmptyObjects': \`${require_assertIsBoolean.getPreciseType(removeEmptyObjects)}\`, 'removeEmptyArrays': \`${require_assertIsBoolean.getPreciseType(removeEmptyArrays)}\`].`);
+		if (require_assertIsBoolean.isNumber(input) || require_assertIsBoolean.isBoolean(input) || require_assertIsBoolean.isNonEmptyString(input)) {
+			const num = Number(input);
+			return require_assertIsBoolean.isInfinityNumber(num) || require_assertIsBoolean.isNaN(num) ? void 0 : num;
+		}
+		if (require_assertIsBoolean.isNumberObject(input) || require_assertIsBoolean.isStringObject(input) || require_assertIsBoolean.isBooleanObject(input)) {
+			const valOf = Number(input.valueOf());
+			return require_assertIsBoolean.isInfinityNumber(valOf) || require_assertIsBoolean.isNaN(valOf) ? void 0 : valOf;
+		}
+		if (require_safeStableStringify.isDate(input, { skipInvalidDate: true })) try {
+			return !require_assertIsBoolean.isNaN(input.getTime()) ? input.getTime() : 0;
+		} catch {
+			return 0;
+		}
+		if (require_assertIsBoolean.isBuffer(input)) {
+			const arr = Array.from(input).map((n) => _internal(n, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !require_assertIsBoolean.isUndefined(item));
+			if (removeEmptyArrays && require_isEmptyObject.isEmptyArray(arr)) return void 0;
+			return arr;
+		}
+		if (require_isTypedArray.isTypedArray(input)) if (input instanceof BigInt64Array || input instanceof BigUint64Array) {
+			const newArray = Array.from(input).map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !require_assertIsBoolean.isUndefined(item));
+			if (removeEmptyArrays && require_isEmptyObject.isEmptyArray(newArray)) return void 0;
+			return newArray;
+		} else {
+			const newArray = Array.from(input).map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !require_assertIsBoolean.isUndefined(item));
+			if (removeEmptyArrays && require_isEmptyObject.isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (require_assertIsBoolean.isSet(input)) {
+			const newArray = Array.from(input).map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !require_assertIsBoolean.isUndefined(item));
+			if (removeEmptyArrays && require_isEmptyObject.isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (require_safeStableStringify.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 !require_assertIsBoolean.isUndefined(key) && !require_assertIsBoolean.isUndefined(value) ? [key, value] : void 0;
+			}).filter((item) => !require_assertIsBoolean.isUndefined(item));
+			if (removeEmptyArrays) newArray = newArray.filter((v) => !require_isEmptyObject.isEmptyArray(v));
+			if (removeEmptyArrays && require_isEmptyObject.isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (require_assertIsBoolean.isArray(input)) {
+			const newArray = input.map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !require_assertIsBoolean.isUndefined(item));
+			if (removeEmptyArrays && require_isEmptyObject.isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (require_assertIsBoolean.isObject(input)) {
+			const newObject = {};
+			for (const [key, value] of Object.entries(input)) {
+				const convertedValue = _internal(value, {
+					removeEmptyObjects,
+					removeEmptyArrays,
+					isRoot: false
+				});
+				if (!require_assertIsBoolean.isUndefined(convertedValue)) newObject[key] = convertedValue;
+			}
+			if (removeEmptyObjects && require_isEmptyObject.isEmptyObject(newObject)) return isRoot ? {} : void 0;
+			return newObject;
+		}
+	}
+	return _internal(input, {
+		removeEmptyObjects,
+		removeEmptyArrays,
+		isRoot: true
+	});
+}
+function toStringDeep(input, options = {}) {
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const removeEmptyObjects = require_assertIsBoolean.hasOwnProp(options, "removeEmptyObjects") ? options.removeEmptyObjects : false;
+	const removeEmptyArrays = require_assertIsBoolean.hasOwnProp(options, "removeEmptyArrays") ? options.removeEmptyArrays : false;
+	function _internal(input, options) {
+		if (require_assertIsBoolean.isNil(input) || require_assertIsBoolean.isInfinityNumber(input)) return void 0;
+		const { removeEmptyArrays, removeEmptyObjects, isRoot } = options;
+		if (!require_assertIsBoolean.isBoolean(removeEmptyObjects) || !require_assertIsBoolean.isBoolean(removeEmptyArrays)) throw new TypeError(`Parameters \`removeEmptyObjects\` and \`removeEmptyArrays\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['removeEmptyObjects': \`${require_assertIsBoolean.getPreciseType(removeEmptyObjects)}\`, 'removeEmptyArrays': \`${require_assertIsBoolean.getPreciseType(removeEmptyArrays)}\`].`);
+		if (require_assertIsBoolean.isNumber(input) || require_assertIsBoolean.isString(input) || require_assertIsBoolean.isBoolean(input)) return String(input);
+		if (require_assertIsBoolean.isNumberObject(input)) {
+			const valOf = input.valueOf();
+			return require_assertIsBoolean.isInfinityNumber(valOf) || require_assertIsBoolean.isNaN(valOf) ? void 0 : valOf.toString();
+		}
+		if (require_assertIsBoolean.isStringObject(input)) return input.valueOf();
+		if (require_assertIsBoolean.isBooleanObject(input)) return input.valueOf().toString();
+		if (require_safeStableStringify.isDate(input, { skipInvalidDate: true })) try {
+			return input.toISOString();
+		} catch {
+			return input.toString();
+		}
+		if (require_isEqual.isRegExp(input)) return input.toString();
+		if (require_assertIsBoolean.isBuffer(input)) return Array.from(input).map((v) => String(v)).filter((v) => !require_assertIsBoolean.isUndefined(v));
+		if (require_isTypedArray.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) => !require_assertIsBoolean.isUndefined(item));
+			if (removeEmptyArrays && require_isEmptyObject.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) => !require_assertIsBoolean.isUndefined(item));
+			if (removeEmptyArrays && require_isEmptyObject.isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (require_assertIsBoolean.isSet(input)) {
+			const arr = Array.from(input).map((v) => _internal(v, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((v) => !require_assertIsBoolean.isUndefined(v));
+			if (removeEmptyArrays && require_isEmptyObject.isEmptyArray(arr)) return void 0;
+			return arr;
+		}
+		if (require_safeStableStringify.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]) => !require_assertIsBoolean.isUndefined(k) && !require_assertIsBoolean.isUndefined(v));
+			if (removeEmptyArrays && require_isEmptyObject.isEmptyArray(arr)) return void 0;
+			return arr;
+		}
+		if (require_assertIsBoolean.isArray(input)) {
+			let newArray = input.map((item) => _internal(item, {
+				removeEmptyObjects,
+				removeEmptyArrays,
+				isRoot: false
+			})).filter((item) => !require_assertIsBoolean.isUndefined(item));
+			if (removeEmptyArrays) newArray = newArray.filter((v) => !(require_assertIsBoolean.isArray(v) && v.length === 0));
+			if (removeEmptyArrays && require_isEmptyObject.isEmptyArray(newArray)) return void 0;
+			return newArray;
+		}
+		if (require_assertIsBoolean.isObject(input)) {
+			const newObject = {};
+			for (const [key, value] of Object.entries(input)) {
+				const convertedValue = _internal(value, {
+					removeEmptyObjects,
+					removeEmptyArrays,
+					isRoot: false
+				});
+				if (!require_assertIsBoolean.isUndefined(convertedValue)) newObject[key] = convertedValue;
+				else if (require_assertIsBoolean.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
+	});
+}
+Object.defineProperty(exports, 'convertType', {
+  enumerable: true,
+  get: function () {
+    return convertType;
+  }
+});
+Object.defineProperty(exports, 'dedupeArray', {
+  enumerable: true,
+  get: function () {
+    return dedupeArray;
+  }
+});
+Object.defineProperty(exports, 'removeObjectPaths', {
+  enumerable: true,
+  get: function () {
+    return removeObjectPaths;
+  }
+});
+Object.defineProperty(exports, 'toBooleanContent', {
+  enumerable: true,
+  get: function () {
+    return toBooleanContent;
+  }
+});
+Object.defineProperty(exports, 'toBooleanContentDeep', {
+  enumerable: true,
+  get: function () {
+    return toBooleanContentDeep;
+  }
+});
+Object.defineProperty(exports, 'toBooleanExplicit', {
+  enumerable: true,
+  get: function () {
+    return toBooleanExplicit;
+  }
+});
+Object.defineProperty(exports, 'toBooleanLoose', {
+  enumerable: true,
+  get: function () {
+    return toBooleanLoose;
+  }
+});
+Object.defineProperty(exports, 'toNumberArrayUnRecursive', {
+  enumerable: true,
+  get: function () {
+    return toNumberArrayUnRecursive;
+  }
+});
+Object.defineProperty(exports, 'toNumberDeep', {
+  enumerable: true,
+  get: function () {
+    return toNumberDeep;
+  }
+});
+Object.defineProperty(exports, 'toStringDeep', {
+  enumerable: true,
+  get: function () {
+    return toStringDeep;
+  }
+});
+Object.defineProperty(exports, 'toStringDeepForce', {
+  enumerable: true,
+  get: function () {
+    return toStringDeepForce;
+  }
+});
+//# sourceMappingURL=conversions-D_Kh0a_C.cjs.map