@tspro/ts-utils-lib 1.13.0 → 1.15.0

package/dist/index.js

@@ -1,4 +1,4 @@
-/* TsUtilsLib v1.13.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+/* TsUtilsLib v1.15.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -26,14 +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);
 
@@ -67,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];
 }
@@ -283,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) => {
@@ -711,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
@@ -884,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;
@@ -917,6 +915,7 @@ __export(str_exports, {
   charCount: () => charCount,
   chunkString: () => chunkString,
   insertAt: () => insertAt,
+  isString: () => isString,
   makeSentenceFromPascal: () => makeSentenceFromPascal,
   removeAt: () => removeAt,
   repeatString: () => repeatString,
@@ -1292,6 +1291,444 @@ var SmallIntCache = class {
   }
 };
 
+// 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 size() {
+    return this.elCount;
+  }
+  get posLen() {
+    return this.hasPos.length;
+  }
+  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;
+    }
+  }
+  indicesArray() {
+    return [...this.indices()];
+  }
+  *values() {
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield this.posEl[id];
+    }
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  *entries() {
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield [id, this.posEl[id]];
+    }
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *[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);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [id, el] of this.entries()) {
+      if (fn(el, id)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [id, el] of this.entries()) {
+      if (!fn(el, 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);
+    }
+    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 IndexArray 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 [id, el] = current.value;
+      acc = fn(acc, el, id);
+    }
+    return acc;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const [id, el] of this.entries()) {
+      result.push(fn(el, id));
+    }
+    return result;
+  }
+  map(fn) {
+    let result = new _IndexArray();
+    for (const [id, el] of this.entries()) {
+      result.set(id, fn(el, id));
+    }
+    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;
+    }
+    return true;
+  }
+  toString() {
+    if (this.size === 0) return `IndexArray[ ]`;
+    const entries = this.entriesArray().map(([id, el]) => `${id}: ${el}`).join(", ");
+    return `IndexArray[ ${entries} ]`;
+  }
+};
+
+// src/core/signed-index-array.ts
+var SignedIndexArray = class _SignedIndexArray {
+  constructor(entries) {
+    // for indexes >= 0
+    __publicField(this, "posEl");
+    __publicField(this, "hasPos");
+    // for indexes < 0
+    __publicField(this, "negEl");
+    __publicField(this, "hasNeg");
+    // number of elems
+    __publicField(this, "elCount");
+    if (entries instanceof _SignedIndexArray) {
+      this.negEl = entries.negEl.slice();
+      this.hasNeg = entries.hasNeg.slice();
+      this.posEl = entries.posEl.slice();
+      this.hasPos = entries.hasPos.slice();
+      this.elCount = entries.elCount;
+    } else {
+      this.negEl = [];
+      this.hasNeg = [];
+      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 (!isInteger(id)) throw new Error(`Invalid index ${id} - must be an integer!`);
+    return id;
+  }
+  get size() {
+    return this.elCount;
+  }
+  get posLen() {
+    return this.hasPos.length;
+  }
+  get negLen() {
+    return this.hasNeg.length;
+  }
+  has(id) {
+    _SignedIndexArray.validateIndex(id);
+    if (id >= 0) {
+      return this.hasPos[id] === true;
+    } else {
+      return this.hasNeg[_SignedIndexArray.toNegIndex(id)] === true;
+    }
+  }
+  set(id, el) {
+    _SignedIndexArray.validateIndex(id);
+    if (id >= 0) {
+      if (this.hasPos[id] !== true) this.elCount++;
+      this.posEl[id] = el;
+      this.hasPos[id] = true;
+    } else {
+      let negId = _SignedIndexArray.toNegIndex(id);
+      if (this.hasNeg[negId] !== true) this.elCount++;
+      this.negEl[negId] = el;
+      this.hasNeg[negId] = true;
+    }
+  }
+  get(id) {
+    _SignedIndexArray.validateIndex(id);
+    if (id >= 0) {
+      return this.hasPos[id] ? this.posEl[id] : void 0;
+    } else {
+      let negId = _SignedIndexArray.toNegIndex(id);
+      return this.hasNeg[negId] ? this.negEl[negId] : 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) {
+    _SignedIndexArray.validateIndex(id);
+    const isPos = id >= 0;
+    const arr = isPos ? this.posEl : this.negEl;
+    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--;
+    return true;
+  }
+  clear() {
+    this.negEl = [];
+    this.hasNeg = [];
+    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 = this.negLen - 1; id >= 0; id--) {
+      if (this.hasNeg[id]) yield _SignedIndexArray.toNegIndex(id);
+    }
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield id;
+    }
+  }
+  indicesArray() {
+    return [...this.indices()];
+  }
+  *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];
+    }
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  *entries() {
+    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.posLen; id++) {
+      if (this.hasPos[id]) yield [id, this.posEl[id]];
+    }
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *[Symbol.iterator]() {
+    yield* this.entries();
+  }
+  clone() {
+    return new _SignedIndexArray(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);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [id, el] of this.entries()) {
+      if (fn(el, id)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [id, el] of this.entries()) {
+      if (!fn(el, 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);
+    }
+    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 SignedIndexArray 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 [id, el] = current.value;
+      acc = fn(acc, el, id);
+    }
+    return acc;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const [id, el] of this.entries()) {
+      result.push(fn(el, id));
+    }
+    return result;
+  }
+  map(fn) {
+    let result = new _SignedIndexArray();
+    for (const [id, el] of this.entries()) {
+      result.set(id, fn(el, id));
+    }
+    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} ]`;
+  }
+};
+
 // src/core/map.ts
 var Map1 = class _Map1 {
   constructor(entries) {
@@ -1311,12 +1748,13 @@ var Map1 = class _Map1 {
   getOrDefault(key1, defaultValue) {
     return this.get(key1) ?? defaultValue;
   }
-  getOrCreate(key1, creator) {
-    let value = this.get(key1);
-    if (!value) {
-      this.set(key1, value = creator());
+  getOrCreate(key1, creatorOrValue) {
+    if (!this.has(key1)) {
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key1, value);
+      return value;
     }
-    return value;
+    return this.get(key1);
   }
   delete(key1) {
     return this.map1.delete(key1);
@@ -1440,12 +1878,13 @@ var Map2 = class _Map2 {
   getOrDefault(key1, key2, defaultValue) {
     return this.get(key1, key2) ?? defaultValue;
   }
-  getOrCreate(key1, key2, creator) {
-    let value = this.get(key1, key2);
-    if (!value) {
-      this.set(key1, key2, value = creator());
+  getOrCreate(key1, key2, creatorOrValue) {
+    if (!this.has(key1, key2)) {
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key1, key2, value);
+      return value;
     }
-    return value;
+    return this.get(key1, key2);
   }
   delete(key1, key2) {
     if (key2 === void 0) return this.map1.delete(key1);
@@ -1616,12 +2055,13 @@ var Map3 = class _Map3 {
   getOrDefault(key1, key2, key3, defaultValue) {
     return this.get(key1, key2, key3) ?? defaultValue;
   }
-  getOrCreate(key1, key2, key3, creator) {
-    let value = this.get(key1, key2, key3);
-    if (!value) {
-      this.set(key1, key2, key3, value = creator());
+  getOrCreate(key1, key2, key3, creatorOrValue) {
+    if (!this.has(key1, key2, key3)) {
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key1, key2, key3, value);
+      return value;
     }
-    return value;
+    return this.get(key1, key2, key3);
   }
   delete(key1, key2, key3) {
     if (key3 === void 0) {
@@ -1786,18 +2226,62 @@ var Map3 = class _Map3 {
     return `Map3(${this.size}) { ${entries.join(", ")} }`;
   }
 };
+
+// src/core/multi-container.ts
+var MultiContainer = class {
+  constructor(base) {
+    this.base = base;
+  }
+  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) {
+    const arr = this.getAll(...keys);
+    for (const v of arr) {
+      yield v;
+    }
+  }
+  clear() {
+    this.base.clear?.();
+  }
+};
+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