@tspro/ts-utils-lib 1.19.0 → 1.20.0

package/dist/index.js

@@ -1,4 +1,4 @@
-/* TsUtilsLib v1.19.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+/* TsUtilsLib v1.20.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -24,20 +24,31 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 var index_exports = {};
 __export(index_exports, {
   Assert: () => assert_exports,
+  BaseContainer: () => BaseContainer,
+  BiMap: () => BiMap,
   Cookies: () => cookies_exports,
+  DeepSet: () => DeepSet,
+  DefaultArray: () => DefaultArray,
+  DefaultEqualityFn: () => DefaultEqualityFn,
   Device: () => device_exports,
   DivRect: () => DivRect,
   Guard: () => guard_exports,
   IndexArray: () => IndexArray,
   LRUCache: () => LRUCache,
+  LinkedList: () => LinkedList,
   Map1: () => Map1,
   Map2: () => Map2,
   Map3: () => Map3,
   MultiContainer: () => MultiContainer,
+  Set1: () => Set1,
+  SetBase: () => SetBase,
   SignedIndexArray: () => SignedIndexArray,
   SmallIntCache: () => SmallIntCache,
   Stack: () => Stack,
+  TriMap: () => TriMap,
+  UniMap: () => UniMap,
   Utils: () => utils_exports,
+  ValueSet: () => ValueSet,
   Vec: () => Vec,
   Vec2: () => Vec2,
   asMulti: () => asMulti
@@ -101,6 +112,7 @@ __export(assert_exports, {
   isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined,
   isNonEmptyString: () => isNonEmptyString,
   isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined,
+  isNotThrowing: () => isNotThrowing,
   isNull: () => isNull,
   isNullish: () => isNullish,
   isNumber: () => isNumber,
@@ -496,6 +508,11 @@ function isThrowing(throwTestFn, msg) {
     _fail(`Expected to throw`, msg);
   return true;
 }
+function isNotThrowing(throwTestFn, msg) {
+  if (!guard_exports.isNotThrowing(throwTestFn))
+    _fail(`Expected to throw`, msg);
+  return true;
+}
 
 // src/web/cookies.ts
 var cookies_exports = {};
@@ -743,6 +760,7 @@ __export(guard_exports, {
   isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined2,
   isNonEmptyString: () => isNonEmptyString2,
   isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined2,
+  isNotThrowing: () => isNotThrowing2,
   isNull: () => isNull2,
   isNullish: () => isNullish2,
   isNumber: () => isNumber2,
@@ -992,6 +1010,14 @@ function isThrowing2(throwTestFn) {
     return true;
   }
 }
+function isNotThrowing2(throwTestFn) {
+  try {
+    throwTestFn();
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
 function tryOr(tryFn, orVal) {
   try {
     return tryFn();
@@ -1425,99 +1451,19 @@ __export(str_exports, {
   removeAt: () => removeAt,
   repeatString: () => repeatString,
   replaceAt: () => replaceAt,
+  stringify: () => stringify,
   toCharArray: () => toCharArray
 });
-function toCharArray(str2) {
-  return str2.split("");
-}
-function repeatString(repeatString2, repeatCount) {
-  if (!isInteger2(repeatCount) || repeatCount < 0) {
-    throw new Error("repeatStr: Invalid repeatCount = " + repeatCount);
-  }
-  return new Array(repeatCount + 1).join(repeatString2);
-}
-function chunkString(str2, chunkSize) {
-  if (!isInteger2(chunkSize) || chunkSize < 1) {
-    throw new Error("chunckString: Invalid chuckSize = " + chunkSize);
-  }
-  let result = [];
-  for (let i = 0; i < str2.length; i += chunkSize) {
-    result.push(str2.slice(i, i + chunkSize));
-  }
-  return result;
-}
-function replaceAt(str2, pos, removeCount, insert) {
-  if (!isInteger2(removeCount) || removeCount < 0) {
-    throw new Error("replaceAt: Invalid removeCount = " + removeCount);
-  } else if (!isInteger2(pos) || pos < 0 || pos + removeCount > str2.length) {
-    throw new Error("replaceAt: Invalid pos = " + pos + ", removeCount = " + removeCount + ", str.length = " + str2.length);
-  } else {
-    return str2.substring(0, pos) + insert + str2.substring(pos + removeCount);
-  }
-}
-function insertAt(str2, pos, insertStr) {
-  return replaceAt(str2, pos, 0, insertStr);
-}
-function removeAt(str2, pos, removeCount) {
-  return replaceAt(str2, pos, removeCount, "");
-}
-function charCount(str2, ch) {
-  if (ch.length !== 1 || str2.length === 0) return 0;
-  let count = 0;
-  for (let i = 0; i < str2.length; i++) {
-    if (str2[i] === ch) count++;
-  }
-  return count;
-}
-function makeSentenceFromPascal(PascalString) {
-  if (PascalString === "") {
-    return "";
-  }
-  let word = PascalString.charAt(0);
-  let sentence = "";
-  const addWord = () => {
-    if (word !== "") {
-      if (sentence === "") {
-        sentence += word.charAt(0).toUpperCase() + word.substring(1);
-      } else {
-        sentence += " " + word;
-      }
-      word = "";
-    }
-  };
-  const isLetterAndCapital = (c) => {
-    return c.toUpperCase() !== c.toLowerCase() && c === c.toUpperCase();
-  };
-  for (let i = 1; i < PascalString.length; i++) {
-    let c = PascalString.charAt(i);
-    if (isLetterAndCapital(c)) {
-      addWord();
-    }
-    word += c.toLowerCase();
-  }
-  addWord();
-  return sentence;
-}
-
-// src/utils/index.ts
-var Is = guard_exports;
 
-// src/core/format-value.ts
-function formatValue(value) {
-  if (isString2(value)) {
-    return `"${value}"`;
-  } else if (isArray2(value)) {
-    return `[ ${value.map((e) => formatValue(e)).join(", ")} ]`.replaceAll("  ", " ");
-  } else if (isFunction2(value.toString)) {
-    return value.toString();
-  } else {
-    return JSON.stringify(value);
-  }
-}
+// src/core/base.ts
+var DefaultEqualityFn = (a, b) => a === b;
+var BaseContainer = class {
+};
 
 // src/core/stack.ts
-var Stack = class {
+var Stack = class extends BaseContainer {
   constructor() {
+    super();
     __publicField(this, "data", []);
   }
   assertId(id) {
@@ -1578,13 +1524,14 @@ var Stack = class {
     this.data.length = 0;
   }
   toString() {
-    return `Stack(${this.length})${formatValue(this.data)}`;
+    return `Stack(${this.length})${stringify(this.data)}`;
   }
 };
 
 // src/core/vec.ts
-var Vec = class _Vec {
+var Vec = class _Vec extends BaseContainer {
   constructor(...coords) {
+    super();
     __publicField(this, "coords");
     if (coords.length < 2) {
       throw new TypeError("Vec needs minumum two coords!");
@@ -1785,19 +1732,31 @@ var DivRect = class _DivRect {
   static createSections(leftw, rightw, toph, bottomh) {
     return new _DivRect(-leftw, 0, rightw, -toph, 0, bottomh);
   }
-  /** @deprecated - Renamed to anchorX. */
+  /**
+   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+   * @private
+   * */
   get centerX() {
     return this.anchorX;
   }
-  /** @deprecated - Renamed to anchorX. */
+  /**
+   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+   * @private
+   * */
   set centerX(x) {
     this.anchorX = x;
   }
-  /** @deprecated - Renamed to anchorY. */
+  /**
+   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+   * @private
+   * */
   get centerY() {
     return this.anchorY;
   }
-  /** @deprecated - Renamed to anchorY. */
+  /**
+   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+   * @private
+   * */
   set centerY(y) {
     this.anchorY = y;
   }
@@ -1915,7 +1874,10 @@ var DivRect = class _DivRect {
   equalsEdges(other) {
     return _DivRect.equalsEdges(this, other);
   }
-  /** @deprecated - Use `DivRect.equalsEdges()` instead. */
+  /**
+   * @deprecated - Use `DivRect.equalsEdges()` instead. Will be removed in v2.0.0.
+   * @private
+   */
   static equalsFrame(a, b) {
     return _DivRect.equalsEdges(a, b);
   }
@@ -2034,9 +1996,10 @@ var DivRect = class _DivRect {
 };
 
 // src/core/LRU-cache.ts
-var LRUCache = class {
+var LRUCache = class extends BaseContainer {
   // Maximum key length.
   constructor(maxSize, maxKeyLength = Infinity) {
+    super();
     __publicField(this, "cache");
     // Stores the actual key-value pairs
     __publicField(this, "next");
@@ -2128,11 +2091,31 @@ var LRUCache = class {
     }
     this.tail = key;
   }
+  *keys() {
+    for (let key = this.head; key != null; key = this.next[key])
+      yield key;
+  }
+  *values() {
+    for (let key = this.head; key != null; key = this.next[key])
+      yield this.cache[key];
+  }
+  *entries() {
+    for (let key = this.head; key != null; key = this.next[key])
+      yield [key, this.cache[key]];
+  }
+  *[Symbol.iterator]() {
+    yield* this.entries();
+  }
+  toString() {
+    const entries = [...this.entries()];
+    return entries.length === 0 ? `LRUCache(0){ }` : `LRUCache(${entries.length}){ ${entries.map((e) => `${stringify(e[0])}: ${stringify(e[1])}`).join(", ")} }`;
+  }
 };
 
 // src/core/index-array.ts
-var IndexArray = class _IndexArray {
+var IndexArray = class _IndexArray extends BaseContainer {
   constructor(entries) {
+    super();
     __publicField(this, "posVal");
     __publicField(this, "hasPos");
     // Number of values
@@ -2345,14 +2328,20 @@ var IndexArray = class _IndexArray {
     return this.valuesArray();
   }
   toString() {
-    const entries = this.entriesArray().map(([id, v]) => `${formatValue(id)}: ${formatValue(v)}`).join(", ");
-    return `IndexArray[ ${entries} ]`.replaceAll("  ", " ");
+    let isRegularArray = true;
+    for (let i = 0; i < this.hasPos.length && isRegularArray; i++)
+      if (!this.hasPos[i]) isRegularArray = false;
+    if (isRegularArray)
+      return stringify(this.posVal.slice(0, this.hasPos.length));
+    const entries = this.entriesArray().map(([id, v]) => `${stringify(id)}: ${stringify(v)}`).join(", ");
+    return entries.length === 0 ? `[ ]` : `[ ${entries} ]`;
   }
 };
 
 // src/core/signed-index-array.ts
-var SignedIndexArray = class _SignedIndexArray {
+var SignedIndexArray = class _SignedIndexArray extends BaseContainer {
   constructor(entries) {
+    super();
     // For indexes >= 0
     __publicField(this, "posVal");
     __publicField(this, "hasPos");
@@ -2608,65 +2597,101 @@ var SignedIndexArray = class _SignedIndexArray {
     return this.valuesArray();
   }
   toString() {
-    const entries = this.entriesArray().map(([id, v]) => `${formatValue(id)}: ${formatValue(v)}`).join(", ");
-    return `SignedIndexArray[ ${entries} ]`.replaceAll("  ", " ");
+    let isRegularArray = this.hasNeg.length === 0;
+    for (let i = 0; i < this.hasPos.length && isRegularArray; i++)
+      if (!this.hasPos[i]) isRegularArray = false;
+    if (isRegularArray)
+      return stringify(this.posVal.slice(0, this.hasPos.length));
+    const entries = this.entriesArray().map(([id, v]) => `${stringify(id)}: ${stringify(v)}`).join(", ");
+    return entries.length === 0 ? `[ ]` : `[ ${entries} ]`;
   }
 };
 
-// src/core/map1.ts
-var Map1 = class _Map1 {
-  constructor(entries) {
-    __publicField(this, "map1");
-    this.map1 = entries instanceof _Map1 ? new Map(entries.map1) : new Map(entries);
+// src/core/default-array.ts
+var DefaultArray = class _DefaultArray extends BaseContainer {
+  constructor(...args) {
+    super();
+    __publicField(this, "defaultValue");
+    __publicField(this, "data");
+    this.defaultValue = args.pop();
+    if (typeof args[0] === "number") {
+      this.data = Array(args[0]).fill(this.defaultValue);
+    } else {
+      this.data = Array.from(args[0]).map(
+        (v) => v === void 0 ? this.defaultValue : v
+      );
+    }
   }
-  has(key1) {
-    return this.map1.has(key1);
+  get size() {
+    return this.data.length;
   }
-  set(key1, value) {
-    this.map1.set(key1, value);
-    return value;
+  get length() {
+    return this.data.length;
   }
-  get(key1) {
-    return this.map1.get(key1);
+  assertId(id) {
+    if (id < 0 || id >= this.data.length)
+      throw new RangeError(`DefaultArray: Index ${id} out of range`);
+    return id;
   }
-  getOrDefault(key1, defaultValue) {
-    return this.get(key1) ?? defaultValue;
+  isEmpty() {
+    return this.size === 0;
   }
-  getOrCreate(key1, creatorOrValue) {
-    if (!this.has(key1)) {
+  isDefault(id) {
+    return this.data[this.assertId(id)] === this.defaultValue;
+  }
+  isSet(id) {
+    return this.data[this.assertId(id)] !== this.defaultValue;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  has(id) {
+    return this.isSet(id);
+  }
+  set(id, value) {
+    return this.data[this.assertId(id)] = value;
+  }
+  get(id) {
+    return this.data[this.assertId(id)];
+  }
+  getOrDefault(id, defaultValue) {
+    let value = this.get(id);
+    return value === this.defaultValue ? defaultValue : value;
+  }
+  getOrCreate(id, creatorOrValue) {
+    if (!this.has(id)) {
       const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
-      this.set(key1, value);
+      this.set(id, value);
       return value;
     }
-    return this.get(key1);
-  }
-  delete(key1) {
-    return this.map1.delete(key1);
-  }
-  clear() {
-    this.map1.clear();
+    return this.get(id);
   }
-  get size() {
-    return this.map1.size;
+  delete(id) {
+    this.assertId(id);
+    if (this.data[id] === this.defaultValue) return false;
+    this.data[id] = this.defaultValue;
+    return true;
   }
-  isEmpty() {
-    return this.size === 0;
+  clear(empty = false) {
+    if (empty)
+      this.data = [];
+    else
+      this.data.fill(this.defaultValue);
   }
   forEach(callbackfn, thisArg) {
-    this.map1.forEach((value, key1) => callbackfn.call(thisArg, value, key1, this));
+    for (const [id, value] of this.entries()) {
+      callbackfn.call(thisArg, value, id, this);
+    }
   }
-  *keys() {
-    yield* this.map1.keys();
+  *indices() {
+    yield* this.data.keys();
   }
   *values() {
-    yield* this.map1.values();
+    yield* this.data.values();
   }
   *entries() {
-    for (const [key1, value] of this.map1)
-      yield [key1, value];
+    yield* this.data.entries();
   }
-  keysArray() {
-    return [...this.keys()];
+  indicesArray() {
+    return [...this.indices()];
   }
   valuesArray() {
     return [...this.values()];
@@ -2675,52 +2700,58 @@ var Map1 = class _Map1 {
     return [...this.entries()];
   }
   *kvKeys() {
-    for (const key of this.keys()) {
-      yield [key];
+    for (const id of this.indices()) {
+      yield [id];
     }
   }
   *kvValues() {
-    for (const el of this.values()) {
-      yield el;
+    for (const value of this.values()) {
+      yield value;
     }
   }
   *kvEntries() {
-    for (const [key, el] of this.entries()) {
-      yield [[key], el];
+    for (const [id, value] of this.entries()) {
+      yield [[id], value];
     }
   }
   *[Symbol.iterator]() {
     yield* this.entries();
   }
   clone() {
-    return new _Map1(this);
+    const ctor = this.constructor;
+    return new ctor(this.values(), this.defaultValue);
   }
   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);
-      }
+    if (this.constructor !== other.constructor)
+      throw new Error(`Cannot merge DefaultArray: different classes (${this.constructor.name} vs ${other.constructor.name})`);
+    if (this.defaultValue !== other.defaultValue)
+      throw new Error(`Cannot merge DefaultArray: different defaultValue (${this.defaultValue} vs ${other.defaultValue})`);
+    for (const [id, value] of other.entries()) {
+      if (this.isDefault(id))
+        this.set(id, value);
+      else if (conflictResolver)
+        this.set(id, conflictResolver(this.get(id), value, id));
+      else
+        this.set(id, value);
     }
     return this;
   }
   some(fn) {
-    for (const [key1, value] of this.map1) {
-      if (fn(value, key1)) return true;
+    for (const [id, value] of this.entries()) {
+      if (fn(value, id)) return true;
     }
     return false;
   }
   every(fn) {
-    for (const [key1, value] of this.map1) {
-      if (!fn(value, key1)) return false;
+    for (const [id, value] of this.entries()) {
+      if (!fn(value, id)) return false;
     }
     return true;
   }
   filter(predicate) {
-    const result = new this.constructor();
-    for (const [key1, value] of this.map1) {
-      if (predicate(value, key1, this)) result.set(key1, value);
+    const result = new this.constructor(this.length, this.defaultValue);
+    for (const [id, value] of this.entries()) {
+      if (predicate(value, id, this)) result.set(id, value);
     }
     return result;
   }
@@ -2729,7 +2760,7 @@ var Map1 = class _Map1 {
     let first = iterator.next();
     if (first.done) {
       if (arguments.length < 2) {
-        throw new TypeError("Reduce of empty Map1 with no initial value!");
+        throw new TypeError("Reduce of empty DefaultArray with no initial value!");
       }
       return init;
     }
@@ -2743,58 +2774,259 @@ var Map1 = class _Map1 {
       start = first;
     }
     for (let current = start; !current.done; current = iterator.next()) {
-      const [key1, value] = current.value;
-      acc = fn(acc, value, key1);
+      const [id, value] = current.value;
+      acc = fn(acc, value, id);
     }
     return acc;
   }
-  mapEntries(fn) {
+  mapToArray(fn) {
     let result = [];
-    for (const [key1, value] of this.map1) {
-      result.push(fn(value, key1));
+    for (const [id, value] of this.entries()) {
+      result.push(fn(value, id));
     }
     return result;
   }
-  mapValues(fn) {
-    let result = new _Map1();
-    for (const [key1, value] of this.map1) {
-      result.set(key1, fn(value, key1));
+  map(fn, defaultValue) {
+    let result = new _DefaultArray(this.data.length, defaultValue);
+    for (let id = 0; id < this.data.length; id++) {
+      result.data[id] = fn(this.data[id], id);
     }
     return result;
   }
-  toMap() {
-    return new Map(this.map1);
+  equals(other, eq2) {
+    if (this.size !== other.size) return false;
+    eq2 ?? (eq2 = (a, b) => a === b);
+    for (let id = 0; id < this.data.length; ++id) {
+      if (!eq2(this.data[id], other.data[id])) return false;
+    }
+    return true;
+  }
+  toArray() {
+    return this.valuesArray();
   }
   toString() {
-    const entries = [...this.map1].map(([k, v]) => `${formatValue(k)} => ${formatValue(v)}`).join(", ");
-    return `Map1(${this.size}){ ${entries} }`.replaceAll("  ", " ");
+    return stringify(this.data);
   }
 };
 
-// src/core/map2.ts
-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);
-      }
-    }
+// src/core/uni-map.ts
+var UniMap = class _UniMap extends BaseContainer {
+  constructor(...args) {
+    super();
+    __publicField(this, "map");
+    __publicField(this, "keyEquals");
+    const maybeEquals = args.at(-1);
+    this.keyEquals = isFunction2(maybeEquals) ? args.pop() : DefaultEqualityFn;
+    const entries = args[0];
+    this.map = new Map(entries);
   }
-  has(key1, key2) {
-    return this.map1.get(key1)?.has(key2) ?? false;
+  static createDeep(arg) {
+    return arg ? new _UniMap(arg, isDeepEqual2) : new _UniMap(isDeepEqual2);
   }
-  set(key1, key2, value) {
-    let map2 = this.map1.get(key1) ?? this.map1.set(key1, /* @__PURE__ */ new Map()).get(key1);
-    map2.set(key2, value);
-    return value;
+  has(key) {
+    if (this.keyEquals === DefaultEqualityFn || this.map.has(key))
+      return this.map.has(key);
+    for (const [k, v] of this.map)
+      if (this.keyEquals(k, key))
+        return true;
+    return false;
   }
-  get(key1, key2) {
-    return this.map1.get(key1)?.get(key2);
+  set(key, value) {
+    if (this.keyEquals === DefaultEqualityFn || this.map.has(key)) {
+      this.map.set(key, value);
+      return value;
+    }
+    for (const key2 of this.map.keys())
+      if (this.keyEquals(key2, key)) {
+        this.map.set(key2, value);
+        return value;
+      }
+    this.map.set(key, value);
+    return value;
+  }
+  get(key) {
+    if (this.keyEquals === DefaultEqualityFn || this.map.has(key))
+      return this.map.get(key);
+    for (const [k, v] of this.map)
+      if (this.keyEquals(k, key))
+        return v;
+    return void 0;
+  }
+  delete(key) {
+    if (this.keyEquals === DefaultEqualityFn || this.map.has(key))
+      return this.map.delete(key);
+    for (const k of this.map.keys())
+      if (this.keyEquals(k, key))
+        return this.map.delete(k);
+    return this.map.delete(key);
+  }
+  getOrDefault(key, defaultValue) {
+    return this.get(key) ?? defaultValue;
+  }
+  getOrCreate(key, creatorOrValue) {
+    if (!this.has(key)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      return this.set(key, value);
+    }
+    return this.get(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.map.forEach((value, key) => callbackfn.call(thisArg, value, key, this));
+  }
+  *keys() {
+    yield* this.map.keys();
+  }
+  *values() {
+    yield* this.map.values();
+  }
+  *entries() {
+    for (const [key, value] of this.map)
+      yield [key, value];
+  }
+  keysArray() {
+    return [...this.keys()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const key of this.keys()) {
+      yield [key];
+    }
+  }
+  *kvValues() {
+    for (const el of this.values()) {
+      yield el;
+    }
+  }
+  *kvEntries() {
+    for (const [key, el] of this.entries()) {
+      yield [[key], el];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.entries();
+  }
+  clone() {
+    return new _UniMap(this, this.keyEquals);
+  }
+  merge(other, conflictResolver) {
+    for (const [key, value] of other.entries()) {
+      if (this.has(key) && conflictResolver) {
+        this.set(key, conflictResolver(this.get(key), value, key));
+      } else {
+        this.set(key, value);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [key, value] of this.map) {
+      if (fn(value, key)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [key, value] of this.map) {
+      if (!fn(value, key)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = new this.constructor();
+    for (const [key, value] of this.map) {
+      if (predicate(value, key, this)) result.set(key, value);
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty Map1 with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[1];
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [key, value] = current.value;
+      acc = fn(acc, value, key);
+    }
+    return acc;
+  }
+  mapEntries(fn) {
+    let result = [];
+    for (const [key, value] of this.map) {
+      result.push(fn(value, key));
+    }
+    return result;
+  }
+  mapValues(fn) {
+    let result = new _UniMap();
+    for (const [key, value] of this.map) {
+      result.set(key, fn(value, key));
+    }
+    return result;
+  }
+  toMap() {
+    return new Map(this.map);
+  }
+  toString() {
+    const entries = [...this.map].map(([k, v]) => `${stringify(k)} => ${stringify(v)}`).join(", ");
+    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries} }`;
+  }
+};
+
+// src/core/bi-map.ts
+var BiMap = class _BiMap extends BaseContainer {
+  constructor(entries) {
+    super();
+    __publicField(this, "map1");
+    __publicField(this, "key1Equals", DefaultEqualityFn);
+    __publicField(this, "key2Equals", DefaultEqualityFn);
+    this.map1 = new UniMap(this.key1Equals);
+    if (entries instanceof _BiMap) {
+      for (const [key1, map2] of entries.map1) {
+        const newMap2 = this.map1.set(key1, new UniMap(this.key2Equals));
+        for (const [key2, value] of map2) {
+          newMap2.set(key2, value);
+        }
+      }
+    } 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) {
+    return this.map1.getOrCreate(key1, () => new UniMap(this.key2Equals)).set(key2, value);
+  }
+  get(key1, key2) {
+    return this.map1.get(key1)?.get(key2);
   }
   getOrDefault(key1, key2, defaultValue) {
     return this.get(key1, key2) ?? defaultValue;
@@ -2869,7 +3101,7 @@ var Map2 = class _Map2 {
     yield* this.entries();
   }
   clone() {
-    return new _Map2(this);
+    return new _BiMap(this);
   }
   merge(other, conflictResolver) {
     for (const [key1, key2, value] of other.entries()) {
@@ -2940,7 +3172,7 @@ var Map2 = class _Map2 {
     return result;
   }
   mapValues(fn) {
-    let result = new _Map2();
+    let result = new _BiMap();
     for (const [key1, map2] of this.map1) {
       for (const [key2, value] of map2) {
         result.set(key1, key2, fn(value, key1, key2));
@@ -2960,24 +3192,28 @@ var Map2 = class _Map2 {
   toString() {
     const entries = [];
     for (const [key1, map2] of this.map1) {
-      const inner = [...map2].map(([key2, v]) => `${formatValue(key2)} => ${formatValue(v)}`).join(", ");
-      entries.push(`${formatValue(key1)} => { ${inner} }`);
+      const inner = [...map2].map(([key2, v]) => `${stringify(key2)} => ${stringify(v)}`).join(", ");
+      entries.push(`${stringify(key1)} => { ${inner} }`);
     }
-    return `Map2(${this.size}){ ${entries} }`.replaceAll("  ", " ");
+    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries} }`;
   }
 };
 
-// src/core/map3.ts
-var Map3 = class _Map3 {
+// src/core/tri-map.ts
+var TriMap = class _TriMap extends BaseContainer {
   constructor(entries) {
-    __publicField(this, "map1", /* @__PURE__ */ new Map());
-    if (entries instanceof _Map3) {
+    super();
+    __publicField(this, "map1");
+    __publicField(this, "key1Equals", DefaultEqualityFn);
+    __publicField(this, "key2Equals", DefaultEqualityFn);
+    __publicField(this, "key3Equals", DefaultEqualityFn);
+    this.map1 = new UniMap(this.key1Equals);
+    if (entries instanceof _TriMap) {
       for (const [key1, map2] of entries.map1) {
-        const newMap2 = /* @__PURE__ */ new Map();
+        const newMap2 = this.map1.set(key1, new UniMap(this.key2Equals));
         for (const [key2, map3] of map2) {
-          newMap2.set(key2, new Map(map3));
+          newMap2.set(key2, new UniMap(map3, this.key3Equals));
         }
-        this.map1.set(key1, newMap2);
       }
     } else if (entries) {
       for (const [key1, key2, key3, value] of entries) {
@@ -2989,10 +3225,8 @@ var Map3 = class _Map3 {
     return this.map1.get(key1)?.get(key2)?.has(key3) ?? false;
   }
   set(key1, key2, key3, value) {
-    let map2 = this.map1.get(key1);
-    if (!map2) this.map1.set(key1, map2 = /* @__PURE__ */ new Map());
-    let map3 = map2.get(key2);
-    if (!map3) map2.set(key2, map3 = /* @__PURE__ */ new Map());
+    let map2 = this.map1.getOrCreate(key1, () => new UniMap(this.key2Equals));
+    let map3 = map2.getOrCreate(key2, () => new UniMap(this.key3Equals));
     map3.set(key3, value);
     return value;
   }
@@ -3084,7 +3318,7 @@ var Map3 = class _Map3 {
     yield* this.entries();
   }
   clone() {
-    return new _Map3(this);
+    return new _TriMap(this);
   }
   merge(other, conflictResolver) {
     for (const [key1, key2, key3, value] of other.entries()) {
@@ -3163,7 +3397,7 @@ var Map3 = class _Map3 {
     return result;
   }
   mapValues(fn) {
-    let result = new _Map3();
+    let result = new _TriMap();
     for (const [key1, map2] of this.map1) {
       for (const [key2, map3] of map2) {
         for (const [key3, value] of map3) {
@@ -3188,17 +3422,199 @@ var Map3 = class _Map3 {
     const entries = [];
     for (const [key1, map2] of this.map1) {
       for (const [key2, map3] of map2) {
-        const inner = [...map3].map(([key3, v]) => `${formatValue(key3)} => ${formatValue(v)}`).join(", ");
-        entries.push(`${formatValue(key1)} => ${formatValue(key2)} => { ${inner} }`);
+        const inner = [...map3].map(([key3, v]) => `${stringify(key3)} => ${stringify(v)}`).join(", ");
+        entries.push(`${stringify(key1)} => ${stringify(key2)} => { ${inner} }`);
+      }
+    }
+    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries.join(", ")} }`;
+  }
+};
+
+// src/core/set.ts
+var ValueSet = class _ValueSet extends BaseContainer {
+  constructor(...args) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "equals");
+    const maybeEquals = args.at(-1);
+    this.equals = isFunction2(maybeEquals) ? args.pop() : DefaultEqualityFn;
+    const entries = args[0];
+    this.data = new Set(entries);
+  }
+  static createDeep(arg) {
+    return arg ? new _ValueSet(arg, isDeepEqual2) : new _ValueSet(isDeepEqual2);
+  }
+  has(value) {
+    if (this.equals === DefaultEqualityFn)
+      return this.data.has(value);
+    return this.some((v) => this.equals(v, value));
+  }
+  add(value) {
+    if (!this.has(value))
+      this.data.add(value);
+    return value;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  set(key, value) {
+    if (!this.equals(key, value))
+      throw new TypeError("ValueSet.set() requires key === value.");
+    this.add(value);
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  get(key) {
+    return this.has(key) ? key : void 0;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  getOrDefault(key, defaultValue) {
+    return this.get(key) ?? defaultValue;
+  }
+  getOrCreate(key, creatorOrValue) {
+    if (!this.has(key)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key, value);
+      return value;
+    }
+    return this.get(key);
+  }
+  delete(value) {
+    if (this.equals === DefaultEqualityFn || this.data.has(value))
+      return this.data.delete(value);
+    for (const v of this.values()) {
+      if (this.equals(v, value)) {
+        this.data.delete(v);
+        return true;
+      }
+    }
+    return false;
+  }
+  clear() {
+    this.data.clear();
+  }
+  get size() {
+    return this.data.size;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.data.forEach((value) => callbackfn.call(thisArg, value, this));
+  }
+  *keys() {
+    yield* this.data.keys();
+  }
+  *values() {
+    yield* this.data.values();
+  }
+  *entries() {
+    yield* this.data.entries();
+  }
+  *kvKeys() {
+    for (const key of this.keys()) {
+      yield [key];
+    }
+  }
+  *kvValues() {
+    for (const el of this.values()) {
+      yield el;
+    }
+  }
+  *kvEntries() {
+    for (const [key, el] of this.entries()) {
+      yield [[key], el];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.values();
+  }
+  clone() {
+    const result = new _ValueSet();
+    for (const v of this.values()) result.add(v);
+    return result;
+  }
+  merge(other) {
+    for (const value of other.values()) {
+      this.add(value);
+    }
+    return this;
+  }
+  some(fn) {
+    for (const value of this.data) {
+      if (fn(value)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const value of this.data) {
+      if (!fn(value)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = new _ValueSet();
+    for (const value of this.data)
+      if (predicate(value, this)) result.add(value);
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.values();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty ValueSet with no initial value!");
       }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value;
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const value = current.value;
+      acc = fn(acc, value);
+    }
+    return acc;
+  }
+  mapValues(fn) {
+    let result = new _ValueSet();
+    for (const value of this.data) {
+      result.add(fn(value));
+    }
+    return result;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const value of this.values()) {
+      result.push(fn(value));
     }
-    return `Map3(${this.size}){ ${entries.join(", ")} }`.replaceAll("  ", " ");
+    return result;
+  }
+  map(fn) {
+    let result = new _ValueSet();
+    for (const value of this.values()) {
+      result.add(fn(value));
+    }
+    return result;
+  }
+  toSet() {
+    return new Set(this.data);
+  }
+  toArray() {
+    return [...this.values()];
+  }
+  toString() {
+    return stringify(this.data);
   }
 };
 
 // src/core/multi-container.ts
-var MultiContainer = class {
+var MultiContainer = class extends BaseContainer {
   constructor(base) {
+    super();
     this.base = base;
   }
   isEmpty() {
@@ -3254,21 +3670,386 @@ var MultiContainer = class {
     const entries = [];
     for (const keys of this.keys()) {
       const arr = this.getAll(...keys);
-      const keyStr = Array.isArray(keys) ? formatValue(keys) : "[ ]";
-      const valuesStr = Array.isArray(arr) ? formatValue(arr) : "[ ]";
+      const keyStr = Array.isArray(keys) ? stringify(keys) : "[ ]";
+      const valuesStr = Array.isArray(arr) ? stringify(arr) : "[ ]";
       entries.push(`${keyStr} => ${valuesStr}`);
     }
-    return `MultiContainer{ ${entries.join(", ")} }`.replaceAll("  ", " ");
+    return entries.length === 0 ? `MultiContainer{ }` : `MultiContainer{ ${entries.join(", ")} }`;
   }
 };
 function asMulti(base) {
   return new MultiContainer(base);
 }
 
-// src/deprecated/vec2.ts
-var Vec2 = class _Vec2 {
-  constructor(x, y) {
-    __publicField(this, "x");
+// src/core/linked-list.ts
+var LinkedListNode = class {
+  constructor(value) {
+    this.value = value;
+    __publicField(this, "next", null);
+    __publicField(this, "prev", null);
+  }
+};
+var LinkedList = class _LinkedList extends BaseContainer {
+  constructor(...args) {
+    super();
+    __publicField(this, "_head", null);
+    __publicField(this, "_tail", null);
+    __publicField(this, "_size", 0);
+    __publicField(this, "equals");
+    const maybeEquals = args.at(-1);
+    this.equals = isFunction2(maybeEquals) ? args.pop() : DefaultEqualityFn;
+    const entries = args[0];
+    if (entries) {
+      for (const v of entries) {
+        this.push(v);
+      }
+    }
+  }
+  static createDeep(entries) {
+    if (entries) {
+      return new _LinkedList(entries, isDeepEqual2);
+    } else {
+      return new _LinkedList(isDeepEqual2);
+    }
+  }
+  get length() {
+    return this._size;
+  }
+  get first() {
+    return this._head?.value;
+  }
+  get last() {
+    return this._tail?.value;
+  }
+  /** Add item to the end of the list */
+  push(value) {
+    const node = new LinkedListNode(value);
+    if (!this._tail) {
+      this._head = this._tail = node;
+    } else {
+      node.prev = this._tail;
+      this._tail.next = node;
+      this._tail = node;
+    }
+    this._size++;
+  }
+  /** Remove item from the end of the list */
+  pop() {
+    if (!this._tail) return void 0;
+    const value = this._tail.value;
+    this._tail = this._tail.prev;
+    if (this._tail) this._tail.next = null;
+    else this._head = null;
+    this._size--;
+    return value;
+  }
+  /** Add item to the beginning of the list */
+  unshift(value) {
+    const node = new LinkedListNode(value);
+    if (!this._head) {
+      this._head = this._tail = node;
+    } else {
+      node.next = this._head;
+      this._head.prev = node;
+      this._head = node;
+    }
+    this._size++;
+  }
+  /** Remove item from the beginning of the list */
+  shift() {
+    if (!this._head) return void 0;
+    const value = this._head.value;
+    this._head = this._head.next;
+    if (this._head) this._head.prev = null;
+    else this._tail = null;
+    this._size--;
+    return value;
+  }
+  /** Check if value exists in the list */
+  has(value) {
+    for (let node = this._head; node; node = node.next) {
+      if (this.equals(node.value, value)) return true;
+    }
+    return false;
+  }
+  /** Get value at index (O(n/2)) */
+  get(index) {
+    return this.nodeAt(index)?.value;
+  }
+  /** Set value at index (O(n/2)) */
+  set(index, value) {
+    const node = this.nodeAt(index);
+    if (!node) return false;
+    node.value = value;
+    return true;
+  }
+  /** Insert value at index (O(n/2)) */
+  insertAt(index, value) {
+    if (index < 0 || index > this._size) return false;
+    if (index === 0) {
+      this.unshift(value);
+      return true;
+    }
+    if (index === this._size) {
+      this.push(value);
+      return true;
+    }
+    const nextNode = this.nodeAt(index);
+    if (!nextNode) return false;
+    const prevNode = nextNode.prev;
+    const newNode = new LinkedListNode(value);
+    newNode.next = nextNode;
+    newNode.prev = prevNode;
+    if (prevNode) prevNode.next = newNode;
+    nextNode.prev = newNode;
+    this._size++;
+    return true;
+  }
+  /** Remove value at index (O(n/2)) */
+  removeAt(index) {
+    const node = this.nodeAt(index);
+    if (!node) return void 0;
+    if (node.prev) node.prev.next = node.next;
+    else this._head = node.next;
+    if (node.next) node.next.prev = node.prev;
+    else this._tail = node.prev;
+    this._size--;
+    return node.value;
+  }
+  /** Remove first matching value (O(n)) */
+  remove(value) {
+    for (let node = this._head; node; node = node.next) {
+      if (this.equals(node.value, value)) {
+        if (node.prev) node.prev.next = node.next;
+        else this._head = node.next;
+        if (node.next) node.next.prev = node.prev;
+        else this._tail = node.prev;
+        this._size--;
+        return true;
+      }
+    }
+    return false;
+  }
+  /** Convert to array */
+  toArray() {
+    const result = [];
+    for (const v of this) result.push(v);
+    return result;
+  }
+  /** Replace contents from array */
+  fromArray(values) {
+    this.clear();
+    for (const v of values) this.push(v);
+  }
+  /** Clear all nodes */
+  clear() {
+    this._head = this._tail = null;
+    this._size = 0;
+  }
+  /** Iterator support */
+  *[Symbol.iterator]() {
+    yield* this.values();
+  }
+  *keys() {
+    for (let id = 0; id < this._size; id++)
+      yield id;
+  }
+  *values() {
+    let node = this._head;
+    while (node) {
+      yield node.value;
+      node = node.next;
+    }
+  }
+  *entries() {
+    let node = this._head;
+    let id = 0;
+    while (node) {
+      yield [id++, node.value];
+      node = node.next;
+    }
+  }
+  toString() {
+    return this._size === 0 ? `LinkedList(0)[ ]` : `LinkedList(${this._size})[ ${this.toArray().join(", ")} ]`;
+  }
+  // ---- Private helpers ----
+  nodeAt(index) {
+    if (index < 0 || index >= this._size) return null;
+    let node;
+    if (index < this._size / 2) {
+      node = this._head;
+      for (let i = 0; i < index; i++) node = node.next;
+    } else {
+      node = this._tail;
+      for (let i = this._size - 1; i > index; i--) node = node.prev;
+    }
+    return node;
+  }
+  clone() {
+    return new _LinkedList(this);
+  }
+};
+
+// src/utils/str/index.ts
+function toCharArray(str2) {
+  return str2.split("");
+}
+function repeatString(repeatString2, repeatCount) {
+  if (!isInteger2(repeatCount) || repeatCount < 0) {
+    throw new Error("repeatStr: Invalid repeatCount = " + repeatCount);
+  }
+  return new Array(repeatCount + 1).join(repeatString2);
+}
+function chunkString(str2, chunkSize) {
+  if (!isInteger2(chunkSize) || chunkSize < 1) {
+    throw new Error("chunckString: Invalid chuckSize = " + chunkSize);
+  }
+  let result = [];
+  for (let i = 0; i < str2.length; i += chunkSize) {
+    result.push(str2.slice(i, i + chunkSize));
+  }
+  return result;
+}
+function replaceAt(str2, pos, removeCount, insert) {
+  if (!isInteger2(removeCount) || removeCount < 0) {
+    throw new Error("replaceAt: Invalid removeCount = " + removeCount);
+  } else if (!isInteger2(pos) || pos < 0 || pos + removeCount > str2.length) {
+    throw new Error("replaceAt: Invalid pos = " + pos + ", removeCount = " + removeCount + ", str.length = " + str2.length);
+  } else {
+    return str2.substring(0, pos) + insert + str2.substring(pos + removeCount);
+  }
+}
+function insertAt(str2, pos, insertStr) {
+  return replaceAt(str2, pos, 0, insertStr);
+}
+function removeAt(str2, pos, removeCount) {
+  return replaceAt(str2, pos, removeCount, "");
+}
+function charCount(str2, ch) {
+  if (ch.length !== 1 || str2.length === 0) return 0;
+  let count = 0;
+  for (let i = 0; i < str2.length; i++) {
+    if (str2[i] === ch) count++;
+  }
+  return count;
+}
+function makeSentenceFromPascal(PascalString) {
+  if (PascalString === "") {
+    return "";
+  }
+  let word = PascalString.charAt(0);
+  let sentence = "";
+  const addWord = () => {
+    if (word !== "") {
+      if (sentence === "") {
+        sentence += word.charAt(0).toUpperCase() + word.substring(1);
+      } else {
+        sentence += " " + word;
+      }
+      word = "";
+    }
+  };
+  const isLetterAndCapital = (c) => {
+    return c.toUpperCase() !== c.toLowerCase() && c === c.toUpperCase();
+  };
+  for (let i = 1; i < PascalString.length; i++) {
+    let c = PascalString.charAt(i);
+    if (isLetterAndCapital(c)) {
+      addWord();
+    }
+    word += c.toLowerCase();
+  }
+  addWord();
+  return sentence;
+}
+function stringify(value, maxDepth = 5, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const t = typeof value;
+  switch (t) {
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+      if (isNaNValue2(value)) return "NaN";
+      if (!isFinite3(value))
+        return value < 0 ? "-Infinity" : "Infinity";
+      return value.toString();
+    case "bigint":
+      return `${value}n`;
+    case "string":
+      return `"${value}"`;
+    case "symbol":
+      return value.description ? `Symbol(${value.description})` : "Symbol()";
+    case "function":
+      return `[Function${value.name ? ` ${value.name}` : ""}]`;
+  }
+  if (seen.has(value))
+    return "[Circular]";
+  if (maxDepth <= 0)
+    return "[Depth limit]";
+  maxDepth--;
+  seen.add(value);
+  const strfy = (v) => stringify(v, maxDepth, seen);
+  if (isArray2(value)) {
+    const inner = value.map((v) => strfy(v)).join(", ");
+    return inner.length === 0 ? "[ ]" : `[ ${inner} ]`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    if (value instanceof DataView)
+      return `DataView(${value.byteLength})`;
+    const inner = Array.from(value).map((v) => strfy(v)).join(", ");
+    return `${value.constructor.name}[ ${inner} ]`;
+  }
+  if (value instanceof ArrayBuffer)
+    return `ArrayBuffer(${value.byteLength})`;
+  if (value instanceof Map) {
+    const entries = Array.from(value.entries()).map(([k, v]) => `${strfy(k)} => ${strfy(v)}`).join(", ");
+    return entries.length === 0 ? `Map(${value.size}){ }` : `Map(${value.size}){ ${entries} }`;
+  }
+  if (value instanceof Set) {
+    const entries = Array.from(value.values()).map((v) => strfy(v)).join(", ");
+    return entries.length === 0 ? `Set(${value.size}){ }` : `Set(${value.size}){ ${entries} }`;
+  }
+  if (value instanceof WeakMap)
+    return "WeakMap{ ? }";
+  if (value instanceof WeakSet)
+    return "WeakSet{ ? }";
+  if (typeof BaseContainer !== "undefined" && value instanceof BaseContainer)
+    return value.toString();
+  if (value instanceof Date)
+    return `Date("${value.toISOString()}")`;
+  if (value instanceof RegExp)
+    return value.toString();
+  if (value instanceof Error)
+    return `${value.name}("${value.message}")`;
+  if (value instanceof Promise)
+    return "Promise{ ? }";
+  if (value instanceof URL)
+    return `URL("${value.href}")`;
+  if (value instanceof URLSearchParams)
+    return `URLSearchParams("${value.toString()}")`;
+  if (value === Math) return "Math";
+  if (value === JSON) return "JSON";
+  if (value === Reflect) return "Reflect";
+  if (value === Intl) return "Intl";
+  if (t === "object") {
+    const ctorName = value.constructor?.name ?? "Object";
+    const entries = Object.entries(value).map(
+      ([key, val]) => `${strfy(key)}: ${strfy(val)}`
+    );
+    if (entries.length === 0) return `${ctorName}{ }`;
+    return `${ctorName}{ ${entries.join(", ")} }`;
+  }
+  return String(value);
+}
+
+// src/utils/index.ts
+var Is = guard_exports;
+
+// src/deprecated/vec2.ts
+var Vec2 = class _Vec2 {
+  constructor(x, y) {
+    __publicField(this, "x");
     __publicField(this, "y");
     this.x = x ?? 0;
     this.y = y ?? 0;
@@ -3341,23 +4122,813 @@ var SmallIntCache = class {
     this.neg = [];
   }
 };
+
+// src/deprecated/map1.ts
+var Map1 = class _Map1 extends BaseContainer {
+  constructor(entries) {
+    super();
+    __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);
+    return value;
+  }
+  get(key1) {
+    return this.map1.get(key1);
+  }
+  getOrDefault(key1, defaultValue) {
+    return this.get(key1) ?? defaultValue;
+  }
+  getOrCreate(key1, creatorOrValue) {
+    if (!this.has(key1)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key1, value);
+      return value;
+    }
+    return this.get(key1);
+  }
+  delete(key1) {
+    return this.map1.delete(key1);
+  }
+  clear() {
+    this.map1.clear();
+  }
+  get size() {
+    return this.map1.size;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.map1.forEach((value, key1) => callbackfn.call(thisArg, value, key1, this));
+  }
+  *keys() {
+    yield* this.map1.keys();
+  }
+  *values() {
+    yield* this.map1.values();
+  }
+  *entries() {
+    for (const [key1, value] of this.map1)
+      yield [key1, value];
+  }
+  keysArray() {
+    return [...this.keys()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const key of this.keys()) {
+      yield [key];
+    }
+  }
+  *kvValues() {
+    for (const el of this.values()) {
+      yield el;
+    }
+  }
+  *kvEntries() {
+    for (const [key, el] of this.entries()) {
+      yield [[key], el];
+    }
+  }
+  *[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(predicate) {
+    const result = new this.constructor();
+    for (const [key1, value] of this.map1) {
+      if (predicate(value, key1, this)) result.set(key1, value);
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty Map1 with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[1];
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [key1, value] = current.value;
+      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]) => `${stringify(k)} => ${stringify(v)}`).join(", ");
+    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries} }`;
+  }
+};
+
+// src/deprecated/map2.ts
+var Map2 = class _Map2 extends BaseContainer {
+  constructor(entries) {
+    super();
+    __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);
+    map2.set(key2, value);
+    return value;
+  }
+  get(key1, key2) {
+    return this.map1.get(key1)?.get(key2);
+  }
+  getOrDefault(key1, key2, defaultValue) {
+    return this.get(key1, key2) ?? defaultValue;
+  }
+  getOrCreate(key1, key2, creatorOrValue) {
+    if (!this.has(key1, key2)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key1, key2, value);
+      return value;
+    }
+    return this.get(key1, key2);
+  }
+  delete(key1, key2) {
+    if (key2 === void 0) return this.map1.delete(key1);
+    const map2 = this.map1.get(key1);
+    if (!map2) return false;
+    return map2.delete(key2);
+  }
+  clear() {
+    this.map1.clear();
+  }
+  get size() {
+    let count = 0;
+    for (const map2 of this.map1.values()) {
+      count += map2.size;
+    }
+    return count;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.map1.forEach((map2, key1) => map2.forEach((value, key2) => callbackfn.call(thisArg, value, key1, key2, this)));
+  }
+  *keys() {
+    for (const [key1, map2] of this.map1)
+      for (const key2 of map2.keys())
+        yield [key1, key2];
+  }
+  *values() {
+    for (const map2 of this.map1.values())
+      for (const value of map2.values())
+        yield value;
+  }
+  *entries() {
+    for (const [key1, map2] of this.map1)
+      for (const [key2, value] of map2)
+        yield [key1, key2, value];
+  }
+  keysArray() {
+    return [...this.keys()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const [key1, key2] of this.keys())
+      yield [key1, key2];
+  }
+  *kvValues() {
+    for (const el of this.values())
+      yield el;
+  }
+  *kvEntries() {
+    for (const [key1, key2, el] of this.entries())
+      yield [[key1, key2], el];
+  }
+  *[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(predicate) {
+    const result = new this.constructor();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, value] of map2) {
+        if (predicate(value, key1, key2, this)) result.set(key1, key2, value);
+      }
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty Map2 with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[2];
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [key1, key2, value] = current.value;
+      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]) => `${stringify(key2)} => ${stringify(v)}`).join(", ");
+      entries.push(`${stringify(key1)} => { ${inner} }`);
+    }
+    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries} }`;
+  }
+};
+
+// src/deprecated/map3.ts
+var Map3 = class _Map3 extends BaseContainer {
+  constructor(entries) {
+    super();
+    __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);
+    if (!map2) this.map1.set(key1, map2 = /* @__PURE__ */ new Map());
+    let map3 = map2.get(key2);
+    if (!map3) map2.set(key2, map3 = /* @__PURE__ */ new Map());
+    map3.set(key3, value);
+    return value;
+  }
+  get(key1, key2, key3) {
+    return this.map1.get(key1)?.get(key2)?.get(key3);
+  }
+  getOrDefault(key1, key2, key3, defaultValue) {
+    return this.get(key1, key2, key3) ?? defaultValue;
+  }
+  getOrCreate(key1, key2, key3, creatorOrValue) {
+    if (!this.has(key1, key2, key3)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key1, key2, key3, value);
+      return value;
+    }
+    return this.get(key1, key2, key3);
+  }
+  delete(key1, key2, key3) {
+    if (key3 === void 0) {
+      if (key2 === void 0) return this.map1.delete(key1);
+      const map2 = this.map1.get(key1);
+      if (!map2) return false;
+      return map2.delete(key2);
+    } else {
+      if (key2 === void 0) return this.map1.delete(key1);
+      const map3 = this.map1.get(key1)?.get(key2);
+      if (!map3) return false;
+      return map3.delete(key3);
+    }
+  }
+  clear() {
+    this.map1.clear();
+  }
+  get size() {
+    let count = 0;
+    for (const map2 of this.map1.values()) {
+      for (const map3 of map2.values()) {
+        count += map3.size;
+      }
+    }
+    return count;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.map1.forEach((map2, key1) => map2.forEach((map3, key2) => map3.forEach((value, key3) => callbackfn.call(thisArg, value, key1, key2, key3, this))));
+  }
+  *keys() {
+    for (const [key1, map2] of this.map1)
+      for (const [key2, map3] of map2)
+        for (const key3 of map3.keys())
+          yield [key1, key2, key3];
+  }
+  *values() {
+    for (const map2 of this.map1.values())
+      for (const map3 of map2.values())
+        for (const value of map3.values())
+          yield value;
+  }
+  *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];
+  }
+  keysArray() {
+    return [...this.keys()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const [key1, key2, key3] of this.keys())
+      yield [key1, key2, key3];
+  }
+  *kvValues() {
+    for (const el of this.values())
+      yield el;
+  }
+  *kvEntries() {
+    for (const [key1, key2, key3, el] of this.entries())
+      yield [[key1, key2, key3], el];
+  }
+  *[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(predicate) {
+    const result = new this.constructor();
+    for (const [key1, map2] of this.map1) {
+      for (const [key2, map3] of map2) {
+        for (const [key3, value] of map3) {
+          if (predicate(value, key1, key2, key3, this)) result.set(key1, key2, key3, value);
+        }
+      }
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty Map3 with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[3];
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [key1, key2, key3, value] = current.value;
+      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]) => `${stringify(key3)} => ${stringify(v)}`).join(", ");
+        entries.push(`${stringify(key1)} => ${stringify(key2)} => { ${inner} }`);
+      }
+    }
+    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries.join(", ")} }`;
+  }
+};
+
+// src/deprecated/set.ts
+var SetBase = class extends BaseContainer {
+  constructor(entries) {
+    super();
+    __publicField(this, "data");
+    this.data = new Set(entries ?? []);
+  }
+  has(value) {
+    return this.some((v) => this.valueEquals(v, value));
+  }
+  add(value) {
+    if (!this.has(value))
+      this.data.add(value);
+    return value;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  set(key, value) {
+    if (!this.valueEquals(key, value))
+      throw new TypeError("SetBase.set() requires key === value.");
+    this.add(value);
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  get(key) {
+    return this.has(key) ? key : void 0;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  getOrDefault(key, defaultValue) {
+    return this.get(key) ?? defaultValue;
+  }
+  getOrCreate(key, creatorOrValue) {
+    if (!this.has(key)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key, value);
+      return value;
+    }
+    return this.get(key);
+  }
+  delete(value) {
+    if (!this.has(value)) return false;
+    for (const v of this.values()) {
+      if (this.valueEquals(v, value)) {
+        this.data.delete(v);
+        return true;
+      }
+    }
+    return false;
+  }
+  clear() {
+    this.data.clear();
+  }
+  get size() {
+    return this.data.size;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.data.forEach((value) => callbackfn.call(thisArg, value, this));
+  }
+  *keys() {
+    yield* this.data.keys();
+  }
+  *values() {
+    yield* this.data.values();
+  }
+  *entries() {
+    yield* this.data.entries();
+  }
+  *kvKeys() {
+    for (const key of this.keys()) {
+      yield [key];
+    }
+  }
+  *kvValues() {
+    for (const el of this.values()) {
+      yield el;
+    }
+  }
+  *kvEntries() {
+    for (const [key, el] of this.entries()) {
+      yield [[key], el];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.values();
+  }
+  clone() {
+    const result = this.createEmpty();
+    for (const v of this.values()) result.add(v);
+    return result;
+  }
+  merge(other) {
+    for (const value of other.values()) {
+      this.add(value);
+    }
+    return this;
+  }
+  some(fn) {
+    for (const value of this.data) {
+      if (fn(value)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const value of this.data) {
+      if (!fn(value)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = this.createEmpty();
+    for (const value of this.data)
+      if (predicate(value, this)) result.add(value);
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.values();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty SetBase with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value;
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const value = current.value;
+      acc = fn(acc, value);
+    }
+    return acc;
+  }
+  mapValues(fn) {
+    let result = this.createEmpty();
+    for (const value of this.data) {
+      result.add(fn(value));
+    }
+    return result;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const value of this.values()) {
+      result.push(fn(value));
+    }
+    return result;
+  }
+  map(fn) {
+    let result = this.createEmpty();
+    for (const value of this.values()) {
+      result.add(fn(value));
+    }
+    return result;
+  }
+  toSet() {
+    return new Set(this.data);
+  }
+  toArray() {
+    return [...this.values()];
+  }
+  toString() {
+    return stringify(this.data);
+  }
+};
+var Set1 = class _Set1 extends SetBase {
+  constructor(entries) {
+    super(entries);
+  }
+  createEmpty() {
+    return new _Set1();
+  }
+  valueEquals(a, b) {
+    return a === b;
+  }
+};
+var DeepSet = class _DeepSet extends SetBase {
+  constructor(entries) {
+    super(entries);
+  }
+  createEmpty() {
+    return new _DeepSet();
+  }
+  valueEquals(a, b) {
+    return isDeepEqual2(a, b);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Assert,
+  BaseContainer,
+  BiMap,
   Cookies,
+  DeepSet,
+  DefaultArray,
+  DefaultEqualityFn,
   Device,
   DivRect,
   Guard,
   IndexArray,
   LRUCache,
+  LinkedList,
   Map1,
   Map2,
   Map3,
   MultiContainer,
+  Set1,
+  SetBase,
   SignedIndexArray,
   SmallIntCache,
   Stack,
+  TriMap,
+  UniMap,
   Utils,
+  ValueSet,
   Vec,
   Vec2,
   asMulti