Memoize II

Requirements

• Export memoize(fn) as named and default. Return a wrapper with the original argument/return/this types in TypeScript. Invoke fn with the wrapper’s receiver and arguments on a cache miss; return the exact cached result on a hit.
• Cache keys consist of receiver identity, argument count, and every argument in order. Use native Map SameValueZero equality: NaN matches NaN, positive/negative zero share a key, and objects/functions/symbols are compared by identity. Do not serialize arguments or compare object contents.
• Distinguish no arguments, an explicit undefined argument, and argument prefixes. Cache every returned value, including undefined, null, false, zero, objects, and promises. Results retain their original references.
• Synchronous exceptions are not cached; a later call with the same key tries again. Returned promises are cached as values, including a promise that later rejects; rejection eviction is outside scope.
• Different memoized wrappers have independent caches. Assume the original function’s result is stable for each receiver/argument tuple; mutating an object used as a key does not invalidate its cache entry.
• Use a Map trie or equivalent identity-based tuple structure with lookup work proportional to argument count. No resolver, expiration, capacity limit, clear API, reentrant-call coordination, or async-value transformation is required.

Examples

Input: let calls = 0; const sum = memoize((...xs) => { calls++; return xs.reduce((a, b) => a + b, 0); }); sum(1, 2); sum(1, 2); calls;
Output: 1

Input: const read = memoize(function (x) { return this.base + x; }); read.call({ base: 2 }, 3);
Output: 5; a different receiver has a separate cache key.