/*
 * (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";

/**
* FORMULA field
* @constructor
*/
function CFieldInstructionFORMULA()
{
	AscWord.FieldInstructionBase.call(this);
	this.ParseQueue = null;
	this.Error = null;
	this.ErrStr = null;
	this.ResultStr = null;
	this.Format = null;
	this.ParentContent = null;
}

CFieldInstructionFORMULA.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionFORMULA.prototype.constructor = CFieldInstructionFORMULA;
CFieldInstructionFORMULA.prototype.Type = AscWord.fieldtype_FORMULA;
CFieldInstructionFORMULA.prototype.SetFormat = function(oFormat)
{
    this.Format = oFormat;
};
CFieldInstructionFORMULA.prototype.SetParseQueue = function(oParseQueue)
{
    this.ParseQueue = oParseQueue;
};
CFieldInstructionFORMULA.prototype.SetError = function(oError)
{
    this.Error = oError;
};

CFieldInstructionFORMULA.prototype.SetFormula = function(sFormula)
{
    this.Formula = sFormula;
};

CFieldInstructionFORMULA.prototype.GetErrorStr = function (oErr) {
	var ret = "!";
	if(oErr)
	{
		if(typeof oErr.Type === 'string')
		{
			ret += AscCommon.translateManager.getValue(oErr.Type);
		}
		if(typeof oErr.Data === 'string')
		{
			ret += (", " + oErr.Data);
		}
	}
	return ret;
};

CFieldInstructionFORMULA.prototype.Calculate = function(oLogicDocument)
{
	this.ErrStr = null;
	this.ResultStr = null;
	this.private_Calculate(oLogicDocument);
	if(this.Error)
	{
		this.ErrStr = this.GetErrorStr(this.Error);
		return;
	}
	if(this.ParseQueue)
	{
		var oCalcError = this.ParseQueue.calculate(oLogicDocument);
		if(oCalcError)
		{
			this.ErrStr = this.GetErrorStr(oCalcError);
			return;
		}
		if(typeof this.ParseQueue.resultS === "string")
		{
			this.ResultStr = this.ParseQueue.resultS;
		}
		else
		{
			this.ResultStr = '';
		}
	}
	else
	{
		this.ResultStr = '';
	}
};
CFieldInstructionFORMULA.prototype.private_Calculate = function (oLogicDocument)
{
	var sListSeparator  = ",";
	var sDigitSeparator = ".";

	if (oLogicDocument && oLogicDocument.GetDecimalSymbol && oLogicDocument.GetListSeparator && oLogicDocument.GetDecimalSymbol() !== oLogicDocument.GetListSeparator())
	{
		sListSeparator  = oLogicDocument.GetListSeparator();
		sDigitSeparator = oLogicDocument.GetDecimalSymbol();
	}

	var oParser = new AscCommonWord.CFormulaParser(sListSeparator, sDigitSeparator);
	oParser.parse(this.Formula, this.ParentContent);

	this.SetParseQueue(oParser.parseQueue);
	if (oParser.parseQueue)
	{
		oParser.parseQueue.format = this.Format;
	}
	this.SetError(oParser.error);
};

CFieldInstructionFORMULA.prototype.SetComplexField = function(oComplexField){
	AscWord.FieldInstructionBase.prototype.SetComplexField.call(this, oComplexField);
	this.ParentContent = null;
	var oBeginChar = oComplexField.BeginChar;
	if(oBeginChar)
	{
		var oRun = oBeginChar.Run;
		if(oRun)
		{
			var oParagraph = oRun.Paragraph;
			if(oParagraph)
			{
				this.ParentContent = oParagraph.Parent;
			}
		}
	}
};
CFieldInstructionFORMULA.prototype.GetResultString = function()
{
	if (!this.ResultStr)
		return this.ResultStr;
	
	return this.applyNumericFormat(this.ResultStr);
};
CFieldInstructionFORMULA.prototype.applyNumericFormat = function(strValue)
{
	if (!this.haveNumericFormat())
		return strValue;
	
	let numValue = parseFloat(strValue);
	if (isNaN(numValue))
		return strValue;
	
	numValue = Math.trunc(numValue + 0.5);
	let textPr = null;
	if (this.ComplexField && this.ComplexField.BeginChar && this.ComplexField.BeginChar.GetRun())
		textPr = this.ComplexField.BeginChar.GetRun().getCompiledPr();
	
	return "" + AscCommon.IntToNumberFormat(numValue, this.getNumericFormat(), {lang: textPr && textPr.Lang, isFromField: true, isSkipFractPart: true});
};

/**
 * PAGE field
 * @constructor
 */
function CFieldInstructionPAGE()
{
	AscWord.FieldInstructionBase.call(this);
}

CFieldInstructionPAGE.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionPAGE.prototype.constructor = CFieldInstructionPAGE;
CFieldInstructionPAGE.prototype.Type = AscWord.fieldtype_PAGE;

/**
 * PAGEREF field
 * @constructor
 */
function CFieldInstructionPAGEREF(sBookmarkName, isHyperlink, isPositionRelative)
{
	AscWord.FieldInstructionBase.call(this);

	this.BookmarkName = sBookmarkName ? sBookmarkName : "";
	this.Hyperlink    = isHyperlink ? true : false;
	this.PosRelative  = isPositionRelative ? true : false;
}

CFieldInstructionPAGEREF.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionPAGEREF.prototype.constructor = CFieldInstructionPAGEREF;
CFieldInstructionPAGEREF.prototype.Type = AscWord.fieldtype_PAGEREF;
CFieldInstructionPAGEREF.prototype.SetHyperlink = function(isHyperlink)
{
	this.Hyperlink   = isHyperlink ? true : false;
};
CFieldInstructionPAGEREF.prototype.SetPositionRelative = function(isPosRel)
{
	this.PosRelative = isPosRel ? true : false;
};
CFieldInstructionPAGEREF.prototype.IsHyperlink = function()
{
	return this.Hyperlink;
};
CFieldInstructionPAGEREF.prototype.IsPositionRelative = function()
{
	return this.PosRelative;
};
CFieldInstructionPAGEREF.prototype.GetBookmarkName = function()
{
	return this.BookmarkName;
};

/**
 * TOC field
 * @constructor
 */
function CFieldInstructionTOC()
{
	AscWord.FieldInstructionBase.call(this);

	this.PreserveTabs     = false;
	this.RemoveBreaks     = true;
	this.Hyperlinks       = false;
	this.Separator        = "";
	this.HeadingS         = -1;
	this.HeadingE         = -1;
	this.Styles           = [];
	this.SkipPageRef      = false;
	this.SkipPageRefStart = -1;
	this.SkipPageRefEnd   = -1;
	this.ForceTabLeader   = undefined;
	this.Caption          = undefined;
	this.CaptionOnlyText  = undefined;
}

CFieldInstructionTOC.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionTOC.prototype.constructor = CFieldInstructionTOC;
CFieldInstructionTOC.prototype.Type = AscWord.fieldtype_TOC;
CFieldInstructionTOC.prototype.IsPreserveTabs = function()
{
	return this.PreserveTabs;
};
CFieldInstructionTOC.prototype.SetPreserveTabs = function(isPreserve)
{
	this.PreserveTabs = isPreserve;
};
CFieldInstructionTOC.prototype.IsRemoveBreaks = function()
{
	return this.RemoveBreaks;
};
CFieldInstructionTOC.prototype.SetRemoveBreaks = function(isRemove)
{
	this.RemoveBreaks = isRemove;
};
CFieldInstructionTOC.prototype.IsHyperlinks = function()
{
	return this.Hyperlinks;
};
CFieldInstructionTOC.prototype.SetHyperlinks = function(isHyperlinks)
{
	this.Hyperlinks = isHyperlinks;
};
CFieldInstructionTOC.prototype.SetSeparator = function(sSeparator)
{
	this.Separator = sSeparator;
};
CFieldInstructionTOC.prototype.GetSeparator = function()
{
	return this.Separator;
};
CFieldInstructionTOC.prototype.SetHeadingRange = function(nStart, nEnd)
{
	this.HeadingS = nStart;
	this.HeadingE = nEnd;
};
CFieldInstructionTOC.prototype.GetHeadingRangeStart = function()
{
	return this.HeadingS;
};
CFieldInstructionTOC.prototype.GetHeadingRangeEnd = function()
{
	return this.HeadingE;
};
CFieldInstructionTOC.prototype.SetStylesArrayRaw = function(sString)
{
	var oLogicDocument = editor.WordControl.m_oLogicDocument;
	var sListSeparator = oLogicDocument.GetListSeparator();

	var arrValues = sString.split(sListSeparator);
	var arrStyles = [];

	for (var nIndex = 0, nCount = arrValues.length; nIndex < nCount; ++nIndex)
	{
		var sName = arrValues[nIndex];
		var nLvl  = nIndex + 1 >= nCount ? 1 : parseInt(arrValues[nIndex + 1]);
		if (isNaN(nLvl))
			nLvl = undefined;
		else
			nIndex++;

		arrStyles.push({
			Name : sName,
			Lvl  : nLvl
		});
	}

	this.SetStylesArray(arrStyles);
};
CFieldInstructionTOC.prototype.SetStylesArray = function(arrStyles)
{
	this.Styles = arrStyles;
};
CFieldInstructionTOC.prototype.GetStylesArray = function()
{
	return this.Styles;
};
CFieldInstructionTOC.prototype.SetPageRefSkippedLvls = function(isSkip, nSkipStart, nSkipEnd)
{
	this.SkipPageRef = isSkip;

	if (true === isSkip
		&& null !== nSkipStart
		&& undefined !== nSkipStart
		&& null !== nSkipEnd
		&& undefined !== nSkipEnd)
	{
		this.SkipPageRefStart = nSkipStart;
		this.SkipPageRefEnd   = nSkipEnd;
	}
	else
	{
		this.SkipPageRefStart = -1;
		this.SkipPageRefEnd   = -1;
	}
};
CFieldInstructionTOC.prototype.IsSkipPageRefLvl = function(nLvl)
{
	if (undefined === nLvl)
		return this.SkipPageRef;

	if (false === this.SkipPageRef)
		return false;

	if (-1 === this.SkipPageRefStart || -1 === this.SkipPageRefEnd)
		return true;

	return  (nLvl >= this.SkipPageRefStart - 1 && nLvl <= this.SkipPageRefEnd - 1);
};
CFieldInstructionTOC.prototype.SetCaption = function (sCaption)
{
	this.Caption = sCaption;
};
CFieldInstructionTOC.prototype.GetCaption = function()
{
	return this.Caption;
};
CFieldInstructionTOC.prototype.SetCaptionOnlyText = function (sVal)
{
	this.CaptionOnlyText = sVal;
};
CFieldInstructionTOC.prototype.GetCaptionOnlyText = function()
{
	return this.CaptionOnlyText;
};
CFieldInstructionTOC.prototype.SetPr = function(oPr)
{
	if (!(oPr instanceof Asc.CTableOfContentsPr))
		return;

	this.SetStylesArray(oPr.get_Styles());
	this.SetHeadingRange(oPr.get_OutlineStart(), oPr.get_OutlineEnd());
	this.SetHyperlinks(oPr.get_Hyperlink());

	if (oPr.PageNumbers)
		this.SetPageRefSkippedLvls(false);
	else
		this.SetPageRefSkippedLvls(true);

	if (oPr.RightTab)
		this.SetSeparator("");
	else
		this.SetSeparator(" ");

	this.ForceTabLeader = oPr.TabLeader;
	var sCaption = oPr.get_CaptionForInstruction();
	if(sCaption !== undefined)
	{
		if(sCaption || this.Styles.length > 0)
		{
			if(oPr.IsIncludeLabelAndNumber)
			{
				this.SetCaption(sCaption);
				this.SetCaptionOnlyText(undefined);
			}
			else
			{
				this.SetCaptionOnlyText(sCaption);
				this.SetCaption(undefined);
			}
			this.SetHeadingRange(-1, -1);
		}
	}
};
CFieldInstructionTOC.prototype.GetForceTabLeader = function()
{
	var nTabLeader = this.ForceTabLeader;
	this.ForceTabLeader = undefined;
	return nTabLeader;
};
CFieldInstructionTOC.prototype.ToString = function()
{
	var oLogicDocument = editor.WordControl.m_oLogicDocument;
	var sListSeparator = oLogicDocument.GetListSeparator();

	var sInstr = "TOC ";

	if (this.HeadingS >= 1
		&& this.HeadingS <= 9
		&& this.HeadingE >= this.HeadingS
		&& this.HeadingE <= 9)
		sInstr +=  "\\o " + "\"" + this.HeadingS + "-" + this.HeadingE + "\" ";

	if (this.SkipPageRef)
	{
		sInstr += "\\n ";

		if (this.SkipPageRefStart >= 1
			&& this.SkipPageRefStart <= 9
			&& this.SkipPageRefEnd >= this.SkipPageRefStart
			&& this.SkipPageRefEnd <= 9)
			sInstr +=  "\"" + this.SkipPageRefStart + "-" + this.SkipPageRefEnd + "\" ";
	}

	if (this.Hyperlinks)
		sInstr += "\\h ";

	if (!this.RemoveBreaks)
		sInstr += "\\x ";

	if (this.PreserveTabs)
		sInstr += "\\w ";

	if (this.Separator)
		sInstr += "\\p \"" + this.Separator + "\"";

	if (this.Styles.length > 0)
	{
		sInstr += "\\t \"";

		for (var nIndex = 0, nCount = this.Styles.length; nIndex < nCount; ++nIndex)
		{
			if (0 === nIndex)
				sInstr += this.Styles[nIndex].Name;
			else
				sInstr += sListSeparator + this.Styles[nIndex].Name;

			if (undefined !== this.Styles[nIndex].Lvl && null !== this.Styles[nIndex].Lvl)
				sInstr += sListSeparator + this.Styles[nIndex].Lvl;
		}

		sInstr += "\" ";
	}
	if(this.Caption !== undefined)
	{
		sInstr += "\\c ";
		if(typeof this.Caption === "string" && this.Caption.length > 0)
		{
			sInstr += "\"" + this.Caption + "\"";
		}
	}
	if(this.CaptionOnlyText !== undefined)
	{
		sInstr += "\\a ";
		if(typeof this.CaptionOnlyText === "string" && this.CaptionOnlyText.length > 0)
		{
			sInstr += "\"" + this.CaptionOnlyText + "\"";
		}
	}

	return sInstr;
};
CFieldInstructionTOC.prototype.IsTableOfFigures = function ()
{
	if(this.Caption !== undefined || this.CaptionOnlyText !== undefined)
	{
		return true;
	}
	return false;
};
CFieldInstructionTOC.prototype.IsTableOfContents = function ()
{
	return !this.IsTableOfFigures();
};
/**
 * ASK field
 * @constructor
 */
function CFieldInstructionASK()
{
	AscWord.FieldInstructionBase.call(this);

	this.BookmarkName = "";
	this.PromptText   = "";
}
CFieldInstructionASK.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionASK.prototype.constructor = CFieldInstructionASK;
CFieldInstructionASK.prototype.Type = AscWord.fieldtype_ASK;
CFieldInstructionASK.prototype.SetBookmarkName = function(sBookmarkName)
{
	this.BookmarkName = sBookmarkName;
};
CFieldInstructionASK.prototype.GetBookmarkName = function()
{
	return this.BookmarkName;
};
CFieldInstructionASK.prototype.SetPromptText = function(sText)
{
	this.PromptText = sText;
};
CFieldInstructionASK.prototype.GetPromptText = function()
{
	if (!this.PromptText)
		return this.BookmarkName;

	return this.PromptText;
};

/**
 * NUMPAGES field
 * @constructor
 */
function CFieldInstructionNUMPAGES()
{
	AscWord.FieldInstructionBase.call(this);
}
CFieldInstructionNUMPAGES.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionNUMPAGES.prototype.constructor = CFieldInstructionNUMPAGES;
CFieldInstructionNUMPAGES.prototype.Type = AscWord.fieldtype_NUMPAGES;

/**
 * HYPERLINK field
 * @constructor
 */
function CFieldInstructionHYPERLINK()
{
	AscWord.FieldInstructionBase.call(this);

	this.ToolTip      = "";
	this.Link         = "";
	this.BookmarkName = "";
}
CFieldInstructionHYPERLINK.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionHYPERLINK.prototype.constructor = CFieldInstructionHYPERLINK;
CFieldInstructionHYPERLINK.prototype.Type = AscWord.fieldtype_HYPERLINK;
CFieldInstructionHYPERLINK.prototype.SetToolTip = function(sToolTip)
{
	this.ToolTip = sToolTip;
};
CFieldInstructionHYPERLINK.prototype.GetToolTip = function()
{
	if ("" === this.ToolTip)
	{
		if (this.Link)
			return (this.BookmarkName ? this.Link + "#" + this.BookmarkName : this.Link)
		else if (this.BookmarkName)
			return AscCommon.translateManager.getValue("Current Document");

		return "";
	}

	return this.ToolTip;
};
CFieldInstructionHYPERLINK.prototype.SetLink = function(sLink)
{
	this.Link = sLink;
};
CFieldInstructionHYPERLINK.prototype.GetLink = function()
{
	return this.Link;
};
CFieldInstructionHYPERLINK.prototype.SetBookmarkName = function(sBookmarkName)
{
	this.BookmarkName = sBookmarkName;
};
CFieldInstructionHYPERLINK.prototype.GetBookmarkName = function()
{
	return this.BookmarkName;
};
CFieldInstructionHYPERLINK.prototype.ToString = function()
{
	var sInstr = "HYPERLINK ";
	if (this.Link)
		sInstr +=  "\"" + this.Link + "\"";

	if (this.ToolTip)
		sInstr += "\\o \"" + this.ToolTip + "\"";

	if (this.BookmarkName)
		sInstr += "\\l " + this.BookmarkName;

	return sInstr;
};
//----------------------------------------------------------------------------------------------------------------------
// Функции для совместимости с обычным ParaHyperlink
//----------------------------------------------------------------------------------------------------------------------
CFieldInstructionHYPERLINK.prototype.GetAnchor = function()
{
	return this.GetBookmarkName();
};
CFieldInstructionHYPERLINK.prototype.GetValue = function()
{
	return this.GetLink();
};
CFieldInstructionHYPERLINK.prototype.SetVisited = function(isVisited)
{
};
/**
 * Проверяем является ли данная ссылка ссылкой в начало документа
 * @returns {boolean}
 */
CFieldInstructionHYPERLINK.prototype.IsTopOfDocument = function()
{
	return (this.GetBookmarkName() === "_top");
};
CFieldInstructionHYPERLINK.prototype.IsUseInDocument = function()
{
	return !!(this.ComplexField && this.ComplexField.IsValid());
};

/**
 * TIME field
 * @constructor
 */
function CFieldInstructionTIME()
{
	AscWord.FieldInstructionBase.call(this);

	this.Format = "";
}
CFieldInstructionTIME.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionTIME.prototype.constructor = CFieldInstructionTIME;
CFieldInstructionTIME.prototype.Type = AscWord.fieldtype_TIME;
CFieldInstructionTIME.prototype.ToString = function()
{
	return ("TIME \\@ \"" + this.sFormat + "\"");
};
CFieldInstructionTIME.prototype.SetFormat = function(sFormat)
{
	this.Format = sFormat;
};
CFieldInstructionTIME.prototype.GetFormat = function()
{
	return this.Format;
};

/**
 * TIME field
 * @constructor
 */
function CFieldInstructionDATE()
{
	AscWord.FieldInstructionBase.call(this);

	this.Format = "";
}
CFieldInstructionDATE.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionDATE.prototype.constructor = CFieldInstructionDATE;
CFieldInstructionDATE.prototype.Type = AscWord.fieldtype_DATE;
CFieldInstructionDATE.prototype.ToString = function()
{
	return ("TIME \\@ \"" + this.sFormat + "\"");
};
CFieldInstructionDATE.prototype.SetFormat = function(sFormat)
{
	this.Format = sFormat;
};
CFieldInstructionDATE.prototype.GetFormat = function()
{
	return this.Format;
};
/**
 * SEQ field
 * @constructor
 */
function CFieldInstructionSEQ()
{

	AscWord.FieldInstructionBase.call(this);
	this.Id = null;
	this.C = false;
	this.H = false;
	this.N = false;
	this.R = null;
	this.S = null;
	this.NumFormat = Asc.c_oAscNumberingFormat.Decimal;
	this.GeneralSwitches = [];

	this.ParentContent = null;
}
CFieldInstructionSEQ.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionSEQ.prototype.constructor = CFieldInstructionSEQ;
CFieldInstructionSEQ.prototype.Type = AscWord.fieldtype_SEQ;
CFieldInstructionSEQ.prototype.ToString = function ()
{
	var sInstruction = " SEQ ";
	if(this.Id)
	{
		sInstruction += this.Id;
	}
	for(var i = 0; i < this.GeneralSwitches.length; ++i)
	{
		sInstruction +=  " \\* " + this.GeneralSwitches[i];
	}
	if(this.C)
	{
		sInstruction += " \\c"
	}
	if(this.H)
	{
		sInstruction += " \\h";
	}
	if(this.R)
	{
		sInstruction += " \\r " + this.R;
	}
	if(this.S)
	{
		sInstruction += " \\s " + this.S;
	}
	return sInstruction;
};
CFieldInstructionSEQ.prototype.SetComplexField = function (oComplexField)
{
	AscWord.FieldInstructionBase.prototype.SetComplexField.call(this, oComplexField);
	this.ParentContent = null;
	var oBeginChar = oComplexField.BeginChar;
	if(oBeginChar)
	{
		var oRun = oBeginChar.Run;
		if(oRun)
		{
			var oParagraph = oRun.Paragraph;
			if(oParagraph)
			{
				this.ParentContent = oParagraph.Parent;
			}
		}
	}
};

CFieldInstructionSEQ.prototype.GetRestartNum = function ()
{
	if(typeof this.R === "string" && this.R.length > 0)
	{
		var aTest = /[0-9]+/.exec(this.R);
		var nResult;
		if(Array.isArray(aTest) && aTest.length > 0)
		{
			nResult = parseInt(aTest[0]);
			if(!isNaN(nResult))
			{
				return nResult;
			}
		}
	}
	return null;
};

CFieldInstructionSEQ.prototype.GetText = function ()
{
	if(!this.ParentContent)
	{
		return "";
	}
	var oTopDocument = this.ParentContent.Is_TopDocument(true);
	var aFields, oField, i, nIndex, nLvl, nCounter;
	if(!oTopDocument)
	{
		return "";
	}
	if(oTopDocument.IsHdrFtr(false) || oTopDocument.IsFootnote(false))
	{
		return AscCommon.translateManager.getValue("Error! Main Document Only.");
	}

	if(this.H)
	{
		if(this.GeneralSwitches.length === 0)
		{
			return "";
		}
	}
	nIndex = this.GetRestartNum();
	if(nIndex === null)
	{
		aFields = [];
		oTopDocument.GetAllSeqFieldsByType(this.Id, aFields);
		nIndex = -1;
		if(this.S)
		{
			nLvl = parseInt(this.S);
			if(!isNaN(nLvl))
			{
				--nLvl;
				for(i = aFields.length - 1; i > -1; --i)
				{
					oField = aFields[i];
					if(AscCommon.isRealObject(oField) && this.ComplexField === oField)
					{
						break;
					}
				}
				if(i > -1)
				{
					nCounter = i;
					for(i = i - 1; i > -1; --i)
					{
						oField = aFields[i];
						if(AscFormat.isRealNumber(oField) && oField <= nLvl)
						{
							aFields = aFields.splice(i + 1, nCounter - i);
							break;
						}
					}
				}
			}
		}
		nCounter = 1;
		for(i = 0; i < aFields.length; ++i)
		{
			oField = aFields[i];
			if(AscCommon.isRealObject(oField))
			{
				if(this.ComplexField === oField)
				{
					nIndex = nCounter;
					break;
				}
				if(!(oField.Instruction && oField.Instruction.C))
				{
					++nCounter;
				}
			}
		}
	}
	if(nIndex > -1)
	{
		return AscCommon.IntToNumberFormat(nIndex, this.NumFormat);
	}
	return AscCommon.translateManager.getValue("Error! Main Document Only.");
};
CFieldInstructionSEQ.prototype.SetId = function (sVal)
{
	this.Id = sVal;
};
CFieldInstructionSEQ.prototype.SetC = function (sVal)
{
	this.C = sVal;
};
CFieldInstructionSEQ.prototype.SetH = function (sVal)
{
	this.H = sVal;
};
CFieldInstructionSEQ.prototype.SetN = function (sVal)
{
	this.N = sVal;
};
CFieldInstructionSEQ.prototype.SetR = function (sVal)
{
	this.R = sVal;
};
CFieldInstructionSEQ.prototype.SetS = function (sVal)
{
	this.S = sVal;
};
CFieldInstructionSEQ.prototype.SetGeneralSwitches = function (aSwitches)
{
	this.GeneralSwitches = aSwitches;
	for(var i = 0; i < aSwitches.length; ++i)
	{
		this.NumFormat = GeneralToNumFormat(aSwitches[i]);
	}
};
CFieldInstructionSEQ.prototype.CheckId = function(type)
{
	if (!(typeof type === "string"))
		return type === this.Id;
	
	return (type.split(" ").join("_") === this.Id);
};

function GeneralToNumFormat(sFormat)
{
	if(typeof sFormat === 'string')
	{
		if(sFormat.toLowerCase() === 'arabic')
		{
			return Asc.c_oAscNumberingFormat.Decimal;
		}
		else if(sFormat.toLowerCase() === 'alphabetic')
		{
			if(sFormat[0] === 'A')
			{
				return Asc.c_oAscNumberingFormat.UpperLetter;
			}
			else
			{
				return Asc.c_oAscNumberingFormat.LowerLetter;
			}
		}
		else if(sFormat.toLowerCase() === 'roman')
		{
			if(sFormat[0] === 'r')
			{
				return Asc.c_oAscNumberingFormat.LowerRoman;
			}
			else
			{
				return Asc.c_oAscNumberingFormat.UpperRoman;
			}
		}
	}
	return Asc.c_oAscNumberingFormat.Decimal;
}

/**
 * STYLEREF field
 * @constructor
 */

function CFieldInstructionSTYLEREF()
{

	AscWord.FieldInstructionBase.call(this);
	this.StyleName = null;
	this.OutlineLvl = null;
	this.L = null;
	this.N = null;
	this.P = null;
	this.R = null;
	this.T = null;
	this.W = null;
	this.S = null;
	this.GeneralSwitches = [];
	this.ParentContent = null;
	this.ParentParagraph = null;
}
CFieldInstructionSTYLEREF.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionSTYLEREF.prototype.constructor = CFieldInstructionSTYLEREF;
CFieldInstructionSTYLEREF.prototype.Type = AscWord.fieldtype_STYLEREF;
CFieldInstructionSTYLEREF.prototype.SetL = function(v){this.L = v;};
CFieldInstructionSTYLEREF.prototype.SetN = function(v){this.N = v;};
CFieldInstructionSTYLEREF.prototype.SetP = function(v){this.P = v;};
CFieldInstructionSTYLEREF.prototype.SetR = function(v){this.R = v;};
CFieldInstructionSTYLEREF.prototype.SetT = function(v){this.T = v;};
CFieldInstructionSTYLEREF.prototype.SetW = function(v){this.W = v;};
CFieldInstructionSTYLEREF.prototype.SetS = function(v){this.S = v;};
CFieldInstructionSTYLEREF.prototype.SetGeneralSwitches = function(v){this.GeneralSwitches = v;};
CFieldInstructionSTYLEREF.prototype.GetText = function()
{
	const sDefaultMessage = "Error! No text of specified style in document.";
	if(this.ParentContent)
	{
		const oHdrFtr = this.ParentContent.IsHdrFtr(true);
		if (oHdrFtr)
		{
			//TODO
		}
		else
		{
			const oFootNote = this.ParentContent.IsFootnote(true);
			if(oFootNote)
			{
				//TODO
			}
			else
			{
				if(this.ParentParagraph)
				{
					let oParagraph = null;
					let sRet = "";
					let bAbove = true;
					let oStyles = this.ParentContent.GetStyles();
					let sStyleId;
					let nOutlineLvl;
					let nStartIndex, oTmpContent;
					let oShape, oMainGroup, oDrawing, oCell, oRow, oTable, oBLSdt;
					let oParentParagraph, oParentContent, nParentIdx;
					let fCheckParagraph = null;
					if(this.StyleName)
					{
						sStyleId = oStyles.GetStyleIdByName(this.StyleName);
						if(sStyleId)
						{
							fCheckParagraph = function (oParagraph)
							{
								return oParagraph.GetParagraphStyle() === sStyleId;
							};
						}
					}
					else if(this.OutlineLvl !== null)
					{
						nOutlineLvl = this.OutlineLvl - 1;
						fCheckParagraph = function (oParagraph)
						{
							return oParagraph.GetOutlineLvl() === nOutlineLvl;
						};
					}
					if(fCheckParagraph)
					{
						oParentParagraph = this.ParentParagraph;
						oParentContent = this.ParentContent;
						nParentIdx = this.ParentParagraph.GetIndex();
						oShape = this.ParentContent.Is_DrawingShape(true);
						if(oShape)
						{
							if(oShape.group)
							{
								oMainGroup = oShape.getMainGroup();
								oDrawing = oMainGroup.parent;
							}
							else
							{
								oDrawing = oShape.parent;
							}
							if(!oDrawing)
							{
								return AscCommon.translateManager.getValue(sDefaultMessage);
							}
							oParentParagraph = oDrawing.GetParagraph();
							oParentContent = oParentParagraph.GetParent();
							nParentIdx = oParentParagraph.GetIndex();
						}

						if(fCheckParagraph(oParentParagraph))
						{
							oParagraph = oParentParagraph;
						}
						oTmpContent = oParentContent;
						nStartIndex = nParentIdx;
						while(oTmpContent && !oParagraph)
						{
							oParagraph = oTmpContent.FindParagraph(fCheckParagraph, true, nStartIndex);
							if(oParagraph)
							{
								break;
							}
							oCell = oTmpContent.IsTableCellContent(true);
							if(oCell)
							{
								oRow = oCell.GetRow();
								oTable = oRow.GetTable();
								if(!oRow || !oTable)
								{
									return AscCommon.translateManager.getValue(sDefaultMessage);
								}
								oParagraph = oRow.FindParagraph(fCheckParagraph, true, oCell.GetIndex() - 1);
								if(!oParagraph)
								{
									oParagraph = oTable.FindParagraph(fCheckParagraph, true, oRow.GetIndex() - 1);
								}
								oTmpContent = oTable.Parent;
								nStartIndex = oTable.GetIndex() - 1;
							}
							else if(oTmpContent.IsBlockLevelSdtContent())
							{
								oBLSdt = oTmpContent.GetParent();
								oTmpContent = oBLSdt.Parent;
								nStartIndex = oBLSdt.GetIndex() - 1;
							}
							else
							{
								break;
							}
						}
						if(!oParagraph)
						{
							oTmpContent = oParentContent;
							nStartIndex = nParentIdx + 1;
							while(oTmpContent && !oParagraph)
							{
								oParagraph = oTmpContent.FindParagraph(fCheckParagraph, false, nStartIndex);
								if(oParagraph)
								{
									break;
								}
								oCell = oTmpContent.IsTableCellContent(true);
								if(oCell)
								{
									oRow = oCell.GetRow();
									oTable = oRow.GetTable();
									if(!oRow || !oTable)
									{
										return AscCommon.translateManager.getValue(sDefaultMessage);
									}
									oParagraph = oRow.FindParagraph(fCheckParagraph, false, oCell.GetIndex() + 1);
									if(!oParagraph)
									{
										oParagraph = oTable.FindParagraph(fCheckParagraph, false, oRow.GetIndex() + 1);
									}
									oTmpContent = oTable.Parent;
									nStartIndex = oTable.GetIndex() + 1;
								}
								else if(oTmpContent.IsBlockLevelSdtContent())
								{
									oBLSdt = oTmpContent.GetParent();
									oTmpContent = oBLSdt.Parent;
									nStartIndex = oBLSdt.GetIndex() + 1;
								}
								else
								{
									break;
								}
							}
						}
						if(oParagraph)
						{
							if(this.N || this.R || this.W || this.S)
							{
								if(oParagraph.IsNumberedNumbering())
								{
									sRet += oParagraph.GetNumberingText(true);
								}
								else
								{
									sRet += "0";
								}
							}
							else
							{
								oParagraph.ApplyToAll = true;
								sRet = oParagraph.GetSelectedText(true, {});
								oParagraph.ApplyToAll = false;
							}
							if(this.P)
							{
								sRet += (" " + AscCommon.translateManager.getValue(bAbove ? "above" : "below"));
							}
							return sRet;
						}
					}
					return AscCommon.translateManager.getValue(sDefaultMessage);
				}
			}
		}
	}
    return AscCommon.translateManager.getValue(sDefaultMessage);
};
CFieldInstructionSTYLEREF.prototype.SetStyleName = function(v)
{
	this.StyleName = v;
};
CFieldInstructionSTYLEREF.prototype.SetOutlineLvl = function(v)
{
	this.OutlineLvl = v;
};
CFieldInstructionSTYLEREF.prototype.ToString = function()
{
	var sRet = " STYLEREF ";

	if(this.S)
	{
		sRet += " \\s"
	}
	if(this.StyleName)
	{
		sRet += this.StyleName;
	}
	else if(this.OutlineLvl !== null)
	{
		sRet += this.OutlineLvl;
	}
	if(this.L)
	{
		sRet += " \\l";
	}
	if(this.N)
	{
		sRet += " \\n"
	}
	if(this.P)
	{
		sRet += " \\p"
	}
	if(this.R)
	{
		sRet += " \\r"
	}
	if(this.T)
	{
		sRet += " \\t"
	}
	if(this.W)
	{
		sRet += " \\w"
	}
	return sRet;
};
CFieldInstructionSTYLEREF.prototype.SetComplexField = function (oComplexField)
{
	AscWord.FieldInstructionBase.prototype.SetComplexField.call(this, oComplexField);
	this.ParentContent = null;
	var oBeginChar = oComplexField.BeginChar;
	if(oBeginChar)
	{
		var oRun = oBeginChar.Run;
		if(oRun)
		{
			var oParagraph = oRun.Paragraph;
			if(oParagraph)
			{
				this.ParentParagraph = oParagraph;
				this.ParentContent = oParagraph.Parent;
			}
		}
	}
};


/**
 * NOTEREF field
 * @constructor
 */
function CFieldInstructionNOTEREF()
{
	AscWord.FieldInstructionBase.call(this);

	this.GeneralSwitches = [];
	this.BookmarkName = "";
	this.Hyperlink = false; // \h - is hyperlink
	this.bIsPosition = false; // \p - above/below
	this.bFormatting = false; // \p - format as notes or endnotes
}
CFieldInstructionNOTEREF.prototype = Object.create(AscWord.FieldInstructionBase.prototype);
CFieldInstructionNOTEREF.prototype.constructor = CFieldInstructionNOTEREF;
CFieldInstructionNOTEREF.prototype.Type = AscWord.fieldtype_NOTEREF;


CFieldInstructionNOTEREF.prototype.SetGeneralSwitches = function (aSwitches)
{
	this.GeneralSwitches = aSwitches;
};
CFieldInstructionNOTEREF.prototype.SetBookmarkName = function(sBookmarkName)
{
	this.BookmarkName = sBookmarkName;
};
CFieldInstructionNOTEREF.prototype.GetBookmarkName = function()
{
	return this.BookmarkName;
};
CFieldInstructionNOTEREF.prototype.SetHyperlink = function(bIsHyperlink)
{
	this.Hyperlink = bIsHyperlink;
};
CFieldInstructionNOTEREF.prototype.GetHyperlink = function()
{
	return this.Hyperlink;
};
CFieldInstructionNOTEREF.prototype.SetIsPosition = function(bVal)
{
	this.bIsPosition = bVal;
};
CFieldInstructionNOTEREF.prototype.IsPosition = function()
{
	return this.bIsPosition;
};
CFieldInstructionNOTEREF.prototype.SetIsFormatting = function(bVal)
{
	this.bFormatting = bVal;
};
CFieldInstructionNOTEREF.prototype.IsFormatting = function()
{
	return this.bFormatting;
};
CFieldInstructionNOTEREF.prototype.ToString = function()
{
	var sInstruction = " NOTEREF ";
	sInstruction += this.BookmarkName;
	for(var nSwitch = 0; nSwitch < this.GeneralSwitches.length; ++nSwitch)
	{
		sInstruction +=  " \\* " + this.GeneralSwitches[nSwitch];
	}
	if(this.GetHyperlink())
	{
		sInstruction += " \\h";
	}
	if(this.IsPosition())
	{
		sInstruction += " \\p";
	}
	if(this.IsFormatting())
	{
		sInstruction += " \\f";
	}
	return sInstruction;
};
//----------------------------------------------------------------------------------------------------------------------
// Функции для совместимости с обычным ParaHyperlink
//----------------------------------------------------------------------------------------------------------------------
CFieldInstructionNOTEREF.prototype.IsTopOfDocument = function()
{
	return (this.GetAnchor() === "_top");
};
CFieldInstructionNOTEREF.prototype.GetAnchor = function()
{
	var sBookmarkName = this.GetBookmarkName();
	var sAnchor = sBookmarkName;
	if(this.ComplexField)
	{
		var oLogicDoc = this.ComplexField.LogicDocument;
		if(oLogicDoc)
		{
			var oBookmarksManager = oLogicDoc.GetBookmarksManager();
			if(oBookmarksManager)
			{
				var oBookmark = oBookmarksManager.GetBookmarkByName(sBookmarkName);
				if(!oBookmark)
				{
					sAnchor = "_top";
				}
			}
		}
	}
	return sAnchor;
};
CFieldInstructionNOTEREF.prototype.GetValue = function()
{
	return "";
};
CFieldInstructionNOTEREF.prototype.SetVisited = function(isVisited)
{
};
CFieldInstructionNOTEREF.prototype.SetToolTip = function(sToolTip)
{
};
CFieldInstructionNOTEREF.prototype.GetToolTip = function()
{
	return AscCommon.translateManager.getValue("Current Document");
};



/**
 * Класс для разбора строки с инструкцией
 * @constructor
 */
function CFieldInstructionParser()
{
	this.Line   = "";
	this.Pos    = 0;
	this.Buffer = "";
	this.Result = null;

	this.SavedStates = [];
}
CFieldInstructionParser.prototype.GetInstructionClass = function(sLine)
{
	this.Line   = sLine;
	this.Pos    = 0;
	this.Buffer = "";
	this.Result = null;

	this.private_Parse();

	return this.Result;
};
CFieldInstructionParser.prototype.InitParaFieldArguments = function(Type, sLine, oParaFiles)
{
	this.Line   = sLine;
	this.Pos    = 0;
	this.Buffer = "";
	this.Result = null;

	oParaFiles.FieldType = Type;
	oParaFiles.Arguments = this.private_ReadArguments().slice(1);
	//todo Switches
	oParaFiles.Switches = this.Pos < this.Line.length ? [this.Line.substring(this.Pos)] : [];
};
CFieldInstructionParser.prototype.private_Parse = function()
{
	if (!this.private_ReadNext())
		return this.private_ReadREF("");
	
	var sBuffer = this.Buffer.toUpperCase();
	if("PAGE" === sBuffer)
	{
		this.private_ReadPAGE();
	}
	else if("PAGEREF" === sBuffer)
	{
		this.private_ReadPAGEREF();
	}
	else if("TOC" === sBuffer)
	{
		this.private_ReadTOC();
	}
	else if("ASC" === sBuffer)
	{
		this.private_ReadASK();
	}
	else if("REF" === sBuffer)
	{
		this.private_ReadREF();
	}
	else if("NOTEREF" === sBuffer)
	{
		this.private_ReadNOTEREF();
	}
	else if("NUMPAGES" === sBuffer)
	{
		this.private_ReadNUMPAGES();
	}
	else if("HYPERLINK" === sBuffer)
	{
		this.private_ReadHYPERLINK();
	}
	else if("SEQ" === sBuffer)
	{
		this.private_ParseSEQ();
	}
	else if("STYLEREF" === sBuffer)
	{
		this.private_ParseSTYLEREF();
	}
	else if ("TIME" === sBuffer)
	{
		this.private_ReadTIME();
	}
	else if ("DATE" === sBuffer)
	{
		this.private_ReadDATE();
	}
	else if ("ADDIN" === sBuffer)
	{
		this.private_ReadADDIN();
	}
	else if ("MERGEFIELD" === sBuffer)
	{
		this.private_ReadMERGEFIELD();
	}
	else if ("FORMTEXT" === sBuffer)
	{
		this.private_ReadFORMTEXT();
	}
	else if ("FORMCHECKBOX" === sBuffer)
	{
		this.private_ReadFORMCHECKBOX();
	}
	else if(sBuffer.indexOf("=") === 0)
	{
		this.private_ReadFORMULA();
	}
	else
	{
		this.private_ReadREF();
	}
};
CFieldInstructionParser.prototype.private_ReadNext = function()
{
	let nLen  = this.Line.length;
	let bWord = false;

	this.Buffer = "";

	while (this.Pos < nLen)
	{
		var nCharCode = this.Line.charCodeAt(this.Pos);
		if (32 === nCharCode || 9 === nCharCode)
		{
			if (bWord)
				return true;
		}
		else if (34 === nCharCode && (0 === this.Pos || 92 !== this.Line.charCodeAt(this.Pos - 1)))
		{
			// Кавычки
			this.Pos++;
			bWord = true;
			while (this.Pos < nLen)
			{
				nCharCode = this.Line.charCodeAt(this.Pos);
				if (34 === nCharCode && 92 !== this.Line.charCodeAt(this.Pos - 1))
				{
					this.Pos++;
					break;
				}
				
				if (34 === nCharCode && 92 === this.Line.charCodeAt(this.Pos - 1) && this.Buffer.length > 0)
					this.Buffer = this.Buffer.substring(0, this.Buffer.length - 1);

				this.Buffer += this.Line.charAt(this.Pos);

				this.Pos++;
			}

			return bWord;
		}
		else
		{
			this.Buffer += this.Line.charAt(this.Pos);
			bWord = true;
		}

		this.Pos++;
	}

	return bWord;
};
CFieldInstructionParser.prototype.private_ReadTillEnd = function()
{
	this.Buffer = this.Line.substr(this.Pos).trim();
	return !!this.Buffer;
};
CFieldInstructionParser.prototype.private_ReadArguments = function()
{
	var arrArguments = [];

	var sArgument = this.private_ReadArgument();
	while (null !== sArgument)
	{
		arrArguments.push(sArgument);
		sArgument = this.private_ReadArgument();
	}

	return arrArguments;
};
CFieldInstructionParser.prototype.private_ReadArgument = function()
{
	this.private_SaveState();

	if (!this.private_ReadNext())
		return null;

	if (this.private_IsSwitch())
	{
		this.private_RestoreState();
		return null;
	}

	this.private_RemoveLastState();
	return this.Buffer;
};
CFieldInstructionParser.prototype.private_IsSwitch = function()
{
	return this.Buffer.charAt(0) === '\\';
};
CFieldInstructionParser.prototype.private_GetSwitchLetter = function()
{
	return this.Buffer.charAt(1);
};
CFieldInstructionParser.prototype.private_SaveState = function()
{
	this.SavedStates.push(this.Pos);
};
CFieldInstructionParser.prototype.private_RestoreState = function()
{
	if (this.SavedStates.length > 0)
		this.Pos = this.SavedStates[this.SavedStates.length - 1];

	this.private_RemoveLastState();
};
CFieldInstructionParser.prototype.private_RemoveLastState = function()
{
	if (this.SavedStates.length > 0)
		this.SavedStates.splice(this.SavedStates.length - 1, 1);
};
CFieldInstructionParser.prototype.private_ReadGeneralFormatSwitch = function()
{
	if (!this.private_IsSwitch() || this.private_GetSwitchLetter() !== '*')
		return;
	
	let arrArguments = this.private_ReadArguments();
	if (arrArguments.length > 0)
		this.Result.addGeneralSwitches(arrArguments);
};
CFieldInstructionParser.prototype.private_ReadPAGE = function()
{
	this.Result = new CFieldInstructionPAGE();

	// Zero or more general-formatting-switches

	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
			this.private_ReadGeneralFormatSwitch();
	}
};
CFieldInstructionParser.prototype.private_ReadFORMULA = function()
{
	this.Result = new CFieldInstructionFORMULA();
    var sFormula = this.Buffer.slice(1, this.Buffer.length);
    var sFormat = null;
    var bFormat = false;
    var bNumFormat = false;
    while(this.private_ReadNext())
	{
    	if(this.private_IsSwitch())
    	{
			bFormat = true;
			if ('#' === this.Buffer.charAt(1))
			{
				bNumFormat = true;
			}
			else
			{
				this.private_ReadGeneralFormatSwitch();
			}
		}
		else
		{
			if(bFormat)
			{
				if(bNumFormat)
				{
                    sFormat = this.Buffer;
				}
			}
			else
			{
                sFormula += this.Buffer;
			}
            bFormat = false;
            bNumFormat = false;
		}
	}
	sFormula = sFormula.toUpperCase();
	var oFormat;
	if(null !== sFormat)
	{
        oFormat = AscCommon.oNumFormatCache.get(sFormat, AscCommon.NumFormatType.WordFieldNumeric);
        this.Result.SetFormat(oFormat);
	}
	this.Result.SetFormula(sFormula);

};
CFieldInstructionParser.prototype.private_ReadPAGEREF = function()
{
	var sBookmarkName = null;
	var isHyperlink = false, isPageRel = false;

	var isSwitch = false, isBookmark = false;

	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
		{
			isSwitch = true;

			if ('p' === this.Buffer.charAt(1))
				isPageRel = true;
			else if ('h' === this.Buffer.charAt(1))
				isHyperlink = true;
		}
		else if (!isSwitch && !isBookmark)
		{
			sBookmarkName = this.Buffer;
			isBookmark    = true;
		}
	}

	this.Result = new CFieldInstructionPAGEREF(sBookmarkName, isHyperlink, isPageRel);
};
CFieldInstructionParser.prototype.private_ReadTOC = function()
{
	// TODO: \a, \b, \c, \d, \f, \l, \s, \z, \u

	this.Result = new CFieldInstructionTOC();
	var arrArguments;

	var isOutline = false, isStyles = false;
	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
		{
			var sType = this.private_GetSwitchLetter();
			if ('w' === sType)
			{
				this.Result.SetPreserveTabs(true);
			}
			else if ('x' === sType)
			{
				this.Result.SetRemoveBreaks(false);
			}
			else if ('h' === sType)
			{
				this.Result.SetHyperlinks(true);
			}
			else if ('p' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
					this.Result.SetSeparator(arrArguments[0]);
			}
			else if ('o' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
				{
					var arrRange = this.private_ParseIntegerRange(arrArguments[0]);
					if (null !== arrRange)
						this.Result.SetHeadingRange(arrRange[0], arrRange[1]);
				}
				else
				{
					this.Result.SetHeadingRange(1, 9);
				}

				isOutline = true;
			}
			else if ('t' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
				{
					this.Result.SetStylesArrayRaw(arrArguments[0]);
					isStyles = true;
				}
			}
			else if ('n' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
				{
					var arrRange = this.private_ParseIntegerRange(arrArguments[0]);
					if (null !== arrRange)
						this.Result.SetPageRefSkippedLvls(true, arrRange[0], arrRange[1]);
					else
						this.Result.SetPageRefSkippedLvls(true, -1, -1);
				}
				else
				{
					this.Result.SetPageRefSkippedLvls(true, -1, -1);
				}
			}
			else if ('c' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0 && (typeof arrArguments[0] === "string"))
					this.Result.SetCaption(arrArguments[0]);
			}
			else if ('a' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0 && (typeof arrArguments[0] === "string"))
					this.Result.SetCaptionOnlyText(arrArguments[0]);
			}
		}
	}

	if (!isOutline && !isStyles)
		this.Result.SetHeadingRange(1, 9);
};
CFieldInstructionParser.prototype.private_ReadASK = function()
{
	this.Result = new CFieldInstructionASK();

	var arrArguments = this.private_ReadArguments();

	if (arrArguments.length >= 2)
		this.Result.SetPromptText(arrArguments[1]);

	if (arrArguments.length >= 1)
		this.Result.SetBookmarkName(arrArguments[0]);

	// TODO: Switches
};
CFieldInstructionParser.prototype.private_ReadREF = function(sBookmarkName)
{
	this.Result = new AscWord.FieldInstructionREF();

	if (undefined !== sBookmarkName)
	{
		this.Result.SetBookmarkName(sBookmarkName);
	}
	else
	{
		var arrArguments = this.private_ReadArguments();
		if (arrArguments.length > 0)
		{
			this.Result.SetBookmarkName(arrArguments[0]);
		}
	}
	
	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
		{
			var sType = this.private_GetSwitchLetter();
			if ('*' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
					this.Result.addGeneralSwitches(arrArguments);
			}
			else if("d" === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
				{
					if(typeof arrArguments[0] === "string" && arrArguments[0].length > 0)
					{
						this.Result.SetDelimiter(arrArguments[0]);
					}
				}
			}
			else if("h" === sType)
			{
				this.Result.SetHyperlink(true);
			}
			else if("n" === sType)
			{
				this.Result.SetIsNumberNoContext(true);
			}
			else if("w" === sType)
			{
				this.Result.SetIsNumberFullContext(true);
			}
			else if("r" === sType)
			{
				this.Result.SetIsNumber(true);
			}
			else if("p" === sType)
			{
				this.Result.SetIsPosition(true);
			}
		}
		else if ("" === this.Result.GetBookmarkName())
		{
			this.Result.SetBookmarkName(this.Buffer);
		}
	}
};
CFieldInstructionParser.prototype.private_ReadNOTEREF = function()
{
	this.Result = new CFieldInstructionNOTEREF();

	var arrArguments = this.private_ReadArguments();
	if (arrArguments.length > 0)
	{
		this.Result.SetBookmarkName(arrArguments[0]);
	}
	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
		{
			var sType = this.private_GetSwitchLetter();
			if ('*' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
					this.Result.SetGeneralSwitches(arrArguments);
			}
			else if("h" === sType) {
				this.Result.SetHyperlink(true);
			}
			else if("f" === sType) {
				this.Result.SetIsFormatting(true);
			}
			else if("p" === sType) {
				this.Result.SetIsPosition(true);
			}
		}
	}
};
CFieldInstructionParser.prototype.private_ReadNUMPAGES = function()
{
	this.Result = new CFieldInstructionNUMPAGES();
	
	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
			this.private_ReadGeneralFormatSwitch();
	}
};
CFieldInstructionParser.prototype.private_ReadHYPERLINK = function()
{
	this.Result = new CFieldInstructionHYPERLINK();
	var arrArguments = this.private_ReadArguments();
	if (arrArguments.length > 0)
		this.Result.SetLink(arrArguments[0]);

	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
		{
			var sType = this.private_GetSwitchLetter();
			if ('o' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
					this.Result.SetToolTip(arrArguments[0]);
			}
			else if ('l' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
					this.Result.SetBookmarkName(arrArguments[0]);
			}

			// TODO: Остальные флаги \m \n \t для нас бесполезны
		}
	}
};
CFieldInstructionParser.prototype.private_ParseIntegerRange = function(sValue)
{
	// value1-value2

	var nSepPos = sValue.indexOf("-");
	if (-1 === nSepPos)
		return null;

	var nValue1 = parseInt(sValue.substr(0, nSepPos));
	var nValue2 = parseInt(sValue.substr(nSepPos + 1));

	if (isNaN(nValue1) || isNaN(nValue2))
		return null;

	return [nValue1, nValue2];
};
CFieldInstructionParser.prototype.private_ParseSEQ = function()
{
	this.Result = new CFieldInstructionSEQ();
	var arrArguments = this.private_ReadArguments();
	if (arrArguments.length > 0)
		this.Result.SetId(arrArguments[0]);

	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
		{
			var sType = this.private_GetSwitchLetter();
			if ('*' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
					this.Result.SetGeneralSwitches(arrArguments);
			}
			else if ('c' === sType)
			{
				this.Result.SetC(true);
			}
			else if ('h' === sType)
			{
				this.Result.SetH(true);
			}
			else if ('n' === sType)
			{
				this.Result.SetN(true);
			}
			else if ('r' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
				{
					this.Result.SetR(arrArguments[0]);
				}
			}
			else if('s' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
				{
					this.Result.SetS(arrArguments[0]);
				}
			}
		}
	}
};
CFieldInstructionParser.prototype.private_ParseSTYLEREF = function()
{
	this.Result = new CFieldInstructionSTYLEREF();
	var arrArguments = this.private_ReadArguments();
	if (arrArguments.length > 0)
	{

		let sArgument = arrArguments[0];
		if (typeof sArgument === "string" &&
			sArgument.length === 1 &&
			AscCommon.IsDigit(sArgument.charCodeAt(0)) &&
			sArgument !== "0")
		{
			this.Result.SetOutlineLvl(parseInt(sArgument));
		}
		else
		{
			this.Result.SetStyleName(sArgument);
		}
	}

	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
		{
			var sType = this.private_GetSwitchLetter();
			if ('*' === sType)
			{
				arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
					this.Result.SetGeneralSwitches(arrArguments);
			}
			else if ('l' === sType)
			{
				this.Result.SetL(true);
			}
			else if ('n' === sType)
			{
				this.Result.SetN(true);
			}
			else if ('p' === sType)
			{
				this.Result.SetP(true);
			}
			else if ('r' === sType)
			{
				this.Result.SetR(true);
			}
			else if('t' === sType)
			{
				this.Result.SetT(true)
			}
			else if('w' === sType)
			{
				this.Result.SetW(true)
			}
			else if ('s' === sType)
			{
				this.Result.SetS(true);
			}
		}
	}
};
CFieldInstructionParser.prototype.private_ReadTIME = function()
{
	this.Result = new CFieldInstructionTIME();

	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
		{
			if ('@' === this.Buffer.charAt(1))
			{
				var arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
					this.Result.SetFormat(arrArguments[0]);
			}
		}
	}
};
CFieldInstructionParser.prototype.private_ReadDATE = function()
{
	this.Result = new CFieldInstructionDATE();

	while (this.private_ReadNext())
	{
		if (this.private_IsSwitch())
		{
			if ('@' === this.Buffer.charAt(1))
			{
				var arrArguments = this.private_ReadArguments();
				if (arrArguments.length > 0)
					this.Result.SetFormat(arrArguments[0]);
			}
		}
	}
};
CFieldInstructionParser.prototype.private_ReadADDIN = function()
{
	this.Result = new AscWord.CFieldInstructionADDIN();
	
	if (this.private_ReadTillEnd())
		this.Result.SetValue(this.Buffer);
};
CFieldInstructionParser.prototype.private_ReadMERGEFIELD = function()
{
	this.Result = new AscWord.CFieldInstructionMERGEFIELD();
	
	let arrArguments = this.private_ReadArguments();
	if (arrArguments.length)
		this.Result.SetName(arrArguments[0]);
};
CFieldInstructionParser.prototype.private_ReadFORMTEXT = function()
{
	this.Result = new AscWord.CFieldInstructionFORMTEXT();
};
CFieldInstructionParser.prototype.private_ReadFORMCHECKBOX = function()
{
	this.Result = new AscWord.CFieldInstructionFORMCHECKBOX();
};