@tspro/ts-utils-lib 1.17.0 → 1.19.0

package/dist/index.d.ts

@@ -1,8 +1,276 @@
+type EnumObject = Record<string, string | number>;
+type EnumKey<E extends EnumObject> = keyof E;
+type EnumValue<E extends EnumObject> = E[EnumKey<E>];
+declare function getEnumKeys<E extends EnumObject>(e: E): EnumKey<E>[];
+declare function getEnumValues<E extends EnumObject>(e: E): EnumValue<E>[];
+declare function getEnumEntries<E extends EnumObject>(e: E): [keyof E, EnumValue<E>][];
+declare function getEnumKey<E extends EnumObject>(e: E, value: EnumValue<E>): keyof E | undefined;
+declare function forEachEnum<E extends EnumObject>(e: E, callback: (key: keyof E, value: E[keyof E]) => void): void;
+declare function isEnumValue$2<E extends EnumObject>(e: E, value: unknown): value is EnumValue<E>;
+declare function assertEnumValue<E extends EnumObject>(e: E, value: unknown): asserts value is EnumValue<E>;
+
+type index$8_EnumKey<E extends EnumObject> = EnumKey<E>;
+type index$8_EnumObject = EnumObject;
+type index$8_EnumValue<E extends EnumObject> = EnumValue<E>;
+declare const index$8_assertEnumValue: typeof assertEnumValue;
+declare const index$8_forEachEnum: typeof forEachEnum;
+declare const index$8_getEnumEntries: typeof getEnumEntries;
+declare const index$8_getEnumKey: typeof getEnumKey;
+declare const index$8_getEnumKeys: typeof getEnumKeys;
+declare const index$8_getEnumValues: typeof getEnumValues;
+declare namespace index$8 {
+  export { type index$8_EnumKey as EnumKey, type index$8_EnumObject as EnumObject, type index$8_EnumValue as EnumValue, index$8_assertEnumValue as assertEnumValue, index$8_forEachEnum as forEachEnum, index$8_getEnumEntries as getEnumEntries, index$8_getEnumKey as getEnumKey, index$8_getEnumKeys as getEnumKeys, index$8_getEnumValues as getEnumValues, isEnumValue$2 as isEnumValue };
+}
+
+type ErrorConstructor = new (msg: string) => Error;
+declare function setErrorClass(errorClass?: ErrorConstructor): void;
+/** @deprecated */
+declare function interrupt(msg?: string): never;
+/** @deprecated */
+declare function assertEnum<E extends EnumObject>(enumVal: unknown, enumObj: E, name?: string): asserts enumVal is E[keyof E];
+/** @deprecated */
+declare function int(value: unknown, msg?: string): number;
+/** @deprecated */
+declare function eq<T>(value1: T, value2: T, msg?: string): T;
+/** @deprecated */
+declare function int_eq(value: unknown, compareTo: unknown, msg?: string): number;
+/** @deprecated */
+declare function int_lt(value: unknown, compareTo: unknown, msg?: string): number;
+/** @deprecated */
+declare function int_lte(value: unknown, compareTo: unknown, msg?: string): number;
+/** @deprecated */
+declare function int_gt(value: unknown, compareTo: unknown, msg?: string): number;
+/** @deprecated */
+declare function int_gte(value: unknown, compareTo: unknown, msg?: string): number;
+/** @deprecated */
+declare function int_between(value: unknown, min: unknown, max: unknown, msg?: string): number;
+/** @deprecated */
+declare function int_between_exclusive(value: unknown, min: unknown, max: unknown, msg?: string): number;
+/** @deprecated */
+declare function odd(value: unknown, msg?: string): number;
+/** @deprecated */
+declare function even(value: unknown, msg?: string): number;
+/** @deprecated */
+declare function in_group<T>(value: T, group: ReadonlyArray<T>, msg?: string): T;
+/** @deprecated */
+declare function finite(value: unknown, msg?: string): number;
+/** @deprecated */
+declare function array_id<T>(array: Readonly<T[]>, index: unknown, msg?: string): number;
+/** @deprecated */
+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;
+declare function requireDefined<T>(value: T | undefined, msg?: string): T;
+declare function fail(msg?: string): never;
+declare function isEqual$1(value1: unknown, value2: unknown, msg?: string): boolean;
+declare function isDeepEqual$1(value1: unknown, value2: unknown, msg?: string): boolean;
+declare function isUndefined$1(value: unknown, msg?: string): value is undefined;
+declare function isNull$1(value: unknown, msg?: string): value is null;
+declare function isNullish$1(value: unknown, msg?: string): value is null | undefined;
+declare function isObject$1(value: unknown, msg?: string): value is Record<string, unknown>;
+declare function isObjectOrUndefined$1(value: unknown, msg?: string): value is Record<string, unknown> | undefined;
+declare function isTypedObject$1<T extends object>(obj: unknown, keys: (keyof T)[], msg?: string): obj is HasProps<T>;
+declare function isArray$1<T>(value: T[] | unknown, msg?: string): value is T[];
+declare function isArrayOrUndefined$1(value: unknown, msg?: string): value is unknown[] | undefined;
+declare function isEmptyArray$1<T>(value: T[] | unknown, msg?: string): value is T[];
+declare function isNonEmptyArray$1<T>(value: T[] | unknown, msg?: string): value is T[];
+declare function isEmptyArrayOrUndefined$1<T>(value: T[] | unknown, msg?: string): value is T[] | undefined;
+declare function isNonEmptyArrayOrUndefined$1<T>(value: T[] | unknown, msg?: string): value is T[] | undefined;
+declare function isString$1(value: unknown, msg?: string): value is string;
+declare function isEmptyString$1(value: unknown, msg?: string): value is "";
+declare function isNonEmptyString$1(value: unknown, msg?: string): value is string;
+declare function isStringOrUndefined$1(value: unknown, msg?: string): value is string | undefined;
+declare function isEmptyStringOrUndefined$1(value: unknown, msg?: string): value is "" | undefined;
+declare function isNonEmptyStringOrUndefined$1(value: unknown, msg?: string): value is string | undefined;
+declare function isBoolean$1(value: unknown, msg?: string): value is boolean;
+declare function isBooleanOrUndefined$1(value: unknown, msg?: string): value is boolean | undefined;
+declare function isTrue$1(value: unknown, msg?: string): value is boolean;
+declare function isTrueOrUndefined$1(value: unknown, msg?: string): value is boolean;
+declare function isFalse$1(value: unknown, msg?: string): value is boolean;
+declare function isFalseOrUndefined$1(value: unknown, msg?: string): value is boolean;
+declare function isFunction$1(value: unknown, msg?: string): value is Function;
+declare function isFunctionOrUndefined$1(value: unknown, msg?: string): value is Function | undefined;
+declare function isEnumValue$1<E extends EnumObject>(enumValue: unknown, enumObject: E, msg?: string): enumValue is E[keyof E];
+declare function isEnumValueOrUndefined$1<E extends EnumObject>(enumValue: unknown, enumObject: E, msg?: string): enumValue is E[keyof E];
+declare function isNumber$1(value: unknown, msg?: string): value is number;
+declare function isNumberOrUndefined$1(value: unknown, msg?: string): value is number | undefined;
+declare function isFinite$1(value: unknown, msg?: string): value is number;
+declare function isInteger$1(value: unknown, msg?: string): value is number;
+declare function isIntegerOrUndefined$1(value: unknown, msg?: string): value is number | undefined;
+declare function isIntegerEq$1(value: unknown, compareTo: unknown, msg?: string): value is number;
+declare function isIntegerGt$1(value: unknown, compareTo: unknown, msg?: string): value is number;
+declare function isIntegerGte$1(value: unknown, compareTo: unknown, msg?: string): value is number;
+declare function isIntegerLt$1(value: unknown, compareTo: unknown, msg?: string): value is number;
+declare function isIntegerLte$1(value: unknown, compareTo: unknown, msg?: string): value is number;
+declare function isIntegerBetween$1(value: unknown, min: unknown, max: unknown, msg?: string): value is number;
+declare function isIntegerBetweenExclusive$1(value: unknown, min: unknown, max: unknown, msg?: string): value is number;
+declare function isNumberBetween$1(value: unknown, min: unknown, max: unknown, msg?: string): value is number;
+declare function isNumberBetweenExclusive$1(value: unknown, min: unknown, max: unknown, msg?: string): value is number;
+declare function isNaNValue$1(value: unknown, msg?: string): value is number;
+declare function isInfinity$1(value: unknown, msg?: string): value is number;
+declare function isPosInfinity$1(value: unknown, msg?: string): value is number;
+declare function isNegInfinity$1(value: unknown, msg?: string): value is number;
+declare function isOddNumber$1(value: unknown, msg?: string): value is number;
+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;
+
+type index$7_ErrorConstructor = ErrorConstructor;
+declare const index$7_array_elem: typeof array_elem;
+declare const index$7_array_id: typeof array_id;
+declare const index$7_assert: typeof assert;
+declare const index$7_assertEnum: typeof assertEnum;
+declare const index$7_eq: typeof eq;
+declare const index$7_even: typeof even;
+declare const index$7_fail: typeof fail;
+declare const index$7_finite: typeof finite;
+declare const index$7_in_group: typeof in_group;
+declare const index$7_int: typeof int;
+declare const index$7_int_between: typeof int_between;
+declare const index$7_int_between_exclusive: typeof int_between_exclusive;
+declare const index$7_int_eq: typeof int_eq;
+declare const index$7_int_gt: typeof int_gt;
+declare const index$7_int_gte: typeof int_gte;
+declare const index$7_int_lt: typeof int_lt;
+declare const index$7_int_lte: typeof int_lte;
+declare const index$7_interrupt: typeof interrupt;
+declare const index$7_odd: typeof odd;
+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 };
+}
+
+/**
+ * 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;
+declare const cookies_decline: typeof decline;
+declare const cookies_erase: typeof erase;
+declare const cookies_eraseAll: typeof eraseAll;
+declare const cookies_isConsentPending: typeof isConsentPending;
+declare const cookies_read: typeof read;
+declare const cookies_readBool: typeof readBool;
+declare const cookies_readInt: typeof readInt;
+declare const cookies_save: typeof save;
+declare const cookies_setExpireDays: typeof setExpireDays;
+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;
+declare const device_FontSize: typeof FontSize;
+declare const device_HostAddress: typeof HostAddress;
+declare const device_IsMobileDevice: typeof IsMobileDevice;
+declare const device_IsTouchDevice: typeof IsTouchDevice;
+declare const device_PxPerMm: typeof PxPerMm;
+declare const device_ScrollbarWidth: typeof ScrollbarWidth;
+declare const device_mmToPx: typeof mmToPx;
+declare const device_pxToMm: typeof pxToMm;
+declare const device_toPx: typeof toPx;
+declare namespace device {
+  export { device_DPI as DPI, device_FontSize as FontSize, device_HostAddress as HostAddress, device_IsMobileDevice as IsMobileDevice, device_IsTouchDevice as IsTouchDevice, device_PxPerMm as PxPerMm, device_ScrollbarWidth as ScrollbarWidth, device_mmToPx as mmToPx, device_pxToMm as pxToMm, device_toPx as toPx };
+}
+
+declare function isEqual(value1: unknown, value2: unknown): boolean;
+declare function isDeepEqual(value1: unknown, value2: unknown): boolean;
 declare function isUndefined(value: unknown): value is undefined;
 declare function isNull(value: unknown): value is null;
 declare function isNullish(value: unknown): value is null | undefined;
 declare function isObject(value: unknown): value is Record<string, unknown>;
 declare function isObjectOrUndefined(value: unknown): value is Record<string, unknown> | undefined;
+type HasProps<T extends object> = T extends Record<string, unknown> ? T : never;
+declare function isTypedObject<T extends object>(obj: unknown, keys: (keyof T)[]): obj is HasProps<T>;
 declare function isArray<T>(a: T[] | unknown): a is T[];
 declare function isArrayOrUndefined(value: unknown): value is unknown[] | undefined;
 declare function isEmptyArray<T>(a: T[] | unknown): a is T[];
@@ -17,6 +285,10 @@ declare function isEmptyStringOrUndefined(value: unknown): value is "" | undefin
 declare function isNonEmptyStringOrUndefined(value: unknown): value is string | undefined;
 declare function isBoolean(value: unknown): value is boolean;
 declare function isBooleanOrUndefined(value: unknown): value is boolean | undefined;
+declare function isTrue(value: unknown): value is true;
+declare function isTrueOrUndefined(value: unknown): value is true;
+declare function isFalse(value: unknown): value is false;
+declare function isFalseOrUndefined(value: unknown): value is false;
 declare function isFunction(value: unknown): value is Function;
 declare function isFunctionOrUndefined(value: unknown): value is Function | undefined;
 declare function isEnumValue<E extends Record<string, string | number>>(value: unknown, enumObj: E, name?: string): value is E[keyof E];
@@ -26,63 +298,90 @@ declare function isNumberOrUndefined(value: unknown): value is number | undefine
 declare function isFinite(value: unknown): value is number;
 declare function isInteger(n: unknown): n is number;
 declare function isIntegerOrUndefined(n: unknown): n is number | undefined;
-declare function isIntegerEq(value: unknown, compareTo: number): value is number;
-declare function isIntegerGt(value: unknown, compareTo: number): value is number;
-declare function isIntegerGte(value: unknown, compareTo: number): value is number;
-declare function isIntegerLt(value: unknown, compareTo: number): value is number;
-declare function isIntegerLte(value: unknown, compareTo: number): value is number;
-declare function isIntegerBetween(value: unknown, min: number, max: number): value is number;
+declare function isIntegerEq(value: unknown, compareTo: unknown): value is number;
+declare function isIntegerGt(value: unknown, compareTo: unknown): value is number;
+declare function isIntegerGte(value: unknown, compareTo: unknown): value is number;
+declare function isIntegerLt(value: unknown, compareTo: unknown): value is number;
+declare function isIntegerLte(value: unknown, compareTo: unknown): value is number;
+declare function isIntegerBetween(value: unknown, min: unknown, max: unknown): value is number;
+declare function isIntegerBetweenExclusive(value: unknown, min: unknown, max: unknown): value is number;
+declare function isNumberBetween(value: unknown, min: unknown, max: unknown): value is number;
+declare function isNumberBetweenExclusive(value: unknown, min: unknown, max: unknown): value is number;
 declare function isNaNValue(value: unknown): value is number;
 declare function isInfinity(value: unknown): value is number;
 declare function isPosInfinity(value: unknown): value is number;
 declare function isNegInfinity(value: unknown): value is number;
+declare function isOddNumber(value: unknown): value is number;
+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 tryOr<TRY_RVAL, OR_RVAL>(tryFn: () => TRY_RVAL, orVal: OR_RVAL | (() => OR_RVAL)): TRY_RVAL | OR_RVAL;
 
-declare const index$8_isArray: typeof isArray;
-declare const index$8_isArrayOrUndefined: typeof isArrayOrUndefined;
-declare const index$8_isBoolean: typeof isBoolean;
-declare const index$8_isBooleanOrUndefined: typeof isBooleanOrUndefined;
-declare const index$8_isEmptyArray: typeof isEmptyArray;
-declare const index$8_isEmptyArrayOrUndefined: typeof isEmptyArrayOrUndefined;
-declare const index$8_isEmptyString: typeof isEmptyString;
-declare const index$8_isEmptyStringOrUndefined: typeof isEmptyStringOrUndefined;
-declare const index$8_isEnumValue: typeof isEnumValue;
-declare const index$8_isEnumValueOrUndefined: typeof isEnumValueOrUndefined;
-declare const index$8_isFinite: typeof isFinite;
-declare const index$8_isFunction: typeof isFunction;
-declare const index$8_isFunctionOrUndefined: typeof isFunctionOrUndefined;
-declare const index$8_isInfinity: typeof isInfinity;
-declare const index$8_isInteger: typeof isInteger;
-declare const index$8_isIntegerBetween: typeof isIntegerBetween;
-declare const index$8_isIntegerEq: typeof isIntegerEq;
-declare const index$8_isIntegerGt: typeof isIntegerGt;
-declare const index$8_isIntegerGte: typeof isIntegerGte;
-declare const index$8_isIntegerLt: typeof isIntegerLt;
-declare const index$8_isIntegerLte: typeof isIntegerLte;
-declare const index$8_isIntegerOrUndefined: typeof isIntegerOrUndefined;
-declare const index$8_isNaNValue: typeof isNaNValue;
-declare const index$8_isNegInfinity: typeof isNegInfinity;
-declare const index$8_isNonEmptyArray: typeof isNonEmptyArray;
-declare const index$8_isNonEmptyArrayOrUndefined: typeof isNonEmptyArrayOrUndefined;
-declare const index$8_isNonEmptyString: typeof isNonEmptyString;
-declare const index$8_isNonEmptyStringOrUndefined: typeof isNonEmptyStringOrUndefined;
-declare const index$8_isNull: typeof isNull;
-declare const index$8_isNullish: typeof isNullish;
-declare const index$8_isNumber: typeof isNumber;
-declare const index$8_isNumberOrUndefined: typeof isNumberOrUndefined;
-declare const index$8_isObject: typeof isObject;
-declare const index$8_isObjectOrUndefined: typeof isObjectOrUndefined;
-declare const index$8_isPosInfinity: typeof isPosInfinity;
-declare const index$8_isString: typeof isString;
-declare const index$8_isStringOrUndefined: typeof isStringOrUndefined;
-declare const index$8_isUndefined: typeof isUndefined;
-declare namespace index$8 {
-  export { index$8_isArray as isArray, index$8_isArrayOrUndefined as isArrayOrUndefined, index$8_isBoolean as isBoolean, index$8_isBooleanOrUndefined as isBooleanOrUndefined, index$8_isEmptyArray as isEmptyArray, index$8_isEmptyArrayOrUndefined as isEmptyArrayOrUndefined, index$8_isEmptyString as isEmptyString, index$8_isEmptyStringOrUndefined as isEmptyStringOrUndefined, index$8_isEnumValue as isEnumValue, index$8_isEnumValueOrUndefined as isEnumValueOrUndefined, index$8_isFinite as isFinite, index$8_isFunction as isFunction, index$8_isFunctionOrUndefined as isFunctionOrUndefined, index$8_isInfinity as isInfinity, index$8_isInteger as isInteger, index$8_isIntegerBetween as isIntegerBetween, index$8_isIntegerEq as isIntegerEq, index$8_isIntegerGt as isIntegerGt, index$8_isIntegerGte as isIntegerGte, index$8_isIntegerLt as isIntegerLt, index$8_isIntegerLte as isIntegerLte, index$8_isIntegerOrUndefined as isIntegerOrUndefined, index$8_isNaNValue as isNaNValue, index$8_isNegInfinity as isNegInfinity, index$8_isNonEmptyArray as isNonEmptyArray, index$8_isNonEmptyArrayOrUndefined as isNonEmptyArrayOrUndefined, index$8_isNonEmptyString as isNonEmptyString, index$8_isNonEmptyStringOrUndefined as isNonEmptyStringOrUndefined, index$8_isNull as isNull, index$8_isNullish as isNullish, index$8_isNumber as isNumber, index$8_isNumberOrUndefined as isNumberOrUndefined, index$8_isObject as isObject, index$8_isObjectOrUndefined as isObjectOrUndefined, index$8_isPosInfinity as isPosInfinity, index$8_isString as isString, index$8_isStringOrUndefined as isStringOrUndefined, index$8_isUndefined as isUndefined };
+type Guard_HasProps<T extends object> = HasProps<T>;
+declare const Guard_isArray: typeof isArray;
+declare const Guard_isArrayIndex: typeof isArrayIndex;
+declare const Guard_isArrayOrUndefined: typeof isArrayOrUndefined;
+declare const Guard_isBoolean: typeof isBoolean;
+declare const Guard_isBooleanOrUndefined: typeof isBooleanOrUndefined;
+declare const Guard_isDeepEqual: typeof isDeepEqual;
+declare const Guard_isEmptyArray: typeof isEmptyArray;
+declare const Guard_isEmptyArrayOrUndefined: typeof isEmptyArrayOrUndefined;
+declare const Guard_isEmptyString: typeof isEmptyString;
+declare const Guard_isEmptyStringOrUndefined: typeof isEmptyStringOrUndefined;
+declare const Guard_isEnumValue: typeof isEnumValue;
+declare const Guard_isEnumValueOrUndefined: typeof isEnumValueOrUndefined;
+declare const Guard_isEqual: typeof isEqual;
+declare const Guard_isEvenNumber: typeof isEvenNumber;
+declare const Guard_isFalse: typeof isFalse;
+declare const Guard_isFalseOrUndefined: typeof isFalseOrUndefined;
+declare const Guard_isFinite: typeof isFinite;
+declare const Guard_isFunction: typeof isFunction;
+declare const Guard_isFunctionOrUndefined: typeof isFunctionOrUndefined;
+declare const Guard_isIncluded: typeof isIncluded;
+declare const Guard_isInfinity: typeof isInfinity;
+declare const Guard_isInteger: typeof isInteger;
+declare const Guard_isIntegerBetween: typeof isIntegerBetween;
+declare const Guard_isIntegerBetweenExclusive: typeof isIntegerBetweenExclusive;
+declare const Guard_isIntegerEq: typeof isIntegerEq;
+declare const Guard_isIntegerGt: typeof isIntegerGt;
+declare const Guard_isIntegerGte: typeof isIntegerGte;
+declare const Guard_isIntegerLt: typeof isIntegerLt;
+declare const Guard_isIntegerLte: typeof isIntegerLte;
+declare const Guard_isIntegerOrUndefined: typeof isIntegerOrUndefined;
+declare const Guard_isNaNValue: typeof isNaNValue;
+declare const Guard_isNegInfinity: typeof isNegInfinity;
+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_isNull: typeof isNull;
+declare const Guard_isNullish: typeof isNullish;
+declare const Guard_isNumber: typeof isNumber;
+declare const Guard_isNumberBetween: typeof isNumberBetween;
+declare const Guard_isNumberBetweenExclusive: typeof isNumberBetweenExclusive;
+declare const Guard_isNumberOrUndefined: typeof isNumberOrUndefined;
+declare const Guard_isObject: typeof isObject;
+declare const Guard_isObjectOrUndefined: typeof isObjectOrUndefined;
+declare const Guard_isOddNumber: typeof isOddNumber;
+declare const Guard_isPosInfinity: typeof isPosInfinity;
+declare const Guard_isString: typeof isString;
+declare const Guard_isStringOrUndefined: typeof isStringOrUndefined;
+declare const Guard_isThrowing: typeof isThrowing;
+declare const Guard_isTrue: typeof isTrue;
+declare const Guard_isTrueOrUndefined: typeof isTrueOrUndefined;
+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 };
 }
 
 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[];
@@ -91,20 +390,20 @@ declare function getRangeArray(start: number, end: number): number[];
 declare function arrayContains<T extends unknown>(arg: T[], item: T): boolean;
 declare function chunckArray<A>(arr: ReadonlyArray<A>, chunckSize: number): A[][];
 
-declare const index$7_arrayContains: typeof arrayContains;
-declare const index$7_chunckArray: typeof chunckArray;
-declare const index$7_duplicate: typeof duplicate;
-declare const index$7_fillArray: typeof fillArray;
-declare const index$7_getRangeArray: typeof getRangeArray;
-declare const index$7_getSequenceArray: typeof getSequenceArray;
-declare const index$7_isArray: typeof isArray;
-declare const index$7_mapRangeArray: typeof mapRangeArray;
-declare const index$7_mapSequenceArray: typeof mapSequenceArray;
-declare const index$7_removeDuplicates: typeof removeDuplicates;
-declare const index$7_removeDuplicatesCmp: typeof removeDuplicatesCmp;
-declare const index$7_toArray: typeof toArray;
-declare namespace index$7 {
-  export { index$7_arrayContains as arrayContains, index$7_chunckArray as chunckArray, index$7_duplicate as duplicate, index$7_fillArray as fillArray, index$7_getRangeArray as getRangeArray, index$7_getSequenceArray as getSequenceArray, index$7_isArray as isArray, index$7_mapRangeArray as mapRangeArray, index$7_mapSequenceArray as mapSequenceArray, index$7_removeDuplicates as removeDuplicates, index$7_removeDuplicatesCmp as removeDuplicatesCmp, index$7_toArray as toArray };
+declare const index$6_arrayContains: typeof arrayContains;
+declare const index$6_chunckArray: typeof chunckArray;
+declare const index$6_duplicate: typeof duplicate;
+declare const index$6_fillArray: typeof fillArray;
+declare const index$6_getRangeArray: typeof getRangeArray;
+declare const index$6_getSequenceArray: typeof getSequenceArray;
+declare const index$6_isArray: typeof isArray;
+declare const index$6_mapRangeArray: typeof mapRangeArray;
+declare const index$6_mapSequenceArray: typeof mapSequenceArray;
+declare const index$6_removeDuplicates: typeof removeDuplicates;
+declare const index$6_removeDuplicatesCmp: typeof removeDuplicatesCmp;
+declare const index$6_toArray: typeof toArray;
+declare namespace index$6 {
+  export { index$6_arrayContains as arrayContains, index$6_chunckArray as chunckArray, index$6_duplicate as duplicate, index$6_fillArray as fillArray, index$6_getRangeArray as getRangeArray, index$6_getSequenceArray as getSequenceArray, index$6_isArray as isArray, index$6_mapRangeArray as mapRangeArray, index$6_mapSequenceArray as mapSequenceArray, index$6_removeDuplicates as removeDuplicates, index$6_removeDuplicatesCmp as removeDuplicatesCmp, index$6_toArray as toArray };
 }
 
 interface CSSProperties {
@@ -153,43 +452,28 @@ declare function getDimension(style?: CSSProperties): {
 declare function styleLayoutChanged(style1?: CSSProperties, style2?: CSSProperties): boolean;
 declare function getCanvasTextWidth(text: string, font: string): number;
 
-type index$6_CSSProperties = CSSProperties;
-declare const index$6_addClass: typeof addClass;
-declare const index$6_appendTo: typeof appendTo;
-declare const index$6_getButton: typeof getButton;
-declare const index$6_getCanvas: typeof getCanvas;
-declare const index$6_getCanvasTextWidth: typeof getCanvasTextWidth;
-declare const index$6_getDimension: typeof getDimension;
-declare const index$6_getHeight: typeof getHeight;
-declare const index$6_getOffset: typeof getOffset;
-declare const index$6_getPadding: typeof getPadding;
-declare const index$6_getWidth: typeof getWidth;
-declare const index$6_hasClass: typeof hasClass;
-declare const index$6_removeClass: typeof removeClass;
-declare const index$6_removeFromParent: typeof removeFromParent;
-declare const index$6_setHeight: typeof setHeight;
-declare const index$6_setOffset: typeof setOffset;
-declare const index$6_setRect: typeof setRect;
-declare const index$6_setVisibility: typeof setVisibility;
-declare const index$6_setWidth: typeof setWidth;
-declare const index$6_styleLayoutChanged: typeof styleLayoutChanged;
-declare namespace index$6 {
-  export { type index$6_CSSProperties as CSSProperties, index$6_addClass as addClass, index$6_appendTo as appendTo, index$6_getButton as getButton, index$6_getCanvas as getCanvas, index$6_getCanvasTextWidth as getCanvasTextWidth, index$6_getDimension as getDimension, index$6_getHeight as getHeight, index$6_getOffset as getOffset, index$6_getPadding as getPadding, index$6_getWidth as getWidth, index$6_hasClass as hasClass, index$6_removeClass as removeClass, index$6_removeFromParent as removeFromParent, index$6_setHeight as setHeight, index$6_setOffset as setOffset, index$6_setRect as setRect, index$6_setVisibility as setVisibility, index$6_setWidth as setWidth, index$6_styleLayoutChanged as styleLayoutChanged };
-}
-
-type EnumObject = {
-    [key: string]: string | number;
-};
-type EnumValue<E extends EnumObject> = E extends {
-    [key: string]: string | infer V;
-} ? V : never;
-declare function getEnumValues<E extends EnumObject>(e: E): Array<EnumValue<E>>;
-
-type index$5_EnumObject = EnumObject;
-type index$5_EnumValue<E extends EnumObject> = EnumValue<E>;
-declare const index$5_getEnumValues: typeof getEnumValues;
+type index$5_CSSProperties = CSSProperties;
+declare const index$5_addClass: typeof addClass;
+declare const index$5_appendTo: typeof appendTo;
+declare const index$5_getButton: typeof getButton;
+declare const index$5_getCanvas: typeof getCanvas;
+declare const index$5_getCanvasTextWidth: typeof getCanvasTextWidth;
+declare const index$5_getDimension: typeof getDimension;
+declare const index$5_getHeight: typeof getHeight;
+declare const index$5_getOffset: typeof getOffset;
+declare const index$5_getPadding: typeof getPadding;
+declare const index$5_getWidth: typeof getWidth;
+declare const index$5_hasClass: typeof hasClass;
+declare const index$5_removeClass: typeof removeClass;
+declare const index$5_removeFromParent: typeof removeFromParent;
+declare const index$5_setHeight: typeof setHeight;
+declare const index$5_setOffset: typeof setOffset;
+declare const index$5_setRect: typeof setRect;
+declare const index$5_setVisibility: typeof setVisibility;
+declare const index$5_setWidth: typeof setWidth;
+declare const index$5_styleLayoutChanged: typeof styleLayoutChanged;
 declare namespace index$5 {
-  export { type index$5_EnumObject as EnumObject, type index$5_EnumValue as EnumValue, index$5_getEnumValues as getEnumValues };
+  export { type index$5_CSSProperties as CSSProperties, index$5_addClass as addClass, index$5_appendTo as appendTo, index$5_getButton as getButton, index$5_getCanvas as getCanvas, index$5_getCanvasTextWidth as getCanvasTextWidth, index$5_getDimension as getDimension, index$5_getHeight as getHeight, index$5_getOffset as getOffset, index$5_getPadding as getPadding, index$5_getWidth as getWidth, index$5_hasClass as hasClass, index$5_removeClass as removeClass, index$5_removeFromParent as removeFromParent, index$5_setHeight as setHeight, index$5_setOffset as setOffset, index$5_setRect as setRect, index$5_setVisibility as setVisibility, index$5_setWidth as setWidth, index$5_styleLayoutChanged as styleLayoutChanged };
 }
 
 declare function getMapKeys<K, V>(map: Map<K, V>): K[];
@@ -321,71 +605,43 @@ 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 };
 }
 
-declare namespace index {
-  export { index$7 as Arr, index$6 as Dom, index$5 as Enum, index$8 as Is, index$4 as Map, index$3 as Math, index$2 as Obj, index$1 as Str };
-}
-
-declare namespace Assert {
-    type ErrorConstructor = new (msg: string) => Error;
-    function setErrorClass(ec?: ErrorConstructor): void;
-    function assert<T>(a: T, userMsg?: string): void;
-    function assertEnum<E extends Record<string, string | number>>(value: unknown, enumObj: E, name?: string): asserts value is E[keyof E];
-    function interrupt(userMsg?: string): never;
-    function int(a: unknown, userMsg?: string): number;
-    function eq<T>(a: T, b: T, userMsg?: string): T;
-    function int_eq(a: unknown, b: unknown, userMsg?: string): number;
-    function int_lt(a: unknown, b: unknown, userMsg?: string): number;
-    function int_lte(a: unknown, b: unknown, userMsg?: string): number;
-    function int_gt(a: unknown, b: unknown, userMsg?: string): number;
-    function int_gte(a: unknown, b: unknown, userMsg?: string): number;
-    function int_between(a: unknown, min: unknown, max: unknown, userMsg?: string): number;
-    function odd(a: unknown, userMsg?: string): number;
-    function even(a: unknown, userMsg?: string): number;
-    function in_group<T>(a: T, group: ReadonlyArray<T>, userMsg?: string): T;
-    function finite(a: unknown, userMsg?: string): number;
-    function array_id<T>(arr: Readonly<T[]>, id: unknown, userMsg?: string): number;
-    function array_elem<T>(arr: Readonly<T[]>, id: number, userMsg?: string): T;
-    function require<T>(arg: T, userMsg?: string): NonNullable<T>;
-}
-
-declare namespace Cookies {
-    function setExpireDays(days: number): void;
-    function isConsentPending(): boolean;
-    function accept(): void;
-    function decline(): void;
-    function save<T extends string | number | boolean>(name: string, value: T): T;
-    function read(name: string, defaultValue: string): string;
-    function readInt(name: string, defaultValue: number): number;
-    function readBool(name: string, defaultValue: boolean): boolean;
-    function erase(name: string): void;
-    function eraseAll(): void;
-}
+/**
+ * @deprecated Use {@link Guard} instead.
+ */
+declare const Is: typeof Guard;
 
-declare namespace Device {
-    const DPI: number;
-    const PxPerMm: number;
-    const ScrollbarWidth: number;
-    const FontSize: number;
-    const IsTouchDevice: boolean;
-    const IsMobileDevice: boolean;
-    const HostAddress: string;
-    function pxToMm(px: number): number;
-    function mmToPx(mm: number): number;
-    function toPx(input: string | number): number;
+declare const index_Is: typeof Is;
+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:
@@ -405,7 +661,9 @@ declare class Vec {
     static vec2(x: number, y: number): Vec;
     static vec3(x: number, y: number, z: number): Vec;
     static zero(dim: number): Vec;
+    get dim(): number;
     get length(): number;
+    magnitude(): number;
     get x(): number;
     get y(): number;
     get z(): number;
@@ -418,6 +676,9 @@ declare class Vec {
     dot(other: Vec): number;
     distance(other: Vec): number;
     normalize(): Vec;
+    static lerp(a: Vec, b: Vec, t: number): Vec;
+    toLength(len: number): Vec;
+    clamp(minLength?: number, maxLength?: number, defaultDir?: Vec): Vec;
     equals(other: Vec): boolean;
     clone(): Vec;
     toObject(): {
@@ -430,14 +691,14 @@ declare class Vec {
 }
 
 /**
- * DivRect class, left, top, right, bottom rectangle divided into four sections by centerX, centerY.
+ * DivRect class is a rectangle (left, top, right, bottom) with an anchor point (anchorX, anchorY).
  */
 declare class DivRect {
     left: number;
-    centerX: number;
+    anchorX: number;
     right: number;
     top: number;
-    centerY: number;
+    anchorY: number;
     bottom: number;
     /**
      * Create rectangle with all zero values.
@@ -445,7 +706,7 @@ declare class DivRect {
     constructor();
     /**
      * Create rectangle with left, right, top, bottom.
-     * Properties centerX and centerY will be centered in the middle.
+     * Properties anchorX and anchorY will be centered in the middle.
      *
      * @param left - Left coordinate.
      * @param right - Right coordinate.
@@ -457,13 +718,13 @@ declare class DivRect {
      * Create rectangle with full arguments.
      *
      * @param left - Left coordinate.
-     * @param centerX - Center x-coordinate.
+     * @param anchorX - Center x-coordinate.
      * @param right - Right coordinate.
      * @param top - Top coordinate.
-     * @param centerY - Center y-coordinate.
+     * @param anchorY - Center y-coordinate.
      * @param bottom - Bottom coordinate.
      */
-    constructor(left: number, centerX: number, right: number, top: number, centerY: number, bottom: number);
+    constructor(left: number, anchorX: number, right: number, top: number, anchorY: number, bottom: number);
     /**
      * Create rect from basic left, top, width and height arguments.
      *
@@ -475,7 +736,7 @@ declare class DivRect {
      */
     static create(left: number, top: number, width: number, height: number): DivRect;
     /**
-     * Create rect from centerX, centerY, width, height arguments.
+     * Create rect from anchorX, anchorY, width, height arguments.
      *
      * @param centerX - Center x-coordinate.
      * @param centerY - Center y-coordinate.
@@ -494,6 +755,14 @@ declare class DivRect {
      * @returns - DivRect.
      */
     static createSections(leftw: number, rightw: number, toph: number, bottomh: number): DivRect;
+    /** @deprecated - Renamed to anchorX. */
+    get centerX(): number;
+    /** @deprecated - Renamed to anchorX. */
+    set centerX(x: number);
+    /** @deprecated - Renamed to anchorY. */
+    get centerY(): number;
+    /** @deprecated - Renamed to anchorY. */
+    set centerY(y: number);
     /**
      * Width getter.
      */
@@ -556,7 +825,7 @@ declare class DivRect {
      */
     equals(other: DivRect): boolean;
     /**
-     * Check if edges of given rects are equal, ignoring centerX and centerY.
+     * Check if edges of given rects are equal, ignoring anchorX and anchorY.
      *
      * @param a - DivRect a.
      * @param b - DivRect b.
@@ -564,12 +833,14 @@ declare class DivRect {
      */
     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.
+     * Check if edges of this Rect equals with given Rect, ignoring anchorX and anchorY.
      *
      * @param other - The other DivRect.
      * @returns - True/false.
      */
     equalsEdges(other: DivRect): boolean;
+    /** @deprecated - Use `DivRect.equalsEdges()` instead. */
+    static equalsFrame(a: DivRect | null | undefined, b: DivRect | null | undefined): boolean;
     /**
      * Created duplicate of this Rect.
      *
@@ -621,7 +892,7 @@ declare class DivRect {
      */
     clipCopy(clipRect: DivRect): DivRect;
     /**
-     * Scale Rect. Anchor pos is (centerX, centerY). Modifies this Rect.
+     * Scale Rect. Anchor pos is (anchorX, anchorY). Modifies this Rect.
      *
      * @param scaleX - Scale x-amount.
      * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
@@ -629,7 +900,7 @@ declare class DivRect {
      */
     scaleInPlace(scaleX: number, scaleY?: number): DivRect;
     /**
-     * Scale Rect. Anchor pos is (centerX, centerY). Immutable, returns modified copy.
+     * Scale Rect. Anchor pos is (anchorX, anchorY). Immutable, returns modified copy.
      *
      * @param scaleX - Scale x-amount.
      * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
@@ -644,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;
@@ -681,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;
@@ -693,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;
@@ -712,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;
@@ -725,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;
@@ -764,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;
@@ -777,9 +1053,13 @@ 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;
 }
 
+/**
+ * A Map implementation mapping a single key to a value.
+ */
 declare class Map1<KEY1, VALUE> implements KVComponent<[KEY1], VALUE> {
     private map1;
     constructor();
@@ -805,7 +1085,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;
@@ -820,6 +1100,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();
@@ -846,7 +1129,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;
@@ -861,6 +1144,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();
@@ -888,7 +1174,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;
@@ -903,6 +1189,9 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2,
     toString(): 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[]>);
@@ -919,10 +1208,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
@@ -932,7 +1225,7 @@ declare function asMulti<K extends any[], VALUE>(base: KVComponent<K, VALUE[]>):
 /**
  * Vec2 class.
  *
- * @deprecated - Use Vec instead, has more functionality.
+ * @deprecated - Use {@link Vec} instead.
  */
 declare class Vec2 {
     readonly x: number;
@@ -946,6 +1239,8 @@ declare class Vec2 {
 }
 
 /**
+ * @deprecated - Use {@link SignedIndexArray} or {@link IndexArray} instead, they have way more functions.
+ *
  * A cache-like structure optimized for small-range integer keys, including negatives.
  *
  * Internally implemented using two sparse arrays: one for non-negative keys,
@@ -963,8 +1258,6 @@ declare class Vec2 {
  * 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;
@@ -977,4 +1270,4 @@ declare class SmallIntCache<VALUE> {
     clear(): void;
 }
 
-export { Assert, Cookies, Device, DivRect, 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, device as Device, DivRect, Guard, IndexArray, type KVComponent, LRUCache, Map1, Map2, Map3, MultiContainer, SignedIndexArray, SmallIntCache, Stack, index as Utils, Vec, Vec2, asMulti };