@mark1russell7/collections 0.1.0 → 0.3.0

package/build/testing/index.d.ts

@@ -11,6 +11,15 @@ export declare function show(value: unknown): string;
 /**
  * This function compares two values deeply: JSON values, arrays, plain objects and maps. Two maps
  * are equal when they have the same keys with equal values, in any order.
+ *
+ * This function is for JSON values in tests. It is not `deepEq`, the equality of the collections,
+ * and it differs in these cases:
+ *
+ * - A `Date`, a `Set` or an instance of a class equals only itself here. So `new Date(0)` does not
+ *   equal `new Date(0)` here, and it does under `deepEq`.
+ * - 0 does not equal -0 here, and it does under `deepEq`.
+ * - `{}` equals `Object.create(null)` here, and it does not under `deepEq`.
+ * - A cyclic value exhausts the stack here, and it ends under `deepEq`.
  */
 export declare function deepEqual(actual: unknown, expected: unknown): boolean;
 /** This function throws `ContractViolation` when the two values are not deeply equal. */

package/build/testing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/testing/check.ts"],"mappings":";;;;;qBAMa,0BAA0B;oBACnB;;;wBAIJ,KAAK;;;;;wBAmBL,UAAU,iBAAiB;;wBAqB3B,KAAK,iBAAiB,mBAAmB;;wBAOzC,MAAM,oBAAoB;;;;;wBAQpB,QAAQ,aAAa,kBAAkB,eAAe"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/testing/check.ts"],"mappings":";;;;;qBAMa,0BAA0B;oBACnB;;;wBAIJ,KAAK;;;;;;;;;;;;;;wBA4BL,UAAU,iBAAiB;;wBAqB3B,KAAK,iBAAiB,mBAAmB;;wBAOzC,MAAM,oBAAoB;;;;;wBAQpB,QAAQ,aAAa,kBAAkB,eAAe"}

package/build/testing/index.js

@@ -24,6 +24,15 @@ function isPlainObject(value) {
 /**
 * This function compares two values deeply: JSON values, arrays, plain objects and maps. Two maps
 * are equal when they have the same keys with equal values, in any order.
+*
+* This function is for JSON values in tests. It is not `deepEq`, the equality of the collections,
+* and it differs in these cases:
+*
+* - A `Date`, a `Set` or an instance of a class equals only itself here. So `new Date(0)` does not
+*   equal `new Date(0)` here, and it does under `deepEq`.
+* - 0 does not equal -0 here, and it does under `deepEq`.
+* - `{}` equals `Object.create(null)` here, and it does not under `deepEq`.
+* - A cyclic value exhausts the stack here, and it ends under `deepEq`.
 */
 function deepEqual(actual, expected) {
 	if (Object.is(actual, expected)) return true;

package/build/testing/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/testing/check.ts"],"sourcesContent":["/**\n * The checks of the contract suite. The suite does not import a test framework, so a runtime\n * entry of this package does not load one. A failed check throws `ContractViolation`.\n */\n\n/** The error of a failed check of the contract suite. */\nexport class ContractViolation extends Error {\n  override readonly name = \"ContractViolation\";\n}\n\n/** This function gives the text of a value for a message: JSON, with a `Map` as its entries. */\nexport function show(value: unknown): string {\n  if (value === undefined) return \"undefined\";\n  try {\n    return JSON.stringify(value, (_key, item: unknown) => (item instanceof Map ? { Map: [...item.entries()] } : item === undefined ? \"<undefined>\" : item));\n  } catch {\n    return String(value);\n  }\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null) return false;\n  const prototype = Object.getPrototypeOf(value) as unknown;\n  return prototype === Object.prototype || prototype === null;\n}\n\n/**\n * This function compares two values deeply: JSON values, arrays, plain objects and maps. Two maps\n * are equal when they have the same keys with equal values, in any order.\n */\nexport function deepEqual(actual: unknown, expected: unknown): boolean {\n  if (Object.is(actual, expected)) return true;\n  if (actual instanceof Map && expected instanceof Map) {\n    if (actual.size !== expected.size) return false;\n    for (const [key, value] of actual) {\n      if (!expected.has(key) || !deepEqual(value, expected.get(key))) return false;\n    }\n    return true;\n  }\n  if (Array.isArray(actual) && Array.isArray(expected)) {\n    return actual.length === expected.length && actual.every((item, index) => deepEqual(item, expected[index]));\n  }\n  if (isPlainObject(actual) && isPlainObject(expected)) {\n    const keys = Object.keys(actual);\n    if (keys.length !== Object.keys(expected).length) return false;\n    return keys.every((key) => Object.prototype.hasOwnProperty.call(expected, key) && deepEqual(actual[key], expected[key]));\n  }\n  return false;\n}\n\n/** This function throws `ContractViolation` when the two values are not deeply equal. */\nexport function same(actual: unknown, expected: unknown, what: string): void {\n  if (!deepEqual(actual, expected)) {\n    throw new ContractViolation(`${what}: expected ${show(expected)}, got ${show(actual)}`);\n  }\n}\n\n/** This function throws `ContractViolation` when the condition is false. */\nexport function holds(condition: boolean, what: string): void {\n  if (!condition) throw new ContractViolation(what);\n}\n\n/**\n * This function starts an operation that must fail with a rejected promise, and gives the error.\n * A synchronous throw breaks the contract too: each method of a storage gives a promise.\n */\nexport async function rejects(start: () => Promise<unknown>, what: string): Promise<unknown> {\n  let promise: Promise<unknown>;\n  try {\n    promise = start();\n  } catch (error) {\n    throw new ContractViolation(`${what}: the method threw at once (${show(error instanceof Error ? error.message : error)}), and did not give a rejected promise`);\n  }\n  holds(typeof promise?.then === \"function\", `${what}: the method did not give a promise`);\n  try {\n    await promise;\n  } catch (error) {\n    return error;\n  }\n  throw new ContractViolation(`${what}: the promise did not reject`);\n}\n"],"mappings":";;;;;;AAMA,IAAa,oBAAb,cAAuC,MAAM;CAC3C,OAAyB;AAC3B;;AAGA,SAAgB,KAAK,OAAwB;CAC3C,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,IAAI;EACF,OAAO,KAAK,UAAU,QAAQ,MAAM,SAAmB,gBAAgB,MAAM,EAAE,KAAK,CAAC,GAAG,KAAK,QAAQ,CAAC,EAAE,IAAI,SAAS,KAAA,IAAY,gBAAgB,IAAK;CACxJ,QAAQ;EACN,OAAO,OAAO,KAAK;CACrB;AACF;AAEA,SAAS,cAAc,OAAkD;CACvE,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,MAAM,YAAY,OAAO,eAAe,KAAK;CAC7C,OAAO,cAAc,OAAO,aAAa,cAAc;AACzD;;;;;AAMA,SAAgB,UAAU,QAAiB,UAA4B;CACrE,IAAI,OAAO,GAAG,QAAQ,QAAQ,GAAG,OAAO;CACxC,IAAI,kBAAkB,OAAO,oBAAoB,KAAK;EACpD,IAAI,OAAO,SAAS,SAAS,MAAM,OAAO;EAC1C,KAAK,MAAM,CAAC,KAAK,UAAU,QACzB,IAAI,CAAC,SAAS,IAAI,GAAG,KAAK,CAAC,UAAU,OAAO,SAAS,IAAI,GAAG,CAAC,GAAG,OAAO;EAEzE,OAAO;CACT;CACA,IAAI,MAAM,QAAQ,MAAM,KAAK,MAAM,QAAQ,QAAQ,GACjD,OAAO,OAAO,WAAW,SAAS,UAAU,OAAO,OAAO,MAAM,UAAU,UAAU,MAAM,SAAS,MAAM,CAAC;CAE5G,IAAI,cAAc,MAAM,KAAK,cAAc,QAAQ,GAAG;EACpD,MAAM,OAAO,OAAO,KAAK,MAAM;EAC/B,IAAI,KAAK,WAAW,OAAO,KAAK,QAAQ,CAAC,CAAC,QAAQ,OAAO;EACzD,OAAO,KAAK,OAAO,QAAQ,OAAO,UAAU,eAAe,KAAK,UAAU,GAAG,KAAK,UAAU,OAAO,MAAM,SAAS,IAAI,CAAC;CACzH;CACA,OAAO;AACT;;AAGA,SAAgB,KAAK,QAAiB,UAAmB,MAAoB;CAC3E,IAAI,CAAC,UAAU,QAAQ,QAAQ,GAC7B,MAAM,IAAI,kBAAkB,GAAG,KAAK,aAAa,KAAK,QAAQ,EAAE,QAAQ,KAAK,MAAM,GAAG;AAE1F;;AAGA,SAAgB,MAAM,WAAoB,MAAoB;CAC5D,IAAI,CAAC,WAAW,MAAM,IAAI,kBAAkB,IAAI;AAClD;;;;;AAMA,eAAsB,QAAQ,OAA+B,MAAgC;CAC3F,IAAI;CACJ,IAAI;EACF,UAAU,MAAM;CAClB,SAAS,OAAO;EACd,MAAM,IAAI,kBAAkB,GAAG,KAAK,8BAA8B,KAAK,iBAAiB,QAAQ,MAAM,UAAU,KAAK,EAAE,uCAAuC;CAChK;CACA,MAAM,OAAO,SAAS,SAAS,YAAY,GAAG,KAAK,oCAAoC;CACvF,IAAI;EACF,MAAM;CACR,SAAS,OAAO;EACd,OAAO;CACT;CACA,MAAM,IAAI,kBAAkB,GAAG,KAAK,6BAA6B;AACnE"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/testing/check.ts"],"sourcesContent":["/**\n * The checks of the contract suite. The suite does not import a test framework, so a runtime\n * entry of this package does not load one. A failed check throws `ContractViolation`.\n */\n\n/** The error of a failed check of the contract suite. */\nexport class ContractViolation extends Error {\n  override readonly name = \"ContractViolation\";\n}\n\n/** This function gives the text of a value for a message: JSON, with a `Map` as its entries. */\nexport function show(value: unknown): string {\n  if (value === undefined) return \"undefined\";\n  try {\n    return JSON.stringify(value, (_key, item: unknown) => (item instanceof Map ? { Map: [...item.entries()] } : item === undefined ? \"<undefined>\" : item));\n  } catch {\n    return String(value);\n  }\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null) return false;\n  const prototype = Object.getPrototypeOf(value) as unknown;\n  return prototype === Object.prototype || prototype === null;\n}\n\n/**\n * This function compares two values deeply: JSON values, arrays, plain objects and maps. Two maps\n * are equal when they have the same keys with equal values, in any order.\n *\n * This function is for JSON values in tests. It is not `deepEq`, the equality of the collections,\n * and it differs in these cases:\n *\n * - A `Date`, a `Set` or an instance of a class equals only itself here. So `new Date(0)` does not\n *   equal `new Date(0)` here, and it does under `deepEq`.\n * - 0 does not equal -0 here, and it does under `deepEq`.\n * - `{}` equals `Object.create(null)` here, and it does not under `deepEq`.\n * - A cyclic value exhausts the stack here, and it ends under `deepEq`.\n */\nexport function deepEqual(actual: unknown, expected: unknown): boolean {\n  if (Object.is(actual, expected)) return true;\n  if (actual instanceof Map && expected instanceof Map) {\n    if (actual.size !== expected.size) return false;\n    for (const [key, value] of actual) {\n      if (!expected.has(key) || !deepEqual(value, expected.get(key))) return false;\n    }\n    return true;\n  }\n  if (Array.isArray(actual) && Array.isArray(expected)) {\n    return actual.length === expected.length && actual.every((item, index) => deepEqual(item, expected[index]));\n  }\n  if (isPlainObject(actual) && isPlainObject(expected)) {\n    const keys = Object.keys(actual);\n    if (keys.length !== Object.keys(expected).length) return false;\n    return keys.every((key) => Object.prototype.hasOwnProperty.call(expected, key) && deepEqual(actual[key], expected[key]));\n  }\n  return false;\n}\n\n/** This function throws `ContractViolation` when the two values are not deeply equal. */\nexport function same(actual: unknown, expected: unknown, what: string): void {\n  if (!deepEqual(actual, expected)) {\n    throw new ContractViolation(`${what}: expected ${show(expected)}, got ${show(actual)}`);\n  }\n}\n\n/** This function throws `ContractViolation` when the condition is false. */\nexport function holds(condition: boolean, what: string): void {\n  if (!condition) throw new ContractViolation(what);\n}\n\n/**\n * This function starts an operation that must fail with a rejected promise, and gives the error.\n * A synchronous throw breaks the contract too: each method of a storage gives a promise.\n */\nexport async function rejects(start: () => Promise<unknown>, what: string): Promise<unknown> {\n  let promise: Promise<unknown>;\n  try {\n    promise = start();\n  } catch (error) {\n    throw new ContractViolation(`${what}: the method threw at once (${show(error instanceof Error ? error.message : error)}), and did not give a rejected promise`);\n  }\n  holds(typeof promise?.then === \"function\", `${what}: the method did not give a promise`);\n  try {\n    await promise;\n  } catch (error) {\n    return error;\n  }\n  throw new ContractViolation(`${what}: the promise did not reject`);\n}\n"],"mappings":";;;;;;AAMA,IAAa,oBAAb,cAAuC,MAAM;CAC3C,OAAyB;AAC3B;;AAGA,SAAgB,KAAK,OAAwB;CAC3C,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,IAAI;EACF,OAAO,KAAK,UAAU,QAAQ,MAAM,SAAmB,gBAAgB,MAAM,EAAE,KAAK,CAAC,GAAG,KAAK,QAAQ,CAAC,EAAE,IAAI,SAAS,KAAA,IAAY,gBAAgB,IAAK;CACxJ,QAAQ;EACN,OAAO,OAAO,KAAK;CACrB;AACF;AAEA,SAAS,cAAc,OAAkD;CACvE,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,MAAM,YAAY,OAAO,eAAe,KAAK;CAC7C,OAAO,cAAc,OAAO,aAAa,cAAc;AACzD;;;;;;;;;;;;;;AAeA,SAAgB,UAAU,QAAiB,UAA4B;CACrE,IAAI,OAAO,GAAG,QAAQ,QAAQ,GAAG,OAAO;CACxC,IAAI,kBAAkB,OAAO,oBAAoB,KAAK;EACpD,IAAI,OAAO,SAAS,SAAS,MAAM,OAAO;EAC1C,KAAK,MAAM,CAAC,KAAK,UAAU,QACzB,IAAI,CAAC,SAAS,IAAI,GAAG,KAAK,CAAC,UAAU,OAAO,SAAS,IAAI,GAAG,CAAC,GAAG,OAAO;EAEzE,OAAO;CACT;CACA,IAAI,MAAM,QAAQ,MAAM,KAAK,MAAM,QAAQ,QAAQ,GACjD,OAAO,OAAO,WAAW,SAAS,UAAU,OAAO,OAAO,MAAM,UAAU,UAAU,MAAM,SAAS,MAAM,CAAC;CAE5G,IAAI,cAAc,MAAM,KAAK,cAAc,QAAQ,GAAG;EACpD,MAAM,OAAO,OAAO,KAAK,MAAM;EAC/B,IAAI,KAAK,WAAW,OAAO,KAAK,QAAQ,CAAC,CAAC,QAAQ,OAAO;EACzD,OAAO,KAAK,OAAO,QAAQ,OAAO,UAAU,eAAe,KAAK,UAAU,GAAG,KAAK,UAAU,OAAO,MAAM,SAAS,IAAI,CAAC;CACzH;CACA,OAAO;AACT;;AAGA,SAAgB,KAAK,QAAiB,UAAmB,MAAoB;CAC3E,IAAI,CAAC,UAAU,QAAQ,QAAQ,GAC7B,MAAM,IAAI,kBAAkB,GAAG,KAAK,aAAa,KAAK,QAAQ,EAAE,QAAQ,KAAK,MAAM,GAAG;AAE1F;;AAGA,SAAgB,MAAM,WAAoB,MAAoB;CAC5D,IAAI,CAAC,WAAW,MAAM,IAAI,kBAAkB,IAAI;AAClD;;;;;AAMA,eAAsB,QAAQ,OAA+B,MAAgC;CAC3F,IAAI;CACJ,IAAI;EACF,UAAU,MAAM;CAClB,SAAS,OAAO;EACd,MAAM,IAAI,kBAAkB,GAAG,KAAK,8BAA8B,KAAK,iBAAiB,QAAQ,MAAM,UAAU,KAAK,EAAE,uCAAuC;CAChK;CACA,MAAM,OAAO,SAAS,SAAS,YAAY,GAAG,KAAK,oCAAoC;CACvF,IAAI;EACF,MAAM;CACR,SAAS,OAAO;EACd,OAAO;CACT;CACA,MAAM,IAAI,kBAAkB,GAAG,KAAK,6BAA6B;AACnE"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/collections",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Collections with no dependencies: lists, maps, queues, a summary tree, channels, lazy operations and dependency graphs.",
   "keywords": [
     "collections",

package/src/testing/check.ts

@@ -27,6 +27,15 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
 /**
  * This function compares two values deeply: JSON values, arrays, plain objects and maps. Two maps
  * are equal when they have the same keys with equal values, in any order.
+ *
+ * This function is for JSON values in tests. It is not `deepEq`, the equality of the collections,
+ * and it differs in these cases:
+ *
+ * - A `Date`, a `Set` or an instance of a class equals only itself here. So `new Date(0)` does not
+ *   equal `new Date(0)` here, and it does under `deepEq`.
+ * - 0 does not equal -0 here, and it does under `deepEq`.
+ * - `{}` equals `Object.create(null)` here, and it does not under `deepEq`.
+ * - A cyclic value exhausts the stack here, and it ends under `deepEq`.
  */
 export function deepEqual(actual: unknown, expected: unknown): boolean {
   if (Object.is(actual, expected)) return true;

package/src/utils/defaults.ts

@@ -39,37 +39,142 @@ export const shallowEq: Eq<any> = (a, b) => {
   return true;
 };
 
+/** SameValueZero: the meaning of `===`, and NaN equals NaN. */
+const sameValueZero = (a: unknown, b: unknown): boolean => a === b || (Number.isNaN(a) && Number.isNaN(b));
+
+const isObject = (value: unknown): value is object => typeof value === "object" && value !== null;
+
+/** The pairs that one comparison holds equal. The log lets a failed try remove its pairs. */
+interface HeldPairs {
+  readonly partners: Map<object, Set<object>>;
+  readonly log: [object, object][];
+}
+
+function releasePairs(held: HeldPairs, mark: number): void {
+  while (held.log.length > mark) {
+    const [a, b] = held.log.pop()!;
+    held.partners.get(a)?.delete(b);
+  }
+}
+
+function equalElements(a: ArrayLike<unknown>, b: ArrayLike<unknown>): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!sameValueZero(a[i], b[i])) return false;
+  }
+  return true;
+}
+
+/** The kinds of `equalObjects` and `hashFields`, so that the relation and its hash stay in step. */
+const isBinary = (value: object): value is ArrayBufferLike | DataView =>
+  value instanceof DataView || value instanceof ArrayBuffer || (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer);
+
+const isOpaque = (value: object): boolean => value instanceof Promise || value instanceof WeakMap || value instanceof WeakSet || value instanceof WeakRef;
+
+const isBoxed = (value: object): boolean =>
+  value instanceof Number || value instanceof String || value instanceof Boolean || value instanceof BigInt || value instanceof Symbol;
+
+function bytesOf(value: ArrayBufferLike | DataView): Uint8Array {
+  return ArrayBuffer.isView(value) ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : new Uint8Array(value);
+}
+
+function enumerableKeys(value: object): (string | symbol)[] {
+  return Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key));
+}
+
+function equalKeys(a: any, b: any, held: HeldPairs): boolean {
+  const keys = enumerableKeys(a);
+  if (keys.length !== enumerableKeys(b).length) return false;
+  return keys.every((key) => Object.prototype.propertyIsEnumerable.call(b, key) && equalValues(a[key], b[key], held));
+}
+
 /**
- * Deep structural equality (recursive comparison).
- * This function handles nested objects and arrays.
+ * The comparison of the entries of two maps, or of the members of two sets. A primitive key finds
+ * its partner by `has`. An object key tries each object key of `b` that is not taken yet. The first
+ * partner is correct, because the relation is an equivalence.
  */
-export const deepEq: Eq<any> = (a, b): boolean => {
-  if (a === b) return true;
-  if (typeof a !== typeof b) return false;
-  if (typeof a !== "object" || a === null || b === null) return false;
+function equalEntries(a: Map<unknown, unknown> | Set<unknown>, b: Map<unknown, unknown> | Set<unknown>, held: HeldPairs): boolean {
+  if (a.size !== b.size) return false;
+  const valueAt = (key: unknown): unknown => (b instanceof Map ? b.get(key) : key);
+  const free = [...b.entries()].filter(([key]) => isObject(key));
+  for (const [key, value] of a.entries()) {
+    if (!isObject(key)) {
+      if (!b.has(key) || !equalValues(value, valueAt(key), held)) return false;
+      continue;
+    }
+    const at = free.findIndex(([otherKey, otherValue]) => {
+      const mark = held.log.length;
+      if (equalValues(key, otherKey, held) && equalValues(value, otherValue, held)) return true;
+      releasePairs(held, mark);
+      return false;
+    });
+    if (at < 0) return false;
+    free.splice(at, 1);
+  }
+  return true;
+}
 
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
+/** The comparison of two objects with the same prototype. */
+function equalObjects(a: any, b: any, held: HeldPairs): boolean {
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
     for (let i = 0; i < a.length; i++) {
-      if (!deepEq(a[i], b[i])) return false;
+      if (!equalValues(a[i], b[i], held)) return false;
     }
     return true;
   }
+  if (isBinary(a)) return equalElements(bytesOf(a), bytesOf(b));
+  if (ArrayBuffer.isView(a)) return equalElements(a as unknown as ArrayLike<unknown>, b);
+  if (isOpaque(a)) return false;
+  if (a instanceof Date && !sameValueZero(a.getTime(), b.getTime())) return false;
+  if (a instanceof RegExp && (a.source !== b.source || a.flags !== b.flags)) return false;
+  if (a instanceof Error && !(a.name === b.name && a.message === b.message && equalValues(a.cause, b.cause, held))) return false;
+  if (isBoxed(a) && !sameValueZero(a.valueOf(), b.valueOf())) return false;
+  if ((a instanceof Map || a instanceof Set) && !equalEntries(a, b, held)) return false;
+  return equalKeys(a, b, held);
+}
 
-  if (Array.isArray(a) !== Array.isArray(b)) return false;
-
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-
-  if (keysA.length !== keysB.length) return false;
-
-  for (const key of keysA) {
-    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
-    if (!deepEq(a[key], b[key])) return false;
+/**
+ * The comparison of two values. A pair stays held after it passes, so a shared or cyclic part
+ * costs one visit. A failure ends the whole comparison, or the try in `equalEntries`, which
+ * releases its pairs.
+ */
+function equalValues(a: unknown, b: unknown, held: HeldPairs): boolean {
+  if (sameValueZero(a, b)) return true;
+  if (!isObject(a) || !isObject(b)) return false;
+  if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
+  let partners = held.partners.get(a);
+  if (partners?.has(b)) return true;
+  if (partners === undefined) {
+    partners = new Set();
+    held.partners.set(a, partners);
   }
+  partners.add(b);
+  held.log.push([a, b]);
+  return equalObjects(a, b, held);
+}
 
-  return true;
-};
+/**
+ * Deep structural equality. This relation is an equivalence: it is reflexive, symmetric and
+ * transitive, for each value.
+ *
+ * - Primitives compare by SameValueZero: NaN equals NaN, and 0 equals -0.
+ * - Two objects must have the same prototype. So `{}` differs from `Object.create(null)`, from an
+ *   instance of a class with the same keys, and from an object of another realm.
+ * - Arrays compare by length and by index. A hole equals `undefined`.
+ * - Typed arrays compare by element. `ArrayBuffer`, `SharedArrayBuffer` and `DataView` compare by byte.
+ * - `Date` compares by time, `RegExp` by source and flags, and `Error` by name, message and cause.
+ * - A boxed primitive compares by its value. `Map` and `Set` compare by entries, in any order. An object key
+ *   matches a deep-equal key.
+ * - Each other object compares by its own enumerable keys, strings and symbols, in any order. The objects above do too,
+ *   except arrays and binary data.
+ * - Functions, `Promise`, `WeakMap`, `WeakSet` and `WeakRef` compare by identity.
+ * - Cycles are safe: two cyclic values are equal when they unfold to the same infinite tree.
+ *
+ * The recursion follows the depth of the data, so a very deep value can exhaust the stack.
+ * `defaultHash` agrees with this relation: two equal values have one hash.
+ */
+export const deepEq: Eq<any> = (a, b): boolean => equalValues(a, b, { partners: new Map(), log: [] });
 
 /**
  * Equality by comparing a specific property.
@@ -90,17 +195,11 @@ export const eqBy = <T, K extends keyof T = keyof T>(
 // Default Hashing
 // ============================================================================
 
-/**
- * Default hash function for primitives and objects.
- * For objects, hashes the JSON string representation.
- */
-export const defaultHash: Hash<any> = (value: any): number => {
+/** The hash of one primitive or function. */
+function hashPrimitive(value: unknown): number {
   if (value === null) return 0;
   if (value === undefined) return 1;
-
-  const type = typeof value;
-
-  switch (type) {
+  switch (typeof value) {
     case "boolean":
       return value ? 1 : 0;
     case "number":
@@ -111,19 +210,104 @@ export const defaultHash: Hash<any> = (value: any): number => {
       return hashString(value.toString());
     case "bigint":
       return hashString(value.toString());
-    case "object":
-      // For objects, hash their JSON representation
-      // This is not ideal for all cases but provides a reasonable default
-      try {
-        return hashString(JSON.stringify(value));
-      } catch {
-        // If JSON.stringify fails, fall back to toString
-        return hashString(value.toString());
-      }
     default:
       return 2;
   }
-};
+}
+
+/** The levels of an object that `defaultHash` reads. A cyclic value unfolds to this depth and stops. */
+const HASH_DEPTH = 16;
+
+/** The hashes of one call, by object and by remaining depth. A shared part costs one visit per depth. */
+type HashMemo = Map<object, number[]>;
+
+/** This function adds one hash to a running hash. The result depends on the order. */
+const mix = (hash: number, part: number): number => (Math.imul(hash, 31) + part) | 0;
+
+/** The finalizer of MurmurHash3. It makes a sum of entries depend on each pair, not on each half. */
+function scramble(hash: number): number {
+  let mixed = hash ^ (hash >>> 16);
+  mixed = Math.imul(mixed, 0x85ebca6b);
+  mixed ^= mixed >>> 13;
+  mixed = Math.imul(mixed, 0xc2b2ae35);
+  return mixed ^ (mixed >>> 16);
+}
+
+/** The start values of the kinds. Two kinds do not compare equal, so their hashes can differ. */
+const KIND = { array: 3, binary: 5, elements: 7, opaque: 11, record: 13 } as const;
+
+const hashAt = (value: unknown, depth: number, memo: HashMemo): number =>
+  isObject(value) ? hashObject(value, depth, memo) : hashPrimitive(value);
+
+function hashElements(start: number, elements: ArrayLike<unknown>): number {
+  let hash = start;
+  for (let i = 0; i < elements.length; i++) hash = mix(hash, hashPrimitive(elements[i]));
+  return hash;
+}
+
+/** The sum of the entries of a map or a set. A sum does not depend on the order of the entries. */
+function hashEntries(value: Map<unknown, unknown> | Set<unknown>, depth: number, memo: HashMemo): number {
+  let sum = 0;
+  for (const [key, entry] of value.entries()) sum = (sum + scramble(mix(hashAt(key, depth, memo), hashAt(entry, depth, memo)))) | 0;
+  return sum;
+}
+
+/** The sum of the own enumerable keys and their values, as `equalKeys` reads them. */
+function hashKeys(value: any, depth: number, memo: HashMemo): number {
+  let sum = 0;
+  for (const key of enumerableKeys(value)) sum = (sum + scramble(mix(hashPrimitive(key), hashAt(value[key], depth, memo)))) | 0;
+  return sum;
+}
+
+/** The hash of the fields of one object. This function reads only what `equalObjects` reads. */
+function hashFields(value: any, depth: number, memo: HashMemo): number {
+  if (Array.isArray(value)) {
+    let hash: number = KIND.array;
+    for (let i = 0; i < value.length; i++) hash = mix(hash, hashAt(value[i], depth, memo));
+    return hash;
+  }
+  if (isBinary(value)) return hashElements(KIND.binary, bytesOf(value));
+  if (ArrayBuffer.isView(value)) return hashElements(KIND.elements, value as unknown as ArrayLike<unknown>);
+  if (isOpaque(value)) return KIND.opaque;
+  let hash: number = KIND.record;
+  if (value instanceof Date) hash = mix(hash, hashNumber(value.getTime()));
+  if (value instanceof RegExp) hash = mix(mix(hash, hashString(value.source)), hashString(value.flags));
+  if (value instanceof Error) {
+    hash = mix(mix(mix(hash, hashAt(value.name, depth, memo)), hashAt(value.message, depth, memo)), hashAt(value.cause, depth, memo));
+  }
+  if (isBoxed(value)) hash = mix(hash, hashPrimitive(value.valueOf()));
+  if (value instanceof Map || value instanceof Set) hash = mix(hash, hashEntries(value, depth, memo));
+  return mix(hash, hashKeys(value, depth, memo));
+}
+
+/** The hash of one object at one depth. The depth falls with each level, so a cycle ends. */
+function hashObject(value: object, depth: number, memo: HashMemo): number {
+  if (depth === 0) return 0;
+  let byDepth = memo.get(value);
+  if (byDepth === undefined) {
+    byDepth = [];
+    memo.set(value, byDepth);
+  }
+  const known = byDepth[depth];
+  if (known !== undefined) return known;
+  const hash = hashFields(value, depth - 1, memo);
+  byDepth[depth] = hash;
+  return hash;
+}
+
+/**
+ * This function is the default hash of a key. It agrees with `deepEq`: when `deepEq(a, b)` is true,
+ * `defaultHash(a)` equals `defaultHash(b)`. So a hash map with `deepEq` finds an equal key.
+ *
+ * - The hash of an object reads the same fields as `deepEq`. The order of the keys of an object,
+ *   and of the entries of a `Map` or a `Set`, has no effect.
+ * - The hash reads 16 levels, so a cyclic or very deep value ends. Two values that differ only
+ *   below that depth have one hash, and `deepEq` then tells them apart.
+ * - A shared part costs one visit per level, so a dense graph ends.
+ * - The hash of an object can change in a new version. Do not store it.
+ */
+export const defaultHash: Hash<any> = (value: any): number =>
+  isObject(value) ? hashObject(value, HASH_DEPTH, new Map()) : hashPrimitive(value);
 
 /**
  * Hash function for strings using djb2 algorithm.