Function deepEqualsInternal

packages/db/src/utils.ts:36–212

* Internal implementation with cycle detection to prevent infinite recursion

(
  a: any,
  b: any,
  visited: Map<object, object>,
)

 * Internal implementation with cycle detection to prevent infinite recursion
 */
function deepEqualsInternal(
  a: any,
  b: any,
  visited: Map<object, object>,
): boolean {
  // Handle strict equality (primitives, same reference)
  if (a === b) return true

  // Handle null/undefined
  if (a == null || b == null) return false

  // Handle different types
  if (typeof a !== typeof b) return false

  // Handle Date objects
  if (a instanceof Date) {
    if (!(b instanceof Date)) return false
    return a.getTime() === b.getTime()
  }
  // Symmetric check: if b is Date but a is not, they're not equal
  if (b instanceof Date) return false

  // Handle RegExp objects
  if (a instanceof RegExp) {
    if (!(b instanceof RegExp)) return false
    return a.source === b.source && a.flags === b.flags
  }
  // Symmetric check: if b is RegExp but a is not, they're not equal
  if (b instanceof RegExp) return false

  // Handle Map objects - only if both are Maps
  if (a instanceof Map) {
    if (!(b instanceof Map)) return false
    if (a.size !== b.size) return false

    // Check for circular references
    if (visited.has(a)) {
      return visited.get(a) === b
    }
    visited.set(a, b)

    const entries = Array.from(a.entries())
    const result = entries.every(([key, val]) => {
      return b.has(key) && deepEqualsInternal(val, b.get(key), visited)
    })

    visited.delete(a)
    return result
  }
  // Symmetric check: if b is Map but a is not, they're not equal
  if (b instanceof Map) return false

  // Handle Set objects - only if both are Sets
  if (a instanceof Set) {
    if (!(b instanceof Set)) return false
    if (a.size !== b.size) return false

    // Check for circular references