@helpers4/object 2.0.0-alpha.8 → 2.0.0-beta.0

package/README.md

@@ -12,19 +12,24 @@ A set of helpers for working with URLs.
 [https://helpers4.dev/typescript/categories/object/](https://helpers4.dev/typescript/categories/object/)
 
 <!-- AUTOMATIC-METHODS -->
+- compact
 - deepClone
 - deepCompare
 - deepMerge
 - get
-- quickCompare
+- omit
+- pick
 - removeUndefinedNull
+- safeJsonParse
 - set
+- shallowEquals
 <!-- /AUTOMATIC-METHODS -->
 
 ## See
 
 <!-- AUTOMATIC-SIBLINGS -->
 - [array](../array)
+- [commit](../commit)
 - [date](../date)
 - [function](../function)
 - [math](../math)
@@ -43,15 +48,16 @@ A set of helpers for working with URLs.
 | Name | Package | Source Code | Description |
 |------|---------|-------------|-------------|
 | array | [@helpers4/array](https://www.npmjs.com/package/@helpers4/array) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/array) | Array manipulation utilities |
-| date | [@helpers4/date](https://www.npmjs.com/package/@helpers4/date) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/date) | date utilities |
+| commit | [@helpers4/commit](https://www.npmjs.com/package/@helpers4/commit) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/commit) | Conventional Commits parsing and analysis |
+| date | [@helpers4/date](https://www.npmjs.com/package/@helpers4/date) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/date) | Date and time utility functions |
 | function | [@helpers4/function](https://www.npmjs.com/package/@helpers4/function) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/function) | Function utilities and type guards |
-| math | [@helpers4/math](https://www.npmjs.com/package/@helpers4/math) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/math) | math utilities |
-| number | [@helpers4/number](https://www.npmjs.com/package/@helpers4/number) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/number) | number utilities |
+| math | [@helpers4/math](https://www.npmjs.com/package/@helpers4/math) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/math) | Mathematical utility functions and calculations |
+| number | [@helpers4/number](https://www.npmjs.com/package/@helpers4/number) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/number) | Number utility functions and validation |
 | object | [@helpers4/object](https://www.npmjs.com/package/@helpers4/object) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/object) | Object manipulation utilities |
 | observable | [@helpers4/observable](https://www.npmjs.com/package/@helpers4/observable) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/observable) | Observable utilities and combinators |
 | promise | [@helpers4/promise](https://www.npmjs.com/package/@helpers4/promise) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/promise) | Promise utilities and error handling |
 | string | [@helpers4/string](https://www.npmjs.com/package/@helpers4/string) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/string) | String manipulation and formatting utilities |
-| type | [@helpers4/type](https://www.npmjs.com/package/@helpers4/type) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/type) | type utilities |
+| type | [@helpers4/type](https://www.npmjs.com/package/@helpers4/type) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/type) | Type checking and validation utilities |
 | url | [@helpers4/url](https://www.npmjs.com/package/@helpers4/url) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/url) | URL parsing and manipulation utilities |
 | version | [@helpers4/version](https://www.npmjs.com/package/@helpers4/version) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/version) | Version string manipulation utilities |
 <!-- /AUTOMATIC-CATEGORIES-TABLE -->

package/lib/index.d.ts

@@ -1,3 +1,21 @@
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Removes all entries with falsy values (`false`, `null`, `undefined`, `0`, `""`, `NaN`) from an object.
+ * @param obj - The source object
+ * @returns A new object containing only entries with truthy values
+ * @example
+ * compact({ a: 1, b: null, c: '', d: 0, e: 'hello' })
+ * // => { a: 1, e: 'hello' }
+ * @since 2.0.0
+ */
+declare function compact<T extends Record<string, unknown>>(obj: T): Partial<T>;
+declare function compact(obj: undefined): undefined;
+declare function compact(obj: null): null;
+
 /**
  * This file is part of helpers4.
  * Copyright (C) 2025 baxyz
@@ -45,7 +63,9 @@ declare function deepCompare(objA: object | undefined | null, objB: object | und
  * @returns The merged object
  * @since 1.9.0
  */
-declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: Record<string, any>[]): T;
+declare function deepMerge<T extends Record<string, unknown>>(target: T, ...sources: Record<string, unknown>[]): T;
+declare function deepMerge(target: undefined, ...sources: Record<string, unknown>[]): undefined;
+declare function deepMerge(target: null, ...sources: Record<string, unknown>[]): null;
 
 /**
  * This file is part of helpers4.
@@ -60,7 +80,7 @@ declare function deepMerge<T extends Record<string, any>>(target: T, ...sources:
  * @returns The value at the path or default value
  * @since 1.9.0
  */
-declare function get<T = any>(obj: any, path: string, defaultValue?: T): T | undefined;
+declare function get<T = unknown>(obj: unknown, path: string, defaultValue?: T): T | undefined;
 
 /**
  * This file is part of helpers4.
@@ -68,15 +88,37 @@ declare function get<T = any>(obj: any, path: string, defaultValue?: T): T | und
  * SPDX-License-Identifier: LGPL-3.0-or-later
  */
 /**
- * Quick comparison of two objects using JSON.stringify.
- * This is a fast but simple comparison that may not work for all edge cases.
- *
- * @param objA - First object to compare
- * @param objB - Second object to compare
- * @returns `true` if objects are identical according to JSON.stringify, `false` otherwise
+ * Creates a new object without the specified keys.
+ * @param obj - The source object
+ * @param keys - The keys to omit
+ * @returns A new object without the omitted keys
+ * @example
+ * omit({ a: 1, b: 2, c: 3 }, ['b'])
+ * // => { a: 1, c: 3 }
+ * @since 2.0.0
+ */
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K>;
+declare function omit(obj: undefined, keys: readonly string[]): undefined;
+declare function omit(obj: null, keys: readonly string[]): null;
+
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Creates a new object with only the specified keys.
+ * @param obj - The source object
+ * @param keys - The keys to pick
+ * @returns A new object with only the picked keys
+ * @example
+ * pick({ a: 1, b: 2, c: 3 }, ['a', 'c'])
+ * // => { a: 1, c: 3 }
  * @since 2.0.0
  */
-declare function quickCompare(objA: unknown, objB: unknown): boolean;
+declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K>;
+declare function pick(obj: undefined, keys: readonly string[]): undefined;
+declare function pick(obj: null, keys: readonly string[]): null;
 
 /**
  * This file is part of helpers4.
@@ -108,6 +150,29 @@ declare function removeUndefinedNull(obj: null): null;
  */
 declare function removeUndefinedNull(obj: undefined): undefined;
 
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Parses a JSON string, returning `null` (or a fallback) on any parse failure.
+ *
+ * Unlike `JSON.parse`, this never throws. Invalid JSON strings and other
+ * parsing edge-cases resolve to `null` or the provided `fallback`.
+ *
+ * @param input - The JSON string to parse.
+ * @param fallback - Value returned on failure. Defaults to `null` when omitted.
+ * @returns The parsed value typed as `T`, or `fallback` on failure.
+ * @example
+ * safeJsonParse<{ a: number }>('{"a":1}')  // => { a: 1 }
+ * safeJsonParse('invalid')                 // => null
+ * safeJsonParse('invalid', [])             // => []
+ * @since next
+ */
+declare function safeJsonParse<T>(input: string): T | null;
+declare function safeJsonParse<T>(input: string, fallback: T): T;
+
 /**
  * This file is part of helpers4.
  * Copyright (C) 2025 baxyz
@@ -121,7 +186,23 @@ declare function removeUndefinedNull(obj: undefined): undefined;
  * @returns The modified object
  * @since 1.9.0
  */
-declare function set(obj: Record<string, any>, path: string, value: any): Record<string, any>;
+declare function set(obj: Record<string, unknown>, path: string, value: unknown): Record<string, unknown>;
+
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Quick comparison of two objects using JSON.stringify.
+ * This is a fast but simple comparison that may not work for all edge cases.
+ *
+ * @param objA - First object to compare
+ * @param objB - Second object to compare
+ * @returns `true` if objects are identical according to JSON.stringify, `false` otherwise
+ * @since 2.0.0
+ */
+declare function shallowEquals(objA: unknown, objB: unknown): boolean;
 
-export { deepClone, deepCompare, deepMerge, get, quickCompare, removeUndefinedNull, set };
+export { compact, deepClone, deepCompare, deepMerge, get, omit, pick, removeUndefinedNull, safeJsonParse, set, shallowEquals };
 export type { DeepCompareResult };

package/lib/index.js

@@ -1,10 +1,22 @@
-import { isNullish } from "radashi";
+//#region helpers/object/compact.ts
+function compact(obj) {
+	if (obj === void 0 || obj === null) return obj;
+	const result = {};
+	for (const key of Object.keys(obj)) if (obj[key]) result[key] = obj[key];
+	return result;
+}
+//#endregion
 //#region helpers/object/deepClone.ts
 /**
 * This file is part of helpers4.
 * Copyright (C) 2025 baxyz
 * SPDX-License-Identifier: LGPL-3.0-or-later
 */
+var UNSAFE_KEYS$2 = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
 /**
 * Creates a deep copy of an object or array
 * @param obj - The object to clone
@@ -16,11 +28,11 @@ function deepClone(obj) {
 	if (obj instanceof Date) return new Date(obj.getTime());
 	if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
 	const cloned = {};
-	for (const key in obj) if (obj.hasOwnProperty(key)) cloned[key] = deepClone(obj[key]);
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key) && !UNSAFE_KEYS$2.has(key)) cloned[key] = deepClone(obj[key]);
 	return cloned;
 }
 //#endregion
-//#region helpers/array/quickCompare.ts
+//#region helpers/array/shallowEquals.ts
 /**
 * This file is part of helpers4.
 * Copyright (C) 2025 baxyz
@@ -29,13 +41,13 @@ function deepClone(obj) {
 /**
 * Quick comparison of two arrays using JSON.stringify.
 * This is a fast but simple comparison that may not work for all edge cases.
-* 
+*
 * @param arrA - First array to compare
 * @param arrB - Second array to compare
 * @returns `true` if arrays are identical according to JSON.stringify, `false` otherwise
 * @since 2.0.0
 */
-function quickCompare$1(arrA, arrB) {
+function shallowEquals$1(arrA, arrB) {
 	try {
 		return JSON.stringify(arrA) === JSON.stringify(arrB);
 	} catch {
@@ -43,26 +55,116 @@ function quickCompare$1(arrA, arrB) {
 	}
 }
 //#endregion
+//#region helpers/date/timestamp.ts
+/**
+* Checks if a timestamp is likely in seconds (Java/Unix style) vs milliseconds (JavaScript style)
+* @param timestamp - The timestamp to check
+* @returns True if timestamp appears to be in seconds
+* @since 1.9.0
+*/
+function isTimestampInSeconds(timestamp) {
+	return Math.abs(timestamp) < 1e10;
+}
+/**
+* Converts a timestamp to JavaScript milliseconds format
+* @param timestamp - The timestamp (in seconds or milliseconds)
+* @returns Timestamp in milliseconds
+* @since 1.9.0
+*/
+function normalizeTimestamp(timestamp) {
+	return isTimestampInSeconds(timestamp) ? timestamp * 1e3 : timestamp;
+}
+//#endregion
+//#region helpers/date/ensureDate.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Type guard that checks whether a value satisfies the {@link EpochMilliseconds}
+* structural interface (e.g. `Temporal.Instant`, `Temporal.ZonedDateTime`).
+*/
+function hasEpochMilliseconds(value) {
+	return typeof value === "object" && value !== null && "epochMilliseconds" in value && typeof value.epochMilliseconds === "number";
+}
+/**
+* Safely converts a date-like value to a valid `Date` object, or returns `null`.
+*
+* Accepts `Date`, timestamps (seconds or milliseconds, auto-detected), date strings,
+* and objects with an `epochMilliseconds` property (e.g. `Temporal.Instant`,
+* `Temporal.ZonedDateTime`).
+* Returns `null` for `null`, `undefined`, empty strings, `0`, and any value that
+* produces an invalid `Date`.
+*
+* This is the date equivalent of {@link ensureArray} — it normalizes flexible
+* input into a guaranteed type (or a safe fallback).
+*
+* @param input - A date-like value to convert
+* @returns A valid `Date` object, or `null` if the input is invalid
+* @example
+* ensureDate('2025-01-19T12:00:00Z') // => Date
+* ensureDate(1737290400)             // => Date (from Unix seconds)
+* ensureDate(1737290400000)          // => Date (from milliseconds)
+* ensureDate(new Date())             // => Date (same reference)
+* ensureDate(null)                   // => null
+* ensureDate('invalid')              // => null
+*
+* @see {@link DateLike} for the accepted input types
+* @since 2.0.0
+*/
+function ensureDate(input) {
+	if (input === null || input === void 0 || input === "" || input === 0) return null;
+	if (input instanceof Date) return isNaN(input.getTime()) ? null : input;
+	if (hasEpochMilliseconds(input)) {
+		const date = new Date(input.epochMilliseconds);
+		return isNaN(date.getTime()) ? null : date;
+	}
+	if (typeof input === "number") {
+		const normalized = normalizeTimestamp(input);
+		const date = new Date(normalized);
+		return isNaN(date.getTime()) ? null : date;
+	}
+	if (typeof input === "string") {
+		const date = new Date(input);
+		return isNaN(date.getTime()) ? null : date;
+	}
+	return null;
+}
+//#endregion
 //#region helpers/date/compare.ts
 /**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
 * Comparison of two dates.
-* 
+*
+* Accepts any {@link DateLike} input (Date, timestamp, or date string).
+*
 * @param dateA - First date to compare
 * @param dateB - Second date to compare
 * @param options - Comparison options
 * @returns `true` if dates are identical according to the specified precision, `false` otherwise
+* @example
+* compare('2025-01-19', new Date('2025-01-19T08:00:00Z'), { precision: 'days' })
+* // => true
 * @since 2.0.0
 */
 function compare(dateA, dateB, options = {}) {
 	const { precision = "milliseconds" } = options;
-	if (!(dateA instanceof Date) || !(dateB instanceof Date)) return dateA === dateB;
-	if (isNaN(dateA.getTime()) || isNaN(dateB.getTime())) return isNaN(dateA.getTime()) && isNaN(dateB.getTime());
+	const a = ensureDate(dateA);
+	const b = ensureDate(dateB);
+	if (a === null || b === null) return false;
 	switch (precision) {
-		case "days": return dateA.toDateString() === dateB.toDateString();
-		case "hours": return Math.floor(dateA.getTime() / (1e3 * 60 * 60)) === Math.floor(dateB.getTime() / (1e3 * 60 * 60));
-		case "minutes": return Math.floor(dateA.getTime() / (1e3 * 60)) === Math.floor(dateB.getTime() / (1e3 * 60));
-		case "seconds": return Math.floor(dateA.getTime() / 1e3) === Math.floor(dateB.getTime() / 1e3);
-		default: return dateA.getTime() === dateB.getTime();
+		case "years": return a.getFullYear() === b.getFullYear();
+		case "months": return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth();
+		case "days": return a.toDateString() === b.toDateString();
+		case "hours": return Math.floor(a.getTime() / (1e3 * 60 * 60)) === Math.floor(b.getTime() / (1e3 * 60 * 60));
+		case "minutes": return Math.floor(a.getTime() / (1e3 * 60)) === Math.floor(b.getTime() / (1e3 * 60));
+		case "seconds": return Math.floor(a.getTime() / 1e3) === Math.floor(b.getTime() / 1e3);
+		default: return a.getTime() === b.getTime();
 	}
 }
 //#endregion
@@ -113,7 +215,7 @@ function isSpecialObject(value) {
 */
 /**
 * Deep comparison of two objects that returns detailed information about differences.
-* 
+*
 * @param objA - First object to compare (can be object, undefined, or null)
 * @param objB - Second object to compare (can be object, undefined, or null)
 * @returns `true` if objects are identical, `false` if incompatible types, or a `DeepCompareResult` object detailing differences
@@ -123,7 +225,7 @@ function deepCompare(objA, objB) {
 	if (objA === objB) return true;
 	if (objA == null || objB == null) return false;
 	if (objA instanceof Date && objB instanceof Date) return compare(objA, objB);
-	if (Array.isArray(objA) && Array.isArray(objB)) return quickCompare$1(objA, objB);
+	if (Array.isArray(objA) && Array.isArray(objB)) return shallowEquals$1(objA, objB);
 	if (Array.isArray(objA) || Array.isArray(objB)) return false;
 	if (isSpecialObject(objA) || isSpecialObject(objB)) return objA === objB;
 	const keys = Array.from(new Set([...Object.keys(objA), ...Object.keys(objB)]));
@@ -137,7 +239,7 @@ function deepCompare(objA, objB) {
 			const valueA = objA[key];
 			const valueB = objB[key];
 			if (Array.isArray(valueA) && Array.isArray(valueB)) {
-				if (!quickCompare$1(valueA, valueB)) differences[key] = false;
+				if (!shallowEquals$1(valueA, valueB)) differences[key] = false;
 			} else if (valueA instanceof Date && valueB instanceof Date) {
 				if (!compare(valueA, valueB)) differences[key] = false;
 			} else if (isSpecialObject(valueA) || isSpecialObject(valueB)) {
@@ -151,34 +253,59 @@ function deepCompare(objA, objB) {
 	return Object.keys(differences).length > 0 ? differences : true;
 }
 //#endregion
-//#region helpers/object/deepMerge.ts
+//#region helpers/type/isPlainObject.ts
 /**
 * This file is part of helpers4.
 * Copyright (C) 2025 baxyz
 * SPDX-License-Identifier: LGPL-3.0-or-later
 */
 /**
-* Merges two or more objects deeply
-* @param target - The target object
-* @param sources - The source objects to merge
-* @returns The merged object
-* @since 1.9.0
+* Checks if a value is a plain object.
+*
+* A plain object is created by `{}`, `new Object()`, or `Object.create(null)`.
+* Returns `false` for arrays, Date, Map, Set, RegExp, class instances, etc.
+*
+* @param value - The value to check
+* @returns True if value is a plain object
+* @example
+* isPlainObject({})           // => true
+* isPlainObject({ a: 1 })    // => true
+* isPlainObject(new Date())  // => false
+* isPlainObject([])          // => false
+* isPlainObject(null)        // => false
+* @since 2.0.0
 */
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+//#endregion
+//#region helpers/object/deepMerge.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+var UNSAFE_KEYS$1 = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
 function deepMerge(target, ...sources) {
+	if (target === void 0 || target === null) return target;
 	if (!sources.length) return target;
 	const source = sources.shift();
 	if (!source) return deepMerge(target, ...sources);
 	for (const key in source) {
+		if (!Object.hasOwn(source, key) || UNSAFE_KEYS$1.has(key)) continue;
 		const targetValue = target[key];
 		const sourceValue = source[key];
-		if (isObject(targetValue) && isObject(sourceValue)) target[key] = deepMerge(targetValue, sourceValue);
+		if (isPlainObject(targetValue) && isPlainObject(sourceValue)) target[key] = deepMerge(targetValue, sourceValue);
 		else if (sourceValue !== void 0) target[key] = sourceValue;
 	}
 	return deepMerge(target, ...sources);
 }
-function isObject(item) {
-	return item && typeof item === "object" && !Array.isArray(item);
-}
 //#endregion
 //#region helpers/object/get.ts
 /**
@@ -204,29 +331,44 @@ function get(obj, path, defaultValue) {
 	return result !== void 0 ? result : defaultValue;
 }
 //#endregion
-//#region helpers/object/quickCompare.ts
+//#region helpers/object/omit.ts
+function omit(obj, keys) {
+	if (obj === void 0 || obj === null) return obj;
+	const result = { ...obj };
+	for (const key of keys) delete result[key];
+	return result;
+}
+//#endregion
+//#region helpers/object/pick.ts
+function pick(obj, keys) {
+	if (obj === void 0 || obj === null) return obj;
+	const result = {};
+	for (const key of keys) if (Object.prototype.hasOwnProperty.call(obj, key)) result[key] = obj[key];
+	return result;
+}
+//#endregion
+//#region helpers/type/isNullish.ts
 /**
 * This file is part of helpers4.
 * Copyright (C) 2025 baxyz
 * SPDX-License-Identifier: LGPL-3.0-or-later
 */
 /**
-* Quick comparison of two objects using JSON.stringify.
-* This is a fast but simple comparison that may not work for all edge cases.
+* Checks if a value is null or undefined (nullish).
+* @param value - The value to check
+* @returns True if value is null or undefined
+* @example
+* isNullish(null)      // => true
+* isNullish(undefined) // => true
+* isNullish(0)         // => false
+* isNullish('')        // => false
 *
-* @param objA - First object to compare
-* @param objB - Second object to compare
-* @returns `true` if objects are identical according to JSON.stringify, `false` otherwise
+* @see {@link isDefined} for the inverse check (`!isNullish`)
+* @see {@link isFalsy} to also catch `0`, `""`, `false`, and `NaN`
 * @since 2.0.0
 */
-function quickCompare(objA, objB) {
-	if (objA === objB) return true;
-	if (typeof objA === "function" || typeof objB === "function") return objA === objB;
-	try {
-		return JSON.stringify(objA) === JSON.stringify(objB);
-	} catch {
-		return objA === objB;
-	}
+function isNullish(value) {
+	return value === null || value === void 0;
 }
 //#endregion
 //#region helpers/object/removeUndefinedNull.ts
@@ -243,10 +385,19 @@ function quickCompare(objA, objB) {
 * @since 1.0.0
 */
 function removeUndefinedNull(obj) {
-	return obj ? Object.entries(obj).filter(([_, v]) => !isNullish(v)).reduce((acc, [k, v]) => ({
-		...acc,
-		[k]: v
-	}), {}) : obj;
+	if (!obj) return obj;
+	const result = {};
+	for (const [k, v] of Object.entries(obj)) if (!isNullish(v)) result[k] = v;
+	return result;
+}
+//#endregion
+//#region helpers/object/safeJsonParse.ts
+function safeJsonParse(input, fallback) {
+	try {
+		return JSON.parse(input);
+	} catch {
+		return arguments.length < 2 ? null : fallback;
+	}
 }
 //#endregion
 //#region helpers/object/set.ts
@@ -255,6 +406,11 @@ function removeUndefinedNull(obj) {
 * Copyright (C) 2025 baxyz
 * SPDX-License-Identifier: LGPL-3.0-or-later
 */
+var UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
 /**
 * Sets a value in an object using a dot-notated path
 * @param obj - The object to set value in
@@ -265,6 +421,7 @@ function removeUndefinedNull(obj) {
 */
 function set(obj, path, value) {
 	const keys = path.split(".");
+	if (keys.some((k) => UNSAFE_KEYS.has(k))) return obj;
 	let current = obj;
 	for (let i = 0; i < keys.length - 1; i++) {
 		const key = keys[i];
@@ -275,6 +432,31 @@ function set(obj, path, value) {
 	return obj;
 }
 //#endregion
-export { deepClone, deepCompare, deepMerge, get, quickCompare, removeUndefinedNull, set };
+//#region helpers/object/shallowEquals.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Quick comparison of two objects using JSON.stringify.
+* This is a fast but simple comparison that may not work for all edge cases.
+*
+* @param objA - First object to compare
+* @param objB - Second object to compare
+* @returns `true` if objects are identical according to JSON.stringify, `false` otherwise
+* @since 2.0.0
+*/
+function shallowEquals(objA, objB) {
+	if (objA === objB) return true;
+	if (typeof objA === "function" || typeof objB === "function") return objA === objB;
+	try {
+		return JSON.stringify(objA) === JSON.stringify(objB);
+	} catch {
+		return objA === objB;
+	}
+}
+//#endregion
+export { compact, deepClone, deepCompare, deepMerge, get, omit, pick, removeUndefinedNull, safeJsonParse, set, shallowEquals };
 
 //# sourceMappingURL=index.js.map