/*
 * (c) Copyright Ascensio System SIA 2010-2024
 *
 * This program is a free software product. You can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License (AGPL)
 * version 3 as published by the Free Software Foundation. In accordance with
 * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
 * that Ascensio System SIA expressly excludes the warranty of non-infringement
 * of any third-party rights.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
 * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
 * street, Riga, Latvia, EU, LV-1050.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */

"use strict";
(
	/**
	 * @param {Window} window
	 * @param {undefined} undefined
	 */
	function (window, undefined) {
		// Import
		var gc_nMaxRow0 = AscCommon.gc_nMaxRow0;
		var gc_nMaxCol0 = AscCommon.gc_nMaxCol0;
		var g_oCellAddressUtils = AscCommon.g_oCellAddressUtils;
		var AscBrowser = AscCommon.AscBrowser;

		var c_oAscSelectionType = Asc.c_oAscSelectionType;


		/** @const */
		var kLeftLim1 = .999999999999999;
		var MAX_EXCEL_INT = 1e308;
		var MIN_EXCEL_INT = -MAX_EXCEL_INT;
		var c_sPerDay = 86400;
		var c_msPerDay = c_sPerDay * 1000;

		/** @const */
		var kUndefinedL = "undefined";
		/** @const */
		var kNullL = "null";
		/** @const */
		var kObjectL = "object";
		/** @const */
		var kFunctionL = "function";
		/** @const */
		var kNumberL = "number";
		/** @const */
		var kArrayL = "array";

		var recalcType = {
			recalc: 0, // без пересчета
			full: 1, // пересчитываем все
			newLines: 2  // пересчитываем новые строки

		};

		var sizePxinPt = 72 / 96;

		function applyFunction(callback) {
			if (kFunctionL === typeof callback) {
				callback.apply(null, Array.prototype.slice.call(arguments, 1));
			}
		}

		function typeOf(obj) {
			if (obj === undefined) {
				return kUndefinedL;
			}
			if (obj === null) {
				return kNullL;
			}
			return Object.prototype.toString.call(obj).slice(8, -1).toLowerCase();
		}

		function lastIndexOf(s, regExp, fromIndex) {
			var end = fromIndex >= 0 && fromIndex <= s.length ? fromIndex : s.length;
			for (var i = end - 1; i >= 0; --i) {
				var j = s.slice(i, end).search(regExp);
				if (j >= 0) {
					return i + j;
				}
			}
			return -1;
		}

		function search(arr, fn) {
			for (var i = 0; i < arr.length; ++i) {
				if (fn(arr[i])) {
					return i;
				}
			}
			return -1;
		}

		function getUniqueRangeColor(arrRanges, curElem, tmpColors) {
			var colorIndex, j, range = arrRanges[curElem];
			for (j = 0; j < curElem; ++j) {
				if (range.isEqual(arrRanges[j])) {
					colorIndex = tmpColors[j];
					break;
				}
			}
			return colorIndex;
		}

		function getMinValueOrNull(val1, val2) {
			return null === val2 ? val1 : (null === val1 ? val2 : Math.min(val1, val2));
		}

		function round(x) {
			var y = x + (x >= 0 ? .5 : -.5);
			return y | y;
			//return Math.round(x);
		}

		function floor(x) {
			var y = x | x;
			y -= x < 0 && y > x ? 1 : 0;
			return y + (x - y > kLeftLim1 ? 1 : 0); // to fix float number precision caused by binary presentation
			//return Math.floor(x);
		}

		function ceil(x) {
			var y = x | x;
			y += x > 0 && y < x ? 1 : 0;
			return y - (y - x > kLeftLim1 ? 1 : 0); // to fix float number precision caused by binary presentation
			//return Math.ceil(x);
		}

		function incDecFonSize(bIncrease, oValue) {
			// Закон изменения размеров :
			// Результатом должно быть ближайшее из отрезка [8,72] по следующим числам 8,9,10,11,12,14,16,18,20,22,24,26,28,36,48,72
			// Если значение меньше или равно 8 и мы уменьшаем, то ничего не меняется
			// Если значение больше или равно 72 и мы увеличиваем, то ничего не меняется

			var aSizes = [8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 26, 28, 36, 48, 72];
			var nLength = aSizes.length;
			var i;
			if (true === bIncrease) {
				if (oValue >= aSizes[nLength - 1])
					return null;
				for (i = 0; i < nLength; ++i)
					if (aSizes[i] > oValue)
						break;
			} else {
				if (oValue <= aSizes[0])
					return null;
				for (i = nLength - 1; i >= 0; --i)
					if (aSizes[i] < oValue)
						break;
			}

			return aSizes[i];
		}

		function calcDecades(num) {
			return Math.abs(num) < 10 ? 1 : 1 + calcDecades(floor(num * 0.1));
		}

		function convertPtToPx(value) {
			value = value / sizePxinPt;
			value = (value * AscBrowser.retinaPixelRatio) >> 0;
			return value;
		}

		function convertPxToPt(value) {
			value = value * sizePxinPt;
			//пункты округляем до сотых
			value = Asc.ceil(value / AscBrowser.retinaPixelRatio * 100) / 100;
			return value;
		}

		// Определяет времени работы функции
		function profileTime(fn/*[, arguments]*/) {
			var start, end, arg = [], i;
			if (arguments.length) {
				if (arguments.length > 1) {
					for (i = 1; i < arguments.length; ++i)
						arg.push(arguments[i]);
					start = new Date();
					fn.apply(window, arg);
					end = new Date();
				} else {
					start = new Date();
					fn();
					end = new Date();
				}
				return end.getTime() - start.getTime();
			}
			return undefined;
		}

		function getMatchingBorder(border1, border2) {
			// ECMA-376 Part 1 17.4.67 tcBorders (Table Cell Borders)
			if (!border1) {
				return border2;
			}
			if (!border2) {
				return border1;
			}

			if (border1.w > border2.w) {
				return border1;
			} else if (border1.w < border2.w) {
				return border2;
			}

			var bc1 = border1.getColorOrDefault();
			var bc2 = border2.getColorOrDefault();
			var r1 = bc1.getR(), g1 = bc1.getG(), b1 = bc1.getB();
			var r2 = bc2.getR(), g2 = bc2.getG(), b2 = bc2.getB();
			var Brightness_1_1 = r1 + b1 + 2 * g1;
			var Brightness_1_2 = r2 + b2 + 2 * g2;
			if (Brightness_1_1 < Brightness_1_2) {
				return border1;
			} else if (Brightness_1_1 > Brightness_1_2) {
				return border2;
			}

			var Brightness_2_1 = Brightness_1_1 - r1;
			var Brightness_2_2 = Brightness_1_2 - r2;
			if (Brightness_2_1 < Brightness_2_2) {
				return border1;
			} else if (Brightness_2_1 > Brightness_2_2) {
				return border2;
			}

			var Brightness_3_1 = g1;
			var Brightness_3_2 = g2;
			if (Brightness_3_1 < Brightness_3_2) {
				return border1;
			} else if (Brightness_3_1 > Brightness_3_2) {
				return border2;
			}

			// borders equal
			return border1;
		}

		function WordSplitting(str) {
			var trueLetter = false;
			var index = 0;
			var wordsArray = [];
			var wordsIndexArray = [];
			for (var i = 0; i < str.length; i++) {
				var nCharCode = str.charCodeAt(i);
				if (AscCommon.g_aPunctuation[nCharCode] !== undefined || nCharCode === 32 || nCharCode === 10) {
					if (trueLetter) {
						trueLetter = false;
						index++;
					}
				} else {
					if (trueLetter === false) {
						wordsIndexArray.push(i);
					}
					trueLetter = true;
					wordsArray[index] = wordsArray[index] || "";
					wordsArray[index] = wordsArray[index] + str[i];
				}
			}
			return {
				wordsArray: wordsArray,
				wordsIndex: wordsIndexArray
			};
		}

		function replaceSpellCheckWords(cellValue, options) {
			// ToDo replace one command
			if (1 === options.indexInArray && options.replaceWith) {
				cellValue = options.replaceWith;
			} else {
				for (var i = 0; i < options.replaceWords.length; ++i) {
					cellValue = cellValue.replace(options.replaceWords[i][0], function () {
						return options.replaceWords[i][1];
					});
				}
			}
			return cellValue;
		}

		function getFindRegExp(value, options, checkEmptyVal) {
			var findFlags = "g"; // Заменяем все вхождения
			// Не чувствителен к регистру
			if (true !== options.isMatchCase) {
				findFlags += "i";
			}
			if (value === "" && checkEmptyVal) {
				value = /^$/;
			} else {
				value = value
					.replace(/(\\)/g, "\\\\").replace(/(\^)/g, "\\^")
					.replace(/(\()/g, "\\(").replace(/(\))/g, "\\)")
					.replace(/(\+)/g, "\\+").replace(/(\[)/g, "\\[")
					.replace(/(\])/g, "\\]").replace(/(\{)/g, "\\{")
					.replace(/(\})/g, "\\}").replace(/(\$)/g, "\\$")
					.replace(/(\.)/g, "\\.")
					.replace(/(~)?\*/g, function ($0, $1) {
						return $1 ? $0 : '(.*)';
					})
					.replace(/(~)?\?/g, function ($0, $1) {
						return $1 ? $0 : '.';
					})
					.replace(/(~\*)/g, "\\*").replace(/(~\?)/g, "\\?");
			}

			if (options.isWholeWord)
				value = '\\b' + value + '\\b';

			return new RegExp(value, findFlags);
		}

		function convertFillToUnifill(fill) {
			var oUniFill = null;
			if (!fill) {
				return AscFormat.CreateNoFillUniFill();
			}
			var oSF = fill.getSolidFill();
			if (oSF) {
				oUniFill = new AscFormat.CreateSolidFillRGBA(oSF.getR(), oSF.getG(), oSF.getB(), Math.min(255, 255 * oSF.getA() + 0.5 >> 0));
			} else if (fill.patternFill) {
				oUniFill = new AscFormat.CUniFill();
				oUniFill.fill = new AscFormat.CPattFill();
				oUniFill.fill.ftype = fill.patternFill.getHatchOffset();
				oUniFill.fill.fgClr = AscFormat.CreateUniColorRGB2(fill.patternFill.fgColor || AscCommonExcel.createRgbColor(0, 0, 0));
				oUniFill.fill.bgClr = AscFormat.CreateUniColorRGB2(fill.patternFill.bgColor || AscCommonExcel.createRgbColor(255, 255, 255));
			} else if (fill.gradientFill) {
				oUniFill = new AscFormat.CUniFill();
				oUniFill.fill = new AscFormat.CGradFill();
				if (fill.gradientFill.type === Asc.c_oAscFillGradType.GRAD_LINEAR) {
					oUniFill.fill.lin = new AscFormat.GradLin();
					oUniFill.fill.lin.angle = fill.gradientFill.degree * 60000;
				} else {
					oUniFill.fill.path = new AscFormat.GradPath();
				}
				for (var i = 0; i < fill.gradientFill.stop.length; ++i) {
					var oGradStop = new AscFormat.CGs();
					oGradStop.pos = fill.gradientFill.stop[i].position * 100000;
					oGradStop.color = AscFormat.CreateUniColorRGB2(fill.gradientFill.stop[i].color || AscCommonExcel.createRgbColor(255, 255, 255));
					oUniFill.fill.addColor(oGradStop);
				}
			}
			return oUniFill;
		}

		function getFullHyperlinkLength(str) {
			var res = 0;
			if (!str) {
				return res;
			}

			var validStr = "ABCDEFabcdef0123456789";
			//new RegExp('/^[xX]?[0-9a-fA-F]{6}$/', 'g')
			var checkHex = function (_val) {
				if (_val !== undefined && validStr.indexOf(_val) !== -1) {
					return true;
				}
				return false;
			};


			for (var i = 0; i < str.length; i++) {
				if (str[i] === "%") {
					if (checkHex(str[i + 1]) && checkHex(str[i + 2])) {
						res++;
					} else {
						res += 3;
					}
				} else {
					res++;
				}
			}

			return res;
		}

		var referenceType = {
			A: 0,			// Absolute
			ARRC: 1,	// Absolute row; relative column
			RRAC: 2,	// Relative row; absolute column
			R: 3			// Relative
		};

		/**
		 * Rectangle region of cells
		 * @constructor
		 * @memberOf Asc
		 * @param c1 {Number} Left side of range.
		 * @param r1 {Number} Top side of range.
		 * @param c2 {Number} Right side of range (inclusively).
		 * @param r2 {Number} Bottom side of range (inclusively).
		 * @param normalize {Boolean=} Optional. If true, range will be converted to form (left,top) - (right,bottom).
		 * @return {Range}
		 */
		function Range(c1, r1, c2, r2, normalize) {
			if (!(this instanceof Range)) {
				return new Range(c1, r1, c2, r2, normalize);
			}

			/** @type Number */
			this.c1 = c1;
			/** @type Number */
			this.r1 = r1;
			/** @type Number */
			this.c2 = c2;
			/** @type Number */
			this.r2 = r2;
			this.refType1 = referenceType.R;
			this.refType2 = referenceType.R;

			return normalize ? this.normalize() : this;
		}

		Range.prototype.compareCell = function (c1, r1, c2, r2) {
			var dif = r1 - r2;
			return 0 !== dif ? dif : c1 - c2;
		};
		Range.prototype.compareByLeftTop = function (a, b) {
			return Range.prototype.compareCell(a.c1, a.r1, b.c1, b.r1);
		};
		Range.prototype.compareByRightTop = function (a, b) {
			return Range.prototype.compareCell(a.c2, a.r1, b.c2, b.r1);
		};
		Range.prototype.compareByLeftBottom = function (a, b) {
			return Range.prototype.compareCell(a.c1, a.r2, b.c1, b.r2);
		};
		Range.prototype.compareByRightBottom = function (a, b) {
			return Range.prototype.compareCell(a.c2, a.r2, b.c2, b.r2);
		};
		Range.prototype.assign = function (c1, r1, c2, r2, normalize) {
			this.c1 = c1;
			this.r1 = r1;
			this.c2 = c2;
			this.r2 = r2;
			return normalize ? this.normalize() : this;
		};
		Range.prototype.assign2 = function (range) {
			this.refType1 = range.refType1;
			this.refType2 = range.refType2;
			return this.assign(range.c1, range.r1, range.c2, range.r2);
		};

		Range.prototype.clone = function (normalize) {
			var oRes = new Range(this.c1, this.r1, this.c2, this.r2, normalize);
			oRes.refType1 = this.refType1;
			oRes.refType2 = this.refType2;
			return oRes;
		};

		Range.prototype.normalize = function () {
			var tmp;
			if (this.c1 > this.c2) {
				tmp = this.c1;
				this.c1 = this.c2;
				this.c2 = tmp;
			}
			if (this.r1 > this.r2) {
				tmp = this.r1;
				this.r1 = this.r2;
				this.r2 = tmp;
			}
			return this;
		};

		Range.prototype.isEqual = function (range) {
			return range && this.c1 === range.c1 && this.r1 === range.r1 && this.c2 === range.c2 && this.r2 === range.r2;
		};

		Range.prototype.isEqualCols = function (range) {
			return range && this.c1 === range.c1 && this.c2 === range.c2;
		};

		Range.prototype.isEqualRows = function (range) {
			return range && this.r1 === range.r1 && this.r2 === range.r2;
		};
		Range.prototype.isNeighbor = function (range) {
			if (this.isEqualCols(range)) {
				if (this.r2 === range.r1 - 1 || range.r2 === this.r1 - 1) {
					return true;
				}
			} else if (this.isEqualRows(range)) {
				if (this.c2 === range.c1 - 1 || range.c2 === this.c1 - 1) {
					return true;
				}
			}
			return false;
		};

		Range.prototype.isEqualAll = function (range) {
			return this.isEqual(range) && this.refType1 === range.refType1 && this.refType2 === range.refType2;
		};

		Range.prototype.isEqualWithOffsetRow = function (range, offsetRow) {
			return this.c1 === range.c1 && this.c2 === range.c2 &&
				this.isAbsC1() === range.isAbsC1() && this.isAbsC2() === range.isAbsC2() &&
				this.isAbsR1() === range.isAbsR1() && this.isAbsR2() === range.isAbsR2() &&
				(((this.isAbsR1() ? this.r1 === range.r1 : this.r1 + offsetRow === range.r1) &&
					(this.isAbsR2() ? this.r2 === range.r2 : this.r2 + offsetRow === range.r2)) ||
					(this.r1 === 0 && this.r2 === gc_nMaxRow0 && this.r1 === range.r1 && this.r2 === range.r2));
		};

		Range.prototype.contains = function (c, r) {
			return this.c1 <= c && c <= this.c2 && this.r1 <= r && r <= this.r2;
		};
		Range.prototype.contains2 = function (cell) {
			return this.contains(cell.col, cell.row);
		};
		Range.prototype.containsCol = function (c) {
			return this.c1 <= c && c <= this.c2;
		};
		Range.prototype.containsRow = function (r) {
			return this.r1 <= r && r <= this.r2;
		};

		Range.prototype.containsRange = function (range) {
			return this.contains(range.c1, range.r1) && this.contains(range.c2, range.r2);
		};

		Range.prototype.containsRanges = function (ranges) {
			if (ranges && ranges.length) {
				for (var i = 0; i < ranges.length; i++) {
					if (!this.containsRange(ranges[i])) {
						return false;
					}
				}
				return true;
			}
			return false;
		};

		Range.prototype.containsFirstLineRange = function (range) {
			return this.contains(range.c1, range.r1) && this.contains(range.c2, range.r1);
		};

		Range.prototype.intersection = function (range) {
			var s1 = this.clone(true), s2 = range instanceof Range ? range.clone(true) :
				new Range(range.c1, range.r1, range.c2, range.r2, true);

			if (s2.c1 > s1.c2 || s2.c2 < s1.c1 || s2.r1 > s1.r2 || s2.r2 < s1.r1) {
				return null;
			}

			return new Range(s2.c1 >= s1.c1 && s2.c1 <= s1.c2 ? s2.c1 : s1.c1, s2.r1 >= s1.r1 && s2.r1 <= s1.r2 ? s2.r1 :
				s1.r1, Math.min(s1.c2, s2.c2), Math.min(s1.r2, s2.r2));
		};

		Range.prototype.intersectionSimple = function (range) {
			var oRes = null;
			var r1 = Math.max(this.r1, range.r1);
			var c1 = Math.max(this.c1, range.c1);
			var r2 = Math.min(this.r2, range.r2);
			var c2 = Math.min(this.c2, range.c2);
			if (r1 <= r2 && c1 <= c2) {
				oRes = new Range(c1, r1, c2, r2);
			}
			return oRes;
		};

		Range.prototype.isIntersect = function (range) {
			var bRes = true;
			if (range.r2 < this.r1 || this.r2 < range.r1) {
				bRes = false;
			} else if (range.c2 < this.c1 || this.c2 < range.c1) {
				bRes = false;
			}
			return bRes;
		};

		Range.prototype.isIntersectForInsertColRow = function (range, isInsertCol) {
			var bRes = true;
			if (range.r2 < this.r1 || this.r2 < range.r1)
				bRes = false;
			else if (range.c2 < this.c1 || this.c2 < range.c1)
				bRes = false;
			else if (isInsertCol && (this.c1 >= range.c1))
				bRes = false;
			else if (!isInsertCol && (this.r1 >= range.r1))
				bRes = false;
			return bRes;
		};

		Range.prototype.isIntersectWithRanges = function (ranges, exceptionIndex) {
			if (ranges) {
				for (var i = 0; i < ranges.length; i++) {
					if ((null == exceptionIndex || (null != exceptionIndex && i !== exceptionIndex)) && this.isIntersect(ranges[i])) {
						return true;
					}
				}
			}
			return false;
		};

		Range.prototype.isIntersectForShift = function (range, offset) {
			var isHor = offset && offset.col;
			var isDelete = offset && (offset.col < 0 || offset.row < 0);
			if (isHor) {
				if (this.r1 <= range.r1 && range.r2 <= this.r2 && this.c1 <= range.c2) {
					return true;
				} else if (isDelete && this.c1 <= range.c1 && range.c2 <= this.c2) {
					var topIn = this.r1 <= range.r1 && range.r1 <= this.r2;
					var bottomIn = this.r1 <= range.r2 && range.r2 <= this.r2;
					return topIn || bottomIn;
				}
			} else {
				if (this.c1 <= range.c1 && range.c2 <= this.c2 && this.r1 <= range.r2) {
					return true;
				} else if (isDelete && this.r1 <= range.r1 && range.r2 <= this.r2) {
					var leftIn = this.c1 <= range.c1 && range.c1 <= this.c2;
					var rightIn = this.c1 <= range.c2 && range.c2 <= this.c2;
					return leftIn || rightIn;
				}
			}
			return false;
		};

		Range.prototype.difference = function (range) {
			var res = [];
			var intersect;
			if (this.r1 > 0) {
				intersect = new Range(0, 0, gc_nMaxCol0, this.r1 - 1).intersectionSimple(range);
				if (intersect) {
					res.push(intersect);
				}
			}
			if (this.c1 > 0) {
				intersect = new Range(0, this.r1, this.c1 - 1, this.r2).intersectionSimple(range);
				if (intersect) {
					res.push(intersect);
				}
			}
			if (this.c2 < gc_nMaxCol0) {
				intersect = new Range(this.c2 + 1, this.r1, gc_nMaxCol0, this.r2).intersectionSimple(range);
				if (intersect) {
					res.push(intersect);
				}
			}
			if (this.r2 < gc_nMaxRow0) {
				intersect = new Range(0, this.r2 + 1, gc_nMaxCol0, gc_nMaxRow0).intersectionSimple(range);
				if (intersect) {
					res.push(intersect);
				}
			}
			return res;
		};
		Range.prototype.isIntersectForShiftCell = function (col, row, offset) {
			var isHor = offset && 0 != offset.col;
			if (isHor) {
				return this.r1 <= row && row <= this.r2 && this.c1 <= col;
			} else {
				return this.c1 <= col && col <= this.c2 && this.r1 <= row;
			}
		};

		Range.prototype.forShift = function (bbox, offset, bUndo) {
			var isNoDelete = true;
			var isHor = 0 != offset.col;
			var toDelete = offset.col < 0 || offset.row < 0;
			var isLastRow = this.r2 === gc_nMaxRow0;
			var isLastCol = this.c2 === gc_nMaxCol0;
			if (isHor) {
				if (toDelete) {
					if (this.c1 < bbox.c1) {
						if (this.c2 <= bbox.c2) {
							this.setOffsetLast(new AscCommon.CellBase(0, -(this.c2 - bbox.c1 + 1)));
						} else {
							this.setOffsetLast(offset);
						}
					} else if (this.c1 <= bbox.c2) {
						if (this.c2 <= bbox.c2) {
							if (!bUndo) {
								var topIn = bbox.r1 <= this.r1 && this.r1 <= bbox.r2;
								var bottomIn = bbox.r1 <= this.r2 && this.r2 <= bbox.r2;
								if (topIn && bottomIn) {
									isNoDelete = false;
								} else if (topIn) {
									this.setOffsetFirst(new AscCommon.CellBase(bbox.r2 - this.r1 + 1, 0));
								} else if (bottomIn) {
									this.setOffsetLast(new AscCommon.CellBase(bbox.r1 - this.r2 - 1, 0));
								}
							}
						} else {
							this.setOffsetFirst(new AscCommon.CellBase(0, bbox.c1 - this.c1));
							this.setOffsetLast(offset);
						}
					} else {
						this.setOffset(offset);
					}
				} else {
					if (this.c1 < bbox.c1) {
						this.setOffsetLast(offset);
					} else {
						if (this.c1 + offset.col <= gc_nMaxCol0) {
							this.setOffset(offset);
						} else {
							isNoDelete = false;
						}
					}
				}
			} else {
				if (toDelete) {
					if (this.r1 < bbox.r1) {
						if (this.r2 <= bbox.r2) {
							this.setOffsetLast(new AscCommon.CellBase(-(this.r2 - bbox.r1 + 1), 0));
						} else {
							this.setOffsetLast(offset);
						}
					} else if (this.r1 <= bbox.r2) {
						if (this.r2 <= bbox.r2) {
							if (!bUndo) {
								var leftIn = bbox.c1 <= this.c1 && this.c1 <= bbox.c2;
								var rightIn = bbox.c1 <= this.c2 && this.c2 <= bbox.c2;
								if (leftIn && rightIn) {
									isNoDelete = false;
								} else if (leftIn) {
									this.setOffsetFirst(new AscCommon.CellBase(0, bbox.c2 - this.c1 + 1));
								} else if (rightIn) {
									this.setOffsetLast(new AscCommon.CellBase(0, bbox.c1 - this.c2 - 1));
								}
							}
						} else {
							this.setOffsetFirst(new AscCommon.CellBase(bbox.r1 - this.r1, 0));
							this.setOffsetLast(offset);
						}
					} else {
						this.setOffset(offset);
					}
				} else {
					if (this.r1 < bbox.r1) {
						this.setOffsetLast(offset);
					} else {
						if (this.r1 + offset.row <= gc_nMaxRow0) {
							this.setOffset(offset);
						} else {
							isNoDelete = false;
						}
					}
				}
			}
			//range sticks to the gc_nMaxRow0/gc_nMaxCol0(but not to 0) and cannot be shifted
			if (isLastRow) {
				this.r2 = gc_nMaxRow0;
			}
			if (isLastCol) {
				this.c2 = gc_nMaxCol0;
			}
			return isNoDelete;
		};

		Range.prototype.isOneCell = function () {
			return this.r1 === this.r2 && this.c1 === this.c2;
		};

		Range.prototype.isOneCol = function () {
			return this.c1 === this.c2;
		};

		Range.prototype.isOneRow = function () {
			return this.r1 === this.r2;
		};

		Range.prototype.isOnTheEdge = function (c, r) {
			return this.r1 === r || this.r2 === r || this.c1 === c || this.c2 === c;
		};

		Range.prototype.union = function (range) {
			var s1 = this.clone(true), s2 = range instanceof Range ? range.clone(true) :
				new Range(range.c1, range.r1, range.c2, range.r2, true);

			return new Range(Math.min(s1.c1, s2.c1), Math.min(s1.r1, s2.r1), Math.max(s1.c2, s2.c2), Math.max(s1.r2, s2.r2));
		};

		Range.prototype.union2 = function (range) {
			this.c1 = Math.min(this.c1, range.c1);
			this.c2 = Math.max(this.c2, range.c2);
			this.r1 = Math.min(this.r1, range.r1);
			this.r2 = Math.max(this.r2, range.r2);
		};

		Range.prototype.union3 = function (c, r) {
			this.c1 = Math.min(this.c1, c);
			this.c2 = Math.max(this.c2, c);
			this.r1 = Math.min(this.r1, r);
			this.r2 = Math.max(this.r2, r);
		};
		Range.prototype.setOffsetWithAbs = function (offset, opt_canResize, opt_circle) {
			var temp;
			var row = offset.row;
			var col = offset.col;
			//todo offset A1048576:A1 (row = 1 -> A1:A2; row = -1 -> A1048575:A1048576)
			if (0 === this.r1 && gc_nMaxRow0 === this.r2) {
				//full sheet is 1:1048576 but row is valid for it
				row = 0;
			} else if (0 === this.c1 && gc_nMaxCol0 === this.c2) {
				col = 0;
			}
			var isAbsRow1 = this.isAbsRow(this.refType1);
			var isAbsCol1 = this.isAbsCol(this.refType1);
			var isAbsRow2 = this.isAbsRow(this.refType2);
			var isAbsCol2 = this.isAbsCol(this.refType2);
			if (!isAbsRow1) {
				this.r1 += row;
				if (this.r1 < 0) {
					if (opt_circle) {
						this.r1 += gc_nMaxRow0 + 1;
					} else {
						this.r1 = 0;
						if (!opt_canResize) {
							return false;
						}
					}
				}
				if (this.r1 > gc_nMaxRow0) {
					if (opt_circle) {
						this.r1 -= gc_nMaxRow0 + 1;
					} else {
						this.r1 = gc_nMaxRow0;
						return false;
					}
				}
			}
			if (!isAbsCol1) {
				this.c1 += col;
				if (this.c1 < 0) {
					if (opt_circle) {
						this.c1 += gc_nMaxCol0 + 1;
					} else {
						this.c1 = 0;
						if (!opt_canResize) {
							return false;
						}
					}
				}
				if (this.c1 > gc_nMaxCol0) {
					if (opt_circle) {
						this.c1 -= gc_nMaxCol0 + 1;
					} else {
						this.c1 = gc_nMaxCol0;
						return false;
					}
				}
			}
			if (!isAbsRow2) {
				this.r2 += row;
				if (this.r2 < 0) {
					if (opt_circle) {
						this.r2 += gc_nMaxRow0 + 1;
					} else {
						this.r2 = 0;
						return false;
					}
				}
				if (this.r2 > gc_nMaxRow0) {
					if (opt_circle) {
						this.r2 -= gc_nMaxRow0 + 1;
					} else {
						this.r2 = gc_nMaxRow0;
						if (!opt_canResize) {
							return false;
						}
					}
				}
			}
			if (!isAbsCol2) {
				this.c2 += col;
				if (this.c2 < 0) {
					if (opt_circle) {
						this.c2 += gc_nMaxCol0 + 1;
					} else {
						this.c2 = 0;
						return false;
					}
				}
				if (this.c2 > gc_nMaxCol0) {
					if (opt_circle) {
						this.c2 -= gc_nMaxCol0 + 1;
					} else {
						this.c2 = gc_nMaxCol0;
						if (!opt_canResize) {
							return false;
						}
					}
				}
			}
			//switch abs flag
			if (this.r1 > this.r2) {
				temp = this.r1;
				this.r1 = this.r2;
				this.r2 = temp;
				if (!isAbsRow1 && isAbsRow2) {
					isAbsRow1 = !isAbsRow1;
					isAbsRow2 = !isAbsRow2;
					this.setAbs(isAbsRow1, isAbsCol1, isAbsRow2, isAbsCol2);
				}
			}
			if (this.c1 > this.c2) {
				temp = this.c1;
				this.c1 = this.c2;
				this.c2 = temp;
				if (!isAbsCol1 && isAbsCol2) {
					isAbsCol1 = !isAbsCol1;
					isAbsCol2 = !isAbsCol2;
					this.setAbs(isAbsRow1, isAbsCol1, isAbsRow2, isAbsCol2);
				}
			}
			return true;
		};
		Range.prototype.setOffset = function (offset) {
			if (this.r1 == 0 && this.r2 == gc_nMaxRow0 && offset.row != 0 ||
				this.c1 == 0 && this.c2 == gc_nMaxCol0 && offset.col != 0) {
				return;
			}
			this.setOffsetFirst(offset);
			this.setOffsetLast(offset);
		};

		Range.prototype.setOffsetFirst = function (offset) {
			this.c1 += offset.col;
			if (this.c1 < 0) {
				this.c1 = 0;
			}
			if (this.c1 > gc_nMaxCol0) {
				this.c1 = gc_nMaxCol0;
			}
			this.r1 += offset.row;
			if (this.r1 < 0) {
				this.r1 = 0;
			}
			if (this.r1 > gc_nMaxRow0) {
				this.r1 = gc_nMaxRow0;
			}
		};

		Range.prototype.setOffsetLast = function (offset) {
			this.c2 += offset.col;
			if (this.c2 < 0) {
				this.c2 = 0;
			}
			if (this.c2 > gc_nMaxCol0) {
				this.c2 = gc_nMaxCol0;
			}
			this.r2 += offset.row;
			if (this.r2 < 0) {
				this.r2 = 0;
			}
			if (this.r2 > gc_nMaxRow0) {
				this.r2 = gc_nMaxRow0;
			}
		};

		Range.prototype._getName = function (val, isCol, abs) {
			var isR1C1Mode = AscCommonExcel.g_R1C1Mode;
			val += 1;
			if (isCol && !isR1C1Mode) {
				val = g_oCellAddressUtils.colnumToColstr(val);
			}
			return (isR1C1Mode ? (isCol ? 'C' : 'R') : '') + (abs ? (isR1C1Mode ? val : '$' + val) :
				(isR1C1Mode ? ((0 !== (val = (val - (isCol ? AscCommonExcel.g_ActiveCell.c1 :
					AscCommonExcel.g_ActiveCell.r1) - 1))) ? '[' + val + ']' : '') : val));
		};
		Range.prototype.getName = function (refType) {
			var isR1C1Mode = AscCommonExcel.g_R1C1Mode;
			var c, r, type = this.getType();
			var sRes = "";
			var c1Abs, c2Abs, r1Abs, r2Abs;
			if (referenceType.A === refType) {
				c1Abs = c2Abs = r1Abs = r2Abs = true;
			} else if (referenceType.R === refType) {
				c1Abs = c2Abs = r1Abs = r2Abs = false;
			} else {
				c1Abs = this.isAbsCol(this.refType1);
				c2Abs = this.isAbsCol(this.refType2);
				r1Abs = this.isAbsRow(this.refType1);
				r2Abs = this.isAbsRow(this.refType2);
			}

			if ((c_oAscSelectionType.RangeMax === type || c_oAscSelectionType.RangeRow === type) && c1Abs === c2Abs) {
				sRes = this._getName(this.r1, false, r1Abs);
				if (this.r1 !== this.r2 || r1Abs !== r2Abs || !isR1C1Mode) {
					sRes += ':' + this._getName(this.r2, false, r2Abs);
				}
			} else if ((c_oAscSelectionType.RangeMax === type || c_oAscSelectionType.RangeCol === type) && r1Abs === r2Abs) {
				sRes = this._getName(this.c1, true, c1Abs);
				if (this.c1 !== this.c2 || c1Abs !== c2Abs || !isR1C1Mode) {
					sRes += ':' + this._getName(this.c2, true, c2Abs);
				}
			} else {
				r = this._getName(this.r1, false, r1Abs);
				c = this._getName(this.c1, true, c1Abs);
				sRes = isR1C1Mode ? r + c : c + r;

				if (!this.isOneCell() || r1Abs !== r2Abs || c1Abs !== c2Abs) {
					r = this._getName(this.r2, false, r2Abs);
					c = this._getName(this.c2, true, c2Abs);
					sRes += ':' + (isR1C1Mode ? r + c : c + r);
				}
			}
			return sRes;
		};

		Range.prototype.getAbsName = function () {
			return this.getName(referenceType.A);
		};

		Range.prototype.getType = function () {
			var bRow = 0 === this.c1 && gc_nMaxCol0 === this.c2;
			var bCol = 0 === this.r1 && gc_nMaxRow0 === this.r2;
			var res;
			if (bCol && bRow) {
				res = c_oAscSelectionType.RangeMax;
			} else if (bCol) {
				res = c_oAscSelectionType.RangeCol;
			} else if (bRow) {
				res = c_oAscSelectionType.RangeRow;
			} else {
				res = c_oAscSelectionType.RangeCells;
			}
			return res;
		};

		Range.prototype.getSharedRange = function (sharedRef, c, r) {
			var isAbsR1 = this.isAbsR1();
			var isAbsC1 = this.isAbsC1();
			var isAbsR2 = this.isAbsR2();
			var isAbsC2 = this.isAbsC2();
			if (this.r1 === 0 && this.r2 === gc_nMaxRow0) {
				isAbsR1 = isAbsR2 = true;
			}
			if (this.c1 === 0 && this.c2 === gc_nMaxCol0) {
				isAbsC1 = isAbsC2 = true;
			}
			var r1 = isAbsR2 ? sharedRef.r1 : Math.max(sharedRef.r2 + (r - this.r2), sharedRef.r1);
			var c1 = isAbsC2 ? sharedRef.c1 : Math.max(sharedRef.c2 + (c - this.c2), sharedRef.c1);
			var r2 = isAbsR1 ? sharedRef.r2 : Math.min(sharedRef.r1 + (r - this.r1), sharedRef.r2);
			var c2 = isAbsC1 ? sharedRef.c2 : Math.min(sharedRef.c1 + (c - this.c1), sharedRef.c2);
			return new Range(c1, r1, c2, r2);
		};
		Range.prototype.getSharedRangeBbox = function (ref, base) {
			var res = this.clone();
			var shiftBase;
			var offset = new AscCommon.CellBase(ref.r1 - base.nRow, ref.c1 - base.nCol);
			if (!offset.isEmpty()) {
				shiftBase = this.clone();
				shiftBase.setOffsetWithAbs(offset, false, false);
			}
			offset.row = ref.r2 - base.nRow;
			offset.col = ref.c2 - base.nCol;
			res.setOffsetWithAbs(offset, false, false);
			res.union2(shiftBase ? shiftBase : this);
			return res;
		};
		Range.prototype.getSharedIntersect = function (sharedRef, bbox) {
			var leftTop = this.getSharedRange(sharedRef, bbox.c1, bbox.r1);
			var rightBottom = this.getSharedRange(sharedRef, bbox.c2, bbox.r2);
			return leftTop.union(rightBottom);
		};
		Range.prototype.setAbs = function (absRow1, absCol1, absRow2, absCol2) {
			this.refType1 = (absRow1 ? 0 : 2) + (absCol1 ? 0 : 1);
			this.refType2 = (absRow2 ? 0 : 2) + (absCol2 ? 0 : 1);
		};
		Range.prototype.isAbsCol = function (refType) {
			return (refType === referenceType.A || refType === referenceType.RRAC);
		};
		Range.prototype.isAbsRow = function (refType) {
			return (refType === referenceType.A || refType === referenceType.ARRC);
		};
		Range.prototype.isAbsR1 = function () {
			return this.isAbsRow(this.refType1);
		};
		Range.prototype.isAbsC1 = function () {
			return this.isAbsCol(this.refType1);
		};
		Range.prototype.isAbsR2 = function () {
			return this.isAbsRow(this.refType2);
		};
		Range.prototype.isAbsC2 = function () {
			return this.isAbsCol(this.refType2);
		};
		Range.prototype.isAbsAll = function () {
			return this.isAbsR1() && this.isAbsC1() && this.isAbsR2() && this.isAbsC2();
		};
		Range.prototype.switchReference = function () {
			this.refType1 = (this.refType1 + 1) % 4;
			this.refType2 = (this.refType2 + 1) % 4;
		};
		Range.prototype.getWidth = function () {
			return this.c2 - this.c1 + 1;
		};
		Range.prototype.getHeight = function () {
			return this.r2 - this.r1 + 1;
		};
		Range.prototype.transpose = function (startCol, startRow) {
			if (startCol === undefined) {
				startCol = this.c1;
			}
			if (startRow === undefined) {
				startRow = this.r1;
			}
			var row0 = this.c1 - startCol + startRow;
			var col0 = this.r1 - startRow + startCol;

			return new Range(col0, row0, col0 + (this.r2 - this.r1), row0 + (this.c2 - this.c1));
		};
		Range.prototype.sliceAfter = function (col, row) {
			let res = null;
			if (col !== this.c2) {
				if (!res) {
					res = [];
				}
				res.push(new Range(col + 1, row, this.c2, row));
			}
			if (row !== this.r2) {
				if (!res) {
					res = [];
				}
				res.push(new Range(this.c1, row + 1, this.c2, this.r2));
			}
			return res;
		};
		/**
		 * Adjusts range coordinates based on removed rows or columns
		 * @param {Range} deleteRange Range being deleted
		 * @param {Boolean} isRow True if deleting rows, false if deleting columns
		 * @returns {Range|null} Adjusted range or null if range should be deleted
		 */
		Range.prototype.adjustRange = function(deleteRange, isRow) {
			if (!deleteRange) {
				return null;
			}
			// Clone range to avoid modifying original
			let newRange = this.clone();

			if (isRow) {
				// Handle row deletion
				let deleteCount = deleteRange.r2 - deleteRange.r1 + 1;

				// Range is fully within deleted rows - return null
				if (this.r1 >= deleteRange.r1 && this.r2 <= deleteRange.r2) {
					return null;
				}

				// Adjust range start row if after deleted section
				if (this.r1 > deleteRange.r2) {
					newRange.r1 = Math.max(0, this.r1 - deleteCount);
					newRange.r2 = Math.max(0, this.r2 - deleteCount);
				}
				// Adjust range end row if crosses deleted section
				else if (this.r2 > deleteRange.r2) {
					newRange.r2 = Math.max(0, this.r2 - deleteCount);
				}
				// Adjust range end row if includes deleted section
				else if (this.r2 >= deleteRange.r1) {
					newRange.r2 = deleteRange.r1 - 1;
				}
			} else {
				// Handle column deletion
				let deleteCount = deleteRange.c2 - deleteRange.c1 + 1;

				// Range is fully within deleted columns - return null
				if (this.c1 >= deleteRange.c1 && this.c2 <= deleteRange.c2) {
					return null;
				}

				// Adjust range start column if after deleted section
				if (this.c1 > deleteRange.c2) {
					newRange.c1 = Math.max(0, this.c1 - deleteCount);
					newRange.c2 = Math.max(0, this.c2 - deleteCount);
				}
				// Adjust range end column if crosses deleted section
				else if (this.c2 > deleteRange.c2) {
					newRange.c2 = Math.max(0, this.c2 - deleteCount);
				}
				// Adjust range end column if includes deleted section
				else if (this.c2 >= deleteRange.c1) {
					newRange.c2 = deleteRange.c1 - 1;
				}
			}

			return newRange;
		};


		/**
		 *
		 * @constructor
		 * @extends {Range}
		 */
		function Range3D() {
			this.sheet = '';
			this.sheet2 = '';

			if (3 == arguments.length) {
				var range = arguments[0];
				Range.call(this, range.c1, range.r1, range.c2, range.r2);
				// ToDo стоит пересмотреть конструкторы.
				this.refType1 = range.refType1;
				this.refType2 = range.refType2;

				this.sheet = arguments[1];
				this.sheet2 = arguments[2];
			} else if (arguments.length > 1) {
				Range.apply(this, arguments);
			} else {
				Range.call(this, 0, 0, 0, 0);
			}
		}

		Range3D.prototype = Object.create(Range.prototype);
		Range3D.prototype.constructor = Range3D;
		Range3D.prototype.isIntersect = function () {
			var oRes = true;

			if (2 == arguments.length) {
				oRes = this.sheet === arguments[1];
			}
			return oRes && Range.prototype.isIntersect.apply(this, arguments);
		};
		Range3D.prototype.clone = function () {
			return new Range3D(Range.prototype.clone.apply(this, arguments), this.sheet, this.sheet2);
		};
		Range3D.prototype.setSheet = function (sheet, sheet2) {
			this.sheet = sheet;
			this.sheet2 = sheet2 ? sheet2 : sheet;
		};
		Range3D.prototype.getName = function () {
			return AscCommon.parserHelp.get3DRef(this.sheet, Range.prototype.getName.apply(this));
		};

		/**
		 * @constructor
		 */
		function SelectionRange(ws) {
			this.ranges = [new Range(0, 0, 0, 0)];
			this.activeCell = new AscCommon.CellBase(0, 0); // Active cell
			this.activeCellId = 0;

			this.worksheet = ws;
		}

		SelectionRange.prototype.clean = function () {
			this.ranges = [new Range(0, 0, 0, 0)];
			this.activeCellId = 0;
			this.activeCell.clean();
		};
		SelectionRange.prototype.contains = function (c, r) {
			return this.ranges.some(function (item) {
				return item.contains(c, r);
			});
		};
		SelectionRange.prototype.contains2 = function (cell) {
			return this.contains(cell.col, cell.row);
		};
		SelectionRange.prototype.containsCol = function (c) {
			return this.ranges.some(function (item) {
				return item.containsCol(c);
			});
		};
		SelectionRange.prototype.containsRow = function (r) {
			return this.ranges.some(function (item) {
				return item.containsRow(r);
			});
		};
		SelectionRange.prototype.inContains = function (ranges) {
			return this.ranges.every(function (item1) {
				return ranges.some(function (item2) {
					return item2.containsRange(item1);
				});
			});
		};
		SelectionRange.prototype.containsRange = function (range) {
			return this.ranges.some(function (item) {
				return item.containsRange(range);
			});
		};
		SelectionRange.prototype.clone = function (worksheet) {
			var res = new this.constructor();
			res.ranges = this.ranges.map(function (range) {
				return range.clone();
			});
			res.activeCell = this.activeCell.clone();
			res.activeCellId = this.activeCellId;
			res.worksheet = worksheet || this.worksheet;
			return res;
		};
		SelectionRange.prototype.isEqual = function (range) {
			if (this.activeCellId !== range.activeCellId || !this.activeCell.isEqual(range.activeCell) ||
				this.ranges.length !== range.ranges.length) {
				return false;
			}
			for (var i = 0; i < this.ranges.length; ++i) {
				if (!this.ranges[i].isEqual(range.ranges[i])) {
					return false;
				}
			}
			return true;
		};
		SelectionRange.prototype.addRange = function () {
			this.activeCellId = this.ranges.push(new Range(0, 0, 0, 0)) - 1;
			this.activeCell.clean();
		};
		SelectionRange.prototype.assign2 = function (range) {
			this.clean();
			this.getLast().assign2(range);
			this.update();
		};
		SelectionRange.prototype.union = function (range) {
			var res = this.ranges.some(function (item) {
				var success = false;
				if (item.c1 === range.c1 && item.c2 === range.c2) {
					if (range.r1 === item.r2 + 1) {
						item.r2 = range.r2;
						success = true;
					} else if (range.r2 === item.r1 - 1) {
						item.r1 = range.r1;
						success = true;
					}
				} else if (item.r1 === range.r1 && item.r2 === range.r2) {
					if (range.c1 === item.c2 + 1) {
						item.c2 = range.c2;
						success = true;
					} else if (range.c2 === item.c1 - 1) {
						item.c1 = range.c1;
						success = true;
					}
				}
				return success;
			});
			if (!res) {
				this.addRange();
				this.getLast().assign2(range);
			}
		};
		SelectionRange.prototype.getUnion = function () {
			var result = new this.constructor(this.worksheet);
			var unionRanges = function (ranges, res) {
				for (var i = 0; i < ranges.length; ++i) {
					if (0 === i) {
						res.assign2(ranges[i]);
					} else {
						res.union(ranges[i]);
					}
				}
			};
			unionRanges(this.ranges, result);

			var isUnion = true, resultTmp;
			while (isUnion && !result.isSingleRange()) {
				resultTmp = new this.constructor(this.worksheet);
				unionRanges(result.ranges, resultTmp);
				isUnion = result.ranges.length !== resultTmp.ranges.length;
				result = resultTmp;
			}
			return result;
		};
		SelectionRange.prototype.offsetCell = function (dr, dc, changeRange, fCheckSize) {
			var done, curRange, mc, incompleate;
			// Check one cell
			if (1 === this.ranges.length) {
				curRange = this.ranges[this.activeCellId];
				if (curRange.isOneCell()) {
					return 0;
				} else {
					mc = this.worksheet.getMergedByCell(this.activeCell.row, this.activeCell.col);
					if (mc && curRange.isEqual(mc)) {
						return 0;
					}
				}
			}

			var lastRow = this.activeCell.row;
			var lastCol = this.activeCell.col;
			this.activeCell.row += dr;
			this.activeCell.col += dc;

			while (!done) {
				done = true;

				curRange = this.ranges[this.activeCellId];
				if (!curRange.contains2(this.activeCell)) {
					if (dr) {
						if (0 < dr) {
							this.activeCell.row = curRange.r1;
							this.activeCell.col += 1;
						} else {
							this.activeCell.row = curRange.r2;
							this.activeCell.col -= 1;
						}
					} else {
						if (0 < dc) {
							this.activeCell.row += 1;
							this.activeCell.col = curRange.c1;
						} else {
							this.activeCell.row -= 1;
							this.activeCell.col = curRange.c2;
						}
					}

					if (!curRange.contains2(this.activeCell)) {
						if (!changeRange) {
							this.activeCell.row = lastRow;
							this.activeCell.col = lastCol;
							return -1;
						}
						if (0 < dc || 0 < dr) {
							this.activeCellId += 1;
							this.activeCellId = (this.ranges.length > this.activeCellId) ? this.activeCellId : 0;
							curRange = this.ranges[this.activeCellId];

							this.activeCell.row = curRange.r1;
							this.activeCell.col = curRange.c1;
						} else {
							this.activeCellId -= 1;
							this.activeCellId = (0 <= this.activeCellId) ? this.activeCellId : this.ranges.length - 1;
							curRange = this.ranges[this.activeCellId];

							this.activeCell.row = curRange.r2;
							this.activeCell.col = curRange.c2;
						}
					}
				}

				mc = this.worksheet.getMergedByCell(this.activeCell.row, this.activeCell.col);
				if (mc) {
					incompleate = !curRange.containsRange(mc);
					if (dc > 0 && (incompleate || this.activeCell.col > mc.c1 || this.activeCell.row !== mc.r1)) {
						// Движение слева направо
						this.activeCell.col = mc.c2 + 1;
						done = false;
					} else if (dc < 0 && (incompleate || this.activeCell.col < mc.c2 || this.activeCell.row !== mc.r1)) {
						// Движение справа налево
						this.activeCell.col = mc.c1 - 1;
						done = false;
					}
					if (dr > 0 && (incompleate || this.activeCell.row > mc.r1 || this.activeCell.col !== mc.c1)) {
						// Движение сверху вниз
						this.activeCell.row = mc.r2 + 1;
						done = false;
					} else if (dr < 0 && (incompleate || this.activeCell.row < mc.r2 || this.activeCell.col !== mc.c1)) {
						// Движение снизу вверх
						this.activeCell.row = mc.r1 - 1;
						done = false;
					}
				}
				if (!done) {
					continue;
				}

				while (this.activeCell.col >= curRange.c1 && this.activeCell.col <= curRange.c2 && fCheckSize(-1, this.activeCell.col)) {
					this.activeCell.col += dc || (dr > 0 ? +1 : -1);
					done = false;
				}
				if (!done) {
					continue;
				}

				while (this.activeCell.row >= curRange.r1 && this.activeCell.row <= curRange.r2 && fCheckSize(this.activeCell.row, -1)) {
					this.activeCell.row += dr || (dc > 0 ? +1 : -1);
					done = false;
				}

				if (!done) {
					continue;
				}

				break;
			}
			return (lastRow !== this.activeCell.row || lastCol !== this.activeCell.col) ? 1 : -1;
		};
		SelectionRange.prototype.setActiveCell = function (r, c) {
			this.activeCell.row = r;
			this.activeCell.col = c;
			this.update();
		};
		SelectionRange.prototype.validActiveCell = function () {
			var res = true;
			// Check active cell in merge cell for selection row or column (bug 36708)
			var mc = this.worksheet.getMergedByCell(this.activeCell.row, this.activeCell.col);
			if (mc) {
				var curRange = this.ranges[this.activeCellId];
				if (!curRange.containsRange(mc)) {
					if (-1 === this.offsetCell(1, 0, false, function () {
						return false;
					})) {
						res = false;
						this.activeCell.row = mc.r1;
						this.activeCell.col = mc.c1;
					}
				}
			}
			return res;
		};
		SelectionRange.prototype.getLast = function () {
			return this.ranges[this.ranges.length - 1];
		};
		SelectionRange.prototype.isSingleRange = function () {
			return 1 === this.ranges.length;
		};
		SelectionRange.prototype.update = function () {
			//меняем выделеную ячейку, если она не входит в диапазон
			//возможно, в будующем придется пределать логику, пока нет примеров, когда это работает плохо
			var range = this.ranges[this.activeCellId];
			if (!range || !range.contains(this.activeCell.col, this.activeCell.row)) {
				range = this.getLast();
				this.activeCell.col = range.c1;
				this.activeCell.row = range.r1;
				this.activeCellId = this.ranges.length - 1;
			}
		};
		SelectionRange.prototype.WriteToBinary = function (w) {
			w.WriteLong(this.ranges.length);
			for (var i = 0; i < this.ranges.length; ++i) {
				var range = this.ranges[i];
				w.WriteLong(range.c1);
				w.WriteLong(range.r1);
				w.WriteLong(range.c2);
				w.WriteLong(range.r2);
			}
			w.WriteLong(this.activeCell.row);
			w.WriteLong(this.activeCell.col);
			w.WriteLong(this.activeCellId);
		};
		SelectionRange.prototype.ReadFromBinary = function (r) {
			this.clean();
			var count = r.GetLong();
			var rangesNew = [];
			for (var i = 0; i < count; ++i) {
				var range = new Asc.Range(r.GetLong(), r.GetLong(), r.GetLong(), r.GetLong());
				rangesNew.push(range);
			}
			if (rangesNew.length > 0) {
				this.ranges = rangesNew;
			}
			this.activeCell.row = r.GetLong();
			this.activeCell.col = r.GetLong();
			this.activeCellId = r.GetLong();
			this.update();
		};
		SelectionRange.prototype.Select = function (doNotUpdate) {
			this.worksheet.selectionRange = this.clone();
			!doNotUpdate && this.worksheet.workbook.handlers.trigger('updateSelection');
		};
		SelectionRange.prototype.isContainsOnlyFullRowOrCol = function (byCol) {
			var res = true;
			for (var i = 0; i < this.ranges.length; ++i) {
				var range = this.ranges[i];
				var type = range.getType();
				if (byCol && c_oAscSelectionType.RangeCol !== type) {
					res = false;
					break;
				}
				if (!byCol && c_oAscSelectionType.RangeRow !== type) {
					res = false;
					break;
				}
			}
			return res;
		};
		SelectionRange.prototype.getSize = function () {
			let res = 0;
			this.ranges.forEach(function (item) {
				res += (item.r2 - item.r1 + 1) * (item.c2 - item.c1 + 1);
			});
			return res;
		};

		/**
		 *
		 * @constructor
		 * @extends {Range}
		 */
		function ActiveRange() {
			if (1 == arguments.length) {
				var range = arguments[0];
				Range.call(this, range.c1, range.r1, range.c2, range.r2);
				// ToDo стоит пересмотреть конструкторы.
				this.refType1 = range.refType1;
				this.refType2 = range.refType2;
			} else if (arguments.length > 1)
				Range.apply(this, arguments);
			else
				Range.call(this, 0, 0, 0, 0);
			this.startCol = 0; // Активная ячейка в выделении
			this.startRow = 0; // Активная ячейка в выделении
			this._updateAdditionalData();
		}

		ActiveRange.prototype = Object.create(Range.prototype);
		ActiveRange.prototype.constructor = ActiveRange;
		ActiveRange.prototype.assign = function () {
			Range.prototype.assign.apply(this, arguments);
			this._updateAdditionalData();
			return this;
		};
		ActiveRange.prototype.assign2 = function () {
			Range.prototype.assign2.apply(this, arguments);
			this._updateAdditionalData();
			return this;
		};
		ActiveRange.prototype.clone = function () {
			var oRes = new ActiveRange(Range.prototype.clone.apply(this, arguments));
			oRes.startCol = this.startCol;
			oRes.startRow = this.startRow;
			return oRes;
		};
		ActiveRange.prototype.normalize = function () {
			Range.prototype.normalize.apply(this, arguments);
			this._updateAdditionalData();
			return this;
		};
		ActiveRange.prototype.isEqualAll = function () {
			var bRes = Range.prototype.isEqual.apply(this, arguments);
			if (bRes && arguments.length > 0) {
				var range = arguments[0];
				bRes = this.startCol == range.startCol && this.startRow == range.startRow;
			}
			return bRes;
		};
		ActiveRange.prototype.contains = function () {
			return Range.prototype.contains.apply(this, arguments);
		};
		ActiveRange.prototype.containsRange = function () {
			return Range.prototype.containsRange.apply(this, arguments);
		};
		ActiveRange.prototype.containsFirstLineRange = function () {
			return Range.prototype.containsFirstLineRange.apply(this, arguments);
		};
		ActiveRange.prototype.intersection = function () {
			var oRes = Range.prototype.intersection.apply(this, arguments);
			if (null != oRes) {
				oRes = new ActiveRange(oRes);
				oRes._updateAdditionalData();
			}
			return oRes;
		};
		ActiveRange.prototype.intersectionSimple = function () {
			var oRes = Range.prototype.intersectionSimple.apply(this, arguments);
			if (null != oRes) {
				oRes = new ActiveRange(oRes);
				oRes._updateAdditionalData();
			}
			return oRes;
		};
		ActiveRange.prototype.union = function () {
			var oRes = new ActiveRange(Range.prototype.union.apply(this, arguments));
			oRes._updateAdditionalData();
			return oRes;
		};
		ActiveRange.prototype.union2 = function () {
			Range.prototype.union2.apply(this, arguments);
			this._updateAdditionalData();
			return this;
		};
		ActiveRange.prototype.union3 = function () {
			Range.prototype.union3.apply(this, arguments);
			this._updateAdditionalData();
			return this;
		};
		ActiveRange.prototype.setOffset = function (offset) {
			this.setOffsetFirst(offset);
			this.setOffsetLast(offset);
		};
		ActiveRange.prototype.setOffsetFirst = function (offset) {
			Range.prototype.setOffsetFirst.apply(this, arguments);
			this._updateAdditionalData();
			return this;
		};
		ActiveRange.prototype.setOffsetLast = function (offset) {
			Range.prototype.setOffsetLast.apply(this, arguments);
			this._updateAdditionalData();
			return this;
		};
		ActiveRange.prototype._updateAdditionalData = function () {
			//меняем выделеную ячейку, если она не входит в диапазон
			//возможно, в будующем придется пределать логику, пока нет примеров, когда это работает плохо
			if (!this.contains(this.startCol, this.startRow)) {
				this.startCol = this.c1;
				this.startRow = this.r1;
			}
		};

		/**
		 *
		 * @constructor
		 * @extends {Range}
		 */
		function FormulaRange() {
			if (1 == arguments.length) {
				var range = arguments[0];
				Range.call(this, range.c1, range.r1, range.c2, range.r2);
			} else if (arguments.length > 1)
				Range.apply(this, arguments);
			else
				Range.call(this, 0, 0, 0, 0);

			this.refType1 = referenceType.R;
			this.refType2 = referenceType.R;
		}

		FormulaRange.prototype = Object.create(Range.prototype);
		FormulaRange.prototype.constructor = FormulaRange;
		FormulaRange.prototype.clone = function () {
			var oRes = new FormulaRange(Range.prototype.clone.apply(this, arguments));
			oRes.refType1 = this.refType1;
			oRes.refType2 = this.refType2;
			return oRes;
		};
		FormulaRange.prototype.intersection = function () {
			var oRes = Range.prototype.intersection.apply(this, arguments);
			if (null != oRes)
				oRes = new FormulaRange(oRes);
			return oRes;
		};
		FormulaRange.prototype.intersectionSimple = function () {
			var oRes = Range.prototype.intersectionSimple.apply(this, arguments);
			if (null != oRes)
				oRes = new FormulaRange(oRes);
			return oRes;
		};
		FormulaRange.prototype.union = function () {
			return new FormulaRange(Range.prototype.union.apply(this, arguments));
		};
		FormulaRange.prototype.getName = function () {
			var sRes = "";
			var c1Abs = this.isAbsCol(this.refType1), c2Abs = this.isAbsCol(this.refType2);
			var r1Abs = this.isAbsRow(this.refType1), r2Abs = this.isAbsRow(this.refType2);

			if (0 == this.c1 && gc_nMaxCol0 == this.c2) {
				if (r1Abs)
					sRes += "$";
				sRes += (this.r1 + 1) + ":";
				if (r2Abs)
					sRes += "$";
				sRes += (this.r2 + 1);
			} else if (0 == this.r1 && gc_nMaxRow0 == this.r2) {
				if (c1Abs)
					sRes += "$";
				sRes += g_oCellAddressUtils.colnumToColstr(this.c1 + 1) + ":";
				if (c2Abs)
					sRes += "$";
				sRes += g_oCellAddressUtils.colnumToColstr(this.c2 + 1);
			} else {
				if (c1Abs)
					sRes += "$";
				sRes += g_oCellAddressUtils.colnumToColstr(this.c1 + 1);
				if (r1Abs)
					sRes += "$";
				sRes += (this.r1 + 1);
				if (!this.isOneCell()) {
					sRes += ":";
					if (c2Abs)
						sRes += "$";
					sRes += g_oCellAddressUtils.colnumToColstr(this.c2 + 1);
					if (r2Abs)
						sRes += "$";
					sRes += (this.r2 + 1);
				}
			}
			return sRes;
		};

		function MultiplyRange(ranges) {
			this.ranges = ranges;
		}

		MultiplyRange.prototype.clone = function () {
			return new MultiplyRange(this.ranges.slice());
		};
		MultiplyRange.prototype.union2 = function (multiplyRange) {
			if (!multiplyRange || !multiplyRange.ranges) {
				return;
			}
			for (var i = 0; i < multiplyRange.ranges.length; i++) {
				this.ranges.push(multiplyRange.ranges[i]);
			}
		};
		MultiplyRange.prototype.isIntersect = function (range) {
			for (var i = 0; i < this.ranges.length; ++i) {
				if (range.isIntersect(this.ranges[i])) {
					return true;
				}
			}
			return false;
		};
		MultiplyRange.prototype.contains = function (c, r) {
			for (var i = 0; i < this.ranges.length; ++i) {
				if (this.ranges[i].contains(c, r)) {
					return true;
				}
			}
			return false;
		};
		MultiplyRange.prototype.getUnionRange = function () {
			if (0 === this.ranges.length) {
				return null;
			}
			var res = this.ranges[0].clone();
			for (var i = 1; i < this.ranges.length; ++i) {
				res.union2(this.ranges[i]);
			}
			return res;
		};
		MultiplyRange.prototype.unionByRowCol = function (_bCol) {
			if (0 === this.ranges.length) {
				return null;
			}
			if (1 === this.ranges.length) {
				return this.ranges;
			}
			var _ranges = this.ranges;
			var map = {};
			var res = [];
			for (var i = 0; i < _ranges.length; i++) {
				for (var j = (_bCol ? _ranges[i].c1 : _ranges[i].r1); j <= (_bCol ? _ranges[i].c2 : _ranges[i].r2); j++) {
					if (!map[j]) {
						res.push(j);
						map[j] = 1;
					}
				}
			}

			res = res.sort(function (a, b) {
				return a - b;
			});

			//объединяем
			var unionRanges = [];
			var start = null;
			var end = null;
			for (var n = 0; n < res.length; n++) {
				if (start === null) {
					start = res[n];
					end = res[n];
				} else if (res[n - 1] === res[n] - 1) {
					end++;
				} else {
					unionRanges.push(Asc.Range(_bCol ? start : 0, !_bCol ? start : 0, _bCol ? end : gc_nMaxCol0, !_bCol ? end : gc_nMaxRow0));
					start = res[n];
					end = res[n];
				}

				if (n === res.length - 1) {
					unionRanges.push(Asc.Range(_bCol ? start : 0, !_bCol ? start : 0, _bCol ? end : gc_nMaxCol0, !_bCol ? end : gc_nMaxRow0));
				}
			}

			return unionRanges.sort(function (a, b) {
				return _bCol ? b.c1 - a.c2 : b.r1 - a.r2;
			});
		};

		MultiplyRange.prototype.getUnionRanges = function() {
			let ranges = this.ranges;
			if (!ranges || ranges.length === 0) {
				return [];
			}

			if (ranges.length === 1) {
				return [ranges[0].clone()];
			}

			const rangesByRow = new Array(ranges.length);

			for (let i = 0; i < ranges.length; i++) {
				rangesByRow[i] = ranges[i].clone(true);
			}

			// First sorting - by row starting position
			rangesByRow.sort(function(a, b) { return a.r1 - b.r1; });

			// First merging pass - combine vertically aligned ranges
			const result = [rangesByRow[0]];
			let currentRange = result[0];

			for (let i = 1; i < rangesByRow.length; i++) {
				const range = rangesByRow[i];

				// Check if ranges have same columns and are adjacent or overlapping rows
				if (range.c1 === currentRange.c1 && range.c2 === currentRange.c2 &&
					range.r1 <= currentRange.r2 + 1) {
					// Extend current range down
					currentRange.r2 = Math.max(currentRange.r2, range.r2);
				} else {
					// Start new range if can't merge
					result.push(range);
					currentRange = range;
				}
			}

			// Second sorting - by column starting position
			result.sort(function(a, b) { return a.c1 - b.c1; });

			// Second merging pass - combine horizontally aligned ranges
			const finalResult = [result[0]];
			let currentHorRange = finalResult[0];

			for (let i = 1; i < result.length; i++) {
				const range = result[i];

				// Check if ranges have same rows and are adjacent or overlapping columns
				if (range.r1 === currentHorRange.r1 && range.r2 === currentHorRange.r2 &&
					range.c1 <= currentHorRange.c2 + 1) {
					// Extend current range horizontally
					currentHorRange.c2 = Math.max(currentHorRange.c2, range.c2);
				} else {
					// Start new range if can't merge
					finalResult.push(range);
					currentHorRange = range;
				}
			}

			// Final merging pass - handle more complex overlapping cases
			let changed = true;
			let iterationRanges = finalResult.slice();

			// Limit iterations to avoid excessive processing
			for (let iteration = 0; iteration < 3 && changed && iterationRanges.length > 1; iteration++) {
				changed = false;
				const tempRanges = [];

				for (let i = 0; i < iterationRanges.length; i++) {
					const currentRange = iterationRanges[i];
					let merged = false;

					// Try to merge with ranges already in result
					for (let j = 0; j < tempRanges.length; j++) {
						const tempRange = tempRanges[j];

						// Check for possible merging cases (same columns or same rows with adjacency)
						if ((tempRange.c1 === currentRange.c1 && tempRange.c2 === currentRange.c2 &&
								(tempRange.r2 + 1 === currentRange.r1 || currentRange.r2 + 1 === tempRange.r1)) ||
							(tempRange.r1 === currentRange.r1 && tempRange.r2 === currentRange.r2 &&
								(tempRange.c2 + 1 === currentRange.c1 || currentRange.c2 + 1 === tempRange.c1))) {

							// Merge ranges by taking the outer boundaries
							tempRange.c1 = Math.min(tempRange.c1, currentRange.c1);
							tempRange.r1 = Math.min(tempRange.r1, currentRange.r1);
							tempRange.c2 = Math.max(tempRange.c2, currentRange.c2);
							tempRange.r2 = Math.max(tempRange.r2, currentRange.r2);

							merged = true;
							changed = true;
							break; // Exit inner loop once merged
						}
					}

					// Add to result if couldn't merge
					if (!merged) {
						tempRanges.push(currentRange);
					}
				}

				// Update working set for next iteration
				iterationRanges = tempRanges;
			}

			return iterationRanges;
		};

		MultiplyRange.prototype.isNull = function () {
			if (!this.ranges || 0 === this.ranges.length || (1 === this.ranges.length && this.ranges[0] == null)) {
				return true;
			}
			return false;
		};

		function VisibleRange(visibleRange, offsetX, offsetY) {
			this.visibleRange = visibleRange;
			this.offsetX = offsetX;
			this.offsetY = offsetY;
		}

		function RangeCache() {
			this.oCache = {};
		}

		RangeCache.prototype.getAscRange = function (sRange) {
			return this._getRange(sRange, 1);
		};
		RangeCache.prototype.getRange3D = function (sRange) {
			var res = AscCommon.parserHelp.parse3DRef(sRange);
			if (!res) {
				return null;
			}
			var range = this._getRange(res.range.toUpperCase(), 1);
			return range ? new Range3D(range, res.sheet, res.sheet2) : null;
		};
		RangeCache.prototype.getActiveRange = function (sRange) {
			return this._getRange(sRange, 2);
		};
		RangeCache.prototype.getRangesFromSqRef = function (sqRef) {
			var res = [];
			var refs = sqRef.split(' ');
			for (var i = 0; i < refs.length; ++i) {
				var ref = AscCommonExcel.g_oRangeCache.getAscRange(refs[i]);
				if (ref) {
					res.push(ref.clone());
				}
			}
			return res;
		};
		RangeCache.prototype.getFormulaRange = function (sRange) {
			return this._getRange(sRange, 3);
		};
		RangeCache.prototype._getRange = function (sRange, type) {
			if (AscCommonExcel.g_R1C1Mode) {
				var o = {
					Formula: sRange, pCurrPos: 0
				};
				if (AscCommon.parserHelp.isArea.call(o, o.Formula, o.pCurrPos)) {
					sRange = o.real_str;
				} else if (AscCommon.parserHelp.isRef.call(o, o.Formula, o.pCurrPos)) {
					sRange = o.real_str;
				}
			}
			var oRes = null;
			var oCacheVal = this.oCache[sRange];
			if (null == oCacheVal) {
				var oFirstAddr, oLastAddr;
				var bIsSingle = true;
				var nIndex = sRange.indexOf(":");
				if (-1 != nIndex) {
					bIsSingle = false;
					oFirstAddr = g_oCellAddressUtils.getCellAddress(sRange.substring(0, nIndex));
					oLastAddr = g_oCellAddressUtils.getCellAddress(sRange.substring(nIndex + 1));
				} else {
					oFirstAddr = oLastAddr = g_oCellAddressUtils.getCellAddress(sRange);
				}
				oCacheVal = {first: null, last: null, ascRange: null, formulaRange: null, activeRange: null};
				//последнее условие, чтобы не распознавалось "A", "1"(должно быть "A:A", "1:1")
				if (oFirstAddr.isValid() && oLastAddr.isValid() &&
					(!bIsSingle || (!oFirstAddr.getIsRow() && !oFirstAddr.getIsCol()))) {
					oCacheVal.first = oFirstAddr;
					oCacheVal.last = oLastAddr;
				}
				this.oCache[sRange] = oCacheVal;
			}
			if (1 == type) {
				oRes = oCacheVal.ascRange;
			} else if (2 == type) {
				oRes = oCacheVal.activeRange;
			} else {
				oRes = oCacheVal.formulaRange;
			}
			if (null == oRes && null != oCacheVal.first && null != oCacheVal.last) {
				var r1 = oCacheVal.first.getRow0(), r2 = oCacheVal.last.getRow0(), c1 = oCacheVal.first.getCol0(),
					c2 = oCacheVal.last.getCol0();
				var r1Abs = oCacheVal.first.getRowAbs(), r2Abs = oCacheVal.last.getRowAbs(),
					c1Abs = oCacheVal.first.getColAbs(), c2Abs = oCacheVal.last.getColAbs();
				if (oCacheVal.first.getIsRow() && oCacheVal.last.getIsRow()) {
					c1 = 0;
					c2 = gc_nMaxCol0;
				}
				if (oCacheVal.first.getIsCol() && oCacheVal.last.getIsCol()) {
					r1 = 0;
					r2 = gc_nMaxRow0;
				}
				if (r1 > r2) {
					var temp = r1;
					r1 = r2;
					r2 = temp;
					temp = r1Abs;
					r1Abs = r2Abs;
					r2Abs = temp;
				}
				if (c1 > c2) {
					var temp = c1;
					c1 = c2;
					c2 = temp;
					temp = c1Abs;
					c1Abs = c2Abs;
					c2Abs = temp;
				}

				if (1 == type) {
					if (null == oCacheVal.ascRange) {
						var oAscRange = new Range(c1, r1, c2, r2);
						oAscRange.setAbs(r1Abs, c1Abs, r2Abs, c2Abs);

						oCacheVal.ascRange = oAscRange;
					}
					oRes = oCacheVal.ascRange;
				} else if (2 == type) {
					if (null == oCacheVal.activeRange) {
						var oActiveRange = new ActiveRange(c1, r1, c2, r2);
						oActiveRange.setAbs(r1Abs, c1Abs, r2Abs, c2Abs);
						oActiveRange.startCol = oActiveRange.c1;
						oActiveRange.startRow = oActiveRange.r1;
						oCacheVal.activeRange = oActiveRange;
					}
					oRes = oCacheVal.activeRange;
				} else {
					if (null == oCacheVal.formulaRange) {
						var oFormulaRange = new FormulaRange(c1, r1, c2, r2);
						oFormulaRange.setAbs(r1Abs, c1Abs, r2Abs, c2Abs);

						oCacheVal.formulaRange = oFormulaRange;
					}
					oRes = oCacheVal.formulaRange;
				}
			}
			return oRes;
		};

		var g_oRangeCache = new RangeCache();

		/**
		 * @constructor
		 * @memberOf Asc
		 */
		function HandlersList(handlers) {
			if (!(this instanceof HandlersList)) {
				return new HandlersList(handlers);
			}
			this.handlers = handlers || {};
			return this;
		}

		HandlersList.prototype = {

			constructor: HandlersList,

			trigger: function (eventName) {
				var h = this.handlers[eventName], t = typeOf(h), a = Array.prototype.slice.call(arguments, 1), i;
				if (t === kFunctionL) {
					return h.apply(this, a);
				}
				if (t === kArrayL) {
					for (i = 0; i < h.length; i += 1) {
						if (typeOf(h[i]) === kFunctionL) {
							h[i].apply(this, a);
						}
					}
					return true;
				}
				return false;
			},

			add: function (eventName, eventHandler, replaceOldHandler) {
				var th = this.handlers, h, old, t;
				if (replaceOldHandler || !th.hasOwnProperty(eventName)) {
					th[eventName] = eventHandler;
				} else {
					old = h = th[eventName];
					t = typeOf(old);
					if (t !== kArrayL) {
						h = th[eventName] = [];
						if (t === kFunctionL) {
							h.push(old);
						}
					}
					h.push(eventHandler);
				}
			},

			remove: function (eventName, eventHandler) {
				var th = this.handlers, h = th[eventName], i;
				if (th.hasOwnProperty(eventName)) {
					if (typeOf(h) !== kArrayL || typeOf(eventHandler) !== kFunctionL) {
						delete th[eventName];
						return true;
					}
					for (i = h.length - 1; i >= 0; i -= 1) {
						if (h[i] === eventHandler) {
							delete h[i];
							return true;
						}
					}
				}
				return false;
			}

		};


		function outputDebugStr(channel) {
			var c = window.console;
			if (Asc.g_debug_mode && c && c[channel] && c[channel].apply) {
				c[channel].apply(this, Array.prototype.slice.call(arguments, 1));
			}
		}

		function trim(val) {
			if (String.prototype.trim)
				return val.trim();
			else
				return val.replace(/^\s+|\s+$/g, '');
		}

		function isNumberInfinity(val) {
			var valTrim = trim(val);
			var valInt = valTrim - 0;
			return valInt == valTrim && valTrim.length > 0 && MIN_EXCEL_INT < valInt && valInt < MAX_EXCEL_INT;//
		}

		function arrayToLowerCase(array) {
			var result = [];
			for (var i = 0, length = array.length; i < length; ++i)
				result.push(array[i].toLowerCase());
			return result;
		}

		function isFixedWidthCell(frag) {
			for (var i = 0; i < frag.length; ++i) {
				var f = frag[i].format;
				if (f && f.getRepeat()) {
					return true;
				}
			}
			return false;
		}

		function dropDecimalAutofit(f) {
			var s = getFragmentsText(f);
			// Проверка scientific format
			if (s.search(/E/i) >= 0) {
				return f;
			}
			// Поиск десятичной точки
			var pos = s.indexOf(AscCommon.g_oDefaultCultureInfo.NumberDecimalSeparator);
			if (-1 !== pos) {
				f = [f[0].clone()];
				f[0].setFragmentText(s.slice(0, pos));
			}
			return f;
		}

		function getFragmentsText(f) {
			if (!f) {
				return "";
			}
			return f.reduce(function (pv, cv) {
				if (null === cv.getFragmentText()) {
					cv.initText();
				}
				return pv + cv.getFragmentText();
			}, "");
		}

		function getFragmentsLength(f) {
			if (!f) {
				return;
			}
			return f.length > 0 ? f.reduce(function (pv, cv) {
				if (null === cv.getFragmentText()) {
					cv.initText();
				}
				return pv + cv.getFragmentText().length;
			}, 0) : 0;
		}

		function getFragmentsCharCodes(f) {
			if (!f) {
				return;
			}
			return f.reduce(function (pv, cv) {
				return pv.concat(cv.getCharCodes());
			}, []);
		}

		function getFragmentsCharCodesLength(f) {
			if (!f) {
				return 0;
			}
			return f.length > 0 ? f.reduce(function (pv, cv) {
				return pv + cv.getCharCodes().length;
			}, 0) : 0;
		}

		function getFragmentsTextFromCode(f) {
			if (!f) {
				return "";
			}
			return f.reduce(function (pv, cv) {
				if (null === cv.getFragmentText()) {
					cv.initText();
				}
				return pv + cv.getFragmentText();
			}, "");
		}

		function convertUnicodeToSimpleString(sUnicode) {
			var sUTF16 = "";
			var nLength = sUnicode.length;
			for (var nPos = 0; nPos < nLength; nPos++) {
				sUTF16 += String.fromCharCode(sUnicode[nPos]);
			}

			return sUTF16;
		}

		function executeInR1C1Mode(mode, runFunction) {
			var oldMode = AscCommonExcel.g_R1C1Mode;
			AscCommonExcel.g_R1C1Mode = mode;
			runFunction();
			AscCommonExcel.g_R1C1Mode = oldMode;
		}

		function lockCustomFunctionRecalculate(mode, runFunction) {
			var oldMode = AscCommonExcel.g_LockCustomFunctionRecalculate;
			AscCommonExcel.g_LockCustomFunctionRecalculate = mode;
			runFunction();
			AscCommonExcel.g_LockCustomFunctionRecalculate = oldMode;
		}

		function checkFilteringMode(f, oThis, args) {
			if (!window['AscCommonExcel'].filteringMode) {
				AscCommon.History.LocalChange = true;
			}
			var ret = f.apply(oThis, args);
			if (!window['AscCommonExcel'].filteringMode) {
				AscCommon.History.LocalChange = false;
			}
			return ret;
		}

		function getEndValueRange(dx, v1, v2, coord1, coord2) {
			var leftDir = {x1: v2, x2: v1},
				rightDir = {x1: v1, x2: v2},
				res;
			if (0 !== dx) {
				if (coord1 > v1 && coord2 < v2) {
					if (0 > dx) {
						res = coord1 === coord2 ? leftDir : rightDir;
					} else {
						res = coord1 === coord2 ? rightDir : leftDir;
					}
				} else if (coord1 === v1 && coord2 === v2) {
					if (0 > dx) {
						res = leftDir;
					} else {
						res = rightDir;
					}
				} else if (coord1 > v1 && coord2 === v2) {
					res = leftDir;
				} else if (coord1 === v1 && coord2 < v2) {
					res = rightDir;
				} else {
					res = rightDir;
				}
			} else {
				res = rightDir;
			}
			return res;
		}

		function checkStylesNames(cellStyles) {
			var oStyle, i;
			for (i = 0; i < cellStyles.DefaultStyles.length; ++i) {
				oStyle = cellStyles.DefaultStyles[i];
				AscFonts.FontPickerByCharacter.getFontsByString(oStyle.Name);
				AscFonts.FontPickerByCharacter.getFontsByString(AscCommon.translateManager.getValue(oStyle.Name));
			}
			for (i = 0; i < cellStyles.CustomStyles.length; ++i) {
				oStyle = cellStyles.CustomStyles[i];
				AscFonts.FontPickerByCharacter.getFontsByString(oStyle.Name);
			}
		}

		function getContext(w, h, wb) {
			var oCanvas = document.createElement('canvas');
			oCanvas.width = w;
			oCanvas.height = h;
			return new Asc.DrawingContext(
				{canvas: oCanvas, units: 0/*px*/, fmgrGraphics: wb.fmgrGraphics, font: wb.m_oFont});
		}

		function getGraphics(ctx) {
			var graphics = new AscCommon.CGraphics();
			graphics.init(ctx.ctx, ctx.getWidth(0), ctx.getHeight(0), ctx.getWidth(3), ctx.getHeight(3));
			graphics.m_oFontManager = AscCommon.g_fontManager;

			return graphics;
		}

		function generateCellStyles(w, h, wb) {
			var result = [];

			var widthWithRetina = AscCommon.AscBrowser.convertToRetinaValue(w, true);
			var heightWithRetina = AscCommon.AscBrowser.convertToRetinaValue(h, true);

			var ctx = getContext(widthWithRetina, heightWithRetina, wb);
			var oCanvas = ctx.getCanvas();
			var graphics = getGraphics(ctx);

			function addStyles(styles, type) {
				var oStyle, name, displayName;
				for (var i = 0; i < styles.length && i < 1000; ++i) {
					oStyle = styles[i];
					if (oStyle.Hidden) {
						continue;
					}
					name = displayName = oStyle.Name;
					if (type === AscCommon.c_oAscStyleImage.Default) {
						// ToDo Возможно стоит переписать немного, чтобы не пробегать каждый раз по массиву custom-стилей (нужно генерировать AllStyles)
						oStyle = cellStyles.getCustomStyleByBuiltinId(oStyle.BuiltinId) || oStyle;
						displayName = AscCommon.translateManager.getValue(name);
					} else if (null !== oStyle.BuiltinId) {
						continue;
					}

					if (window["IS_NATIVE_EDITOR"]) {
						window["native"]["BeginDrawStyle"](type, name);
					}
					drawStyle(ctx, graphics, wb.stringRender, oStyle, displayName, widthWithRetina, heightWithRetina);
					if (window["IS_NATIVE_EDITOR"]) {
						window["native"]["EndDrawStyle"]();
					} else {
						result.push(new AscCommon.CStyleImage(name, type, oCanvas.toDataURL("image/png")));
					}
				}
			}

			var cellStyles = wb.model.CellStyles;
			addStyles(cellStyles.CustomStyles, AscCommon.c_oAscStyleImage.Document);
			addStyles(cellStyles.DefaultStyles, AscCommon.c_oAscStyleImage.Default);

			return result;
		}

		function drawStyle(ctx, graphics, sr, oStyle, sStyleName, width, height, opt_cf_preview) {
			var bc = null, bs = Asc.c_oAscBorderStyles.None, isNotFirst = false; // cached border color
			ctx.clear();
			// Fill cell
			if (oStyle.ApplyFill) {
				var fill = oStyle.getFill();
				if (null !== fill) {
					AscCommonExcel.drawFillCell(ctx, graphics, fill, new AscCommon.asc_CRect(0, 0, width, height));
				}
			}

			function drawBorder(type, b, x1, y1, x2, y2) {
				if (b && b.w > 0) {
					var isStroke = false;
					var isNewColor = !AscCommonExcel.g_oColorManager.isEqual(bc, b.getColorOrDefault());
					var isNewStyle = bs !== b.s;
					if (isNotFirst && (isNewColor || isNewStyle)) {
						ctx.stroke();
						isStroke = true;
					}

					if (isNewColor) {
						bc = b.getColorOrDefault();
						ctx.setStrokeStyle(bc);
					}
					if (isNewStyle) {
						bs = b.s;
						ctx.setLineWidth(b.w);
						ctx.setLineDash(b.getDashSegments());
					}

					if (isStroke || false === isNotFirst) {
						isNotFirst = true;
						ctx.beginPath();
					}

					switch (type) {
						case AscCommon.c_oAscBorderType.Hor:
							ctx.lineHor(x1, y1, x2);
							break;
						case AscCommon.c_oAscBorderType.Ver:
							ctx.lineVer(x1, y1, y2);
							break;
						case AscCommon.c_oAscBorderType.Diag:
							ctx.lineDiag(x1, y1, x2, y2);
							break;
					}
				}
			}

			// Draw text
			var format = oStyle.getFont().clone();
			// Для размера шрифта делаем ограничение для превью в 16pt (у Excel 18pt, но и высота превью больше 22px)
			var nSize = format.getSize();
			if (16 < format.getSize()) {
				nSize = 16;
			}

			// рисуем в пикселях
			if (window["IS_NATIVE_EDITOR"]) {
				nSize *= AscCommon.AscBrowser.retinaPixelRatio;
			}

			format.setSize(nSize);

			var tm;
			var cellFlags = new AscCommonExcel.CellFlags();
			cellFlags.textAlign = oStyle.xfs.align && oStyle.xfs.align.hor;

			var fragments = [];
			var tempFragment = new AscCommonExcel.Fragment();
			tempFragment.setFragmentText(sStyleName);
			tempFragment.format = format;
			fragments.push(tempFragment);
			tm = sr.measureString(fragments, cellFlags, width);

			let textAlign = sr.getEffectiveAlign();
			let width_padding = 4;
			if (textAlign === AscCommon.align_Center) {
				width_padding = Asc.round(0.5 * (width - tm.width));
			}
			else if(textAlign === AscCommon.align_Right) {
				width_padding = Asc.round(width - tm.width - width_padding);
			}

			// Текст будем рисовать по центру (в Excel чуть по другому реализовано, у них постоянный отступ снизу)
			var textY = Asc.round(0.5 * (height - tm.height));
			if (!opt_cf_preview) {
				let oldCtx = sr.drawingCtx;
				sr.drawingCtx = ctx;
				sr.render(ctx, width_padding, textY, tm.width, oStyle.getFontColor() || new AscCommon.CColor(0, 0, 0));
				sr.drawingCtx = oldCtx;
			} else {
				sr.render(ctx, width_padding, textY, tm.width, oStyle.getFontColor() || new AscCommon.CColor(0, 0, 0));
			}

			if (oStyle.ApplyBorder) {
				// borders
				var oBorders = oStyle.getBorder();
				drawBorder(AscCommon.c_oAscBorderType.Ver, oBorders.l, 0, 0, 0, height);
				drawBorder(AscCommon.c_oAscBorderType.Hor, oBorders.b, 0, height - 1, width, height - 1);
				drawBorder(AscCommon.c_oAscBorderType.Ver, oBorders.r, width - 1, height, width - 1, 0);
				drawBorder(AscCommon.c_oAscBorderType.Hor, oBorders.t, width, 0, 0, 0);
				if (isNotFirst) {
					ctx.stroke();
				}
			}
		}

		function drawFillCell(ctx, graphics, fill, rect) {
			if (!fill.hasFill()) {
				return;
			}

			var solid = fill.getSolidFill();
			if (solid) {
				ctx.setFillStyle(solid).fillRect(rect._x, rect._y, rect._width, rect._height);
				return;
			}

			var vector_koef = AscCommonExcel.vector_koef / ctx.getZoom();
			if (AscCommon.AscBrowser.isCustomScaling()) {
				vector_koef /= AscCommon.AscBrowser.retinaPixelRatio;
			}
			rect._x *= vector_koef;
			rect._y *= vector_koef;
			rect._width *= vector_koef;
			rect._height *= vector_koef;
			AscFormat.ExecuteNoHistory(
				function () {
					var geometry = new AscFormat.CreateGeometry("rect");
					geometry.Recalculate(rect._width, rect._height, true);
					var oUniFill = AscCommonExcel.convertFillToUnifill(fill);

					if (ctx instanceof AscCommonExcel.CPdfPrinter) {
						graphics.SaveGrState();
						var _baseTransform;
						if (!ctx.Transform) {
							_baseTransform = new AscCommon.CMatrix();
						} else {
							_baseTransform = ctx.Transform;
						}
						graphics.SetBaseTransform(_baseTransform);
					}

					graphics.SaveGrState();
					var oMatrix = new AscCommon.CMatrix();
					oMatrix.tx = rect._x;
					oMatrix.ty = rect._y;
					//TODO !!!rtl print
					let api = window.Asc.editor;
					let wb = api && api.wb;
					let ws = wb.getWorksheet();
					/*if (ws && ws.getRightToLeft()) {
						oMatrix.sx = -1;
						oMatrix.tx = (ws.getCtxWidth() * vector_koef) - oMatrix.tx;
					}*/
					graphics.transform3(oMatrix);
					var shapeDrawer = new AscCommon.CShapeDrawer();
					shapeDrawer.Graphics = graphics;

					shapeDrawer.fromShape2(new AscFormat.CColorObj(null, oUniFill, geometry), graphics, geometry);
					shapeDrawer.draw(geometry);
					graphics.RestoreGrState();

					if (ctx instanceof AscCommonExcel.CPdfPrinter) {
						graphics.SetBaseTransform(null);
						graphics.RestoreGrState();
					}
				}, this, []
			);
		}

		function generateSlicerStyles(w, h, wb) {
			var result = [];

			w = AscCommon.AscBrowser.convertToRetinaValue(w, true);
			h = AscCommon.AscBrowser.convertToRetinaValue(h, true);

			var ctx = getContext(w, h, wb);
			var oCanvas = ctx.getCanvas();
			var graphics = getGraphics(ctx);

			function addStyles(styles, type) {
				for (var sStyleName in styles) {
					if (styles.hasOwnProperty(sStyleName)) {
						var oSlicerStyle = styles[sStyleName];
						var oTableStyle = oAllTableStyles[sStyleName];
						if (oSlicerStyle && oTableStyle) {
							drawSlicerStyle(ctx, graphics, oSlicerStyle, oTableStyle, w, h);
							result.push(new AscCommon.CStyleImage(sStyleName, type, oCanvas.toDataURL("image/png")));
						}
					}
				}
			}

			var oAllTableStyles = wb.model.TableStyles.AllStyles;
			addStyles(wb.model.SlicerStyles.CustomStyles, AscCommon.c_oAscStyleImage.Document);
			addStyles(wb.model.SlicerStyles.DefaultStyles, AscCommon.c_oAscStyleImage.Default);

			return result;
		}

		function drawSlicerStyle(ctx, graphics, oSlicerStyle, oTableStyle, width, height) {
			ctx.clear();

			var dxf, dxfWhole;

			var nBH = (height / 6) >> 0;

			var nIns = (height / 6 / 5) >> 0;
			var nHIns = (height / 6 / 5 + 0.5) >> 0;
			//whole
			dxfWhole = oTableStyle.wholeTable && oTableStyle.wholeTable.dxf;
			var oOldFill;
			if (dxfWhole) {
				oOldFill = dxfWhole.getFill();
				if (!oOldFill) {
					var oFill = new AscCommonExcel.Fill();
					oFill.fromColor(new AscCommonExcel.RgbColor(0xFFFFFF));
					dxfWhole.setFill(oFill);
				}
			}
			drawSlicerPreviewElement(dxfWhole, null, ctx, graphics, 0, 0, width, height);
			if (dxfWhole) {
				dxfWhole.setFill(oOldFill);
			}
			dxfWhole = dxfWhole || true;

			//header
			dxf = oTableStyle.headerRow && oTableStyle.headerRow.dxf;
			drawSlicerPreviewElement(dxf, dxfWhole, ctx, graphics, 0, 0, width, nBH);

			var nPos = nBH + nIns;
			var aBT = [
				Asc.ST_slicerStyleType.selectedItemWithData,
				Asc.ST_slicerStyleType.unselectedItemWithData,
				Asc.ST_slicerStyleType.selectedItemWithNoData,
				Asc.ST_slicerStyleType.unselectedItemWithNoData
			];
			for (var nType = 0; nType < aBT.length; ++nType) {
				dxf = oSlicerStyle[aBT[nType]];
				drawSlicerPreviewElement(dxf, dxfWhole, ctx, graphics, nHIns, nPos, width - nHIns, nPos + nBH);
				nPos += (nBH + nIns);
			}
		}

		function drawSlicerPreviewElement(dxf, dxfWhole, ctx, graphics, x0, y0, x1, y1) {
			var oFill = dxf && dxf.getFill();
			if (oFill) {
				AscCommonExcel.drawFillCell(ctx, graphics, oFill, new AscCommon.asc_CRect(x0, y0, x1 - x0, y1 - y0));
			}
			var oBorder = dxf && dxf.getBorder();
			if (oBorder) {
				var oS = oBorder.l;
				if (oS && !oS.isEmpty()) {
					ctx.setStrokeStyle(oS.getColorOrDefault()).setLineWidth(1).setLineDash(oS.getDashSegments()).beginPath();
					ctx.lineVer(x0, y0, y1);
					ctx.stroke();
				}
				oS = oBorder.t;
				if (oS && !oS.isEmpty()) {
					ctx.setStrokeStyle(oS.getColorOrDefault()).setLineWidth(1).setLineDash(oS.getDashSegments()).beginPath();
					ctx.lineHor(x0 + 1, y0, x1 - 1);
					ctx.stroke();
				}
				oS = oBorder.r;
				if (oS && !oS.isEmpty()) {
					ctx.setStrokeStyle(oS.getColorOrDefault()).setLineWidth(1).setLineDash(oS.getDashSegments()).beginPath();
					ctx.lineVer(x1 - 1, y0, y1);
					ctx.stroke();
				}
				oS = oBorder.b;
				if (oS && !oS.isEmpty()) {
					ctx.setStrokeStyle(oS.getColorOrDefault()).setLineWidth(1).setLineDash(oS.getDashSegments()).beginPath();
					ctx.lineHor(x0 + 1, y1 - 1, x1 - 1);
					ctx.stroke();
				}
			}
			if (dxfWhole) {
				var nTIns = 5;
				var nTW = 8;

				nTIns = AscCommon.AscBrowser.convertToRetinaValue(nTIns, true);
				nTW = AscCommon.AscBrowser.convertToRetinaValue(nTW, true);

				var oFont = dxf && dxf.getFont() || dxfWhole && dxfWhole.getFont && dxfWhole.getFont();
				var oColor = oFont ? oFont.getColor() : new AscCommon.CColor(0, 0, 0);
				ctx.setStrokeStyle(oColor);
				ctx.setLineWidth(1);
				ctx.setLineDash([]);
				ctx.beginPath();
				ctx.lineHor(nTIns, (y0 + (y1 - y0) / 2.0 + 0.5) >> 0, nTIns + nTW);
				ctx.stroke();
			}
		}

		function generateXfsStyle(w, h, wb, xfs, text) {
			if (AscCommon.AscBrowser.isRetina) {
				w = AscCommon.AscBrowser.convertToRetinaValue(w, true);
				h = AscCommon.AscBrowser.convertToRetinaValue(h, true);
			}

			var ctx = getContext(w, h, wb);
			var oCanvas = ctx.getCanvas();
			var graphics = getGraphics(ctx);

			var oStyle = new AscCommonExcel.CCellStyle();
			oStyle.xfs = xfs;

			drawStyle(ctx, graphics, wb.stringRender, oStyle, text, w, h);
			return new AscCommon.CStyleImage(text, null, oCanvas.toDataURL("image/png"));
		}

		function createAndPutCanvas(id) {
			var parent = document.getElementById(id);
			if (!parent)
				return;

			var w = parent.clientWidth;
			var h = parent.clientHeight;
			if (!w || !h) {
				return;
			}

			var canvas = parent.firstChild;
			if (!canvas) {
				canvas = document.createElement('canvas');
				canvas.style.cssText = "pointer-events: none;padding:0;margin:0;user-select:none;";
				canvas.style.width = w + "px";
				canvas.style.height = h + "px";
				parent.appendChild(canvas);
			}

			canvas.width = AscCommon.AscBrowser.convertToRetinaValue(w, true);
			canvas.height = AscCommon.AscBrowser.convertToRetinaValue(h, true);

			return canvas;
		}

		//TODO рассмотреть объединение с generateXfsStyle
		function generateXfsStyle2(id, wb, xfs, text) {
			var canvas = createAndPutCanvas(id);
			if (!canvas) {
				return;
			}
			var w = canvas.width;
			var h = canvas.height;

			var ctx = new Asc.DrawingContext({
				canvas: canvas,
				units: 0/*px*/,
				fmgrGraphics: wb.fmgrGraphics,
				font: wb.m_oFont
			});
			var graphics = getGraphics(ctx);

			var oStyle = new AscCommonExcel.CCellStyle();
			oStyle.xfs = xfs;

			drawStyle(ctx, graphics, wb.stringRender, oStyle, text, w, h, true);
		}

		function drawGradientPreview(id, wb, colors, _colorBorderOut, _colorBorderIn, _realPercentWidth, _indent) {
			if (!colors || !colors.length) {
				return null;
			}

			var canvas = createAndPutCanvas(id);
			if (!canvas) {
				return;
			}
			var w = canvas.width;
			var h = canvas.height;

			var ctx = new Asc.DrawingContext({
				canvas: canvas,
				units: 0/*px*/,
				fmgrGraphics: wb.fmgrGraphics,
				font: wb.m_oFont
			});
			var graphics = getGraphics(ctx);

			var fill = new AscCommonExcel.Fill();
			if (colors.length === 1) {
				fill.fromColor(colors[0]);
			} else {
				fill.gradientFill = new AscCommonExcel.GradientFill();
				var arrColors = [];
				for (var i = 0; i < colors.length; i++) {
					var _stop = new AscCommonExcel.GradientStop();
					_stop.position = i / (colors.length - 1);
					_stop.color = colors[i];
					arrColors.push(_stop);
				}
				fill.gradientFill.asc_putGradientStops(arrColors);
			}

			if (!_indent) {
				_indent = 0;
			}
			var rectX = _indent;
			var rectY = _indent;
			var rectW = w - _indent * 2;
			var rectH = h - _indent * 2;
			if (_realPercentWidth) {
				if (_realPercentWidth > 0) {
					rectW = rectW * _realPercentWidth;
				} else {
					rectX = rectW - rectW * Math.abs(_realPercentWidth) + 1;
					rectW = rectW * Math.abs(_realPercentWidth) + 1;
				}
			}
			AscCommonExcel.drawFillCell(ctx, graphics, fill, new AscCommon.asc_CRect(rectX, rectY, rectW, rectH));

			if (_colorBorderIn) {
				ctx.setLineWidth(1).setStrokeStyle(_colorBorderIn).strokeRect(rectX, rectY, rectW - 1, rectH - 1);
			}
			if (_colorBorderOut) {
				ctx.setLineWidth(1).setStrokeStyle(_colorBorderOut).strokeRect(0, 0, w - 1, h - 1);
			}
		}

		function drawIconSetPreview(id, wb, iconImgs) {
			if (!iconImgs || !iconImgs.length) {
				return null;
			}

			var canvas = createAndPutCanvas(id);
			if (!canvas) {
				return;
			}

			var ctx = new Asc.DrawingContext({
				canvas: canvas,
				units: 0/*px*/,
				fmgrGraphics: wb.fmgrGraphics,
				font: wb.m_oFont
			});
			var graphics = getGraphics(ctx);

			var shapeDrawer = new AscCommon.CShapeDrawer();
			shapeDrawer.Graphics = graphics;


			AscFormat.ExecuteNoHistory(
				function () {
					for (var i = 0; i < iconImgs.length; i++) {
						var img = iconImgs[i];

						if (!img) {
							continue;
						}

						var geometry = new AscFormat.CreateGeometry("rect");
						geometry.Recalculate(5, 5, true);

						var oUniFill = new AscFormat.builder_CreateBlipFill(img, "stretch");
						graphics.save();
						var oMatrix = new AscCommon.CMatrix();
						oMatrix.tx = i * 5;
						oMatrix.ty = 0;
						graphics.transform3(oMatrix);

						shapeDrawer.fromShape2(new AscFormat.CColorObj(null, oUniFill, geometry), graphics, geometry);
						shapeDrawer.draw(geometry);
						graphics.restore();
					}
				}, this, []
			);
		}

		//-----------------------------------------------------------------
		// События движения мыши
		//-----------------------------------------------------------------
		/** @constructor */
		function asc_CMouseMoveData(obj) {
			if (!(this instanceof asc_CMouseMoveData)) {
				return new asc_CMouseMoveData(obj);
			}

			if (obj) {
				this.type = obj.type;
				this.x = obj.x;
				this.reverseX = obj.reverseX;	// Отображать комментарий слева от ячейки
				this.y = obj.y;
				this.hyperlink = obj.hyperlink;
				this.aCommentIndexes = obj.aCommentIndexes;
				this.userId = obj.userId;
				this.lockedObjectType = obj.lockedObjectType;

				// Для resize
				this.sizeCCOrPt = obj.sizeCCOrPt;
				this.sizePx = obj.sizePx;

				//Filter
				this.filter = obj.filter;

				//Tooltip
				this.tooltip = obj.tooltip;

				this.color = obj.color;

				this.placeholderType = obj.placeholderType;
			}

			return this;
		}

		asc_CMouseMoveData.prototype = {
			constructor: asc_CMouseMoveData,
			asc_getType: function () {
				return this.type;
			},
			asc_getX: function () {
				return this.x;
			},
			asc_getReverseX: function () {
				return this.reverseX;
			},
			asc_getY: function () {
				return this.y;
			},
			asc_getHyperlink: function () {
				return this.hyperlink;
			},
			asc_getCommentIndexes: function () {
				return this.aCommentIndexes;
			},
			asc_getUserId: function () {
				return this.userId;
			},
			asc_getLockedObjectType: function () {
				return this.lockedObjectType;
			},
			asc_getSizeCCOrPt: function () {
				return this.sizeCCOrPt;
			},
			asc_getSizePx: function () {
				return this.sizePx;
			},
			asc_getFilter: function () {
				return this.filter;
			},
			asc_getTooltip: function () {
				return this.tooltip;
			},
			asc_getColor: function () {
				return this.color;
			},
			asc_getPlaceholderType: function () {
				return this.placeholderType;
			}
		};

		// Гиперссылка
		/** @constructor */
		function asc_CHyperlink(obj) {
			// Класс Hyperlink из модели
			this.hyperlinkModel = null != obj ? obj : new AscCommonExcel.Hyperlink();
			// Используется только для выдачи наружу и выставлении обратно
			this.text = null;

			return this;
		}

		asc_CHyperlink.prototype.clone = function () {
			let res = new asc_CHyperlink();

			res.hyperlinkModel = this.hyperlinkModel && this.hyperlinkModel.clone();
			res.text = this.text;

			return res;
		};
		asc_CHyperlink.prototype.calculateProps = function () {
			let type = this.asc_getType();
			let api = window.Asc.editor;
			let fileName = api && api.DocInfo && api.DocInfo.Title;
			if (type === Asc.c_oAscHyperlinkType.WebLink && this.hyperlinkModel.getHyperlinkFunction()) {
				let res = null;
				let sHyperlink = this.hyperlinkModel.Hyperlink;
				let ph = {operand_str: null, pCurrPos: 0};
				let _3dRef = AscCommon.parserHelp.is3DRef.call(ph, sHyperlink, 0);

				if (_3dRef && _3dRef[0] && _3dRef[3] && _3dRef[1]) {
					let ref;
					if (AscCommon.parserHelp.isArea.call(ph, sHyperlink, ph.pCurrPos) || AscCommon.parserHelp.isRef.call(ph, sHyperlink, ph.pCurrPos)) {
						ref = ph.real_str ? ph.real_str.toUpperCase() : ph.operand_str.toUpperCase()
					}

					if (ref) {
						if (AscCommon.rx_allowedProtocols.test(_3dRef[3])) {
							//https://test.com/test1/testFile.xlsx#TestSheet!F10
							sHyperlink = _3dRef[3] + "#" + _3dRef[1] + "!" + ref;
							res = this.clone();
							res.asc_setHyperlinkUrl(sHyperlink);
						} else {
							//check [test.xlsx]Sheet2!A1
							//while check link on this file
							//TODO need calculate links on other files
							if (_3dRef[3] === fileName) {
								type = Asc.c_oAscHyperlinkType.RangeLink;
								res = this.clone();
								res.asc_setHyperlinkUrl(null);
								res.asc_setSheet(_3dRef[1]);
								res.asc_setRange(ref);
								res.hyperlinkModel._updateLocation();
							} else {
								//TODO
							}
						}
					}
				} else if (_3dRef[3]) {
					//check [test.xlsx]A14

					let external = _3dRef[3];
					if (external === fileName) {
						ph.pCurrPos += _3dRef[4];

						let ref;
						if (AscCommon.parserHelp.isArea.call(ph, sHyperlink, ph.pCurrPos) || AscCommon.parserHelp.isRef.call(ph, sHyperlink, ph.pCurrPos)) {
							ref = ph.real_str ? ph.real_str.toUpperCase() : ph.operand_str.toUpperCase()
						}
						if (ref) {
							res = this.clone();
							res.asc_setHyperlinkUrl(null);
							let sCurSheetName = api.wbModel.getActiveWs().sName;
							res.asc_setSheet(sCurSheetName);
							res.asc_setRange(ref);
							res.hyperlinkModel._updateLocation();
						} else {
							//TODO
						}
					}
				}

				if (res) {
					return res;
				}
			}
			return null;
		};
		asc_CHyperlink.prototype.asc_getType = function () {
			return this.hyperlinkModel.getHyperlinkType();
		};
		asc_CHyperlink.prototype.asc_getHyperlinkUrl = function () {
			return this.hyperlinkModel.Hyperlink;
		};
		asc_CHyperlink.prototype.asc_getTooltip = function () {
			return this.hyperlinkModel.Tooltip;
		};
		asc_CHyperlink.prototype.asc_getLocation = function () {
			return this.hyperlinkModel.getLocation();
		};
		asc_CHyperlink.prototype.asc_getSheet = function () {
			return this.hyperlinkModel.LocationSheet;
		};
		asc_CHyperlink.prototype.asc_getRange = function () {
			return this.hyperlinkModel.getLocationRange();
		};
		asc_CHyperlink.prototype.asc_getText = function () {
			return this.text;
		};

		asc_CHyperlink.prototype.asc_setType = function (val) {
			// В принципе эта функция избыточна
			switch (val) {
				case Asc.c_oAscHyperlinkType.WebLink:
					this.hyperlinkModel.setLocation(null);
					break;
				case Asc.c_oAscHyperlinkType.RangeLink:
					this.hyperlinkModel.Hyperlink = null;
					break;
			}
		};
		asc_CHyperlink.prototype.asc_setHyperlinkUrl = function (val) {
			this.hyperlinkModel.Hyperlink = val;
		};
		asc_CHyperlink.prototype.asc_setTooltip = function (val) {
			this.hyperlinkModel.Tooltip = val ? val.slice(0, Asc.c_oAscMaxTooltipLength) : val;
		};
		asc_CHyperlink.prototype.asc_setLocation = function (val) {
			this.hyperlinkModel.setLocation(val);
		};
		asc_CHyperlink.prototype.asc_setSheet = function (val) {
			this.hyperlinkModel.setLocationSheet(val);
		};
		asc_CHyperlink.prototype.asc_setRange = function (val) {
			this.hyperlinkModel.setLocationRange(val);
		};
		asc_CHyperlink.prototype.asc_setText = function (val) {
			this.text = val;
		};

		function CPagePrint() {
			this.pageWidth = 0;
			this.pageHeight = 0;

			this.pageClipRectLeft = 0;
			this.pageClipRectTop = 0;
			this.pageClipRectWidth = 0;
			this.pageClipRectHeight = 0;

			this.pageRange = null;

			this.leftFieldInPx = 0;
			this.topFieldInPx = 0;

			this.pageGridLines = false;
			this.pageHeadings = false;

			this.indexWorksheet = -1;

			this.startOffset = 0;
			this.startOffsetPx = 0;

			this.scale = null;

			this.titleRowRange = null;
			this.titleColRange = null;
			this.titleWidth = 0;
			this.titleHeight = 0;

			return this;
		}

		CPagePrint.prototype.clone = function () {
			let res = new CPagePrint();
			res.pageWidth = this.pageWidth;
			res.pageHeight = this.pageHeight;
			res.pageClipRectLeft = this.pageClipRectLeft;
			res.pageClipRectTop = this.pageClipRectTop;
			res.pageClipRectWidth = this.pageClipRectWidth;
			res.pageClipRectHeight = this.pageClipRectHeight;

			res.pageRange = this.pageRange ? this.pageRange.clone() : null;

			res.leftFieldInPx = this.leftFieldInPx;
			res.topFieldInPx = this.topFieldInPx;

			res.pageGridLines = this.pageGridLines;
			res.pageHeadings = this.pageHeadings;

			res.indexWorksheet = this.indexWorksheet;

			res.startOffset = this.startOffset;
			res.startOffsetPx = this.startOffsetPx;

			res.scale = this.scale;

			res.titleRowRange = this.titleRowRange;
			res.titleColRange = this.titleColRange;
			res.titleWidth = this.titleWidth;
			res.titleHeight = this.titleHeight;

			return res;
		};
		CPagePrint.prototype.recalculate = function (pageOptions) {
			const horizontalCentered = pageOptions && pageOptions.asc_getHorizontalCentered();
			const verticalCentered = pageOptions && pageOptions.asc_getVerticalCentered();
			if (horizontalCentered) {
				let widthOffset = this.pageWidth - (this.pageClipRectLeft + this.pageClipRectRight);
				this.pageClipRectLeft = this.pageClipRectWidth
			}
		};

		function CPrintPagesData() {
			this.arrPages = [];
			this.currentIndex = 0;

			return this;
		}

		/** @constructor */
		function asc_CAdjustPrint() {
			// Вид печати
			this.printType = Asc.c_oAscPrintType.ActiveSheets;
			this.pageOptionsMap = null;
			this.ignorePrintArea = null;

			this.isOnlyFirstPage = null;
			this.nativeOptions = undefined;
			this.activeSheetsArray = null;//массив с индексами листов, которые необходимо напечатать

			this.startPageIndex = null;
			this.endPageIndex = null;

			return this;
		}

		asc_CAdjustPrint.prototype.asc_getPrintType = function () {
			return this.printType;
		};
		asc_CAdjustPrint.prototype.asc_setPrintType = function (val) {
			this.printType = val;
		};
		asc_CAdjustPrint.prototype.asc_getPageOptionsMap = function () {
			return this.pageOptionsMap;
		};
		asc_CAdjustPrint.prototype.asc_setPageOptionsMap = function (val) {
			this.pageOptionsMap = val;
		};
		asc_CAdjustPrint.prototype.asc_getIgnorePrintArea = function () {
			return this.ignorePrintArea;
		};
		asc_CAdjustPrint.prototype.asc_setIgnorePrintArea = function (val) {
			this.ignorePrintArea = val;
		};
		asc_CAdjustPrint.prototype.asc_getNativeOptions = function () {
			return this.nativeOptions;
		};
		asc_CAdjustPrint.prototype.asc_setNativeOptions = function (val) {
			this.nativeOptions = val;
		};
		asc_CAdjustPrint.prototype.asc_getActiveSheetsArray = function () {
			return this.activeSheetsArray;
		};
		asc_CAdjustPrint.prototype.asc_setActiveSheetsArray = function (val) {
			this.activeSheetsArray = val;
		};
		asc_CAdjustPrint.prototype.asc_getStartPageIndex = function () {
			return this.startPageIndex;
		};
		asc_CAdjustPrint.prototype.asc_setStartPageIndex = function (val) {
			this.startPageIndex = val;
		};
		asc_CAdjustPrint.prototype.asc_getEndPageIndex = function () {
			return this.endPageIndex;
		};
		asc_CAdjustPrint.prototype.asc_setEndPageIndex = function (val) {
			this.endPageIndex = val;
		};

		/** @constructor */
		function asc_CLockInfo() {
			this["sheetId"] = null;
			this["type"] = null;
			this["subType"] = null;
			this["guid"] = null;
			this["rangeOrObjectId"] = null;
		}

		/** @constructor */
		function asc_CCollaborativeRange(c1, r1, c2, r2) {
			this["c1"] = c1;
			this["r1"] = r1;
			this["c2"] = c2;
			this["r2"] = r2;
		}

		/** @constructor */
		function asc_CSheetViewSettings() {
			// Показывать ли сетку
			this.showGridLines = null;
			// Показывать обозначения строк и столбцов
			this.showRowColHeaders = null;

			// Закрепление области
			this.pane = null;

			//current view zoom
			this.zoomScale = 100;

			this.showZeros = null;
			this.rightToLeft = null;
			this.showFormulas = null;

			this.topLeftCell = null;
			this.view = null;

			this.tabSelected = null;

			return this;
		}

		asc_CSheetViewSettings.prototype = {
			constructor: asc_CSheetViewSettings,
			clone: function () {
				var result = new asc_CSheetViewSettings();
				result.showGridLines = this.showGridLines;
				result.showRowColHeaders = this.showRowColHeaders;
				result.zoom = this.zoom;
				if (this.pane) {
					result.pane = this.pane.clone();
				}
				result.showZeros = this.showZeros;
				result.topLeftCell = this.topLeftCell;
				result.rightToLeft = this.rightToLeft;
				result.showFormulas = this.showFormulas;
				return result;
			},
			isEqual: function (settings) {
				//TODO showzeros?
				return this.asc_getShowGridLines() === settings.asc_getShowGridLines() &&
					this.asc_getShowRowColHeaders() === settings.asc_getShowRowColHeaders();
			},
			asc_getShowGridLines: function () {
				return false !== this.showGridLines;
			},
			asc_getShowRowColHeaders: function () {
				return false !== this.showRowColHeaders;
			},
			asc_getZoomScale: function () {
				return this.zoomScale;
			},
			asc_getIsFreezePane: function () {
				return null !== this.pane && this.pane.isInit();
			},
			asc_getShowZeros: function () {
				return false !== this.showZeros;
			},
			asc_getShowFormulas: function () {
				return false !== this.showFormulas;
			},
			asc_getRightToLeft: function () {
				return this.rightToLeft;
			},
			asc_setShowGridLines: function (val) {
				this.showGridLines = val;
			},
			asc_setShowRowColHeaders: function (val) {
				this.showRowColHeaders = val;
			},
			asc_setZoomScale: function (val) {
				this.zoomScale = val;
			},
			asc_setShowZeros: function (val) {
				this.showZeros = val;
			},
			asc_setShowFormulas: function (val) {
				this.showFormulas = val;
			},
			asc_setRightToLeft: function (val) {
				this.rightToLeft = val;
			}
		};

		/** @constructor */
		function asc_CPane() {
			this.state = null;
			this.topLeftCell = null;
			this.xSplit = 0;
			this.ySplit = 0;
			// CellAddress для удобства
			this.topLeftFrozenCell = null;

			return this;
		}

		asc_CPane.prototype.isInit = function () {
			return null !== this.topLeftFrozenCell;
		};
		asc_CPane.prototype.clone = function () {
			var res = new asc_CPane();
			res.state = this.state;
			res.topLeftCell = this.topLeftCell;
			res.xSplit = this.xSplit;
			res.ySplit = this.ySplit;
			res.topLeftFrozenCell = this.topLeftFrozenCell ?
				new AscCommon.CellAddress(this.topLeftFrozenCell.row, this.topLeftFrozenCell.col) : null;
			return res;
		};
		asc_CPane.prototype.init = function () {
			// ToDo Обрабатываем пока только frozen и frozenSplit
			if ((AscCommonExcel.c_oAscPaneState.Frozen === this.state || AscCommonExcel.c_oAscPaneState.FrozenSplit === this.state) &&
				(0 < this.xSplit || 0 < this.ySplit)) {
				this.topLeftFrozenCell = new AscCommon.CellAddress(this.ySplit, this.xSplit, 0);
				if (!this.topLeftFrozenCell.isValid())
					this.topLeftFrozenCell = null;
			}
		};

		function RedoObjectParam() {
			this.bIsOn = false;
			this.oChangeWorksheetUpdate = {};
			this.bUpdateWorksheetByModel = false;
			this.bOnSheetsChanged = false;
			this.oOnUpdateTabColor = {};
			this.oOnUpdateSheetViewSettings = {};
			this.bAddRemoveRowCol = false;
			this.bChangeColorScheme = false;
			this.bChangeActive = false;
			this.activeSheet = null;
			this.onSlicer = {};
			this.onSlicerCache = {};
			this.UpdateRigions = {};
			this.snapshot = null;
		}

		/** @constructor */
		function asc_CSheetPr() {
			if (!(this instanceof asc_CSheetPr)) {
				return new asc_CSheetPr();
			}

			this.CodeName = null;
			this.EnableFormatConditionsCalculation = null;
			this.FilterMode = null;
			this.Published = null;
			this.SyncHorizontal = null;
			this.SyncRef = null;
			this.SyncVertical = null;
			this.TransitionEntry = null;
			this.TransitionEvaluation = null;

			this.TabColor = null;
			this.AutoPageBreaks = true;
			this.FitToPage = false;
			this.ApplyStyles = false;
			this.ShowOutlineSymbols = true;
			this.SummaryBelow = true;
			this.SummaryRight = true;

			return this;
		}

		asc_CSheetPr.prototype.clone = function () {
			var res = new asc_CSheetPr();

			res.CodeName = this.CodeName;
			res.EnableFormatConditionsCalculation = this.EnableFormatConditionsCalculation;
			res.FilterMode = this.FilterMode;
			res.Published = this.Published;
			res.SyncHorizontal = this.SyncHorizontal;
			res.SyncRef = this.SyncRef;
			res.SyncVertical = this.SyncVertical;
			res.TransitionEntry = this.TransitionEntry;
			res.TransitionEvaluation = this.TransitionEvaluation;
			if (this.TabColor)
				res.TabColor = this.TabColor.clone();

			res.FitToPage = this.FitToPage;

			res.SummaryBelow = this.SummaryBelow;
			res.SummaryRight = this.SummaryRight;

			return res;
		};

		// Математическая информация о выделении
		/** @constructor */
		function asc_CSelectionMathInfo() {
			this.count = 0;
			this.countNumbers = 0;
			this.sum = null;
			this.average = null;
			this.min = null;
			this.max = null;
		}

		asc_CSelectionMathInfo.prototype = {
			constructor: asc_CSelectionMathInfo,
			asc_getCount: function () {
				return this.count;
			},
			asc_getCountNumbers: function () {
				return this.countNumbers;
			},
			asc_getSum: function () {
				return this.sum;
			},
			asc_getAverage: function () {
				return this.average;
			},
			asc_getMin: function () {
				return this.min;
			},
			asc_getMax: function () {
				return this.max;
			}
		};

		/** @constructor */
		function asc_CFindOptions() {
			this.findWhat = "";							// текст, который ищем
			this.wordsIndex = 0;                         // индекс текущего слова
			this.scanByRows = true;						// просмотр по строкам/столбцам
			this.scanForward = true;					// поиск вперед/назад
			this.isMatchCase = false;					// учитывать регистр
			this.isWholeCell = false;
			this.isWholeWord = false;
			this.isSpellCheck = false;		    // изменение вызванное в проверке орфографии
			this.scanOnOnlySheet = Asc.c_oAscSearchBy.Sheet;				// искать только на листе/в книге c_oAscSearchBy
			this.lookIn = Asc.c_oAscFindLookIn.Formulas;	// искать в формулах/значениях/примечаниях

			this.findRegExp = null;
			this.replaceWith = "";						// текст, на который заменяем (если у нас замена)
			this.isReplaceAll = false;					// заменить все (если у нас замена)

			// внутренние переменные
			this.findInSelection = false;
			this.selectionRange = null;
			this.findRange = null;
			this.findResults = null;
			this.indexInArray = 0;
			this.countFind = 0;
			this.countReplace = 0;
			this.countFindAll = 0;
			this.countReplaceAll = 0;
			this.sheetIndex = -1;
			this.error = false;

			this.isNeedRecalc = null;

			this.specificRange = null;
			this.isForMacros = null;
			this.activeCell = null;

			//если запускаем новый поиск из-за измененного документа, то присылаем последний элемент, на который
			//кликнул пользователь и далее пытаемся найти следующий/предыдущий
			this.lastSearchElem = null;

			this.isNotSearchEmptyCells = null;
		}

		asc_CFindOptions.prototype.clone = function () {
			var result = new asc_CFindOptions();
			result.wordsIndex = this.wordsIndex;
			result.findWhat = this.findWhat;
			result.scanByRows = this.scanByRows;
			result.scanForward = this.scanForward;
			result.isMatchCase = this.isMatchCase;
			result.isWholeCell = this.isWholeCell;
			result.isWholeWord = this.isWholeWord;
			result.isSpellCheck = this.isSpellCheck;
			result.scanOnOnlySheet = this.scanOnOnlySheet;
			result.lookIn = this.lookIn;


			result.replaceWith = this.replaceWith;
			result.isReplaceAll = this.isReplaceAll;

			result.findInSelection = this.findInSelection;
			result.selectionRange = this.selectionRange ? this.selectionRange.clone() : null;
			result.findRange = this.findRange ? this.findRange.clone() : null;
			result.indexInArray = this.indexInArray;
			result.countFind = this.countFind;
			result.countReplace = this.countReplace;
			result.countFindAll = this.countFindAll;
			result.countReplaceAll = this.countReplaceAll;
			result.sheetIndex = this.sheetIndex;
			result.error = this.error;

			result.specificRange = this.specificRange;
			result.lastSearchElem = this.lastSearchElem;
			result.isNotSearchEmptyCells = this.isNotSearchEmptyCells;
			result.activeCell = this.activeCell;

			return result;
		};

		asc_CFindOptions.prototype.isEqual = function (obj) {
			return obj && this.isEqual2(obj) && this.scanForward === obj.scanForward &&
				this.scanOnOnlySheet === obj.scanOnOnlySheet;
		};
		asc_CFindOptions.prototype.isEqual2 = function (obj) {
			return obj && this.findWhat === obj.findWhat && this.scanByRows === obj.scanByRows && this.isMatchCase === obj.isMatchCase && this.isWholeCell === obj.isWholeCell &&
				this.lookIn === obj.lookIn && this.specificRange == obj.specificRange && this.isNotSearchEmptyCells == obj.isNotSearchEmptyCells && this.activeCell ==
				obj.activeCell;
		};
		asc_CFindOptions.prototype.clearFindAll = function () {
			this.countFindAll = 0;
			this.countReplaceAll = 0;
			this.error = false;
		};
		asc_CFindOptions.prototype.updateFindAll = function () {
			this.countFindAll += this.countFind;
			this.countReplaceAll += this.countReplace;
		};
		asc_CFindOptions.prototype.GetText = function () {
			return this.findWhat;
		};
		asc_CFindOptions.prototype.IsMatchCase = function () {
			return this.isMatchCase;
		};
		asc_CFindOptions.prototype.IsWholeWords = function () {
			return this.isWholeWord;
		};
		asc_CFindOptions.prototype.IsWholeWords = function () {
			return this.isWholeWord;
		};

		asc_CFindOptions.prototype.asc_setFindWhat = function (val) {
			this.findWhat = val;
		};
		asc_CFindOptions.prototype.asc_setScanByRows = function (val) {
			this.scanByRows = val;
		};
		asc_CFindOptions.prototype.asc_setScanForward = function (val) {
			this.scanForward = val;
		};
		asc_CFindOptions.prototype.asc_setIsMatchCase = function (val) {
			this.isMatchCase = val;
		};
		asc_CFindOptions.prototype.asc_setIsWholeCell = function (val) {
			this.isWholeCell = val;
		};
		asc_CFindOptions.prototype.asc_setIsWholeWord = function (val) {
			this.isWholeWord = val;
		};
		asc_CFindOptions.prototype.asc_changeSingleWord = function (val) {
			this.isChangeSingleWord = val;
		};
		asc_CFindOptions.prototype.asc_setScanOnOnlySheet = function (val) {
			//TODO не стал менять native.js, поставил условие для scanOnOnlySheet
			if (val === true) {
				this.scanOnOnlySheet = Asc.c_oAscSearchBy.Sheet;
			} else if (val === false) {
				this.scanOnOnlySheet = Asc.c_oAscSearchBy.Workbook;
			} else {
				this.scanOnOnlySheet = val;
			}
		};
		asc_CFindOptions.prototype.asc_setLookIn = function (val) {
			this.lookIn = val;
		};
		asc_CFindOptions.prototype.asc_setReplaceWith = function (val) {
			this.replaceWith = val;
		};
		asc_CFindOptions.prototype.asc_setIsReplaceAll = function (val) {
			this.isReplaceAll = val;
		};
		asc_CFindOptions.prototype.asc_setSpecificRange = function (val) {
			this.specificRange = val;
		};
		asc_CFindOptions.prototype.asc_setNeedRecalc = function (val) {
			this.isNeedRecalc = val;
		};
		asc_CFindOptions.prototype.asc_setLastSearchElem = function (val) {
			this.lastSearchElem = val;
		};
		asc_CFindOptions.prototype.asc_getLastSearchElem = function (bGetFromSearchEngine) {
			if (bGetFromSearchEngine) {
				let api = window.Asc.editor;
				let wb = api && api.wb;
				if (wb) {
					let searchEngine = wb.SearchEngine;
					if (searchEngine && searchEngine.Elements && searchEngine.Id && searchEngine.Elements[searchEngine.Id - 1]) {
						let element = searchEngine.Elements[searchEngine.Id - 1];
						return [searchEngine.Id - 1, element.sheet, element.name, element.cell, element.text, element.formula];
					}
				}
			}
			return this.lastSearchElem;
		};
		asc_CFindOptions.prototype.asc_setNotSearchEmptyCells = function (val) {
			this.isNotSearchEmptyCells = val;
		};
		asc_CFindOptions.prototype.asc_setActiveCell = function (val) {
			this.activeCell = val;
		};
		asc_CFindOptions.prototype.asc_setIsForMacros = function (val) {
			this.isForMacros = val;
		};

		/** @constructor */
		function findResults() {
			this.values = {};

			this.currentKey1 = -1;
			this.currentKey2 = -1;
			this.currentKeys1 = null;
			this.currentKeys2 = null;
		}

		findResults.prototype.isNotEmpty = function () {
			return 0 !== Object.keys(this.values).length;
		};
		findResults.prototype.contains = function (key1, key2) {
			return this.values[key1] && this.values[key1][key2];
		};
		findResults.prototype.add = function (key1, key2, cell) {
			if (!this.values[key1]) {
				this.values[key1] = {};
			}
			this.values[key1][key2] = cell;
		};
		findResults.prototype._init = function (key1, key2) {
			this.currentKey1 = key1;
			this.currentKey2 = key2;
			this.currentKeyIndex1 = -1;
			this.currentKeyIndex2 = -1;

			this.currentKeys2 = null;
			this.currentKeys1 = Object.keys(this.values).sort(AscCommon.fSortAscending);
			this.currentKeyIndex1 = this._findKey(this.currentKey1, this.currentKeys1);
			if (0 === this.currentKeys1[this.currentKeyIndex1] - this.currentKey1) {
				this.currentKeys2 = Object.keys(this.values[this.currentKey1]).sort(AscCommon.fSortAscending);
				this.currentKeyIndex2 = this._findKey(this.currentKey2, this.currentKeys2);
			}
		};
		findResults.prototype.find = function (key1, key2, forward) {
			this.forward = forward;

			if (this.currentKey1 !== key1 || this.currentKey2 !== key2) {
				this._init(key1, key2);
			}

			if (0 === this.currentKeys1.length) {
				return false;
			}

			var step = this.forward ? +1 : -1;
			this.currentKeyIndex2 += step;
			if (!this.currentKeys2 || !this.currentKeys2[this.currentKeyIndex2]) {
				this.currentKeyIndex1 += step;
				if (!this.currentKeys1[this.currentKeyIndex1]) {
					this.currentKeyIndex1 = this.forward ? 0 : this.currentKeys1.length - 1;
				}
				this.currentKey1 = this.currentKeys1[this.currentKeyIndex1] >> 0;
				this.currentKeys2 = Object.keys(this.values[this.currentKey1]).sort(AscCommon.fSortAscending);
				this.currentKeyIndex2 = this.forward ? 0 : this.currentKeys2.length - 1;
			}
			this.currentKey2 = this.currentKeys2[this.currentKeyIndex2] >> 0;
			return true;
		};
		findResults.prototype._findKey = function (key, arrayKeys) {
			var i = this.forward ? 0 : arrayKeys.length - 1;
			var step = this.forward ? +1 : -1;
			var _key;
			while (_key = arrayKeys[i]) {
				_key = step * ((_key >> 0) - key);
				if (_key >= 0) {
					return 0 === _key ? i : (i - step);
				}
				i += step;
			}
			return -2;
		};

		function CSpellcheckState() {
			this.lastSpellInfo = null;
			this.lastIndex = 0;

			this.lockSpell = false;
			this.startCell = null;
			this.currentCell = null;
			this.iteration = false;
			this.ignoreWords = {};
			this.changeWords = {};
			this.cellsChange = [];
			this.newWord = null;
			this.cellText = null;
			this.newCellText = null;
			this.isStart = false;
			this.afterReplace = false;
			this.isIgnoreUppercase = false;
			this.isIgnoreNumbers = false;
		}

		CSpellcheckState.prototype.clean = function () {
			this.isStart = false;
			this.lastSpellInfo = null;
			this.lastIndex = 0;

			this.lockSpell = false;
			this.startCell = null;
			this.currentCell = null;
			this.iteration = false;
			this.ignoreWords = {};
			this.changeWords = {};
			this.cellsChange = [];
			this.newWord = null;
			this.cellText = null;
			this.newCellText = null;
			this.afterReplace = false;
		};
		CSpellcheckState.prototype.nextRow = function () {
			this.lastSpellInfo = null;
			this.lastIndex = 0;

			this.currentCell.row += 1;
			this.currentCell.col = 0;
		};

		/** @constructor */
		function asc_CCompleteMenu(name, type, desc) {
			this.name = name;
			this.type = type;
		}

		asc_CCompleteMenu.prototype.asc_getName = function () {
			return this.name;
		};
		asc_CCompleteMenu.prototype.asc_getType = function () {
			return this.type;
		};

		function CCacheMeasureEmpty2() {
			this.cache = {};
		}

		CCacheMeasureEmpty2.prototype.getKey = function (elem) {
			return elem.getName() + (elem.getBold() ? 'B' : 'N') + (elem.getItalic() ? 'I' : 'N');
		};
		CCacheMeasureEmpty2.prototype.add = function (elem, val) {
			this.cache[this.getKey(elem)] = val;
		};
		CCacheMeasureEmpty2.prototype.get = function (elem) {
			return this.cache[this.getKey(elem)];
		};
		var g_oCacheMeasureEmpty2 = new CCacheMeasureEmpty2();

		function CCacheMeasureEmpty() {
			this.cache = {};
		}

		CCacheMeasureEmpty.prototype.add = function (elem, val) {
			var fn = elem.getName();
			var font = (this.cache[fn] || (this.cache[fn] = {}));
			font[elem.getSize()] = val;
		};
		CCacheMeasureEmpty.prototype.get = function (elem) {
			var font = this.cache[elem.getName()];
			return font ? font[elem.getSize()] : null;
		};
		var g_oCacheMeasureEmpty = new CCacheMeasureEmpty();

		/**
		 * передаём в меню для того, чтобы показать иконку опций авторавертывания таблиц
		 * @constructor
		 */
		function asc_CAutoCorrectOptions() {
			this.type = null;
			this.options = [];
			this.cellCoord = null;
		}

		asc_CAutoCorrectOptions.prototype.asc_setType = function (val) {
			this.type = val;
		};
		asc_CAutoCorrectOptions.prototype.asc_setOptions = function (val) {
			this.options = val;
		};
		asc_CAutoCorrectOptions.prototype.asc_setCellCoord = function (val) {
			this.cellCoord = val;
		};
		asc_CAutoCorrectOptions.prototype.asc_getType = function () {
			return this.type;
		};
		asc_CAutoCorrectOptions.prototype.asc_getOptions = function () {
			return this.options;
		};
		asc_CAutoCorrectOptions.prototype.asc_getCellCoord = function () {
			return this.cellCoord;
		};

		function CEditorEnterOptions() {
			this.cursorPos = null;
			this.eventPos = null;
			this.focus = false;
			this.newText = null;
			this.hideCursor = false;
			this.quickInput = false;
		}

		/** @constructor */
		function cDate() {
			var bind = Function.bind;
			var unbind = bind.bind(bind);
			var date = new (unbind(Date, null).apply(null, arguments));
			date.__proto__ = cDate.prototype;
			return date;
		}

		cDate.prototype = Object.create(Date.prototype);
		cDate.prototype.constructor = cDate;
		cDate.prototype.excelNullDate1900 = Date.UTC(1899, 11, 30, 0, 0, 0);
		cDate.prototype.excelNullDate1904 = Date.UTC(1904, 0, 1, 0, 0, 0);

		cDate.prototype.getExcelNullDate = function () {
			return AscCommon.bDate1904 ? cDate.prototype.excelNullDate1904 : cDate.prototype.excelNullDate1900;
		};

		cDate.prototype.isLeapYear = function () {
			var y = this.getUTCFullYear();
			return (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0;
		};
		cDate.prototype.isLeapYear1900 = function () {
			var y = this.getUTCFullYear();
			return (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0 || 1900 === y;
		};

		cDate.prototype.getDaysInMonth = function () {
//    return arguments.callee[this.isLeapYear() ? 'L' : 'R'][this.getMonth()];
			return this.isLeapYear() ? this.getDaysInMonth.L[this.getUTCMonth()] : this.getDaysInMonth.R[this.getUTCMonth()];
		};

		cDate.prototype.getLocalDaysInMonth = function () {
			return this.isLeapYear() ? this.getDaysInMonth.L[this.getMonth()] : this.getDaysInMonth.R[this.getMonth()];
		}

		// durations of months for the regular year
		cDate.prototype.getDaysInMonth.R = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
		// durations of months for the leap year
		cDate.prototype.getDaysInMonth.L = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

		cDate.prototype.getDayOfYear = function () {
			let year = Date.prototype.getUTCFullYear.call(this);
			let month = Date.prototype.getUTCMonth.call(this);
			let date = Date.prototype.getUTCDate.call(this);
			if (1899 === year && 11 === month && 30 === date) {
				return 0;
			} else if (1899 === year && 11 === month && 31 === date) {
				return 1;
			}
			let dayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
			let dayOfYear = dayCount[month] + date;
			if (month > 1 && this.isLeapYear1900()) dayOfYear++;
			if (1900 === year && month <= 1) {
				dayOfYear++;
			}
			return dayOfYear;
		};

		cDate.prototype.truncate = function () {
			this.setUTCHours(0, 0, 0, 0);
			return this;
		};

		cDate.prototype.getExcelDate = function (bLocal) {
			return Math.floor(this.getExcelDateWithTime(bLocal));
		};

		cDate.prototype.getExcelDateWithTime = function (bLocal) {
			var year = this.getUTCFullYear(), month = this.getUTCMonth(), date = this.getUTCDate(), res;
			var timeZoneOffset = bLocal ? this.getTimezoneOffset() * 60 * 1000 : 0;

			if (1900 === year && 0 === month && 0 === date) {
				res = 0;
			} else if (1900 < year || (1900 === year && 1 < month)) {
				res = (Date.UTC(year, month, date, this.getUTCHours(), this.getUTCMinutes(), this.getUTCSeconds()) - this.getExcelNullDate() - timeZoneOffset) / c_msPerDay;
			} else if (1900 === year && 1 === month && 29 === date) {
				res = 60;
			} else {
				res = (Date.UTC(year, month, date, this.getUTCHours(), this.getUTCMinutes(), this.getUTCSeconds()) - this.getExcelNullDate() - timeZoneOffset) / c_msPerDay - 1;
			}

			return res;
		};

		cDate.prototype.getExcelDateWithTime2 = function () {
			var year = Date.prototype.getUTCFullYear.call(this);
			var month = Date.prototype.getUTCMonth.call(this);
			var date = Date.prototype.getUTCDate.call(this);

			return (Date.UTC(year, month, date, this.getUTCHours(), this.getUTCMinutes(), this.getUTCSeconds()) - this.getExcelNullDate()) / c_msPerDay;
		};

		cDate.prototype.getDateFromExcel = function (val) {

			val = Math.floor(val);

			return this.getDateFromExcelWithTime(val);
		};

		cDate.prototype.getDateFromExcelWithTime = function (val) {
			if (AscCommon.bDate1904) {
				return new cDate(val * c_msPerDay + this.getExcelNullDate());
			} else {
				if (val < 60) {
					return new cDate(val * c_msPerDay + this.getExcelNullDate());
				} else if (val === 60) {
					return new cDate(Date.UTC(1900, 1, 29));
				} else {
					return new cDate(val * c_msPerDay + this.getExcelNullDate());
				}
			}
		};

		cDate.prototype.getDateFromExcelWithTime2 = function (val) {
			let value = val * c_msPerDay + this.getExcelNullDate();
			//double value is truncated in cDate constructor so use round
			return new cDate(Math.round(value));
		};

		cDate.prototype.addYears = function (counts) {
			this.setUTCFullYear(this.getUTCFullYear() + Math.floor(counts));
		};

		cDate.prototype.addMonths = function (counts) {
			if (this.lastDayOfMonth()) {
				this.setUTCDate(1);
				this.setUTCMonth(this.getUTCMonth() + Math.floor(counts));
				this.setUTCDate(this.getDaysInMonth());
			} else {
				this.setUTCMonth(this.getUTCMonth() + Math.floor(counts));
			}
		};

		cDate.prototype.addDays = function (counts) {
			this.setUTCDate(this.getUTCDate() + Math.floor(counts));
		};
		cDate.prototype.addDays2 = function (counts) {
			Date.prototype.setUTCDate.call(this, Date.prototype.getUTCDate.call(this) + Math.floor(counts));
		};

		cDate.prototype.lastDayOfMonth = function () {
			return this.getDaysInMonth() == this.getUTCDate();
		};
		cDate.prototype.getUTCDate = function () {
			var year = Date.prototype.getUTCFullYear.call(this);
			var month = Date.prototype.getUTCMonth.call(this);
			var date = Date.prototype.getUTCDate.call(this);

			if (1899 == year && 11 == month && 31 == date) {
				return 0;
			} else {
				return date;
			}
		};

		cDate.prototype.getUTCMonth = function () {
			var year = Date.prototype.getUTCFullYear.call(this);
			var month = Date.prototype.getUTCMonth.call(this);
			var date = Date.prototype.getUTCDate.call(this);

			if (1899 == year && 11 == month && (30 === date || 31 === date)) {
				return 0;
			} else {
				return month;
			}
		};

		cDate.prototype.getUTCFullYear = function () {
			var year = Date.prototype.getUTCFullYear.call(this);
			var month = Date.prototype.getUTCMonth.call(this);
			var date = Date.prototype.getUTCDate.call(this);

			if (1899 == year && 11 == month && (30 === date || 31 === date)) {
				return 1900;
			} else {
				return year;
			}
		};

		cDate.prototype.getDateString = function (api, bLocal) {
			return api.asc_getLocaleExample(AscCommon.getShortDateFormat(), this.getExcelDate(bLocal));
		};
		cDate.prototype.getTimeString = function (api) {
			return api.asc_getLocaleExample(AscCommon.getShortTimeFormat(), this.getExcelDateWithTime() - this.getTimezoneOffset() / (60 * 24));
		};
		cDate.prototype.fromISO8601 = function (dateStr) {
			let date;
			if (dateStr.endsWith("Z")) {
				date = new cDate(dateStr);
			} else {
				date = new cDate(dateStr + "Z");
			}
			if (isNaN(date)) {
				date = null;
			}
			return date;
		};
		cDate.prototype.getCurrentDate = function () {
			return this;
		}

		function getIconsForLoad() {
			return AscCommonExcel.getCFIconsForLoad().concat(AscCommonExcel.getSlicerIconsForLoad()).concat(AscCommonExcel.getPivotButtonsForLoad());
		}


		/*
		 * Export
		 * -----------------------------------------------------------------------------
		 */
		var prot;
		window['Asc'] = window['Asc'] || {};
		window['AscCommonExcel'] = window['AscCommonExcel'] || {};
		window['AscCommonExcel'].g_ActiveCell = null; // Active Cell for calculate (in R1C1 mode for relative cell)
		window['AscCommonExcel'].g_R1C1Mode = false; // No calculate in R1C1 mode
		window['AscCommonExcel'].g_LockCustomFunctionRecalculate = false;
		window["AscCommonExcel"].recalcType = recalcType;
		window["AscCommonExcel"].sizePxinPt = sizePxinPt;
		window['AscCommonExcel'].c_sPerDay = c_sPerDay;
		window['AscCommonExcel'].c_msPerDay = c_msPerDay;
		window["AscCommonExcel"].applyFunction = applyFunction;
		window['AscCommonExcel'].g_IncludeNewRowColInTable = true;
		window['AscCommonExcel'].g_AutoCorrectHyperlinks = true;

		window["Asc"]["cDate"] = window["Asc"].cDate = window['AscCommonExcel'].cDate = cDate;
		prot = cDate.prototype;
		prot["getExcelDateWithTime"] = prot.getExcelDateWithTime;

		window["Asc"].typeOf = typeOf;
		window["Asc"].lastIndexOf = lastIndexOf;
		window["Asc"].search = search;
		window["Asc"].getUniqueRangeColor = getUniqueRangeColor;
		window["Asc"].getMinValueOrNull = getMinValueOrNull;
		window["Asc"].round = round;
		window["Asc"].floor = floor;
		window["Asc"].ceil = ceil;
		window["Asc"].incDecFonSize = incDecFonSize;
		window["AscCommonExcel"].calcDecades = calcDecades;
		window["AscCommonExcel"].convertPtToPx = convertPtToPx;
		window["AscCommonExcel"].convertPxToPt = convertPxToPt;
		window["Asc"].profileTime = profileTime;
		window["AscCommonExcel"].getMatchingBorder = getMatchingBorder;
		window["AscCommonExcel"].WordSplitting = WordSplitting;
		window["AscCommonExcel"].getFindRegExp = getFindRegExp;
		window["AscCommonExcel"].convertFillToUnifill = convertFillToUnifill;
		window["AscCommonExcel"].replaceSpellCheckWords = replaceSpellCheckWords;
		window["AscCommonExcel"].getFullHyperlinkLength = getFullHyperlinkLength;
		window["Asc"].outputDebugStr = outputDebugStr;
		window["Asc"].isNumberInfinity = isNumberInfinity;
		window["Asc"].trim = trim;
		window["Asc"].arrayToLowerCase = arrayToLowerCase;
		window["Asc"].isFixedWidthCell = isFixedWidthCell;
		window["AscCommonExcel"].dropDecimalAutofit = dropDecimalAutofit;
		window["AscCommonExcel"].getFragmentsText = getFragmentsText;
		window['AscCommonExcel'].getFragmentsLength = getFragmentsLength;
		window["AscCommonExcel"].getFragmentsCharCodes = getFragmentsCharCodes;
		window["AscCommonExcel"].getFragmentsCharCodesLength = getFragmentsCharCodesLength;
		window["AscCommonExcel"].convertUnicodeToSimpleString = convertUnicodeToSimpleString;
		window['AscCommonExcel'].executeInR1C1Mode = executeInR1C1Mode;
		window['AscCommonExcel'].checkFilteringMode = checkFilteringMode;
		window['AscCommonExcel'].lockCustomFunctionRecalculate = lockCustomFunctionRecalculate;
		window["Asc"].getEndValueRange = getEndValueRange;
		window["AscCommonExcel"].checkStylesNames = checkStylesNames;
		window["AscCommonExcel"].generateCellStyles = generateCellStyles;
		window["AscCommonExcel"].generateSlicerStyles = generateSlicerStyles;
		window["AscCommonExcel"].generateXfsStyle = generateXfsStyle;
		window["AscCommonExcel"].generateXfsStyle2 = generateXfsStyle2;
		window["AscCommonExcel"].getIconsForLoad = getIconsForLoad;
		window["AscCommonExcel"].drawGradientPreview = drawGradientPreview;
		window["AscCommonExcel"].drawIconSetPreview = drawIconSetPreview;

		window["Asc"]["referenceType"] = window["AscCommonExcel"].referenceType = referenceType;
		prot = referenceType;
		prot['A'] = prot.A;
		prot['ARRC'] = prot.ARRC;
		prot['RRAC'] = prot.RRAC;
		prot['R'] = prot.R;
		window["Asc"].Range = Range;
		window["AscCommonExcel"].Range3D = Range3D;
		window["AscCommonExcel"].SelectionRange = SelectionRange;
		window["AscCommonExcel"].ActiveRange = ActiveRange;
		window["AscCommonExcel"].FormulaRange = FormulaRange;
		window["AscCommonExcel"].MultiplyRange = MultiplyRange;
		window["AscCommonExcel"].VisibleRange = VisibleRange;
		window["AscCommonExcel"].g_oRangeCache = g_oRangeCache;

		window["AscCommonExcel"].HandlersList = HandlersList;

		window["AscCommonExcel"].RedoObjectParam = RedoObjectParam;

		window["AscCommonExcel"].asc_CMouseMoveData = asc_CMouseMoveData;
		prot = asc_CMouseMoveData.prototype;
		prot["asc_getType"] = prot.asc_getType;
		prot["asc_getX"] = prot.asc_getX;
		prot["asc_getReverseX"] = prot.asc_getReverseX;
		prot["asc_getY"] = prot.asc_getY;
		prot["asc_getHyperlink"] = prot.asc_getHyperlink;
		prot["asc_getCommentIndexes"] = prot.asc_getCommentIndexes;
		prot["asc_getUserId"] = prot.asc_getUserId;
		prot["asc_getLockedObjectType"] = prot.asc_getLockedObjectType;
		prot["asc_getSizeCCOrPt"] = prot.asc_getSizeCCOrPt;
		prot["asc_getSizePx"] = prot.asc_getSizePx;
		prot["asc_getFilter"] = prot.asc_getFilter;
		prot["asc_getTooltip"] = prot.asc_getTooltip;
		prot["asc_getColor"] = prot.asc_getColor;
		prot["asc_getPlaceholderType"] = prot.asc_getPlaceholderType;

		window["Asc"]["asc_CHyperlink"] = window["Asc"].asc_CHyperlink = asc_CHyperlink;
		prot = asc_CHyperlink.prototype;
		prot["asc_getType"] = prot.asc_getType;
		prot["asc_getHyperlinkUrl"] = prot.asc_getHyperlinkUrl;
		prot["asc_getTooltip"] = prot.asc_getTooltip;
		prot["asc_getLocation"] = prot.asc_getLocation;
		prot["asc_getSheet"] = prot.asc_getSheet;
		prot["asc_getRange"] = prot.asc_getRange;
		prot["asc_getText"] = prot.asc_getText;
		prot["asc_setType"] = prot.asc_setType;
		prot["asc_setHyperlinkUrl"] = prot.asc_setHyperlinkUrl;
		prot["asc_setTooltip"] = prot.asc_setTooltip;
		prot["asc_setLocation"] = prot.asc_setLocation;
		prot["asc_setSheet"] = prot.asc_setSheet;
		prot["asc_setRange"] = prot.asc_setRange;
		prot["asc_setText"] = prot.asc_setText;

		window["AscCommonExcel"].CPagePrint = CPagePrint;
		window["AscCommonExcel"].CPrintPagesData = CPrintPagesData;

		window["Asc"]["asc_CAdjustPrint"] = window["Asc"].asc_CAdjustPrint = asc_CAdjustPrint;
		prot = asc_CAdjustPrint.prototype;
		prot["asc_getPrintType"] = prot.asc_getPrintType;
		prot["asc_setPrintType"] = prot.asc_setPrintType;
		prot["asc_getPageOptionsMap"] = prot.asc_getPageOptionsMap;
		prot["asc_setPageOptionsMap"] = prot.asc_setPageOptionsMap;
		prot["asc_getIgnorePrintArea"] = prot.asc_getIgnorePrintArea;
		prot["asc_setIgnorePrintArea"] = prot.asc_setIgnorePrintArea;
		prot["asc_getNativeOptions"] = prot.asc_getNativeOptions;
		prot["asc_setNativeOptions"] = prot.asc_setNativeOptions;
		prot["asc_getActiveSheetsArray"] = prot.asc_getActiveSheetsArray;
		prot["asc_setActiveSheetsArray"] = prot.asc_setActiveSheetsArray;
		prot["asc_getStartPageIndex"] = prot.asc_getStartPageIndex;
		prot["asc_setStartPageIndex"] = prot.asc_setStartPageIndex;
		prot["asc_getEndPageIndex"] = prot.asc_getEndPageIndex;
		prot["asc_setEndPageIndex"] = prot.asc_setEndPageIndex;

		window["AscCommonExcel"].asc_CLockInfo = asc_CLockInfo;

		window["AscCommonExcel"].asc_CCollaborativeRange = asc_CCollaborativeRange;

		window["AscCommonExcel"].asc_CSheetViewSettings = asc_CSheetViewSettings;
		prot = asc_CSheetViewSettings.prototype;
		prot["asc_getShowGridLines"] = prot.asc_getShowGridLines;
		prot["asc_getShowRowColHeaders"] = prot.asc_getShowRowColHeaders;
		prot["asc_getIsFreezePane"] = prot.asc_getIsFreezePane;
		prot["asc_getShowZeros"] = prot.asc_getShowZeros;
		prot["asc_getShowFormulas"] = prot.asc_getShowFormulas;
		prot["asc_setShowGridLines"] = prot.asc_setShowGridLines;
		prot["asc_setShowRowColHeaders"] = prot.asc_setShowRowColHeaders;
		prot["asc_setShowZeros"] = prot.asc_setShowZeros;
		prot["asc_setShowFormulas"] = prot.asc_setShowFormulas;
		prot["asc_setRightToLeft"] = prot.asc_setRightToLeft;
		prot["asc_getRightToLeft"] = prot.asc_getRightToLeft;

		window["AscCommonExcel"].asc_CPane = asc_CPane;
		window["AscCommonExcel"].asc_CSheetPr = asc_CSheetPr;

		window["AscCommonExcel"].asc_CSelectionMathInfo = asc_CSelectionMathInfo;
		prot = asc_CSelectionMathInfo.prototype;
		prot["asc_getCount"] = prot.asc_getCount;
		prot["asc_getCountNumbers"] = prot.asc_getCountNumbers;
		prot["asc_getSum"] = prot.asc_getSum;
		prot["asc_getAverage"] = prot.asc_getAverage;
		prot["asc_getMin"] = prot.asc_getMin;
		prot["asc_getMax"] = prot.asc_getMax;

		window["Asc"]["asc_CFindOptions"] = window["Asc"].asc_CFindOptions = asc_CFindOptions;
		prot = asc_CFindOptions.prototype;
		prot["asc_setFindWhat"] = prot.asc_setFindWhat;
		prot["asc_setScanByRows"] = prot.asc_setScanByRows;
		prot["asc_setScanForward"] = prot.asc_setScanForward;
		prot["asc_setIsMatchCase"] = prot.asc_setIsMatchCase;
		prot["asc_setIsWholeCell"] = prot.asc_setIsWholeCell;
		prot["asc_setScanOnOnlySheet"] = prot.asc_setScanOnOnlySheet;
		prot["asc_setLookIn"] = prot.asc_setLookIn;
		prot["asc_setReplaceWith"] = prot.asc_setReplaceWith;
		prot["asc_setIsReplaceAll"] = prot.asc_setIsReplaceAll;
		prot["asc_setSpecificRange"] = prot.asc_setSpecificRange;
		prot["asc_setNeedRecalc"] = prot.asc_setNeedRecalc;
		prot["asc_setLastSearchElem"] = prot.asc_setLastSearchElem;
		prot["asc_getLastSearchElem"] = prot.asc_getLastSearchElem;
		prot["asc_setNotSearchEmptyCells"] = prot.asc_setNotSearchEmptyCells;
		prot["asc_setActiveCell"] = prot.asc_setActiveCell;
		prot["asc_setIsForMacros"] = prot.asc_setIsForMacros;


		window["AscCommonExcel"].findResults = findResults;

		window["AscCommonExcel"].CSpellcheckState = CSpellcheckState;

		window["AscCommonExcel"].asc_CCompleteMenu = asc_CCompleteMenu;
		prot = asc_CCompleteMenu.prototype;
		prot["asc_getName"] = prot.asc_getName;
		prot["asc_getType"] = prot.asc_getType;

		window["AscCommonExcel"].g_oCacheMeasureEmpty = g_oCacheMeasureEmpty;
		window["AscCommonExcel"].g_oCacheMeasureEmpty2 = g_oCacheMeasureEmpty2;

		window["Asc"]["asc_CAutoCorrectOptions"] = window["Asc"].asc_CAutoCorrectOptions = asc_CAutoCorrectOptions;
		prot = asc_CAutoCorrectOptions.prototype;
		prot["asc_getType"] = prot.asc_getType;
		prot["asc_getOptions"] = prot.asc_getOptions;
		prot["asc_getCellCoord"] = prot.asc_getCellCoord;

		window['AscCommonExcel'].CEditorEnterOptions = CEditorEnterOptions;
		window['AscCommonExcel'].drawFillCell = drawFillCell;
		window['AscCommonExcel'].getContext = getContext;
		window['AscCommonExcel'].getGraphics = getGraphics;
	})(window);