@helpers4/object 2.0.4 → 3.0.0-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/README.md +5 -3
  2. package/lib/index.d.ts +243 -78
  3. package/lib/index.js +121 -69
  4. package/lib/index.js.map +1 -1
  5. package/llms.txt +179 -151
  6. package/meta/api.json +150 -202
  7. package/meta/examples.json +20 -20
  8. package/meta/native-alternatives.json +1 -1
  9. package/package.json +3 -3
package/lib/index.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"index.js","names":[],"sources":["../../../helpers/object/compact.ts","../../../helpers/object/_unsafeKeys.ts","../../../helpers/object/deepClone.ts","../../../helpers/type/isPlainObject.ts","../../../helpers/object/deepMerge.ts","../../../helpers/array/equalsDeep.ts","../../../helpers/date/timestamp.ts","../../../helpers/date/ensureDate.ts","../../../helpers/date/compare.ts","../../../helpers/type/isSpecialObject.ts","../../../helpers/object/diff.ts","../../../helpers/object/equalsDeep.ts","../../../helpers/object/equalsShallow.ts","../../../helpers/object/_parsePath.ts","../../../helpers/object/get.ts","../../../helpers/object/groupBy.ts","../../../helpers/object/invert.ts","../../../helpers/object/isEmpty.ts","../../../helpers/object/isNonEmpty.ts","../../../helpers/object/map.ts","../../../helpers/object/omit.ts","../../../helpers/object/pick.ts","../../../helpers/type/isNullish.ts","../../../helpers/object/removeUndefinedNull.ts","../../../helpers/object/safeJsonParse.ts","../../../helpers/object/set.ts"],"sourcesContent":["/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Removes all entries with falsy values (`false`, `null`, `undefined`, `0`, `\"\"`, `NaN`) from an object.\n * @param obj - The source object\n * @returns A new object containing only entries with truthy values\n * @example\n * compact({ a: 1, b: null, c: '', d: 0, e: 'hello' })\n * // => { a: 1, e: 'hello' }\n * @since 2.0.0\n */\nexport function compact<T extends Record<string, unknown>>(obj: T): Partial<T>;\nexport function compact(obj: undefined): undefined;\nexport function compact(obj: null): null;\nexport function compact<T extends Record<string, unknown>>(obj: T | undefined | null): Partial<T> | undefined | null {\n if (obj === undefined || obj === null) return obj;\n const result: Partial<T> = {};\n for (const key of Object.keys(obj) as (keyof T)[]) {\n if (obj[key]) {\n result[key] = obj[key];\n }\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Keys that must never be set on a plain object (prototype-pollution guard).\n * @internal\n */\nexport const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { UNSAFE_KEYS } from './_unsafeKeys.js';\n\n/**\n * Creates a deep copy of an object or array\n * @param obj - The object to clone\n * @returns Deep cloned object\n * @since 1.9.0\n */\nexport function deepClone<T>(obj: T): T {\n if (obj === null || typeof obj !== \"object\") {\n return obj;\n }\n\n if (obj instanceof Date) {\n return new Date(obj.getTime()) as T;\n }\n\n if (Array.isArray(obj)) {\n return obj.map(item => deepClone(item)) as T;\n }\n\n const cloned = {} as T;\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key) && !UNSAFE_KEYS.has(key)) {\n cloned[key] = deepClone(obj[key]);\n }\n }\n\n return cloned;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if a value is a plain object.\n *\n * A plain object is created by `{}`, `new Object()`, or `Object.create(null)`.\n * Returns `false` for arrays, Date, Map, Set, RegExp, class instances, etc.\n *\n * @param value - The value to check\n * @returns True if value is a plain object\n * @example\n * isPlainObject({}) // => true\n * isPlainObject({ a: 1 }) // => true\n * isPlainObject(new Date()) // => false\n * isPlainObject([]) // => false\n * isPlainObject(null) // => false\n * @since 2.0.0\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n if (value === null || typeof value !== 'object') return false;\n const proto = Object.getPrototypeOf(value);\n return proto === Object.prototype || proto === null;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { isPlainObject } from '../type/isPlainObject';\nimport { UNSAFE_KEYS } from './_unsafeKeys.js';\n\n// Shared merge logic for a single key (string or symbol).\n// Extracted to avoid duplicating the plain-object / replace / skip logic between\n// the string-key loop (for...in) and the symbol-key loop (getOwnPropertySymbols).\nfunction mergeKey(\n target: Record<PropertyKey, unknown>,\n source: Record<PropertyKey, unknown>,\n key: PropertyKey,\n): void {\n const targetValue = target[key];\n const sourceValue = source[key];\n if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {\n target[key] = deepMerge(\n targetValue as Record<PropertyKey, unknown>,\n sourceValue as Record<PropertyKey, unknown>,\n );\n } else if (sourceValue !== undefined) {\n target[key] = sourceValue;\n }\n}\n\n/**\n * Merges two or more objects deeply.\n *\n * Recursively merges own enumerable properties — both string and symbol keys.\n * Plain objects are merged recursively; all other values (arrays, class instances,\n * primitives, etc.) are replaced by the source value.\n * `undefined` source values do not overwrite existing target values.\n *\n * @param target - The target object (mutated in place)\n * @param sources - One or more source objects to merge into the target\n * @returns The mutated target\n * @since 1.9.0\n */\nexport function deepMerge<T extends Record<PropertyKey, unknown>>(target: T, ...sources: Record<PropertyKey, unknown>[]): T;\nexport function deepMerge(target: undefined, ...sources: Record<PropertyKey, unknown>[]): undefined;\nexport function deepMerge(target: null, ...sources: Record<PropertyKey, unknown>[]): null;\nexport function deepMerge<T extends Record<PropertyKey, unknown>>(target: T | undefined | null, ...sources: Record<PropertyKey, unknown>[]): T | undefined | null {\n if (target === undefined || target === null) return target;\n if (!sources.length) return target;\n const source = sources.shift();\n\n if (!source) return deepMerge(target, ...sources);\n\n const t = target as Record<PropertyKey, unknown>;\n const s = source as Record<PropertyKey, unknown>;\n\n for (const key in source) {\n if (!Object.hasOwn(source, key) || UNSAFE_KEYS.has(key)) continue;\n mergeKey(t, s, key);\n }\n\n for (const sym of Object.getOwnPropertySymbols(source)) {\n if (!Object.prototype.propertyIsEnumerable.call(source, sym)) continue;\n mergeKey(t, s, sym);\n }\n\n return deepMerge(target, ...sources);\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { isPlainObject } from '../type/isPlainObject';\n\n/**\n * Recursive structural array equality.\n *\n * Two arrays are equal when they have the same length and each pair of\n * elements at the same index is structurally equal:\n * - Arrays recurse with `equalsDeep`.\n * - Plain objects recurse key-by-key with structural comparison.\n * - `Date` instances are compared by their epoch value.\n * - All other values use strict equality (`===`), which means `NaN !== NaN`\n * and special objects (Map, Set, RegExp, Promise, class instances\\u2026) are\n * compared by reference.\n *\n * For positional one-level comparison use {@link equalsShallow}. For\n * order-independent comparison use {@link equalsUnordered}.\n *\n * @param arrA - First array to compare\n * @param arrB - Second array to compare\n * @returns `true` if arrays are deeply equal, `false` otherwise.\n * @since 2.0.0\n */\nexport function equalsDeep<T>(arrA: readonly T[], arrB: readonly T[]): boolean {\n if (arrA === arrB) {\n return true;\n }\n if (!Array.isArray(arrA) || !Array.isArray(arrB)) {\n return false;\n }\n if (arrA.length !== arrB.length) {\n return false;\n }\n for (let i = 0; i < arrA.length; i++) {\n if (!valuesEqual(arrA[i], arrB[i])) {\n return false;\n }\n }\n return true;\n}\n\nfunction valuesEqual(a: unknown, b: unknown): boolean {\n if (a === b) {\n return true;\n }\n if (Array.isArray(a) && Array.isArray(b)) {\n return equalsDeep(a, b);\n }\n if (a instanceof Date && b instanceof Date) {\n return a.getTime() === b.getTime();\n }\n if (isPlainObject(a) && isPlainObject(b)) {\n const ao = a as Record<string, unknown>;\n const bo = b as Record<string, unknown>;\n const keysA = Object.keys(ao);\n if (keysA.length !== Object.keys(bo).length) {\n return false;\n }\n for (const key of keysA) {\n if (!Object.prototype.hasOwnProperty.call(bo, key)) {\n return false;\n }\n if (!valuesEqual(ao[key], bo[key])) {\n return false;\n }\n }\n return true;\n }\n return false;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { ensureDate } from './ensureDate';\nimport type { DateLike } from './types';\n\n/**\n * Checks if a timestamp is likely in seconds (Java/Unix style) vs milliseconds (JavaScript style)\n * @param timestamp - The timestamp to check\n * @returns True if timestamp appears to be in seconds\n * @since 1.9.0\n */\nexport function isTimestampInSeconds(timestamp: number): boolean {\n // Timestamps before year 2001 in milliseconds are less than 10^10\n // Use Math.abs to correctly handle negative timestamps (before epoch)\n return Math.abs(timestamp) < 10000000000;\n}\n\n/**\n * Converts a timestamp to JavaScript milliseconds format\n * @param timestamp - The timestamp (in seconds or milliseconds)\n * @returns Timestamp in milliseconds\n * @since 1.9.0\n */\nexport function normalizeTimestamp(timestamp: number): number {\n return isTimestampInSeconds(timestamp) ? timestamp * 1000 : timestamp;\n}\n\n/**\n * Converts a date to a timestamp in **seconds** (epoch seconds).\n *\n * Use this when sending a date to a backend API that expects seconds\n * (e.g. Java `Instant.getEpochSecond()`, Python `time.time()`).\n *\n * @param date - The date to convert\n * @returns Seconds since the Unix epoch, or `null` for invalid input\n * @example\n * toSeconds('2025-01-19T12:00:00Z') // => 1737288000\n * toSeconds(null) // => null\n *\n * @since 2.0.0\n */\nexport function toSeconds(date: DateLike): number | null {\n const d = ensureDate(date);\n if (!d) return null;\n return Math.floor(d.getTime() / 1000);\n}\n\n/**\n * Converts a date to a timestamp in **milliseconds** (epoch millis).\n *\n * Use this when you need a plain number from a `DateLike` value\n * (e.g. for `Date.now()` comparisons, localStorage, or JS-native APIs).\n *\n * @param date - The date to convert\n * @returns Milliseconds since the Unix epoch, or `null` for invalid input\n * @example\n * toMillis('2025-01-19T12:00:00Z') // => 1737288000000\n * toMillis(null) // => null\n *\n * @since 2.0.0\n */\nexport function toMillis(date: DateLike): number | null {\n const d = ensureDate(date);\n if (!d) return null;\n return d.getTime();\n}\n\n/**\n * Creates a `Date` from a timestamp in **seconds**.\n *\n * Use this when receiving a timestamp from a backend that sends seconds\n * (e.g. Java `Instant.getEpochSecond()`). No heuristic — the input is\n * always treated as seconds.\n *\n * @param seconds - Seconds since the Unix epoch\n * @returns A valid `Date`, or `null` for `NaN` / non-finite input\n * @example\n * fromSeconds(1737288000) // => Date('2025-01-19T12:00:00Z')\n * fromSeconds(0) // => Date('1970-01-01T00:00:00Z')\n * fromSeconds(NaN) // => null\n *\n * @since 2.0.0\n */\nexport function fromSeconds(seconds: number): Date | null {\n if (!Number.isFinite(seconds)) return null;\n return new Date(seconds * 1000);\n}\n\n/**\n * Creates a `Date` from a timestamp in **milliseconds**.\n *\n * Use this when receiving a timestamp from a JS-native source\n * (e.g. `Date.now()`, `performance.timeOrigin`). No heuristic — the\n * input is always treated as milliseconds.\n *\n * @param ms - Milliseconds since the Unix epoch\n * @returns A valid `Date`, or `null` for `NaN` / non-finite input\n * @example\n * fromMillis(1737288000000) // => Date('2025-01-19T12:00:00Z')\n * fromMillis(0) // => Date('1970-01-01T00:00:00Z')\n * fromMillis(NaN) // => null\n *\n * @since 2.0.0\n */\nexport function fromMillis(ms: number): Date | null {\n if (!Number.isFinite(ms)) return null;\n return new Date(ms);\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { normalizeTimestamp } from './timestamp';\nimport type { DateLike, EpochMilliseconds } from './types';\n\n/**\n * Type guard that checks whether a value satisfies the {@link EpochMilliseconds}\n * structural interface (e.g. `Temporal.Instant`, `Temporal.ZonedDateTime`).\n */\nfunction hasEpochMilliseconds(value: unknown): value is EpochMilliseconds {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'epochMilliseconds' in value &&\n typeof (value as EpochMilliseconds).epochMilliseconds === 'number'\n );\n}\n\n/**\n * Safely converts a date-like value to a valid `Date` object, or returns `null`.\n *\n * Accepts `Date`, timestamps (seconds or milliseconds, auto-detected), date strings,\n * and objects with an `epochMilliseconds` property (e.g. `Temporal.Instant`,\n * `Temporal.ZonedDateTime`).\n * Returns `null` for `null`, `undefined`, empty strings, `0`, and any value that\n * produces an invalid `Date`.\n *\n * This is the date equivalent of {@link ensureArray} — it normalizes flexible\n * input into a guaranteed type (or a safe fallback).\n *\n * @param input - A date-like value to convert\n * @returns A valid `Date` object, or `null` if the input is invalid\n * @example\n * ensureDate('2025-01-19T12:00:00Z') // => Date\n * ensureDate(1737290400) // => Date (from Unix seconds)\n * ensureDate(1737290400000) // => Date (from milliseconds)\n * ensureDate(new Date()) // => Date (same reference)\n * ensureDate(null) // => null\n * ensureDate('invalid') // => null\n *\n * @see {@link DateLike} for the accepted input types\n * @since 2.0.0\n */\nexport function ensureDate(input: DateLike | null | undefined): Date | null {\n if (input === null || input === undefined || input === '' || input === 0) {\n return null;\n }\n\n if (input instanceof Date) {\n return isNaN(input.getTime()) ? null : input;\n }\n\n if (hasEpochMilliseconds(input)) {\n const date = new Date(input.epochMilliseconds);\n return isNaN(date.getTime()) ? null : date;\n }\n\n if (typeof input === 'number') {\n const normalized = normalizeTimestamp(input);\n const date = new Date(normalized);\n return isNaN(date.getTime()) ? null : date;\n }\n\n if (typeof input === 'string') {\n const date = new Date(input);\n return isNaN(date.getTime()) ? null : date;\n }\n\n return null;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { ensureDate } from './ensureDate';\nimport type { DateLike } from './types';\n\n/**\n * Options for date comparison\n * @since 2.0.0\n */\nexport interface DateCompareOptions {\n /**\n * Comparison precision\n * - 'milliseconds': Compare all including milliseconds (default)\n * - 'seconds': Ignore milliseconds, compare to the second\n * - 'minutes': Ignore seconds and milliseconds, compare to the minute\n * - 'hours': Ignore minutes, seconds and milliseconds, compare to the hour\n * - 'days': Compare only the date part (ignore time completely)\n * - 'months': Compare only year and month\n * - 'years': Compare only year\n */\n precision?: 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'months' | 'years';\n}\n\n/**\n * Comparison of two dates.\n *\n * Accepts any {@link DateLike} input (Date, timestamp, or date string).\n *\n * @param dateA - First date to compare\n * @param dateB - Second date to compare\n * @param options - Comparison options\n * @returns `true` if dates are identical according to the specified precision, `false` otherwise\n * @example\n * compare('2025-01-19', new Date('2025-01-19T08:00:00Z'), { precision: 'days' })\n * // => true\n * @since 2.0.0\n */\nexport function compare(dateA: DateLike, dateB: DateLike, options: DateCompareOptions = {}): boolean {\n const { precision = 'milliseconds' } = options;\n\n const a = ensureDate(dateA);\n const b = ensureDate(dateB);\n\n // Any invalid → not equal\n if (a === null || b === null) {\n return false;\n }\n\n switch (precision) {\n case 'years':\n return a.getFullYear() === b.getFullYear();\n\n case 'months':\n return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth();\n\n case 'days':\n return a.toDateString() === b.toDateString();\n\n case 'hours': {\n const hoursA = Math.floor(a.getTime() / (1000 * 60 * 60));\n const hoursB = Math.floor(b.getTime() / (1000 * 60 * 60));\n return hoursA === hoursB;\n }\n\n case 'minutes': {\n const minutesA = Math.floor(a.getTime() / (1000 * 60));\n const minutesB = Math.floor(b.getTime() / (1000 * 60));\n return minutesA === minutesB;\n }\n\n case 'seconds': {\n const secondsA = Math.floor(a.getTime() / 1000);\n const secondsB = Math.floor(b.getTime() / 1000);\n return secondsA === secondsB;\n }\n\n case 'milliseconds':\n default:\n return a.getTime() === b.getTime();\n }\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Determines if a value is a special object that should not have its properties compared deeply.\n * Special objects include: Date, Function, Promise, Observable, RegExp, Error, Map, Set, WeakMap, WeakSet, etc.\n * \n * @param value - The value to check\n * @returns `true` if the value is a special object, `false` otherwise\n * @since 2.0.0\n */\nexport function isSpecialObject(value: unknown): boolean {\n if (value === null || value === undefined) {\n return false;\n }\n\n // Functions are special objects\n if (typeof value === 'function') {\n return true;\n }\n\n // Non-objects are not special\n if (typeof value !== 'object') {\n return false;\n }\n\n // Arrays are not considered special objects for our purposes\n if (Array.isArray(value)) {\n return false;\n }\n\n // Check for built-in special objects\n if (\n value instanceof Date ||\n value instanceof Promise ||\n value instanceof RegExp ||\n value instanceof Error ||\n value instanceof Map ||\n value instanceof Set ||\n value instanceof WeakMap ||\n value instanceof WeakSet ||\n value instanceof ArrayBuffer ||\n value instanceof DataView\n ) {\n return true;\n }\n\n // Check for Observable (RxJS or similar)\n if (value.constructor?.name === 'Observable') {\n return true;\n }\n\n // Check for DOM elements (if in browser environment)\n if (typeof HTMLElement !== 'undefined' && value instanceof HTMLElement) {\n return true;\n }\n\n // Check for other built-in types by constructor name\n const constructorName = value.constructor?.name;\n if (constructorName && [\n 'Buffer', // Node.js Buffer\n 'URL', // Web URL API\n 'URLSearchParams',\n 'File', // Web File API\n 'Blob', // Web Blob API\n 'FormData', // Web FormData API\n 'Headers', // Web Headers API\n 'Request', // Web Request API\n 'Response', // Web Response API\n 'EventTarget', // Web EventTarget API\n 'Symbol' // Symbol objects\n ].includes(constructorName)) {\n return true;\n }\n\n return false;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { equalsDeep as arrayDeepEquals } from '../array/equalsDeep';\nimport { compare as compareDate } from '../date/compare';\nimport { isSpecialObject } from '../type/isSpecialObject';\n\n/**\n * Per-key diff result. Each entry tells what differs between the two\n * objects:\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.\n *\n * @since 2.0.0\n */\nexport interface DiffResult {\n [key: string]: 'onlyA' | 'onlyB' | false | DiffResult;\n}\n\n/**\n * Options for {@link diff}.\n * @since 2.0.0\n */\nexport interface DiffOptions {\n /**\n * Maximum recursion depth for nested plain objects. Defaults to\n * `Infinity` (full structural diff).\n *\n * - `0` compares values at the top-level only with strict equality.\n * - `1` compares the first level of nested objects with strict equality.\n * - `Infinity` recurses through every plain-object level.\n *\n * Arrays, `Date` and special objects (Map, Set, RegExp\\u2026) are always\n * leaf-compared (via {@link arrayDeepEquals}, epoch comparison, or\n * reference equality respectively) regardless of `depth`.\n */\n depth?: number;\n}\n\n/**\n * Structural object diff.\n *\n * Returns `true` when both inputs are deeply equal, otherwise a\n * {@link DiffResult} describing the differences key by key.\n *\n * Comparison 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 *\n * For a boolean wrapper see {@link equalsDeep} from this category.\n * For a one-level boolean check see {@link equalsShallow} from this category.\n *\n * @param objA - First value (object, `null`, or `undefined`).\n * @param objB - Second value (object, `null`, or `undefined`).\n * @param options - See {@link DiffOptions}.\n * @returns `true` when equal, otherwise a {@link DiffResult}, or `false` for incompatible types.\n * @since 2.0.0\n */\nexport function diff(\n objA: object | undefined | null,\n objB: object | undefined | null,\n options: DiffOptions = {},\n): true | false | DiffResult {\n const depth = options.depth ?? Infinity;\n\n // Quick reference equality check\n if (objA === objB) {\n return true;\n }\n\n // Handle null/undefined cases\n if (objA == null || objB == null) {\n return false;\n }\n\n // Handle Date objects\n if (objA instanceof Date && objB instanceof Date) {\n return compareDate(objA, objB);\n }\n\n // Handle Arrays at root level\n if (Array.isArray(objA) && Array.isArray(objB)) {\n return arrayDeepEquals(objA, objB);\n }\n if (Array.isArray(objA) || Array.isArray(objB)) {\n return false;\n }\n\n // Handle special objects - compare by reference only\n if (isSpecialObject(objA) || isSpecialObject(objB)) {\n return objA === objB;\n }\n\n // Plain object detailed comparison\n return diffPlainObjects(objA, objB, depth);\n}\n\nfunction diffPlainObjects(\n objA: object,\n objB: object,\n depth: number,\n): true | DiffResult {\n const keys = Array.from(new Set([...Object.keys(objA), ...Object.keys(objB)]));\n const differences: DiffResult = Object.create(null) as DiffResult;\n\n for (const key of keys) {\n const hasA = Object.prototype.hasOwnProperty.call(objA, key);\n const hasB = Object.prototype.hasOwnProperty.call(objB, key);\n\n if (!hasA && hasB) {\n differences[key] = 'onlyB';\n continue;\n }\n if (hasA && !hasB) {\n differences[key] = 'onlyA';\n continue;\n }\n\n const valueA = (objA as Record<string, unknown>)[key];\n const valueB = (objB as Record<string, unknown>)[key];\n\n if (valueA === valueB) {\n continue;\n }\n\n if (Array.isArray(valueA) && Array.isArray(valueB)) {\n if (!arrayDeepEquals(valueA, valueB)) {\n differences[key] = false;\n }\n continue;\n }\n if (Array.isArray(valueA) || Array.isArray(valueB)) {\n differences[key] = false;\n continue;\n }\n\n if (valueA instanceof Date && valueB instanceof Date) {\n if (!compareDate(valueA, valueB)) {\n differences[key] = false;\n }\n continue;\n }\n if (valueA instanceof Date || valueB instanceof Date) {\n differences[key] = false;\n continue;\n }\n\n if (isSpecialObject(valueA) || isSpecialObject(valueB)) {\n // valueA === valueB already handled above, so any special-object pair\n // that reaches here must differ.\n differences[key] = false;\n continue;\n }\n\n const bothPlainObjects =\n valueA !== null && valueB !== null &&\n typeof valueA === 'object' && typeof valueB === 'object';\n\n if (!bothPlainObjects) {\n differences[key] = false;\n continue;\n }\n\n if (depth <= 0) {\n // depth budget exhausted \\u2192 strict-equal nested objects only match by reference\n differences[key] = false;\n continue;\n }\n\n const nested = diffPlainObjects(valueA as object, valueB as object, depth - 1);\n if (nested !== true) {\n differences[key] = nested;\n }\n }\n\n return Object.keys(differences).length > 0 ? differences : true;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { diff } from './diff';\n\n/**\n * Recursive structural object equality.\n *\n * Boolean wrapper around {@link diff} \\u2014 returns `true` when the two values\n * are deeply equal according to the same rules. Use this when you only\n * need a yes/no answer; use {@link diff} when you also need to know\n * *what* differs.\n *\n * For a one-level boolean check use {@link equalsShallow}.\n *\n * @param objA - First value (object, `null`, or `undefined`).\n * @param objB - Second value (object, `null`, or `undefined`).\n * @returns `true` if both inputs are deeply equal, `false` otherwise.\n * @since 2.0.0\n */\nexport function equalsDeep(\n objA: object | undefined | null,\n objB: object | undefined | null,\n): boolean {\n return diff(objA, objB) === true;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * One-level (shallow) object equality.\n *\n * Two objects are equal when they share the exact same set of own\n * enumerable string keys and each pair of values satisfies strict equality\n * (`===`). No recursion: nested objects/arrays are compared by reference.\n *\n * Falls back to strict equality when either input is `null`, `undefined`\n * or not an object \\u2014 so primitives match if and only if they are `===`.\n * Arrays are not supported; they always return `false` (unless identical\n * references). Use `array/equalsShallow` instead.\n *\n * For recursive structural comparison use {@link equalsDeep}. For a diff\n * structure use {@link diff}.\n *\n * @param objA - First value to compare\n * @param objB - Second value to compare\n * @returns `true` if values are shallowly equal, `false` otherwise.\n * @since 2.0.0\n */\nexport function equalsShallow(objA: unknown, objB: unknown): boolean {\n if (objA === objB) {\n return true;\n }\n if (\n objA === null || objB === null ||\n typeof objA !== 'object' || typeof objB !== 'object'\n ) {\n return false;\n }\n const a = objA as Record<string, unknown>;\n const b = objB as Record<string, unknown>;\n if (Array.isArray(objA) || Array.isArray(objB)) {\n return false;\n }\n const keysA = Object.keys(a);\n if (keysA.length !== Object.keys(b).length) {\n return false;\n }\n for (const key of keysA) {\n if (!Object.prototype.hasOwnProperty.call(b, key) || a[key] !== b[key]) {\n return false;\n }\n }\n return true;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Parses a string path into an array of string/number segments.\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 bare `.`) returns `['']` (addresses the `''` key on the root object).\n * - Consecutive dots (`a..b`) produce an empty-string segment: `['a', '', 'b']`.\n * - Non-bracket text trailing a `]` within the same dot-segment throws a RangeError;\n * use a dot separator instead (`'a[0].b'` not `'a[0]b'`).\n *\n * @internal\n * @example\n * parsePath('a.b.c') // => ['a', 'b', 'c'] (all strings)\n * parsePath('layers.1.x') // => ['layers', '1', 'x'] (all strings)\n * parsePath('layers[1].x') // => ['layers', 1, 'x'] (bracket → number)\n * parsePath('.[0]') // => [0] (leading dot stripped)\n * parsePath('a..b') // => ['a', '', 'b'] (empty segment preserved)\n * parsePath('.') // => [''] (leading dot → empty-string key)\n */\n// `g` flag: stateful — callers must reset lastIndex before each use.\nconst BRACKET = /\\[(\\d+)\\]/g;\n\n// Module-level cache: most call sites use a fixed set of string paths (e.g. sort keys),\n// so parsing the same path string repeatedly on every get()/set() call is pure waste.\nconst parsePathCache = new Map<string, readonly (string | number)[]>();\n\nexport function parsePath(path: string): readonly (string | number)[] {\n const cached = parsePathCache.get(path);\n if (cached !== undefined) return cached;\n\n const result = Object.freeze(parsePathUncached(path));\n parsePathCache.set(path, result);\n return result;\n}\n\nfunction parsePathUncached(path: string): (string | number)[] {\n if (path === '') return [''];\n if (path[0] === '.') path = path.slice(1);\n if (path === '') return [''];\n const result: (string | number)[] = [];\n // Split on `.` first so consecutive dots produce empty segments, then parse `[n]` within each.\n for (const dotSegment of path.split('.')) {\n BRACKET.lastIndex = 0;\n let last = 0;\n let match: RegExpExecArray | null;\n while ((match = BRACKET.exec(dotSegment)) !== null) {\n // String prefix before this [n] — omit only when the segment starts with '['.\n if (match.index > last) result.push(dotSegment.slice(last, match.index));\n result.push(parseInt(match[1], 10));\n last = BRACKET.lastIndex;\n }\n if (last === 0) {\n // No brackets found — push the whole dot-segment as a string key.\n result.push(dotSegment);\n } else if (last < dotSegment.length) {\n // Trailing non-bracket text after the last ']' (e.g. 'a[0]b') — ambiguous and\n // almost always a mistake. Throw rather than silently drop 'b'.\n throw new RangeError(\n `parsePath: non-bracket text '${dotSegment.slice(last)}' after ']' in segment '${dotSegment}' — use 'a[0].b' instead of 'a[0]b'`,\n );\n }\n // last === dotSegment.length: segment ended right after the last ']', nothing to push.\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { parsePath } from './_parsePath.js';\nimport type { DeepGet } from './_types.js';\n\n/**\n * Gets a value from an object using a dot/bracket-notated path or explicit key array.\n *\n * **Two path forms are supported:**\n *\n * 1. **String path** — dot notation (`'a.b.c'`) and bracket notation (`'layers[1].name'`)\n * are both accepted and mixed freely. Segments are traversed as string keys; `[n]`\n * indices become numeric keys.\n *\n * 2. **Key array** (`PropertyKey[]`) — explicit array of `string | number | symbol` keys,\n * no parsing performed. Enables symbol-keyed traversal and compile-time type inference:\n * `get(obj, ['a', 'b'] as const)` infers the return type from the path.\n *\n * @param obj - The object to read from\n * @param path - Dot/bracket-notation string or explicit `PropertyKey[]`\n * @param defaultValue - Returned when the path is absent or resolves to `undefined`\n * @returns The value at the path, or `defaultValue`\n * @example\n * get({ a: { b: { c: 42 } } }, 'a.b.c') // => 42\n * get({ a: [1, 2, 3] }, 'a[1]') // => 2\n * get({ a: { b: 0 } }, 'a.b', 99) // => 0 (falsy values are returned as-is)\n * get({ a: 1 }, 'b.c', 'default') // => 'default'\n *\n * const id = Symbol('id')\n * get({ [id]: 'alice' }, [id]) // => 'alice' (symbol key)\n * @since 1.9.0\n */\nexport function get<T = unknown>(obj: unknown, path: string, defaultValue?: T): T | undefined;\nexport function get<T extends object, const Path extends readonly PropertyKey[]>(\n obj: T,\n path: Path,\n defaultValue?: DeepGet<T, Path>,\n): DeepGet<T, Path> | undefined;\nexport function get(obj: unknown, path: string | PropertyKey[], defaultValue?: unknown): unknown {\n const keys: readonly PropertyKey[] = typeof path === 'string' ? parsePath(path) : path;\n let result: unknown = obj;\n\n for (const key of keys) {\n if (result == null || typeof result !== 'object') {\n return defaultValue;\n }\n result = (result as Record<PropertyKey, unknown>)[key];\n }\n\n return result !== undefined ? result : defaultValue;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Groups an array of items by a key derived from each item.\n *\n * A thin, typed wrapper around `Object.groupBy` (ES2024) that works on\n * older targets and provides stricter return-type inference.\n *\n * @param items - The array to group\n * @param keyFn - Function that returns the group key for each item\n * @returns A record mapping each key to the array of items with that key\n * @example\n * groupBy([1, 2, 3, 4], n => n % 2 === 0 ? 'even' : 'odd')\n * // => { odd: [1, 3], even: [2, 4] }\n * @since 2.0.0\n */\nexport function groupBy<T, K extends PropertyKey>(\n items: readonly T[],\n keyFn: (item: T) => K\n): Partial<Record<K, T[]>> {\n const result = {} as Partial<Record<K, T[]>>;\n for (const item of items) {\n const key = keyFn(item);\n if (result[key] === undefined) {\n result[key] = [];\n }\n (result[key] as T[]).push(item);\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Returns a new object with keys and values swapped.\n * If multiple keys share the same value, the last one wins.\n *\n * @param obj - The object whose keys and values are to be swapped\n * @returns A new object with values as keys and original keys as values\n * @example\n * invert({ a: 'x', b: 'y', c: 'z' })\n * // => { x: 'a', y: 'b', z: 'c' }\n *\n * invert({ one: 1, two: 2 })\n * // => { 1: 'one', 2: 'two' }\n * @since 2.0.0\n */\nexport function invert<K extends string, V extends PropertyKey>(obj: Record<K, V>): Record<V, K> {\n const result = {} as Record<V, K>;\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n result[obj[key as K]] = key as unknown as K;\n }\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if a plain object has no own enumerable string-keyed properties.\n *\n * Symbol-keyed properties are not counted. Use `Object.getOwnPropertySymbols`\n * separately if symbol keys matter for your use case.\n *\n * @param value - The object to check\n * @returns `true` if the object has no own enumerable string-keyed properties\n * @example\n * isEmpty({}) // => true\n * isEmpty({ a: 1 }) // => false\n * isEmpty({ a: undefined }) // => false (key exists)\n * @since 2.0.3\n */\nexport function isEmpty(value: Record<PropertyKey, unknown>): boolean {\n return Object.keys(value).length === 0;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if a plain object has at least one own enumerable string-keyed property.\n *\n * Symbol-keyed properties are not counted. Use `Object.getOwnPropertySymbols`\n * separately if symbol keys matter for your use case.\n *\n * @param value - The object to check\n * @returns `true` if the object has at least one own enumerable string-keyed property\n * @example\n * isNonEmpty({ a: 1 }) // => true\n * isNonEmpty({}) // => false\n * @since 2.0.3\n */\nexport function isNonEmpty(value: Record<PropertyKey, unknown>): boolean {\n return Object.keys(value).length > 0;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Transforms the values and/or keys of a plain object in a single pass.\n *\n * Both callbacks are optional and default to identity (no transformation).\n * When `mapValue` is omitted the original values are preserved;\n * when `mapKey` is omitted the original keys are preserved.\n *\n * Note: if two different keys map to the same output key the last one wins\n * (insertion order).\n *\n * @param obj - The source object\n * @param mapValue - Callback called with `(value, key)` for each entry.\n * Defaults to identity.\n * @param mapKey - Callback called with `(key, value)` for each entry.\n * Defaults to identity.\n * @returns A new object with transformed keys and/or values\n * @example\n * map({ a: 1, b: 2 }, v => v * 10)\n * // => { a: 10, b: 20 }\n *\n * map({ a: 1, b: 2 }, undefined, k => k.toUpperCase())\n * // => { A: 1, B: 2 }\n *\n * map({ a: 1, b: 2 }, v => v * 10, k => k.toUpperCase())\n * // => { A: 10, B: 20 }\n * @since 2.0.0\n */\nexport function map<\n TObj extends Record<string, unknown>,\n TVal = TObj[keyof TObj],\n TKey extends PropertyKey = keyof TObj,\n>(\n obj: TObj,\n mapValue?: (value: TObj[keyof TObj], key: keyof TObj) => TVal,\n mapKey?: (key: keyof TObj, value: TObj[keyof TObj]) => TKey\n): Record<TKey, TVal> {\n const result = {} as Record<TKey, TVal>;\n for (const key of Object.keys(obj) as (keyof TObj)[]) {\n const value = obj[key];\n const newKey = mapKey ? mapKey(key, value) : (key as unknown as TKey);\n const newVal = mapValue ? mapValue(value, key) : (value as unknown as TVal);\n result[newKey] = newVal;\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Creates a new object without the specified keys.\n * @param obj - The source object\n * @param keys - The keys to omit\n * @returns A new object without the omitted keys\n * @example\n * omit({ a: 1, b: 2, c: 3 }, ['b'])\n * // => { a: 1, c: 3 }\n * @since 2.0.0\n */\nexport function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K>;\nexport function omit(obj: undefined, keys: readonly string[]): undefined;\nexport function omit(obj: null, keys: readonly string[]): null;\nexport function omit<T extends Record<string, unknown>, K extends keyof T>(\n obj: T | undefined | null,\n keys: readonly K[]\n): Omit<T, K> | undefined | null {\n if (obj === undefined || obj === null) return obj;\n const result = { ...obj };\n for (const key of keys) {\n delete result[key];\n }\n return result as Omit<T, K>;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Creates a new object with only the specified keys.\n * @param obj - The source object\n * @param keys - The keys to pick\n * @returns A new object with only the picked keys\n * @example\n * pick({ a: 1, b: 2, c: 3 }, ['a', 'c'])\n * // => { a: 1, c: 3 }\n * @since 2.0.0\n */\nexport function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K>;\nexport function pick(obj: undefined, keys: readonly string[]): undefined;\nexport function pick(obj: null, keys: readonly string[]): null;\nexport function pick<T extends Record<string, unknown>, K extends keyof T>(\n obj: T | undefined | null,\n keys: readonly K[]\n): Pick<T, K> | undefined | null {\n if (obj === undefined || obj === null) return obj;\n const result = {} as Pick<T, K>;\n for (const key of keys) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n result[key] = obj[key];\n }\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if a value is null or undefined (nullish).\n * @param value - The value to check\n * @returns True if value is null or undefined\n * @example\n * isNullish(null) // => true\n * isNullish(undefined) // => true\n * isNullish(0) // => false\n * isNullish('') // => false\n *\n * @see {@link isDefined} for the inverse check (`!isNullish`)\n * @see {@link isFalsy} to also catch `0`, `\"\"`, `false`, and `NaN`\n * @since 2.0.0\n */\nexport function isNullish(value: unknown): value is null | undefined {\n return value === null || value === undefined;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { isNullish } from '../type/isNullish';\n\n/**\n * Remove null and undefined values from an object.\n *\n * @param obj an object\n * @returns A shallow copy of the object without null or undefined values\n * @since 1.0.0\n */\nexport function removeUndefinedNull<T extends Record<string, string | number | boolean | null | undefined>>(obj: T): Partial<T>;\n\n/**\n * Remove null and undefined values from an object.\n *\n * @param obj a null object\n * @returns null\n * @since 1.0.0\n */\nexport function removeUndefinedNull(obj: null): null;\n\n/**\n * Remove null and undefined values from an object.\n *\n * @param obj an undefined object\n * @returns undefined\n * @since 1.0.0\n */\nexport function removeUndefinedNull(obj: undefined): undefined;\n\n/**\n * Remove null and undefined values from an object.\n *\n * @param obj an object\n * @returns A shallow copy of the object without null or undefined values\n * @since 1.0.0\n */\nexport function removeUndefinedNull<T extends Record<string, string | number | boolean | null | undefined>>(obj: T | null | undefined): Partial<T> | null | undefined {\n if (!obj) return obj;\n const result: Record<string, unknown> = {};\n for (const [k, v] of Object.entries(obj)) {\n if (!isNullish(v)) { result[k] = v; }\n }\n return result as Partial<T>;\n}\n\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Parses a JSON string, returning `null` (or a fallback) on any parse failure.\n *\n * Unlike `JSON.parse`, this never throws. Invalid JSON strings and other\n * parsing edge-cases resolve to `null` or the provided `fallback`.\n *\n * @param input - The JSON string to parse.\n * @param fallback - Value returned on failure. Defaults to `null` when omitted.\n * @returns The parsed value typed as `T`, or `fallback` on failure.\n * @example\n * safeJsonParse<{ a: number }>('{\"a\":1}') // => { a: 1 }\n * safeJsonParse('invalid') // => null\n * safeJsonParse('invalid', []) // => []\n * @since 2.0.0\n */\nexport function safeJsonParse<T>(input: string): T | null;\nexport function safeJsonParse<T>(input: string, fallback: T): T;\nexport function safeJsonParse<T>(input: string, fallback?: T): T | null {\n try {\n return JSON.parse(input) as T;\n } catch {\n // Distinguish \"no fallback provided\" (→ null) from \"fallback is undefined\"\n // (→ undefined as T) to keep runtime behaviour aligned with the overloads.\n return arguments.length < 2 ? null : (fallback as T);\n }\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { parsePath } from './_parsePath.js';\nimport type { DeepGet, DeepSet } from './_types.js';\nimport { UNSAFE_KEYS } from './_unsafeKeys.js';\n\n/**\n * Sets a value in an object at the given path, creating intermediate objects as needed.\n *\n * **Three path forms are supported:**\n *\n * 1. **Dot notation** (`string`) — segments split on `.` are kept as-is string keys.\n * `\"layers.1.name\"` → keys `[\"layers\", \"1\", \"name\"]` (all strings, including `\"1\"`).\n *\n * 2. **Bracket notation** (`string`) — `[n]` segments are parsed as numeric keys.\n * `\"layers[1].name\"` → keys `[\"layers\", 1, \"name\"]` (index `1` becomes a number).\n * Dot and bracket can be mixed freely: `\"a[0].b[2].c\"`.\n *\n * 3. **Key array** (`PropertyKey[]`) — explicit array of `string | number | symbol` keys,\n * no parsing performed. Enables full key-type control, including symbols:\n * `[\"layers\", 1, Symbol('id')]`.\n *\n * Intermediate nodes that are absent, `null`, or not an object are replaced with `{}`.\n * Any path containing a string segment equal to `__proto__`, `constructor`, or `prototype`\n * is rejected and the original object is returned unchanged (prototype-pollution guard).\n *\n * @param obj - The object to mutate\n * @param path - Dot/bracket-notation string or explicit `PropertyKey[]`\n * @param value - Value to assign at the path\n * @returns The mutated object (same reference)\n * @example\n * // 1. Dot notation — \"1\" stays a string key\n * set({}, 'a.b.c', 42)\n * // => { a: { b: { c: 42 } } }\n *\n * set({}, 'layers.1.name', 'bg')\n * // => { layers: { '1': { name: 'bg' } } }\n *\n * // 2. Bracket notation — [1] becomes a number key\n * set({ layers: [{}, { name: 'old' }] }, 'layers[1].name', 'bg')\n * // => { layers: [{}, { name: 'bg' }] }\n *\n * // 3. Key array — supports symbols\n * const id = Symbol('id')\n * set({}, ['user', id], 'alice')\n * // => { user: { [id]: 'alice' } }\n * @since 1.9.0\n */\n\nexport function set(obj: Record<string, unknown>, path: string, value: unknown): Record<string, unknown>;\nexport function set<T extends object, const Path extends readonly PropertyKey[], V extends DeepGet<T, Path>>(obj: T, path: Path, value: V): DeepSet<T, Path, V>;\nexport function set(obj: object, path: string | PropertyKey[], value: unknown): object {\n const keys: readonly PropertyKey[] = typeof path === 'string' ? parsePath(path) : path;\n\n if (keys.length === 0) return obj;\n if (keys.some((k) => typeof k === 'string' && UNSAFE_KEYS.has(k))) return obj;\n\n let current = obj as Record<PropertyKey, unknown>;\n\n for (let i = 0; i < keys.length - 1; i++) {\n const key = keys[i];\n\n // Object.hasOwn (not `key in current`) is intentional: `in` checks the prototype chain,\n // which would silently traverse into — and potentially mutate — an inherited object.\n // Using hasOwn ensures we only follow own properties; inherited intermediate nodes are\n // shadowed with a fresh own `{}` instead of being followed into the prototype.\n if (!Object.hasOwn(current, key) || typeof current[key] !== 'object' || current[key] === null) {\n current[key] = {};\n }\n\n current = current[key] as Record<PropertyKey, unknown>;\n }\n\n current[keys[keys.length - 1]] = value;\n return obj;\n}\n"],"mappings":"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"}
1
+ {"version":3,"file":"index.js","names":[],"sources":["../../../helpers/_shared/_unsafeKeys.ts","../../../helpers/object/cloneDeep.ts","../../../helpers/object/compact.ts","../../../helpers/guard/isPlainObject.ts","../../../helpers/array/equalsDeep.ts","../../../helpers/date/timestamp.ts","../../../helpers/date/ensureDate.ts","../../../helpers/date/compare.ts","../../../helpers/guard/isSpecialObject.ts","../../../helpers/object/diff.ts","../../../helpers/object/equalsDeep.ts","../../../helpers/object/equalsShallow.ts","../../../helpers/object/_parsePath.ts","../../../helpers/object/get.ts","../../../helpers/object/groupBy.ts","../../../helpers/object/invert.ts","../../../helpers/object/isEmpty.ts","../../../helpers/object/isNonEmpty.ts","../../../helpers/object/map.ts","../../../helpers/object/mergeDeep.ts","../../../helpers/object/omit.ts","../../../helpers/object/pick.ts","../../../helpers/guard/isNullish.ts","../../../helpers/object/removeUndefinedNull.ts","../../../helpers/object/safeJsonParse.ts","../../../helpers/object/set.ts"],"sourcesContent":["/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Keys that must never be set on a plain object (prototype-pollution guard).\n * @ignore\n */\nconst UNSAFE_KEY_LIST = ['__proto__', 'constructor', 'prototype'] as const;\n\n/** @ignore */\nexport type UnsafeKey = (typeof UNSAFE_KEY_LIST)[number];\n\nexport const UNSAFE_KEYS = new Set<string>(UNSAFE_KEY_LIST);\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { UNSAFE_KEYS } from '../_shared/_unsafeKeys.js';\n\n/**\n * Creates a deep copy of an object or array.\n *\n * Recursively clones own enumerable string keys. `Date` instances are\n * reconstructed with the same epoch value. Prototype-polluting keys\n * (`__proto__`, `constructor`, `prototype`) are silently skipped.\n * Does **not** handle circular references.\n *\n * **Limitation:** symbol-keyed own properties are **not** copied — only string\n * keys are processed. Use `structuredClone` if symbol propagation is required.\n *\n * @param obj - The value to clone\n * @returns A deep copy of `obj`\n * @example\n * cloneDeep({ a: { b: [1, 2] } })\n * // => { a: { b: [1, 2] } } — fully independent copy\n *\n * cloneDeep(new Date('2024-01-01'))\n * // => Date with the same timestamp\n *\n * // Primitives pass through unchanged\n * cloneDeep(42) // => 42\n * cloneDeep(null) // => null\n * @since 1.9.0\n */\nexport function cloneDeep<T>(obj: T): T {\n if (obj === null || typeof obj !== 'object') {\n return obj;\n }\n\n if (obj instanceof Date) {\n return new Date(obj.getTime()) as T;\n }\n\n if (Array.isArray(obj)) {\n return obj.map(item => cloneDeep(item)) as T;\n }\n\n const cloned = {} as T;\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key) && !UNSAFE_KEYS.has(key)) {\n cloned[key] = cloneDeep(obj[key]);\n }\n }\n\n return cloned;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { UNSAFE_KEYS } from '../_shared/_unsafeKeys.js';\n\n/**\n * Removes all entries with falsy values (`false`, `null`, `undefined`, `0`, `\"\"`, `NaN`) from an object.\n * Own keys that are prototype-polluting strings (`__proto__`, `constructor`, `prototype`) are\n * silently skipped.\n * @param obj - The source object\n * @returns A new object containing only entries with truthy values\n * @example\n * compact({ a: 1, b: null, c: '', d: 0, e: 'hello' })\n * // => { a: 1, e: 'hello' }\n * @since 2.0.0\n */\nexport function compact<T extends Record<string, unknown>>(obj: T): Partial<T>;\nexport function compact(obj: undefined): undefined;\nexport function compact(obj: null): null;\nexport function compact<T extends Record<string, unknown>>(obj: T | undefined | null): Partial<T> | undefined | null {\n if (obj === undefined || obj === null) return obj;\n const result: Partial<T> = {};\n for (const key of Object.keys(obj) as (keyof T)[]) {\n if (UNSAFE_KEYS.has(key as string)) continue;\n if (obj[key]) {\n result[key] = obj[key];\n }\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if a value is a plain object.\n *\n * A plain object is created by `{}`, `new Object()`, or `Object.create(null)`.\n * Returns `false` for arrays, Date, Map, Set, RegExp, class instances, etc.\n *\n * @param value - The value to check\n * @returns True if value is a plain object\n * @example\n * isPlainObject({}) // => true\n * isPlainObject({ a: 1 }) // => true\n * isPlainObject(new Date()) // => false\n * isPlainObject([]) // => false\n * isPlainObject(null) // => false\n * @since 2.0.0\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n if (value === null || typeof value !== 'object') return false;\n const proto = Object.getPrototypeOf(value);\n return proto === Object.prototype || proto === null;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { isPlainObject } from '../guard/isPlainObject';\n\n/**\n * Recursive structural array equality.\n *\n * Two arrays are equal when they have the same length and each pair of\n * elements at the same index is structurally equal:\n * - Arrays recurse with `equalsDeep`.\n * - Plain objects recurse key-by-key with structural comparison.\n * - `Date` instances are compared by their epoch value.\n * - All other values use strict equality (`===`), which means `NaN !== NaN`\n * and special objects (Map, Set, RegExp, Promise, class instances\\u2026) are\n * compared by reference.\n *\n * For positional one-level comparison use {@link equalsShallow}. For\n * order-independent comparison use {@link equalsUnordered}.\n *\n * @param arrA - First array to compare\n * @param arrB - Second array to compare\n * @returns `true` if arrays are deeply equal, `false` otherwise.\n * @since 2.0.0\n */\nexport function equalsDeep<T>(arrA: readonly T[], arrB: readonly T[]): boolean {\n if (arrA === arrB) {\n return true;\n }\n if (!Array.isArray(arrA) || !Array.isArray(arrB)) {\n return false;\n }\n if (arrA.length !== arrB.length) {\n return false;\n }\n for (let i = 0; i < arrA.length; i++) {\n if (!valuesEqual(arrA[i], arrB[i])) {\n return false;\n }\n }\n return true;\n}\n\nfunction valuesEqual(a: unknown, b: unknown): boolean {\n if (a === b) {\n return true;\n }\n if (Array.isArray(a) && Array.isArray(b)) {\n return equalsDeep(a, b);\n }\n if (a instanceof Date && b instanceof Date) {\n return a.getTime() === b.getTime();\n }\n if (isPlainObject(a) && isPlainObject(b)) {\n const ao = a as Record<string, unknown>;\n const bo = b as Record<string, unknown>;\n const keysA = Object.keys(ao);\n if (keysA.length !== Object.keys(bo).length) {\n return false;\n }\n for (const key of keysA) {\n if (!Object.prototype.hasOwnProperty.call(bo, key)) {\n return false;\n }\n if (!valuesEqual(ao[key], bo[key])) {\n return false;\n }\n }\n return true;\n }\n return false;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { ensureDate } from './ensureDate';\nimport type { DateLike } from './types';\n\n/**\n * Checks if a timestamp is likely in seconds (Java/Unix style) vs milliseconds (JavaScript style)\n * @param timestamp - The timestamp to check\n * @returns True if timestamp appears to be in seconds\n * @since 1.9.0\n */\nexport function isTimestampInSeconds(timestamp: number): boolean {\n // Timestamps before year 2001 in milliseconds are less than 10^10\n // Use Math.abs to correctly handle negative timestamps (before epoch)\n return Math.abs(timestamp) < 10000000000;\n}\n\n/**\n * Converts a timestamp to JavaScript milliseconds format\n * @param timestamp - The timestamp (in seconds or milliseconds)\n * @returns Timestamp in milliseconds\n * @since 1.9.0\n */\nexport function normalizeTimestamp(timestamp: number): number {\n return isTimestampInSeconds(timestamp) ? timestamp * 1000 : timestamp;\n}\n\n/**\n * Converts a date to a timestamp in **seconds** (epoch seconds).\n *\n * Use this when sending a date to a backend API that expects seconds\n * (e.g. Java `Instant.getEpochSecond()`, Python `time.time()`).\n *\n * @param date - The date to convert\n * @returns Seconds since the Unix epoch, or `null` for invalid input\n * @example\n * toSeconds('2025-01-19T12:00:00Z') // => 1737288000\n * toSeconds(null) // => null\n *\n * @since 2.0.0\n */\nexport function toSeconds(date: DateLike): number | null {\n const d = ensureDate(date);\n if (!d) return null;\n return Math.floor(d.getTime() / 1000);\n}\n\n/**\n * Converts a date to a timestamp in **milliseconds** (epoch millis).\n *\n * Use this when you need a plain number from a `DateLike` value\n * (e.g. for `Date.now()` comparisons, localStorage, or JS-native APIs).\n *\n * @param date - The date to convert\n * @returns Milliseconds since the Unix epoch, or `null` for invalid input\n * @example\n * toMillis('2025-01-19T12:00:00Z') // => 1737288000000\n * toMillis(null) // => null\n *\n * @since 2.0.0\n */\nexport function toMillis(date: DateLike): number | null {\n const d = ensureDate(date);\n if (!d) return null;\n return d.getTime();\n}\n\n/**\n * Creates a `Date` from a timestamp in **seconds**.\n *\n * Use this when receiving a timestamp from a backend that sends seconds\n * (e.g. Java `Instant.getEpochSecond()`). No heuristic — the input is\n * always treated as seconds.\n *\n * @param seconds - Seconds since the Unix epoch\n * @returns A valid `Date`, or `null` for `NaN` / non-finite input\n * @example\n * fromSeconds(1737288000) // => Date('2025-01-19T12:00:00Z')\n * fromSeconds(0) // => Date('1970-01-01T00:00:00Z')\n * fromSeconds(NaN) // => null\n *\n * @since 2.0.0\n */\nexport function fromSeconds(seconds: number): Date | null {\n if (!Number.isFinite(seconds)) return null;\n return new Date(seconds * 1000);\n}\n\n/**\n * Creates a `Date` from a timestamp in **milliseconds**.\n *\n * Use this when receiving a timestamp from a JS-native source\n * (e.g. `Date.now()`, `performance.timeOrigin`). No heuristic — the\n * input is always treated as milliseconds.\n *\n * @param ms - Milliseconds since the Unix epoch\n * @returns A valid `Date`, or `null` for `NaN` / non-finite input\n * @example\n * fromMillis(1737288000000) // => Date('2025-01-19T12:00:00Z')\n * fromMillis(0) // => Date('1970-01-01T00:00:00Z')\n * fromMillis(NaN) // => null\n *\n * @since 2.0.0\n */\nexport function fromMillis(ms: number): Date | null {\n if (!Number.isFinite(ms)) return null;\n return new Date(ms);\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { normalizeTimestamp } from './timestamp';\nimport type { DateLike, EpochMilliseconds } from './types';\n\n/**\n * Type guard that checks whether a value satisfies the {@link EpochMilliseconds}\n * structural interface (e.g. `Temporal.Instant`, `Temporal.ZonedDateTime`).\n */\nfunction hasEpochMilliseconds(value: unknown): value is EpochMilliseconds {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'epochMilliseconds' in value &&\n typeof (value as EpochMilliseconds).epochMilliseconds === 'number'\n );\n}\n\n/**\n * Safely converts a date-like value to a valid `Date` object, or returns `null`.\n *\n * Accepts `Date`, timestamps (seconds or milliseconds, auto-detected), date strings,\n * and objects with an `epochMilliseconds` property (e.g. `Temporal.Instant`,\n * `Temporal.ZonedDateTime`).\n * Returns `null` for `null`, `undefined`, empty strings, `0`, and any value that\n * produces an invalid `Date`.\n *\n * This is the date equivalent of {@link ensureArray} — it normalizes flexible\n * input into a guaranteed type (or a safe fallback).\n *\n * @param input - A date-like value to convert\n * @returns A valid `Date` object, or `null` if the input is invalid\n * @example\n * ensureDate('2025-01-19T12:00:00Z') // => Date\n * ensureDate(1737290400) // => Date (from Unix seconds)\n * ensureDate(1737290400000) // => Date (from milliseconds)\n * ensureDate(new Date()) // => Date (same reference)\n * ensureDate(null) // => null\n * ensureDate('invalid') // => null\n *\n * @see {@link DateLike} for the accepted input types\n * @since 2.0.0\n */\nexport function ensureDate(input: DateLike | null | undefined): Date | null {\n if (input === null || input === undefined || input === '' || input === 0) {\n return null;\n }\n\n if (input instanceof Date) {\n return isNaN(input.getTime()) ? null : input;\n }\n\n if (hasEpochMilliseconds(input)) {\n const date = new Date(input.epochMilliseconds);\n return isNaN(date.getTime()) ? null : date;\n }\n\n if (typeof input === 'number') {\n const normalized = normalizeTimestamp(input);\n const date = new Date(normalized);\n return isNaN(date.getTime()) ? null : date;\n }\n\n if (typeof input === 'string') {\n const date = new Date(input);\n return isNaN(date.getTime()) ? null : date;\n }\n\n return null;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { ensureDate } from './ensureDate';\nimport type { DateLike } from './types';\n\n/**\n * Options for date comparison\n * @since 2.0.0\n */\nexport interface DateCompareOptions {\n /**\n * Comparison precision\n * - 'milliseconds': Compare all including milliseconds (default)\n * - 'seconds': Ignore milliseconds, compare to the second\n * - 'minutes': Ignore seconds and milliseconds, compare to the minute\n * - 'hours': Ignore minutes, seconds and milliseconds, compare to the hour\n * - 'days': Compare only the date part (ignore time completely)\n * - 'months': Compare only year and month\n * - 'years': Compare only year\n */\n precision?: 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'months' | 'years';\n}\n\n/**\n * Comparison of two dates.\n *\n * Accepts any {@link DateLike} input (Date, timestamp, or date string).\n *\n * @param dateA - First date to compare\n * @param dateB - Second date to compare\n * @param options - Comparison options\n * @returns `true` if dates are identical according to the specified precision, `false` otherwise\n * @example\n * compare('2025-01-19', new Date('2025-01-19T08:00:00Z'), { precision: 'days' })\n * // => true\n * @since 2.0.0\n */\nexport function compare(dateA: DateLike, dateB: DateLike, options: DateCompareOptions = {}): boolean {\n const { precision = 'milliseconds' } = options;\n\n const a = ensureDate(dateA);\n const b = ensureDate(dateB);\n\n // Any invalid → not equal\n if (a === null || b === null) {\n return false;\n }\n\n switch (precision) {\n case 'years':\n return a.getFullYear() === b.getFullYear();\n\n case 'months':\n return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth();\n\n case 'days':\n return a.toDateString() === b.toDateString();\n\n case 'hours': {\n const hoursA = Math.floor(a.getTime() / (1000 * 60 * 60));\n const hoursB = Math.floor(b.getTime() / (1000 * 60 * 60));\n return hoursA === hoursB;\n }\n\n case 'minutes': {\n const minutesA = Math.floor(a.getTime() / (1000 * 60));\n const minutesB = Math.floor(b.getTime() / (1000 * 60));\n return minutesA === minutesB;\n }\n\n case 'seconds': {\n const secondsA = Math.floor(a.getTime() / 1000);\n const secondsB = Math.floor(b.getTime() / 1000);\n return secondsA === secondsB;\n }\n\n case 'milliseconds':\n default:\n return a.getTime() === b.getTime();\n }\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Determines if a value is a special object that should not have its properties compared deeply.\n * Special objects include: Date, Function, Promise, Observable, RegExp, Error, Map, Set, WeakMap, WeakSet, etc.\n * \n * @param value - The value to check\n * @returns `true` if the value is a special object, `false` otherwise\n * @since 2.0.0\n */\nexport function isSpecialObject(value: unknown): boolean {\n if (value === null || value === undefined) {\n return false;\n }\n\n // Functions are special objects\n if (typeof value === 'function') {\n return true;\n }\n\n // Non-objects are not special\n if (typeof value !== 'object') {\n return false;\n }\n\n // Arrays are not considered special objects for our purposes\n if (Array.isArray(value)) {\n return false;\n }\n\n // Check for built-in special objects\n if (\n value instanceof Date ||\n value instanceof Promise ||\n value instanceof RegExp ||\n value instanceof Error ||\n value instanceof Map ||\n value instanceof Set ||\n value instanceof WeakMap ||\n value instanceof WeakSet ||\n value instanceof ArrayBuffer ||\n value instanceof DataView\n ) {\n return true;\n }\n\n // Check for Observable (RxJS or similar)\n if (value.constructor?.name === 'Observable') {\n return true;\n }\n\n // Check for DOM elements (if in browser environment)\n if (typeof HTMLElement !== 'undefined' && value instanceof HTMLElement) {\n return true;\n }\n\n // Check for other built-in types by constructor name\n const constructorName = value.constructor?.name;\n if (constructorName && [\n 'Buffer', // Node.js Buffer\n 'URL', // Web URL API\n 'URLSearchParams',\n 'File', // Web File API\n 'Blob', // Web Blob API\n 'FormData', // Web FormData API\n 'Headers', // Web Headers API\n 'Request', // Web Request API\n 'Response', // Web Response API\n 'EventTarget', // Web EventTarget API\n 'Symbol' // Symbol objects\n ].includes(constructorName)) {\n return true;\n }\n\n return false;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { equalsDeep as arrayDeepEquals } from '../array/equalsDeep';\nimport { compare as compareDate } from '../date/compare';\nimport { isSpecialObject } from '../guard/isSpecialObject';\n\n/**\n * Per-key diff result. Each entry tells what differs between the two\n * objects:\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.\n *\n * @since 2.0.0\n */\nexport interface DiffResult {\n [key: string]: 'onlyA' | 'onlyB' | false | DiffResult;\n}\n\n/**\n * Options for {@link diff}.\n * @since 2.0.0\n */\nexport interface DiffOptions {\n /**\n * Maximum recursion depth for nested plain objects. Defaults to\n * `Infinity` (full structural diff).\n *\n * - `0` compares values at the top-level only with strict equality.\n * - `1` compares the first level of nested objects with strict equality.\n * - `Infinity` recurses through every plain-object level.\n *\n * Arrays, `Date` and special objects (Map, Set, RegExp\\u2026) are always\n * leaf-compared (via {@link arrayDeepEquals}, epoch comparison, or\n * reference equality respectively) regardless of `depth`.\n */\n depth?: number;\n}\n\n/**\n * Structural object diff.\n *\n * Returns `true` when both inputs are deeply equal, otherwise a\n * {@link DiffResult} describing the differences key by key.\n *\n * Comparison 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 *\n * For a boolean wrapper see {@link equalsDeep} from this category.\n * For a one-level boolean check see {@link equalsShallow} from this category.\n *\n * @param objA - First value (object, `null`, or `undefined`).\n * @param objB - Second value (object, `null`, or `undefined`).\n * @param options - See {@link DiffOptions}.\n * @returns `true` when equal, otherwise a {@link DiffResult}, or `false` for incompatible types.\n * @since 2.0.0\n */\nexport function diff(\n objA: object | undefined | null,\n objB: object | undefined | null,\n options: DiffOptions = {},\n): true | false | DiffResult {\n const depth = options.depth ?? Infinity;\n\n // Quick reference equality check\n if (objA === objB) {\n return true;\n }\n\n // Handle null/undefined cases\n if (objA == null || objB == null) {\n return false;\n }\n\n // Handle Date objects\n if (objA instanceof Date && objB instanceof Date) {\n return compareDate(objA, objB);\n }\n\n // Handle Arrays at root level\n if (Array.isArray(objA) && Array.isArray(objB)) {\n return arrayDeepEquals(objA, objB);\n }\n if (Array.isArray(objA) || Array.isArray(objB)) {\n return false;\n }\n\n // Handle special objects - compare by reference only\n if (isSpecialObject(objA) || isSpecialObject(objB)) {\n return objA === objB;\n }\n\n // Plain object detailed comparison\n return diffPlainObjects(objA, objB, depth);\n}\n\nfunction diffPlainObjects(\n objA: object,\n objB: object,\n depth: number,\n): true | DiffResult {\n const keys = Array.from(new Set([...Object.keys(objA), ...Object.keys(objB)]));\n const differences: DiffResult = Object.create(null) as DiffResult;\n\n for (const key of keys) {\n const hasA = Object.prototype.hasOwnProperty.call(objA, key);\n const hasB = Object.prototype.hasOwnProperty.call(objB, key);\n\n if (!hasA && hasB) {\n differences[key] = 'onlyB';\n continue;\n }\n if (hasA && !hasB) {\n differences[key] = 'onlyA';\n continue;\n }\n\n const valueA = (objA as Record<string, unknown>)[key];\n const valueB = (objB as Record<string, unknown>)[key];\n\n if (valueA === valueB) {\n continue;\n }\n\n if (Array.isArray(valueA) && Array.isArray(valueB)) {\n if (!arrayDeepEquals(valueA, valueB)) {\n differences[key] = false;\n }\n continue;\n }\n if (Array.isArray(valueA) || Array.isArray(valueB)) {\n differences[key] = false;\n continue;\n }\n\n if (valueA instanceof Date && valueB instanceof Date) {\n if (!compareDate(valueA, valueB)) {\n differences[key] = false;\n }\n continue;\n }\n if (valueA instanceof Date || valueB instanceof Date) {\n differences[key] = false;\n continue;\n }\n\n if (isSpecialObject(valueA) || isSpecialObject(valueB)) {\n // valueA === valueB already handled above, so any special-object pair\n // that reaches here must differ.\n differences[key] = false;\n continue;\n }\n\n const bothPlainObjects =\n valueA !== null && valueB !== null &&\n typeof valueA === 'object' && typeof valueB === 'object';\n\n if (!bothPlainObjects) {\n differences[key] = false;\n continue;\n }\n\n if (depth <= 0) {\n // depth budget exhausted \\u2192 strict-equal nested objects only match by reference\n differences[key] = false;\n continue;\n }\n\n const nested = diffPlainObjects(valueA as object, valueB as object, depth - 1);\n if (nested !== true) {\n differences[key] = nested;\n }\n }\n\n return Object.keys(differences).length > 0 ? differences : true;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { diff } from './diff';\n\n/**\n * Recursive structural object equality.\n *\n * Boolean wrapper around {@link diff} \\u2014 returns `true` when the two values\n * are deeply equal according to the same rules. Use this when you only\n * need a yes/no answer; use {@link diff} when you also need to know\n * *what* differs.\n *\n * For a one-level boolean check use {@link equalsShallow}.\n *\n * @param objA - First value (object, `null`, or `undefined`).\n * @param objB - Second value (object, `null`, or `undefined`).\n * @returns `true` if both inputs are deeply equal, `false` otherwise.\n * @since 2.0.0\n */\nexport function equalsDeep(\n objA: object | undefined | null,\n objB: object | undefined | null,\n): boolean {\n return diff(objA, objB) === true;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * One-level (shallow) object equality.\n *\n * Two objects are equal when they share the exact same set of own\n * enumerable string keys and each pair of values satisfies strict equality\n * (`===`). No recursion: nested objects/arrays are compared by reference.\n *\n * Falls back to strict equality when either input is `null`, `undefined`\n * or not an object \\u2014 so primitives match if and only if they are `===`.\n * Arrays are not supported; they always return `false` (unless identical\n * references). Use `array/equalsShallow` instead.\n *\n * For recursive structural comparison use {@link equalsDeep}. For a diff\n * structure use {@link diff}.\n *\n * @param objA - First value to compare\n * @param objB - Second value to compare\n * @returns `true` if values are shallowly equal, `false` otherwise.\n * @since 2.0.0\n */\nexport function equalsShallow(objA: unknown, objB: unknown): boolean {\n if (objA === objB) {\n return true;\n }\n if (\n objA === null || objB === null ||\n typeof objA !== 'object' || typeof objB !== 'object'\n ) {\n return false;\n }\n const a = objA as Record<string, unknown>;\n const b = objB as Record<string, unknown>;\n if (Array.isArray(objA) || Array.isArray(objB)) {\n return false;\n }\n const keysA = Object.keys(a);\n if (keysA.length !== Object.keys(b).length) {\n return false;\n }\n for (const key of keysA) {\n if (!Object.prototype.hasOwnProperty.call(b, key) || a[key] !== b[key]) {\n return false;\n }\n }\n return true;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Parses a string path into an array of string/number segments.\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 bare `.`) returns `['']` (addresses the `''` key on the root object).\n * - Consecutive dots (`a..b`) produce an empty-string segment: `['a', '', 'b']`.\n * - Non-bracket text trailing a `]` within the same dot-segment throws a RangeError;\n * use a dot separator instead (`'a[0].b'` not `'a[0]b'`).\n *\n * @ignore\n * @example\n * parsePath('a.b.c') // => ['a', 'b', 'c'] (all strings)\n * parsePath('layers.1.x') // => ['layers', '1', 'x'] (all strings)\n * parsePath('layers[1].x') // => ['layers', 1, 'x'] (bracket → number)\n * parsePath('.[0]') // => [0] (leading dot stripped)\n * parsePath('a..b') // => ['a', '', 'b'] (empty segment preserved)\n * parsePath('.') // => [''] (leading dot → empty-string key)\n */\n// `g` flag: stateful — callers must reset lastIndex before each use.\nconst BRACKET = /\\[(\\d+)\\]/g;\n\n// Module-level cache: most call sites use a fixed set of string paths (e.g. sort keys),\n// so parsing the same path string repeatedly on every get()/set() call is pure waste.\nconst parsePathCache = new Map<string, readonly (string | number)[]>();\n\nexport function parsePath(path: string): readonly (string | number)[] {\n const cached = parsePathCache.get(path);\n if (cached !== undefined) return cached;\n\n const result = Object.freeze(parsePathUncached(path));\n parsePathCache.set(path, result);\n return result;\n}\n\nfunction parsePathUncached(path: string): (string | number)[] {\n if (path === '') return [''];\n if (path[0] === '.') path = path.slice(1);\n if (path === '') return [''];\n const result: (string | number)[] = [];\n // Split on `.` first so consecutive dots produce empty segments, then parse `[n]` within each.\n for (const dotSegment of path.split('.')) {\n BRACKET.lastIndex = 0;\n let last = 0;\n let match: RegExpExecArray | null;\n while ((match = BRACKET.exec(dotSegment)) !== null) {\n // String prefix before this [n] — omit only when the segment starts with '['.\n if (match.index > last) result.push(dotSegment.slice(last, match.index));\n result.push(parseInt(match[1], 10));\n last = BRACKET.lastIndex;\n }\n if (last === 0) {\n // No brackets found — push the whole dot-segment as a string key.\n result.push(dotSegment);\n } else if (last < dotSegment.length) {\n // Trailing non-bracket text after the last ']' (e.g. 'a[0]b') — ambiguous and\n // almost always a mistake. Throw rather than silently drop 'b'.\n throw new RangeError(\n `parsePath: non-bracket text '${dotSegment.slice(last)}' after ']' in segment '${dotSegment}' — use 'a[0].b' instead of 'a[0]b'`,\n );\n }\n // last === dotSegment.length: segment ended right after the last ']', nothing to push.\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { parsePath } from './_parsePath.js';\nimport type { DeepGet, ParsePath } from './_types.js';\n\n/**\n * Gets a value from an object using a dot/bracket-notated path or explicit key array.\n *\n * **Two path forms are supported:**\n *\n * 1. **String path** — dot notation (`'a.b.c'`) and bracket notation (`'layers[1].name'`)\n * are both accepted and mixed freely.\n * - Dot segments are always string keys: `'a.1'` → key `'1'` (string).\n * - Bracket segments are always number keys: `'a[1]'` → key `1` (number).\n * - String literal paths give **full compile-time type inference** on the return type.\n * - Dynamic (non-literal) strings return `unknown`.\n *\n * 2. **Key array** (`PropertyKey[]`) — explicit array of `string | number | symbol` keys,\n * no parsing performed. Enables symbol-keyed traversal and compile-time type inference:\n * `get(obj, ['a', 'b'] as const)` infers the return type from the path.\n *\n * Both forms support **all objects** (plain objects, arrays, class instances).\n * Symbol keys are only reachable via the key-array form.\n *\n * @param obj - The object to read from\n * @param path - Dot/bracket-notation string literal or explicit `PropertyKey[]`\n * @param defaultValue - Returned when the path is absent or resolves to `undefined`\n * @returns The value at the path, or `defaultValue`\n * @example\n * get({ a: { b: { c: 42 } } }, 'a.b.c') // => 42 (inferred: number | undefined)\n * get({ layers: [{ name: 'bg' }] }, 'layers[0].name') // => 'bg' (inferred: string | undefined)\n * get({ a: { b: 0 } }, 'a.b', 99) // => 0 (falsy values returned as-is)\n * get({ a: 1 }, 'b.c', 'default') // => 'default'\n *\n * const id = Symbol('id')\n * get({ [id]: 'alice' }, [id]) // => 'alice' (symbol key, inferred: string | undefined)\n * @since 1.9.0\n */\nexport function get<D>(obj: null | undefined, path: string | readonly PropertyKey[], defaultValue: D): D;\nexport function get(obj: null | undefined, path: string | readonly PropertyKey[]): undefined;\nexport function get<T extends object, const P extends string | readonly PropertyKey[]>(\n obj: T | null | undefined,\n path: P,\n defaultValue?: DeepGet<T, ParsePath<P>>,\n): DeepGet<T, ParsePath<P>> | undefined;\nexport function get(obj: unknown, path: string | readonly PropertyKey[], defaultValue?: unknown): unknown {\n if (obj == null) return defaultValue;\n const keys: readonly PropertyKey[] = typeof path === 'string' ? parsePath(path) : path;\n let result: unknown = obj;\n\n for (const key of keys) {\n if (result == null || typeof result !== 'object') {\n return defaultValue;\n }\n result = (result as Record<PropertyKey, unknown>)[key];\n }\n\n return result !== undefined ? result : defaultValue;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { UNSAFE_KEYS } from '../_shared/_unsafeKeys.js';\n\n/**\n * Groups an array of items by a key derived from each item.\n *\n * A thin, typed wrapper around `Object.groupBy` (ES2024) that works on\n * older targets and provides stricter return-type inference.\n * `null` and `undefined` are treated as empty arrays and return `{}`.\n * Items whose computed key is a prototype-polluting string (`__proto__`,\n * `constructor`, `prototype`) are silently skipped.\n *\n * @param items - The array to group\n * @param keyFn - Function that returns the group key for each item\n * @returns A record mapping each key to the array of items with that key\n * @example\n * groupBy([1, 2, 3, 4], n => n % 2 === 0 ? 'even' : 'odd')\n * // => { odd: [1, 3], even: [2, 4] }\n * groupBy(null, n => n % 2 === 0 ? 'even' : 'odd')\n * // => {}\n * @since 2.0.0\n */\nexport function groupBy<T, K extends PropertyKey>(\n items: readonly T[] | null | undefined,\n keyFn: (item: T) => K\n): Partial<Record<K, T[]>> {\n const result = {} as Partial<Record<K, T[]>>;\n if (items == null) return result;\n for (const item of items) {\n const key = keyFn(item);\n if (typeof key === 'string' && UNSAFE_KEYS.has(key)) continue;\n if (result[key] === undefined) {\n result[key] = [];\n }\n (result[key] as T[]).push(item);\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { UNSAFE_KEYS } from '../_shared/_unsafeKeys.js';\n\n/**\n * Returns a new object with keys and values swapped.\n * If multiple keys share the same value, the last one wins.\n * `null` and `undefined` are treated as empty objects and return `{}`.\n * Entries whose source key **or** value is a prototype-polluting string\n * (`__proto__`, `constructor`, `prototype`) are silently skipped.\n *\n * @param obj - The object whose keys and values are to be swapped\n * @returns A new object with values as keys and original keys as values\n * @example\n * invert({ a: 'x', b: 'y', c: 'z' })\n * // => { x: 'a', y: 'b', z: 'c' }\n *\n * invert({ one: 1, two: 2 })\n * // => { 1: 'one', 2: 'two' }\n *\n * invert(null)\n * // => {}\n * @since 2.0.0\n */\nexport function invert<K extends string, V extends PropertyKey>(obj: Record<K, V> | null | undefined): Record<V, K> {\n const result = {} as Record<V, K>;\n if (obj == null) return result;\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key) && !UNSAFE_KEYS.has(key)) {\n const val = obj[key as K];\n if (typeof val === 'string' && UNSAFE_KEYS.has(val)) continue;\n result[val] = key as unknown as K;\n }\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if a plain object has no own enumerable string-keyed properties.\n * `null` and `undefined` are treated as empty objects and return `true`.\n *\n * Symbol-keyed properties are not counted. Use `Object.getOwnPropertySymbols`\n * separately if symbol keys matter for your use case.\n *\n * @param value - The object to check\n * @returns `true` if the object has no own enumerable string-keyed properties, or if `value` is `null`/`undefined`\n * @example\n * isEmpty({}) // => true\n * isEmpty(null) // => true\n * isEmpty(undefined) // => true\n * isEmpty({ a: 1 }) // => false\n * isEmpty({ a: undefined }) // => false (key exists)\n * @since 2.0.3\n */\nexport function isEmpty(value: Record<PropertyKey, unknown> | null | undefined): boolean {\n return value == null || Object.keys(value).length === 0;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if a plain object has at least one own enumerable string-keyed property.\n * `null` and `undefined` are treated as empty objects and return `false`.\n *\n * Symbol-keyed properties are not counted. Use `Object.getOwnPropertySymbols`\n * separately if symbol keys matter for your use case.\n *\n * @param value - The object to check\n * @returns `true` if the object has at least one own enumerable string-keyed property; `false` for empty, `null`, or `undefined`.\n * Acts as a type guard: the `if` branch narrows `Record<PropertyKey, unknown> | null | undefined` to `Record<PropertyKey, unknown>`.\n * @example\n * isNonEmpty({ a: 1 }) // => true\n * isNonEmpty({}) // => false\n * isNonEmpty(null) // => false\n * isNonEmpty(undefined) // => false\n * @since 2.0.3\n */\nexport function isNonEmpty(value: Record<PropertyKey, unknown> | null | undefined): value is Record<PropertyKey, unknown> {\n return value != null && Object.keys(value).length > 0;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { UNSAFE_KEYS } from '../_shared/_unsafeKeys.js';\n\n/**\n * Transforms the values and/or keys of a plain object in a single pass.\n *\n * Both callbacks are optional and default to identity (no transformation).\n * When `mapValue` is omitted the original values are preserved;\n * when `mapKey` is omitted the original keys are preserved.\n *\n * Note: if two different keys map to the same output key the last one wins\n * (insertion order). Entries whose mapped key is a prototype-polluting string\n * (`__proto__`, `constructor`, `prototype`) are silently skipped.\n *\n * @param obj - The source object\n * @param mapValue - Callback called with `(value, key)` for each entry.\n * Defaults to identity.\n * @param mapKey - Callback called with `(key, value)` for each entry.\n * Defaults to identity.\n * @returns A new object with transformed keys and/or values\n * @example\n * map({ a: 1, b: 2 }, v => v * 10)\n * // => { a: 10, b: 20 }\n *\n * map({ a: 1, b: 2 }, undefined, k => k.toUpperCase())\n * // => { A: 1, B: 2 }\n *\n * map({ a: 1, b: 2 }, v => v * 10, k => k.toUpperCase())\n * // => { A: 10, B: 20 }\n * @since 2.0.0\n */\nexport function map<\n TObj extends Record<string, unknown>,\n TVal = TObj[keyof TObj],\n TKey extends PropertyKey = keyof TObj,\n>(\n obj: TObj | null | undefined,\n mapValue?: (value: TObj[keyof TObj], key: keyof TObj) => TVal,\n mapKey?: (key: keyof TObj, value: TObj[keyof TObj]) => TKey\n): Record<TKey, TVal> {\n const result = {} as Record<TKey, TVal>;\n if (obj == null) return result;\n for (const key of Object.keys(obj) as (keyof TObj)[]) {\n const value = obj[key];\n const newKey = mapKey ? mapKey(key, value) : (key as unknown as TKey);\n if (typeof newKey === 'string' && UNSAFE_KEYS.has(newKey)) continue;\n const newVal = mapValue ? mapValue(value, key) : (value as unknown as TVal);\n result[newKey] = newVal;\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { cloneDeep } from './cloneDeep.js';\nimport { isPlainObject } from '../guard/isPlainObject';\nimport type { MergeResult } from './_types.js';\nimport { UNSAFE_KEYS } from '../_shared/_unsafeKeys.js';\n\nfunction applyKey(\n result: Record<PropertyKey, unknown>,\n source: Record<PropertyKey, unknown>,\n key: PropertyKey,\n): void {\n const resultValue = result[key];\n const sourceValue = source[key];\n if (isPlainObject(resultValue) && isPlainObject(sourceValue)) {\n result[key] = mergeDeep(\n resultValue as Record<PropertyKey, unknown>,\n sourceValue as Record<PropertyKey, unknown>,\n );\n } else if (sourceValue !== undefined) {\n result[key] = (isPlainObject(sourceValue) || Array.isArray(sourceValue))\n ? cloneDeep(sourceValue)\n : sourceValue;\n }\n}\n\nfunction applySource(\n result: Record<PropertyKey, unknown>,\n source: Record<PropertyKey, unknown>,\n): void {\n for (const key in source) {\n if (!Object.hasOwn(source, key) || UNSAFE_KEYS.has(key)) continue;\n applyKey(result, source, key);\n }\n for (const sym of Object.getOwnPropertySymbols(source)) {\n if (!Object.prototype.propertyIsEnumerable.call(source, sym)) continue;\n applyKey(result, source, sym);\n }\n}\n\n/**\n * Merges two or more objects deeply, returning a **new** object without mutating any input.\n *\n * Sources are applied left to right. For each key:\n * - If both sides are plain objects → merged recursively into a new object.\n * - Otherwise → **later source wins** (the earlier value is overwritten).\n * - `undefined` in a source **never overwrites** an existing value.\n * - `null` in a source **does overwrite** and prevents a later source from\n * deep-merging into that key: `mergeDeep({ a: { x: 1 } }, { a: null }, { a: { y: 2 } })`\n * → `{ a: { y: 2 } }` — `x: 1` is permanently lost.\n * - Arrays, class instances, and all non-plain-object values are **replaced**, not merged.\n *\n * Own enumerable string and symbol keys of each source are processed at the top level;\n * inherited and non-enumerable properties are skipped. Prototype-polluting keys\n * (`__proto__`, `constructor`, `prototype`) are silently ignored.\n * **Note:** symbol keys inside nested plain-object values are not preserved — they are\n * lost when those values are deep-cloned. Only top-level symbol keys survive.\n *\n * **TypeScript return type — intersection semantics**\n *\n * The return type is `A & B & C …` (intersection of all source types). This is accurate\n * when keys are disjoint or share the same type:\n * ```ts\n * mergeDeep({ a: 1 }, { b: 'x' }) // { a: number } & { b: string } ✓\n * mergeDeep({ a: { b: 1 } }, { a: { c: 2 } }) // { a: { b: number } & { c: number } } ✓\n * ```\n * When the same key carries **incompatible types** across sources, the intersection\n * resolves to `never` for that key — TypeScript surfaces the conflict rather than\n * silently picking a type:\n * ```ts\n * mergeDeep({ a: 1 }, { a: 'x' }) // { a: never } ← type conflict detected\n * ```\n * At runtime the later source always wins (`'x'`), but the `never` type signals that\n * the caller should align their source types. If intentional, cast the result.\n *\n * @param sources - Two or more objects to merge (none are mutated)\n * @returns A new object that is the deep merge of all sources\n * @example\n * mergeDeep({ a: 1, b: { c: 2 } }, { b: { d: 3 }, e: 4 })\n * // => { a: 1, b: { c: 2, d: 3 }, e: 4 }\n *\n * // Later source wins for non-object values\n * mergeDeep({ a: 1, arr: [1, 2] }, { a: 2, arr: [3] })\n * // => { a: 2, arr: [3] }\n *\n * // undefined never overwrites\n * mergeDeep({ a: 1 }, { a: undefined })\n * // => { a: 1 }\n *\n * // Three sources, left to right\n * mergeDeep({ x: 1 }, { y: 2 }, { x: 99, z: 3 })\n * // => { x: 99, y: 2, z: 3 }\n * @since 1.9.0\n */\nexport function mergeDeep<T extends [object, ...object[]]>(...sources: [...T]): MergeResult<T>;\nexport function mergeDeep(...sources: object[]): object {\n const result: Record<PropertyKey, unknown> = {};\n for (const source of sources) {\n if (source !== null && source !== undefined) {\n applySource(result, source as Record<PropertyKey, unknown>);\n }\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Creates a new object without the specified keys.\n * @param obj - The source object\n * @param keys - The keys to omit\n * @returns A new object without the omitted keys\n * @example\n * omit({ a: 1, b: 2, c: 3 }, ['b'])\n * // => { a: 1, c: 3 }\n * @since 2.0.0\n */\nexport function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K>;\nexport function omit(obj: undefined, keys: readonly string[]): undefined;\nexport function omit(obj: null, keys: readonly string[]): null;\nexport function omit<T extends Record<string, unknown>, K extends keyof T>(\n obj: T | undefined | null,\n keys: readonly K[]\n): Omit<T, K> | undefined | null {\n if (obj === undefined || obj === null) return obj;\n const result = { ...obj };\n for (const key of keys) {\n delete result[key];\n }\n return result as Omit<T, K>;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { UNSAFE_KEYS } from '../_shared/_unsafeKeys.js';\n\n/**\n * Creates a new object with only the specified keys.\n * Keys that are prototype-polluting strings (`__proto__`, `constructor`, `prototype`) are\n * silently skipped.\n * @param obj - The source object\n * @param keys - The keys to pick\n * @returns A new object with only the picked keys\n * @example\n * pick({ a: 1, b: 2, c: 3 }, ['a', 'c'])\n * // => { a: 1, c: 3 }\n * @since 2.0.0\n */\nexport function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K>;\nexport function pick(obj: undefined, keys: readonly string[]): undefined;\nexport function pick(obj: null, keys: readonly string[]): null;\nexport function pick<T extends Record<string, unknown>, K extends keyof T>(\n obj: T | undefined | null,\n keys: readonly K[]\n): Pick<T, K> | undefined | null {\n if (obj === undefined || obj === null) return obj;\n const result = {} as Pick<T, K>;\n for (const key of keys) {\n if (typeof key === 'string' && UNSAFE_KEYS.has(key)) continue;\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n result[key] = obj[key];\n }\n }\n return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if a value is null or undefined (nullish).\n * @param value - The value to check\n * @returns True if value is null or undefined\n * @example\n * isNullish(null) // => true\n * isNullish(undefined) // => true\n * isNullish(0) // => false\n * isNullish('') // => false\n *\n * @see {@link isDefined} for the inverse check (`!isNullish`)\n * @see {@link isFalsy} to also catch `0`, `\"\"`, `false`, and `NaN`\n * @since 2.0.0\n */\nexport function isNullish(value: unknown): value is null | undefined {\n return value === null || value === undefined;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { isNullish } from '../guard/isNullish';\n\n/**\n * Remove null and undefined values from an object.\n *\n * @param obj an object\n * @returns A shallow copy of the object without null or undefined values\n * @since 1.0.0\n */\nexport function removeUndefinedNull<T extends Record<string, string | number | boolean | null | undefined>>(obj: T): Partial<T>;\n\n/**\n * Remove null and undefined values from an object.\n *\n * @param obj a null object\n * @returns null\n * @since 1.0.0\n */\nexport function removeUndefinedNull(obj: null): null;\n\n/**\n * Remove null and undefined values from an object.\n *\n * @param obj an undefined object\n * @returns undefined\n * @since 1.0.0\n */\nexport function removeUndefinedNull(obj: undefined): undefined;\n\n/**\n * Remove null and undefined values from an object.\n *\n * @param obj an object\n * @returns A shallow copy of the object without null or undefined values\n * @since 1.0.0\n */\nexport function removeUndefinedNull<T extends Record<string, string | number | boolean | null | undefined>>(obj: T | null | undefined): Partial<T> | null | undefined {\n if (!obj) return obj;\n const result: Record<string, unknown> = {};\n for (const [k, v] of Object.entries(obj)) {\n if (!isNullish(v)) { result[k] = v; }\n }\n return result as Partial<T>;\n}\n\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Parses a JSON string, returning `null` (or a fallback) on any parse failure.\n *\n * Unlike `JSON.parse`, this never throws. Invalid JSON strings and other\n * parsing edge-cases resolve to `null` or the provided `fallback`.\n *\n * @param input - The JSON string to parse.\n * @param fallback - Value returned on failure. Defaults to `null` when omitted.\n * @returns The parsed value typed as `T`, or `fallback` on failure.\n * @example\n * safeJsonParse<{ a: number }>('{\"a\":1}') // => { a: 1 }\n * safeJsonParse('invalid') // => null\n * safeJsonParse('invalid', []) // => []\n * @since 2.0.0\n */\nexport function safeJsonParse<T>(input: string): T | null;\nexport function safeJsonParse<T>(input: string, fallback: T): T;\nexport function safeJsonParse<T>(input: string, fallback?: T): T | null {\n try {\n return JSON.parse(input) as T;\n } catch {\n // Distinguish \"no fallback provided\" (→ null) from \"fallback is undefined\"\n // (→ undefined as T) to keep runtime behaviour aligned with the overloads.\n return arguments.length < 2 ? null : (fallback as T);\n }\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\nimport { parsePath } from './_parsePath.js';\nimport type { ContainsUnsafeStringKey, DeepGet, DeepSet, ParsePath } from './_types.js';\nimport { UNSAFE_KEYS } from '../_shared/_unsafeKeys.js';\n\n/**\n * Sets a value in an object at the given path, creating intermediate objects as needed.\n *\n * **Two path forms are supported:**\n *\n * 1. **String path** — dot notation and bracket notation, mixed freely.\n * - Dot segments are always string keys: `'layers.1.name'` → keys `['layers', '1', 'name']`.\n * - Bracket segments are always number keys: `'layers[1].name'` → keys `['layers', 1, 'name']`.\n * - String literal paths give **full compile-time type inference** on the return type.\n * - Dynamic (non-literal) strings return `T` (same object type).\n *\n * 2. **Key array** (`PropertyKey[]`) — explicit array of `string | number | symbol` keys,\n * no parsing performed. Enables symbol-keyed access and precise return-type inference.\n *\n * Both forms support **all objects** (plain objects, arrays, class instances).\n * Symbol keys are only reachable via the key-array form.\n *\n * Intermediate nodes that are absent, `null`, or not an object are replaced with `{}`.\n * Any path containing a string segment equal to `__proto__`, `constructor`, or `prototype`\n * is rejected and the original object is returned unchanged (prototype-pollution guard).\n *\n * @param obj - The object to mutate\n * @param path - Dot/bracket-notation string literal or explicit `PropertyKey[]`\n * @param value - Value to assign at the path\n * @returns The mutated object (same reference, narrowed type)\n * @example\n * // Dot notation — \"1\" stays a string key\n * set({}, 'a.b.c', 42)\n * // => { a: { b: { c: 42 } } }\n *\n * // Bracket notation — [1] becomes a number key\n * set({ layers: [{}, { name: 'old' }] }, 'layers[1].name', 'bg')\n * // => { layers: [{}, { name: 'bg' }] }\n *\n * // Key array — supports symbols\n * const id = Symbol('id')\n * set({}, ['user', id], 'alice')\n * // => { user: { [id]: 'alice' } }\n * @since 1.9.0\n */\nexport function set<\n T extends object,\n const P extends string | readonly PropertyKey[],\n V extends DeepGet<T, ParsePath<P>>,\n>(\n obj: T,\n path: P,\n value: V,\n): string extends P ? T : readonly PropertyKey[] extends P ? T : ContainsUnsafeStringKey<ParsePath<P>> extends true ? T : DeepSet<T, ParsePath<P>, V>;\nexport function set(obj: object, path: string | PropertyKey[], value: unknown): object {\n const keys: readonly PropertyKey[] = typeof path === 'string' ? parsePath(path) : path;\n\n if (keys.length === 0) return obj;\n if (keys.some((k) => typeof k === 'string' && UNSAFE_KEYS.has(k))) return obj;\n\n let current = obj as Record<PropertyKey, unknown>;\n\n for (let i = 0; i < keys.length - 1; i++) {\n const key = keys[i];\n\n // Object.hasOwn (not `key in current`) is intentional: `in` checks the prototype chain,\n // which would silently traverse into — and potentially mutate — an inherited object.\n // Using hasOwn ensures we only follow own properties; inherited intermediate nodes are\n // shadowed with a fresh own `{}` instead of being followed into the prototype.\n if (!Object.hasOwn(current, key) || typeof current[key] !== 'object' || current[key] === null) {\n current[key] = {};\n }\n\n current = current[key] as Record<PropertyKey, unknown>;\n }\n\n current[keys[keys.length - 1]] = value;\n return obj;\n}\n"],"mappings":"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"}