@helpers4/object 2.0.0-alpha.9 → 2.0.0-beta.3

package/meta/api.json

@@ -1,7 +1,79 @@
 {
   "category": "object",
-  "version": "2.0.0-alpha.9",
+  "version": "2.0.0-beta.3",
   "functions": [
+    {
+      "name": "compact",
+      "kind": "function",
+      "description": "Removes all entries with falsy values (`false`, `null`, `undefined`, `0`, `\"\"`, `NaN`) from an object.",
+      "since": "2.0.0",
+      "signatures": [
+        {
+          "signature": "compact<T extends Record<string, unknown>>(obj: T): Partial<T>",
+          "description": "Removes all entries with falsy values (`false`, `null`, `undefined`, `0`, `\"\"`, `NaN`) from an object.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "T",
+              "description": "The source object"
+            }
+          ],
+          "returns": {
+            "type": "Partial<T>",
+            "description": "A new object containing only entries with truthy values"
+          },
+          "typeParameters": [
+            {
+              "name": "T",
+              "constraint": "Record<string, unknown>"
+            }
+          ]
+        },
+        {
+          "signature": "compact(obj: undefined): undefined",
+          "description": "Removes all entries with falsy values (`false`, `null`, `undefined`, `0`, `\"\"`, `NaN`) from an object.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "undefined",
+              "description": "The source object"
+            }
+          ],
+          "returns": {
+            "type": "undefined",
+            "description": "A new object containing only entries with truthy values"
+          }
+        },
+        {
+          "signature": "compact(obj: null): null",
+          "description": "Removes all entries with falsy values (`false`, `null`, `undefined`, `0`, `\"\"`, `NaN`) from an object.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "null",
+              "description": "The source object"
+            }
+          ],
+          "returns": {
+            "type": "null",
+            "description": "A new object containing only entries with truthy values"
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Remove falsy values from object",
+          "description": "Removes all entries with falsy values (false, null, undefined, 0, \"\", NaN).",
+          "code": "compact({ a: 1, b: null, c: '', d: 0, e: 'hello' })\n// => { a: 1, e: 'hello' }"
+        },
+        {
+          "title": "Clean up API response",
+          "description": "Useful to strip empty or missing fields before sending data.",
+          "code": "compact({ name: 'Alice', email: '', age: 0, role: 'admin' })\n// => { name: 'Alice', role: 'admin' }"
+        }
+      ],
+      "sourceFile": "compact.ts"
+    },
     {
       "name": "deepClone",
       "kind": "function",
@@ -39,29 +111,117 @@
       "sourceFile": "deepClone.ts"
     },
     {
-      "name": "deepCompare",
+      "name": "deepMerge",
       "kind": "function",
-      "description": "Deep comparison of two objects that returns detailed information about differences.",
+      "description": "Merges two or more objects deeply",
+      "since": "1.9.0",
+      "signatures": [
+        {
+          "signature": "deepMerge<T extends Record<string, unknown>>(target: T, sources: Record<string, unknown>[]): T",
+          "description": "Merges two or more objects deeply",
+          "params": [
+            {
+              "name": "target",
+              "type": "T",
+              "description": "The target object"
+            },
+            {
+              "name": "sources",
+              "type": "Record<string, unknown>[]",
+              "description": "The source objects to merge"
+            }
+          ],
+          "returns": {
+            "type": "T",
+            "description": "The merged object"
+          },
+          "typeParameters": [
+            {
+              "name": "T",
+              "constraint": "Record<string, unknown>"
+            }
+          ]
+        },
+        {
+          "signature": "deepMerge(target: undefined, sources: Record<string, unknown>[]): undefined",
+          "description": "Merges two or more objects deeply",
+          "params": [
+            {
+              "name": "target",
+              "type": "undefined",
+              "description": "The target object"
+            },
+            {
+              "name": "sources",
+              "type": "Record<string, unknown>[]",
+              "description": "The source objects to merge"
+            }
+          ],
+          "returns": {
+            "type": "undefined",
+            "description": "The merged object"
+          }
+        },
+        {
+          "signature": "deepMerge(target: null, sources: Record<string, unknown>[]): null",
+          "description": "Merges two or more objects deeply",
+          "params": [
+            {
+              "name": "target",
+              "type": "null",
+              "description": "The target object"
+            },
+            {
+              "name": "sources",
+              "type": "Record<string, unknown>[]",
+              "description": "The source objects to merge"
+            }
+          ],
+          "returns": {
+            "type": "null",
+            "description": "The merged object"
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Merge two objects deeply",
+          "description": "Recursively merges source properties into the target object.",
+          "code": "deepMerge({ a: 1, b: { c: 2 } }, { b: { d: 3 }, e: 4 })\n// => { a: 1, b: { c: 2, d: 3 }, e: 4 }"
+        }
+      ],
+      "sourceFile": "deepMerge.ts"
+    },
+    {
+      "name": "diff",
+      "kind": "function",
+      "description": "Structural object diff.\n\nReturns `true` when both inputs are deeply equal, otherwise a\nDiffResult describing the differences key by key.\n\nComparison rules:\n- Same reference \\u2192 `true`.\n- Either side is `null`/`undefined` (and not both) \\u2192 `false`.\n- Both `Date` \\u2192 epoch comparison.\n- Both arrays \\u2192 compared with `array/equalsDeep` (leaf, no diff drill-down).\n- Special objects (Map, Set, RegExp, Promise, class instances\\u2026) \\u2192 reference equality.\n- Plain objects \\u2192 key-by-key, recursing up to `options.depth` levels.\n- Mixed types (e.g. array vs object, Date vs object) \\u2192 `false`.\n\nFor a boolean wrapper see equalsDeep from this category.\nFor a one-level boolean check see equalsShallow from this category.",
       "since": "2.0.0",
       "signatures": [
         {
-          "signature": "deepCompare(objA: object | null | undefined, objB: object | null | undefined): boolean | DeepCompareResult",
-          "description": "Deep comparison of two objects that returns detailed information about differences.",
+          "signature": "diff(objA: object | null | undefined, objB: object | null | undefined, options: DiffOptions): boolean | DiffResult",
+          "description": "Structural object diff.\n\nReturns `true` when both inputs are deeply equal, otherwise a\nDiffResult describing the differences key by key.\n\nComparison rules:\n- Same reference \\u2192 `true`.\n- Either side is `null`/`undefined` (and not both) \\u2192 `false`.\n- Both `Date` \\u2192 epoch comparison.\n- Both arrays \\u2192 compared with `array/equalsDeep` (leaf, no diff drill-down).\n- Special objects (Map, Set, RegExp, Promise, class instances\\u2026) \\u2192 reference equality.\n- Plain objects \\u2192 key-by-key, recursing up to `options.depth` levels.\n- Mixed types (e.g. array vs object, Date vs object) \\u2192 `false`.\n\nFor a boolean wrapper see equalsDeep from this category.\nFor a one-level boolean check see equalsShallow from this category.",
           "params": [
             {
               "name": "objA",
               "type": "object | null | undefined",
-              "description": "First object to compare (can be object, undefined, or null)"
+              "description": "First value (object, `null`, or `undefined`)."
             },
             {
               "name": "objB",
               "type": "object | null | undefined",
-              "description": "Second object to compare (can be object, undefined, or null)"
+              "description": "Second value (object, `null`, or `undefined`)."
+            },
+            {
+              "name": "options",
+              "type": "DiffOptions",
+              "description": "See DiffOptions.",
+              "defaultValue": "{}"
             }
           ],
           "returns": {
-            "type": "boolean | DeepCompareResult",
-            "description": "`true` if objects are identical, `false` if incompatible types, or a `DeepCompareResult` object detailing differences"
+            "type": "boolean | DiffResult",
+            "description": "`true` when equal, otherwise a DiffResult, or `false` for incompatible types."
           }
         }
       ],
@@ -69,66 +229,104 @@
         {
           "title": "Compare nested objects",
           "description": "Deeply compares two objects, returning true when they are structurally equal.",
-          "code": "deepCompare({ a: { b: 1 } }, { a: { b: 1 } })\n// => true"
+          "code": "diff({ a: { b: 1 } }, { a: { b: 1 } })\n// => true"
         },
         {
           "title": "Detect deep differences",
           "description": "Returns a detailed diff object when nested values differ.",
-          "code": "deepCompare({ a: { b: 1 } }, { a: { b: 2 } })\n// => { a: { b: false } }"
+          "code": "diff({ a: { b: 1 } }, { a: { b: 2 } })\n// => { a: { b: false } }"
         }
       ],
-      "sourceFile": "deepCompare.ts"
+      "sourceFile": "diff.ts",
+      "relatedTypes": [
+        {
+          "name": "DiffOptions",
+          "description": "Options for diff.",
+          "typeDefinition": "interface DiffOptions {\n  depth?: number;\n}"
+        },
+        {
+          "name": "DiffResult",
+          "description": "Per-key diff result. Each entry tells what differs between the two\nobjects:\n- `\"onlyA\"` \\u2014 the key exists only on the first input.\n- `\"onlyB\"` \\u2014 the key exists only on the second input.\n- `false`  \\u2014 both inputs have the key but the values differ.\n- nested `DiffResult` \\u2014 plain-object values that differ deeper.",
+          "typeDefinition": "interface DiffResult {}"
+        }
+      ]
     },
     {
-      "name": "DeepCompareResult",
-      "kind": "interface",
-      "description": "Result type for deep comparison when objects are not identical",
+      "name": "equalsDeep",
+      "kind": "function",
+      "description": "Recursive structural object equality.\n\nBoolean wrapper around diff \\u2014 returns `true` when the two values\nare deeply equal according to the same rules. Use this when you only\nneed a yes/no answer; use diff when you also need to know\n*what* differs.\n\nFor a one-level boolean check use equalsShallow.",
       "since": "2.0.0",
-      "signatures": [],
-      "examples": [],
-      "sourceFile": "deepCompare.ts"
+      "signatures": [
+        {
+          "signature": "equalsDeep(objA: object | null | undefined, objB: object | null | undefined): boolean",
+          "description": "Recursive structural object equality.\n\nBoolean wrapper around diff \\u2014 returns `true` when the two values\nare deeply equal according to the same rules. Use this when you only\nneed a yes/no answer; use diff when you also need to know\n*what* differs.\n\nFor a one-level boolean check use equalsShallow.",
+          "params": [
+            {
+              "name": "objA",
+              "type": "object | null | undefined",
+              "description": "First value (object, `null`, or `undefined`)."
+            },
+            {
+              "name": "objB",
+              "type": "object | null | undefined",
+              "description": "Second value (object, `null`, or `undefined`)."
+            }
+          ],
+          "returns": {
+            "type": "boolean",
+            "description": "`true` if both inputs are deeply equal, `false` otherwise."
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Compare nested objects",
+          "description": "Recursive structural equality. Returns true when the two values are deeply equal.",
+          "code": "equalsDeep({ a: { b: 1 } }, { a: { b: 1 } })\n// => true"
+        },
+        {
+          "title": "Detect deep differences",
+          "description": "Returns false when nested values differ.",
+          "code": "equalsDeep({ a: { b: 1 } }, { a: { b: 2 } })\n// => false"
+        }
+      ],
+      "sourceFile": "equalsDeep.ts"
     },
     {
-      "name": "deepMerge",
+      "name": "equalsShallow",
       "kind": "function",
-      "description": "Merges two or more objects deeply",
-      "since": "1.9.0",
+      "description": "One-level (shallow) object equality.\n\nTwo objects are equal when they share the exact same set of own\nenumerable string keys and each pair of values satisfies strict equality\n(`===`). No recursion: nested objects/arrays are compared by reference.\n\nFalls back to strict equality when either input is `null`, `undefined`\nor not an object \\u2014 so primitives match if and only if they are `===`.\nArrays are not supported; they always return `false` (unless identical\nreferences). Use `array/equalsShallow` instead.\n\nFor recursive structural comparison use equalsDeep. For a diff\nstructure use diff.",
+      "since": "2.0.0",
       "signatures": [
         {
-          "signature": "deepMerge<T extends Record<string, any>>(target: T, sources: Record<string, any>[]): T",
-          "description": "Merges two or more objects deeply",
+          "signature": "equalsShallow(objA: unknown, objB: unknown): boolean",
+          "description": "One-level (shallow) object equality.\n\nTwo objects are equal when they share the exact same set of own\nenumerable string keys and each pair of values satisfies strict equality\n(`===`). No recursion: nested objects/arrays are compared by reference.\n\nFalls back to strict equality when either input is `null`, `undefined`\nor not an object \\u2014 so primitives match if and only if they are `===`.\nArrays are not supported; they always return `false` (unless identical\nreferences). Use `array/equalsShallow` instead.\n\nFor recursive structural comparison use equalsDeep. For a diff\nstructure use diff.",
           "params": [
             {
-              "name": "target",
-              "type": "T",
-              "description": "The target object"
+              "name": "objA",
+              "type": "unknown",
+              "description": "First value to compare"
             },
             {
-              "name": "sources",
-              "type": "Record<string, any>[]",
-              "description": "The source objects to merge"
+              "name": "objB",
+              "type": "unknown",
+              "description": "Second value to compare"
             }
           ],
           "returns": {
-            "type": "T",
-            "description": "The merged object"
-          },
-          "typeParameters": [
-            {
-              "name": "T",
-              "constraint": "Record<string, any>"
-            }
-          ]
+            "type": "boolean",
+            "description": "`true` if values are shallowly equal, `false` otherwise."
+          }
         }
       ],
       "examples": [
         {
-          "title": "Merge two objects deeply",
-          "description": "Recursively merges source properties into the target object.",
-          "code": "deepMerge({ a: 1, b: { c: 2 } }, { b: { d: 3 }, e: 4 })\n// => { a: 1, b: { c: 2, d: 3 }, e: 4 }"
+          "title": "Compare two equal objects",
+          "description": "Uses JSON.stringify for a fast comparison.",
+          "code": "equalsShallow({ a: 1, b: 2 }, { a: 1, b: 2 })\n// => true"
         }
       ],
-      "sourceFile": "deepMerge.ts"
+      "sourceFile": "equalsShallow.ts"
     },
     {
       "name": "get",
@@ -137,12 +335,12 @@
       "since": "1.9.0",
       "signatures": [
         {
-          "signature": "get<T = any>(obj: any, path: string, defaultValue?: T): T | undefined",
+          "signature": "get<T = unknown>(obj: unknown, path: string, defaultValue?: T): T | undefined",
           "description": "Gets a value from an object using a dot-notated path",
           "params": [
             {
               "name": "obj",
-              "type": "any",
+              "type": "unknown",
               "description": "The object to get value from"
             },
             {
@@ -164,7 +362,7 @@
           "typeParameters": [
             {
               "name": "T",
-              "default": "any"
+              "default": "unknown"
             }
           ]
         }
@@ -184,40 +382,350 @@
       "sourceFile": "get.ts"
     },
     {
-      "name": "quickCompare",
+      "name": "groupBy",
       "kind": "function",
-      "description": "Quick comparison of two objects using JSON.stringify.\nThis is a fast but simple comparison that may not work for all edge cases.",
+      "description": "Groups an array of items by a key derived from each item.\n\nA thin, typed wrapper around `Object.groupBy` (ES2024) that works on\nolder targets and provides stricter return-type inference.",
+      "since": "next",
+      "signatures": [
+        {
+          "signature": "groupBy<T, K extends PropertyKey>(items: readonly T[], keyFn: function): Partial<Record<K, T[]>>",
+          "description": "Groups an array of items by a key derived from each item.\n\nA thin, typed wrapper around `Object.groupBy` (ES2024) that works on\nolder targets and provides stricter return-type inference.",
+          "params": [
+            {
+              "name": "items",
+              "type": "readonly T[]",
+              "description": "The array to group"
+            },
+            {
+              "name": "keyFn",
+              "type": "function",
+              "description": "Function that returns the group key for each item"
+            }
+          ],
+          "returns": {
+            "type": "Partial<Record<K, T[]>>",
+            "description": "A record mapping each key to the array of items with that key"
+          },
+          "typeParameters": [
+            {
+              "name": "T"
+            },
+            {
+              "name": "K",
+              "constraint": "PropertyKey"
+            }
+          ]
+        }
+      ],
+      "examples": [
+        {
+          "title": "Group numbers by parity",
+          "description": "Groups elements by the string key returned by the callback.",
+          "code": "groupBy([1, 2, 3, 4], n => n % 2 === 0 ? 'even' : 'odd')\n// => { odd: [1, 3], even: [2, 4] }"
+        },
+        {
+          "title": "Group objects by a property",
+          "description": "Use a property accessor as the grouping key.",
+          "code": "const users = [\n  { name: 'Alice', role: 'admin' },\n  { name: 'Bob',   role: 'user'  },\n  { name: 'Carol', role: 'admin' },\n];\ngroupBy(users, u => u.role)\n// => { admin: [{...Alice}, {...Carol}], user: [{...Bob}] }"
+        }
+      ],
+      "sourceFile": "groupBy.ts"
+    },
+    {
+      "name": "invert",
+      "kind": "function",
+      "description": "Returns a new object with keys and values swapped.\nIf multiple keys share the same value, the last one wins.",
+      "since": "next",
+      "signatures": [
+        {
+          "signature": "invert<K extends string, V extends PropertyKey>(obj: Record<K, V>): Record<V, K>",
+          "description": "Returns a new object with keys and values swapped.\nIf multiple keys share the same value, the last one wins.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "Record<K, V>",
+              "description": "The object whose keys and values are to be swapped"
+            }
+          ],
+          "returns": {
+            "type": "Record<V, K>",
+            "description": "A new object with values as keys and original keys as values"
+          },
+          "typeParameters": [
+            {
+              "name": "K",
+              "constraint": "string"
+            },
+            {
+              "name": "V",
+              "constraint": "PropertyKey"
+            }
+          ]
+        }
+      ],
+      "examples": [
+        {
+          "title": "Swap keys and values",
+          "description": "Returns a new object with keys and values swapped.",
+          "code": "invert({ a: 'x', b: 'y', c: 'z' })\n// => { x: 'a', y: 'b', z: 'c' }"
+        },
+        {
+          "title": "Build a reverse lookup map",
+          "description": "Useful when you have a code-to-label map and need label-to-code.",
+          "code": "const STATUS_LABELS = { 200: 'OK', 404: 'Not Found', 500: 'Internal Server Error' };\nconst LABEL_TO_CODE = invert(STATUS_LABELS);\n\nLABEL_TO_CODE['OK']; // => '200'"
+        }
+      ],
+      "sourceFile": "invert.ts"
+    },
+    {
+      "name": "map",
+      "kind": "function",
+      "description": "Transforms the values and/or keys of a plain object in a single pass.\n\nBoth callbacks are optional and default to identity (no transformation).\nWhen `mapValue` is omitted the original values are preserved;\nwhen `mapKey` is omitted the original keys are preserved.\n\nNote: if two different keys map to the same output key the last one wins\n(insertion order).",
+      "since": "next",
+      "signatures": [
+        {
+          "signature": "map<TObj extends Record<string, unknown>, TVal = indexedAccess, TKey extends PropertyKey = keyof TObj>(obj: TObj, mapValue?: function, mapKey?: function): Record<TKey, TVal>",
+          "description": "Transforms the values and/or keys of a plain object in a single pass.\n\nBoth callbacks are optional and default to identity (no transformation).\nWhen `mapValue` is omitted the original values are preserved;\nwhen `mapKey` is omitted the original keys are preserved.\n\nNote: if two different keys map to the same output key the last one wins\n(insertion order).",
+          "params": [
+            {
+              "name": "obj",
+              "type": "TObj",
+              "description": "The source object"
+            },
+            {
+              "name": "mapValue",
+              "type": "function",
+              "description": "Callback called with `(value, key)` for each entry.\n  Defaults to identity.",
+              "optional": true
+            },
+            {
+              "name": "mapKey",
+              "type": "function",
+              "description": "Callback called with `(key, value)` for each entry.\n  Defaults to identity.",
+              "optional": true
+            }
+          ],
+          "returns": {
+            "type": "Record<TKey, TVal>",
+            "description": "A new object with transformed keys and/or values"
+          },
+          "typeParameters": [
+            {
+              "name": "TObj",
+              "constraint": "Record<string, unknown>"
+            },
+            {
+              "name": "TVal",
+              "default": "indexedAccess"
+            },
+            {
+              "name": "TKey",
+              "constraint": "PropertyKey",
+              "default": "keyof TObj"
+            }
+          ]
+        }
+      ],
+      "examples": [
+        {
+          "title": "Transform values",
+          "description": "Maps each value of an object through a transform function.",
+          "code": "map({ a: 1, b: 2 }, v => v * 10)\n// => { a: 10, b: 20 }"
+        },
+        {
+          "title": "Transform keys",
+          "description": "Maps each key of an object through a transform function.",
+          "code": "map({ a: 1, b: 2 }, undefined, k => k.toUpperCase())\n// => { A: 1, B: 2 }"
+        },
+        {
+          "title": "Transform both keys and values in a single pass",
+          "description": "Provide both a value mapper and a key mapper to rewrite the whole object.",
+          "code": "map(\n  { price: 100, discount: 20 },\n  v => v / 100,\n  k => `${k}Ratio`\n)\n// => { priceRatio: 1, discountRatio: 0.2 }"
+        }
+      ],
+      "sourceFile": "map.ts"
+    },
+    {
+      "name": "omit",
+      "kind": "function",
+      "description": "Creates a new object without the specified keys.",
       "since": "2.0.0",
       "signatures": [
         {
-          "signature": "quickCompare(objA: unknown, objB: unknown): boolean",
-          "description": "Quick comparison of two objects using JSON.stringify.\nThis is a fast but simple comparison that may not work for all edge cases.",
+          "signature": "omit<T extends Record<string, unknown>, K extends string | number | symbol>(obj: T, keys: readonly K[]): Omit<T, K>",
+          "description": "Creates a new object without the specified keys.",
           "params": [
             {
-              "name": "objA",
-              "type": "unknown",
-              "description": "First object to compare"
+              "name": "obj",
+              "type": "T",
+              "description": "The source object"
             },
             {
-              "name": "objB",
-              "type": "unknown",
-              "description": "Second object to compare"
+              "name": "keys",
+              "type": "readonly K[]",
+              "description": "The keys to omit"
             }
           ],
           "returns": {
-            "type": "boolean",
-            "description": "`true` if objects are identical according to JSON.stringify, `false` otherwise"
+            "type": "Omit<T, K>",
+            "description": "A new object without the omitted keys"
+          },
+          "typeParameters": [
+            {
+              "name": "T",
+              "constraint": "Record<string, unknown>"
+            },
+            {
+              "name": "K",
+              "constraint": "string | number | symbol"
+            }
+          ]
+        },
+        {
+          "signature": "omit(obj: undefined, keys: readonly string[]): undefined",
+          "description": "Creates a new object without the specified keys.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "undefined",
+              "description": "The source object"
+            },
+            {
+              "name": "keys",
+              "type": "readonly string[]",
+              "description": "The keys to omit"
+            }
+          ],
+          "returns": {
+            "type": "undefined",
+            "description": "A new object without the omitted keys"
+          }
+        },
+        {
+          "signature": "omit(obj: null, keys: readonly string[]): null",
+          "description": "Creates a new object without the specified keys.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "null",
+              "description": "The source object"
+            },
+            {
+              "name": "keys",
+              "type": "readonly string[]",
+              "description": "The keys to omit"
+            }
+          ],
+          "returns": {
+            "type": "null",
+            "description": "A new object without the omitted keys"
           }
         }
       ],
       "examples": [
         {
-          "title": "Compare two equal objects",
-          "description": "Uses JSON.stringify for a fast comparison.",
-          "code": "quickCompare({ a: 1, b: 2 }, { a: 1, b: 2 })\n// => true"
+          "title": "Omit specific keys",
+          "description": "Creates a new object without the specified keys.",
+          "code": "omit({ a: 1, b: 2, c: 3 }, ['b'])\n// => { a: 1, c: 3 }"
+        },
+        {
+          "title": "Remove sensitive fields",
+          "description": "Useful to strip sensitive data before sending to client.",
+          "code": "const user = { id: 1, name: 'Alice', password: 'secret', token: 'abc123' };\nomit(user, ['password', 'token'])\n// => { id: 1, name: 'Alice' }"
+        }
+      ],
+      "sourceFile": "omit.ts"
+    },
+    {
+      "name": "pick",
+      "kind": "function",
+      "description": "Creates a new object with only the specified keys.",
+      "since": "2.0.0",
+      "signatures": [
+        {
+          "signature": "pick<T extends Record<string, unknown>, K extends string | number | symbol>(obj: T, keys: readonly K[]): Pick<T, K>",
+          "description": "Creates a new object with only the specified keys.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "T",
+              "description": "The source object"
+            },
+            {
+              "name": "keys",
+              "type": "readonly K[]",
+              "description": "The keys to pick"
+            }
+          ],
+          "returns": {
+            "type": "Pick<T, K>",
+            "description": "A new object with only the picked keys"
+          },
+          "typeParameters": [
+            {
+              "name": "T",
+              "constraint": "Record<string, unknown>"
+            },
+            {
+              "name": "K",
+              "constraint": "string | number | symbol"
+            }
+          ]
+        },
+        {
+          "signature": "pick(obj: undefined, keys: readonly string[]): undefined",
+          "description": "Creates a new object with only the specified keys.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "undefined",
+              "description": "The source object"
+            },
+            {
+              "name": "keys",
+              "type": "readonly string[]",
+              "description": "The keys to pick"
+            }
+          ],
+          "returns": {
+            "type": "undefined",
+            "description": "A new object with only the picked keys"
+          }
+        },
+        {
+          "signature": "pick(obj: null, keys: readonly string[]): null",
+          "description": "Creates a new object with only the specified keys.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "null",
+              "description": "The source object"
+            },
+            {
+              "name": "keys",
+              "type": "readonly string[]",
+              "description": "The keys to pick"
+            }
+          ],
+          "returns": {
+            "type": "null",
+            "description": "A new object with only the picked keys"
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Pick specific keys",
+          "description": "Creates a new object with only the specified keys.",
+          "code": "pick({ a: 1, b: 2, c: 3 }, ['a', 'c'])\n// => { a: 1, c: 3 }"
+        },
+        {
+          "title": "Extract user fields",
+          "description": "Useful to select only the fields you need from an object.",
+          "code": "const user = { id: 1, name: 'Alice', email: 'alice@example.com', password: 'secret' };\npick(user, ['id', 'name', 'email'])\n// => { id: 1, name: 'Alice', email: 'alice@example.com' }"
         }
       ],
-      "sourceFile": "quickCompare.ts"
+      "sourceFile": "pick.ts"
     },
     {
       "name": "removeUndefinedNull",
@@ -286,6 +794,77 @@
       ],
       "sourceFile": "removeUndefinedNull.ts"
     },
+    {
+      "name": "safeJsonParse",
+      "kind": "function",
+      "description": "Parses a JSON string, returning `null` (or a fallback) on any parse failure.\n\nUnlike `JSON.parse`, this never throws. Invalid JSON strings and other\nparsing edge-cases resolve to `null` or the provided `fallback`.",
+      "since": "next",
+      "signatures": [
+        {
+          "signature": "safeJsonParse<T>(input: string): T | null",
+          "description": "Parses a JSON string, returning `null` (or a fallback) on any parse failure.\n\nUnlike `JSON.parse`, this never throws. Invalid JSON strings and other\nparsing edge-cases resolve to `null` or the provided `fallback`.",
+          "params": [
+            {
+              "name": "input",
+              "type": "string",
+              "description": "The JSON string to parse."
+            }
+          ],
+          "returns": {
+            "type": "T | null",
+            "description": "The parsed value typed as `T`, or `fallback` on failure."
+          },
+          "typeParameters": [
+            {
+              "name": "T"
+            }
+          ]
+        },
+        {
+          "signature": "safeJsonParse<T>(input: string, fallback: T): T",
+          "description": "Parses a JSON string, returning `null` (or a fallback) on any parse failure.\n\nUnlike `JSON.parse`, this never throws. Invalid JSON strings and other\nparsing edge-cases resolve to `null` or the provided `fallback`.",
+          "params": [
+            {
+              "name": "input",
+              "type": "string",
+              "description": "The JSON string to parse."
+            },
+            {
+              "name": "fallback",
+              "type": "T",
+              "description": "Value returned on failure. Defaults to `null` when omitted."
+            }
+          ],
+          "returns": {
+            "type": "T",
+            "description": "The parsed value typed as `T`, or `fallback` on failure."
+          },
+          "typeParameters": [
+            {
+              "name": "T"
+            }
+          ]
+        }
+      ],
+      "examples": [
+        {
+          "title": "Parse valid JSON",
+          "description": "Returns the parsed value when the input is valid JSON.",
+          "code": "safeJsonParse<{ a: number }>('{\"a\":1}')\n// => { a: 1 }"
+        },
+        {
+          "title": "Return null on invalid input",
+          "description": "Returns null instead of throwing when JSON is malformed.",
+          "code": "safeJsonParse('invalid')\n// => null"
+        },
+        {
+          "title": "Use a fallback value",
+          "description": "Returns the provided fallback when parsing fails.",
+          "code": "safeJsonParse('invalid', [])\n// => []"
+        }
+      ],
+      "sourceFile": "safeJsonParse.ts"
+    },
     {
       "name": "set",
       "kind": "function",
@@ -293,12 +872,12 @@
       "since": "1.9.0",
       "signatures": [
         {
-          "signature": "set(obj: Record<string, any>, path: string, value: any): Record<string, any>",
+          "signature": "set(obj: Record<string, unknown>, path: string, value: unknown): Record<string, unknown>",
           "description": "Sets a value in an object using a dot-notated path",
           "params": [
             {
               "name": "obj",
-              "type": "Record<string, any>",
+              "type": "Record<string, unknown>",
               "description": "The object to set value in"
             },
             {
@@ -308,12 +887,12 @@
             },
             {
               "name": "value",
-              "type": "any",
+              "type": "unknown",
               "description": "The value to set"
             }
           ],
           "returns": {
-            "type": "Record<string, any>",
+            "type": "Record<string, unknown>",
             "description": "The modified object"
           }
         }