{"version":3,"file":"proxy.cjs","sources":["../../src/proxy.ts"],"sourcesContent":["/**\n * A utility for creating a proxy that captures changes to an object\n * and provides a way to retrieve those changes.\n */\n\nimport { deepEqualsInternal, isTemporal } from './utils'\n\n// Resolve draft handles before calling native Map/Set membership methods.\nconst draftCopies = new WeakMap<object, object>()\nfunction defineDataProperty(\n  object: object,\n  key: PropertyKey,\n  value: unknown,\n): void {\n  if (key !== `__proto__`) {\n    ;(object as Record<PropertyKey, unknown>)[key] = value\n    return\n  }\n  Object.defineProperty(object, key, {\n    value,\n    enumerable: true,\n    configurable: true,\n    writable: true,\n  })\n}\n\nfunction unwrapDraft(value: unknown): unknown {\n  return value !== null && typeof value === `object`\n    ? (draftCopies.get(value) ?? value)\n    : value\n}\n\n/**\n * Array and typed-array methods that modify the value in place.\n */\nconst ARRAY_MODIFYING_METHODS = new Set([\n  `pop`,\n  `push`,\n  `shift`,\n  `unshift`,\n  `splice`,\n  `sort`,\n  `reverse`,\n  `fill`,\n  `copyWithin`,\n  `set`,\n])\n\n/**\n * Set of Map/Set iterator methods.\n */\nconst MAP_SET_ITERATOR_METHODS = new Set([\n  `entries`,\n  `keys`,\n  `values`,\n  `forEach`,\n])\n\n/**\n * Check if a value is a proxiable object (not Date, RegExp, or Temporal)\n */\nfunction isProxiableObject(\n  value: unknown,\n): value is Record<string | symbol, unknown> {\n  return (\n    value !== null &&\n    typeof value === `object` &&\n    !((value as any) instanceof Date) &&\n    !((value as any) instanceof RegExp) &&\n    !isTemporal(value)\n  )\n}\n\n/**\n * Creates a wrapper for methods that modify a collection (array, Map, Set).\n * The wrapper calls the method and marks the change tracker as modified.\n */\nfunction createModifyingMethodHandler<T extends object>(\n  methodFn: (...args: Array<unknown>) => unknown,\n  changeTracker: ChangeTracker<T>,\n  markChanged: (tracker: ChangeTracker<T>) => void,\n  receiver: unknown,\n): (...args: Array<unknown>) => unknown {\n  return function (...args: Array<unknown>) {\n    const result = methodFn.apply(changeTracker.copy_, args)\n    markChanged(changeTracker)\n    // A method that returns the value itself returns the draft.\n    return result === changeTracker.copy_ ? receiver : result\n  }\n}\n\n/**\n * Use the native live iterator, but expose tracked values. Editing an entry\n * changes its owned draft copy in place; it must not delete/reinsert a Set slot.\n */\nfunction createMapSetIteratorHandler<T extends object>(\n  methodName: string,\n  prop: string | symbol,\n  changeTracker: ChangeTracker<T>,\n  collectionProxy: unknown,\n  memoizedCreateChangeProxy: (\n    obj: Record<string | symbol, unknown>,\n    parent?: ChangeParent,\n  ) => { proxy: Record<string | symbol, unknown> },\n): ((...args: Array<unknown>) => unknown) | undefined {\n  if (!MAP_SET_ITERATOR_METHODS.has(methodName) && prop !== Symbol.iterator) {\n    return undefined\n  }\n\n  return (...args) => {\n    const copy = changeTracker.copy_ as Map<unknown, unknown> | Set<unknown>\n    const isMap = copy instanceof Map\n    if (isMap && methodName === `keys`) return copy.keys()\n\n    const track = (value: unknown) =>\n      isProxiableObject(value)\n        ? memoizedCreateChangeProxy(value, {\n            tracker: changeTracker as unknown as ChangeTracker<\n              Record<string | symbol, unknown>\n            >,\n            prop: ``,\n            retainIdentity: true,\n          }).proxy\n        : value\n\n    if (methodName === `forEach`) {\n      const callback = args[0]\n      if (typeof callback !== `function`)\n        throw new TypeError(`forEach callback must be a function`)\n      return copy.forEach((value, key) => {\n        const tracked = track(value)\n        callback.call(args[1], tracked, isMap ? key : tracked, collectionProxy)\n      })\n    }\n\n    const entries = copy.entries()\n    const pairs =\n      methodName === `entries` || (isMap && prop === Symbol.iterator)\n    return {\n      next() {\n        const result = entries.next()\n        if (result.done) return result\n        const [key, value] = result.value\n        const tracked = track(value)\n        return {\n          done: false,\n          value: pairs ? [isMap ? key : tracked, tracked] : tracked,\n        }\n      },\n      [Symbol.iterator]() {\n        return this\n      },\n    }\n  }\n}\n\n// Update type for ChangeTracker\ninterface ChangeParent {\n  tracker: ChangeTracker<Record<string | symbol, unknown>>\n  prop: string | symbol\n  // Map/Set entries already belong to the parent's private copy.\n  retainIdentity?: boolean\n}\n\ninterface ChangeTracker<T extends object> {\n  valueCopies: WeakMap<object, unknown>\n  originalObject: T\n  modified: boolean\n  copy_: T\n  assigned_: Record<string | symbol, boolean>\n  parent?: ChangeParent\n  target: T\n}\n\n/**\n * Deep clones an object while preserving special types like Date and RegExp\n */\n\ninterface TypedArray {\n  length: number\n  set: (source: TypedArray) => void\n}\n\nfunction deepClone<T extends unknown>(\n  obj: T,\n  visited = new WeakMap<object, unknown>(),\n  detach = false,\n): T {\n  // A draft handle and its underlying copy must share one cycle identity.\n  obj = unwrapDraft(obj) as T\n  // Handle null and undefined\n  if (obj === null || obj === undefined) {\n    return obj\n  }\n\n  // Handle primitive types\n  if (typeof obj !== `object`) {\n    return obj\n  }\n\n  // If we've already cloned this object, return the cached clone\n  if (visited.has(obj as object)) {\n    return visited.get(obj as object) as T\n  }\n\n  if (obj instanceof Date) {\n    const clone = new Date(obj.getTime())\n    visited.set(obj, clone)\n    return clone as T\n  }\n\n  if (obj instanceof RegExp) {\n    const clone = new RegExp(obj.source, obj.flags)\n    clone.lastIndex = obj.lastIndex\n    visited.set(obj, clone)\n    return clone as T\n  }\n\n  if (obj instanceof URL) {\n    const clone = new URL(obj.href)\n    visited.set(obj, clone)\n    return clone as T\n  }\n\n  if (Array.isArray(obj)) {\n    const arrayClone = new Array<unknown>(obj.length)\n    visited.set(obj as object, arrayClone)\n    obj.forEach((item, index) => {\n      arrayClone[index] = deepClone(item, visited, detach)\n    })\n    return arrayClone as unknown as T\n  }\n\n  // Handle TypedArrays\n  if (ArrayBuffer.isView(obj) && !(obj instanceof DataView)) {\n    // Create an instance of the same type by length, then copy the values.\n    // A subclass constructor need not forward a source array to super.\n    const TypedArrayConstructor = Object.getPrototypeOf(obj).constructor\n    const clone = new TypedArrayConstructor(\n      (obj as unknown as TypedArray).length,\n    ) as TypedArray\n    visited.set(obj as object, clone)\n    clone.set(obj as unknown as TypedArray)\n    return clone as unknown as T\n  }\n\n  if (obj instanceof Map) {\n    const clone = new Map() as Map<unknown, unknown>\n    visited.set(obj as object, clone)\n    obj.forEach((value, key) => {\n      clone.set(key, deepClone(value, visited, detach))\n    })\n    return clone as unknown as T\n  }\n\n  if (obj instanceof Set) {\n    const clone = new Set()\n    visited.set(obj as object, clone)\n    obj.forEach((value) => {\n      clone.add(deepClone(value, visited, detach))\n    })\n    return clone as unknown as T\n  }\n\n  // Handle Temporal objects\n  if (isTemporal(obj)) {\n    // Temporal objects are immutable, so we can return them directly\n    // This preserves all their internal state correctly\n    return obj\n  }\n\n  // Arbitrary instances may carry private/native state we cannot reconstruct.\n  // Keep them by reference at publication, rather than silently flattening them.\n  if (detach) {\n    const prototype = Object.getPrototypeOf(obj)\n    if (prototype !== Object.prototype && prototype !== null) return obj\n  }\n\n  const clone = {} as Record<string | symbol, unknown>\n  visited.set(obj as object, clone)\n\n  // Own enumerable string keys and every own symbol key, in native order.\n  for (const key of Reflect.ownKeys(obj)) {\n    if (\n      typeof key === `symbol` ||\n      Object.prototype.propertyIsEnumerable.call(obj, key)\n    ) {\n      // Copy data properties without invoking Object.prototype.__proto__.\n      defineDataProperty(\n        clone,\n        key,\n        deepClone(\n          (obj as Record<string | symbol, unknown>)[key],\n          visited,\n          detach,\n        ),\n      )\n    }\n  }\n\n  return clone as T\n}\n\n// Generic value equality intentionally ignores some native state. Draft\n// assignments must also preserve Set contents/order and RegExp match position.\nfunction draftValuesEqual(\n  left: unknown,\n  right: unknown,\n  paired = new Map<object, object>(),\n): boolean {\n  return deepEqualsInternal(left, right, paired, true)\n}\n\n/**\n * Creates a proxy that tracks changes to the target object\n *\n * @param target The object to proxy\n * @param parent Optional parent information\n * @returns An object containing the proxy and a function to get the changes\n */\nexport function createChangeProxy<\n  T extends Record<string | symbol, any | undefined>,\n>(\n  target: T,\n  parent?: ChangeParent,\n): {\n  proxy: T\n\n  getChanges: () => Record<string | symbol, any>\n} {\n  const changeProxyCache = new Map<object, object>()\n\n  function memoizedCreateChangeProxy<\n    TInner extends Record<string | symbol, any | undefined>,\n  >(\n    innerTarget: TInner,\n    innerParent?: ChangeParent,\n  ): {\n    proxy: TInner\n    getChanges: () => Record<string | symbol, any>\n  } {\n    if (changeProxyCache.has(innerTarget)) {\n      return changeProxyCache.get(innerTarget) as {\n        proxy: TInner\n        getChanges: () => Record<string | symbol, any>\n      }\n    } else {\n      const changeProxy = createChangeProxy(innerTarget, innerParent)\n      changeProxyCache.set(innerTarget, changeProxy)\n      return changeProxy\n    }\n  }\n  // Existing values share one private copy per row. Newly inserted objects\n  // retain normal references during the callback; the result is detached below.\n  const valueCopies =\n    parent?.tracker.valueCopies ?? new WeakMap<object, unknown>()\n  const changeTracker: ChangeTracker<T> = {\n    valueCopies,\n    copy_: parent\n      ? ((valueCopies.get(target) ?? target) as T)\n      : deepClone(target, valueCopies),\n    originalObject: deepClone(target),\n    modified: false,\n    assigned_: Object.create(null),\n    parent,\n    target, // Store reference to the target object\n  }\n\n  // Mark this object and all its ancestors as modified\n  // Also propagate the actual changes up the chain\n  function markChanged(state: ChangeTracker<object>) {\n    if (!state.modified) {\n      state.modified = true\n    }\n\n    // Propagate the change up the parent chain\n    if (state.parent) {\n      if (\n        !state.parent.retainIdentity &&\n        state.parent.tracker.copy_[state.parent.prop] === state.copy_\n      ) {\n        // Only mark an edge that still points to this child. A retained handle\n        // must not reinstall itself after the callback replaces or deletes it.\n        state.parent.tracker.assigned_[state.parent.prop] = true\n      }\n\n      // Mark parent as changed\n      markChanged(state.parent.tracker)\n    }\n  }\n\n  // Check if all properties in the current state have reverted to original values.\n  // assigned_ keys are always strings: traps record `prop.toString()`.\n  function checkIfReverted(\n    state: ChangeTracker<Record<string | symbol, unknown>>,\n  ): boolean {\n    if (state.copy_ instanceof Map || state.copy_ instanceof Set) {\n      // Compare entry contents: these containers have no assigned properties.\n      return draftValuesEqual(\n        Array.from(state.copy_),\n        Array.from(\n          state.originalObject as unknown as\n            | Map<unknown, unknown>\n            | Set<unknown>,\n        ),\n      )\n    }\n    for (const prop in state.assigned_) {\n      // false marks a deletion, which always differs from the original. A key\n      // added with the value undefined differs from an absent key.\n      if (\n        !state.assigned_[prop] ||\n        Object.hasOwn(state.copy_, prop) !==\n          Object.hasOwn(state.originalObject, prop) ||\n        !draftValuesEqual(\n          state.copy_[prop],\n          (state.originalObject as any)[prop],\n        )\n      ) {\n        return false\n      }\n    }\n    return true\n  }\n\n  // Update parent status based on child changes\n  function checkParentStatus(\n    parentState: ChangeTracker<Record<string | symbol, unknown>>,\n  ) {\n    // Check if all properties of the parent are reverted\n    const isReverted = checkIfReverted(parentState)\n\n    if (isReverted) {\n      // If everything is reverted, clear the tracking\n      parentState.modified = false\n      parentState.assigned_ = Object.create(null)\n\n      // Continue up the chain. The parent's edge to this object no longer\n      // counts as a change when the parent's value equals its original; a\n      // replaced object can revert to its own snapshot and still differ.\n      const edge = parentState.parent\n      if (edge) {\n        if (\n          draftValuesEqual(\n            edge.tracker.copy_[edge.prop],\n            edge.tracker.originalObject[edge.prop],\n          )\n        )\n          delete edge.tracker.assigned_[edge.prop]\n        checkParentStatus(edge.tracker)\n      }\n    }\n  }\n\n  // Create a proxy for the target object.\n  // Use the unfrozen copy_ as the proxy target to avoid Proxy invariant violations\n  // when the original target is frozen (e.g., from Immer)\n  const proxy = new Proxy(changeTracker.copy_, {\n    get(ptarget, prop, receiver) {\n      const value = changeTracker.copy_[prop as keyof T]\n\n      // If it's a getter, return the value directly\n      const desc = Object.getOwnPropertyDescriptor(ptarget, prop)\n      if (desc?.get) {\n        return value\n      }\n\n      // The Proxy invariants require a read-only non-configurable value as\n      // stored, as after Object.freeze. A raw object can still be written\n      // through, so its key counts as changed.\n      if (desc?.configurable === false && !desc.writable) {\n        if (isProxiableObject(value)) {\n          changeTracker.assigned_[String(prop)] = true\n          markChanged(changeTracker)\n        }\n        return value\n      }\n\n      // If the value is a function, bind it to the ptarget\n      if (typeof value === `function`) {\n        // A function stored as data is returned as stored, like any value. A\n        // call then sees the draft as `this`, so its writes are tracked. A\n        // constructor is not a method. Only inherited methods (Array, Map,\n        // Set) need the handling below.\n        if (Object.hasOwn(ptarget, prop) || prop === `constructor`) return value\n\n        const methodName = prop.toString()\n\n        // A subarray shares the buffer, so it is a draft whose writes mark\n        // this value changed, like a Map value.\n        if (methodName === `subarray` && ArrayBuffer.isView(ptarget)) {\n          return (...args: Array<unknown>) =>\n            memoizedCreateChangeProxy(value.apply(ptarget, args), {\n              tracker: changeTracker,\n              prop: ``,\n              retainIdentity: true,\n            }).proxy\n        }\n\n        // Array and typed-array methods that modify the value in place\n        if (\n          ARRAY_MODIFYING_METHODS.has(methodName) &&\n          (Array.isArray(ptarget) || ArrayBuffer.isView(ptarget))\n        ) {\n          return createModifyingMethodHandler(\n            value,\n            changeTracker,\n            markChanged,\n            receiver,\n          )\n        }\n\n        if (Array.isArray(ptarget)) {\n          // Other methods, iterators included, read through the draft\n          // itself, so returned and callback elements are drafts and searches\n          // find them. This also tracks the callback array and implicit\n          // reduce seed.\n          return value.bind(receiver)\n        }\n\n        // For Map and Set methods that modify the collection\n        if (ptarget instanceof Map || ptarget instanceof Set) {\n          const resolveValue = (entry: unknown) => {\n            const raw = unwrapDraft(entry)\n            return raw !== null && typeof raw === `object`\n              ? (valueCopies.get(raw) ?? raw)\n              : raw\n          }\n\n          if (\n            methodName === `has` ||\n            methodName === `delete` ||\n            methodName === `add` ||\n            methodName === `set`\n          ) {\n            return (...args: Array<unknown>) => {\n              if (ptarget instanceof Set) args[0] = resolveValue(args[0])\n              else if (methodName === `set`) args[1] = resolveValue(args[1])\n              const result = value.apply(ptarget, args)\n              if (methodName !== `has`) markChanged(changeTracker)\n              return result === ptarget ? receiver : result\n            }\n          }\n\n          if (ptarget instanceof Map && methodName === `get`) {\n            return (key: unknown) => {\n              const entry = ptarget.get(key)\n              return isProxiableObject(entry)\n                ? memoizedCreateChangeProxy(entry, {\n                    tracker: changeTracker,\n                    prop: ``,\n                    retainIdentity: true,\n                  }).proxy\n                : entry\n            }\n          }\n\n          if (methodName === `clear`) {\n            return createModifyingMethodHandler(\n              value,\n              changeTracker,\n              markChanged,\n              receiver,\n            )\n          }\n\n          // Handle iterator methods for Map and Set\n          const iteratorHandler = createMapSetIteratorHandler(\n            methodName,\n            prop,\n            changeTracker,\n            receiver,\n            memoizedCreateChangeProxy,\n          )\n          if (iteratorHandler) {\n            return iteratorHandler\n          }\n        }\n        return value.bind(ptarget)\n      }\n\n      // If the value is an object (but not Date, RegExp, or Temporal), create a proxy for it\n      if (isProxiableObject(value)) {\n        // Create a parent reference for the nested object\n        const nestedParent = {\n          tracker: changeTracker,\n          prop: String(prop),\n        }\n\n        // Create (or reuse) the proxy for the nested object\n        return memoizedCreateChangeProxy(value, nestedParent).proxy\n      }\n\n      return value\n    },\n\n    set(_sobj, prop, value) {\n      const currentValue = changeTracker.copy_[prop as keyof T]\n\n      // Only track the change if the value is actually different\n      if (\n        !Object.hasOwn(changeTracker.copy_, prop) ||\n        !draftValuesEqual(currentValue, value)\n      ) {\n        // Check if the new value is equal to the original value\n        // Important: Use the originalObject to get the true original value\n        const originalValue = changeTracker.originalObject[prop as keyof T]\n        const isRevertToOriginal =\n          Object.hasOwn(changeTracker.originalObject, prop) &&\n          draftValuesEqual(value, originalValue)\n\n        if (isRevertToOriginal) {\n          // If the value is reverted to its original state, remove it from changes\n          delete changeTracker.assigned_[prop.toString()]\n\n          // Make sure the copy is updated with the original value\n          changeTracker.copy_[prop as keyof T] = deepClone(originalValue)\n\n          // Some properties may still be changed; checkParentStatus clears\n          // tracking here and up the chain once everything is reverted.\n          changeTracker.modified = true\n          checkParentStatus(changeTracker)\n        } else {\n          // Set the value on the copy\n          changeTracker.copy_[prop as keyof T] = value\n\n          // Track that this property was assigned - store using the actual property (symbol or string)\n          changeTracker.assigned_[prop.toString()] = true\n\n          // Mark this object and its ancestors as modified\n          markChanged(changeTracker)\n        }\n      }\n\n      return true\n    },\n\n    defineProperty(ptarget, prop, descriptor) {\n      // Forward the defineProperty to the target to maintain Proxy invariants\n      // This allows Object.seal() and Object.freeze() to work on the proxy\n      const result = Reflect.defineProperty(ptarget, prop, descriptor)\n      // A value or an accessor changes what the key reads. Sealing does not.\n      if (\n        result &&\n        (`value` in descriptor || descriptor.get || descriptor.set)\n      ) {\n        changeTracker.assigned_[prop.toString()] = true\n        markChanged(changeTracker)\n      }\n      return result\n    },\n\n    getOwnPropertyDescriptor(ptarget, prop) {\n      // Forward to target to maintain Proxy invariants for seal/freeze\n      return Reflect.getOwnPropertyDescriptor(ptarget, prop)\n    },\n\n    preventExtensions(ptarget) {\n      // Forward to target to allow Object.seal() and Object.preventExtensions()\n      return Reflect.preventExtensions(ptarget)\n    },\n\n    isExtensible(ptarget) {\n      // Forward to target to maintain consistency\n      return Reflect.isExtensible(ptarget)\n    },\n\n    deleteProperty(dobj, prop) {\n      const stringProp = typeof prop === `symbol` ? prop.toString() : prop\n\n      if (Object.hasOwn(dobj, prop)) {\n        // Check if the property exists in the original object\n        const hadPropertyInOriginal = Object.hasOwn(\n          changeTracker.originalObject,\n          prop,\n        )\n\n        // Forward the delete to the target using Reflect\n        // This respects Object.seal/preventExtensions constraints\n        const result = Reflect.deleteProperty(dobj, prop)\n\n        if (result) {\n          // If the property didn't exist in the original object, removing it\n          // should revert to the original state\n          if (!hadPropertyInOriginal) {\n            delete changeTracker.assigned_[stringProp]\n\n            // Deleting an added key is a revert. Like the set trap, clear\n            // tracking here and up the chain once everything is reverted.\n            changeTracker.modified = true\n            checkParentStatus(changeTracker)\n          } else {\n            // Mark this property as deleted\n            changeTracker.assigned_[stringProp] = false\n            markChanged(changeTracker)\n          }\n        }\n\n        return result\n      }\n\n      return true\n    },\n  })\n  draftCopies.set(proxy, changeTracker.copy_)\n\n  // Return the proxy and a function to get the changes\n  return {\n    proxy,\n    getChanges: () => {\n      // First, check if the object is still considered modified\n      if (!changeTracker.modified) {\n        return {}\n      }\n\n      // If we have a copy, return it directly\n      // Check if valueObj is actually an object\n      if (\n        typeof changeTracker.copy_ !== `object` ||\n        Array.isArray(changeTracker.copy_)\n      ) {\n        return changeTracker.copy_\n      }\n\n      if (Object.keys(changeTracker.assigned_).length === 0) {\n        return changeTracker.copy_\n      }\n\n      const result: Record<string, any | undefined> = {}\n      const mayHaveChangedAliases = Object.keys(changeTracker.assigned_).some(\n        (key) =>\n          typeof changeTracker.copy_[key] === `object` ||\n          typeof changeTracker.originalObject[key] === `object`,\n      )\n      const pairedRoots = new Map<object, object>([\n        [changeTracker.copy_, changeTracker.originalObject],\n      ])\n\n      // Iterate through keys in keyObj\n      for (const key in changeTracker.copy_) {\n        const value: unknown = changeTracker.copy_[key]\n        const original: unknown = changeTracker.originalObject[key]\n        // Compare child contents, stopping only at paired root backedges. A\n        // child's own changes still count even when it also points to this row.\n        if (\n          changeTracker.assigned_[key] === true ||\n          (mayHaveChangedAliases &&\n            !draftValuesEqual(\n              value instanceof Set ? Array.from(value) : value,\n              original instanceof Set ? Array.from(original) : original,\n              pairedRoots,\n            ))\n        ) {\n          defineDataProperty(result, key, changeTracker.copy_[key])\n        }\n      }\n\n      for (const key of Object.keys(changeTracker.assigned_)) {\n        if (changeTracker.assigned_[key] === false) {\n          defineDataProperty(result, key, undefined)\n        }\n      }\n\n      return result as unknown as Record<string | symbol, unknown>\n    },\n  }\n}\n\n/**\n * Creates proxies for an array of objects and tracks changes to each\n *\n * @param targets Array of objects to proxy\n * @returns An object containing the array of proxies and a function to get all changes\n */\nexport function createArrayChangeProxy<T extends object>(\n  targets: Array<T>,\n): {\n  proxies: Array<T>\n  getChanges: () => Array<Record<string | symbol, unknown>>\n} {\n  const proxiesWithChanges = targets.map((target) => createChangeProxy(target))\n\n  return {\n    proxies: proxiesWithChanges.map((p) => p.proxy),\n    getChanges: () => proxiesWithChanges.map((p) => p.getChanges()),\n  }\n}\n\n/**\n * Creates a proxy for an object, passes it to a callback function,\n * and returns the changes made by the callback\n *\n * @param target The object to proxy\n * @param callback Function that receives the proxy and can make changes to it\n * @returns The changes made to the object\n */\nexport function withChangeTracking<T extends object>(\n  target: T,\n  callback: (proxy: T) => void,\n): Record<string | symbol, unknown> {\n  const { proxy, getChanges } = createChangeProxy(target)\n\n  callback(proxy)\n\n  return deepClone(getChanges(), undefined, true)\n}\n\n/**\n * Creates proxies for an array of objects, passes them to a callback function,\n * and returns the changes made by the callback for each object\n *\n * @param targets Array of objects to proxy\n * @param callback Function that receives the proxies and can make changes to them\n * @returns Array of changes made to each object\n */\nexport function withArrayChangeTracking<T extends object>(\n  targets: Array<T>,\n  callback: (proxies: Array<T>) => void,\n): Array<Record<string | symbol, unknown>> {\n  const { proxies, getChanges } = createArrayChangeProxy(targets)\n\n  callback(proxies)\n\n  return deepClone(getChanges(), undefined, true)\n}\n"],"names":["isTemporal","clone","deepEqualsInternal"],"mappings":";;;AAQA,MAAM,kCAAkB,QAAA;AACxB,SAAS,mBACP,QACA,KACA,OACM;AACN,MAAI,QAAQ,aAAa;AACrB,WAAwC,GAAG,IAAI;AACjD;AAAA,EACF;AACA,SAAO,eAAe,QAAQ,KAAK;AAAA,IACjC;AAAA,IACA,YAAY;AAAA,IACZ,cAAc;AAAA,IACd,UAAU;AAAA,EAAA,CACX;AACH;AAEA,SAAS,YAAY,OAAyB;AAC5C,SAAO,UAAU,QAAQ,OAAO,UAAU,WACrC,YAAY,IAAI,KAAK,KAAK,QAC3B;AACN;AAKA,MAAM,8CAA8B,IAAI;AAAA,EACtC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAKD,MAAM,+CAA+B,IAAI;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAKD,SAAS,kBACP,OAC2C;AAC3C,SACE,UAAU,QACV,OAAO,UAAU,YACjB,EAAG,iBAAyB,SAC5B,EAAG,iBAAyB,WAC5B,CAACA,MAAAA,WAAW,KAAK;AAErB;AAMA,SAAS,6BACP,UACA,eACA,aACA,UACsC;AACtC,SAAO,YAAa,MAAsB;AACxC,UAAM,SAAS,SAAS,MAAM,cAAc,OAAO,IAAI;AACvD,gBAAY,aAAa;AAEzB,WAAO,WAAW,cAAc,QAAQ,WAAW;AAAA,EACrD;AACF;AAMA,SAAS,4BACP,YACA,MACA,eACA,iBACA,2BAIoD;AACpD,MAAI,CAAC,yBAAyB,IAAI,UAAU,KAAK,SAAS,OAAO,UAAU;AACzE,WAAO;AAAA,EACT;AAEA,SAAO,IAAI,SAAS;AAClB,UAAM,OAAO,cAAc;AAC3B,UAAM,QAAQ,gBAAgB;AAC9B,QAAI,SAAS,eAAe,OAAQ,QAAO,KAAK,KAAA;AAEhD,UAAM,QAAQ,CAAC,UACb,kBAAkB,KAAK,IACnB,0BAA0B,OAAO;AAAA,MAC/B,SAAS;AAAA,MAGT,MAAM;AAAA,MACN,gBAAgB;AAAA,IAAA,CACjB,EAAE,QACH;AAEN,QAAI,eAAe,WAAW;AAC5B,YAAM,WAAW,KAAK,CAAC;AACvB,UAAI,OAAO,aAAa;AACtB,cAAM,IAAI,UAAU,qCAAqC;AAC3D,aAAO,KAAK,QAAQ,CAAC,OAAO,QAAQ;AAClC,cAAM,UAAU,MAAM,KAAK;AAC3B,iBAAS,KAAK,KAAK,CAAC,GAAG,SAAS,QAAQ,MAAM,SAAS,eAAe;AAAA,MACxE,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,KAAK,QAAA;AACrB,UAAM,QACJ,eAAe,aAAc,SAAS,SAAS,OAAO;AACxD,WAAO;AAAA,MACL,OAAO;AACL,cAAM,SAAS,QAAQ,KAAA;AACvB,YAAI,OAAO,KAAM,QAAO;AACxB,cAAM,CAAC,KAAK,KAAK,IAAI,OAAO;AAC5B,cAAM,UAAU,MAAM,KAAK;AAC3B,eAAO;AAAA,UACL,MAAM;AAAA,UACN,OAAO,QAAQ,CAAC,QAAQ,MAAM,SAAS,OAAO,IAAI;AAAA,QAAA;AAAA,MAEtD;AAAA,MACA,CAAC,OAAO,QAAQ,IAAI;AAClB,eAAO;AAAA,MACT;AAAA,IAAA;AAAA,EAEJ;AACF;AA6BA,SAAS,UACP,KACA,8BAAc,QAAA,GACd,SAAS,OACN;AAEH,QAAM,YAAY,GAAG;AAErB,MAAI,QAAQ,QAAQ,QAAQ,QAAW;AACrC,WAAO;AAAA,EACT;AAGA,MAAI,OAAO,QAAQ,UAAU;AAC3B,WAAO;AAAA,EACT;AAGA,MAAI,QAAQ,IAAI,GAAa,GAAG;AAC9B,WAAO,QAAQ,IAAI,GAAa;AAAA,EAClC;AAEA,MAAI,eAAe,MAAM;AACvB,UAAMC,SAAQ,IAAI,KAAK,IAAI,SAAS;AACpC,YAAQ,IAAI,KAAKA,MAAK;AACtB,WAAOA;AAAAA,EACT;AAEA,MAAI,eAAe,QAAQ;AACzB,UAAMA,SAAQ,IAAI,OAAO,IAAI,QAAQ,IAAI,KAAK;AAC9CA,WAAM,YAAY,IAAI;AACtB,YAAQ,IAAI,KAAKA,MAAK;AACtB,WAAOA;AAAAA,EACT;AAEA,MAAI,eAAe,KAAK;AACtB,UAAMA,SAAQ,IAAI,IAAI,IAAI,IAAI;AAC9B,YAAQ,IAAI,KAAKA,MAAK;AACtB,WAAOA;AAAAA,EACT;AAEA,MAAI,MAAM,QAAQ,GAAG,GAAG;AACtB,UAAM,aAAa,IAAI,MAAe,IAAI,MAAM;AAChD,YAAQ,IAAI,KAAe,UAAU;AACrC,QAAI,QAAQ,CAAC,MAAM,UAAU;AAC3B,iBAAW,KAAK,IAAI,UAAU,MAAM,SAAS,MAAM;AAAA,IACrD,CAAC;AACD,WAAO;AAAA,EACT;AAGA,MAAI,YAAY,OAAO,GAAG,KAAK,EAAE,eAAe,WAAW;AAGzD,UAAM,wBAAwB,OAAO,eAAe,GAAG,EAAE;AACzD,UAAMA,SAAQ,IAAI;AAAA,MACf,IAA8B;AAAA,IAAA;AAEjC,YAAQ,IAAI,KAAeA,MAAK;AAChCA,WAAM,IAAI,GAA4B;AACtC,WAAOA;AAAAA,EACT;AAEA,MAAI,eAAe,KAAK;AACtB,UAAMA,6BAAY,IAAA;AAClB,YAAQ,IAAI,KAAeA,MAAK;AAChC,QAAI,QAAQ,CAAC,OAAO,QAAQ;AAC1BA,aAAM,IAAI,KAAK,UAAU,OAAO,SAAS,MAAM,CAAC;AAAA,IAClD,CAAC;AACD,WAAOA;AAAAA,EACT;AAEA,MAAI,eAAe,KAAK;AACtB,UAAMA,6BAAY,IAAA;AAClB,YAAQ,IAAI,KAAeA,MAAK;AAChC,QAAI,QAAQ,CAAC,UAAU;AACrBA,aAAM,IAAI,UAAU,OAAO,SAAS,MAAM,CAAC;AAAA,IAC7C,CAAC;AACD,WAAOA;AAAAA,EACT;AAGA,MAAID,MAAAA,WAAW,GAAG,GAAG;AAGnB,WAAO;AAAA,EACT;AAIA,MAAI,QAAQ;AACV,UAAM,YAAY,OAAO,eAAe,GAAG;AAC3C,QAAI,cAAc,OAAO,aAAa,cAAc,KAAM,QAAO;AAAA,EACnE;AAEA,QAAM,QAAQ,CAAA;AACd,UAAQ,IAAI,KAAe,KAAK;AAGhC,aAAW,OAAO,QAAQ,QAAQ,GAAG,GAAG;AACtC,QACE,OAAO,QAAQ,YACf,OAAO,UAAU,qBAAqB,KAAK,KAAK,GAAG,GACnD;AAEA;AAAA,QACE;AAAA,QACA;AAAA,QACA;AAAA,UACG,IAAyC,GAAG;AAAA,UAC7C;AAAA,UACA;AAAA,QAAA;AAAA,MACF;AAAA,IAEJ;AAAA,EACF;AAEA,SAAO;AACT;AAIA,SAAS,iBACP,MACA,OACA,SAAS,oBAAI,OACJ;AACT,SAAOE,MAAAA,mBAAmB,MAAM,OAAO,QAAQ,IAAI;AACrD;AASO,SAAS,kBAGd,QACA,QAKA;AACA,QAAM,uCAAuB,IAAA;AAE7B,WAAS,0BAGP,aACA,aAIA;AACA,QAAI,iBAAiB,IAAI,WAAW,GAAG;AACrC,aAAO,iBAAiB,IAAI,WAAW;AAAA,IAIzC,OAAO;AACL,YAAM,cAAc,kBAAkB,aAAa,WAAW;AAC9D,uBAAiB,IAAI,aAAa,WAAW;AAC7C,aAAO;AAAA,IACT;AAAA,EACF;AAGA,QAAM,cACJ,QAAQ,QAAQ,mCAAmB,QAAA;AACrC,QAAM,gBAAkC;AAAA,IACtC;AAAA,IACA,OAAO,SACD,YAAY,IAAI,MAAM,KAAK,SAC7B,UAAU,QAAQ,WAAW;AAAA,IACjC,gBAAgB,UAAU,MAAM;AAAA,IAChC,UAAU;AAAA,IACV,WAAW,uBAAO,OAAO,IAAI;AAAA,IAC7B;AAAA,IACA;AAAA;AAAA,EAAA;AAKF,WAAS,YAAY,OAA8B;AACjD,QAAI,CAAC,MAAM,UAAU;AACnB,YAAM,WAAW;AAAA,IACnB;AAGA,QAAI,MAAM,QAAQ;AAChB,UACE,CAAC,MAAM,OAAO,kBACd,MAAM,OAAO,QAAQ,MAAM,MAAM,OAAO,IAAI,MAAM,MAAM,OACxD;AAGA,cAAM,OAAO,QAAQ,UAAU,MAAM,OAAO,IAAI,IAAI;AAAA,MACtD;AAGA,kBAAY,MAAM,OAAO,OAAO;AAAA,IAClC;AAAA,EACF;AAIA,WAAS,gBACP,OACS;AACT,QAAI,MAAM,iBAAiB,OAAO,MAAM,iBAAiB,KAAK;AAE5D,aAAO;AAAA,QACL,MAAM,KAAK,MAAM,KAAK;AAAA,QACtB,MAAM;AAAA,UACJ,MAAM;AAAA,QAAA;AAAA,MAGR;AAAA,IAEJ;AACA,eAAW,QAAQ,MAAM,WAAW;AAGlC,UACE,CAAC,MAAM,UAAU,IAAI,KACrB,OAAO,OAAO,MAAM,OAAO,IAAI,MAC7B,OAAO,OAAO,MAAM,gBAAgB,IAAI,KAC1C,CAAC;AAAA,QACC,MAAM,MAAM,IAAI;AAAA,QACf,MAAM,eAAuB,IAAI;AAAA,MAAA,GAEpC;AACA,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAGA,WAAS,kBACP,aACA;AAEA,UAAM,aAAa,gBAAgB,WAAW;AAE9C,QAAI,YAAY;AAEd,kBAAY,WAAW;AACvB,kBAAY,YAAY,uBAAO,OAAO,IAAI;AAK1C,YAAM,OAAO,YAAY;AACzB,UAAI,MAAM;AACR,YACE;AAAA,UACE,KAAK,QAAQ,MAAM,KAAK,IAAI;AAAA,UAC5B,KAAK,QAAQ,eAAe,KAAK,IAAI;AAAA,QAAA;AAGvC,iBAAO,KAAK,QAAQ,UAAU,KAAK,IAAI;AACzC,0BAAkB,KAAK,OAAO;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AAKA,QAAM,QAAQ,IAAI,MAAM,cAAc,OAAO;AAAA,IAC3C,IAAI,SAAS,MAAM,UAAU;AAC3B,YAAM,QAAQ,cAAc,MAAM,IAAe;AAGjD,YAAM,OAAO,OAAO,yBAAyB,SAAS,IAAI;AAC1D,UAAI,MAAM,KAAK;AACb,eAAO;AAAA,MACT;AAKA,UAAI,MAAM,iBAAiB,SAAS,CAAC,KAAK,UAAU;AAClD,YAAI,kBAAkB,KAAK,GAAG;AAC5B,wBAAc,UAAU,OAAO,IAAI,CAAC,IAAI;AACxC,sBAAY,aAAa;AAAA,QAC3B;AACA,eAAO;AAAA,MACT;AAGA,UAAI,OAAO,UAAU,YAAY;AAK/B,YAAI,OAAO,OAAO,SAAS,IAAI,KAAK,SAAS,cAAe,QAAO;AAEnE,cAAM,aAAa,KAAK,SAAA;AAIxB,YAAI,eAAe,cAAc,YAAY,OAAO,OAAO,GAAG;AAC5D,iBAAO,IAAI,SACT,0BAA0B,MAAM,MAAM,SAAS,IAAI,GAAG;AAAA,YACpD,SAAS;AAAA,YACT,MAAM;AAAA,YACN,gBAAgB;AAAA,UAAA,CACjB,EAAE;AAAA,QACP;AAGA,YACE,wBAAwB,IAAI,UAAU,MACrC,MAAM,QAAQ,OAAO,KAAK,YAAY,OAAO,OAAO,IACrD;AACA,iBAAO;AAAA,YACL;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UAAA;AAAA,QAEJ;AAEA,YAAI,MAAM,QAAQ,OAAO,GAAG;AAK1B,iBAAO,MAAM,KAAK,QAAQ;AAAA,QAC5B;AAGA,YAAI,mBAAmB,OAAO,mBAAmB,KAAK;AACpD,gBAAM,eAAe,CAAC,UAAmB;AACvC,kBAAM,MAAM,YAAY,KAAK;AAC7B,mBAAO,QAAQ,QAAQ,OAAO,QAAQ,WACjC,YAAY,IAAI,GAAG,KAAK,MACzB;AAAA,UACN;AAEA,cACE,eAAe,SACf,eAAe,YACf,eAAe,SACf,eAAe,OACf;AACA,mBAAO,IAAI,SAAyB;AAClC,kBAAI,mBAAmB,IAAK,MAAK,CAAC,IAAI,aAAa,KAAK,CAAC,CAAC;AAAA,uBACjD,eAAe,MAAO,MAAK,CAAC,IAAI,aAAa,KAAK,CAAC,CAAC;AAC7D,oBAAM,SAAS,MAAM,MAAM,SAAS,IAAI;AACxC,kBAAI,eAAe,MAAO,aAAY,aAAa;AACnD,qBAAO,WAAW,UAAU,WAAW;AAAA,YACzC;AAAA,UACF;AAEA,cAAI,mBAAmB,OAAO,eAAe,OAAO;AAClD,mBAAO,CAAC,QAAiB;AACvB,oBAAM,QAAQ,QAAQ,IAAI,GAAG;AAC7B,qBAAO,kBAAkB,KAAK,IAC1B,0BAA0B,OAAO;AAAA,gBAC/B,SAAS;AAAA,gBACT,MAAM;AAAA,gBACN,gBAAgB;AAAA,cAAA,CACjB,EAAE,QACH;AAAA,YACN;AAAA,UACF;AAEA,cAAI,eAAe,SAAS;AAC1B,mBAAO;AAAA,cACL;AAAA,cACA;AAAA,cACA;AAAA,cACA;AAAA,YAAA;AAAA,UAEJ;AAGA,gBAAM,kBAAkB;AAAA,YACtB;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UAAA;AAEF,cAAI,iBAAiB;AACnB,mBAAO;AAAA,UACT;AAAA,QACF;AACA,eAAO,MAAM,KAAK,OAAO;AAAA,MAC3B;AAGA,UAAI,kBAAkB,KAAK,GAAG;AAE5B,cAAM,eAAe;AAAA,UACnB,SAAS;AAAA,UACT,MAAM,OAAO,IAAI;AAAA,QAAA;AAInB,eAAO,0BAA0B,OAAO,YAAY,EAAE;AAAA,MACxD;AAEA,aAAO;AAAA,IACT;AAAA,IAEA,IAAI,OAAO,MAAM,OAAO;AACtB,YAAM,eAAe,cAAc,MAAM,IAAe;AAGxD,UACE,CAAC,OAAO,OAAO,cAAc,OAAO,IAAI,KACxC,CAAC,iBAAiB,cAAc,KAAK,GACrC;AAGA,cAAM,gBAAgB,cAAc,eAAe,IAAe;AAClE,cAAM,qBACJ,OAAO,OAAO,cAAc,gBAAgB,IAAI,KAChD,iBAAiB,OAAO,aAAa;AAEvC,YAAI,oBAAoB;AAEtB,iBAAO,cAAc,UAAU,KAAK,SAAA,CAAU;AAG9C,wBAAc,MAAM,IAAe,IAAI,UAAU,aAAa;AAI9D,wBAAc,WAAW;AACzB,4BAAkB,aAAa;AAAA,QACjC,OAAO;AAEL,wBAAc,MAAM,IAAe,IAAI;AAGvC,wBAAc,UAAU,KAAK,SAAA,CAAU,IAAI;AAG3C,sBAAY,aAAa;AAAA,QAC3B;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAAA,IAEA,eAAe,SAAS,MAAM,YAAY;AAGxC,YAAM,SAAS,QAAQ,eAAe,SAAS,MAAM,UAAU;AAE/D,UACE,WACC,WAAW,cAAc,WAAW,OAAO,WAAW,MACvD;AACA,sBAAc,UAAU,KAAK,SAAA,CAAU,IAAI;AAC3C,oBAAY,aAAa;AAAA,MAC3B;AACA,aAAO;AAAA,IACT;AAAA,IAEA,yBAAyB,SAAS,MAAM;AAEtC,aAAO,QAAQ,yBAAyB,SAAS,IAAI;AAAA,IACvD;AAAA,IAEA,kBAAkB,SAAS;AAEzB,aAAO,QAAQ,kBAAkB,OAAO;AAAA,IAC1C;AAAA,IAEA,aAAa,SAAS;AAEpB,aAAO,QAAQ,aAAa,OAAO;AAAA,IACrC;AAAA,IAEA,eAAe,MAAM,MAAM;AACzB,YAAM,aAAa,OAAO,SAAS,WAAW,KAAK,aAAa;AAEhE,UAAI,OAAO,OAAO,MAAM,IAAI,GAAG;AAE7B,cAAM,wBAAwB,OAAO;AAAA,UACnC,cAAc;AAAA,UACd;AAAA,QAAA;AAKF,cAAM,SAAS,QAAQ,eAAe,MAAM,IAAI;AAEhD,YAAI,QAAQ;AAGV,cAAI,CAAC,uBAAuB;AAC1B,mBAAO,cAAc,UAAU,UAAU;AAIzC,0BAAc,WAAW;AACzB,8BAAkB,aAAa;AAAA,UACjC,OAAO;AAEL,0BAAc,UAAU,UAAU,IAAI;AACtC,wBAAY,aAAa;AAAA,UAC3B;AAAA,QACF;AAEA,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,IACT;AAAA,EAAA,CACD;AACD,cAAY,IAAI,OAAO,cAAc,KAAK;AAG1C,SAAO;AAAA,IACL;AAAA,IACA,YAAY,MAAM;AAEhB,UAAI,CAAC,cAAc,UAAU;AAC3B,eAAO,CAAA;AAAA,MACT;AAIA,UACE,OAAO,cAAc,UAAU,YAC/B,MAAM,QAAQ,cAAc,KAAK,GACjC;AACA,eAAO,cAAc;AAAA,MACvB;AAEA,UAAI,OAAO,KAAK,cAAc,SAAS,EAAE,WAAW,GAAG;AACrD,eAAO,cAAc;AAAA,MACvB;AAEA,YAAM,SAA0C,CAAA;AAChD,YAAM,wBAAwB,OAAO,KAAK,cAAc,SAAS,EAAE;AAAA,QACjE,CAAC,QACC,OAAO,cAAc,MAAM,GAAG,MAAM,YACpC,OAAO,cAAc,eAAe,GAAG,MAAM;AAAA,MAAA;AAEjD,YAAM,kCAAkB,IAAoB;AAAA,QAC1C,CAAC,cAAc,OAAO,cAAc,cAAc;AAAA,MAAA,CACnD;AAGD,iBAAW,OAAO,cAAc,OAAO;AACrC,cAAM,QAAiB,cAAc,MAAM,GAAG;AAC9C,cAAM,WAAoB,cAAc,eAAe,GAAG;AAG1D,YACE,cAAc,UAAU,GAAG,MAAM,QAChC,yBACC,CAAC;AAAA,UACC,iBAAiB,MAAM,MAAM,KAAK,KAAK,IAAI;AAAA,UAC3C,oBAAoB,MAAM,MAAM,KAAK,QAAQ,IAAI;AAAA,UACjD;AAAA,QAAA,GAEJ;AACA,6BAAmB,QAAQ,KAAK,cAAc,MAAM,GAAG,CAAC;AAAA,QAC1D;AAAA,MACF;AAEA,iBAAW,OAAO,OAAO,KAAK,cAAc,SAAS,GAAG;AACtD,YAAI,cAAc,UAAU,GAAG,MAAM,OAAO;AAC1C,6BAAmB,QAAQ,KAAK,MAAS;AAAA,QAC3C;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAAA,EAAA;AAEJ;AAQO,SAAS,uBACd,SAIA;AACA,QAAM,qBAAqB,QAAQ,IAAI,CAAC,WAAW,kBAAkB,MAAM,CAAC;AAE5E,SAAO;AAAA,IACL,SAAS,mBAAmB,IAAI,CAAC,MAAM,EAAE,KAAK;AAAA,IAC9C,YAAY,MAAM,mBAAmB,IAAI,CAAC,MAAM,EAAE,YAAY;AAAA,EAAA;AAElE;AAUO,SAAS,mBACd,QACA,UACkC;AAClC,QAAM,EAAE,OAAO,eAAe,kBAAkB,MAAM;AAEtD,WAAS,KAAK;AAEd,SAAO,UAAU,cAAc,QAAW,IAAI;AAChD;AAUO,SAAS,wBACd,SACA,UACyC;AACzC,QAAM,EAAE,SAAS,eAAe,uBAAuB,OAAO;AAE9D,WAAS,OAAO;AAEhB,SAAO,UAAU,cAAc,QAAW,IAAI;AAChD;;;;;"}