[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10,"_11":12},"actionData","errors","root",{"_163":-5,"_166":167,"_168":169},"routes/shell",{"_41":42,"_162":-5,"_163":-5,"_164":165},"routes/repo",{"_34":-7,"_35":36,"_37":38,"_39":40,"_41":42,"_43":32,"_44":32,"_45":32,"_46":32,"_47":32,"_48":32,"_49":50,"_51":52,"_53":32,"_54":-7,"_55":-7,"_56":57,"_58":59,"_60":61,"_62":-5,"_63":64,"_65":66,"_67":68,"_69":70},"routes/repo.blob",{"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":-5,"_26":27,"_28":29,"_29":30,"_31":32,"_33":14},"ref","main","path","lib/mod.test.ts","oid","c82259948ac5e8b094009e6b46eba1d9fb39d08d","size",24033,"commit","4ad87b4a27dc9cdf5d509a7b324f57ddc6041ecb","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","import { assert, assertEquals, assertNotEquals, assertNotMatch, assertThrows } from '@std/assert';\nimport fc from 'fast-check';\nimport { Buffer } from 'node:buffer';\nimport { identify } from '../lib/mod.ts';\n\nDeno.test('exports :: identify is a function', () => {\n\tassertEquals(typeof identify, 'function');\n});\n\n// ~> Primitives\n\nDeno.test('primitives :: are deterministic', () => {\n\tconst stable = (v: unknown) => assertEquals(identify(v), identify(v), `${String(v)} is unstable`);\n\tstable('hello');\n\tstable('');\n\tstable(0);\n\tstable(-0);\n\tstable(123);\n\tstable(-4.5);\n\tstable(NaN);\n\tstable(Infinity);\n\tstable(-Infinity);\n\tstable(true);\n\tstable(false);\n\tstable(null);\n\tstable(undefined);\n\tstable(123n);\n});\n\nDeno.test('primitives :: distinct values are distinct', () => {\n\tassertNotEquals(identify(1), identify(2));\n\tassertNotEquals(identify('a'), identify('b'));\n\tassertNotEquals(identify(true), identify(false));\n\tassertNotEquals(identify(1.5), identify(1.50001));\n\tassertNotEquals(identify(''), identify(' '));\n});\n\nDeno.test('primitives :: are distinct from their string form', () => {\n\t// A number, boolean, or null is its own thing, never its text spelling.\n\tassertNotEquals(identify(1), identify('1'));\n\tassertEquals(identify('1'), identify('1'));\n\tassertNotEquals(identify(true), identify('true'));\n\tassertNotEquals(identify(null), identify('null'));\n\tassertNotEquals(identify(undefined), identify('undefined'));\n});\n\nDeno.test('strings :: preserve exact content', () => {\n\tassertEquals(identify('café'), identify('café'));\n\tassertEquals(identify('a\\n\\t\"b'), identify('a\\n\\t\"b'));\n\tassertNotEquals(identify('a'), identify('A'));\n\tassertNotEquals(identify('ab'), identify('a b'));\n\t// A unicode round-trip over a wide range stays deterministic.\n\tfor (let i = 0; i < 0x2000; i += 7) {\n\t\tconst s = String.fromCharCode(i);\n\t\tassertEquals(identify(s), identify(s));\n\t}\n});\n\nDeno.test('numbers :: float precision is retained', () => {\n\tassertEquals(identify(0.1 + 0.2), identify(0.30000000000000004));\n\tassertNotEquals(identify(0.1 + 0.2), identify(0.3));\n\tassertNotEquals(identify(1), identify(1.0000000000000002));\n});\n\nDeno.test('numbers :: signed zero collapses', () => {\n\t// -0 and 0 are conventionally the same value.\n\tassertEquals(identify(-0), identify(0));\n});\n\nDeno.test('numbers :: non-finite values fold into null', () => {\n\tassertEquals(identify(NaN), identify(null));\n\tassertEquals(identify(Infinity), identify(null));\n\tassertEquals(identify(-Infinity), identify(null));\n});\n\nDeno.test('bigint :: matches the equivalent number', () => {\n\tassertEquals(identify(1n), identify(1));\n\tassertEquals(identify(42n), identify(42));\n\tassertEquals(identify(0n), identify(0));\n});\n\nDeno.test('symbols :: dropped like JSON.stringify', () => {\n\t// Symbols have no real representation; they are omitted as object/map values\n\t// and fold to null in array/set positions, matching JSON.stringify.\n\tassertEquals(identify({ a: 1, s: Symbol() }), identify({ a: 1 }));\n\tassertEquals(identify({ a: 1, s: Symbol('x') }), identify({ a: 1 }));\n\tassertEquals(identify([1, Symbol(), 2]), identify([1, null, 2]));\n\t// A bare symbol canonicalizes to the same marker as a bare undefined.\n\tassertEquals(identify(Symbol()), identify(undefined));\n\tassertEquals(identify(Symbol('x')), identify(undefined));\n});\n\nDeno.test('functions :: dropped like JSON.stringify', () => {\n\t// Functions have no real representation; same drop rules as symbols/undefined.\n\tassertEquals(identify({ a: 1, f: () => {} }), identify({ a: 1 }));\n\tassertEquals(identify([1, () => {}, 2]), identify([1, null, 2]));\n\t// Distinct function bodies are indistinguishable once dropped.\n\tassertEquals(identify({ f: () => 1 }), identify({ f: () => 2 }));\n\tassertEquals(identify({ f() {} }), identify({}));\n\t// A bare function canonicalizes to the same marker as a bare undefined.\n\tassertEquals(identify(() => {}), identify(undefined));\n});\n\n// ~> toJSON\n\nDeno.test('toJSON :: result is serialized in place', () => {\n\tassertEquals(identify({ toJSON: () => ({ a: 1, b: [2] }) }), identify({ a: 1, b: [2] }));\n\tassertEquals(identify({ ignored: 99, toJSON: () => ({ a: 1 }) }), identify({ a: 1 }));\n\t// Primitive and undefined results behave like that primitive / a drop.\n\tassertEquals(identify({ toJSON: () => 42 }), identify(42));\n\tassertEquals(identify({ toJSON: () => 'x' }), identify('x'));\n\tassertEquals(identify({ a: 1, b: { toJSON: () => undefined } }), identify({ a: 1 }));\n});\n\nDeno.test('toJSON :: URL serializes as its href', () => {\n\tassertEquals(\n\t\tidentify(new URL('https://example.com/a?b=1#c')),\n\t\tidentify('https://example.com/a?b=1#c'),\n\t);\n\tassertEquals(identify(new URL('https://a.test/')), identify(new URL('https://a.test/')));\n\tassertNotEquals(identify(new URL('https://a.test/')), identify(new URL('https://b.test/')));\n});\n\nDeno.test('toJSON :: builtins with special forms ignore toJSON', () => {\n\tassertEquals(identify(new Date(0)), 'd0');\n\tassertNotEquals(identify(new Date(0)), identify(new Date(0).toJSON()));\n\tassertEquals(identify(Buffer.from([1, 2])), identify(new Uint8Array([1, 2])));\n});\n\nDeno.test('toJSON :: only applied once, like JSON.stringify', () => {\n\tconst o: any = { a: 1 };\n\to.toJSON = () => o;\n\tassertEquals(identify(o), identify({ a: 1 }));\n});\n\nDeno.test('toJSON :: result cycling back to the original does not overflow', () => {\n\tconst fresh: any = {};\n\tfresh.toJSON = () => ({ wrap: fresh });\n\n\tconst stable: any = {};\n\tconst wrapper = { wrap: stable };\n\tstable.toJSON = () => wrapper;\n\n\tassertEquals(identify(fresh), identify(fresh));\n\tassertEquals(identify(fresh), identify(stable));\n});\n\nDeno.test('toJSON :: result resolving to an ancestor closes the cycle', () => {\n\tconst getter: any = {\n\t\tget g() {\n\t\t\treturn { toJSON: () => getter };\n\t\t},\n\t};\n\tassert(identify(getter));\n\tassertEquals(identify(getter), identify(getter));\n\n\tconst parent: any = {};\n\tconst child: any = { toJSON: () => parent };\n\tparent.child = child;\n\tassert(identify(parent));\n\tassertEquals(identify(parent), identify(parent));\n\n\tconst root: any = {};\n\tconst mid: any = {};\n\troot.mid = mid;\n\tmid.leaf = { toJSON: () => root };\n\tassert(identify(root));\n\tassertEquals(identify(root), identify(root));\n});\n\nDeno.test('toJSON :: ancestor cycles resolve through every container', () => {\n\tconst viaSet: any = { s: new Set() };\n\tviaSet.s.add({ toJSON: () => viaSet });\n\n\tconst viaMap: any = { m: new Map() };\n\tviaMap.m.set('k', { toJSON: () => viaMap });\n\n\tconst viaArray: any = { arr: [] as unknown[] };\n\tviaArray.arr.push({ toJSON: () => viaArray });\n\n\tassertEquals(identify(viaSet), identify(viaSet));\n\tassertEquals(identify(viaMap), identify(viaMap));\n\tassertEquals(identify(viaArray), identify(viaArray));\n});\n\nDeno.test('toJSON :: array and mutual results still resolve cycles', () => {\n\tconst arr: any = {};\n\tarr.toJSON = () => [arr];\n\tassertEquals(identify(arr), identify(arr));\n\n\tconst a: any = {};\n\tconst b: any = {};\n\ta.toJSON = () => ({ b });\n\tb.toJSON = () => ({ a });\n\tassertEquals(identify(a), identify(a));\n\tassertEquals(identify(b), identify(b));\n});\n\n// ~> Dates & RegExps\n\nDeno.test('dates :: equal instants match, different instants differ', () => {\n\tassertEquals(identify(new Date(0)), identify(new Date(0)));\n\tassertEquals(identify(new Date(1700000000000)), identify(new Date(1700000000000)));\n\tassertNotEquals(identify(new Date(0)), identify(new Date(1)));\n});\n\nDeno.test('dates :: are distinct from their numeric timestamp', () => {\n\tassertNotEquals(identify(new Date(0)), identify(0));\n});\n\nDeno.test('regexps :: source and flags both matter', () => {\n\tassertEquals(identify(/abc/gi), identify(/abc/gi));\n\tassertNotEquals(identify(/a/), identify(/b/));\n\tassertNotEquals(identify(/a/), identify(/a/g));\n\tassertNotEquals(identify(/a/gi), identify(/a/g));\n});\n\n// ~> Arrays\n\nDeno.test('arrays :: flat equality', () => {\n\tassertEquals(identify([1, 2, 3]), identify([1, 2, 3]));\n});\n\nDeno.test('arrays :: empty', () => {\n\tassertEquals(identify([]), identify([]));\n\tassertNotEquals(identify([]), identify([0]));\n});\n\nDeno.test('arrays :: order is significant', () => {\n\tassertNotEquals(identify([3, 2, 1]), identify([1, 2, 3]));\n});\n\nDeno.test('arrays :: nested', () => {\n\tassertEquals(\n\t\tidentify([[3, 2, 1], [1, 2, 3]]),\n\t\tidentify([[3, 2, 1], [1, 2, 3]]),\n\t);\n\tassertNotEquals(\n\t\tidentify([[1], [2, 3]]),\n\t\tidentify([[1, 2], [3]]),\n\t);\n});\n\nDeno.test('arrays :: circular', () => {\n\tconst arr: unknown[] = [1, 2, 3];\n\tarr.push(arr);\n\tassert(identify(arr));\n\tassertEquals(identify(arr), identify(arr));\n});\n\nDeno.test('arrays :: undefined elements fold into null', () => {\n\tassertEquals(identify([1, undefined, 2]), identify([1, null, 2]));\n});\n\nDeno.test('arrays :: adjacent elements keep their own slots', () => {\n\tassertNotEquals(identify(['a', 'b']), identify(['ab']));\n});\n\n// ~> Objects\n\nDeno.test('objects :: basic equality', () => {\n\tassertEquals(identify({ foo: 'bar' }), identify({ foo: 'bar' }));\n});\n\nDeno.test('objects :: empty', () => {\n\tassertEquals(identify({}), identify({}));\n\tassertEquals(identify({}), identify({ a: undefined }));\n});\n\nDeno.test('objects :: undefined values are dropped', () => {\n\tassertEquals(\n\t\tidentify({ a: 1, c: undefined, b: 'hello' }),\n\t\tidentify({ a: 1, b: 'hello' }),\n\t);\n});\n\nDeno.test('objects :: key order does not matter', () => {\n\tassertEquals(\n\t\tidentify({ one: 'one', two: 'two' }),\n\t\tidentify({ two: 'two', one: 'one' }),\n\t);\n});\n\nDeno.test('objects :: numeric-like keys order independent', () => {\n\tassertEquals(identify({ 10: 'a', 2: 'b' }), identify({ 2: 'b', 10: 'a' }));\n});\n\nDeno.test('objects :: nested, key order does not matter at any depth', () => {\n\tassertEquals(\n\t\tidentify({ a: { b: 'c' }, d: { e: { f: 'g' } } }),\n\t\tidentify({ d: { e: { f: 'g' } }, a: { b: 'c' } }),\n\t);\n});\n\nDeno.test('objects :: different values differ', () => {\n\tassertNotEquals(identify({ a: 1, b: 2 }), identify({ a: 1, b: 3 }));\n\tassertNotEquals(identify({ a: 1 }), identify({ a: 1, b: 2 }));\n});\n\nDeno.test('objects :: circular', () => {\n\tconst o: Record = { a: 'b' };\n\to.c = o;\n\tassert(identify(o));\n\tassertEquals(identify(o), identify(o));\n});\n\nDeno.test('objects :: partial circular', () => {\n\tconst o = { v: 1 };\n\tconst a = ['a', o];\n\tassertEquals(identify(a), identify(a));\n});\n\nDeno.test('objects :: class instances hash by their own keys', () => {\n\tclass Foo {\n\t\ta = 1;\n\t\tb = 2;\n\t}\n\tassertEquals(identify(new Foo()), identify(new Foo()));\n\tassertEquals(identify(new Foo()), identify({ a: 1, b: 2 }));\n});\n\nDeno.test('objects :: null-prototype objects are supported', () => {\n\tconst nullProto = Object.assign(Object.create(null), { a: 1, b: 2 });\n\tassertEquals(identify(nullProto), identify({ a: 1, b: 2 }));\n});\n\nDeno.test('objects :: a literal \"constructor\" key still hashes', () => {\n\tassertEquals(identify({ constructor: 1 }), identify({ constructor: 1 }));\n\tassertNotEquals(identify({ constructor: 1 }), identify({ constructor: 2 }));\n});\n\nDeno.test('objects :: null object and null property', () => {\n\tassertEquals(identify(null), identify(null));\n\tassertEquals(identify({ f: null }), identify({ f: null }));\n\t// A null value is distinct from a missing key.\n\tassertNotEquals(identify({ f: null }), identify({}));\n});\n\nDeno.test('objects :: deterministic key sorting', () => {\n\tassertEquals(identify({ b: 2, c: 3, a: 1 }), identify({ a: 1, b: 2, c: 3 }));\n});\n\n// ~> Sets\n\nDeno.test('sets :: order is significant', () => {\n\tassertNotEquals(identify(new Set([1, 2, 3])), identify(new Set([3, 2, 1])));\n});\n\nDeno.test('sets :: order is significant for object members', () => {\n\tassertNotEquals(\n\t\tidentify(new Set([{ a: 'a' }, { b: 'b' }])),\n\t\tidentify(new Set([{ b: 'b' }, { a: 'a' }])),\n\t);\n});\n\nDeno.test('sets :: nested', () => {\n\tassertEquals(\n\t\tidentify(new Set([new Set([1]), new Set([2])])),\n\t\tidentify(new Set([new Set([1]), new Set([2])])),\n\t);\n});\n\nDeno.test('sets :: circular', () => {\n\tconst s: Set = new Set([1, 2, 3]);\n\ts.add(s);\n\tassert(identify(s));\n\tassertEquals(identify(s), identify(s));\n});\n\n// ~> Maps\n\nDeno.test('maps :: key order does not matter', () => {\n\tassertEquals(\n\t\tidentify(new Map([['a', 'b'], ['c', 'd']])),\n\t\tidentify(new Map([['c', 'd'], ['a', 'b']])),\n\t);\n});\n\nDeno.test('maps :: single entry (fast path) is stable', () => {\n\tassertEquals(identify(new Map([['z', 1]])), identify(new Map([['z', 1]])));\n});\n\nDeno.test('maps :: mixed key types, order independent', () => {\n\tassertEquals(\n\t\tidentify(new Map([['a', 1], [2, 'b'], ['c', 3]])),\n\t\tidentify(new Map([[2, 'b'], ['c', 3], ['a', 1]])),\n\t);\n});\n\nDeno.test('maps :: different values differ', () => {\n\tassertNotEquals(\n\t\tidentify(new Map([['a', 1]])),\n\t\tidentify(new Map([['a', 2]])),\n\t);\n});\n\nDeno.test('maps :: circular', () => {\n\tconst m: Map = new Map([['a', 'b'], ['c', 'd']]);\n\tm.set('e', m);\n\tassert(identify(m));\n\tassertEquals(identify(m), identify(m));\n});\n\n// ~> Cross-type behaviour\n\nDeno.test('cross-type :: a Map matches the equivalent plain object', () => {\n\tassertEquals(identify({ a: 'b' }), identify(new Map([['a', 'b']])));\n\tassertEquals(\n\t\tidentify({ a: 1, b: 2 }),\n\t\tidentify(new Map([['a', 1], ['b', 2]])),\n\t);\n});\n\nDeno.test('cross-type :: objects and arrays are distinct', () => {\n\tassertNotEquals(identify({ a: 'b' }), identify(['a', 'b']));\n\tassertNotEquals(identify({}), identify([]));\n});\n\nDeno.test('cross-type :: a Set is distinct from an Array', () => {\n\tassertNotEquals(identify(new Set([1, 2, 3])), identify([1, 2, 3]));\n});\n\nDeno.test('cross-type :: a typed array matches the equivalent index-keyed object', () => {\n\tassertEquals(identify(new Uint8Array([1, 2])), identify({ 0: 1, 1: 2 }));\n\tassertEquals(identify(new Uint8Array([])), identify({}));\n\tassertEquals(identify(new Uint8Array([1, 2])), identify(new Int16Array([1, 2])));\n});\n\n// ~> Circular & shared references\n\nDeno.test('refs :: circular ids are consistent regardless of visitation order', () => {\n\tlet o: Record = { a: 1, c: 2 };\n\to.b = o;\n\to.d = new Map(); // the map is seen 2nd\n\t(o.d as Map).set('x', o.d);\n\tassertEquals(Object.keys(o), ['a', 'c', 'b', 'd']);\n\tconst a = identify(o);\n\n\to = { a: 1 };\n\to.d = new Map(); // the map is seen first\n\t(o.d as Map).set('x', o.d);\n\to.b = o;\n\to.c = 2;\n\tassertEquals(Object.keys(o), ['a', 'd', 'b', 'c']);\n\tconst b = identify(o);\n\n\tassertEquals(a, b, `${a} === ${b}`);\n});\n\nDeno.test('refs :: deeply nested circular objects are equal', () => {\n\tconst build = () => {\n\t\tconst o: Record = { b: { c: 123 } };\n\t\to.b.d = o;\n\t\to.x = [9, o.b];\n\t\treturn o;\n\t};\n\tassertEquals(identify(build()), identify(build()));\n});\n\nDeno.test('refs :: a shared reference equals two distinct equal instances', () => {\n\tconst shared = { v: 1 };\n\tassertEquals(\n\t\tidentify({ x: shared, y: shared }),\n\t\tidentify({ x: { v: 1 }, y: { v: 1 } }),\n\t);\n});\n\nDeno.test('refs :: each distinct node is only back-referenced when reused', () => {\n\tconst hash = identify({\n\t\ta: [[1], [2], [3]],\n\t\tb: new Set([new Set([1]), new Set([2]), new Set([3])]),\n\t});\n\tassertNotMatch(hash, /~\\d+/);\n});\n\nDeno.test('refs :: circular reference to root', () => {\n\tconst o: any = { id: 123 };\n\to.self = o;\n\tassert(identify(o));\n\tassertEquals(identify(o), identify(o));\n});\n\nDeno.test('refs :: nested circular reference to root', () => {\n\t// A back-reference buried under a node, plus an awkward string to escape.\n\tconst o: any = { label: 'a\\n\\t\"b' };\n\to.inner = { root: o };\n\tassertEquals(identify(o), identify(o));\n});\n\nDeno.test('refs :: child circular reference', () => {\n\tconst o: any = { id: 1, child: { id: 2 } };\n\to.child.self = o.child;\n\tassertEquals(identify(o), identify(o));\n});\n\nDeno.test('refs :: nested child circular reference', () => {\n\tconst o: any = { id: 1, child: { id: 2 } };\n\to.child.wrap = { ref: o.child };\n\tassertEquals(identify(o), identify(o));\n});\n\nDeno.test('refs :: circular objects in an array', () => {\n\tconst o: any = { id: 123 };\n\to.list = [o, o];\n\tassertEquals(identify(o), identify(o));\n});\n\nDeno.test('refs :: nested circular references in an array', () => {\n\tconst build = () => {\n\t\tconst o: any = { items: [{ foo: 1 }, { bar: 2 }] };\n\t\to.items[0].self = o.items[0];\n\t\to.items[1].self = o.items[1];\n\t\treturn o;\n\t};\n\tassertEquals(identify(build()), identify(build()));\n});\n\nDeno.test('refs :: circular arrays', () => {\n\tconst fixture: any = [];\n\tfixture.push(fixture, fixture);\n\tassert(identify(fixture));\n\tassertEquals(identify(fixture), identify(fixture));\n});\n\nDeno.test('refs :: nested circular arrays', () => {\n\tconst build = () => {\n\t\tconst arr: any = [];\n\t\tarr.push({ foo: 1, back: arr }, { bar: 2, back: arr });\n\t\treturn arr;\n\t};\n\tassertEquals(identify(build()), identify(build()));\n});\n\nDeno.test('refs :: repeated non-circular references in objects', () => {\n\t// One shared node behind three keys hashes like three separate equal nodes.\n\tconst shared = { foo: 1, bar: 'abc' };\n\tassertEquals(\n\t\tidentify({ a: shared, b: shared, c: shared }),\n\t\tidentify({\n\t\t\ta: { foo: 1, bar: 'abc' },\n\t\t\tb: { foo: 1, bar: 'abc' },\n\t\t\tc: { foo: 1, bar: 'abc' },\n\t\t}),\n\t);\n});\n\nDeno.test('refs :: repeated non-circular references in arrays', () => {\n\tconst shared = { foo: 1 };\n\tassertEquals(\n\t\tidentify([shared, shared]),\n\t\tidentify([{ foo: 1 }, { foo: 1 }]),\n\t);\n});\n\n// ~> On-the-wire format\n//\n// These lock the exact serialization. A change here is a breaking change to every\n// previously-stored identity, so update deliberately.\n\nDeno.test('format :: supported builtins serialize consistently', () => {\n\tconst assertWire = (name: string, input: unknown, expected: string) =>\n\t\tassertEquals(identify(input), expected, name);\n\n\tassertWire('array', [1, undefined, 'x'], 'an1Lsx');\n\tassertWire('bigint', 123n, 'n123');\n\tassertWire('bigint64 array', new BigInt64Array([-1n, 2n]), 'o0n-11n2');\n\tassertWire('biguint64 array', new BigUint64Array([1n, 2n]), 'o0n11n2');\n\tassertWire('boolean', true, 'T');\n\tassertWire('buffer', Buffer.from([1, 2]), 'o0n11n2');\n\tassertWire('data view', new DataView(new Uint8Array([1, 2]).buffer), 'o');\n\tassertWire('date', new Date(0), 'd0');\n\tassertWire('float32 array', new Float32Array([1.5, -2.25]), 'o0n1.51n-2.25');\n\tassertWire('float64 array', new Float64Array([1.5, -2.25]), 'o0n1.51n-2.25');\n\tassertWire('int8 array', new Int8Array([-1, 2]), 'o0n-11n2');\n\tassertWire('int16 array', new Int16Array([-1, 2]), 'o0n-11n2');\n\tassertWire('int32 array', new Int32Array([-1, 2]), 'o0n-11n2');\n\tassertWire('map', new Map([['b', 2], ['a', 1]]), 'oan1bn2');\n\tassertWire('null', null, 'L');\n\tassertWire('object', { b: 2, a: 1 }, 'oan1bn2');\n\tassertWire('regexp', /ab/gi, 'rabgi');\n\tassertWire('set', new Set([1, 2]), 'en1n2');\n\tassertWire('string', 'hello', 'shello');\n\tassertWire('uint8 array', new Uint8Array([1, 2]), 'o0n11n2');\n\tassertWire('uint8 clamped array', new Uint8ClampedArray([1, 255]), 'o0n11n255');\n\tassertWire('uint16 array', new Uint16Array([1, 2]), 'o0n11n2');\n\tassertWire('uint32 array', new Uint32Array([1, 2]), 'o0n11n2');\n\tassertWire('custom toJSON', { toJSON: () => ({ a: 1, b: [2] }) }, 'oan1ban2');\n\tassertWire('url', new URL('https://example.com/a?b=1#c'), 'shttps://example.com/a?b=1#c');\n});\n\nDeno.test('format :: circular array back-reference', () => {\n\tconst arr: unknown[] = [1, 2, 3];\n\tarr.push(arr);\n\tassertEquals(identify(arr), 'an1n2n3~1');\n});\n\nDeno.test('format :: every element is visited exactly once', () => {\n\tconst c: unknown[] = [1];\n\tc.push(c);\n\tconst hash = identify({\n\t\ta: { b: ['c', new Set(['d', new Map([['e', 'f']]), c, 'g'])] },\n\t});\n\tassertEquals(hash, 'oaobascesdoesfan1~5sg');\n});\n\n// ~> Robustness\n\nDeno.test('robustness :: very deep input does not overflow', () => {\n\tlet root: Record = {};\n\tlet node = root;\n\tfor (let i = 0; i < 1000; i++) {\n\t\tnode.i = i;\n\t\tnode.child = {};\n\t\tnode = node.child;\n\t}\n\tassert(identify(root));\n\tassertEquals(identify(root), identify(root));\n});\n\nDeno.test('robustness :: unsupported builtins throw', () => {\n\tassertThrows(() => identify(new WeakMap()));\n\tassertThrows(() => identify(new WeakSet()));\n\tassertThrows(() => identify(Promise.resolve()));\n\tassertThrows(() => identify(new ArrayBuffer(8)));\n});\n\nDeno.test('robustness :: does not mutate the input', () => {\n\tconst child: any = { foo: 1 };\n\tchild.self = child;\n\tconst o: any = { a: child, b: child };\n\tidentify(o);\n\tassertEquals(Object.keys(o), ['a', 'b']);\n\tassert(o.a === child);\n\tassert(o.b === child);\n\tassert(child.self === child);\n});\n\nDeno.test('robustness :: hashing never pollutes Object.prototype', () => {\n\tidentify(JSON.parse('{\"__proto__\":{\"polluted\":true}}'));\n\tidentify(JSON.parse('{\"constructor\":{\"prototype\":{\"polluted\":true}}}'));\n\tassertEquals(({} as Record).polluted, undefined);\n});\n\n// ~> Known limitation\n\n// Cycle detection keys off object reference identity, so two structurally-different\n// cyclic shapes that share a referenced node can collapse to the same identity.\nDeno.test.ignore('limitation :: samey circular shapes should not match', () => {\n\tconst o1: any = { a: 1, b: 2 };\n\tconst o2: any = { a: 1, b: 2 };\n\to1.c = o1;\n\to1.d = o2;\n\to2.c = o2;\n\tconst a = identify(o1);\n\to2.c = o1;\n\tconst b = identify(o1);\n\tassertNotEquals(a, b, `${a} != ${b}`);\n});\n\n// ~> Property based tests\n\nconst keyArb = fc.constantFrom('a', 'b', 'c', 'd', 'foo', 'bar', '1', '2');\nconst leafArb = fc.oneof(\n\tfc.integer(),\n\tfc.double(),\n\tfc.string(),\n\tfc.boolean(),\n\tfc.constant(null),\n\tfc.constant(undefined),\n\tfc.date(),\n\tfc.constantFrom(/a/, /b/gi, /\\d+/m),\n);\nconst jsonish = fc.letrec((tie) => ({\n\tnode: fc.oneof(\n\t\t{ maxDepth: 4 },\n\t\tleafArb,\n\t\tfc.array(tie('node'), { maxLength: 5 }),\n\t\tfc.array(tie('node'), { maxLength: 5 }).map((xs) => new Set(xs)),\n\t\tfc.array(fc.tuple(keyArb, tie('node')), { maxLength: 5 }).map((es) => new Map(es)),\n\t\tfc.dictionary(keyArb, tie('node'), { maxKeys: 5 }),\n\t),\n})).node;\n\n// Rebuilds a value with object/map key insertion order reversed at every level,\n// while preserving array/set element order (which is significant).\nfunction reorder(v: any): any {\n\tif (v === null || typeof v !== 'object' || v instanceof Date || v instanceof RegExp) return v;\n\tif (Array.isArray(v)) return v.map(reorder);\n\tif (v instanceof Set) {\n\t\tconst s = new Set();\n\t\tfor (const x of v) s.add(reorder(x));\n\t\treturn s;\n\t}\n\tif (v instanceof Map) {\n\t\tconst m = new Map();\n\t\tfor (const [k, val] of [...v].reverse()) m.set(k, reorder(val));\n\t\treturn m;\n\t}\n\tconst o: Record = {};\n\tfor (const k of Object.keys(v).reverse()) o[k] = reorder(v[k]);\n\treturn o;\n}\n\nDeno.test('fuzz :: identify always returns a string and is idempotent', () => {\n\tfc.assert(\n\t\tfc.property(jsonish, (v) => {\n\t\t\tconst hash = identify(v);\n\t\t\treturn typeof hash === 'string' && identify(v) === hash;\n\t\t}),\n\t\t{ numRuns: 1000 },\n\t);\n});\n\nDeno.test('fuzz :: object & map key order is irrelevant', () => {\n\tfc.assert(\n\t\tfc.property(jsonish, (v) => identify(v) === identify(reorder(v))),\n\t\t{ numRuns: 1000 },\n\t);\n});\n\nDeno.test('fuzz :: an object and the equivalent Map share an identity', () => {\n\tconst flatObj = fc.dictionary(keyArb, leafArb, { maxKeys: 6 });\n\tfc.assert(\n\t\tfc.property(flatObj, (o) => {\n\t\t\tconst asMap = new Map(Object.entries(o));\n\t\t\treturn identify(o) === identify(asMap);\n\t\t}),\n\t\t{ numRuns: 500 },\n\t);\n});\n\nDeno.test('fuzz :: reversing a distinct-element array changes the identity', () => {\n\t// Distinct integers have distinct identities, so a length >= 2 reversal differs.\n\tconst distinct = fc.uniqueArray(fc.integer(), { minLength: 2, maxLength: 8 });\n\tfc.assert(\n\t\tfc.property(distinct, (xs) => identify(xs) !== identify([...xs].reverse())),\n\t\t{ numRuns: 500 },\n\t);\n});\n\nDeno.test('fuzz :: adding a defined key changes the identity', () => {\n\tconst flatObj = fc.dictionary(keyArb, leafArb, { maxKeys: 5 });\n\tfc.assert(\n\t\tfc.property(flatObj, fc.string({ minLength: 1 }), leafArb, (o, k, v) => {\n\t\t\tif (k in o || v === undefined) return true; // a dropped/undefined value is a no-op\n\t\t\tconst before = identify(o);\n\t\t\treturn before !== identify({ ...o, [k]: v });\n\t\t}),\n\t\t{ numRuns: 500 },\n\t);\n});\n","editable",false,"branch","documentNavigation","repo","maraisr/object-identity","repoId","aab75610-33c5-41e6-a0ff-b9e5178a7ee1","ownerId","user:599459","site","nexthub","private","admin","settings","maintainer","triage","starred","stars",0,"watchers",1,"watching","pinned","notify","views",[118,119,120,121,122,123,124,125,126,127,128,129,130],"navigation",{"_56":57,"_78":79,"_80":81,"_82":83,"_84":85,"_86":87,"_88":89},"sources",[],"viewer","meta",{"_71":72,"_73":74,"_75":72,"_43":32,"_76":14,"_77":32,"_49":50,"_51":52},"branches",[14],"tags",[],"cloneUrl","https://git.nexthub.sh/maraisr/object-identity.git","description","","owner","maraisr","section","head","empty","pins",[100,101,102],"documents",{"_97":98,"_99":50},"code",{"_94":95,"_96":50},"automations",{"_92":52,"_93":-5},"delivery",{"_90":50,"_91":-5},"tag","RRyYGQsMb4A3zr2ndz0H-cRwLG8","releases","applications","workflows","deployments","commits",102,"changes","counts",{},"total",{"_103":96,"_105":116,"_15":96,"_107":117,"_54":109,"_110":32,"_111":109,"_112":50},{"_103":113,"_105":114,"_15":113,"_107":115,"_54":109,"_110":32,"_111":109,"_112":50},{"_103":104,"_105":106,"_15":104,"_107":108,"_54":109,"_110":32,"_111":109,"_112":50},"id","issues","name","Issues","filters",{},true,"saved","pinnable","count","tasks","Tasks",{},"Changes",{},{"_103":96,"_105":116,"_15":96,"_107":161,"_54":109,"_110":32,"_111":109},{"_103":113,"_105":114,"_15":113,"_107":160,"_54":109,"_110":32,"_111":109},{"_103":104,"_105":106,"_15":104,"_107":159,"_54":109,"_110":32,"_111":109},{"_103":156,"_105":157,"_15":156,"_107":158,"_54":32,"_110":32,"_111":109},{"_103":153,"_105":154,"_15":153,"_107":155,"_54":32,"_110":32,"_111":109},{"_103":92,"_105":151,"_15":84,"_107":152,"_54":32,"_110":32,"_111":109},{"_103":93,"_105":148,"_15":149,"_107":150,"_54":32,"_110":32,"_111":109},{"_103":90,"_105":146,"_15":90,"_107":147,"_54":32,"_110":32,"_111":109},{"_103":142,"_105":143,"_15":144,"_107":145,"_54":32,"_110":32,"_111":109},{"_103":80,"_105":140,"_15":80,"_107":141,"_54":32,"_110":32,"_111":32},{"_103":137,"_105":138,"_15":137,"_107":139,"_54":32,"_110":32,"_111":32},{"_103":134,"_105":135,"_15":134,"_107":136,"_54":32,"_110":32,"_111":32},{"_103":131,"_105":132,"_15":131,"_107":133,"_54":32,"_110":32,"_111":32},"decisions","Decisions",{},"changelog","Changelog",{},"roadmap","Roadmap",{},"Documents",{},"activity","Activity","insights",{},"Releases",{},"Deployments","automations/deployments",{},"Workflows",{},"discussions","Discussions",{},"goals","Goals",{},{},{},{},"groups","user","agents",[],"now",1794434482515,"sidebar","expanded"]