@rzl-zone/utils-js 3.3.1 → 3.5.0

package/dist/chunk-LS6U7FAY.cjs

@@ -1 +1,98 @@
-"use strict";var e=require("./chunk-FJZGG54N.cjs"),r=require("./chunk-JBQMXC5I.cjs"),t=require("./chunk-ZETAZZLD.cjs"),s=require("./chunk-6JFZL7YE.cjs"),i=require("./chunk-T7PU2V7X.cjs"),n=require("./chunk-PZQ6I4JJ.cjs"),a=e=>{s.assertIsArray(e,{message:({currentType:e,validType:r})=>`First parameter (\`values\`) must be of type \`${r}\` (array literal or instance), but received: \`${e}\`.`});const t=[];return e.forEach((s,i)=>{for(let n=i+1;n<e.length;n++)if(r.isEqual(s,e[n])){t.some(e=>r.isEqual(e,s))||t.push(s);break}}),t};exports.findDuplicates=a,exports.omitKeys=(e,r)=>{if(!n.isPlainObject(e))return{};s.assertIsArray(r,{message:({currentType:e,validType:r})=>`Second parameter (\`keysToOmit\`) must be of type \`${r}\` (array literal or instance), but received: \`${e}\`.`});const t=a(r);if(t.length>0)throw new Error(`Function "omitKeys" Error: Duplicate keys detected - \`${t}\``);return Object.fromEntries(Object.entries(e).filter(([e])=>!r.includes(e)))},exports.omitKeysDeep=(r,c)=>{if(!n.isPlainObject(r))return{};s.assertIsArray(c,{message:({currentType:e,validType:r})=>`Second parameter (\`keysToOmit\`) must be of type \`${r}\` (array literal or instance), but received: \`${e}\`.`});const o=a(c);if(n.isNonEmptyArray(o))throw new Error(`Function "omitKeysDeep" Error: Duplicate keys detected - \`${i.safeStableStringify(o)}\`.`);const u=(e,r)=>{if(!n.isObjectOrArray(e))return e;const[s,...i]=r;if(t.isEmptyArray(i))if(n.isArray(e)){const r=parseInt(s);!n.isNaN(r)&&r in e&&e.splice(r,1)}else delete e[s];else{const r=e[s];n.isObjectOrArray(r)&&(e[s]=u(r,i))}return e},y=e=>{if(n.isArray(e))return e.map(y).filter(e=>!(n.isObjectOrArray(e)&&0===Object.keys(e).length));if(n.isObjectOrArray(e)){return Object.fromEntries(Object.entries(e).map(([e,r])=>[e,y(r)]).filter(([,e])=>!(n.isUndefined(e)||n.isObjectOrArray(e)&&0===Object.keys(e).length)))}return e},l=e.safeJsonParse(i.safeStableStringify(r));for(const e of c){const r=e.split(".");u(l,r)}return y(l)};
+'use strict';
+
+var chunkFJZGG54N_cjs = require('./chunk-FJZGG54N.cjs');
+var chunkJBQMXC5I_cjs = require('./chunk-JBQMXC5I.cjs');
+var chunkZETAZZLD_cjs = require('./chunk-ZETAZZLD.cjs');
+var chunk6JFZL7YE_cjs = require('./chunk-6JFZL7YE.cjs');
+var chunkT7PU2V7X_cjs = require('./chunk-T7PU2V7X.cjs');
+var chunkPZQ6I4JJ_cjs = require('./chunk-PZQ6I4JJ.cjs');
+var findDuplicates = (values) => {
+  chunk6JFZL7YE_cjs.assertIsArray(values, {
+    message: ({ currentType, validType }) => `First parameter (\`values\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.`
+  });
+  const duplicates = [];
+  values.forEach((item, index) => {
+    for (let i = index + 1; i < values.length; i++) {
+      if (chunkJBQMXC5I_cjs.isEqual(item, values[i])) {
+        if (!duplicates.some((dup) => chunkJBQMXC5I_cjs.isEqual(dup, item))) {
+          duplicates.push(item);
+        }
+        break;
+      }
+    }
+  });
+  return duplicates;
+};
+var omitKeys = (object, keysToOmit) => {
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(object)) return {};
+  chunk6JFZL7YE_cjs.assertIsArray(keysToOmit, {
+    message: ({ currentType, validType }) => `Second parameter (\`keysToOmit\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.`
+  });
+  const duplicates = findDuplicates(keysToOmit);
+  if (duplicates.length > 0) {
+    throw new Error(
+      `Function "omitKeys" Error: Duplicate keys detected - \`${duplicates}\``
+    );
+  }
+  return Object.fromEntries(
+    Object.entries(object).filter(([key]) => !keysToOmit.includes(key))
+  );
+};
+var omitKeysDeep = (object, keysToOmit) => {
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(object)) return {};
+  chunk6JFZL7YE_cjs.assertIsArray(keysToOmit, {
+    message: ({ currentType, validType }) => `Second parameter (\`keysToOmit\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.`
+  });
+  const duplicates = findDuplicates(keysToOmit);
+  if (chunkPZQ6I4JJ_cjs.isNonEmptyArray(duplicates)) {
+    throw new Error(
+      `Function "omitKeysDeep" Error: Duplicate keys detected - \`${chunkT7PU2V7X_cjs.safeStableStringify(
+        duplicates
+      )}\`.`
+    );
+  }
+  const omitAtPath = (obj, pathParts) => {
+    if (!chunkPZQ6I4JJ_cjs.isObjectOrArray(obj)) return obj;
+    const [current, ...rest] = pathParts;
+    if (chunkZETAZZLD_cjs.isEmptyArray(rest)) {
+      if (chunkPZQ6I4JJ_cjs.isArray(obj)) {
+        const index = parseInt(current);
+        if (!chunkPZQ6I4JJ_cjs.isNaN(index) && index in obj) {
+          obj.splice(index, 1);
+        }
+      } else {
+        delete obj[current];
+      }
+    } else {
+      const next = obj[current];
+      if (chunkPZQ6I4JJ_cjs.isObjectOrArray(next)) {
+        obj[current] = omitAtPath(next, rest);
+      }
+    }
+    return obj;
+  };
+  const deepRemoveEmptyObjects = (obj) => {
+    if (chunkPZQ6I4JJ_cjs.isArray(obj)) {
+      return obj.map(deepRemoveEmptyObjects).filter((item) => !(chunkPZQ6I4JJ_cjs.isObjectOrArray(item) && Object.keys(item).length === 0));
+    }
+    if (chunkPZQ6I4JJ_cjs.isObjectOrArray(obj)) {
+      const cleaned = Object.fromEntries(
+        Object.entries(obj).map(([k, v]) => [k, deepRemoveEmptyObjects(v)]).filter(
+          ([, v]) => !chunkPZQ6I4JJ_cjs.isUndefined(v) && !(chunkPZQ6I4JJ_cjs.isObjectOrArray(v) && Object.keys(v).length === 0)
+        )
+      );
+      return cleaned;
+    }
+    return obj;
+  };
+  const result = chunkFJZGG54N_cjs.safeJsonParse(chunkT7PU2V7X_cjs.safeStableStringify(object));
+  for (const key of keysToOmit) {
+    const parts = key.split(".");
+    omitAtPath(result, parts);
+  }
+  return deepRemoveEmptyObjects(result);
+};
+
+exports.findDuplicates = findDuplicates;
+exports.omitKeys = omitKeys;
+exports.omitKeysDeep = omitKeysDeep;

package/dist/chunk-NBZWMBO6.js

@@ -1 +1,88 @@
-import{isDate as e,isMap as r}from"./chunk-PET42Z7W.js";import{isObjectOrArray as t,isError as n,isSet as f,isArray as i,isUndefined as u}from"./chunk-CMW2TBOQ.js";var o=e=>e instanceof RegExp;function s(e){return e instanceof ArrayBuffer}function g(a,c,l,y=new WeakMap){if(a===c)return!0;if(a!=a&&c!=c)return!0;if(!t(a)||!t(c))return!1;if(y.get(a)===c)return!0;y.set(a,c);const h=(e,r,t,n,f)=>{if(l){const i=l(e,r,t,n,f,y);if(!u(i))return i}return g(e,r,l,y)};if(e(a)&&e(c))return a.getTime()===c.getTime();if(o(a)&&o(c))return a.source===c.source&&a.flags===c.flags;if(n(a)&&n(c))return a.name===c.name&&a.message===c.message;if(ArrayBuffer.isView(a)&&ArrayBuffer.isView(c)){const e=new Uint8Array(a.buffer,a.byteOffset,a.byteLength),r=new Uint8Array(c.buffer,c.byteOffset,c.byteLength);if(e.length!==r.length)return!1;for(let t=0;t<e.length;t++)if(e[t]!==r[t])return!1;return!0}if(s(a)&&s(c)){if(a.byteLength!==c.byteLength)return!1;const e=new Uint8Array(a),r=new Uint8Array(c);for(let t=0;t<e.length;t++)if(e[t]!==r[t])return!1;return!0}if(r(a)&&r(c)){if(a.size!==c.size)return!1;for(const[e,r]of a){if(!c.has(e))return!1;if(!g(r,c.get(e),l,y))return!1}return!0}if(f(a)&&f(c)){if(a.size!==c.size)return!1;for(const e of a){let r=!1;for(const t of c)if(g(e,t,l,y)){r=!0;break}if(!r)return!1}return!0}if(i(a)&&i(c)){if(a.length!==c.length)return!1;for(let e=0;e<a.length;e++)if(!h(a[e],c[e],e,a,c))return!1;return!0}if(Object.getPrototypeOf(a)!==Object.getPrototypeOf(c))return!1;const b=Reflect.ownKeys(a),m=Reflect.ownKeys(c);if(b.length!==m.length)return!1;for(const e of b){if(!h(a[e],c[e],e,a,c))return!1}return!0}function a(e,r){return g(e,r,void 0,new WeakMap)}export{g as baseDeepEqual,s as isArrayBuffer,a as isEqual,o as isRegExp};
+import { isDate, isMap } from './chunk-PET42Z7W.js';
+import { isObjectOrArray, isError, isSet, isArray, isUndefined } from './chunk-CMW2TBOQ.js';
+var isRegExp = (value) => {
+  return value instanceof RegExp;
+};
+function isArrayBuffer(value) {
+  return value instanceof ArrayBuffer;
+}
+function baseDeepEqual(value, other, customizer, seen = /* @__PURE__ */ new WeakMap()) {
+  if (value === other) return true;
+  if (value !== value && other !== other) return true;
+  if (!isObjectOrArray(value) || !isObjectOrArray(other)) {
+    return false;
+  }
+  if (seen.get(value) === other) return true;
+  seen.set(value, other);
+  const callCustomizer = (v, o, key, valObj, othObj) => {
+    if (customizer) {
+      const result = customizer(v, o, key, valObj, othObj, seen);
+      if (!isUndefined(result)) return result;
+    }
+    return baseDeepEqual(v, o, customizer, seen);
+  };
+  if (isDate(value) && isDate(other)) return value.getTime() === other.getTime();
+  if (isRegExp(value) && isRegExp(other))
+    return value.source === other.source && value.flags === other.flags;
+  if (isError(value) && isError(other))
+    return value.name === other.name && value.message === other.message;
+  if (ArrayBuffer.isView(value) && ArrayBuffer.isView(other)) {
+    const v = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    const o = new Uint8Array(other.buffer, other.byteOffset, other.byteLength);
+    if (v.length !== o.length) return false;
+    for (let i = 0; i < v.length; i++) if (v[i] !== o[i]) return false;
+    return true;
+  }
+  if (isArrayBuffer(value) && isArrayBuffer(other)) {
+    if (value.byteLength !== other.byteLength) return false;
+    const v = new Uint8Array(value), o = new Uint8Array(other);
+    for (let i = 0; i < v.length; i++) if (v[i] !== o[i]) return false;
+    return true;
+  }
+  if (isMap(value) && isMap(other)) {
+    if (value.size !== other.size) return false;
+    for (const [k, v] of value) {
+      if (!other.has(k)) return false;
+      if (!baseDeepEqual(v, other.get(k), customizer, seen)) return false;
+    }
+    return true;
+  }
+  if (isSet(value) && isSet(other)) {
+    if (value.size !== other.size) return false;
+    for (const v of value) {
+      let matched = false;
+      for (const o of other) {
+        if (baseDeepEqual(v, o, customizer, seen)) {
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) return false;
+    }
+    return true;
+  }
+  if (isArray(value) && isArray(other)) {
+    if (value.length !== other.length) return false;
+    for (let i = 0; i < value.length; i++) {
+      if (!callCustomizer(value[i], other[i], i, value, other)) return false;
+    }
+    return true;
+  }
+  if (Object.getPrototypeOf(value) !== Object.getPrototypeOf(other)) {
+    return false;
+  }
+  const vKeys = Reflect.ownKeys(value);
+  const oKeys = Reflect.ownKeys(other);
+  if (vKeys.length !== oKeys.length) return false;
+  for (const key of vKeys) {
+    const vVal = value[key];
+    const oVal = other[key];
+    if (!callCustomizer(vVal, oVal, key, value, other)) return false;
+  }
+  return true;
+}
+function isEqual(value, other) {
+  return baseDeepEqual(value, other, void 0, /* @__PURE__ */ new WeakMap());
+}
+
+export { baseDeepEqual, isArrayBuffer, isEqual, isRegExp };

package/dist/chunk-NRF6LWBC.cjs

@@ -1 +1,45 @@
-"use strict";var e=require("./chunk-V45XJKHW.cjs"),r=require("./chunk-ZETAZZLD.cjs"),i=require("./chunk-UDA26MCU.cjs"),s=require("./chunk-PZQ6I4JJ.cjs");function t(e){if(s.isNil(e))return;if(!s.isArray(e))return[];return e.reduce((e,i)=>{if(!s.isNil(i))if(s.isArray(i)){const s=t(i);s&&!r.isEmptyArray(s)&&e.push(s)}else e.push(i);return e},[])}exports.filterNilArray=t,exports.toStringArrayUnRecursive=function(r,n={}){s.assertIsPlainObject(n,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});const u=!s.hasOwnProp(n,"removeInvalidValue")||n.removeInvalidValue;if(s.assertIsBoolean(u,{message:({currentType:e,validType:r})=>`Parameter \`removeInvalidValue\` property of the \`options\` (second parameter) must be of type \`${r}\`, but received: \`${e}\`.`}),s.isArray(r)){const n=Array.from(r,r=>s.isString(r)||e.isFinite(r)||s.isBoolean(r)||i.isBigInt(r)?String(r):s.isNull(r)?null:void 0);return u?t(n):n}};
+'use strict';
+
+var chunkV45XJKHW_cjs = require('./chunk-V45XJKHW.cjs');
+var chunkZETAZZLD_cjs = require('./chunk-ZETAZZLD.cjs');
+var chunkUDA26MCU_cjs = require('./chunk-UDA26MCU.cjs');
+var chunkPZQ6I4JJ_cjs = require('./chunk-PZQ6I4JJ.cjs');
+function filterNilArray(input) {
+  if (chunkPZQ6I4JJ_cjs.isNil(input)) return void 0;
+  if (!chunkPZQ6I4JJ_cjs.isArray(input)) return [];
+  const filtered = input.reduce((output, element) => {
+    if (!chunkPZQ6I4JJ_cjs.isNil(element)) {
+      if (chunkPZQ6I4JJ_cjs.isArray(element)) {
+        const cleanedNested = filterNilArray(element);
+        if (cleanedNested && !chunkZETAZZLD_cjs.isEmptyArray(cleanedNested)) {
+          output.push(cleanedNested);
+        }
+      } else {
+        output.push(element);
+      }
+    }
+    return output;
+  }, []);
+  return filtered;
+}
+function toStringArrayUnRecursive(array, options = {}) {
+  chunkPZQ6I4JJ_cjs.assertIsPlainObject(options, {
+    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const riv = chunkPZQ6I4JJ_cjs.hasOwnProp(options, "removeInvalidValue") ? options.removeInvalidValue : true;
+  chunkPZQ6I4JJ_cjs.assertIsBoolean(riv, {
+    message: ({ currentType, validType }) => `Parameter \`removeInvalidValue\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  if (chunkPZQ6I4JJ_cjs.isArray(array)) {
+    const result = Array.from(array, (x) => {
+      if (chunkPZQ6I4JJ_cjs.isString(x) || chunkV45XJKHW_cjs.isFinite(x) || chunkPZQ6I4JJ_cjs.isBoolean(x) || chunkUDA26MCU_cjs.isBigInt(x)) return String(x);
+      return chunkPZQ6I4JJ_cjs.isNull(x) ? null : void 0;
+    });
+    if (riv) return filterNilArray(result);
+    return result;
+  }
+  return void 0;
+}
+
+exports.filterNilArray = filterNilArray;
+exports.toStringArrayUnRecursive = toStringArrayUnRecursive;

package/dist/chunk-OI5XKNZO.js

@@ -1 +1,42 @@
-import{isFinite as e}from"./chunk-3IBQ5MOM.js";import{isEmptyArray as r}from"./chunk-6JFCSH7J.js";import{isBigInt as t}from"./chunk-QNKGP5DY.js";import{isNil as o,isArray as n,assertIsPlainObject as u,hasOwnProp as i,assertIsBoolean as m,isString as p,isBoolean as s,isNull as a}from"./chunk-CMW2TBOQ.js";function c(e){if(o(e))return;if(!n(e))return[];return e.reduce((e,t)=>{if(!o(t))if(n(t)){const o=c(t);o&&!r(o)&&e.push(o)}else e.push(t);return e},[])}function f(r,o={}){u(o,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});const f=!i(o,"removeInvalidValue")||o.removeInvalidValue;if(m(f,{message:({currentType:e,validType:r})=>`Parameter \`removeInvalidValue\` property of the \`options\` (second parameter) must be of type \`${r}\`, but received: \`${e}\`.`}),n(r)){const o=Array.from(r,r=>p(r)||e(r)||s(r)||t(r)?String(r):a(r)?null:void 0);return f?c(o):o}}export{c as filterNilArray,f as toStringArrayUnRecursive};
+import { isFinite } from './chunk-3IBQ5MOM.js';
+import { isEmptyArray } from './chunk-6JFCSH7J.js';
+import { isBigInt } from './chunk-QNKGP5DY.js';
+import { isNil, isArray, assertIsPlainObject, hasOwnProp, assertIsBoolean, isString, isBoolean, isNull } from './chunk-CMW2TBOQ.js';
+function filterNilArray(input) {
+  if (isNil(input)) return void 0;
+  if (!isArray(input)) return [];
+  const filtered = input.reduce((output, element) => {
+    if (!isNil(element)) {
+      if (isArray(element)) {
+        const cleanedNested = filterNilArray(element);
+        if (cleanedNested && !isEmptyArray(cleanedNested)) {
+          output.push(cleanedNested);
+        }
+      } else {
+        output.push(element);
+      }
+    }
+    return output;
+  }, []);
+  return filtered;
+}
+function toStringArrayUnRecursive(array, options = {}) {
+  assertIsPlainObject(options, {
+    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const riv = hasOwnProp(options, "removeInvalidValue") ? options.removeInvalidValue : true;
+  assertIsBoolean(riv, {
+    message: ({ currentType, validType }) => `Parameter \`removeInvalidValue\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  if (isArray(array)) {
+    const result = Array.from(array, (x) => {
+      if (isString(x) || isFinite(x) || isBoolean(x) || isBigInt(x)) return String(x);
+      return isNull(x) ? null : void 0;
+    });
+    if (riv) return filterNilArray(result);
+    return result;
+  }
+  return void 0;
+}
+
+export { filterNilArray, toStringArrayUnRecursive };

package/dist/chunk-ONZFBJVW.js

@@ -1 +1,5 @@
-var a=a=>a instanceof URL;export{a as isURL};
+var isURL = (value) => {
+  return value instanceof URL;
+};
+
+export { isURL };

package/dist/chunk-OYTYSY7G.js

@@ -1 +1,94 @@
-import{safeJsonParse as e}from"./chunk-2CQX5CBG.js";import{isEqual as r}from"./chunk-NBZWMBO6.js";import{isEmptyArray as t}from"./chunk-6JFCSH7J.js";import{assertIsArray as n}from"./chunk-CKTLUNWX.js";import{safeStableStringify as o}from"./chunk-PET42Z7W.js";import{isPlainObject as s,isNonEmptyArray as i,isObjectOrArray as c,isArray as a,isNaN as u,isUndefined as m}from"./chunk-CMW2TBOQ.js";var f=e=>{n(e,{message:({currentType:e,validType:r})=>`First parameter (\`values\`) must be of type \`${r}\` (array literal or instance), but received: \`${e}\`.`});const t=[];return e.forEach((n,o)=>{for(let s=o+1;s<e.length;s++)if(r(n,e[s])){t.some(e=>r(e,n))||t.push(n);break}}),t},p=(e,r)=>{if(!s(e))return{};n(r,{message:({currentType:e,validType:r})=>`Second parameter (\`keysToOmit\`) must be of type \`${r}\` (array literal or instance), but received: \`${e}\`.`});const t=f(r);if(t.length>0)throw new Error(`Function "omitKeys" Error: Duplicate keys detected - \`${t}\``);return Object.fromEntries(Object.entries(e).filter(([e])=>!r.includes(e)))},l=(r,p)=>{if(!s(r))return{};n(p,{message:({currentType:e,validType:r})=>`Second parameter (\`keysToOmit\`) must be of type \`${r}\` (array literal or instance), but received: \`${e}\`.`});const l=f(p);if(i(l))throw new Error(`Function "omitKeysDeep" Error: Duplicate keys detected - \`${o(l)}\`.`);const y=(e,r)=>{if(!c(e))return e;const[n,...o]=r;if(t(o))if(a(e)){const r=parseInt(n);!u(r)&&r in e&&e.splice(r,1)}else delete e[n];else{const r=e[n];c(r)&&(e[n]=y(r,o))}return e},d=e=>{if(a(e))return e.map(d).filter(e=>!(c(e)&&0===Object.keys(e).length));if(c(e)){return Object.fromEntries(Object.entries(e).map(([e,r])=>[e,d(r)]).filter(([,e])=>!(m(e)||c(e)&&0===Object.keys(e).length)))}return e},h=e(o(r));for(const e of p){const r=e.split(".");y(h,r)}return d(h)};export{f as findDuplicates,p as omitKeys,l as omitKeysDeep};
+import { safeJsonParse } from './chunk-2CQX5CBG.js';
+import { isEqual } from './chunk-NBZWMBO6.js';
+import { isEmptyArray } from './chunk-6JFCSH7J.js';
+import { assertIsArray } from './chunk-CKTLUNWX.js';
+import { safeStableStringify } from './chunk-PET42Z7W.js';
+import { isPlainObject, isNonEmptyArray, isObjectOrArray, isArray, isNaN, isUndefined } from './chunk-CMW2TBOQ.js';
+var findDuplicates = (values) => {
+  assertIsArray(values, {
+    message: ({ currentType, validType }) => `First parameter (\`values\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.`
+  });
+  const duplicates = [];
+  values.forEach((item, index) => {
+    for (let i = index + 1; i < values.length; i++) {
+      if (isEqual(item, values[i])) {
+        if (!duplicates.some((dup) => isEqual(dup, item))) {
+          duplicates.push(item);
+        }
+        break;
+      }
+    }
+  });
+  return duplicates;
+};
+var omitKeys = (object, keysToOmit) => {
+  if (!isPlainObject(object)) return {};
+  assertIsArray(keysToOmit, {
+    message: ({ currentType, validType }) => `Second parameter (\`keysToOmit\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.`
+  });
+  const duplicates = findDuplicates(keysToOmit);
+  if (duplicates.length > 0) {
+    throw new Error(
+      `Function "omitKeys" Error: Duplicate keys detected - \`${duplicates}\``
+    );
+  }
+  return Object.fromEntries(
+    Object.entries(object).filter(([key]) => !keysToOmit.includes(key))
+  );
+};
+var omitKeysDeep = (object, keysToOmit) => {
+  if (!isPlainObject(object)) return {};
+  assertIsArray(keysToOmit, {
+    message: ({ currentType, validType }) => `Second parameter (\`keysToOmit\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.`
+  });
+  const duplicates = findDuplicates(keysToOmit);
+  if (isNonEmptyArray(duplicates)) {
+    throw new Error(
+      `Function "omitKeysDeep" Error: Duplicate keys detected - \`${safeStableStringify(
+        duplicates
+      )}\`.`
+    );
+  }
+  const omitAtPath = (obj, pathParts) => {
+    if (!isObjectOrArray(obj)) return obj;
+    const [current, ...rest] = pathParts;
+    if (isEmptyArray(rest)) {
+      if (isArray(obj)) {
+        const index = parseInt(current);
+        if (!isNaN(index) && index in obj) {
+          obj.splice(index, 1);
+        }
+      } else {
+        delete obj[current];
+      }
+    } else {
+      const next = obj[current];
+      if (isObjectOrArray(next)) {
+        obj[current] = omitAtPath(next, rest);
+      }
+    }
+    return obj;
+  };
+  const deepRemoveEmptyObjects = (obj) => {
+    if (isArray(obj)) {
+      return obj.map(deepRemoveEmptyObjects).filter((item) => !(isObjectOrArray(item) && Object.keys(item).length === 0));
+    }
+    if (isObjectOrArray(obj)) {
+      const cleaned = Object.fromEntries(
+        Object.entries(obj).map(([k, v]) => [k, deepRemoveEmptyObjects(v)]).filter(
+          ([, v]) => !isUndefined(v) && !(isObjectOrArray(v) && Object.keys(v).length === 0)
+        )
+      );
+      return cleaned;
+    }
+    return obj;
+  };
+  const result = safeJsonParse(safeStableStringify(object));
+  for (const key of keysToOmit) {
+    const parts = key.split(".");
+    omitAtPath(result, parts);
+  }
+  return deepRemoveEmptyObjects(result);
+};
+
+export { findDuplicates, omitKeys, omitKeysDeep };

package/dist/chunk-PET42Z7W.js

@@ -1 +1,107 @@
-import{isBigInt as e}from"./chunk-QNKGP5DY.js";import{assertIsPlainObject as r,isPlainObject as t,isBoolean as n,isNaN as o,hasOwnProp as s,getPreciseType as i,isUndefined as a,isNumberObject as u,isInfinityNumber as f,isStringObject as p,isBooleanObject as c,isFunction as l,isSymbol as y,isObjectOrArray as d,isSet as m,isArray as b,isNull as v,isNumber as S,isObject as g}from"./chunk-CMW2TBOQ.js";function k(e){return"[object Map]"===Object.prototype.toString.call(e)||e instanceof Map}var h=(e,s={})=>{r(s,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});const i=!(!t(s)||!n(s.skipInvalidDate))&&s.skipInvalidDate,a=e instanceof Date;return i?a:a&&!o(e.getTime())},O=(t,O={})=>{r(O,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});const $=!!s(O,"pretty")&&O.pretty,T=!s(O,"sortKeys")||O.sortKeys,A=!!s(O,"sortArray")&&O.sortArray,j=!!s(O,"keepUndefined")&&O.keepUndefined;if(!(n(T)&&n(A)&&n($)&&n(j)))throw new TypeError(`Parameters \`sortKeys\`, \`sortArray\`, \`keepUndefined\` and \`pretty\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: "['sortKeys': \`${i(T)}\`, 'sortArray': \`${i(A)}\`, 'keepUndefined': \`${i(j)}\`, 'pretty': \`${i($)}\`]".`);if(a(t))return j?"undefined":"null";const K=new WeakSet,w=e=>v(e)||!d(e)&&!l(e),C=r=>{if(u(r)){const e=r.valueOf();return o(e)||f(e)?null:e}if(p(r))return r.valueOf();if(c(r))return r.valueOf();if(!l(r)&&!y(r)){if(e(r))return r.toString();if(o(r)||f(r))return null;if(a(r))return j?void 0:null;if(d(r)){if(K.has(r))return"[Circular]";if(K.add(r),h(r))return r.toISOString();if(k(r))return{map:Array.from(r.entries()).map(([e,r])=>[e,C(r)])};if(m(r))return{set:Array.from(r.values()).map(C)};if(b(r)){const e=r.map(C);if(A){const r=[],t=[];for(const n of e)w(n)?r.push(n):t.push(n);return r.sort((e,r)=>S(e)&&S(r)?e-r:String(e).localeCompare(String(r))),[...r,...t]}return e}const e=Object.keys(r);T&&e.sort((e,r)=>{const t=Number(e),n=Number(r);return o(t)||o(n)?e.localeCompare(r):t-n});const t={};if(g(r))for(const n of e){const e=C(r[n]);a(e)||(t[n]=e)}return t}return r}};try{return JSON.stringify(C(t),null,$?2:0)}catch(e){return console.warn("Error in safeStableStringify:",e),"{}"}};export{h as isDate,k as isMap,O as safeStableStringify};
+import { isBigInt } from './chunk-QNKGP5DY.js';
+import { assertIsPlainObject, isPlainObject, isBoolean, isNaN, hasOwnProp, getPreciseType, isUndefined, isNumberObject, isInfinityNumber, isStringObject, isBooleanObject, isFunction, isSymbol, isObjectOrArray, isSet, isArray, isNull, isNumber, isObject } from './chunk-CMW2TBOQ.js';
+function isMap(value) {
+  return Object.prototype.toString.call(value) === "[object Map]" || value instanceof Map;
+}
+var isDate = (value, options = {}) => {
+  assertIsPlainObject(options, {
+    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const skipInvalidDate = isPlainObject(options) && isBoolean(options.skipInvalidDate) ? options.skipInvalidDate : false;
+  const instanceDate = value instanceof Date;
+  if (skipInvalidDate) return instanceDate;
+  return instanceDate && !isNaN(value.getTime());
+};
+var safeStableStringify = (value, options = {}) => {
+  assertIsPlainObject(options, {
+    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const pretty = hasOwnProp(options, "pretty") ? options.pretty : false;
+  const sortKeys = hasOwnProp(options, "sortKeys") ? options.sortKeys : true;
+  const sortArray = hasOwnProp(options, "sortArray") ? options.sortArray : false;
+  const keepUndefined = hasOwnProp(options, "keepUndefined") ? options.keepUndefined : false;
+  if (!isBoolean(sortKeys) || !isBoolean(sortArray) || !isBoolean(pretty) || !isBoolean(keepUndefined)) {
+    throw new TypeError(
+      `Parameters \`sortKeys\`, \`sortArray\`, \`keepUndefined\` and \`pretty\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: "['sortKeys': \`${getPreciseType(
+        sortKeys
+      )}\`, 'sortArray': \`${getPreciseType(
+        sortArray
+      )}\`, 'keepUndefined': \`${getPreciseType(
+        keepUndefined
+      )}\`, 'pretty': \`${getPreciseType(pretty)}\`]".`
+    );
+  }
+  if (isUndefined(value)) {
+    return keepUndefined ? "undefined" : "null";
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const isPrimitive = (val) => isNull(val) || !isObjectOrArray(val) && !isFunction(val);
+  const deepProcess = (val) => {
+    if (isNumberObject(val)) {
+      const valOf = val.valueOf();
+      return isNaN(valOf) || isInfinityNumber(valOf) ? null : valOf;
+    }
+    if (isStringObject(val)) return val.valueOf();
+    if (isBooleanObject(val)) return val.valueOf();
+    if (isFunction(val) || isSymbol(val)) return void 0;
+    if (isBigInt(val)) return val.toString();
+    if (isNaN(val) || isInfinityNumber(val)) return null;
+    if (isUndefined(val)) {
+      return keepUndefined ? void 0 : null;
+    }
+    if (isObjectOrArray(val)) {
+      if (seen.has(val)) return "[Circular]";
+      seen.add(val);
+      if (isDate(val)) return val.toISOString();
+      if (isMap(val)) {
+        return {
+          map: Array.from(val.entries()).map(([k, v]) => [k, deepProcess(v)])
+        };
+      }
+      if (isSet(val)) return { set: Array.from(val.values()).map(deepProcess) };
+      if (isArray(val)) {
+        const processedArr = val.map(deepProcess);
+        if (sortArray) {
+          const primitives = [];
+          const nonPrimitives = [];
+          for (const item of processedArr) {
+            if (isPrimitive(item)) primitives.push(item);
+            else nonPrimitives.push(item);
+          }
+          primitives.sort((a, b) => {
+            if (isNumber(a) && isNumber(b)) return a - b;
+            return String(a).localeCompare(String(b));
+          });
+          return [...primitives, ...nonPrimitives];
+        }
+        return processedArr;
+      }
+      const keys = Object.keys(val);
+      if (sortKeys) {
+        keys.sort((a, b) => {
+          const na = Number(a);
+          const nb = Number(b);
+          if (!isNaN(na) && !isNaN(nb)) return na - nb;
+          return a.localeCompare(b);
+        });
+      }
+      const result = {};
+      if (isObject(val)) {
+        for (const k of keys) {
+          const v = deepProcess(val[k]);
+          if (!isUndefined(v)) result[k] = v;
+        }
+      }
+      return result;
+    }
+    return val;
+  };
+  try {
+    return JSON.stringify(deepProcess(value), null, pretty ? 2 : 0);
+  } catch (err) {
+    console.warn("Error in safeStableStringify:", err);
+    return "{}";
+  }
+};
+
+export { isDate, isMap, safeStableStringify };