function deepEquals(a, b, visited = new WeakMap()) {
  if (Object.is(a, b)) return true;

  if (a == null || b == null) return false;
  if (typeof a !== typeof b) return false;

  if (typeof a !== 'object' && typeof a !== 'function') return false;
  if (typeof b !== 'object' && typeof b !== 'function') return false;

  // If both are functions and Object.is(a, b) was false, they are distinct functions.
  if (typeof a === 'function') return false;

  // Cycle detection
  let aVisited = visited.get(a);
  if (aVisited && aVisited.has(b)) return true;
  if (!aVisited) {
    aVisited = new WeakSet();
    visited.set(a, aVisited);
  }
  aVisited.add(b);

  // Prototype check
  if (Reflect.getPrototypeOf(a) !== Reflect.getPrototypeOf(b)) return false;
  if (Object.isExtensible(a) !== Object.isExtensible(b)) return false;

  // Built-in specific comparisons
  if (a instanceof Number || a instanceof Boolean || a instanceof String || a instanceof Symbol || a instanceof BigInt) {
    if (!Object.is(a.valueOf(), b.valueOf())) return false;
  }

  if (a instanceof Promise || a instanceof WeakMap || a instanceof WeakSet || (typeof WeakRef !== 'undefined' && a instanceof WeakRef)) {
    return false;
  }

  if (a instanceof Date) {
    if (!Object.is(a.getTime(), b.getTime())) return false;
  }

  if (a instanceof RegExp) {
    if (a.source !== b.source || a.flags !== b.flags) return false;
  }

  if (a instanceof ArrayBuffer || (typeof SharedArrayBuffer !== 'undefined' && a instanceof SharedArrayBuffer)) {
    if (a.byteLength !== b.byteLength) return false;
    const viewA = new Uint8Array(a);
    const viewB = new Uint8Array(b);
    for (let i = 0; i < a.byteLength; i++) {
      if (viewA[i] !== viewB[i]) return false;
    }
  }

  if (a instanceof DataView) {
    if (a.byteLength !== b.byteLength) return false;
    const viewA = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
    const viewB = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
    for (let i = 0; i < a.byteLength; i++) {
      if (viewA[i] !== viewB[i]) return false;
    }
  }

  // Set comparison
  if (a instanceof Set) {
    if (a.size !== b.size) return false;
    const matchedB = new Set();
    for (const itemA of a) {
      let found = false;
      for (const itemB of b) {
        if (!matchedB.has(itemB) && deepEquals(itemA, itemB, visited)) {
          matchedB.add(itemB);
          found = true;
          break;
        }
      }
      if (!found) return false;
    }
  }

  // Map comparison
  if (a instanceof Map) {
    if (a.size !== b.size) return false;
    const matchedB = new Set();
    for (const [keyA, valA] of a) {
      let found = false;
      for (const [keyB, valB] of b) {
        if (!matchedB.has(keyB) && deepEquals(keyA, keyB, visited) && deepEquals(valA, valB, visited)) {
          matchedB.add(keyB);
          found = true;
          break;
        }
      }
      if (!found) return false;
    }
  }

  // Compare own properties (including symbols, non-enumerable properties, holey arrays, and descriptors)
  const keysA = Reflect.ownKeys(a);
  const keysB = Reflect.ownKeys(b);

  if (keysA.length !== keysB.length) return false;

  for (const key of keysA) {
    if (a instanceof Error && key === 'stack') continue; // Ignore stack traces in error comparison

    const descB = Object.getOwnPropertyDescriptor(b, key);
    if (!descB) return false;
    const descA = Object.getOwnPropertyDescriptor(a, key);

    if (descA.enumerable !== descB.enumerable) return false;
    if (descA.configurable !== descB.configurable) return false;
    if (descA.writable !== descB.writable) return false;
    if (Boolean(descA.get) !== Boolean(descB.get)) return false;
    if (Boolean(descA.set) !== Boolean(descB.set)) return false;

    if (descA.get) {
      if (!deepEquals(descA.get, descB.get, visited)) return false;
    } else {
      if (!deepEquals(a[key], b[key], visited)) return false;
    }
  }

  return true;
}

yes, one of the major use-cases is testing (where execution time is not as important), but CI time is not costless

Thanks again to everyone for the great feedback and discussion. For those curious to read more, the website of the Linden project is here: https://lin.den.re

I demoed to a few people this week the graphical debugger we built to navigate the ECMAScript regex semantics. Here's a permalink to that tricky example Aurèle demoed, and a demo of what happens when a non-linear engine tries to match a*a*b on aaaaaa (click the l flag to see what it looks like in a linear engine instead; dimmed nodes are skipped).