@rzl-zone/utils-js 3.1.0-beta.2 → 3.1.2-beta.0

package/dist/nils-DMz3kU7M.d.ts

@@ -1,177 +1,177 @@
 /** --------------------------------------------------
-* * ***Nullish.***
-* --------------------------------------------------
-* Represents all values considered **"nullish"**:
-* - `null`
-* - `undefined`
-*
-* Useful as a shorthand when working with optional or missing values.
-*/
+ * * ***Nullish.***
+ * --------------------------------------------------
+ * Represents all values considered **"nullish"**:
+ * - `null`
+ * - `undefined`
+ *
+ * Useful as a shorthand when working with optional or missing values.
+ */
 type Nullish=null|undefined;
 /** --------------------------------------------------
-* * ***Nullable.***
-* --------------------------------------------------
-* Represents a type that can be either `T` or `null`.
-*
-* @template T - The base type.
-*
-* @example
-* ```ts
-* type A = Nullable<string>; // ➔ string | null
-* ```
-*/
+ * * ***Nullable.***
+ * --------------------------------------------------
+ * Represents a type that can be either `T` or `null`.
+ *
+ * @template T - The base type.
+ *
+ * @example
+ * ```ts
+ * type A = Nullable<string>; // ➔ string | null
+ * ```
+ */
 type Nullable<T>=T|null;
 /** --------------------------------------------------
-* * ***Nilable.***
-* --------------------------------------------------
-* Represents a type that can be either `T`, `null`, or `undefined`.
-*
-* @template T - The base type.
-*
-* @example
-* ```ts
-* type A = Nilable<number>; // ➔ number | null | undefined
-* ```
-*/
+ * * ***Nilable.***
+ * --------------------------------------------------
+ * Represents a type that can be either `T`, `null`, or `undefined`.
+ *
+ * @template T - The base type.
+ *
+ * @example
+ * ```ts
+ * type A = Nilable<number>; // ➔ number | null | undefined
+ * ```
+ */
 type Nilable<T>=T|null|undefined;
 /** --------------------------------------------------
-* * ***Undefinedable.***
-* --------------------------------------------------
-* Represents a type that can be either `T` or `undefined`.
-*
-* @template T - The base type.
-*
-* @example
-* ```ts
-* type A = Undefinedable<boolean>; // ➔ boolean | undefined
-* ```
-*/
+ * * ***Undefinedable.***
+ * --------------------------------------------------
+ * Represents a type that can be either `T` or `undefined`.
+ *
+ * @template T - The base type.
+ *
+ * @example
+ * ```ts
+ * type A = Undefinedable<boolean>; // ➔ boolean | undefined
+ * ```
+ */
 type Undefinedable<T>=T|undefined;
 /** -------------------------------------------------------
-* * ***NonNil.***
-* -------------------------------------------------------
-* Removes both `null` and `undefined` from the given type `T`.
-*
-* @template T - The type to filter.
-*
-* @example
-* ```ts
-* type A = NonNil<string | null | undefined>;
-* // ➔ string
-*
-* type B = NonNil<number | null>;
-* // ➔ number
-*
-* type C = NonNil<undefined | null>;
-* // ➔ never
-*
-* type D = NonNil<boolean | undefined>;
-* // ➔ boolean
-* ```
-*/
+ * * ***NonNil.***
+ * -------------------------------------------------------
+ * Removes both `null` and `undefined` from the given type `T`.
+ *
+ * @template T - The type to filter.
+ *
+ * @example
+ * ```ts
+ * type A = NonNil<string | null | undefined>;
+ * // ➔ string
+ *
+ * type B = NonNil<number | null>;
+ * // ➔ number
+ *
+ * type C = NonNil<undefined | null>;
+ * // ➔ never
+ *
+ * type D = NonNil<boolean | undefined>;
+ * // ➔ boolean
+ * ```
+ */
 type NonNil<T>=T extends null|undefined?never:T;
 /** -------------------------------------------------------
-* * ***NonNull.***
-* -------------------------------------------------------
-* Removes `null` from the given type `T`.
-*
-* @template T - The type to filter.
-*
-* @example
-* ```ts
-* type A = NonNull<string | null>;
-* // ➔ string
-*
-* type B = NonNull<number | null | undefined>;
-* // ➔ number | undefined
-*
-* type C = NonNull<null>;
-* // ➔ never
-* ```
-*/
+ * * ***NonNull.***
+ * -------------------------------------------------------
+ * Removes `null` from the given type `T`.
+ *
+ * @template T - The type to filter.
+ *
+ * @example
+ * ```ts
+ * type A = NonNull<string | null>;
+ * // ➔ string
+ *
+ * type B = NonNull<number | null | undefined>;
+ * // ➔ number | undefined
+ *
+ * type C = NonNull<null>;
+ * // ➔ never
+ * ```
+ */
 type NonNull<T>=T extends null?never:T;
 /** -------------------------------------------------------
-* * ***NonUndefined.***
-* -------------------------------------------------------
-* Remove `undefined` from the given type `T`.
-*
-* @template T - The type to filter.
-*
-* @example
-* ```ts
-* type A = NonUndefined<string | undefined>;
-* // ➔ string
-*
-* type B = NonUndefined<number | null | undefined>;
-* // ➔ number | null
-*
-* type C = NonUndefined<undefined>;
-* // ➔ never
-* ```
-*/
+ * * ***NonUndefined.***
+ * -------------------------------------------------------
+ * Remove `undefined` from the given type `T`.
+ *
+ * @template T - The type to filter.
+ *
+ * @example
+ * ```ts
+ * type A = NonUndefined<string | undefined>;
+ * // ➔ string
+ *
+ * type B = NonUndefined<number | null | undefined>;
+ * // ➔ number | null
+ *
+ * type C = NonUndefined<undefined>;
+ * // ➔ never
+ * ```
+ */
 type NonUndefined<T>=T extends undefined?never:T;
 /** --------------------------------------------------
-* * ***KeepNil.***
-* --------------------------------------------------
-*
-* Keeps `null` and/or `undefined` in the output type
-* **only if** they exist in the input type `T`.
-* Otherwise, resolves to `never`.
-*
-* @template T - Input type to check for `null` and `undefined`.
-*
-* @example
-* ```ts
-* type A = KeepNil<string | null>;          // ➔ null
-* type B = KeepNil<number | undefined>;     // ➔ undefined
-* type C = KeepNil<string | null | undefined>; // ➔ null | undefined
-* type D = KeepNil<boolean>;                // ➔ never
-* ```
-*/
+ * * ***KeepNil.***
+ * --------------------------------------------------
+ *
+ * Keeps `null` and/or `undefined` in the output type
+ * **only if** they exist in the input type `T`.
+ * Otherwise, resolves to `never`.
+ *
+ * @template T - Input type to check for `null` and `undefined`.
+ *
+ * @example
+ * ```ts
+ * type A = KeepNil<string | null>;          // ➔ null
+ * type B = KeepNil<number | undefined>;     // ➔ undefined
+ * type C = KeepNil<string | null | undefined>; // ➔ null | undefined
+ * type D = KeepNil<boolean>;                // ➔ never
+ * ```
+ */
 type KeepNil<T>=(null extends T?null:never)|(undefined extends T?undefined:never);
 /** --------------------------------------------------
-* * ***KeepNull.***
-* --------------------------------------------------
-* Keeps `null` in the output type **only if** the input type `T` includes `null`.
-* Otherwise resolves to `never`.
-*
-* @template T - Input type to check for `null`.
-*
-* @example
-* ```ts
-* type A = KeepNull<string | null>; // ➔ null
-* type B = KeepNull<string>;        // ➔ never
-* ```
-*/
+ * * ***KeepNull.***
+ * --------------------------------------------------
+ * Keeps `null` in the output type **only if** the input type `T` includes `null`.
+ * Otherwise resolves to `never`.
+ *
+ * @template T - Input type to check for `null`.
+ *
+ * @example
+ * ```ts
+ * type A = KeepNull<string | null>; // ➔ null
+ * type B = KeepNull<string>;        // ➔ never
+ * ```
+ */
 type KeepNull<T>=null extends T?null:never;
 /** --------------------------------------------------
-* * ***KeepUndef.***
-* --------------------------------------------------
-* Keeps `undefined` in the output type **only if** the input type `T` includes `undefined`.
-* Otherwise resolves to `never`.
-*
-* @template T - Input type to check for `undefined`.
-*
-* @example
-* ```ts
-* type A = KeepUndef<number | undefined>; // ➔ undefined
-* type B = KeepUndef<number>;             // ➔ never
-* ```
-*/
+ * * ***KeepUndef.***
+ * --------------------------------------------------
+ * Keeps `undefined` in the output type **only if** the input type `T` includes `undefined`.
+ * Otherwise resolves to `never`.
+ *
+ * @template T - Input type to check for `undefined`.
+ *
+ * @example
+ * ```ts
+ * type A = KeepUndef<number | undefined>; // ➔ undefined
+ * type B = KeepUndef<number>;             // ➔ never
+ * ```
+ */
 type KeepUndef<T>=undefined extends T?undefined:never;
 /** -------------------------------------------------------
-* * ***NullToUndefined.***
-* -------------------------------------------------------
-* Transforms `null` or `undefined` types into `undefined`, otherwise, returns the original type `T` unchanged.
-*
-* @template T - The input type to transform.
-* @example
-* ```ts
-* type A = NullToUndefined<null>;          // ➔ undefined
-* type B = NullToUndefined<undefined>;     // ➔ undefined
-* type C = NullToUndefined<string>;        // ➔ string
-* type D = NullToUndefined<null[]>;        // ➔ null[]
-* type E = NullToUndefined<(string | null)[]>; // ➔ (string | null)[]
-* ```
-*/
+ * * ***NullToUndefined.***
+ * -------------------------------------------------------
+ * Transforms `null` or `undefined` types into `undefined`, otherwise, returns the original type `T` unchanged.
+ *
+ * @template T - The input type to transform.
+ * @example
+ * ```ts
+ * type A = NullToUndefined<null>;          // ➔ undefined
+ * type B = NullToUndefined<undefined>;     // ➔ undefined
+ * type C = NullToUndefined<string>;        // ➔ string
+ * type D = NullToUndefined<null[]>;        // ➔ null[]
+ * type E = NullToUndefined<(string | null)[]>; // ➔ (string | null)[]
+ * ```
+ */
 type NullToUndefined<T>=T extends null?undefined:T extends undefined?undefined:T;export type{KeepNil as K,NonUndefined as N,Undefinedable as U,KeepNull as a,KeepUndef as b,Nilable as c,NonNil as d,NonNull as e,Nullable as f,NullToUndefined as g,Nullish as h};

package/dist/omit-VvmIsZmX.d.ts

@@ -1,28 +1,28 @@
 import{P as Prettify}from'./prettify-C4xLcYOP.js';
 /** --------------------------------------------------
-* * ***OmitStrict.***
-* --------------------------------------------------
-* Strictly omits keys `K` from type `T`, with optional flattening for readability using `Prettify`.
-*
-* ✅ Enhances autocomplete and type inspection clarity in editors.
-* ✅ Optionally flattens nested intersections or mapped types into a cleaner shape.
-*
-* @template T - The original object type.
-* @template K - The keys to omit from `T`.
-* @template WithPrettify - Whether to prettify the result (default is `true`).
-* @template WithPrettifyRecursive - Whether to prettify nested object properties recursively (default is `true`).
-*
-* @example
-* ```ts
-* type A = { a: number; b: string; c: boolean };
-* type B = OmitStrict<A, 'b'>;
-* // ➔ { a: number; c: boolean }
-*
-* type C = OmitStrict<A, 'b', false>;
-* // ➔ Omit without prettifying, keeps intersection structure
-*
-* type D = OmitStrict<A, 'b', true, false>;
-* // ➔ Prettifies only top level, does not recurse into nested objects
-* ```
-*/
+ * * ***OmitStrict.***
+ * --------------------------------------------------
+ * Strictly omits keys `K` from type `T`, with optional flattening for readability using `Prettify`.
+ *
+ * ✅ Enhances autocomplete and type inspection clarity in editors.
+ * ✅ Optionally flattens nested intersections or mapped types into a cleaner shape.
+ *
+ * @template T - The original object type.
+ * @template K - The keys to omit from `T`.
+ * @template WithPrettify - Whether to prettify the result (default is `true`).
+ * @template WithPrettifyRecursive - Whether to prettify nested object properties recursively (default is `true`).
+ *
+ * @example
+ * ```ts
+ * type A = { a: number; b: string; c: boolean };
+ * type B = OmitStrict<A, 'b'>;
+ * // ➔ { a: number; c: boolean }
+ *
+ * type C = OmitStrict<A, 'b', false>;
+ * // ➔ Omit without prettifying, keeps intersection structure
+ *
+ * type D = OmitStrict<A, 'b', true, false>;
+ * // ➔ Prettifies only top level, does not recurse into nested objects
+ * ```
+ */
 type OmitStrict<T,K extends keyof T,WithPrettify extends boolean=true,WithPrettifyRecursive extends boolean=true>=WithPrettify extends true?Prettify<Omit<T,K>,{recursive:WithPrettifyRecursive;}>:WithPrettify extends false?Omit<T,K>:never;export type{OmitStrict as O};

package/dist/operations/index.cjs

@@ -1 +1 @@
-'use strict';var chunkPYUVKHUF_cjs=require('../chunk-PYUVKHUF.cjs');require('../chunk-IJTZWWRJ.cjs'),require('../chunk-PFLNHD4B.cjs'),require('../chunk-ISJ33O2J.cjs'),require('../chunk-RV2VULM7.cjs'),require('../chunk-O7SJR4CY.cjs'),require('../chunk-7YWAQOA4.cjs'),require('../chunk-LVUSFXQS.cjs');Object.defineProperty(exports,"findDuplicates",{enumerable:true,get:function(){return chunkPYUVKHUF_cjs.a}});Object.defineProperty(exports,"omitKeys",{enumerable:true,get:function(){return chunkPYUVKHUF_cjs.b}});Object.defineProperty(exports,"omitKeysDeep",{enumerable:true,get:function(){return chunkPYUVKHUF_cjs.c}});
+'use strict';var chunkEXCOQLWX_cjs=require('../chunk-EXCOQLWX.cjs');require('../chunk-ZFDS7W6B.cjs'),require('../chunk-G7R5XZRM.cjs'),require('../chunk-UQDJF5RR.cjs'),require('../chunk-RV2VULM7.cjs'),require('../chunk-26W3VZIK.cjs'),require('../chunk-7YWAQOA4.cjs'),require('../chunk-CII6WWLO.cjs');Object.defineProperty(exports,"findDuplicates",{enumerable:true,get:function(){return chunkEXCOQLWX_cjs.a}});Object.defineProperty(exports,"omitKeys",{enumerable:true,get:function(){return chunkEXCOQLWX_cjs.b}});Object.defineProperty(exports,"omitKeysDeep",{enumerable:true,get:function(){return chunkEXCOQLWX_cjs.c}});

package/dist/operations/index.d.ts

@@ -1,127 +1,127 @@
 import{N as NumberRangeUnion}from'../NumberRangeUnion-DC-C3_Kq.js';
 /** ----------------------------------------------------------------------
-* * ***Utility: `findDuplicates`.***
-* ----------------------------------------------------------------------
-* **Finds duplicate values in an array by deep equality comparison.**
-* - **Behavior:**
-*    - Uses ***{@link isEqual | `isEqual`}*** to compare elements
-*      (handles objects, arrays, dates, NaN, etc.).
-*    - Returns a new array containing only the *first occurrences* of duplicated values.
-*    - Does **not mutate** the original array.
-*    - Throws ***{@link TypeError | `TypeError`}*** if input is not an array.
-* @template T Type of elements in the input array.
-* @param {T[]} values - The array to check for duplicates.
-* @returns {T[]} An array of the duplicate values found in the input,
-*                preserving order of their first duplicate appearance.
-* @throws {TypeError} If the provided `values` argument is not an array.
-* @example
-* findDuplicates([1, 2, 2, 3, 4, 4]);
-* // ➔ [2, 4]
-* findDuplicates(["apple", "banana", "apple", "orange"]);
-* // ➔ ["apple"]
-* findDuplicates([{ a: 1 }, { a: 1 }, { a: 2 }]);
-* // ➔ [{ a: 1 }]
-* findDuplicates([NaN, NaN, 1]);
-* // ➔ [NaN]
-* findDuplicates([true, false, true]);
-* // ➔ [true]
-* findDuplicates([1, 2, 3]);
-* // ➔ []
-*/
+ * * ***Utility: `findDuplicates`.***
+ * ----------------------------------------------------------------------
+ * **Finds duplicate values in an array by deep equality comparison.**
+ * - **Behavior:**
+ *    - Uses ***{@link isEqual | `isEqual`}*** to compare elements
+ *      (handles objects, arrays, dates, NaN, etc.).
+ *    - Returns a new array containing only the *first occurrences* of duplicated values.
+ *    - Does **not mutate** the original array.
+ *    - Throws ***{@link TypeError | `TypeError`}*** if input is not an array.
+ * @template T Type of elements in the input array.
+ * @param {T[]} values - The array to check for duplicates.
+ * @returns {T[]} An array of the duplicate values found in the input,
+ *                preserving order of their first duplicate appearance.
+ * @throws {TypeError} If the provided `values` argument is not an array.
+ * @example
+ * findDuplicates([1, 2, 2, 3, 4, 4]);
+ * // ➔ [2, 4]
+ * findDuplicates(["apple", "banana", "apple", "orange"]);
+ * // ➔ ["apple"]
+ * findDuplicates([{ a: 1 }, { a: 1 }, { a: 2 }]);
+ * // ➔ [{ a: 1 }]
+ * findDuplicates([NaN, NaN, 1]);
+ * // ➔ [NaN]
+ * findDuplicates([true, false, true]);
+ * // ➔ [true]
+ * findDuplicates([1, 2, 3]);
+ * // ➔ []
+ */
 declare const findDuplicates:<T>(values:T[])=>T[];
 /** --------------------------------
-* * ***Utility: `omitKeys`.***
-* --------------------------------
-* **This function creates a shallow copy of the given object omitting the
-*  specified keys.**
-* - **Behavior:**
-*    - It will return a new object without mutating the original.
-*    - It also validates that ***`keysToOmit`*** does not contain duplicate keys.
-* - **ℹ️ Internally:**
-*    - It uses ***{@link isEqual | `isEqual`}*** to check for duplicates in
-*      the ***`keysToOmit`*** array.
-* @template I The type of the input object.
-* @template K The keys to omit from the object.
-* @param {I} object - The source object to omit keys from.
-* @param {K[]} keysToOmit - An array of keys to exclude from the returned object.
-* @returns {Omit<I, K>} A new object without the specified keys.
-* @throws {TypeError} If `keysToOmit` is not an array.
-* @throws {Error} If duplicate keys are found in `keysToOmit`.
-* @example
-* omitKeys({ a: 1, b: 2, c: 3 }, ["b", "c"]);
-* //➔ { a: 1 }
-* omitKeys({ name: "John", age: 30 }, ["age"]);
-* //➔ { name: "John" }
-* omitKeys({ a: 1, b: 2 }, []);
-* //➔ { a: 1, b: 2 } (no changes)
-*/
+ * * ***Utility: `omitKeys`.***
+ * --------------------------------
+ * **This function creates a shallow copy of the given object omitting the
+ *  specified keys.**
+ * - **Behavior:**
+ *    - It will return a new object without mutating the original.
+ *    - It also validates that ***`keysToOmit`*** does not contain duplicate keys.
+ * - **ℹ️ Internally:**
+ *    - It uses ***{@link isEqual | `isEqual`}*** to check for duplicates in
+ *      the ***`keysToOmit`*** array.
+ * @template I The type of the input object.
+ * @template K The keys to omit from the object.
+ * @param {I} object - The source object to omit keys from.
+ * @param {K[]} keysToOmit - An array of keys to exclude from the returned object.
+ * @returns {Omit<I, K>} A new object without the specified keys.
+ * @throws {TypeError} If `keysToOmit` is not an array.
+ * @throws {Error} If duplicate keys are found in `keysToOmit`.
+ * @example
+ * omitKeys({ a: 1, b: 2, c: 3 }, ["b", "c"]);
+ * //➔ { a: 1 }
+ * omitKeys({ name: "John", age: 30 }, ["age"]);
+ * //➔ { name: "John" }
+ * omitKeys({ a: 1, b: 2 }, []);
+ * //➔ { a: 1, b: 2 } (no changes)
+ */
 declare const omitKeys:<I extends Record<string,unknown>,K extends keyof I>(object:I,keysToOmit:K[])=>Omit<I,K>;type IndexArray=NumberRangeUnion<0,30>;type DotPath<T,Prev extends string="">=T extends Array<infer U>?DotPath<U,`${Prev}${Prev extends "" ? "" : "."}${IndexArray}`>:T extends object?{[K in keyof T & string]:`${Prev}${Prev extends "" ? "" : "."}${K}`|DotPath<T[K],`${Prev}${Prev extends "" ? "" : "."}${K}`>;}[keyof T & string]:never;
 /** ------------------------------------------------------
-* * ***Utility: `omitKeysDeep`.***
-* ------------------------------------------------------
-* **Recursively omits properties from an object using dot notation paths.**
-* - **Behavior:**
-*    - Also removes resulting empty objects (`{}`) and arrays (`[]`),
-*    - cascading upwards to remove empty parents until root if needed.
-* - **⚠️ Be careful:**
-*    - If after omission an object or array becomes empty, it will be removed entirely
-*      including all the way up to the root if necessary, resulting in `{}`.
-* - **ℹ️ Note:**
-*    - For array indices, TypeScript autocomplete only suggests `0`–`30`
-*      (to prevent editor lag on large unions).
-*      However, higher indices are still fully supported at runtime — you can
-*      manually type `"arr.99.key"` and it will work the same.
-* @template I - Type of the input object
-* @param {I} object
-*  The object to process. Should be a plain nested object or array structure.
-* @param {DotPath<I>[]} keysToOmit
-*  An array of string paths in dot notation indicating the properties to remove, paths
-*  can include numeric indices to target array elements, e.g. `"arr.0.x"` to
-*  remove `x` from the first object inside the `arr` array.
-* @returns {Partial<I>}
-*  A new deeply cloned object with the specified keys omitted, with resulting
-*  empty objects or arrays fully removed (even if it collapses to `{}`).
-* @throws {TypeError}
-*    If `keysToOmit` is not an array will throw TypeError.
-* @throws {Error} If `keysToOmit` contains duplicate paths will throw Error.
-* @example
-* omitKeysDeep({ arr: [{ a: 1 }] }, ["arr.0.a"]);
-* // ➔ {} (array becomes empty and removed)
-* omitKeysDeep({ a: { b: { c: 1 }, d: 2 }, e: 3 }, ["a.b.c"]);
-* // ➔ { a: { d: 2 }, e: 3 }
-* omitKeysDeep({ a: [{ b: 1 }, { c: 2 }] }, ["a.0.b"]);
-* // ➔ { a: [{ c: 2 }] }
-* omitKeysDeep({ a: [{ b: 1 }] }, ["a.0.b"]);
-* // ➔ {} (array becomes empty and removed)
-* omitKeysDeep({ complex: [{ deep: [{ x: 1, y: 2 }] }] }, ["complex.0.deep.0.x"]);
-* // ➔ { complex: [{ deep: [{ y: 2 }] }] }
-* omitKeysDeep({ complex: [{ deep: [{ x: 1 }] }] }, ["complex.0.deep.0.x"]);
-* // ➔ {} (deep chain emptied and collapsed)
-* omitKeysDeep({ data: [[{ foo: 1, bar: 2 }]] }, ["data.0.0.foo"]);
-* // ➔ { data: [[{ bar: 2 }]] }
-* omitKeysDeep({ data: [[{ foo: 1 }]] }, ["data.0.0.foo"]);
-* // ➔ {} (nested arrays emptied completely)
-* omitKeysDeep({ x: [{ y: [{ z: 1 }, { w: 2 }] }] }, ["x.0.y.0.z"]);
-* // ➔ { x: [{ y: [{ w: 2 }] }] }
-* omitKeysDeep({ x: [{ y: [{ z: 1 }] }] }, ["x.0.y.0.z"]);
-* // ➔ {} (entire nested arrays removed)
-* omitKeysDeep({ p: { q: { r: 5 } }, s: 6 }, ["p.q.r"]);
-* // ➔ { s: 6 } (`p` removed because it becomes empty)
-* omitKeysDeep({ arr: [{ a: 1, b: 2 }, { c: 3 }] }, ["arr.0.a"]);
-* // ➔ { arr: [{ b: 2 }, { c: 3 }] }
-* omitKeysDeep({ root: [{ sub: [{ leaf: 10 }] }] }, ["root.0.sub.0.leaf"]);
-* // ➔ {} (deep nested arrays emptied to root)
-* omitKeysDeep({ meta: { tags: ["x", "y"], count: 2 } }, ["meta.count"]);
-* // ➔ { meta: { tags: ["x", "y"] } }
-* omitKeysDeep({ arr: [[{ a: 1 }, { b: 2 }]] }, ["arr.0.0.a"]);
-* // ➔ { arr: [[{ b: 2 }]] }
-* omitKeysDeep({ arr: [[{ a: 1 }]] }, ["arr.0.0.a"]);
-* // ➔ {} (double nested emptied)
-* omitKeysDeep({ nested: [{ list: [{ id: 1, val: 2 }] }] }, ["nested.0.list.0.val"]);
-* // ➔ { nested: [{ list: [{ id: 1 }] }] }
-* omitKeysDeep({ nested: [{ list: [{ id: 1 }] }] }, ["nested.0.list.0.id"]);
-* // ➔ {} (full collapse to empty)
-* omitKeysDeep({ mixed: { a: [1, 2, 3], b: { c: 4 } } }, ["mixed.b.c"]);
-* // ➔ { mixed: { a: [1, 2, 3] } }
-*/
+ * * ***Utility: `omitKeysDeep`.***
+ * ------------------------------------------------------
+ * **Recursively omits properties from an object using dot notation paths.**
+ * - **Behavior:**
+ *    - Also removes resulting empty objects (`{}`) and arrays (`[]`),
+ *    - cascading upwards to remove empty parents until root if needed.
+ * - **⚠️ Be careful:**
+ *    - If after omission an object or array becomes empty, it will be removed entirely
+ *      including all the way up to the root if necessary, resulting in `{}`.
+ * - **ℹ️ Note:**
+ *    - For array indices, TypeScript autocomplete only suggests `0`–`30`
+ *      (to prevent editor lag on large unions).
+ *      However, higher indices are still fully supported at runtime — you can
+ *      manually type `"arr.99.key"` and it will work the same.
+ * @template I - Type of the input object
+ * @param {I} object
+ *  The object to process. Should be a plain nested object or array structure.
+ * @param {DotPath<I>[]} keysToOmit
+ *  An array of string paths in dot notation indicating the properties to remove, paths
+ *  can include numeric indices to target array elements, e.g. `"arr.0.x"` to
+ *  remove `x` from the first object inside the `arr` array.
+ * @returns {Partial<I>}
+ *  A new deeply cloned object with the specified keys omitted, with resulting
+ *  empty objects or arrays fully removed (even if it collapses to `{}`).
+ * @throws {TypeError}
+ *    If `keysToOmit` is not an array will throw TypeError.
+ * @throws {Error} If `keysToOmit` contains duplicate paths will throw Error.
+ * @example
+ * omitKeysDeep({ arr: [{ a: 1 }] }, ["arr.0.a"]);
+ * // ➔ {} (array becomes empty and removed)
+ * omitKeysDeep({ a: { b: { c: 1 }, d: 2 }, e: 3 }, ["a.b.c"]);
+ * // ➔ { a: { d: 2 }, e: 3 }
+ * omitKeysDeep({ a: [{ b: 1 }, { c: 2 }] }, ["a.0.b"]);
+ * // ➔ { a: [{ c: 2 }] }
+ * omitKeysDeep({ a: [{ b: 1 }] }, ["a.0.b"]);
+ * // ➔ {} (array becomes empty and removed)
+ * omitKeysDeep({ complex: [{ deep: [{ x: 1, y: 2 }] }] }, ["complex.0.deep.0.x"]);
+ * // ➔ { complex: [{ deep: [{ y: 2 }] }] }
+ * omitKeysDeep({ complex: [{ deep: [{ x: 1 }] }] }, ["complex.0.deep.0.x"]);
+ * // ➔ {} (deep chain emptied and collapsed)
+ * omitKeysDeep({ data: [[{ foo: 1, bar: 2 }]] }, ["data.0.0.foo"]);
+ * // ➔ { data: [[{ bar: 2 }]] }
+ * omitKeysDeep({ data: [[{ foo: 1 }]] }, ["data.0.0.foo"]);
+ * // ➔ {} (nested arrays emptied completely)
+ * omitKeysDeep({ x: [{ y: [{ z: 1 }, { w: 2 }] }] }, ["x.0.y.0.z"]);
+ * // ➔ { x: [{ y: [{ w: 2 }] }] }
+ * omitKeysDeep({ x: [{ y: [{ z: 1 }] }] }, ["x.0.y.0.z"]);
+ * // ➔ {} (entire nested arrays removed)
+ * omitKeysDeep({ p: { q: { r: 5 } }, s: 6 }, ["p.q.r"]);
+ * // ➔ { s: 6 } (`p` removed because it becomes empty)
+ * omitKeysDeep({ arr: [{ a: 1, b: 2 }, { c: 3 }] }, ["arr.0.a"]);
+ * // ➔ { arr: [{ b: 2 }, { c: 3 }] }
+ * omitKeysDeep({ root: [{ sub: [{ leaf: 10 }] }] }, ["root.0.sub.0.leaf"]);
+ * // ➔ {} (deep nested arrays emptied to root)
+ * omitKeysDeep({ meta: { tags: ["x", "y"], count: 2 } }, ["meta.count"]);
+ * // ➔ { meta: { tags: ["x", "y"] } }
+ * omitKeysDeep({ arr: [[{ a: 1 }, { b: 2 }]] }, ["arr.0.0.a"]);
+ * // ➔ { arr: [[{ b: 2 }]] }
+ * omitKeysDeep({ arr: [[{ a: 1 }]] }, ["arr.0.0.a"]);
+ * // ➔ {} (double nested emptied)
+ * omitKeysDeep({ nested: [{ list: [{ id: 1, val: 2 }] }] }, ["nested.0.list.0.val"]);
+ * // ➔ { nested: [{ list: [{ id: 1 }] }] }
+ * omitKeysDeep({ nested: [{ list: [{ id: 1 }] }] }, ["nested.0.list.0.id"]);
+ * // ➔ {} (full collapse to empty)
+ * omitKeysDeep({ mixed: { a: [1, 2, 3], b: { c: 4 } } }, ["mixed.b.c"]);
+ * // ➔ { mixed: { a: [1, 2, 3] } }
+ */
 declare const omitKeysDeep:<I extends Record<string,unknown>>(object:I,keysToOmit:DotPath<I>[])=>Partial<I>;export{findDuplicates,omitKeys,omitKeysDeep};

package/dist/operations/index.js

@@ -1 +1 @@
-export{a as findDuplicates,b as omitKeys,c as omitKeysDeep}from'../chunk-UUMKL74S.js';import'../chunk-MWLEM7ED.js';import'../chunk-ME5OV5HN.js';import'../chunk-2JQQQ625.js';import'../chunk-SYJC7UAW.js';import'../chunk-467VEMJH.js';import'../chunk-5SZUSNGZ.js';import'../chunk-MJAW5RAK.js';
+export{a as findDuplicates,b as omitKeys,c as omitKeysDeep}from'../chunk-K3UVKYEU.js';import'../chunk-EEQY5QUG.js';import'../chunk-LQ76EDZG.js';import'../chunk-SL3RQOWA.js';import'../chunk-SYJC7UAW.js';import'../chunk-J4NCYYGS.js';import'../chunk-5SZUSNGZ.js';import'../chunk-EWYPSKKM.js';