@tspro/ts-utils-lib 1.21.0 → 2.1.0

package/dist/index.js

@@ -1,103 +1,152 @@
-/* TsUtilsLib v1.21.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
-"use strict";
+'use strict';
+
+/*!
+ * TsUtilsLib v2.1.0 (cjs)
+ * (c) 2023–2025 PahkaSoft
+ * Licensed under the MIT License
+ */
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AnchoredRect: () => AnchoredRect,
-  Assert: () => assert_exports,
-  BaseContainer: () => BaseContainer,
-  BiMap: () => BiMap,
-  Cookies: () => cookies_exports,
-  DeepSet: () => DeepSet,
-  DefaultArray: () => DefaultArray,
-  DefaultEqualityFn: () => DefaultEqualityFn,
-  Device: () => device_exports,
-  DivRect: () => DivRect,
-  Guard: () => guard_exports,
-  IndexArray: () => IndexArray,
-  LRUCache: () => LRUCache,
-  LinkedList: () => LinkedList,
-  Map1: () => Map1,
-  Map2: () => Map2,
-  Map3: () => Map3,
-  MultiContainer: () => MultiContainer,
-  Rect: () => Rect,
-  Set1: () => Set1,
-  SetBase: () => SetBase,
-  SignedIndexArray: () => SignedIndexArray,
-  SmallIntCache: () => SmallIntCache,
-  Stack: () => Stack,
-  TriMap: () => TriMap,
-  UniMap: () => UniMap,
-  Utils: () => utils_exports,
-  ValueSet: () => ValueSet,
-  Vec: () => Vec,
-  Vec2: () => Vec2,
-  asMulti: () => asMulti
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/assert/index.ts
 var assert_exports = {};
 __export(assert_exports, {
-  array_elem: () => array_elem,
-  array_id: () => array_id,
   assert: () => assert,
-  assertEnum: () => assertEnum,
-  eq: () => eq,
-  even: () => even,
+  doesNotThrow: () => doesNotThrow2,
+  doesThrow: () => doesThrow2,
   fail: () => fail,
-  finite: () => finite,
-  in_group: () => in_group,
-  int: () => int,
-  int_between: () => int_between,
-  int_between_exclusive: () => int_between_exclusive,
-  int_eq: () => int_eq,
-  int_gt: () => int_gt,
-  int_gte: () => int_gte,
-  int_lt: () => int_lt,
-  int_lte: () => int_lte,
-  interrupt: () => interrupt,
+  isArray: () => isArray2,
+  isArrayOrUndefined: () => isArrayOrUndefined2,
+  isBigInt: () => isBigInt2,
+  isBoolean: () => isBoolean2,
+  isBooleanOrUndefined: () => isBooleanOrUndefined2,
+  isDeepEqual: () => isDeepEqual2,
+  isDefined: () => isDefined2,
+  isEmptyArray: () => isEmptyArray2,
+  isEmptyArrayOrUndefined: () => isEmptyArrayOrUndefined2,
+  isEmptyObject: () => isEmptyObject2,
+  isEmptyString: () => isEmptyString2,
+  isEmptyStringOrUndefined: () => isEmptyStringOrUndefined2,
+  isEnumValue: () => isEnumValue2,
+  isEnumValueOrUndefined: () => isEnumValueOrUndefined2,
+  isEven: () => isEven2,
+  isFalse: () => isFalse2,
+  isFalseOrUndefined: () => isFalseOrUndefined2,
+  isFinite: () => isFinite3,
+  isFloat: () => isFloat2,
+  isFunction: () => isFunction2,
+  isFunctionOrUndefined: () => isFunctionOrUndefined2,
+  isIncluded: () => isIncluded2,
+  isIndex: () => isIndex2,
+  isInfinity: () => isInfinity2,
+  isInteger: () => isInteger2,
+  isIntegerBetween: () => isIntegerBetween2,
+  isIntegerBetweenExclusive: () => isIntegerBetweenExclusive2,
+  isIntegerEq: () => isIntegerEq2,
+  isIntegerGt: () => isIntegerGt2,
+  isIntegerGte: () => isIntegerGte2,
+  isIntegerLt: () => isIntegerLt2,
+  isIntegerLte: () => isIntegerLte2,
+  isIntegerOrUndefined: () => isIntegerOrUndefined2,
+  isMultipleOf: () => isMultipleOf2,
+  isNaNValue: () => isNaNValue2,
+  isNeg: () => isNeg2,
+  isNegInfinity: () => isNegInfinity2,
+  isNegZero: () => isNegZero2,
+  isNonEmptyArray: () => isNonEmptyArray2,
+  isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined2,
+  isNonEmptyString: () => isNonEmptyString2,
+  isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined2,
+  isNonNeg: () => isNonNeg2,
+  isNonNull: () => isNonNull2,
+  isNonPos: () => isNonPos2,
+  isNull: () => isNull2,
+  isNullish: () => isNullish2,
+  isNumber: () => isNumber2,
+  isNumberBetween: () => isNumberBetween2,
+  isNumberBetweenExclusive: () => isNumberBetweenExclusive2,
+  isNumberOrUndefined: () => isNumberOrUndefined2,
+  isNumericString: () => isNumericString2,
+  isObject: () => isObject2,
+  isObjectOrUndefined: () => isObjectOrUndefined2,
+  isOdd: () => isOdd2,
+  isPlainObject: () => isPlainObject2,
+  isPos: () => isPos2,
+  isPosInfinity: () => isPosInfinity2,
+  isPosZero: () => isPosZero2,
+  isPowerOfTwo: () => isPowerOfTwo2,
+  isSafeInteger: () => isSafeInteger2,
+  isStrictEqual: () => isStrictEqual2,
+  isString: () => isString2,
+  isStringOrUndefined: () => isStringOrUndefined2,
+  isTrue: () => isTrue2,
+  isTrueOrUndefined: () => isTrueOrUndefined2,
+  isTypedObject: () => isTypedObject2,
+  isUndefined: () => isUndefined2,
+  isZero: () => isZero2,
+  require: () => require2,
+  requireDefined: () => requireDefined,
+  requireElement: () => requireElement,
+  setErrorClass: () => setErrorClass
+});
+
+// src/utils/str/index.ts
+var str_exports = {};
+__export(str_exports, {
+  charCount: () => charCount,
+  chunkString: () => chunkString,
+  insertAt: () => insertAt,
+  isString: () => isString,
+  makeSentenceFromPascal: () => makeSentenceFromPascal,
+  removeAt: () => removeAt,
+  repeatString: () => repeatString,
+  replaceAt: () => replaceAt,
+  stringify: () => stringify,
+  toCharArray: () => toCharArray
+});
+
+// src/utils/obj/index.ts
+var obj_exports = {};
+__export(obj_exports, {
+  deepEqual: () => deepEqual,
+  getCtorName: () => getCtorName,
+  hasProperties: () => hasProperties,
+  isObject: () => isObject
+});
+
+// src/guard/index.ts
+var guard_exports = {};
+__export(guard_exports, {
+  doesNotThrow: () => doesNotThrow,
+  doesThrow: () => doesThrow,
   isArray: () => isArray,
-  isArrayIndex: () => isArrayIndex,
   isArrayOrUndefined: () => isArrayOrUndefined,
+  isBigInt: () => isBigInt,
   isBoolean: () => isBoolean,
   isBooleanOrUndefined: () => isBooleanOrUndefined,
   isDeepEqual: () => isDeepEqual,
+  isDefined: () => isDefined,
   isEmptyArray: () => isEmptyArray,
   isEmptyArrayOrUndefined: () => isEmptyArrayOrUndefined,
+  isEmptyObject: () => isEmptyObject,
   isEmptyString: () => isEmptyString,
   isEmptyStringOrUndefined: () => isEmptyStringOrUndefined,
   isEnumValue: () => isEnumValue,
   isEnumValueOrUndefined: () => isEnumValueOrUndefined,
-  isEqual: () => isEqual,
-  isEvenNumber: () => isEvenNumber,
+  isEven: () => isEven,
   isFalse: () => isFalse,
   isFalseOrUndefined: () => isFalseOrUndefined,
   isFinite: () => isFinite2,
+  isFloat: () => isFloat,
   isFunction: () => isFunction,
   isFunctionOrUndefined: () => isFunctionOrUndefined,
   isIncluded: () => isIncluded,
+  isIndex: () => isIndex,
   isInfinity: () => isInfinity,
   isInteger: () => isInteger,
   isIntegerBetween: () => isIntegerBetween,
@@ -108,458 +157,944 @@ __export(assert_exports, {
   isIntegerLt: () => isIntegerLt,
   isIntegerLte: () => isIntegerLte,
   isIntegerOrUndefined: () => isIntegerOrUndefined,
+  isMultipleOf: () => isMultipleOf,
   isNaNValue: () => isNaNValue,
+  isNeg: () => isNeg,
   isNegInfinity: () => isNegInfinity,
+  isNegZero: () => isNegZero,
   isNonEmptyArray: () => isNonEmptyArray,
   isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined,
   isNonEmptyString: () => isNonEmptyString,
   isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined,
-  isNotThrowing: () => isNotThrowing,
+  isNonNeg: () => isNonNeg,
+  isNonNull: () => isNonNull,
+  isNonPos: () => isNonPos,
   isNull: () => isNull,
   isNullish: () => isNullish,
   isNumber: () => isNumber,
   isNumberBetween: () => isNumberBetween,
   isNumberBetweenExclusive: () => isNumberBetweenExclusive,
   isNumberOrUndefined: () => isNumberOrUndefined,
+  isNumericString: () => isNumericString,
   isObject: () => isObject,
   isObjectOrUndefined: () => isObjectOrUndefined,
-  isOddNumber: () => isOddNumber,
+  isOdd: () => isOdd,
+  isPlainObject: () => isPlainObject,
+  isPos: () => isPos,
   isPosInfinity: () => isPosInfinity,
+  isPosZero: () => isPosZero,
+  isPowerOfTwo: () => isPowerOfTwo,
+  isSafeInteger: () => isSafeInteger,
+  isStrictEqual: () => isStrictEqual,
   isString: () => isString,
   isStringOrUndefined: () => isStringOrUndefined,
-  isThrowing: () => isThrowing,
   isTrue: () => isTrue,
   isTrueOrUndefined: () => isTrueOrUndefined,
   isTypedObject: () => isTypedObject,
   isUndefined: () => isUndefined,
-  odd: () => odd,
-  require: () => require2,
-  requireDefined: () => requireDefined,
-  setErrorClass: () => setErrorClass
+  isZero: () => isZero,
+  tryOr: () => tryOr
 });
-var errorConstructor = Error;
-function setErrorClass(errorClass) {
-  errorConstructor = errorClass ?? Error;
-}
-function _fail(...msgs) {
-  let msg = msgs.join(", ");
-  throw new errorConstructor("Assertion Failed!" + (msg === "" ? "" : " " + msg));
-}
-function interrupt(msg) {
-  _fail("Interrupted!");
-}
-function assertEnum(enumVal, enumObj, name = "value") {
-  if (!guard_exports.isEnumValue(enumVal, enumObj))
-    _fail(`Invalid enum value ${enumVal}.`);
+
+// src/utils/enum/index.ts
+var enum_exports = {};
+__export(enum_exports, {
+  forEachEnum: () => forEachEnum,
+  getEnumEntries: () => getEnumEntries,
+  getEnumKey: () => getEnumKey,
+  getEnumKeys: () => getEnumKeys,
+  getEnumValues: () => getEnumValues
+});
+function getEnumKeys(e) {
+  return Object.keys(e).filter((k) => isNaN(Number(k)));
 }
-function int(value, msg) {
-  if (!guard_exports.isInteger(value))
-    _fail(`Expected ${value} to be integer.`, msg);
-  return value;
+function getEnumValues(e) {
+  return getEnumKeys(e).map((k) => e[k]);
 }
-function eq(value1, value2, msg) {
-  if (value1 !== value2)
-    _fail(`Expected ${value1} to equal ${value2}.`, msg);
-  return value1;
+function getEnumEntries(e) {
+  return getEnumKeys(e).map((k) => [k, e[k]]);
 }
-function int_eq(value, compareTo, msg) {
-  if (!guard_exports.isIntegerEq(value, compareTo))
-    _fail(`Expected ${value} to be integer equal to ${compareTo}.`, msg);
-  return value;
+function getEnumKey(e, value) {
+  return getEnumKeys(e).find((k) => e[k] === value);
 }
-function int_lt(value, compareTo, msg) {
-  if (!guard_exports.isIntegerLt(value, compareTo))
-    _fail(`Expected ${value} to be integer less than ${compareTo}.`, msg);
-  return value;
+function forEachEnum(e, callback) {
+  for (const [k, v] of getEnumEntries(e)) callback(k, v);
 }
-function int_lte(value, compareTo, msg) {
-  if (!guard_exports.isIntegerLte(value, compareTo))
-    _fail(`Expected ${value} to be integer less than or equal to ${compareTo}.`, msg);
-  return value;
+
+// src/guard/index.ts
+function isStrictEqual(val1, val2) {
+  return val1 === val2;
 }
-function int_gt(value, compareTo, msg) {
-  if (!guard_exports.isIntegerGt(value, compareTo))
-    _fail(`Expected ${value} to be integer greater than ${compareTo}.`, msg);
-  return value;
+function isDeepEqual(val1, val2) {
+  return deepEqual(val1, val2);
 }
-function int_gte(value, compareTo, msg) {
-  if (!guard_exports.isIntegerGte(value, compareTo))
-    _fail(`Expected ${value} to be integer greater than or equal to ${compareTo}.`, msg);
-  return value;
+function isUndefined(val) {
+  return val === void 0;
 }
-function int_between(value, min, max, msg) {
-  if (!guard_exports.isIntegerBetween(value, min, max))
-    _fail(`Expected integer between ${min} <= ${value} <= ${max}.`, msg);
-  return value;
+function isNull(val) {
+  return val === null;
 }
-function int_between_exclusive(value, min, max, msg) {
-  if (!guard_exports.isIntegerBetweenExclusive(value, min, max))
-    _fail(`Expected integer between ${min} < ${value} < ${max}.`, msg);
-  return value;
+function isNullish(val) {
+  return val === void 0 || val === null;
 }
-function odd(value, msg) {
-  if (!guard_exports.isOddNumber(value))
-    _fail(`Expected ${value} to be odd number.`, msg);
-  return value;
+function isDefined(val) {
+  return val !== void 0;
 }
-function even(value, msg) {
-  if (!guard_exports.isEvenNumber(value))
-    _fail(`Expected ${value} to be even number.`, msg);
-  return value;
+function isNonNull(val) {
+  return val !== null;
 }
-function in_group(value, group, msg) {
-  if (!group.some((e) => e === value))
-    _fail(`Expected ${value} to be in group [${group.map((v) => String(v)).join(", ")}].`, msg);
-  return value;
+function isObject(val) {
+  return typeof val === "object" && val !== null && !isArray(val);
 }
-function finite(value, msg) {
-  if (!guard_exports.isFinite(value))
-    _fail(`Expected ${value} to be finite number.`, msg);
-  return value;
+function isEmptyObject(val) {
+  return isObject(val) && Object.keys(val).length === 0;
 }
-function array_id(array, index, msg) {
-  if (!guard_exports.isInteger(index) || !guard_exports.isArray(array) || index < 0 || index >= array.length)
-    _fail(`Expected ${index} to be array index in bounds [0..${array.length - 1}].`, msg);
-  return index;
+function isObjectOrUndefined(val) {
+  return val === void 0 || isObject(val);
 }
-function array_elem(array, index, msg) {
-  return array[array_id(array, index, msg)];
+function isPlainObject(val) {
+  if (!isObject(val)) return false;
+  const proto = Object.getPrototypeOf(val);
+  return proto === Object.prototype || proto === null;
 }
-function assert(condition, msg) {
-  if (!condition) {
-    _fail(msg);
-  }
+function isTypedObject(val, keys) {
+  return isObject(val) && keys.every((k) => k in val);
 }
-function require2(value, msg) {
-  if (value == null) {
-    _fail(`Expected ${value} not to be nullish`, msg);
-  }
-  return value;
+function isSet(val) {
+  return val instanceof Set;
 }
-function requireDefined(value, msg) {
-  if (value === void 0) {
-    _fail(`Expected ${value} not to be undefined`, msg);
-  }
-  return value;
+function isArray(arr) {
+  return !!arr && Object.prototype.toString.call(arr) === "[object Array]";
 }
-function fail(msg) {
-  _fail(msg);
+function isArrayOrUndefined(arr) {
+  return arr === void 0 || isArray(arr);
 }
-function isEqual(value1, value2, msg) {
-  if (!guard_exports.isEqual(value1, value2))
-    _fail(`Expected ${value1} to equal with ${value2}`, msg);
-  return true;
+function isEmptyArray(arr) {
+  return isArray(arr) && arr.length === 0;
 }
-function isDeepEqual(value1, value2, msg) {
-  if (!guard_exports.isDeepEqual(value1, value2))
-    _fail(`Expected ${value1} to deep equal with ${value2}`, msg);
-  return true;
+function isNonEmptyArray(arr) {
+  return isArray(arr) && arr.length > 0;
 }
-function isUndefined(value, msg) {
-  if (!guard_exports.isUndefined(value))
-    _fail(`Expected ${value} to be undefined`, msg);
-  return true;
+function isEmptyArrayOrUndefined(arr) {
+  return isArray(arr) && arr.length === 0 || arr === void 0;
 }
-function isNull(value, msg) {
-  if (!guard_exports.isNull(value))
-    _fail(`Expected ${value} to be null`, msg);
-  return true;
+function isNonEmptyArrayOrUndefined(arr) {
+  return isArray(arr) && arr.length > 0 || arr === void 0;
 }
-function isNullish(value, msg) {
-  if (!guard_exports.isNullish(value))
-    _fail(`Expected ${value} to be null or undefined`, msg);
-  return true;
+function isString(val) {
+  return typeof val === "string";
 }
-function isObject(value, msg) {
-  if (!guard_exports.isObject(value))
-    _fail(`Expected ${value} to be object`, msg);
-  return true;
+function isEmptyString(val) {
+  return typeof val === "string" && val.length === 0;
 }
-function isObjectOrUndefined(value, msg) {
-  if (!guard_exports.isObjectOrUndefined(value))
-    _fail(`Expected ${value} to be object or undefined`, msg);
-  return true;
+function isNonEmptyString(val) {
+  return typeof val === "string" && val.length > 0;
 }
-function isTypedObject(obj, keys, msg) {
-  if (!guard_exports.isTypedObject(obj, keys))
-    _fail(`Expected ${obj} to be object with keys [${keys.map((key) => `'${String(key)}'`).join(", ")}]`, msg);
-  return true;
+function isStringOrUndefined(val) {
+  return val === void 0 || typeof val === "string";
 }
-function isArray(value, msg) {
-  if (!guard_exports.isArray(value))
-    _fail(`Expected ${value} to be array`, msg);
-  return true;
+function isEmptyStringOrUndefined(val) {
+  return typeof val === "string" && val.length === 0 || val === void 0;
 }
-function isArrayOrUndefined(value, msg) {
-  if (!guard_exports.isArrayOrUndefined(value))
-    _fail(`Expected ${value} to be array or undefined`, msg);
-  return true;
+function isNonEmptyStringOrUndefined(val) {
+  return typeof val === "string" && val.length > 0 || val === void 0;
 }
-function isEmptyArray(value, msg) {
-  if (!guard_exports.isEmptyArray(value))
-    _fail(`Expected ${value} to be empty array`, msg);
-  return true;
+function isBoolean(val) {
+  return typeof val === "boolean";
 }
-function isNonEmptyArray(value, msg) {
-  if (!guard_exports.isNonEmptyArray(value))
-    _fail(`Expected ${value} to be non-empty array`, msg);
-  return true;
+function isBooleanOrUndefined(val) {
+  return val === void 0 || typeof val === "boolean";
 }
-function isEmptyArrayOrUndefined(value, msg) {
-  if (!guard_exports.isEmptyArrayOrUndefined(value))
-    _fail(`Expected ${value} to be empty array or undefined`, msg);
-  return true;
+function isTrue(val) {
+  return val === true;
 }
-function isNonEmptyArrayOrUndefined(value, msg) {
-  if (!guard_exports.isNonEmptyArrayOrUndefined(value))
-    _fail(`Expected ${value} to be non-empty array or undefined`, msg);
-  return true;
+function isTrueOrUndefined(val) {
+  return val === true || val === void 0;
 }
-function isString(value, msg) {
-  if (!guard_exports.isString(value))
-    _fail(`Expected ${value} to be string`, msg);
-  return true;
+function isFalse(val) {
+  return val === false;
 }
-function isEmptyString(value, msg) {
-  if (!guard_exports.isEmptyString(value))
-    _fail(`Expected ${value} to be empty string`, msg);
-  return true;
+function isFalseOrUndefined(val) {
+  return val === false || val === void 0;
 }
-function isNonEmptyString(value, msg) {
-  if (!guard_exports.isNonEmptyString(value))
-    _fail(`Expected ${value} to be non-empty string`, msg);
-  return true;
+function isFunction(val) {
+  return typeof val === "function";
 }
-function isStringOrUndefined(value, msg) {
-  if (!guard_exports.isStringOrUndefined(value))
-    _fail(`Expected ${value} to be string or undefined`, msg);
-  return true;
+function isFunctionOrUndefined(val) {
+  return val === void 0 || typeof val === "function";
 }
-function isEmptyStringOrUndefined(value, msg) {
-  if (!guard_exports.isEmptyStringOrUndefined(value))
-    _fail(`Expected ${value} to be empty string or undefined`, msg);
-  return true;
+function isEnumValue(val, enumObj) {
+  return getEnumValues(enumObj).some((v) => v === val);
 }
-function isNonEmptyStringOrUndefined(value, msg) {
-  if (!guard_exports.isNonEmptyStringOrUndefined(value))
-    _fail(`Expected ${value} to be non-empty string or undefined`, msg);
-  return true;
+function isEnumValueOrUndefined(val, enumObj) {
+  return val === void 0 || getEnumValues(enumObj).some((v) => v === val);
 }
-function isBoolean(value, msg) {
-  if (!guard_exports.isBoolean(value))
-    _fail(`Expected ${value} to be boolean`, msg);
-  return true;
+function isNumericString(val) {
+  if (typeof val !== "string" || val.trim() === "") return false;
+  const n = +val;
+  return Number.isFinite(n);
 }
-function isBooleanOrUndefined(value, msg) {
-  if (!guard_exports.isBooleanOrUndefined(value))
-    _fail(`Expected ${value} to be boolean or undefined`, msg);
-  return true;
+function isBigInt(val) {
+  return typeof val === "bigint";
 }
-function isTrue(value, msg) {
-  if (!guard_exports.isTrue(value))
-    _fail(`Expected ${value} to be true`, msg);
-  return true;
+function isNumber(val) {
+  return typeof val === "number";
 }
-function isTrueOrUndefined(value, msg) {
-  if (!guard_exports.isTrueOrUndefined(value))
-    _fail(`Expected ${value} to be true or undefined`, msg);
-  return true;
+function isNumberOrUndefined(val) {
+  return typeof val === "number" || val === void 0;
 }
-function isFalse(value, msg) {
-  if (!guard_exports.isFalse(value))
-    _fail(`Expected ${value} to be false`, msg);
-  return true;
+function isFinite2(val) {
+  return typeof val === "number" && Number.isFinite(val);
 }
-function isFalseOrUndefined(value, msg) {
-  if (!guard_exports.isFalseOrUndefined(value))
-    _fail(`Expected ${value} to be false or undefined`, msg);
-  return true;
+function isFloat(val) {
+  return isFinite2(val) && !isInteger(val);
 }
-function isFunction(value, msg) {
-  if (!guard_exports.isFunction(value))
-    _fail(`Expected ${value} to be function`, msg);
-  return true;
+function isInteger(val) {
+  return typeof val === "number" && isFinite2(val) && val === Math.trunc(val);
 }
-function isFunctionOrUndefined(value, msg) {
-  if (!guard_exports.isFunctionOrUndefined(value))
-    _fail(`Expected ${value} to be function or undefined`, msg);
-  return true;
+function isSafeInteger(val) {
+  return isInteger(val) && Number.isSafeInteger(val);
 }
-function isEnumValue(enumValue, enumObject, msg) {
-  if (!guard_exports.isEnumValue(enumValue, enumObject))
-    _fail(`Expected ${enumValue} to be enum value`, msg);
-  return true;
+function isIntegerOrUndefined(val) {
+  return typeof val === "number" && isFinite2(val) && val === Math.trunc(val) || val === void 0;
 }
-function isEnumValueOrUndefined(enumValue, enumObject, msg) {
-  if (!guard_exports.isEnumValueOrUndefined(enumValue, enumObject))
-    _fail(`Expected ${enumValue} to be enum value or undefined`, msg);
-  return true;
+function isIntegerEq(val, ref) {
+  return isInteger(val) && val === ref;
 }
-function isNumber(value, msg) {
-  if (!guard_exports.isNumber(value))
-    _fail(`Expected ${value} to be number`, msg);
-  return true;
+function isIntegerGt(val, ref) {
+  return isInteger(val) && isNumber(ref) && val > ref;
 }
-function isNumberOrUndefined(value, msg) {
-  if (!guard_exports.isNumberOrUndefined(value))
-    _fail(`Expected ${value} to be number or undefined`, msg);
-  return true;
+function isIntegerGte(val, ref) {
+  return isInteger(val) && isNumber(ref) && val >= ref;
 }
-function isFinite2(value, msg) {
-  if (!guard_exports.isFinite(value))
-    _fail(`Expected ${value} to be finite`, msg);
-  return true;
+function isIntegerLt(val, ref) {
+  return isInteger(val) && isNumber(ref) && val < ref;
 }
-function isInteger(value, msg) {
-  if (!guard_exports.isInteger(value))
-    _fail(`Expected ${value} to be integer`, msg);
-  return true;
+function isIntegerLte(val, ref) {
+  return isInteger(val) && isNumber(ref) && val <= ref;
 }
-function isIntegerOrUndefined(value, msg) {
-  if (!guard_exports.isIntegerOrUndefined(value))
-    _fail(`Expected ${value} to be integer or undefined`, msg);
-  return true;
+function isIntegerBetween(val, min, max) {
+  return isInteger(val) && isNumber(min) && isNumber(max) && val >= min && val <= max;
 }
-function isIntegerEq(value, compareTo, msg) {
-  if (!guard_exports.isIntegerEq(value, compareTo))
-    _fail(`Expected ${value} to be integer equal to ${compareTo}`, msg);
-  return true;
+function isIntegerBetweenExclusive(val, min, max) {
+  return isInteger(val) && isNumber(min) && isNumber(max) && val > min && val < max;
 }
-function isIntegerGt(value, compareTo, msg) {
-  if (!guard_exports.isIntegerGt(value, compareTo))
-    _fail(`Expected ${value} to be integer > ${compareTo}`, msg);
-  return true;
+function isNumberBetween(val, min, max) {
+  return isNumber(val) && isNumber(min) && isNumber(max) && val >= min && val <= max;
 }
-function isIntegerGte(value, compareTo, msg) {
-  if (!guard_exports.isIntegerGte(value, compareTo))
-    _fail(`Expected ${value} to be integer >= ${compareTo}`, msg);
-  return true;
+function isNumberBetweenExclusive(val, min, max) {
+  return isNumber(val) && isNumber(min) && isNumber(max) && val > min && val < max;
 }
-function isIntegerLt(value, compareTo, msg) {
-  if (!guard_exports.isIntegerLt(value, compareTo))
-    _fail(`Expected ${value} to be integer < ${compareTo}`, msg);
-  return true;
+function isNaNValue(val) {
+  return typeof val === "number" && Number.isNaN(val);
 }
-function isIntegerLte(value, compareTo, msg) {
-  if (!guard_exports.isIntegerLte(value, compareTo))
-    _fail(`Expected ${value} to be integer <= ${compareTo}`, msg);
-  return true;
+function isInfinity(val) {
+  return val === Infinity || val === -Infinity;
 }
-function isIntegerBetween(value, min, max, msg) {
-  if (!guard_exports.isIntegerBetween(value, min, max))
-    _fail(`Expected integer ${min} <= ${value} <= ${max}.`, msg);
-  return true;
+function isPosInfinity(val) {
+  return val === Infinity;
 }
-function isIntegerBetweenExclusive(value, min, max, msg) {
-  if (!guard_exports.isIntegerBetweenExclusive(value, min, max))
-    _fail(`Expected integer ${min} < ${value} < ${max}.`, msg);
-  return true;
+function isNegInfinity(val) {
+  return val === -Infinity;
 }
-function isNumberBetween(value, min, max, msg) {
-  if (!guard_exports.isNumberBetween(value, min, max))
-    _fail(`Expected number ${min} <= ${value} <= ${max}.`, msg);
-  return true;
+function isPos(val) {
+  return typeof val === "number" && val > 0;
 }
-function isNumberBetweenExclusive(value, min, max, msg) {
-  if (!guard_exports.isNumberBetweenExclusive(value, min, max))
-    _fail(`Expected number ${min} < ${value} < ${max}.`, msg);
-  return true;
+function isNeg(val) {
+  return typeof val === "number" && val < 0;
 }
-function isNaNValue(value, msg) {
-  if (!guard_exports.isNaNValue(value))
-    _fail(`Expected ${value} to be NaN.`, msg);
-  return true;
+function isNonPos(val) {
+  return typeof val === "number" && val <= 0;
 }
-function isInfinity(value, msg) {
-  if (!guard_exports.isInfinity(value))
-    _fail(`Expected ${value} to be +-Infinity.`, msg);
-  return true;
+function isNonNeg(val) {
+  return typeof val === "number" && val >= 0;
 }
-function isPosInfinity(value, msg) {
-  if (!guard_exports.isPosInfinity(value))
-    _fail(`Expected ${value} to be +Infinity.`, msg);
-  return true;
+function isZero(val) {
+  return typeof val === "number" && val === 0;
 }
-function isNegInfinity(value, msg) {
-  if (!guard_exports.isNegInfinity(value))
-    _fail(`Expected ${value} to be -Infinity.`, msg);
-  return true;
+function isPosZero(val) {
+  return typeof val === "number" && val === 0 && 1 / val === Infinity;
 }
-function isOddNumber(value, msg) {
-  if (!guard_exports.isOddNumber(value))
-    _fail(`Expected ${value} to odd number.`, msg);
-  return true;
+function isNegZero(val) {
+  return typeof val === "number" && val === 0 && 1 / val === -Infinity;
 }
-function isEvenNumber(value, msg) {
-  if (!guard_exports.isEvenNumber(value))
-    _fail(`Expected ${value} to even number.`, msg);
-  return true;
+function isOdd(val) {
+  return isInteger(val) && Math.abs(val) % 2 === 1;
 }
-function isIncluded(value, array, msg) {
-  if (!guard_exports.isIncluded(value, array))
-    _fail(`Expected ${value} to be included in [${array.map((v) => String(v)).join(", ")}].`, msg);
-  return true;
+function isEven(val) {
+  return isInteger(val) && val % 2 === 0;
 }
-function isArrayIndex(index, array, msg) {
-  if (!guard_exports.isArrayIndex(index, array))
-    _fail(`Expected ${index} to be index for array [${array.map((v) => String(v)).join(", ")}]`, msg);
-  return true;
+function isMultipleOf(val, base) {
+  return typeof val === "number" && typeof base === "number" && val % base === 0;
 }
-function isThrowing(throwTestFn, msg) {
-  if (!guard_exports.isThrowing(throwTestFn))
-    _fail(`Expected to throw`, msg);
-  return true;
+function isPowerOfTwo(val) {
+  return isInteger(val) && val > 0 && (val & val - 1) === 0;
 }
-function isNotThrowing(throwTestFn, msg) {
-  if (!guard_exports.isNotThrowing(throwTestFn))
-    _fail(`Expected to throw`, msg);
-  return true;
+function isIncluded(val, container) {
+  if (isArray(container)) {
+    return container.includes(val);
+  }
+  if (isSet(container)) {
+    return container.has(val);
+  }
+  return false;
 }
-
-// src/web/cookies.ts
-var cookies_exports = {};
-__export(cookies_exports, {
-  accept: () => accept,
-  decline: () => decline,
-  erase: () => erase,
-  eraseAll: () => eraseAll,
-  isConsentPending: () => isConsentPending,
-  read: () => read,
-  readBool: () => readBool,
-  readInt: () => readInt,
-  save: () => save,
-  setExpireDays: () => setExpireDays
-});
-var ConsentCookieName = "ConsentCookie";
-var _consent;
-var _expires;
-var str = _read(ConsentCookieName);
-_consent = str === "accept" /* Accept */ || str === "decline" /* Decline */ ? str : void 0;
-function _getList() {
-  let s = document.cookie;
-  return s.split(";").map((c) => c.trim());
+function isIndex(index, array) {
+  return isArray(array) ? isIntegerBetween(index, 0, array.length - 1) : isIntegerGte(index, 0);
 }
-function _save(name, value) {
-  let cookie = name + "=" + value.toString() + ";sameSite=Lax;";
-  if (_expires) {
-    cookie += "expires=" + _expires.toUTCString() + ";";
+function doesThrow(throwTestFn) {
+  try {
+    throwTestFn();
+    return false;
+  } catch (err) {
+    return true;
   }
-  document.cookie = cookie;
-  return value;
 }
-function _read(name, defaultValue) {
-  let str2 = _getList().find((c) => c.startsWith(name + "="));
-  return str2 === void 0 ? defaultValue : str2.substring(name.length + 1);
+function doesNotThrow(throwTestFn) {
+  try {
+    throwTestFn();
+    return true;
+  } catch (err) {
+    return false;
+  }
 }
-function _erase(name) {
-  document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 UTC;";
+function tryOr(tryFn, orVal) {
+  try {
+    return tryFn();
+  } catch (err) {
+    return isFunction(orVal) ? orVal() : orVal;
+  }
 }
-function setExpireDays(days) {
-  _expires = /* @__PURE__ */ new Date();
-  _expires.setDate(_expires.getDate() + days);
+
+// src/utils/obj/index.ts
+function hasProperties(obj, props) {
+  return isObject(obj) && props.every((p) => p in obj);
 }
-function isConsentPending() {
-  return _consent === void 0;
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, i) => deepEqual(val, b[i]));
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+function getCtorName(obj) {
+  if (obj === null) return "null";
+  if (isArray(obj)) return "Array";
+  if (typeof obj !== "object") return typeof obj;
+  const tag = Object.prototype.toString.call(obj).slice(8, -1);
+  return tag || "Object";
+}
+
+// src/utils/str/index.ts
+function toCharArray(str2) {
+  return str2.split("");
+}
+function repeatString(repeatString2, repeatCount) {
+  if (!isInteger(repeatCount) || repeatCount < 0) {
+    throw new Error("repeatStr: Invalid repeatCount = " + repeatCount);
+  }
+  return new Array(repeatCount + 1).join(repeatString2);
+}
+function chunkString(str2, chunkSize) {
+  if (!isInteger(chunkSize) || chunkSize < 1) {
+    throw new Error("chunckString: Invalid chuckSize = " + chunkSize);
+  }
+  let result = [];
+  for (let i = 0; i < str2.length; i += chunkSize) {
+    result.push(str2.slice(i, i + chunkSize));
+  }
+  return result;
+}
+function replaceAt(str2, pos, removeCount, insert) {
+  if (!isInteger(removeCount) || removeCount < 0) {
+    throw new Error("replaceAt: Invalid removeCount = " + removeCount);
+  } else if (!isInteger(pos) || pos < 0 || pos + removeCount > str2.length) {
+    throw new Error("replaceAt: Invalid pos = " + pos + ", removeCount = " + removeCount + ", str.length = " + str2.length);
+  } else {
+    return str2.substring(0, pos) + insert + str2.substring(pos + removeCount);
+  }
+}
+function insertAt(str2, pos, insertStr) {
+  return replaceAt(str2, pos, 0, insertStr);
+}
+function removeAt(str2, pos, removeCount) {
+  return replaceAt(str2, pos, removeCount, "");
+}
+function charCount(str2, ch) {
+  if (ch.length !== 1 || str2.length === 0) return 0;
+  let count = 0;
+  for (let i = 0; i < str2.length; i++) {
+    if (str2[i] === ch) count++;
+  }
+  return count;
+}
+function makeSentenceFromPascal(PascalString) {
+  if (PascalString === "") {
+    return "";
+  }
+  let word = PascalString.charAt(0);
+  let sentence = "";
+  const addWord = () => {
+    if (word !== "") {
+      if (sentence === "") {
+        sentence += word.charAt(0).toUpperCase() + word.substring(1);
+      } else {
+        sentence += " " + word;
+      }
+      word = "";
+    }
+  };
+  const isLetterAndCapital = (c) => {
+    return c.toUpperCase() !== c.toLowerCase() && c === c.toUpperCase();
+  };
+  for (let i = 1; i < PascalString.length; i++) {
+    let c = PascalString.charAt(i);
+    if (isLetterAndCapital(c)) {
+      addWord();
+    }
+    word += c.toLowerCase();
+  }
+  addWord();
+  return sentence;
+}
+function stringify(value, maxDepth = 5, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const t = typeof value;
+  switch (t) {
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+      if (isNaNValue(value)) return "NaN";
+      if (!isFinite2(value))
+        return value < 0 ? "-Infinity" : "Infinity";
+      return value.toString();
+    case "bigint":
+      return `${value}n`;
+    case "string":
+      return `"${value}"`;
+    case "symbol":
+      return value.description ? `Symbol(${value.description})` : "Symbol()";
+    case "function":
+      return `[Function${value.name ? ` ${value.name}` : ""}]`;
+  }
+  if (seen.has(value))
+    return "[Circular]";
+  if (maxDepth <= 0)
+    return "[Depth limit]";
+  maxDepth--;
+  seen.add(value);
+  const strfy = (v) => stringify(v, maxDepth, seen);
+  if (isArray(value)) {
+    const inner = value.map((v) => strfy(v)).join(", ");
+    return inner.length === 0 ? "[ ]" : `[ ${inner} ]`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    if (value instanceof DataView)
+      return `DataView(${value.byteLength})`;
+    const inner = Array.from(value).map((v) => strfy(v)).join(", ");
+    return `${value.constructor.name}[ ${inner} ]`;
+  }
+  if (value instanceof ArrayBuffer)
+    return `ArrayBuffer(${value.byteLength})`;
+  if (value instanceof Map) {
+    const entries = Array.from(value.entries()).map(([k, v]) => `${strfy(k)} => ${strfy(v)}`).join(", ");
+    return entries.length === 0 ? `Map(${value.size}){ }` : `Map(${value.size}){ ${entries} }`;
+  }
+  if (value instanceof Set) {
+    const entries = Array.from(value.values()).map((v) => strfy(v)).join(", ");
+    return entries.length === 0 ? `Set(${value.size}){ }` : `Set(${value.size}){ ${entries} }`;
+  }
+  if (value instanceof WeakMap)
+    return "WeakMap{ ? }";
+  if (value instanceof WeakSet)
+    return "WeakSet{ ? }";
+  if (value instanceof Date)
+    return `Date("${value.toISOString()}")`;
+  if (value instanceof RegExp)
+    return value.toString();
+  if (value instanceof Error)
+    return `${value.name}("${value.message}")`;
+  if (value instanceof Promise)
+    return "Promise{ ? }";
+  if (value instanceof URL)
+    return `URL("${value.href}")`;
+  if (value instanceof URLSearchParams)
+    return `URLSearchParams("${value.toString()}")`;
+  if (value === Math) return "Math";
+  if (value === JSON) return "JSON";
+  if (value === Reflect) return "Reflect";
+  if (value === Intl) return "Intl";
+  const hasCustomToString = typeof value?.toString === "function" && value.toString !== Object.prototype.toString;
+  if (hasCustomToString) {
+    try {
+      const str2 = value.toString();
+      if (!/^\[object .+\]$/.test(str2)) return str2;
+    } catch {
+    }
+  }
+  if (t === "object") {
+    const ctorName = getCtorName(value);
+    const entries = Object.entries(value).map(
+      ([key, val]) => `${strfy(key)}: ${strfy(val)}`
+    );
+    if (entries.length === 0) return `${ctorName}{ }`;
+    return `${ctorName}{ ${entries.join(", ")} }`;
+  }
+  return String(value);
+}
+
+// src/assert/index.ts
+var fmt = stringify;
+var errorConstructor = Error;
+function setErrorClass(errorClass) {
+  errorConstructor = errorClass ?? Error;
+}
+function _fail(...msgs) {
+  let msg = msgs.join(", ");
+  throw new errorConstructor("Assertion Failed!" + (msg === "" ? "" : " " + msg));
+}
+function assert(condition, msg) {
+  if (!condition) {
+    _fail(msg);
+  }
+}
+function require2(val, msg) {
+  if (val == null) {
+    _fail(`Expected ${fmt(val)} not to be nullish`, msg);
+  }
+  return val;
+}
+function requireDefined(val, msg) {
+  if (val === void 0) {
+    _fail(`Expected ${fmt(val)} not to be undefined`, msg);
+  }
+  return val;
+}
+function requireElement(index, array, msg) {
+  if (!guard_exports.isIndex(index, array))
+    _fail(`Expected ${index} to be index for array ${fmt(array)}`, msg);
+  return array[index];
+}
+function fail(msg) {
+  _fail(msg);
+}
+function isStrictEqual2(val1, val2, msg) {
+  if (!guard_exports.isStrictEqual(val1, val2))
+    _fail(`Expected ${fmt(val1)} to ne strict equal to ${val2}`, msg);
+  return val1;
+}
+function isDeepEqual2(val1, val2, msg) {
+  if (!guard_exports.isDeepEqual(val1, val2))
+    _fail(`Expected ${fmt(val1)} to deep equal with ${fmt(val2)}`, msg);
+  return val1;
+}
+function isUndefined2(val, msg) {
+  if (!guard_exports.isUndefined(val))
+    _fail(`Expected ${fmt(val)} to be undefined`, msg);
+  return val;
+}
+function isNull2(val, msg) {
+  if (!guard_exports.isNull(val))
+    _fail(`Expected ${fmt(val)} to be null`, msg);
+  return val;
+}
+function isNullish2(val, msg) {
+  if (!guard_exports.isNullish(val))
+    _fail(`Expected ${fmt(val)} to be null or undefined`, msg);
+  return val;
+}
+function isDefined2(val, msg) {
+  if (!guard_exports.isDefined(val)) {
+    _fail(`Expected ${fmt(val)} to be defined`, msg);
+  }
+  return val;
+}
+function isNonNull2(val, msg) {
+  if (!guard_exports.isNonNull(val)) {
+    _fail(`Expected ${fmt(val)} to be defined`, msg);
+  }
+  return val;
+}
+function isObject2(val, msg) {
+  if (!guard_exports.isObject(val))
+    _fail(`Expected ${fmt(val)} to be object`, msg);
+  return val;
+}
+function isEmptyObject2(val, msg) {
+  if (!guard_exports.isEmptyObject(val))
+    _fail(`Expected ${fmt(val)} to be empty object`, msg);
+  return val;
+}
+function isPlainObject2(val, msg) {
+  if (!guard_exports.isPlainObject(val))
+    _fail(`Expected ${fmt(val)} to be plain object`, msg);
+  return val;
+}
+function isObjectOrUndefined2(val, msg) {
+  if (!guard_exports.isObjectOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be object or undefined`, msg);
+  return val;
+}
+function isTypedObject2(val, keys, msg) {
+  if (!guard_exports.isTypedObject(val, keys))
+    _fail(`Expected ${fmt(val)} to have keys ${fmt(keys)}`, msg);
+  return val;
+}
+function isArray2(val, msg) {
+  if (!guard_exports.isArray(val))
+    _fail(`Expected ${fmt(val)} to be array`, msg);
+  return val;
+}
+function isArrayOrUndefined2(val, msg) {
+  if (!guard_exports.isArrayOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be array or undefined`, msg);
+  return true;
+}
+function isEmptyArray2(val, msg) {
+  if (!guard_exports.isEmptyArray(val))
+    _fail(`Expected ${fmt(val)} to be empty array`, msg);
+}
+function isNonEmptyArray2(val, msg) {
+  if (!guard_exports.isNonEmptyArray(val))
+    _fail(`Expected ${fmt(val)} to be non-empty array`, msg);
+}
+function isEmptyArrayOrUndefined2(val, msg) {
+  if (!guard_exports.isEmptyArrayOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be empty array or undefined`, msg);
+}
+function isNonEmptyArrayOrUndefined2(val, msg) {
+  if (!guard_exports.isNonEmptyArrayOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be non-empty array or undefined`, msg);
+}
+function isString2(val, msg) {
+  if (!guard_exports.isString(val))
+    _fail(`Expected ${fmt(val)} to be string`, msg);
+  return val;
+}
+function isEmptyString2(val, msg) {
+  if (!guard_exports.isEmptyString(val))
+    _fail(`Expected ${fmt(val)} to be empty string`, msg);
+  return val;
+}
+function isNonEmptyString2(val, msg) {
+  if (!guard_exports.isNonEmptyString(val))
+    _fail(`Expected ${fmt(val)} to be non-empty string`, msg);
+  return val;
+}
+function isStringOrUndefined2(val, msg) {
+  if (!guard_exports.isStringOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be string or undefined`, msg);
+  return val;
+}
+function isEmptyStringOrUndefined2(val, msg) {
+  if (!guard_exports.isEmptyStringOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be empty string or undefined`, msg);
+  return val;
+}
+function isNonEmptyStringOrUndefined2(val, msg) {
+  if (!guard_exports.isNonEmptyStringOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be non-empty string or undefined`, msg);
+  return val;
+}
+function isBoolean2(val, msg) {
+  if (!guard_exports.isBoolean(val))
+    _fail(`Expected ${fmt(val)} to be boolean`, msg);
+  return val;
+}
+function isBooleanOrUndefined2(val, msg) {
+  if (!guard_exports.isBooleanOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be boolean or undefined`, msg);
+  return val;
+}
+function isTrue2(val, msg) {
+  if (!guard_exports.isTrue(val))
+    _fail(`Expected ${fmt(val)} to be true`, msg);
+  return val;
+}
+function isTrueOrUndefined2(val, msg) {
+  if (!guard_exports.isTrueOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be true or undefined`, msg);
+  return val;
+}
+function isFalse2(val, msg) {
+  if (!guard_exports.isFalse(val))
+    _fail(`Expected ${fmt(val)} to be false`, msg);
+  return val;
+}
+function isFalseOrUndefined2(val, msg) {
+  if (!guard_exports.isFalseOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be false or undefined`, msg);
+  return val;
+}
+function isFunction2(val, msg) {
+  if (!guard_exports.isFunction(val))
+    _fail(`Expected ${fmt(val)} to be function`, msg);
+  return val;
+}
+function isFunctionOrUndefined2(val, msg) {
+  if (!guard_exports.isFunctionOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be function or undefined`, msg);
+  return val;
+}
+function isEnumValue2(val, enumObject, msg) {
+  if (!guard_exports.isEnumValue(val, enumObject))
+    _fail(`Expected ${fmt(val)} to be enum val`, msg);
+  return val;
+}
+function isEnumValueOrUndefined2(val, enumObject, msg) {
+  if (!guard_exports.isEnumValueOrUndefined(val, enumObject))
+    _fail(`Expected ${fmt(val)} to be enum val or undefined`, msg);
+  return val;
+}
+function isNumericString2(val, msg) {
+  if (!guard_exports.isNumericString(val))
+    _fail(`Expected ${fmt(val)} to be numeric string`, msg);
+  return val;
+}
+function isBigInt2(val, msg) {
+  if (!guard_exports.isBigInt(val))
+    _fail(`Expected ${fmt(val)} to be BigInt`, msg);
+  return val;
+}
+function isNumber2(val, msg) {
+  if (!guard_exports.isNumber(val))
+    _fail(`Expected ${fmt(val)} to be number`, msg);
+  return val;
+}
+function isNumberOrUndefined2(val, msg) {
+  if (!guard_exports.isNumberOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be number or undefined`, msg);
+  return val;
+}
+function isFinite3(val, msg) {
+  if (!guard_exports.isFinite(val))
+    _fail(`Expected ${fmt(val)} to be finite`, msg);
+  return val;
+}
+function isFloat2(val, msg) {
+  if (!guard_exports.isFloat(val))
+    _fail(`Expected ${fmt(val)} to be float`, msg);
+  return val;
+}
+function isInteger2(val, msg) {
+  if (!guard_exports.isInteger(val))
+    _fail(`Expected ${fmt(val)} to be integer`, msg);
+  return val;
+}
+function isSafeInteger2(val, msg) {
+  if (!guard_exports.isSafeInteger(val))
+    _fail(`Expected ${fmt(val)} to be safe integer`, msg);
+  return val;
+}
+function isIntegerOrUndefined2(val, msg) {
+  if (!guard_exports.isIntegerOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be integer or undefined`, msg);
+  return val;
+}
+function isIntegerEq2(val, ref, msg) {
+  if (!guard_exports.isIntegerEq(val, ref))
+    _fail(`Expected ${fmt(val)} to be integer equal to ${fmt(ref)}`, msg);
+  return val;
+}
+function isIntegerGt2(val, ref, msg) {
+  if (!guard_exports.isIntegerGt(val, ref))
+    _fail(`Expected ${fmt(val)} to be integer > ${fmt(ref)}`, msg);
+  return val;
+}
+function isIntegerGte2(val, ref, msg) {
+  if (!guard_exports.isIntegerGte(val, ref))
+    _fail(`Expected ${fmt(val)} to be integer >= ${fmt(ref)}`, msg);
+  return val;
+}
+function isIntegerLt2(val, ref, msg) {
+  if (!guard_exports.isIntegerLt(val, ref))
+    _fail(`Expected ${fmt(val)} to be integer < ${fmt(ref)}`, msg);
+  return val;
+}
+function isIntegerLte2(val, ref, msg) {
+  if (!guard_exports.isIntegerLte(val, ref))
+    _fail(`Expected ${fmt(val)} to be integer <= ${fmt(ref)}`, msg);
+  return val;
+}
+function isIntegerBetween2(val, min, max, msg) {
+  if (!guard_exports.isIntegerBetween(val, min, max))
+    _fail(`Expected integer ${fmt(min)} <= ${fmt(val)} <= ${fmt(max)}`, msg);
+  return val;
+}
+function isIntegerBetweenExclusive2(val, min, max, msg) {
+  if (!guard_exports.isIntegerBetweenExclusive(val, min, max))
+    _fail(`Expected integer ${fmt(min)} < ${fmt(val)} < ${fmt(max)}`, msg);
+  return val;
+}
+function isNumberBetween2(val, min, max, msg) {
+  if (!guard_exports.isNumberBetween(val, min, max))
+    _fail(`Expected number ${fmt(min)} <= ${fmt(val)} <= ${fmt(max)}`, msg);
+  return val;
+}
+function isNumberBetweenExclusive2(val, min, max, msg) {
+  if (!guard_exports.isNumberBetweenExclusive(val, min, max))
+    _fail(`Expected number ${fmt(min)} < ${fmt(val)} < ${fmt(max)}`, msg);
+  return val;
+}
+function isNaNValue2(val, msg) {
+  if (!guard_exports.isNaNValue(val))
+    _fail(`Expected ${fmt(val)} to be NaN`, msg);
+  return NaN;
+}
+function isInfinity2(val, msg) {
+  if (!guard_exports.isInfinity(val))
+    _fail(`Expected ${fmt(val)} to be +-Infinity`, msg);
+  return val;
+}
+function isPosInfinity2(val, msg) {
+  if (!guard_exports.isPosInfinity(val))
+    _fail(`Expected ${fmt(val)} to be +Infinity`, msg);
+  return val;
+}
+function isNegInfinity2(val, msg) {
+  if (!guard_exports.isNegInfinity(val))
+    _fail(`Expected ${fmt(val)} to be -Infinity`, msg);
+  return val;
+}
+function isPos2(val, msg) {
+  if (!guard_exports.isPos(val))
+    _fail(`Expected ${fmt(val)} to be positive (> 0)`, msg);
+  return val;
+}
+function isNeg2(val, msg) {
+  if (!guard_exports.isNeg(val))
+    _fail(`Expected ${fmt(val)} to be negative (< 0)`, msg);
+  return val;
+}
+function isNonPos2(val, msg) {
+  if (!guard_exports.isNonPos(val))
+    _fail(`Expected ${fmt(val)} to be non-positive (<= 0)`, msg);
+  return val;
+}
+function isNonNeg2(val, msg) {
+  if (!guard_exports.isNonNeg(val))
+    _fail(`Expected ${fmt(val)} to be non-negative (>= 0)`, msg);
+  return val;
+}
+function isZero2(val, msg) {
+  if (!guard_exports.isZero(val))
+    _fail(`Expected ${fmt(val)} to be 0`, msg);
+  return val;
+}
+function isPosZero2(val, msg) {
+  if (!guard_exports.isPosZero(val))
+    _fail(`Expected ${fmt(val)} to be +0`, msg);
+  return val;
+}
+function isNegZero2(val, msg) {
+  if (!guard_exports.isNegZero(val))
+    _fail(`Expected ${fmt(val)} to be -0`, msg);
+  return val;
+}
+function isOdd2(val, msg) {
+  if (!guard_exports.isOdd(val))
+    _fail(`Expected ${fmt(val)} to odd`, msg);
+  return val;
+}
+function isEven2(val, msg) {
+  if (!guard_exports.isEven(val))
+    _fail(`Expected ${fmt(val)} to even`, msg);
+  return val;
+}
+function isMultipleOf2(val, base, msg) {
+  if (!guard_exports.isMultipleOf(val, base))
+    _fail(`Expected ${fmt(val)} to be divisble bu ${fmt(base)}`, msg);
+  return val;
+}
+function isPowerOfTwo2(val, msg) {
+  if (!guard_exports.isPowerOfTwo(val))
+    _fail(`Expected ${fmt(val)} to be power of two`, msg);
+  return val;
+}
+function isIncluded2(val, arr, msg) {
+  if (!guard_exports.isIncluded(val, arr))
+    _fail(`Expected ${fmt(val)} to be included in ${fmt(arr)}`, msg);
+  return val;
+}
+function isIndex2(...args) {
+  const index = args.shift();
+  const msg = guard_exports.isString(args[args.length - 1]) ? args.pop() : void 0;
+  const arr = guard_exports.isArray(args[0]) ? args.shift() : void 0;
+  if (!guard_exports.isIndex(index, arr)) {
+    if (arr === void 0)
+      _fail(`Expected ${index} to be index`, msg);
+    else
+      _fail(`Expected ${index} to be index for ${fmt(arr)}`, msg);
+  }
+  return index;
+}
+function doesThrow2(throwTestFn, msg) {
+  if (!guard_exports.doesThrow(throwTestFn))
+    _fail(`Expected to throw`, msg);
+  return true;
+}
+function doesNotThrow2(throwTestFn, msg) {
+  if (!guard_exports.doesNotThrow(throwTestFn))
+    _fail(`Expected to throw`, msg);
+  return true;
+}
+
+// src/web/cookies.ts
+var cookies_exports = {};
+__export(cookies_exports, {
+  accept: () => accept,
+  decline: () => decline,
+  erase: () => erase,
+  eraseAll: () => eraseAll,
+  isConsentPending: () => isConsentPending,
+  read: () => read,
+  readBool: () => readBool,
+  readInt: () => readInt,
+  save: () => save,
+  setExpireDays: () => setExpireDays
+});
+var ConsentCookieName = "ConsentCookie";
+var _consent;
+var _expires;
+var str = _read(ConsentCookieName);
+_consent = str === "accept" /* Accept */ || str === "decline" /* Decline */ ? str : void 0;
+function _getList() {
+  let s = document.cookie;
+  return s.split(";").map((c) => c.trim());
+}
+function _save(name, value) {
+  let cookie = name + "=" + value.toString() + ";sameSite=Lax;";
+  if (_expires) {
+    cookie += "expires=" + _expires.toUTCString() + ";";
+  }
+  document.cookie = cookie;
+  return value;
+}
+function _read(name, defaultValue) {
+  let str2 = _getList().find((c) => c.startsWith(name + "="));
+  return str2 === void 0 ? defaultValue : str2.substring(name.length + 1);
+}
+function _erase(name) {
+  document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 UTC;";
+}
+function setExpireDays(days) {
+  _expires = /* @__PURE__ */ new Date();
+  _expires.setDate(_expires.getDate() + days);
+}
+function isConsentPending() {
+  return _consent === void 0;
 }
 function accept() {
   _consent = "accept" /* Accept */;
@@ -723,319 +1258,12 @@ function toPx(input) {
   }
 }
 
-// src/guard/index.ts
-var guard_exports = {};
-__export(guard_exports, {
-  isArray: () => isArray2,
-  isArrayIndex: () => isArrayIndex2,
-  isArrayOrUndefined: () => isArrayOrUndefined2,
-  isBoolean: () => isBoolean2,
-  isBooleanOrUndefined: () => isBooleanOrUndefined2,
-  isDeepEqual: () => isDeepEqual2,
-  isEmptyArray: () => isEmptyArray2,
-  isEmptyArrayOrUndefined: () => isEmptyArrayOrUndefined2,
-  isEmptyString: () => isEmptyString2,
-  isEmptyStringOrUndefined: () => isEmptyStringOrUndefined2,
-  isEnumValue: () => isEnumValue3,
-  isEnumValueOrUndefined: () => isEnumValueOrUndefined2,
-  isEqual: () => isEqual2,
-  isEvenNumber: () => isEvenNumber2,
-  isFalse: () => isFalse2,
-  isFalseOrUndefined: () => isFalseOrUndefined2,
-  isFinite: () => isFinite3,
-  isFunction: () => isFunction2,
-  isFunctionOrUndefined: () => isFunctionOrUndefined2,
-  isIncluded: () => isIncluded2,
-  isInfinity: () => isInfinity2,
-  isInteger: () => isInteger2,
-  isIntegerBetween: () => isIntegerBetween2,
-  isIntegerBetweenExclusive: () => isIntegerBetweenExclusive2,
-  isIntegerEq: () => isIntegerEq2,
-  isIntegerGt: () => isIntegerGt2,
-  isIntegerGte: () => isIntegerGte2,
-  isIntegerLt: () => isIntegerLt2,
-  isIntegerLte: () => isIntegerLte2,
-  isIntegerOrUndefined: () => isIntegerOrUndefined2,
-  isNaNValue: () => isNaNValue2,
-  isNegInfinity: () => isNegInfinity2,
-  isNonEmptyArray: () => isNonEmptyArray2,
-  isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined2,
-  isNonEmptyString: () => isNonEmptyString2,
-  isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined2,
-  isNotThrowing: () => isNotThrowing2,
-  isNull: () => isNull2,
-  isNullish: () => isNullish2,
-  isNumber: () => isNumber2,
-  isNumberBetween: () => isNumberBetween2,
-  isNumberBetweenExclusive: () => isNumberBetweenExclusive2,
-  isNumberOrUndefined: () => isNumberOrUndefined2,
-  isObject: () => isObject2,
-  isObjectOrUndefined: () => isObjectOrUndefined2,
-  isOddNumber: () => isOddNumber2,
-  isPosInfinity: () => isPosInfinity2,
-  isString: () => isString2,
-  isStringOrUndefined: () => isStringOrUndefined2,
-  isThrowing: () => isThrowing2,
-  isTrue: () => isTrue2,
-  isTrueOrUndefined: () => isTrueOrUndefined2,
-  isTypedObject: () => isTypedObject2,
-  isUndefined: () => isUndefined2,
-  tryOr: () => tryOr
-});
-
-// src/utils/obj/index.ts
-var obj_exports = {};
-__export(obj_exports, {
-  deepEqual: () => deepEqual,
-  hasProperties: () => hasProperties,
-  isObject: () => isObject2
-});
-function hasProperties(obj, props) {
-  return isObject2(obj) && props.every((p) => p in obj);
-}
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (a === null || b === null) return false;
-  if (typeof a !== "object" || typeof b !== "object") return false;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    return a.every((val, i) => deepEqual(val, b[i]));
-  }
-  if (Array.isArray(a) !== Array.isArray(b)) return false;
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) return false;
-  for (const key of keysA) {
-    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
-    if (!deepEqual(a[key], b[key])) return false;
-  }
-  return true;
-}
-
-// src/utils/enum/index.ts
-var enum_exports = {};
-__export(enum_exports, {
-  assertEnumValue: () => assertEnumValue,
-  forEachEnum: () => forEachEnum,
-  getEnumEntries: () => getEnumEntries,
-  getEnumKey: () => getEnumKey,
-  getEnumKeys: () => getEnumKeys,
-  getEnumValues: () => getEnumValues,
-  isEnumValue: () => isEnumValue2
-});
-function getEnumKeys(e) {
-  return Object.keys(e).filter((k) => isNaN(Number(k)));
-}
-function getEnumValues(e) {
-  return getEnumKeys(e).map((k) => e[k]);
-}
-function getEnumEntries(e) {
-  return getEnumKeys(e).map((k) => [k, e[k]]);
-}
-function getEnumKey(e, value) {
-  return getEnumKeys(e).find((k) => e[k] === value);
-}
-function forEachEnum(e, callback) {
-  for (const [k, v] of getEnumEntries(e)) callback(k, v);
-}
-function isEnumValue2(e, value) {
-  return getEnumValues(e).includes(value);
-}
-function assertEnumValue(e, value) {
-  if (!isEnumValue2(e, value)) {
-    throw new TypeError(`Invalid enum value: ${String(value)}`);
-  }
-}
-
-// src/guard/index.ts
-function isEqual2(value1, value2) {
-  return value1 === value2;
-}
-function isDeepEqual2(value1, value2) {
-  return deepEqual(value1, value2);
-}
-function isUndefined2(value) {
-  return value === void 0;
-}
-function isNull2(value) {
-  return value === null;
-}
-function isNullish2(value) {
-  return value === void 0 || value === null;
-}
-function isObject2(value) {
-  return typeof value === "object" && value !== null && !isArray2(value);
-}
-function isObjectOrUndefined2(value) {
-  return value === void 0 || isObject2(value);
-}
-function isTypedObject2(obj, keys) {
-  return isObject2(obj) && keys.every((k) => k in obj);
-}
-function isArray2(a) {
-  return !!a && Object.prototype.toString.call(a) === "[object Array]";
-}
-function isArrayOrUndefined2(value) {
-  return value === void 0 || isArray2(value);
-}
-function isEmptyArray2(a) {
-  return isArray2(a) && a.length === 0;
-}
-function isNonEmptyArray2(a) {
-  return isArray2(a) && a.length > 0;
-}
-function isEmptyArrayOrUndefined2(a) {
-  return isArray2(a) && a.length === 0 || a === void 0;
-}
-function isNonEmptyArrayOrUndefined2(a) {
-  return isArray2(a) && a.length > 0 || a === void 0;
-}
-function isString2(value) {
-  return typeof value === "string";
-}
-function isEmptyString2(value) {
-  return typeof value === "string" && value.length === 0;
-}
-function isNonEmptyString2(value) {
-  return typeof value === "string" && value.length > 0;
-}
-function isStringOrUndefined2(value) {
-  return value === void 0 || typeof value === "string";
-}
-function isEmptyStringOrUndefined2(value) {
-  return typeof value === "string" && value.length === 0 || value === void 0;
-}
-function isNonEmptyStringOrUndefined2(value) {
-  return typeof value === "string" && value.length > 0 || value === void 0;
-}
-function isBoolean2(value) {
-  return typeof value === "boolean";
-}
-function isBooleanOrUndefined2(value) {
-  return value === void 0 || typeof value === "boolean";
-}
-function isTrue2(value) {
-  return value === true;
-}
-function isTrueOrUndefined2(value) {
-  return value === true || value === void 0;
-}
-function isFalse2(value) {
-  return value === false;
-}
-function isFalseOrUndefined2(value) {
-  return value === false || value === void 0;
-}
-function isFunction2(value) {
-  return typeof value === "function";
-}
-function isFunctionOrUndefined2(value) {
-  return value === void 0 || typeof value === "function";
-}
-function isEnumValue3(value, enumObj, name = "value") {
-  return getEnumValues(enumObj).some((v) => v === value);
-}
-function isEnumValueOrUndefined2(value, enumObj, name = "value") {
-  return value === void 0 || getEnumValues(enumObj).some((v) => v === value);
-}
-function isNumber2(value) {
-  return typeof value === "number";
-}
-function isNumberOrUndefined2(value) {
-  return typeof value === "number" || value === void 0;
-}
-function isFinite3(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function isInteger2(n) {
-  return typeof n === "number" && isFinite3(n) && n === Math.trunc(n);
-}
-function isIntegerOrUndefined2(n) {
-  return typeof n === "number" && isFinite3(n) && n === Math.trunc(n) || n === void 0;
-}
-function isIntegerEq2(value, compareTo) {
-  return isInteger2(value) && value === compareTo;
-}
-function isIntegerGt2(value, compareTo) {
-  return isInteger2(value) && isNumber2(compareTo) && value > compareTo;
-}
-function isIntegerGte2(value, compareTo) {
-  return isInteger2(value) && isNumber2(compareTo) && value >= compareTo;
-}
-function isIntegerLt2(value, compareTo) {
-  return isInteger2(value) && isNumber2(compareTo) && value < compareTo;
-}
-function isIntegerLte2(value, compareTo) {
-  return isInteger2(value) && isNumber2(compareTo) && value <= compareTo;
-}
-function isIntegerBetween2(value, min, max) {
-  return isInteger2(value) && isNumber2(min) && isNumber2(max) && value >= min && value <= max;
-}
-function isIntegerBetweenExclusive2(value, min, max) {
-  return isInteger2(value) && isNumber2(min) && isNumber2(max) && value > min && value < max;
-}
-function isNumberBetween2(value, min, max) {
-  return isNumber2(value) && isNumber2(min) && isNumber2(max) && value >= min && value <= max;
-}
-function isNumberBetweenExclusive2(value, min, max) {
-  return isNumber2(value) && isNumber2(min) && isNumber2(max) && value > min && value < max;
-}
-function isNaNValue2(value) {
-  return typeof value === "number" && Number.isNaN(value);
-}
-function isInfinity2(value) {
-  return typeof value === "number" && Math.abs(value) === Infinity;
-}
-function isPosInfinity2(value) {
-  return typeof value === "number" && value === Infinity;
-}
-function isNegInfinity2(value) {
-  return typeof value === "number" && value === -Infinity;
-}
-function isOddNumber2(value) {
-  return isInteger2(value) && value % 2 === 1;
-}
-function isEvenNumber2(value) {
-  return isInteger2(value) && value % 2 === 0;
-}
-function isIncluded2(value, array) {
-  return array.includes(value);
-}
-function isArrayIndex2(index, array) {
-  return isInteger2(index) && isArray2(array) && index >= 0 && index < array.length;
-}
-function isThrowing2(throwTestFn) {
-  try {
-    throwTestFn();
-    return false;
-  } catch (err) {
-    return true;
-  }
-}
-function isNotThrowing2(throwTestFn) {
-  try {
-    throwTestFn();
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
-function tryOr(tryFn, orVal) {
-  try {
-    return tryFn();
-  } catch (err) {
-    return isFunction2(orVal) ? orVal() : orVal;
-  }
-}
-
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
   Arr: () => arr_exports,
   Dom: () => dom_exports,
   Enum: () => enum_exports,
-  Is: () => Is,
-  Map: () => map_exports,
   Math: () => math_exports,
   Obj: () => obj_exports,
   Str: () => str_exports
@@ -1050,33 +1278,29 @@ __export(arr_exports, {
   fillArray: () => fillArray,
   getRangeArray: () => getRangeArray,
   getSequenceArray: () => getSequenceArray,
-  isArray: () => isArray2,
+  isArray: () => isArray,
   mapRangeArray: () => mapRangeArray,
   mapSequenceArray: () => mapSequenceArray,
   removeDuplicates: () => removeDuplicates,
-  removeDuplicatesCmp: () => removeDuplicatesCmp,
   toArray: () => toArray
 });
 function toArray(a) {
-  return isArray2(a) ? a : [a];
+  return isArray(a) ? a : [a];
 }
 function duplicate(a) {
-  return a === void 0 ? a : a.slice();
+  return a?.slice() ?? [];
 }
 function removeDuplicates(arr, compareFn) {
   return compareFn !== void 0 ? arr.filter((a, id, self) => id === self.findIndex((b) => compareFn(a, b))) : arr.filter((a, id, self) => id === self.indexOf(a));
 }
-function removeDuplicatesCmp(arr, compareFn) {
-  return arr.filter((a, id, self) => id === self.findIndex((b) => compareFn(a, b)));
-}
 function fillArray(fillValue, fillCount) {
-  if (!isInteger2(fillCount) || fillCount < 0) {
+  if (!isInteger(fillCount) || fillCount < 0) {
     throw new Error("fillArray: Invalid fillCount = " + fillCount);
   }
   return new Array(fillCount).fill(fillValue);
 }
 function mapSequenceArray(len, fn) {
-  if (!isInteger2(len) || len < 0) {
+  if (!isInteger(len) || len < 0) {
     throw new Error("mapSequenceArray: Invalid len = " + len);
   }
   let arr = new Array(len);
@@ -1089,10 +1313,10 @@ function getSequenceArray(len) {
   return mapSequenceArray(len, (i) => i);
 }
 function mapRangeArray(start, end, fn) {
-  if (!isInteger2(start)) {
+  if (!isInteger(start)) {
     throw new Error("mapRangeArray: Invalid start = " + end);
   }
-  if (!isInteger2(end)) {
+  if (!isInteger(end)) {
     throw new Error("mapRangeArray: Invalid end = " + end);
   }
   let len = Math.abs(end - start) + 1;
@@ -1109,7 +1333,7 @@ function arrayContains(arg, item) {
   return arg.indexOf(item) >= 0;
 }
 function chunckArray(arr, chunckSize) {
-  if (!isInteger2(chunckSize) || chunckSize < 1) {
+  if (!isInteger(chunckSize) || chunckSize < 1) {
     throw new Error("chunckArray: Invalid chunckSize = " + chunckSize);
   }
   let result = [];
@@ -1309,15 +1533,6 @@ function getCanvasTextWidth(text, font) {
   return ctx.measureText(text).width;
 }
 
-// src/utils/map/index.ts
-var map_exports = {};
-__export(map_exports, {
-  getMapKeys: () => getMapKeys
-});
-function getMapKeys(map) {
-  return [...map.keys()];
-}
-
 // src/utils/math/index.ts
 var math_exports = {};
 __export(math_exports, {
@@ -1327,8 +1542,8 @@ __export(math_exports, {
   cmp: () => cmp,
   interpolateCoord: () => interpolateCoord,
   interpolateY: () => interpolateY,
-  isInteger: () => isInteger2,
-  isNumber: () => isNumber2,
+  isInteger: () => isInteger,
+  isNumber: () => isNumber,
   linearToDecibels: () => linearToDecibels,
   mod: () => mod,
   romanize: () => romanize,
@@ -1348,7 +1563,7 @@ function mod(m, n) {
   return (m % n + n) % n;
 }
 function romanize(n) {
-  if (!isInteger2(n) || n < 0) {
+  if (!isInteger(n) || n < 0) {
     throw new Error("romanize: Invalid n = " + n);
   }
   var digits = String(+n).split("");
@@ -1389,7 +1604,7 @@ function romanize(n) {
   return Array(+digits.join("") + 1).join("M") + roman;
 }
 function toOrdinalNumber(n) {
-  if (!isInteger2(n)) {
+  if (!isInteger(n)) {
     throw new Error("toOrdinalNumber: Invalid n = " + n);
   }
   const nStr = n.toString();
@@ -1442,21 +1657,6 @@ function cmp(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
 
-// src/utils/str/index.ts
-var str_exports = {};
-__export(str_exports, {
-  charCount: () => charCount,
-  chunkString: () => chunkString,
-  insertAt: () => insertAt,
-  isString: () => isString2,
-  makeSentenceFromPascal: () => makeSentenceFromPascal,
-  removeAt: () => removeAt,
-  repeatString: () => repeatString,
-  replaceAt: () => replaceAt,
-  stringify: () => stringify,
-  toCharArray: () => toCharArray
-});
-
 // src/core/base.ts
 var DefaultEqualityFn = (a, b) => a === b;
 var BaseContainer = class {
@@ -1487,7 +1687,7 @@ var Stack = class extends BaseContainer {
     return this.data.pop();
   }
   popOr(defaultValueOrCreator) {
-    return this.isEmpty() ? isFunction2(defaultValueOrCreator) ? defaultValueOrCreator() : defaultValueOrCreator : this.data.pop();
+    return this.isEmpty() ? isFunction(defaultValueOrCreator) ? defaultValueOrCreator() : defaultValueOrCreator : this.data.pop();
   }
   top() {
     return this.data[this.assertId(this.length - 1)];
@@ -1496,7 +1696,7 @@ var Stack = class extends BaseContainer {
     return this.data[this.length - 1];
   }
   topOr(defaultValueOrCreator) {
-    return this.isEmpty() ? isFunction2(defaultValueOrCreator) ? defaultValueOrCreator() : defaultValueOrCreator : this.data[this.length - 1];
+    return this.isEmpty() ? isFunction(defaultValueOrCreator) ? defaultValueOrCreator() : defaultValueOrCreator : this.data[this.length - 1];
   }
   peek(depth = 0) {
     return this.data[this.assertId(this.data.length - 1 - depth)];
@@ -1507,7 +1707,7 @@ var Stack = class extends BaseContainer {
   peekOr(depth = 0, defaultValueOrCreator) {
     const id = this.data.length - 1 - depth;
     const value = id < 0 ? void 0 : this.data[id];
-    return value === void 0 ? isFunction2(defaultValueOrCreator) ? defaultValueOrCreator() : defaultValueOrCreator : value;
+    return value === void 0 ? isFunction(defaultValueOrCreator) ? defaultValueOrCreator() : defaultValueOrCreator : value;
   }
   *values() {
     for (let id = this.data.length - 1; id >= 0; id--)
@@ -1616,7 +1816,7 @@ var Vec = class _Vec extends BaseContainer {
     if (a.coords.length !== b.coords.length) {
       throw new TypeError("Coordinate length mismatch!");
     }
-    if (!isFinite3(t)) {
+    if (!isFinite2(t)) {
       throw new TypeError("Lerp t is not finite!");
     }
     return a.add(b.sub(a).mul(t));
@@ -2167,6 +2367,9 @@ var AnchoredRect = class _AnchoredRect {
   toRect() {
     return new Rect(this.left, this.right, this.width, this.height);
   }
+  toString() {
+    return `Rect(left=${this.left}, anchorX=${this.anchorX}, right=${this.right}, top=${this.top}, anchorY=${this.anchorY}, bottom=${this.bottom})`;
+  }
 };
 
 // src/core/LRU-cache.ts
@@ -2310,7 +2513,7 @@ var IndexArray = class _IndexArray extends BaseContainer {
     }
   }
   static validateIndex(id) {
-    if (!isIntegerGte2(id, 0)) throw new Error(`Invalid index ${id} - must be an integer >= 0!`);
+    if (!isIntegerGte(id, 0)) throw new Error(`Invalid index ${id} - must be an integer >= 0!`);
     return id;
   }
   get posLen() {
@@ -2349,7 +2552,7 @@ var IndexArray = class _IndexArray extends BaseContainer {
   }
   getOrCreate(id, creatorOrValue) {
     if (!this.has(id)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
       this.set(id, value);
       return value;
     }
@@ -2486,15 +2689,15 @@ var IndexArray = class _IndexArray extends BaseContainer {
     }
     return result;
   }
-  equals(other, eq2) {
+  equals(other, eq) {
     if (this.size !== other.size) return false;
-    eq2 ?? (eq2 = (a, b) => a === b);
+    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 && !eq2(this.posVal[i], other.posVal[i])) return false;
+      if (hasA && !eq(this.posVal[i], other.posVal[i])) return false;
     }
     return true;
   }
@@ -2547,7 +2750,7 @@ var SignedIndexArray = class _SignedIndexArray extends BaseContainer {
     return -id - 1;
   }
   static validateIndex(id) {
-    if (!isInteger2(id)) throw new Error(`Invalid index ${id} - must be an integer!`);
+    if (!isInteger(id)) throw new Error(`Invalid index ${id} - must be an integer!`);
     return id;
   }
   get size() {
@@ -2597,7 +2800,7 @@ var SignedIndexArray = class _SignedIndexArray extends BaseContainer {
   }
   getOrCreate(id, creatorOrValue) {
     if (!this.has(id)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
       this.set(id, value);
       return value;
     }
@@ -2605,10 +2808,10 @@ var SignedIndexArray = class _SignedIndexArray extends BaseContainer {
   }
   delete(id) {
     _SignedIndexArray.validateIndex(id);
-    const isPos = id >= 0;
-    const arr = isPos ? this.posVal : this.negVal;
-    const has = isPos ? this.hasPos : this.hasNeg;
-    const idx = isPos ? id : _SignedIndexArray.toNegIndex(id);
+    const isPos3 = id >= 0;
+    const arr = isPos3 ? this.posVal : this.negVal;
+    const has = isPos3 ? this.hasPos : this.hasNeg;
+    const idx = isPos3 ? id : _SignedIndexArray.toNegIndex(id);
     if (!has[idx]) return false;
     arr[idx] = void 0;
     has[idx] = false;
@@ -2748,22 +2951,22 @@ var SignedIndexArray = class _SignedIndexArray extends BaseContainer {
     }
     return result;
   }
-  equals(other, eq2) {
+  equals(other, eq) {
     if (this.size !== other.size) return false;
-    eq2 ?? (eq2 = (a, b) => a === b);
+    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 && !eq2(this.posVal[i], other.posVal[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 && !eq2(this.negVal[i], other.negVal[i])) return false;
+      if (hasA && !eq(this.negVal[i], other.negVal[i])) return false;
     }
     return true;
   }
@@ -2832,7 +3035,7 @@ var DefaultArray = class _DefaultArray extends BaseContainer {
   }
   getOrCreate(id, creatorOrValue) {
     if (!this.has(id)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
       this.set(id, value);
       return value;
     }
@@ -2967,11 +3170,11 @@ var DefaultArray = class _DefaultArray extends BaseContainer {
     }
     return result;
   }
-  equals(other, eq2) {
+  equals(other, eq) {
     if (this.size !== other.size) return false;
-    eq2 ?? (eq2 = (a, b) => a === b);
+    eq ?? (eq = (a, b) => a === b);
     for (let id = 0; id < this.data.length; ++id) {
-      if (!eq2(this.data[id], other.data[id])) return false;
+      if (!eq(this.data[id], other.data[id])) return false;
     }
     return true;
   }
@@ -2990,12 +3193,12 @@ var UniMap = class _UniMap extends BaseContainer {
     __publicField(this, "map");
     __publicField(this, "keyEquals");
     const maybeEquals = args.at(-1);
-    this.keyEquals = isFunction2(maybeEquals) ? args.pop() : DefaultEqualityFn;
+    this.keyEquals = isFunction(maybeEquals) ? args.pop() : DefaultEqualityFn;
     const entries = args[0];
     this.map = new Map(entries);
   }
   static createDeep(arg) {
-    return arg ? new _UniMap(arg, isDeepEqual2) : new _UniMap(isDeepEqual2);
+    return arg ? new _UniMap(arg, isDeepEqual) : new _UniMap(isDeepEqual);
   }
   has(key) {
     if (this.keyEquals === DefaultEqualityFn || this.map.has(key))
@@ -3039,7 +3242,7 @@ var UniMap = class _UniMap extends BaseContainer {
   }
   getOrCreate(key, creatorOrValue) {
     if (!this.has(key)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
       return this.set(key, value);
     }
     return this.get(key);
@@ -3130,7 +3333,7 @@ var UniMap = class _UniMap extends BaseContainer {
     let first = iterator.next();
     if (first.done) {
       if (arguments.length < 2) {
-        throw new TypeError("Reduce of empty Map1 with no initial value!");
+        throw new TypeError("Reduce of empty UniMap with no initial value!");
       }
       return init;
     }
@@ -3207,7 +3410,7 @@ var BiMap = class _BiMap extends BaseContainer {
   }
   getOrCreate(key1, key2, creatorOrValue) {
     if (!this.has(key1, key2)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
       this.set(key1, key2, value);
       return value;
     }
@@ -3317,7 +3520,7 @@ var BiMap = class _BiMap extends BaseContainer {
     let first = iterator.next();
     if (first.done) {
       if (arguments.length < 2) {
-        throw new TypeError("Reduce of empty Map2 with no initial value!");
+        throw new TypeError("Reduce of empty BiMap with no initial value!");
       }
       return init;
     }
@@ -3412,7 +3615,7 @@ var TriMap = class _TriMap extends BaseContainer {
   }
   getOrCreate(key1, key2, key3, creatorOrValue) {
     if (!this.has(key1, key2, key3)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
       this.set(key1, key2, key3, value);
       return value;
     }
@@ -3540,7 +3743,7 @@ var TriMap = class _TriMap extends BaseContainer {
     let first = iterator.next();
     if (first.done) {
       if (arguments.length < 2) {
-        throw new TypeError("Reduce of empty Map3 with no initial value!");
+        throw new TypeError("Reduce of empty TriMap with no initial value!");
       }
       return init;
     }
@@ -3611,12 +3814,12 @@ var ValueSet = class _ValueSet extends BaseContainer {
     __publicField(this, "data");
     __publicField(this, "equals");
     const maybeEquals = args.at(-1);
-    this.equals = isFunction2(maybeEquals) ? args.pop() : DefaultEqualityFn;
+    this.equals = isFunction(maybeEquals) ? args.pop() : DefaultEqualityFn;
     const entries = args[0];
     this.data = new Set(entries);
   }
   static createDeep(arg) {
-    return arg ? new _ValueSet(arg, isDeepEqual2) : new _ValueSet(isDeepEqual2);
+    return arg ? new _ValueSet(arg, isDeepEqual) : new _ValueSet(isDeepEqual);
   }
   has(value) {
     if (this.equals === DefaultEqualityFn)
@@ -3644,7 +3847,7 @@ var ValueSet = class _ValueSet extends BaseContainer {
   }
   getOrCreate(key, creatorOrValue) {
     if (!this.has(key)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
       this.set(key, value);
       return value;
     }
@@ -3871,7 +4074,7 @@ var LinkedList = class _LinkedList extends BaseContainer {
     __publicField(this, "_size", 0);
     __publicField(this, "equals");
     const maybeEquals = args.at(-1);
-    this.equals = isFunction2(maybeEquals) ? args.pop() : DefaultEqualityFn;
+    this.equals = isFunction(maybeEquals) ? args.pop() : DefaultEqualityFn;
     const entries = args[0];
     if (entries) {
       for (const v of entries) {
@@ -3881,9 +4084,9 @@ var LinkedList = class _LinkedList extends BaseContainer {
   }
   static createDeep(entries) {
     if (entries) {
-      return new _LinkedList(entries, isDeepEqual2);
+      return new _LinkedList(entries, isDeepEqual);
     } else {
-      return new _LinkedList(isDeepEqual2);
+      return new _LinkedList(isDeepEqual);
     }
   }
   get length() {
@@ -4064,1416 +4267,33 @@ var LinkedList = class _LinkedList extends BaseContainer {
   }
 };
 
-// src/utils/str/index.ts
-function toCharArray(str2) {
-  return str2.split("");
-}
-function repeatString(repeatString2, repeatCount) {
-  if (!isInteger2(repeatCount) || repeatCount < 0) {
-    throw new Error("repeatStr: Invalid repeatCount = " + repeatCount);
-  }
-  return new Array(repeatCount + 1).join(repeatString2);
-}
-function chunkString(str2, chunkSize) {
-  if (!isInteger2(chunkSize) || chunkSize < 1) {
-    throw new Error("chunckString: Invalid chuckSize = " + chunkSize);
-  }
-  let result = [];
-  for (let i = 0; i < str2.length; i += chunkSize) {
-    result.push(str2.slice(i, i + chunkSize));
-  }
-  return result;
-}
-function replaceAt(str2, pos, removeCount, insert) {
-  if (!isInteger2(removeCount) || removeCount < 0) {
-    throw new Error("replaceAt: Invalid removeCount = " + removeCount);
-  } else if (!isInteger2(pos) || pos < 0 || pos + removeCount > str2.length) {
-    throw new Error("replaceAt: Invalid pos = " + pos + ", removeCount = " + removeCount + ", str.length = " + str2.length);
-  } else {
-    return str2.substring(0, pos) + insert + str2.substring(pos + removeCount);
-  }
-}
-function insertAt(str2, pos, insertStr) {
-  return replaceAt(str2, pos, 0, insertStr);
-}
-function removeAt(str2, pos, removeCount) {
-  return replaceAt(str2, pos, removeCount, "");
-}
-function charCount(str2, ch) {
-  if (ch.length !== 1 || str2.length === 0) return 0;
-  let count = 0;
-  for (let i = 0; i < str2.length; i++) {
-    if (str2[i] === ch) count++;
-  }
-  return count;
+// src/index.ts
+function getLibInfo() {
+  return "TsUtilsLib v2.1.0 (cjs)";
 }
-function makeSentenceFromPascal(PascalString) {
-  if (PascalString === "") {
-    return "";
-  }
-  let word = PascalString.charAt(0);
-  let sentence = "";
-  const addWord = () => {
-    if (word !== "") {
-      if (sentence === "") {
-        sentence += word.charAt(0).toUpperCase() + word.substring(1);
-      } else {
-        sentence += " " + word;
-      }
-      word = "";
-    }
-  };
-  const isLetterAndCapital = (c) => {
-    return c.toUpperCase() !== c.toLowerCase() && c === c.toUpperCase();
-  };
-  for (let i = 1; i < PascalString.length; i++) {
-    let c = PascalString.charAt(i);
-    if (isLetterAndCapital(c)) {
-      addWord();
-    }
-    word += c.toLowerCase();
-  }
-  addWord();
-  return sentence;
-}
-function stringify(value, maxDepth = 5, seen = /* @__PURE__ */ new WeakSet()) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const t = typeof value;
-  switch (t) {
-    case "boolean":
-      return value ? "true" : "false";
-    case "number":
-      if (isNaNValue2(value)) return "NaN";
-      if (!isFinite3(value))
-        return value < 0 ? "-Infinity" : "Infinity";
-      return value.toString();
-    case "bigint":
-      return `${value}n`;
-    case "string":
-      return `"${value}"`;
-    case "symbol":
-      return value.description ? `Symbol(${value.description})` : "Symbol()";
-    case "function":
-      return `[Function${value.name ? ` ${value.name}` : ""}]`;
-  }
-  if (seen.has(value))
-    return "[Circular]";
-  if (maxDepth <= 0)
-    return "[Depth limit]";
-  maxDepth--;
-  seen.add(value);
-  const strfy = (v) => stringify(v, maxDepth, seen);
-  if (isArray2(value)) {
-    const inner = value.map((v) => strfy(v)).join(", ");
-    return inner.length === 0 ? "[ ]" : `[ ${inner} ]`;
-  }
-  if (ArrayBuffer.isView(value)) {
-    if (value instanceof DataView)
-      return `DataView(${value.byteLength})`;
-    const inner = Array.from(value).map((v) => strfy(v)).join(", ");
-    return `${value.constructor.name}[ ${inner} ]`;
-  }
-  if (value instanceof ArrayBuffer)
-    return `ArrayBuffer(${value.byteLength})`;
-  if (value instanceof Map) {
-    const entries = Array.from(value.entries()).map(([k, v]) => `${strfy(k)} => ${strfy(v)}`).join(", ");
-    return entries.length === 0 ? `Map(${value.size}){ }` : `Map(${value.size}){ ${entries} }`;
-  }
-  if (value instanceof Set) {
-    const entries = Array.from(value.values()).map((v) => strfy(v)).join(", ");
-    return entries.length === 0 ? `Set(${value.size}){ }` : `Set(${value.size}){ ${entries} }`;
-  }
-  if (value instanceof WeakMap)
-    return "WeakMap{ ? }";
-  if (value instanceof WeakSet)
-    return "WeakSet{ ? }";
-  if (typeof BaseContainer !== "undefined" && value instanceof BaseContainer)
-    return value.toString();
-  if (value instanceof Date)
-    return `Date("${value.toISOString()}")`;
-  if (value instanceof RegExp)
-    return value.toString();
-  if (value instanceof Error)
-    return `${value.name}("${value.message}")`;
-  if (value instanceof Promise)
-    return "Promise{ ? }";
-  if (value instanceof URL)
-    return `URL("${value.href}")`;
-  if (value instanceof URLSearchParams)
-    return `URLSearchParams("${value.toString()}")`;
-  if (value === Math) return "Math";
-  if (value === JSON) return "JSON";
-  if (value === Reflect) return "Reflect";
-  if (value === Intl) return "Intl";
-  if (t === "object") {
-    const ctorName = value.constructor?.name ?? "Object";
-    const entries = Object.entries(value).map(
-      ([key, val]) => `${strfy(key)}: ${strfy(val)}`
-    );
-    if (entries.length === 0) return `${ctorName}{ }`;
-    return `${ctorName}{ ${entries.join(", ")} }`;
-  }
-  return String(value);
-}
-
-// src/utils/index.ts
-var Is = guard_exports;
-
-// src/deprecated/vec2.ts
-var Vec2 = class _Vec2 {
-  constructor(x, y) {
-    __publicField(this, "x");
-    __publicField(this, "y");
-    this.x = x ?? 0;
-    this.y = y ?? 0;
-  }
-  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/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 (!guard_exports.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 (!guard_exports.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 (!guard_exports.isInteger(key)) {
-      return false;
-    } else if (key >= 0) {
-      return key in this.pos;
-    } else {
-      return -key - 1 in this.neg;
-    }
-  }
-  delete(key) {
-    if (!guard_exports.isInteger(key)) {
-      return;
-    } else if (key >= 0) {
-      delete this.pos[key];
-    } else {
-      delete this.neg[-key - 1];
-    }
-  }
-  clear() {
-    this.pos = [];
-    this.neg = [];
-  }
-};
-
-// src/deprecated/map1.ts
-var Map1 = class _Map1 extends BaseContainer {
-  constructor(entries) {
-    super();
-    __publicField(this, "map1");
-    this.map1 = entries instanceof _Map1 ? new Map(entries.map1) : new Map(entries);
-  }
-  has(key1) {
-    return this.map1.has(key1);
-  }
-  set(key1, value) {
-    this.map1.set(key1, value);
-    return value;
-  }
-  get(key1) {
-    return this.map1.get(key1);
-  }
-  getOrDefault(key1, defaultValue) {
-    return this.get(key1) ?? defaultValue;
-  }
-  getOrCreate(key1, creatorOrValue) {
-    if (!this.has(key1)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
-      this.set(key1, value);
-      return value;
-    }
-    return this.get(key1);
-  }
-  delete(key1) {
-    return this.map1.delete(key1);
-  }
-  clear() {
-    this.map1.clear();
-  }
-  get size() {
-    return this.map1.size;
-  }
-  isEmpty() {
-    return this.size === 0;
-  }
-  forEach(callbackfn, thisArg) {
-    this.map1.forEach((value, key1) => callbackfn.call(thisArg, value, key1, this));
-  }
-  *keys() {
-    yield* this.map1.keys();
-  }
-  *values() {
-    yield* this.map1.values();
-  }
-  *entries() {
-    for (const [key1, value] of this.map1)
-      yield [key1, value];
-  }
-  keysArray() {
-    return [...this.keys()];
-  }
-  valuesArray() {
-    return [...this.values()];
-  }
-  entriesArray() {
-    return [...this.entries()];
-  }
-  *kvKeys() {
-    for (const key of this.keys()) {
-      yield [key];
-    }
-  }
-  *kvValues() {
-    for (const el of this.values()) {
-      yield el;
-    }
-  }
-  *kvEntries() {
-    for (const [key, el] of this.entries()) {
-      yield [[key], el];
-    }
-  }
-  *[Symbol.iterator]() {
-    yield* this.entries();
-  }
-  clone() {
-    return new _Map1(this);
-  }
-  merge(other, conflictResolver) {
-    for (const [key1, value] of other.entries()) {
-      if (this.has(key1) && conflictResolver) {
-        this.set(key1, conflictResolver(this.get(key1), value, key1));
-      } else {
-        this.set(key1, value);
-      }
-    }
-    return this;
-  }
-  some(fn) {
-    for (const [key1, value] of this.map1) {
-      if (fn(value, key1)) return true;
-    }
-    return false;
-  }
-  every(fn) {
-    for (const [key1, value] of this.map1) {
-      if (!fn(value, key1)) return false;
-    }
-    return true;
-  }
-  filter(predicate) {
-    const result = new this.constructor();
-    for (const [key1, value] of this.map1) {
-      if (predicate(value, key1, this)) result.set(key1, value);
-    }
-    return result;
-  }
-  reduce(fn, init) {
-    let iterator = this.entries();
-    let first = iterator.next();
-    if (first.done) {
-      if (arguments.length < 2) {
-        throw new TypeError("Reduce of empty Map1 with no initial value!");
-      }
-      return init;
-    }
-    let acc;
-    let start;
-    if (arguments.length < 2) {
-      acc = first.value[1];
-      start = iterator.next();
-    } else {
-      acc = init;
-      start = first;
-    }
-    for (let current = start; !current.done; current = iterator.next()) {
-      const [key1, value] = current.value;
-      acc = fn(acc, value, key1);
-    }
-    return acc;
-  }
-  mapEntries(fn) {
-    let result = [];
-    for (const [key1, value] of this.map1) {
-      result.push(fn(value, key1));
-    }
-    return result;
-  }
-  mapValues(fn) {
-    let result = new _Map1();
-    for (const [key1, value] of this.map1) {
-      result.set(key1, fn(value, key1));
-    }
-    return result;
-  }
-  toMap() {
-    return new Map(this.map1);
-  }
-  toString() {
-    const entries = [...this.map1].map(([k, v]) => `${stringify(k)} => ${stringify(v)}`).join(", ");
-    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries} }`;
-  }
-};
 
-// src/deprecated/map2.ts
-var Map2 = class _Map2 extends BaseContainer {
-  constructor(entries) {
-    super();
-    __publicField(this, "map1", /* @__PURE__ */ new Map());
-    if (entries instanceof _Map2) {
-      for (const [key1, inner] of entries.map1) {
-        this.map1.set(key1, new Map(inner));
-      }
-    } else if (entries) {
-      for (const [key1, key2, value] of entries) {
-        this.set(key1, key2, value);
-      }
-    }
-  }
-  has(key1, key2) {
-    return this.map1.get(key1)?.has(key2) ?? false;
-  }
-  set(key1, key2, value) {
-    let map2 = this.map1.get(key1) ?? this.map1.set(key1, /* @__PURE__ */ new Map()).get(key1);
-    map2.set(key2, value);
-    return value;
-  }
-  get(key1, key2) {
-    return this.map1.get(key1)?.get(key2);
-  }
-  getOrDefault(key1, key2, defaultValue) {
-    return this.get(key1, key2) ?? defaultValue;
-  }
-  getOrCreate(key1, key2, creatorOrValue) {
-    if (!this.has(key1, key2)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
-      this.set(key1, key2, value);
-      return value;
-    }
-    return this.get(key1, key2);
-  }
-  delete(key1, key2) {
-    if (key2 === void 0) return this.map1.delete(key1);
-    const map2 = this.map1.get(key1);
-    if (!map2) return false;
-    return map2.delete(key2);
-  }
-  clear() {
-    this.map1.clear();
-  }
-  get size() {
-    let count = 0;
-    for (const map2 of this.map1.values()) {
-      count += map2.size;
-    }
-    return count;
-  }
-  isEmpty() {
-    return this.size === 0;
-  }
-  forEach(callbackfn, thisArg) {
-    this.map1.forEach((map2, key1) => map2.forEach((value, key2) => callbackfn.call(thisArg, value, key1, key2, this)));
-  }
-  *keys() {
-    for (const [key1, map2] of this.map1)
-      for (const key2 of map2.keys())
-        yield [key1, key2];
-  }
-  *values() {
-    for (const map2 of this.map1.values())
-      for (const value of map2.values())
-        yield value;
-  }
-  *entries() {
-    for (const [key1, map2] of this.map1)
-      for (const [key2, value] of map2)
-        yield [key1, key2, value];
-  }
-  keysArray() {
-    return [...this.keys()];
-  }
-  valuesArray() {
-    return [...this.values()];
-  }
-  entriesArray() {
-    return [...this.entries()];
-  }
-  *kvKeys() {
-    for (const [key1, key2] of this.keys())
-      yield [key1, key2];
-  }
-  *kvValues() {
-    for (const el of this.values())
-      yield el;
-  }
-  *kvEntries() {
-    for (const [key1, key2, el] of this.entries())
-      yield [[key1, key2], el];
-  }
-  *[Symbol.iterator]() {
-    yield* this.entries();
-  }
-  clone() {
-    return new _Map2(this);
-  }
-  merge(other, conflictResolver) {
-    for (const [key1, key2, value] of other.entries()) {
-      if (this.has(key1, key2) && conflictResolver) {
-        this.set(key1, key2, conflictResolver(this.get(key1, key2), value, key1, key2));
-      } else {
-        this.set(key1, key2, value);
-      }
-    }
-    return this;
-  }
-  some(fn) {
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, value] of map2) {
-        if (fn(value, key1, key2)) return true;
-      }
-    }
-    return false;
-  }
-  every(fn) {
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, value] of map2) {
-        if (!fn(value, key1, key2)) return false;
-      }
-    }
-    return true;
-  }
-  filter(predicate) {
-    const result = new this.constructor();
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, value] of map2) {
-        if (predicate(value, key1, key2, this)) result.set(key1, key2, value);
-      }
-    }
-    return result;
-  }
-  reduce(fn, init) {
-    let iterator = this.entries();
-    let first = iterator.next();
-    if (first.done) {
-      if (arguments.length < 2) {
-        throw new TypeError("Reduce of empty Map2 with no initial value!");
-      }
-      return init;
-    }
-    let acc;
-    let start;
-    if (arguments.length < 2) {
-      acc = first.value[2];
-      start = iterator.next();
-    } else {
-      acc = init;
-      start = first;
-    }
-    for (let current = start; !current.done; current = iterator.next()) {
-      const [key1, key2, value] = current.value;
-      acc = fn(acc, value, key1, key2);
-    }
-    return acc;
-  }
-  mapEntries(fn) {
-    let result = [];
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, value] of map2) {
-        result.push(fn(value, key1, key2));
-      }
-    }
-    return result;
-  }
-  mapValues(fn) {
-    let result = new _Map2();
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, value] of map2) {
-        result.set(key1, key2, fn(value, key1, key2));
-      }
-    }
-    return result;
-  }
-  toMap() {
-    let result = /* @__PURE__ */ new Map();
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, value] of map2) {
-        result.set([key1, key2], value);
-      }
-    }
-    return result;
-  }
-  toString() {
-    const entries = [];
-    for (const [key1, map2] of this.map1) {
-      const inner = [...map2].map(([key2, v]) => `${stringify(key2)} => ${stringify(v)}`).join(", ");
-      entries.push(`${stringify(key1)} => { ${inner} }`);
-    }
-    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries} }`;
-  }
-};
-
-// src/deprecated/map3.ts
-var Map3 = class _Map3 extends BaseContainer {
-  constructor(entries) {
-    super();
-    __publicField(this, "map1", /* @__PURE__ */ new Map());
-    if (entries instanceof _Map3) {
-      for (const [key1, map2] of entries.map1) {
-        const newMap2 = /* @__PURE__ */ new Map();
-        for (const [key2, map3] of map2) {
-          newMap2.set(key2, new Map(map3));
-        }
-        this.map1.set(key1, newMap2);
-      }
-    } else if (entries) {
-      for (const [key1, key2, key3, value] of entries) {
-        this.set(key1, key2, key3, value);
-      }
-    }
-  }
-  has(key1, key2, key3) {
-    return this.map1.get(key1)?.get(key2)?.has(key3) ?? false;
-  }
-  set(key1, key2, key3, value) {
-    let map2 = this.map1.get(key1);
-    if (!map2) this.map1.set(key1, map2 = /* @__PURE__ */ new Map());
-    let map3 = map2.get(key2);
-    if (!map3) map2.set(key2, map3 = /* @__PURE__ */ new Map());
-    map3.set(key3, value);
-    return value;
-  }
-  get(key1, key2, key3) {
-    return this.map1.get(key1)?.get(key2)?.get(key3);
-  }
-  getOrDefault(key1, key2, key3, defaultValue) {
-    return this.get(key1, key2, key3) ?? defaultValue;
-  }
-  getOrCreate(key1, key2, key3, creatorOrValue) {
-    if (!this.has(key1, key2, key3)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
-      this.set(key1, key2, key3, value);
-      return value;
-    }
-    return this.get(key1, key2, key3);
-  }
-  delete(key1, key2, key3) {
-    if (key3 === void 0) {
-      if (key2 === void 0) return this.map1.delete(key1);
-      const map2 = this.map1.get(key1);
-      if (!map2) return false;
-      return map2.delete(key2);
-    } else {
-      if (key2 === void 0) return this.map1.delete(key1);
-      const map3 = this.map1.get(key1)?.get(key2);
-      if (!map3) return false;
-      return map3.delete(key3);
-    }
-  }
-  clear() {
-    this.map1.clear();
-  }
-  get size() {
-    let count = 0;
-    for (const map2 of this.map1.values()) {
-      for (const map3 of map2.values()) {
-        count += map3.size;
-      }
-    }
-    return count;
-  }
-  isEmpty() {
-    return this.size === 0;
-  }
-  forEach(callbackfn, thisArg) {
-    this.map1.forEach((map2, key1) => map2.forEach((map3, key2) => map3.forEach((value, key3) => callbackfn.call(thisArg, value, key1, key2, key3, this))));
-  }
-  *keys() {
-    for (const [key1, map2] of this.map1)
-      for (const [key2, map3] of map2)
-        for (const key3 of map3.keys())
-          yield [key1, key2, key3];
-  }
-  *values() {
-    for (const map2 of this.map1.values())
-      for (const map3 of map2.values())
-        for (const value of map3.values())
-          yield value;
-  }
-  *entries() {
-    for (const [key1, map2] of this.map1)
-      for (const [key2, map3] of map2)
-        for (const [key3, value] of map3)
-          yield [key1, key2, key3, value];
-  }
-  keysArray() {
-    return [...this.keys()];
-  }
-  valuesArray() {
-    return [...this.values()];
-  }
-  entriesArray() {
-    return [...this.entries()];
-  }
-  *kvKeys() {
-    for (const [key1, key2, key3] of this.keys())
-      yield [key1, key2, key3];
-  }
-  *kvValues() {
-    for (const el of this.values())
-      yield el;
-  }
-  *kvEntries() {
-    for (const [key1, key2, key3, el] of this.entries())
-      yield [[key1, key2, key3], el];
-  }
-  *[Symbol.iterator]() {
-    yield* this.entries();
-  }
-  clone() {
-    return new _Map3(this);
-  }
-  merge(other, conflictResolver) {
-    for (const [key1, key2, key3, value] of other.entries()) {
-      if (this.has(key1, key2, key3) && conflictResolver) {
-        this.set(key1, key2, key3, conflictResolver(this.get(key1, key2, key3), value, key1, key2, key3));
-      } else {
-        this.set(key1, key2, key3, value);
-      }
-    }
-    return this;
-  }
-  some(fn) {
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, map3] of map2) {
-        for (const [key3, value] of map3) {
-          if (fn(value, key1, key2, key3)) return true;
-        }
-      }
-    }
-    return false;
-  }
-  every(fn) {
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, map3] of map2) {
-        for (const [key3, value] of map3) {
-          if (!fn(value, key1, key2, key3)) return false;
-        }
-      }
-    }
-    return true;
-  }
-  filter(predicate) {
-    const result = new this.constructor();
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, map3] of map2) {
-        for (const [key3, value] of map3) {
-          if (predicate(value, key1, key2, key3, this)) result.set(key1, key2, key3, value);
-        }
-      }
-    }
-    return result;
-  }
-  reduce(fn, init) {
-    let iterator = this.entries();
-    let first = iterator.next();
-    if (first.done) {
-      if (arguments.length < 2) {
-        throw new TypeError("Reduce of empty Map3 with no initial value!");
-      }
-      return init;
-    }
-    let acc;
-    let start;
-    if (arguments.length < 2) {
-      acc = first.value[3];
-      start = iterator.next();
-    } else {
-      acc = init;
-      start = first;
-    }
-    for (let current = start; !current.done; current = iterator.next()) {
-      const [key1, key2, key3, value] = current.value;
-      acc = fn(acc, value, key1, key2, key3);
-    }
-    return acc;
-  }
-  mapEntries(fn) {
-    let result = [];
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, map3] of map2) {
-        for (const [key3, value] of map3) {
-          result.push(fn(value, key1, key2, key3));
-        }
-      }
-    }
-    return result;
-  }
-  mapValues(fn) {
-    let result = new _Map3();
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, map3] of map2) {
-        for (const [key3, value] of map3) {
-          result.set(key1, key2, key3, fn(value, key1, key2, key3));
-        }
-      }
-    }
-    return result;
-  }
-  toMap() {
-    let result = /* @__PURE__ */ new Map();
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, map3] of map2) {
-        for (const [key3, value] of map3) {
-          result.set([key1, key2, key3], value);
-        }
-      }
-    }
-    return result;
-  }
-  toString() {
-    const entries = [];
-    for (const [key1, map2] of this.map1) {
-      for (const [key2, map3] of map2) {
-        const inner = [...map3].map(([key3, v]) => `${stringify(key3)} => ${stringify(v)}`).join(", ");
-        entries.push(`${stringify(key1)} => ${stringify(key2)} => { ${inner} }`);
-      }
-    }
-    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries.join(", ")} }`;
-  }
-};
-
-// src/deprecated/set.ts
-var SetBase = class extends BaseContainer {
-  constructor(entries) {
-    super();
-    __publicField(this, "data");
-    this.data = new Set(entries ?? []);
-  }
-  has(value) {
-    return this.some((v) => this.valueEquals(v, value));
-  }
-  add(value) {
-    if (!this.has(value))
-      this.data.add(value);
-    return value;
-  }
-  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
-  set(key, value) {
-    if (!this.valueEquals(key, value))
-      throw new TypeError("SetBase.set() requires key === value.");
-    this.add(value);
-  }
-  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
-  get(key) {
-    return this.has(key) ? key : void 0;
-  }
-  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
-  getOrDefault(key, defaultValue) {
-    return this.get(key) ?? defaultValue;
-  }
-  getOrCreate(key, creatorOrValue) {
-    if (!this.has(key)) {
-      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
-      this.set(key, value);
-      return value;
-    }
-    return this.get(key);
-  }
-  delete(value) {
-    if (!this.has(value)) return false;
-    for (const v of this.values()) {
-      if (this.valueEquals(v, value)) {
-        this.data.delete(v);
-        return true;
-      }
-    }
-    return false;
-  }
-  clear() {
-    this.data.clear();
-  }
-  get size() {
-    return this.data.size;
-  }
-  isEmpty() {
-    return this.size === 0;
-  }
-  forEach(callbackfn, thisArg) {
-    this.data.forEach((value) => callbackfn.call(thisArg, value, this));
-  }
-  *keys() {
-    yield* this.data.keys();
-  }
-  *values() {
-    yield* this.data.values();
-  }
-  *entries() {
-    yield* this.data.entries();
-  }
-  *kvKeys() {
-    for (const key of this.keys()) {
-      yield [key];
-    }
-  }
-  *kvValues() {
-    for (const el of this.values()) {
-      yield el;
-    }
-  }
-  *kvEntries() {
-    for (const [key, el] of this.entries()) {
-      yield [[key], el];
-    }
-  }
-  *[Symbol.iterator]() {
-    yield* this.values();
-  }
-  clone() {
-    const result = this.createEmpty();
-    for (const v of this.values()) result.add(v);
-    return result;
-  }
-  merge(other) {
-    for (const value of other.values()) {
-      this.add(value);
-    }
-    return this;
-  }
-  some(fn) {
-    for (const value of this.data) {
-      if (fn(value)) return true;
-    }
-    return false;
-  }
-  every(fn) {
-    for (const value of this.data) {
-      if (!fn(value)) return false;
-    }
-    return true;
-  }
-  filter(predicate) {
-    const result = this.createEmpty();
-    for (const value of this.data)
-      if (predicate(value, this)) result.add(value);
-    return result;
-  }
-  reduce(fn, init) {
-    let iterator = this.values();
-    let first = iterator.next();
-    if (first.done) {
-      if (arguments.length < 2) {
-        throw new TypeError("Reduce of empty SetBase with no initial value!");
-      }
-      return init;
-    }
-    let acc;
-    let start;
-    if (arguments.length < 2) {
-      acc = first.value;
-      start = iterator.next();
-    } else {
-      acc = init;
-      start = first;
-    }
-    for (let current = start; !current.done; current = iterator.next()) {
-      const value = current.value;
-      acc = fn(acc, value);
-    }
-    return acc;
-  }
-  mapValues(fn) {
-    let result = this.createEmpty();
-    for (const value of this.data) {
-      result.add(fn(value));
-    }
-    return result;
-  }
-  mapToArray(fn) {
-    let result = [];
-    for (const value of this.values()) {
-      result.push(fn(value));
-    }
-    return result;
-  }
-  map(fn) {
-    let result = this.createEmpty();
-    for (const value of this.values()) {
-      result.add(fn(value));
-    }
-    return result;
-  }
-  toSet() {
-    return new Set(this.data);
-  }
-  toArray() {
-    return [...this.values()];
-  }
-  toString() {
-    return stringify(this.data);
-  }
-};
-var Set1 = class _Set1 extends SetBase {
-  constructor(entries) {
-    super(entries);
-  }
-  createEmpty() {
-    return new _Set1();
-  }
-  valueEquals(a, b) {
-    return a === b;
-  }
-};
-var DeepSet = class _DeepSet extends SetBase {
-  constructor(entries) {
-    super(entries);
-  }
-  createEmpty() {
-    return new _DeepSet();
-  }
-  valueEquals(a, b) {
-    return isDeepEqual2(a, b);
-  }
-};
-
-// src/deprecated/div-rect.ts
-var DivRect = class _DivRect {
-  constructor(...args) {
-    __publicField(this, "left");
-    __publicField(this, "anchorX");
-    __publicField(this, "right");
-    __publicField(this, "top");
-    __publicField(this, "anchorY");
-    __publicField(this, "bottom");
-    if (args.length === 6) {
-      this.left = args[0];
-      this.anchorX = args[1];
-      this.right = args[2];
-      this.top = args[3];
-      this.anchorY = args[4];
-      this.bottom = args[5];
-    } else if (args.length === 4) {
-      this.left = args[0];
-      this.right = args[1];
-      this.anchorX = (this.left + this.right) / 2;
-      this.top = args[2];
-      this.bottom = args[3];
-      this.anchorY = (this.top + this.bottom) / 2;
-    } else if (args.length === 0) {
-      this.left = this.anchorX = this.right = 0;
-      this.top = this.anchorY = this.bottom = 0;
-    } else {
-      throw new TypeError(`Invalid DivRect args: ${args}`);
-    }
-  }
-  set(...args) {
-    if (args.length === 6) {
-      this.left = args[0];
-      this.anchorX = args[1];
-      this.right = args[2];
-      this.top = args[3];
-      this.anchorY = args[4];
-      this.bottom = args[5];
-    } else if (args.length === 4) {
-      this.left = args[0];
-      this.right = args[1];
-      this.anchorX = (this.left + this.right) / 2;
-      this.top = args[2];
-      this.bottom = args[3];
-      this.anchorY = (this.top + this.bottom) / 2;
-    } else if (args.length === 0) {
-      this.left = this.anchorX = this.right = 0;
-      this.top = this.anchorY = this.bottom = 0;
-    } else {
-      throw new TypeError(`Invalid DivRect args: ${args}`);
-    }
-    return this;
-  }
-  /**
-   * Create rect from basic left, top, width and height arguments.
-   * 
-   * @param left - Left coordinate.
-   * @param top - Top coordinate.
-   * @param width - Width.
-   * @param height - Height.
-   * @returns - DivRect.
-   */
-  static create(left, top, width, height) {
-    return new _DivRect(left, left + width, top, top + height);
-  }
-  /**
-   * Create rect from anchorX, anchorY, width, height arguments.
-   * 
-   * @param centerX - Center x-coordinate.
-   * @param centerY - Center y-coordinate.
-   * @param width - Width.
-   * @param height - Height.
-   * @returns - DivRect.
-   */
-  static createCentered(centerX, centerY, width, height) {
-    return new _DivRect(
-      centerX - width / 2,
-      centerX,
-      centerX + width / 2,
-      centerY - height / 2,
-      centerY,
-      centerY + height / 2
-    );
-  }
-  /**
-   * Create rect from sections.
-   * 
-   * @param leftw - Left section width.
-   * @param rightw - Right section width.
-   * @param toph - Top section height.
-   * @param bottomh - Bottomsection height.
-   * @returns - DivRect.
-   */
-  static createSections(leftw, rightw, toph, bottomh) {
-    return new _DivRect(-leftw, 0, rightw, -toph, 0, bottomh);
-  }
-  /**
-   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
-   * @private
-   * */
-  get centerX() {
-    return this.anchorX;
-  }
-  /**
-   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
-   * @private
-   * */
-  set centerX(x) {
-    this.anchorX = x;
-  }
-  /**
-   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
-   * @private
-   * */
-  get centerY() {
-    return this.anchorY;
-  }
-  /**
-   * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
-   * @private
-   * */
-  set centerY(y) {
-    this.anchorY = y;
-  }
-  /**
-   * Width getter.
-   */
-  get width() {
-    return this.right - this.left;
-  }
-  /**
-   * Height getter.
-   */
-  get height() {
-    return this.bottom - this.top;
-  }
-  /**
-   * Left section width getter.
-   */
-  get leftw() {
-    return this.anchorX - this.left;
-  }
-  /**
-   * Right section width getter.
-   */
-  get rightw() {
-    return this.right - this.anchorX;
-  }
-  /**
-   * Top section height getter.
-   */
-  get toph() {
-    return this.anchorY - this.top;
-  }
-  /**
-   * Bottom section height getter.
-   */
-  get bottomh() {
-    return this.bottom - this.anchorY;
-  }
-  /**
-   * Does this Rect contain given (x, y)-point?
-   * 
-   * @param x - X-coordinate.
-   * @param y - Y-coordinate.
-   * @returns - True/false.
-   */
-  contains(x, y) {
-    return x >= this.left && x <= this.right && y >= this.top && y <= this.bottom;
-  }
-  /**
-   * Do a and b rects overlap?
-   * 
-   * @param a - DivRect a.
-   * @param b - DivRect b.
-   * @returns - True/false.
-   */
-  static overlap(a, b) {
-    return a.right > b.left && a.left < b.right && a.bottom > b.top && a.top < b.bottom;
-  }
-  /**
-   * Do horizontal measures of a and b rects overlap?
-   * 
-   * @param a - DivRect a.
-   * @param b - DivRect b.
-   * @returns - True/false.
-   */
-  static overlapX(a, b) {
-    return a.right > b.left && a.left < b.right;
-  }
-  /**
-   * Check if given rects are equal.
-   * @param a - DivRect a.
-   * @param b - DivRect b.
-   * @returns - True/false.
-   */
-  static equals(a, b) {
-    if (a == null && b == null) {
-      return true;
-    } else if (a == null || b == null) {
-      return false;
-    } else {
-      return a === b || a.left === b.left && a.anchorX === b.anchorX && a.right === b.right && a.top === b.top && a.anchorY === b.anchorY && a.bottom === b.bottom;
-    }
-  }
-  /**
-   * Check if this rect equals with another rect.
-   * @param other - The other rect.
-   * @returns - True/false.
-   */
-  equals(other) {
-    return _DivRect.equals(this, other);
-  }
-  /**
-   * Check if edges of given rects are equal, ignoring anchorX and anchorY.
-   * 
-   * @param a - DivRect a.
-   * @param b - DivRect b.
-   * @returns - True/false.
-   */
-  static equalsEdges(a, b) {
-    if (a == null && b == null) {
-      return true;
-    } else if (a == null || b == null) {
-      return false;
-    } else {
-      return a === b || a.left === b.left && a.right === b.right && a.top === b.top && a.bottom === b.bottom;
-    }
-  }
-  /**
-   * Check if edges of this Rect equals with given Rect, ignoring anchorX and anchorY.
-   * 
-   * @param other - The other DivRect.
-   * @returns - True/false.
-   */
-  equalsEdges(other) {
-    return _DivRect.equalsEdges(this, other);
-  }
-  /**
-   * @deprecated - Use {@link equalsEdges()} instead. Will be removed in v2.0.0.
-   * @private
-   */
-  static equalsFrame(a, b) {
-    return _DivRect.equalsEdges(a, b);
-  }
-  /**
-   * @deprecated - Use {@link clone()} instead. Will be removed in v2.0.0.
-   * @private
-   */
-  copy() {
-    return new _DivRect(this.left, this.anchorX, this.right, this.top, this.anchorY, this.bottom);
-  }
-  /**
-   * Created duplicate of this Rect.
-   * @returns - Duplicate.
-   */
-  clone() {
-    return new _DivRect(this.left, this.anchorX, this.right, this.top, this.anchorY, this.bottom);
-  }
-  /**
-   * Move this rect by (dx, dy). Modifies this Rect.
-   * 
-   * @param dx - Offset amount in x-direction.
-   * @param dy - Offset amount in y-direction.
-   * @returns - This DivRect instance.
-   */
-  offsetInPlace(dx, dy) {
-    this.left += dx;
-    this.anchorX += dx;
-    this.right += dx;
-    this.top += dy;
-    this.anchorY += dy;
-    this.bottom += dy;
-    return this;
-  }
-  /**
-   * Move this rect by (dx, dy). Immutable, returns modified copy.
-   * 
-   * @param dx - Offset amount in x-direction.
-   * @param dy - Offset amount in y-direction.
-   * @returns - DivRect copy with applied offset.
-   */
-  offsetCopy(dx, dy) {
-    return this.clone().offsetInPlace(dx, dy);
-  }
-  /**
-   * Expand this Rect by given Rect. Modifies this Rect.
-   * 
-   * @param rect - DivRect to expand this instance with.
-   * @returns - This DivRect instance.
-   */
-  expandInPlace(rect) {
-    this.left = Math.min(this.left, rect.left);
-    this.right = Math.max(this.right, rect.right);
-    this.top = Math.min(this.top, rect.top);
-    this.bottom = Math.max(this.bottom, rect.bottom);
-    return this;
-  }
-  /**
-   * Expand this Rect by given Rect. Immutable, returns modified copy.
-   * 
-   * @param rect - DivRect to expand this instance with.
-   * @returns - Expanded copy of this DivRect.
-   */
-  expandCopy(rect) {
-    return this.clone().expandInPlace(rect);
-  }
-  /**
-   * Clip this Rect by given Rect. Mmodifies this Rect.
-   * 
-   * @param clipRect - DivRect to clip this instance with.
-   * @returns - This DivRect instance.
-   */
-  clipInPlace(clipRect) {
-    this.left = Math.max(this.left, clipRect.left);
-    this.right = Math.min(this.right, clipRect.right);
-    this.anchorX = clamp(this.anchorX, this.left, this.right);
-    this.top = Math.max(this.top, clipRect.top);
-    this.bottom = Math.min(this.bottom, clipRect.bottom);
-    this.anchorY = clamp(this.anchorY, this.top, this.bottom);
-    return this;
-  }
-  /**
-   * Clip this Rect by given Rect. Immutable, return modified copy.
-   * 
-   * @param clipRect - DivRecto to clip this instance with.
-   * @returns - Clipped DivRect copy.
-   */
-  clipCopy(clipRect) {
-    return this.clone().clipInPlace(clipRect);
-  }
-  /**
-   * Scale Rect. Anchor pos is (anchorX, anchorY). Modifies this Rect.
-   * 
-   * @param scaleX - Scale x-amount.
-   * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
-   * @returns This DivRect instance.
-   */
-  scaleInPlace(scaleX, scaleY = scaleX) {
-    this.left = this.anchorX - this.leftw * scaleX;
-    this.right = this.anchorX + this.rightw * scaleX;
-    this.top = this.anchorY - this.toph * scaleY;
-    this.bottom = this.anchorY + this.bottomh * scaleY;
-    return this;
-  }
-  /**
-   * Scale Rect. Anchor pos is (anchorX, anchorY). Immutable, returns modified copy.
-   * 
-   * @param scaleX - Scale x-amount.
-   * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
-   * @returns Scaled copy of this DivRect.
-   */
-  scaleCopy(scaleX, scaleY = scaleX) {
-    return this.clone().scaleInPlace(scaleX, scaleY);
-  }
-  /**
-   * Get this DivRect instance.
-   * @returns - This DivRect instance.
-   */
-  getRect() {
-    return this;
-  }
-  toRect() {
-    return new Rect(this.left, this.right, this.width, this.height);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AnchoredRect,
-  Assert,
-  BaseContainer,
-  BiMap,
-  Cookies,
-  DeepSet,
-  DefaultArray,
-  DefaultEqualityFn,
-  Device,
-  DivRect,
-  Guard,
-  IndexArray,
-  LRUCache,
-  LinkedList,
-  Map1,
-  Map2,
-  Map3,
-  MultiContainer,
-  Rect,
-  Set1,
-  SetBase,
-  SignedIndexArray,
-  SmallIntCache,
-  Stack,
-  TriMap,
-  UniMap,
-  Utils,
-  ValueSet,
-  Vec,
-  Vec2,
-  asMulti
-});
+exports.AnchoredRect = AnchoredRect;
+exports.Assert = assert_exports;
+exports.BaseContainer = BaseContainer;
+exports.BiMap = BiMap;
+exports.Cookies = cookies_exports;
+exports.DefaultArray = DefaultArray;
+exports.DefaultEqualityFn = DefaultEqualityFn;
+exports.Device = device_exports;
+exports.Guard = guard_exports;
+exports.IndexArray = IndexArray;
+exports.LRUCache = LRUCache;
+exports.LinkedList = LinkedList;
+exports.MultiContainer = MultiContainer;
+exports.Rect = Rect;
+exports.SignedIndexArray = SignedIndexArray;
+exports.Stack = Stack;
+exports.TriMap = TriMap;
+exports.UniMap = UniMap;
+exports.Utils = utils_exports;
+exports.ValueSet = ValueSet;
+exports.Vec = Vec;
+exports.asMulti = asMulti;
+exports.getLibInfo = getLibInfo;
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map