@tspro/ts-utils-lib 1.12.0 → 1.13.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [1.13.0] - 2025-10-18
+### Added
+- Added even more functionality to Map1, Map2 and Map3.
+
 ## [1.12.0] - 2025-10-15
 ### Added
 - Added more functionality to Map1, Map2 and Map3.

package/dist/index.d.mts

@@ -449,40 +449,78 @@ declare class SmallIntCache<V> {
 declare class Map1<KEY1, VALUE> {
     private map1;
     constructor();
+    constructor(map1: Map1<KEY1, VALUE>);
+    constructor(entries: Iterable<[KEY1, VALUE]>);
+    has(key1: KEY1): boolean;
     set(key1: KEY1, value: VALUE): VALUE;
     get(key1: KEY1): VALUE | undefined;
-    has(key1: KEY1): boolean;
+    getOrDefault(key1: KEY1, defaultValue: VALUE): VALUE;
+    getOrCreate(key1: KEY1, creator: () => VALUE): VALUE;
     delete(key1: KEY1): boolean;
     clear(): void;
     get size(): number;
     forEach(callbackfn: (value: VALUE, key1: KEY1, map1: Map1<KEY1, VALUE>) => void, thisArg?: any): void;
     keys(): IterableIterator<KEY1>;
+    keysArray(): KEY1[];
     values(): IterableIterator<VALUE>;
+    valuesArray(): VALUE[];
     entries(): IterableIterator<[KEY1, VALUE]>;
+    entriesArray(): [KEY1, VALUE][];
     [Symbol.iterator](): Generator<[KEY1, VALUE], void, any>;
+    clone(): Map1<KEY1, VALUE>;
+    merge(other: Map1<KEY1, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1) => VALUE): this;
+    some(fn: (value: VALUE, key1: KEY1) => boolean): boolean;
+    every(fn: (value: VALUE, key1: KEY1) => boolean): boolean;
+    filter(fn: (value: VALUE, key1: KEY1) => boolean): Map1<KEY1, VALUE>;
+    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1) => R, init: R): R;
+    mapEntries<R>(fn: (value: VALUE, key1: KEY1) => R): R[];
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1) => R): Map1<KEY1, R>;
+    toMap(): Map<KEY1, VALUE>;
+    toString(): string;
 }
 declare class Map2<KEY1, KEY2, VALUE> {
     private map1;
     constructor();
+    constructor(map2: Map2<KEY1, KEY2, VALUE>);
+    constructor(entries: Iterable<[KEY1, KEY2, VALUE]>);
+    has(key1: KEY1, key2: KEY2): boolean;
     set(key1: KEY1, key2: KEY2, value: VALUE): VALUE;
     get(key1: KEY1, key2: KEY2): VALUE | undefined;
-    has(key1: KEY1, key2: KEY2): boolean;
+    getOrDefault(key1: KEY1, key2: KEY2, defaultValue: VALUE): VALUE;
+    getOrCreate(key1: KEY1, key2: KEY2, creator: () => VALUE): VALUE;
     delete(key1: KEY1): boolean;
     delete(key1: KEY1, key2: KEY2): boolean;
     clear(): void;
     get size(): number;
     forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, map2: Map2<KEY1, KEY2, VALUE>) => void, thisArg?: any): void;
     keys(): IterableIterator<[KEY1, KEY2]>;
+    keysArray(): [KEY1, KEY2][];
     values(): IterableIterator<VALUE>;
+    valuesArray(): VALUE[];
     entries(): IterableIterator<[KEY1, KEY2, VALUE]>;
+    entriesArray(): [KEY1, KEY2, VALUE][];
     [Symbol.iterator](): Generator<[KEY1, KEY2, VALUE], void, any>;
+    clone(): Map2<KEY1, KEY2, VALUE>;
+    merge(other: Map2<KEY1, KEY2, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2) => VALUE): this;
+    some(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): boolean;
+    every(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): boolean;
+    filter(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): Map2<KEY1, KEY2, VALUE>;
+    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1, key2: KEY2) => R, init: R): R;
+    mapEntries<R>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): R[];
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): Map2<KEY1, KEY2, R>;
+    toMap(): Map<[KEY1, KEY2], VALUE>;
+    toString(): string;
 }
 declare class Map3<KEY1, KEY2, KEY3, VALUE> {
     private map1;
     constructor();
+    constructor(entries: Iterable<[KEY1, KEY2, KEY3, VALUE]>);
+    constructor(map3: Map3<KEY1, KEY2, KEY3, VALUE>);
+    has(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
     set(key1: KEY1, key2: KEY2, key3: KEY3, value: VALUE): VALUE;
     get(key1: KEY1, key2: KEY2, key3: KEY3): VALUE | undefined;
-    has(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
+    getOrDefault(key1: KEY1, key2: KEY2, key3: KEY3, defaultValue: VALUE): VALUE;
+    getOrCreate(key1: KEY1, key2: KEY2, key3: KEY3, creator: () => VALUE): VALUE;
     delete(key1: KEY1): boolean;
     delete(key1: KEY1, key2: KEY2): boolean;
     delete(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
@@ -490,9 +528,22 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> {
     get size(): number;
     forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, map2: Map3<KEY1, KEY2, KEY3, VALUE>) => void, thisArg?: any): void;
     keys(): IterableIterator<[KEY1, KEY2, KEY3]>;
+    keysArray(): [KEY1, KEY2, KEY3][];
     values(): IterableIterator<VALUE>;
+    valuesArray(): VALUE[];
     entries(): IterableIterator<[KEY1, KEY2, KEY3, VALUE]>;
+    entriesArray(): [KEY1, KEY2, KEY3, VALUE][];
     [Symbol.iterator](): Generator<[KEY1, KEY2, KEY3, VALUE], void, any>;
+    clone(): Map3<KEY1, KEY2, KEY3, VALUE>;
+    merge(other: Map3<KEY1, KEY2, KEY3, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => VALUE): this;
+    some(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): boolean;
+    every(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): boolean;
+    filter(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): Map3<KEY1, KEY2, KEY3, VALUE>;
+    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R, init: R): R;
+    mapEntries<R>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): R[];
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): Map3<KEY1, KEY2, KEY3, R>;
+    toMap(): Map<[KEY1, KEY2, KEY3], VALUE>;
+    toString(): string;
 }
 
 export { Assert, Cookies, Device, LRUCache, Map1, Map2, Map3, SmallIntCache, Stack, index as Utils, Vec2 };

package/dist/index.d.ts

@@ -449,40 +449,78 @@ declare class SmallIntCache<V> {
 declare class Map1<KEY1, VALUE> {
     private map1;
     constructor();
+    constructor(map1: Map1<KEY1, VALUE>);
+    constructor(entries: Iterable<[KEY1, VALUE]>);
+    has(key1: KEY1): boolean;
     set(key1: KEY1, value: VALUE): VALUE;
     get(key1: KEY1): VALUE | undefined;
-    has(key1: KEY1): boolean;
+    getOrDefault(key1: KEY1, defaultValue: VALUE): VALUE;
+    getOrCreate(key1: KEY1, creator: () => VALUE): VALUE;
     delete(key1: KEY1): boolean;
     clear(): void;
     get size(): number;
     forEach(callbackfn: (value: VALUE, key1: KEY1, map1: Map1<KEY1, VALUE>) => void, thisArg?: any): void;
     keys(): IterableIterator<KEY1>;
+    keysArray(): KEY1[];
     values(): IterableIterator<VALUE>;
+    valuesArray(): VALUE[];
     entries(): IterableIterator<[KEY1, VALUE]>;
+    entriesArray(): [KEY1, VALUE][];
     [Symbol.iterator](): Generator<[KEY1, VALUE], void, any>;
+    clone(): Map1<KEY1, VALUE>;
+    merge(other: Map1<KEY1, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1) => VALUE): this;
+    some(fn: (value: VALUE, key1: KEY1) => boolean): boolean;
+    every(fn: (value: VALUE, key1: KEY1) => boolean): boolean;
+    filter(fn: (value: VALUE, key1: KEY1) => boolean): Map1<KEY1, VALUE>;
+    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1) => R, init: R): R;
+    mapEntries<R>(fn: (value: VALUE, key1: KEY1) => R): R[];
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1) => R): Map1<KEY1, R>;
+    toMap(): Map<KEY1, VALUE>;
+    toString(): string;
 }
 declare class Map2<KEY1, KEY2, VALUE> {
     private map1;
     constructor();
+    constructor(map2: Map2<KEY1, KEY2, VALUE>);
+    constructor(entries: Iterable<[KEY1, KEY2, VALUE]>);
+    has(key1: KEY1, key2: KEY2): boolean;
     set(key1: KEY1, key2: KEY2, value: VALUE): VALUE;
     get(key1: KEY1, key2: KEY2): VALUE | undefined;
-    has(key1: KEY1, key2: KEY2): boolean;
+    getOrDefault(key1: KEY1, key2: KEY2, defaultValue: VALUE): VALUE;
+    getOrCreate(key1: KEY1, key2: KEY2, creator: () => VALUE): VALUE;
     delete(key1: KEY1): boolean;
     delete(key1: KEY1, key2: KEY2): boolean;
     clear(): void;
     get size(): number;
     forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, map2: Map2<KEY1, KEY2, VALUE>) => void, thisArg?: any): void;
     keys(): IterableIterator<[KEY1, KEY2]>;
+    keysArray(): [KEY1, KEY2][];
     values(): IterableIterator<VALUE>;
+    valuesArray(): VALUE[];
     entries(): IterableIterator<[KEY1, KEY2, VALUE]>;
+    entriesArray(): [KEY1, KEY2, VALUE][];
     [Symbol.iterator](): Generator<[KEY1, KEY2, VALUE], void, any>;
+    clone(): Map2<KEY1, KEY2, VALUE>;
+    merge(other: Map2<KEY1, KEY2, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2) => VALUE): this;
+    some(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): boolean;
+    every(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): boolean;
+    filter(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): Map2<KEY1, KEY2, VALUE>;
+    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1, key2: KEY2) => R, init: R): R;
+    mapEntries<R>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): R[];
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): Map2<KEY1, KEY2, R>;
+    toMap(): Map<[KEY1, KEY2], VALUE>;
+    toString(): string;
 }
 declare class Map3<KEY1, KEY2, KEY3, VALUE> {
     private map1;
     constructor();
+    constructor(entries: Iterable<[KEY1, KEY2, KEY3, VALUE]>);
+    constructor(map3: Map3<KEY1, KEY2, KEY3, VALUE>);
+    has(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
     set(key1: KEY1, key2: KEY2, key3: KEY3, value: VALUE): VALUE;
     get(key1: KEY1, key2: KEY2, key3: KEY3): VALUE | undefined;
-    has(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
+    getOrDefault(key1: KEY1, key2: KEY2, key3: KEY3, defaultValue: VALUE): VALUE;
+    getOrCreate(key1: KEY1, key2: KEY2, key3: KEY3, creator: () => VALUE): VALUE;
     delete(key1: KEY1): boolean;
     delete(key1: KEY1, key2: KEY2): boolean;
     delete(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
@@ -490,9 +528,22 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> {
     get size(): number;
     forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, map2: Map3<KEY1, KEY2, KEY3, VALUE>) => void, thisArg?: any): void;
     keys(): IterableIterator<[KEY1, KEY2, KEY3]>;
+    keysArray(): [KEY1, KEY2, KEY3][];
     values(): IterableIterator<VALUE>;
+    valuesArray(): VALUE[];
     entries(): IterableIterator<[KEY1, KEY2, KEY3, VALUE]>;
+    entriesArray(): [KEY1, KEY2, KEY3, VALUE][];
     [Symbol.iterator](): Generator<[KEY1, KEY2, KEY3, VALUE], void, any>;
+    clone(): Map3<KEY1, KEY2, KEY3, VALUE>;
+    merge(other: Map3<KEY1, KEY2, KEY3, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => VALUE): this;
+    some(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): boolean;
+    every(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): boolean;
+    filter(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): Map3<KEY1, KEY2, KEY3, VALUE>;
+    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R, init: R): R;
+    mapEntries<R>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): R[];
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): Map3<KEY1, KEY2, KEY3, R>;
+    toMap(): Map<[KEY1, KEY2, KEY3], VALUE>;
+    toString(): string;
 }
 
 export { Assert, Cookies, Device, LRUCache, Map1, Map2, Map3, SmallIntCache, Stack, index as Utils, Vec2 };

package/dist/index.js

@@ -1,4 +1,4 @@
-/* TsUtilsLib v1.12.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+/* TsUtilsLib v1.13.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1293,9 +1293,13 @@ var SmallIntCache = class {
 };
 
 // src/core/map.ts
-var Map1 = class {
-  constructor() {
-    __publicField(this, "map1", /* @__PURE__ */ new Map());
+var Map1 = class _Map1 {
+  constructor(entries) {
+    __publicField(this, "map1");
+    this.map1 = entries instanceof _Map1 ? new Map(entries.map1) : new Map(entries);
+  }
+  has(key1) {
+    return this.map1.has(key1);
   }
   set(key1, value) {
     this.map1.set(key1, value);
@@ -1304,8 +1308,15 @@ var Map1 = class {
   get(key1) {
     return this.map1.get(key1);
   }
-  has(key1) {
-    return this.map1.has(key1);
+  getOrDefault(key1, defaultValue) {
+    return this.get(key1) ?? defaultValue;
+  }
+  getOrCreate(key1, creator) {
+    let value = this.get(key1);
+    if (!value) {
+      this.set(key1, value = creator());
+    }
+    return value;
   }
   delete(key1) {
     return this.map1.delete(key1);
@@ -1322,20 +1333,101 @@ var Map1 = class {
   keys() {
     return this.map1.keys();
   }
+  keysArray() {
+    return [...this.keys()];
+  }
   values() {
     return this.map1.values();
   }
+  valuesArray() {
+    return [...this.values()];
+  }
   *entries() {
     for (const [key1, value] of this.map1)
       yield [key1, value];
   }
+  entriesArray() {
+    return [...this.entries()];
+  }
   *[Symbol.iterator]() {
     yield* this.entries();
   }
+  clone() {
+    return new _Map1(this);
+  }
+  merge(other, conflictResolver) {
+    for (const [key1, value] of other.entries()) {
+      if (this.has(key1) && conflictResolver) {
+        this.set(key1, conflictResolver(this.get(key1), value, key1));
+      } else {
+        this.set(key1, value);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [key1, value] of this.map1) {
+      if (fn(value, key1)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [key1, value] of this.map1) {
+      if (!fn(value, key1)) return false;
+    }
+    return true;
+  }
+  filter(fn) {
+    let result = new _Map1();
+    for (const [key1, value] of this.map1) {
+      if (fn(value, key1)) result.set(key1, value);
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let acc = init;
+    for (const [key1, value] of this.map1) {
+      acc = fn(acc, value, key1);
+    }
+    return acc;
+  }
+  mapEntries(fn) {
+    let result = [];
+    for (const [key1, value] of this.map1) {
+      result.push(fn(value, key1));
+    }
+    return result;
+  }
+  mapValues(fn) {
+    let result = new _Map1();
+    for (const [key1, value] of this.map1) {
+      result.set(key1, fn(value, key1));
+    }
+    return result;
+  }
+  toMap() {
+    return new Map(this.map1);
+  }
+  toString() {
+    const entries = [...this.map1].map(([k, v]) => `${k} => ${v}`).join(", ");
+    return `Map1(${this.map1.size}) { ${entries} }`;
+  }
 };
-var Map2 = class {
-  constructor() {
+var Map2 = class _Map2 {
+  constructor(entries) {
     __publicField(this, "map1", /* @__PURE__ */ new Map());
+    if (entries instanceof _Map2) {
+      for (const [key1, inner] of entries.map1) {
+        this.map1.set(key1, new Map(inner));
+      }
+    } else if (entries) {
+      for (const [key1, key2, value] of entries) {
+        this.set(key1, key2, value);
+      }
+    }
+  }
+  has(key1, key2) {
+    return this.map1.get(key1)?.has(key2) ?? false;
   }
   set(key1, key2, value) {
     let map2 = this.map1.get(key1) ?? this.map1.set(key1, /* @__PURE__ */ new Map()).get(key1);
@@ -1345,8 +1437,15 @@ var Map2 = class {
   get(key1, key2) {
     return this.map1.get(key1)?.get(key2);
   }
-  has(key1, key2) {
-    return this.map1.get(key1)?.has(key2) ?? false;
+  getOrDefault(key1, key2, defaultValue) {
+    return this.get(key1, key2) ?? defaultValue;
+  }
+  getOrCreate(key1, key2, creator) {
+    let value = this.get(key1, key2);
+    if (!value) {
+      this.set(key1, key2, value = creator());
+    }
+    return value;
   }
   delete(key1, key2) {
     if (key2 === void 0) return this.map1.delete(key1);
@@ -1369,12 +1468,15 @@ var Map2 = class {
   }
   keys() {
     function* gen(map1) {
-      for (const [k1, map2] of map1)
-        for (const k2 of map2.keys())
-          yield [k1, k2];
+      for (const [key1, map2] of map1)
+        for (const key2 of map2.keys())
+          yield [key1, key2];
     }
     return gen(this.map1);
   }
+  keysArray() {
+    return [...this.keys()];
+  }
   values() {
     function* gen(map1) {
       for (const map2 of map1.values())
@@ -1383,18 +1485,122 @@ var Map2 = class {
     }
     return gen(this.map1);
   }
+  valuesArray() {
+    return [...this.values()];
+  }
   *entries() {
     for (const [key1, map2] of this.map1)
       for (const [key2, value] of map2)
         yield [key1, key2, value];
   }
+  entriesArray() {
+    return [...this.entries()];
+  }
   *[Symbol.iterator]() {
     yield* this.entries();
   }
+  clone() {
+    return new _Map2(this);
+  }
+  merge(other, conflictResolver) {
+    for (const [key1, key2, value] of other.entries()) {
+      if (this.has(key1, key2) && conflictResolver) {
+        this.set(key1, key2, conflictResolver(this.get(key1, key2), value, key1, key2));
+      } else {
+        this.set(key1, key2, value);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        if (fn(value, key1, key2)) return true;
+      }
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        if (!fn(value, key1, key2)) return false;
+      }
+    }
+    return true;
+  }
+  filter(fn) {
+    let result = new _Map2();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        if (fn(value, key1, key2)) result.set(key1, key2, value);
+      }
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let acc = init;
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        acc = fn(acc, value, key1, key2);
+      }
+    }
+    return acc;
+  }
+  mapEntries(fn) {
+    let result = [];
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        result.push(fn(value, key1, key2));
+      }
+    }
+    return result;
+  }
+  mapValues(fn) {
+    let result = new _Map2();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        result.set(key1, key2, fn(value, key1, key2));
+      }
+    }
+    return result;
+  }
+  toMap() {
+    let result = /* @__PURE__ */ new Map();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        result.set([key1, key2], value);
+      }
+    }
+    return result;
+  }
+  toString() {
+    const entries = [];
+    for (const [key1, map2] of this.map1) {
+      const inner = [...map2].map(([key2, v]) => `${key2} => ${v}`).join(", ");
+      entries.push(`${key1} => { ${inner} }`);
+    }
+    return `Map2(${this.size}) { ${entries.join(", ")} }`;
+  }
 };
-var Map3 = class {
-  constructor() {
+var Map3 = class _Map3 {
+  constructor(entries) {
     __publicField(this, "map1", /* @__PURE__ */ new Map());
+    if (entries instanceof _Map3) {
+      for (const [key1, map2] of entries.map1) {
+        const newMap2 = /* @__PURE__ */ new Map();
+        for (const [key2, map3] of map2) {
+          newMap2.set(key2, new Map(map3));
+        }
+        this.map1.set(key1, newMap2);
+      }
+    } else if (entries) {
+      for (const [key1, key2, key3, value] of entries) {
+        this.set(key1, key2, key3, value);
+      }
+    }
+  }
+  has(key1, key2, key3) {
+    return this.map1.get(key1)?.get(key2)?.has(key3) ?? false;
   }
   set(key1, key2, key3, value) {
     let map2 = this.map1.get(key1);
@@ -1407,8 +1613,15 @@ var Map3 = class {
   get(key1, key2, key3) {
     return this.map1.get(key1)?.get(key2)?.get(key3);
   }
-  has(key1, key2, key3) {
-    return this.map1.get(key1)?.get(key2)?.has(key3) ?? false;
+  getOrDefault(key1, key2, key3, defaultValue) {
+    return this.get(key1, key2, key3) ?? defaultValue;
+  }
+  getOrCreate(key1, key2, key3, creator) {
+    let value = this.get(key1, key2, key3);
+    if (!value) {
+      this.set(key1, key2, key3, value = creator());
+    }
+    return value;
   }
   delete(key1, key2, key3) {
     if (key3 === void 0) {
@@ -1440,13 +1653,16 @@ var Map3 = class {
   }
   keys() {
     function* gen(map1) {
-      for (const [k1, map2] of map1)
-        for (const [k2, map3] of map2)
-          for (const k3 of map3.keys())
-            yield [k1, k2, k3];
+      for (const [key1, map2] of map1)
+        for (const [key2, map3] of map2)
+          for (const key3 of map3.keys())
+            yield [key1, key2, key3];
     }
     return gen(this.map1);
   }
+  keysArray() {
+    return [...this.keys()];
+  }
   values() {
     function* gen(map1) {
       for (const map2 of map1.values())
@@ -1456,15 +1672,119 @@ var Map3 = class {
     }
     return gen(this.map1);
   }
+  valuesArray() {
+    return [...this.values()];
+  }
   *entries() {
     for (const [key1, map2] of this.map1)
       for (const [key2, map3] of map2)
         for (const [key3, value] of map3)
           yield [key1, key2, key3, value];
   }
+  entriesArray() {
+    return [...this.entries()];
+  }
   *[Symbol.iterator]() {
     yield* this.entries();
   }
+  clone() {
+    return new _Map3(this);
+  }
+  merge(other, conflictResolver) {
+    for (const [key1, key2, key3, value] of other.entries()) {
+      if (this.has(key1, key2, key3) && conflictResolver) {
+        this.set(key1, key2, key3, conflictResolver(this.get(key1, key2, key3), value, key1, key2, key3));
+      } else {
+        this.set(key1, key2, key3, value);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          if (fn(value, key1, key2, key3)) return true;
+        }
+      }
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          if (!fn(value, key1, key2, key3)) return false;
+        }
+      }
+    }
+    return true;
+  }
+  filter(fn) {
+    let result = new _Map3();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          if (fn(value, key1, key2, key3)) result.set(key1, key2, key3, value);
+        }
+      }
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let acc = init;
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          acc = fn(acc, value, key1, key2, key3);
+        }
+      }
+    }
+    return acc;
+  }
+  mapEntries(fn) {
+    let result = [];
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          result.push(fn(value, key1, key2, key3));
+        }
+      }
+    }
+    return result;
+  }
+  mapValues(fn) {
+    let result = new _Map3();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          result.set(key1, key2, key3, fn(value, key1, key2, key3));
+        }
+      }
+    }
+    return result;
+  }
+  toMap() {
+    let result = /* @__PURE__ */ new Map();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          result.set([key1, key2, key3], value);
+        }
+      }
+    }
+    return result;
+  }
+  toString() {
+    const entries = [];
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        const inner = [...map3].map(([key3, v]) => `${key3} => ${v}`).join(", ");
+        entries.push(`${key1} => ${key2} => { ${inner} }`);
+      }
+    }
+    return `Map3(${this.size}) { ${entries.join(", ")} }`;
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.mjs

@@ -1,4 +1,4 @@
-/* TsUtilsLib v1.12.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+/* TsUtilsLib v1.13.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
@@ -1263,9 +1263,13 @@ var SmallIntCache = class {
 };
 
 // src/core/map.ts
-var Map1 = class {
-  constructor() {
-    __publicField(this, "map1", /* @__PURE__ */ new Map());
+var Map1 = class _Map1 {
+  constructor(entries) {
+    __publicField(this, "map1");
+    this.map1 = entries instanceof _Map1 ? new Map(entries.map1) : new Map(entries);
+  }
+  has(key1) {
+    return this.map1.has(key1);
   }
   set(key1, value) {
     this.map1.set(key1, value);
@@ -1274,8 +1278,15 @@ var Map1 = class {
   get(key1) {
     return this.map1.get(key1);
   }
-  has(key1) {
-    return this.map1.has(key1);
+  getOrDefault(key1, defaultValue) {
+    return this.get(key1) ?? defaultValue;
+  }
+  getOrCreate(key1, creator) {
+    let value = this.get(key1);
+    if (!value) {
+      this.set(key1, value = creator());
+    }
+    return value;
   }
   delete(key1) {
     return this.map1.delete(key1);
@@ -1292,20 +1303,101 @@ var Map1 = class {
   keys() {
     return this.map1.keys();
   }
+  keysArray() {
+    return [...this.keys()];
+  }
   values() {
     return this.map1.values();
   }
+  valuesArray() {
+    return [...this.values()];
+  }
   *entries() {
     for (const [key1, value] of this.map1)
       yield [key1, value];
   }
+  entriesArray() {
+    return [...this.entries()];
+  }
   *[Symbol.iterator]() {
     yield* this.entries();
   }
+  clone() {
+    return new _Map1(this);
+  }
+  merge(other, conflictResolver) {
+    for (const [key1, value] of other.entries()) {
+      if (this.has(key1) && conflictResolver) {
+        this.set(key1, conflictResolver(this.get(key1), value, key1));
+      } else {
+        this.set(key1, value);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [key1, value] of this.map1) {
+      if (fn(value, key1)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [key1, value] of this.map1) {
+      if (!fn(value, key1)) return false;
+    }
+    return true;
+  }
+  filter(fn) {
+    let result = new _Map1();
+    for (const [key1, value] of this.map1) {
+      if (fn(value, key1)) result.set(key1, value);
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let acc = init;
+    for (const [key1, value] of this.map1) {
+      acc = fn(acc, value, key1);
+    }
+    return acc;
+  }
+  mapEntries(fn) {
+    let result = [];
+    for (const [key1, value] of this.map1) {
+      result.push(fn(value, key1));
+    }
+    return result;
+  }
+  mapValues(fn) {
+    let result = new _Map1();
+    for (const [key1, value] of this.map1) {
+      result.set(key1, fn(value, key1));
+    }
+    return result;
+  }
+  toMap() {
+    return new Map(this.map1);
+  }
+  toString() {
+    const entries = [...this.map1].map(([k, v]) => `${k} => ${v}`).join(", ");
+    return `Map1(${this.map1.size}) { ${entries} }`;
+  }
 };
-var Map2 = class {
-  constructor() {
+var Map2 = class _Map2 {
+  constructor(entries) {
     __publicField(this, "map1", /* @__PURE__ */ new Map());
+    if (entries instanceof _Map2) {
+      for (const [key1, inner] of entries.map1) {
+        this.map1.set(key1, new Map(inner));
+      }
+    } else if (entries) {
+      for (const [key1, key2, value] of entries) {
+        this.set(key1, key2, value);
+      }
+    }
+  }
+  has(key1, key2) {
+    return this.map1.get(key1)?.has(key2) ?? false;
   }
   set(key1, key2, value) {
     let map2 = this.map1.get(key1) ?? this.map1.set(key1, /* @__PURE__ */ new Map()).get(key1);
@@ -1315,8 +1407,15 @@ var Map2 = class {
   get(key1, key2) {
     return this.map1.get(key1)?.get(key2);
   }
-  has(key1, key2) {
-    return this.map1.get(key1)?.has(key2) ?? false;
+  getOrDefault(key1, key2, defaultValue) {
+    return this.get(key1, key2) ?? defaultValue;
+  }
+  getOrCreate(key1, key2, creator) {
+    let value = this.get(key1, key2);
+    if (!value) {
+      this.set(key1, key2, value = creator());
+    }
+    return value;
   }
   delete(key1, key2) {
     if (key2 === void 0) return this.map1.delete(key1);
@@ -1339,12 +1438,15 @@ var Map2 = class {
   }
   keys() {
     function* gen(map1) {
-      for (const [k1, map2] of map1)
-        for (const k2 of map2.keys())
-          yield [k1, k2];
+      for (const [key1, map2] of map1)
+        for (const key2 of map2.keys())
+          yield [key1, key2];
     }
     return gen(this.map1);
   }
+  keysArray() {
+    return [...this.keys()];
+  }
   values() {
     function* gen(map1) {
       for (const map2 of map1.values())
@@ -1353,18 +1455,122 @@ var Map2 = class {
     }
     return gen(this.map1);
   }
+  valuesArray() {
+    return [...this.values()];
+  }
   *entries() {
     for (const [key1, map2] of this.map1)
       for (const [key2, value] of map2)
         yield [key1, key2, value];
   }
+  entriesArray() {
+    return [...this.entries()];
+  }
   *[Symbol.iterator]() {
     yield* this.entries();
   }
+  clone() {
+    return new _Map2(this);
+  }
+  merge(other, conflictResolver) {
+    for (const [key1, key2, value] of other.entries()) {
+      if (this.has(key1, key2) && conflictResolver) {
+        this.set(key1, key2, conflictResolver(this.get(key1, key2), value, key1, key2));
+      } else {
+        this.set(key1, key2, value);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        if (fn(value, key1, key2)) return true;
+      }
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        if (!fn(value, key1, key2)) return false;
+      }
+    }
+    return true;
+  }
+  filter(fn) {
+    let result = new _Map2();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        if (fn(value, key1, key2)) result.set(key1, key2, value);
+      }
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let acc = init;
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        acc = fn(acc, value, key1, key2);
+      }
+    }
+    return acc;
+  }
+  mapEntries(fn) {
+    let result = [];
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        result.push(fn(value, key1, key2));
+      }
+    }
+    return result;
+  }
+  mapValues(fn) {
+    let result = new _Map2();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        result.set(key1, key2, fn(value, key1, key2));
+      }
+    }
+    return result;
+  }
+  toMap() {
+    let result = /* @__PURE__ */ new Map();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        result.set([key1, key2], value);
+      }
+    }
+    return result;
+  }
+  toString() {
+    const entries = [];
+    for (const [key1, map2] of this.map1) {
+      const inner = [...map2].map(([key2, v]) => `${key2} => ${v}`).join(", ");
+      entries.push(`${key1} => { ${inner} }`);
+    }
+    return `Map2(${this.size}) { ${entries.join(", ")} }`;
+  }
 };
-var Map3 = class {
-  constructor() {
+var Map3 = class _Map3 {
+  constructor(entries) {
     __publicField(this, "map1", /* @__PURE__ */ new Map());
+    if (entries instanceof _Map3) {
+      for (const [key1, map2] of entries.map1) {
+        const newMap2 = /* @__PURE__ */ new Map();
+        for (const [key2, map3] of map2) {
+          newMap2.set(key2, new Map(map3));
+        }
+        this.map1.set(key1, newMap2);
+      }
+    } else if (entries) {
+      for (const [key1, key2, key3, value] of entries) {
+        this.set(key1, key2, key3, value);
+      }
+    }
+  }
+  has(key1, key2, key3) {
+    return this.map1.get(key1)?.get(key2)?.has(key3) ?? false;
   }
   set(key1, key2, key3, value) {
     let map2 = this.map1.get(key1);
@@ -1377,8 +1583,15 @@ var Map3 = class {
   get(key1, key2, key3) {
     return this.map1.get(key1)?.get(key2)?.get(key3);
   }
-  has(key1, key2, key3) {
-    return this.map1.get(key1)?.get(key2)?.has(key3) ?? false;
+  getOrDefault(key1, key2, key3, defaultValue) {
+    return this.get(key1, key2, key3) ?? defaultValue;
+  }
+  getOrCreate(key1, key2, key3, creator) {
+    let value = this.get(key1, key2, key3);
+    if (!value) {
+      this.set(key1, key2, key3, value = creator());
+    }
+    return value;
   }
   delete(key1, key2, key3) {
     if (key3 === void 0) {
@@ -1410,13 +1623,16 @@ var Map3 = class {
   }
   keys() {
     function* gen(map1) {
-      for (const [k1, map2] of map1)
-        for (const [k2, map3] of map2)
-          for (const k3 of map3.keys())
-            yield [k1, k2, k3];
+      for (const [key1, map2] of map1)
+        for (const [key2, map3] of map2)
+          for (const key3 of map3.keys())
+            yield [key1, key2, key3];
     }
     return gen(this.map1);
   }
+  keysArray() {
+    return [...this.keys()];
+  }
   values() {
     function* gen(map1) {
       for (const map2 of map1.values())
@@ -1426,15 +1642,119 @@ var Map3 = class {
     }
     return gen(this.map1);
   }
+  valuesArray() {
+    return [...this.values()];
+  }
   *entries() {
     for (const [key1, map2] of this.map1)
       for (const [key2, map3] of map2)
         for (const [key3, value] of map3)
           yield [key1, key2, key3, value];
   }
+  entriesArray() {
+    return [...this.entries()];
+  }
   *[Symbol.iterator]() {
     yield* this.entries();
   }
+  clone() {
+    return new _Map3(this);
+  }
+  merge(other, conflictResolver) {
+    for (const [key1, key2, key3, value] of other.entries()) {
+      if (this.has(key1, key2, key3) && conflictResolver) {
+        this.set(key1, key2, key3, conflictResolver(this.get(key1, key2, key3), value, key1, key2, key3));
+      } else {
+        this.set(key1, key2, key3, value);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          if (fn(value, key1, key2, key3)) return true;
+        }
+      }
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          if (!fn(value, key1, key2, key3)) return false;
+        }
+      }
+    }
+    return true;
+  }
+  filter(fn) {
+    let result = new _Map3();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          if (fn(value, key1, key2, key3)) result.set(key1, key2, key3, value);
+        }
+      }
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let acc = init;
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          acc = fn(acc, value, key1, key2, key3);
+        }
+      }
+    }
+    return acc;
+  }
+  mapEntries(fn) {
+    let result = [];
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          result.push(fn(value, key1, key2, key3));
+        }
+      }
+    }
+    return result;
+  }
+  mapValues(fn) {
+    let result = new _Map3();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          result.set(key1, key2, key3, fn(value, key1, key2, key3));
+        }
+      }
+    }
+    return result;
+  }
+  toMap() {
+    let result = /* @__PURE__ */ new Map();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          result.set([key1, key2, key3], value);
+        }
+      }
+    }
+    return result;
+  }
+  toString() {
+    const entries = [];
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        const inner = [...map3].map(([key3, v]) => `${key3} => ${v}`).join(", ");
+        entries.push(`${key1} => ${key2} => { ${inner} }`);
+      }
+    }
+    return `Map3(${this.size}) { ${entries.join(", ")} }`;
+  }
 };
 export {
   Assert,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tspro/ts-utils-lib",
-    "version": "1.12.0",
+    "version": "1.13.0",
     "author": "PahkaSoft",
     "license": "MIT",
     "private": false,