@tspro/ts-utils-lib 1.20.0 → 2.0.0

package/dist/index.d.mts

@@ -6,193 +6,108 @@ 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 };
+  export { type index$8_EnumKey as EnumKey, type index$8_EnumObject as EnumObject, type index$8_EnumValue as EnumValue, 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 };
 }
 
 type ErrorConstructor = new (msg: string) => Error;
 declare function setErrorClass(errorClass?: ErrorConstructor): void;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function interrupt(msg?: string): never;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function assertEnum<E extends EnumObject>(enumVal: unknown, enumObj: E, name?: string): asserts enumVal is E[keyof E];
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function int(value: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function eq<T>(value1: T, value2: T, msg?: string): T;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function int_eq(value: unknown, compareTo: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function int_lt(value: unknown, compareTo: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function int_lte(value: unknown, compareTo: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function int_gt(value: unknown, compareTo: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function int_gte(value: unknown, compareTo: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function int_between(value: unknown, min: unknown, max: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function int_between_exclusive(value: unknown, min: unknown, max: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function odd(value: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function even(value: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function in_group<T>(value: T, group: ReadonlyArray<T>, msg?: string): T;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function finite(value: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function array_id<T>(array: Readonly<T[]>, index: unknown, msg?: string): number;
-/**
- * @deprecated - Wil be removed in v2.0.0.
- * @private
- */
-declare function array_elem<T>(array: Readonly<T[]>, index: number, msg?: string): T;
 declare function assert<T>(condition: T, msg?: string): void;
-declare function require<T>(value: T | null | undefined, msg?: string): T;
-declare function requireDefined<T>(value: T | undefined, msg?: string): T;
+declare function require<T>(val: T | null | undefined, msg?: string): T;
+declare function requireDefined<T>(val: T | undefined, msg?: string): T;
+declare function requireElement<E>(index: unknown, array: ReadonlyArray<E>, msg?: string): E;
 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;
-declare function isNotThrowing$1(throwTestFn: () => void, msg?: string): true;
+declare function isStrictEqual$1<T = any>(val1: T, val2: unknown, msg?: string): T;
+declare function isDeepEqual$1<T = any>(val1: T, val2: unknown, msg?: string): T;
+declare function isUndefined$1(val: unknown, msg?: string): undefined;
+declare function isNull$1(val: unknown, msg?: string): null;
+declare function isNullish$1(val: unknown, msg?: string): null | undefined;
+declare function isDefined$1<T>(val: T, msg?: string): Exclude<T, undefined>;
+declare function isNonNull$1<T>(val: T, msg?: string): Exclude<T, null>;
+declare function isObject$1(val: unknown, msg?: string): Record<string, unknown>;
+declare function isEmptyObject$1(val: unknown, msg?: string): Record<string, unknown>;
+declare function isPlainObject$1(val: unknown, msg?: string): Record<string, unknown>;
+declare function isObjectOrUndefined$1(val: unknown, msg?: string): Record<string, unknown> | undefined;
+declare function isTypedObject$1<T extends object>(val: unknown, keys: (keyof T)[], msg?: string): HasProps<T>;
+declare function isArray$1<T>(val: unknown, msg?: string): T[];
+declare function isArrayOrUndefined$1(val: unknown, msg?: string): val is unknown[] | undefined;
+declare function isEmptyArray$1<T = any>(val: T[], msg?: string): asserts val is T[];
+declare function isNonEmptyArray$1<T = any>(val: T[], msg?: string): asserts val is T[];
+declare function isEmptyArrayOrUndefined$1<T = any>(val: unknown, msg?: string): asserts val is T[] | undefined;
+declare function isNonEmptyArrayOrUndefined$1<T = any>(val: unknown, msg?: string): asserts val is T[] | undefined;
+declare function isString$1(val: unknown, msg?: string): string;
+declare function isEmptyString$1(val: unknown, msg?: string): "";
+declare function isNonEmptyString$1(val: unknown, msg?: string): string;
+declare function isStringOrUndefined$1(val: unknown, msg?: string): string | undefined;
+declare function isEmptyStringOrUndefined$1(val: unknown, msg?: string): "" | undefined;
+declare function isNonEmptyStringOrUndefined$1(val: unknown, msg?: string): string | undefined;
+declare function isBoolean$1(val: unknown, msg?: string): boolean;
+declare function isBooleanOrUndefined$1(val: unknown, msg?: string): boolean | undefined;
+declare function isTrue$1(val: unknown, msg?: string): true;
+declare function isTrueOrUndefined$1(val: unknown, msg?: string): true | undefined;
+declare function isFalse$1(val: unknown, msg?: string): false;
+declare function isFalseOrUndefined$1(val: unknown, msg?: string): false | undefined;
+declare function isFunction$1<T extends (...args: any[]) => any>(val: unknown, msg?: string): T;
+declare function isFunctionOrUndefined$1<T extends (...args: any[]) => any>(val: unknown, msg?: string): T | undefined;
+declare function isEnumValue$1<E extends EnumObject>(val: unknown, enumObject: E, msg?: string): E[keyof E];
+declare function isEnumValueOrUndefined$1<E extends EnumObject>(val: unknown, enumObject: E, msg?: string): E[keyof E] | undefined;
+declare function isNumericString$1(val: unknown, msg?: string): string;
+declare function isBigInt$1(val: unknown, msg?: string): BigInt;
+declare function isNumber$1(val: unknown, msg?: string): number;
+declare function isNumberOrUndefined$1(val: unknown, msg?: string): number | undefined;
+declare function isFinite$1(val: unknown, msg?: string): number;
+declare function isFloat$1(val: unknown, msg?: string): number;
+declare function isInteger$1(val: unknown, msg?: string): number;
+declare function isSafeInteger$1(val: unknown, msg?: string): number;
+declare function isIntegerOrUndefined$1(val: unknown, msg?: string): number | undefined;
+declare function isIntegerEq$1(val: unknown, ref: unknown, msg?: string): number;
+declare function isIntegerGt$1(val: unknown, ref: unknown, msg?: string): number;
+declare function isIntegerGte$1(val: unknown, ref: unknown, msg?: string): number;
+declare function isIntegerLt$1(val: unknown, ref: unknown, msg?: string): number;
+declare function isIntegerLte$1(val: unknown, ref: unknown, msg?: string): number;
+declare function isIntegerBetween$1(val: unknown, min: unknown, max: unknown, msg?: string): number;
+declare function isIntegerBetweenExclusive$1(val: unknown, min: unknown, max: unknown, msg?: string): number;
+declare function isNumberBetween$1(val: unknown, min: unknown, max: unknown, msg?: string): number;
+declare function isNumberBetweenExclusive$1(val: unknown, min: unknown, max: unknown, msg?: string): number;
+declare function isNaNValue$1(val: unknown, msg?: string): number;
+declare function isInfinity$1(val: unknown, msg?: string): number;
+declare function isPosInfinity$1(val: unknown, msg?: string): number;
+declare function isNegInfinity$1(val: unknown, msg?: string): number;
+declare function isPos$1(val: unknown, msg?: string): number;
+declare function isNeg$1(val: unknown, msg?: string): number;
+declare function isNonPos$1(val: unknown, msg?: string): number;
+declare function isNonNeg$1(val: unknown, msg?: string): number;
+declare function isZero$1(val: unknown, msg?: string): number;
+declare function isPosZero$1(val: unknown, msg?: string): number;
+declare function isNegZero$1(val: unknown, msg?: string): number;
+declare function isOdd$1(val: unknown, msg?: string): number;
+declare function isEven$1(val: unknown, msg?: string): number;
+declare function isMultipleOf$1(val: unknown, base: unknown, msg?: string): number;
+declare function isPowerOfTwo$1(val: unknown, msg?: string): number;
+declare function isIncluded$1<T>(val: unknown, arr: ReadonlyArray<T> | Set<T>, msg?: string): T;
+declare function isIndex$1<T>(index: unknown, msg?: string): number;
+declare function isIndex$1<T>(index: unknown, arr: ReadonlyArray<T>, msg?: string): number;
+declare function doesThrow$1(throwTestFn: () => void, msg?: string): true;
+declare function doesNotThrow$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_requireElement: typeof requireElement;
 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, isNotThrowing$1 as isNotThrowing, isNull$1 as isNull, isNullish$1 as isNullish, isNumber$1 as isNumber, isNumberBetween$1 as isNumberBetween, isNumberBetweenExclusive$1 as isNumberBetweenExclusive, isNumberOrUndefined$1 as isNumberOrUndefined, isObject$1 as isObject, isObjectOrUndefined$1 as isObjectOrUndefined, isOddNumber$1 as isOddNumber, isPosInfinity$1 as isPosInfinity, isString$1 as isString, isStringOrUndefined$1 as isStringOrUndefined, isThrowing$1 as isThrowing, isTrue$1 as isTrue, isTrueOrUndefined$1 as isTrueOrUndefined, isTypedObject$1 as isTypedObject, isUndefined$1 as isUndefined, index$7_odd as odd, index$7_require as require, index$7_requireDefined as requireDefined, index$7_setErrorClass as setErrorClass };
+  export { type index$7_ErrorConstructor as ErrorConstructor, index$7_assert as assert, doesNotThrow$1 as doesNotThrow, doesThrow$1 as doesThrow, index$7_fail as fail, isArray$1 as isArray, isArrayOrUndefined$1 as isArrayOrUndefined, isBigInt$1 as isBigInt, isBoolean$1 as isBoolean, isBooleanOrUndefined$1 as isBooleanOrUndefined, isDeepEqual$1 as isDeepEqual, isDefined$1 as isDefined, isEmptyArray$1 as isEmptyArray, isEmptyArrayOrUndefined$1 as isEmptyArrayOrUndefined, isEmptyObject$1 as isEmptyObject, isEmptyString$1 as isEmptyString, isEmptyStringOrUndefined$1 as isEmptyStringOrUndefined, isEnumValue$1 as isEnumValue, isEnumValueOrUndefined$1 as isEnumValueOrUndefined, isEven$1 as isEven, isFalse$1 as isFalse, isFalseOrUndefined$1 as isFalseOrUndefined, isFinite$1 as isFinite, isFloat$1 as isFloat, isFunction$1 as isFunction, isFunctionOrUndefined$1 as isFunctionOrUndefined, isIncluded$1 as isIncluded, isIndex$1 as isIndex, 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, isMultipleOf$1 as isMultipleOf, isNaNValue$1 as isNaNValue, isNeg$1 as isNeg, isNegInfinity$1 as isNegInfinity, isNegZero$1 as isNegZero, isNonEmptyArray$1 as isNonEmptyArray, isNonEmptyArrayOrUndefined$1 as isNonEmptyArrayOrUndefined, isNonEmptyString$1 as isNonEmptyString, isNonEmptyStringOrUndefined$1 as isNonEmptyStringOrUndefined, isNonNeg$1 as isNonNeg, isNonNull$1 as isNonNull, isNonPos$1 as isNonPos, isNull$1 as isNull, isNullish$1 as isNullish, isNumber$1 as isNumber, isNumberBetween$1 as isNumberBetween, isNumberBetweenExclusive$1 as isNumberBetweenExclusive, isNumberOrUndefined$1 as isNumberOrUndefined, isNumericString$1 as isNumericString, isObject$1 as isObject, isObjectOrUndefined$1 as isObjectOrUndefined, isOdd$1 as isOdd, isPlainObject$1 as isPlainObject, isPos$1 as isPos, isPosInfinity$1 as isPosInfinity, isPosZero$1 as isPosZero, isPowerOfTwo$1 as isPowerOfTwo, isSafeInteger$1 as isSafeInteger, isStrictEqual$1 as isStrictEqual, isString$1 as isString, isStringOrUndefined$1 as isStringOrUndefined, isTrue$1 as isTrue, isTrueOrUndefined$1 as isTrueOrUndefined, isTypedObject$1 as isTypedObject, isUndefined$1 as isUndefined, isZero$1 as isZero, index$7_require as require, index$7_requireDefined as requireDefined, index$7_requireElement as requireElement, index$7_setErrorClass as setErrorClass };
 }
 
 /**
@@ -314,131 +229,162 @@ 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[];
-declare function isNonEmptyArray<T>(a: T[] | unknown): a is T[];
-declare function isEmptyArrayOrUndefined<T>(a: T[] | unknown): a is T[] | undefined;
-declare function isNonEmptyArrayOrUndefined<T>(a: T[] | unknown): a is T[] | undefined;
-declare function isString(value: unknown): value is string;
-declare function isEmptyString(value: unknown): value is "";
-declare function isNonEmptyString(value: unknown): value is string;
-declare function isStringOrUndefined(value: unknown): value is string | undefined;
-declare function isEmptyStringOrUndefined(value: unknown): value is "" | undefined;
-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];
-declare function isEnumValueOrUndefined<E extends Record<string, string | number>>(value: unknown, enumObj: E, name?: string): value is E[keyof E] | undefined;
-declare function isNumber(value: unknown): value is number;
-declare function isNumberOrUndefined(value: unknown): value is number | undefined;
-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: 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 isNotThrowing(throwTestFn: () => void): boolean;
+declare function isStrictEqual(val1: unknown, val2: unknown): boolean;
+declare function isDeepEqual(val1: unknown, val2: unknown): boolean;
+declare function isUndefined(val: unknown): val is undefined;
+declare function isNull(val: unknown): val is null;
+declare function isNullish(val: unknown): val is null | undefined;
+declare function isDefined<T>(val: T): val is Exclude<T, undefined>;
+declare function isNonNull<T>(val: T): val is Exclude<T, null>;
+declare function isObject(val: unknown): val is Record<string, unknown>;
+declare function isEmptyObject(val: unknown): val is Record<string, never>;
+declare function isObjectOrUndefined(val: unknown): val is Record<string, unknown> | undefined;
+declare function isPlainObject(val: unknown): val is Record<string, unknown>;
+declare function isTypedObject<T extends object>(val: unknown, keys: (keyof T)[]): val is HasProps<T>;
+declare function isArray<T>(arr: T[] | unknown): arr is T[];
+declare function isArrayOrUndefined(arr: unknown): arr is unknown[] | undefined;
+declare function isEmptyArray<T>(arr: T[] | unknown): arr is T[] & {
+    length: 0;
+};
+declare function isNonEmptyArray<T>(arr: T[] | unknown): arr is T[];
+declare function isEmptyArrayOrUndefined<T>(arr: T[] | unknown): arr is T[] | undefined;
+declare function isNonEmptyArrayOrUndefined<T>(arr: T[] | unknown): arr is T[] | undefined;
+declare function isString(val: unknown): val is string;
+declare function isEmptyString(val: unknown): val is "";
+declare function isNonEmptyString(val: unknown): val is string;
+declare function isStringOrUndefined(val: unknown): val is string | undefined;
+declare function isEmptyStringOrUndefined(val: unknown): val is "" | undefined;
+declare function isNonEmptyStringOrUndefined(val: unknown): val is string | undefined;
+declare function isBoolean(val: unknown): val is boolean;
+declare function isBooleanOrUndefined(val: unknown): val is boolean | undefined;
+declare function isTrue(val: unknown): val is true;
+declare function isTrueOrUndefined(val: unknown): val is true | undefined;
+declare function isFalse(val: unknown): val is false;
+declare function isFalseOrUndefined(val: unknown): val is false | undefined;
+declare function isFunction<T extends (...args: any[]) => any>(val: unknown): val is T;
+declare function isFunctionOrUndefined(val: unknown): val is ((...args: any[]) => any) | undefined;
+declare function isEnumValue<E extends EnumObject>(val: unknown, enumObj: E): val is E[keyof E];
+declare function isEnumValueOrUndefined<E extends EnumObject>(val: unknown, enumObj: E): val is E[keyof E] | undefined;
+declare function isNumericString(val: unknown): val is string;
+declare function isBigInt(val: unknown): val is BigInt;
+declare function isNumber(val: unknown): val is number;
+declare function isNumberOrUndefined(val: unknown): val is number | undefined;
+declare function isFinite(val: unknown): val is number;
+declare function isFloat(val: unknown): val is number;
+declare function isInteger(val: unknown): val is number;
+declare function isSafeInteger(val: unknown): val is number;
+declare function isIntegerOrUndefined(val: unknown): val is number | undefined;
+declare function isIntegerEq(val: unknown, ref: unknown): val is number;
+declare function isIntegerGt(val: unknown, ref: unknown): val is number;
+declare function isIntegerGte(val: unknown, ref: unknown): val is number;
+declare function isIntegerLt(val: unknown, ref: unknown): val is number;
+declare function isIntegerLte(val: unknown, ref: unknown): val is number;
+declare function isIntegerBetween(val: unknown, min: unknown, max: unknown): val is number;
+declare function isIntegerBetweenExclusive(val: unknown, min: unknown, max: unknown): val is number;
+declare function isNumberBetween(val: unknown, min: unknown, max: unknown): val is number;
+declare function isNumberBetweenExclusive(val: unknown, min: unknown, max: unknown): val is number;
+declare function isNaNValue(val: unknown): val is number;
+declare function isInfinity(val: unknown): val is number;
+declare function isPosInfinity(val: unknown): val is number;
+declare function isNegInfinity(val: unknown): val is number;
+declare function isPos(val: unknown): val is number;
+declare function isNeg(val: unknown): val is number;
+declare function isNonPos(val: unknown): val is number;
+declare function isNonNeg(val: unknown): val is number;
+declare function isZero(val: unknown): val is number;
+declare function isPosZero(val: unknown): val is number;
+declare function isNegZero(val: unknown): val is number;
+declare function isOdd(val: unknown): val is number;
+declare function isEven(val: unknown): val is number;
+declare function isMultipleOf(val: unknown, base: unknown): val is number;
+declare function isPowerOfTwo(val: unknown): val is number;
+declare function isIncluded<T>(val: unknown, container: ReadonlyArray<T> | Set<T>): val is T;
+declare function isIndex<T>(index: unknown, array?: ReadonlyArray<T>): index is number;
+declare function doesThrow(throwTestFn: () => void): boolean;
+declare function doesNotThrow(throwTestFn: () => void): boolean;
 declare function tryOr<TRY_RVAL, OR_RVAL>(tryFn: () => TRY_RVAL, orVal: OR_RVAL | (() => OR_RVAL)): TRY_RVAL | OR_RVAL;
 
-type Guard_HasProps<T extends object> = HasProps<T>;
-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_isNotThrowing: typeof isNotThrowing;
-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_isNotThrowing as isNotThrowing, Guard_isNull as isNull, Guard_isNullish as isNullish, Guard_isNumber as isNumber, Guard_isNumberBetween as isNumberBetween, Guard_isNumberBetweenExclusive as isNumberBetweenExclusive, Guard_isNumberOrUndefined as isNumberOrUndefined, Guard_isObject as isObject, Guard_isObjectOrUndefined as isObjectOrUndefined, Guard_isOddNumber as isOddNumber, Guard_isPosInfinity as isPosInfinity, Guard_isString as isString, Guard_isStringOrUndefined as isStringOrUndefined, Guard_isThrowing as isThrowing, Guard_isTrue as isTrue, Guard_isTrueOrUndefined as isTrueOrUndefined, Guard_isTypedObject as isTypedObject, Guard_isUndefined as isUndefined, Guard_tryOr as tryOr };
+type index$6_HasProps<T extends object> = HasProps<T>;
+declare const index$6_doesNotThrow: typeof doesNotThrow;
+declare const index$6_doesThrow: typeof doesThrow;
+declare const index$6_isArray: typeof isArray;
+declare const index$6_isArrayOrUndefined: typeof isArrayOrUndefined;
+declare const index$6_isBigInt: typeof isBigInt;
+declare const index$6_isBoolean: typeof isBoolean;
+declare const index$6_isBooleanOrUndefined: typeof isBooleanOrUndefined;
+declare const index$6_isDeepEqual: typeof isDeepEqual;
+declare const index$6_isDefined: typeof isDefined;
+declare const index$6_isEmptyArray: typeof isEmptyArray;
+declare const index$6_isEmptyArrayOrUndefined: typeof isEmptyArrayOrUndefined;
+declare const index$6_isEmptyObject: typeof isEmptyObject;
+declare const index$6_isEmptyString: typeof isEmptyString;
+declare const index$6_isEmptyStringOrUndefined: typeof isEmptyStringOrUndefined;
+declare const index$6_isEnumValue: typeof isEnumValue;
+declare const index$6_isEnumValueOrUndefined: typeof isEnumValueOrUndefined;
+declare const index$6_isEven: typeof isEven;
+declare const index$6_isFalse: typeof isFalse;
+declare const index$6_isFalseOrUndefined: typeof isFalseOrUndefined;
+declare const index$6_isFinite: typeof isFinite;
+declare const index$6_isFloat: typeof isFloat;
+declare const index$6_isFunction: typeof isFunction;
+declare const index$6_isFunctionOrUndefined: typeof isFunctionOrUndefined;
+declare const index$6_isIncluded: typeof isIncluded;
+declare const index$6_isIndex: typeof isIndex;
+declare const index$6_isInfinity: typeof isInfinity;
+declare const index$6_isInteger: typeof isInteger;
+declare const index$6_isIntegerBetween: typeof isIntegerBetween;
+declare const index$6_isIntegerBetweenExclusive: typeof isIntegerBetweenExclusive;
+declare const index$6_isIntegerEq: typeof isIntegerEq;
+declare const index$6_isIntegerGt: typeof isIntegerGt;
+declare const index$6_isIntegerGte: typeof isIntegerGte;
+declare const index$6_isIntegerLt: typeof isIntegerLt;
+declare const index$6_isIntegerLte: typeof isIntegerLte;
+declare const index$6_isIntegerOrUndefined: typeof isIntegerOrUndefined;
+declare const index$6_isMultipleOf: typeof isMultipleOf;
+declare const index$6_isNaNValue: typeof isNaNValue;
+declare const index$6_isNeg: typeof isNeg;
+declare const index$6_isNegInfinity: typeof isNegInfinity;
+declare const index$6_isNegZero: typeof isNegZero;
+declare const index$6_isNonEmptyArray: typeof isNonEmptyArray;
+declare const index$6_isNonEmptyArrayOrUndefined: typeof isNonEmptyArrayOrUndefined;
+declare const index$6_isNonEmptyString: typeof isNonEmptyString;
+declare const index$6_isNonEmptyStringOrUndefined: typeof isNonEmptyStringOrUndefined;
+declare const index$6_isNonNeg: typeof isNonNeg;
+declare const index$6_isNonNull: typeof isNonNull;
+declare const index$6_isNonPos: typeof isNonPos;
+declare const index$6_isNull: typeof isNull;
+declare const index$6_isNullish: typeof isNullish;
+declare const index$6_isNumber: typeof isNumber;
+declare const index$6_isNumberBetween: typeof isNumberBetween;
+declare const index$6_isNumberBetweenExclusive: typeof isNumberBetweenExclusive;
+declare const index$6_isNumberOrUndefined: typeof isNumberOrUndefined;
+declare const index$6_isNumericString: typeof isNumericString;
+declare const index$6_isObject: typeof isObject;
+declare const index$6_isObjectOrUndefined: typeof isObjectOrUndefined;
+declare const index$6_isOdd: typeof isOdd;
+declare const index$6_isPlainObject: typeof isPlainObject;
+declare const index$6_isPos: typeof isPos;
+declare const index$6_isPosInfinity: typeof isPosInfinity;
+declare const index$6_isPosZero: typeof isPosZero;
+declare const index$6_isPowerOfTwo: typeof isPowerOfTwo;
+declare const index$6_isSafeInteger: typeof isSafeInteger;
+declare const index$6_isStrictEqual: typeof isStrictEqual;
+declare const index$6_isString: typeof isString;
+declare const index$6_isStringOrUndefined: typeof isStringOrUndefined;
+declare const index$6_isTrue: typeof isTrue;
+declare const index$6_isTrueOrUndefined: typeof isTrueOrUndefined;
+declare const index$6_isTypedObject: typeof isTypedObject;
+declare const index$6_isUndefined: typeof isUndefined;
+declare const index$6_isZero: typeof isZero;
+declare const index$6_tryOr: typeof tryOr;
+declare namespace index$6 {
+  export { type index$6_HasProps as HasProps, index$6_doesNotThrow as doesNotThrow, index$6_doesThrow as doesThrow, index$6_isArray as isArray, index$6_isArrayOrUndefined as isArrayOrUndefined, index$6_isBigInt as isBigInt, index$6_isBoolean as isBoolean, index$6_isBooleanOrUndefined as isBooleanOrUndefined, index$6_isDeepEqual as isDeepEqual, index$6_isDefined as isDefined, index$6_isEmptyArray as isEmptyArray, index$6_isEmptyArrayOrUndefined as isEmptyArrayOrUndefined, index$6_isEmptyObject as isEmptyObject, index$6_isEmptyString as isEmptyString, index$6_isEmptyStringOrUndefined as isEmptyStringOrUndefined, index$6_isEnumValue as isEnumValue, index$6_isEnumValueOrUndefined as isEnumValueOrUndefined, index$6_isEven as isEven, index$6_isFalse as isFalse, index$6_isFalseOrUndefined as isFalseOrUndefined, index$6_isFinite as isFinite, index$6_isFloat as isFloat, index$6_isFunction as isFunction, index$6_isFunctionOrUndefined as isFunctionOrUndefined, index$6_isIncluded as isIncluded, index$6_isIndex as isIndex, index$6_isInfinity as isInfinity, index$6_isInteger as isInteger, index$6_isIntegerBetween as isIntegerBetween, index$6_isIntegerBetweenExclusive as isIntegerBetweenExclusive, index$6_isIntegerEq as isIntegerEq, index$6_isIntegerGt as isIntegerGt, index$6_isIntegerGte as isIntegerGte, index$6_isIntegerLt as isIntegerLt, index$6_isIntegerLte as isIntegerLte, index$6_isIntegerOrUndefined as isIntegerOrUndefined, index$6_isMultipleOf as isMultipleOf, index$6_isNaNValue as isNaNValue, index$6_isNeg as isNeg, index$6_isNegInfinity as isNegInfinity, index$6_isNegZero as isNegZero, index$6_isNonEmptyArray as isNonEmptyArray, index$6_isNonEmptyArrayOrUndefined as isNonEmptyArrayOrUndefined, index$6_isNonEmptyString as isNonEmptyString, index$6_isNonEmptyStringOrUndefined as isNonEmptyStringOrUndefined, index$6_isNonNeg as isNonNeg, index$6_isNonNull as isNonNull, index$6_isNonPos as isNonPos, index$6_isNull as isNull, index$6_isNullish as isNullish, index$6_isNumber as isNumber, index$6_isNumberBetween as isNumberBetween, index$6_isNumberBetweenExclusive as isNumberBetweenExclusive, index$6_isNumberOrUndefined as isNumberOrUndefined, index$6_isNumericString as isNumericString, index$6_isObject as isObject, index$6_isObjectOrUndefined as isObjectOrUndefined, index$6_isOdd as isOdd, index$6_isPlainObject as isPlainObject, index$6_isPos as isPos, index$6_isPosInfinity as isPosInfinity, index$6_isPosZero as isPosZero, index$6_isPowerOfTwo as isPowerOfTwo, index$6_isSafeInteger as isSafeInteger, index$6_isStrictEqual as isStrictEqual, index$6_isString as isString, index$6_isStringOrUndefined as isStringOrUndefined, index$6_isTrue as isTrue, index$6_isTrueOrUndefined as isTrueOrUndefined, index$6_isTypedObject as isTypedObject, index$6_isUndefined as isUndefined, index$6_isZero as isZero, index$6_tryOr as tryOr };
 }
 
-declare function toArray<T>(a: T | T[]): Array<T>;
-declare function duplicate<T>(a: T[] | undefined): T[] | undefined;
-declare function removeDuplicates<T>(arr: T[], compareFn?: (a: T, b: T) => boolean): T[];
-/**
- * @deprecated - Use {@link removeDuplicates} with compareFn instead.  Will be removed in v2.0.0.
- * @private
- */
-declare function removeDuplicatesCmp<T>(arr: ReadonlyArray<T>, compareFn: (t1: T, t2: T) => boolean): T[];
+declare function toArray<T>(a: T | T[]): T[];
+declare function duplicate<T>(a: ReadonlyArray<T> | undefined): T[];
+declare function removeDuplicates<T>(arr: ReadonlyArray<T>, compareFn?: (a: T, b: T) => boolean): Array<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[];
@@ -447,20 +393,19 @@ 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$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 };
+declare const index$5_arrayContains: typeof arrayContains;
+declare const index$5_chunckArray: typeof chunckArray;
+declare const index$5_duplicate: typeof duplicate;
+declare const index$5_fillArray: typeof fillArray;
+declare const index$5_getRangeArray: typeof getRangeArray;
+declare const index$5_getSequenceArray: typeof getSequenceArray;
+declare const index$5_isArray: typeof isArray;
+declare const index$5_mapRangeArray: typeof mapRangeArray;
+declare const index$5_mapSequenceArray: typeof mapSequenceArray;
+declare const index$5_removeDuplicates: typeof removeDuplicates;
+declare const index$5_toArray: typeof toArray;
+declare namespace index$5 {
+  export { index$5_arrayContains as arrayContains, index$5_chunckArray as chunckArray, index$5_duplicate as duplicate, index$5_fillArray as fillArray, index$5_getRangeArray as getRangeArray, index$5_getSequenceArray as getSequenceArray, index$5_isArray as isArray, index$5_mapRangeArray as mapRangeArray, index$5_mapSequenceArray as mapSequenceArray, index$5_removeDuplicates as removeDuplicates, index$5_toArray as toArray };
 }
 
 interface CSSProperties {
@@ -509,35 +454,28 @@ declare function getDimension(style?: CSSProperties): {
 declare function styleLayoutChanged(style1?: CSSProperties, style2?: CSSProperties): boolean;
 declare function getCanvasTextWidth(text: string, font: string): number;
 
-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_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[];
-
-declare const index$4_getMapKeys: typeof getMapKeys;
+type index$4_CSSProperties = CSSProperties;
+declare const index$4_addClass: typeof addClass;
+declare const index$4_appendTo: typeof appendTo;
+declare const index$4_getButton: typeof getButton;
+declare const index$4_getCanvas: typeof getCanvas;
+declare const index$4_getCanvasTextWidth: typeof getCanvasTextWidth;
+declare const index$4_getDimension: typeof getDimension;
+declare const index$4_getHeight: typeof getHeight;
+declare const index$4_getOffset: typeof getOffset;
+declare const index$4_getPadding: typeof getPadding;
+declare const index$4_getWidth: typeof getWidth;
+declare const index$4_hasClass: typeof hasClass;
+declare const index$4_removeClass: typeof removeClass;
+declare const index$4_removeFromParent: typeof removeFromParent;
+declare const index$4_setHeight: typeof setHeight;
+declare const index$4_setOffset: typeof setOffset;
+declare const index$4_setRect: typeof setRect;
+declare const index$4_setVisibility: typeof setVisibility;
+declare const index$4_setWidth: typeof setWidth;
+declare const index$4_styleLayoutChanged: typeof styleLayoutChanged;
 declare namespace index$4 {
-  export { index$4_getMapKeys as getMapKeys };
+  export { type index$4_CSSProperties as CSSProperties, index$4_addClass as addClass, index$4_appendTo as appendTo, index$4_getButton as getButton, index$4_getCanvas as getCanvas, index$4_getCanvasTextWidth as getCanvasTextWidth, index$4_getDimension as getDimension, index$4_getHeight as getHeight, index$4_getOffset as getOffset, index$4_getPadding as getPadding, index$4_getWidth as getWidth, index$4_hasClass as hasClass, index$4_removeClass as removeClass, index$4_removeFromParent as removeFromParent, index$4_setHeight as setHeight, index$4_setOffset as setOffset, index$4_setRect as setRect, index$4_setVisibility as setVisibility, index$4_setWidth as setWidth, index$4_styleLayoutChanged as styleLayoutChanged };
 }
 
 declare function linearToDecibels(linearVolume: number): number;
@@ -580,11 +518,13 @@ declare namespace index$3 {
 }
 
 /**
- * <pre>
- * Usage:
- *   hasProperties(obj, ["a", "b"]);          // Gives type Record<string, unknown>
- *   hasProperties(obj, ["a", "b"] as const); // Gives type Record<"a" | "b", unknown>
- * </pre>
+ * ```ts
+ * // Gives type Record<string, unknown>
+ * hasProperties(obj, ["a", "b"]);
+ *
+ * // Gives type Record<"a" | "b", unknown>
+ * hasProperties(obj, ["a", "b"] as const);
+ * ```
  */
 declare function hasProperties<T extends readonly string[]>(obj: unknown, props: T | string[]): obj is Record<T[number], unknown>;
 declare function deepEqual<T>(a: T, b: T): boolean;
@@ -664,15 +604,8 @@ 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_stringify as stringify, index$1_toCharArray as toCharArray };
 }
 
-/**
- * @deprecated Use {@link Guard} instead. Will be removed in v2.0.0.
- * @private
- */
-declare const Is: typeof Guard;
-
-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 };
+  export { index$5 as Arr, index$4 as Dom, index$8 as Enum, index$3 as Math, index$2 as Obj, index$1 as Str };
 }
 
 type EqualityFn<V> = (a: V, b: V) => boolean;
@@ -773,9 +706,65 @@ declare class Vec extends BaseContainer {
 }
 
 /**
- * DivRect class is a rectangle (left, top, right, bottom) with an anchor point (anchorX, anchorY).
+ * An immutable 2D rectangle defined by its top-left corner (x, y) and size (width, height).
+ * Provides geometric utilities like intersection, containment, scaling, etc.
+ */
+declare class Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor();
+    constructor(width: number, height: number);
+    constructor(x: number, y: number, width: number, height: number);
+    set(): Rect;
+    set(width: number, height: number): Rect;
+    set(x: number, y: number, width: number, height: number): Rect;
+    static fromPoints(p1: {
+        x: number;
+        y: number;
+    }, p2: {
+        x: number;
+        y: number;
+    }): Rect;
+    static fromCenter(cx: number, cy: number, width: number, height: number): Rect;
+    get left(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    get centerX(): number;
+    get centerY(): number;
+    get center(): {
+        x: number;
+        y: number;
+    };
+    get area(): number;
+    get isEmpty(): boolean;
+    containsPoint(px: number, py: number): boolean;
+    containsRect(other: Rect): boolean;
+    intersects(other: Rect): boolean;
+    intersectionCopy(other: Rect): Rect;
+    unionCopy(other: Rect): Rect;
+    insetCopy(dx: number, dy: number): Rect;
+    inflateCopy(dx: number, dy: number): Rect;
+    offsetInPlace(dx: number, dy: number): Rect;
+    offsetCopy(dx: number, dy: number): Rect;
+    scaleInPlace(scaleX: number, scaleY?: number): Rect;
+    scaleCopy(scaleX: number, scaleY?: number): Rect;
+    roundCopy(): Rect;
+    floorCopy(): Rect;
+    ceilCopy(): Rect;
+    expandCopy(px: number, py: number): Rect;
+    equals(other: Rect): boolean;
+    clone(): Rect;
+    toString(): string;
+    toAnchoredRect(): AnchoredRect;
+}
+
+/**
+ * A mutable AnchoredRect class is a rectangle (left, top, right, bottom) with an anchor point (anchorX, anchorY).
  */
-declare class DivRect {
+declare class AnchoredRect {
     left: number;
     anchorX: number;
     right: number;
@@ -807,6 +796,31 @@ declare class DivRect {
      * @param bottom - Bottom coordinate.
      */
     constructor(left: number, anchorX: number, right: number, top: number, anchorY: number, bottom: number);
+    /**
+     * Set rectangle with all zero values.
+     */
+    set(): AnchoredRect;
+    /**
+     * Set 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.
+     */
+    set(left: number, right: number, top: number, bottom: number): AnchoredRect;
+    /**
+     * Set 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.
+     */
+    set(left: number, anchorX: number, right: number, top: number, anchorY: number, bottom: number): AnchoredRect;
     /**
      * Create rect from basic left, top, width and height arguments.
      *
@@ -814,9 +828,9 @@ declare class DivRect {
      * @param top - Top coordinate.
      * @param width - Width.
      * @param height - Height.
-     * @returns - DivRect.
+     * @returns - AnchoredRect.
      */
-    static create(left: number, top: number, width: number, height: number): DivRect;
+    static create(left: number, top: number, width: number, height: number): AnchoredRect;
     /**
      * Create rect from anchorX, anchorY, width, height arguments.
      *
@@ -824,9 +838,9 @@ declare class DivRect {
      * @param centerY - Center y-coordinate.
      * @param width - Width.
      * @param height - Height.
-     * @returns - DivRect.
+     * @returns - AnchoredRect.
      */
-    static createCentered(centerX: number, centerY: number, width: number, height: number): DivRect;
+    static createCentered(centerX: number, centerY: number, width: number, height: number): AnchoredRect;
     /**
      * Create rect from sections.
      *
@@ -834,29 +848,17 @@ declare class DivRect {
      * @param rightw - Right section width.
      * @param toph - Top section height.
      * @param bottomh - Bottomsection height.
-     * @returns - DivRect.
+     * @returns - AnchoredRect.
      */
-    static createSections(leftw: number, rightw: number, toph: number, bottomh: number): DivRect;
+    static createSections(leftw: number, rightw: number, toph: number, bottomh: number): AnchoredRect;
     /**
-     * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
-     * @private
-     * */
+     * Get center x-coordinate.
+     */
     get centerX(): number;
     /**
-     * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
-     * @private
-     * */
-    set centerX(x: number);
-    /**
-     * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
-     * @private
-     * */
+     * Get center ycoordinate.
+     */
     get centerY(): number;
-    /**
-     * @deprecated - Renamed to anchorX. Will be removed in v2.0.0.
-     * @private
-     * */
-    set centerY(y: number);
     /**
      * Width getter.
      */
@@ -892,123 +894,118 @@ declare class DivRect {
     /**
      * Do a and b rects overlap?
      *
-     * @param a - DivRect a.
-     * @param b - DivRect b.
+     * @param a - AnchoredRect a.
+     * @param b - AnchoredRect b.
      * @returns - True/false.
      */
-    static overlap(a: DivRect, b: DivRect): boolean;
+    static overlap(a: AnchoredRect, b: AnchoredRect): boolean;
     /**
      * Do horizontal measures of a and b rects overlap?
      *
-     * @param a - DivRect a.
-     * @param b - DivRect b.
+     * @param a - AnchoredRect a.
+     * @param b - AnchoredRect b.
      * @returns - True/false.
      */
-    static overlapX(a: DivRect, b: DivRect): boolean;
+    static overlapX(a: AnchoredRect, b: AnchoredRect): boolean;
     /**
      * Check if given rects are equal.
-     * @param a - DivRect a.
-     * @param b - DivRect b.
+     * @param a - AnchoredRect a.
+     * @param b - AnchoredRect b.
      * @returns - True/false.
      */
-    static equals(a: DivRect | null | undefined, b: DivRect | null | undefined): boolean;
+    static equals(a: AnchoredRect | null | undefined, b: AnchoredRect | null | undefined): boolean;
     /**
      * Check if this rect equals with another rect.
      * @param other - The other rect.
      * @returns - True/false.
      */
-    equals(other: DivRect): boolean;
+    equals(other: AnchoredRect): boolean;
     /**
      * Check if edges of given rects are equal, ignoring anchorX and anchorY.
      *
-     * @param a - DivRect a.
-     * @param b - DivRect b.
+     * @param a - AnchoredRect a.
+     * @param b - AnchoredRect b.
      * @returns - True/false.
      */
-    static equalsEdges(a: DivRect | null | undefined, b: DivRect | null | undefined): boolean;
+    static equalsEdges(a: AnchoredRect | null | undefined, b: AnchoredRect | null | undefined): boolean;
     /**
      * Check if edges of this Rect equals with given Rect, ignoring anchorX and anchorY.
      *
-     * @param other - The other DivRect.
+     * @param other - The other AnchoredRect.
      * @returns - True/false.
      */
-    equalsEdges(other: DivRect): boolean;
-    /**
-     * @deprecated - Use `DivRect.equalsEdges()` instead. Will be removed in v2.0.0.
-     * @private
-     */
-    static equalsFrame(a: DivRect | null | undefined, b: DivRect | null | undefined): boolean;
+    equalsEdges(other: AnchoredRect): boolean;
     /**
      * Created duplicate of this Rect.
-     *
      * @returns - Duplicate.
      */
-    copy(): DivRect;
+    clone(): AnchoredRect;
     /**
      * 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.
+     * @returns - This AnchoredRect instance.
      */
-    offsetInPlace(dx: number, dy: number): DivRect;
+    offsetInPlace(dx: number, dy: number): AnchoredRect;
     /**
      * 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.
+     * @returns - AnchoredRect copy with applied offset.
      */
-    offsetCopy(dx: number, dy: number): DivRect;
+    offsetCopy(dx: number, dy: number): AnchoredRect;
     /**
      * Expand this Rect by given Rect. Modifies this Rect.
      *
-     * @param rect - DivRect to expand this instance with.
-     * @returns - This DivRect instance.
+     * @param rect - AnchoredRect to expand this instance with.
+     * @returns - This AnchoredRect instance.
      */
-    expandInPlace(rect: DivRect): DivRect;
+    expandInPlace(rect: AnchoredRect): AnchoredRect;
     /**
      * Expand this Rect by given Rect. Immutable, returns modified copy.
      *
-     * @param rect - DivRect to expand this instance with.
-     * @returns - Expanded copy of this DivRect.
+     * @param rect - AnchoredRect to expand this instance with.
+     * @returns - Expanded copy of this AnchoredRect.
      */
-    expandCopy(rect: DivRect): DivRect;
+    expandCopy(rect: AnchoredRect): AnchoredRect;
     /**
      * Clip this Rect by given Rect. Mmodifies this Rect.
      *
-     * @param clipRect - DivRect to clip this instance with.
-     * @returns - This DivRect instance.
+     * @param clipRect - AnchoredRect to clip this instance with.
+     * @returns - This AnchoredRect instance.
      */
-    clipInPlace(clipRect: DivRect): DivRect;
+    clipInPlace(clipRect: AnchoredRect): AnchoredRect;
     /**
      * Clip this Rect by given Rect. Immutable, return modified copy.
      *
-     * @param clipRect - DivRecto to clip this instance with.
-     * @returns - Clipped DivRect copy.
+     * @param clipRect - AnchoredRecto to clip this instance with.
+     * @returns - Clipped AnchoredRect copy.
      */
-    clipCopy(clipRect: DivRect): DivRect;
+    clipCopy(clipRect: AnchoredRect): AnchoredRect;
     /**
      * 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.
+     * @returns This AnchoredRect instance.
      */
-    scaleInPlace(scaleX: number, scaleY?: number): DivRect;
+    scaleInPlace(scaleX: number, scaleY?: number): AnchoredRect;
     /**
      * 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.
+     * @returns Scaled copy of this AnchoredRect.
      */
-    scaleCopy(scaleX: number, scaleY?: number): DivRect;
+    scaleCopy(scaleX: number, scaleY?: number): AnchoredRect;
     /**
-     * Get this DivRect instance.
-     * @returns - This DivRect instance.
+     * Get this AnchoredRect instance.
+     * @returns - This AnchoredRect instance.
      */
-    getRect(): DivRect;
+    getRect(): AnchoredRect;
+    toRect(): Rect;
 }
 
 /**
@@ -1473,268 +1470,4 @@ declare class LinkedList<V> extends BaseContainer implements Iterable<V> {
     clone(): LinkedList<V>;
 }
 
-/**
- * @deprecated - Use {@link Vec} instead. Will be removed in v2.0.0.
- * @private
- *
- * Vec2 class.
- */
-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. Will be removed in v2.0.0.
- * @private
- *
- * 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;
-}
-
-/**
- * @deprecated - Use {@link UniMap} instead. Will be removed in v2.0.0.
- * @private
- * A Map implementation mapping a single key to a value.
- */
-declare class Map1<KEY1, VALUE> extends BaseContainer implements KVComponent<[KEY1], VALUE> {
-    private map1;
-    constructor();
-    constructor(map1: Map1<KEY1, VALUE>);
-    constructor(entries: Iterable<[KEY1, VALUE]>);
-    has(key1: KEY1): boolean;
-    set(key1: KEY1, value: VALUE): VALUE;
-    get(key1: KEY1): VALUE | undefined;
-    getOrDefault(key1: KEY1, defaultValue: VALUE): VALUE;
-    getOrCreate(key1: KEY1, value: VALUE): VALUE;
-    getOrCreate(key1: KEY1, creator: () => VALUE): VALUE;
-    delete(key1: KEY1): boolean;
-    clear(): void;
-    get size(): number;
-    isEmpty(): boolean;
-    forEach(callbackfn: (value: VALUE, key1: KEY1, map1: Map1<KEY1, VALUE>) => void, thisArg?: any): void;
-    keys(): IterableIterator<KEY1>;
-    values(): IterableIterator<VALUE>;
-    entries(): IterableIterator<[KEY1, VALUE]>;
-    keysArray(): KEY1[];
-    valuesArray(): VALUE[];
-    entriesArray(): [KEY1, VALUE][];
-    kvKeys(): IterableIterator<[KEY1]>;
-    kvValues(): IterableIterator<VALUE>;
-    kvEntries(): IterableIterator<[[KEY1], VALUE]>;
-    [Symbol.iterator](): IterableIterator<[KEY1, VALUE]>;
-    clone(): Map1<KEY1, VALUE>;
-    merge(other: Map1<KEY1, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1) => VALUE): this;
-    some(fn: (value: VALUE, key1: KEY1) => boolean): boolean;
-    every(fn: (value: VALUE, key1: KEY1) => boolean): boolean;
-    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, array: Map1<KEY1, VALUE>) => value is S): Map1<KEY1, S>;
-    filter(predicate: (value: VALUE, key1: KEY1, array: Map1<KEY1, VALUE>) => unknown): Map1<KEY1, VALUE>;
-    reduce(fn: (acc: VALUE, value: VALUE, key1: KEY1) => VALUE): VALUE;
-    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1) => R, init: R): R;
-    mapEntries<R>(fn: (value: VALUE, key1: KEY1) => R): R[];
-    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1) => R): Map1<KEY1, R>;
-    toMap(): Map<KEY1, VALUE>;
-    toString(): string;
-}
-
-/**
- * @deprecated - Use {@link BiMap} instead. Will be removed in v2.0.0.
- * @private
- * A Map implementation mapping a double key to a value.
- */
-declare class Map2<KEY1, KEY2, VALUE> extends BaseContainer implements KVComponent<[KEY1, KEY2], VALUE> {
-    private map1;
-    constructor();
-    constructor(map2: Map2<KEY1, KEY2, VALUE>);
-    constructor(entries: Iterable<[KEY1, KEY2, VALUE]>);
-    has(key1: KEY1, key2: KEY2): boolean;
-    set(key1: KEY1, key2: KEY2, value: VALUE): VALUE;
-    get(key1: KEY1, key2: KEY2): VALUE | undefined;
-    getOrDefault(key1: KEY1, key2: KEY2, defaultValue: VALUE): VALUE;
-    getOrCreate(key1: KEY1, key2: KEY2, value: VALUE): VALUE;
-    getOrCreate(key1: KEY1, key2: KEY2, creator: () => VALUE): VALUE;
-    delete(key1: KEY1): boolean;
-    delete(key1: KEY1, key2: KEY2): boolean;
-    clear(): void;
-    get size(): number;
-    isEmpty(): boolean;
-    forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, map2: Map2<KEY1, KEY2, VALUE>) => void, thisArg?: any): void;
-    keys(): IterableIterator<[KEY1, KEY2]>;
-    values(): IterableIterator<VALUE>;
-    entries(): IterableIterator<[KEY1, KEY2, VALUE]>;
-    keysArray(): [KEY1, KEY2][];
-    valuesArray(): VALUE[];
-    entriesArray(): [KEY1, KEY2, VALUE][];
-    kvKeys(): IterableIterator<[KEY1, KEY2]>;
-    kvValues(): IterableIterator<VALUE>;
-    kvEntries(): IterableIterator<[[KEY1, KEY2], VALUE]>;
-    [Symbol.iterator](): IterableIterator<[KEY1, KEY2, VALUE]>;
-    clone(): Map2<KEY1, KEY2, VALUE>;
-    merge(other: Map2<KEY1, KEY2, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2) => VALUE): this;
-    some(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): boolean;
-    every(fn: (value: VALUE, key1: KEY1, key2: KEY2) => boolean): boolean;
-    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, key2: KEY2, array: Map2<KEY1, KEY2, VALUE>) => value is S): Map2<KEY1, KEY2, S>;
-    filter(predicate: (value: VALUE, key1: KEY1, key2: KEY2, array: Map2<KEY1, KEY2, VALUE>) => unknown): Map2<KEY1, KEY2, VALUE>;
-    reduce(fn: (acc: VALUE, value: VALUE, key1: KEY1, key2: KEY2) => VALUE): VALUE;
-    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1, key2: KEY2) => R, init: R): R;
-    mapEntries<R>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): R[];
-    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2) => R): Map2<KEY1, KEY2, R>;
-    toMap(): Map<[KEY1, KEY2], VALUE>;
-    toString(): string;
-}
-
-/**
- * @deprecated - Use {@link TriMap} instead. Will be removed in v2.0.0.
- * @private
- * A Map implementation mapping a triple key to a value.
- */
-declare class Map3<KEY1, KEY2, KEY3, VALUE> extends BaseContainer implements KVComponent<[KEY1, KEY2, KEY3], VALUE> {
-    private map1;
-    constructor();
-    constructor(entries: Iterable<[KEY1, KEY2, KEY3, VALUE]>);
-    constructor(map3: Map3<KEY1, KEY2, KEY3, VALUE>);
-    has(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
-    set(key1: KEY1, key2: KEY2, key3: KEY3, value: VALUE): VALUE;
-    get(key1: KEY1, key2: KEY2, key3: KEY3): VALUE | undefined;
-    getOrDefault(key1: KEY1, key2: KEY2, key3: KEY3, defaultValue: VALUE): VALUE;
-    getOrCreate(key1: KEY1, key2: KEY2, key3: KEY3, value: VALUE): VALUE;
-    getOrCreate(key1: KEY1, key2: KEY2, key3: KEY3, creator: () => VALUE): VALUE;
-    delete(key1: KEY1): boolean;
-    delete(key1: KEY1, key2: KEY2): boolean;
-    delete(key1: KEY1, key2: KEY2, key3: KEY3): boolean;
-    clear(): void;
-    get size(): number;
-    isEmpty(): boolean;
-    forEach(callbackfn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, map2: Map3<KEY1, KEY2, KEY3, VALUE>) => void, thisArg?: any): void;
-    keys(): IterableIterator<[KEY1, KEY2, KEY3]>;
-    values(): IterableIterator<VALUE>;
-    entries(): IterableIterator<[KEY1, KEY2, KEY3, VALUE]>;
-    keysArray(): [KEY1, KEY2, KEY3][];
-    valuesArray(): VALUE[];
-    entriesArray(): [KEY1, KEY2, KEY3, VALUE][];
-    kvKeys(): IterableIterator<[KEY1, KEY2, KEY3]>;
-    kvValues(): IterableIterator<VALUE>;
-    kvEntries(): IterableIterator<[[KEY1, KEY2, KEY3], VALUE]>;
-    [Symbol.iterator](): IterableIterator<[KEY1, KEY2, KEY3, VALUE]>;
-    clone(): Map3<KEY1, KEY2, KEY3, VALUE>;
-    merge(other: Map3<KEY1, KEY2, KEY3, VALUE>, conflictResolver?: (oldValue: VALUE, newValue: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => VALUE): this;
-    some(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): boolean;
-    every(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => boolean): boolean;
-    filter<S extends VALUE>(predicate: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, array: Map3<KEY1, KEY2, KEY3, VALUE>) => value is S): Map3<KEY1, KEY2, KEY3, S>;
-    filter(predicate: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3, array: Map3<KEY1, KEY2, KEY3, VALUE>) => unknown): Map3<KEY1, KEY2, KEY3, VALUE>;
-    reduce(fn: (acc: VALUE, value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => VALUE): VALUE;
-    reduce<R>(fn: (acc: R, value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R, init: R): R;
-    mapEntries<R>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): R[];
-    mapValues<R = VALUE>(fn: (value: VALUE, key1: KEY1, key2: KEY2, key3: KEY3) => R): Map3<KEY1, KEY2, KEY3, R>;
-    toMap(): Map<[KEY1, KEY2, KEY3], VALUE>;
-    toString(): string;
-}
-
-/**
- * @deprecated - Use {@link ValueSet} instead. Will be removed in v2.0.0.
- * @private
- * An abstract base class implementation of a Set data structure.
- */
-declare abstract class SetBase<VALUE, CLS extends SetBase<VALUE, CLS> = any> extends BaseContainer implements KVComponent<[VALUE], VALUE> {
-    protected data: Set<VALUE>;
-    constructor(entries?: Iterable<VALUE>);
-    protected abstract valueEquals(a: VALUE, b: VALUE): boolean;
-    protected abstract createEmpty<R = VALUE>(): SetBase<R, any>;
-    has(value: VALUE): boolean;
-    add(value: VALUE): VALUE;
-    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
-    set(key: VALUE, value: VALUE): void;
-    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
-    get(key: VALUE): VALUE | undefined;
-    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
-    getOrDefault(key: VALUE, defaultValue: VALUE): VALUE;
-    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
-    getOrCreate(key: VALUE, value: VALUE): VALUE;
-    /** @internal - This method exists only for interface `KVComponent` compatibility.*/
-    getOrCreate(key: VALUE, creator: () => VALUE): VALUE;
-    delete(value: VALUE): boolean;
-    clear(): void;
-    get size(): number;
-    isEmpty(): boolean;
-    forEach(callbackfn: (value: VALUE, set1: SetBase<VALUE>) => void, thisArg?: any): void;
-    keys(): IterableIterator<VALUE>;
-    values(): IterableIterator<VALUE>;
-    entries(): IterableIterator<[VALUE, VALUE]>;
-    kvKeys(): IterableIterator<[VALUE]>;
-    kvValues(): IterableIterator<VALUE>;
-    kvEntries(): IterableIterator<[[VALUE], VALUE]>;
-    [Symbol.iterator](): IterableIterator<VALUE>;
-    clone(): SetBase<VALUE>;
-    merge(other: SetBase<VALUE>): this;
-    some(fn: (value: VALUE) => boolean): boolean;
-    every(fn: (value: VALUE) => boolean): boolean;
-    filter<R extends VALUE>(predicate: (value: VALUE, set1: SetBase<VALUE, any>) => value is R): SetBase<R, any>;
-    filter(predicate: (value: VALUE, set1: SetBase<VALUE>) => unknown): SetBase<VALUE, any>;
-    reduce(fn: (acc: VALUE, value: VALUE) => VALUE): VALUE;
-    reduce<R = VALUE>(fn: (acc: R, value: VALUE) => R, init: R): R;
-    mapValues<R = VALUE>(fn: (value: VALUE) => R): SetBase<R, any>;
-    mapToArray<R = VALUE>(fn: (value: VALUE) => R): R[];
-    map<R = VALUE>(fn: (value: VALUE) => R): SetBase<R, any>;
-    toSet(): Set<VALUE>;
-    toArray(): VALUE[];
-    toString(): string;
-}
-/**
- * @deprecated - Use {@link ValueSet} instead. Will be removed in v2.0.0.
- * @private
- * A simple Set data structure. Comparison of values is done
- * using === operator (e.g. "a" === "a", but [1, 2] !== [1, 2]).
- */
-declare class Set1<VALUE> extends SetBase<VALUE, Set1<VALUE>> {
-    constructor();
-    constructor(set: SetBase<VALUE>);
-    constructor(entries: Iterable<VALUE>);
-    protected createEmpty<R = VALUE>(): Set1<R>;
-    protected valueEquals(a: VALUE, b: VALUE): boolean;
-}
-/**
- * @deprecated - Use {@link ValueSet}.createDeep() instead. Will be removed in v2.0.0.
- * @private
- * A simple Set data structure, where comparison of values is done
- * using deep equality (e.g. "a" === "a" and also [1, 2] === [1, 2]).
- */
-declare class DeepSet<VALUE> extends SetBase<VALUE, DeepSet<VALUE>> {
-    constructor();
-    constructor(set: SetBase<VALUE>);
-    constructor(entries: Iterable<VALUE>);
-    protected createEmpty<R = VALUE>(): DeepSet<R>;
-    protected valueEquals(a: VALUE, b: VALUE): boolean;
-}
-
-export { index$7 as Assert, BaseContainer, BiMap, cookies as Cookies, DeepSet, DefaultArray, DefaultEqualityFn, device as Device, DivRect, type EqualityFn, Guard, IndexArray, type KVComponent, LRUCache, LinkedList, Map1, Map2, Map3, MultiContainer, Set1, SetBase, SignedIndexArray, SmallIntCache, Stack, TriMap, UniMap, index as Utils, ValueSet, Vec, Vec2, asMulti };
+export { AnchoredRect, index$7 as Assert, BaseContainer, BiMap, cookies as Cookies, DefaultArray, DefaultEqualityFn, device as Device, type EqualityFn, index$6 as Guard, IndexArray, type KVComponent, LRUCache, LinkedList, MultiContainer, Rect, SignedIndexArray, Stack, TriMap, UniMap, index as Utils, ValueSet, Vec, asMulti };