Run results for: update: lodash.isEqual vs fast-deep-equal vs deepEqual implementation vs claude generated update to fast-deep-equal

Test name	Executions per second
✓ updated fast-deep-equal	22 Ops/sec
fast-deep-equal	21 Ops/sec
original deepEqual comparison	12 Ops/sec
lodash.isEqual	1 Ops/sec

lodash.isEqual

const makeObject = (count) => {
    const obj = {};

    for (let i = 0; i < count; i++) {
        obj['k' + i] = {
            id: i,
            value: i * 3,
            flag: (i & 1) === 0,
            text: 'value' + i,
        };
    }

    return obj;
};

const makeArray = (count) => {
    const arr = new Array(count);

    for (let i = 0; i < count; i++) {
        arr[i] = {
            id: i,
            name: 'item' + i,
            values: [i, i + 1, i + 2, i + 3],
            enabled: (i & 1) === 0,
        };
    }

    return arr;
};

const makeDeepObject = (depth) => {
    let root = {
        value: 0
    };
    let current = root;

    for (let i = 1; i < depth; i++) {
        current.next = {
            value: i,
            payload: {
                left: i,
                right: i + 1,
                flag: (i & 1) === 0,
            },
        };

        current = current.next;
    }

    return root;
};

const makeWideObject = (width, depth) => {
    if (depth === 0) {
        return {
            value: 1,
            text: 'leaf',
        };
    }

    const obj = {};

    for (let i = 0; i < width; i++) {
        obj['k' + i] = makeWideObject(width, depth - 1);
    }

    return obj;
};

const shuffleKeys = (obj) => {
    const entries = Object.entries(obj);

    entries.reverse();

    const out = {};

    for (const [k, v] of entries)
        out[k] = v;

    return out;
};

const makeMap = (count) => {
    const map = new Map();

    for (let i = 0; i < count; i++) {
        map.set({
            id: i
        }, {
            value: i,
            nested: {
                x: i,
                y: i + 1,
                z: i + 2,
            },
        })
    }
    return map;
};

const makeObjectKeyMap = (count) => {
    const map = new Map();

    for (let i = 0; i < count; i++) {
        map.set({
            id: i,
            nested: {
                x: i,
                u: i + 2
            }
        }, {
            value: i,
            nested: {
                x: i,
                y: i + 1,
                z: i + 2,
            },
        }, )
    }

    return map;
};

const makeSet = (count) => {
    const set = new Set();

    for (let i = 0; i < count; i++) {
        set.add({
            id: i,
            value: i,
            nested: {
                x: i,
                y: i * 2,
            },
        });
    }

    return set;
};

function makeNestedObjectSetMap(count) {
    const map = new Map();

    for (let i = 0; i < count; i++) {
        map.set({
            id: i
        }, {
            values: new Set([{
                    x: i
                },
                {
                    y: i
                },
                {
                    z: i
                },
            ]),
        }, );
    }

    return map;
};

const makeTypedArray = (count) => {
    const arr = new Float64Array(count);

    for (let i = 0; i < count; i++) {
        arr[i] = i;
    }

    return arr;
};

function buildErrorType(idxVal) {
    return [new Error(`${idxVal}`), new TypeError(`${idxVal}`), new RangeError(`${idxVal}`)][idxVal % 3];
}

function makeErrorCollection(count) {
    const arr = new Array(count);

    for (let i = 0; i < count; i++) {
        arr[i] = buildErrorType(i);
    }

    return arr;
}

const makeBuffer = (bytes) => {
    const buffer = new ArrayBuffer(bytes);
    const view = new Uint8Array(buffer);

    for (let i = 0; i < bytes; i++) {
        view[i] = i & 255;
    }

    return buffer;
};

const makeUser = (count) => ({
    id: 123,
    name: 'John',
    enabled: true,
    created: new Date(1700000000000),

    profile: {
        age: 42,
        country: 'US',
        verified: true,
    },

    tags: Array.from({
        length: count
    }, (_, i) => 'tag' + i),

    addresses: Array.from({
        length: count
    }, (_, i) => ({
        city: 'City' + i,
        zip: i,
        active: (i & 1) === 0,
    })),

    scores: new Float64Array(count),
});
      
const objA = makeObject(10000);
const lateMismatchObjB = makeObject(10000);
lateMismatchObjB.k9999 = -1;

const data = [{
        description: 'equal numbers',
        value1: 1,
        value2: 1,
        equal: true,
    },
    {
        description: 'not equal numbers',
        value1: 1,
        value2: 2,
        equal: false,
    },
    {
        description: 'number and array are not equal',
        value1: 1,
        value2: [],
        equal: false,
    },
    {
        description: '0 and object are not equal',
        value1: 0,
        value2: {},
        equal: false,
    },
    {
        description: 'equal strings',
        value1: 'a',
        value2: 'a',
        equal: true,
    },
    {
        description: 'big object',
        value1: {
            prop1: 'value1',
            prop2: 'value2',
            prop3: 'value3',
            prop4: {
                subProp1: 'sub value1',
                subProp2: {
                    subSubProp1: 'sub sub value1',
                    subSubProp2: [
                        1,
                        2,
                        {
                            prop2: 1,
                            prop: 2
                        },
                        4,
                        5,
                    ],
                },
            },
            prop5: 1000,
            prop6: new Date(2016, 2, 10),
        },
        value2: {
            prop5: 1000,
            prop3: 'value3',
            prop1: 'value1',
            prop2: 'value2',
            prop6: new Date('2016/03/10'),
            prop4: {
                subProp2: {
                    subSubProp1: 'sub sub value1',
                    subSubProp2: [
                        1,
                        2,
                        {
                            prop2: 1,
                            prop: 2
                        },
                        4,
                        5,
                    ],
                },
                subProp1: 'sub value1',
            },
        },
        equal: true,
    },
    // Stress Testing
  {
        description: '100-level linked object',
        value1: makeDeepObject(100),
        value2: makeDeepObject(100),
        equal: true,
    },
    {
        description: '200-level linked object',
        value1: makeDeepObject(200),
        value2: makeDeepObject(200),
        equal: true,
    },
    {
        description: '2500-property object',
        value1: makeObject(2500),
        value2: makeObject(2500),
        equal: true,
    },
    {
        description: '10000-property nested object-key map',
        value1: makeObjectKeyMap(10000),
        value2: makeObjectKeyMap(10000),
        equal: true,
    },
    {
        description: '6x5 object tree (~9,300 nodes)',
        value1: makeWideObject(6, 5),
        value2: makeWideObject(6, 5),
        equal: true,
    },
    {
        description: '10x2 object tree',
        value1: makeWideObject(10, 2),
        value2: makeWideObject(10, 2),
        equal: true,
    },
    {
        description: '10x2 object tree, shuffled',
        value1: makeWideObject(10, 2),
        value2: shuffleKeys(makeWideObject(10, 2)),
        equal: true,
    },
    {
        description: '2500-object array',
        value1: makeArray(2500),
        value2: makeArray(2500),
        equal: true,
    },
    {
        description: '10000-object array',
        value1: makeArray(10000),
        value2: makeArray(10000),
        equal: true,
    },
    {
        description: '2000-entry Map',
        value1: makeMap(2000),
        value2: makeMap(2000),
        equal: true,
    },
    {
        description: '4000-entry Map',
        value1: makeMap(4000),
        value2: makeMap(4000),
        equal: true,
    },
    {
        description: '2000-entry Set',
        value1: makeSet(2000),
        value2: makeSet(2000),
        equal: true,
    },
    {
        description: '2000-element Map with nested Object Set',
        value1: makeNestedObjectSetMap(2000),
        value2: makeNestedObjectSetMap(2000),
        equal: true,
    },
    {
        description: '250-element Error Collection',
        value1: makeErrorCollection(250),
        value2: makeErrorCollection(250),
        equal: true,
    },
    {
        description: '250000-element Float64Array',
        value1: makeTypedArray(250000),
        value2: makeTypedArray(250000),
        equal: true,
    },
    {
        description: '2MB ArrayBuffer',
        value1: makeBuffer(2 * 1024 * 1024),
        value2: makeBuffer(2 * 1024 * 1024),
        equal: true,
    },
    {
        description: 'realistic user object (2000 items)',
        value1: makeUser(2000),
        value2: makeUser(2000),
        equal: true,
    },
    {
        description: 'user object (10000 items)',
        value1: makeUser(10000),
        value2: makeUser(10000),
        equal: true,
    },
    {
        description: 'late mismatch object (10000 items)',
        value1: objA,
        value2: lateMismatchObjB,
        equal: false,
    },
];

const failureCollection = [];
data.forEach((item) => {
    const result = _.isEqual(item.value1, item.value2);
  	if (item.equal === result) return;
     
    const description = `Failed: ${item.description}`;
  	const message = (`library test result: (${result}) does not match expected output: (${item.equal})`);
  	failureCollection.push({description, message})
});
console.assert(failureCollection.length === 0, "%o", failureCollection);

fast-deep-equal

function oldFastDeepEqual(a, b) {
  if (a === b) return true;

  if (a && b && typeof a == 'object' && typeof b == 'object') {
    if (a.constructor !== b.constructor) return false;

    var length, i, keys;
    if (Array.isArray(a)) {
      length = a.length;
      if (length != b.length) return false;
      for (i = length; i-- !== 0;)
        if (!oldFastDeepEqual(a[i], b[i])) return false;
      return true;
    }

    if ((a instanceof Map) && (b instanceof Map)) {
      if (a.size !== b.size) return false;
      for (i of a.entries())
        if (!b.has(i[0])) return false;
      for (i of a.entries())
        if (!oldFastDeepEqual(i[1], b.get(i[0]))) return false;
      return true;
    }

    if ((a instanceof Set) && (b instanceof Set)) {
      if (a.size !== b.size) return false;
      for (i of a.entries())
        if (!b.has(i[0])) return false;
      return true;
    }

    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
      length = a.length;
      if (length != b.length) return false;
      for (i = length; i-- !== 0;)
        if (a[i] !== b[i]) return false;
      return true;
    }

    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();

    keys = Object.keys(a);
    length = keys.length;
    if (length !== Object.keys(b).length) return false;

    for (i = length; i-- !== 0;)
      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;

    for (i = length; i-- !== 0;) {
      var key = keys[i];
      if (key === '_owner' && a.$$typeof) {
        // React-specific: avoid traversing React elements' _owner.
        //  _owner contains circular references
        // and is not needed when comparing the actual elements (and not their owners)
        continue;
      }
      if (!oldFastDeepEqual(a[key], b[key])) return false;
    }

    return true;
  }

  // true if both NaN, false otherwise
  return a!==a && b!==b;
};

const makeObject = (count) => {
    const obj = {};

    for (let i = 0; i < count; i++) {
        obj['k' + i] = {
            id: i,
            value: i * 3,
            flag: (i & 1) === 0,
            text: 'value' + i,
        };
    }

    return obj;
};

const makeArray = (count) => {
    const arr = new Array(count);

    for (let i = 0; i < count; i++) {
        arr[i] = {
            id: i,
            name: 'item' + i,
            values: [i, i + 1, i + 2, i + 3],
            enabled: (i & 1) === 0,
        };
    }

    return arr;
};

const makeDeepObject = (depth) => {
    let root = {
        value: 0
    };
    let current = root;

    for (let i = 1; i < depth; i++) {
        current.next = {
            value: i,
            payload: {
                left: i,
                right: i + 1,
                flag: (i & 1) === 0,
            },
        };

        current = current.next;
    }

    return root;
};

const makeWideObject = (width, depth) => {
    if (depth === 0) {
        return {
            value: 1,
            text: 'leaf',
        };
    }

    const obj = {};

    for (let i = 0; i < width; i++) {
        obj['k' + i] = makeWideObject(width, depth - 1);
    }

    return obj;
};

const shuffleKeys = (obj) => {
    const entries = Object.entries(obj);

    entries.reverse();

    const out = {};

    for (const [k, v] of entries)
        out[k] = v;

    return out;
};

const makeMap = (count) => {
    const map = new Map();

    for (let i = 0; i < count; i++) {
        map.set({
            id: i
        }, {
            value: i,
            nested: {
                x: i,
                y: i + 1,
                z: i + 2,
            },
        })
    }
    return map;
};

const makeObjectKeyMap = (count) => {
    const map = new Map();

    for (let i = 0; i < count; i++) {
        map.set({
            id: i,
            nested: {
                x: i,
                u: i + 2
            }
        }, {
            value: i,
            nested: {
                x: i,
                y: i + 1,
                z: i + 2,
            },
        }, )
    }

    return map;
};

const makeSet = (count) => {
    const set = new Set();

    for (let i = 0; i < count; i++) {
        set.add({
            id: i,
            value: i,
            nested: {
                x: i,
                y: i * 2,
            },
        });
    }

    return set;
};

function makeNestedObjectSetMap(count) {
    const map = new Map();

    for (let i = 0; i < count; i++) {
        map.set({
            id: i
        }, {
            values: new Set([{
                    x: i
                },
                {
                    y: i
                },
                {
                    z: i
                },
            ]),
        }, );
    }

    return map;
};

const makeTypedArray = (count) => {
    const arr = new Float64Array(count);

    for (let i = 0; i < count; i++) {
        arr[i] = i;
    }

    return arr;
};

function buildErrorType(idxVal) {
    return [new Error(`${idxVal}`), new TypeError(`${idxVal}`), new RangeError(`${idxVal}`)][idxVal % 3];
}

function makeErrorCollection(count) {
    const arr = new Array(count);

    for (let i = 0; i < count; i++) {
        arr[i] = buildErrorType(i);
    }

    return arr;
}

const makeBuffer = (bytes) => {
    const buffer = new ArrayBuffer(bytes);
    const view = new Uint8Array(buffer);

    for (let i = 0; i < bytes; i++) {
        view[i] = i & 255;
    }

    return buffer;
};

const makeUser = (count) => ({
    id: 123,
    name: 'John',
    enabled: true,
    created: new Date(1700000000000),

    profile: {
        age: 42,
        country: 'US',
        verified: true,
    },

    tags: Array.from({
        length: count
    }, (_, i) => 'tag' + i),

    addresses: Array.from({
        length: count
    }, (_, i) => ({
        city: 'City' + i,
        zip: i,
        active: (i & 1) === 0,
    })),

    scores: new Float64Array(count),
});
      
const objA = makeObject(10000);
const lateMismatchObjB = makeObject(10000);
lateMismatchObjB.k9999 = -1;

const data = [{
        description: 'equal numbers',
        value1: 1,
        value2: 1,
        equal: true,
    },
    {
        description: 'not equal numbers',
        value1: 1,
        value2: 2,
        equal: false,
    },
    {
        description: 'number and array are not equal',
        value1: 1,
        value2: [],
        equal: false,
    },
    {
        description: '0 and object are not equal',
        value1: 0,
        value2: {},
        equal: false,
    },
    {
        description: 'equal strings',
        value1: 'a',
        value2: 'a',
        equal: true,
    },
    {
        description: 'big object',
        value1: {
            prop1: 'value1',
            prop2: 'value2',
            prop3: 'value3',
            prop4: {
                subProp1: 'sub value1',
                subProp2: {
                    subSubProp1: 'sub sub value1',
                    subSubProp2: [
                        1,
                        2,
                        {
                            prop2: 1,
                            prop: 2
                        },
                        4,
                        5,
                    ],
                },
            },
            prop5: 1000,
            prop6: new Date(2016, 2, 10),
        },
        value2: {
            prop5: 1000,
            prop3: 'value3',
            prop1: 'value1',
            prop2: 'value2',
            prop6: new Date('2016/03/10'),
            prop4: {
                subProp2: {
                    subSubProp1: 'sub sub value1',
                    subSubProp2: [
                        1,
                        2,
                        {
                            prop2: 1,
                            prop: 2
                        },
                        4,
                        5,
                    ],
                },
                subProp1: 'sub value1',
            },
        },
        equal: true,
    },
    // Stress Testing
  {
        description: '100-level linked object',
        value1: makeDeepObject(100),
        value2: makeDeepObject(100),
        equal: true,
    },
    {
        description: '200-level linked object',
        value1: makeDeepObject(200),
        value2: makeDeepObject(200),
        equal: true,
    },
    {
        description: '2500-property object',
        value1: makeObject(2500),
        value2: makeObject(2500),
        equal: true,
    },
    {
        description: '10000-property nested object-key map',
        value1: makeObjectKeyMap(10000),
        value2: makeObjectKeyMap(10000),
        equal: true,
    },
    {
        description: '6x5 object tree (~9,300 nodes)',
        value1: makeWideObject(6, 5),
        value2: makeWideObject(6, 5),
        equal: true,
    },
    {
        description: '10x2 object tree',
        value1: makeWideObject(10, 2),
        value2: makeWideObject(10, 2),
        equal: true,
    },
    {
        description: '10x2 object tree, shuffled',
        value1: makeWideObject(10, 2),
        value2: shuffleKeys(makeWideObject(10, 2)),
        equal: true,
    },
    {
        description: '2500-object array',
        value1: makeArray(2500),
        value2: makeArray(2500),
        equal: true,
    },
    {
        description: '10000-object array',
        value1: makeArray(10000),
        value2: makeArray(10000),
        equal: true,
    },
    {
        description: '2000-entry Map',
        value1: makeMap(2000),
        value2: makeMap(2000),
        equal: true,
    },
    {
        description: '4000-entry Map',
        value1: makeMap(4000),
        value2: makeMap(4000),
        equal: true,
    },
    {
        description: '2000-entry Set',
        value1: makeSet(2000),
        value2: makeSet(2000),
        equal: true,
    },
    {
        description: '2000-element Map with nested Object Set',
        value1: makeNestedObjectSetMap(2000),
        value2: makeNestedObjectSetMap(2000),
        equal: true,
    },
    {
        description: '250-element Error Collection',
        value1: makeErrorCollection(250),
        value2: makeErrorCollection(250),
        equal: true,
    },
    {
        description: '250000-element Float64Array',
        value1: makeTypedArray(250000),
        value2: makeTypedArray(250000),
        equal: true,
    },
    {
        description: '2MB ArrayBuffer',
        value1: makeBuffer(2 * 1024 * 1024),
        value2: makeBuffer(2 * 1024 * 1024),
        equal: true,
    },
    {
        description: 'realistic user object (2000 items)',
        value1: makeUser(2000),
        value2: makeUser(2000),
        equal: true,
    },
    {
        description: 'user object (10000 items)',
        value1: makeUser(10000),
        value2: makeUser(10000),
        equal: true,
    },
    {
        description: 'late mismatch object (10000 items)',
        value1: objA,
        value2: lateMismatchObjB,
        equal: false,
    },
];

const failureCollection = [];
data.forEach((item) => {
    const result = oldFastDeepEqual(item.value1, item.value2);
  	  	if (item.equal === result) return;
     
    const description = `Failed: ${item.description}`;
  	const message = (`library test result: (${result}) does not match expected output: (${item.equal})`);
  	failureCollection.push({description, message})
});
console.assert(failureCollection.length === 0, "%o", failureCollection);

updated fast-deep-equal

/**
 * Fast, strict deep-equality comparison.
 *
 * Supports: primitives (incl. NaN), Date, RegExp, Array, Map, Set,
 * ArrayBuffer views (TypedArrays, including BigInt64Array / BigUint64Array
 * where the environment provides them), and plain objects compared by
 * their own enumerable string-keyed properties.
 *
 * This is a port of the ajv-validator/fast-deep-equal "es6"
 * template, with the following algorithmic changes over the original:
 *
 *  - Map comparison is a single pass instead of two (`has` + `equal` are
 *    checked together while iterating `a` once).
 *  - Set comparison iterates values directly instead of `.entries()`,
 *    avoiding an unnecessary [value, value] tuple allocation per item.
 *  - Plain-object comparison merges the "own property" check and the
 *    "recursive equality" check into a single reverse pass over the keys
 *    instead of two separate passes.
 *  - `Object.prototype.hasOwnProperty` / `valueOf` / `toString` are
 *    resolved once at module scope instead of being looked up on every
 *    call, since `Object.prototype.x` is otherwise re-resolved on every
 *    invocation of `equal`.
 *  - The `it.react`-specific `_owner` skip from the original template was
 *    dropped; it was optional/templated behavior outside the core
 *    equality semantics. Reintroduce it as an explicit key-skip predicate
 *    if you need it back.
 */

const objectProto = Object.prototype;
const hasOwnProperty = objectProto.hasOwnProperty;
const defaultValueOf = objectProto.valueOf;
const defaultToString = objectProto.toString;

function updatedFastDeepEqual(a, b) {
  if (a === b) return true;

  if (a && b && typeof a === 'object' && typeof b === 'object') {
    const objA = a;
    const objB = b;

    if (objA.constructor !== objB.constructor) return false;

    let length;
    let i;

    if (Array.isArray(objA)) {
      const arrA = objA;
      const arrB = objB;
      length = arrA.length;
      if (length !== arrB.length) return false;
      for (i = length; i-- !== 0;) {
        if (!updatedFastDeepEqual(arrA[i], arrB[i])) return false;
      }
      return true;
    }

    if (objA instanceof Map && objB instanceof Map) {
      if (objA.size !== objB.size) return false;
      for (const [key, value] of objA) {
        if (!objB.has(key) || !updatedFastDeepEqual(value, objB.get(key))) return false;
      }
      return true;
    }

    if (objA instanceof Set && objB instanceof Set) {
      if (objA.size !== objB.size) return false;
      for (const value of objA) {
        if (!objB.has(value)) return false;
      }
      return true;
    }

    if (ArrayBuffer.isView(objA) && ArrayBuffer.isView(objB)) {
      // Note: like the original, this assumes TypedArray-style `.length`.
      // A bare DataView has `.byteLength`, not `.length`; DataView equality
      // is out of scope here, matching upstream fast-deep-equal behavior.
      const viewA = objA;
      const viewB = objB;
      length = viewA.length;
      if (length !== viewB.length) return false;
      for (i = length; i-- !== 0;) {
        if (viewA[i] !== viewB[i]) return false;
      }
      return true;
    }

    if (objA.constructor === RegExp) {
      const reA = objA;
      const reB = objB;
      return reA.source === reB.source && reA.flags === reB.flags;
    }

    const valueOfA = (objA).valueOf;
    if (valueOfA !== defaultValueOf) {
      return valueOfA.call(objA) === (objB).valueOf.call(objB);
    }

    const toStringA = (objA).toString;
    if (toStringA !== defaultToString) {
      return toStringA.call(objA) === (objB).toString.call(objB);
    }

    const keys = Object.keys(objA);
    length = keys.length;
    if (length !== Object.keys(objB).length) return false;

    // Single combined pass: own-property check + recursive equality.
    for (i = length; i-- !== 0;) {
      const key = keys[i];
      if (!hasOwnProperty.call(objB, key) || !updatedFastDeepEqual(objA[key], objB[key])) {
        return false;
      }
    }

    return true;
  }

  // Reached only for non-object values that failed `a === b`:
  // true iff both are NaN, false otherwise.
  return a !== a && b !== b;
}


const makeObject = (count) => {
  const obj = {};

  for (let i = 0; i < count; i++) {
    obj['k' + i] = {
      id: i,
      value: i * 3,
      flag: (i & 1) === 0,
      text: 'value' + i,
    };
  }

  return obj;
};

const makeArray = (count) => {
  const arr = new Array(count);

  for (let i = 0; i < count; i++) {
    arr[i] = {
      id: i,
      name: 'item' + i,
      values: [i, i + 1, i + 2, i + 3],
      enabled: (i & 1) === 0,
    };
  }

  return arr;
};

const makeDeepObject = (depth) => {
  let root = {
    value: 0
  };
  let current = root;

  for (let i = 1; i < depth; i++) {
    current.next = {
      value: i,
      payload: {
        left: i,
        right: i + 1,
        flag: (i & 1) === 0,
      },
    };

    current = current.next;
  }

  return root;
};

const makeWideObject = (width, depth) => {
  if (depth === 0) {
    return {
      value: 1,
      text: 'leaf',
    };
  }

  const obj = {};

  for (let i = 0; i < width; i++) {
    obj['k' + i] = makeWideObject(width, depth - 1);
  }

  return obj;
};

const shuffleKeys = (obj) => {
  const entries = Object.entries(obj);

  entries.reverse();

  const out = {};

  for (const [k, v] of entries)
    out[k] = v;

  return out;
};

const makeMap = (count) => {
  const map = new Map();

  for (let i = 0; i < count; i++) {
    map.set({
      id: i
    }, {
      value: i,
      nested: {
        x: i,
        y: i + 1,
        z: i + 2,
      },
    })
  }
  return map;
};

const makeObjectKeyMap = (count) => {
  const map = new Map();

  for (let i = 0; i < count; i++) {
    map.set({
      id: i,
      nested: {
        x: i,
        u: i + 2
      }
    }, {
      value: i,
      nested: {
        x: i,
        y: i + 1,
        z: i + 2,
      },
    },)
  }

  return map;
};

const makeSet = (count) => {
  const set = new Set();

  for (let i = 0; i < count; i++) {
    set.add({
      id: i,
      value: i,
      nested: {
        x: i,
        y: i * 2,
      },
    });
  }

  return set;
};

function makeNestedObjectSetMap(count) {
  const map = new Map();

  for (let i = 0; i < count; i++) {
    map.set({
      id: i
    }, {
      values: new Set([{
        x: i
      },
      {
        y: i
      },
      {
        z: i
      },
      ]),
    },);
  }

  return map;
};

const makeTypedArray = (count) => {
  const arr = new Float64Array(count);

  for (let i = 0; i < count; i++) {
    arr[i] = i;
  }

  return arr;
};

function buildErrorType(idxVal) {
  return [new Error(`${idxVal}`), new TypeError(`${idxVal}`), new RangeError(`${idxVal}`)][idxVal % 3];
}

function makeErrorCollection(count) {
  const arr = new Array(count);

  for (let i = 0; i < count; i++) {
    arr[i] = buildErrorType(i);
  }

  return arr;
}

const makeBuffer = (bytes) => {
  const buffer = new ArrayBuffer(bytes);
  const view = new Uint8Array(buffer);

  for (let i = 0; i < bytes; i++) {
    view[i] = i & 255;
  }

  return buffer;
};

const makeUser = (count) => ({
  id: 123,
  name: 'John',
  enabled: true,
  created: new Date(1700000000000),

  profile: {
    age: 42,
    country: 'US',
    verified: true,
  },

  tags: Array.from({
    length: count
  }, (_, i) => 'tag' + i),

  addresses: Array.from({
    length: count
  }, (_, i) => ({
    city: 'City' + i,
    zip: i,
    active: (i & 1) === 0,
  })),

  scores: new Float64Array(count),
});

const objA = makeObject(10000);
const lateMismatchObjB = makeObject(10000);
lateMismatchObjB.k9999 = -1;

const data = [{
  description: 'equal numbers',
  value1: 1,
  value2: 1,
  equal: true,
},
{
  description: 'not equal numbers',
  value1: 1,
  value2: 2,
  equal: false,
},
{
  description: 'number and array are not equal',
  value1: 1,
  value2: [],
  equal: false,
},
{
  description: '0 and object are not equal',
  value1: 0,
  value2: {},
  equal: false,
},
{
  description: 'equal strings',
  value1: 'a',
  value2: 'a',
  equal: true,
},
{
  description: 'big object',
  value1: {
    prop1: 'value1',
    prop2: 'value2',
    prop3: 'value3',
    prop4: {
      subProp1: 'sub value1',
      subProp2: {
        subSubProp1: 'sub sub value1',
        subSubProp2: [
          1,
          2,
          {
            prop2: 1,
            prop: 2
          },
          4,
          5,
        ],
      },
    },
    prop5: 1000,
    prop6: new Date(2016, 2, 10),
  },
  value2: {
    prop5: 1000,
    prop3: 'value3',
    prop1: 'value1',
    prop2: 'value2',
    prop6: new Date('2016/03/10'),
    prop4: {
      subProp2: {
        subSubProp1: 'sub sub value1',
        subSubProp2: [
          1,
          2,
          {
            prop2: 1,
            prop: 2
          },
          4,
          5,
        ],
      },
      subProp1: 'sub value1',
    },
  },
  equal: true,
},
// Stress Testing
{
  description: '100-level linked object',
  value1: makeDeepObject(100),
  value2: makeDeepObject(100),
  equal: true,
},
{
  description: '200-level linked object',
  value1: makeDeepObject(200),
  value2: makeDeepObject(200),
  equal: true,
},
{
  description: '2500-property object',
  value1: makeObject(2500),
  value2: makeObject(2500),
  equal: true,
},
{
  description: '10000-property nested object-key map',
  value1: makeObjectKeyMap(10000),
  value2: makeObjectKeyMap(10000),
  equal: true,
},
{
  description: '6x5 object tree (~9,300 nodes)',
  value1: makeWideObject(6, 5),
  value2: makeWideObject(6, 5),
  equal: true,
},
{
  description: '10x2 object tree',
  value1: makeWideObject(10, 2),
  value2: makeWideObject(10, 2),
  equal: true,
},
{
  description: '10x2 object tree, shuffled',
  value1: makeWideObject(10, 2),
  value2: shuffleKeys(makeWideObject(10, 2)),
  equal: true,
},
{
  description: '2500-object array',
  value1: makeArray(2500),
  value2: makeArray(2500),
  equal: true,
},
{
  description: '10000-object array',
  value1: makeArray(10000),
  value2: makeArray(10000),
  equal: true,
},
{
  description: '2000-entry Map',
  value1: makeMap(2000),
  value2: makeMap(2000),
  equal: true,
},
{
  description: '4000-entry Map',
  value1: makeMap(4000),
  value2: makeMap(4000),
  equal: true,
},
{
  description: '2000-entry Set',
  value1: makeSet(2000),
  value2: makeSet(2000),
  equal: true,
},
{
  description: '2000-element Map with nested Object Set',
  value1: makeNestedObjectSetMap(2000),
  value2: makeNestedObjectSetMap(2000),
  equal: true,
},
{
  description: '250-element Error Collection',
  value1: makeErrorCollection(250),
  value2: makeErrorCollection(250),
  equal: true,
},
{
  description: '250000-element Float64Array',
  value1: makeTypedArray(250000),
  value2: makeTypedArray(250000),
  equal: true,
},
{
  description: '2MB ArrayBuffer',
  value1: makeBuffer(2 * 1024 * 1024),
  value2: makeBuffer(2 * 1024 * 1024),
  equal: true,
},
{
  description: 'realistic user object (2000 items)',
  value1: makeUser(2000),
  value2: makeUser(2000),
  equal: true,
},
{
  description: 'user object (10000 items)',
  value1: makeUser(10000),
  value2: makeUser(10000),
  equal: true,
},
{
  description: 'late mismatch object (10000 items)',
  value1: objA,
  value2: lateMismatchObjB,
  equal: false,
},
];

const failureCollection = [];
data.forEach((item) => {
  const result = updatedFastDeepEqual(item.value1, item.value2);
  	if (item.equal === result) return;
     
    const description = `Failed: ${item.description}`;
  	const message = (`library test result: (${result}) does not match expected output: (${item.equal})`);
  	failureCollection.push({description, message})
});
console.assert(failureCollection.length === 0, "%o", failureCollection);

original deepEqual comparison

function deepEqual(object1, object2) {
  const keys1 = Object.keys(object1);
  const keys2 = Object.keys(object2);
  if (keys1.length !== keys2.length) {
    return false;
  }
  for (const key of keys1) {
    const val1 = object1[key];
    const val2 = object2[key];
    const areObjects = isObject(val1) && isObject(val2);
    if (
      areObjects && !deepEqual(val1, val2) ||
      !areObjects && val1 !== val2
    ) {
      return false;
    }
  }
  return true;
}

function isObject(object) {
  return object != null && typeof object === 'object';
}


const makeObject = (count) => {
  const obj = {};

  for (let i = 0; i < count; i++) {
    obj['k' + i] = {
      id: i,
      value: i * 3,
      flag: (i & 1) === 0,
      text: 'value' + i,
    };
  }

  return obj;
};

const makeArray = (count) => {
  const arr = new Array(count);

  for (let i = 0; i < count; i++) {
    arr[i] = {
      id: i,
      name: 'item' + i,
      values: [i, i + 1, i + 2, i + 3],
      enabled: (i & 1) === 0,
    };
  }

  return arr;
};

const makeDeepObject = (depth) => {
  let root = {
    value: 0
  };
  let current = root;

  for (let i = 1; i < depth; i++) {
    current.next = {
      value: i,
      payload: {
        left: i,
        right: i + 1,
        flag: (i & 1) === 0,
      },
    };

    current = current.next;
  }

  return root;
};

const makeWideObject = (width, depth) => {
  if (depth === 0) {
    return {
      value: 1,
      text: 'leaf',
    };
  }

  const obj = {};

  for (let i = 0; i < width; i++) {
    obj['k' + i] = makeWideObject(width, depth - 1);
  }

  return obj;
};

const shuffleKeys = (obj) => {
  const entries = Object.entries(obj);

  entries.reverse();

  const out = {};

  for (const [k, v] of entries)
    out[k] = v;

  return out;
};

const makeMap = (count) => {
  const map = new Map();

  for (let i = 0; i < count; i++) {
    map.set({
      id: i
    }, {
      value: i,
      nested: {
        x: i,
        y: i + 1,
        z: i + 2,
      },
    })
  }
  return map;
};

const makeObjectKeyMap = (count) => {
  const map = new Map();

  for (let i = 0; i < count; i++) {
    map.set({
      id: i,
      nested: {
        x: i,
        u: i + 2
      }
    }, {
      value: i,
      nested: {
        x: i,
        y: i + 1,
        z: i + 2,
      },
    },)
  }

  return map;
};

const makeSet = (count) => {
  const set = new Set();

  for (let i = 0; i < count; i++) {
    set.add({
      id: i,
      value: i,
      nested: {
        x: i,
        y: i * 2,
      },
    });
  }

  return set;
};

function makeNestedObjectSetMap(count) {
  const map = new Map();

  for (let i = 0; i < count; i++) {
    map.set({
      id: i
    }, {
      values: new Set([{
        x: i
      },
      {
        y: i
      },
      {
        z: i
      },
      ]),
    },);
  }

  return map;
};

const makeTypedArray = (count) => {
  const arr = new Float64Array(count);

  for (let i = 0; i < count; i++) {
    arr[i] = i;
  }

  return arr;
};

function buildErrorType(idxVal) {
  return [new Error(`${idxVal}`), new TypeError(`${idxVal}`), new RangeError(`${idxVal}`)][idxVal % 3];
}

function makeErrorCollection(count) {
  const arr = new Array(count);

  for (let i = 0; i < count; i++) {
    arr[i] = buildErrorType(i);
  }

  return arr;
}

const makeBuffer = (bytes) => {
  const buffer = new ArrayBuffer(bytes);
  const view = new Uint8Array(buffer);

  for (let i = 0; i < bytes; i++) {
    view[i] = i & 255;
  }

  return buffer;
};

const makeUser = (count) => ({
  id: 123,
  name: 'John',
  enabled: true,
  created: new Date(1700000000000),

  profile: {
    age: 42,
    country: 'US',
    verified: true,
  },

  tags: Array.from({
    length: count
  }, (_, i) => 'tag' + i),

  addresses: Array.from({
    length: count
  }, (_, i) => ({
    city: 'City' + i,
    zip: i,
    active: (i & 1) === 0,
  })),

  scores: new Float64Array(count),
});

const objA = makeObject(10000);
const lateMismatchObjB = makeObject(10000);
lateMismatchObjB.k9999 = -1;

const data = [{
  description: 'equal numbers',
  value1: 1,
  value2: 1,
  equal: true,
},
{
  description: 'not equal numbers',
  value1: 1,
  value2: 2,
  equal: false,
},
{
  description: 'number and array are not equal',
  value1: 1,
  value2: [],
  equal: false,
},
{
  description: '0 and object are not equal',
  value1: 0,
  value2: {},
  equal: false,
},
{
  description: 'equal strings',
  value1: 'a',
  value2: 'a',
  equal: true,
},
{
  description: 'big object',
  value1: {
    prop1: 'value1',
    prop2: 'value2',
    prop3: 'value3',
    prop4: {
      subProp1: 'sub value1',
      subProp2: {
        subSubProp1: 'sub sub value1',
        subSubProp2: [
          1,
          2,
          {
            prop2: 1,
            prop: 2
          },
          4,
          5,
        ],
      },
    },
    prop5: 1000,
    prop6: new Date(2016, 2, 10),
  },
  value2: {
    prop5: 1000,
    prop3: 'value3',
    prop1: 'value1',
    prop2: 'value2',
    prop6: new Date('2016/03/10'),
    prop4: {
      subProp2: {
        subSubProp1: 'sub sub value1',
        subSubProp2: [
          1,
          2,
          {
            prop2: 1,
            prop: 2
          },
          4,
          5,
        ],
      },
      subProp1: 'sub value1',
    },
  },
  equal: true,
},
// Stress Testing
{
  description: '100-level linked object',
  value1: makeDeepObject(100),
  value2: makeDeepObject(100),
  equal: true,
},
{
  description: '200-level linked object',
  value1: makeDeepObject(200),
  value2: makeDeepObject(200),
  equal: true,
},
{
  description: '2500-property object',
  value1: makeObject(2500),
  value2: makeObject(2500),
  equal: true,
},
{
  description: '10000-property nested object-key map',
  value1: makeObjectKeyMap(10000),
  value2: makeObjectKeyMap(10000),
  equal: true,
},
{
  description: '6x5 object tree (~9,300 nodes)',
  value1: makeWideObject(6, 5),
  value2: makeWideObject(6, 5),
  equal: true,
},
{
  description: '10x2 object tree',
  value1: makeWideObject(10, 2),
  value2: makeWideObject(10, 2),
  equal: true,
},
{
  description: '10x2 object tree, shuffled',
  value1: makeWideObject(10, 2),
  value2: shuffleKeys(makeWideObject(10, 2)),
  equal: true,
},
{
  description: '2500-object array',
  value1: makeArray(2500),
  value2: makeArray(2500),
  equal: true,
},
{
  description: '10000-object array',
  value1: makeArray(10000),
  value2: makeArray(10000),
  equal: true,
},
{
  description: '2000-entry Map',
  value1: makeMap(2000),
  value2: makeMap(2000),
  equal: true,
},
{
  description: '4000-entry Map',
  value1: makeMap(4000),
  value2: makeMap(4000),
  equal: true,
},
{
  description: '2000-entry Set',
  value1: makeSet(2000),
  value2: makeSet(2000),
  equal: true,
},
{
  description: '2000-element Map with nested Object Set',
  value1: makeNestedObjectSetMap(2000),
  value2: makeNestedObjectSetMap(2000),
  equal: true,
},
{
  description: '250-element Error Collection',
  value1: makeErrorCollection(250),
  value2: makeErrorCollection(250),
  equal: true,
},
{
  description: '250000-element Float64Array',
  value1: makeTypedArray(250000),
  value2: makeTypedArray(250000),
  equal: true,
},
{
  description: '2MB ArrayBuffer',
  value1: makeBuffer(2 * 1024 * 1024),
  value2: makeBuffer(2 * 1024 * 1024),
  equal: true,
},
{
  description: 'realistic user object (2000 items)',
  value1: makeUser(2000),
  value2: makeUser(2000),
  equal: true,
},
{
  description: 'user object (10000 items)',
  value1: makeUser(10000),
  value2: makeUser(10000),
  equal: true,
},
{
  description: 'late mismatch object (10000 items)',
  value1: objA,
  value2: lateMismatchObjB,
  equal: false,
},
];

const failureCollection = [];
data.forEach((item) => {
  const result = deepEqual(item.value1, item.value2);
  	if (item.equal === result) return;
     
    const description = `Failed: ${item.description}`;
  	const message = (`library test result: (${result}) does not match expected output: (${item.equal})`);
  	failureCollection.push({description, message})
});
console.assert(failureCollection.length === 0, "%o", failureCollection);