@helpers4/object 3.0.0-alpha.1 → 3.0.0

package/meta/api.json

@@ -1,7 +1,48 @@
 {
   "category": "object",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0",
   "functions": [
+    {
+      "name": "clone",
+      "kind": "function",
+      "description": "Creates a shallow copy of a value — one level deep, unlike cloneDeep.\n\nUnlike a plain `{ ...value }` spread, this correctly reconstructs `Date`,\n`Map`, `Set`, and arrays instead of producing an empty (or wrong-shaped)\nplain object for them. Primitives are returned as-is. Any other object\n(including class instances not listed above) has its own enumerable string\nkeys shallow-copied into a plain object — the same fallback `cloneDeep`\nuses, so the two stay consistent for types neither one special-cases.",
+      "since": "3.0.0",
+      "signatures": [
+        {
+          "signature": "clone<T>(value: T): T",
+          "description": "Creates a shallow copy of a value — one level deep, unlike cloneDeep.\n\nUnlike a plain `{ ...value }` spread, this correctly reconstructs `Date`,\n`Map`, `Set`, and arrays instead of producing an empty (or wrong-shaped)\nplain object for them. Primitives are returned as-is. Any other object\n(including class instances not listed above) has its own enumerable string\nkeys shallow-copied into a plain object — the same fallback `cloneDeep`\nuses, so the two stay consistent for types neither one special-cases.",
+          "params": [
+            {
+              "name": "value",
+              "type": "T",
+              "description": "The value to shallow-clone"
+            }
+          ],
+          "returns": {
+            "type": "T",
+            "description": "A shallow copy of `value`"
+          },
+          "typeParameters": [
+            {
+              "name": "T"
+            }
+          ]
+        }
+      ],
+      "examples": [
+        {
+          "title": "Shallow-copy a plain object",
+          "description": "Top-level keys are copied; nested values still share references (shallow).",
+          "code": "const obj = { a: 1, b: { c: 2 } };\nconst copy = clone(obj);\ncopy.b === obj.b // => true (same nested reference)"
+        },
+        {
+          "title": "Correctly clones Date/Map/Set, unlike a spread",
+          "description": "{ ...new Date() } produces {} — clone() doesn't have that problem.",
+          "code": "clone(new Map([['a', 1]]))\n// => new Map with the same entries, not {}"
+        }
+      ],
+      "sourceFile": "clone.ts"
+    },
     {
       "name": "cloneDeep",
       "kind": "function",
@@ -246,6 +287,42 @@
       ],
       "sourceFile": "equalsShallow.ts"
     },
+    {
+      "name": "flatten",
+      "kind": "function",
+      "description": "Flattens a nested object into a single-level object whose keys are the\ndot-notation path to each leaf value. The inverse of unflatten.\n\nOnly **plain objects** are recursed into — arrays, `Date`, `Map`, `RegExp`,\nclass instances, and empty plain objects `{}` are kept as opaque leaf\nvalues. This keeps `flatten`/`unflatten` a clean, invertible pair: arrays\ncan't be losslessly told apart from plain objects once reduced to dotted\nkeys, so this implementation doesn't attempt it.\n\nCaveat shared by every dotted-path flattening scheme: a key that itself\ncontains a literal `.` is indistinguishable from real nesting once\nflattened (`{ 'a.b': 1 }` and `{ a: { b: 1 } }` both produce `{ 'a.b': 1 }`).",
+      "since": "3.0.0",
+      "signatures": [
+        {
+          "signature": "flatten(obj: Record<string, unknown>): Record<string, unknown>",
+          "description": "Flattens a nested object into a single-level object whose keys are the\ndot-notation path to each leaf value. The inverse of unflatten.\n\nOnly **plain objects** are recursed into — arrays, `Date`, `Map`, `RegExp`,\nclass instances, and empty plain objects `{}` are kept as opaque leaf\nvalues. This keeps `flatten`/`unflatten` a clean, invertible pair: arrays\ncan't be losslessly told apart from plain objects once reduced to dotted\nkeys, so this implementation doesn't attempt it.\n\nCaveat shared by every dotted-path flattening scheme: a key that itself\ncontains a literal `.` is indistinguishable from real nesting once\nflattened (`{ 'a.b': 1 }` and `{ a: { b: 1 } }` both produce `{ 'a.b': 1 }`).",
+          "params": [
+            {
+              "name": "obj",
+              "type": "Record<string, unknown>",
+              "description": "The object to flatten"
+            }
+          ],
+          "returns": {
+            "type": "Record<string, unknown>",
+            "description": "A single-level object with dot-notation keys"
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Flatten a nested config object",
+          "description": "Each key in the result is the full dot-notation path to a leaf value.",
+          "code": "flatten({ server: { host: 'localhost', port: 8080 } })\n// => { 'server.host': 'localhost', 'server.port': 8080 }"
+        },
+        {
+          "title": "Arrays and special objects are kept as leaves",
+          "description": "Only plain objects are recursed into — arrays stay intact.",
+          "code": "flatten({ tags: ['a', 'b'], meta: { owner: 'x' } })\n// => { tags: ['a', 'b'], 'meta.owner': 'x' }"
+        }
+      ],
+      "sourceFile": "flatten.ts"
+    },
     {
       "name": "get",
       "kind": "function",
@@ -722,6 +799,89 @@
       ],
       "sourceFile": "omit.ts"
     },
+    {
+      "name": "omitBy",
+      "kind": "function",
+      "description": "Creates a new object without the own enumerable entries for which\n`predicate` returns `true`.\n\nComplements omit for when the keys to remove aren't known ahead of\ntime — `omit` takes an explicit key list, `omitBy` takes a predicate.",
+      "since": "3.0.0",
+      "signatures": [
+        {
+          "signature": "omitBy<T extends Record<string, unknown>>(obj: T | null | undefined, predicate: function): Partial<T> | null | undefined",
+          "description": "Creates a new object without the own enumerable entries for which\n`predicate` returns `true`.\n\nComplements omit for when the keys to remove aren't known ahead of\ntime — `omit` takes an explicit key list, `omitBy` takes a predicate.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "T | null | undefined",
+              "description": "The source object. `null`/`undefined` pass through unchanged."
+            },
+            {
+              "name": "predicate",
+              "type": "function",
+              "description": "Called with `(value, key)` for each own enumerable entry"
+            }
+          ],
+          "returns": {
+            "type": "Partial<T> | null | undefined",
+            "description": "A new object without the matching entries"
+          },
+          "typeParameters": [
+            {
+              "name": "T",
+              "constraint": "Record<string, unknown>"
+            }
+          ]
+        }
+      ],
+      "examples": [
+        {
+          "title": "Drop entries matching a predicate",
+          "description": "Unlike omit(), the keys to drop don’t need to be known ahead of time.",
+          "code": "omitBy({ a: 1, b: undefined, c: 2 }, (value) => value === undefined)\n// => { a: 1, c: 2 }"
+        },
+        {
+          "title": "Drop entries by key name",
+          "description": "The predicate also receives the key, so filtering by name works too.",
+          "code": "omitBy({ id: 1, name: 'x', _internal: true }, (_v, key) => key.startsWith('_'))\n// => { id: 1, name: 'x' }"
+        }
+      ],
+      "sourceFile": "omitBy.ts"
+    },
+    {
+      "name": "parsePropertyPath",
+      "kind": "function",
+      "description": "Parses a dot/bracket-notation property path into an array of string/number\nkey segments — the same notation accepted by get and set.\n\n- Dot separators (`.`) split segments; each segment becomes a string key.\n- Bracket indices (`[n]`) become number keys.\n- A leading `.` is treated as \"current level\" and stripped before parsing,\n  so `.[0]` ≡ `[0]` and `.a.b` ≡ `a.b`.\n- Empty string (or a bare `.`) returns `['']` (addresses the `''` key on the root object).\n- Consecutive dots (`a..b`) produce an empty-string segment: `['a', '', 'b']`.\n\nResults are cached (up to 500 distinct path strings, oldest evicted first)\nsince real-world callers tend to reuse a small, fixed set of literal paths.",
+      "since": "3.0.0",
+      "signatures": [
+        {
+          "signature": "parsePropertyPath(path: string): readonly string | number[]",
+          "description": "Parses a dot/bracket-notation property path into an array of string/number\nkey segments — the same notation accepted by get and set.\n\n- Dot separators (`.`) split segments; each segment becomes a string key.\n- Bracket indices (`[n]`) become number keys.\n- A leading `.` is treated as \"current level\" and stripped before parsing,\n  so `.[0]` ≡ `[0]` and `.a.b` ≡ `a.b`.\n- Empty string (or a bare `.`) returns `['']` (addresses the `''` key on the root object).\n- Consecutive dots (`a..b`) produce an empty-string segment: `['a', '', 'b']`.\n\nResults are cached (up to 500 distinct path strings, oldest evicted first)\nsince real-world callers tend to reuse a small, fixed set of literal paths.",
+          "params": [
+            {
+              "name": "path",
+              "type": "string",
+              "description": "The dot/bracket-notation path string to parse"
+            }
+          ],
+          "returns": {
+            "type": "readonly string | number[]",
+            "description": "The parsed key segments"
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Parse a dot/bracket-notation path into key segments",
+          "description": "The same notation accepted by get() and set() — bracket indices become numbers.",
+          "code": "parsePropertyPath('layers[1].name')\n// => ['layers', 1, 'name']"
+        },
+        {
+          "title": "Malformed paths throw instead of silently misparsing",
+          "description": "Text trailing a closing bracket within a segment is ambiguous — use 'a[0].b' instead.",
+          "code": "parsePropertyPath('a[0]b')\n// => throws RangeError"
+        }
+      ],
+      "sourceFile": "parsePropertyPath.ts"
+    },
     {
       "name": "pick",
       "kind": "function",
@@ -813,6 +973,53 @@
       ],
       "sourceFile": "pick.ts"
     },
+    {
+      "name": "pickBy",
+      "kind": "function",
+      "description": "Creates a new object with only the own enumerable entries for which\n`predicate` returns `true`.\n\nComplements pick for when the keys to keep aren't known ahead of\ntime — `pick` takes an explicit key list, `pickBy` takes a predicate.",
+      "since": "3.0.0",
+      "signatures": [
+        {
+          "signature": "pickBy<T extends Record<string, unknown>>(obj: T | null | undefined, predicate: function): Partial<T> | null | undefined",
+          "description": "Creates a new object with only the own enumerable entries for which\n`predicate` returns `true`.\n\nComplements pick for when the keys to keep aren't known ahead of\ntime — `pick` takes an explicit key list, `pickBy` takes a predicate.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "T | null | undefined",
+              "description": "The source object. `null`/`undefined` pass through unchanged."
+            },
+            {
+              "name": "predicate",
+              "type": "function",
+              "description": "Called with `(value, key)` for each own enumerable entry"
+            }
+          ],
+          "returns": {
+            "type": "Partial<T> | null | undefined",
+            "description": "A new object with only the matching entries"
+          },
+          "typeParameters": [
+            {
+              "name": "T",
+              "constraint": "Record<string, unknown>"
+            }
+          ]
+        }
+      ],
+      "examples": [
+        {
+          "title": "Keep only entries matching a predicate",
+          "description": "Unlike pick(), the keys to keep don’t need to be known ahead of time.",
+          "code": "pickBy({ a: 1, b: 0, c: 2 }, (value) => value > 0)\n// => { a: 1, c: 2 }"
+        },
+        {
+          "title": "Keep entries by key name",
+          "description": "The predicate also receives the key, so filtering by name works too.",
+          "code": "pickBy({ _id: 1, name: 'x', _internal: true }, (_v, key) => !key.startsWith('_'))\n// => { name: 'x' }"
+        }
+      ],
+      "sourceFile": "pickBy.ts"
+    },
     {
       "name": "removeUndefinedNull",
       "kind": "function",
@@ -1015,6 +1222,149 @@
         }
       ],
       "sourceFile": "set.ts"
+    },
+    {
+      "name": "unflatten",
+      "kind": "function",
+      "description": "Rebuilds a nested object from a single-level object whose keys are\ndot-notation paths. The inverse of flatten.\n\nUses set internally, so intermediate nodes are always created as\nplain objects (never arrays — see flatten's doc for why), and any\nkey segment equal to `__proto__`, `constructor`, or `prototype` is silently\nrejected (same prototype-pollution guard as `set`).",
+      "since": "3.0.0",
+      "signatures": [
+        {
+          "signature": "unflatten(obj: Record<string, unknown>): Record<string, unknown>",
+          "description": "Rebuilds a nested object from a single-level object whose keys are\ndot-notation paths. The inverse of flatten.\n\nUses set internally, so intermediate nodes are always created as\nplain objects (never arrays — see flatten's doc for why), and any\nkey segment equal to `__proto__`, `constructor`, or `prototype` is silently\nrejected (same prototype-pollution guard as `set`).",
+          "params": [
+            {
+              "name": "obj",
+              "type": "Record<string, unknown>",
+              "description": "A single-level object with dot-notation keys"
+            }
+          ],
+          "returns": {
+            "type": "Record<string, unknown>",
+            "description": "The rebuilt nested object"
+          }
+        }
+      ],
+      "examples": [
+        {
+          "title": "Rebuild a nested object from dotted keys",
+          "description": "The inverse of flatten() — useful for parsing flat config sources (env vars, .ini files).",
+          "code": "unflatten({ 'server.host': 'localhost', 'server.port': 8080 })\n// => { server: { host: 'localhost', port: 8080 } }"
+        },
+        {
+          "title": "Multiple keys under the same parent are merged",
+          "description": "Every dotted key contributes to the same nested structure.",
+          "code": "unflatten({ 'a.x': 1, 'a.y': 2 })\n// => { a: { x: 1, y: 2 } }"
+        }
+      ],
+      "sourceFile": "unflatten.ts"
+    },
+    {
+      "name": "unset",
+      "kind": "function",
+      "description": "Removes the value at a dot/bracket-notation path or explicit key array,\nmutating the object in place. Uses the same path syntax as get/set.\n\nA missing intermediate segment is a no-op (nothing to remove), not an error.\nAs with `set`, any path containing a string segment equal to `__proto__`,\n`constructor`, or `prototype` is rejected and the object is returned unchanged.\n\nThe removed key stops appearing in `Object.keys`/`for...in` — unlike setting\nit to `undefined`, which would keep the key present.",
+      "since": "3.0.0",
+      "signatures": [
+        {
+          "signature": "unset<T extends object>(obj: T, path: string | readonly PropertyKey[]): T",
+          "description": "Removes the value at a dot/bracket-notation path or explicit key array,\nmutating the object in place. Uses the same path syntax as get/set.\n\nA missing intermediate segment is a no-op (nothing to remove), not an error.\nAs with `set`, any path containing a string segment equal to `__proto__`,\n`constructor`, or `prototype` is rejected and the object is returned unchanged.\n\nThe removed key stops appearing in `Object.keys`/`for...in` — unlike setting\nit to `undefined`, which would keep the key present.",
+          "params": [
+            {
+              "name": "obj",
+              "type": "T",
+              "description": "The object to mutate"
+            },
+            {
+              "name": "path",
+              "type": "string | readonly PropertyKey[]",
+              "description": "Dot/bracket-notation string, or explicit `PropertyKey[]`"
+            }
+          ],
+          "returns": {
+            "type": "T",
+            "description": "The same object reference, with the key removed if it existed"
+          },
+          "typeParameters": [
+            {
+              "name": "T",
+              "constraint": "object"
+            }
+          ]
+        }
+      ],
+      "examples": [
+        {
+          "title": "Remove a nested value by path",
+          "description": "Uses the same dot/bracket path syntax as get() and set().",
+          "code": "const config = { server: { host: 'localhost', debug: true } };\nunset(config, 'server.debug')\n// => { server: { host: 'localhost' } }"
+        },
+        {
+          "title": "Missing paths are a safe no-op",
+          "description": "Unlike set(), unset() never creates intermediate objects — there is nothing to remove.",
+          "code": "unset({ a: 1 }, 'x.y.z')\n// => { a: 1 }  (unchanged)"
+        }
+      ],
+      "sourceFile": "unset.ts"
+    },
+    {
+      "name": "update",
+      "kind": "function",
+      "description": "Updates the value at a path by applying a function to its current value,\ncreating intermediate objects as needed. Equivalent to\n`set(obj, path, updater(get(obj, path)))` in a single call.\n\nUses the same path syntax and type-inference rules as get and\nset — see those for the full behavior (string vs. `PropertyKey[]`\npaths, prototype-pollution guarding, etc.).",
+      "since": "3.0.0",
+      "signatures": [
+        {
+          "signature": "update<T extends object, P extends string | readonly PropertyKey[], V extends unknown>(obj: T, path: P, updater: function): conditional",
+          "description": "Updates the value at a path by applying a function to its current value,\ncreating intermediate objects as needed. Equivalent to\n`set(obj, path, updater(get(obj, path)))` in a single call.\n\nUses the same path syntax and type-inference rules as get and\nset — see those for the full behavior (string vs. `PropertyKey[]`\npaths, prototype-pollution guarding, etc.).",
+          "params": [
+            {
+              "name": "obj",
+              "type": "T",
+              "description": "The object to mutate"
+            },
+            {
+              "name": "path",
+              "type": "P",
+              "description": "Dot/bracket-notation string literal or explicit `PropertyKey[]`"
+            },
+            {
+              "name": "updater",
+              "type": "function",
+              "description": "Called with the current value (`undefined` if the path is\n  absent); its return value is written back at the path"
+            }
+          ],
+          "returns": {
+            "type": "conditional",
+            "description": "The mutated object (same reference, narrowed type)"
+          },
+          "typeParameters": [
+            {
+              "name": "T",
+              "constraint": "object"
+            },
+            {
+              "name": "P",
+              "constraint": "string | readonly PropertyKey[]"
+            },
+            {
+              "name": "V",
+              "constraint": "unknown"
+            }
+          ]
+        }
+      ],
+      "examples": [
+        {
+          "title": "Increment a counter in one call",
+          "description": "Equivalent to set(obj, path, updater(get(obj, path))), without repeating the path.",
+          "code": "const state = { count: 1 };\nupdate(state, 'count', (n) => (n ?? 0) + 1)\n// => { count: 2 }"
+        },
+        {
+          "title": "Missing paths create intermediate objects, like set()",
+          "description": "The updater receives undefined when the path does not exist yet.",
+          "code": "const stats: Record<string, unknown> = {};\nupdate(stats, 'hits.total', (n: number | undefined) => (n ?? 0) + 1)\n// => { hits: { total: 1 } }"
+        }
+      ],
+      "sourceFile": "update.ts"
     }
   ]
 }

package/meta/examples.json

@@ -1,6 +1,21 @@
 {
   "category": "object",
   "functions": [
+    {
+      "name": "clone",
+      "examples": [
+        {
+          "title": "Shallow-copy a plain object",
+          "description": "Top-level keys are copied; nested values still share references (shallow).",
+          "code": "const obj = { a: 1, b: { c: 2 } };\nconst copy = clone(obj);\ncopy.b === obj.b // => true (same nested reference)"
+        },
+        {
+          "title": "Correctly clones Date/Map/Set, unlike a spread",
+          "description": "{ ...new Date() } produces {} — clone() doesn't have that problem.",
+          "code": "clone(new Map([['a', 1]]))\n// => new Map with the same entries, not {}"
+        }
+      ]
+    },
     {
       "name": "cloneDeep",
       "examples": [
@@ -66,6 +81,21 @@
         }
       ]
     },
+    {
+      "name": "flatten",
+      "examples": [
+        {
+          "title": "Flatten a nested config object",
+          "description": "Each key in the result is the full dot-notation path to a leaf value.",
+          "code": "flatten({ server: { host: 'localhost', port: 8080 } })\n// => { 'server.host': 'localhost', 'server.port': 8080 }"
+        },
+        {
+          "title": "Arrays and special objects are kept as leaves",
+          "description": "Only plain objects are recursed into — arrays stay intact.",
+          "code": "flatten({ tags: ['a', 'b'], meta: { owner: 'x' } })\n// => { tags: ['a', 'b'], 'meta.owner': 'x' }"
+        }
+      ]
+    },
     {
       "name": "get",
       "examples": [
@@ -191,6 +221,36 @@
         }
       ]
     },
+    {
+      "name": "omitBy",
+      "examples": [
+        {
+          "title": "Drop entries matching a predicate",
+          "description": "Unlike omit(), the keys to drop don’t need to be known ahead of time.",
+          "code": "omitBy({ a: 1, b: undefined, c: 2 }, (value) => value === undefined)\n// => { a: 1, c: 2 }"
+        },
+        {
+          "title": "Drop entries by key name",
+          "description": "The predicate also receives the key, so filtering by name works too.",
+          "code": "omitBy({ id: 1, name: 'x', _internal: true }, (_v, key) => key.startsWith('_'))\n// => { id: 1, name: 'x' }"
+        }
+      ]
+    },
+    {
+      "name": "parsePropertyPath",
+      "examples": [
+        {
+          "title": "Parse a dot/bracket-notation path into key segments",
+          "description": "The same notation accepted by get() and set() — bracket indices become numbers.",
+          "code": "parsePropertyPath('layers[1].name')\n// => ['layers', 1, 'name']"
+        },
+        {
+          "title": "Malformed paths throw instead of silently misparsing",
+          "description": "Text trailing a closing bracket within a segment is ambiguous — use 'a[0].b' instead.",
+          "code": "parsePropertyPath('a[0]b')\n// => throws RangeError"
+        }
+      ]
+    },
     {
       "name": "pick",
       "examples": [
@@ -206,6 +266,21 @@
         }
       ]
     },
+    {
+      "name": "pickBy",
+      "examples": [
+        {
+          "title": "Keep only entries matching a predicate",
+          "description": "Unlike pick(), the keys to keep don’t need to be known ahead of time.",
+          "code": "pickBy({ a: 1, b: 0, c: 2 }, (value) => value > 0)\n// => { a: 1, c: 2 }"
+        },
+        {
+          "title": "Keep entries by key name",
+          "description": "The predicate also receives the key, so filtering by name works too.",
+          "code": "pickBy({ _id: 1, name: 'x', _internal: true }, (_v, key) => !key.startsWith('_'))\n// => { name: 'x' }"
+        }
+      ]
+    },
     {
       "name": "removeUndefinedNull",
       "examples": [
@@ -255,6 +330,51 @@
           "code": "const id = Symbol('id')\nset({}, ['user', id], 'alice')\n// => { user: { [id]: 'alice' } }"
         }
       ]
+    },
+    {
+      "name": "unflatten",
+      "examples": [
+        {
+          "title": "Rebuild a nested object from dotted keys",
+          "description": "The inverse of flatten() — useful for parsing flat config sources (env vars, .ini files).",
+          "code": "unflatten({ 'server.host': 'localhost', 'server.port': 8080 })\n// => { server: { host: 'localhost', port: 8080 } }"
+        },
+        {
+          "title": "Multiple keys under the same parent are merged",
+          "description": "Every dotted key contributes to the same nested structure.",
+          "code": "unflatten({ 'a.x': 1, 'a.y': 2 })\n// => { a: { x: 1, y: 2 } }"
+        }
+      ]
+    },
+    {
+      "name": "unset",
+      "examples": [
+        {
+          "title": "Remove a nested value by path",
+          "description": "Uses the same dot/bracket path syntax as get() and set().",
+          "code": "const config = { server: { host: 'localhost', debug: true } };\nunset(config, 'server.debug')\n// => { server: { host: 'localhost' } }"
+        },
+        {
+          "title": "Missing paths are a safe no-op",
+          "description": "Unlike set(), unset() never creates intermediate objects — there is nothing to remove.",
+          "code": "unset({ a: 1 }, 'x.y.z')\n// => { a: 1 }  (unchanged)"
+        }
+      ]
+    },
+    {
+      "name": "update",
+      "examples": [
+        {
+          "title": "Increment a counter in one call",
+          "description": "Equivalent to set(obj, path, updater(get(obj, path))), without repeating the path.",
+          "code": "const state = { count: 1 };\nupdate(state, 'count', (n) => (n ?? 0) + 1)\n// => { count: 2 }"
+        },
+        {
+          "title": "Missing paths create intermediate objects, like set()",
+          "description": "The updater receives undefined when the path does not exist yet.",
+          "code": "const stats: Record<string, unknown> = {};\nupdate(stats, 'hits.total', (n: number | undefined) => (n ?? 0) + 1)\n// => { hits: { total: 1 } }"
+        }
+      ]
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helpers4/object",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0",
   "description": "A set of helpers in TS/JS, compatible with tree-shaking, for object.",
   "author": "baxyz <baxy@etik.com>",
   "license": "LGPL-3.0",
@@ -27,11 +27,13 @@
   "keywords": [
     "helpers",
     "object",
+    "clone",
     "cloneDeep",
     "compact",
     "diff",
     "equalsDeep",
     "equalsShallow",
+    "flatten",
     "get",
     "groupBy",
     "invert",
@@ -40,10 +42,16 @@
     "map",
     "mergeDeep",
     "omit",
+    "omitBy",
+    "parsePropertyPath",
     "pick",
+    "pickBy",
     "removeUndefinedNull",
     "safeJsonParse",
-    "set"
+    "set",
+    "unflatten",
+    "unset",
+    "update"
   ],
   "files": [
     "lib/index.js",
@@ -56,6 +64,6 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=26.0.0"
   }
 }