@tspro/ts-utils-lib 1.14.0 → 1.16.0

package/dist/index.js

@@ -1,4 +1,4 @@
-/* TsUtilsLib v1.14.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+/* TsUtilsLib v1.16.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -26,15 +26,18 @@ __export(index_exports, {
   Assert: () => Assert,
   Cookies: () => Cookies,
   Device: () => Device,
+  IndexArray: () => IndexArray,
   LRUCache: () => LRUCache,
   Map1: () => Map1,
   Map2: () => Map2,
   Map3: () => Map3,
+  MultiContainer: () => MultiContainer,
   SignedIndexArray: () => SignedIndexArray,
   SmallIntCache: () => SmallIntCache,
   Stack: () => Stack,
   Utils: () => utils_exports,
-  Vec2: () => Vec2
+  Vec2: () => Vec2,
+  asMulti: () => asMulti
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -68,136 +71,175 @@ __export(arr_exports, {
   toArray: () => toArray
 });
 
-// src/utils/math/index.ts
-var math_exports = {};
-__export(math_exports, {
-  avg: () => avg,
-  calcNormal: () => calcNormal,
-  clamp: () => clamp,
-  cmp: () => cmp,
-  interpolateCoord: () => interpolateCoord,
-  interpolateY: () => interpolateY,
+// src/utils/is/index.ts
+var is_exports = {};
+__export(is_exports, {
+  isArray: () => isArray,
+  isArrayOrUndefined: () => isArrayOrUndefined,
+  isBoolean: () => isBoolean,
+  isBooleanOrUndefined: () => isBooleanOrUndefined,
+  isEmptyArray: () => isEmptyArray,
+  isEmptyArrayOrUndefined: () => isEmptyArrayOrUndefined,
+  isEmptyString: () => isEmptyString,
+  isEmptyStringOrUndefined: () => isEmptyStringOrUndefined,
+  isEnumValue: () => isEnumValue,
+  isEnumValueOrUndefined: () => isEnumValueOrUndefined,
+  isFinite: () => isFinite2,
+  isFunction: () => isFunction,
+  isFunctionOrUndefined: () => isFunctionOrUndefined,
+  isInfinity: () => isInfinity,
   isInteger: () => isInteger,
-  linearToDecibels: () => linearToDecibels,
-  mod: () => mod,
-  romanize: () => romanize,
-  sum: () => sum,
-  toOrdinalNumber: () => toOrdinalNumber
+  isIntegerBetween: () => isIntegerBetween,
+  isIntegerEq: () => isIntegerEq,
+  isIntegerGt: () => isIntegerGt,
+  isIntegerGte: () => isIntegerGte,
+  isIntegerLt: () => isIntegerLt,
+  isIntegerLte: () => isIntegerLte,
+  isIntegerOrUndefined: () => isIntegerOrUndefined,
+  isNaNValue: () => isNaNValue,
+  isNegInfinity: () => isNegInfinity,
+  isNonEmptyArray: () => isNonEmptyArray,
+  isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined,
+  isNonEmptyString: () => isNonEmptyString,
+  isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined,
+  isNull: () => isNull,
+  isNullish: () => isNullish,
+  isNumber: () => isNumber,
+  isNumberOrUndefined: () => isNumberOrUndefined,
+  isObject: () => isObject,
+  isObjectOrUndefined: () => isObjectOrUndefined,
+  isPosInfinity: () => isPosInfinity,
+  isString: () => isString,
+  isStringOrUndefined: () => isStringOrUndefined,
+  isUndefined: () => isUndefined
+});
+
+// src/utils/enum/index.ts
+var enum_exports = {};
+__export(enum_exports, {
+  getEnumValues: () => getEnumValues
 });
+function getEnumValues(e) {
+  return Object.keys(e).filter((key) => Number.isNaN(Number(key))).map((key) => e[key]);
+}
+
+// src/utils/is/index.ts
+function isUndefined(value) {
+  return value === void 0;
+}
+function isNull(value) {
+  return value === null;
+}
+function isNullish(value) {
+  return value === void 0 || value === null;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !isArray(value);
+}
+function isObjectOrUndefined(value) {
+  return value === void 0 || isObject(value);
+}
+function isArray(a) {
+  return !!a && Object.prototype.toString.call(a) === "[object Array]";
+}
+function isArrayOrUndefined(value) {
+  return value === void 0 || isArray(value);
+}
+function isEmptyArray(a) {
+  return isArray(a) && a.length === 0;
+}
+function isNonEmptyArray(a) {
+  return isArray(a) && a.length > 0;
+}
+function isEmptyArrayOrUndefined(a) {
+  return isArray(a) && a.length === 0 || a === void 0;
+}
+function isNonEmptyArrayOrUndefined(a) {
+  return isArray(a) && a.length > 0 || a === void 0;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isEmptyString(value) {
+  return typeof value === "string" && value.length === 0;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isStringOrUndefined(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isEmptyStringOrUndefined(value) {
+  return typeof value === "string" && value.length === 0 || value === void 0;
+}
+function isNonEmptyStringOrUndefined(value) {
+  return typeof value === "string" && value.length > 0 || value === void 0;
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isBooleanOrUndefined(value) {
+  return value === void 0 || typeof value === "boolean";
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isFunctionOrUndefined(value) {
+  return value === void 0 || typeof value === "function";
+}
+function isEnumValue(value, enumObj, name = "value") {
+  return getEnumValues(enumObj).some((v) => v === value);
+}
+function isEnumValueOrUndefined(value, enumObj, name = "value") {
+  return value === void 0 || getEnumValues(enumObj).some((v) => v === value);
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isNumberOrUndefined(value) {
+  return typeof value === "number" || value === void 0;
+}
+function isFinite2(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
 function isInteger(n) {
-  return typeof n === "number" && isFinite(n) && n === Math.trunc(n);
+  return typeof n === "number" && isFinite2(n) && n === Math.trunc(n);
 }
-function linearToDecibels(linearVolume) {
-  if (!isFinite(linearVolume)) {
-    throw new Error("linearToDecibel: Invalid linearVolume = " + linearVolume);
-  } else if (linearVolume <= 0) {
-    return -Infinity;
-  } else {
-    return 20 * Math.log10(linearVolume);
-  }
+function isIntegerOrUndefined(n) {
+  return typeof n === "number" && isFinite2(n) && n === Math.trunc(n) || n === void 0;
 }
-function mod(m, n) {
-  return (m % n + n) % n;
+function isIntegerEq(value, compareTo) {
+  return isInteger(value) && value === compareTo;
 }
-function romanize(n) {
-  if (!isInteger(n) || n < 0) {
-    throw new Error("romanize: Invalid n = " + n);
-  }
-  var digits = String(+n).split("");
-  var key = [
-    "",
-    "C",
-    "CC",
-    "CCC",
-    "CD",
-    "D",
-    "DC",
-    "DCC",
-    "DCCC",
-    "CM",
-    "",
-    "X",
-    "XX",
-    "XXX",
-    "XL",
-    "L",
-    "LX",
-    "LXX",
-    "LXXX",
-    "XC",
-    "",
-    "I",
-    "II",
-    "III",
-    "IV",
-    "V",
-    "VI",
-    "VII",
-    "VIII",
-    "IX"
-  ];
-  var roman = "", i = 3;
-  while (i--) roman = (key[+digits.pop() + i * 10] || "") + roman;
-  return Array(+digits.join("") + 1).join("M") + roman;
+function isIntegerGt(value, compareTo) {
+  return isInteger(value) && value > compareTo;
 }
-function toOrdinalNumber(n) {
-  if (!isInteger(n)) {
-    throw new Error("toOrdinalNumber: Invalid n = " + n);
-  }
-  const nStr = n.toString();
-  const lastDigit = Number(nStr.charAt(nStr.length - 1));
-  if (n === 1 || n >= 20 && lastDigit === 1) {
-    return nStr + "st";
-  } else if (n === 2 || n >= 20 && lastDigit === 2) {
-    return nStr + "nd";
-  } else if (n === 3 || n >= 20 && lastDigit === 3) {
-    return nStr + "rd";
-  } else {
-    return nStr + "th";
-  }
+function isIntegerGte(value, compareTo) {
+  return isInteger(value) && value >= compareTo;
 }
-function interpolateCoord(startX, startY, endX, endY, t) {
-  return {
-    x: startX + (endX - startX) * t,
-    y: startY + (endY - startY) * t
-  };
+function isIntegerLt(value, compareTo) {
+  return isInteger(value) && value < compareTo;
 }
-function interpolateY(startX, startY, endX, endY, x) {
-  let t = (x - startX) / (endX - startX);
-  return startY + (endY - startY) * t;
+function isIntegerLte(value, compareTo) {
+  return isInteger(value) && value <= compareTo;
 }
-function clamp(num, min, max) {
-  return Math.min(Math.max(num, min), max);
+function isIntegerBetween(value, min, max) {
+  return isInteger(value) && value >= min && value <= max;
 }
-function calcNormal(x1, y1, x2, y2) {
-  let dx = x2 - x1;
-  let dy = y2 - y1;
-  let nx = -dy;
-  let ny = dx;
-  let len = Math.sqrt(nx * nx + ny * ny);
-  if (len > 0) {
-    nx /= len;
-    ny /= len;
-  } else {
-    nx = 0;
-    ny = 1;
-  }
-  return { nx, ny };
+function isNaNValue(value) {
+  return typeof value === "number" && Number.isNaN(value);
 }
-function sum(arr) {
-  return arr.reduce((prev, cur) => cur + prev, 0);
+function isInfinity(value) {
+  return typeof value === "number" && Math.abs(value) === Infinity;
 }
-function avg(...values) {
-  return sum(values) / values.length;
+function isPosInfinity(value) {
+  return typeof value === "number" && value === Infinity;
 }
-function cmp(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
+function isNegInfinity(value) {
+  return typeof value === "number" && value === -Infinity;
 }
 
 // src/utils/arr/index.ts
-function isArray(a) {
-  return !!a && Object.prototype.toString.call(a) === "[object Array]";
-}
 function toArray(a) {
   return isArray(a) ? a : [a];
 }
@@ -284,15 +326,6 @@ __export(dom_exports, {
   styleLayoutChanged: () => styleLayoutChanged
 });
 
-// src/utils/enum/index.ts
-var enum_exports = {};
-__export(enum_exports, {
-  getEnumValues: () => getEnumValues
-});
-function getEnumValues(e) {
-  return Object.keys(e).filter((key) => Number.isNaN(Number(key))).map((key) => e[key]);
-}
-
 // src/modules/assert.ts
 var Assert;
 ((Assert2) => {
@@ -712,172 +745,139 @@ function getCanvasTextWidth(text, font) {
   return ctx.measureText(text).width;
 }
 
-// src/utils/is/index.ts
-var is_exports = {};
-__export(is_exports, {
-  isArray: () => isArray2,
-  isArrayOrUndefined: () => isArrayOrUndefined,
-  isBoolean: () => isBoolean,
-  isBooleanOrUndefined: () => isBooleanOrUndefined,
-  isEmptyArray: () => isEmptyArray,
-  isEmptyArrayOrUndefined: () => isEmptyArrayOrUndefined,
-  isEmptyString: () => isEmptyString,
-  isEmptyStringOrUndefined: () => isEmptyStringOrUndefined,
-  isEnumValue: () => isEnumValue,
-  isEnumValueOrUndefined: () => isEnumValueOrUndefined,
-  isFinite: () => isFinite2,
-  isFunction: () => isFunction,
-  isFunctionOrUndefined: () => isFunctionOrUndefined,
-  isInfinity: () => isInfinity,
-  isInteger: () => isInteger2,
-  isIntegerBetween: () => isIntegerBetween,
-  isIntegerEq: () => isIntegerEq,
-  isIntegerGt: () => isIntegerGt,
-  isIntegerGte: () => isIntegerGte,
-  isIntegerLt: () => isIntegerLt,
-  isIntegerLte: () => isIntegerLte,
-  isIntegerOrUndefined: () => isIntegerOrUndefined,
-  isNaNValue: () => isNaNValue,
-  isNegInfinity: () => isNegInfinity,
-  isNonEmptyArray: () => isNonEmptyArray,
-  isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined,
-  isNonEmptyString: () => isNonEmptyString,
-  isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined,
-  isNull: () => isNull,
-  isNullish: () => isNullish,
-  isNumber: () => isNumber,
-  isNumberOrUndefined: () => isNumberOrUndefined,
-  isObject: () => isObject,
-  isObjectOrUndefined: () => isObjectOrUndefined,
-  isPosInfinity: () => isPosInfinity,
-  isString: () => isString,
-  isStringOrUndefined: () => isStringOrUndefined,
-  isUndefined: () => isUndefined
+// src/utils/map/index.ts
+var map_exports = {};
+__export(map_exports, {
+  getMapKeys: () => getMapKeys
 });
-function isUndefined(value) {
-  return value === void 0;
-}
-function isNull(value) {
-  return value === null;
-}
-function isNullish(value) {
-  return value === void 0 || value === null;
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null && !isArray2(value);
-}
-function isObjectOrUndefined(value) {
-  return value === void 0 || isObject(value);
-}
-function isArray2(a) {
-  return !!a && Object.prototype.toString.call(a) === "[object Array]";
-}
-function isArrayOrUndefined(value) {
-  return value === void 0 || isArray2(value);
-}
-function isEmptyArray(a) {
-  return isArray2(a) && a.length === 0;
-}
-function isNonEmptyArray(a) {
-  return isArray2(a) && a.length > 0;
-}
-function isEmptyArrayOrUndefined(a) {
-  return isArray2(a) && a.length === 0 || a === void 0;
-}
-function isNonEmptyArrayOrUndefined(a) {
-  return isArray2(a) && a.length > 0 || a === void 0;
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function isEmptyString(value) {
-  return typeof value === "string" && value.length === 0;
-}
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0;
-}
-function isStringOrUndefined(value) {
-  return value === void 0 || typeof value === "string";
-}
-function isEmptyStringOrUndefined(value) {
-  return typeof value === "string" && value.length === 0 || value === void 0;
-}
-function isNonEmptyStringOrUndefined(value) {
-  return typeof value === "string" && value.length > 0 || value === void 0;
-}
-function isBoolean(value) {
-  return typeof value === "boolean";
-}
-function isBooleanOrUndefined(value) {
-  return value === void 0 || typeof value === "boolean";
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function isFunctionOrUndefined(value) {
-  return value === void 0 || typeof value === "function";
-}
-function isEnumValue(value, enumObj, name = "value") {
-  return getEnumValues(enumObj).some((v) => v === value);
-}
-function isEnumValueOrUndefined(value, enumObj, name = "value") {
-  return value === void 0 || getEnumValues(enumObj).some((v) => v === value);
-}
-function isNumber(value) {
-  return typeof value === "number";
-}
-function isNumberOrUndefined(value) {
-  return typeof value === "number" || value === void 0;
-}
-function isFinite2(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function isInteger2(n) {
-  return typeof n === "number" && isFinite2(n) && n === Math.trunc(n);
-}
-function isIntegerOrUndefined(n) {
-  return typeof n === "number" && isFinite2(n) && n === Math.trunc(n) || n === void 0;
+function getMapKeys(map) {
+  let keys = [];
+  map.forEach((value, key) => keys.push(key));
+  return keys;
 }
-function isIntegerEq(value, compareTo) {
-  return isInteger2(value) && value === compareTo;
+
+// src/utils/math/index.ts
+var math_exports = {};
+__export(math_exports, {
+  avg: () => avg,
+  calcNormal: () => calcNormal,
+  clamp: () => clamp,
+  cmp: () => cmp,
+  interpolateCoord: () => interpolateCoord,
+  interpolateY: () => interpolateY,
+  isInteger: () => isInteger,
+  isNumber: () => isNumber,
+  linearToDecibels: () => linearToDecibels,
+  mod: () => mod,
+  romanize: () => romanize,
+  sum: () => sum,
+  toOrdinalNumber: () => toOrdinalNumber
+});
+function linearToDecibels(linearVolume) {
+  if (!isFinite(linearVolume)) {
+    throw new Error("linearToDecibel: Invalid linearVolume = " + linearVolume);
+  } else if (linearVolume <= 0) {
+    return -Infinity;
+  } else {
+    return 20 * Math.log10(linearVolume);
+  }
 }
-function isIntegerGt(value, compareTo) {
-  return isInteger2(value) && value > compareTo;
+function mod(m, n) {
+  return (m % n + n) % n;
 }
-function isIntegerGte(value, compareTo) {
-  return isInteger2(value) && value >= compareTo;
+function romanize(n) {
+  if (!isInteger(n) || n < 0) {
+    throw new Error("romanize: Invalid n = " + n);
+  }
+  var digits = String(+n).split("");
+  var key = [
+    "",
+    "C",
+    "CC",
+    "CCC",
+    "CD",
+    "D",
+    "DC",
+    "DCC",
+    "DCCC",
+    "CM",
+    "",
+    "X",
+    "XX",
+    "XXX",
+    "XL",
+    "L",
+    "LX",
+    "LXX",
+    "LXXX",
+    "XC",
+    "",
+    "I",
+    "II",
+    "III",
+    "IV",
+    "V",
+    "VI",
+    "VII",
+    "VIII",
+    "IX"
+  ];
+  var roman = "", i = 3;
+  while (i--) roman = (key[+digits.pop() + i * 10] || "") + roman;
+  return Array(+digits.join("") + 1).join("M") + roman;
 }
-function isIntegerLt(value, compareTo) {
-  return isInteger2(value) && value < compareTo;
+function toOrdinalNumber(n) {
+  if (!isInteger(n)) {
+    throw new Error("toOrdinalNumber: Invalid n = " + n);
+  }
+  const nStr = n.toString();
+  const lastDigit = Number(nStr.charAt(nStr.length - 1));
+  if (n === 1 || n >= 20 && lastDigit === 1) {
+    return nStr + "st";
+  } else if (n === 2 || n >= 20 && lastDigit === 2) {
+    return nStr + "nd";
+  } else if (n === 3 || n >= 20 && lastDigit === 3) {
+    return nStr + "rd";
+  } else {
+    return nStr + "th";
+  }
 }
-function isIntegerLte(value, compareTo) {
-  return isInteger2(value) && value <= compareTo;
+function interpolateCoord(startX, startY, endX, endY, t) {
+  return {
+    x: startX + (endX - startX) * t,
+    y: startY + (endY - startY) * t
+  };
 }
-function isIntegerBetween(value, min, max) {
-  return isInteger2(value) && value >= min && value <= max;
+function interpolateY(startX, startY, endX, endY, x) {
+  let t = (x - startX) / (endX - startX);
+  return startY + (endY - startY) * t;
 }
-function isNaNValue(value) {
-  return typeof value === "number" && Number.isNaN(value);
+function clamp(num, min, max) {
+  return Math.min(Math.max(num, min), max);
 }
-function isInfinity(value) {
-  return typeof value === "number" && Math.abs(value) === Infinity;
+function calcNormal(x1, y1, x2, y2) {
+  let dx = x2 - x1;
+  let dy = y2 - y1;
+  let nx = -dy;
+  let ny = dx;
+  let len = Math.sqrt(nx * nx + ny * ny);
+  if (len > 0) {
+    nx /= len;
+    ny /= len;
+  } else {
+    nx = 0;
+    ny = 1;
+  }
+  return { nx, ny };
 }
-function isPosInfinity(value) {
-  return typeof value === "number" && value === Infinity;
+function sum(arr) {
+  return arr.reduce((prev, cur) => cur + prev, 0);
 }
-function isNegInfinity(value) {
-  return typeof value === "number" && value === -Infinity;
+function avg(...values) {
+  return sum(values) / values.length;
 }
-
-// src/utils/map/index.ts
-var map_exports = {};
-__export(map_exports, {
-  getMapKeys: () => getMapKeys
-});
-function getMapKeys(map) {
-  let keys = [];
-  map.forEach((value, key) => keys.push(key));
-  return keys;
+function cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
 }
 
 // src/utils/obj/index.ts
@@ -885,13 +885,10 @@ var obj_exports = {};
 __export(obj_exports, {
   deepEqual: () => deepEqual,
   hasProperties: () => hasProperties,
-  isObject: () => isObject2
+  isObject: () => isObject
 });
-function isObject2(obj) {
-  return typeof obj === "object" && obj !== null && !isArray(obj);
-}
 function hasProperties(obj, props) {
-  return isObject2(obj) && props.every((p) => p in obj);
+  return isObject(obj) && props.every((p) => p in obj);
 }
 function deepEqual(a, b) {
   if (a === b) return true;
@@ -918,6 +915,7 @@ __export(str_exports, {
   charCount: () => charCount,
   chunkString: () => chunkString,
   insertAt: () => insertAt,
+  isString: () => isString,
   makeSentenceFromPascal: () => makeSentenceFromPascal,
   removeAt: () => removeAt,
   repeatString: () => repeatString,
@@ -1193,103 +1191,316 @@ var LRUCache = class {
     if (this.size >= this.capacity) {
       this.evict();
     }
-    this.cache[key] = value;
-    this.addToTail(key);
-    this.size++;
+    this.cache[key] = value;
+    this.addToTail(key);
+    this.size++;
+  }
+  // Marks a key as most recently used
+  touch(key) {
+    if (this.tail === key) return;
+    this.removeKey(key);
+    this.addToTail(key);
+  }
+  // Evicts the least recently used item (at the head)
+  evict() {
+    if (this.head !== null) {
+      const oldestKey = this.head;
+      this.removeKey(oldestKey);
+      delete this.cache[oldestKey];
+      this.size--;
+    }
+  }
+  // Removes a key from the linked list
+  removeKey(key) {
+    const prevKey = this.prev[key];
+    const nextKey = this.next[key];
+    if (prevKey !== void 0) {
+      this.next[prevKey] = nextKey;
+    } else {
+      this.head = nextKey ?? null;
+    }
+    if (nextKey !== void 0) {
+      this.prev[nextKey] = prevKey;
+    } else {
+      this.tail = prevKey ?? null;
+    }
+    delete this.prev[key];
+    delete this.next[key];
+  }
+  // Adds a key to the tail (most recently used position)
+  addToTail(key) {
+    if (this.tail !== null) {
+      this.next[this.tail] = key;
+      this.prev[key] = this.tail;
+    } else {
+      this.head = key;
+    }
+    this.tail = key;
+  }
+};
+
+// 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, "hasPos");
+    // number of elems
+    __publicField(this, "elCount");
+    if (entries instanceof _IndexArray) {
+      this.posEl = entries.posEl.slice();
+      this.hasPos = entries.hasPos.slice();
+      this.elCount = entries.elCount;
+    } else {
+      this.posEl = [];
+      this.hasPos = [];
+      this.elCount = 0;
+      if (entries) {
+        for (const [id, el] of entries) {
+          this.set(id, el);
+        }
+      }
+    }
+  }
+  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;
+  }
+  get posLen() {
+    return this.hasPos.length;
+  }
+  get size() {
+    return this.elCount;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  has(id) {
+    _IndexArray.validateIndex(id);
+    return this.hasPos[id] === true;
+  }
+  set(id, el) {
+    _IndexArray.validateIndex(id);
+    if (this.hasPos[id] !== true) this.elCount++;
+    this.posEl[id] = el;
+    this.hasPos[id] = true;
+  }
+  get(id) {
+    _IndexArray.validateIndex(id);
+    return this.hasPos[id] ? this.posEl[id] : void 0;
+  }
+  getOrDefault(id, defaultValue) {
+    return this.get(id) ?? defaultValue;
+  }
+  getOrCreate(id, creatorOrValue) {
+    if (!this.has(id)) {
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(id, value);
+      return value;
+    }
+    return this.get(id);
+  }
+  delete(id) {
+    _IndexArray.validateIndex(id);
+    if (!this.hasPos[id]) return false;
+    this.posEl[id] = void 0;
+    this.hasPos[id] = false;
+    this.elCount--;
+    return true;
+  }
+  clear() {
+    this.posEl = [];
+    this.hasPos = [];
+    this.elCount = 0;
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [id, el] of this.entries()) {
+      callbackfn.call(thisArg, el, id, this);
+    }
+  }
+  *indices() {
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield id;
+    }
+  }
+  *values() {
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield this.posEl[id];
+    }
+  }
+  *entries() {
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield [id, this.posEl[id]];
+    }
+  }
+  indicesArray() {
+    return [...this.indices()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const id of this.indices()) {
+      yield [id];
+    }
   }
-  // Marks a key as most recently used
-  touch(key) {
-    if (this.tail === key) return;
-    this.removeKey(key);
-    this.addToTail(key);
+  *kvValues() {
+    for (const el of this.values()) {
+      yield el;
+    }
   }
-  // Evicts the least recently used item (at the head)
-  evict() {
-    if (this.head !== null) {
-      const oldestKey = this.head;
-      this.removeKey(oldestKey);
-      delete this.cache[oldestKey];
-      this.size--;
+  *kvEntries() {
+    for (const [id, el] of this.entries()) {
+      yield [[id], el];
     }
   }
-  // Removes a key from the linked list
-  removeKey(key) {
-    const prevKey = this.prev[key];
-    const nextKey = this.next[key];
-    if (prevKey !== void 0) {
-      this.next[prevKey] = nextKey;
-    } else {
-      this.head = nextKey ?? null;
+  *[Symbol.iterator]() {
+    yield* this.entries();
+  }
+  clone() {
+    return new _IndexArray(this);
+  }
+  merge(other, conflictResolver) {
+    for (const [id, value] of other.entries()) {
+      if (this.has(id) && conflictResolver) {
+        this.set(id, conflictResolver(this.get(id), value, id));
+      } else {
+        this.set(id, value);
+      }
     }
-    if (nextKey !== void 0) {
-      this.prev[nextKey] = prevKey;
-    } else {
-      this.tail = prevKey ?? null;
+    return this;
+  }
+  some(fn) {
+    for (const [id, el] of this.entries()) {
+      if (fn(el, id)) return true;
     }
-    delete this.prev[key];
-    delete this.next[key];
+    return false;
   }
-  // Adds a key to the tail (most recently used position)
-  addToTail(key) {
-    if (this.tail !== null) {
-      this.next[this.tail] = key;
-      this.prev[key] = this.tail;
-    } else {
-      this.head = key;
+  every(fn) {
+    for (const [id, el] of this.entries()) {
+      if (!fn(el, id)) return false;
     }
-    this.tail = key;
+    return true;
   }
-};
-
-// 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 = [];
+  filter(fn) {
+    let result = new _IndexArray();
+    for (const [id, el] of this.entries()) {
+      if (fn(el, id)) result.set(id, el);
+    }
+    return result;
   }
-  set(key, value) {
-    if (!isInteger(key)) {
-      throw new Error("Key must be an integer");
-    } else if (key >= 0) {
-      this.pos[key] = value;
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty IndexArray with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[1];
+      start = iterator.next();
     } else {
-      this.neg[-key - 1] = value;
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [id, el] = current.value;
+      acc = fn(acc, el, id);
     }
+    return acc;
   }
-  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];
+  mapToArray(fn) {
+    let result = [];
+    for (const [id, el] of this.entries()) {
+      result.push(fn(el, id));
     }
+    return result;
   }
-  has(key) {
-    if (!isInteger(key)) {
-      return false;
-    } else if (key >= 0) {
-      return key in this.pos;
-    } else {
-      return -key - 1 in this.neg;
+  map(fn) {
+    let result = new _IndexArray();
+    for (const [id, el] of this.entries()) {
+      result.set(id, fn(el, id));
     }
+    return result;
   }
-  delete(key) {
-    if (!isInteger(key)) {
-      return;
-    } else if (key >= 0) {
-      delete this.pos[key];
-    } else {
-      delete this.neg[-key - 1];
+  equals(other, eq) {
+    if (this.size !== other.size) return false;
+    eq ?? (eq = (a, b) => a === b);
+    const posLen = Math.max(this.posLen, other.posLen);
+    for (let i = 0; i < posLen; ++i) {
+      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;
     }
+    return true;
   }
-  clear() {
-    this.pos = [];
-    this.neg = [];
+  toString() {
+    if (this.size === 0) return `IndexArray[ ]`;
+    const entries = this.entriesArray().map(([id, el]) => `${id}: ${el}`).join(", ");
+    return `IndexArray[ ${entries} ]`;
   }
 };
 
@@ -1326,38 +1537,50 @@ var SignedIndexArray = class _SignedIndexArray {
   static toNegIndex(id) {
     return -id - 1;
   }
+  static validateIndex(id) {
+    if (!isInteger(id)) throw new Error(`Invalid index ${id} - must be an integer!`);
+    return id;
+  }
   get size() {
     return this.elCount;
   }
+  isEmpty() {
+    return this.size === 0;
+  }
+  get posLen() {
+    return this.hasPos.length;
+  }
+  get negLen() {
+    return this.hasNeg.length;
+  }
   has(id) {
-    if (!isInteger(id)) {
-      return false;
-    } else if (id >= 0) {
+    _SignedIndexArray.validateIndex(id);
+    if (id >= 0) {
       return this.hasPos[id] === true;
     } else {
       return this.hasNeg[_SignedIndexArray.toNegIndex(id)] === true;
     }
   }
   set(id, el) {
-    if (!isInteger(id)) {
-      throw new Error("Index must be an integer");
-    } else if (id >= 0) {
+    _SignedIndexArray.validateIndex(id);
+    if (id >= 0) {
       if (this.hasPos[id] !== true) this.elCount++;
       this.posEl[id] = el;
       this.hasPos[id] = true;
     } else {
-      if (this.hasNeg[_SignedIndexArray.toNegIndex(id)] !== true) this.elCount++;
-      this.negEl[_SignedIndexArray.toNegIndex(id)] = el;
-      this.hasNeg[_SignedIndexArray.toNegIndex(id)] = true;
+      let negId = _SignedIndexArray.toNegIndex(id);
+      if (this.hasNeg[negId] !== true) this.elCount++;
+      this.negEl[negId] = el;
+      this.hasNeg[negId] = true;
     }
   }
   get(id) {
-    if (!isInteger(id)) {
-      throw new Error("Index must be an integer");
-    } else if (id >= 0) {
+    _SignedIndexArray.validateIndex(id);
+    if (id >= 0) {
       return this.hasPos[id] ? this.posEl[id] : void 0;
     } else {
-      return this.hasNeg[_SignedIndexArray.toNegIndex(id)] ? this.negEl[_SignedIndexArray.toNegIndex(id)] : void 0;
+      let negId = _SignedIndexArray.toNegIndex(id);
+      return this.hasNeg[negId] ? this.negEl[negId] : void 0;
     }
   }
   getOrDefault(id, defaultValue) {
@@ -1372,7 +1595,7 @@ var SignedIndexArray = class _SignedIndexArray {
     return this.get(id);
   }
   delete(id) {
-    if (!isInteger(id)) return false;
+    _SignedIndexArray.validateIndex(id);
     const isPos = id >= 0;
     const arr = isPos ? this.posEl : this.negEl;
     const has = isPos ? this.hasPos : this.hasNeg;
@@ -1395,45 +1618,54 @@ var SignedIndexArray = class _SignedIndexArray {
       callbackfn.call(thisArg, el, id, this);
     }
   }
-  indices() {
-    function* gen(self) {
-      for (let id = self.negEl.length - 1; id >= 0; id--) {
-        if (self.hasNeg[id]) yield _SignedIndexArray.toNegIndex(id);
-      }
-      for (let id = 0; id < self.posEl.length; id++) {
-        if (self.hasPos[id]) yield id;
-      }
+  *indices() {
+    for (let id = this.negLen - 1; id >= 0; id--) {
+      if (this.hasNeg[id]) yield _SignedIndexArray.toNegIndex(id);
     }
-    return gen(this);
-  }
-  indicesArray() {
-    return [...this.indices()];
-  }
-  values() {
-    function* gen(self) {
-      for (let id = self.negEl.length - 1; id >= 0; id--) {
-        if (self.hasNeg[id]) yield self.negEl[id];
-      }
-      for (let id = 0; id < self.posEl.length; id++) {
-        if (self.hasPos[id]) yield self.posEl[id];
-      }
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield id;
     }
-    return gen(this);
   }
-  valuesArray() {
-    return [...this.values()];
+  *values() {
+    for (let id = this.negLen - 1; id >= 0; id--) {
+      if (this.hasNeg[id]) yield this.negEl[id];
+    }
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield this.posEl[id];
+    }
   }
   *entries() {
-    for (let id = this.negEl.length - 1; id >= 0; id--) {
+    for (let id = this.negLen - 1; id >= 0; id--) {
       if (this.hasNeg[id]) yield [_SignedIndexArray.toNegIndex(id), this.negEl[id]];
     }
-    for (let id = 0; id < this.posEl.length; id++) {
+    for (let id = 0; id < this.posLen; id++) {
       if (this.hasPos[id]) yield [id, this.posEl[id]];
     }
   }
+  indicesArray() {
+    return [...this.indices()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
   entriesArray() {
     return [...this.entries()];
   }
+  *kvKeys() {
+    for (const id of this.indices()) {
+      yield [id];
+    }
+  }
+  *kvValues() {
+    for (const el of this.values()) {
+      yield el;
+    }
+  }
+  *kvEntries() {
+    for (const [id, el] of this.entries()) {
+      yield [[id], el];
+    }
+  }
   *[Symbol.iterator]() {
     yield* this.entries();
   }
@@ -1507,7 +1739,27 @@ var SignedIndexArray = class _SignedIndexArray {
     }
     return result;
   }
+  equals(other, eq) {
+    if (this.size !== other.size) return false;
+    eq ?? (eq = (a, b) => a === b);
+    const posLen = Math.max(this.posLen, other.posLen);
+    for (let i = 0; i < posLen; ++i) {
+      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;
+    }
+    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;
+    }
+    return true;
+  }
   toString() {
+    if (this.size === 0) return `SignedIndexArray[ ]`;
     const entries = this.entriesArray().map(([id, el]) => `${id}: ${el}`).join(", ");
     return `SignedIndexArray[ ${entries} ]`;
   }
@@ -1549,28 +1801,46 @@ var Map1 = class _Map1 {
   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() {
-    return this.map1.keys();
+  *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()];
   }
-  values() {
-    return this.map1.values();
-  }
   valuesArray() {
     return [...this.values()];
   }
-  *entries() {
-    for (const [key1, value] of this.map1)
-      yield [key1, value];
-  }
   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();
   }
@@ -1686,39 +1956,48 @@ var Map2 = class _Map2 {
     }
     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() {
-    function* gen(map1) {
-      for (const [key1, map2] of map1)
-        for (const key2 of map2.keys())
-          yield [key1, key2];
-    }
-    return gen(this.map1);
-  }
-  keysArray() {
-    return [...this.keys()];
-  }
-  values() {
-    function* gen(map1) {
-      for (const map2 of map1.values())
-        for (const value of map2.values())
-          yield value;
-    }
-    return gen(this.map1);
+  *keys() {
+    for (const [key1, map2] of this.map1)
+      for (const key2 of map2.keys())
+        yield [key1, key2];
   }
-  valuesArray() {
-    return [...this.values()];
+  *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();
   }
@@ -1872,32 +2151,23 @@ var Map3 = class _Map3 {
     }
     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() {
-    function* gen(map1) {
-      for (const [key1, map2] of map1)
-        for (const [key2, map3] of map2)
-          for (const key3 of map3.keys())
-            yield [key1, key2, key3];
-    }
-    return gen(this.map1);
-  }
-  keysArray() {
-    return [...this.keys()];
-  }
-  values() {
-    function* gen(map1) {
-      for (const map2 of map1.values())
-        for (const map3 of map2.values())
-          for (const value of map3.values())
-            yield value;
-    }
-    return gen(this.map1);
+  *keys() {
+    for (const [key1, map2] of this.map1)
+      for (const [key2, map3] of map2)
+        for (const key3 of map3.keys())
+          yield [key1, key2, key3];
   }
-  valuesArray() {
-    return [...this.values()];
+  *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)
@@ -1905,9 +2175,27 @@ var Map3 = class _Map3 {
         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();
   }
@@ -2010,19 +2298,91 @@ var Map3 = class _Map3 {
     return `Map3(${this.size}) { ${entries.join(", ")} }`;
   }
 };
+
+// src/core/multi-container.ts
+var MultiContainer = class {
+  constructor(base) {
+    this.base = base;
+  }
+  isEmpty() {
+    return this.base.isEmpty();
+  }
+  clear() {
+    this.base.clear?.();
+  }
+  add(...keysAndValue) {
+    const keys = keysAndValue.slice(0, -1);
+    const value = keysAndValue[keysAndValue.length - 1];
+    const arr = this.base.get(...keys);
+    this.base.set(...[...keys, arr ? [...arr, value] : [value]]);
+    return value;
+  }
+  remove(...keysAndValue) {
+    const keys = keysAndValue.slice(0, -1);
+    const value = keysAndValue[keysAndValue.length - 1];
+    const arr = this.base.get(...keys);
+    if (!arr) return false;
+    const i = arr.indexOf(value);
+    if (i === -1) return false;
+    arr.splice(i, 1);
+    if (arr.length === 0) this.base.delete(...keys);
+    return true;
+  }
+  getAll(...keys) {
+    return this.base.get(...keys) ?? [];
+  }
+  *iterAll(...keys) {
+    yield* this.getAll(...keys);
+  }
+  *values() {
+    for (const keys of this.keys()) {
+      yield* this.getAll(...keys);
+    }
+  }
+  *keys() {
+    for (const keys of this.base.kvKeys()) {
+      yield keys;
+    }
+  }
+  *entries() {
+    for (const keys of this.keys()) {
+      const arr = this.getAll(...keys);
+      if (arr.length > 0) yield [keys, arr];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  toString() {
+    const entries = [];
+    for (const keys of this.keys()) {
+      const arr = this.getAll(...keys);
+      const keyStr = Array.isArray(keys) ? `[${keys.map((k) => JSON.stringify(k)).join(", ")}]` : `[${JSON.stringify(keys)}]`;
+      const valuesStr = Array.isArray(arr) ? `[${arr.map((v) => JSON.stringify(v)).join(", ")}]` : "[]";
+      entries.push(`${keyStr} => ${valuesStr}`);
+    }
+    return `MultiContainer{ ${entries.join(", ")} }`;
+  }
+};
+function asMulti(base) {
+  return new MultiContainer(base);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Assert,
   Cookies,
   Device,
+  IndexArray,
   LRUCache,
   Map1,
   Map2,
   Map3,
+  MultiContainer,
   SignedIndexArray,
   SmallIntCache,
   Stack,
   Utils,
-  Vec2
+  Vec2,
+  asMulti
 });
 //# sourceMappingURL=index.js.map