scriptc/tests/fixtures/npm/node_modules/node24-deep-equality-fixture/index.js

import { isDeepStrictEqual as equal } from "node:util";
import assert from "node:assert/strict";
export function reportDeepEquality() {
  class Foo { constructor(value) { this.value = value; } }
  class Bar { constructor(value) { this.value = value; } }
  const foo = new Foo(1);
  const bar = new Bar(1);
  console.log("classes", equal(foo, bar), equal(foo, bar, false), equal(foo, bar, true));
  console.log("recursive", equal({ inner: foo }, { inner: bar }, true), equal({ inner: foo }, { inner: bar }));
  console.log("truthiness", equal(foo, bar, 0), equal(foo, bar, "yes"), equal(foo, bar, { skipPrototype: false }));
  console.log("functions", equal(() => 1, () => 1), equal({ f: () => 1 }, { f: () => 1 }));
  const symbol = Symbol("key");
  console.log("keys", equal({ [symbol]: 1 }, { [symbol]: 1 }), equal({ [symbol]: 1 }, {}));
  console.log("holes", equal([, 1], [undefined, 1]), equal([, 1], [, 1]));
  const cycleA = { value: 1 }; cycleA.self = cycleA;
  const cycleB = { value: 1 }; cycleB.self = cycleB;
  console.log("cycles", equal(cycleA, cycleB));
  console.log("sets", equal(new Set([{ a: 1 }, { a: 2 }]), new Set([{ a: 2 }, { a: 1 }])));
  console.log("set consumed", equal(new Set([{ a: 1 }, { a: 1 }]), new Set([{ a: 1 }, { a: 2 }])));
  console.log("maps", equal(new Map([[{ a: 1 }, { b: 2 }]]), new Map([[{ a: 1 }, { b: 2 }]])));
  console.log("map consumed", equal(new Map([[{ a: 1 }, 1], [{ a: 1 }, 1]]), new Map([[{ a: 1 }, 1], [{ a: 2 }, 1]])));
  console.log("map values", equal(new Map([[{ a: 1 }, 1], [{ a: 1 }, 2]]), new Map([[{ a: 1 }, 2], [{ a: 1 }, 1]])));
  const setA = new Set([foo]); const setB = new Set([bar]);
  console.log("collection prototypes", equal(setA, setB), equal(setA, setB, true));
  setA.extra = 1; setB.extra = 2;
  console.log("collection props", equal(setA, setB, true));
  const mapA = new Map(); const mapB = new Map(); mapA.set(mapA, mapA); mapB.set(mapB, mapB);
  console.log("map cycles", equal(mapA, mapB));
  const dateA = new Date(1); const dateB = new Date(1); dateA.extra = 1; dateB.extra = 2;
  console.log("dates", equal(new Date(NaN), new Date(NaN)), equal(dateA, dateB));
  const regexpA = /a/g; const regexpB = /a/g; regexpB.lastIndex = 1;
  console.log("regexp", equal(regexpA, regexpB));
  regexpB.lastIndex = 0; regexpA.extra = 1;
  console.log("regexp props", equal(regexpA, regexpB));
  const boxedA = new Number(NaN); const boxedB = new Number(NaN); boxedA.extra = 1; boxedB.extra = 2;
  console.log("boxed", equal(new Number(NaN), new Number(NaN)), equal(boxedA, boxedB));
  const bytesA = new Uint8Array([1, 2]); const bytesB = new Uint8Array([1, 2]); bytesA.extra = 1; bytesB.extra = 2;
  console.log("bytes props", equal(bytesA, bytesB));
  console.log("buffer proto", equal(Buffer.from([1]), new Uint8Array([1])), equal(Buffer.from([1]), new Uint8Array([1]), true));
  const bitsA = new Uint32Array([0x7fc00001]); const bitsB = new Uint32Array([0x7fc00002]);
  console.log("NaN payload", equal(new Float32Array(bitsA.buffer), new Float32Array(bitsB.buffer)));
  console.log("signed float", equal(new Float64Array([0]), new Float64Array([-0])));
  console.log("data view", equal(new DataView(new Uint8Array([0, 1]).buffer, 1), new DataView(new Uint8Array([1]).buffer)));
  const bufferA = new Uint8Array([1]).buffer; const bufferB = new Uint8Array([1]).buffer;
  bufferA.extra = 1; bufferB.extra = 2;
  console.log("arraybuffer props", equal(bufferA, bufferB));
  const promise = Promise.resolve(1); const weak = new WeakMap();
  console.log("identity", equal(promise, promise), equal(promise, Promise.resolve(1)), equal(weak, weak), equal(weak, new WeakMap()), equal(new WeakSet(), new WeakSet()));
  const errorA = new Error("fail", { cause: { value: 1 } }); const errorB = new Error("fail", { cause: { value: 2 } });
  console.log("error cause", equal(errorA, errorB), equal(new Error("fail"), new Error("fail", { cause: undefined })));
  console.log("aggregate", equal(new AggregateError([new Error("a")], "fail"), new AggregateError([new Error("b")], "fail")));
  console.log("urls", equal(new URL("https://example.com/a"), new URL("https://example.com/b")));
  const denseA = [1]; const denseB = [2];
  Object.defineProperty(denseA, "0", { enumerable: false });
  Object.defineProperty(denseB, "0", { enumerable: false });
  console.log("nonenumerable index", equal(denseA, denseB));
  const prototypeA = { constructor: Object, inherited: 1 };
  const prototypeB = { constructor: Object, inherited: 2 };
  console.log("same constructor", equal(Object.create(prototypeA), Object.create(prototypeB)));
  const nullA = Object.create(null); const nullB = Object.create(null);
  console.log("null proto", equal(nullA, nullB), equal(nullA, {}), equal(nullA, {}, true));
  const shared = { value: 1 };
  console.log("alias structure", equal({ x: shared, y: shared }, { x: { value: 1 }, y: { value: 1 } }));
  const sharedKey = { key: 1 };
  console.log("map identity candidate", equal(new Map([[sharedKey, 1], [{ key: 1 }, 2]]), new Map([[sharedKey, 2], [{ key: 1 }, 1]])));
  const taggedA = {}; const taggedB = {};
  Object.defineProperty(taggedA, Symbol.toStringTag, { value: "Alpha" });
  Object.defineProperty(taggedB, Symbol.toStringTag, { value: "Beta" });
  console.log("hidden tags", equal(taggedA, taggedB), equal(taggedA, taggedB, true));
  const getterA = { get value() { return 1; } }; const getterB = { get value() { return 1; } };
  console.log("getters", equal(getterA, getterB));
  try { equal({ get value() { throw new RangeError("getter failed"); } }, getterB); }
  catch (error) { console.error(error.name, error.message); }
  assert.deepStrictEqual(cycleA, cycleB);
  assert.notDeepStrictEqual(new Set([{ a: 1 }, { a: 1 }]), new Set([{ a: 1 }, { a: 2 }]));
  assert.notDeepStrictEqual(regexpA, regexpB);
  console.log("assert integration");
}