@tspro/ts-utils-lib 1.19.1 → 1.21.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-/* TsUtilsLib v1.19.1 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+/* TsUtilsLib v1.21.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) => {
@@ -64,6 +64,7 @@ __export(assert_exports, {
   isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined,
   isNonEmptyString: () => isNonEmptyString,
   isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined,
+  isNotThrowing: () => isNotThrowing,
   isNull: () => isNull,
   isNullish: () => isNullish,
   isNumber: () => isNumber,
@@ -459,6 +460,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 = {};
@@ -706,6 +712,7 @@ __export(guard_exports, {
   isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined2,
   isNonEmptyString: () => isNonEmptyString2,
   isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined2,
+  isNotThrowing: () => isNotThrowing2,
   isNull: () => isNull2,
   isNullish: () => isNullish2,
   isNumber: () => isNumber2,
@@ -955,6 +962,14 @@ function isThrowing2(throwTestFn) {
     return true;
   }
 }
+function isNotThrowing2(throwTestFn) {
+  try {
+    throwTestFn();
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
 function tryOr(tryFn, orVal) {
   try {
     return tryFn();
@@ -1388,99 +1403,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) {
@@ -1541,13 +1476,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!");
@@ -1675,8 +1611,179 @@ var Vec = class _Vec {
   }
 };
 
-// src/core/div-rect.ts
-var DivRect = class _DivRect {
+// src/core/rect.ts
+var Rect = class _Rect {
+  constructor(...args) {
+    __publicField(this, "x");
+    __publicField(this, "y");
+    __publicField(this, "width");
+    __publicField(this, "height");
+    if (args.length === 0) {
+      this.x = this.y = this.width = this.height = 0;
+    } else if (args.length === 2) {
+      this.x = this.y = 0;
+      this.width = args[0];
+      this.height = args[1];
+    } else {
+      this.x = args[0];
+      this.y = args[1];
+      this.width = args[2];
+      this.height = args[3];
+    }
+    if (this.width < 0 || this.height < 0)
+      throw new Error("Rect width and height must be non-negative.");
+  }
+  set(...args) {
+    if (args.length === 0) {
+      this.x = this.y = this.width = this.height = 0;
+    } else if (args.length === 2) {
+      this.x = this.y = 0;
+      this.width = args[0];
+      this.height = args[1];
+    } else {
+      this.x = args[0];
+      this.y = args[1];
+      this.width = args[2];
+      this.height = args[3];
+    }
+    if (this.width < 0 || this.height < 0)
+      throw new Error("Rect width and height must be non-negative.");
+    return this;
+  }
+  // --- Static Constructors ---
+  static fromPoints(p1, p2) {
+    const x = Math.min(p1.x, p2.x);
+    const y = Math.min(p1.y, p2.y);
+    const w = Math.abs(p1.x - p2.x);
+    const h = Math.abs(p1.y - p2.y);
+    return new _Rect(x, y, w, h);
+  }
+  static fromCenter(cx, cy, width, height) {
+    return new _Rect(cx - width / 2, cy - height / 2, width, height);
+  }
+  // --- Derived Properties ---
+  get left() {
+    return this.x;
+  }
+  get top() {
+    return this.y;
+  }
+  get right() {
+    return this.x + this.width;
+  }
+  get bottom() {
+    return this.y + this.height;
+  }
+  get centerX() {
+    return this.x + this.width / 2;
+  }
+  get centerY() {
+    return this.y + this.height / 2;
+  }
+  get center() {
+    return { x: this.centerX, y: this.centerY };
+  }
+  get area() {
+    return this.width * this.height;
+  }
+  get isEmpty() {
+    return this.width <= 0 || this.height <= 0;
+  }
+  // --- Geometric Tests ---
+  containsPoint(px, py) {
+    return px >= this.left && px <= this.right && py >= this.top && py <= this.bottom;
+  }
+  containsRect(other) {
+    return other.left >= this.left && other.right <= this.right && other.top >= this.top && other.bottom <= this.bottom;
+  }
+  intersects(other) {
+    return !(other.right < this.left || other.left > this.right || other.bottom < this.top || other.top > this.bottom);
+  }
+  // --- Operations ---
+  intersectionCopy(other) {
+    const x1 = Math.max(this.left, other.left);
+    const y1 = Math.max(this.top, other.top);
+    const x2 = Math.min(this.right, other.right);
+    const y2 = Math.min(this.bottom, other.bottom);
+    if (x2 <= x1 || y2 <= y1) return new _Rect();
+    return new _Rect(x1, y1, x2 - x1, y2 - y1);
+  }
+  unionCopy(other) {
+    const x1 = Math.min(this.left, other.left);
+    const y1 = Math.min(this.top, other.top);
+    const x2 = Math.max(this.right, other.right);
+    const y2 = Math.max(this.bottom, other.bottom);
+    return new _Rect(x1, y1, x2 - x1, y2 - y1);
+  }
+  insetCopy(dx, dy) {
+    return new _Rect(this.x + dx, this.y + dy, this.width - 2 * dx, this.height - 2 * dy);
+  }
+  inflateCopy(dx, dy) {
+    return new _Rect(this.x - dx, this.y - dy, this.width + 2 * dx, this.height + 2 * dy);
+  }
+  offsetInPlace(dx, dy) {
+    this.x += dx;
+    this.y += dy;
+    return this;
+  }
+  offsetCopy(dx, dy) {
+    return new _Rect(this.x + dx, this.y + dy, this.width, this.height);
+  }
+  scaleInPlace(scaleX, scaleY = scaleX) {
+    this.x = this.centerX - this.width * scaleX / 2;
+    this.width *= scaleX;
+    this.y = this.centerY - this.height * scaleY / 2;
+    this.height *= scaleY;
+    return this;
+  }
+  scaleCopy(scaleX, scaleY = scaleX) {
+    return this.clone().scaleInPlace(scaleX, scaleY);
+  }
+  roundCopy() {
+    const left = Math.round(this.left);
+    const top = Math.round(this.top);
+    const right = Math.round(this.right);
+    const bottom = Math.round(this.bottom);
+    return new _Rect(left, top, right - left, bottom - top);
+  }
+  floorCopy() {
+    const left = Math.floor(this.left);
+    const top = Math.floor(this.top);
+    const right = Math.floor(this.right);
+    const bottom = Math.floor(this.bottom);
+    return new _Rect(left, top, right - left, bottom - top);
+  }
+  ceilCopy() {
+    const left = Math.ceil(this.left);
+    const top = Math.ceil(this.top);
+    const right = Math.ceil(this.right);
+    const bottom = Math.ceil(this.bottom);
+    return new _Rect(left, top, right - left, bottom - top);
+  }
+  expandCopy(px, py) {
+    const left = Math.min(this.left, px);
+    const top = Math.min(this.top, py);
+    const right = Math.max(this.right, px);
+    const bottom = Math.max(this.bottom, py);
+    return new _Rect(left, top, right - left, bottom - top);
+  }
+  // --- Utilities ---
+  equals(other) {
+    return this.x === other.x && this.y === other.y && this.width === other.width && this.height === other.height;
+  }
+  clone() {
+    return new _Rect(this.x, this.y, this.width, this.height);
+  }
+  toString() {
+    return `Rect(x=${this.x}, y=${this.y}, w=${this.width}, h=${this.height})`;
+  }
+  toAnchoredRect() {
+    return new AnchoredRect(this.left, this.right, this.top, this.bottom);
+  }
+};
+
+// src/core/anchor-rect.ts
+var AnchoredRect = class _AnchoredRect {
   constructor(...args) {
     __publicField(this, "left");
     __publicField(this, "anchorX");
@@ -1702,8 +1809,31 @@ var DivRect = class _DivRect {
       this.left = this.anchorX = this.right = 0;
       this.top = this.anchorY = this.bottom = 0;
     } else {
-      throw new TypeError(`Invalid DivRect args: ${args}`);
+      throw new TypeError(`Invalid AnchoredRect args: ${args}`);
+    }
+  }
+  set(...args) {
+    if (args.length === 6) {
+      this.left = args[0];
+      this.anchorX = args[1];
+      this.right = args[2];
+      this.top = args[3];
+      this.anchorY = args[4];
+      this.bottom = args[5];
+    } else if (args.length === 4) {
+      this.left = args[0];
+      this.right = args[1];
+      this.anchorX = (this.left + this.right) / 2;
+      this.top = args[2];
+      this.bottom = args[3];
+      this.anchorY = (this.top + this.bottom) / 2;
+    } else if (args.length === 0) {
+      this.left = this.anchorX = this.right = 0;
+      this.top = this.anchorY = this.bottom = 0;
+    } else {
+      throw new TypeError(`Invalid AnchoredRect args: ${args}`);
     }
+    return this;
   }
   /**
    * Create rect from basic left, top, width and height arguments.
@@ -1712,10 +1842,10 @@ var DivRect = class _DivRect {
    * @param top - Top coordinate.
    * @param width - Width.
    * @param height - Height.
-   * @returns - DivRect.
+   * @returns - AnchoredRect.
    */
   static create(left, top, width, height) {
-    return new _DivRect(left, left + width, top, top + height);
+    return new _AnchoredRect(left, left + width, top, top + height);
   }
   /**
    * Create rect from anchorX, anchorY, width, height arguments.
@@ -1724,10 +1854,10 @@ var DivRect = class _DivRect {
    * @param centerY - Center y-coordinate.
    * @param width - Width.
    * @param height - Height.
-   * @returns - DivRect.
+   * @returns - AnchoredRect.
    */
   static createCentered(centerX, centerY, width, height) {
-    return new _DivRect(
+    return new _AnchoredRect(
       centerX - width / 2,
       centerX,
       centerX + width / 2,
@@ -1743,26 +1873,22 @@ var DivRect = class _DivRect {
    * @param rightw - Right section width.
    * @param toph - Top section height.
    * @param bottomh - Bottomsection height.
-   * @returns - DivRect.
+   * @returns - AnchoredRect.
    */
   static createSections(leftw, rightw, toph, bottomh) {
-    return new _DivRect(-leftw, 0, rightw, -toph, 0, bottomh);
+    return new _AnchoredRect(-leftw, 0, rightw, -toph, 0, bottomh);
   }
-  /** @deprecated - Renamed to anchorX. */
+  /**
+   * Get center x-coordinate.
+   */
   get centerX() {
-    return this.anchorX;
-  }
-  /** @deprecated - Renamed to anchorX. */
-  set centerX(x) {
-    this.anchorX = x;
+    return this.left + this.width / 2;
   }
-  /** @deprecated - Renamed to anchorY. */
+  /**
+   * Get center ycoordinate.
+   */
   get centerY() {
-    return this.anchorY;
-  }
-  /** @deprecated - Renamed to anchorY. */
-  set centerY(y) {
-    this.anchorY = y;
+    return this.top + this.height / 2;
   }
   /**
    * Width getter.
@@ -1813,8 +1939,8 @@ var DivRect = class _DivRect {
   /**
    * Do a and b rects overlap?
    * 
-   * @param a - DivRect a.
-   * @param b - DivRect b.
+   * @param a - AnchoredRect a.
+   * @param b - AnchoredRect b.
    * @returns - True/false.
    */
   static overlap(a, b) {
@@ -1823,8 +1949,8 @@ var DivRect = class _DivRect {
   /**
    * Do horizontal measures of a and b rects overlap?
    * 
-   * @param a - DivRect a.
-   * @param b - DivRect b.
+   * @param a - AnchoredRect a.
+   * @param b - AnchoredRect b.
    * @returns - True/false.
    */
   static overlapX(a, b) {
@@ -1832,8 +1958,8 @@ var DivRect = class _DivRect {
   }
   /**
    * Check if given rects are equal.
-   * @param a - DivRect a.
-   * @param b - DivRect b.
+   * @param a - AnchoredRect a.
+   * @param b - AnchoredRect b.
    * @returns - True/false.
    */
   static equals(a, b) {
@@ -1851,13 +1977,13 @@ var DivRect = class _DivRect {
    * @returns - True/false.
    */
   equals(other) {
-    return _DivRect.equals(this, other);
+    return _AnchoredRect.equals(this, other);
   }
   /**
    * Check if edges of given rects are equal, ignoring anchorX and anchorY.
    * 
-   * @param a - DivRect a.
-   * @param b - DivRect b.
+   * @param a - AnchoredRect a.
+   * @param b - AnchoredRect b.
    * @returns - True/false.
    */
   static equalsEdges(a, b) {
@@ -1872,30 +1998,25 @@ var DivRect = class _DivRect {
   /**
    * Check if edges of this Rect equals with given Rect, ignoring anchorX and anchorY.
    * 
-   * @param other - The other DivRect.
+   * @param other - The other AnchoredRect.
    * @returns - True/false.
    */
   equalsEdges(other) {
-    return _DivRect.equalsEdges(this, other);
-  }
-  /** @deprecated - Use `DivRect.equalsEdges()` instead. */
-  static equalsFrame(a, b) {
-    return _DivRect.equalsEdges(a, b);
+    return _AnchoredRect.equalsEdges(this, other);
   }
   /**
    * Created duplicate of this Rect.
-   * 
    * @returns - Duplicate.
    */
-  copy() {
-    return new _DivRect(this.left, this.anchorX, this.right, this.top, this.anchorY, this.bottom);
+  clone() {
+    return new _AnchoredRect(this.left, this.anchorX, this.right, this.top, this.anchorY, this.bottom);
   }
   /**
    * Move this rect by (dx, dy). Modifies this Rect.
    * 
    * @param dx - Offset amount in x-direction.
    * @param dy - Offset amount in y-direction.
-   * @returns - This DivRect instance.
+   * @returns - This AnchoredRect instance.
    */
   offsetInPlace(dx, dy) {
     this.left += dx;
@@ -1911,16 +2032,16 @@ var DivRect = class _DivRect {
    * 
    * @param dx - Offset amount in x-direction.
    * @param dy - Offset amount in y-direction.
-   * @returns - DivRect copy with applied offset.
+   * @returns - AnchoredRect copy with applied offset.
    */
   offsetCopy(dx, dy) {
-    return this.copy().offsetInPlace(dx, dy);
+    return this.clone().offsetInPlace(dx, dy);
   }
   /**
    * Expand this Rect by given Rect. Modifies this Rect.
    * 
-   * @param rect - DivRect to expand this instance with.
-   * @returns - This DivRect instance.
+   * @param rect - AnchoredRect to expand this instance with.
+   * @returns - This AnchoredRect instance.
    */
   expandInPlace(rect) {
     this.left = Math.min(this.left, rect.left);
@@ -1932,17 +2053,17 @@ var DivRect = class _DivRect {
   /**
    * Expand this Rect by given Rect. Immutable, returns modified copy.
    * 
-   * @param rect - DivRect to expand this instance with.
-   * @returns - Expanded copy of this DivRect.
+   * @param rect - AnchoredRect to expand this instance with.
+   * @returns - Expanded copy of this AnchoredRect.
    */
   expandCopy(rect) {
-    return this.copy().expandInPlace(rect);
+    return this.clone().expandInPlace(rect);
   }
   /**
    * Clip this Rect by given Rect. Mmodifies this Rect.
    * 
-   * @param clipRect - DivRect to clip this instance with.
-   * @returns - This DivRect instance.
+   * @param clipRect - AnchoredRect to clip this instance with.
+   * @returns - This AnchoredRect instance.
    */
   clipInPlace(clipRect) {
     this.left = Math.max(this.left, clipRect.left);
@@ -1956,21 +2077,20 @@ var DivRect = class _DivRect {
   /**
    * Clip this Rect by given Rect. Immutable, return modified copy.
    * 
-   * @param clipRect - DivRecto to clip this instance with.
-   * @returns - Clipped DivRect copy.
+   * @param clipRect - AnchoredRecto to clip this instance with.
+   * @returns - Clipped AnchoredRect copy.
    */
   clipCopy(clipRect) {
-    return this.copy().clipInPlace(clipRect);
+    return this.clone().clipInPlace(clipRect);
   }
   /**
    * Scale Rect. Anchor pos is (anchorX, anchorY). Modifies this Rect.
    * 
    * @param scaleX - Scale x-amount.
    * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
-   * @returns This DivRect instance.
+   * @returns This AnchoredRect instance.
    */
-  scaleInPlace(scaleX, scaleY) {
-    scaleY = scaleY ?? scaleX;
+  scaleInPlace(scaleX, scaleY = scaleX) {
     this.left = this.anchorX - this.leftw * scaleX;
     this.right = this.anchorX + this.rightw * scaleX;
     this.top = this.anchorY - this.toph * scaleY;
@@ -1982,24 +2102,28 @@ var DivRect = class _DivRect {
    * 
    * @param scaleX - Scale x-amount.
    * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
-   * @returns Scaled copy of this DivRect.
+   * @returns Scaled copy of this AnchoredRect.
    */
-  scaleCopy(scaleX, scaleY) {
-    return this.copy().scaleInPlace(scaleX, scaleY);
+  scaleCopy(scaleX, scaleY = scaleX) {
+    return this.clone().scaleInPlace(scaleX, scaleY);
   }
   /**
-   * Get this DivRect instance.
-   * @returns - This DivRect instance.
+   * Get this AnchoredRect instance.
+   * @returns - This AnchoredRect instance.
    */
   getRect() {
     return this;
   }
+  toRect() {
+    return new Rect(this.left, this.right, this.width, this.height);
+  }
 };
 
 // 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");
@@ -2091,11 +2215,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
@@ -2308,14 +2452,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");
@@ -2571,21 +2721,28 @@ 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/default-array.ts
-var DefaultArray = class _DefaultArray {
-  constructor(lengthOrValues, defaultValue) {
-    this.defaultValue = defaultValue;
+var DefaultArray = class _DefaultArray extends BaseContainer {
+  constructor(...args) {
+    super();
+    __publicField(this, "defaultValue");
     __publicField(this, "data");
-    if (typeof lengthOrValues === "number") {
-      this.data = Array(lengthOrValues).fill(defaultValue);
+    this.defaultValue = args.pop();
+    if (typeof args[0] === "number") {
+      this.data = Array(args[0]).fill(this.defaultValue);
     } else {
-      this.data = Array.from(lengthOrValues).map(
-        (v) => v === void 0 ? defaultValue : v
+      this.data = Array.from(args[0]).map(
+        (v) => v === void 0 ? this.defaultValue : v
       );
     }
   }
@@ -2686,9 +2843,7 @@ var DefaultArray = class _DefaultArray {
   }
   clone() {
     const ctor = this.constructor;
-    const clone = new ctor(this.length, this.defaultValue);
-    clone.data = this.data.slice();
-    return clone;
+    return new ctor(this.values(), this.defaultValue);
   }
   merge(other, conflictResolver) {
     if (this.constructor !== other.constructor)
@@ -2774,62 +2929,92 @@ var DefaultArray = class _DefaultArray {
     return this.valuesArray();
   }
   toString() {
-    const entries = this.entriesArray().map(([id, v]) => `${formatValue(id)}: ${formatValue(v)}`).join(", ");
-    return `DefaultArray[ ${entries} ]`.replaceAll("  ", " ");
+    return stringify(this.data);
   }
 };
 
-// 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/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) {
-    return this.map1.has(key1);
+  static createDeep(arg) {
+    return arg ? new _UniMap(arg, isDeepEqual2) : new _UniMap(isDeepEqual2);
   }
-  set(key1, value) {
-    this.map1.set(key1, 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;
+  }
+  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(key1) {
-    return this.map1.get(key1);
+  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;
   }
-  getOrDefault(key1, defaultValue) {
-    return this.get(key1) ?? defaultValue;
+  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);
   }
-  getOrCreate(key1, creatorOrValue) {
-    if (!this.has(key1)) {
+  getOrDefault(key, defaultValue) {
+    return this.get(key) ?? defaultValue;
+  }
+  getOrCreate(key, creatorOrValue) {
+    if (!this.has(key)) {
       const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
-      this.set(key1, value);
-      return value;
+      return this.set(key, value);
     }
-    return this.get(key1);
-  }
-  delete(key1) {
-    return this.map1.delete(key1);
+    return this.get(key);
   }
   clear() {
-    this.map1.clear();
+    this.map.clear();
   }
   get size() {
-    return this.map1.size;
+    return this.map.size;
   }
   isEmpty() {
     return this.size === 0;
   }
   forEach(callbackfn, thisArg) {
-    this.map1.forEach((value, key1) => callbackfn.call(thisArg, value, key1, this));
+    this.map.forEach((value, key) => callbackfn.call(thisArg, value, key, this));
   }
   *keys() {
-    yield* this.map1.keys();
+    yield* this.map.keys();
   }
   *values() {
-    yield* this.map1.values();
+    yield* this.map.values();
   }
   *entries() {
-    for (const [key1, value] of this.map1)
-      yield [key1, value];
+    for (const [key, value] of this.map)
+      yield [key, value];
   }
   keysArray() {
     return [...this.keys()];
@@ -2859,34 +3044,34 @@ var Map1 = class _Map1 {
     yield* this.entries();
   }
   clone() {
-    return new _Map1(this);
+    return new _UniMap(this, this.keyEquals);
   }
   merge(other, conflictResolver) {
-    for (const [key1, value] of other.entries()) {
-      if (this.has(key1) && conflictResolver) {
-        this.set(key1, conflictResolver(this.get(key1), value, key1));
+    for (const [key, value] of other.entries()) {
+      if (this.has(key) && conflictResolver) {
+        this.set(key, conflictResolver(this.get(key), value, key));
       } else {
-        this.set(key1, value);
+        this.set(key, value);
       }
     }
     return this;
   }
   some(fn) {
-    for (const [key1, value] of this.map1) {
-      if (fn(value, key1)) return true;
+    for (const [key, value] of this.map) {
+      if (fn(value, key)) return true;
     }
     return false;
   }
   every(fn) {
-    for (const [key1, value] of this.map1) {
-      if (!fn(value, key1)) return false;
+    for (const [key, value] of this.map) {
+      if (!fn(value, key)) 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);
+    for (const [key, value] of this.map) {
+      if (predicate(value, key, this)) result.set(key, value);
     }
     return result;
   }
@@ -2909,41 +3094,48 @@ 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 [key, value] = current.value;
+      acc = fn(acc, value, key);
     }
     return acc;
   }
   mapEntries(fn) {
     let result = [];
-    for (const [key1, value] of this.map1) {
-      result.push(fn(value, key1));
+    for (const [key, value] of this.map) {
+      result.push(fn(value, key));
     }
     return result;
   }
   mapValues(fn) {
-    let result = new _Map1();
-    for (const [key1, value] of this.map1) {
-      result.set(key1, fn(value, key1));
+    let result = new _UniMap();
+    for (const [key, value] of this.map) {
+      result.set(key, fn(value, key));
     }
     return result;
   }
   toMap() {
-    return new Map(this.map1);
+    return new Map(this.map);
   }
   toString() {
-    const entries = [...this.map1].map(([k, v]) => `${formatValue(k)} => ${formatValue(v)}`).join(", ");
-    return `Map1(${this.size}){ ${entries} }`.replaceAll("  ", " ");
+    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/map2.ts
-var Map2 = class _Map2 {
+// src/core/bi-map.ts
+var BiMap = class _BiMap extends BaseContainer {
   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));
+    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) {
@@ -2955,9 +3147,7 @@ var Map2 = class _Map2 {
     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;
+    return this.map1.getOrCreate(key1, () => new UniMap(this.key2Equals)).set(key2, value);
   }
   get(key1, key2) {
     return this.map1.get(key1)?.get(key2);
@@ -3035,7 +3225,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()) {
@@ -3106,7 +3296,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));
@@ -3126,24 +3316,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) {
@@ -3155,10 +3349,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;
   }
@@ -3250,7 +3442,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()) {
@@ -3329,7 +3521,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) {
@@ -3354,22 +3546,32 @@ 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 `Map3(${this.size}){ ${entries.join(", ")} }`.replaceAll("  ", " ");
+    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries.join(", ")} }`;
   }
 };
 
 // src/core/set.ts
-var SetBase = class {
-  constructor(entries) {
+var ValueSet = class _ValueSet extends BaseContainer {
+  constructor(...args) {
+    super();
     __publicField(this, "data");
-    this.data = new Set(entries ?? []);
+    __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) {
-    return this.some((v) => this.valueEquals(v, value));
+    if (this.equals === DefaultEqualityFn)
+      return this.data.has(value);
+    return this.some((v) => this.equals(v, value));
   }
   add(value) {
     if (!this.has(value))
@@ -3378,8 +3580,8 @@ var SetBase = class {
   }
   /** @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.");
+    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.*/
@@ -3399,9 +3601,10 @@ var SetBase = class {
     return this.get(key);
   }
   delete(value) {
-    if (!this.has(value)) return false;
+    if (this.equals === DefaultEqualityFn || this.data.has(value))
+      return this.data.delete(value);
     for (const v of this.values()) {
-      if (this.valueEquals(v, value)) {
+      if (this.equals(v, value)) {
         this.data.delete(v);
         return true;
       }
@@ -3448,7 +3651,7 @@ var SetBase = class {
     yield* this.values();
   }
   clone() {
-    const result = this.createEmpty();
+    const result = new _ValueSet();
     for (const v of this.values()) result.add(v);
     return result;
   }
@@ -3471,7 +3674,7 @@ var SetBase = class {
     return true;
   }
   filter(predicate) {
-    const result = this.createEmpty();
+    const result = new _ValueSet();
     for (const value of this.data)
       if (predicate(value, this)) result.add(value);
     return result;
@@ -3481,7 +3684,7 @@ var SetBase = class {
     let first = iterator.next();
     if (first.done) {
       if (arguments.length < 2) {
-        throw new TypeError("Reduce of empty SetBase with no initial value!");
+        throw new TypeError("Reduce of empty ValueSet with no initial value!");
       }
       return init;
     }
@@ -3501,7 +3704,7 @@ var SetBase = class {
     return acc;
   }
   mapValues(fn) {
-    let result = this.createEmpty();
+    let result = new _ValueSet();
     for (const value of this.data) {
       result.add(fn(value));
     }
@@ -3515,7 +3718,7 @@ var SetBase = class {
     return result;
   }
   map(fn) {
-    let result = this.createEmpty();
+    let result = new _ValueSet();
     for (const value of this.values()) {
       result.add(fn(value));
     }
@@ -3528,41 +3731,14 @@ var SetBase = class {
     return [...this.values()];
   }
   toString() {
-    return `${this.getName()}(${this.size})${formatValue([...this.data])}`.replaceAll("  ", " ");
-  }
-};
-var Set1 = class _Set1 extends SetBase {
-  constructor(entries) {
-    super(entries);
-  }
-  createEmpty() {
-    return new _Set1();
-  }
-  valueEquals(a, b) {
-    return a === b;
-  }
-  getName() {
-    return "Set1";
-  }
-};
-var DeepSet = class _DeepSet extends SetBase {
-  constructor(entries) {
-    super(entries);
-  }
-  createEmpty() {
-    return new _DeepSet();
-  }
-  valueEquals(a, b) {
-    return isDeepEqual2(a, b);
-  }
-  getName() {
-    return "DeepSet";
+    return stringify(this.data);
   }
 };
 
 // src/core/multi-container.ts
-var MultiContainer = class {
+var MultiContainer = class extends BaseContainer {
   constructor(base) {
+    super();
     this.base = base;
   }
   isEmpty() {
@@ -3618,17 +3794,382 @@ 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/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) {
@@ -3705,26 +4246,1181 @@ 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);
+  }
+};
+
+// src/deprecated/div-rect.ts
+var DivRect = class _DivRect {
+  constructor(...args) {
+    __publicField(this, "left");
+    __publicField(this, "anchorX");
+    __publicField(this, "right");
+    __publicField(this, "top");
+    __publicField(this, "anchorY");
+    __publicField(this, "bottom");
+    if (args.length === 6) {
+      this.left = args[0];
+      this.anchorX = args[1];
+      this.right = args[2];
+      this.top = args[3];
+      this.anchorY = args[4];
+      this.bottom = args[5];
+    } else if (args.length === 4) {
+      this.left = args[0];
+      this.right = args[1];
+      this.anchorX = (this.left + this.right) / 2;
+      this.top = args[2];
+      this.bottom = args[3];
+      this.anchorY = (this.top + this.bottom) / 2;
+    } else if (args.length === 0) {
+      this.left = this.anchorX = this.right = 0;
+      this.top = this.anchorY = this.bottom = 0;
+    } else {
+      throw new TypeError(`Invalid DivRect args: ${args}`);
+    }
+  }
+  set(...args) {
+    if (args.length === 6) {
+      this.left = args[0];
+      this.anchorX = args[1];
+      this.right = args[2];
+      this.top = args[3];
+      this.anchorY = args[4];
+      this.bottom = args[5];
+    } else if (args.length === 4) {
+      this.left = args[0];
+      this.right = args[1];
+      this.anchorX = (this.left + this.right) / 2;
+      this.top = args[2];
+      this.bottom = args[3];
+      this.anchorY = (this.top + this.bottom) / 2;
+    } else if (args.length === 0) {
+      this.left = this.anchorX = this.right = 0;
+      this.top = this.anchorY = this.bottom = 0;
+    } else {
+      throw new TypeError(`Invalid DivRect args: ${args}`);
+    }
+    return this;
+  }
+  /**
+   * Create rect from basic left, top, width and height arguments.
+   * 
+   * @param left - Left coordinate.
+   * @param top - Top coordinate.
+   * @param width - Width.
+   * @param height - Height.
+   * @returns - DivRect.
+   */
+  static create(left, top, width, height) {
+    return new _DivRect(left, left + width, top, top + height);
+  }
+  /**
+   * Create rect from anchorX, anchorY, width, height arguments.
+   * 
+   * @param centerX - Center x-coordinate.
+   * @param centerY - Center y-coordinate.
+   * @param width - Width.
+   * @param height - Height.
+   * @returns - DivRect.
+   */
+  static createCentered(centerX, centerY, width, height) {
+    return new _DivRect(
+      centerX - width / 2,
+      centerX,
+      centerX + width / 2,
+      centerY - height / 2,
+      centerY,
+      centerY + height / 2
+    );
+  }
+  /**
+   * Create rect from sections.
+   * 
+   * @param leftw - Left section width.
+   * @param rightw - Right section width.
+   * @param toph - Top section height.
+   * @param bottomh - Bottomsection height.
+   * @returns - DivRect.
+   */
+  static createSections(leftw, rightw, toph, bottomh) {
+    return new _DivRect(-leftw, 0, rightw, -toph, 0, bottomh);
+  }
+  /**
+   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+   * @private
+   * */
+  get centerX() {
+    return this.anchorX;
+  }
+  /**
+   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+   * @private
+   * */
+  set centerX(x) {
+    this.anchorX = x;
+  }
+  /**
+   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+   * @private
+   * */
+  get centerY() {
+    return this.anchorY;
+  }
+  /**
+   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+   * @private
+   * */
+  set centerY(y) {
+    this.anchorY = y;
+  }
+  /**
+   * Width getter.
+   */
+  get width() {
+    return this.right - this.left;
+  }
+  /**
+   * Height getter.
+   */
+  get height() {
+    return this.bottom - this.top;
+  }
+  /**
+   * Left section width getter.
+   */
+  get leftw() {
+    return this.anchorX - this.left;
+  }
+  /**
+   * Right section width getter.
+   */
+  get rightw() {
+    return this.right - this.anchorX;
+  }
+  /**
+   * Top section height getter.
+   */
+  get toph() {
+    return this.anchorY - this.top;
+  }
+  /**
+   * Bottom section height getter.
+   */
+  get bottomh() {
+    return this.bottom - this.anchorY;
+  }
+  /**
+   * Does this Rect contain given (x, y)-point?
+   * 
+   * @param x - X-coordinate.
+   * @param y - Y-coordinate.
+   * @returns - True/false.
+   */
+  contains(x, y) {
+    return x >= this.left && x <= this.right && y >= this.top && y <= this.bottom;
+  }
+  /**
+   * Do a and b rects overlap?
+   * 
+   * @param a - DivRect a.
+   * @param b - DivRect b.
+   * @returns - True/false.
+   */
+  static overlap(a, b) {
+    return a.right > b.left && a.left < b.right && a.bottom > b.top && a.top < b.bottom;
+  }
+  /**
+   * Do horizontal measures of a and b rects overlap?
+   * 
+   * @param a - DivRect a.
+   * @param b - DivRect b.
+   * @returns - True/false.
+   */
+  static overlapX(a, b) {
+    return a.right > b.left && a.left < b.right;
+  }
+  /**
+   * Check if given rects are equal.
+   * @param a - DivRect a.
+   * @param b - DivRect b.
+   * @returns - True/false.
+   */
+  static equals(a, b) {
+    if (a == null && b == null) {
+      return true;
+    } else if (a == null || b == null) {
+      return false;
+    } else {
+      return a === b || a.left === b.left && a.anchorX === b.anchorX && a.right === b.right && a.top === b.top && a.anchorY === b.anchorY && a.bottom === b.bottom;
+    }
+  }
+  /**
+   * Check if this rect equals with another rect.
+   * @param other - The other rect.
+   * @returns - True/false.
+   */
+  equals(other) {
+    return _DivRect.equals(this, other);
+  }
+  /**
+   * Check if edges of given rects are equal, ignoring anchorX and anchorY.
+   * 
+   * @param a - DivRect a.
+   * @param b - DivRect b.
+   * @returns - True/false.
+   */
+  static equalsEdges(a, b) {
+    if (a == null && b == null) {
+      return true;
+    } else if (a == null || b == null) {
+      return false;
+    } else {
+      return a === b || a.left === b.left && a.right === b.right && a.top === b.top && a.bottom === b.bottom;
+    }
+  }
+  /**
+   * Check if edges of this Rect equals with given Rect, ignoring anchorX and anchorY.
+   * 
+   * @param other - The other DivRect.
+   * @returns - True/false.
+   */
+  equalsEdges(other) {
+    return _DivRect.equalsEdges(this, other);
+  }
+  /**
+   * @deprecated - Use {@link equalsEdges()} instead. Will be removed in v2.0.0.
+   * @private
+   */
+  static equalsFrame(a, b) {
+    return _DivRect.equalsEdges(a, b);
+  }
+  /**
+   * @deprecated - Use {@link clone()} instead. Will be removed in v2.0.0.
+   * @private
+   */
+  copy() {
+    return new _DivRect(this.left, this.anchorX, this.right, this.top, this.anchorY, this.bottom);
+  }
+  /**
+   * Created duplicate of this Rect.
+   * @returns - Duplicate.
+   */
+  clone() {
+    return new _DivRect(this.left, this.anchorX, this.right, this.top, this.anchorY, this.bottom);
+  }
+  /**
+   * Move this rect by (dx, dy). Modifies this Rect.
+   * 
+   * @param dx - Offset amount in x-direction.
+   * @param dy - Offset amount in y-direction.
+   * @returns - This DivRect instance.
+   */
+  offsetInPlace(dx, dy) {
+    this.left += dx;
+    this.anchorX += dx;
+    this.right += dx;
+    this.top += dy;
+    this.anchorY += dy;
+    this.bottom += dy;
+    return this;
+  }
+  /**
+   * Move this rect by (dx, dy). Immutable, returns modified copy.
+   * 
+   * @param dx - Offset amount in x-direction.
+   * @param dy - Offset amount in y-direction.
+   * @returns - DivRect copy with applied offset.
+   */
+  offsetCopy(dx, dy) {
+    return this.clone().offsetInPlace(dx, dy);
+  }
+  /**
+   * Expand this Rect by given Rect. Modifies this Rect.
+   * 
+   * @param rect - DivRect to expand this instance with.
+   * @returns - This DivRect instance.
+   */
+  expandInPlace(rect) {
+    this.left = Math.min(this.left, rect.left);
+    this.right = Math.max(this.right, rect.right);
+    this.top = Math.min(this.top, rect.top);
+    this.bottom = Math.max(this.bottom, rect.bottom);
+    return this;
+  }
+  /**
+   * Expand this Rect by given Rect. Immutable, returns modified copy.
+   * 
+   * @param rect - DivRect to expand this instance with.
+   * @returns - Expanded copy of this DivRect.
+   */
+  expandCopy(rect) {
+    return this.clone().expandInPlace(rect);
+  }
+  /**
+   * Clip this Rect by given Rect. Mmodifies this Rect.
+   * 
+   * @param clipRect - DivRect to clip this instance with.
+   * @returns - This DivRect instance.
+   */
+  clipInPlace(clipRect) {
+    this.left = Math.max(this.left, clipRect.left);
+    this.right = Math.min(this.right, clipRect.right);
+    this.anchorX = clamp(this.anchorX, this.left, this.right);
+    this.top = Math.max(this.top, clipRect.top);
+    this.bottom = Math.min(this.bottom, clipRect.bottom);
+    this.anchorY = clamp(this.anchorY, this.top, this.bottom);
+    return this;
+  }
+  /**
+   * Clip this Rect by given Rect. Immutable, return modified copy.
+   * 
+   * @param clipRect - DivRecto to clip this instance with.
+   * @returns - Clipped DivRect copy.
+   */
+  clipCopy(clipRect) {
+    return this.clone().clipInPlace(clipRect);
+  }
+  /**
+   * Scale Rect. Anchor pos is (anchorX, anchorY). Modifies this Rect.
+   * 
+   * @param scaleX - Scale x-amount.
+   * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
+   * @returns This DivRect instance.
+   */
+  scaleInPlace(scaleX, scaleY = scaleX) {
+    this.left = this.anchorX - this.leftw * scaleX;
+    this.right = this.anchorX + this.rightw * scaleX;
+    this.top = this.anchorY - this.toph * scaleY;
+    this.bottom = this.anchorY + this.bottomh * scaleY;
+    return this;
+  }
+  /**
+   * Scale Rect. Anchor pos is (anchorX, anchorY). Immutable, returns modified copy.
+   * 
+   * @param scaleX - Scale x-amount.
+   * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
+   * @returns Scaled copy of this DivRect.
+   */
+  scaleCopy(scaleX, scaleY = scaleX) {
+    return this.clone().scaleInPlace(scaleX, scaleY);
+  }
+  /**
+   * Get this DivRect instance.
+   * @returns - This DivRect instance.
+   */
+  getRect() {
+    return this;
+  }
+  toRect() {
+    return new Rect(this.left, this.right, this.width, this.height);
+  }
+};
 export {
+  AnchoredRect,
   assert_exports as Assert,
+  BaseContainer,
+  BiMap,
   cookies_exports as Cookies,
   DeepSet,
   DefaultArray,
+  DefaultEqualityFn,
   device_exports as Device,
   DivRect,
   guard_exports as Guard,
   IndexArray,
   LRUCache,
+  LinkedList,
   Map1,
   Map2,
   Map3,
   MultiContainer,
+  Rect,
   Set1,
   SetBase,
   SignedIndexArray,
   SmallIntCache,
   Stack,
+  TriMap,
+  UniMap,
   utils_exports as Utils,
+  ValueSet,
   Vec,
   Vec2,
   asMulti