		export declare class Browser {
		static UserAgent: string;
		static Edge: boolean;
		static MSTouchUI: boolean;
		static WebKitTouchUI: boolean;
		static MacOSMobilePlatform: boolean;
		static MacOSPlatform: boolean;
		static NetscapeFamily: boolean;
		static Opera: boolean;
		static Safari: boolean;
		static IE: boolean;
		static WebKitFamily: boolean;
		static Firefox: boolean;
		static AndroidDefaultBrowser: boolean;
		static AndroidChromeBrowser: boolean;
		static WindowsPlatform: boolean;
		static AndroidMobilePlatform: boolean;
		static WindowsPhonePlatform: boolean;
		static Chrome: boolean;
		static Netscape: boolean;
		static Mozilla: boolean;
		static HardwareAcceleration: boolean;
		static TouchUI: boolean;
		static MobileUI: boolean;
		static SamsungAndroidDevice: boolean;
		static VirtualKeyboardSupported: boolean;
		static Info: string;
		static MajorVersion: number;
		static PlaformMajorVersion: string;
		static Version: number;
		static IdentUserAgent(userAgent: string, ignoreDocumentMode?: boolean): void;
		static GetBrowserVersion(userAgent: string, matches: RegExpExecArray, tridentPattern: string, ieCompatibleVersionString: string): number;
		private static getIECompatibleVersionString;
		static isTouchEnabled(): boolean;
		static fillUserAgentInfo(browserTypesOrderedList: string[], browserType: string, version: number, platform: string, isSamsungAndroidDevice?: boolean \| null): void;
		private static indentPlatformMajorVersion;
		private static getVersionFromMatches;
		private static getVersionFromTrident;
		static fillDocumentElementBrowserTypeClassNames(browserTypesOrderedList: string[]): void;
		static _foo: void;
		static UserAgent: string;
		static Edge: boolean;
		static MSTouchUI: boolean;
		static WebKitTouchUI: boolean;
		static MacOSMobilePlatform: boolean;
		static MacOSPlatform: boolean;
		static NetscapeFamily: boolean;
		static Opera: boolean;
		static Safari: boolean;
		static IE: boolean;
		static WebKitFamily: boolean;
		static Firefox: boolean;
		static AndroidDefaultBrowser: boolean;
		static AndroidChromeBrowser: boolean;
		static WindowsPlatform: boolean;
		static AndroidMobilePlatform: boolean;
		static WindowsPhonePlatform: boolean;
		static Chrome: boolean;
		static Netscape: boolean;
		static Mozilla: boolean;
		static HardwareAcceleration: boolean;
		static TouchUI: boolean;
		static MobileUI: boolean;
		static SamsungAndroidDevice: boolean;
		static VirtualKeyboardSupported: boolean;
		static Info: string;
		static MajorVersion: number;
		static PlaformMajorVersion: string;
		static Version: number;
		static IdentUserAgent(userAgent: string, ignoreDocumentMode?: boolean): void;
		static GetBrowserVersion(userAgent: string, matches: RegExpExecArray, tridentPattern: string, ieCompatibleVersionString: string): number;
		private static getIECompatibleVersionString;
		static isTouchEnabled(): boolean;
		static fillUserAgentInfo(browserTypesOrderedList: string[], browserType: string, version: number, platform: string, isSamsungAndroidDevice?: boolean \| null): void;
		private static indentPlatformMajorVersion;
		private static getVersionFromMatches;
		private static getVersionFromTrident;
		static fillDocumentElementBrowserTypeClassNames(browserTypesOrderedList: string[]): void;
		static _foo: void;
		}
		//# sourceMappingURL=browser.d.ts.map

lib/class/batch-updatable.d.ts

		export interface IBatchUpdatableObject {
		beginUpdate(): void;
		endUpdate(): void;
		beginUpdate(): void;
		endUpdate(): void;
		}
		export interface IBatchUpdatableObjectExtend extends IBatchUpdatableObject {
		suspendUpdate(): void;
		continueUpdate(): void;
		isUpdateLocked(): boolean;
		onUpdateLocked(): void;
		suspendUpdate(): void;
		continueUpdate(): void;
		isUpdateLocked(): boolean;
		onUpdateLocked(): void;
		}
		export declare abstract class BatchUpdatableObject implements IBatchUpdatableObjectExtend {
		private suspendUpdateCount;
		private occurredEvents;
		beginUpdate(): void;
		endUpdate(): void;
		suspendUpdate(): void;
		continueUpdate(): void;
		isUpdateLocked(): boolean;
		abstract onUpdateUnlocked(occurredEvents: number): void;
		onUpdateLocked(): void;
		registerOccurredEvent(eventMask: number): void;
		resetOccurredEvents(): void;
		isLocked(): boolean;
		private suspendUpdateCount;
		private occurredEvents;
		beginUpdate(): void;
		endUpdate(): void;
		suspendUpdate(): void;
		continueUpdate(): void;
		isUpdateLocked(): boolean;
		abstract onUpdateUnlocked(occurredEvents: number): void;
		onUpdateLocked(): void;
		registerOccurredEvent(eventMask: number): void;
		resetOccurredEvents(): void;
		isLocked(): boolean;
		}
		export declare class EmptyBatchUpdatableObject implements IBatchUpdatableObject {
		beginUpdate(): void;
		endUpdate(): void;
		beginUpdate(): void;
		endUpdate(): void;
		}
		//# sourceMappingURL=batch-updatable.d.ts.map

lib/class/chunked-text.d.ts

		export declare class ChunkedText {
		protected maxChunkSize: number;
		protected chunks: string[];
		protected chunkIndex: number;
		protected chunk: string;
		protected chunkLength: number;
		protected posInChunk: number;
		protected _currPos: number;
		protected _textLength: number;
		constructor(text: string, maxChunkSize?: number);
		resetToStart(): void;
		resetToEnd(): void;
		addText(text: string): void;
		getText(): string;
		moveToNextChar(): boolean;
		moveToPrevChar(): boolean;
		setPositionTo(position: number): void;
		private setChunk;
		private pushText;
		readonly currChar: string;
		readonly currPos: number;
		readonly textLength: number;
		protected maxChunkSize: number;
		protected chunks: string[];
		protected chunkIndex: number;
		protected chunk: string;
		protected chunkLength: number;
		protected posInChunk: number;
		protected _currPos: number;
		protected _textLength: number;
		constructor(text: string, maxChunkSize?: number);
		resetToStart(): void;
		resetToEnd(): void;
		addText(text: string): void;
		getText(): string;
		moveToNextChar(): boolean;
		moveToPrevChar(): boolean;
		setPositionTo(position: number): void;
		private setChunk;
		private pushText;
		readonly currChar: string;
		readonly currPos: number;
		readonly textLength: number;
		}
		//# sourceMappingURL=chunked-text.d.ts.map

lib/class/delayed-manager.d.ts

		export declare class DelayedActionManager {
		private actionTimeout;
		private actionTimeoutId;
		private actionStartTime;
		private action;
		constructor(action: () => void);
		reset(): void;
		start(timeout: number): void;
		executeIfTimerExpired(): void;
		executeAction(): void;
		stop(): void;
		readonly actionExecuted: boolean;
		private actionTimeout;
		private actionTimeoutId;
		private actionStartTime;
		private action;
		constructor(action: () => void);
		reset(): void;
		start(timeout: number): void;
		executeIfTimerExpired(): void;
		executeAction(): void;
		stop(): void;
		readonly actionExecuted: boolean;
		}
		//# sourceMappingURL=delayed-manager.d.ts.map

lib/class/event-handlers-holder.d.ts

		export declare class DomEventHandlersHolder {
		private handlers;
		addListener(element: Element \| Document, eventName: string, handler: EventListenerOrEventListenerObject, options?: boolean \| AddEventListenerOptions): void;
		addListenerToWindow(eventName: string, handler: EventListenerOrEventListenerObject, options?: boolean \| AddEventListenerOptions): void;
		addListenerToDocument(eventName: string, handler: EventListenerOrEventListenerObject, options?: boolean \| AddEventListenerOptions): void;
		removeAllListeners(): void;
		private handlers;
		addListener(element: Element \| Document, eventName: string, handler: EventListenerOrEventListenerObject, options?: boolean \| AddEventListenerOptions): void;
		addListenerToWindow(eventName: string, handler: EventListenerOrEventListenerObject, options?: boolean \| AddEventListenerOptions): void;
		addListenerToDocument(eventName: string, handler: EventListenerOrEventListenerObject, options?: boolean \| AddEventListenerOptions): void;
		removeAllListeners(): void;
		}
		//# sourceMappingURL=event-handlers-holder.d.ts.map

lib/class/flag.d.ts

		import { ICloneable } from '../types';
		export declare class Flag implements ICloneable<Flag> {
		private value;
		constructor(initValue?: number);
		get(enumVal: number): boolean;
		set(enumVal: number, newValue: boolean): this;
		add(value: number): void;
		anyOf(...flags: number[]): boolean;
		getValue(): number;
		clone(): Flag;
		private value;
		constructor(initValue?: number);
		get(enumVal: number): boolean;
		set(enumVal: number, newValue: boolean): this;
		add(value: number): void;
		anyOf(...flags: number[]): boolean;
		getValue(): number;
		clone(): Flag;
		}
		//# sourceMappingURL=flag.d.ts.map

lib/class/initializer.d.ts

		export declare class Initializer {
		set<TProp extends Exclude<keyof this, 'set'>>(property: TProp, value: this[TProp]): this;
		set<TProp extends Exclude<keyof this, 'set'>>(property: TProp, value: this[TProp]): this;
		}
		export declare function Initialize<TOptions>(options: TOptions): {
		set: <TProperty extends keyof TOptions>(property: TProperty, value: TOptions[TProperty]) => {
		set: any;
		result: TOptions;
		};
		result: TOptions;
		set: <TProperty extends keyof TOptions>(property: TProperty, value: TOptions[TProperty]) => {
		set: any;
		result: TOptions;
		};
		result: TOptions;
		};
		//# sourceMappingURL=initializer.d.ts.map

lib/class/min-max.d.ts

		export declare class MinMax<T> {
		minElement: T;
		maxElement: T;
		constructor(minElement: T, maxElement: T);
		minElement: T;
		maxElement: T;
		constructor(minElement: T, maxElement: T);
		}
		export declare class MinMaxNumber extends MinMax<number> {
		readonly length: number;
		readonly length: number;
		}
		export declare class ExtendedMin<T> {
		minElement: T;
		minValue: number;
		constructor(minElement: T, minValue: number);
		minElement: T;
		minValue: number;
		constructor(minElement: T, minValue: number);
		}
		export declare class ExtendedMax<T> {
		maxElement: T;
		maxValue: number;
		constructor(maxElement: T, maxValue: number);
		maxElement: T;
		maxValue: number;
		constructor(maxElement: T, maxValue: number);
		}
		export declare class ExtendedMinMax<T> extends MinMax<T> {
		minValue: number;
		maxValue: number;
		constructor(minElement: T, minValue: number, maxElement: T, maxValue: number);
		minValue: number;
		maxValue: number;
		constructor(minElement: T, minValue: number, maxElement: T, maxValue: number);
		}
		//# sourceMappingURL=min-max.d.ts.map

lib/class/ordered-list.d.ts

		import { CmpFunc } from '../types';
		export declare class OrderedList<T> {
		list: T[];
		private comparer;
		constructor(comparer: CmpFunc<T>);
		add(elem: T): this;
		sort(): void;
		findIndex(elem: T): number;
		findElement(elem: T): T \| null;
		list: T[];
		private comparer;
		constructor(comparer: CmpFunc<T>);
		add(elem: T): this;
		sort(): void;
		findIndex(elem: T): number;
		findElement(elem: T): T \| null;
		}
		//# sourceMappingURL=ordered-list.d.ts.map

lib/class/pair.d.ts

		export declare class Pair<firstT, secondT> {
		first: firstT;
		second: secondT;
		constructor(first: firstT, second: secondT);
		first: firstT;
		second: secondT;
		constructor(first: firstT, second: secondT);
		}
		//# sourceMappingURL=pair.d.ts.map

lib/class/stack.d.ts

		export declare class Stack<T> {
		private list;
		private _count;
		last: T \| undefined;
		push(val: T): void;
		pop(): T \| undefined;
		peek(): T \| undefined;
		getPrevious(): T;
		readonly count: number;
		private list;
		private _count;
		last: T \| undefined;
		push(val: T): void;
		pop(): T \| undefined;
		peek(): T \| undefined;
		getPrevious(): T;
		readonly count: number;
		}
		//# sourceMappingURL=stack.d.ts.map

lib/class/unit-converter.d.ts

		export declare class UnitConverter {
		static DPI: number;
		static CENTIMETERS_PER_INCH: number;
		static PICAS_PER_INCH: number;
		static hundredthsOfMillimeterToTwipsRound(value: number): number;
		static documentsToTwips(value: number): number;
		static pixelsToTwips(value: number): number;
		static pixelsToTwipsCustomDpi(value: number, dpi: number): number;
		static inchesToTwips(value: number): number;
		static pointsToTwips(value: number): number;
		static picasToTwips(value: number): number;
		static centimetersToTwips(value: number): number;
		static pixelsToTwipsF(value: number): number;
		static pixelsToTwipsFCustomDpi(value: number, dpi: number): number;
		static inchesToTwipsF(value: number): number;
		static pointsToTwipsF(value: number): number;
		static centimetersToTwipsF(value: number): number;
		static twipsToDegrees(value: number): number;
		static twipsToRadians(value: number): number;
		static degreesToTwips(value: number): number;
		static radiansToTwips(value: number): number;
		static radiansToDegrees(value: number): number;
		static twipsToFD(value: number): number;
		static fdToTwips(value: number): number;
		static emuToTwips(val: number): number;
		static twipsToPixels(value: number): number;
		static inchesToPixels(value: number): number;
		static centimeterToPixel(value: number): number;
		static millimetersToPixel(value: number): number;
		static pointsToPixels(value: number): number;
		static pointsToPixelsF(value: number): number;
		static twipsToPixelsF(value: number): number;
		static pixelsToPoints(value: number): number;
		static pixelsToPointsF(value: number): number;
		static twipsToPoints(value: number): number;
		static twipsToPointsF(value: number): number;
		static twipsToInches(value: number): number;
		static pixelsToInches(value: number): number;
		static twipsToCentimeters(value: number): number;
		static pixelToCentimeters(value: number): number;
		static twipsToHundredthsOfMillimeter(value: number): number;
		static pixelsToHundredthsOfMillimeter(value: number): number;
		static hundredthsOfMillimeterToTwips(value: number): number;
		static twipsToEmu(val: number): number;
		static twipsToDegree(value: number): number;
		static DPI: number;
		static CENTIMETERS_PER_INCH: number;
		static PICAS_PER_INCH: number;
		static hundredthsOfMillimeterToTwipsRound(value: number): number;
		static documentsToTwips(value: number): number;
		static pixelsToTwips(value: number): number;
		static pixelsToTwipsCustomDpi(value: number, dpi: number): number;
		static inchesToTwips(value: number): number;
		static pointsToTwips(value: number): number;
		static picasToTwips(value: number): number;
		static centimetersToTwips(value: number): number;
		static pixelsToTwipsF(value: number): number;
		static pixelsToTwipsFCustomDpi(value: number, dpi: number): number;
		static inchesToTwipsF(value: number): number;
		static pointsToTwipsF(value: number): number;
		static centimetersToTwipsF(value: number): number;
		static twipsToDegrees(value: number): number;
		static twipsToRadians(value: number): number;
		static degreesToTwips(value: number): number;
		static radiansToTwips(value: number): number;
		static radiansToDegrees(value: number): number;
		static twipsToFD(value: number): number;
		static fdToTwips(value: number): number;
		static emuToTwips(val: number): number;
		static twipsToPixels(value: number): number;
		static inchesToPixels(value: number): number;
		static centimeterToPixel(value: number): number;
		static millimetersToPixel(value: number): number;
		static pointsToPixels(value: number): number;
		static pointsToPixelsF(value: number): number;
		static twipsToPixelsF(value: number): number;
		static pixelsToPoints(value: number): number;
		static pixelsToPointsF(value: number): number;
		static twipsToPoints(value: number): number;
		static twipsToPointsF(value: number): number;
		static twipsToInches(value: number): number;
		static pixelsToInches(value: number): number;
		static twipsToCentimeters(value: number): number;
		static pixelToCentimeters(value: number): number;
		static twipsToHundredthsOfMillimeter(value: number): number;
		static pixelsToHundredthsOfMillimeter(value: number): number;
		static hundredthsOfMillimeterToTwips(value: number): number;
		static twipsToEmu(val: number): number;
		static twipsToDegree(value: number): number;
		}
		//# sourceMappingURL=unit-converter.d.ts.map

lib/constants.d.ts

		export declare class Constants {
		static MIN_SAFE_INTEGER: number;
		static MAX_SAFE_INTEGER: number;
		static MAX_BYTE: number;
		static MIN_SAFE_INTEGER: number;
		static MAX_SAFE_INTEGER: number;
		static MAX_BYTE: number;
		}
		export declare class Int32Constants {
		static MIN_VALUE: number;
		static MAX_VALUE: number;
		static MIN_VALUE: number;
		static MAX_VALUE: number;
		}
		//# sourceMappingURL=constants.d.ts.map

lib/errors.d.ts

		export declare class Errors {
		static NotImplemented: string;
		static InternalException: string;
		static ValueCannotBeNull: string;
		static internalExceptionTemplate(str: string): string;
		static NotImplemented: string;
		static InternalException: string;
		static ValueCannotBeNull: string;
		static internalExceptionTemplate(str: string): string;
		}
		//# sourceMappingURL=errors.d.ts.map

lib/formatters/date-time-field.d.ts

		import { IDateFormatterOptions } from './options';
		export declare class DateTimeFieldFormatter {
		private date;
		private formatString;
		private result;
		private AMPMKeyword;
		private readonly options;
		constructor(options: IDateFormatterOptions);
		format(date: Date, formatString: string): string;
		private formatNext;
		private isKeyword;
		private processAsAMPMKeyword;
		private processAsEmbedText;
		private processAsSingleCharacter;
		private processAsFormattingItem;
		private getCharacterSequenceLength;
		private tryCreateFormattingItem;
		private charsAreEqual;
		private charsAreNotEqual;
		private date;
		private formatString;
		private result;
		private AMPMKeyword;
		private readonly options;
		constructor(options: IDateFormatterOptions);
		format(date: Date, formatString: string): string;
		private formatNext;
		private isKeyword;
		private processAsAMPMKeyword;
		private processAsEmbedText;
		private processAsSingleCharacter;
		private processAsFormattingItem;
		private getCharacterSequenceLength;
		private tryCreateFormattingItem;
		private charsAreEqual;
		private charsAreNotEqual;
		}
		//# sourceMappingURL=date-time-field.d.ts.map

lib/formatters/date-utils.d.ts

		export declare class DateUtils {
		static fixTimezoneGap(oldDate: Date, newDate: Date): void;
		static expandTwoDigitYear(value: number, options: {
		twoDigitYearMax: number;
		}): number;
		static toUtcTime(date: Date): Date;
		private static getTimeZoneOffset;
		static fixTimezoneGap(oldDate: Date, newDate: Date): void;
		static expandTwoDigitYear(value: number, options: {
		twoDigitYearMax: number;
		}): number;
		static toUtcTime(date: Date): Date;
		private static getTimeZoneOffset;
		}
		//# sourceMappingURL=date-utils.d.ts.map

136

lib/formatters/date.d.ts

		import { IDateFormatterOptions } from './options';
		export declare class DateFormatter {
		readonly options: IDateFormatterOptions;
		private date;
		private mask;
		private specifiers;
		private spPositions;
		private parserKeys;
		private savedYear;
		private isYearParsed;
		private parsedMonth;
		private strToParse;
		private hasAmPm;
		private dayMonthNameReplacePattern;
		private parseNumbers;
		private currentParseNumber;
		private readonly knownSpecifiers;
		private readonly replacers;
		private readonly parsers;
		constructor(options: IDateFormatterOptions);
		setFormatString(mask: string): void;
		format(date: Date): string;
		parse(str: string, rememberParserKeys: boolean): Date \| boolean;
		hasYear(): boolean;
		hasMonth(): boolean;
		hasDay(): boolean;
		hasHours(): boolean;
		hasMinutes(): boolean;
		hasSeconds(): boolean;
		hasMilliseconds(): boolean;
		private hasParserKey;
		static expandPredefinedFormat(format: string, options: IDateFormatterOptions): string;
		private applyMonth;
		private registerSpecifier;
		private replaceDay;
		private replaceMonth;
		private replaceYear;
		private replaceHours23;
		private replaceHours12;
		private replaceMinutes;
		private replaceSeconds;
		private replaceMsTrimmed;
		private replaceMs;
		private replaceEra;
		private replaceAmPm;
		private catchNumbers;
		private popParseNumber;
		private findAbbrMonth;
		private findFullMonth;
		private findMonthCore;
		private parseDay;
		private parseMonth;
		private parseYear;
		private parseHours;
		private parseMinutes;
		private parseSeconds;
		private parseMs;
		private parseEra;
		private parseAmPm;
		private parseDecInt;
		private padLeft;
		private formatMs;
		private parseMinSecCore;
		private fixHours;
		private getAmPmState;
		private getDayMonthNameReplacePattern;
		private createDayMonthNameReplacePattern;
		private createReplacePattern;
		private isNumericSpecifier;
		private isKnownSpecifier;
		readonly options: IDateFormatterOptions;
		private date;
		private mask;
		private specifiers;
		private spPositions;
		private parserKeys;
		private savedYear;
		private isYearParsed;
		private parsedMonth;
		private strToParse;
		private hasAmPm;
		private dayMonthNameReplacePattern;
		private parseNumbers;
		private currentParseNumber;
		private readonly knownSpecifiers;
		private readonly replacers;
		private readonly parsers;
		constructor(options: IDateFormatterOptions);
		setFormatString(mask: string): void;
		format(date: Date): string;
		parse(str: string, rememberParserKeys: boolean): Date \| boolean;
		hasYear(): boolean;
		hasMonth(): boolean;
		hasDay(): boolean;
		hasHours(): boolean;
		hasMinutes(): boolean;
		hasSeconds(): boolean;
		hasMilliseconds(): boolean;
		private hasParserKey;
		static expandPredefinedFormat(format: string, options: IDateFormatterOptions): string;
		private applyMonth;
		private registerSpecifier;
		private replaceDay;
		private replaceMonth;
		private replaceYear;
		private replaceHours23;
		private replaceHours12;
		private replaceMinutes;
		private replaceSeconds;
		private replaceMsTrimmed;
		private replaceMs;
		private replaceEra;
		private replaceAmPm;
		private catchNumbers;
		private popParseNumber;
		private findAbbrMonth;
		private findFullMonth;
		private findMonthCore;
		private parseDay;
		private parseMonth;
		private parseYear;
		private parseHours;
		private parseMinutes;
		private parseSeconds;
		private parseMs;
		private parseEra;
		private parseAmPm;
		private parseDecInt;
		private padLeft;
		private formatMs;
		private parseMinSecCore;
		private fixHours;
		private getAmPmState;
		private getDayMonthNameReplacePattern;
		private createDayMonthNameReplacePattern;
		private createReplacePattern;
		private isNumericSpecifier;
		private isKnownSpecifier;
		}
		//# sourceMappingURL=date.d.ts.map

lib/formatters/manager.d.ts

		@@ -6,11 +6,11 @@ import { DateFormatter } from './date';
		export declare class SimpleFormattersManager {
		stringFormatter: StringFormatter;
		dateFormatter: DateFormatter;
		numberFormatter: NumberFormatter;
		options: IFormattersOptions;
		constructor(options: IFormattersOptions);
		formatString(pattern: string, ...args: any[]): string;
		formatDate(format: string, date: Date): string;
		formatNumber(format: string, value: number): string;
		stringFormatter: StringFormatter;
		dateFormatter: DateFormatter;
		numberFormatter: NumberFormatter;
		options: IFormattersOptions;
		constructor(options: IFormattersOptions);
		formatString(pattern: string, ...args: any[]): string;
		formatDate(format: string, date: Date): string;
		formatNumber(format: string, value: number): string;
		}
		//# sourceMappingURL=manager.d.ts.map

lib/formatters/number.d.ts

		import { INumberFormatterOptions } from './options';
		export declare class NumberFormatter {
		private positive;
		private digits;
		private pointPos;
		private spec;
		private prec;
		private upper;
		private custom;
		private readonly options;
		constructor(options: INumberFormatterOptions);
		format(format: string, value: number): string;
		private formatCurrency;
		private formatDecimal;
		private formatExp;
		private formatExpCore;
		private formatFixed;
		private formatGeneral;
		private formatNumber;
		private formatPercent;
		private formatHex;
		private formatCustom;
		private static getCustomFormatSections;
		private selectCustomFormatSection;
		private static createCustomFormatInfo;
		private static parseCustomFormatSection;
		private createCustomFormatLists;
		private formatCustomCore;
		private fillDigitInfo;
		private fillFormatInfo;
		private round;
		private appendGroupedInteger;
		private appendDigits;
		private positive;
		private digits;
		private pointPos;
		private spec;
		private prec;
		private upper;
		private custom;
		private readonly options;
		constructor(options: INumberFormatterOptions);
		format(format: string, value: number): string;
		private formatCurrency;
		private formatDecimal;
		private formatExp;
		private formatExpCore;
		private formatFixed;
		private formatGeneral;
		private formatNumber;
		private formatPercent;
		private formatHex;
		private formatCustom;
		private static getCustomFormatSections;
		private selectCustomFormatSection;
		private static createCustomFormatInfo;
		private static parseCustomFormatSection;
		private createCustomFormatLists;
		private formatCustomCore;
		private fillDigitInfo;
		private fillFormatInfo;
		private round;
		private appendGroupedInteger;
		private appendDigits;
		}
		//# sourceMappingURL=number.d.ts.map

lib/formatters/options.d.ts

		export interface IDateFormatterOptions {
		twoDigitYearMax: number;
		ts: string;
		ds: string;
		am: string;
		pm: string;
		monthNames: string[];
		genMonthNames: string[];
		abbrMonthNames: string[];
		abbrDayNames: string[];
		dayNames: string[];
		shortTime: string;
		longTime: string;
		shortDate: string;
		longDate: string;
		monthDay: string;
		yearMonth: string;
		twoDigitYearMax: number;
		ts: string;
		ds: string;
		am: string;
		pm: string;
		monthNames: string[];
		genMonthNames: string[];
		abbrMonthNames: string[];
		abbrDayNames: string[];
		dayNames: string[];
		shortTime: string;
		longTime: string;
		shortDate: string;
		longDate: string;
		monthDay: string;
		yearMonth: string;
		}
		export interface INumberFormatterOptions {
		numDecimalPoint: string;
		numPrec: number;
		numGroupSeparator: string;
		numGroups: number[];
		numNegPattern: number;
		numPosInf: string;
		numNegInf: string;
		numNan: string;
		currency: string;
		currDecimalPoint: string;
		currPrec: number;
		currGroupSeparator: string;
		currGroups: number[];
		currPosPattern: number;
		currNegPattern: number;
		percentPattern: number;
		numDecimalPoint: string;
		numPrec: number;
		numGroupSeparator: string;
		numGroups: number[];
		numNegPattern: number;
		numPosInf: string;
		numNegInf: string;
		numNan: string;
		currency: string;
		currDecimalPoint: string;
		currPrec: number;
		currGroupSeparator: string;
		currGroups: number[];
		currPosPattern: number;
		currNegPattern: number;
		percentPattern: number;
		}
		export interface IFormattersOptions extends IDateFormatterOptions, INumberFormatterOptions {
		clone(): IFormattersOptions;
		clone(): IFormattersOptions;
		}
		//# sourceMappingURL=options.d.ts.map

lib/formatters/string.d.ts

		import { DateFormatter } from './date';
		import { NumberFormatter } from './number';
		export declare class StringFormatter {
		private readonly dateFormatter;
		private readonly numberFormatter;
		private activeDateFormat;
		constructor(dateFormatter: DateFormatter, numberFormatter: NumberFormatter);
		format(pattern: string, ...args: any[]): string;
		private parseSpec;
		private readonly dateFormatter;
		private readonly numberFormatter;
		private activeDateFormat;
		constructor(dateFormatter: DateFormatter, numberFormatter: NumberFormatter);
		format(pattern: string, ...args: any[]): string;
		private parseSpec;
		}
		//# sourceMappingURL=string.d.ts.map

lib/geometry/interfaces.d.ts

		export interface IPoint {
		x: number;
		y: number;
		x: number;
		y: number;
		}
		export interface ISize {
		width: number;
		height: number;
		width: number;
		height: number;
		}
		@@ -12,7 +12,7 @@ export interface IRectangle extends IPoint, ISize {
		export interface IOffsets {
		left: number;
		right: number;
		top: number;
		bottom: number;
		left: number;
		right: number;
		top: number;
		bottom: number;
		}
		//# sourceMappingURL=interfaces.d.ts.map

lib/geometry/line-equation.d.ts

		import { IPoint } from './interfaces';
		import { Point } from './point';
		export declare class LineEquation {
		private aParam;
		private bParam;
		private cParam;
		constructor(aParam: number, bParam: number, cParam: number);
		equals(obj: LineEquation): boolean;
		getIntersection(equation: LineEquation): Point \| null;
		static fromPoints(pointA: IPoint, pointB: IPoint): LineEquation;
		static getIntersection(a: LineEquation, b: LineEquation): Point \| null;
		static equals(a: LineEquation, b: LineEquation): boolean;
		private aParam;
		private bParam;
		private cParam;
		constructor(aParam: number, bParam: number, cParam: number);
		equals(obj: LineEquation): boolean;
		getIntersection(equation: LineEquation): Point \| null;
		static fromPoints(pointA: IPoint, pointB: IPoint): LineEquation;
		static getIntersection(a: LineEquation, b: LineEquation): Point \| null;
		static equals(a: LineEquation, b: LineEquation): boolean;
		}
		//# sourceMappingURL=line-equation.d.ts.map

lib/geometry/margins.d.ts

		import { ICloneable, IEquatable, ISupportConverting, ISupportCopyFrom } from '../types';
		import { Offsets } from './offsets';
		export declare class Margins extends Offsets implements IEquatable<Margins>, ICloneable<Margins>, ISupportCopyFrom<Margins>, ISupportConverting<number> {
		static empty(): Margins;
		clone(): Margins;
		static empty(): Margins;
		clone(): Margins;
		}
		//# sourceMappingURL=margins.d.ts.map

lib/geometry/metrics.d.ts

		import { IPoint } from './interfaces';
		export declare class Metrics {
		static euclideanDistance(a: IPoint, b: IPoint): number;
		static manhattanDistance(a: IPoint, b: IPoint): number;
		static euclideanDistance(a: IPoint, b: IPoint): number;
		static manhattanDistance(a: IPoint, b: IPoint): number;
		}
		//# sourceMappingURL=metrics.d.ts.map

lib/geometry/offsets.d.ts

		import { IEquatable, ISupportConverting, ISupportCopyFrom, SimpleConverter } from '../types';
		import { IOffsets } from './interfaces';
		export declare class Offsets implements IEquatable<Offsets>, ISupportCopyFrom<Offsets>, ISupportConverting<number>, IOffsets {
		left: number;
		right: number;
		top: number;
		bottom: number;
		static empty(): Offsets;
		constructor(left: number, right: number, top: number, bottom: number);
		static fromNumber(offset: number): Offsets;
		static fromOffsets(offsets: IOffsets): Offsets;
		static fromSide(horizontal: number, vertical: number): Offsets;
		normalize(): this;
		toString(): string;
		isEmpty(): boolean;
		offset(offset: IOffsets): this;
		multiply(mult: number): this;
		multiply(multHoriz: number, multVert: number): this;
		multiply(multLeft: number, multRight: number, multTop: number, multBottom: number): this;
		clone(): Offsets;
		copyFrom(obj: IOffsets): void;
		equals(obj: IOffsets): boolean;
		applyConverter(converter: SimpleConverter): this;
		readonly horizontal: number;
		readonly vertical: number;
		left: number;
		right: number;
		top: number;
		bottom: number;
		static empty(): Offsets;
		constructor(left: number, right: number, top: number, bottom: number);
		static fromNumber(offset: number): Offsets;
		static fromOffsets(offsets: IOffsets): Offsets;
		static fromSide(horizontal: number, vertical: number): Offsets;
		normalize(): this;
		toString(): string;
		isEmpty(): boolean;
		offset(offset: IOffsets): this;
		multiply(mult: number): this;
		multiply(multHoriz: number, multVert: number): this;
		multiply(multLeft: number, multRight: number, multTop: number, multBottom: number): this;
		clone(): Offsets;
		copyFrom(obj: IOffsets): void;
		equals(obj: IOffsets): boolean;
		applyConverter(converter: SimpleConverter): this;
		readonly horizontal: number;
		readonly vertical: number;
		}
		//# sourceMappingURL=offsets.d.ts.map

lib/geometry/paddings.d.ts

		import { ICloneable, IEquatable, ISupportConverting, ISupportCopyFrom } from '../types';
		import { Offsets } from './offsets';
		export declare class Paddings extends Offsets implements IEquatable<Paddings>, ICloneable<Paddings>, ISupportCopyFrom<Paddings>, ISupportConverting<number> {
		static empty(): Paddings;
		clone(): Paddings;
		static empty(): Paddings;
		clone(): Paddings;
		}
		//# sourceMappingURL=paddings.d.ts.map

lib/geometry/point.d.ts

		@@ -5,23 +5,23 @@ import { ICloneable, IEquatable, ISupportConverting, ISupportCopyFrom, SimpleConverter } from '../types';
		export declare class Point implements IPoint, ICloneable<Point>, ISupportCopyFrom<Point>, IEquatable<Point>, ISupportConverting<number> {
		x: number;
		y: number;
		static zero(): Point;
		constructor(x: number, y: number);
		static fromNumber(num: number): Point;
		isZero(): boolean;
		toString(): string;
		copyFrom(obj: Point): void;
		clone(): Point;
		equals(obj: IPoint): boolean;
		offset(offsetX: number, offsetY: number): this;
		offsetByPoint(offset: IPoint): this;
		multiply(multiplierX: number, multiplierY: number): this;
		negative(): this;
		applyConverter(converter: SimpleConverter): this;
		static plus(a: IPoint, b: IPoint): Point;
		static minus(a: IPoint, b: IPoint): Point;
		static xComparer(a: IPoint, b: IPoint): number;
		static yComparer(a: IPoint, b: IPoint): number;
		static equals(a: IPoint, b: IPoint): boolean;
		x: number;
		y: number;
		static zero(): Point;
		constructor(x: number, y: number);
		static fromNumber(num: number): Point;
		isZero(): boolean;
		toString(): string;
		copyFrom(obj: Point): void;
		clone(): Point;
		equals(obj: IPoint): boolean;
		offset(offsetX: number, offsetY: number): this;
		offsetByPoint(offset: IPoint): this;
		multiply(multiplierX: number, multiplierY: number): this;
		negative(): this;
		applyConverter(converter: SimpleConverter): this;
		static plus(a: IPoint, b: IPoint): Point;
		static minus(a: IPoint, b: IPoint): Point;
		static xComparer(a: IPoint, b: IPoint): number;
		static yComparer(a: IPoint, b: IPoint): number;
		static equals(a: IPoint, b: IPoint): boolean;
		}
		//# sourceMappingURL=point.d.ts.map

lib/geometry/polygon.d.ts

		@@ -6,12 +6,12 @@ import { IRectangle } from './interfaces';
		export declare class Polygon<T extends Point = Point> extends PolygonalChain<T> {
		static fromRectangle(rect: IRectangle): Polygon<Point>;
		getEdge(edgeIndex: number): Segment;
		static collision<T1 extends Point, T2 extends Point>(a: Polygon<T1>, b: Polygon<T2>): CollisionResult;
		readonly numEdges: number;
		static fromRectangle(rect: IRectangle): Polygon<Point>;
		getEdge(edgeIndex: number): Segment;
		static collision<T1 extends Point, T2 extends Point>(a: Polygon<T1>, b: Polygon<T2>): CollisionResult;
		readonly numEdges: number;
		}
		export declare enum CollisionResult {
		None = 0,
		Intersect = 1,
		Contact = 2
		None = 0,
		Intersect = 1,
		Contact = 2
		}
		//# sourceMappingURL=polygon.d.ts.map

lib/geometry/polygonal-chain.d.ts

		@@ -8,10 +8,10 @@ import { ExtendedMinMax } from '../class/min-max';
		export declare class PolygonalChain<T extends Point = Point> {
		points: T[];
		constructor(points: T[]);
		getSegment(edgeIndex: number): Segment;
		rotateAround(point: IPoint, angle: number, rightSC?: boolean, byClockwise?: boolean): this;
		changeCoordinateCenterTo(p: IPoint): this;
		projection(axis: Vector): ExtendedMinMax<T>;
		readonly bounds: Rectangle;
		points: T[];
		constructor(points: T[]);
		getSegment(edgeIndex: number): Segment;
		rotateAround(point: IPoint, angle: number, rightSC?: boolean, byClockwise?: boolean): this;
		changeCoordinateCenterTo(p: IPoint): this;
		projection(axis: Vector): ExtendedMinMax<T>;
		readonly bounds: Rectangle;
		}
		//# sourceMappingURL=polygonal-chain.d.ts.map

124

lib/geometry/rectangle.d.ts

		@@ -8,69 +8,69 @@ import { Flag } from '../class/flag';
		export declare class Rectangle implements IRectangle, IEquatable<Rectangle>, ICloneable<Rectangle>, ISupportCopyFrom<Rectangle> {
		x: number;
		y: number;
		width: number;
		height: number;
		constructor(x: number, y: number, width: number, height: number);
		createRectangle(): Rectangle;
		createSize(): Size;
		createPosition(): Point;
		createVerticalInterval(): FixedInterval;
		createHorizontalInterval(): FixedInterval;
		static fromGeometry(point: IPoint, size: ISize): Rectangle;
		static fromPoints(pointA: IPoint, pointB: IPoint): Rectangle;
		static fromPositions(x1: number, y1: number, x2: number, y2: number): Rectangle;
		static fromCenter(center: Point, minRadius: number): Rectangle;
		isCollapsed(): boolean;
		isEmpty(): boolean;
		toString(): string;
		setPosition(pos: IPoint): this;
		setSize(size: ISize): this;
		setGeomerty(rect: IRectangle): this;
		moveRectangle(offsetX: number, offsetY: number): this;
		moveRectangleByPoint(offset: IPoint): this;
		resize(deltaX: number, deltaY: number): this;
		nonNegativeSize(): this;
		multiply(multiplierX: number, multiplierY: number): this;
		equals(obj: IRectangle): boolean;
		clone(): Rectangle;
		copyFrom(obj: IRectangle): void;
		containsPoint(point: IPoint): boolean;
		containsRectangle(rectangle: Rectangle): boolean;
		inflate(deltaX: number, deltaY?: number): this;
		applyOffsetsInside(offsets: IOffsets): this;
		applyNormalizedOffsetsInside(offsets: IOffsets): this;
		applyOffsetsOutside(offsets: IOffsets): this;
		applyConverter(converter: SimpleConverter<number>): this;
		static getHorizIntersection(objA: IRectangle, objB: IRectangle): FixedInterval \| null;
		static getVertIntersection(objA: IRectangle, objB: IRectangle): FixedInterval \| null;
		static getIntersection(objA: IRectangle, objB: IRectangle): Rectangle \| null;
		static getHorNonCollapsedIntersection(objA: Rectangle, objB: Rectangle): FixedInterval \| null;
		static getVertNonCollapsedIntersection(objA: Rectangle, objB: Rectangle): FixedInterval \| null;
		static getNonCollapsedIntersection(objA: Rectangle, objB: Rectangle): Rectangle \| null;
		static areIntersected(rectA: IRectangle, rectB: IRectangle): boolean;
		static union(rectA: IRectangle, rectB: IRectangle): Rectangle;
		static equals(a: IRectangle, b: IRectangle): boolean;
		static center(rect: IRectangle): Point;
		static containsPoint(rect: IRectangle, point: IPoint): boolean;
		readonly right: number;
		readonly bottom: number;
		readonly center: Point;
		x: number;
		y: number;
		width: number;
		height: number;
		constructor(x: number, y: number, width: number, height: number);
		createRectangle(): Rectangle;
		createSize(): Size;
		createPosition(): Point;
		createVerticalInterval(): FixedInterval;
		createHorizontalInterval(): FixedInterval;
		static fromGeometry(point: IPoint, size: ISize): Rectangle;
		static fromPoints(pointA: IPoint, pointB: IPoint): Rectangle;
		static fromPositions(x1: number, y1: number, x2: number, y2: number): Rectangle;
		static fromCenter(center: Point, minRadius: number): Rectangle;
		isCollapsed(): boolean;
		isEmpty(): boolean;
		toString(): string;
		setPosition(pos: IPoint): this;
		setSize(size: ISize): this;
		setGeomerty(rect: IRectangle): this;
		moveRectangle(offsetX: number, offsetY: number): this;
		moveRectangleByPoint(offset: IPoint): this;
		resize(deltaX: number, deltaY: number): this;
		nonNegativeSize(): this;
		multiply(multiplierX: number, multiplierY: number): this;
		equals(obj: IRectangle): boolean;
		clone(): Rectangle;
		copyFrom(obj: IRectangle): void;
		containsPoint(point: IPoint): boolean;
		containsRectangle(rectangle: Rectangle): boolean;
		inflate(deltaX: number, deltaY?: number): this;
		applyOffsetsInside(offsets: IOffsets): this;
		applyNormalizedOffsetsInside(offsets: IOffsets): this;
		applyOffsetsOutside(offsets: IOffsets): this;
		applyConverter(converter: SimpleConverter<number>): this;
		static getHorizIntersection(objA: IRectangle, objB: IRectangle): FixedInterval \| null;
		static getVertIntersection(objA: IRectangle, objB: IRectangle): FixedInterval \| null;
		static getIntersection(objA: IRectangle, objB: IRectangle): Rectangle \| null;
		static getHorNonCollapsedIntersection(objA: Rectangle, objB: Rectangle): FixedInterval \| null;
		static getVertNonCollapsedIntersection(objA: Rectangle, objB: Rectangle): FixedInterval \| null;
		static getNonCollapsedIntersection(objA: Rectangle, objB: Rectangle): Rectangle \| null;
		static areIntersected(rectA: IRectangle, rectB: IRectangle): boolean;
		static union(rectA: IRectangle, rectB: IRectangle): Rectangle;
		static equals(a: IRectangle, b: IRectangle): boolean;
		static center(rect: IRectangle): Point;
		static containsPoint(rect: IRectangle, point: IPoint): boolean;
		readonly right: number;
		readonly bottom: number;
		readonly center: Point;
		}
		export declare enum HitTestDeviation {
		None = 0,
		Top = 1,
		Bottom = 2,
		Left = 4,
		Right = 8
		None = 0,
		Top = 1,
		Bottom = 2,
		Left = 4,
		Right = 8
		}
		export declare class RectangleDeviation {
		initRectangle: Rectangle;
		initPoint: Point;
		deviation: Flag;
		offsetToInside: Point;
		insidePoint: Point;
		constructor(initRectangle: Rectangle, initPoint: Point);
		calcDeviation(): this;
		calcAdditionalParams(): this;
		initRectangle: Rectangle;
		initPoint: Point;
		deviation: Flag;
		offsetToInside: Point;
		insidePoint: Point;
		constructor(initRectangle: Rectangle, initPoint: Point);
		calcDeviation(): this;
		calcAdditionalParams(): this;
		}
		//# sourceMappingURL=rectangle.d.ts.map

lib/geometry/segment.d.ts

		import { IPoint, IRectangle } from './interfaces';
		import { Point } from './point';
		export declare class Segment<T extends Point = Point> {
		startPoint: T;
		endPoint: T;
		constructor(startPoint: T, endPoint: T);
		isIntersected<AnotherT extends Point>(segment: Segment<AnotherT>): boolean;
		containsPoint(point: IPoint, accuracy?: number): boolean;
		isIntersectedByRect(rect: IRectangle): boolean;
		private intersectCore;
		readonly length: number;
		readonly xLength: number;
		readonly yLength: number;
		readonly center: Point;
		startPoint: T;
		endPoint: T;
		constructor(startPoint: T, endPoint: T);
		isIntersected<AnotherT extends Point>(segment: Segment<AnotherT>): boolean;
		containsPoint(point: IPoint, accuracy?: number): boolean;
		isIntersectedByRect(rect: IRectangle): boolean;
		private intersectCore;
		readonly length: number;
		readonly xLength: number;
		readonly yLength: number;
		readonly center: Point;
		}
		//# sourceMappingURL=segment.d.ts.map

lib/geometry/size.d.ts

		import { ICloneable, IEquatable, ISupportCopyFrom, SimpleConverter } from '../types';
		import { ISize } from './interfaces';
		export declare class Size implements ISize, ICloneable<Size>, ISupportCopyFrom<Size>, IEquatable<ISize> {
		width: number;
		height: number;
		static empty(): Size;
		constructor(width: number, height: number);
		static fromNumber(num: number): Size;
		static initByCommonAction(action: (directAdp: (s: ISize) => number, reverseAdp: (s: ISize) => number) => number): Size;
		isEmpty(): boolean;
		toString(): string;
		nonNegativeSize(): this;
		offset(offsetWidth: number, offsetHeight: number): this;
		multiply(multiplierW: number, multiplierH: number): this;
		equals(obj: ISize): boolean;
		clone(): Size;
		copyFrom(obj: Size): void;
		applyConverter(conv: SimpleConverter): this;
		static equals(a: ISize, b: ISize): boolean;
		width: number;
		height: number;
		static empty(): Size;
		constructor(width: number, height: number);
		static fromNumber(num: number): Size;
		static initByCommonAction(action: (directAdp: (s: ISize) => number, reverseAdp: (s: ISize) => number) => number): Size;
		isEmpty(): boolean;
		toString(): string;
		nonNegativeSize(): this;
		offset(offsetWidth: number, offsetHeight: number): this;
		multiply(multiplierW: number, multiplierH: number): this;
		equals(obj: ISize): boolean;
		clone(): Size;
		copyFrom(obj: Size): void;
		applyConverter(conv: SimpleConverter): this;
		static equals(a: ISize, b: ISize): boolean;
		}
		//# sourceMappingURL=size.d.ts.map

lib/geometry/vector.d.ts

		import { Point } from './point';
		import { Segment } from './segment';
		export declare class Vector {
		x: number;
		y: number;
		constructor(x?: number, y?: number);
		static fromPoints(begin: Point, end: Point): Vector;
		static fromSegment(segment: Segment): Vector;
		normalize(): Vector;
		negative(): this;
		static angleBetween(a: Vector, b: Vector): number;
		static scalarProduct(a: Point \| Vector, b: Point \| Vector): number;
		readonly length: number;
		readonly axisX: Vector;
		readonly axisY: Vector;
		x: number;
		y: number;
		constructor(x?: number, y?: number);
		static fromPoints(begin: Point, end: Point): Vector;
		static fromSegment(segment: Segment): Vector;
		normalize(): Vector;
		negative(): this;
		static angleBetween(a: Vector, b: Vector): number;
		static scalarProduct(a: Point \| Vector, b: Point \| Vector): number;
		readonly length: number;
		readonly axisX: Vector;
		readonly axisY: Vector;
		}
		//# sourceMappingURL=vector.d.ts.map

lib/intervals/algorithms.d.ts

		@@ -7,24 +7,24 @@ import { ConstInterval } from './const';
		export declare class IntervalAlgorithms {
		static oneConstainsOtherArraysOfInterval(mergedIntervalsA: FixedInterval[], intervalsB: FixedInterval[]): boolean;
		static getIntersection<T extends ConstInterval>(intervalA: T & IReproducibleInterval<T>, intervalB: T): T \| null;
		static getIntersectionTemplate<ResultIntervalT extends ConstInterval, TemplateT extends IReproducibleInterval<ResultIntervalT>>(intervalA: ConstInterval, intervalB: ConstInterval, template: TemplateT): ResultIntervalT \| null;
		static getIntersectionNonNullLength<T extends ConstInterval>(intervalA: T & IReproducibleInterval<T>, intervalB: ConstInterval): T \| null;
		static getIntersectionNonNullLengthTemplate<ResultIntervalT extends ConstInterval, TemplateT extends IReproducibleInterval<ResultIntervalT>>(intervalA: ConstInterval, intervalB: ConstInterval, template: TemplateT): ResultIntervalT \| null;
		static getIntersectionsTwoArraysOfInterval<T extends MutableInterval>(intervalsA: (T & IReproducibleInterval<T>)[], intervalsB: ConstInterval[]): T[];
		static getIntersectionsTwoArraysOfIntervalTemplate<ResultIntervalT extends MutableInterval, TemplateT extends IReproducibleInterval<ResultIntervalT>>(intervalsA: ConstInterval[], intervalsB: ConstInterval[], template: TemplateT): ResultIntervalT[];
		static getAffectedObjects<T extends MutableInterval, TObj extends {
		interval: T;
		}>(objects: TObj[], intervals: (T & IReproducibleInterval<T>)[], getFirstIndex?: (start: number, objects: TObj[]) => number, conflictResolver?: (objectInterval: ConstInterval, touchingIntervalLength: number, touchPoint: number) => boolean): SparseIntervals<T>;
		static getAffectedObjectsTemplate<ResultIntervalT extends MutableInterval, TemplateT extends IReproducibleInterval<ResultIntervalT>, TObj extends {
		interval: ConstInterval;
		}>(objects: TObj[], intervals: ConstInterval[], template: TemplateT, getFirstIndex?: (start: number, objects: TObj[]) => number, conflictResolver?: (objectInterval: ConstInterval, touchingIntervalLength: number, touchPoint: number) => boolean): SparseIntervals<ResultIntervalT>;
		static handleAffectedObjects<IntervalT extends ConstInterval, TObj extends {
		interval: ConstInterval;
		}>(objects: TObj[], intervals: IntervalT[], callback: (obj: TObj, index: number, interval: IntervalT, intersection: ConstInterval) => void, getFirstIndex?: (start: number, objects: TObj[]) => number): void;
		static getMergedIntervals<T extends ConstInterval>(intervals: (T & IReproducibleInterval<T>)[], needSort: boolean): T[];
		static getMergedIntervalsTemplate<ResultIntervalT extends ConstInterval>(intervals: ConstInterval[], needSort: boolean, template: IReproducibleInterval<ResultIntervalT>): ResultIntervalT[];
		static reflectIntervals<T extends ConstInterval>(intervals: T[], bounds: (T & IReproducibleInterval<T>)): T[];
		static reflectIntervalsTemplate<ResultT extends ConstInterval>(intervals: ConstInterval[], bounds: ConstInterval, template: IReproducibleInterval<ResultT>): ResultT[];
		static reflectionOfPointOnInterval(value: number, valInterval: FixedInterval, targetInterval: FixedInterval): number;
		static oneConstainsOtherArraysOfInterval(mergedIntervalsA: FixedInterval[], intervalsB: FixedInterval[]): boolean;
		static getIntersection<T extends ConstInterval>(intervalA: T & IReproducibleInterval<T>, intervalB: T): T \| null;
		static getIntersectionTemplate<ResultIntervalT extends ConstInterval, TemplateT extends IReproducibleInterval<ResultIntervalT>>(intervalA: ConstInterval, intervalB: ConstInterval, template: TemplateT): ResultIntervalT \| null;
		static getIntersectionNonNullLength<T extends ConstInterval>(intervalA: T & IReproducibleInterval<T>, intervalB: ConstInterval): T \| null;
		static getIntersectionNonNullLengthTemplate<ResultIntervalT extends ConstInterval, TemplateT extends IReproducibleInterval<ResultIntervalT>>(intervalA: ConstInterval, intervalB: ConstInterval, template: TemplateT): ResultIntervalT \| null;
		static getIntersectionsTwoArraysOfInterval<T extends MutableInterval>(intervalsA: (T & IReproducibleInterval<T>)[], intervalsB: ConstInterval[]): T[];
		static getIntersectionsTwoArraysOfIntervalTemplate<ResultIntervalT extends MutableInterval, TemplateT extends IReproducibleInterval<ResultIntervalT>>(intervalsA: ConstInterval[], intervalsB: ConstInterval[], template: TemplateT): ResultIntervalT[];
		static getAffectedObjects<T extends MutableInterval, TObj extends {
		interval: T;
		}>(objects: TObj[], intervals: (T & IReproducibleInterval<T>)[], getFirstIndex?: (start: number, objects: TObj[]) => number, conflictResolver?: (objectInterval: ConstInterval, touchingIntervalLength: number, touchPoint: number) => boolean): SparseIntervals<T>;
		static getAffectedObjectsTemplate<ResultIntervalT extends MutableInterval, TemplateT extends IReproducibleInterval<ResultIntervalT>, TObj extends {
		interval: ConstInterval;
		}>(objects: TObj[], intervals: ConstInterval[], template: TemplateT, getFirstIndex?: (start: number, objects: TObj[]) => number, conflictResolver?: (objectInterval: ConstInterval, touchingIntervalLength: number, touchPoint: number) => boolean): SparseIntervals<ResultIntervalT>;
		static handleAffectedObjects<IntervalT extends ConstInterval, TObj extends {
		interval: ConstInterval;
		}>(objects: TObj[], intervals: IntervalT[], callback: (obj: TObj, index: number, interval: IntervalT, intersection: ConstInterval) => void, getFirstIndex?: (start: number, objects: TObj[]) => number): void;
		static getMergedIntervals<T extends ConstInterval>(intervals: (T & IReproducibleInterval<T>)[], needSort: boolean): T[];
		static getMergedIntervalsTemplate<ResultIntervalT extends ConstInterval>(intervals: ConstInterval[], needSort: boolean, template: IReproducibleInterval<ResultIntervalT>): ResultIntervalT[];
		static reflectIntervals<T extends ConstInterval>(intervals: T[], bounds: (T & IReproducibleInterval<T>)): T[];
		static reflectIntervalsTemplate<ResultT extends ConstInterval>(intervals: ConstInterval[], bounds: ConstInterval, template: IReproducibleInterval<ResultT>): ResultT[];
		static reflectionOfPointOnInterval(value: number, valInterval: FixedInterval, targetInterval: FixedInterval): number;
		}
		//# sourceMappingURL=algorithms.d.ts.map

lib/intervals/boundary.d.ts

		@@ -6,17 +6,17 @@ import { ICloneable, IEquatable, ISupportCopyFrom } from '../types';
		export declare class BoundaryInterval extends MutableInterval implements IEquatable<BoundaryInterval>, ICloneable<BoundaryInterval>, ISupportCopyFrom<BoundaryInterval>, IReproducibleInterval<BoundaryInterval> {
		start: number;
		end: number;
		constructor(start: number, end: number);
		static normalized(pointA: number, pointB: number): BoundaryInterval;
		copyFrom(obj: BoundaryInterval): void;
		equals(obj: BoundaryInterval): boolean;
		clone(): BoundaryInterval;
		makeByStartEnd(start: number, end: number): BoundaryInterval;
		makeByStartLength(start: number, length: number): BoundaryInterval;
		makeByLengthEnd(length: number, end: number): BoundaryInterval;
		static makeByConstInterval(interval: ConstInterval): BoundaryInterval;
		expand(interval: BoundaryInterval): this;
		length: number;
		readonly center: number;
		start: number;
		end: number;
		constructor(start: number, end: number);
		static normalized(pointA: number, pointB: number): BoundaryInterval;
		copyFrom(obj: BoundaryInterval): void;
		equals(obj: BoundaryInterval): boolean;
		clone(): BoundaryInterval;
		makeByStartEnd(start: number, end: number): BoundaryInterval;
		makeByStartLength(start: number, length: number): BoundaryInterval;
		makeByLengthEnd(length: number, end: number): BoundaryInterval;
		static makeByConstInterval(interval: ConstInterval): BoundaryInterval;
		expand(interval: BoundaryInterval): this;
		length: number;
		readonly center: number;
		}
		//# sourceMappingURL=boundary.d.ts.map

lib/intervals/const.d.ts

		export declare abstract class ConstInterval {
		isNormalized(): boolean;
		isCollapsed(): boolean;
		equals(obj: ConstInterval): boolean;
		static isCollapsed(intervals: ConstInterval[]): boolean;
		containsInterval(interval: ConstInterval): boolean;
		containsIntervalWithoutEnd(interval: ConstInterval): boolean;
		contains(pos: number): boolean;
		containsWithIntervalEnd(val: number): boolean;
		containsWithoutIntervalEndAndStart(pos: number): boolean;
		readonly start: number;
		readonly length: number;
		readonly end: number;
		readonly center: number;
		isNormalized(): boolean;
		isCollapsed(): boolean;
		equals(obj: ConstInterval): boolean;
		static isCollapsed(intervals: ConstInterval[]): boolean;
		containsInterval(interval: ConstInterval): boolean;
		containsIntervalWithoutEnd(interval: ConstInterval): boolean;
		contains(pos: number): boolean;
		containsWithIntervalEnd(val: number): boolean;
		containsWithoutIntervalEndAndStart(pos: number): boolean;
		readonly start: number;
		readonly length: number;
		readonly end: number;
		readonly center: number;
		}
		//# sourceMappingURL=const.d.ts.map

lib/intervals/fixed.d.ts

		@@ -6,17 +6,17 @@ import { ICloneable, IEquatable, ISupportCopyFrom } from '../types';
		export declare class FixedInterval extends MutableInterval implements IEquatable<FixedInterval>, ICloneable<FixedInterval>, ISupportCopyFrom<FixedInterval>, IReproducibleInterval<FixedInterval> {
		start: number;
		length: number;
		constructor(start: number, length: number);
		copyFrom(obj: FixedInterval): void;
		equals(obj: FixedInterval): boolean;
		clone(): FixedInterval;
		makeByStartEnd(start: number, end: number): FixedInterval;
		makeByStartLength(start: number, length: number): FixedInterval;
		makeByLengthEnd(length: number, end: number): FixedInterval;
		static fromPositions(start: number, end: number): FixedInterval;
		static makeByConstInterval(interval: ConstInterval): FixedInterval;
		expand(interval: FixedInterval): this;
		end: number;
		readonly center: number;
		start: number;
		length: number;
		constructor(start: number, length: number);
		copyFrom(obj: FixedInterval): void;
		equals(obj: FixedInterval): boolean;
		clone(): FixedInterval;
		makeByStartEnd(start: number, end: number): FixedInterval;
		makeByStartLength(start: number, length: number): FixedInterval;
		makeByLengthEnd(length: number, end: number): FixedInterval;
		static fromPositions(start: number, end: number): FixedInterval;
		static makeByConstInterval(interval: ConstInterval): FixedInterval;
		expand(interval: FixedInterval): this;
		end: number;
		readonly center: number;
		}
		//# sourceMappingURL=fixed.d.ts.map

lib/intervals/mutable.d.ts

		import { ConstInterval } from './const';
		export declare abstract class MutableInterval extends ConstInterval {
		abstract expand(interval: ConstInterval): this;
		normalizeLength(): this;
		start: number;
		length: number;
		end: number;
		abstract expand(interval: ConstInterval): this;
		normalizeLength(): this;
		start: number;
		length: number;
		end: number;
		}
		//# sourceMappingURL=mutable.d.ts.map

lib/intervals/reproducible.d.ts

		import { ConstInterval } from './const';
		export interface IReproducibleInterval<T extends ConstInterval> {
		makeByStartEnd(start: number, end: number): T;
		makeByStartLength(start: number, length: number): T;
		makeByLengthEnd(length: number, end: number): T;
		makeByStartEnd(start: number, end: number): T;
		makeByStartLength(start: number, length: number): T;
		makeByLengthEnd(length: number, end: number): T;
		}
		//# sourceMappingURL=reproducible.d.ts.map

lib/intervals/sparse/collector.d.ts

		@@ -5,9 +5,9 @@ import { MutableInterval } from '../mutable';
		export declare class SparseIntervalsCollector<IntervalT extends MutableInterval, TemplateT extends IReproducibleInterval<IntervalT>> {
		private intervals;
		private curr;
		private template;
		constructor(template: TemplateT);
		add(index: number): void;
		getIntervals(): SparseIntervals<IntervalT>;
		private intervals;
		private curr;
		private template;
		constructor(template: TemplateT);
		add(index: number): void;
		getIntervals(): SparseIntervals<IntervalT>;
		}
		//# sourceMappingURL=collector.d.ts.map

lib/intervals/sparse/intervals.d.ts

		@@ -5,12 +5,12 @@ import { ConstInterval } from '../const';
		export declare class SparseIntervals<T extends ConstInterval> {
		private list;
		private _count;
		private _numIntervals;
		constructor(list?: T[]);
		getInterval(index: number): T;
		getNativeIterator(): SparseIntervalsIterator<T>;
		getObjectsIterator<ObjT extends any>(objects: ObjT[]): SparseObjectsIterator<T, ObjT>;
		readonly count: number;
		readonly numIntervals: number;
		private list;
		private _count;
		private _numIntervals;
		constructor(list?: T[]);
		getInterval(index: number): T;
		getNativeIterator(): SparseIntervalsIterator<T>;
		getObjectsIterator<ObjT extends any>(objects: ObjT[]): SparseObjectsIterator<T, ObjT>;
		readonly count: number;
		readonly numIntervals: number;
		}
		//# sourceMappingURL=intervals.d.ts.map

lib/intervals/sparse/iterator.d.ts

		import { ConstInterval } from '../const';
		import { SparseIntervals } from './intervals';
		export declare class SparseIntervalsIterator<T extends ConstInterval> {
		index: number;
		private sparseIntervals;
		private curr;
		private intervalIndex;
		private posInInterval;
		constructor(sparseIntervals: SparseIntervals<T>);
		moveNext(): boolean;
		movePrev(): boolean;
		protected initObject(): void;
		readonly isStarted: boolean;
		index: number;
		private sparseIntervals;
		private curr;
		private intervalIndex;
		private posInInterval;
		constructor(sparseIntervals: SparseIntervals<T>);
		moveNext(): boolean;
		movePrev(): boolean;
		protected initObject(): void;
		readonly isStarted: boolean;
		}
		//# sourceMappingURL=iterator.d.ts.map

lib/intervals/sparse/map-collector.d.ts

		@@ -6,12 +6,12 @@ import { CmpFunc } from '../../types';
		export declare class SparseIntervalsMapCollector<IntervalT extends MutableInterval, TemplateT extends IReproducibleInterval<IntervalT>, ObjT> {
		private valMap;
		private intervals;
		private curr;
		private currVal;
		private cmp;
		private template;
		constructor(cmp: CmpFunc<ObjT>, template: TemplateT);
		add(index: number, value: ObjT): void;
		getIterator(): SparseIntervalsMapIterator<IntervalT, ObjT>;
		private valMap;
		private intervals;
		private curr;
		private currVal;
		private cmp;
		private template;
		constructor(cmp: CmpFunc<ObjT>, template: TemplateT);
		add(index: number, value: ObjT): void;
		getIterator(): SparseIntervalsMapIterator<IntervalT, ObjT>;
		}
		//# sourceMappingURL=map-collector.d.ts.map

lib/intervals/sparse/map-iterator.d.ts

		import { ConstInterval } from '../const';
		export declare class SparseIntervalsMapIterator<T extends ConstInterval, ObjT> {
		private valMap;
		private sparseIntervals;
		position: number;
		object: ObjT;
		interval: T;
		intervalIndex: number;
		posInInterval: number;
		constructor(intervals: T[], valMap: Record<number, ObjT>);
		moveToNextPosition(): boolean;
		moveToNextInterval(): boolean;
		readonly numIntervals: number;
		private valMap;
		private sparseIntervals;
		position: number;
		object: ObjT;
		interval: T;
		intervalIndex: number;
		posInInterval: number;
		constructor(intervals: T[], valMap: Record<number, ObjT>);
		moveToNextPosition(): boolean;
		moveToNextInterval(): boolean;
		readonly numIntervals: number;
		}
		//# sourceMappingURL=map-iterator.d.ts.map

lib/intervals/sparse/objects-iterator.d.ts

		@@ -5,7 +5,7 @@ import { ConstInterval } from '../const';
		export declare class SparseObjectsIterator<T extends ConstInterval, ObjT> extends SparseIntervalsIterator<T> {
		objects: ObjT[];
		obj: ObjT;
		constructor(sparseIntervals: SparseIntervals<T>, objects: ObjT[]);
		protected initObject(): void;
		objects: ObjT[];
		obj: ObjT;
		constructor(sparseIntervals: SparseIntervals<T>, objects: ObjT[]);
		protected initObject(): void;
		}
		//# sourceMappingURL=objects-iterator.d.ts.map

lib/pdf/helper-frame.d.ts

		export declare class PdfHelperFrame {
		private readonly container;
		private readonly frameClassName;
		private helperFrame;
		private helperFrameName;
		constructor(container: HTMLElement, frameClassName: string);
		dispose(): void;
		showPrintDialog(resourceUrl: string): void;
		private getHelperFrame;
		private removeHelperFrame;
		private createHelperFrame;
		private getNewName;
		private readonly container;
		private readonly frameClassName;
		private helperFrame;
		private helperFrameName;
		constructor(container: HTMLElement, frameClassName: string);
		dispose(): void;
		showPrintDialog(resourceUrl: string): void;
		private getHelperFrame;
		private removeHelperFrame;
		private createHelperFrame;
		private getNewName;
		}
		//# sourceMappingURL=helper-frame.d.ts.map

lib/pdf/plugin-helper.d.ts

		export declare class PdfPluginHelper {
		private static plugin;
		static isInstalled(): boolean;
		static getPdfPlugin(): any;
		static getActiveXObject(name: string): ActiveXObject \| null;
		static getNavigatorPlugin(name: string): Plugin \| null;
		static getVersion(): number \| null;
		private static plugin;
		static isInstalled(): boolean;
		static getPdfPlugin(): any;
		static getActiveXObject(name: string): ActiveXObject \| null;
		static getNavigatorPlugin(name: string): Plugin \| null;
		static getVersion(): number \| null;
		}
		//# sourceMappingURL=plugin-helper.d.ts.map

lib/sequence-comparison/common.d.ts

		export declare enum SesType {
		Delete = -1,
		Common = 0,
		Add = 1
		Delete = -1,
		Common = 0,
		Add = 1
		}
		export interface ISequenceComparatorItertor<T> {
		length: number;
		getComparer(): ((a: T, b: T) => boolean);
		getByIndex(index: number): T;
		length: number;
		getComparer(): ((a: T, b: T) => boolean);
		getByIndex(index: number): T;
		}
		export declare class SesElem<T> {
		elem: T;
		type: SesType;
		constructor(elem: T, type: SesType);
		toString(): string;
		elem: T;
		type: SesType;
		constructor(elem: T, type: SesType);
		toString(): string;
		}
		export declare class SequenceComparator<T> {
		editDistance: number \| null;
		lcs: string;
		ses: SesElem<T>[];
		private readonly reverse;
		private readonly offset;
		private readonly path;
		private readonly pathposi;
		private readonly comparer;
		private a;
		private b;
		private m;
		private n;
		constructor(a: ISequenceComparatorItertor<T>, b: ISequenceComparatorItertor<T>);
		calculate(): SesElem<T>[];
		toString(): string;
		protected snake(k: number, p: number, pp: number): number;
		protected recordSeq(epc: PathElem[]): void;
		editDistance: number \| null;
		lcs: string;
		ses: SesElem<T>[];
		private readonly reverse;
		private readonly offset;
		private readonly path;
		private readonly pathposi;
		private readonly comparer;
		private a;
		private b;
		private m;
		private n;
		constructor(a: ISequenceComparatorItertor<T>, b: ISequenceComparatorItertor<T>);
		calculate(): SesElem<T>[];
		toString(): string;
		protected snake(k: number, p: number, pp: number): number;
		protected recordSeq(epc: PathElem[]): void;
		}
		declare class PathElem {
		x: number;
		y: number;
		k: number \| null;
		constructor(x: number, y: number, k: number \| null);
		x: number;
		y: number;
		k: number \| null;
		constructor(x: number, y: number, k: number \| null);
		}
		export {};
		//# sourceMappingURL=common.d.ts.map

lib/sequence-comparison/string.d.ts

		import { ISequenceComparatorItertor, SesType } from './common';
		export declare class StringSequenceComparator {
		editDistance: number \| null;
		lcs: string;
		ses: StringSesElem[];
		private readonly reverse;
		private readonly offset;
		private readonly path;
		private readonly pathposi;
		private a;
		private b;
		private m;
		private n;
		constructor(a: string, b: string);
		calculate(): StringSesElem[];
		toString(): string;
		protected snake(k: number, p: number, pp: number): number;
		protected recordSeq(epc: PathElem[]): void;
		editDistance: number \| null;
		lcs: string;
		ses: StringSesElem[];
		private readonly reverse;
		private readonly offset;
		private readonly path;
		private readonly pathposi;
		private a;
		private b;
		private m;
		private n;
		constructor(a: string, b: string);
		calculate(): StringSesElem[];
		toString(): string;
		protected snake(k: number, p: number, pp: number): number;
		protected recordSeq(epc: PathElem[]): void;
		}
		declare class PathElem {
		x: number;
		y: number;
		k: number \| null;
		constructor(x: number, y: number, k: number \| null);
		x: number;
		y: number;
		k: number \| null;
		constructor(x: number, y: number, k: number \| null);
		}
		export declare class StringSesElem {
		elem: string;
		type: SesType;
		constructor(elem: string, type: SesType);
		toString(): string;
		elem: string;
		type: SesType;
		constructor(elem: string, type: SesType);
		toString(): string;
		}
		export declare class StringSequenceComparatorItertor implements ISequenceComparatorItertor<string> {
		str: string;
		constructor(str: string);
		getComparer(): ((a: string, b: string) => boolean);
		getByIndex(index: number): string;
		readonly length: number;
		str: string;
		constructor(str: string);
		getComparer(): ((a: string, b: string) => boolean);
		getByIndex(index: number): string;
		readonly length: number;
		}
		export {};
		//# sourceMappingURL=string.d.ts.map

lib/types.d.ts

		@@ -5,16 +5,16 @@ export declare type EqualFunc<T> = (a: T, b: T) => boolean;
		export interface ICloneable<T> {
		clone(): T;
		clone(): T;
		}
		export interface ISupportCopyFrom<T> {
		copyFrom(obj: T): void;
		copyFrom(obj: T): void;
		}
		export interface IDisposable {
		dispose(): any;
		dispose(): any;
		}
		export interface IEquatable<T> {
		equals(obj: T): boolean;
		equals(obj: T): boolean;
		}
		export interface ISupportConverting<T> {
		applyConverter(converter: SimpleConverter<T>): this;
		applyConverter(converter: SimpleConverter<T>): this;
		}
		//# sourceMappingURL=types.d.ts.map

lib/utils/attr.d.ts

		export declare class AttrUtils {
		private static readonly emptyObject;
		static setElementAttribute(obj: HTMLElement, attrName: string, value: string): void;
		static setStyleAttribute(obj: CSSStyleDeclaration, attrName: string, value: string): void;
		static getElementAttribute(obj: HTMLElement, attrName: string): string \| null;
		static getStyleAttribute(obj: CSSStyleDeclaration, attrName: string): string \| null;
		static removeElementAttribute(obj: HTMLElement, attrName: string): void;
		static removeStyleAttribute(obj: CSSStyleDeclaration, attrName: string): void;
		static changeElementStyleAttribute(obj: HTMLElement, attrName: string, newValue: string): void;
		static restoreElementStyleAttribute(obj: HTMLElement, attrName: string): boolean;
		private static saveStyleAttributeInElement;
		private static isExistsAttributeInElement;
		private static isAttributeExists;
		private static readonly emptyObject;
		static setElementAttribute(obj: HTMLElement, attrName: string, value: string): void;
		static setStyleAttribute(obj: CSSStyleDeclaration, attrName: string, value: string): void;
		static getElementAttribute(obj: HTMLElement, attrName: string): string \| null;
		static getStyleAttribute(obj: CSSStyleDeclaration, attrName: string): string \| null;
		static removeElementAttribute(obj: HTMLElement, attrName: string): void;
		static removeStyleAttribute(obj: CSSStyleDeclaration, attrName: string): void;
		static changeElementStyleAttribute(obj: HTMLElement, attrName: string, newValue: string): void;
		static restoreElementStyleAttribute(obj: HTMLElement, attrName: string): boolean;
		private static saveStyleAttributeInElement;
		private static isExistsAttributeInElement;
		private static isAttributeExists;
		}
		//# sourceMappingURL=attr.d.ts.map

lib/utils/base64.d.ts

		import { DxMimeType } from './mime-type';
		export declare class Base64Utils {
		static dataUrl: RegExp;
		static normalizeToDataUrl(base64: string, mimeType: string): string;
		static prependByDataUrl(base64: string, mimeType: string): string;
		static checkPrependDataUrl(base64: string): boolean;
		static deleteDataUrlPrefix(base64DataUrl: string): string;
		static getUint8Array(base64: string): Uint8Array;
		static fromArrayBuffer(buffer: ArrayBuffer): string;
		static getFileFromBase64(base64: string, fileName?: string, options?: FilePropertyBag): File;
		static getMimeTypeAsString(base64: string): string \| null;
		static getKnownMimeType(base64: string): DxMimeType;
		static fromBlobAsArrayBuffer(blob: Blob, callback: (base64: string) => void): void;
		static fromBlobAsDataUrl(blob: Blob, callback: (base64: string) => void): void;
		static dataUrl: RegExp;
		static normalizeToDataUrl(base64: string, mimeType: string): string;
		static prependByDataUrl(base64: string, mimeType: string): string;
		static checkPrependDataUrl(base64: string): boolean;
		static deleteDataUrlPrefix(base64DataUrl: string): string;
		static getUint8Array(base64: string): Uint8Array;
		static fromArrayBuffer(buffer: ArrayBuffer): string;
		static getFileFromBase64(base64: string, fileName?: string, options?: FilePropertyBag): File;
		static getMimeTypeAsString(base64: string): string \| null;
		static getKnownMimeType(base64: string): DxMimeType;
		static fromBlobAsArrayBuffer(blob: Blob, callback: (base64: string) => void): void;
		static fromBlobAsDataUrl(blob: Blob, callback: (base64: string) => void): void;
		}
		//# sourceMappingURL=base64.d.ts.map

lib/utils/color.d.ts

		export declare type Color = number;
		export declare class ColorUtils {
		static readonly DARK_COLOR: any;
		static readonly LIGHT_COLOR: any;
		static getAlpha(color: Color): number;
		static getRed(color: Color): number;
		static getGreen(color: Color): number;
		static getBlue(color: Color): number;
		static redPartToString(color: Color): string;
		static greenPartToString(color: Color): string;
		static bluePartToString(color: Color): string;
		static fromArgbNumber(alpha: number, red: number, green: number, blue: number): Color;
		static fromRgbaString(color: string, alpha?: number): Color \| null;
		static fromHashString(hash: string, alpha?: number): Color \| null;
		static fromColorName(color: string, alpha?: number): Color \| null;
		static fromString(color: string, alpha?: number): Color \| null;
		static colorToHash(color: Color): string;
		static stringToHash(color: string): string \| null;
		static isHashColorString(color: string): boolean;
		static isKnownColorName(color: string): boolean;
		static isGray(color: number): boolean;
		static colorNames: Record<string, string>;
		static readonly DARK_COLOR: any;
		static readonly LIGHT_COLOR: any;
		static getAlpha(color: Color): number;
		static getRed(color: Color): number;
		static getGreen(color: Color): number;
		static getBlue(color: Color): number;
		static redPartToString(color: Color): string;
		static greenPartToString(color: Color): string;
		static bluePartToString(color: Color): string;
		static fromArgbNumber(alpha: number, red: number, green: number, blue: number): Color;
		static fromRgbaString(color: string, alpha?: number): Color \| null;
		static fromHashString(hash: string, alpha?: number): Color \| null;
		static fromColorName(color: string, alpha?: number): Color \| null;
		static fromString(color: string, alpha?: number): Color \| null;
		static colorToHash(color: Color): string;
		static stringToHash(color: string): string \| null;
		static isHashColorString(color: string): boolean;
		static isKnownColorName(color: string): boolean;
		static isGray(color: number): boolean;
		static colorNames: Record<string, string>;
		}
		//# sourceMappingURL=color.d.ts.map

lib/utils/comparers.d.ts

		import { IEquatable } from '../types';
		export declare class Comparers {
		static number(a: number, b: number): number;
		static string(a: string, b: string): number;
		static stringIgnoreCase(a: string, b: string): number;
		static number(a: number, b: number): number;
		static string(a: string, b: string): number;
		static stringIgnoreCase(a: string, b: string): number;
		}
		export declare class Equals {
		static simpleType<T extends number \| boolean \| string>(a: T, b: T): boolean;
		static object<T extends IEquatable<T>>(a: T, b: T): boolean;
		static simpleType<T extends number \| boolean \| string>(a: T, b: T): boolean;
		static object<T extends IEquatable<T>>(a: T, b: T): boolean;
		}
		//# sourceMappingURL=comparers.d.ts.map

lib/utils/data-transfer.d.ts

		export declare class DataTransferUtils {
		private static isBrowserSupportExtendedClientBuffer;
		static getPlainTextItem(items: DataTransferItemList): DataTransferItem \| null;
		static getRtfTextItem(items: DataTransferItemList): DataTransferItem \| null;
		static getImageItem(items: DataTransferItemList): File \| null;
		static getTransferItemByType(items: DataTransferItemList, type: string): DataTransferItem \| null;
		private static isBrowserSupportExtendedClientBuffer;
		static getPlainTextItem(items: DataTransferItemList): DataTransferItem \| null;
		static getRtfTextItem(items: DataTransferItemList): DataTransferItem \| null;
		static getImageItem(items: DataTransferItemList): File \| null;
		static getTransferItemByType(items: DataTransferItemList, type: string): DataTransferItem \| null;
		}
		//# sourceMappingURL=data-transfer.d.ts.map

lib/utils/dom.d.ts

		import { IPoint, IRectangle, ISize } from '../geometry/interfaces';
		export declare class DomUtils {
		private static html2PlainTextFilter;
		private static verticalScrollBarWidth;
		static clearInnerHtml(element: HTMLElement): void;
		static setStylePosition(style: CSSStyleDeclaration, point: IPoint): void;
		static setStyleSize(style: CSSStyleDeclaration, size: ISize): void;
		static setStyleSizeAndPosition(style: CSSStyleDeclaration, rectangle: IRectangle): void;
		static hideNode(node: Node \| null \| undefined): void;
		static isHTMLElementNode(node: Node): node is HTMLElement;
		static isTextNode(node: Node): boolean;
		static isElementNode(node: Node): node is Element;
		static isHTMLTableRowElement(element: Element): element is HTMLTableRowElement;
		static isItParent(parentElement: Node, element: HTMLElement): boolean;
		static getParentByTagName(element: HTMLElement, tagName: string): HTMLElement \| null;
		static getDocumentScrollTop(): number;
		static getDocumentScrollLeft(): number;
		static getCurrentStyle(element: HTMLElement): CSSStyleDeclaration;
		static setFocus(element: HTMLElement): void;
		static hasClassName(element: Element, className: string): boolean;
		static addClassName(element: Element, className: string): void;
		static removeClassName(element: Element, className: string): void;
		static toggleClassName(element: Element, className: string, toggle?: boolean): void;
		static pxToInt(px: string): number;
		static pxToFloat(px: string): number;
		static getAbsolutePositionY(element: HTMLElement): number;
		static getAbsolutePositionX(element: HTMLElement): number;
		static isInteractiveControl(element: HTMLElement): boolean;
		static getClearClientHeight(element: HTMLElement): number;
		static getTopBottomPaddings(element: HTMLElement, style?: CSSStyleDeclaration): number;
		static getVerticalBordersWidth(element: HTMLElement, style?: CSSStyleDeclaration): number;
		static getNodes(parent: Element, predicate: (e: Element) => boolean): Element[];
		static getChildNodes(parent: Element, predicate: (e: ChildNode) => boolean): ChildNode[];
		static getNodesByClassName(parent: Element, className: string): Element[];
		static getChildNodesByClassName(parent: Element, className: string): Element[];
		static getVerticalScrollBarWidth(): number;
		static getHorizontalBordersWidth(element: HTMLElement, style?: CSSStyleDeclaration): number;
		static getFontFamiliesFromCssString(cssString: string): string[];
		static getInnerText(container: HTMLElement): string \| null;
		private static html2PlainTextFilter;
		private static verticalScrollBarWidth;
		static clearInnerHtml(element: HTMLElement): void;
		static setStylePosition(style: CSSStyleDeclaration, point: IPoint): void;
		static setStyleSize(style: CSSStyleDeclaration, size: ISize): void;
		static setStyleSizeAndPosition(style: CSSStyleDeclaration, rectangle: IRectangle): void;
		static hideNode(node: Node \| null \| undefined): void;
		static isHTMLElementNode(node: Node): node is HTMLElement;
		static isTextNode(node: Node): boolean;
		static isElementNode(node: Node): node is Element;
		static isHTMLTableRowElement(element: Element): element is HTMLTableRowElement;
		static isItParent(parentElement: Node, element: HTMLElement): boolean;
		static getParentByTagName(element: HTMLElement, tagName: string): HTMLElement \| null;
		static getDocumentScrollTop(): number;
		static getDocumentScrollLeft(): number;
		static getCurrentStyle(element: HTMLElement): CSSStyleDeclaration;
		static setFocus(element: HTMLElement): void;
		static hasClassName(element: Element, className: string): boolean;
		static addClassName(element: Element, className: string): void;
		static removeClassName(element: Element, className: string): void;
		static toggleClassName(element: Element, className: string, toggle?: boolean): void;
		static pxToInt(px: string): number;
		static pxToFloat(px: string): number;
		static getAbsolutePositionY(element: HTMLElement): number;
		static getAbsolutePositionX(element: HTMLElement): number;
		static isInteractiveControl(element: HTMLElement): boolean;
		static getClearClientHeight(element: HTMLElement): number;
		static getTopBottomPaddings(element: HTMLElement, style?: CSSStyleDeclaration): number;
		static getVerticalBordersWidth(element: HTMLElement, style?: CSSStyleDeclaration): number;
		static getNodes(parent: Element, predicate: (e: Element) => boolean): Element[];
		static getChildNodes(parent: Element, predicate: (e: ChildNode) => boolean): ChildNode[];
		static getNodesByClassName(parent: Element, className: string): Element[];
		static getChildNodesByClassName(parent: Element, className: string): Element[];
		static getVerticalScrollBarWidth(): number;
		static getHorizontalBordersWidth(element: HTMLElement, style?: CSSStyleDeclaration): number;
		static getFontFamiliesFromCssString(cssString: string): string[];
		static getInnerText(container: HTMLElement): string \| null;
		}
		//# sourceMappingURL=dom.d.ts.map

lib/utils/encode.d.ts

		export declare class EncodeUtils {
		static encodeHtml(text: string): string;
		static decodeHtml(text: string): string;
		static prepareTextForRequest(text: string): string;
		static prepareTextForCallBackRequest(text: string): string;
		static decodeViaTextArea(html: string): string;
		static encodeHtml(text: string): string;
		static decodeHtml(text: string): string;
		static prepareTextForRequest(text: string): string;
		static prepareTextForCallBackRequest(text: string): string;
		static decodeViaTextArea(html: string): string;
		}
		//# sourceMappingURL=encode.d.ts.map

lib/utils/enum.d.ts

		export declare class EnumUtils {
		static forEach(enumObject: Record<string, unknown>, callback: (value: number) => void): void;
		static isAnyOf(value: number, ...params: number[]): boolean;
		static forEach(enumObject: Record<string, unknown>, callback: (value: number) => void): void;
		static isAnyOf(value: number, ...params: number[]): boolean;
		}
		//# sourceMappingURL=enum.d.ts.map

lib/utils/evt.d.ts

		export declare class EvtUtils {
		static preventEvent(evt: Event): void;
		static getEventSource(evt: Event): HTMLElement \| null;
		static getEventSourceByPosition(evt: MouseEvent \| TouchEvent): HTMLElement \| null;
		static getMouseWheelEventName(): string;
		static isLeftButtonPressed(evt: Event): boolean;
		static preventEventAndBubble(evt: Event): void;
		private static clientEventRequiresDocScrollCorrection;
		static getEventX(evt: MouseEvent \| TouchEvent): number;
		static getEventY(evt: MouseEvent \| TouchEvent): number;
		static cancelBubble(evt: Event): void;
		static getWheelDelta(evt: WheelEvent): number;
		static preventEvent(evt: Event): void;
		static getEventSource(evt: Event): HTMLElement \| null;
		static getEventSourceByPosition(evt: MouseEvent \| TouchEvent): HTMLElement \| null;
		static getMouseWheelEventName(): string;
		static isLeftButtonPressed(evt: Event): boolean;
		static preventEventAndBubble(evt: Event): void;
		private static clientEventRequiresDocScrollCorrection;
		static getEventX(evt: MouseEvent \| TouchEvent): number;
		static getEventY(evt: MouseEvent \| TouchEvent): number;
		static cancelBubble(evt: Event): void;
		static getWheelDelta(evt: WheelEvent): number;
		}
		//# sourceMappingURL=evt.d.ts.map

lib/utils/file.d.ts

		export declare class FileUtils {
		static loadJavascriptFile(srcUri: string, callback: () => void): {
		htmlScriptElement: HTMLScriptElement;
		};
		static startDownloadFileLocal(content: File \| Blob \| ArrayBuffer \| string, fileName: string): void;
		static loadJavascriptFile(srcUri: string, callback: () => void): {
		htmlScriptElement: HTMLScriptElement;
		};
		static startDownloadFileLocal(content: File \| Blob \| ArrayBuffer \| string, fileName: string): void;
		}
		//# sourceMappingURL=file.d.ts.map

lib/utils/fonts.d.ts

		export interface IFontFaceDescriptors {
		style?: 'normal' \| 'italic' \| string;
		weight?: 'normal' \| 'bold' \| '100' \| '200' \| '300' \| '400' \| '500' \| '600' \| '700' \| '800' \| '900' \| string \| number;
		stretch?: string;
		unicodeRange?: string;
		variant?: string;
		featureSettings?: string;
		variationSettings?: string;
		display?: string;
		style?: 'normal' \| 'italic' \| string;
		weight?: 'normal' \| 'bold' \| '100' \| '200' \| '300' \| '400' \| '500' \| '600' \| '700' \| '800' \| '900' \| string \| number;
		stretch?: string;
		unicodeRange?: string;
		variant?: string;
		featureSettings?: string;
		variationSettings?: string;
		display?: string;
		}
		export interface IFontFace extends IFontFaceDescriptors {
		family: string;
		readonly status: 'unloaded' \| 'loading' \| 'loaded' \| 'error';
		family: string;
		readonly status: 'unloaded' \| 'loading' \| 'loaded' \| 'error';
		}
		@@ -15,0 +15,0 @@ export declare function fontWebApiAvailable(): boolean;

lib/utils/json.d.ts

		export declare class JsonUtils {
		static isValid(json: string): boolean;
		static isValid(json: string): boolean;
		}
		//# sourceMappingURL=json.d.ts.map

210

lib/utils/key.d.ts

		export declare class KeyUtils {
		static getKeyModifiers(evt: MouseEvent \| KeyboardEvent): number;
		static getShortcutCode(keyCode: number, isCtrlKey: boolean, isShiftKey: boolean, isAltKey: boolean, isMetaKey: boolean): number;
		static getShortcutCodeByEvent(evt: KeyboardEvent): number;
		static getEventKeyCode(evt: KeyboardEvent): number;
		static parseShortcutString(shortcutString: string): number;
		static getKeyModifiers(evt: MouseEvent \| KeyboardEvent): number;
		static getShortcutCode(keyCode: number, isCtrlKey: boolean, isShiftKey: boolean, isAltKey: boolean, isMetaKey: boolean): number;
		static getShortcutCodeByEvent(evt: KeyboardEvent): number;
		static getEventKeyCode(evt: KeyboardEvent): number;
		static parseShortcutString(shortcutString: string): number;
		}
		export declare enum ModifierKey {
		None = 0,
		Ctrl = 65536,
		Shift = 262144,
		Alt = 1048576,
		Meta = 16777216
		None = 0,
		Ctrl = 65536,
		Shift = 262144,
		Alt = 1048576,
		Meta = 16777216
		}
		export declare enum KeyCode {
		Backspace = 8,
		Tab = 9,
		Enter = 13,
		Pause = 19,
		CapsLock = 20,
		Esc = 27,
		Space = 32,
		PageUp = 33,
		PageDown = 34,
		End = 35,
		Home = 36,
		Left = 37,
		Up = 38,
		Right = 39,
		Down = 40,
		Insert = 45,
		Delete = 46,
		Key_0 = 48,
		Key_1 = 49,
		Key_2 = 50,
		Key_3 = 51,
		Key_4 = 52,
		Key_5 = 53,
		Key_6 = 54,
		Key_7 = 55,
		Key_8 = 56,
		Key_9 = 57,
		Key_a = 65,
		Key_b = 66,
		Key_c = 67,
		Key_d = 68,
		Key_e = 69,
		Key_f = 70,
		Key_g = 71,
		Key_h = 72,
		Key_i = 73,
		Key_j = 74,
		Key_k = 75,
		Key_l = 76,
		Key_m = 77,
		Key_n = 78,
		Key_o = 79,
		Key_p = 80,
		Key_q = 81,
		Key_r = 82,
		Key_s = 83,
		Key_t = 84,
		Key_u = 85,
		Key_v = 86,
		Key_w = 87,
		Key_x = 88,
		Key_y = 89,
		Key_z = 90,
		Windows = 91,
		ContextMenu = 93,
		Numpad_0 = 96,
		Numpad_1 = 97,
		Numpad_2 = 98,
		Numpad_3 = 99,
		Numpad_4 = 100,
		Numpad_5 = 101,
		Numpad_6 = 102,
		Numpad_7 = 103,
		Numpad_8 = 104,
		Numpad_9 = 105,
		Multiply = 106,
		Add = 107,
		Subtract = 109,
		Decimal = 110,
		Divide = 111,
		F1 = 112,
		F2 = 113,
		F3 = 114,
		F4 = 115,
		F5 = 116,
		F6 = 117,
		F7 = 118,
		F8 = 119,
		F9 = 120,
		F10 = 121,
		F11 = 122,
		F12 = 123,
		NumLock = 144,
		ScrollLock = 145,
		Semicolon = 186,
		Equals = 187,
		Comma = 188,
		Dash = 189,
		Period = 190,
		ForwardSlash = 191,
		GraveAccent = 192,
		OpenBracket = 219,
		BackSlash = 220,
		CloseBracket = 221,
		SingleQuote = 222
		Backspace = 8,
		Tab = 9,
		Enter = 13,
		Pause = 19,
		CapsLock = 20,
		Esc = 27,
		Space = 32,
		PageUp = 33,
		PageDown = 34,
		End = 35,
		Home = 36,
		Left = 37,
		Up = 38,
		Right = 39,
		Down = 40,
		Insert = 45,
		Delete = 46,
		Key_0 = 48,
		Key_1 = 49,
		Key_2 = 50,
		Key_3 = 51,
		Key_4 = 52,
		Key_5 = 53,
		Key_6 = 54,
		Key_7 = 55,
		Key_8 = 56,
		Key_9 = 57,
		Key_a = 65,
		Key_b = 66,
		Key_c = 67,
		Key_d = 68,
		Key_e = 69,
		Key_f = 70,
		Key_g = 71,
		Key_h = 72,
		Key_i = 73,
		Key_j = 74,
		Key_k = 75,
		Key_l = 76,
		Key_m = 77,
		Key_n = 78,
		Key_o = 79,
		Key_p = 80,
		Key_q = 81,
		Key_r = 82,
		Key_s = 83,
		Key_t = 84,
		Key_u = 85,
		Key_v = 86,
		Key_w = 87,
		Key_x = 88,
		Key_y = 89,
		Key_z = 90,
		Windows = 91,
		ContextMenu = 93,
		Numpad_0 = 96,
		Numpad_1 = 97,
		Numpad_2 = 98,
		Numpad_3 = 99,
		Numpad_4 = 100,
		Numpad_5 = 101,
		Numpad_6 = 102,
		Numpad_7 = 103,
		Numpad_8 = 104,
		Numpad_9 = 105,
		Multiply = 106,
		Add = 107,
		Subtract = 109,
		Decimal = 110,
		Divide = 111,
		F1 = 112,
		F2 = 113,
		F3 = 114,
		F4 = 115,
		F5 = 116,
		F6 = 117,
		F7 = 118,
		F8 = 119,
		F9 = 120,
		F10 = 121,
		F11 = 122,
		F12 = 123,
		NumLock = 144,
		ScrollLock = 145,
		Semicolon = 186,
		Equals = 187,
		Comma = 188,
		Dash = 189,
		Period = 190,
		ForwardSlash = 191,
		GraveAccent = 192,
		OpenBracket = 219,
		BackSlash = 220,
		CloseBracket = 221,
		SingleQuote = 222
		}
		//# sourceMappingURL=key.d.ts.map

104

lib/utils/list.d.ts

		@@ -5,55 +5,55 @@ import { ExtendedMin, ExtendedMinMax, MinMax, ExtendedMax } from '../class/min-max';
		export declare class ListUtils {
		static remove<T>(list: T[], element: T): void;
		static removeBy<T>(list: T[], callback: (currVal: T, index: number) => boolean): T \| null;
		static shallowCopy<T>(list: T[]): T[];
		static deepCopy<T extends ICloneable<T>>(list: readonly T[]): T[];
		static initByValue<T>(numElements: number, initValue: T): T[];
		static initByCallback<T>(numElements: number, initCallback: (index: number) => T): T[];
		static forEachOnInterval(interval: ConstInterval, callback: (index: number) => void): void;
		static reverseForEachOnInterval(interval: ConstInterval, callback: (index: number) => void): void;
		static reducedMap<T, TRes>(list: readonly T[], callback: (currVal: T, index: number) => TRes \| null, startIndex?: number, endIndex?: number): TRes[];
		static filter<T>(list: readonly T[], callback: (currVal: T, index: number) => boolean, startIndex?: number, endIndex?: number): T[];
		static map<T, TRes>(list: readonly T[], callback: (currVal: T, index: number) => TRes, startIndex?: number, endIndex?: number): TRes[];
		static indexBy<T>(list: readonly T[], callback: (currElement: T, index: number) => boolean, startIndex?: number, endIndex?: number): number;
		static reverseIndexBy<T>(list: readonly T[], callback: (currElement: T, index: number) => boolean, startIndex?: number, endIndex?: number): number;
		static elementBy<T>(list: readonly T[], callback: (currElement: T, index: number) => boolean, startIndex?: number, endIndex?: number): T \| null;
		static reverseElementBy<T>(list: readonly T[], callback: (currElement: T, index: number) => boolean, startIndex?: number, endIndex?: number): T \| null;
		static last<T>(list: readonly T[]): T;
		static setLast<T>(list: T[], newVal: T): T;
		static incLast(list: number[]): number;
		static decLast(list: number[]): number;
		static equals<T extends IEquatable<T>>(a: T[], b: T[]): boolean;
		static equalsByReference(a: any[], b: any[]): boolean;
		static unique<T>(list: T[], cmp: CmpFunc<T>, equal?: CmpFunc<T>, finalizeObj?: (obj: T) => void): T[];
		static uniqueNumber(list: number[]): number[];
		static forEach<T>(list: readonly T[], callback: (value: T, index: number) => void, startIndex?: number, endIndex?: number): void;
		static forEach2<TA, TB>(listA: readonly TA[], listB: readonly TB[], callback: (valueA: TA, valueB: TB, index: number) => void, startIndex?: number, endIndex?: number): void;
		static reverseForEach<T>(list: readonly T[], callback: (value: T, index: number) => void, startIndex?: number, endIndex?: number): void;
		static reverseIndexOf<T>(list: readonly T[], element: T, startIndex?: number, endIndex?: number): number;
		static accumulate<T, TAcc>(list: readonly T[], initAccValue: TAcc, callback: (acc: TAcc, currVal: T, index: number) => TAcc, startIndex?: number, endIndex?: number): TAcc;
		static accumulateNumber<T>(list: readonly T[], callback: (currVal: T, index: number, acc: number) => number, initAccValue?: number, startIndex?: number, endIndex?: number): number;
		static anyOf<T>(list: readonly T[], callback: (currVal: T, index: number) => boolean, startIndex?: number, endIndex?: number): boolean;
		static unsafeAnyOf<T, TRes>(list: readonly T[], callback: (currVal: T, index: number) => TRes \| null \| undefined, startIndex?: number, endIndex?: number): TRes \| null;
		static reverseAnyOf<T>(list: readonly T[], callback: (currVal: T, index: number) => boolean, startIndex?: number, endIndex?: number): boolean;
		static unsafeReverseAnyOf<T, TRes>(list: readonly T[], callback: (currVal: T, index: number) => TRes \| null \| undefined, startIndex?: number, endIndex?: number): TRes \| null;
		static anyOf2<TA, TB>(listA: readonly TA[], listB: TB[], callback: (currValA: TA, currValB: TB, index: number) => boolean, startIndex?: number, endIndex?: number): boolean;
		static allOf<T>(list: readonly T[], callback: (currVal: T, index: number) => boolean, startIndex?: number, endIndex?: number): boolean;
		static allOf2<TA, TB>(listA: readonly TA[], listB: TB[], callback: (currValA: TA, currValB: TB, index: number) => boolean, startIndex?: number, endIndex?: number): boolean;
		static allOfOnInterval(interval: ConstInterval, callback: (index: number) => boolean): boolean;
		static addListOnTail<T>(resultList: T[], addedList: readonly T[]): T[];
		static joinLists<T, TRes>(converter: (list: T[]) => TRes[], ...lists: T[][]): TRes[];
		static push<T>(list: T[], element: T): T[];
		static countIf<T>(list: readonly T[], callback: (currElement: T, index: number) => boolean): number;
		static clear<T>(list: T[]): void;
		static merge<T>(list: T[], cmp: CmpFunc<T>, shouldMerge: (a: T, b: T) => boolean, merge: (toMerge: T, fromMerge: T) => void, startIndex?: number, endIndex?: number): T[];
		static min<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): T \| null;
		static max<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): T \| null;
		static minMax<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): MinMax<T> \| null;
		static minExtended<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): ExtendedMin<T> \| null;
		static maxExtended<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): ExtendedMax<T> \| null;
		static minMaxExtended<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): ExtendedMinMax<T> \| null;
		static minByCmp<T>(list: readonly T[], cmp: CmpFunc<T>, startIndex?: number, endIndex?: number): T \| null;
		static maxByCmp<T>(list: readonly T[], cmp: CmpFunc<T>, startIndex?: number, endIndex?: number): T \| null;
		static minMaxByCmp<T>(list: readonly T[], cmp: CmpFunc<T>, startIndex?: number, endIndex?: number): MinMax<T> \| null;
		static remove<T>(list: T[], element: T): void;
		static removeBy<T>(list: T[], callback: (currVal: T, index: number) => boolean): T \| null;
		static shallowCopy<T>(list: T[]): T[];
		static deepCopy<T extends ICloneable<T>>(list: readonly T[]): T[];
		static initByValue<T>(numElements: number, initValue: T): T[];
		static initByCallback<T>(numElements: number, initCallback: (index: number) => T): T[];
		static forEachOnInterval(interval: ConstInterval, callback: (index: number) => void): void;
		static reverseForEachOnInterval(interval: ConstInterval, callback: (index: number) => void): void;
		static reducedMap<T, TRes>(list: readonly T[], callback: (currVal: T, index: number) => TRes \| null, startIndex?: number, endIndex?: number): TRes[];
		static filter<T>(list: readonly T[], callback: (currVal: T, index: number) => boolean, startIndex?: number, endIndex?: number): T[];
		static map<T, TRes>(list: readonly T[], callback: (currVal: T, index: number) => TRes, startIndex?: number, endIndex?: number): TRes[];
		static indexBy<T>(list: readonly T[], callback: (currElement: T, index: number) => boolean, startIndex?: number, endIndex?: number): number;
		static reverseIndexBy<T>(list: readonly T[], callback: (currElement: T, index: number) => boolean, startIndex?: number, endIndex?: number): number;
		static elementBy<T>(list: readonly T[], callback: (currElement: T, index: number) => boolean, startIndex?: number, endIndex?: number): T \| null;
		static reverseElementBy<T>(list: readonly T[], callback: (currElement: T, index: number) => boolean, startIndex?: number, endIndex?: number): T \| null;
		static last<T>(list: readonly T[]): T;
		static setLast<T>(list: T[], newVal: T): T;
		static incLast(list: number[]): number;
		static decLast(list: number[]): number;
		static equals<T extends IEquatable<T>>(a: T[], b: T[]): boolean;
		static equalsByReference(a: any[], b: any[]): boolean;
		static unique<T>(list: T[], cmp: CmpFunc<T>, equal?: CmpFunc<T>, finalizeObj?: (obj: T) => void): T[];
		static uniqueNumber(list: number[]): number[];
		static forEach<T>(list: readonly T[], callback: (value: T, index: number) => void, startIndex?: number, endIndex?: number): void;
		static forEach2<TA, TB>(listA: readonly TA[], listB: readonly TB[], callback: (valueA: TA, valueB: TB, index: number) => void, startIndex?: number, endIndex?: number): void;
		static reverseForEach<T>(list: readonly T[], callback: (value: T, index: number) => void, startIndex?: number, endIndex?: number): void;
		static reverseIndexOf<T>(list: readonly T[], element: T, startIndex?: number, endIndex?: number): number;
		static accumulate<T, TAcc>(list: readonly T[], initAccValue: TAcc, callback: (acc: TAcc, currVal: T, index: number) => TAcc, startIndex?: number, endIndex?: number): TAcc;
		static accumulateNumber<T>(list: readonly T[], callback: (currVal: T, index: number, acc: number) => number, initAccValue?: number, startIndex?: number, endIndex?: number): number;
		static anyOf<T>(list: readonly T[], callback: (currVal: T, index: number) => boolean, startIndex?: number, endIndex?: number): boolean;
		static unsafeAnyOf<T, TRes>(list: readonly T[], callback: (currVal: T, index: number) => TRes \| null \| undefined, startIndex?: number, endIndex?: number): TRes \| null;
		static reverseAnyOf<T>(list: readonly T[], callback: (currVal: T, index: number) => boolean, startIndex?: number, endIndex?: number): boolean;
		static unsafeReverseAnyOf<T, TRes>(list: readonly T[], callback: (currVal: T, index: number) => TRes \| null \| undefined, startIndex?: number, endIndex?: number): TRes \| null;
		static anyOf2<TA, TB>(listA: readonly TA[], listB: TB[], callback: (currValA: TA, currValB: TB, index: number) => boolean, startIndex?: number, endIndex?: number): boolean;
		static allOf<T>(list: readonly T[], callback: (currVal: T, index: number) => boolean, startIndex?: number, endIndex?: number): boolean;
		static allOf2<TA, TB>(listA: readonly TA[], listB: TB[], callback: (currValA: TA, currValB: TB, index: number) => boolean, startIndex?: number, endIndex?: number): boolean;
		static allOfOnInterval(interval: ConstInterval, callback: (index: number) => boolean): boolean;
		static addListOnTail<T>(resultList: T[], addedList: readonly T[]): T[];
		static joinLists<T, TRes>(converter: (list: T[]) => TRes[], ...lists: T[][]): TRes[];
		static push<T>(list: T[], element: T): T[];
		static countIf<T>(list: readonly T[], callback: (currElement: T, index: number) => boolean): number;
		static clear<T>(list: T[]): void;
		static merge<T>(list: T[], cmp: CmpFunc<T>, shouldMerge: (a: T, b: T) => boolean, merge: (toMerge: T, fromMerge: T) => void, startIndex?: number, endIndex?: number): T[];
		static min<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): T \| null;
		static max<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): T \| null;
		static minMax<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): MinMax<T> \| null;
		static minExtended<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): ExtendedMin<T> \| null;
		static maxExtended<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): ExtendedMax<T> \| null;
		static minMaxExtended<T>(list: readonly T[], getValue: (val: T) => number, startIndex?: number, endIndex?: number): ExtendedMinMax<T> \| null;
		static minByCmp<T>(list: readonly T[], cmp: CmpFunc<T>, startIndex?: number, endIndex?: number): T \| null;
		static maxByCmp<T>(list: readonly T[], cmp: CmpFunc<T>, startIndex?: number, endIndex?: number): T \| null;
		static minMaxByCmp<T>(list: readonly T[], cmp: CmpFunc<T>, startIndex?: number, endIndex?: number): MinMax<T> \| null;
		}
		//# sourceMappingURL=list.d.ts.map

lib/utils/map/number.d.ts

		import { CmpFunc, ICloneable } from '../../types';
		import { MinMax, ExtendedMin, ExtendedMax, ExtendedMinMax } from '../../class/min-max';
		export declare class NumberMapUtils {
		static forEach<TValue>(map: Record<number, TValue>, callback: (element: TValue, key: number) => void): void;
		static map<TValue, TRes>(map: Record<number, TValue>, callback: (element: TValue, key: number) => TRes): Record<number, TRes>;
		static reducedMap<T, TRes>(map: Record<number, T>, callback: (currVal: T, key: number) => TRes \| null): Record<number, TRes>;
		static clear<T>(map: Record<number, T>): void;
		static shallowCopy<T>(map: Record<number, T>): Record<number, T>;
		static deepCopy<T extends ICloneable<T>>(map: Record<number, T>): Record<number, T>;
		static isEmpty<T>(map: Record<number, T>): boolean;
		static accumulate<T, TAcc>(map: Record<number, T>, initAccValue: TAcc, callback: (acc: TAcc, currVal: T, key: number) => TAcc): TAcc;
		static keyBy<T>(map: Record<number, T>, callback: (element: T, key: number) => boolean): number \| null;
		static elementBy<T>(map: Record<number, T>, callback: (element: T, key: number) => boolean): T \| null;
		static containsBy<T>(map: Record<number, T>, callback: (element: T, key: number) => boolean): boolean;
		static toList<T>(map: Record<number, T>): T[];
		static toListBy<T, TRes>(map: Record<number, T>, callback: (elem: T, key: number) => TRes, maxElements?: number): TRes[];
		static anyOf<T, TRes>(map: Record<number, T>, callback: (currVal: T, key: number) => TRes \| null): TRes \| null;
		static unsafeAnyOf<T, TRes>(map: Record<number, T>, callback: (currVal: T, key: number) => TRes \| null \| undefined): TRes \| null;
		static allOf<T>(map: Record<number, T>, callback: (currVal: T, key: number) => boolean): boolean;
		static mapLength<T>(map: Record<number, T>): number;
		static min<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): T \| null;
		static max<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): T \| null;
		static minMax<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): MinMax<T> \| null;
		static minExtended<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): ExtendedMin<T> \| null;
		static maxExtended<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): ExtendedMax<T> \| null;
		static minMaxExtended<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): ExtendedMinMax<T> \| null;
		static maxByCmp<T>(map: Record<number, T>, cmp: CmpFunc<T>): T \| null;
		static minByCmp<T>(map: Record<number, T>, cmp: CmpFunc<T>): T \| null;
		static forEach<TValue>(map: Record<number, TValue>, callback: (element: TValue, key: number) => void): void;
		static map<TValue, TRes>(map: Record<number, TValue>, callback: (element: TValue, key: number) => TRes): Record<number, TRes>;
		static reducedMap<T, TRes>(map: Record<number, T>, callback: (currVal: T, key: number) => TRes \| null): Record<number, TRes>;
		static clear<T>(map: Record<number, T>): void;
		static shallowCopy<T>(map: Record<number, T>): Record<number, T>;
		static deepCopy<T extends ICloneable<T>>(map: Record<number, T>): Record<number, T>;
		static isEmpty<T>(map: Record<number, T>): boolean;
		static accumulate<T, TAcc>(map: Record<number, T>, initAccValue: TAcc, callback: (acc: TAcc, currVal: T, key: number) => TAcc): TAcc;
		static keyBy<T>(map: Record<number, T>, callback: (element: T, key: number) => boolean): number \| null;
		static elementBy<T>(map: Record<number, T>, callback: (element: T, key: number) => boolean): T \| null;
		static containsBy<T>(map: Record<number, T>, callback: (element: T, key: number) => boolean): boolean;
		static toList<T>(map: Record<number, T>): T[];
		static toListBy<T, TRes>(map: Record<number, T>, callback: (elem: T, key: number) => TRes, maxElements?: number): TRes[];
		static anyOf<T, TRes>(map: Record<number, T>, callback: (currVal: T, key: number) => TRes \| null): TRes \| null;
		static unsafeAnyOf<T, TRes>(map: Record<number, T>, callback: (currVal: T, key: number) => TRes \| null \| undefined): TRes \| null;
		static allOf<T>(map: Record<number, T>, callback: (currVal: T, key: number) => boolean): boolean;
		static mapLength<T>(map: Record<number, T>): number;
		static min<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): T \| null;
		static max<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): T \| null;
		static minMax<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): MinMax<T> \| null;
		static minExtended<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): ExtendedMin<T> \| null;
		static maxExtended<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): ExtendedMax<T> \| null;
		static minMaxExtended<T>(map: Record<number, T>, getValue: (val: T, key: number) => number): ExtendedMinMax<T> \| null;
		static maxByCmp<T>(map: Record<number, T>, cmp: CmpFunc<T>): T \| null;
		static minByCmp<T>(map: Record<number, T>, cmp: CmpFunc<T>): T \| null;
		}
		//# sourceMappingURL=number.d.ts.map

lib/utils/map/string.d.ts

		import { ExtendedMax, ExtendedMin, ExtendedMinMax, MinMax } from '../../class/min-max';
		import { CmpFunc, ICloneable } from '../../types';
		export declare class StringMapUtils {
		static forEach<TValue>(map: Record<string, TValue>, callback: (element: TValue, key: string) => void): void;
		static map<TValue, TRes>(map: Record<string, TValue>, callback: (element: TValue, key: string) => TRes): Record<string, TRes>;
		static reducedMap<T, TRes>(map: Record<string, T>, callback: (currVal: T, key: string) => TRes \| null): Record<string, TRes>;
		static clear<T>(map: Record<string, T>): void;
		static shallowCopy<T>(map: Record<string, T>): Record<string, T>;
		static deepCopy<T extends ICloneable<T>>(map: Record<string, T>): Record<string, T>;
		static isEmpty<T>(map: Record<string, T>): boolean;
		static accumulate<T, TAcc>(map: Record<string, T>, initAccValue: TAcc, callback: (acc: TAcc, currVal: T, key: string) => TAcc): TAcc;
		static keyBy<T>(map: Record<string, T>, callback: (element: T, key: string) => boolean): string \| null;
		static elementBy<T>(map: Record<string, T>, callback: (element: T, key: string) => boolean): T \| null;
		static containsBy<T>(map: Record<string, T>, callback: (element: T, key: string) => boolean): boolean;
		static toList<T>(map: Record<string, T>): T[];
		static toListBy<T, TRes>(map: Record<string, T>, callback: (elem: T, key: string) => TRes, maxElements?: number): TRes[];
		static anyOf<T, TRes>(map: Record<string, T>, callback: (currVal: T, key: string) => TRes \| null): TRes \| null;
		static unsafeAnyOf<T, TRes>(map: Record<string, T>, callback: (currVal: T, key: string) => TRes \| null \| undefined): TRes \| null;
		static allOf<T>(map: Record<string, T>, callback: (currVal: T, key: string) => boolean): boolean;
		static mapLength<T>(map: Record<string, T>): number;
		static min<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): T \| null;
		static max<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): T \| null;
		static minMax<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): MinMax<T> \| null;
		static minExtended<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): ExtendedMin<T> \| null;
		static maxExtended<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): ExtendedMax<T> \| null;
		static minMaxExtended<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): ExtendedMinMax<T> \| null;
		static maxByCmp<T>(map: Record<string, T>, cmp: CmpFunc<T>): T \| null;
		static minByCmp<T>(map: Record<string, T>, cmp: CmpFunc<T>): T \| null;
		static forEach<TValue>(map: Record<string, TValue>, callback: (element: TValue, key: string) => void): void;
		static map<TValue, TRes>(map: Record<string, TValue>, callback: (element: TValue, key: string) => TRes): Record<string, TRes>;
		static reducedMap<T, TRes>(map: Record<string, T>, callback: (currVal: T, key: string) => TRes \| null): Record<string, TRes>;
		static clear<T>(map: Record<string, T>): void;
		static shallowCopy<T>(map: Record<string, T>): Record<string, T>;
		static deepCopy<T extends ICloneable<T>>(map: Record<string, T>): Record<string, T>;
		static isEmpty<T>(map: Record<string, T>): boolean;
		static accumulate<T, TAcc>(map: Record<string, T>, initAccValue: TAcc, callback: (acc: TAcc, currVal: T, key: string) => TAcc): TAcc;
		static keyBy<T>(map: Record<string, T>, callback: (element: T, key: string) => boolean): string \| null;
		static elementBy<T>(map: Record<string, T>, callback: (element: T, key: string) => boolean): T \| null;
		static containsBy<T>(map: Record<string, T>, callback: (element: T, key: string) => boolean): boolean;
		static toList<T>(map: Record<string, T>): T[];
		static toListBy<T, TRes>(map: Record<string, T>, callback: (elem: T, key: string) => TRes, maxElements?: number): TRes[];
		static anyOf<T, TRes>(map: Record<string, T>, callback: (currVal: T, key: string) => TRes \| null): TRes \| null;
		static unsafeAnyOf<T, TRes>(map: Record<string, T>, callback: (currVal: T, key: string) => TRes \| null \| undefined): TRes \| null;
		static allOf<T>(map: Record<string, T>, callback: (currVal: T, key: string) => boolean): boolean;
		static mapLength<T>(map: Record<string, T>): number;
		static min<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): T \| null;
		static max<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): T \| null;
		static minMax<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): MinMax<T> \| null;
		static minExtended<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): ExtendedMin<T> \| null;
		static maxExtended<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): ExtendedMax<T> \| null;
		static minMaxExtended<T>(map: Record<string, T>, getValue: (val: T, key: string) => number): ExtendedMinMax<T> \| null;
		static maxByCmp<T>(map: Record<string, T>, cmp: CmpFunc<T>): T \| null;
		static minByCmp<T>(map: Record<string, T>, cmp: CmpFunc<T>): T \| null;
		}
		//# sourceMappingURL=string.d.ts.map

lib/utils/math.d.ts

		export declare class MathUtils {
		private static powFactor;
		static somePrimes: number[];
		static round(value: number, digits?: number): number;
		static numberCloseTo(num: number, to: number, accuracy?: number): boolean;
		static restrictValue(val: number, minVal: number, maxVal: number): number;
		static getRandomInt(min: number, max: number): number;
		static generateGuid(): string;
		private static powFactor;
		static somePrimes: number[];
		static round(value: number, digits?: number): number;
		static numberCloseTo(num: number, to: number, accuracy?: number): boolean;
		static restrictValue(val: number, minVal: number, maxVal: number): number;
		static getRandomInt(min: number, max: number): number;
		static generateGuid(): string;
		}
		//# sourceMappingURL=math.d.ts.map

lib/utils/mime-type.d.ts

		@@ -15,28 +15,28 @@ export declare const OpenXmlMimeType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
		export declare enum DxMimeType {
		Unknown = 0,
		OpenXml = 1,
		Rtf = 2,
		PlainText = 3,
		Docm = 4,
		Png = 5,
		Gif = 6,
		Jpeg = 7,
		Pjpeg = 8,
		Svg = 9,
		Tiff = 10,
		Ico = 11,
		Wbmp = 12,
		Webp = 13
		Unknown = 0,
		OpenXml = 1,
		Rtf = 2,
		PlainText = 3,
		Docm = 4,
		Png = 5,
		Gif = 6,
		Jpeg = 7,
		Pjpeg = 8,
		Svg = 9,
		Tiff = 10,
		Ico = 11,
		Wbmp = 12,
		Webp = 13
		}
		export declare class MimeTypeUtils {
		static stringTypeToTypeMap: Record<string, DxMimeType \| undefined>;
		static typeToStringTypeMap: Record<DxMimeType, string \| undefined>;
		static typeToExtensionMap: Record<DxMimeType, string \| undefined>;
		static extensionToTypeMap: Record<string, DxMimeType \| undefined>;
		static stringTypeToExtension(mimeTypeAsStr: string): string;
		static typeToExtension(mimeType: DxMimeType): string;
		static extensionToType(extension: string): DxMimeType;
		static typeToStringType(mimeType: DxMimeType): string;
		static stringTypeToType(mimeTypeAsStr: string): DxMimeType;
		static stringTypeToTypeMap: Record<string, DxMimeType \| undefined>;
		static typeToStringTypeMap: Record<DxMimeType, string \| undefined>;
		static typeToExtensionMap: Record<DxMimeType, string \| undefined>;
		static extensionToTypeMap: Record<string, DxMimeType \| undefined>;
		static stringTypeToExtension(mimeTypeAsStr: string): string;
		static typeToExtension(mimeType: DxMimeType): string;
		static extensionToType(extension: string): DxMimeType;
		static typeToStringType(mimeType: DxMimeType): string;
		static stringTypeToType(mimeTypeAsStr: string): DxMimeType;
		}
		//# sourceMappingURL=mime-type.d.ts.map

lib/utils/popup.d.ts

		export declare class PopupUtils {
		static preventContextMenu(evt: MouseEvent): void;
		static preventContextMenu(evt: MouseEvent): void;
		}
		//# sourceMappingURL=popup.d.ts.map

lib/utils/search.d.ts

		export declare class SearchUtils {
		static binaryIndexOf<T>(array: T[], comparer: (a: T) => number, minIndex?: number, maxIndex?: number): number;
		static normedBinaryIndexOf<T>(array: T[], comparer: (a: T) => number, minIndex?: number, maxIndex?: number): number;
		static binaryIndexNormalizator(index: number): number;
		static normedInterpolationIndexOf<T>(array: T[], getValue: (obj: T) => number, toFind: number, lowIndex?: number, highIndex?: number): number;
		static binaryIndexOf<T>(array: T[], comparer: (a: T) => number, minIndex?: number, maxIndex?: number): number;
		static normedBinaryIndexOf<T>(array: T[], comparer: (a: T) => number, minIndex?: number, maxIndex?: number): number;
		static binaryIndexNormalizator(index: number): number;
		static normedInterpolationIndexOf<T>(array: T[], getValue: (obj: T) => number, toFind: number, lowIndex?: number, highIndex?: number): number;
		}
		//# sourceMappingURL=search.d.ts.map

lib/utils/string.d.ts

		export declare class StringUtils {
		static isAlpha(ch: string): boolean;
		static isDigit(ch: string): boolean;
		static stringHashCode(str: string): number;
		static endsAt(str: string, template: string): boolean;
		static startsAt(str: string, template: string): boolean;
		static stringInLowerCase(str: string): boolean;
		static stringInUpperCase(str: string): boolean;
		static atLeastOneSymbolInUpperCase(str: string): boolean;
		static getSymbolFromEnd(text: string, posFromEnd: number): string;
		static trim(str: string, trimChars?: string[]): string;
		static trimStart(str: string, trimChars?: string[]): string;
		static trimEnd(str: string, trimChars?: string[]): string;
		static getDecimalSeparator(): string;
		static repeat(str: string, count: number): string;
		static isNullOrEmpty(str: string \| null \| undefined): boolean;
		static padLeft(str: string, totalWidth: number, paddingChar: string): string;
		private static trimInternal;
		static isAlpha(ch: string): boolean;
		static isDigit(ch: string): boolean;
		static stringHashCode(str: string): number;
		static endsAt(str: string, template: string): boolean;
		static startsAt(str: string, template: string): boolean;
		static stringInLowerCase(str: string): boolean;
		static stringInUpperCase(str: string): boolean;
		static atLeastOneSymbolInUpperCase(str: string): boolean;
		static getSymbolFromEnd(text: string, posFromEnd: number): string;
		static trim(str: string, trimChars?: string[]): string;
		static trimStart(str: string, trimChars?: string[]): string;
		static trimEnd(str: string, trimChars?: string[]): string;
		static getDecimalSeparator(): string;
		static repeat(str: string, count: number): string;
		static isNullOrEmpty(str: string \| null \| undefined): boolean;
		static padLeft(str: string, totalWidth: number, paddingChar: string): string;
		private static trimInternal;
		}
		//# sourceMappingURL=string.d.ts.map

lib/utils/touch.d.ts

		export declare class TouchUtils {
		static touchMouseDownEventName: string;
		static touchMouseUpEventName: string;
		static touchMouseMoveEventName: string;
		static msTouchDraggableClassName: string;
		static documentTouchHandlers: Record<string, EventListenerOrEventListenerObject[]>;
		static documentEventAttachingAllowed: boolean;
		static onEventAttachingToDocument(eventName: string, func: EventListenerOrEventListenerObject): boolean;
		static isTouchEventName(eventName: string): boolean;
		static isTouchEvent(evt: Event): evt is TouchEvent;
		static getEventX(evt: TouchEvent): number;
		static getEventY(evt: TouchEvent): number;
		static touchMouseDownEventName: string;
		static touchMouseUpEventName: string;
		static touchMouseMoveEventName: string;
		static msTouchDraggableClassName: string;
		static documentTouchHandlers: Record<string, EventListenerOrEventListenerObject[]>;
		static documentEventAttachingAllowed: boolean;
		static onEventAttachingToDocument(eventName: string, func: EventListenerOrEventListenerObject): boolean;
		static isTouchEventName(eventName: string): boolean;
		static isTouchEvent(evt: Event): evt is TouchEvent;
		static getEventX(evt: TouchEvent): number;
		static getEventY(evt: TouchEvent): number;
		}
		//# sourceMappingURL=touch.d.ts.map

lib/utils/url.d.ts

		export declare class Url {
		static containsClientScript(url: string): boolean;
		static navigate(url: string, target?: string): void;
		private static navigateTo;
		private static openInNewWindow;
		private static openInNewWindowViaIframe;
		private static getFrame;
		static containsClientScript(url: string): boolean;
		static navigate(url: string, target?: string): void;
		private static navigateTo;
		private static openInNewWindow;
		private static openInNewWindowViaIframe;
		private static getFrame;
		}
		//# sourceMappingURL=url.d.ts.map

package.json

		{
		"name": "@devexpress/utils",
		"version": "1.2.0",
		"version": "1.2.1",
		"description": "DevExpress utils",
		@@ -5,0 +5,0 @@ "author": "DevExpress Inc.",

dist/dx.utils.js

Sorry, the diff of this file is too big to display

dist/dx.utils.min.js

Sorry, the diff of this file is too big to display

@devexpress/utils - npm Package Compare versions

Improved metrics