@tspro/ts-utils-lib 1.16.0 → 1.17.0

package/dist/index.js

@@ -1,4 +1,4 @@
-/* TsUtilsLib v1.16.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+/* TsUtilsLib v1.17.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -26,6 +26,7 @@ __export(index_exports, {
   Assert: () => Assert,
   Cookies: () => Cookies,
   Device: () => Device,
+  DivRect: () => DivRect,
   IndexArray: () => IndexArray,
   LRUCache: () => LRUCache,
   Map1: () => Map1,
@@ -36,6 +37,7 @@ __export(index_exports, {
   SmallIntCache: () => SmallIntCache,
   Stack: () => Stack,
   Utils: () => utils_exports,
+  Vec: () => Vec,
   Vec2: () => Vec2,
   asMulti: () => asMulti
 });
@@ -1117,28 +1119,396 @@ var Stack = class {
   }
 };
 
-// src/core/vec2.ts
-var Vec2 = class _Vec2 {
-  constructor(x, y) {
-    __publicField(this, "x");
-    __publicField(this, "y");
-    this.x = x ?? 0;
-    this.y = y ?? 0;
+// src/core/vec.ts
+var Vec = class _Vec {
+  constructor(...coords) {
+    __publicField(this, "coords");
+    if (coords.length < 2) {
+      throw new TypeError("Vec needs minumum two coords!");
+    }
+    this.coords = coords;
   }
-  length() {
-    return Math.sqrt(this.x * this.x + this.y * this.y);
+  static vec2(x, y) {
+    return new _Vec(x, y);
   }
-  add(a) {
-    return new _Vec2(this.x + a.x, this.y + a.y);
+  static vec3(x, y, z) {
+    return new _Vec(x, y, z);
   }
-  sub(a) {
-    return new _Vec2(this.x - a.x, this.y - a.y);
+  static zero(dim) {
+    if (dim < 2) {
+      throw new TypeError("Vec.zero requires dimension >= 2");
+    }
+    return new _Vec(...Array(dim).fill(0));
   }
-  mul(a) {
-    return new _Vec2(this.x * a, this.y * a);
+  get length() {
+    return Math.hypot(...this.coords);
   }
-  div(a) {
-    return new _Vec2(this.x / a, this.y / a);
+  get x() {
+    return this.coords[0];
+  }
+  get y() {
+    return this.coords[1];
+  }
+  get z() {
+    if (this.coords[2] === void 0) {
+      throw new TypeError("Vec z-coord not available!");
+    }
+    return this.coords[2];
+  }
+  add(...args) {
+    const otherCoords = args[0] instanceof _Vec ? args[0].coords : args;
+    if (this.coords.length !== otherCoords.length) {
+      throw new TypeError("Coordinate length mismatch!");
+    }
+    return new _Vec(...this.coords.map((coord, i) => coord + otherCoords[i]));
+  }
+  sub(...args) {
+    const otherCoords = args[0] instanceof _Vec ? args[0].coords : args;
+    if (this.coords.length !== otherCoords.length) {
+      throw new TypeError("Coordinate length mismatch!");
+    }
+    return new _Vec(...this.coords.map((coord, i) => coord - otherCoords[i]));
+  }
+  mul(scalar) {
+    return new _Vec(...this.coords.map((coord) => coord * scalar));
+  }
+  div(scalar) {
+    return new _Vec(...this.coords.map((coord) => coord / scalar));
+  }
+  dot(other) {
+    if (this.coords.length !== other.coords.length) {
+      throw new TypeError("Coordinate length mismatch!");
+    }
+    return this.coords.reduce((sum2, c, i) => sum2 + c * other.coords[i], 0);
+  }
+  distance(other) {
+    if (this.coords.length !== other.coords.length) {
+      throw new TypeError("Coordinate length mismatch!");
+    }
+    return Math.hypot(...this.coords.map((c, i) => c - other.coords[i]));
+  }
+  normalize() {
+    const len = this.length;
+    if (len === 0) {
+      throw new TypeError("Cannot normalize zero-length vector!");
+    }
+    return this.div(len);
+  }
+  equals(other) {
+    return this.coords.length === other.coords.length && this.coords.every((v, i) => v === other.coords[i]);
+  }
+  clone() {
+    return new _Vec(...this.coords);
+  }
+  toObject() {
+    return { x: this.x, y: this.y, z: this.z };
+  }
+  [Symbol.iterator]() {
+    return this.coords[Symbol.iterator]();
+  }
+  toString() {
+    return `Vec(${this.coords.join(", ")})`;
+  }
+};
+
+// src/core/div-rect.ts
+var DivRect = class _DivRect {
+  constructor(...args) {
+    __publicField(this, "left");
+    __publicField(this, "centerX");
+    __publicField(this, "right");
+    __publicField(this, "top");
+    __publicField(this, "centerY");
+    __publicField(this, "bottom");
+    if (args.length === 6) {
+      this.left = args[0];
+      this.centerX = args[1];
+      this.right = args[2];
+      this.top = args[3];
+      this.centerY = args[4];
+      this.bottom = args[5];
+    } else if (args.length === 4) {
+      this.left = args[0];
+      this.right = args[1];
+      this.centerX = (this.left + this.right) / 2;
+      this.top = args[2];
+      this.bottom = args[3];
+      this.centerY = (this.top + this.bottom) / 2;
+    } else if (args.length === 0) {
+      this.left = this.centerX = this.right = 0;
+      this.top = this.centerY = this.bottom = 0;
+    } else {
+      throw new TypeError(`Invalid DivRect args: ${args}`);
+    }
+  }
+  /**
+   * 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 centerX, centerY, 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);
+  }
+  /**
+   * 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.centerX - this.left;
+  }
+  /**
+   * Right section width getter.
+   */
+  get rightw() {
+    return this.right - this.centerX;
+  }
+  /**
+   * Top section height getter.
+   */
+  get toph() {
+    return this.centerY - this.top;
+  }
+  /**
+   * Bottom section height getter.
+   */
+  get bottomh() {
+    return this.bottom - this.centerY;
+  }
+  /**
+   * 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.centerX === b.centerX && a.right === b.right && a.top === b.top && a.centerY === b.centerY && 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 centerX and centerY.
+   * 
+   * @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 centerX and centerY.
+   * 
+   * @param other - The other DivRect.
+   * @returns - True/false.
+   */
+  equalsEdges(other) {
+    return _DivRect.equalsEdges(this, other);
+  }
+  /**
+   * Created duplicate of this Rect.
+   * 
+   * @returns - Duplicate.
+   */
+  copy() {
+    return new _DivRect(this.left, this.centerX, this.right, this.top, this.centerY, 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.centerX += dx;
+    this.right += dx;
+    this.top += dy;
+    this.centerY += 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.copy().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.copy().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.centerX = clamp(this.centerX, this.left, this.right);
+    this.top = Math.max(this.top, clipRect.top);
+    this.bottom = Math.min(this.bottom, clipRect.bottom);
+    this.centerY = clamp(this.centerY, 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.copy().clipInPlace(clipRect);
+  }
+  /**
+   * Scale Rect. Anchor pos is (centerX, centerY). 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) {
+    scaleY = scaleY ?? scaleX;
+    this.left = this.centerX - this.leftw * scaleX;
+    this.right = this.centerX + this.rightw * scaleX;
+    this.top = this.centerY - this.toph * scaleY;
+    this.bottom = this.centerY + this.bottomh * scaleY;
+    return this;
+  }
+  /**
+   * Scale Rect. Anchor pos is (centerX, centerY). 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) {
+    return this.copy().scaleInPlace(scaleX, scaleY);
+  }
+  /**
+   * Get this DivRect instance.
+   * @returns - This DivRect instance.
+   */
+  getRect() {
+    return this;
   }
 };
 
@@ -1239,84 +1609,28 @@ var LRUCache = class {
   }
 };
 
-// src/core/small-int-cache.ts
-var SmallIntCache = class {
-  // for keys < 0
-  constructor() {
-    __publicField(this, "pos");
-    // for keys >= 0
-    __publicField(this, "neg");
-    this.pos = [];
-    this.neg = [];
-  }
-  set(key, value) {
-    if (!isInteger(key)) {
-      throw new Error("Key must be an integer");
-    } else if (key >= 0) {
-      this.pos[key] = value;
-    } else {
-      this.neg[-key - 1] = value;
-    }
-  }
-  get(key) {
-    if (!isInteger(key)) {
-      throw new Error("Key must be an integer");
-    } else if (key >= 0) {
-      return this.pos[key];
-    } else {
-      return this.neg[-key - 1];
-    }
-  }
-  has(key) {
-    if (!isInteger(key)) {
-      return false;
-    } else if (key >= 0) {
-      return key in this.pos;
-    } else {
-      return -key - 1 in this.neg;
-    }
-  }
-  delete(key) {
-    if (!isInteger(key)) {
-      return;
-    } else if (key >= 0) {
-      delete this.pos[key];
-    } else {
-      delete this.neg[-key - 1];
-    }
-  }
-  clear() {
-    this.pos = [];
-    this.neg = [];
-  }
-};
-
 // src/core/index-array.ts
 var IndexArray = class _IndexArray {
   constructor(entries) {
-    // for indexes >= 0
-    __publicField(this, "posEl");
+    __publicField(this, "posVal");
     __publicField(this, "hasPos");
-    // number of elems
-    __publicField(this, "elCount");
+    // Number of values
+    __publicField(this, "valCount");
     if (entries instanceof _IndexArray) {
-      this.posEl = entries.posEl.slice();
+      this.posVal = entries.posVal.slice();
       this.hasPos = entries.hasPos.slice();
-      this.elCount = entries.elCount;
+      this.valCount = entries.valCount;
     } else {
-      this.posEl = [];
+      this.posVal = [];
       this.hasPos = [];
-      this.elCount = 0;
+      this.valCount = 0;
       if (entries) {
-        for (const [id, el] of entries) {
-          this.set(id, el);
+        for (const [id, value] of entries) {
+          this.set(id, value);
         }
       }
     }
   }
-  static toNegIndex(id) {
-    return -id - 1;
-  }
   static validateIndex(id) {
     if (!isIntegerGte(id, 0)) throw new Error(`Invalid index ${id} - must be an integer >= 0!`);
     return id;
@@ -1325,7 +1639,7 @@ var IndexArray = class _IndexArray {
     return this.hasPos.length;
   }
   get size() {
-    return this.elCount;
+    return this.valCount;
   }
   isEmpty() {
     return this.size === 0;
@@ -1334,15 +1648,15 @@ var IndexArray = class _IndexArray {
     _IndexArray.validateIndex(id);
     return this.hasPos[id] === true;
   }
-  set(id, el) {
+  set(id, value) {
     _IndexArray.validateIndex(id);
-    if (this.hasPos[id] !== true) this.elCount++;
-    this.posEl[id] = el;
+    if (this.hasPos[id] !== true) this.valCount++;
+    this.posVal[id] = value;
     this.hasPos[id] = true;
   }
   get(id) {
     _IndexArray.validateIndex(id);
-    return this.hasPos[id] ? this.posEl[id] : void 0;
+    return this.hasPos[id] ? this.posVal[id] : void 0;
   }
   getOrDefault(id, defaultValue) {
     return this.get(id) ?? defaultValue;
@@ -1358,19 +1672,19 @@ var IndexArray = class _IndexArray {
   delete(id) {
     _IndexArray.validateIndex(id);
     if (!this.hasPos[id]) return false;
-    this.posEl[id] = void 0;
+    this.posVal[id] = void 0;
     this.hasPos[id] = false;
-    this.elCount--;
+    this.valCount--;
     return true;
   }
   clear() {
-    this.posEl = [];
+    this.posVal = [];
     this.hasPos = [];
-    this.elCount = 0;
+    this.valCount = 0;
   }
   forEach(callbackfn, thisArg) {
-    for (const [id, el] of this.entries()) {
-      callbackfn.call(thisArg, el, id, this);
+    for (const [id, value] of this.entries()) {
+      callbackfn.call(thisArg, value, id, this);
     }
   }
   *indices() {
@@ -1380,12 +1694,12 @@ var IndexArray = class _IndexArray {
   }
   *values() {
     for (let id = 0; id < this.posLen; id++) {
-      if (this.hasPos[id]) yield this.posEl[id];
+      if (this.hasPos[id]) yield this.posVal[id];
     }
   }
   *entries() {
     for (let id = 0; id < this.posLen; id++) {
-      if (this.hasPos[id]) yield [id, this.posEl[id]];
+      if (this.hasPos[id]) yield [id, this.posVal[id]];
     }
   }
   indicesArray() {
@@ -1403,13 +1717,13 @@ var IndexArray = class _IndexArray {
     }
   }
   *kvValues() {
-    for (const el of this.values()) {
-      yield el;
+    for (const value of this.values()) {
+      yield value;
     }
   }
   *kvEntries() {
-    for (const [id, el] of this.entries()) {
-      yield [[id], el];
+    for (const [id, value] of this.entries()) {
+      yield [[id], value];
     }
   }
   *[Symbol.iterator]() {
@@ -1429,21 +1743,21 @@ var IndexArray = class _IndexArray {
     return this;
   }
   some(fn) {
-    for (const [id, el] of this.entries()) {
-      if (fn(el, id)) return true;
+    for (const [id, value] of this.entries()) {
+      if (fn(value, id)) return true;
     }
     return false;
   }
   every(fn) {
-    for (const [id, el] of this.entries()) {
-      if (!fn(el, id)) return false;
+    for (const [id, value] of this.entries()) {
+      if (!fn(value, id)) return false;
     }
     return true;
   }
-  filter(fn) {
-    let result = new _IndexArray();
-    for (const [id, el] of this.entries()) {
-      if (fn(el, id)) result.set(id, el);
+  filter(predicate) {
+    const result = new this.constructor();
+    for (const [id, value] of this.entries()) {
+      if (predicate(value, id, this)) result.set(id, value);
     }
     return result;
   }
@@ -1466,22 +1780,22 @@ var IndexArray = class _IndexArray {
       start = first;
     }
     for (let current = start; !current.done; current = iterator.next()) {
-      const [id, el] = current.value;
-      acc = fn(acc, el, id);
+      const [id, value] = current.value;
+      acc = fn(acc, value, id);
     }
     return acc;
   }
   mapToArray(fn) {
     let result = [];
-    for (const [id, el] of this.entries()) {
-      result.push(fn(el, id));
+    for (const [id, value] of this.entries()) {
+      result.push(fn(value, id));
     }
     return result;
   }
   map(fn) {
     let result = new _IndexArray();
-    for (const [id, el] of this.entries()) {
-      result.set(id, fn(el, id));
+    for (const [id, value] of this.entries()) {
+      result.set(id, fn(value, id));
     }
     return result;
   }
@@ -1493,13 +1807,13 @@ var IndexArray = class _IndexArray {
       const hasA = this.hasPos[i];
       const hasB = other.hasPos[i];
       if (hasA !== hasB) return false;
-      if (hasA && !eq(this.posEl[i], other.posEl[i])) return false;
+      if (hasA && !eq(this.posVal[i], other.posVal[i])) return false;
     }
     return true;
   }
   toString() {
     if (this.size === 0) return `IndexArray[ ]`;
-    const entries = this.entriesArray().map(([id, el]) => `${id}: ${el}`).join(", ");
+    const entries = this.entriesArray().map(([id, value]) => `${id}: ${value}`).join(", ");
     return `IndexArray[ ${entries} ]`;
   }
 };
@@ -1507,29 +1821,29 @@ var IndexArray = class _IndexArray {
 // src/core/signed-index-array.ts
 var SignedIndexArray = class _SignedIndexArray {
   constructor(entries) {
-    // for indexes >= 0
-    __publicField(this, "posEl");
+    // For indexes >= 0
+    __publicField(this, "posVal");
     __publicField(this, "hasPos");
-    // for indexes < 0
-    __publicField(this, "negEl");
+    // For indexes < 0
+    __publicField(this, "negVal");
     __publicField(this, "hasNeg");
-    // number of elems
-    __publicField(this, "elCount");
+    // Number of values
+    __publicField(this, "valCount");
     if (entries instanceof _SignedIndexArray) {
-      this.negEl = entries.negEl.slice();
+      this.negVal = entries.negVal.slice();
       this.hasNeg = entries.hasNeg.slice();
-      this.posEl = entries.posEl.slice();
+      this.posVal = entries.posVal.slice();
       this.hasPos = entries.hasPos.slice();
-      this.elCount = entries.elCount;
+      this.valCount = entries.valCount;
     } else {
-      this.negEl = [];
+      this.negVal = [];
       this.hasNeg = [];
-      this.posEl = [];
+      this.posVal = [];
       this.hasPos = [];
-      this.elCount = 0;
+      this.valCount = 0;
       if (entries) {
-        for (const [id, el] of entries) {
-          this.set(id, el);
+        for (const [id, value] of entries) {
+          this.set(id, value);
         }
       }
     }
@@ -1542,7 +1856,7 @@ var SignedIndexArray = class _SignedIndexArray {
     return id;
   }
   get size() {
-    return this.elCount;
+    return this.valCount;
   }
   isEmpty() {
     return this.size === 0;
@@ -1561,26 +1875,26 @@ var SignedIndexArray = class _SignedIndexArray {
       return this.hasNeg[_SignedIndexArray.toNegIndex(id)] === true;
     }
   }
-  set(id, el) {
+  set(id, value) {
     _SignedIndexArray.validateIndex(id);
     if (id >= 0) {
-      if (this.hasPos[id] !== true) this.elCount++;
-      this.posEl[id] = el;
+      if (this.hasPos[id] !== true) this.valCount++;
+      this.posVal[id] = value;
       this.hasPos[id] = true;
     } else {
       let negId = _SignedIndexArray.toNegIndex(id);
-      if (this.hasNeg[negId] !== true) this.elCount++;
-      this.negEl[negId] = el;
+      if (this.hasNeg[negId] !== true) this.valCount++;
+      this.negVal[negId] = value;
       this.hasNeg[negId] = true;
     }
   }
   get(id) {
     _SignedIndexArray.validateIndex(id);
     if (id >= 0) {
-      return this.hasPos[id] ? this.posEl[id] : void 0;
+      return this.hasPos[id] ? this.posVal[id] : void 0;
     } else {
       let negId = _SignedIndexArray.toNegIndex(id);
-      return this.hasNeg[negId] ? this.negEl[negId] : void 0;
+      return this.hasNeg[negId] ? this.negVal[negId] : void 0;
     }
   }
   getOrDefault(id, defaultValue) {
@@ -1597,25 +1911,25 @@ var SignedIndexArray = class _SignedIndexArray {
   delete(id) {
     _SignedIndexArray.validateIndex(id);
     const isPos = id >= 0;
-    const arr = isPos ? this.posEl : this.negEl;
+    const arr = isPos ? this.posVal : this.negVal;
     const has = isPos ? this.hasPos : this.hasNeg;
     const idx = isPos ? id : _SignedIndexArray.toNegIndex(id);
     if (!has[idx]) return false;
     arr[idx] = void 0;
     has[idx] = false;
-    this.elCount--;
+    this.valCount--;
     return true;
   }
   clear() {
-    this.negEl = [];
+    this.negVal = [];
     this.hasNeg = [];
-    this.posEl = [];
+    this.posVal = [];
     this.hasPos = [];
-    this.elCount = 0;
+    this.valCount = 0;
   }
   forEach(callbackfn, thisArg) {
-    for (const [id, el] of this.entries()) {
-      callbackfn.call(thisArg, el, id, this);
+    for (const [id, value] of this.entries()) {
+      callbackfn.call(thisArg, value, id, this);
     }
   }
   *indices() {
@@ -1628,18 +1942,18 @@ var SignedIndexArray = class _SignedIndexArray {
   }
   *values() {
     for (let id = this.negLen - 1; id >= 0; id--) {
-      if (this.hasNeg[id]) yield this.negEl[id];
+      if (this.hasNeg[id]) yield this.negVal[id];
     }
     for (let id = 0; id < this.posLen; id++) {
-      if (this.hasPos[id]) yield this.posEl[id];
+      if (this.hasPos[id]) yield this.posVal[id];
     }
   }
   *entries() {
     for (let id = this.negLen - 1; id >= 0; id--) {
-      if (this.hasNeg[id]) yield [_SignedIndexArray.toNegIndex(id), this.negEl[id]];
+      if (this.hasNeg[id]) yield [_SignedIndexArray.toNegIndex(id), this.negVal[id]];
     }
     for (let id = 0; id < this.posLen; id++) {
-      if (this.hasPos[id]) yield [id, this.posEl[id]];
+      if (this.hasPos[id]) yield [id, this.posVal[id]];
     }
   }
   indicesArray() {
@@ -1657,13 +1971,13 @@ var SignedIndexArray = class _SignedIndexArray {
     }
   }
   *kvValues() {
-    for (const el of this.values()) {
-      yield el;
+    for (const value of this.values()) {
+      yield value;
     }
   }
   *kvEntries() {
-    for (const [id, el] of this.entries()) {
-      yield [[id], el];
+    for (const [id, value] of this.entries()) {
+      yield [[id], value];
     }
   }
   *[Symbol.iterator]() {
@@ -1683,21 +1997,21 @@ var SignedIndexArray = class _SignedIndexArray {
     return this;
   }
   some(fn) {
-    for (const [id, el] of this.entries()) {
-      if (fn(el, id)) return true;
+    for (const [id, value] of this.entries()) {
+      if (fn(value, id)) return true;
     }
     return false;
   }
   every(fn) {
-    for (const [id, el] of this.entries()) {
-      if (!fn(el, id)) return false;
+    for (const [id, value] of this.entries()) {
+      if (!fn(value, id)) return false;
     }
     return true;
   }
-  filter(fn) {
-    let result = new _SignedIndexArray();
-    for (const [id, el] of this.entries()) {
-      if (fn(el, id)) result.set(id, el);
+  filter(predicate) {
+    const result = new this.constructor();
+    for (const [id, value] of this.entries()) {
+      if (predicate(value, id, this)) result.set(id, value);
     }
     return result;
   }
@@ -1720,22 +2034,22 @@ var SignedIndexArray = class _SignedIndexArray {
       start = first;
     }
     for (let current = start; !current.done; current = iterator.next()) {
-      const [id, el] = current.value;
-      acc = fn(acc, el, id);
+      const [id, value] = current.value;
+      acc = fn(acc, value, id);
     }
     return acc;
   }
   mapToArray(fn) {
     let result = [];
-    for (const [id, el] of this.entries()) {
-      result.push(fn(el, id));
+    for (const [id, value] of this.entries()) {
+      result.push(fn(value, id));
     }
     return result;
   }
   map(fn) {
     let result = new _SignedIndexArray();
-    for (const [id, el] of this.entries()) {
-      result.set(id, fn(el, id));
+    for (const [id, value] of this.entries()) {
+      result.set(id, fn(value, id));
     }
     return result;
   }
@@ -1747,25 +2061,25 @@ var SignedIndexArray = class _SignedIndexArray {
       const hasA = this.hasPos[i];
       const hasB = other.hasPos[i];
       if (hasA !== hasB) return false;
-      if (hasA && !eq(this.posEl[i], other.posEl[i])) return false;
+      if (hasA && !eq(this.posVal[i], other.posVal[i])) return false;
     }
     const negLen = Math.max(this.negLen, other.negLen);
     for (let i = 0; i < negLen; ++i) {
       const hasA = this.hasNeg[i];
       const hasB = other.hasNeg[i];
       if (hasA !== hasB) return false;
-      if (hasA && !eq(this.negEl[i], other.negEl[i])) return false;
+      if (hasA && !eq(this.negVal[i], other.negVal[i])) return false;
     }
     return true;
   }
   toString() {
     if (this.size === 0) return `SignedIndexArray[ ]`;
-    const entries = this.entriesArray().map(([id, el]) => `${id}: ${el}`).join(", ");
+    const entries = this.entriesArray().map(([id, value]) => `${id}: ${value}`).join(", ");
     return `SignedIndexArray[ ${entries} ]`;
   }
 };
 
-// src/core/map.ts
+// src/core/map1.ts
 var Map1 = class _Map1 {
   constructor(entries) {
     __publicField(this, "map1");
@@ -1869,16 +2183,33 @@ var Map1 = class _Map1 {
     }
     return true;
   }
-  filter(fn) {
-    let result = new _Map1();
+  filter(predicate) {
+    const result = new this.constructor();
     for (const [key1, value] of this.map1) {
-      if (fn(value, key1)) result.set(key1, value);
+      if (predicate(value, key1, this)) result.set(key1, value);
     }
     return result;
   }
   reduce(fn, init) {
-    let acc = init;
-    for (const [key1, value] of this.map1) {
+    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;
@@ -1902,9 +2233,11 @@ var Map1 = class _Map1 {
   }
   toString() {
     const entries = [...this.map1].map(([k, v]) => `${k} => ${v}`).join(", ");
-    return `Map1(${this.map1.size}) { ${entries} }`;
+    return entries.length === 0 ? `Map1(0){ }` : `Map1(${this.size}){ ${entries} }`;
   }
 };
+
+// src/core/map2.ts
 var Map2 = class _Map2 {
   constructor(entries) {
     __publicField(this, "map1", /* @__PURE__ */ new Map());
@@ -2030,21 +2363,36 @@ var Map2 = class _Map2 {
     }
     return true;
   }
-  filter(fn) {
-    let result = new _Map2();
+  filter(predicate) {
+    const result = new this.constructor();
     for (const [key1, map2] of this.map1) {
       for (const [key2, value] of map2) {
-        if (fn(value, key1, key2)) result.set(key1, key2, value);
+        if (predicate(value, key1, key2, this)) result.set(key1, key2, value);
       }
     }
     return result;
   }
   reduce(fn, init) {
-    let acc = init;
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, value] of map2) {
-        acc = fn(acc, value, key1, key2);
+    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;
   }
@@ -2081,9 +2429,11 @@ var Map2 = class _Map2 {
       const inner = [...map2].map(([key2, v]) => `${key2} => ${v}`).join(", ");
       entries.push(`${key1} => { ${inner} }`);
     }
-    return `Map2(${this.size}) { ${entries.join(", ")} }`;
+    return entries.length === 0 ? `Map2(0){ }` : `Map2(${this.size}){ ${entries} }`;
   }
 };
+
+// src/core/map3.ts
 var Map3 = class _Map3 {
   constructor(entries) {
     __publicField(this, "map1", /* @__PURE__ */ new Map());
@@ -2232,25 +2582,38 @@ var Map3 = class _Map3 {
     }
     return true;
   }
-  filter(fn) {
-    let result = new _Map3();
+  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 (fn(value, key1, key2, key3)) result.set(key1, key2, key3, value);
+          if (predicate(value, key1, key2, key3, this)) result.set(key1, key2, key3, value);
         }
       }
     }
     return result;
   }
   reduce(fn, init) {
-    let acc = init;
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, map3] of map2) {
-        for (const [key3, value] of map3) {
-          acc = fn(acc, value, key1, key2, key3);
-        }
+    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;
   }
@@ -2295,7 +2658,7 @@ var Map3 = class _Map3 {
         entries.push(`${key1} => ${key2} => { ${inner} }`);
       }
     }
-    return `Map3(${this.size}) { ${entries.join(", ")} }`;
+    return entries.length === 0 ? `Map3(0){ }` : `Map3(${this.size}){ ${entries.join(", ")} }`;
   }
 };
 
@@ -2367,11 +2730,89 @@ var MultiContainer = class {
 function asMulti(base) {
   return new MultiContainer(base);
 }
+
+// src/core/deprecated/vec2.ts
+var Vec2 = class _Vec2 {
+  constructor(x, y) {
+    __publicField(this, "x");
+    __publicField(this, "y");
+    this.x = x ?? 0;
+    this.y = y ?? 0;
+  }
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  add(a) {
+    return new _Vec2(this.x + a.x, this.y + a.y);
+  }
+  sub(a) {
+    return new _Vec2(this.x - a.x, this.y - a.y);
+  }
+  mul(a) {
+    return new _Vec2(this.x * a, this.y * a);
+  }
+  div(a) {
+    return new _Vec2(this.x / a, this.y / a);
+  }
+};
+
+// src/core/deprecated/small-int-cache.ts
+var SmallIntCache = class {
+  // for keys < 0
+  constructor() {
+    __publicField(this, "pos");
+    // for keys >= 0
+    __publicField(this, "neg");
+    this.pos = [];
+    this.neg = [];
+  }
+  set(key, value) {
+    if (!isInteger(key)) {
+      throw new Error("Key must be an integer");
+    } else if (key >= 0) {
+      this.pos[key] = value;
+    } else {
+      this.neg[-key - 1] = value;
+    }
+  }
+  get(key) {
+    if (!isInteger(key)) {
+      throw new Error("Key must be an integer");
+    } else if (key >= 0) {
+      return this.pos[key];
+    } else {
+      return this.neg[-key - 1];
+    }
+  }
+  has(key) {
+    if (!isInteger(key)) {
+      return false;
+    } else if (key >= 0) {
+      return key in this.pos;
+    } else {
+      return -key - 1 in this.neg;
+    }
+  }
+  delete(key) {
+    if (!isInteger(key)) {
+      return;
+    } else if (key >= 0) {
+      delete this.pos[key];
+    } else {
+      delete this.neg[-key - 1];
+    }
+  }
+  clear() {
+    this.pos = [];
+    this.neg = [];
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Assert,
   Cookies,
   Device,
+  DivRect,
   IndexArray,
   LRUCache,
   Map1,
@@ -2382,6 +2823,7 @@ function asMulti(base) {
   SmallIntCache,
   Stack,
   Utils,
+  Vec,
   Vec2,
   asMulti
 });