{"version":3,"file":"deep-merge.mjs","sources":["../../src/utilities/deep-clone.ts","../../src/utilities/deep-freeze.ts","../../src/utilities/deeply-equal.ts","../../src/utilities/deep-merge.ts"],"sourcesContent":["/**\n * Deeply clones any value using native structuredClone while restoring symbol-keyed properties.\n *\n * - Uses structuredClone for all supported types (objects, arrays, Date, Map, Set, etc.).\n * - After cloning, walks the source and clone graphs together to restore symbol-keyed properties.\n * - Preserves graph identity for shared references and circular references when symbol-keyed values participate in the graph.\n * - Supports nested symbol keys in objects, arrays, Maps, and Sets.\n * - Does not clone functions or DOM nodes (same as structuredClone).\n *\n * @template T The type of the value to clone.\n * @param obj The value to deeply clone.\n * @returns A deep clone of the input value, including symbol-keyed properties at all nested levels.\n */\nexport function deepClone<T>(obj: T): T {\n  const clone = structuredClone(obj);\n  const seen = new WeakMap<object, object>();\n\n  function cloneMissingValue(value: unknown): unknown {\n    if (!isObjectLike(value)) {\n      return value;\n    }\n\n    const existingClone = seen.get(value);\n\n    if (existingClone) {\n      return existingClone;\n    }\n\n    const clonedValue = structuredClone(value);\n    patchGraph(value, clonedValue);\n\n    return clonedValue;\n  }\n\n  function patchSymbolProperties(source: object, target: object): void {\n    for (const symbolKey of Object.getOwnPropertySymbols(source)) {\n      const descriptor = getSymbolDescriptor(source, symbolKey);\n\n      if ('value' in descriptor) {\n        Object.defineProperty(target, symbolKey, {\n          ...descriptor,\n          value: cloneMissingValue(descriptor.value),\n        });\n        continue;\n      }\n\n      Object.defineProperty(target, symbolKey, descriptor);\n    }\n  }\n\n  function patchObjectProperties(source: Record<PropertyKey, unknown>, target: Record<PropertyKey, unknown>): void {\n    for (const key of Reflect.ownKeys(source)) {\n      if (typeof key === 'symbol') {\n        continue;\n      }\n\n      patchGraph(source[key], target[key]);\n    }\n  }\n\n  function patchMapEntries(source: Map<unknown, unknown>, target: Map<unknown, unknown>): void {\n    const sourceEntries = Array.from(source.entries());\n    const targetEntries = Array.from(target.entries());\n\n    for (let index = 0; index < sourceEntries.length; index += 1) {\n      const sourceEntry = sourceEntries[index];\n      const targetEntry = targetEntries[index];\n\n      patchGraph(sourceEntry[0], targetEntry[0]);\n      patchGraph(sourceEntry[1], targetEntry[1]);\n    }\n  }\n\n  function patchSetEntries(source: Set<unknown>, target: Set<unknown>): void {\n    const sourceValues = Array.from(source.values());\n    const targetValues = Array.from(target.values());\n\n    for (let index = 0; index < sourceValues.length; index += 1) {\n      patchGraph(sourceValues[index], targetValues[index]);\n    }\n  }\n\n  function patchGraph(source: unknown, target: unknown): void {\n    if (!isObjectLike(source) || !isObjectLike(target)) {\n      return;\n    }\n\n    if (seen.has(source)) {\n      return;\n    }\n\n    seen.set(source, target);\n\n    if (source instanceof Map && target instanceof Map) {\n      patchMapEntries(source, target);\n      patchSymbolProperties(source, target);\n      return;\n    }\n\n    if (source instanceof Set && target instanceof Set) {\n      patchSetEntries(source, target);\n      patchSymbolProperties(source, target);\n      return;\n    }\n\n    patchObjectProperties(source as Record<PropertyKey, unknown>, target as Record<PropertyKey, unknown>);\n    patchSymbolProperties(source, target);\n  }\n\n  patchGraph(obj, clone);\n  return clone;\n}\n\nfunction isObjectLike(value: unknown): value is object {\n  return typeof value === 'object' && value !== null;\n}\n\nfunction getSymbolDescriptor(source: object, symbolKey: symbol): PropertyDescriptor {\n  const descriptor = Object.getOwnPropertyDescriptor(source, symbolKey);\n\n  if (descriptor === undefined) {\n    throw new Error('Expected own symbol descriptor to exist.');\n  }\n\n  return descriptor;\n}\n","/**\n * Recursively freezes an object and all nested values.\n *\n * This function ensures deep immutability by calling Object.freeze on the target object\n * and recursively freezing nested own properties, including symbol-keyed properties,\n * as well as values stored inside Maps and Sets. Circular references are handled safely.\n *\n * ⚠️ Performance note: For very large or deeply nested object graphs, this can be slow,\n * as every reachable nested object is eagerly frozen, including values stored in Maps,\n * Sets, non-enumerable properties, and symbol-keyed properties. If you only need to\n * prevent mutation of the top-level object, use Object.freeze directly instead.\n *\n * @template T The type of the object to freeze.\n * @param obj The object to deeply freeze.\n * @param seen (internal) Used to track already-visited objects for circular reference protection.\n * @returns The deeply frozen object (same reference as input).\n */\nexport function deepFreeze<T extends object>(obj: T, seen = new WeakSet()): T {\n  if (seen.has(obj)) {\n    return obj;\n  }\n\n  seen.add(obj);\n  Object.freeze(obj);\n  freezeMapEntries(obj, seen);\n  freezeSetEntries(obj, seen);\n  freezeOwnProperties(obj, seen);\n\n  return obj;\n}\n\nfunction freezeIfNeeded(value: unknown, seen: WeakSet<object>): void {\n  if (isObjectLike(value) && !Object.isFrozen(value)) {\n    deepFreeze(value, seen);\n  }\n}\n\nfunction freezeMapEntries(obj: object, seen: WeakSet<object>): void {\n  if (!(obj instanceof Map)) {\n    return;\n  }\n\n  for (const [key, value] of obj) {\n    freezeIfNeeded(key, seen);\n    freezeIfNeeded(value, seen);\n  }\n}\n\nfunction freezeSetEntries(obj: object, seen: WeakSet<object>): void {\n  if (obj instanceof Set) {\n    for (const value of obj) {\n      freezeIfNeeded(value, seen);\n    }\n  }\n}\n\nfunction freezeOwnProperties(obj: object, seen: WeakSet<object>): void {\n  for (const key of Reflect.ownKeys(obj)) {\n    const descriptor = Object.getOwnPropertyDescriptor(obj, key);\n\n    if (!descriptor || !('value' in descriptor)) {\n      continue;\n    }\n\n    freezeIfNeeded(descriptor.value, seen);\n  }\n}\n\n/**\n * Type guard to check if a value is a non-null object.\n */\nfunction isObjectLike(value: unknown): value is object {\n  return typeof value === 'object' && value !== null;\n}\n","/**\n * Recursively checks deep equality between two values, supporting plain objects, arrays, Date, Map, Set, and circular references.\n *\n * - Handles nested structures, arrays, and objects.\n * - Compares Date objects by value.\n * - Compares Map and Set contents (unordered for Set).\n * - Handles circular references using a WeakMap.\n *\n * @param a - The first value to compare.\n * @param b - The second value to compare.\n * @param seen - (Internal) WeakMap for tracking circular references.\n * @returns {boolean} True if the values are deeply equal, false otherwise.\n */\nexport function deeplyEqual(a: any, b: any, seen = new WeakMap<object, WeakMap<object, true>>()): boolean {\n  return compareValues(a, b, seen, []);\n}\n\ntype SeenPairs = WeakMap<object, WeakMap<object, true>>;\ntype SeenTrailEntry = {\n  left: object;\n  right: object;\n};\n\nfunction compareValues(a: any, b: any, seen: SeenPairs, trail: SeenTrailEntry[]): boolean {\n  if (Object.is(a, b)) {\n    return true;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  if (typeof a !== 'object') {\n    return false;\n  }\n\n  if (a === null || b === null) {\n    return a === b;\n  }\n\n  if (a instanceof Map !== b instanceof Map) {\n    return false;\n  }\n  if (a instanceof Set !== b instanceof Set) {\n    return false;\n  }\n  if (Array.isArray(a) !== Array.isArray(b)) {\n    return false;\n  }\n  if (a instanceof Date !== b instanceof Date) {\n    return false;\n  }\n\n  if (a instanceof Date) {\n    return a.getTime() === b.getTime();\n  }\n\n  if (hasSeenPair(a, b, seen)) {\n    return true;\n  }\n\n  rememberPair(a, b, seen, trail);\n\n  if (a instanceof Map) {\n    return mapsEqual(a, b, seen, trail);\n  }\n\n  if (a instanceof Set) {\n    return setsEqual(a, b, seen);\n  }\n\n  if (Array.isArray(a)) {\n    return arraysEqual(a, b, seen, trail);\n  }\n\n  return objectsEqual(a, b, seen, trail);\n}\n\nfunction mapsEqual(a: Map<any, any>, b: Map<any, any>, seen: SeenPairs, trail: SeenTrailEntry[]): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  const aIter = a.entries();\n  const bIter = b.entries();\n\n  let aEntry = aIter.next();\n  let bEntry = bIter.next();\n\n  while (!(aEntry.done || bEntry.done)) {\n    const [aKey, aVal] = aEntry.value;\n    const [bKey, bVal] = bEntry.value;\n\n    if (!compareValues(aKey, bKey, seen, trail) || !compareValues(aVal, bVal, seen, trail)) {\n      return false;\n    }\n\n    aEntry = aIter.next();\n    bEntry = bIter.next();\n  }\n\n  return Boolean(aEntry.done && bEntry.done);\n}\n\nfunction setsEqual(a: Set<any>, b: Set<any>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  const unmatchedCandidates = Array.from(b.values());\n\n  for (const val of a) {\n    const candidateIndex = unmatchedCandidates.findIndex((candidate) => compareWithRollback(val, candidate, seen));\n\n    if (candidateIndex === -1) {\n      return false;\n    }\n\n    unmatchedCandidates.splice(candidateIndex, 1);\n  }\n\n  return true;\n}\n\nfunction arraysEqual(a: any[], b: any[], seen: SeenPairs, trail: SeenTrailEntry[]): boolean {\n  if (a.length !== b.length) {\n    return false;\n  }\n\n  for (let i = 0; i < a.length; i++) {\n    const aHas = Object.hasOwn(a, i);\n    const bHas = Object.hasOwn(b, i);\n\n    if (aHas !== bHas) {\n      return false;\n    }\n\n    if (aHas && !compareValues(a[i], b[i], seen, trail)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction objectsEqual(\n  a: Record<string | symbol, any>,\n  b: Record<string | symbol, any>,\n  seen: SeenPairs,\n  trail: SeenTrailEntry[],\n): boolean {\n  const aKeys = [...Object.keys(a), ...Object.getOwnPropertySymbols(a)];\n  const bKeys = [...Object.keys(b), ...Object.getOwnPropertySymbols(b)];\n\n  if (aKeys.length !== bKeys.length) {\n    return false;\n  }\n\n  for (const key of aKeys) {\n    if (!(bKeys.includes(key) && compareValues(a[key], b[key], seen, trail))) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction compareWithRollback(a: any, b: any, seen: SeenPairs): boolean {\n  const trail: SeenTrailEntry[] = [];\n  const equal = compareValues(a, b, seen, trail);\n\n  if (!equal) {\n    rollbackSeenPairs(seen, trail);\n  }\n\n  return equal;\n}\n\nfunction hasSeenPair(left: object, right: object, seen: SeenPairs): boolean {\n  return seen.get(left)?.has(right) ?? false;\n}\n\nfunction rememberPair(left: object, right: object, seen: SeenPairs, trail: SeenTrailEntry[]): void {\n  let rightPairs = seen.get(left);\n\n  if (!rightPairs) {\n    rightPairs = new WeakMap<object, true>();\n    seen.set(left, rightPairs);\n  }\n\n  rightPairs.set(right, true);\n  trail.push({ left, right });\n}\n\nfunction rollbackSeenPairs(seen: SeenPairs, trail: SeenTrailEntry[]): void {\n  for (let index = trail.length - 1; index >= 0; index -= 1) {\n    const entry = trail[index];\n    const rightPairs = seen.get(entry.left);\n\n    rightPairs?.delete(entry.right);\n  }\n}\n","import { deeplyEqual } from './deeply-equal';\n\ntype MergeSeen = WeakMap<object, WeakMap<object, object>>;\n\n/**\n * Deeply merges two objects or arrays.\n *\n * - For plain objects, properties from the source overwrite or are deeply merged into the target.\n * - For arrays, if both target and source values are arrays, the source array replaces the target array.\n * - If one is an array and the other is a plain object, the array/object is shallow-copied and the other's properties/indices are assigned.\n * - If only one value is an array or object, the source value replaces the target value.\n * - Non-object/array values from the source always replace those in the target.\n * - If the target is not an object/array but the source is a plain object, the source is returned.\n * - If the source is not an object/array but the target is a plain object, the target is returned.\n *\n * The original target and source are never mutated; a new object or array is returned.\n *\n * Symbol-keyed properties are also deeply merged and preserved.\n *\n * @template T The type of the target object or array.\n * @param target The target object or array to merge into.\n * @param source The source object or array to merge from.\n * @returns A new deeply merged object or array.\n */\nexport function deepMerge<T>(target: T, source: Partial<T>, seen: MergeSeen = new WeakMap()): T {\n  if (Array.isArray(target) && Array.isArray(source)) {\n    return source.slice() as T;\n  }\n  if (Array.isArray(target) && isPlainObject(source)) {\n    return mergeArrayWithObject(target, source) as T;\n  }\n  if (isPlainObject(target) && Array.isArray(source)) {\n    return mergeObjectWithArray(target, source) as T;\n  }\n  if (isPlainObject(target) && isPlainObject(source)) {\n    return mergeObjects(target, source, seen) as T;\n  }\n  if (isPlainObject(source)) {\n    return source as T;\n  }\n  if (isPlainObject(target)) {\n    return target;\n  }\n  return source as T;\n}\n\nfunction isPlainObject(obj: any): obj is object {\n  return Object.prototype.toString.call(obj) === '[object Object]';\n}\n\nfunction mergeArrayWithObject(target: any[], source: object): any[] {\n  const result = [...target];\n  for (const key of Reflect.ownKeys(source)) {\n    result[key as any] = (source as any)[key];\n  }\n  return result;\n}\n\nfunction mergeObjectWithArray(target: object, source: any[]): object {\n  const result = copyObjectLike(target);\n  for (let i = 0; i < source.length; i++) {\n    (result as any)[i] = source[i];\n  }\n  return result;\n}\n\nfunction mergeObjects(target: object, source: object, seen: MergeSeen): object {\n  const cached = getSeenMerge(target, source, seen);\n\n  if (cached) {\n    return cached;\n  }\n\n  const result = copyObjectLike(target) as Record<PropertyKey, unknown>;\n  rememberMerge(target, source, result, seen);\n\n  for (const key of Reflect.ownKeys(source)) {\n    const sourceValue = (source as any)[key];\n    const targetValue = (target as any)[key];\n\n    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {\n      result[key] = sourceValue.slice();\n      continue;\n    }\n\n    if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {\n      result[key] = mergeObjectsWithReference(targetValue, sourceValue, seen);\n      continue;\n    }\n\n    result[key] = deeplyEqual(sourceValue, targetValue) ? targetValue : sourceValue;\n  }\n  return result;\n}\n\nfunction mergeObjectsWithReference(targetObj: object, sourceObj: object, seen: WeakMap<any, any>) {\n  const merged = mergeObjects(targetObj, sourceObj, seen);\n  return deeplyEqual(merged, targetObj) ? targetObj : merged;\n}\n\nfunction copyObjectLike(source: object): object {\n  const descriptors = Object.getOwnPropertyDescriptors(source);\n\n  for (const key of Reflect.ownKeys(descriptors) as Array<keyof typeof descriptors>) {\n    const descriptor = descriptors[key];\n\n    if ('value' in descriptor) {\n      descriptors[key] = {\n        ...descriptor,\n        configurable: true,\n        writable: true,\n      };\n    }\n  }\n\n  return Object.create(Object.getPrototypeOf(source), descriptors);\n}\n\nfunction getSeenMerge(target: object, source: object, seen: MergeSeen): object | undefined {\n  return seen.get(source)?.get(target);\n}\n\nfunction rememberMerge(target: object, source: object, result: object, seen: MergeSeen): void {\n  let targetMap = seen.get(source);\n\n  if (!targetMap) {\n    targetMap = new WeakMap<object, object>();\n    seen.set(source, targetMap);\n  }\n\n  targetMap.set(target, result);\n}\n"],"names":["deepClone","obj","clone","seen","cloneMissingValue","value","isObjectLike","existingClone","clonedValue","patchGraph","patchSymbolProperties","source","target","symbolKey","descriptor","getSymbolDescriptor","patchObjectProperties","key","patchMapEntries","sourceEntries","targetEntries","index","sourceEntry","targetEntry","patchSetEntries","sourceValues","targetValues","deepFreeze","freezeMapEntries","freezeSetEntries","freezeOwnProperties","freezeIfNeeded","deeplyEqual","a","b","compareValues","trail","hasSeenPair","rememberPair","mapsEqual","setsEqual","arraysEqual","objectsEqual","aIter","bIter","aEntry","bEntry","aKey","aVal","bKey","bVal","unmatchedCandidates","val","candidateIndex","candidate","compareWithRollback","aHas","bHas","aKeys","bKeys","equal","rollbackSeenPairs","left","right","rightPairs","entry","deepMerge","isPlainObject","mergeArrayWithObject","mergeObjectWithArray","mergeObjects","result","copyObjectLike","i","cached","getSeenMerge","rememberMerge","sourceValue","targetValue","mergeObjectsWithReference","targetObj","sourceObj","merged","descriptors","targetMap"],"mappings":"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"}