@dungarees/core 0.11.0 → 0.11.2

package/util.js

@@ -36,107 +36,89 @@ export const toCamelCase = (segments) => {
 };
 export const kebabCase2camelCase = (kebabCase) => toCamelCase(fromKebabCase(kebabCase));
 export const camelCase2kebabCase = (camelCase) => toKebabCase(fromCamelCase(camelCase));
+// `null` has to be excluded explicitly: `typeof null` is `'object'`, so without this a null value
+// reaches the key walks below and throws instead of simply not matching.
+const isKeyedObject = (input) => typeof input === 'object' && input !== null;
+const isDataViewEqual = (a, b) => {
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    for (let index = a.byteLength; index-- !== 0;) {
+        if (a.getUint8(index) !== b.getUint8(index)) {
+            return false;
+        }
+    }
+    return true;
+};
+// `valueOf` and `toString` exist on every object, so the only useful question is whether this one
+// replaced them with something that describes its value.
+const hasOwnValueOf = (value) => value.valueOf !== Object.prototype.valueOf && typeof value.valueOf === 'function';
+// Called through a parameter whose own `toString` is declared, so the call is not read as a
+// stringification of a plain object.
+const toOwnString = (value) => value.toString();
+const hasOwnToString = (value) => value.toString !== Object.prototype.toString && typeof value.toString === 'function';
 export const isDeepEqual = (a, b) => {
     // in order to support circular references we have to keep track of visited objects.
     // for that reason we have to create new function for each invocation.
     const visited = new WeakMap();
-    // eslint-disable-next-line complexity
     const inner = (a, b) => {
         // in case strict equality - there is nothing to check anymore.
         if (a === b) {
             return true;
         }
-        // in case any of values is not an object, there is nothing to do, except to check strict equality.
-        if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) {
+        // in case any of values is not an object, there is nothing to do, except to check strict
+        // equality.
+        if (!isKeyedObject(a) || !isKeyedObject(b)) {
             // looks weird, but it is most efficient way to test NaN.
-            // otherwise we have to involve Number.isNaN, which causes context switch and therefore is slower.
-            // eslint-disable-next-line no-self-compare
+            // otherwise we have to involve Number.isNaN, which causes context switch and therefore is
+            // slower.
             return a !== a && b !== b;
         }
         // if constructors are different, objects are definitely not equal.
         if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) {
             return false;
         }
-        const { constructor } = a;
-        if (constructor === Date) {
+        if (a instanceof Date && b instanceof Date) {
             return a.getTime() === b.getTime();
         }
-        if (constructor === RegExp) {
+        if (a instanceof RegExp && b instanceof RegExp) {
             return a.source === b.source && a.flags === b.flags;
         }
-        if (constructor === Set) {
-            if (a.size !== b.size) {
-                return false;
-            }
-            for (const value of a) {
-                if (!b.has(value)) {
-                    return false;
-                }
-            }
-            return true;
+        if (a instanceof Set && b instanceof Set) {
+            return a.size === b.size && [...a].every((value) => b.has(value));
         }
-        if (constructor === ArrayBuffer) {
-            a = new DataView(a);
-            b = new DataView(b);
-        }
-        if (constructor === DataView || ArrayBuffer.isView(a)) {
-            // this is a TypedArray.
-            if (constructor !== DataView) {
-                a = new DataView(a.buffer);
-                b = new DataView(b.buffer);
-            }
-            if (a.byteLength !== b.byteLength)
-                return false;
-            for (let i = a.byteLength; i-- !== 0;) {
-                if (a.getUint8(i) !== b.getUint8(i)) {
-                    return false;
-                }
-            }
-            return true;
+        if (a instanceof ArrayBuffer && b instanceof ArrayBuffer) {
+            return isDataViewEqual(new DataView(a), new DataView(b));
+        }
+        if (a instanceof DataView && b instanceof DataView) {
+            return isDataViewEqual(a, b);
+        }
+        // this is a TypedArray.
+        if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+            return isDataViewEqual(new DataView(a.buffer), new DataView(b.buffer));
         }
         // Check circular references
-        if (visited.has(a) && visited.get(a) === b) {
+        if (visited.get(a) === b) {
             return true;
         }
         visited.set(a, b);
-        if (constructor === Array) {
-            if (a.length !== b.length) {
-                return false;
-            }
-            for (let i = a.length; i-- !== 0;) {
-                if (!inner(a[i], b[i])) {
-                    return false;
-                }
-            }
-            return true;
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return a.length === b.length && a.every((item, index) => inner(item, b[index]));
         }
-        if (constructor === Map) {
-            if (a.size !== b.size) {
-                return false;
-            }
-            for (const entry of a) {
-                if (!b.has(entry[0]) || !inner(entry[1], b.get(entry[0]))) {
-                    return false;
-                }
-            }
-            return true;
+        if (a instanceof Map && b instanceof Map) {
+            return (a.size === b.size && [...a].every(([key, value]) => b.has(key) && inner(value, b.get(key))));
         }
-        // at this point, we've handled all possible data containers and we can compare objects as plain.
-        if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === 'function' && typeof b.valueOf === 'function') {
+        // at this point, we've handled all possible data containers and we can compare objects as
+        // plain.
+        if (hasOwnValueOf(a) && hasOwnValueOf(b)) {
             return a.valueOf() === b.valueOf();
         }
-        if (a.toString !== Object.prototype.toString && typeof a.toString === 'function' && typeof b.toString === 'function') {
-            return a.toString() === b.toString();
+        if (hasOwnToString(a) && hasOwnToString(b)) {
+            return toOwnString(a) === toOwnString(b);
         }
         const aKeys = Object.keys(a);
-        let key;
-        for (let l = aKeys.length; l-- !== 0;) {
-            key = aKeys[l];
-            if (!Object.hasOwn(b, key) || !inner(a[key], b[key])) {
-                return false;
-            }
-        }
-        return Object.keys(b).length === aKeys.length;
+        return (aKeys.length === Object.keys(b).length &&
+            aKeys.every((key) => Object.hasOwn(b, key) && inner(a[key], b[key])));
     };
     return inner(a, b);
 };
@@ -144,19 +126,17 @@ export const deepEqualPartial = (actual, expected) => {
     if (actual === undefined || actual === null) {
         return true;
     }
-    const isObject = (input) => typeof input === 'object';
-    if (!isObject(expected)) {
+    if (!isKeyedObject(expected)) {
         return expected === actual;
     }
-    if (!isObject(actual)) {
+    if (!isKeyedObject(actual)) {
         return false;
     }
     return Object.keys(actual).every((key) => {
-        const val = actual[key];
-        if (val instanceof Object) {
-            return deepEqualPartial(expected[key], val);
-        }
-        return actual[key] === expected[key];
+        const value = actual[key];
+        return value instanceof Object
+            ? deepEqualPartial(expected[key], value)
+            : value === expected[key];
     });
 };
 export const findByPattern = (patterns, itemToMatch) => patterns
@@ -210,7 +190,7 @@ export const assertTypeByGuard = ({ value, guard, message, }) => {
     }
     return value;
 };
-export const assertPredicate = ({ value, predicate, message, }) => {
+export const assertPredicate = ({ value, predicate, message }) => {
     if (!predicate(value)) {
         throw new Error(getErrorMessage(message, value));
     }
@@ -222,15 +202,55 @@ export const assertImpossible = (message) => {
 const getErrorMessage = (message, value) => typeof message === 'function' ? message(value) : message;
 export const unPrototypeProperties = (obj, keys) => {
     const propertyEntries = keys.map((key) => {
-        const value = isFunction(obj[key]) ? (...args) => obj[key](...args) : obj[key];
-        return [key, value];
+        const property = obj[key];
+        return [key, isFunction(property) ? property.bind(obj) : property];
     });
     return Object.fromEntries(propertyEntries);
 };
 const isFunction = (value) => value instanceof Function;
-export const mapConst = (array) => (transformer) => {
-    return array.map((item) => transformer(item));
+export const boolFromThrow = (fn) => {
+    try {
+        fn();
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const boolFromThrowAsync = async (fn) => {
+    try {
+        await fn();
+        return true;
+    }
+    catch {
+        return false;
+    }
 };
+export function mapConst(array, transformer) {
+    return transformer === undefined
+        ? (t) => {
+            return array.map((item, index) => t(item, index));
+        }
+        : array.map((item, index) => transformer(item, index));
+}
+export function mapConstKeysToEntries(array, transformer) {
+    return transformer === undefined
+        ? (t) => {
+            return array.map((item, index) => [
+                item,
+                t(item, index),
+            ]);
+        }
+        : array.map((item, index) => [
+            item,
+            transformer(item, index),
+        ]);
+}
 export const objectFromConstEntries = (entries) => {
     return Object.fromEntries(entries);
 };
+export function mapObjectFromKeys(keys, transformer) {
+    return transformer === undefined
+        ? (t) => objectFromConstEntries(mapConstKeysToEntries(keys)(t))
+        : objectFromConstEntries(mapConstKeysToEntries(keys, transformer));
+}

package/util.test.js

@@ -1,23 +1,22 @@
-import { assertDefined, assertPredicate, assertTypeByGuard, assertImpossible, camelCase2kebabCase, capitalize, deepEqualPartial, findByPattern, isDefined, join, kebabCase2camelCase, makeObjectFromStringLiteral, mapConst, optionalPatternToList, pluralize, split, unPrototypeProperties, objectFromConstEntries, } from './util.js';
-import { assert } from 'tsafe';
-import { expect, test } from 'vitest';
+import { assertDefined, assertImpossible, assertPredicate, assertTypeByGuard, boolFromThrow, boolFromThrowAsync, camelCase2kebabCase, capitalize, deepEqualPartial, findByPattern, isDeepEqual, isDefined, join, kebabCase2camelCase, makeObjectFromStringLiteral, mapConst, mapConstKeysToEntries, mapObjectFromKeys, objectFromConstEntries, optionalPatternToList, pluralize, split, unPrototypeProperties, } from './util.js';
+import { expect, expectTypeOf, test } from 'vitest';
 test('makeObjectFromStringLiteral', () => {
     const obj = makeObjectFromStringLiteral('key', 1);
     expect(obj['key']).toBe(1);
 });
 test('split is working in a typesafe way', () => {
     const splitted = split('a.a.a', '.');
-    assert();
+    expectTypeOf().toEqualTypeOf();
     expect(splitted).toEqual(['a', 'a', 'a']);
 });
 test('join is working in a typesafe way', () => {
     const joined = join(['a', 'a', 'a'], '.');
-    assert();
+    expectTypeOf().toEqualTypeOf();
     expect(joined).toBe('a.a.a');
 });
 test('capitalize', () => {
     const capitalized = capitalize('apple');
-    assert();
+    expectTypeOf().toEqualTypeOf();
     expect(capitalized).toBe('Apple');
 });
 test('pluralize', () => {
@@ -34,14 +33,14 @@ test('kebabCase2camelCase', () => {
     const camelCase = 'firstSecondThird';
     const output = kebabCase2camelCase(kebabCase);
     expect(output).toBe(camelCase);
-    assert();
+    expectTypeOf().toEqualTypeOf();
 });
 test('camelCase2kebabCase', () => {
     const kebabCase = 'first-second-third';
     const camelCase = 'firstSecondThird';
     const output = camelCase2kebabCase(camelCase);
     expect(output).toBe(kebabCase);
-    assert();
+    expectTypeOf().toEqualTypeOf();
 });
 test('deepEqualPartial', () => {
     expect(deepEqualPartial({}, {})).toBe(true);
@@ -52,18 +51,22 @@ test('deepEqualPartial', () => {
     expect(deepEqualPartial({ foo: { baz: 'bar' } }, { foo: { baz: 'bar' }, quux: 'kill me' })).toBe(true);
     expect(deepEqualPartial({ foo: { baz: 'baz' } }, { foo: { baz: 'bar' }, quux: 'kill me' })).toBe(false);
 });
+test('deepEqualPartial treats a null expected as unequal rather than throwing', () => {
+    expect(deepEqualPartial({ baz: 54 }, null)).toBe(false);
+    expect(deepEqualPartial({ baz: 54 }, undefined)).toBe(false);
+    expect(deepEqualPartial(null, null)).toBe(true);
+});
 test('findByPattern', () => {
-    // eslint-disable-next-line
     const value1 = findByPattern([], '');
-    assert();
+    expectTypeOf().toEqualTypeOf();
     expect(value1).toBeUndefined();
     // @ts-expect-error itemToMatch has to follow the pattern type
     findByPattern([], {});
     // @ts-expect-error itemToMatch type has to be a serializable type
     const _ = (findByPattern);
-    assert(_);
+    expect(_).toBeDefined();
     const value2 = findByPattern([{ pattern: 'ab', value: 1 }], 'ab');
-    assert();
+    expectTypeOf().toEqualTypeOf();
     expect(value2).toBe(1);
     const value3 = findByPattern([{ pattern: 'ab', value: 1 }], 'no-match');
     expect(value3).toBe(undefined);
@@ -103,12 +106,12 @@ test('findByPattern', () => {
 });
 test('optionalPatternToList', () => {
     const list1 = optionalPatternToList(1);
-    assert();
+    expectTypeOf().toEqualTypeOf();
     expect(list1).toEqual([{ value: 1 }]);
     const list2 = optionalPatternToList([{ value: 1 }]);
-    assert();
+    expectTypeOf().toEqualTypeOf();
     expect(list2).toEqual([{ value: 1 }]);
-    assert();
+    expectTypeOf().toEqualTypeOf();
 });
 test('isDefined', () => {
     expect(isDefined(0)).toStrictEqual(true);
@@ -164,7 +167,7 @@ test('unPrototypeProperties', () => {
     }
     const instance = new Test(1);
     const noPrototype = unPrototypeProperties(instance, ['method']);
-    assert();
+    expectTypeOf().toEqualTypeOf();
     expect(noPrototype.method()).toBe(1);
     const method = noPrototype.method;
     expect(method()).toBe(1);
@@ -172,23 +175,87 @@ test('unPrototypeProperties', () => {
     expect(Object.hasOwn(noPrototype, 'method2')).toBe(false);
     const clone = { ...noPrototype };
     expect(clone.method()).toBe(1);
-    // @ts-expect-error method2 is not a property of clone
-    expect(() => clone.method2()).toThrow('method2 is not a function');
+    expect(Object.hasOwn(clone, 'method2')).toBe(false);
     // @ts-expect-error method3 is not a property of clone
     unPrototypeProperties(clone, ['method3']);
 });
 test('mapConst', () => {
     const input = ['a', 'b', 'c'];
     const output = mapConst(input)((value) => `${value}-const`);
-    assert();
+    expectTypeOf().toEqualTypeOf();
     expect(output).toEqual(['a-const', 'b-const', 'c-const']);
 });
+test('mapConst expets a lambda with a correct return type', () => {
+    const input = ['a', 'b', 'c'];
+    // @ts-expect-error The return type of the lambda should depend on the input value
+    mapConst(input)(() => 1);
+});
 test('mapConst infers input type from array', () => {
     const input = ['a', 'b', 'c'];
-    mapConst(input)((value) => {
-        assert();
+    const output = [];
+    mapConst(input)((value, index) => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf(index).toEqualTypeOf();
+        output.push(index);
+        return `${value}-const`;
+    });
+    expect(output).toEqual([0, 1, 2]);
+});
+test('mapConst non-curried infers input type from array', () => {
+    const input = ['a', 'b', 'c'];
+    const output = [];
+    const result = mapConst(input, (value, index) => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf(index).toEqualTypeOf();
+        output.push(index);
+        return 1;
+    });
+    expectTypeOf().toEqualTypeOf();
+    expect(result).toEqual([1, 1, 1]);
+    expect(output).toEqual([0, 1, 2]);
+});
+test('mapConstKeysToEntries infers input type from array', () => {
+    const input = ['a', 'b', 'c'];
+    const output = mapConstKeysToEntries(input)((value) => `${value}-const`);
+    expectTypeOf().toEqualTypeOf();
+    expect(output).toEqual([
+        ['a', 'a-const'],
+        ['b', 'b-const'],
+        ['c', 'c-const'],
+    ]);
+});
+test('mapConstKeysToEntries expets a lambda with a correct return type', () => {
+    const input = ['a', 'b', 'c'];
+    // @ts-expect-error The return type of the lambda should depend on the input value
+    mapConstKeysToEntries(input)(() => 1);
+});
+test('mapConstKeysToEntries infers input type from array', () => {
+    const input = ['a', 'b', 'c'];
+    const output = [];
+    const a = mapConstKeysToEntries(input, (value, index) => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf(index).toEqualTypeOf();
+        output.push(index);
+        return 1;
+    });
+    expectTypeOf().toEqualTypeOf();
+    expect(a).toEqual([
+        ['a', 1],
+        ['b', 1],
+        ['c', 1],
+    ]);
+    expect(output).toEqual([0, 1, 2]);
+});
+test('mapConstKeysToEntries infers input type from array', () => {
+    const input = ['a', 'b', 'c'];
+    const output = [];
+    mapConstKeysToEntries(input)((value, index) => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf(index).toEqualTypeOf();
+        output.push(index);
         return `${value}-const`;
     });
+    expect(output).toEqual([0, 1, 2]);
 });
 test('objectFromConstEntries', () => {
     const entries = [
@@ -197,6 +264,156 @@ test('objectFromConstEntries', () => {
         ['c', 3],
     ];
     const obj = objectFromConstEntries(entries);
-    assert();
+    expectTypeOf().toEqualTypeOf();
     expect(obj).toEqual({ a: 1, b: 2, c: 3 });
 });
+test('mapObjectFromKeys', () => {
+    const keys = ['a', 'b', 'c'];
+    const obj = mapObjectFromKeys(keys)((key, index) => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf(index).toEqualTypeOf();
+        return `${key}-const`;
+    });
+    expectTypeOf().toEqualTypeOf();
+    expect(obj).toEqual({ a: 'a-const', b: 'b-const', c: 'c-const' });
+});
+test('mapObjectFromKeys non-curried infers input type from array', () => {
+    const keys = ['a', 'b', 'c'];
+    const obj = mapObjectFromKeys(keys, (key, index) => {
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf(index).toEqualTypeOf();
+        return 1;
+    });
+    expectTypeOf().toEqualTypeOf();
+    expect(obj).toEqual({ a: 1, b: 1, c: 1 });
+});
+test('boolFromThrow returns true when function does not throw', () => {
+    expect(boolFromThrow(() => { })).toBe(true);
+});
+test('boolFromThrow returns false when function throws', () => {
+    expect(boolFromThrow(() => {
+        throw new Error('fail');
+    })).toBe(false);
+});
+test('boolFromThrowAsync returns true when async function does not throw', async () => {
+    await expect(boolFromThrowAsync(async () => { })).resolves.toBe(true);
+});
+test('boolFromThrowAsync returns false when async function rejects', async () => {
+    await expect(boolFromThrowAsync(async () => {
+        throw new Error('fail');
+    })).resolves.toBe(false);
+});
+test('isDeepEqual compares primitives by strict equality, with NaN equal to itself', () => {
+    expect(isDeepEqual(1, 1)).toBe(true);
+    expect(isDeepEqual(1, 2)).toBe(false);
+    expect(isDeepEqual('a', 'a')).toBe(true);
+    expect(isDeepEqual(1, '1')).toBe(false);
+    expect(isDeepEqual(NaN, NaN)).toBe(true);
+    expect(isDeepEqual(undefined, undefined)).toBe(true);
+    expect(isDeepEqual(null, null)).toBe(true);
+    expect(isDeepEqual(null, {})).toBe(false);
+    expect(isDeepEqual({}, null)).toBe(false);
+});
+test('isDeepEqual compares plain objects by their own keys', () => {
+    expect(isDeepEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
+    expect(isDeepEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false);
+    expect(isDeepEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false);
+    expect(isDeepEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } })).toBe(true);
+    expect(isDeepEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 2 } } })).toBe(false);
+});
+test('isDeepEqual compares arrays element-wise', () => {
+    expect(isDeepEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+    expect(isDeepEqual([1, 2], [1, 2, 3])).toBe(false);
+    expect(isDeepEqual([{ a: 1 }], [{ a: 1 }])).toBe(true);
+    expect(isDeepEqual([{ a: 1 }], [{ a: 2 }])).toBe(false);
+    expect(isDeepEqual([], [])).toBe(true);
+});
+test('isDeepEqual treats a different prototype as unequal', () => {
+    class A {
+        constructor(x) {
+            this.x = x;
+        }
+    }
+    class B {
+        constructor(x) {
+            this.x = x;
+        }
+    }
+    expect(isDeepEqual(new A(1), new B(1))).toBe(false);
+    expect(isDeepEqual([1], { 0: 1 })).toBe(false);
+});
+test('isDeepEqual compares Dates by time', () => {
+    expect(isDeepEqual(new Date(1000), new Date(1000))).toBe(true);
+    expect(isDeepEqual(new Date(1000), new Date(2000))).toBe(false);
+});
+test('isDeepEqual compares RegExps by source and flags', () => {
+    expect(isDeepEqual(/ab+/g, /ab+/g)).toBe(true);
+    expect(isDeepEqual(/ab+/g, /ab+/i)).toBe(false);
+    expect(isDeepEqual(/ab+/g, /ac+/g)).toBe(false);
+});
+test('isDeepEqual compares Sets by size and membership', () => {
+    expect(isDeepEqual(new Set([1, 2]), new Set([1, 2]))).toBe(true);
+    expect(isDeepEqual(new Set([1, 2]), new Set([2, 1]))).toBe(true);
+    expect(isDeepEqual(new Set([1, 2]), new Set([1, 3]))).toBe(false);
+    expect(isDeepEqual(new Set([1]), new Set([1, 2]))).toBe(false);
+});
+test('isDeepEqual compares Maps by size and entries', () => {
+    expect(isDeepEqual(new Map([['a', 1]]), new Map([['a', 1]]))).toBe(true);
+    expect(isDeepEqual(new Map([['a', 1]]), new Map([['a', 2]]))).toBe(false);
+    expect(isDeepEqual(new Map([['a', 1]]), new Map([['b', 1]]))).toBe(false);
+    expect(isDeepEqual(new Map([['a', { b: 1 }]]), new Map([['a', { b: 1 }]]))).toBe(true);
+});
+test('isDeepEqual compares ArrayBuffers and typed arrays byte by byte', () => {
+    const bufferOf = (bytes) => new Uint8Array(bytes).buffer;
+    expect(isDeepEqual(bufferOf([1, 2, 3]), bufferOf([1, 2, 3]))).toBe(true);
+    expect(isDeepEqual(bufferOf([1, 2, 3]), bufferOf([1, 2, 4]))).toBe(false);
+    expect(isDeepEqual(bufferOf([1, 2]), bufferOf([1, 2, 3]))).toBe(false);
+    expect(isDeepEqual(new Uint8Array([1, 2]), new Uint8Array([1, 2]))).toBe(true);
+    expect(isDeepEqual(new Uint8Array([1, 2]), new Uint8Array([1, 3]))).toBe(false);
+    expect(isDeepEqual(new DataView(bufferOf([9])), new DataView(bufferOf([9])))).toBe(true);
+    expect(isDeepEqual(new DataView(bufferOf([9])), new DataView(bufferOf([8])))).toBe(false);
+});
+test('isDeepEqual survives circular references', () => {
+    const a = { name: 'a' };
+    a.self = a;
+    const b = { name: 'a' };
+    b.self = b;
+    expect(isDeepEqual(a, b)).toBe(true);
+    const c = { name: 'c' };
+    c.self = c;
+    expect(isDeepEqual(a, c)).toBe(false);
+});
+test('isDeepEqual prefers a custom valueOf when one is defined', () => {
+    class Money {
+        constructor(cents) {
+            this.cents = cents;
+        }
+        valueOf() {
+            return this.cents;
+        }
+    }
+    expect(isDeepEqual(new Money(100), new Money(100))).toBe(true);
+    expect(isDeepEqual(new Money(100), new Money(200))).toBe(false);
+});
+test('isDeepEqual falls back to a custom toString when one is defined', () => {
+    class Tag {
+        constructor(label) {
+            this.label = label;
+        }
+        toString() {
+            return this.label;
+        }
+    }
+    expect(isDeepEqual(new Tag('x'), new Tag('x'))).toBe(true);
+    expect(isDeepEqual(new Tag('x'), new Tag('y'))).toBe(false);
+});
+test('isDeepEqual compares subclasses of built-ins by their built-in semantics', () => {
+    class MySet extends Set {
+    }
+    class MyMap extends Map {
+    }
+    expect(isDeepEqual(new MySet([1]), new MySet([1]))).toBe(true);
+    expect(isDeepEqual(new MySet([1]), new MySet([2]))).toBe(false);
+    expect(isDeepEqual(new MyMap([['a', 1]]), new MyMap([['a', 1]]))).toBe(true);
+    expect(isDeepEqual(new MyMap([['a', 1]]), new MyMap([['a', 2]]))).toBe(false);
+});