public ImportStatement(Token importToken, IList<Token> importChain, IList<Token> fromChain, Token asValue)
     : base(importToken)
 {
     this.ImportChain = importChain.ToArray();
     this.FromChain = fromChain == null ? null : fromChain.ToArray();
     this.AsValue = asValue;
 }

        public override Token Build(Token lastToken, ScriptEngine engine, Script script, ref SourceCode sourceCode)
        {
            while ((++sourceCode).SpecialChar)
            {
            }
            if (sourceCode.Peek() != '{')
            {
                sourceCode.Throw(String.Format("Error parsing a 'do' statement, expected a '{' but got '{0}' instead.",
                                               sourceCode.Peek()));
            }
            List<List<List<Token>>> code = engine.BuildLongTokens(ref sourceCode, ref script, new[] {'}'});

            if (!sourceCode.SeekToNext("while"))
            {
                sourceCode.Throw("Error parsing a 'do' statement, was expecting a 'while' after the { } block.");
            }

            if (!sourceCode.SeekToNext('('))
            {
                sourceCode.Throw("Error parsing a 'do' statement, was expecting a '(' after 'while'.");
            }

            List<List<Token>> exitCondition = engine.BuildTokensAdvanced(ref sourceCode, ref script, new[] {')'});

            return new DoWhileToken(code, exitCondition);
        }

 public HttpParameter(Token name,
                      string value)
     : this()
 {
     Name = name;
     Value = value;
 }

 void Expect(Token tok)
 {
     if(Next() == tok)
         Consume();
     else
         Error();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="GenericParamRow" /> struct.
 /// </summary>
 /// <param name="number">The number.</param>
 /// <param name="flags">The flags.</param>
 /// <param name="owner">The owner.</param>
 /// <param name="nameString">The name string.</param>
 public GenericParamRow(ushort number, GenericParameterAttributes flags, Token owner, HeapIndexToken nameString)
 {
     Number = number;
     Flags = flags;
     Owner = owner;
     NameString = nameString;
 }

 public override void AppendAnythingElse(TreeConstruction tree, Token token)
 {
     OnMessageRaised(new UnexpectedTokenAfterHtmlError(token.Name));
     tree.ChangeInsertionMode<InBodyInsertionMode>();
     tree.ReprocessFlag = true;
     return;
 }

 public ScriptForEachStatement(AstNodeArgs args)
     : base(args)
 {
     name = (Token)ChildNodes[1];
       expr = (ScriptExpr)ChildNodes[3];
       statement = (ScriptStatement)ChildNodes[4];
 }

		public BracketIndex(Expression root, Token bracketToken, Expression index, Executable owner)
			: base(root.FirstToken, owner)
		{
			this.Root = root;
			this.BracketToken = bracketToken;
			this.Index = index;
		}

 // Text Parsing
 protected void GenericRCDATAElementParsingAlgorithm(TreeConstruction tree, Token token)
 {
     tree.InsertElementForToken((TagToken)token);
     tree.Parser.ChangeTokenState<RCDATAState>();
     tree.OriginalInsertionMode = tree.CurrentInsertionMode;
     tree.ChangeInsertionMode<TextInsertionMode>();
 }

        public static AuthRequest Create(Token token, Trust trust)
        {
            Scope scope = null;

            if (trust != null)
            {
                scope = new Scope()
                {
                    Trust = trust,
                };
            }

            return new AuthRequest()
            {
                Auth = new Auth()
                {
                    Identity = new Identity()
                    {
                        Methods = new[] { "token" },
                        Token = token
                    },
                    Scope = scope
                }
            };
        }

        public LiteralExpression(ScriptLoadingContext lcontext, Token t)
            : base(lcontext)
        {
            switch (t.Type)
            {
                case TokenType.Number:
                case TokenType.Number_Hex:
                case TokenType.Number_HexFloat:
                    Value = DynValue.NewNumber(t.GetNumberValue()).AsReadOnly();
                    break;
                case TokenType.String:
                case TokenType.String_Long:
                    Value = DynValue.NewString(t.Text).AsReadOnly();
                    break;
                case TokenType.True:
                    Value = DynValue.True;
                    break;
                case TokenType.False:
                    Value = DynValue.False;
                    break;
                case TokenType.Nil:
                    Value = DynValue.Nil;
                    break;
                default:
                    throw new InternalErrorException("type mismatch");
            }

            if (Value == null)
                throw new SyntaxErrorException(t, "unknown literal format near '{0}'", t.Text);

            lcontext.Lexer.Next();
        }

        public virtual async Task<string> CreateTokenAsync(Token token)
        {
            var header = await CreateHeaderAsync(token);
            var payload = await CreatePayloadAsync(token);

            return await SignAsync(new JwtSecurityToken(header, payload));
        }

 public ControlInvokation(Token Source, Control Control, List<Node> Arguments, Node Body)
     : base(Source)
 {
     this.Control = Control;
     this.Arguments = Arguments;
     this.Body = Body;
 }

 internal static void ValidateToken(Token token)
 {
     if (ReferenceEquals(token, null))
         throw new ArgumentNullException(nameof(token));
     if (String.IsNullOrEmpty(token.Value))
         throw new ArgumentException(nameof(token.Value));
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="GenericParamRow"/> struct.
 /// </summary>
 /// <param name="number">The number.</param>
 /// <param name="flags">The flags.</param>
 /// <param name="owner">The owner table idx.</param>
 /// <param name="nameStringIdx">The name string idx.</param>
 public GenericParamRow(ushort number, GenericParameterAttributes flags, Token owner, HeapIndexToken nameStringIdx)
 {
     this.number = number;
     this.flags = flags;
     this.owner = owner;
     this.nameStringIdx = nameStringIdx;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AssemblyRefOSRow"/> struct.
 /// </summary>
 /// <param name="platformId">The platform id.</param>
 /// <param name="majorVersion">The major version.</param>
 /// <param name="minorVersion">The minor version.</param>
 /// <param name="assemblyRef">The assembly ref.</param>
 public AssemblyRefOSRow(uint platformId, uint majorVersion, uint minorVersion, Token assemblyRef)
 {
     this.platformId = platformId;
     this.majorVersion = majorVersion;
     this.minorVersion = minorVersion;
     this.assemblyRef = assemblyRef;
 }

		public ForLoopStatement(ScriptLoadingContext lcontext, Token nameToken, Token forToken)
			: base(lcontext)
		{
			//	for Name ‘=’ exp ‘,’ exp [‘,’ exp] do block end | 

			// lexer already at the '=' ! [due to dispatching vs for-each]
			CheckTokenType(lcontext, TokenType.Op_Assignment);

			m_Start = Expression.Expr(lcontext);
			CheckTokenType(lcontext, TokenType.Comma);
			m_End = Expression.Expr(lcontext);

			if (lcontext.Lexer.Current.Type == TokenType.Comma)
			{
				lcontext.Lexer.Next();
				m_Step = Expression.Expr(lcontext);
			}
			else
			{
				m_Step = new LiteralExpression(lcontext, DynValue.NewNumber(1));
			}

			lcontext.Scope.PushBlock();
			m_VarName = lcontext.Scope.DefineLocal(nameToken.Text);
			m_RefFor = forToken.GetSourceRef(CheckTokenType(lcontext, TokenType.Do));
			m_InnerBlock = new CompositeStatement(lcontext);
			m_RefEnd = CheckTokenType(lcontext, TokenType.End).GetSourceRef();
			m_StackFrame = lcontext.Scope.PopBlock();

			lcontext.Source.Refs.Add(m_RefFor);
			lcontext.Source.Refs.Add(m_RefEnd);
		}		

		public Lexer(TextReader rdr)
		{
			this.sb = new StringBuilder();
			this.lineNumber = 1;
			this.rdr = rdr;
			this.tok = Token.EOFile;
		}

 public static StatementNode Parse(Token[] tokens, ref int i)
 {
     if (IfNode.IsIf(tokens, i))
     {
         return IfNode.Parse(tokens, ref i);
     }
     else if (WhileNode.IsWhile(tokens, i))
     {
         return WhileNode.Parse(tokens, ref i);
     }
     else if (ForNode.IsFor(tokens, i))
     {
         return ForNode.Parse(tokens, ref i);
     }
     else if (BreakNode.IsBreak(tokens, i))
     {
         return BreakNode.Parse(tokens, ref i);
     }
     else if (ContinueNode.IsContinue(tokens, i))
     {
         return ContinueNode.Parse(tokens, ref i);
     }
     else if (VariableDeclarationNode.IsVariableDeclaration(tokens, i))
     {
         VariableDeclarationNode node = VariableDeclarationNode.Parse(tokens, ref i);
         Parser.Expect(tokens, ref i, TokenType.Semicolon);
         return node;
     }
     else //Assume expression if no previous match
     {
         ExpressionStatementNode node = ExpressionStatementNode.Parse(tokens, ref i);
         Parser.Expect(tokens, ref i, TokenType.Semicolon);
         return node;
     }
 }

        private IEnumerable<Parselet> FuncArgs(Token<R> fromToken, RantFunctionGroup group)
        { 
            Token<R> funcToken = null;
            var actions = new List<RantAction>();
            var sequences = new List<RantAction>();

            while (!reader.End)
            {
                funcToken = reader.ReadToken();

                if (funcToken.ID == R.Semicolon)
                {
                    // add action to args and continue
                    sequences.Add(actions.Count == 1 ? actions[0] : new RASequence(actions, funcToken));
                    actions.Clear();
                    reader.SkipSpace();
                    continue;
                }
                else if (funcToken.ID == R.RightSquare)
                {
                    // add action to args and return
                    sequences.Add(actions.Count == 1 ? actions[0] : new RASequence(actions, funcToken));
                    AddToOutput(new RAFunction(Stringe.Range(fromToken, funcToken),
                        compiler.GetFunctionInfo(group, sequences.Count, fromToken, funcToken), sequences));
                    yield break;
                }

                yield return GetParselet(funcToken, actions.Add);
            }

            compiler.SyntaxError(fromToken, "Unterminated function: unexpected end of file");
        }