@tspro/ts-utils-lib 1.15.0 → 1.17.0

package/dist/index.d.ts

@@ -384,21 +384,267 @@ declare class Stack<T> {
     clear(): void;
 }
 
-declare class Vec2 {
-    readonly x: number;
-    readonly y: number;
-    constructor(x?: number, y?: number);
-    length(): number;
-    add(a: Vec2): Vec2;
-    sub(a: Vec2): Vec2;
-    mul(a: number): Vec2;
-    div(a: number): Vec2;
+/**
+ * Vector class.
+ *
+ * ```ts
+ * // Example usage:
+ * const a = new Vec(1, 2);
+ * const b = new Vec(3, 4);
+ *
+ * console.log(a.add(b).toString());     // Vec(4, 6)
+ * console.log(a.add(3, 3).toString());  // Vec(4, 5)
+ * console.log(a.mul(2).toString());     // Vec(2, 4)
+ * console.log(a.equals(b));             // false
+ * console.log(a.clone().equals(a));     // true
+ * ```
+ */
+declare class Vec {
+    readonly coords: number[];
+    constructor(...coords: number[]);
+    static vec2(x: number, y: number): Vec;
+    static vec3(x: number, y: number, z: number): Vec;
+    static zero(dim: number): Vec;
+    get length(): number;
+    get x(): number;
+    get y(): number;
+    get z(): number;
+    add(other: Vec): Vec;
+    add(...coords: number[]): Vec;
+    sub(other: Vec): Vec;
+    sub(...coords: number[]): Vec;
+    mul(scalar: number): Vec;
+    div(scalar: number): Vec;
+    dot(other: Vec): number;
+    distance(other: Vec): number;
+    normalize(): Vec;
+    equals(other: Vec): boolean;
+    clone(): Vec;
+    toObject(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    [Symbol.iterator](): ArrayIterator<number>;
+    toString(): string;
+}
+
+/**
+ * DivRect class, left, top, right, bottom rectangle divided into four sections by centerX, centerY.
+ */
+declare class DivRect {
+    left: number;
+    centerX: number;
+    right: number;
+    top: number;
+    centerY: number;
+    bottom: number;
+    /**
+     * Create rectangle with all zero values.
+     */
+    constructor();
+    /**
+     * Create rectangle with left, right, top, bottom.
+     * Properties centerX and centerY will be centered in the middle.
+     *
+     * @param left - Left coordinate.
+     * @param right - Right coordinate.
+     * @param top - Top coordinate.
+     * @param bottom - Bottom coordinate.
+     */
+    constructor(left: number, right: number, top: number, bottom: number);
+    /**
+     * Create rectangle with full arguments.
+     *
+     * @param left - Left coordinate.
+     * @param centerX - Center x-coordinate.
+     * @param right - Right coordinate.
+     * @param top - Top coordinate.
+     * @param centerY - Center y-coordinate.
+     * @param bottom - Bottom coordinate.
+     */
+    constructor(left: number, centerX: number, right: number, top: number, centerY: number, bottom: number);
+    /**
+     * 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: number, top: number, width: number, height: number): DivRect;
+    /**
+     * Create rect from centerX, centerY, width, height arguments.
+     *
+     * @param centerX - Center x-coordinate.
+     * @param centerY - Center y-coordinate.
+     * @param width - Width.
+     * @param height - Height.
+     * @returns - DivRect.
+     */
+    static createCentered(centerX: number, centerY: number, width: number, height: number): DivRect;
+    /**
+     * 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: number, rightw: number, toph: number, bottomh: number): DivRect;
+    /**
+     * Width getter.
+     */
+    get width(): number;
+    /**
+     * Height getter.
+     */
+    get height(): number;
+    /**
+     * Left section width getter.
+     */
+    get leftw(): number;
+    /**
+     * Right section width getter.
+     */
+    get rightw(): number;
+    /**
+     * Top section height getter.
+     */
+    get toph(): number;
+    /**
+     * Bottom section height getter.
+     */
+    get bottomh(): number;
+    /**
+     * Does this Rect contain given (x, y)-point?
+     *
+     * @param x - X-coordinate.
+     * @param y - Y-coordinate.
+     * @returns - True/false.
+     */
+    contains(x: number, y: number): boolean;
+    /**
+     * Do a and b rects overlap?
+     *
+     * @param a - DivRect a.
+     * @param b - DivRect b.
+     * @returns - True/false.
+     */
+    static overlap(a: DivRect, b: DivRect): boolean;
+    /**
+     * Do horizontal measures of a and b rects overlap?
+     *
+     * @param a - DivRect a.
+     * @param b - DivRect b.
+     * @returns - True/false.
+     */
+    static overlapX(a: DivRect, b: DivRect): boolean;
+    /**
+     * Check if given rects are equal.
+     * @param a - DivRect a.
+     * @param b - DivRect b.
+     * @returns - True/false.
+     */
+    static equals(a: DivRect | null | undefined, b: DivRect | null | undefined): boolean;
+    /**
+     * Check if this rect equals with another rect.
+     * @param other - The other rect.
+     * @returns - True/false.
+     */
+    equals(other: DivRect): boolean;
+    /**
+     * Check if edges of given rects are equal, ignoring centerX and centerY.
+     *
+     * @param a - DivRect a.
+     * @param b - DivRect b.
+     * @returns - True/false.
+     */
+    static equalsEdges(a: DivRect | null | undefined, b: DivRect | null | undefined): boolean;
+    /**
+     * Check if edges of this Rect equals with given Rect, ignoring centerX and centerY.
+     *
+     * @param other - The other DivRect.
+     * @returns - True/false.
+     */
+    equalsEdges(other: DivRect): boolean;
+    /**
+     * Created duplicate of this Rect.
+     *
+     * @returns - Duplicate.
+     */
+    copy(): DivRect;
+    /**
+     * 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: number, dy: number): DivRect;
+    /**
+     * 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: number, dy: number): DivRect;
+    /**
+     * Expand this Rect by given Rect. Modifies this Rect.
+     *
+     * @param rect - DivRect to expand this instance with.
+     * @returns - This DivRect instance.
+     */
+    expandInPlace(rect: DivRect): DivRect;
+    /**
+     * 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: DivRect): DivRect;
+    /**
+     * Clip this Rect by given Rect. Mmodifies this Rect.
+     *
+     * @param clipRect - DivRect to clip this instance with.
+     * @returns - This DivRect instance.
+     */
+    clipInPlace(clipRect: DivRect): DivRect;
+    /**
+     * Clip this Rect by given Rect. Immutable, return modified copy.
+     *
+     * @param clipRect - DivRecto to clip this instance with.
+     * @returns - Clipped DivRect copy.
+     */
+    clipCopy(clipRect: DivRect): DivRect;
+    /**
+     * Scale Rect. Anchor pos is (centerX, centerY). Modifies this Rect.
+     *
+     * @param scaleX - Scale x-amount.
+     * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
+     * @returns This DivRect instance.
+     */
+    scaleInPlace(scaleX: number, scaleY?: number): DivRect;
+    /**
+     * Scale Rect. Anchor pos is (centerX, centerY). Immutable, returns modified copy.
+     *
+     * @param scaleX - Scale x-amount.
+     * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
+     * @returns Scaled copy of this DivRect.
+     */
+    scaleCopy(scaleX: number, scaleY?: number): DivRect;
+    /**
+     * Get this DivRect instance.
+     * @returns - This DivRect instance.
+     */
+    getRect(): DivRect;
 }
 
 /**
  * LRUCache class: Least Recently Used cache with a fixed capacity
- *
- * Provided by ChatGPT.
  */
 declare class LRUCache<K extends string, V> {
     private cache;
@@ -418,138 +664,119 @@ declare class LRUCache<K extends string, V> {
     private addToTail;
 }
 
-/**
- * A cache-like structure optimized for small-range integer keys, including negatives.
- *
- * Internally implemented using two sparse arrays: one for non-negative keys,
- * and one for negative keys (stored by index `-key - 1`).
- *
- * @remarks
- * - Fast access for small integer keys.
- * - Not suitable for large or sparse key ranges — memory usage may grow significantly.
- * - Supports `get`, `set`, `delete`, `has` and `clear`
- *
- * @example
- * ```ts
- * const cache = new SmallIntCache<string>();
- * cache.set(-2, 'A');
- * cache.set(3, 'B');
- * console.log(cache.get(-2)); // 'A'
- * ```
- *
- * @deprecated - Same functionality an more is available now in SignedIndexArray<EL> and IndexArray<EL> containers.
- */
-declare class SmallIntCache<V> {
-    private pos;
-    private neg;
-    constructor();
-    set(key: number, value: V): void;
-    get(key: number): V | undefined;
-    has(key: number): boolean;
-    delete(key: number): void;
-    clear(): void;
-}
-
-interface KVComponent<K extends any[], EL> {
+interface KVComponent<K extends any[], VALUE> {
     get size(): number;
+    isEmpty(): boolean;
     has(...keys: K): boolean;
-    get(...keys: K): EL | undefined;
-    getOrDefault(...keysAndDefault: [...K, EL]): EL;
-    getOrCreate(...keysAndCreator: [...K, EL]): EL;
-    set(...keysAndValue: [...K, EL]): void;
+    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]>;
 }
 
 /**
  * An array-like structure for non-negative indexes.
  */
-declare class IndexArray<EL> implements KVComponent<[number], EL> {
-    private static toNegIndex;
+declare class IndexArray<VALUE> implements KVComponent<[number], VALUE> {
     private static validateIndex;
-    private posEl;
+    private posVal;
     private hasPos;
-    private elCount;
+    private valCount;
     constructor();
-    constructor(arr: IndexArray<EL>);
-    constructor(entries: Iterable<[number, EL]>);
-    get size(): number;
+    constructor(arr: IndexArray<VALUE>);
+    constructor(entries: Iterable<[number, VALUE]>);
     private get posLen();
+    get size(): number;
+    isEmpty(): boolean;
     has(id: number): boolean;
-    set(id: number, el: EL): void;
-    get(id: number): EL | undefined;
-    getOrDefault(id: number, defaultValue: EL): EL;
-    getOrCreate(id: number, value: EL): EL;
-    getOrCreate(id: number, creator: () => EL): EL;
+    set(id: number, value: VALUE): void;
+    get(id: number): VALUE | undefined;
+    getOrDefault(id: number, defaultValue: VALUE): VALUE;
+    getOrCreate(id: number, value: VALUE): VALUE;
+    getOrCreate(id: number, creator: () => VALUE): VALUE;
     delete(id: number): boolean;
     clear(): void;
-    forEach(callbackfn: (el: EL, id: number, arr: IndexArray<EL>) => void, thisArg?: any): void;
+    forEach(callbackfn: (value: VALUE, id: number, arr: IndexArray<VALUE>) => void, thisArg?: any): void;
     indices(): IterableIterator<number>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[number, VALUE]>;
     indicesArray(): number[];
-    values(): IterableIterator<EL>;
-    valuesArray(): EL[];
-    entries(): IterableIterator<[number, EL]>;
-    entriesArray(): [number, EL][];
-    [Symbol.iterator](): Generator<[number, EL], void, any>;
-    clone(): IndexArray<EL>;
-    merge(other: IndexArray<EL>, conflictResolver?: (oldValue: EL, newValue: EL, id: number) => EL): this;
-    some(fn: (el: EL, id: number) => boolean): boolean;
-    every(fn: (value: EL, key1: number) => boolean): boolean;
-    filter(fn: (value: EL, key1: number) => boolean): IndexArray<EL>;
-    reduce(fn: (acc: EL, el: EL, id: number) => EL): EL;
-    reduce<R>(fn: (acc: R, el: EL, id: number) => R, init: R): R;
-    mapToArray<R>(fn: (value: EL, key1: number) => R): R[];
-    map<R = EL>(fn: (value: EL, key1: number) => R): IndexArray<R>;
-    equals(other: IndexArray<EL>): boolean;
-    equals(other: IndexArray<EL>, eq: (a: EL, b: EL) => boolean): boolean;
+    valuesArray(): VALUE[];
+    entriesArray(): [number, VALUE][];
+    kvKeys(): IterableIterator<[number]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[number], VALUE]>;
+    [Symbol.iterator](): Generator<[number, VALUE], void, any>;
+    clone(): IndexArray<VALUE>;
+    merge(other: IndexArray<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, index: number, array: IndexArray<VALUE>) => value is S): IndexArray<S>;
+    filter(predicate: (value: VALUE, index: number, array: IndexArray<VALUE>) => unknown): IndexArray<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): IndexArray<R>;
+    equals(other: IndexArray<VALUE>): boolean;
+    equals(other: IndexArray<VALUE>, eq: (a: VALUE, b: VALUE) => boolean): boolean;
     toString(): string;
 }
 
 /**
  * An array-like structure for signed indexes, including negatives.
  */
-declare class SignedIndexArray<EL> implements KVComponent<[number], EL> {
+declare class SignedIndexArray<VALUE> implements KVComponent<[number], VALUE> {
     private static toNegIndex;
     private static validateIndex;
-    private posEl;
+    private posVal;
     private hasPos;
-    private negEl;
+    private negVal;
     private hasNeg;
-    private elCount;
+    private valCount;
     constructor();
-    constructor(arr: SignedIndexArray<EL>);
-    constructor(entries: Iterable<[number, EL]>);
+    constructor(arr: SignedIndexArray<VALUE>);
+    constructor(entries: Iterable<[number, VALUE]>);
     get size(): number;
+    isEmpty(): boolean;
     private get posLen();
     private get negLen();
     has(id: number): boolean;
-    set(id: number, el: EL): void;
-    get(id: number): EL | undefined;
-    getOrDefault(id: number, defaultValue: EL): EL;
-    getOrCreate(id: number, value: EL): EL;
-    getOrCreate(id: number, creator: () => EL): EL;
+    set(id: number, value: VALUE): void;
+    get(id: number): VALUE | undefined;
+    getOrDefault(id: number, defaultValue: VALUE): VALUE;
+    getOrCreate(id: number, value: VALUE): VALUE;
+    getOrCreate(id: number, creator: () => VALUE): VALUE;
     delete(id: number): boolean;
     clear(): void;
-    forEach(callbackfn: (el: EL, id: number, arr: SignedIndexArray<EL>) => void, thisArg?: any): void;
+    forEach(callbackfn: (value: VALUE, id: number, arr: SignedIndexArray<VALUE>) => void, thisArg?: any): void;
     indices(): IterableIterator<number>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[number, VALUE]>;
     indicesArray(): number[];
-    values(): IterableIterator<EL>;
-    valuesArray(): EL[];
-    entries(): IterableIterator<[number, EL]>;
-    entriesArray(): [number, EL][];
-    [Symbol.iterator](): Generator<[number, EL], void, any>;
-    clone(): SignedIndexArray<EL>;
-    merge(other: SignedIndexArray<EL>, conflictResolver?: (oldValue: EL, newValue: EL, id: number) => EL): this;
-    some(fn: (el: EL, id: number) => boolean): boolean;
-    every(fn: (value: EL, key1: number) => boolean): boolean;
-    filter(fn: (value: EL, key1: number) => boolean): SignedIndexArray<EL>;
-    reduce(fn: (acc: EL, el: EL, id: number) => EL): EL;
-    reduce<R>(fn: (acc: R, el: EL, id: number) => R, init: R): R;
-    mapToArray<R>(fn: (value: EL, key1: number) => R): R[];
-    map<R = EL>(fn: (value: EL, key1: number) => R): SignedIndexArray<R>;
-    equals(other: SignedIndexArray<EL>): boolean;
-    equals(other: SignedIndexArray<EL>, eq: (a: EL, b: EL) => boolean): boolean;
+    valuesArray(): VALUE[];
+    entriesArray(): [number, VALUE][];
+    kvKeys(): IterableIterator<[number]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[number], VALUE]>;
+    [Symbol.iterator](): Generator<[number, VALUE], void, any>;
+    clone(): SignedIndexArray<VALUE>;
+    merge(other: SignedIndexArray<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, index: number, array: SignedIndexArray<VALUE>) => value is S): SignedIndexArray<S>;
+    filter(predicate: (value: VALUE, index: number, array: SignedIndexArray<VALUE>) => unknown): SignedIndexArray<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): SignedIndexArray<R>;
+    equals(other: SignedIndexArray<VALUE>): boolean;
+    equals(other: SignedIndexArray<VALUE>, eq: (a: VALUE, b: VALUE) => boolean): boolean;
     toString(): string;
 }
 
@@ -567,25 +794,32 @@ declare class Map1<KEY1, VALUE> implements KVComponent<[KEY1], 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>;
-    keysArray(): KEY1[];
     values(): IterableIterator<VALUE>;
-    valuesArray(): VALUE[];
     entries(): IterableIterator<[KEY1, VALUE]>;
+    keysArray(): KEY1[];
+    valuesArray(): VALUE[];
     entriesArray(): [KEY1, VALUE][];
+    kvKeys(): IterableIterator<[KEY1]>;
+    kvValues(): IterableIterator<VALUE>;
+    kvEntries(): IterableIterator<[[KEY1], VALUE]>;
     [Symbol.iterator](): Generator<[KEY1, VALUE], void, any>;
     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(fn: (value: VALUE, key1: KEY1) => boolean): Map1<KEY1, VALUE>;
+    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;
 }
+
 declare class Map2<KEY1, KEY2, VALUE> implements KVComponent<[KEY1, KEY2], VALUE> {
     private map1;
     constructor();
@@ -601,25 +835,32 @@ declare class Map2<KEY1, KEY2, VALUE> implements KVComponent<[KEY1, KEY2], VALUE
     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]>;
-    keysArray(): [KEY1, KEY2][];
     values(): IterableIterator<VALUE>;
-    valuesArray(): 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](): Generator<[KEY1, KEY2, VALUE], void, any>;
     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(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): Map2<KEY1, KEY2, VALUE>;
+    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;
 }
+
 declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2, KEY3], VALUE> {
     private map1;
     constructor();
@@ -636,19 +877,25 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2,
     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]>;
-    keysArray(): [KEY1, KEY2, KEY3][];
     values(): IterableIterator<VALUE>;
-    valuesArray(): 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](): Generator<[KEY1, KEY2, KEY3, VALUE], void, any>;
     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(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): Map3<KEY1, KEY2, KEY3, VALUE>;
+    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>;
@@ -659,11 +906,17 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2,
 declare class MultiContainer<K extends any[], V> {
     private readonly base;
     constructor(base: KVComponent<K, V[]>);
+    isEmpty(): boolean;
+    clear(): void;
     add(...keysAndValue: [...K, V]): V;
     remove(...keysAndValue: [...K, V]): boolean;
     getAll(...keys: K): V[];
     iterAll(...keys: K): IterableIterator<V>;
-    clear(): void;
+    values(): IterableIterator<V>;
+    keys(): IterableIterator<K>;
+    entries(): IterableIterator<[K, V[]]>;
+    [Symbol.iterator](): IterableIterator<[K, V[]]>;
+    toString(): string;
 }
 /**
  * ```ts
@@ -674,6 +927,54 @@ declare class MultiContainer<K extends any[], V> {
  * @param base
  * @returns
  */
-declare function asMulti<K extends any[], EL>(base: KVComponent<K, EL[]>): MultiContainer<K, EL>;
+declare function asMulti<K extends any[], VALUE>(base: KVComponent<K, VALUE[]>): MultiContainer<K, VALUE>;
+
+/**
+ * Vec2 class.
+ *
+ * @deprecated - Use Vec instead, has more functionality.
+ */
+declare class Vec2 {
+    readonly x: number;
+    readonly y: number;
+    constructor(x?: number, y?: number);
+    length(): number;
+    add(a: Vec2): Vec2;
+    sub(a: Vec2): Vec2;
+    mul(a: number): Vec2;
+    div(a: number): Vec2;
+}
+
+/**
+ * A cache-like structure optimized for small-range integer keys, including negatives.
+ *
+ * Internally implemented using two sparse arrays: one for non-negative keys,
+ * and one for negative keys (stored by index `-key - 1`).
+ *
+ * @remarks
+ * - Fast access for small integer keys.
+ * - Not suitable for large or sparse key ranges — memory usage may grow significantly.
+ * - Supports `get`, `set`, `delete`, `has` and `clear`
+ *
+ * @example
+ * ```ts
+ * const cache = new SmallIntCache<string>();
+ * cache.set(-2, 'A');
+ * cache.set(3, 'B');
+ * console.log(cache.get(-2)); // 'A'
+ * ```
+ *
+ * @deprecated - Same functionality an more is available now in SignedIndexArray<VALUE> and IndexArray<VALUE> containers.
+ */
+declare class SmallIntCache<VALUE> {
+    private pos;
+    private neg;
+    constructor();
+    set(key: number, value: VALUE): void;
+    get(key: number): VALUE | undefined;
+    has(key: number): boolean;
+    delete(key: number): void;
+    clear(): void;
+}
 
-export { Assert, Cookies, Device, IndexArray, type KVComponent, LRUCache, Map1, Map2, Map3, MultiContainer, SignedIndexArray, SmallIntCache, Stack, index as Utils, Vec2, asMulti };
+export { Assert, Cookies, Device, DivRect, IndexArray, type KVComponent, LRUCache, Map1, Map2, Map3, MultiContainer, SignedIndexArray, SmallIntCache, Stack, index as Utils, Vec, Vec2, asMulti };