@tspro/ts-utils-lib 1.16.0 → 1.18.0

package/dist/index.d.ts

@@ -1,8 +1,207 @@
+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 };
+}
+
+declare function setExpireDays(days: number): void;
+declare function isConsentPending(): boolean;
+declare function accept(): void;
+declare function decline(): void;
+declare function save<T extends string | number | boolean>(name: string, value: T): T;
+declare function read(name: string, defaultValue: string): string;
+declare function readInt(name: string, defaultValue: number): number;
+declare function readBool(name: string, defaultValue: boolean): boolean;
+declare function erase(name: string): void;
+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 };
+}
+
+declare const DPI: number;
+declare const PxPerMm: number;
+declare const ScrollbarWidth: number;
+declare const FontSize: number;
+declare const IsTouchDevice: boolean;
+declare const IsMobileDevice: boolean;
+declare const HostAddress: string;
+declare function pxToMm(px: number): number;
+declare function mmToPx(mm: number): number;
+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 +216,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,57 +229,83 @@ 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>;
@@ -91,20 +320,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 +382,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,57 +535,14 @@ 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 };
 }
 
 declare class Stack<T> {
@@ -384,21 +555,282 @@ 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 dim(): number;
+    get length(): number;
+    magnitude(): 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;
+    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(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    [Symbol.iterator](): ArrayIterator<number>;
+    toString(): string;
+}
+
+/**
+ * DivRect class, left, top, right, bottom rectangle divided into four sections by anchorX, anchorY.
+ */
+declare class DivRect {
+    left: number;
+    anchorX: number;
+    right: number;
+    top: number;
+    anchorY: number;
+    bottom: number;
+    /**
+     * Create rectangle with all zero values.
+     */
+    constructor();
+    /**
+     * Create rectangle with left, right, top, bottom.
+     * Properties anchorX and anchorY 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 anchorX - Center x-coordinate.
+     * @param right - Right coordinate.
+     * @param top - Top coordinate.
+     * @param anchorY - Center y-coordinate.
+     * @param bottom - Bottom coordinate.
+     */
+    constructor(left: number, anchorX: number, right: number, top: number, anchorY: 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 anchorX, anchorY, width, height arguments.
+     *
+     * @param centerX - Center x-coordinate.
+     * @param centerY - Center y-coordinate.
+     * @param width - Width.
+     * @param height - Height.
+     * @returns - DivRect.
+     */
+    static createCentered(centerX: 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;
+    /** @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.
+     */
+    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 anchorX and anchorY.
+     *
+     * @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 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.
+     *
+     * @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 (anchorX, anchorY). Modifies this Rect.
+     *
+     * @param scaleX - Scale x-amount.
+     * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
+     * @returns This DivRect instance.
+     */
+    scaleInPlace(scaleX: number, scaleY?: number): DivRect;
+    /**
+     * Scale Rect. Anchor pos is (anchorX, anchorY). Immutable, returns modified copy.
+     *
+     * @param scaleX - Scale x-amount.
+     * @param scaleY - Scale y-amount. If undefined then scale x-amount is used.
+     * @returns Scaled copy of this DivRect.
+     */
+    scaleCopy(scaleX: 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,150 +850,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<EL>;
+    kvValues(): IterableIterator<VALUE>;
     kvKeys(): IterableIterator<K>;
-    kvEntries(): IterableIterator<[K, EL]>;
+    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]>);
+    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<EL>;
-    entries(): IterableIterator<[number, EL]>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[number, VALUE]>;
     indicesArray(): number[];
-    valuesArray(): EL[];
-    entriesArray(): [number, EL][];
+    valuesArray(): VALUE[];
+    entriesArray(): [number, VALUE][];
     kvKeys(): IterableIterator<[number]>;
-    kvValues(): IterableIterator<EL>;
-    kvEntries(): IterableIterator<[[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;
+    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<EL>;
-    entries(): IterableIterator<[number, EL]>;
+    values(): IterableIterator<VALUE>;
+    entries(): IterableIterator<[number, VALUE]>;
     indicesArray(): number[];
-    valuesArray(): EL[];
-    entriesArray(): [number, EL][];
+    valuesArray(): VALUE[];
+    entriesArray(): [number, VALUE][];
     kvKeys(): IterableIterator<[number]>;
-    kvValues(): IterableIterator<EL>;
-    kvEntries(): IterableIterator<[[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;
+    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;
 }
 
@@ -595,13 +996,16 @@ declare class Map1<KEY1, VALUE> implements KVComponent<[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();
@@ -633,13 +1037,16 @@ declare class Map2<KEY1, KEY2, VALUE> implements KVComponent<[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();
@@ -672,7 +1079,9 @@ declare class Map3<KEY1, KEY2, KEY3, VALUE> implements KVComponent<[KEY1, KEY2,
     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>;
@@ -704,6 +1113,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 {@link Vec} instead.
+ */
+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;
+}
+
+/**
+ * @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,
+ * 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'
+ * ```
+ */
+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 { 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 };