@tspro/ts-utils-lib 1.19.0 → 1.20.0

package/dist/index.d.ts

@@ -24,39 +24,90 @@ declare namespace index$8 {
 
 type ErrorConstructor = new (msg: string) => Error;
 declare function setErrorClass(errorClass?: ErrorConstructor): void;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function interrupt(msg?: string): never;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function assertEnum<E extends EnumObject>(enumVal: unknown, enumObj: E, name?: string): asserts enumVal is E[keyof E];
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function int(value: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function eq<T>(value1: T, value2: T, msg?: string): T;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function int_eq(value: unknown, compareTo: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function int_lt(value: unknown, compareTo: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function int_lte(value: unknown, compareTo: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function int_gt(value: unknown, compareTo: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function int_gte(value: unknown, compareTo: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function int_between(value: unknown, min: unknown, max: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function int_between_exclusive(value: unknown, min: unknown, max: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function odd(value: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function even(value: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function in_group<T>(value: T, group: ReadonlyArray<T>, msg?: string): T;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function finite(value: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function array_id<T>(array: Readonly<T[]>, index: unknown, msg?: string): number;
-/** @deprecated */
+/**
+ * @deprecated - Wil be removed in v2.0.0.
+ * @private
+ */
 declare function array_elem<T>(array: Readonly<T[]>, index: number, msg?: string): T;
 declare function assert<T>(condition: T, msg?: string): void;
 declare function require<T>(value: T | null | undefined, msg?: string): T;
@@ -115,6 +166,7 @@ declare function isEvenNumber$1(value: unknown, msg?: string): value is number;
 declare function isIncluded$1<T>(value: T, array: ReadonlyArray<T>, msg?: string): value is T;
 declare function isArrayIndex$1<T>(index: unknown, array: ReadonlyArray<T>, msg?: string): index is number;
 declare function isThrowing$1(throwTestFn: () => void, msg?: string): true;
+declare function isNotThrowing$1(throwTestFn: () => void, msg?: string): true;
 
 type index$7_ErrorConstructor = ErrorConstructor;
 declare const index$7_array_elem: typeof array_elem;
@@ -140,7 +192,7 @@ declare const index$7_require: typeof require;
 declare const index$7_requireDefined: typeof requireDefined;
 declare const index$7_setErrorClass: typeof setErrorClass;
 declare namespace index$7 {
-  export { type index$7_ErrorConstructor as ErrorConstructor, index$7_array_elem as array_elem, index$7_array_id as array_id, index$7_assert as assert, index$7_assertEnum as assertEnum, index$7_eq as eq, index$7_even as even, index$7_fail as fail, index$7_finite as finite, index$7_in_group as in_group, index$7_int as int, index$7_int_between as int_between, index$7_int_between_exclusive as int_between_exclusive, index$7_int_eq as int_eq, index$7_int_gt as int_gt, index$7_int_gte as int_gte, index$7_int_lt as int_lt, index$7_int_lte as int_lte, index$7_interrupt as interrupt, isArray$1 as isArray, isArrayIndex$1 as isArrayIndex, isArrayOrUndefined$1 as isArrayOrUndefined, isBoolean$1 as isBoolean, isBooleanOrUndefined$1 as isBooleanOrUndefined, isDeepEqual$1 as isDeepEqual, isEmptyArray$1 as isEmptyArray, isEmptyArrayOrUndefined$1 as isEmptyArrayOrUndefined, isEmptyString$1 as isEmptyString, isEmptyStringOrUndefined$1 as isEmptyStringOrUndefined, isEnumValue$1 as isEnumValue, isEnumValueOrUndefined$1 as isEnumValueOrUndefined, isEqual$1 as isEqual, isEvenNumber$1 as isEvenNumber, isFalse$1 as isFalse, isFalseOrUndefined$1 as isFalseOrUndefined, isFinite$1 as isFinite, isFunction$1 as isFunction, isFunctionOrUndefined$1 as isFunctionOrUndefined, isIncluded$1 as isIncluded, isInfinity$1 as isInfinity, isInteger$1 as isInteger, isIntegerBetween$1 as isIntegerBetween, isIntegerBetweenExclusive$1 as isIntegerBetweenExclusive, isIntegerEq$1 as isIntegerEq, isIntegerGt$1 as isIntegerGt, isIntegerGte$1 as isIntegerGte, isIntegerLt$1 as isIntegerLt, isIntegerLte$1 as isIntegerLte, isIntegerOrUndefined$1 as isIntegerOrUndefined, isNaNValue$1 as isNaNValue, isNegInfinity$1 as isNegInfinity, isNonEmptyArray$1 as isNonEmptyArray, isNonEmptyArrayOrUndefined$1 as isNonEmptyArrayOrUndefined, isNonEmptyString$1 as isNonEmptyString, isNonEmptyStringOrUndefined$1 as isNonEmptyStringOrUndefined, isNull$1 as isNull, isNullish$1 as isNullish, isNumber$1 as isNumber, isNumberBetween$1 as isNumberBetween, isNumberBetweenExclusive$1 as isNumberBetweenExclusive, isNumberOrUndefined$1 as isNumberOrUndefined, isObject$1 as isObject, isObjectOrUndefined$1 as isObjectOrUndefined, isOddNumber$1 as isOddNumber, isPosInfinity$1 as isPosInfinity, isString$1 as isString, isStringOrUndefined$1 as isStringOrUndefined, isThrowing$1 as isThrowing, isTrue$1 as isTrue, isTrueOrUndefined$1 as isTrueOrUndefined, isTypedObject$1 as isTypedObject, isUndefined$1 as isUndefined, index$7_odd as odd, index$7_require as require, index$7_requireDefined as requireDefined, index$7_setErrorClass as setErrorClass };
+  export { type index$7_ErrorConstructor as ErrorConstructor, index$7_array_elem as array_elem, index$7_array_id as array_id, index$7_assert as assert, index$7_assertEnum as assertEnum, index$7_eq as eq, index$7_even as even, index$7_fail as fail, index$7_finite as finite, index$7_in_group as in_group, index$7_int as int, index$7_int_between as int_between, index$7_int_between_exclusive as int_between_exclusive, index$7_int_eq as int_eq, index$7_int_gt as int_gt, index$7_int_gte as int_gte, index$7_int_lt as int_lt, index$7_int_lte as int_lte, index$7_interrupt as interrupt, isArray$1 as isArray, isArrayIndex$1 as isArrayIndex, isArrayOrUndefined$1 as isArrayOrUndefined, isBoolean$1 as isBoolean, isBooleanOrUndefined$1 as isBooleanOrUndefined, isDeepEqual$1 as isDeepEqual, isEmptyArray$1 as isEmptyArray, isEmptyArrayOrUndefined$1 as isEmptyArrayOrUndefined, isEmptyString$1 as isEmptyString, isEmptyStringOrUndefined$1 as isEmptyStringOrUndefined, isEnumValue$1 as isEnumValue, isEnumValueOrUndefined$1 as isEnumValueOrUndefined, isEqual$1 as isEqual, isEvenNumber$1 as isEvenNumber, isFalse$1 as isFalse, isFalseOrUndefined$1 as isFalseOrUndefined, isFinite$1 as isFinite, isFunction$1 as isFunction, isFunctionOrUndefined$1 as isFunctionOrUndefined, isIncluded$1 as isIncluded, isInfinity$1 as isInfinity, isInteger$1 as isInteger, isIntegerBetween$1 as isIntegerBetween, isIntegerBetweenExclusive$1 as isIntegerBetweenExclusive, isIntegerEq$1 as isIntegerEq, isIntegerGt$1 as isIntegerGt, isIntegerGte$1 as isIntegerGte, isIntegerLt$1 as isIntegerLt, isIntegerLte$1 as isIntegerLte, isIntegerOrUndefined$1 as isIntegerOrUndefined, isNaNValue$1 as isNaNValue, isNegInfinity$1 as isNegInfinity, isNonEmptyArray$1 as isNonEmptyArray, isNonEmptyArrayOrUndefined$1 as isNonEmptyArrayOrUndefined, isNonEmptyString$1 as isNonEmptyString, isNonEmptyStringOrUndefined$1 as isNonEmptyStringOrUndefined, isNotThrowing$1 as isNotThrowing, isNull$1 as isNull, isNullish$1 as isNullish, isNumber$1 as isNumber, isNumberBetween$1 as isNumberBetween, isNumberBetweenExclusive$1 as isNumberBetweenExclusive, isNumberOrUndefined$1 as isNumberOrUndefined, isObject$1 as isObject, isObjectOrUndefined$1 as isObjectOrUndefined, isOddNumber$1 as isOddNumber, isPosInfinity$1 as isPosInfinity, isString$1 as isString, isStringOrUndefined$1 as isStringOrUndefined, isThrowing$1 as isThrowing, isTrue$1 as isTrue, isTrueOrUndefined$1 as isTrueOrUndefined, isTypedObject$1 as isTypedObject, isUndefined$1 as isUndefined, index$7_odd as odd, index$7_require as require, index$7_requireDefined as requireDefined, index$7_setErrorClass as setErrorClass };
 }
 
 /**
@@ -316,6 +368,7 @@ declare function isEvenNumber(value: unknown): value is number;
 declare function isIncluded<T>(value: T, array: ReadonlyArray<T>): value is T;
 declare function isArrayIndex<T>(index: unknown, array: ReadonlyArray<T>): index is number;
 declare function isThrowing(throwTestFn: () => void): boolean;
+declare function isNotThrowing(throwTestFn: () => void): boolean;
 declare function tryOr<TRY_RVAL, OR_RVAL>(tryFn: () => TRY_RVAL, orVal: OR_RVAL | (() => OR_RVAL)): TRY_RVAL | OR_RVAL;
 
 type Guard_HasProps<T extends object> = HasProps<T>;
@@ -355,6 +408,7 @@ declare const Guard_isNonEmptyArray: typeof isNonEmptyArray;
 declare const Guard_isNonEmptyArrayOrUndefined: typeof isNonEmptyArrayOrUndefined;
 declare const Guard_isNonEmptyString: typeof isNonEmptyString;
 declare const Guard_isNonEmptyStringOrUndefined: typeof isNonEmptyStringOrUndefined;
+declare const Guard_isNotThrowing: typeof isNotThrowing;
 declare const Guard_isNull: typeof isNull;
 declare const Guard_isNullish: typeof isNullish;
 declare const Guard_isNumber: typeof isNumber;
@@ -374,13 +428,16 @@ declare const Guard_isTypedObject: typeof isTypedObject;
 declare const Guard_isUndefined: typeof isUndefined;
 declare const Guard_tryOr: typeof tryOr;
 declare namespace Guard {
-  export { type Guard_HasProps as HasProps, Guard_isArray as isArray, Guard_isArrayIndex as isArrayIndex, Guard_isArrayOrUndefined as isArrayOrUndefined, Guard_isBoolean as isBoolean, Guard_isBooleanOrUndefined as isBooleanOrUndefined, Guard_isDeepEqual as isDeepEqual, Guard_isEmptyArray as isEmptyArray, Guard_isEmptyArrayOrUndefined as isEmptyArrayOrUndefined, Guard_isEmptyString as isEmptyString, Guard_isEmptyStringOrUndefined as isEmptyStringOrUndefined, Guard_isEnumValue as isEnumValue, Guard_isEnumValueOrUndefined as isEnumValueOrUndefined, Guard_isEqual as isEqual, Guard_isEvenNumber as isEvenNumber, Guard_isFalse as isFalse, Guard_isFalseOrUndefined as isFalseOrUndefined, Guard_isFinite as isFinite, Guard_isFunction as isFunction, Guard_isFunctionOrUndefined as isFunctionOrUndefined, Guard_isIncluded as isIncluded, Guard_isInfinity as isInfinity, Guard_isInteger as isInteger, Guard_isIntegerBetween as isIntegerBetween, Guard_isIntegerBetweenExclusive as isIntegerBetweenExclusive, Guard_isIntegerEq as isIntegerEq, Guard_isIntegerGt as isIntegerGt, Guard_isIntegerGte as isIntegerGte, Guard_isIntegerLt as isIntegerLt, Guard_isIntegerLte as isIntegerLte, Guard_isIntegerOrUndefined as isIntegerOrUndefined, Guard_isNaNValue as isNaNValue, Guard_isNegInfinity as isNegInfinity, Guard_isNonEmptyArray as isNonEmptyArray, Guard_isNonEmptyArrayOrUndefined as isNonEmptyArrayOrUndefined, Guard_isNonEmptyString as isNonEmptyString, Guard_isNonEmptyStringOrUndefined as isNonEmptyStringOrUndefined, Guard_isNull as isNull, Guard_isNullish as isNullish, Guard_isNumber as isNumber, Guard_isNumberBetween as isNumberBetween, Guard_isNumberBetweenExclusive as isNumberBetweenExclusive, Guard_isNumberOrUndefined as isNumberOrUndefined, Guard_isObject as isObject, Guard_isObjectOrUndefined as isObjectOrUndefined, Guard_isOddNumber as isOddNumber, Guard_isPosInfinity as isPosInfinity, Guard_isString as isString, Guard_isStringOrUndefined as isStringOrUndefined, Guard_isThrowing as isThrowing, Guard_isTrue as isTrue, Guard_isTrueOrUndefined as isTrueOrUndefined, Guard_isTypedObject as isTypedObject, Guard_isUndefined as isUndefined, Guard_tryOr as tryOr };
+  export { type Guard_HasProps as HasProps, Guard_isArray as isArray, Guard_isArrayIndex as isArrayIndex, Guard_isArrayOrUndefined as isArrayOrUndefined, Guard_isBoolean as isBoolean, Guard_isBooleanOrUndefined as isBooleanOrUndefined, Guard_isDeepEqual as isDeepEqual, Guard_isEmptyArray as isEmptyArray, Guard_isEmptyArrayOrUndefined as isEmptyArrayOrUndefined, Guard_isEmptyString as isEmptyString, Guard_isEmptyStringOrUndefined as isEmptyStringOrUndefined, Guard_isEnumValue as isEnumValue, Guard_isEnumValueOrUndefined as isEnumValueOrUndefined, Guard_isEqual as isEqual, Guard_isEvenNumber as isEvenNumber, Guard_isFalse as isFalse, Guard_isFalseOrUndefined as isFalseOrUndefined, Guard_isFinite as isFinite, Guard_isFunction as isFunction, Guard_isFunctionOrUndefined as isFunctionOrUndefined, Guard_isIncluded as isIncluded, Guard_isInfinity as isInfinity, Guard_isInteger as isInteger, Guard_isIntegerBetween as isIntegerBetween, Guard_isIntegerBetweenExclusive as isIntegerBetweenExclusive, Guard_isIntegerEq as isIntegerEq, Guard_isIntegerGt as isIntegerGt, Guard_isIntegerGte as isIntegerGte, Guard_isIntegerLt as isIntegerLt, Guard_isIntegerLte as isIntegerLte, Guard_isIntegerOrUndefined as isIntegerOrUndefined, Guard_isNaNValue as isNaNValue, Guard_isNegInfinity as isNegInfinity, Guard_isNonEmptyArray as isNonEmptyArray, Guard_isNonEmptyArrayOrUndefined as isNonEmptyArrayOrUndefined, Guard_isNonEmptyString as isNonEmptyString, Guard_isNonEmptyStringOrUndefined as isNonEmptyStringOrUndefined, Guard_isNotThrowing as isNotThrowing, Guard_isNull as isNull, Guard_isNullish as isNullish, Guard_isNumber as isNumber, Guard_isNumberBetween as isNumberBetween, Guard_isNumberBetweenExclusive as isNumberBetweenExclusive, Guard_isNumberOrUndefined as isNumberOrUndefined, Guard_isObject as isObject, Guard_isObjectOrUndefined as isObjectOrUndefined, Guard_isOddNumber as isOddNumber, Guard_isPosInfinity as isPosInfinity, Guard_isString as isString, Guard_isStringOrUndefined as isStringOrUndefined, Guard_isThrowing as isThrowing, Guard_isTrue as isTrue, Guard_isTrueOrUndefined as isTrueOrUndefined, Guard_isTypedObject as isTypedObject, Guard_isUndefined as isUndefined, Guard_tryOr as tryOr };
 }
 
 declare function toArray<T>(a: T | T[]): Array<T>;
 declare function duplicate<T>(a: T[] | undefined): T[] | undefined;
 declare function removeDuplicates<T>(arr: T[], compareFn?: (a: T, b: T) => boolean): T[];
-/** @deprecated - Use {@link removeDuplicates} with compareFn instead. */
+/**
+ * @deprecated - Use {@link removeDuplicates} with compareFn instead.  Will be removed in v2.0.0.
+ * @private
+ */
 declare function removeDuplicatesCmp<T>(arr: ReadonlyArray<T>, compareFn: (t1: T, t2: T) => boolean): T[];
 declare function fillArray<T>(fillValue: T, fillCount: number): T[];
 declare function mapSequenceArray<T>(len: number, fn: (i: number) => T): T[];
@@ -591,6 +648,7 @@ declare function charCount(str: string, ch: string): number;
  * @param PascalString
  */
 declare function makeSentenceFromPascal(PascalString: string): string;
+declare function stringify(value: any, maxDepth?: number, seen?: WeakSet<WeakKey>): string;
 
 declare const index$1_charCount: typeof charCount;
 declare const index$1_chunkString: typeof chunkString;
@@ -600,13 +658,15 @@ declare const index$1_makeSentenceFromPascal: typeof makeSentenceFromPascal;
 declare const index$1_removeAt: typeof removeAt;
 declare const index$1_repeatString: typeof repeatString;
 declare const index$1_replaceAt: typeof replaceAt;
+declare const index$1_stringify: typeof stringify;
 declare const index$1_toCharArray: typeof toCharArray;
 declare namespace index$1 {
-  export { index$1_charCount as charCount, index$1_chunkString as chunkString, index$1_insertAt as insertAt, index$1_isString as isString, index$1_makeSentenceFromPascal as makeSentenceFromPascal, index$1_removeAt as removeAt, index$1_repeatString as repeatString, index$1_replaceAt as replaceAt, index$1_toCharArray as toCharArray };
+  export { index$1_charCount as charCount, index$1_chunkString as chunkString, index$1_insertAt as insertAt, index$1_isString as isString, index$1_makeSentenceFromPascal as makeSentenceFromPascal, index$1_removeAt as removeAt, index$1_repeatString as repeatString, index$1_replaceAt as replaceAt, index$1_stringify as stringify, index$1_toCharArray as toCharArray };
 }
 
 /**
- * @deprecated Use {@link Guard} instead.
+ * @deprecated Use {@link Guard} instead. Will be removed in v2.0.0.
+ * @private
  */
 declare const Is: typeof Guard;
 
@@ -615,11 +675,33 @@ declare namespace index {
   export { index$6 as Arr, index$5 as Dom, index$8 as Enum, index_Is as Is, index$4 as Map, index$3 as Math, index$2 as Obj, index$1 as Str };
 }
 
+type EqualityFn<V> = (a: V, b: V) => boolean;
+declare const DefaultEqualityFn: EqualityFn<any>;
+interface KVComponent<K extends any[], VALUE> {
+    get size(): number;
+    isEmpty(): boolean;
+    has(...keys: K): boolean;
+    get(...keys: K): VALUE | undefined;
+    getOrDefault(...keysAndDefault: [...K, VALUE]): VALUE;
+    getOrCreate(...keysAndCreator: [...K, VALUE]): VALUE;
+    set(...keysAndValue: [...K, VALUE]): void;
+    delete(...keys: K): boolean;
+    clear?(): void;
+    toString(): string;
+    kvValues(): IterableIterator<VALUE>;
+    kvKeys(): IterableIterator<K>;
+    kvEntries(): IterableIterator<[K, VALUE]>;
+}
+declare abstract class BaseContainer {
+    abstract toString(): string;
+}
+
 /**
  * This is a stack data structure.
  */
-declare class Stack<T> {
+declare class Stack<T> extends BaseContainer {
     private readonly data;
+    constructor();
     private assertId;
     get length(): number;
     push(el: T): T;
@@ -655,7 +737,7 @@ declare class Stack<T> {
  * console.log(a.clone().equals(a));     // true
  * ```
  */
-declare class Vec {
+declare class Vec extends BaseContainer {
     readonly coords: number[];
     constructor(...coords: number[]);
     static vec2(x: number, y: number): Vec;
@@ -755,13 +837,25 @@ declare class DivRect {
      * @returns - DivRect.
      */
     static createSections(leftw: number, rightw: number, toph: number, bottomh: number): DivRect;
-    /** @deprecated - Renamed to anchorX. */
+    /**
+     * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+     * @private
+     * */
     get centerX(): number;
-    /** @deprecated - Renamed to anchorX. */
+    /**
+     * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+     * @private
+     * */
     set centerX(x: number);
-    /** @deprecated - Renamed to anchorY. */
+    /**
+     * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+     * @private
+     * */
     get centerY(): number;
-    /** @deprecated - Renamed to anchorY. */
+    /**
+     * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
+     * @private
+     * */
     set centerY(y: number);
     /**
      * Width getter.
@@ -839,7 +933,10 @@ declare class DivRect {
      * @returns - True/false.
      */
     equalsEdges(other: DivRect): boolean;
-    /** @deprecated - Use `DivRect.equalsEdges()` instead. */
+    /**
+     * @deprecated - Use `DivRect.equalsEdges()` instead. Will be removed in v2.0.0.
+     * @private
+     */
     static equalsFrame(a: DivRect | null | undefined, b: DivRect | null | undefined): boolean;
     /**
      * Created duplicate of this Rect.
@@ -917,7 +1014,7 @@ declare class DivRect {
 /**
  * LRUCache is an implementation of least recently used cache with a fixed capacity.
  */
-declare class LRUCache<K extends string, V> {
+declare class LRUCache<K extends string, V> extends BaseContainer {
     private cache;
     private next;
     private prev;
@@ -933,29 +1030,18 @@ declare class LRUCache<K extends string, V> {
     private evict;
     private removeKey;
     private addToTail;
-}
-
-interface KVComponent<K extends any[], VALUE> {
-    get size(): number;
-    isEmpty(): boolean;
-    has(...keys: K): boolean;
-    get(...keys: K): VALUE | undefined;
-    getOrDefault(...keysAndDefault: [...K, VALUE]): VALUE;
-    getOrCreate(...keysAndCreator: [...K, VALUE]): VALUE;
-    set(...keysAndValue: [...K, VALUE]): void;
-    delete(...keys: K): boolean;
-    clear?(): void;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
     toString(): string;
-    kvValues(): IterableIterator<VALUE>;
-    kvKeys(): IterableIterator<K>;
-    kvEntries(): IterableIterator<[K, VALUE]>;
 }
 
 /**
  * `IndexArray` is a sparse array with non-negative indexes. It stores values
  * to indexes, and each index also has flag telling it has a value.
  */
-declare class IndexArray<VALUE> implements KVComponent<[number], VALUE> {
+declare class IndexArray<VALUE> extends BaseContainer implements KVComponent<[number], VALUE> {
     private static validateIndex;
     private posVal;
     private hasPos;
@@ -1007,7 +1093,7 @@ declare class IndexArray<VALUE> implements KVComponent<[number], VALUE> {
  * `IndexArray` is a sparse array with positive and negative indexes. It stores
  * values to indexes, and each index also has flag telling it has a value.
  */
-declare class SignedIndexArray<VALUE> implements KVComponent<[number], VALUE> {
+declare class SignedIndexArray<VALUE> extends BaseContainer implements KVComponent<[number], VALUE> {
     private static toNegIndex;
     private static validateIndex;
     private posVal;
@@ -1057,56 +1143,116 @@ declare class SignedIndexArray<VALUE> implements KVComponent<[number], VALUE> {
     toString(): string;
 }
 
+/**
+ * `DefaultArray` is an array list where every index is guaranteed to have a value.
+ * There are no undefineds unless that is part of the value type.
+ * When you create `DefaultArray` you give a default value. For example if you
+ * delete an index then that index is set to the default value.
+ */
+declare class DefaultArray<VALUE> extends BaseContainer implements KVComponent<[number], VALUE> {
+    private readonly defaultValue;
+    private data;
+    constructor(defaultValue: VALUE);
+    constructor(length: number, defaultValue: VALUE);
+    constructor(values: Iterable<VALUE>, defaultValue: VALUE);
+    get size(): number;
+    get length(): number;
+    private assertId;
+    isEmpty(): boolean;
+    isDefault(id: number): boolean;
+    isSet(id: number): boolean;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    has(id: number): boolean;
+    set(id: number, value: VALUE): VALUE;
+    get(id: number): VALUE;
+    getOrDefault(id: number, defaultValue: VALUE): VALUE;
+    getOrCreate(id: number, value: VALUE): VALUE;
+    getOrCreate(id: number, creator: () => VALUE): VALUE;
+    delete(id: number): boolean;
+    clear(empty?: boolean): void;
+    forEach(callbackfn: (value: VALUE, id: number, arr: DefaultArray<VALUE>) => void, thisArg?: any): void;
+    indices(): IterableIterator<number>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[number, VALUE]>;
+    indicesArray(): number[];
+    valuesArray(): VALUE[];
+    entriesArray(): [number, VALUE][];
+    kvKeys(): IterableIterator<[number]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[number], VALUE]>;
+    [Symbol.iterator](): IterableIterator<[number, VALUE]>;
+    clone(): DefaultArray<VALUE>;
+    merge(other: DefaultArray<VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, id: number) => VALUE): this;
+    some(fn: (value: VALUE, id: number) => boolean): boolean;
+    every(fn: (value: VALUE, key1: number) => boolean): boolean;
+    filter<S extends VALUE>(predicate: (value: VALUE, id: number, array: DefaultArray<VALUE>) => value is S): DefaultArray<S>;
+    filter(predicate: (value: VALUE, id: number, array: DefaultArray<VALUE>) => unknown): DefaultArray<VALUE>;
+    reduce(fn: (acc: VALUE, value: VALUE, id: number) => VALUE): VALUE;
+    reduce<R>(fn: (acc: R, value: VALUE, id: number) => R, init: R): R;
+    mapToArray<R>(fn: (value: VALUE, key1: number) => R): R[];
+    map<R = VALUE>(fn: (value: VALUE, key1: number) => R, defaultValue: R): DefaultArray<R>;
+    equals(other: DefaultArray<VALUE>): boolean;
+    equals(other: DefaultArray<VALUE>, eq: (a: VALUE, b: VALUE) => boolean): boolean;
+    toArray(): VALUE[];
+    toString(): string;
+}
+
 /**
  * A Map implementation mapping a single key to a value.
  */
-declare class Map1<KEY1, VALUE> implements KVComponent<[KEY1], VALUE> {
-    private map1;
+declare class UniMap<KEY, VALUE> extends BaseContainer implements KVComponent<[KEY], VALUE> {
+    private map;
+    private keyEquals;
     constructor();
-    constructor(map1: Map1<KEY1, VALUE>);
-    constructor(entries: Iterable<[KEY1, VALUE]>);
-    has(key1: KEY1): boolean;
-    set(key1: KEY1, value: VALUE): VALUE;
-    get(key1: KEY1): VALUE | undefined;
-    getOrDefault(key1: KEY1, defaultValue: VALUE): VALUE;
-    getOrCreate(key1: KEY1, value: VALUE): VALUE;
-    getOrCreate(key1: KEY1, creator: () => VALUE): VALUE;
-    delete(key1: KEY1): boolean;
+    constructor(equals?: EqualityFn<KEY>);
+    constructor(list: UniMap<KEY, VALUE> | Iterable<[KEY, VALUE]>, equals?: EqualityFn<KEY>);
+    static createDeep<KEY1, VALUE>(): UniMap<KEY1, VALUE>;
+    static createDeep<KEY1, VALUE>(set: UniMap<KEY1, VALUE>): UniMap<KEY1, VALUE>;
+    static createDeep<KEY1, VALUE>(entries: Iterable<[KEY1, VALUE]>): UniMap<KEY1, VALUE>;
+    has(key: KEY): boolean;
+    set(key: KEY, value: VALUE): VALUE;
+    get(key: KEY): VALUE | undefined;
+    delete(key: KEY): boolean;
+    getOrDefault(key: KEY, defaultValue: VALUE): VALUE;
+    getOrCreate(key: KEY, value: VALUE): VALUE;
+    getOrCreate(key: KEY, creator: () => VALUE): VALUE;
     clear(): void;
     get size(): number;
     isEmpty(): boolean;
-    forEach(callbackfn: (value: VALUE, key1: KEY1, map1: Map1<KEY1, VALUE>) => void, thisArg?: any): void;
-    keys(): IterableIterator<KEY1>;
+    forEach(callbackfn: (value: VALUE, key: KEY, map1: UniMap<KEY, VALUE>) => void, thisArg?: any): void;
+    keys(): IterableIterator<KEY>;
     values(): IterableIterator<VALUE>;
-    entries(): IterableIterator<[KEY1, VALUE]>;
-    keysArray(): KEY1[];
+    entries(): IterableIterator<[KEY, VALUE]>;
+    keysArray(): KEY[];
     valuesArray(): VALUE[];
-    entriesArray(): [KEY1, VALUE][];
-    kvKeys(): IterableIterator<[KEY1]>;
+    entriesArray(): [KEY, VALUE][];
+    kvKeys(): IterableIterator<[KEY]>;
     kvValues(): IterableIterator<VALUE>;
-    kvEntries(): IterableIterator<[[KEY1], VALUE]>;
-    [Symbol.iterator](): IterableIterator<[KEY1, VALUE]>;
-    clone(): Map1<KEY1, VALUE>;
-    merge(other: Map1<KEY1, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1) => VALUE): this;
-    some(fn: (value: VALUE, key1: KEY1) => boolean): boolean;
-    every(fn: (value: VALUE, key1: KEY1) => boolean): boolean;
-    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, array: Map1<KEY1, VALUE>) => value is S): Map1<KEY1, S>;
-    filter(predicate: (value: VALUE, key1: KEY1, array: Map1<KEY1, VALUE>) => unknown): Map1<KEY1, VALUE>;
-    reduce(fn: (acc: VALUE, value: VALUE, key1: KEY1) => VALUE): VALUE;
-    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1) => R, init: R): R;
-    mapEntries<R>(fn: (value: VALUE, key1: KEY1) => R): R[];
-    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1) => R): Map1<KEY1, R>;
-    toMap(): Map<KEY1, VALUE>;
+    kvEntries(): IterableIterator<[[KEY], VALUE]>;
+    [Symbol.iterator](): IterableIterator<[KEY, VALUE]>;
+    clone(): UniMap<KEY, VALUE>;
+    merge(other: UniMap<KEY, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key: KEY) => VALUE): this;
+    some(fn: (value: VALUE, key: KEY) => boolean): boolean;
+    every(fn: (value: VALUE, key: KEY) => boolean): boolean;
+    filter<S extends VALUE>(predicate: (value: VALUE, key: KEY, array: UniMap<KEY, VALUE>) => value is S): UniMap<KEY, S>;
+    filter(predicate: (value: VALUE, key: KEY, array: UniMap<KEY, VALUE>) => unknown): UniMap<KEY, VALUE>;
+    reduce(fn: (acc: VALUE, value: VALUE, key: KEY) => VALUE): VALUE;
+    reduce<R>(fn: (acc: R, value: VALUE, key: KEY) => R, init: R): R;
+    mapEntries<R>(fn: (value: VALUE, key: KEY) => R): R[];
+    mapValues<R = VALUE>(fn: (value: VALUE, key: KEY) => R): UniMap<KEY, R>;
+    toMap(): Map<KEY, VALUE>;
     toString(): string;
 }
 
 /**
  * A Map implementation mapping a double key to a value.
  */
-declare class Map2<KEY1, KEY2, VALUE> implements KVComponent<[KEY1, KEY2], VALUE> {
+declare class BiMap<KEY1, KEY2, VALUE> extends BaseContainer implements KVComponent<[KEY1, KEY2], VALUE> {
     private map1;
+    private key1Equals;
+    private key2Equals;
     constructor();
-    constructor(map2: Map2<KEY1, KEY2, VALUE>);
+    constructor(biMap: BiMap<KEY1, KEY2, VALUE>);
     constructor(entries: Iterable<[KEY1, KEY2, VALUE]>);
     has(key1: KEY1, key2: KEY2): boolean;
     set(key1: KEY1, key2: KEY2, value: VALUE): VALUE;
@@ -1119,7 +1265,7 @@ declare class Map2<KEY1, KEY2, VALUE> implements KVComponent<[KEY1, KEY2], VALUE
     clear(): void;
     get size(): number;
     isEmpty(): boolean;
-    forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, map2: Map2<KEY1, KEY2, VALUE>) => void, thisArg?: any): void;
+    forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, map2: BiMap<KEY1, KEY2, VALUE>) => void, thisArg?: any): void;
     keys(): IterableIterator<[KEY1, KEY2]>;
     values(): IterableIterator<VALUE>;
     entries(): IterableIterator<[KEY1, KEY2, VALUE]>;
@@ -1130,16 +1276,16 @@ declare class Map2<KEY1, KEY2, VALUE> implements KVComponent<[KEY1, KEY2], VALUE
     kvValues(): IterableIterator<VALUE>;
     kvEntries(): IterableIterator<[[KEY1, KEY2], VALUE]>;
     [Symbol.iterator](): IterableIterator<[KEY1, KEY2, VALUE]>;
-    clone(): Map2<KEY1, KEY2, VALUE>;
-    merge(other: Map2<KEY1, KEY2, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2) => VALUE): this;
+    clone(): BiMap<KEY1, KEY2, VALUE>;
+    merge(other: BiMap<KEY1, KEY2, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2) => VALUE): this;
     some(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): boolean;
     every(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): boolean;
-    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, key2: KEY2, array: Map2<KEY1, KEY2, VALUE>) => value is S): Map2<KEY1, KEY2, S>;
-    filter(predicate: (value: VALUE, key1: KEY1, key2: KEY2, array: Map2<KEY1, KEY2, VALUE>) => unknown): Map2<KEY1, KEY2, VALUE>;
+    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, key2: KEY2, array: BiMap<KEY1, KEY2, VALUE>) => value is S): BiMap<KEY1, KEY2, S>;
+    filter(predicate: (value: VALUE, key1: KEY1, key2: KEY2, array: BiMap<KEY1, KEY2, VALUE>) => unknown): BiMap<KEY1, KEY2, VALUE>;
     reduce(fn: (acc: VALUE, value: VALUE, key1: KEY1, key2: KEY2) => VALUE): VALUE;
     reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1, key2: KEY2) => R, init: R): R;
     mapEntries<R>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): R[];
-    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): Map2<KEY1, KEY2, R>;
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): BiMap<KEY1, KEY2, R>;
     toMap(): Map<[KEY1, KEY2], VALUE>;
     toString(): string;
 }
@@ -1147,11 +1293,14 @@ declare class Map2<KEY1, KEY2, VALUE> implements KVComponent<[KEY1, KEY2], VALUE
 /**
  * A Map implementation mapping a triple key to a value.
  */
-declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2, KEY3], VALUE> {
+declare class TriMap<KEY1, KEY2, KEY3, VALUE> extends BaseContainer implements KVComponent<[KEY1, KEY2, KEY3], VALUE> {
     private map1;
+    private key1Equals;
+    private key2Equals;
+    private key3Equals;
     constructor();
     constructor(entries: Iterable<[KEY1, KEY2, KEY3, VALUE]>);
-    constructor(map3: Map3<KEY1, KEY2, KEY3, VALUE>);
+    constructor(triMap: TriMap<KEY1, KEY2, KEY3, VALUE>);
     has(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
     set(key1: KEY1, key2: KEY2, key3: KEY3, value: VALUE): VALUE;
     get(key1: KEY1, key2: KEY2, key3: KEY3): VALUE | undefined;
@@ -1164,7 +1313,7 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2,
     clear(): void;
     get size(): number;
     isEmpty(): boolean;
-    forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, map2: Map3<KEY1, KEY2, KEY3, VALUE>) => void, thisArg?: any): void;
+    forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, map2: TriMap<KEY1, KEY2, KEY3, VALUE>) => void, thisArg?: any): void;
     keys(): IterableIterator<[KEY1, KEY2, KEY3]>;
     values(): IterableIterator<VALUE>;
     entries(): IterableIterator<[KEY1, KEY2, KEY3, VALUE]>;
@@ -1175,24 +1324,76 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2,
     kvValues(): IterableIterator<VALUE>;
     kvEntries(): IterableIterator<[[KEY1, KEY2, KEY3], VALUE]>;
     [Symbol.iterator](): IterableIterator<[KEY1, KEY2, KEY3, VALUE]>;
-    clone(): Map3<KEY1, KEY2, KEY3, VALUE>;
-    merge(other: Map3<KEY1, KEY2, KEY3, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => VALUE): this;
+    clone(): TriMap<KEY1, KEY2, KEY3, VALUE>;
+    merge(other: TriMap<KEY1, KEY2, KEY3, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => VALUE): this;
     some(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): boolean;
     every(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): boolean;
-    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, array: Map3<KEY1, KEY2, KEY3, VALUE>) => value is S): Map3<KEY1, KEY2, KEY3, S>;
-    filter(predicate: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, array: Map3<KEY1, KEY2, KEY3, VALUE>) => unknown): Map3<KEY1, KEY2, KEY3, VALUE>;
+    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, array: TriMap<KEY1, KEY2, KEY3, VALUE>) => value is S): TriMap<KEY1, KEY2, KEY3, S>;
+    filter(predicate: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, array: TriMap<KEY1, KEY2, KEY3, VALUE>) => unknown): TriMap<KEY1, KEY2, KEY3, VALUE>;
     reduce(fn: (acc: VALUE, value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => VALUE): VALUE;
     reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R, init: R): R;
     mapEntries<R>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): R[];
-    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): Map3<KEY1, KEY2, KEY3, R>;
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): TriMap<KEY1, KEY2, KEY3, R>;
     toMap(): Map<[KEY1, KEY2, KEY3], VALUE>;
     toString(): string;
 }
 
+/**
+ * An implementation of a Set data structure.
+ */
+declare class ValueSet<VALUE> extends BaseContainer implements KVComponent<[VALUE], VALUE> {
+    private data;
+    private equals;
+    constructor();
+    constructor(equals?: EqualityFn<VALUE>);
+    constructor(list: ValueSet<VALUE> | Iterable<VALUE>, equals?: EqualityFn<VALUE>);
+    static createDeep<VALUE>(): ValueSet<VALUE>;
+    static createDeep<VALUE>(set: ValueSet<VALUE>): ValueSet<VALUE>;
+    static createDeep<VALUE>(entries: Iterable<VALUE>): ValueSet<VALUE>;
+    has(value: VALUE): boolean;
+    add(value: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    set(key: VALUE, value: VALUE): void;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    get(key: VALUE): VALUE | undefined;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrDefault(key: VALUE, defaultValue: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrCreate(key: VALUE, value: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrCreate(key: VALUE, creator: () => VALUE): VALUE;
+    delete(value: VALUE): boolean;
+    clear(): void;
+    get size(): number;
+    isEmpty(): boolean;
+    forEach(callbackfn: (value: VALUE, set: ValueSet<VALUE>) => void, thisArg?: any): void;
+    keys(): IterableIterator<VALUE>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[VALUE, VALUE]>;
+    kvKeys(): IterableIterator<[VALUE]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[VALUE], VALUE]>;
+    [Symbol.iterator](): IterableIterator<VALUE>;
+    clone(): ValueSet<VALUE>;
+    merge(other: ValueSet<VALUE>): this;
+    some(fn: (value: VALUE) => boolean): boolean;
+    every(fn: (value: VALUE) => boolean): boolean;
+    filter<R extends VALUE>(predicate: (value: VALUE, set: ValueSet<VALUE>) => value is R): ValueSet<R>;
+    filter(predicate: (value: VALUE, set1: ValueSet<VALUE>) => unknown): ValueSet<VALUE>;
+    reduce(fn: (acc: VALUE, value: VALUE) => VALUE): VALUE;
+    reduce<R = VALUE>(fn: (acc: R, value: VALUE) => R, init: R): R;
+    mapValues<R = VALUE>(fn: (value: VALUE) => R): ValueSet<R>;
+    mapToArray<R = VALUE>(fn: (value: VALUE) => R): R[];
+    map<R = VALUE>(fn: (value: VALUE) => R): ValueSet<R>;
+    toSet(): Set<VALUE>;
+    toArray(): VALUE[];
+    toString(): string;
+}
+
 /**
  * Wrapper class of a key-value container that contain array values.
  */
-declare class MultiContainer<K extends any[], V> {
+declare class MultiContainer<K extends any[], V> extends BaseContainer {
     private readonly base;
     constructor(base: KVComponent<K, V[]>);
     isEmpty(): boolean;
@@ -1222,10 +1423,61 @@ declare class MultiContainer<K extends any[], V> {
  */
 declare function asMulti<K extends any[], VALUE>(base: KVComponent<K, VALUE[]>): MultiContainer<K, VALUE>;
 
+declare class LinkedList<V> extends BaseContainer implements Iterable<V> {
+    private _head;
+    private _tail;
+    private _size;
+    private readonly equals;
+    constructor();
+    constructor(equals?: EqualityFn<V>);
+    constructor(list: LinkedList<V> | Iterable<V>, equals?: EqualityFn<V>);
+    static createDeep<V>(): LinkedList<V>;
+    static createDeep<V>(list: LinkedList<V>): LinkedList<V>;
+    static createDeep<V>(entries: Iterable<V>): LinkedList<V>;
+    get length(): number;
+    get first(): V | undefined;
+    get last(): V | undefined;
+    /** Add item to the end of the list */
+    push(value: V): void;
+    /** Remove item from the end of the list */
+    pop(): V | undefined;
+    /** Add item to the beginning of the list */
+    unshift(value: V): void;
+    /** Remove item from the beginning of the list */
+    shift(): V | undefined;
+    /** Check if value exists in the list */
+    has(value: V): boolean;
+    /** Get value at index (O(n/2)) */
+    get(index: number): V | undefined;
+    /** Set value at index (O(n/2)) */
+    set(index: number, value: V): boolean;
+    /** Insert value at index (O(n/2)) */
+    insertAt(index: number, value: V): boolean;
+    /** Remove value at index (O(n/2)) */
+    removeAt(index: number): V | undefined;
+    /** Remove first matching value (O(n)) */
+    remove(value: V): boolean;
+    /** Convert to array */
+    toArray(): V[];
+    /** Replace contents from array */
+    fromArray(values: Iterable<V>): void;
+    /** Clear all nodes */
+    clear(): void;
+    /** Iterator support */
+    [Symbol.iterator](): Iterator<V>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[number, V]>;
+    toString(): string;
+    private nodeAt;
+    clone(): LinkedList<V>;
+}
+
 /**
- * Vec2 class.
+ * @deprecated - Use {@link Vec} instead. Will be removed in v2.0.0.
+ * @private
  *
- * @deprecated - Use {@link Vec} instead.
+ * Vec2 class.
  */
 declare class Vec2 {
     readonly x: number;
@@ -1239,7 +1491,8 @@ declare class Vec2 {
 }
 
 /**
- * @deprecated - Use {@link SignedIndexArray} or {@link IndexArray} instead, they have way more functions.
+ * @deprecated - Use {@link SignedIndexArray} or {@link IndexArray} instead, they have way more functions. Will be removed in v2.0.0.
+ * @private
  *
  * A cache-like structure optimized for small-range integer keys, including negatives.
  *
@@ -1270,4 +1523,218 @@ declare class SmallIntCache<VALUE> {
     clear(): void;
 }
 
-export { index$7 as Assert, cookies as Cookies, device as Device, DivRect, Guard, IndexArray, type KVComponent, LRUCache, Map1, Map2, Map3, MultiContainer, SignedIndexArray, SmallIntCache, Stack, index as Utils, Vec, Vec2, asMulti };
+/**
+ * @deprecated - Use {@link UniMap} instead. Will be removed in v2.0.0.
+ * @private
+ * A Map implementation mapping a single key to a value.
+ */
+declare class Map1<KEY1, VALUE> extends BaseContainer implements KVComponent<[KEY1], VALUE> {
+    private map1;
+    constructor();
+    constructor(map1: Map1<KEY1, VALUE>);
+    constructor(entries: Iterable<[KEY1, VALUE]>);
+    has(key1: KEY1): boolean;
+    set(key1: KEY1, value: VALUE): VALUE;
+    get(key1: KEY1): VALUE | undefined;
+    getOrDefault(key1: KEY1, defaultValue: VALUE): VALUE;
+    getOrCreate(key1: KEY1, value: VALUE): VALUE;
+    getOrCreate(key1: KEY1, creator: () => VALUE): VALUE;
+    delete(key1: KEY1): boolean;
+    clear(): void;
+    get size(): number;
+    isEmpty(): boolean;
+    forEach(callbackfn: (value: VALUE, key1: KEY1, map1: Map1<KEY1, VALUE>) => void, thisArg?: any): void;
+    keys(): IterableIterator<KEY1>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[KEY1, VALUE]>;
+    keysArray(): KEY1[];
+    valuesArray(): VALUE[];
+    entriesArray(): [KEY1, VALUE][];
+    kvKeys(): IterableIterator<[KEY1]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[KEY1], VALUE]>;
+    [Symbol.iterator](): IterableIterator<[KEY1, VALUE]>;
+    clone(): Map1<KEY1, VALUE>;
+    merge(other: Map1<KEY1, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1) => VALUE): this;
+    some(fn: (value: VALUE, key1: KEY1) => boolean): boolean;
+    every(fn: (value: VALUE, key1: KEY1) => boolean): boolean;
+    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, array: Map1<KEY1, VALUE>) => value is S): Map1<KEY1, S>;
+    filter(predicate: (value: VALUE, key1: KEY1, array: Map1<KEY1, VALUE>) => unknown): Map1<KEY1, VALUE>;
+    reduce(fn: (acc: VALUE, value: VALUE, key1: KEY1) => VALUE): VALUE;
+    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1) => R, init: R): R;
+    mapEntries<R>(fn: (value: VALUE, key1: KEY1) => R): R[];
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1) => R): Map1<KEY1, R>;
+    toMap(): Map<KEY1, VALUE>;
+    toString(): string;
+}
+
+/**
+ * @deprecated - Use {@link BiMap} instead. Will be removed in v2.0.0.
+ * @private
+ * A Map implementation mapping a double key to a value.
+ */
+declare class Map2<KEY1, KEY2, VALUE> extends BaseContainer implements KVComponent<[KEY1, KEY2], VALUE> {
+    private map1;
+    constructor();
+    constructor(map2: Map2<KEY1, KEY2, VALUE>);
+    constructor(entries: Iterable<[KEY1, KEY2, VALUE]>);
+    has(key1: KEY1, key2: KEY2): boolean;
+    set(key1: KEY1, key2: KEY2, value: VALUE): VALUE;
+    get(key1: KEY1, key2: KEY2): VALUE | undefined;
+    getOrDefault(key1: KEY1, key2: KEY2, defaultValue: VALUE): VALUE;
+    getOrCreate(key1: KEY1, key2: KEY2, value: VALUE): VALUE;
+    getOrCreate(key1: KEY1, key2: KEY2, creator: () => VALUE): VALUE;
+    delete(key1: KEY1): boolean;
+    delete(key1: KEY1, key2: KEY2): boolean;
+    clear(): void;
+    get size(): number;
+    isEmpty(): boolean;
+    forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, map2: Map2<KEY1, KEY2, VALUE>) => void, thisArg?: any): void;
+    keys(): IterableIterator<[KEY1, KEY2]>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[KEY1, KEY2, VALUE]>;
+    keysArray(): [KEY1, KEY2][];
+    valuesArray(): VALUE[];
+    entriesArray(): [KEY1, KEY2, VALUE][];
+    kvKeys(): IterableIterator<[KEY1, KEY2]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[KEY1, KEY2], VALUE]>;
+    [Symbol.iterator](): IterableIterator<[KEY1, KEY2, VALUE]>;
+    clone(): Map2<KEY1, KEY2, VALUE>;
+    merge(other: Map2<KEY1, KEY2, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2) => VALUE): this;
+    some(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): boolean;
+    every(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): boolean;
+    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, key2: KEY2, array: Map2<KEY1, KEY2, VALUE>) => value is S): Map2<KEY1, KEY2, S>;
+    filter(predicate: (value: VALUE, key1: KEY1, key2: KEY2, array: Map2<KEY1, KEY2, VALUE>) => unknown): Map2<KEY1, KEY2, VALUE>;
+    reduce(fn: (acc: VALUE, value: VALUE, key1: KEY1, key2: KEY2) => VALUE): VALUE;
+    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1, key2: KEY2) => R, init: R): R;
+    mapEntries<R>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): R[];
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): Map2<KEY1, KEY2, R>;
+    toMap(): Map<[KEY1, KEY2], VALUE>;
+    toString(): string;
+}
+
+/**
+ * @deprecated - Use {@link TriMap} instead. Will be removed in v2.0.0.
+ * @private
+ * A Map implementation mapping a triple key to a value.
+ */
+declare class Map3<KEY1, KEY2, KEY3, VALUE> extends BaseContainer implements KVComponent<[KEY1, KEY2, KEY3], VALUE> {
+    private map1;
+    constructor();
+    constructor(entries: Iterable<[KEY1, KEY2, KEY3, VALUE]>);
+    constructor(map3: Map3<KEY1, KEY2, KEY3, VALUE>);
+    has(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
+    set(key1: KEY1, key2: KEY2, key3: KEY3, value: VALUE): VALUE;
+    get(key1: KEY1, key2: KEY2, key3: KEY3): VALUE | undefined;
+    getOrDefault(key1: KEY1, key2: KEY2, key3: KEY3, defaultValue: VALUE): VALUE;
+    getOrCreate(key1: KEY1, key2: KEY2, key3: KEY3, value: VALUE): VALUE;
+    getOrCreate(key1: KEY1, key2: KEY2, key3: KEY3, creator: () => VALUE): VALUE;
+    delete(key1: KEY1): boolean;
+    delete(key1: KEY1, key2: KEY2): boolean;
+    delete(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
+    clear(): void;
+    get size(): number;
+    isEmpty(): boolean;
+    forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, map2: Map3<KEY1, KEY2, KEY3, VALUE>) => void, thisArg?: any): void;
+    keys(): IterableIterator<[KEY1, KEY2, KEY3]>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[KEY1, KEY2, KEY3, VALUE]>;
+    keysArray(): [KEY1, KEY2, KEY3][];
+    valuesArray(): VALUE[];
+    entriesArray(): [KEY1, KEY2, KEY3, VALUE][];
+    kvKeys(): IterableIterator<[KEY1, KEY2, KEY3]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[KEY1, KEY2, KEY3], VALUE]>;
+    [Symbol.iterator](): IterableIterator<[KEY1, KEY2, KEY3, VALUE]>;
+    clone(): Map3<KEY1, KEY2, KEY3, VALUE>;
+    merge(other: Map3<KEY1, KEY2, KEY3, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => VALUE): this;
+    some(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): boolean;
+    every(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): boolean;
+    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, array: Map3<KEY1, KEY2, KEY3, VALUE>) => value is S): Map3<KEY1, KEY2, KEY3, S>;
+    filter(predicate: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, array: Map3<KEY1, KEY2, KEY3, VALUE>) => unknown): Map3<KEY1, KEY2, KEY3, VALUE>;
+    reduce(fn: (acc: VALUE, value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => VALUE): VALUE;
+    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R, init: R): R;
+    mapEntries<R>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): R[];
+    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): Map3<KEY1, KEY2, KEY3, R>;
+    toMap(): Map<[KEY1, KEY2, KEY3], VALUE>;
+    toString(): string;
+}
+
+/**
+ * @deprecated - Use {@link ValueSet} instead. Will be removed in v2.0.0.
+ * @private
+ * An abstract base class implementation of a Set data structure.
+ */
+declare abstract class SetBase<VALUE, CLS extends SetBase<VALUE, CLS> = any> extends BaseContainer implements KVComponent<[VALUE], VALUE> {
+    protected data: Set<VALUE>;
+    constructor(entries?: Iterable<VALUE>);
+    protected abstract valueEquals(a: VALUE, b: VALUE): boolean;
+    protected abstract createEmpty<R = VALUE>(): SetBase<R, any>;
+    has(value: VALUE): boolean;
+    add(value: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    set(key: VALUE, value: VALUE): void;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    get(key: VALUE): VALUE | undefined;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrDefault(key: VALUE, defaultValue: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrCreate(key: VALUE, value: VALUE): VALUE;
+    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+    getOrCreate(key: VALUE, creator: () => VALUE): VALUE;
+    delete(value: VALUE): boolean;
+    clear(): void;
+    get size(): number;
+    isEmpty(): boolean;
+    forEach(callbackfn: (value: VALUE, set1: SetBase<VALUE>) => void, thisArg?: any): void;
+    keys(): IterableIterator<VALUE>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[VALUE, VALUE]>;
+    kvKeys(): IterableIterator<[VALUE]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[VALUE], VALUE]>;
+    [Symbol.iterator](): IterableIterator<VALUE>;
+    clone(): SetBase<VALUE>;
+    merge(other: SetBase<VALUE>): this;
+    some(fn: (value: VALUE) => boolean): boolean;
+    every(fn: (value: VALUE) => boolean): boolean;
+    filter<R extends VALUE>(predicate: (value: VALUE, set1: SetBase<VALUE, any>) => value is R): SetBase<R, any>;
+    filter(predicate: (value: VALUE, set1: SetBase<VALUE>) => unknown): SetBase<VALUE, any>;
+    reduce(fn: (acc: VALUE, value: VALUE) => VALUE): VALUE;
+    reduce<R = VALUE>(fn: (acc: R, value: VALUE) => R, init: R): R;
+    mapValues<R = VALUE>(fn: (value: VALUE) => R): SetBase<R, any>;
+    mapToArray<R = VALUE>(fn: (value: VALUE) => R): R[];
+    map<R = VALUE>(fn: (value: VALUE) => R): SetBase<R, any>;
+    toSet(): Set<VALUE>;
+    toArray(): VALUE[];
+    toString(): string;
+}
+/**
+ * @deprecated - Use {@link ValueSet} instead. Will be removed in v2.0.0.
+ * @private
+ * A simple Set data structure. Comparison of values is done
+ * using === operator (e.g. "a" === "a", but [1, 2] !== [1, 2]).
+ */
+declare class Set1<VALUE> extends SetBase<VALUE, Set1<VALUE>> {
+    constructor();
+    constructor(set: SetBase<VALUE>);
+    constructor(entries: Iterable<VALUE>);
+    protected createEmpty<R = VALUE>(): Set1<R>;
+    protected valueEquals(a: VALUE, b: VALUE): boolean;
+}
+/**
+ * @deprecated - Use {@link ValueSet}.createDeep() instead. Will be removed in v2.0.0.
+ * @private
+ * A simple Set data structure, where comparison of values is done
+ * using deep equality (e.g. "a" === "a" and also [1, 2] === [1, 2]).
+ */
+declare class DeepSet<VALUE> extends SetBase<VALUE, DeepSet<VALUE>> {
+    constructor();
+    constructor(set: SetBase<VALUE>);
+    constructor(entries: Iterable<VALUE>);
+    protected createEmpty<R = VALUE>(): DeepSet<R>;
+    protected valueEquals(a: VALUE, b: VALUE): boolean;
+}
+
+export { index$7 as Assert, BaseContainer, BiMap, cookies as Cookies, DeepSet, DefaultArray, DefaultEqualityFn, device as Device, DivRect, type EqualityFn, Guard, IndexArray, type KVComponent, LRUCache, LinkedList, Map1, Map2, Map3, MultiContainer, Set1, SetBase, SignedIndexArray, SmallIntCache, Stack, TriMap, UniMap, index as Utils, ValueSet, Vec, Vec2, asMulti };