devexpress-richedit
Version:
DevExpress Rich Text Editor is an advanced word-processing tool designed for working with rich text documents.
1,317 lines (1,243 loc) • 7.9 MB
JavaScript
/**
* DevExpress WebRichEdit (dx.richedit.js)
* Version: 24.2.6
* Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
* License: https://www.devexpress.com/Support/EULAs
*/
/******/ (function() { // webpackBootstrap
/******/ "use strict";
/******/ var __webpack_modules__ = ({
/***/ 9279:
/***/ (function(__unused_webpack_module, exports) {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Browser = void 0;
var Browser = (function () {
function Browser() {
}
Browser.IdentUserAgent = function (userAgent, ignoreDocumentMode) {
if (ignoreDocumentMode === void 0) { ignoreDocumentMode = false; }
var browserTypesOrderedList = ['Mozilla', 'IE', 'Firefox', 'Netscape', 'Safari', 'Chrome', 'Opera', 'Opera10', 'Edge'];
var defaultBrowserType = 'IE';
var defaultPlatform = 'Win';
var defaultVersions = { Safari: 2, Chrome: 0.1, Mozilla: 1.9, Netscape: 8, Firefox: 2, Opera: 9, IE: 6, Edge: 12 };
if (!userAgent || userAgent.length === 0) {
Browser.fillUserAgentInfo(browserTypesOrderedList, defaultBrowserType, defaultVersions[defaultBrowserType], defaultPlatform);
return;
}
userAgent = userAgent.toLowerCase();
Browser.indentPlatformMajorVersion(userAgent);
try {
var platformIdentStrings = {
'Windows': 'Win',
'Macintosh': 'Mac',
'Mac OS': 'Mac',
'Mac_PowerPC': 'Mac',
'cpu os': 'MacMobile',
'cpu iphone os': 'MacMobile',
'Android': 'Android',
'!Windows Phone': 'WinPhone',
'!WPDesktop': 'WinPhone',
'!ZuneWP': 'WinPhone'
};
var optSlashOrSpace = '(?:/|\\s*)?';
var versionString = '(\\d+)(?:\\.((?:\\d+?[1-9])|\\d)0*?)?';
var optVersion = '(?:' + versionString + ')?';
var patterns = {
Safari: 'applewebkit(?:.*?(?:version/' + versionString + '[\\.\\w\\d]*?(?:\\s+mobile/\\S*)?\\s+safari))?',
Chrome: '(?:chrome|crios)(?!frame)' + optSlashOrSpace + optVersion,
Mozilla: 'mozilla(?:.*rv:' + optVersion + '.*Gecko)?',
Netscape: '(?:netscape|navigator)\\d*/?\\s*' + optVersion,
Firefox: 'firefox' + optSlashOrSpace + optVersion,
Opera: '(?:opera|\\sopr)' + optSlashOrSpace + optVersion,
Opera10: 'opera.*\\s*version' + optSlashOrSpace + optVersion,
IE: 'msie\\s*' + optVersion,
Edge: 'edge' + optSlashOrSpace + optVersion
};
var browserType = null;
var version = -1;
for (var i = 0; i < browserTypesOrderedList.length; i++) {
var browserTypeCandidate = browserTypesOrderedList[i];
var regExp = new RegExp(patterns[browserTypeCandidate], 'i');
var matches = regExp.exec(userAgent);
if (matches && matches.index >= 0) {
if (browserType === 'IE' && version >= 11 && browserTypeCandidate === 'Safari')
continue;
browserType = browserTypeCandidate;
if (browserType === 'Opera10')
browserType = 'Opera';
var tridentPattern = 'trident' + optSlashOrSpace + optVersion;
version = Browser.GetBrowserVersion(userAgent, matches, tridentPattern, Browser.getIECompatibleVersionString());
if (browserType === 'Mozilla' && version >= 11)
browserType = 'IE';
}
}
if (!browserType)
browserType = defaultBrowserType;
var browserVersionDetected = version !== -1;
if (!browserVersionDetected)
version = defaultVersions[browserType];
var platform = null;
var minOccurenceIndex = Number.MAX_VALUE;
for (var identStr in platformIdentStrings) {
if (!Object.prototype.hasOwnProperty.call(platformIdentStrings, identStr))
continue;
var importantIdent = identStr.substr(0, 1) === '!';
var occurenceIndex = userAgent.indexOf((importantIdent ? identStr.substr(1) : identStr).toLowerCase());
if (occurenceIndex >= 0 && (occurenceIndex < minOccurenceIndex || importantIdent)) {
minOccurenceIndex = importantIdent ? 0 : occurenceIndex;
platform = platformIdentStrings[identStr];
}
}
var samsungPattern = 'SM-[A-Z]';
var m = userAgent.toUpperCase().match(samsungPattern);
var isSamsungAndroidDevice = m && m.length > 0;
if (platform === 'WinPhone' && version < 9)
version = Math.floor(Browser.getVersionFromTrident(userAgent, 'trident' + optSlashOrSpace + optVersion));
if (!ignoreDocumentMode && browserType === 'IE' && version > 7 && document.documentMode < version)
version = document.documentMode;
if (platform === 'WinPhone')
version = Math.max(9, version);
if (!platform)
platform = defaultPlatform;
if (platform === platformIdentStrings['cpu os'] && !browserVersionDetected)
version = 4;
Browser.fillUserAgentInfo(browserTypesOrderedList, browserType, version, platform, isSamsungAndroidDevice);
}
catch (e) {
Browser.fillUserAgentInfo(browserTypesOrderedList, defaultBrowserType, defaultVersions[defaultBrowserType], defaultPlatform);
}
};
Browser.GetBrowserVersion = function (userAgent, matches, tridentPattern, ieCompatibleVersionString) {
var version = Browser.getVersionFromMatches(matches);
if (ieCompatibleVersionString) {
var versionFromTrident = Browser.getVersionFromTrident(userAgent, tridentPattern);
if (ieCompatibleVersionString === 'edge' || parseInt(ieCompatibleVersionString) === versionFromTrident)
return versionFromTrident;
}
return version;
};
Browser.getIECompatibleVersionString = function () {
if (document.compatible) {
for (var i = 0; i < document.compatible.length; i++) {
if (document.compatible[i].userAgent === 'IE' && document.compatible[i].version)
return document.compatible[i].version.toLowerCase();
}
}
return '';
};
Browser.isTouchEnabled = function () {
return Browser.hasTouchStart() || Browser.hasMaxTouchPoints() || Browser.hasMsMaxTouchPoints();
};
Browser.hasTouchStart = function () {
return ('ontouchstart' in window);
};
Browser.hasMaxTouchPoints = function () {
return navigator['maxTouchPoints'] > 0;
};
Browser.hasMsMaxTouchPoints = function () {
return navigator['msMaxTouchPoints'] > 0;
};
Browser.hasNavigator = function () {
return typeof navigator !== 'undefined';
};
Browser.fillUserAgentInfo = function (browserTypesOrderedList, browserType, version, platform, isSamsungAndroidDevice) {
if (isSamsungAndroidDevice === void 0) { isSamsungAndroidDevice = false; }
for (var i = 0; i < browserTypesOrderedList.length; i++) {
var type = browserTypesOrderedList[i];
Browser[type] = type === browserType;
}
Browser.Version = Math.floor(10.0 * version) / 10.0;
Browser.MajorVersion = Math.floor(Browser.Version);
Browser.WindowsPlatform = platform === 'Win' || platform === 'WinPhone';
Browser.MacOSMobilePlatform = platform === 'MacMobile' || (platform === 'Mac' && Browser.isTouchEnabled());
Browser.MacOSPlatform = platform === 'Mac' && !Browser.MacOSMobilePlatform;
Browser.AndroidMobilePlatform = platform === 'Android';
Browser.WindowsPhonePlatform = platform === 'WinPhone';
Browser.WebKitFamily = Browser.Safari || Browser.Chrome || Browser.Opera && Browser.MajorVersion >= 15;
Browser.NetscapeFamily = Browser.Netscape || Browser.Mozilla || Browser.Firefox;
Browser.WebKitTouchUI = Browser.MacOSMobilePlatform || Browser.AndroidMobilePlatform;
var isIETouchUI = Browser.IE && Browser.MajorVersion > 9 && Browser.WindowsPlatform && Browser.UserAgent.toLowerCase().indexOf('touch') >= 0;
Browser.MSTouchUI = isIETouchUI || (Browser.Edge && !!window.navigator.maxTouchPoints);
Browser.TouchUI = Browser.WebKitTouchUI || Browser.MSTouchUI;
Browser.MobileUI = Browser.WebKitTouchUI || Browser.WindowsPhonePlatform;
Browser.AndroidDefaultBrowser = Browser.AndroidMobilePlatform && !Browser.Chrome;
Browser.AndroidChromeBrowser = Browser.AndroidMobilePlatform && Browser.Chrome;
if (isSamsungAndroidDevice)
Browser.SamsungAndroidDevice = isSamsungAndroidDevice;
if (Browser.MSTouchUI) {
var isARMArchitecture = Browser.UserAgent.toLowerCase().indexOf('arm;') > -1;
Browser.VirtualKeyboardSupported = isARMArchitecture || Browser.WindowsPhonePlatform;
}
else
Browser.VirtualKeyboardSupported = Browser.WebKitTouchUI;
Browser.fillDocumentElementBrowserTypeClassNames(browserTypesOrderedList);
};
Browser.indentPlatformMajorVersion = function (userAgent) {
var regex = /(?:(?:windows nt|macintosh|mac os|cpu os|cpu iphone os|android|windows phone|linux) )(\d+)(?:[-0-9_.])*/;
var matches = regex.exec(userAgent);
if (matches)
Browser.PlaformMajorVersion = matches[1];
};
Browser.getVersionFromMatches = function (matches) {
var result = -1;
var versionStr = '';
if (matches) {
if (matches[1]) {
versionStr += matches[1];
if (matches[2])
versionStr += '.' + matches[2];
}
if (versionStr !== '') {
result = parseFloat(versionStr);
if (isNaN(result))
result = -1;
}
}
return result;
};
Browser.getVersionFromTrident = function (userAgent, tridentPattern) {
var tridentDiffFromVersion = 4;
var matches = new RegExp(tridentPattern, 'i').exec(userAgent);
return Browser.getVersionFromMatches(matches) + tridentDiffFromVersion;
};
Browser.fillDocumentElementBrowserTypeClassNames = function (browserTypesOrderedList) {
var documentElementClassName = '';
var browserTypeslist = browserTypesOrderedList.concat(['WindowsPlatform', 'MacOSPlatform', 'MacOSMobilePlatform', 'AndroidMobilePlatform',
'WindowsPhonePlatform', 'WebKitFamily', 'WebKitTouchUI', 'MSTouchUI', 'TouchUI', 'AndroidDefaultBrowser']);
for (var i = 0; i < browserTypeslist.length; i++) {
var type = browserTypeslist[i];
if (Browser[type])
documentElementClassName += 'dx' + type + ' ';
}
documentElementClassName += 'dxBrowserVersion-' + Browser.MajorVersion;
if (typeof document !== 'undefined' && document && document.documentElement) {
if (document.documentElement.className !== '')
documentElementClassName = ' ' + documentElementClassName;
document.documentElement.className += documentElementClassName;
Browser.Info = documentElementClassName;
}
};
Browser.getUserAgent = function () {
return Browser.hasNavigator() && navigator.userAgent ? navigator.userAgent.toLowerCase() : '';
};
Browser.UserAgent = Browser.getUserAgent();
Browser._foo = Browser.IdentUserAgent(Browser.UserAgent);
return Browser;
}());
exports.Browser = Browser;
/***/ }),
/***/ 1772:
/***/ (function(__unused_webpack_module, exports) {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
exports.m1 = exports.IS = void 0;
var BatchUpdatableObject = (function () {
function BatchUpdatableObject() {
this.suspendUpdateCount = 0;
this.occurredEvents = 0;
}
BatchUpdatableObject.prototype.beginUpdate = function () {
if (this.suspendUpdateCount === 0)
this.onUpdateLocked();
if (this.suspendUpdateCount < 0)
this.suspendUpdateCount--;
else
this.suspendUpdateCount++;
};
BatchUpdatableObject.prototype.endUpdate = function () {
if (this.suspendUpdateCount < 0)
this.suspendUpdateCount++;
else if (this.suspendUpdateCount > 0)
this.suspendUpdateCount--;
if (!this.isUpdateLocked()) {
var occurredEvents = this.occurredEvents;
this.occurredEvents = 0;
this.onUpdateUnlocked(occurredEvents);
}
};
BatchUpdatableObject.prototype.suspendUpdate = function () {
if (this.suspendUpdateCount > 0) {
this.suspendUpdateCount *= -1;
var occurredEvents = this.occurredEvents;
this.occurredEvents = 0;
this.onUpdateUnlocked(occurredEvents);
}
};
BatchUpdatableObject.prototype.continueUpdate = function () {
if (this.suspendUpdateCount < 0)
this.suspendUpdateCount *= -1;
};
BatchUpdatableObject.prototype.isUpdateLocked = function () {
return this.suspendUpdateCount > 0;
};
BatchUpdatableObject.prototype.onUpdateLocked = function () { };
BatchUpdatableObject.prototype.registerOccurredEvent = function (eventMask) {
this.occurredEvents |= eventMask;
};
BatchUpdatableObject.prototype.resetOccurredEvents = function () {
this.occurredEvents = 0;
};
BatchUpdatableObject.prototype.isLocked = function () {
return this.suspendUpdateCount !== 0;
};
return BatchUpdatableObject;
}());
exports.IS = BatchUpdatableObject;
var EmptyBatchUpdatableObject = (function () {
function EmptyBatchUpdatableObject() {
}
EmptyBatchUpdatableObject.prototype.beginUpdate = function () { };
EmptyBatchUpdatableObject.prototype.endUpdate = function () { };
return EmptyBatchUpdatableObject;
}());
exports.m1 = EmptyBatchUpdatableObject;
/***/ }),
/***/ 677:
/***/ (function(__unused_webpack_module, exports) {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
exports.T = void 0;
var ChunkedText = (function () {
function ChunkedText(text, maxChunkSize) {
if (maxChunkSize === void 0) { maxChunkSize = 2000; }
this.maxChunkSize = maxChunkSize;
this.chunks = [];
this._textLength = 0;
this.pushText(text);
this.resetToStart();
}
Object.defineProperty(ChunkedText.prototype, "currChar", {
get: function () {
return this.chunk[this.posInChunk];
},
enumerable: false,
configurable: true
});
Object.defineProperty(ChunkedText.prototype, "currPos", {
get: function () {
return this._currPos;
},
enumerable: false,
configurable: true
});
Object.defineProperty(ChunkedText.prototype, "textLength", {
get: function () {
return this._textLength;
},
enumerable: false,
configurable: true
});
ChunkedText.prototype.resetToStart = function () {
this.setChunk(0);
this.posInChunk = -1;
this._currPos = -1;
};
ChunkedText.prototype.resetToEnd = function () {
this.setChunk(this.chunks.length - 1);
this.posInChunk = this.chunkLength - 1;
this._currPos = this._textLength;
};
ChunkedText.prototype.addText = function (text) {
this.pushText(text);
if (this._currPos === -1) {
this.chunk = this.chunks[0];
this.chunkLength = this.chunk.length;
}
else
this.setPositionTo(this._currPos);
};
ChunkedText.prototype.getText = function () {
return this.chunks.join('');
};
ChunkedText.prototype.moveToNextChar = function () {
this.posInChunk++;
this._currPos++;
if (this.posInChunk < this.chunkLength)
return true;
if (this.setChunk(this.chunkIndex + 1)) {
this.posInChunk = 0;
return true;
}
else {
this.posInChunk = this.chunkLength;
this._currPos = this._textLength;
return false;
}
};
ChunkedText.prototype.moveToPrevChar = function () {
this.posInChunk--;
this._currPos--;
if (this.posInChunk >= 0)
return true;
if (this.setChunk(this.chunkIndex - 1)) {
this.posInChunk = this.chunkLength - 1;
return true;
}
else {
this.posInChunk = -1;
this._currPos = -1;
return false;
}
};
ChunkedText.prototype.setPositionTo = function (position) {
var restLength = position;
this.chunkIndex = 0;
for (var ind = 0; true; ind++) {
if (this.setChunk(ind)) {
if (restLength > this.chunkLength)
restLength -= this.chunk.length;
else {
this.posInChunk = restLength;
this._currPos = position;
return;
}
}
else {
this.posInChunk = this.chunkLength;
this._currPos = this._textLength;
return;
}
}
};
ChunkedText.prototype.setChunk = function (index) {
var prevChunkVal = this.chunk;
this.chunk = this.chunks[index];
if (!this.chunk) {
this.chunk = prevChunkVal;
return false;
}
this.chunkIndex = index;
this.chunkLength = this.chunk.length;
return true;
};
ChunkedText.prototype.pushText = function (text) {
if (!text.length)
return;
var textPos = 0;
while (textPos < text.length) {
if (textPos === 0) {
var lastChunk = this.chunks.pop();
if (lastChunk) {
if (lastChunk.length < this.maxChunkSize) {
var restLen = this.maxChunkSize - lastChunk.length;
this.chunks.push(lastChunk + text.substr(textPos, restLen));
textPos += restLen;
continue;
}
else
this.chunks.push(lastChunk);
}
}
this.chunks.push(text.substr(textPos, this.maxChunkSize));
textPos += this.maxChunkSize;
}
this._textLength += text.length;
};
return ChunkedText;
}());
exports.T = ChunkedText;
/***/ }),
/***/ 6218:
/***/ (function(__unused_webpack_module, exports) {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
exports.R = void 0;
var DelayedActionManager = (function () {
function DelayedActionManager(action) {
this.action = action;
this.reset();
}
Object.defineProperty(DelayedActionManager.prototype, "actionExecuted", {
get: function () {
return this.actionTimeoutId === null;
},
enumerable: false,
configurable: true
});
DelayedActionManager.prototype.reset = function () {
this.actionTimeout = undefined;
this.actionTimeoutId = undefined;
this.actionStartTime = undefined;
};
DelayedActionManager.prototype.start = function (timeout) {
var _this = this;
this.actionTimeout = timeout;
this.actionTimeoutId = setTimeout(function () { return _this.executeAction(); }, this.actionTimeout);
this.actionStartTime = Date.now();
};
DelayedActionManager.prototype.executeIfTimerExpired = function () {
if (Date.now() - this.actionStartTime > this.actionTimeout)
this.executeAction();
};
DelayedActionManager.prototype.executeAction = function () {
if (!this.actionExecuted) {
this.action();
this.stop();
}
};
DelayedActionManager.prototype.stop = function () {
clearTimeout(this.actionTimeoutId);
this.actionTimeoutId = null;
};
return DelayedActionManager;
}());
exports.R = DelayedActionManager;
/***/ }),
/***/ 6136:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
exports.$ = void 0;
var touch_1 = __webpack_require__(1632);
var DomEventHandler = (function () {
function DomEventHandler(element, eventName, handler, options) {
if (options === void 0) { options = true; }
this.element = element;
this.eventName = eventName;
this.handler = handler;
this.options = options;
}
return DomEventHandler;
}());
var DomEventHandlersHolder = (function () {
function DomEventHandlersHolder() {
this.handlers = [];
}
DomEventHandlersHolder.prototype.addListener = function (element, eventName, handler, options) {
if (options === void 0) { options = true; }
this.handlers.push(new DomEventHandler(element, eventName, handler, options));
element.addEventListener(eventName, handler, options);
};
DomEventHandlersHolder.prototype.addListenerToWindow = function (eventName, handler, options) {
if (options === void 0) { options = true; }
this.handlers.push(new DomEventHandler(window, eventName, handler, options));
window.addEventListener(eventName, handler, options);
};
DomEventHandlersHolder.prototype.addListenerToDocument = function (eventName, handler, options) {
if (options === void 0) { options = true; }
var attachingAllowed = touch_1.TouchUtils.onEventAttachingToDocument(eventName, handler);
if (attachingAllowed) {
this.handlers.push(new DomEventHandler(document, eventName, handler, options));
document.addEventListener(eventName, handler, options);
}
};
DomEventHandlersHolder.prototype.removeAllListeners = function () {
this.handlers.forEach(function (evtHandler) { return evtHandler.element.removeEventListener(evtHandler.eventName, evtHandler.handler, evtHandler.options); });
this.handlers = [];
};
return DomEventHandlersHolder;
}());
exports.$ = DomEventHandlersHolder;
/***/ }),
/***/ 7820:
/***/ (function(__unused_webpack_module, exports) {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Flag = void 0;
var Flag = (function () {
function Flag(initValue) {
if (initValue === void 0) { initValue = 0; }
this.value = initValue;
}
Flag.prototype.get = function (enumVal) {
return (this.value & enumVal) === enumVal;
};
Flag.prototype.set = function (enumVal, newValue) {
var currVal = (this.value & enumVal) === enumVal;
if (currVal !== newValue) {
if (newValue)
this.value |= enumVal;
else
this.value ^= enumVal;
}
return this;
};
Flag.prototype.add = function (value) {
this.value |= value;
};
Flag.prototype.anyOf = function () {
var flags = [];
for (var _i = 0; _i < arguments.length; _i++) {
flags[_i] = arguments[_i];
}
for (var _a = 0, flags_1 = flags; _a < flags_1.length; _a++) {
var flag = flags_1[_a];
if ((this.value & flag) === flag)
return true;
}
return false;
};
Flag.prototype.getValue = function () {
return this.value;
};
Flag.prototype.clone = function () {
return new Flag(this.value);
};
return Flag;
}());
exports.Flag = Flag;
/***/ }),
/***/ 7496:
/***/ (function(__unused_webpack_module, exports) {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
__webpack_unused_export__ = exports.m7 = void 0;
var Initializer = (function () {
function Initializer() {
}
Initializer.prototype.set = function (property, value) {
this[property] = value;
return this;
};
return Initializer;
}());
exports.m7 = Initializer;
function Initialize(options) {
var set = function (property, value) {
options[property] = value;
return {
set: set,
result: options
};
};
return {
set: set,
result: options
};
}
__webpack_unused_export__ = Initialize;
/***/ }),
/***/ 6799:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.ExtendedMinMax = exports.ExtendedMax = exports.ExtendedMin = exports.MinMaxNumber = exports.MinMax = void 0;
var tslib_1 = __webpack_require__(2020);
var MinMax = (function () {
function MinMax(minElement, maxElement) {
this.minElement = minElement;
this.maxElement = maxElement;
}
return MinMax;
}());
exports.MinMax = MinMax;
var MinMaxNumber = (function (_super) {
tslib_1.__extends(MinMaxNumber, _super);
function MinMaxNumber() {
return _super !== null && _super.apply(this, arguments) || this;
}
Object.defineProperty(MinMaxNumber.prototype, "length", {
get: function () {
return this.maxElement - this.minElement;
},
enumerable: false,
configurable: true
});
return MinMaxNumber;
}(MinMax));
exports.MinMaxNumber = MinMaxNumber;
var ExtendedMin = (function () {
function ExtendedMin(minElement, minValue) {
this.minElement = minElement;
this.minValue = minValue;
}
return ExtendedMin;
}());
exports.ExtendedMin = ExtendedMin;
var ExtendedMax = (function () {
function ExtendedMax(maxElement, maxValue) {
this.maxElement = maxElement;
this.maxValue = maxValue;
}
return ExtendedMax;
}());
exports.ExtendedMax = ExtendedMax;
var ExtendedMinMax = (function (_super) {
tslib_1.__extends(ExtendedMinMax, _super);
function ExtendedMinMax(minElement, minValue, maxElement, maxValue) {
var _this = _super.call(this, minElement, maxElement) || this;
_this.minValue = minValue;
_this.maxValue = maxValue;
return _this;
}
return ExtendedMinMax;
}(MinMax));
exports.ExtendedMinMax = ExtendedMinMax;
/***/ }),
/***/ 9094:
/***/ (function(__unused_webpack_module, exports) {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
exports.K = void 0;
var Stack = (function () {
function Stack() {
this.list = [];
this._count = 0;
this.last = undefined;
}
Stack.prototype.push = function (val) {
this.list.push(val);
this.last = val;
this._count++;
};
Stack.prototype.pop = function () {
this._count--;
var result = this.list.pop();
this.last = this.list[this.list.length - 1];
return result;
};
Stack.prototype.peek = function () {
return this.last;
};
Object.defineProperty(Stack.prototype, "count", {
get: function () {
return this._count;
},
enumerable: false,
configurable: true
});
Stack.prototype.getPrevious = function () {
return this.list[this._count - 2];
};
return Stack;
}());
exports.K = Stack;
/***/ }),
/***/ 9291:
/***/ (function(__unused_webpack_module, exports) {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
exports.u = void 0;
var UnitConverter = (function () {
function UnitConverter() {
}
UnitConverter.hundredthsOfMillimeterToTwipsRound = function (value) {
return Math.round(1440 * value / 2540.0);
};
UnitConverter.documentsToTwips = function (value) {
return 24 * value / 5;
};
UnitConverter.pixelsToTwips = function (value) {
return Math.round(UnitConverter.pixelsToTwipsF(value));
};
UnitConverter.pixelsToTwipsCustomDpi = function (value, dpi) {
return Math.round(UnitConverter.pixelsToTwipsFCustomDpi(value, dpi));
};
UnitConverter.inchesToTwips = function (value) {
return Math.round(UnitConverter.inchesToTwipsF(value));
};
UnitConverter.pointsToTwips = function (value) {
return Math.round(UnitConverter.pointsToTwipsF(value));
};
UnitConverter.picasToTwips = function (value) {
return Math.round(value * 1440 / UnitConverter.PICAS_PER_INCH);
};
UnitConverter.centimetersToTwips = function (value) {
return Math.round(UnitConverter.centimetersToTwipsF(value));
};
UnitConverter.pixelsToTwipsF = function (value) {
return value * 1440 / UnitConverter.DPI;
};
UnitConverter.pixelsToTwipsFCustomDpi = function (value, dpi) {
return value * 1440 / dpi;
};
UnitConverter.inchesToTwipsF = function (value) {
return value * 1440;
};
UnitConverter.pointsToTwipsF = function (value) {
return value * 20;
};
UnitConverter.centimetersToTwipsF = function (value) {
return value * 1440 / UnitConverter.CENTIMETERS_PER_INCH;
};
UnitConverter.twipsToDegrees = function (value) {
return value / 60000;
};
UnitConverter.twipsToRadians = function (value) {
return value / 60000 * Math.PI / 180;
};
UnitConverter.degreesToTwips = function (value) {
return value * 60000;
};
UnitConverter.radiansToTwips = function (value) {
return value * 60000 / Math.PI * 180;
};
UnitConverter.radiansToDegrees = function (value) {
return value / Math.PI * 180;
};
UnitConverter.twipsToFD = function (value) {
return Math.round(value * 2048 / 1875);
};
UnitConverter.fdToTwips = function (value) {
return Math.round(value * 1875 / 2048);
};
UnitConverter.emuToTwips = function (val) {
return val / 635;
};
UnitConverter.twipsToPixels = function (value) {
return Math.round(UnitConverter.twipsToPixelsF(value));
};
UnitConverter.inchesToPixels = function (value) {
return Math.round(UnitConverter.DPI * value);
};
UnitConverter.centimeterToPixel = function (value) {
return Math.round(this.centimeterToPixelF(value));
};
UnitConverter.centimeterToPixelF = function (value) {
return value * UnitConverter.DPI / UnitConverter.CENTIMETERS_PER_INCH;
};
UnitConverter.millimetersToPixel = function (value) {
return Math.round(value / (UnitConverter.CENTIMETERS_PER_INCH / UnitConverter.DPI) / 10);
};
UnitConverter.pointsToPixels = function (value) {
return Math.round(value * UnitConverter.DPI / 72);
};
UnitConverter.pointsToPixelsF = function (value) {
return value * UnitConverter.DPI / 72;
};
UnitConverter.twipsToPixelsF = function (value) {
return value * UnitConverter.DPI / 1440;
};
UnitConverter.pixelsToPoints = function (value) {
return Math.round(value * 72 / UnitConverter.DPI);
};
UnitConverter.pixelsToPointsF = function (value) {
return value * 72 / UnitConverter.DPI;
};
UnitConverter.twipsToPoints = function (value) {
return Math.round(this.twipsToPointsF(value));
};
UnitConverter.twipsToPointsF = function (value) {
return value / 20;
};
UnitConverter.twipsToInches = function (value) {
return value / 1440;
};
UnitConverter.pixelsToInches = function (value) {
return value / UnitConverter.DPI;
};
UnitConverter.twipsToCentimeters = function (value) {
return value * UnitConverter.CENTIMETERS_PER_INCH / 1440;
};
UnitConverter.pixelToCentimeters = function (value) {
return value * UnitConverter.CENTIMETERS_PER_INCH / UnitConverter.DPI;
};
UnitConverter.twipsToHundredthsOfMillimeter = function (value) {
return Math.round(127 * value / 72);
};
UnitConverter.pixelsToHundredthsOfMillimeter = function (value) {
return Math.round(2540 * value / UnitConverter.DPI);
};
UnitConverter.hundredthsOfMillimeterToTwips = function (value) {
return 15 * value / 127;
};
UnitConverter.twipsToEmu = function (val) {
return val * 635;
};
UnitConverter.twipsToDegree = function (value) {
return value / 60000;
};
UnitConverter.DPI = 96;
UnitConverter.CENTIMETERS_PER_INCH = 2.54;
UnitConverter.PICAS_PER_INCH = 6;
return UnitConverter;
}());
exports.u = UnitConverter;
/***/ }),
/***/ 8785:
/***/ (function(__unused_webpack_module, exports) {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Int32Constants = exports.Constants = void 0;
var Constants = (function () {
function Constants() {
}
Constants.MIN_SAFE_INTEGER = -(Math.pow(2, 53) - 1);
Constants.MAX_SAFE_INTEGER = (Math.pow(2, 53) - 1);
Constants.MAX_BYTE = Math.pow(2, 8) - 1;
return Constants;
}());
exports.Constants = Constants;
var Int32Constants = (function () {
function Int32Constants() {
}
Int32Constants.MIN_VALUE = -2147483648;
Int32Constants.MAX_VALUE = 2147483647;
return Int32Constants;
}());
exports.Int32Constants = Int32Constants;
/***/ }),
/***/ 7774:
/***/ (function(__unused_webpack_module, exports) {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
exports.D = void 0;
var Errors = (function () {
function Errors() {
}
Errors.internalExceptionTemplate = function (str) {
return Errors.InternalException + " " + str;
};
Errors.NotImplemented = 'The method is not implemented.';
Errors.InternalException = 'Internal exception.';
Errors.ValueCannotBeNull = 'Value cannot be null.';
return Errors;
}());
exports.D = Errors;
/***/ }),
/***/ 8889:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
exports.J = void 0;
var tslib_1 = __webpack_require__(2020);
var DateTimeFieldFormatter = (function () {
function DateTimeFieldFormatter(options) {
this.AMPMKeyword = 'am/pm';
this.options = options;
}
DateTimeFieldFormatter.prototype.format = function (date, formatString) {
this.date = date;
this.formatString = formatString;
this.result = '';
var index = 0;
var formatLength = this.formatString.length;
while (index < formatLength)
index += this.formatNext(index);
return this.result;
};
DateTimeFieldFormatter.prototype.formatNext = function (index) {
var ch = this.formatString[index];
var formattingItem = this.tryCreateFormattingItem(ch);
if (formattingItem)
return this.processAsFormattingItem(index, formattingItem);
if (this.isKeyword(this.AMPMKeyword, index))
return this.processAsAMPMKeyword();
if (ch === '\'')
return this.processAsEmbedText(index);
return this.processAsSingleCharacter(index);
};
DateTimeFieldFormatter.prototype.isKeyword = function (keyword, index) {
if (keyword.length > (this.formatString.length - index))
return false;
var substring = this.formatString.substr(index, keyword.length);
return keyword.toLowerCase() === substring.toLowerCase();
};
DateTimeFieldFormatter.prototype.processAsAMPMKeyword = function () {
var result = (this.date.getHours() - 12) >= 0 ? this.options.pm : this.options.am;
this.result += result;
return this.AMPMKeyword.length;
};
DateTimeFieldFormatter.prototype.processAsEmbedText = function (index) {
var startTextIndex = index + 1;
if (startTextIndex >= (this.formatString.length - 1))
return 1;
var textLength = this.getCharacterSequenceLength(this.formatString[index], startTextIndex, this.charsAreNotEqual);
if ((textLength + startTextIndex) === this.formatString.length) {
this.result += '\'';
return 1;
}
this.result += this.formatString.substr(startTextIndex, textLength);
return textLength + 2;
};
DateTimeFieldFormatter.prototype.processAsSingleCharacter = function (index) {
this.result += this.formatString[index];
return 1;
};
DateTimeFieldFormatter.prototype.processAsFormattingItem = function (index, formattingItem) {
var sequenceLength = this.getCharacterSequenceLength(this.formatString[index], index, this.charsAreEqual);
var patternLength = formattingItem.getAvailablePatternLength(sequenceLength);
var result = formattingItem.format(this.date, patternLength);
this.result += result;
return Math.min(sequenceLength, patternLength);
};
DateTimeFieldFormatter.prototype.getCharacterSequenceLength = function (ch, index, predicate) {
var length = this.formatString.length;
var nextCharIndex = index + 1;
while (nextCharIndex < length && predicate(ch, this.formatString[nextCharIndex]))
nextCharIndex++;
return nextCharIndex - index;
};
DateTimeFieldFormatter.prototype.tryCreateFormattingItem = function (formattingChar) {
switch (formattingChar) {
case 'h':
return new Hour12FormattingItem(this.options);
case 'H':
return new Hour24FormattingItem(this.options);
case 'm':
return new MinuteFormattingItem(this.options);
case 'S':
case 's':
return new SecondFormattingItem(this.options);
case 'Y':
case 'y':
return new YearFormattingItem(this.options);
case 'M':
return new MonthFormattingItem(this.options);
case 'D':
case 'd':
return new DayFormattingItem(this.options);
}
return null;
};
DateTimeFieldFormatter.prototype.charsAreEqual = function (ch1, ch2) {
return ch1 === ch2;
};
DateTimeFieldFormatter.prototype.charsAreNotEqual = function (ch1, ch2) {
return ch1 !== ch2;
};
return DateTimeFieldFormatter;
}());
exports.J = DateTimeFieldFormatter;
var DateTimeFormattingItem = (function () {
function DateTimeFormattingItem(options) {
this.options = options;
}
DateTimeFormattingItem.prototype.getAvailablePatternLength = function (patternLength) {
var count = this.patternsLength.length;
for (var i = 0; i < count; i++) {
if (this.patternsLength[i] >= patternLength)
return this.patternsLength[i];
}
return this.patternsLength[count - 1];
};
return DateTimeFormattingItem;
}());
var NumericFormattingItem = (function (_super) {
tslib_1.__extends(NumericFormattingItem, _super);
function NumericFormattingItem() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.patternsLength = [1, 2];
return _this;
}
NumericFormattingItem.prototype.formatCore = function (value, patternLength) {
var result = '' + value;
if (patternLength === 2 && result.length === 1)
return '0' + result;
return result;
};
return NumericFormattingItem;
}(DateTimeFormattingItem));
var CombinedFormattingItem = (function (_super) {
tslib_1.__extends(CombinedFormattingItem, _super);
function CombinedFormattingItem() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.patternsLength = [1, 2, 3, 4];
return _this;
}
CombinedFormattingItem.prototype.format = function (date, patternLength) {
if (patternLength <= 2)
return this.formatCore(this.getNumericValue(date), patternLength);
if (patternLength === 3)
return this.getAbbreviatedName(date);
return this.getFullName(date);
};
return CombinedFormattingItem;
}(NumericFormattingItem));
var Hour24FormattingItem = (function (_super) {
tslib_1.__extends(Hour24FormattingItem, _super);
function Hour24FormattingItem() {
return _super !== null && _super.apply(this, arguments) || this;
}
Hour24FormattingItem.prototype.format = function (date, patternLength) {
return this.formatCore(date.getHours(), patternLength);
};
return Hour24FormattingItem;
}(NumericFormattingItem));
var Hour12FormattingItem = (function (_super) {
tslib_1.__extends(Hour12FormattingItem, _super);
function Hour12FormattingItem() {
return _super !== null && _super.apply(this, arguments) || this;
}
Hour12FormattingItem.prototype.format = function (date, patternLength) {
var hour = date.getHours() % 12;
if (hour === 0)
hour = 12;
return this.formatCore(hour, patternLength);
};
return Hour12FormattingItem;
}(NumericFormattingItem));
var MinuteFormattingItem = (function (_super) {
tslib_1.__extends(MinuteFormattingItem, _super);
function MinuteFormattingItem() {
return _super !== null && _super.apply(this, arguments) || this;
}
MinuteFormattingItem.prototype.format = function (date, patternLength) {
return this.formatCore(date.getMinutes(), patternLength);
};
return MinuteFormattingItem;
}(NumericFormattingItem));
var SecondFormattingItem = (function (_super) {
tslib_1.__extends(SecondFormattingItem, _super);
function SecondFormattingItem() {
return _super !== null && _super.apply(this, arguments) || this;
}
SecondFormattingItem.prototype.format = function (date, patternLength) {
return this.formatCore(date.getSeconds(), patternLength);
};
return SecondFormattingItem;
}(NumericFormattingItem));
var DayFormattingItem = (function (_super) {
tslib_1.__extends(DayFormattingItem, _super);
function DayFormattingItem() {
return _super !== null && _super.apply(this, arguments) || this;
}
DayFormattingItem.prototype.getAbbreviatedName = function (date) {
return this.options.abbrDayNames[this.getDayOfWeek(date)];
};
DayFormattingItem.prototype.getFullName = function (date) {
return this.options.dayNames[this.getDayOfWeek(date)];
};
DayFormattingItem.prototype.getNumericValue = function (date) {
return date.getDate();
};
DayFormattingItem.prototype.getDayOfWeek = function (date) {
return date.getDay();
};
return DayFormattingItem;
}(CombinedFormattingItem));
var MonthFormattingItem = (function (_super) {
tslib_1.__extends(MonthFormattingItem, _super);
function MonthFormattingItem() {
return _super !== null && _super.apply(this, arguments) || this;
}
MonthFormattingItem.prototype.getAbbreviatedName = function (date) {
return this.options.abbrMonthNames[date.getMonth()];
};
MonthFormattingItem.prototype.getFullName = function (date) {
return this.options.monthNames[date.getMonth()];
};
MonthFormattingItem.prototype.getNumericValue = function (date) {
return date.getMonth() + 1;
};
return MonthFormattingItem;
}(CombinedFormattingItem));
var YearFormattingItem = (function (_super) {
tslib_1.__extends(YearFormattingItem, _super);
function YearFormattingItem() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.patternsLength = [2, 4];
return _this;
}
YearFormattingItem.prototype.format = function (date, patternLength) {
var year = date.getFullYear();
if (patternLength === 2 && year > 99) {
var shortYear = year % 100;
var result = '' + shortYear;
if (result.length === 1)
return '0' + result;
return result;
}
return '' + year;
};
return YearFormattingItem;
}(DateTimeFormattingItem));
/***/ }),
/***/ 8786:
/***/ (function(__unused_webpack_module, exports) {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.DateUtils = void 0;
var DateUtils = (function () {
function DateUtils() {
}
DateUtils.fixTimezoneGap = function (oldDate, newDate) {
var diff = newDate.getHours() - oldDate.getHours();
if (diff === 0)
return;
var sign = (diff === 1 || diff === -23) ? -1 : 1;
var trial = new Date(newDate.getTime() + sign * 3600000);
var isDateChangedAsExpected = newDate.getHours() - trial.getHours() === diff;
if (isDateChangedAsExpected && (sign > 0 || trial.getDate() === newDate.getDate()))
newDate.setTime(trial.getTime());
};
DateUtils.expandTwoDigitYear = function (value, options) {
value += 1900;
if (value + 99 < options.twoDigitYearMax)
value += 100;
return value;
};
DateUtils.toUtcTime = function (date) {
var result = new Date();
result.setTime(date.valueOf() + DateUtils.getTimeZoneOffset(date));
return result;
};
DateUtils.getTimeZoneOffset = function (date) {
var utcFullYear = date.getUTCFullYear();
var utcDate = new Date(utcFullYear, date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds());
if (utcFullYear < 100)
utcDate.setFullYear(utcFullYear);
return utcDate.valueOf() - date.valueOf();
};
return DateUtils;
}());
exports.DateUtils = DateUtils;
/***/ }),
/***/ 5308:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.DateFormatter = void 0;
var string_1 = __webpack_require__(2866);
var string_2 = __webpack_require__(49);
var date_utils_1 = __webpack_require__(8786);
var DateFormatter = (function () {
function DateFormatter(options) {
this.date = new Date(2000, 0, 1);
this.mask = '';
this.specifiers = {};
this.spPositions = [];
this.parserKeys = [];
this.savedYear = -1;
this.isYearParsed = false;
this.parsedMonth = -1;
this.knownSpecifiers = ['d', 'M', 'y', 'H', 'h', 'm', 's', 'f', 'F', 'g', 't'];
this.replacers = {
'd': this.replaceDay,
'M': this.replaceMonth,
'y': this.replaceYear,
'H': this.replaceHours23,
'h': this.replaceHours12,
'm': this.replaceMinutes,
's': this.replaceSeconds,
'F': this.replaceMsTrimmed,
'f': this.replaceMs,
'g': this.replaceEra,
't': this.replaceAmPm
};
this.parsers = {
'd': this.parseDay,
'M': this.parseMonth,
'y': this.parseYear,
'H': this.parseHours,
'h': this.parseHours,
'm': this.parseMinutes,
's': this.parseSeconds,
'F': this.parseMs,
'f': this.parseMs,
'g': this.parseEra,
't': this.parseAmPm
};
this.options = options;
}
DateFormatter.prototype.setFormatString = function (mask) {
if (mask.length === 2 && mask.charAt(0) === '%')
mask = mask.charAt(1);
var stringContainsDateSeparator = !!mask && (mask.indexOf(this.options.ds) !== -1);
this.specifiers = {};
this.spPositions = [];
this.mask = '';
var subt = 0;
var startPos = 0;
var skip = false;
var backslash = false;
var sp = '';
var prevCh = '';
for (var pos = 0; true; pos++) {
var ch = mask.charAt(pos);
if (ch === '') {
if (sp.length > 0)
this.registerSpecifier(startPos, sp, stringContainsDateSeparator);
break;
}
if (ch === '\\' && !backslash) {
backslash = true;
subt++;
}
else {
if (!backslash && (ch === '\'' || ch === '"')) {