@rzl-zone/utils-js 3.4.0 → 3.5.1

package/dist/chunk-FWCKOJZM.js

@@ -1 +1,542 @@
-import{isNonEmptyValue as e,isTypedArray as r}from"./chunk-5IGC6PBH.js";import{filterNilArray as t}from"./chunk-OI5XKNZO.js";import{isEmptyString as o}from"./chunk-W2WNBUDE.js";import{assertIsString as n}from"./chunk-SBKGWRS5.js";import{isRegExp as i,isEqual as m}from"./chunk-NBZWMBO6.js";import{isEmptyObject as s,isEmptyArray as a}from"./chunk-6JFCSH7J.js";import{assertIsArray as p}from"./chunk-CKTLUNWX.js";import{safeStableStringify as u,isDate as c,isMap as f}from"./chunk-PET42Z7W.js";import{isBigInt as y}from"./chunk-QNKGP5DY.js";import{assertIsPlainObject as l,hasOwnProp as v,assertIsBoolean as b,isArray as d,isNull as E,getPreciseType as g,isNaN as O,isString as j,isNumber as h,isBoolean as A,isNil as S,isNumberObject as T,isBooleanObject as $,isStringObject as N,isSymbol as k,isFunction as w,isObjectOrArray as R,isError as I,isSet as P,isObject as B,isNonEmptyString as C,isPlainObject as D,isUndefined as W,isInfinityNumber as M,isBuffer as J}from"./chunk-CMW2TBOQ.js";function K(e,r={}){l(r,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});const o=!v(r,"removeInvalidValueNumber")||r.removeInvalidValueNumber;if(b(o,{message:({currentType:e,validType:r})=>`Parameter \`removeInvalidValueNumber\` property of the \`options\` (second parameter) must be of type \`${r}\`, but received: \`${e}\`.`}),d(e)){const r=Array.from(e,e=>{if(y(e))return Number(e);const r=String(e).trim().match(/-?\d+(\.\d+)?/);return r?Number(r[0]):E(e)?null:void 0});return o?t(r):r}}function U(e,r){if(!1!==r&&"stringOrNumber"!==r&&"primitives"!==r&&"all"!==r)throw new TypeError(`Second parameter \`forceToString\` must be of type \`false\` or \`string\` with value one of "stringOrNumber" | "primitives" | "all", but received: \`${g(r)}\`, with value: \`${u(r)}\`.`);if(O(e))return"primitives"===r||"all"===r?"NaN":NaN;if(j(e)||h(e))return"stringOrNumber"===r||"primitives"===r||"all"===r?String(e):e;if(A(e)||y(e)||S(e))return"primitives"===r||"all"===r?String(e):e;if(T(e)||$(e)||N(e))return"all"===r?e.valueOf().toString():e;if(k(e))return"all"===r?e.toString():e;if(w(e))return"all"===r?e.toString():e;if(d(e))return e.map(e=>U(e,r));if(R(e)){if(c(e))return"all"===r?e.toISOString():e;if(i(e))return"all"===r?e.toString():e;if(I(e)||e instanceof Promise)return"all"===r?e.toString():e;if(P(e))return"all"===r?[...e].map(e=>U(e,r)):e;if(f(e))return"all"===r?[...e.entries()].map(([e,t])=>[U(e,r),U(t,r)]):e;const t={};if(B(e))for(const o of Object.keys(e))t[o]=U(e[o],r);return t}return e}var G=(e,r={})=>{p(e,{message:({currentType:e,validType:r})=>`First parameter (\`inputArray\`) must be of type \`${r}\` (array literal or instance), but received: \`${e}\`.`}),l(r,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});const t=!!v(r,"flatten")&&r.flatten,o=!!v(r,"forceToString")&&r.forceToString;if(!1!==o&&"stringOrNumber"!==o&&"primitives"!==o&&"all"!==o)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: \`${g(o)}\`, with value: \`${u(o)}\`.`);b(t,{message:({currentType:e,validType:r})=>`Parameter \`flatten\` property of the \`options\` (second parameter) must be of type \`${r}\`, but received: \`${e}\`.`});const n=e=>{const r=[];return e.reduce((e,t)=>{const i=d(t)?n(t):U(t,o);return r.some(e=>m(e,i))||(r.push(i),e.push(i)),e},[])},i=e=>d(e)?e.flatMap(i):P(e)?[...e].flatMap(i):f(e)?[...e.values()].flatMap(i):[e];return n(t?i(e):e)},L=r=>!S(r)&&(j(r)?C(r):A(r)?r:h(r,{includeNaN:!0})?0!==r:d(r)||B(r)?e(r):Boolean(r)),V=e=>!S(e)&&(j(e)?C(e):A(e)?e:h(e,{includeNaN:!0})?0!==e:d(e)?e.some(V):!!B(e)&&Object.values(e).some(V)),Z=(e,r={})=>{if(S(e))return!1;D(r)||(r={});const t=!!v(r,"caseInsensitive")&&r.caseInsensitive,o=!v(r,"trimString")||r.trimString,n=!!v(r,"includeIndeterminate")&&r.includeIndeterminate;if(!A(t)||!A(o)||!A(n))throw new TypeError(`Parameters \`caseInsensitive\`, \`trimString\` and \`includeIndeterminate\` property of the \`options\` (second parameter) expected to be a \`boolean\` type, but received: ['caseInsensitive': \`${g(t)}\`, 'trimString': \`${g(o)}\`, 'includeIndeterminate': \`${g(n)}\`].`);if(j(e)){let r=e;o&&(r=r.trim()),t&&(r=r.toLowerCase());const i=["true","on","yes","1"];return n&&i.push("indeterminate"),i.includes(r)}return h(e)?1===e:!!A(e)&&e},x=e=>!S(e)&&(j(e)?!o(e):A(e)?e:h(e,{includeNaN:!0})?0!==e:d(e)?e.length>0:Boolean(e)),F=e=>{const r={undefined:void 0,null:null,nan:NaN,true:!0,false:!1,yes:!0,no:!1};if(j(e)){const t=e.trim().toLowerCase();if(Object.prototype.hasOwnProperty.call(r,t))return r[t];const o=t.replace(/,/g,""),n=Number(o);return!O(n)&&C(o)?n:e.trim()}return e},H=(e,r)=>{if(!R(e))return e;const[t,...o]=r;if(d(e))for(const t of e)R(t)&&H(t,r);else a(o)?D(e)&&delete e[t]:D(e)&&R(e[t])&&H(e[t],o);return e},Q=(e,r)=>{if(!D(e))return e;const[t,...o]=r;return 0===o.length?D(e)&&delete e[t]:D(e[t])&&Q(e[t],o),e};function X(e,r,t=!0){if(s(e,{checkSymbols:!0}))return{};if(p(r,{message:({currentType:e,validType:t})=>`Second parameter (\`keysToDelete\`) must be of type \`${t}\` with value of { key: string, deep?: boolean } plain-object, but received: \`${e}\`, with value: \`${u(r)}\`.`}),!r.every(e=>D(e)&&"key"in e))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: \`${u(r)}\`.`);let o=t?(e=>{try{if(w(structuredClone))return structuredClone(e)}catch{}return JSON.parse(JSON.stringify(e))})(e):e;for(const{key:e,deep:t}of r){if(n(e,{message:({currentType:e,validType:r})=>`Parameter \`key\` at Second Parameter (\`keysToDelete\`) must be of type \`${r}\`, but received: \`${e}\`.`}),!W(t)&&!A(t))throw new TypeError(`Parameter \`deep\` at Second Parameter (\`keysToDelete\`) ➔ (key: "${e}", deep: ${t}) must be of type \`boolean\` or \`undefined\`, but received: \`${g(t)}\`.`);const r=e.split(".");o=t?H(o,r):Q(o,r)}return o}function Y(e,t={}){l(t,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});return function e(t,o){if(S(t)||i(t))return;const{removeEmptyArrays:n,removeEmptyObjects:m,isRoot:p}=o;if(!A(m)||!A(n))throw new TypeError(`Parameters \`removeEmptyObjects\` and \`removeEmptyArrays\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['removeEmptyObjects': \`${g(m)}\`, 'removeEmptyArrays': \`${g(n)}\`].`);if(h(t)||A(t)||C(t)){const e=Number(t);return M(e)||O(e)?void 0:e}if(T(t)||N(t)||$(t)){const e=Number(t.valueOf());return M(e)||O(e)?void 0:e}if(c(t,{skipInvalidDate:!0}))try{return O(t.getTime())?0:t.getTime()}catch{return 0}if(J(t)){const r=Array.from(t).map(r=>e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1})).filter(e=>!W(e));if(n&&a(r))return;return r}if(r(t)){if(t instanceof BigInt64Array||t instanceof BigUint64Array){const r=Array.from(t).map(r=>e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1})).filter(e=>!W(e));if(n&&a(r))return;return r}{const r=Array.from(t).map(r=>e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1})).filter(e=>!W(e));if(n&&a(r))return;return r}}if(P(t)){const r=Array.from(t).map(r=>e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1})).filter(e=>!W(e));if(n&&a(r))return;return r}if(f(t)){let r=Array.from(t.entries()).map(([r,t])=>{const o=e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1}),i=e(t,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1});return W(o)||W(i)?void 0:[o,i]}).filter(e=>!W(e));if(n&&(r=r.filter(e=>!a(e))),n&&a(r))return;return r}if(d(t)){const r=t.map(r=>e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1})).filter(e=>!W(e));if(n&&a(r))return;return r}if(B(t)){const r={};for(const[o,i]of Object.entries(t)){const t=e(i,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1});W(t)||(r[o]=t)}return m&&s(r)?p?{}:void 0:r}}(e,{removeEmptyObjects:!!v(t,"removeEmptyObjects")&&t.removeEmptyObjects,removeEmptyArrays:!!v(t,"removeEmptyArrays")&&t.removeEmptyArrays,isRoot:!0})}function q(e,t={}){l(t,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});return function e(t,o){if(S(t)||M(t))return;const{removeEmptyArrays:n,removeEmptyObjects:m,isRoot:s}=o;if(!A(m)||!A(n))throw new TypeError(`Parameters \`removeEmptyObjects\` and \`removeEmptyArrays\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['removeEmptyObjects': \`${g(m)}\`, 'removeEmptyArrays': \`${g(n)}\`].`);if(h(t)||j(t)||A(t))return String(t);if(T(t)){const e=t.valueOf();return M(e)||O(e)?void 0:e.toString()}if(N(t))return t.valueOf();if($(t))return t.valueOf().toString();if(c(t,{skipInvalidDate:!0}))try{return t.toISOString()}catch{return t.toString()}if(i(t))return t.toString();if(J(t))return Array.from(t).map(e=>String(e)).filter(e=>!W(e));if(r(t)){if(t instanceof BigInt64Array||t instanceof BigUint64Array){const r=Array.from(t).map(r=>e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1})).map(e=>String(e)).filter(e=>!W(e));if(n&&a(r))return;return r}{const r=Array.from(t).map(r=>e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1})).map(e=>String(e)).filter(e=>!W(e));if(n&&a(r))return;return r}}if(P(t)){const r=Array.from(t).map(r=>e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1})).filter(e=>!W(e));if(n&&a(r))return;return r}if(f(t)){const r=Array.from(t.entries()).map(([r,t])=>[e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1}),e(t,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1})]).filter(([e,r])=>!W(e)&&!W(r));if(n&&a(r))return;return r}if(d(t)){let r=t.map(r=>e(r,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1})).filter(e=>!W(e));if(n&&(r=r.filter(e=>!(d(e)&&0===e.length))),n&&a(r))return;return r}if(B(t)){const r={};for(const[o,i]of Object.entries(t)){const t=e(i,{removeEmptyObjects:m,removeEmptyArrays:n,isRoot:!1});W(t)?d(i)&&!n&&(r[o]=[]):r[o]=t}return m&&0===Object.keys(r).length?s?{}:void 0:r}}(e,{removeEmptyObjects:!!v(t,"removeEmptyObjects")&&t.removeEmptyObjects,removeEmptyArrays:!!v(t,"removeEmptyArrays")&&t.removeEmptyArrays,isRoot:!0})}export{F as convertType,G as dedupeArray,X as removeObjectPaths,L as toBooleanContent,V as toBooleanContentDeep,Z as toBooleanExplicit,x as toBooleanLoose,K as toNumberArrayUnRecursive,Y as toNumberDeep,q as toStringDeep,U as toStringDeepForce};
+/*!
+ * ====================================================
+ * Rzl Utils-JS.
+ * ----------------------------------------------------
+ * Version: 3.5.1.
+ * Author: Rizalvin Dwiky.
+ * Repository: https://github.com/rzl-zone/utils-js.
+ * ====================================================
+ */
+import { isNonEmptyValue, isTypedArray } from './chunk-5IGC6PBH.js';
+import { filterNilArray } from './chunk-OI5XKNZO.js';
+import { isEmptyString } from './chunk-W2WNBUDE.js';
+import { assertIsString } from './chunk-SBKGWRS5.js';
+import { isRegExp, isEqual } from './chunk-NBZWMBO6.js';
+import { isEmptyObject, isEmptyArray } from './chunk-6JFCSH7J.js';
+import { assertIsArray } from './chunk-CKTLUNWX.js';
+import { safeStableStringify, isDate, isMap } from './chunk-PET42Z7W.js';
+import { isBigInt } from './chunk-QNKGP5DY.js';
+import { assertIsPlainObject, hasOwnProp, assertIsBoolean, isArray, isNull, getPreciseType, isNaN, isString, isNumber, isBoolean, isNil, isNumberObject, isBooleanObject, isStringObject, isSymbol, isFunction, isObjectOrArray, isError, isSet, isObject, isNonEmptyString, isPlainObject, isUndefined, isInfinityNumber, isBuffer } from './chunk-CMW2TBOQ.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 str = String(x).trim();
+      const match = str.match(/-?\d+(\.\d+)?/);
+      return match ? Number(match[0]) : isNull(x) ? null : void 0;
+    });
+    return riv ? filterNilArray(result) : result;
+  }
+  return void 0;
+}
+
+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)}\`.`
+    );
+  }
+  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;
+}
+
+var 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)}\`.`
+    );
+  }
+  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);
+};
+
+var 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);
+};
+
+var 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;
+};
+
+var 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;
+};
+
+var 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);
+};
+
+var 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;
+};
+
+var deepCloneSafe = (obj) => {
+  try {
+    if (isFunction(structuredClone)) {
+      return structuredClone(obj);
+    }
+  } catch {
+  }
+  return JSON.parse(JSON.stringify(obj));
+};
+
+var 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)) {
+    if (isPlainObject(obj)) delete obj[currentKey];
+  } else if (isPlainObject(obj) && isObjectOrArray(obj[currentKey])) {
+    deleteNestedKey(obj[currentKey], rest);
+  }
+  return obj;
+};
+
+var deleteExactPathOnce = (obj, path) => {
+  if (!isPlainObject(obj)) return obj;
+  const [currentKey, ...rest] = path;
+  if (rest.length === 0) {
+    if (isPlainObject(obj)) delete obj[currentKey];
+  } else if (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
+    )}\`.`
+  });
+  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
+      )}\`.`
+    );
+  }
+  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\`) \u2794 (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(input2, options2) {
+    if (isNil(input2) || isRegExp(input2)) return void 0;
+    const { removeEmptyArrays: removeEmptyArrays2, removeEmptyObjects: removeEmptyObjects2, isRoot } = options2;
+    if (!isBoolean(removeEmptyObjects2) || !isBoolean(removeEmptyArrays2)) {
+      throw new TypeError(
+        `Parameters \`removeEmptyObjects\` and \`removeEmptyArrays\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['removeEmptyObjects': \`${getPreciseType(
+          removeEmptyObjects2
+        )}\`, 'removeEmptyArrays': \`${getPreciseType(removeEmptyArrays2)}\`].`
+      );
+    }
+    if (isNumber(input2) || isBoolean(input2) || isNonEmptyString(input2)) {
+      const num = Number(input2);
+      return isInfinityNumber(num) || isNaN(num) ? void 0 : num;
+    }
+    if (isNumberObject(input2) || isStringObject(input2) || isBooleanObject(input2)) {
+      const valOf = Number(input2.valueOf());
+      return isInfinityNumber(valOf) || isNaN(valOf) ? void 0 : valOf;
+    }
+    if (isDate(input2, { skipInvalidDate: true })) {
+      try {
+        return !isNaN(input2.getTime()) ? input2.getTime() : 0;
+      } catch {
+        return 0;
+      }
+    }
+    if (isBuffer(input2)) {
+      const arr = Array.from(input2).map(
+        (n) => _internal(n, {
+          removeEmptyObjects: removeEmptyObjects2,
+          removeEmptyArrays: removeEmptyArrays2,
+          isRoot: false
+        })
+      ).filter((item) => !isUndefined(item));
+      if (removeEmptyArrays2 && isEmptyArray(arr)) return void 0;
+      return arr;
+    }
+    if (isTypedArray(input2)) {
+      if (input2 instanceof BigInt64Array || input2 instanceof BigUint64Array) {
+        const newArray = Array.from(input2).map(
+          (item) => _internal(item, {
+            removeEmptyObjects: removeEmptyObjects2,
+            removeEmptyArrays: removeEmptyArrays2,
+            isRoot: false
+          })
+        ).filter((item) => !isUndefined(item));
+        if (removeEmptyArrays2 && isEmptyArray(newArray)) return void 0;
+        return newArray;
+      } else {
+        const newArray = Array.from(input2).map(
+          (item) => _internal(item, {
+            removeEmptyObjects: removeEmptyObjects2,
+            removeEmptyArrays: removeEmptyArrays2,
+            isRoot: false
+          })
+        ).filter((item) => !isUndefined(item));
+        if (removeEmptyArrays2 && isEmptyArray(newArray)) return void 0;
+        return newArray;
+      }
+    }
+    if (isSet(input2)) {
+      const newArray = Array.from(input2).map(
+        (item) => _internal(item, {
+          removeEmptyObjects: removeEmptyObjects2,
+          removeEmptyArrays: removeEmptyArrays2,
+          isRoot: false
+        })
+      ).filter((item) => !isUndefined(item));
+      if (removeEmptyArrays2 && isEmptyArray(newArray)) return void 0;
+      return newArray;
+    }
+    if (isMap(input2)) {
+      let newArray = Array.from(input2.entries()).map(([k, v]) => {
+        const key = _internal(k, {
+          removeEmptyObjects: removeEmptyObjects2,
+          removeEmptyArrays: removeEmptyArrays2,
+          isRoot: false
+        });
+        const value = _internal(v, {
+          removeEmptyObjects: removeEmptyObjects2,
+          removeEmptyArrays: removeEmptyArrays2,
+          isRoot: false
+        });
+        return !isUndefined(key) && !isUndefined(value) ? [key, value] : void 0;
+      }).filter((item) => !isUndefined(item));
+      if (removeEmptyArrays2) {
+        newArray = newArray.filter((v) => !isEmptyArray(v));
+      }
+      if (removeEmptyArrays2 && isEmptyArray(newArray)) return void 0;
+      return newArray;
+    }
+    if (isArray(input2)) {
+      const newArray = input2.map(
+        (item) => _internal(item, {
+          removeEmptyObjects: removeEmptyObjects2,
+          removeEmptyArrays: removeEmptyArrays2,
+          isRoot: false
+        })
+      ).filter((item) => !isUndefined(item));
+      if (removeEmptyArrays2 && isEmptyArray(newArray)) return void 0;
+      return newArray;
+    }
+    if (isObject(input2)) {
+      const newObject = {};
+      for (const [key, value] of Object.entries(input2)) {
+        const convertedValue = _internal(value, {
+          removeEmptyObjects: removeEmptyObjects2,
+          removeEmptyArrays: removeEmptyArrays2,
+          isRoot: false
+        });
+        if (!isUndefined(convertedValue)) {
+          newObject[key] = convertedValue;
+        }
+      }
+      if (removeEmptyObjects2 && isEmptyObject(newObject)) {
+        return isRoot ? {} : void 0;
+      }
+      return newObject;
+    }
+    return void 0;
+  }
+  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(input2, options2) {
+    if (isNil(input2) || isInfinityNumber(input2)) return void 0;
+    const { removeEmptyArrays: removeEmptyArrays2, removeEmptyObjects: removeEmptyObjects2, isRoot } = options2;
+    if (!isBoolean(removeEmptyObjects2) || !isBoolean(removeEmptyArrays2)) {
+      throw new TypeError(
+        `Parameters \`removeEmptyObjects\` and \`removeEmptyArrays\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['removeEmptyObjects': \`${getPreciseType(
+          removeEmptyObjects2
+        )}\`, 'removeEmptyArrays': \`${getPreciseType(removeEmptyArrays2)}\`].`
+      );
+    }
+    if (isNumber(input2) || isString(input2) || isBoolean(input2)) return String(input2);
+    if (isNumberObject(input2)) {
+      const valOf = input2.valueOf();
+      return isInfinityNumber(valOf) || isNaN(valOf) ? void 0 : valOf.toString();
+    }
+    if (isStringObject(input2)) return input2.valueOf();
+    if (isBooleanObject(input2)) return input2.valueOf().toString();
+    if (isDate(input2, { skipInvalidDate: true })) {
+      try {
+        return input2.toISOString();
+      } catch {
+        return input2.toString();
+      }
+    }
+    if (isRegExp(input2)) return input2.toString();
+    if (isBuffer(input2)) {
+      return Array.from(input2).map((v) => String(v)).filter((v) => !isUndefined(v));
+    }
+    if (isTypedArray(input2)) {
+      if (input2 instanceof BigInt64Array || input2 instanceof BigUint64Array) {
+        const newArray = Array.from(input2).map(
+          (item) => _internal(item, {
+            removeEmptyObjects: removeEmptyObjects2,
+            removeEmptyArrays: removeEmptyArrays2,
+            isRoot: false
+          })
+        ).map((v) => String(v)).filter((item) => !isUndefined(item));
+        if (removeEmptyArrays2 && isEmptyArray(newArray)) return void 0;
+        return newArray;
+      } else {
+        const newArray = Array.from(input2).map(
+          (item) => _internal(item, {
+            removeEmptyObjects: removeEmptyObjects2,
+            removeEmptyArrays: removeEmptyArrays2,
+            isRoot: false
+          })
+        ).map((v) => String(v)).filter((item) => !isUndefined(item));
+        if (removeEmptyArrays2 && isEmptyArray(newArray)) return void 0;
+        return newArray;
+      }
+    }
+    if (isSet(input2)) {
+      const arr = Array.from(input2).map(
+        (v) => _internal(v, { removeEmptyObjects: removeEmptyObjects2, removeEmptyArrays: removeEmptyArrays2, isRoot: false })
+      ).filter((v) => !isUndefined(v));
+      if (removeEmptyArrays2 && isEmptyArray(arr)) return void 0;
+      return arr;
+    }
+    if (isMap(input2)) {
+      const arr = Array.from(input2.entries()).map(([k, v]) => [
+        _internal(k, { removeEmptyObjects: removeEmptyObjects2, removeEmptyArrays: removeEmptyArrays2, isRoot: false }),
+        _internal(v, { removeEmptyObjects: removeEmptyObjects2, removeEmptyArrays: removeEmptyArrays2, isRoot: false })
+      ]).filter(([k, v]) => !isUndefined(k) && !isUndefined(v));
+      if (removeEmptyArrays2 && isEmptyArray(arr)) return void 0;
+      return arr;
+    }
+    if (isArray(input2)) {
+      let newArray = input2.map(
+        (item) => _internal(item, {
+          removeEmptyObjects: removeEmptyObjects2,
+          removeEmptyArrays: removeEmptyArrays2,
+          isRoot: false
+        })
+      ).filter((item) => !isUndefined(item));
+      if (removeEmptyArrays2) {
+        newArray = newArray.filter((v) => !(isArray(v) && v.length === 0));
+      }
+      if (removeEmptyArrays2 && isEmptyArray(newArray)) return void 0;
+      return newArray;
+    }
+    if (isObject(input2)) {
+      const newObject = {};
+      for (const [key, value] of Object.entries(input2)) {
+        const convertedValue = _internal(value, {
+          removeEmptyObjects: removeEmptyObjects2,
+          removeEmptyArrays: removeEmptyArrays2,
+          isRoot: false
+        });
+        if (!isUndefined(convertedValue)) {
+          newObject[key] = convertedValue;
+        } else if (isArray(value) && !removeEmptyArrays2) {
+          newObject[key] = [];
+        }
+      }
+      if (removeEmptyObjects2 && Object.keys(newObject).length === 0) {
+        return isRoot ? {} : void 0;
+      }
+      return newObject;
+    }
+    return void 0;
+  }
+  return _internal(input, {
+    removeEmptyObjects,
+    removeEmptyArrays,
+    isRoot: true
+  });
+}
+
+export { convertType, dedupeArray, removeObjectPaths, toBooleanContent, toBooleanContentDeep, toBooleanExplicit, toBooleanLoose, toNumberArrayUnRecursive, toNumberDeep, toStringDeep, toStringDeepForce };