@tspro/ts-utils-lib 1.18.0 → 1.19.1

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [1.19.1] - 2025-10-27
+## Fixed
+- Forgot to export `DefaultArray`, `SetBase`, `Set1` and `DeepSet`.
+
+## [1.19.0] - 2025-10-27
+### Added
+- SignedIndexArray.toArray(), IndexArray.toArray(), IndexArray.length;
+- Set1 and DeepSet.
+- DefaultArray.
+- Stack functions.
+
 ## [1.18.0] - 2025-10-24
 ### Changed
 - Deprecated `DivRect` properties `centerX` and `centerY`, replaced with `anchorX` and `anchorY`.

package/dist/index.d.mts

@@ -143,15 +143,60 @@ 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 };
 }
 
+/**
+ * Set expiration time for cookies.
+ * @param days - Number of days until cookies expire.
+ */
 declare function setExpireDays(days: number): void;
+/**
+ * Is consent pending (cookies not yet accepted)?
+ * @returns
+ */
 declare function isConsentPending(): boolean;
+/**
+ * Consent cookies.
+ */
 declare function accept(): void;
+/**
+ * Decline cookies. This will reject all cookies than a single flags that cookies have been declined.
+ */
 declare function decline(): void;
+/**
+ * Save a cookie.
+ * @param name - Cookie name.
+ * @param value - Cookie value, can be string, number or boolean.
+ * @returns - Returns given value.
+ */
 declare function save<T extends string | number | boolean>(name: string, value: T): T;
+/**
+ * Read a string cookie.
+ * @param name - Cookie name.
+ * @param defaultValue - Default value returned when cookie with given name was not found.
+ * @returns - String cookie value.
+ */
 declare function read(name: string, defaultValue: string): string;
+/**
+ * Read an integer cookie.
+ * @param name - Cookie name.
+ * @param defaultValue - Default value returned when cookie with given name was not found.
+ * @returns - Integer cookie valus.
+ */
 declare function readInt(name: string, defaultValue: number): number;
+/**
+ * Read a boolean cookie.
+ * @param name - Cookie name.
+ * @param defaultValue - Default value returned when cookie with given name was not found.
+ * @returns - Boolean cookie value.
+ */
 declare function readBool(name: string, defaultValue: boolean): boolean;
+/**
+ * Erase cookie.
+ * @param name - Name of cookie to be erased.
+ */
 declare function erase(name: string): void;
+/**
+ * Erase all cookies.
+ */
 declare function eraseAll(): void;
 
 declare const cookies_accept: typeof accept;
@@ -168,15 +213,39 @@ declare namespace cookies {
   export { cookies_accept as accept, cookies_decline as decline, cookies_erase as erase, cookies_eraseAll as eraseAll, cookies_isConsentPending as isConsentPending, cookies_read as read, cookies_readBool as readBool, cookies_readInt as readInt, cookies_save as save, cookies_setExpireDays as setExpireDays };
 }
 
+/** Devices dots per inch. */
 declare const DPI: number;
+/** Devices pixels per millimeter. */
 declare const PxPerMm: number;
+/** Browsers scroll bar width. */
 declare const ScrollbarWidth: number;
+/** Browsers system font size. */
 declare const FontSize: number;
+/** Is touch device? */
 declare const IsTouchDevice: boolean;
+/** Is mobile device? */
 declare const IsMobileDevice: boolean;
+/** Host address. */
 declare const HostAddress: string;
+/**
+ * Convert pixels to millimeters on a device.
+ * @param px - Pixels.
+ * @returns - Millimeters.
+ */
 declare function pxToMm(px: number): number;
+/**
+ * Convert millimeters to pixels on a device.
+ * @param mm - Millimeters.
+ * @returns - Pixels.
+ */
 declare function mmToPx(mm: number): number;
+/**
+ * Convert input to pixels on a device. Input value is in html style form containing number
+ * followed by unit (e.g. "10px"). Supported units are "mm", "cm", "in", "inch", "em" and "px".
+ *
+ * @param input - Input value.
+ * @returns - Pixels.
+ */
 declare function toPx(input: string | number): number;
 
 declare const device_DPI: typeof DPI;
@@ -310,8 +379,9 @@ declare namespace Guard {
 
 declare function toArray<T>(a: T | T[]): Array<T>;
 declare function duplicate<T>(a: T[] | undefined): T[] | undefined;
-declare function removeDuplicates<T>(a: T[]): T[];
-declare function removeDuplicatesCmp<T>(arr: ReadonlyArray<T>, cmp: (t1: T, t2: T) => boolean): T[];
+declare function removeDuplicates<T>(arr: T[], compareFn?: (a: T, b: T) => boolean): T[];
+/** @deprecated - Use {@link removeDuplicates} with compareFn instead. */
+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[];
 declare function getSequenceArray(len: number): number[];
@@ -545,18 +615,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 };
 }
 
+/**
+ * This is a stack data structure.
+ */
 declare class Stack<T> {
-    private readonly list;
-    push(e: T): T;
+    private readonly data;
+    private assertId;
+    get length(): number;
+    push(el: T): T;
     pop(): T;
+    popOrUndef(): T | undefined;
+    popOr(defaultValueOrCreator: T | (() => T)): T;
     top(): T;
+    topOrUndef(): T | undefined;
+    topOr(defaultValueOrCreator: T | (() => T)): T;
+    peek(depth?: number): T;
+    peekOrUndef(depth?: number): T | undefined;
+    peekOr(depth: number | undefined, defaultValueOrCreator: T | (() => T)): T;
+    values(): IterableIterator<T>;
+    [Symbol.iterator](): IterableIterator<T>;
     toArray(): T[];
-    get length(): number;
+    isEmpty(): boolean;
     clear(): void;
+    toString(): string;
 }
 
 /**
- * Vector class.
+ * `Vec` is a generic vector class with two or more coordinates.
  *
  * ```ts
  * // Example usage:
@@ -606,7 +691,7 @@ declare class Vec {
 }
 
 /**
- * DivRect class, left, top, right, bottom rectangle divided into four sections by anchorX, anchorY.
+ * DivRect class is a rectangle (left, top, right, bottom) with an anchor point (anchorX, anchorY).
  */
 declare class DivRect {
     left: number;
@@ -830,7 +915,7 @@ declare class DivRect {
 }
 
 /**
- * LRUCache class: Least Recently Used cache with a fixed capacity
+ * LRUCache is an implementation of least recently used cache with a fixed capacity.
  */
 declare class LRUCache<K extends string, V> {
     private cache;
@@ -867,7 +952,8 @@ interface KVComponent<K extends any[], VALUE> {
 }
 
 /**
- * An array-like structure for non-negative indexes.
+ * `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> {
     private static validateIndex;
@@ -879,6 +965,8 @@ declare class IndexArray<VALUE> implements KVComponent<[number], VALUE> {
     constructor(entries: Iterable<[number, VALUE]>);
     private get posLen();
     get size(): number;
+    get length(): number;
+    private trimRight;
     isEmpty(): boolean;
     has(id: number): boolean;
     set(id: number, value: VALUE): void;
@@ -898,7 +986,7 @@ declare class IndexArray<VALUE> implements KVComponent<[number], VALUE> {
     kvKeys(): IterableIterator<[number]>;
     kvValues(): IterableIterator<VALUE>;
     kvEntries(): IterableIterator<[[number], VALUE]>;
-    [Symbol.iterator](): Generator<[number, VALUE], void, any>;
+    [Symbol.iterator](): IterableIterator<[number, VALUE]>;
     clone(): IndexArray<VALUE>;
     merge(other: IndexArray<VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, id: number) => VALUE): this;
     some(fn: (value: VALUE, id: number) => boolean): boolean;
@@ -911,11 +999,13 @@ declare class IndexArray<VALUE> implements KVComponent<[number], VALUE> {
     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;
+    toArray(): VALUE[];
     toString(): string;
 }
 
 /**
- * An array-like structure for signed indexes, including negatives.
+ * `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> {
     private static toNegIndex;
@@ -950,7 +1040,7 @@ declare class SignedIndexArray<VALUE> implements KVComponent<[number], VALUE> {
     kvKeys(): IterableIterator<[number]>;
     kvValues(): IterableIterator<VALUE>;
     kvEntries(): IterableIterator<[[number], VALUE]>;
-    [Symbol.iterator](): Generator<[number, VALUE], void, any>;
+    [Symbol.iterator](): IterableIterator<[number, VALUE]>;
     clone(): SignedIndexArray<VALUE>;
     merge(other: SignedIndexArray<VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, id: number) => VALUE): this;
     some(fn: (value: VALUE, id: number) => boolean): boolean;
@@ -963,9 +1053,66 @@ declare class SignedIndexArray<VALUE> implements KVComponent<[number], VALUE> {
     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;
+    toArray(): 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> implements KVComponent<[number], VALUE> {
+    readonly defaultValue: VALUE;
+    private data;
+    constructor(values: Iterable<VALUE>, defaultValue: VALUE);
+    constructor(length: number, 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(): this;
+    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;
     constructor();
@@ -991,7 +1138,7 @@ declare class Map1<KEY1, VALUE> implements KVComponent<[KEY1], VALUE> {
     kvKeys(): IterableIterator<[KEY1]>;
     kvValues(): IterableIterator<VALUE>;
     kvEntries(): IterableIterator<[[KEY1], VALUE]>;
-    [Symbol.iterator](): Generator<[KEY1, VALUE], void, any>;
+    [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;
@@ -1006,6 +1153,9 @@ declare class Map1<KEY1, VALUE> implements KVComponent<[KEY1], VALUE> {
     toString(): string;
 }
 
+/**
+ * A Map implementation mapping a double key to a value.
+ */
 declare class Map2<KEY1, KEY2, VALUE> implements KVComponent<[KEY1, KEY2], VALUE> {
     private map1;
     constructor();
@@ -1032,7 +1182,7 @@ declare class Map2<KEY1, KEY2, VALUE> implements KVComponent<[KEY1, KEY2], VALUE
     kvKeys(): IterableIterator<[KEY1, KEY2]>;
     kvValues(): IterableIterator<VALUE>;
     kvEntries(): IterableIterator<[[KEY1, KEY2], VALUE]>;
-    [Symbol.iterator](): Generator<[KEY1, KEY2, VALUE], void, any>;
+    [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;
@@ -1047,6 +1197,9 @@ declare class Map2<KEY1, KEY2, VALUE> implements KVComponent<[KEY1, KEY2], VALUE
     toString(): string;
 }
 
+/**
+ * A Map implementation mapping a triple key to a value.
+ */
 declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2, KEY3], VALUE> {
     private map1;
     constructor();
@@ -1074,7 +1227,7 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2,
     kvKeys(): IterableIterator<[KEY1, KEY2, KEY3]>;
     kvValues(): IterableIterator<VALUE>;
     kvEntries(): IterableIterator<[[KEY1, KEY2, KEY3], VALUE]>;
-    [Symbol.iterator](): Generator<[KEY1, KEY2, KEY3, VALUE], void, any>;
+    [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;
@@ -1089,6 +1242,82 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2,
     toString(): string;
 }
 
+/**
+ * An abstract base class implementation of a Set data structure.
+ */
+declare abstract class SetBase<VALUE, CLS extends SetBase<VALUE, CLS> = any> 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>;
+    protected abstract getName(): string;
+    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;
+}
+/**
+ * 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;
+    protected getName(): string;
+}
+/**
+ * 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;
+    protected getName(): string;
+}
+
+/**
+ * Wrapper class of a key-value container that contain array values.
+ */
 declare class MultiContainer<K extends any[], V> {
     private readonly base;
     constructor(base: KVComponent<K, V[]>);
@@ -1105,10 +1334,14 @@ declare class MultiContainer<K extends any[], V> {
     toString(): string;
 }
 /**
+ * Create a multi-container.
+ *
  * ```ts
  * // Usage:
  * const multi = asMulti(new Map2<string, string, number[]>());
- * multi.add("A", "B", 5);
+ * multi.add("a", "b", 5);
+ * multi.add("a", "b", 10);
+ * multi.add("a", "c", 15);
  * ```
  * @param base
  * @returns
@@ -1163,4 +1396,4 @@ 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 };
+export { index$7 as Assert, cookies as Cookies, DeepSet, DefaultArray, device as Device, DivRect, Guard, IndexArray, type KVComponent, LRUCache, Map1, Map2, Map3, MultiContainer, Set1, SetBase, SignedIndexArray, SmallIntCache, Stack, index as Utils, Vec, Vec2, asMulti };