{"addressing":"content-addressed","addressedBy":"cf0ee281d97aa77d85623e649232e6d7a04d72d3bc607fa27172636a2ba53843","canonicalText":"{\"formatVersion\":1,\"frozen\":{\"address\":{\"language\":\"typescript\",\"major\":1,\"name\":\"object/deep-equal\"},\"benchmarks\":{\"profiles\":[{\"class\":\"stops-early\",\"data\":{\"fields\":[],\"kind\":\"record\"},\"description\":\"Shallow objects of a handful of keys that differ in the first one looked at. The dominant shape in memoisation, and the path a caller takes on most calls.\",\"name\":\"two-renders-of-one-view\",\"samples\":{\"kind\":\"carried\",\"values\":[{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":1}},{\"name\":\"name\",\"value\":{\"kind\":\"primitive\",\"value\":\"a\"}},{\"name\":\"open\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":2}},{\"name\":\"name\",\"value\":{\"kind\":\"primitive\",\"value\":\"a\"}},{\"name\":\"open\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"at\",\"value\":{\"kind\":\"primitive\",\"value\":0}},{\"name\":\"of\",\"value\":{\"kind\":\"primitive\",\"value\":\"x\"}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"at\",\"value\":{\"kind\":\"primitive\",\"value\":1}},{\"name\":\"of\",\"value\":{\"kind\":\"primitive\",\"value\":\"x\"}}],\"kind\":\"record\"}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2},{\"kind\":\"primitive\",\"value\":3}],\"kind\":\"list\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":9},{\"kind\":\"primitive\",\"value\":2},{\"kind\":\"primitive\",\"value\":3}],\"kind\":\"list\"}}],\"kind\":\"record\"}]}},{\"class\":\"stops-late\",\"data\":{\"fields\":[],\"kind\":\"record\"},\"description\":\"Records agreeing on everything but their last field, so the walk pays the whole traversal and answers false. Timed apart from the profile above because an implementation optimised for the first difference measures nothing here.\",\"name\":\"a-row-that-changed-at-the-end\",\"samples\":{\"kind\":\"carried\",\"values\":[{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":1}},{\"name\":\"name\",\"value\":{\"kind\":\"primitive\",\"value\":\"a\"}},{\"name\":\"tags\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":\"x\"},{\"kind\":\"primitive\",\"value\":\"y\"}],\"kind\":\"list\"}},{\"name\":\"meta\",\"value\":{\"fields\":[{\"name\":\"seen\",\"value\":{\"kind\":\"primitive\",\"value\":2}},{\"name\":\"at\",\"value\":{\"kind\":\"primitive\",\"value\":\"z\"}}],\"kind\":\"record\"}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":1}},{\"name\":\"name\",\"value\":{\"kind\":\"primitive\",\"value\":\"a\"}},{\"name\":\"tags\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":\"x\"},{\"kind\":\"primitive\",\"value\":\"y\"}],\"kind\":\"list\"}},{\"name\":\"meta\",\"value\":{\"fields\":[{\"name\":\"seen\",\"value\":{\"kind\":\"primitive\",\"value\":2}},{\"name\":\"at\",\"value\":{\"kind\":\"primitive\",\"value\":\"w\"}}],\"kind\":\"record\"}}],\"kind\":\"record\"}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2},{\"kind\":\"primitive\",\"value\":3},{\"kind\":\"primitive\",\"value\":4},{\"kind\":\"primitive\",\"value\":5},{\"kind\":\"primitive\",\"value\":6},{\"kind\":\"primitive\",\"value\":7},{\"kind\":\"primitive\",\"value\":8}],\"kind\":\"list\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2},{\"kind\":\"primitive\",\"value\":3},{\"kind\":\"primitive\",\"value\":4},{\"kind\":\"primitive\",\"value\":5},{\"kind\":\"primitive\",\"value\":6},{\"kind\":\"primitive\",\"value\":7},{\"kind\":\"primitive\",\"value\":9}],\"kind\":\"list\"}}],\"kind\":\"record\"}]}},{\"class\":\"walks-everything\",\"data\":{\"fields\":[],\"kind\":\"record\"},\"description\":\"Structurally identical nested objects, walked to the last leaf and answered true. The worst case of the ordinary path and the one that decides whether this can be called in a render.\",\"name\":\"two-copies-of-one-tree\",\"samples\":{\"kind\":\"carried\",\"values\":[{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"a\",\"value\":{\"fields\":[{\"name\":\"b\",\"value\":{\"fields\":[{\"name\":\"c\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2},{\"fields\":[{\"name\":\"d\",\"value\":{\"kind\":\"primitive\",\"value\":\"x\"}}],\"kind\":\"record\"}],\"kind\":\"list\"}}],\"kind\":\"record\"}}],\"kind\":\"record\"}},{\"name\":\"e\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":3},{\"kind\":\"primitive\",\"value\":4}],\"kind\":\"list\"}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"a\",\"value\":{\"fields\":[{\"name\":\"b\",\"value\":{\"fields\":[{\"name\":\"c\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2},{\"fields\":[{\"name\":\"d\",\"value\":{\"kind\":\"primitive\",\"value\":\"x\"}}],\"kind\":\"record\"}],\"kind\":\"list\"}}],\"kind\":\"record\"}}],\"kind\":\"record\"}},{\"name\":\"e\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":3},{\"kind\":\"primitive\",\"value\":4}],\"kind\":\"list\"}}],\"kind\":\"record\"}}],\"kind\":\"record\"}]}},{\"class\":\"walks-everything\",\"data\":{\"fields\":[],\"kind\":\"record\"},\"description\":\"Sets and Maps holding objects, where a member of one has to be matched against the unclaimed members of the other. The only quadratic path in the contract, and the one the declared collection bound comes from.\",\"name\":\"members-without-an-order\",\"samples\":{\"kind\":\"carried\",\"values\":[{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":3}}],\"kind\":\"record\"}],\"kind\":\"set\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":3}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"}],\"kind\":\"set\"}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"key\":{\"fields\":[{\"name\":\"k\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"},\"value\":{\"kind\":\"primitive\",\"value\":\"a\"}},{\"key\":{\"fields\":[{\"name\":\"k\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"},\"value\":{\"kind\":\"primitive\",\"value\":\"b\"}}],\"kind\":\"map\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"key\":{\"fields\":[{\"name\":\"k\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"},\"value\":{\"kind\":\"primitive\",\"value\":\"b\"}},{\"key\":{\"fields\":[{\"name\":\"k\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"},\"value\":{\"kind\":\"primitive\",\"value\":\"a\"}}],\"kind\":\"map\"}}],\"kind\":\"record\"}]}}],\"vocabulary\":[{\"meaning\":\"the pair parts at the first key looked at, which is most of what a caller does\",\"name\":\"stops-early\"},{\"meaning\":\"the pair parts at the last leaf, so the whole traversal is paid for a false\",\"name\":\"stops-late\"},{\"meaning\":\"the pair agrees, so every leaf of both graphs is visited\",\"name\":\"walks-everything\"}]},\"caseTables\":[{\"cases\":[{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"kind\":\"number\",\"literal\":\"nan\"}},{\"name\":\"right\",\"value\":{\"kind\":\"number\",\"literal\":\"nan\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"identity-of-a-primitive\",\"id\":\"not-a-number-equals-itself\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"`NaN === NaN` is false and `Object.is(NaN, NaN)` is true. A comparison about data takes the second: a caller holding two records that both failed to parse a number is holding the same record twice, not two different ones.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"kind\":\"number\",\"literal\":\"negative-zero\"}},{\"name\":\"right\",\"value\":{\"kind\":\"primitive\",\"value\":0}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"identity-of-a-primitive\",\"id\":\"negative-zero-is-not-zero\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The other half of `Object.is`, and the half the ecosystem splits on: `lodash` and `fast-deep-equal` answer true, `util.isDeepStrictEqual` answers false. A refund that rounded away to nothing keeps the mark saying which way the money went - the same argument `number/round@1` freezes one contract over.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"z\",\"value\":{\"kind\":\"number\",\"literal\":\"negative-zero\"}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"z\",\"value\":{\"kind\":\"primitive\",\"value\":0}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"identity-of-a-primitive\",\"id\":\"negative-zero-nested-is-still-not-zero\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The same rule one level down, because a rule that held only at the root would be a property of the entry point rather than of the walk.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"v\",\"value\":{\"digits\":\"1\",\"kind\":\"big-integer\"}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"identity-of-a-primitive\",\"id\":\"a-bigint-is-not-its-number\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"`1n == 1` is true and `Object.is(1n, 1)` is false. Two values a caller cannot add together are not the same datum, and the loose comparison is the one nothing here uses.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[],\"kind\":\"boxed\",\"of\":\"string\",\"value\":{\"kind\":\"primitive\",\"value\":\"a\"}}},{\"name\":\"right\",\"value\":{\"kind\":\"primitive\",\"value\":\"a\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"identity-of-a-primitive\",\"id\":\"a-boxed-primitive-is-not-its-primitive\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"One is an object with a prototype and own indexed properties, the other is a primitive. `typeof` separates them and so does anything a caller does with them afterwards.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"a\",\"value\":{\"kind\":\"primitive\",\"value\":1}},{\"name\":\"b\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"b\",\"value\":{\"kind\":\"primitive\",\"value\":2}},{\"name\":\"a\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"the-shape-of-a-plain-object\",\"id\":\"the-order-keys-were-written-in-is-not-read\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The first thing the spelling a caller reaches for gets wrong: comparing two `JSON.stringify` results answers false here, because a serialisation carries an order the data does not have.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"a\",\"value\":{\"kind\":\"undefined\"}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"the-shape-of-a-plain-object\",\"id\":\"a-key-holding-undefined-is-not-a-missing-key\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The two are different to `Object.keys`, to `in`, and to a caller writing `if (\\\"a\\\" in row)`. The `JSON.stringify` spelling answers true, because `undefined` is dropped on the way out.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[],\"kind\":\"record\",\"symbolFields\":[{\"key\":{\"description\":\"object/deep-equal@1 case\",\"kind\":\"symbol\",\"shared\":1},\"value\":{\"kind\":\"primitive\",\"value\":1}}]}},{\"name\":\"right\",\"value\":{\"fields\":[],\"kind\":\"record\",\"symbolFields\":[{\"key\":{\"kind\":\"again\",\"shared\":1},\"value\":{\"kind\":\"primitive\",\"value\":2}}]}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"the-shape-of-a-plain-object\",\"id\":\"data-under-a-symbol-key-is-data\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"Measured, four of six shipped implementations answer true here: they walk `Object.keys`, which does not report a symbol. Two objects whose data differs compare equal, and nothing about the call says so.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"className\":\"ASmallClass\",\"fields\":[{\"name\":\"x\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"instance\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"x\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"the-shape-of-a-plain-object\",\"id\":\"a-class-instance-is-not-its-fields\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The prototype is part of what the value is: methods, a constructor and whatever else the class carries are all reachable from one and not from the other. Every implementation measured agrees, and `inputDomain` says in as many words that a caller who wants them equal wants a different function.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"a\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\",\"prototype\":\"none\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"a\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"the-shape-of-a-plain-object\",\"id\":\"a-null-prototype-object-is-not-a-plain-one\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The same rule at the other end of the prototype chain, and the place the ecosystem parts again: `lodash` answers true, `util.isDeepStrictEqual` answers false. An object built to have no inherited `toString` is not the object that has one.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"a\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"a\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"the-shape-of-a-plain-object\",\"id\":\"a-getter-is-read-as-the-value-it-returns\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"A comparison reads values, and reading a property is what a caller does too. The alternative - comparing descriptors - would answer about how an object was written rather than about what it carries, and would make a memoised object differ from its own plain copy.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"kind\":\"hole\"},{\"kind\":\"primitive\",\"value\":1}],\"kind\":\"list\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"kind\":\"undefined\"},{\"kind\":\"primitive\",\"value\":1}],\"kind\":\"list\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"arrays-and-their-holes\",\"id\":\"a-hole-is-not-an-undefined\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"`Object.keys([,1])` is `[\\\"1\\\"]` and `Object.keys([undefined,1])` is `[\\\"0\\\",\\\"1\\\"]`, so the two differ in what they hold and not only in what they read as. `map` and `forEach` skip the hole and visit the `undefined`, which is where a caller meets the difference.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2}],\"kind\":\"list\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2},{\"kind\":\"hole\"}],\"kind\":\"list\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"arrays-and-their-holes\",\"id\":\"a-trailing-hole-changes-the-length\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"Own keys are identical here and the lengths are 2 and 3, so this is the row that says the walk compares an array's length as well as its keys. Without it a table built only from key sets would pass an implementation that dropped the length check.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1}],\"kind\":\"set\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":2}],\"kind\":\"set\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"collections-carry-what-no-key-walk-sees\",\"id\":\"two-sets-of-different-members-are-different\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The sharpest instance in the catalogue of a silent wrong answer: measured, `fast-deep-equal@3.1.3` and `dequal/lite@2.0.3` both answer true, because a Set has no own enumerable property and a walk over keys sees two empty objects.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2}],\"kind\":\"set\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1}],\"kind\":\"set\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"collections-carry-what-no-key-walk-sees\",\"id\":\"two-sets-of-different-size-are-different\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The same two implementations answer true here too, which is what separates this from the row above: it is not that they compare members badly, it is that they do not look at the collection at all.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"key\":{\"kind\":\"primitive\",\"value\":\"a\"},\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"map\"}},{\"name\":\"right\",\"value\":{\"entries\":[],\"kind\":\"map\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"collections-carry-what-no-key-walk-sees\",\"id\":\"a-populated-map-is-not-an-empty-one\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The `JSON.stringify` spelling also answers true here, and for the same reason as the two above rather than a different one - a Map serialises as `{}`. Three ways of asking, one blindness.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"key\":{\"kind\":\"primitive\",\"value\":\"a\"},\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"map\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"key\":{\"kind\":\"primitive\",\"value\":\"a\"},\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"map\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"collections-carry-what-no-key-walk-sees\",\"id\":\"a-map-value-is-compared\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"A Map is compared by its entries and not only by its keys, which is the half an implementation comparing sizes and key sets would pass without.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2}],\"kind\":\"set\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"kind\":\"primitive\",\"value\":2},{\"kind\":\"primitive\",\"value\":1}],\"kind\":\"set\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"collections-carry-what-no-key-walk-sees\",\"id\":\"the-order-members-were-added-in-is-not-read\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"Insertion order is observable on a Set - it decides iteration - and it is not part of what the Set holds. A caller who built the same set of ids from two different queries has one set of ids.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"}],\"kind\":\"set\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"}],\"kind\":\"set\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"collections-carry-what-no-key-walk-sees\",\"id\":\"a-set-member-is-compared-by-its-data\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The other direction of the same blindness, and the one the ecosystem's remedy gets wrong: `fast-deep-equal/es6` - the entry point its README sends a caller to for collections - answers false, because it tests membership with `has`, which is reference identity.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"key\":{\"fields\":[{\"name\":\"k\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"},\"value\":{\"kind\":\"primitive\",\"value\":\"v\"}}],\"kind\":\"map\"}},{\"name\":\"right\",\"value\":{\"entries\":[{\"key\":{\"fields\":[{\"name\":\"k\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"},\"value\":{\"kind\":\"primitive\",\"value\":\"v\"}}],\"kind\":\"map\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"collections-carry-what-no-key-walk-sees\",\"id\":\"a-map-key-is-compared-by-its-data\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The same for a key rather than a member, which is the harder half: matching entries without an order means a key of one has to be found among the unclaimed keys of the other, and that is the only quadratic path in the contract.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"epoch\":{\"kind\":\"primitive\",\"value\":0},\"kind\":\"instant\"}},{\"name\":\"right\",\"value\":{\"epoch\":{\"kind\":\"primitive\",\"value\":0},\"kind\":\"instant\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"two-instants-are-one-date\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"A Date carries a number of milliseconds in a slot and has no own property at all. Two dates naming one instant are one datum.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"epoch\":{\"kind\":\"number\",\"literal\":\"nan\"},\"kind\":\"instant\"}},{\"name\":\"right\",\"value\":{\"epoch\":{\"kind\":\"number\",\"literal\":\"nan\"},\"kind\":\"instant\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"an-invalid-date-equals-an-invalid-date\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The slot holds `NaN`, and the rule is the one the first group settles: `Object.is` and not `===`. Measured, three of five shipped implementations answer false here, which is `NaN`'s own trap arriving inside a built-in.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"epoch\":{\"kind\":\"primitive\",\"value\":0},\"kind\":\"instant\"}},{\"name\":\"right\",\"value\":{\"epoch\":{\"kind\":\"number\",\"literal\":\"nan\"},\"kind\":\"instant\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"an-invalid-date-is-not-an-instant\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The neighbour of the row above, and the reason that row is about `Object.is` rather than about treating every invalid date as equal to everything.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"flags\":\"gi\",\"kind\":\"pattern\",\"source\":\"ab+c\"}},{\"name\":\"right\",\"value\":{\"flags\":\"gi\",\"kind\":\"pattern\",\"source\":\"ab+c\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"a-pattern-is-its-source-and-its-flags\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The two things a pattern is. Everything else about a RegExp object is derived from them or is the state of a scan, which the last row of this group settles.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"flags\":\"g\",\"kind\":\"pattern\",\"source\":\"a\"}},{\"name\":\"right\",\"value\":{\"flags\":\"g\",\"kind\":\"pattern\",\"source\":\"b\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"a-pattern-source-is-part-of-it\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The half of the row above that says `source` is read.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"flags\":\"g\",\"kind\":\"pattern\",\"source\":\"a\"}},{\"name\":\"right\",\"value\":{\"flags\":\"i\",\"kind\":\"pattern\",\"source\":\"a\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"a-pattern-flag-is-part-of-it\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The other half, and not the same claim: an implementation comparing only `source` passes the row above and fails here.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"flags\":\"g\",\"kind\":\"pattern\",\"source\":\"a\"}},{\"name\":\"right\",\"value\":{\"flags\":\"g\",\"kind\":\"pattern\",\"source\":\"a\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"where-a-pattern-stopped-is-not-part-of-it\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"`util.isDeepStrictEqual` reads `lastIndex` and answers false; `lodash`, `dequal` and `fast-deep-equal` ignore it. **This contract excludes it and the argument is not a show of hands.** Measured: `structuredClone(/a/g)` with `lastIndex` at 3 returns a pattern whose `lastIndex` is 0, with `source` and `flags` identical, and the same for a sticky pattern. The declared domain is the values `structuredClone` carries and the admission oracle is that a value equals its own clone, so reading `lastIndex` would make this contract fail the oracle it was admitted on. `util.isDeepStrictEqual` is bound by no such domain; this contract is.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[],\"kind\":\"boxed\",\"of\":\"number\",\"value\":{\"kind\":\"primitive\",\"value\":7}}},{\"name\":\"right\",\"value\":{\"fields\":[],\"kind\":\"boxed\",\"of\":\"number\",\"value\":{\"kind\":\"primitive\",\"value\":8}}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"a-boxed-number-carries-a-number\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"**A row the author of this contract got wrong.** A boxed number has no own property, so a walk that enumerates keys sees two empty objects and answers true - which is what this contract's own walk did, silently, until the dispatch was measured. `lodash` and `util.isDeepStrictEqual` were right about it all along.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[],\"kind\":\"boxed\",\"of\":\"boolean\",\"value\":{\"kind\":\"primitive\",\"value\":true}}},{\"name\":\"right\",\"value\":{\"fields\":[],\"kind\":\"boxed\",\"of\":\"boolean\",\"value\":{\"kind\":\"primitive\",\"value\":false}}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"a-boxed-boolean-carries-a-boolean\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The same slot blindness on a second kind, kept as its own row because a dispatch repaired for `Number` alone passes the row above and fails here - which is how the repair was checked.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[],\"kind\":\"boxed\",\"of\":\"bigint\",\"value\":{\"digits\":\"1\",\"kind\":\"big-integer\"}}},{\"name\":\"right\",\"value\":{\"fields\":[],\"kind\":\"boxed\",\"of\":\"bigint\",\"value\":{\"digits\":\"2\",\"kind\":\"big-integer\"}}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"a-boxed-bigint-carries-a-bigint\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The third kind, and the one that is easiest to leave out because `Object(1n)` is not a spelling anybody writes on purpose - which is exactly why a caller meets it through a library rather than through their own code.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[],\"kind\":\"boxed\",\"of\":\"number\",\"value\":{\"kind\":\"primitive\",\"value\":7}}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"tag\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"boxed\",\"of\":\"number\",\"value\":{\"kind\":\"primitive\",\"value\":7}}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"a-slot-does-not-hide-an-own-property\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The slots agree and the own keys do not. Measured, `lodash` answers true here - it reads the slot and stops - so this row is one of the two places this contract is stricter than the most-used implementation rather than looser.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"elements\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2}],\"kind\":\"typed-array\",\"of\":\"Uint8Array\"}},{\"name\":\"right\",\"value\":{\"elements\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":2}],\"kind\":\"typed-array\",\"of\":\"Uint8Array\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"two-typed-arrays-of-one-kind-are-their-elements\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"A typed array has indexed own properties, so a key walk finds something - which is why this row passes almost everywhere and the next two do not.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"elements\":[{\"kind\":\"primitive\",\"value\":1},{\"kind\":\"primitive\",\"value\":0}],\"kind\":\"typed-array\",\"of\":\"Uint8Array\"}},{\"name\":\"right\",\"value\":{\"elements\":[{\"kind\":\"primitive\",\"value\":1}],\"kind\":\"typed-array\",\"of\":\"Uint16Array\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"a-typed-array-kind-is-part-of-it\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"Same bytes, different kinds, different lengths, and a caller cannot use one where the other is expected. The prototypes differ, which is what the walk reads.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"elements\":[{\"kind\":\"number\",\"literal\":\"nan\"}],\"kind\":\"typed-array\",\"of\":\"Float64Array\"}},{\"name\":\"right\",\"value\":{\"elements\":[{\"kind\":\"number\",\"literal\":\"nan\"}],\"kind\":\"typed-array\",\"of\":\"Float64Array\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"not-a-number-inside-a-float-array-equals-itself\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The row that caught three of the five shipped implementations against the oracle: they compare elements with `===`, so a float array holding `NaN` is not equal to its own structured clone. `Object.is` per element is the rule, and it is the first group's rule again rather than a new one.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"elements\":[{\"kind\":\"number\",\"literal\":\"negative-zero\"}],\"kind\":\"typed-array\",\"of\":\"Float64Array\"}},{\"name\":\"right\",\"value\":{\"elements\":[{\"kind\":\"primitive\",\"value\":0}],\"kind\":\"typed-array\",\"of\":\"Float64Array\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-value-in-an-internal-slot\",\"id\":\"negative-zero-inside-a-float-array-is-not-zero\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The other half of `Object.is` inside a typed array, and the half an implementation comparing bytes would get right by accident - which is a different implementation from one that got the row above right.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"errorKind\":\"Error\",\"fields\":[],\"kind\":\"error\",\"message\":\"x\"}},{\"name\":\"right\",\"value\":{\"errorKind\":\"Error\",\"fields\":[],\"kind\":\"error\",\"message\":\"x\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"an-error-is-data\",\"id\":\"two-errors-of-one-message-are-one-error\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"An error caught and stored is a value like any other. `stack` is not read, because it names where the error was constructed rather than what it says, and two errors built at two call sites for one reason are one reason.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"errorKind\":\"Error\",\"fields\":[],\"kind\":\"error\",\"message\":\"a\"}},{\"name\":\"right\",\"value\":{\"errorKind\":\"Error\",\"fields\":[],\"kind\":\"error\",\"message\":\"b\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"an-error-is-data\",\"id\":\"a-message-is-part-of-an-error\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"Measured, `dequal` answers true here - it walks own enumerable properties and `message` is not one of them. The same blindness as the collections, on the type a caller is most likely to be comparing when something has gone wrong.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"cause\":{\"kind\":\"primitive\",\"value\":1},\"errorKind\":\"Error\",\"fields\":[],\"kind\":\"error\",\"message\":\"a\"}},{\"name\":\"right\",\"value\":{\"cause\":{\"kind\":\"primitive\",\"value\":2},\"errorKind\":\"Error\",\"fields\":[],\"kind\":\"error\",\"message\":\"a\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"an-error-is-data\",\"id\":\"a-cause-is-part-of-an-error\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"`cause` is where the original failure is kept, so an implementation reading `name` and `message` alone answers true for two errors that happened for different reasons. It is compared as data rather than by identity, so a cause that is itself an object is walked.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"errorKind\":\"TypeError\",\"fields\":[],\"kind\":\"error\",\"message\":\"x\"}},{\"name\":\"right\",\"value\":{\"errorKind\":\"Error\",\"fields\":[],\"kind\":\"error\",\"message\":\"x\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"an-error-is-data\",\"id\":\"an-error-kind-is-part-of-it\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The prototype rule of the second group, arriving where a caller most often branches on it: code that asks `err instanceof TypeError` is asking about exactly this difference.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"name\",\"value\":{\"kind\":\"primitive\",\"value\":\"root\"}},{\"name\":\"self\",\"value\":{\"kind\":\"again\",\"shared\":1}}],\"kind\":\"record\",\"shared\":1}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"name\",\"value\":{\"kind\":\"primitive\",\"value\":\"root\"}},{\"name\":\"self\",\"value\":{\"kind\":\"again\",\"shared\":2}}],\"kind\":\"record\",\"shared\":2}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"a-graph-that-returns-to-itself\",\"id\":\"a-cycle-terminates\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"Measured, three of six shipped implementations do not answer this at all - they exhaust the call stack. Answering is the claim; answering `true` is the second half, and it is the coinductive reading: two graphs that unfold to the same infinite tree are the same data.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"entries\":[{\"kind\":\"again\",\"shared\":1}],\"kind\":\"set\",\"shared\":1}},{\"name\":\"right\",\"value\":{\"entries\":[{\"kind\":\"again\",\"shared\":2}],\"kind\":\"set\",\"shared\":2}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":true}}],\"kind\":\"record\"},\"group\":\"a-graph-that-returns-to-itself\",\"id\":\"a-set-containing-itself-terminates\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The same claim through a collection rather than through a property, and it is not the same test: matching members recurses, so an implementation whose cycle detection lives only in the property walk answers the row above and never returns from this one.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"name\",\"value\":{\"kind\":\"primitive\",\"value\":\"root\"}},{\"name\":\"self\",\"value\":{\"kind\":\"again\",\"shared\":1}}],\"kind\":\"record\",\"shared\":1}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"name\",\"value\":{\"kind\":\"primitive\",\"value\":\"root\"}},{\"name\":\"self\",\"value\":{\"fields\":[{\"name\":\"name\",\"value\":{\"kind\":\"primitive\",\"value\":\"root\"}},{\"name\":\"self\",\"value\":{\"kind\":\"primitive\",\"value\":null}}],\"kind\":\"record\"}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-graph-that-returns-to-itself\",\"id\":\"a-cycle-is-not-the-same-as-its-unrolling\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The row that stops the one above from being satisfied by an implementation that answers `true` whenever it has seen a pair before. A cycle and a finite unrolling of it part at the first place the unrolling ends.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"s\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\",\"shared\":1},{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"}],\"kind\":\"set\"}},{\"name\":\"also\",\"value\":{\"entries\":[{\"kind\":\"again\",\"shared\":1}],\"kind\":\"list\"}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"s\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"}],\"kind\":\"set\"}},{\"name\":\"also\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"}],\"kind\":\"list\"}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-graph-that-returns-to-itself\",\"id\":\"a-failed-candidate-leaves-nothing-behind\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"**The row the author of this contract got wrong, in the hour after writing down the danger of cycle detection.** The two Sets match either way round; `also` holds `{v:1}` against `{v:2}`. An implementation that memoises the pairs a failed candidate tried answers `true`, because the failed attempt left `({v:1}, {v:2})` marked as assumed equal. All four shipped implementations answer `false`, so this row founds no admission - what it founds is the clause, and the evidence for the clause is that the fault was committed here.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"also\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\",\"shared\":1}],\"kind\":\"list\"}},{\"name\":\"s\",\"value\":{\"entries\":[{\"kind\":\"again\",\"shared\":1},{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"}],\"kind\":\"set\"}}],\"kind\":\"record\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"also\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"}],\"kind\":\"list\"}},{\"name\":\"s\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"v\",\"value\":{\"kind\":\"primitive\",\"value\":1}}],\"kind\":\"record\"}],\"kind\":\"set\"}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"a-graph-that-returns-to-itself\",\"id\":\"and-answers-the-same-either-way-round\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The same two values with their two keys declared in the other order, and nothing else changed. The walk that got the row above wrong answered `false` here, so a table carrying only one of the two would have been green on half the defect - which is what makes this a row rather than a note.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"kind\":\"opaque\",\"nature\":\"promise\"}},{\"name\":\"right\",\"value\":{\"kind\":\"opaque\",\"nature\":\"promise\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"what-the-domain-does-not-carry\",\"id\":\"two-promises-are-not-compared\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"Nothing about a promise's contents is readable synchronously, so there is nothing to compare. `false` rather than a throw, because the caller asked a question with an answer: these are not the same value.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"kind\":\"opaque\",\"nature\":\"weak-map\"}},{\"name\":\"right\",\"value\":{\"kind\":\"opaque\",\"nature\":\"weak-map\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"what-the-domain-does-not-carry\",\"id\":\"two-weak-collections-are-not-compared\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"A WeakMap cannot be enumerated by design. Answering `true` for two of them - which the author's own walk did, because they have no own property - is the silent `true` this contract exists to refuse, arriving on a type nobody thinks to test.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"kind\":\"not-data\",\"nature\":\"function\"}},{\"name\":\"right\",\"value\":{\"kind\":\"not-data\",\"nature\":\"function\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"what-the-domain-does-not-carry\",\"id\":\"two-functions-are-not-compared\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"Two functions are equal when they are the same reference and not otherwise: source text is not behaviour, and a closure carries what no reading of it shows. The author's walk answered `true` for these two as well.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"className\":\"ASmallClass\",\"fields\":[{\"name\":\"x\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"instance\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"x\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"what-a-clone-does-not-preserve\",\"id\":\"a-class-instance-is-not-its-own-clone\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"`structuredClone` returns a plain object for a class instance - measured, the prototype goes from the class to `Object` - so the clone is not the same kind of thing. This row is what `p1-reflexive-under-a-copy` excludes rather than what it asserts, and it was found by fast-check on the first hundred draws while the property was being calibrated.\"},{\"data\":{\"fields\":[{\"name\":\"left\",\"value\":{\"fields\":[{\"name\":\"b\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\",\"prototype\":\"none\"}},{\"name\":\"right\",\"value\":{\"fields\":[{\"name\":\"b\",\"value\":{\"kind\":\"primitive\",\"value\":2}}],\"kind\":\"record\"}},{\"name\":\"expected\",\"value\":{\"kind\":\"primitive\",\"value\":false}}],\"kind\":\"record\"},\"group\":\"what-a-clone-does-not-preserve\",\"id\":\"a-null-prototype-object-is-not-its-own-clone\",\"provenance\":{\"kind\":\"specified\"},\"rationale\":\"The same flattening at the other end: a null-prototype object clones to a plain one. `util.isDeepStrictEqual` answers `false` here too and `lodash` answers `true`, so the ecosystem is split on the row that decides how the oracle has to be stated.\"}],\"groups\":[{\"id\":\"identity-of-a-primitive\",\"note\":\"Where the walk stops before it starts. Every one of these is decided by `Object.is`, which is the language's own rule and the reason `NaN` equals itself here while `-0` does not equal `0`.\",\"title\":\"Identity of a primitive\"},{\"id\":\"the-shape-of-a-plain-object\",\"note\":null,\"title\":\"The shape of a plain object\"},{\"id\":\"arrays-and-their-holes\",\"note\":\"An array is compared by its own keys, so a hole and a stored `undefined` are different things - which is what `Object.keys` says about them and what nothing that walks values alone can see.\",\"title\":\"Arrays and their holes\"},{\"id\":\"collections-carry-what-no-key-walk-sees\",\"note\":\"The reason this contract exists. `Object.keys(new Set([1]))` is the empty array, so an implementation that walks own properties sees two empty objects and says they match - measured, two of five shipped implementations answer `true` for `new Set([1])` against `new Set([2])`.\",\"title\":\"Collections carry what no key walk sees\"},{\"id\":\"a-value-in-an-internal-slot\",\"note\":\"The same blindness one floor down: a `Date`, a boxed number and a typed array carry their value where no own property is, and a walk that enumerates keys sees nothing to compare.\",\"title\":\"A value in an internal slot\"},{\"id\":\"an-error-is-data\",\"note\":null,\"title\":\"An error is data\"},{\"id\":\"a-graph-that-returns-to-itself\",\"note\":\"Terminating is half of it. The other half is that a comparison which remembers what it has already assumed must forget an assumption it made speculatively, and the last two rows are the ones the author got wrong.\",\"title\":\"A graph that returns to itself\"},{\"id\":\"what-the-domain-does-not-carry\",\"note\":\"Values `structuredClone` refuses. The contract answers `false` rather than guessing or throwing, because a silent `true` on two different functions is the defect this whole catalogue is written against.\",\"title\":\"What the domain does not carry\"},{\"id\":\"what-a-clone-does-not-preserve\",\"note\":\"`p1-reflexive-under-a-copy` is the oracle this contract was admitted on, and it is not unconditional. `structuredClone` returns a plain object for a class instance and for a null-prototype object, so a value of either shape is not equal to its own clone - measured, and `util.isDeepStrictEqual` answers the same. The property's alphabet excludes both, and these rows are where they are settled instead.\",\"title\":\"What a clone does not preserve\"}],\"name\":\"edge-cases\",\"purpose\":\"the pairs this contract settles, each answered by the walk and by the transposition of itself, because an order-insensitive matching can answer differently by side\"}],\"environments\":[\"node\",\"browser\",\"bun\"],\"harness\":[{\"bytes\":28902,\"path\":\"contract.ts\",\"sha256\":\"a81d506e5508114c09b3e042a2b9fa7b6bce205f2737cf5df60a08ebaae7b19d\"},{\"bytes\":7300,\"path\":\"edge-cases.test.ts\",\"sha256\":\"573f6126911e7e5c9235d108977d7c2ff9ed737ec32983515e7070172528adde\"},{\"bytes\":31958,\"path\":\"edge-cases.ts\",\"sha256\":\"e522101f87ed5efa900a2d1578c6a3669ed01a8e5355bdffd40a7c2cab4b60b5\"},{\"bytes\":5457,\"path\":\"profiles.test.ts\",\"sha256\":\"501a582ff7f000151aaf1e5abf437670f432247c56badc2e753da104eb4b1fb6\"},{\"bytes\":13428,\"path\":\"properties.test.ts\",\"sha256\":\"deae75c3e8339e88ed1e387c6b7bf4e7429957a351ca372a8d388ecb24fbf6dd\"},{\"bytes\":13327,\"path\":\"reference.ts\",\"sha256\":\"b95927962c5e235be2e378ba97881c1a7166e7d4f9725ee66cdebe0564d18efb\"},{\"bytes\":2881,\"path\":\"signature.test-d.ts\",\"sha256\":\"58a93ebd566c328868835aaf9687c1e201958f0c98b0f3b74660b54e662e97c6\"}],\"identity\":{\"description\":\"Answers whether two JavaScript values carry the same data. `===` compares references, and the spelling a caller reaches for instead - comparing two JSON.stringify results - is wrong on seven of nine ordinary pairs: it answers false for {a:1,b:2} against {b:2,a:1}, true for a populated Map against an empty one, true for a Date against its own ISO string, true for -0 against 0, and it throws on a cyclic value and on a BigInt. The cause is one line of the language: Object.keys of a Set is the empty array, so a collection carries its contents where no property walk reaches. Measured on fast-deep-equal 3.1.3, deep-equal 2.2.3, dequal 2.0.3, lodash 4.18.1 and the runtime's own util.isDeepStrictEqual, eleven of twenty-eight ordinary pairs are answered differently by at least two of them - and two of those five answer true for new Set([1]) against new Set([2]) and for a populated Map against an empty one, because they walk own properties and a Set has none. The entry point their README sends a caller to for collections answers false for a Set of objects against its own structured clone. This contract settles all of it, and settles two things nothing else does: the comparison does not consume the call stack in proportion to the depth of ordinary structure, and a candidate match inside a collection that fails leaves nothing behind it.\",\"exportName\":\"deepEqual\",\"inputDomain\":\"The values structuredClone carries: primitives, plain objects, arrays, Map, Set, Date, RegExp, Error, typed arrays, ArrayBuffer, DataView, boxed primitives, and any graph made of them, including one that returns to itself. It is not a schema validator, not a similarity score and not an assertion - it answers and never throws. It does not read into a Promise, a WeakMap, a WeakSet, a WeakRef or a function, because nothing about their contents is observable; two distinct such values are answered false rather than guessed at. It compares prototypes, so an instance of a class and a plain object carrying the same fields are two different things, and a caller who wants them equal wants a different function.\",\"relationToTheLanguage\":\"ECMAScript compares two values structurally nowhere: Object.is and === answer about references, and JSON.stringify is not a comparison. Read on 2026-08-23, three stage 1 proposals touch this and none would answer it. Composites, last moved 2026-08-18, gives value equality to purpose-built frozen string-keyed structures compared with === after interning - it is shallow, cannot hold a cycle and cannot be asked about two objects that already exist. Array Equality, last moved 2021-04-22, is scoped to arrays. Comparisons, last moved 2026-06-11, is about assertion functions and its open question is whether it should cover rich equality comparisons at all; that is the proposal this contract is re-examined against. The runtime's util.isDeepStrictEqual is a host's assertion helper, absent from the browser, specified nowhere, and the first of six to fall over on depth.\",\"searchAliases\":[\"deep equal\",\"deepEqual\",\"deep compare\",\"compare objects\",\"are two objects equal\",\"object equality\",\"structural equality\",\"compare arrays\",\"deep comparison\",\"isEqual\",\"lodash isEqual\",\"compare nested objects\",\"compare Map\",\"compare Set\",\"value equality\"],\"summary\":\"Compare two values by the data they carry rather than by reference, walking into arrays, objects, Map, Set, typed arrays, Date, RegExp and Error, terminating on graphs that return to themselves, and never writing to either argument.\"},\"ownDeclarations\":[{\"name\":\"theClauses\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":\"the-stack-is-not-spent-on-ordinary-depth\"}},{\"name\":\"claim\",\"value\":{\"kind\":\"primitive\",\"value\":\"The comparison does not consume the call stack in proportion to the depth of ordinary structure - objects and arrays - because that walk runs on a stack of its own on the heap.\"}},{\"name\":\"bound\",\"value\":{\"kind\":\"primitive\",\"value\":\"Nesting through collections costs one call frame per level, because a candidate member has to be settled completely before it can be claimed, and no order-insensitive matching avoids that. Measured at about 1 500 levels of nested Set or Map, where dequal reaches about twice as far. The bound is declared so that a caller meets it here rather than in production.\"}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":\"speculation-inside-a-collection-is-taken-back\"}},{\"name\":\"claim\",\"value\":{\"kind\":\"primitive\",\"value\":\"A candidate match inside a Map or a Set that fails leaves nothing behind it. The pairs being compared are a path, entered on the way down and left on the way up, and a speculative walk that fails takes back everything it opened.\"}},{\"name\":\"bound\",\"value\":{\"kind\":\"primitive\",\"value\":\"No implementation measured gets this wrong, so it founds no admission. What it carries instead is `theAuthoringFaults` below: the fault is easy enough that the person who had just enumerated it committed it, and a fifty-four case trial did not see it.\"}}],\"kind\":\"record\"}],\"kind\":\"list\"},\"verification\":\"documentary\"},{\"name\":\"theDepthReadings\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"implementation\",\"value\":{\"kind\":\"primitive\",\"value\":\"this contract\"}},{\"name\":\"ordinaryStructure\",\"value\":{\"kind\":\"primitive\",\"value\":\"at least 1 000 000\"}},{\"name\":\"throughCollections\",\"value\":{\"kind\":\"primitive\",\"value\":\"about 1 500\"}},{\"name\":\"note\",\"value\":{\"kind\":\"primitive\",\"value\":\"Ordinary structure is walked on an explicit stack, so its depth costs no call frames at all and the figure is where the probe stopped asking rather than where the walk stopped answering. Nesting through collections costs one frame per level, for the reason the clause below states.\"}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"implementation\",\"value\":{\"kind\":\"primitive\",\"value\":\"dequal 2.0.3\"}},{\"name\":\"ordinaryStructure\",\"value\":{\"kind\":\"primitive\",\"value\":\"about 5 000\"}},{\"name\":\"throughCollections\",\"value\":{\"kind\":\"primitive\",\"value\":\"about 3 000\"}},{\"name\":\"note\",\"value\":{\"kind\":\"primitive\",\"value\":\"Twice as far as this contract through collections. The clause below is about ordinary structure, and through collections this contract is not the best of the five - which is stated here because a reading that named only where it won would not be a reading.\"}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"implementation\",\"value\":{\"kind\":\"primitive\",\"value\":\"fast-deep-equal/es6 3.1.3\"}},{\"name\":\"ordinaryStructure\",\"value\":{\"kind\":\"primitive\",\"value\":\"about 8 000\"}},{\"name\":\"throughCollections\",\"value\":{\"kind\":\"primitive\",\"value\":\"one\"}},{\"name\":\"note\",\"value\":{\"kind\":\"primitive\",\"value\":\"The second figure is not a ceiling. It answers false for a Set containing a Set against the same shape, because it tests membership by reference, so the bisection reports the depth at which it stops being right rather than the depth at which it stops answering. Counting it as a ceiling would be a cause nobody measured.\"}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"implementation\",\"value\":{\"kind\":\"primitive\",\"value\":\"lodash 4.18.1\"}},{\"name\":\"ordinaryStructure\",\"value\":{\"kind\":\"primitive\",\"value\":\"about 1 500\"}},{\"name\":\"throughCollections\",\"value\":{\"kind\":\"primitive\",\"value\":\"about 1 200\"}},{\"name\":\"note\",\"value\":{\"kind\":\"primitive\",\"value\":null}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"implementation\",\"value\":{\"kind\":\"primitive\",\"value\":\"util.isDeepStrictEqual on Node 24.15.0\"}},{\"name\":\"ordinaryStructure\",\"value\":{\"kind\":\"primitive\",\"value\":\"about 1 000\"}},{\"name\":\"throughCollections\",\"value\":{\"kind\":\"primitive\",\"value\":\"about 800\"}},{\"name\":\"note\",\"value\":{\"kind\":\"primitive\",\"value\":\"The strictest implementation measured and the first to give up. A thousand-deep structure is a linked list or a parsed tree, not a pathological input.\"}}],\"kind\":\"record\"}],\"kind\":\"list\"},\"verification\":\"documentary\"},{\"name\":\"theAuthoringFaults\",\"value\":{\"entries\":[{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":\"a-memo-where-a-path-was-needed\"}},{\"name\":\"what\",\"value\":{\"kind\":\"primitive\",\"value\":\"A candidate match inside a Set that failed left the pair it had tried marked as assumed equal, and nothing removed it. Given { s: Set([{v:1},{v:2}]), also: [{v:1}] } against { s: Set([{v:2},{v:1}]), also: [{v:2}] } the walk answered true where the answer is false - and answered false when the two keys were declared in the other order.\"}},{\"name\":\"howItWasFound\",\"value\":{\"kind\":\"primitive\",\"value\":\"By asking what a failed candidate leaves behind, not by a test. All four shipped implementations answer this correctly.\"}},{\"name\":\"remedy\",\"value\":{\"kind\":\"primitive\",\"value\":\"The pairs under comparison are a path rather than a memo, and a speculative walk that fails unwinds what it opened.\"}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":\"a-dispatch-that-enumerated-what-the-author-remembered\"}},{\"name\":\"what\",\"value\":{\"kind\":\"primitive\",\"value\":\"The built-in dispatch listed the kinds the author had thought of, and the ones carrying their value in an internal slot have no own property for a key walk to see. Over twelve pairs the walk answered eight wrongly, every one a silent true: new Number(7) against new Number(8), new Boolean(true) against new Boolean(false), Object(1n) against Object(2n), two boxed symbols, two promises, two WeakMaps, two WeakSets and two functions. lodash and util.isDeepStrictEqual answer all twelve correctly.\"}},{\"name\":\"howItWasFound\",\"value\":{\"kind\":\"primitive\",\"value\":\"By asking what the dispatch cannot see, not by a test.\"}},{\"name\":\"remedy\",\"value\":{\"kind\":\"primitive\",\"value\":\"The dispatch reads Object.prototype.toString rather than instanceof, because the tag reads the slot where the prototype proves nothing: Object.create(Number.prototype) passes instanceof Number, has no slot, and a walk that trusted the prototype would call valueOf on it and throw.\"}}],\"kind\":\"record\"},{\"fields\":[{\"name\":\"id\",\"value\":{\"kind\":\"primitive\",\"value\":\"a-branch-that-answered-for-the-whole-value\"}},{\"name\":\"what\",\"value\":{\"kind\":\"primitive\",\"value\":\"Every built-in branch answered for the value and not for its slot, so a built-in carrying an own property beside its slot compared equal to the same value without one. Measured over eight pairs, the walk answered six wrongly, every one a silent true: a Date, a RegExp, a Set, a Map, an ArrayBuffer and a typed array. lodash gets all eight wrong; util.isDeepStrictEqual gets all eight right.\"}},{\"name\":\"howItWasFound\",\"value\":{\"kind\":\"primitive\",\"value\":\"By p6-a-perturbed-clone-is-not-the-original, whose counter-example was a typed array holding a single zero - and the counter-example was not the fault. Chasing why that one value survived a perturbation is what led to the branches.\"}},{\"name\":\"remedy\",\"value\":{\"kind\":\"primitive\",\"value\":\"The repair left the branches. A branch settles only what its value carries in a slot, and settle compares the own keys once on the way out for every kind of value - so a branch added later inherits it rather than needing its own patch, which is what the first two got.\"}}],\"kind\":\"record\"}],\"kind\":\"list\"},\"verification\":\"documentary\"}],\"properties\":{\"runs\":1000,\"universal\":[{\"applicable\":true,\"name\":\"never mutates its arguments\",\"reason\":\"Both arguments are arbitrary object graphs and the walk has to remember where it has been. Witnessed by an implementation that marks each visited object with a temporary property and removes it on the way out, which is a real technique and leaves a marker on every object it failed to unwind - the shape a walk reaches the first time somebody makes cycle detection \\\"cheaper\\\". The property walks both arguments before and after the call and compares the own keys of every reachable object, so a marker left anywhere in either graph reddens it.\"},{\"applicable\":true,\"name\":\"deterministic\",\"reason\":\"Violable in practice, and witnessed twice over. A cache keyed on one argument answers a second call from the first, and - measured on this contract's own walk while it was being written - a comparison that memoises the pairs a failed candidate tried answers differently depending on the order the keys of an object were declared in, which is the same defect arriving through the data instead of through a cache. This property is ordered under `no ambient input` rather than independent of it: every mutant measured to redden it reddens that one too, and the memoise-last mutant reddens that one and not this.\"},{\"applicable\":true,\"name\":\"no ambient input\",\"reason\":\"Violable in practice: this contract reads two values and answers a boolean, so the call history is the only ambient input it can plausibly acquire. Witnessed by an implementation holding the last pair it was asked and its verdict, and serving that verdict whenever both arguments match by reference - which answers correctly until one of the two graphs is mutated between calls, and then answers the previous question. The property interleaves a probe with an arbitrary history and requires the probe to answer identically either way.\"},{\"applicable\":false,\"name\":\"no ambient output\",\"reason\":\"Not reachable by a property - a test cannot observe a write that happened before it ran, and a correct memoising cache is indistinguishable from a defect by behaviour alone.\"}]},\"sharedHarness\":[{\"bytes\":16621,\"path\":\"packages/catalogue/every-contract.ts\",\"sha256\":\"651fcc16fdc900bcded8e572bc5bb044c52322bb9c04bc2c05630e2761d5cc16\"},{\"bytes\":9777,\"path\":\"packages/catalogue/identifier.ts\",\"sha256\":\"8ab32ffcd699e39aa4fcb7604722f28dc12b723fca3a126a413c3e0a26ff3ff6\"}],\"surface\":{\"exports\":[{\"name\":\"deepEqual\",\"parameters\":[{\"name\":\"left\",\"type\":\"unknown\"},{\"name\":\"right\",\"type\":\"unknown\"}],\"role\":\"the-answer\",\"text\":\"(left: unknown, right: unknown) => boolean\",\"typeName\":\"DeepEqual\"}],\"supportingTypes\":[]}},\"unit\":\"contract\"}","formatVersion":1}