public ScopeGuardStatement(TextPosition tp, ScopeGuardType type, ProgramContext block)
     : base(tp)
 {
     ScopeGuardType = type;
     Block = block;
     AppendChild(Block);
 }

 /// <summary>
 /// Creates a new XML declaration token.
 /// </summary>
 public XmlDeclarationToken(TextPosition position)
     : base(XmlTokenType.Declaration, position)
 {
     _version = String.Empty;
     _encoding = null;
     _standalone = false;
 }

 public WithExpression(TextPosition cp, Element access, ProgramContext block)
 {
     Access = access;
     Block = block;
     AppendChild(Block);
     AppendChild(Access);
 }

 protected EnumSymbol(TextPosition tp, string name, ProgramContext block)
     : base(tp)
 {
     Name = name;
     Block = block;
     AppendChild(Block);
 }

 /// <summary>
 /// Creates a new DOCTYPE token with the quirks mode set initially.
 /// </summary>
 /// <param name="quirksForced">The state of the force-quirks flag.</param>
 /// <param name="position">The token's position.</param>
 public HtmlDoctypeToken(Boolean quirksForced, TextPosition position)
     : base(HtmlTokenType.Doctype, position)
 {
     _publicIdentifier = null;
     _systemIdentifier = null;
     _quirks = quirksForced;
 }

        public Location(ISourceText file, TextPosition position)
        {
            Requires.NotNull(file, nameof(file));

            File = file;
            Position = position;
        }

        public InsertTextCommand(
			TextPosition textPosition,
			string text)
            : base(textPosition)
        {
            Text = text;
        }

 public MemberAccess(TextPosition tp, Element acs, string member)
     : base(tp)
 {
     Access = acs;
     Member = member;
     AppendChild(Access);
 }

 /// <summary>
 /// Creates a new CSS range token.
 /// </summary>
 /// <param name="range">The selected range string.</param>
 /// <param name="position">The token's position.</param>
 public CssRangeToken(String range, TextPosition position)
     : base(CssTokenType.Range, range, position)
 {
     _start = range.Replace(Symbols.QuestionMark, '0');
     _end = range.Replace(Symbols.QuestionMark, 'F');
     _range = GetRange();
 }

 public AliasDeclaration(TextPosition tp, Identifier from, Identifier to)
     : base(tp)
 {
     From = from;
     To = to;
     Name = To == null ? string.Empty : To.Value;
 }

 protected MonadicExpression(TextPosition tp, TokenType op, Element exp)
     : base(tp)
 {
     Operator = op;
     Exp = exp;
     AppendChild(Exp);
 }

 public void VerticalUpPoint(TickBarPlacement placement, string expected)
 {
     var textPositionOptions = new TextPositionOptions(  placement, TextOrientation.VerticalUp);
     var textSize = new Size(this.text.Width, this.text.Height);
     var textPosition = new TextPosition(textSize,textPositionOptions, new Point(0, 0), 0);
     Assert.AreEqual(expected, textPosition.Point.ToString("F0"));
 }

 /// <summary>
 /// Creates a new DOCTYPE token.
 /// </summary>
 public XmlDoctypeToken(TextPosition position)
     : base(XmlTokenType.Doctype, position)
 {
     _name = null;
     _publicIdentifier = null;
     _systemIdentifier = null;
 }

 /// <summary>
 /// Creates a new entity token.
 /// </summary>
 public XmlEntityToken(TextPosition position, String value, Boolean numeric = false, Boolean hex = false)
     : base(XmlTokenType.Entity, position)
 {
     _numeric = numeric;
     _hex = hex;
     _value = value;
 }

 public AssociatePair(TextPosition tp, Element left, Element right)
     : base(tp)
 {
     Left = left;
     Right = right;
     AppendChild(Left);
     AppendChild(Right);
 }

 public CatchStatement(TextPosition tp, Element use, ProgramContext block)
     : base(tp)
 {
     Use = use;
     Block = block;
     AppendChild(Use);
     AppendChild(Block);
 }

 protected VariantSymbol(TextPosition tp, VariantType type, Element def = null)
     : base(tp)
 {
     VariantType = type;
     DefaultValue = def;
     AppendChild(DefaultValue);
     IsInitialize = true;
 }

 public TuplePair(TextPosition tp, Identifier tag, Element exp)
     : base(tp)
 {
     Tag = tag;
     Exp = exp;
     AppendChild(Tag);
     AppendChild(Exp);
 }

 public CallExpression(TextPosition tp, Element acs, TupleLiteral args)
     : base(tp)
 {
     Access = acs;
     Arguments = args;
     AppendChild(Access);
     AppendChild(Arguments);
 }

 public TemplateInstanceExpression(TextPosition tp, Element acs, TupleLiteral args)
     : base(tp)
 {
     Access = acs;
     DecParameters = args;
     AppendChild(Access);
     AppendChild(DecParameters);
 }