@naturalcycles/js-lib 14.213.0 → 14.215.0

package/dist/array/array.util.d.ts

@@ -104,6 +104,9 @@ export declare function _sortBy<T>(items: T[], mapper: Mapper<T, any>, mutate?:
 export declare function _sortDescBy<T>(items: T[], mapper: Mapper<T, any>, mutate?: boolean): T[];
 /**
  * Like items.find(), but it tries to find from the END of the array.
+ *
+ * Node 18+ supports native array.findLast() - use that.
+ * iOS Safari only has it since 15.4
  */
 export declare function _findLast<T>(items: T[], predicate: Predicate<T>): T | undefined;
 export declare function _takeWhile<T>(items: T[], predicate: Predicate<T>): T[];

package/dist/array/array.util.js

@@ -173,6 +173,9 @@ function _sortDescBy(items, mapper, mutate = false) {
 exports._sortDescBy = _sortDescBy;
 /**
  * Like items.find(), but it tries to find from the END of the array.
+ *
+ * Node 18+ supports native array.findLast() - use that.
+ * iOS Safari only has it since 15.4
  */
 function _findLast(items, predicate) {
     return [...items].reverse().find(predicate);

package/dist/decorators/asyncMemo.decorator.d.ts

@@ -20,20 +20,6 @@ export interface AsyncMemoOptions {
      * False will allow >1 execution in case of errors.
      */
     cacheRejections?: boolean;
-    /**
-     * Default to false
-     */
-    logHit?: boolean;
-    /**
-     * Default to false
-     */
-    logMiss?: boolean;
-    /**
-     * Set to `false` to skip logging method arguments.
-     *
-     * Defaults to true.
-     */
-    logArgs?: boolean;
     /**
      * Default to `console`
      */
@@ -42,6 +28,10 @@ export interface AsyncMemoOptions {
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
  *
+ * Important: it awaits the method to return the result before caching it.
+ *
+ * todo: test for "swarm requests", it should return "the same promise" and not cause a swarm origin hit
+ *
  * Method CANNOT return `undefined`, as undefined will always be treated as cache MISS and retried.
  * Return `null` instead (it'll be cached).
  */

package/dist/decorators/asyncMemo.decorator.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._AsyncMemo = void 0;
-const time_util_1 = require("../time/time.util");
 const decorator_util_1 = require("./decorator.util");
 const memo_util_1 = require("./memo.util");
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
  *
+ * Important: it awaits the method to return the result before caching it.
+ *
+ * todo: test for "swarm requests", it should return "the same promise" and not cause a swarm origin hit
+ *
  * Method CANNOT return `undefined`, as undefined will always be treated as cache MISS and retried.
  * Return `null` instead (it'll be cached).
  */
@@ -18,7 +21,7 @@ const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
     const originalFn = descriptor.value;
     // Map from "instance" of the Class where @_AsyncMemo is applied to AsyncMemoCache instance.
     const cache = new Map();
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheRejections = true, } = opt;
+    const { logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheRejections = true, } = opt;
     const keyStr = String(key);
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
     descriptor.value = async function (...args) {
@@ -39,16 +42,12 @@ const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
         }
         if (value !== undefined) {
             // hit!
-            if (logHit) {
-                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_AsyncMemo hit`);
-            }
             if (value instanceof Error) {
                 throw value;
             }
             return value;
         }
         // Here we know it's a MISS, let's execute the real method
-        const started = Date.now();
         try {
             value = await originalFn.apply(ctx, args);
             // Save the value in the Cache, without awaiting it
@@ -80,11 +79,6 @@ const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
             }
             throw err;
         }
-        finally {
-            if (logMiss) {
-                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_AsyncMemo miss (${(0, time_util_1._since)(started)})`);
-            }
-        }
     };
     descriptor.value.dropCache = async () => {
         logger.log(`${methodSignature} @_AsyncMemo.dropCache()`);

package/dist/decorators/memo.decorator.d.ts

@@ -19,19 +19,6 @@ export interface MemoOptions {
      * False will allow >1 execution in case of errors.
      */
     cacheErrors?: boolean;
-    /**
-     * Default to false
-     */
-    logHit?: boolean;
-    /**
-     * Default to false
-     */
-    logMiss?: boolean;
-    /**
-     * Defaults to true.
-     * Set to false to skip logging method arguments.
-     */
-    logArgs?: boolean;
     /**
      * Default to `console`
      */

package/dist/decorators/memo.decorator.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._Memo = void 0;
-const time_util_1 = require("../time/time.util");
 const decorator_util_1 = require("./decorator.util");
 const memo_util_1 = require("./memo.util");
 /**
@@ -37,7 +36,7 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
     // UPD: tests show that normal Map also doesn't leak (to be tested further)
     // Normal Map is needed to allow .dropCache()
     const cache = new Map();
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheErrors = true, } = opt;
+    const { logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheErrors = true, } = opt;
     const keyStr = String(key);
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
     descriptor.value = function (...args) {
@@ -48,16 +47,12 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
             cache.set(ctx, cacheFactory());
         }
         else if (cache.get(ctx).has(cacheKey)) {
-            if (logHit) {
-                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_Memo hit`);
-            }
             value = cache.get(ctx).get(cacheKey);
             if (value instanceof Error) {
                 throw value;
             }
             return value;
         }
-        const started = Date.now();
         try {
             value = originalFn.apply(ctx, args);
             try {
@@ -79,11 +74,6 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
             }
             throw err;
         }
-        finally {
-            if (logMiss) {
-                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_Memo miss (${(0, time_util_1._since)(started)})`);
-            }
-        }
     };
     descriptor.value.dropCache = () => {
         logger.log(`${methodSignature} @_Memo.dropCache()`);

package/dist/decorators/memoFn.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._memoFn = void 0;
-const time_util_1 = require("../time/time.util");
-const decorator_util_1 = require("./decorator.util");
 const memo_util_1 = require("./memo.util");
 /**
  * Only supports Sync functions.
@@ -10,24 +8,19 @@ const memo_util_1 = require("./memo.util");
  * Technically, you can use it with Async functions, but it'll return the Promise without awaiting it.
  */
 function _memoFn(fn, opt = {}) {
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheErrors = true, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+    const { logger = console, cacheErrors = true, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
-    const fnName = fn.name;
     const memoizedFn = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
         let value;
         if (cache.has(cacheKey)) {
-            if (logHit) {
-                logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) memoFn hit`);
-            }
             value = cache.get(cacheKey);
             if (value instanceof Error) {
                 throw value;
             }
             return value;
         }
-        const started = Date.now();
         try {
             value = fn.apply(ctx, args);
             try {
@@ -49,11 +42,6 @@ function _memoFn(fn, opt = {}) {
             }
             throw err;
         }
-        finally {
-            if (logMiss) {
-                logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) memoFn miss (${(0, time_util_1._since)(started)})`);
-            }
-        }
     };
     Object.assign(memoizedFn, { cache });
     return memoizedFn;

package/dist/decorators/memoFnAsync.js

@@ -1,17 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._memoFnAsync = void 0;
-const time_util_1 = require("../time/time.util");
-const decorator_util_1 = require("./decorator.util");
 const memo_util_1 = require("./memo.util");
 /**
  * Only supports Sync functions.
  * To support Async functions - use _memoFnAsync
  */
 function _memoFnAsync(fn, opt = {}) {
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheRejections = true, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+    const { logger = console, cacheRejections = true, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
-    const fnName = fn.name;
     const memoizedFn = async function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
@@ -23,15 +20,11 @@ function _memoFnAsync(fn, opt = {}) {
             logger.error(err);
         }
         if (value !== undefined) {
-            if (logHit) {
-                logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) memoFnAsync hit`);
-            }
             if (value instanceof Error) {
                 throw value;
             }
             return value;
         }
-        const started = Date.now();
         try {
             value = await fn.apply(ctx, args);
             void (async () => {
@@ -57,11 +50,6 @@ function _memoFnAsync(fn, opt = {}) {
             }
             throw err;
         }
-        finally {
-            if (logMiss) {
-                logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) memoFnAsync miss (${(0, time_util_1._since)(started)})`);
-            }
-        }
     };
     Object.assign(memoizedFn, { cache });
     return memoizedFn;

package/dist/decorators/memoSimple.decorator.d.ts

@@ -1,8 +1,5 @@
 import type { CommonLogger } from '../log/commonLogger';
 export interface MemoOpts {
-    logHit?: boolean;
-    logMiss?: boolean;
-    logArgs?: boolean;
     logger?: CommonLogger;
 }
 /**

package/dist/decorators/memoSimple.decorator.js

@@ -37,23 +37,16 @@ const memoSimple = (opt = {}) => (target, key, descriptor) => {
   }
    */
     const cache = new memo_util_1.MapMemoCache();
-    const { logHit, logMiss, logArgs = true, logger = console } = opt;
+    const { logger = console } = opt;
     const keyStr = String(key);
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
     descriptor.value = function (...args) {
         const ctx = this;
         const cacheKey = (0, memo_util_1.jsonMemoSerializer)(args);
         if (cache.has(cacheKey)) {
-            if (logHit) {
-                logger.log(`${methodSignature}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @memo hit`);
-            }
             return cache.get(cacheKey);
         }
-        const d = Date.now();
         const res = originalFn.apply(ctx, args);
-        if (logMiss) {
-            logger.log(`${methodSignature}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @memo miss (${Date.now() - d} ms)`);
-        }
         cache.set(cacheKey, res);
         return res;
     };

package/dist/index.d.ts

@@ -35,6 +35,8 @@ export * from './object/deepEquals';
 export * from './object/object.util';
 export * from './object/sortObject';
 export * from './object/sortObjectDeep';
+export * from './object/map2';
+export * from './object/set2';
 export * from './promise/pDefer';
 export * from './promise/pDelay';
 export * from './promise/pFilter';

package/dist/index.js

@@ -39,6 +39,8 @@ tslib_1.__exportStar(require("./object/deepEquals"), exports);
 tslib_1.__exportStar(require("./object/object.util"), exports);
 tslib_1.__exportStar(require("./object/sortObject"), exports);
 tslib_1.__exportStar(require("./object/sortObjectDeep"), exports);
+tslib_1.__exportStar(require("./object/map2"), exports);
+tslib_1.__exportStar(require("./object/set2"), exports);
 tslib_1.__exportStar(require("./promise/pDefer"), exports);
 tslib_1.__exportStar(require("./promise/pDelay"), exports);
 tslib_1.__exportStar(require("./promise/pFilter"), exports);

package/dist/object/deepEquals.d.ts

@@ -1,11 +1,63 @@
 /**
- * deepEquals, but after JSON stringify/parse
- * E.g if object A has extra properties with value `undefined` -
- * it won't be _deepEquals true, but will be _deepJsonEquals true.
- * (because JSON.stringify removes undefined properties).
+ Returns true if a and b are deeply equal.
+ 
+ Equality is checked recursively, with the following rules/caveats:
+ - Primitive values are checked with ===
+ - NaN === NaN
+ - Array length should be the same, and every value should be equal
+ - Sets are checked similarly to arrays (but order doesn't matter in Sets)
+ - Objects and Maps are checked that all values match. Undefined values are treated the same as absent key (important!)
+ - Order of object/Map keys doesn't matter, unlike when comparing JSON.stringify(a) === JSON.stringify(b)
+ - Regex are compared by their source and flags
+ - Functions are compared by their `.toString`
+ - Any object that overrides `.toString()` is compared by that (e.g Function)
+ - Any object that overrides `.valueOf()` is compared by that (e.g Date)
+ 
+ What are the differences between various deep-equality functions?
+ There are:
+ - _deepEquals
+ - _deepJsonEquals
+ - _jsonEquals
+ 
+ _deepEquals uses "common sense" equality.
+ It tries to work "as you would expect it to".
+ With the important caveat that undefined values are treated the same as absent key.
+ So, _deepEquals should be the first choice.
+ It's also the most performant of 3.
+ 
+ _deepJsonEquals uses different logic, that's often not what you expect.
+ It should be used to compare objects of how they would look after "passing via JSON.stringify",
+ for example when you return it over the API to the Frontend,
+ or when you pass it to be saved to the Database.
+ If some object has custom .toJSON() implementation - it'll invoke that (similar to JSON.stringify).
+ For these cases - it can be better than _deepEquals.
+ And it's better than _jsonEquals, because it doesn't fail/depend on object key order.
+ 
+ _jsonEquals is simply JSON.stringify(a) === JSON.stringify(b).
+ It's the simplest implementation, but also the slowest of 3.
+ 
+ TLDR: _deepEquals should be useful in most of the cases, start there.
+ */
+export declare function _deepEquals(a: any, b: any): boolean;
+/**
+ Returns true if a and b are deeply equal.
+ 
+ Equality is checked in the same way as if both arguments are processed via
+ JSON.stringify and JSON.parse:
+ - undefined values are removed, undefined values in an array are turned into `null`, etc.
+ - Any Regex, Map, Set, Function stringifies to {}.
+ - Date stringifies to its IsoDateTimeString representation.
+ - Any object that implements toJSON is compared by the output of its toJSON().
+ - NaN stringifies to null
+ - Order of object keys does not matter, unlike when comparing JSON.stringify(a) === JSON.stringify(b)
+ 
+ See _deepEquals docs for more details and comparison.
  */
 export declare function _deepJsonEquals(a: any, b: any): boolean;
 /**
- * Based on: https://github.com/epoberezkin/fast-deep-equal/
+ * Shortcut for JSON.stringify(a) === JSON.stringify(b)
+ *
+ * Simplest "deep equals" implementation, but also the slowest,
+ * and not robust, in the sense that it depends on the order of object keys.
  */
-export declare function _deepEquals(a: any, b: any): boolean;
+export declare function _jsonEquals(a: any, b: any): boolean;

package/dist/object/deepEquals.js

@@ -1,75 +1,169 @@
 "use strict";
+// Heavily inspired by https://github.com/epoberezkin/fast-deep-equal
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._deepEquals = exports._deepJsonEquals = void 0;
-const isArray = Array.isArray;
-const keyList = Object.keys;
-const hasProp = Object.prototype.hasOwnProperty;
+exports._jsonEquals = exports._deepJsonEquals = exports._deepEquals = void 0;
 /**
- * deepEquals, but after JSON stringify/parse
- * E.g if object A has extra properties with value `undefined` -
- * it won't be _deepEquals true, but will be _deepJsonEquals true.
- * (because JSON.stringify removes undefined properties).
- */
-function _deepJsonEquals(a, b) {
-    if (a === b)
-        return true;
-    const aj = JSON.stringify(a);
-    const bj = JSON.stringify(b);
-    if (aj === bj)
-        return true;
-    return _deepEquals(JSON.parse(aj), JSON.parse(bj));
-}
-exports._deepJsonEquals = _deepJsonEquals;
-/**
- * Based on: https://github.com/epoberezkin/fast-deep-equal/
+ Returns true if a and b are deeply equal.
+ 
+ Equality is checked recursively, with the following rules/caveats:
+ - Primitive values are checked with ===
+ - NaN === NaN
+ - Array length should be the same, and every value should be equal
+ - Sets are checked similarly to arrays (but order doesn't matter in Sets)
+ - Objects and Maps are checked that all values match. Undefined values are treated the same as absent key (important!)
+ - Order of object/Map keys doesn't matter, unlike when comparing JSON.stringify(a) === JSON.stringify(b)
+ - Regex are compared by their source and flags
+ - Functions are compared by their `.toString`
+ - Any object that overrides `.toString()` is compared by that (e.g Function)
+ - Any object that overrides `.valueOf()` is compared by that (e.g Date)
+ 
+ What are the differences between various deep-equality functions?
+ There are:
+ - _deepEquals
+ - _deepJsonEquals
+ - _jsonEquals
+ 
+ _deepEquals uses "common sense" equality.
+ It tries to work "as you would expect it to".
+ With the important caveat that undefined values are treated the same as absent key.
+ So, _deepEquals should be the first choice.
+ It's also the most performant of 3.
+ 
+ _deepJsonEquals uses different logic, that's often not what you expect.
+ It should be used to compare objects of how they would look after "passing via JSON.stringify",
+ for example when you return it over the API to the Frontend,
+ or when you pass it to be saved to the Database.
+ If some object has custom .toJSON() implementation - it'll invoke that (similar to JSON.stringify).
+ For these cases - it can be better than _deepEquals.
+ And it's better than _jsonEquals, because it doesn't fail/depend on object key order.
+ 
+ _jsonEquals is simply JSON.stringify(a) === JSON.stringify(b).
+ It's the simplest implementation, but also the slowest of 3.
+ 
+ TLDR: _deepEquals should be useful in most of the cases, start there.
  */
 function _deepEquals(a, b) {
     if (a === b)
         return true;
+    if (Number.isNaN(a)) {
+        return Number.isNaN(b);
+    }
     if (a && b && typeof a === 'object' && typeof b === 'object') {
-        const arrA = isArray(a);
-        const arrB = isArray(b);
-        let i;
-        let length;
-        let key;
-        if (arrA !== arrB)
+        if (a.constructor !== b.constructor)
             return false;
-        if (arrA && arrB) {
-            length = a.length;
+        if (Array.isArray(a)) {
+            const length = a.length;
             if (length !== b.length)
                 return false;
-            for (i = length; i-- !== 0;)
+            for (let i = length; i-- !== 0;) {
                 if (!_deepEquals(a[i], b[i]))
                     return false;
+            }
             return true;
         }
-        const dateA = a instanceof Date;
-        const dateB = b instanceof Date;
-        if (dateA !== dateB)
-            return false;
-        if (dateA && dateB)
-            return a.getTime() === b.getTime();
-        const regexpA = a instanceof RegExp;
-        const regexpB = b instanceof RegExp;
-        if (regexpA !== regexpB)
-            return false;
-        if (regexpA && regexpB)
-            return a.toString() === b.toString();
-        const keys = keyList(a);
-        length = keys.length;
-        if (length !== keyList(b).length)
-            return false;
-        for (i = length; i-- !== 0;)
-            if (!hasProp.call(b, keys[i]))
+        if (a instanceof Map && b instanceof Map) {
+            for (const key of new Set([...a.keys(), ...b.keys()])) {
+                if (!_deepEquals(a.get(key), b.get(key)))
+                    return false;
+            }
+            return true;
+        }
+        if (a instanceof Set && b instanceof Set) {
+            if (a.size !== b.size)
                 return false;
-        for (i = length; i-- !== 0;) {
-            key = keys[i];
+            for (const key of a) {
+                if (!b.has(key))
+                    return false;
+            }
+            return true;
+        }
+        if (a.constructor === RegExp)
+            return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf)
+            return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString)
+            return a.toString() === b.toString();
+        for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
             if (!_deepEquals(a[key], b[key]))
                 return false;
         }
         return true;
     }
-    // eslint-disable-next-line no-self-compare
-    return a !== a && b !== b;
+    return a === b;
 }
 exports._deepEquals = _deepEquals;
+/**
+ Returns true if a and b are deeply equal.
+ 
+ Equality is checked in the same way as if both arguments are processed via
+ JSON.stringify and JSON.parse:
+ - undefined values are removed, undefined values in an array are turned into `null`, etc.
+ - Any Regex, Map, Set, Function stringifies to {}.
+ - Date stringifies to its IsoDateTimeString representation.
+ - Any object that implements toJSON is compared by the output of its toJSON().
+ - NaN stringifies to null
+ - Order of object keys does not matter, unlike when comparing JSON.stringify(a) === JSON.stringify(b)
+ 
+ See _deepEquals docs for more details and comparison.
+ */
+function _deepJsonEquals(a, b) {
+    if (a === b)
+        return true;
+    if (Number.isNaN(a)) {
+        a = null;
+    }
+    else if (typeof a === 'function') {
+        a = undefined;
+    }
+    else if (a && typeof a === 'object') {
+        if (a instanceof Date) {
+            a = a.valueOf();
+        }
+        else if ('toJSON' in a) {
+            a = a.toJSON();
+        }
+    }
+    if (Number.isNaN(b)) {
+        b = null;
+    }
+    else if (typeof b === 'function') {
+        b = undefined;
+    }
+    else if (b && typeof b === 'object') {
+        if (b instanceof Date) {
+            b = b.valueOf();
+        }
+        else if ('toJSON' in b) {
+            b = b.toJSON();
+        }
+    }
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        if (Array.isArray(a)) {
+            const length = a.length;
+            if (length !== b.length)
+                return false;
+            for (let i = length; i-- !== 0;) {
+                if (!_deepJsonEquals(a[i], b[i]))
+                    return false;
+            }
+            return true;
+        }
+        for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
+            if (!_deepJsonEquals(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    return a === b;
+}
+exports._deepJsonEquals = _deepJsonEquals;
+/**
+ * Shortcut for JSON.stringify(a) === JSON.stringify(b)
+ *
+ * Simplest "deep equals" implementation, but also the slowest,
+ * and not robust, in the sense that it depends on the order of object keys.
+ */
+function _jsonEquals(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+exports._jsonEquals = _jsonEquals;

package/dist/object/map2.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Like Map, but serializes to JSON as an object.
+ *
+ * Fixes the "issue" of stock Map being json-serialized as `{}`.
+ *
+ * @experimental
+ */
+export declare class Map2<K = any, V = any> extends Map<K, V> {
+    /**
+     * Convenience way to create Map2 from object.
+     */
+    static of<V>(obj: Record<any, V>): Map2<string, V>;
+    toObject(): Record<string, V>;
+    toJSON(): Record<string, V>;
+}

package/dist/object/map2.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Map2 = void 0;
+/**
+ * Like Map, but serializes to JSON as an object.
+ *
+ * Fixes the "issue" of stock Map being json-serialized as `{}`.
+ *
+ * @experimental
+ */
+class Map2 extends Map {
+    /**
+     * Convenience way to create Map2 from object.
+     */
+    static of(obj) {
+        return new Map2(Object.entries(obj));
+    }
+    toObject() {
+        return Object.fromEntries(this);
+    }
+    toJSON() {
+        return Object.fromEntries(this);
+    }
+}
+exports.Map2 = Map2;