var parser = ( function ( ) { var o = function ( k , v , o , l ) { for ( o = o || { } , l = k . length ; l -- ; o [ k [ l ] ] = v ) ; return o ; } , $V0 = [ 1 , 18 ] , $V1 = [ 1 , 7 ] , $V2 = [ 1 , 19 ] , $V3 = [ 1 , 20 ] , $V4 = [ 1 , 14 ] , $V5 = [ 1 , 15 ] , $V6 = [ 1 , 16 ] , $V7 = [ 1 , 33 ] , $V8 = [ 1 , 31 ] , $V9 = [ 1 , 23 ] , $Va = [ 1 , 22 ] , $Vb = [ 1 , 24 ] , $Vc = [ 1 , 25 ] , $Vd = [ 1 , 26 ] , $Ve = [ 1 , 27 ] , $Vf = [ 1 , 28 ] , $Vg = [ 1 , 29 ] , $Vh = [ 1 , 30 ] , $Vi = [ 5 , 8 , 15 , 18 , 20 , 28 , 29 , 32 , 33 , 34 , 35 , 36 , 37 , 38 ] , $Vj = [ 5 , 15 , 18 ] , $Vk = [ 5 , 12 , 15 , 17 , 18 , 24 , 25 , 28 , 29 , 30 ] , $Vl = [ 1 , 57 ] , $Vm = [ 5 , 8 , 12 , 15 , 17 , 18 , 24 , 25 , 28 , 29 , 30 ] , $Vn = [ 15 , 18 ] , $Vo = [ 5 , 8 , 15 , 18 , 28 , 29 , 38 ] , $Vp = [ 5 , 8 , 15 , 18 , 28 , 29 , 32 , 33 , 38 ] , $Vq = [ 5 , 8 , 15 , 18 , 28 , 29 , 32 , 33 , 34 , 37 , 38 ] , $Vr = [ 5 , 8 , 15 , 18 , 28 , 29 , 32 , 33 , 34 , 35 , 36 , 37 , 38 ] , $Vs = [ 5 , 8 , 15 , 18 ] , $Vt = [ 5 , 8 , 15 , 18 , 20 , 22 , 28 , 29 , 32 , 33 , 34 , 35 , 36 , 37 , 38 ] ; var parser = { trace : function trace ( ) { } , yy : { } , symbols_ : { "error" : 2 , "SCRIPT" : 3 , "expression" : 4 , "EOF" : 5 , "expressionsOptionalTrailingSemi" : 6 , "separator" : 7 , ";" : 8 , "expressions" : 9 , "EXPRESSION_BLOCK" : 10 , "IDENTIFIER" : 11 , "IDENTIFIER_TOKEN" : 12 , "argument" : 13 , "arguments" : 14 , "," : 15 , "FUNCTION_CALL" : 16 , "(" : 17 , ")" : 18 , "LOGICAL_EXPRESSION" : 19 , "LOGICAL_OPERATOR_TOKEN" : 20 , "ASSIGNMENT" : 21 , "ASSIGNMENT_OPERATOR_TOKEN" : 22 , "number" : 23 , "DIGITS_TOKEN" : 24 , "." : 25 , "NUMBER_LITERAL" : 26 , "UNARY_EXPRESSION" : 27 , "-" : 28 , "+" : 29 , "!" : 30 , "BINARY_EXPRESSION" : 31 , "*" : 32 , "/" : 33 , "%" : 34 , "&" : 35 , "|" : 36 , "^" : 37 , "COMPARISON_TOKEN" : 38 , "$accept" : 0 , "$end" : 1 } , terminals_ : { 2 : "error" , 5 : "EOF" , 8 : ";" , 12 : "IDENTIFIER_TOKEN" , 15 : "," , 17 : "(" , 18 : ")" , 20 : "LOGICAL_OPERATOR_TOKEN" , 22 : "ASSIGNMENT_OPERATOR_TOKEN" , 24 : "DIGITS_TOKEN" , 25 : "." , 28 : "-" , 29 : "+" , 30 : "!" , 32 : "*" , 33 : "/" , 34 : "%" , 35 : "&" , 36 : "|" , 37 : "^" , 38 : "COMPARISON_TOKEN" } , productions_ : [ 0 , [ 3 , 2 ] , [ 3 , 2 ] , [ 3 , 1 ] , [ 7 , 1 ] , [ 7 , 2 ] , [ 9 , 2 ] , [ 9 , 3 ] , [ 6 , 1 ] , [ 6 , 2 ] , [ 10 , 1 ] , [ 11 , 1 ] , [ 13 , 1 ] , [ 13 , 1 ] , [ 14 , 1 ] , [ 14 , 3 ] , [ 16 , 3 ] , [ 16 , 4 ] , [ 19 , 3 ] , [ 21 , 3 ] , [ 21 , 3 ] , [ 23 , 1 ] , [ 23 , 2 ] , [ 23 , 3 ] , [ 23 , 2 ] , [ 23 , 1 ] , [ 26 , 1 ] , [ 27 , 2 ] , [ 27 , 2 ] , [ 27 , 2 ] , [ 31 , 3 ] , [ 31 , 3 ] , [ 31 , 3 ] , [ 31 , 3 ] , [ 31 , 3 ] , [ 31 , 3 ] , [ 31 , 3 ] , [ 31 , 3 ] , [ 31 , 3 ] , [ 4 , 1 ] , [ 4 , 1 ] , [ 4 , 3 ] , [ 4 , 1 ] , [ 4 , 1 ] , [ 4 , 1 ] , [ 4 , 1 ] , [ 4 , 1 ] , [ 4 , 3 ] ] , performAction : function anonymous ( yytext , yyleng , yylineno , yy , yystate , $$ , _$ ) { var $0 = $$ . length - 1 ; switch ( yystate ) { case 1 : return { type : 'SCRIPT' , body : [ $$ [ $0 - 1 ] ] , loc : this . _$ } ; break ; case 2 : return { type : 'SCRIPT' , body : $$ [ $0 - 1 ] , loc : this . _$ } ; break ; case 3 : return { type : 'SCRIPT' , body : [ ] , loc : this . _$ } ; break ; case 6 : this . $ = [ $$ [ $0 - 1 ] ] ; break ; case 7 : this . $ = $$ [ $0 - 2 ] . concat ( [ $$ [ $0 - 1 ] ] ) ; break ; case 8 : this . $ = $$ [ $0 ] ; break ; case 9 : this . $ = $$ [ $0 - 1 ] . concat ( [ $$ [ $0 ] ] ) ; break ; case 10 : this . $ = { type : 'EXPRESSION_BLOCK' , body : $$ [ $0 ] , loc : this . _$ } ; break ; case 11 : this . $ = { type : 'IDENTIFIER' , value : $$ [ $0 ] . toLowerCase ( ) , loc : this . _$ } ; break ; case 14 : this . $ = [ $$ [ $0 ] ] ; break ; case 15 : this . $ = $$ [ $0 - 2 ] . concat ( [ $$ [ $0 ] ] ) ; break ; case 16 : this . $ = { type : 'CALL_EXPRESSION' , callee : $$ [ $0 - 2 ] , arguments : [ ] , loc : this . _$ } ; break ; case 17 : this . $ = { type : 'CALL_EXPRESSION' , callee : $$ [ $0 - 3 ] , arguments : $$ [ $0 - 1 ] , loc : this . _$ } ; break ; case 18 : this . $ = { type : 'LOGICAL_EXPRESSION' , left : $$ [ $0 - 2 ] , right : $$ [ $0 ] , operator : $$ [ $0 - 1 ] , loc : this . _$ } ; break ; case 19 : case 20 : this . $ = { type : 'ASSIGNMENT_EXPRESSION' , left : $$ [ $0 - 2 ] , operator : $$ [ $0 - 1 ] , right : $$ [ $0 ] , loc : this . _$ } ; break ; case 21 : this . $ = Number ( $$ [ $0 ] ) ; break ; case 22 : this . $ = Number ( $$ [ $0 - 1 ] ) ; break ; case 23 : this . $ = Number ( $$ [ $0 - 2 ] + $$ [ $0 - 1 ] + $$ [ $0 ] ) ; break ; case 24 : this . $ = Number ( '0' + $$ [ $0 - 1 ] + $$ [ $0 ] ) ; break ; case 25 : this . $ = 0 ; break ; case 26 : this . $ = { type : 'NUMBER_LITERAL' , value : $$ [ $0 ] , loc : this . _$ } ; break ; case 27 : case 28 : case 29 : this . $ = { type : 'UNARY_EXPRESSION' , value : $$ [ $0 ] , operator : $$ [ $0 - 1 ] , loc : this . _$ } ; break ; case 30 : case 31 : case 32 : case 33 : case 34 : case 35 : case 36 : case 37 : case 38 : this . $ = { type : 'BINARY_EXPRESSION' , left : $$ [ $0 - 2 ] , right : $$ [ $0 ] , operator : $$ [ $0 - 1 ] , loc : this . _$ } ; break ; case 41 : case 47 : this . $ = $$ [ $0 - 1 ] ; break ; } } , table : [ { 3 : 1 , 4 : 2 , 5 : [ 1 , 4 ] , 6 : 3 , 9 : 13 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 1 : [ 3 ] } , { 5 : [ 1 , 21 ] , 7 : 32 , 8 : $V7 , 20 : $V8 , 28 : $V9 , 29 : $Va , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg , 38 : $Vh } , { 5 : [ 1 , 34 ] } , { 1 : [ 2 , 3 ] } , o ( $Vi , [ 2 , 39 ] ) , o ( $Vi , [ 2 , 40 ] ) , { 4 : 35 , 6 : 37 , 9 : 13 , 10 : 36 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , o ( $Vi , [ 2 , 42 ] ) , o ( $Vi , [ 2 , 43 ] ) , o ( $Vi , [ 2 , 44 ] , { 22 : [ 1 , 38 ] } ) , o ( $Vi , [ 2 , 45 ] , { 17 : [ 1 , 40 ] , 22 : [ 1 , 39 ] } ) , o ( $Vi , [ 2 , 46 ] ) , o ( $Vj , [ 2 , 8 ] , { 31 : 5 , 27 : 6 , 26 : 8 , 21 : 9 , 16 : 10 , 11 : 11 , 19 : 12 , 23 : 17 , 4 : 41 , 12 : $V0 , 17 : $V1 , 24 : $V2 , 25 : $V3 , 28 : $V4 , 29 : $V5 , 30 : $V6 } ) , { 4 : 42 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 43 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 44 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , o ( $Vi , [ 2 , 26 ] ) , o ( [ 5 , 8 , 15 , 17 , 18 , 20 , 22 , 28 , 29 , 32 , 33 , 34 , 35 , 36 , 37 , 38 ] , [ 2 , 11 ] ) , o ( $Vi , [ 2 , 21 ] , { 25 : [ 1 , 45 ] } ) , o ( $Vi , [ 2 , 25 ] , { 24 : [ 1 , 46 ] } ) , { 1 : [ 2 , 1 ] } , { 4 : 47 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 48 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 49 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 50 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 51 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 52 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 53 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 54 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 55 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 56 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , o ( $Vk , [ 2 , 6 ] , { 8 : $Vl } ) , o ( $Vm , [ 2 , 4 ] ) , { 1 : [ 2 , 2 ] } , { 7 : 32 , 8 : $V7 , 18 : [ 1 , 58 ] , 20 : $V8 , 28 : $V9 , 29 : $Va , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg , 38 : $Vh } , { 18 : [ 1 , 59 ] } , o ( $Vn , [ 2 , 10 ] ) , { 4 : 60 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 61 , 11 : 11 , 12 : $V0 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , { 4 : 65 , 6 : 37 , 9 : 13 , 10 : 66 , 11 : 11 , 12 : $V0 , 13 : 64 , 14 : 63 , 16 : 10 , 17 : $V1 , 18 : [ 1 , 62 ] , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , o ( $Vj , [ 2 , 9 ] , { 7 : 67 , 8 : $V7 , 20 : $V8 , 28 : $V9 , 29 : $Va , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg , 38 : $Vh } ) , o ( $Vo , [ 2 , 27 ] , { 20 : $V8 , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg } ) , o ( $Vo , [ 2 , 28 ] , { 20 : $V8 , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg } ) , o ( $Vo , [ 2 , 29 ] , { 20 : $V8 , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg } ) , o ( $Vi , [ 2 , 22 ] , { 24 : [ 1 , 68 ] } ) , o ( $Vi , [ 2 , 24 ] ) , o ( $Vo , [ 2 , 30 ] , { 20 : $V8 , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg } ) , o ( $Vo , [ 2 , 31 ] , { 20 : $V8 , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg } ) , o ( $Vp , [ 2 , 32 ] , { 20 : $V8 , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg } ) , o ( $Vp , [ 2 , 33 ] , { 20 : $V8 , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg } ) , o ( $Vq , [ 2 , 34 ] , { 20 : $V8 , 35 : $Ve , 36 : $Vf } ) , o ( $Vr , [ 2 , 35 ] , { 20 : $V8 } ) , o ( $Vr , [ 2 , 36 ] , { 20 : $V8 } ) , o ( $Vq , [ 2 , 37 ] , { 20 : $V8 , 35 : $Ve , 36 : $Vf } ) , o ( $Vs , [ 2 , 38 ] , { 20 : $V8 , 28 : $V9 , 29 : $Va , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg , 38 : $Vh } ) , o ( $Vi , [ 2 , 18 ] ) , o ( $Vm , [ 2 , 5 ] ) , o ( $Vi , [ 2 , 41 ] ) , o ( $Vi , [ 2 , 47 ] ) , o ( $Vs , [ 2 , 20 ] , { 20 : $V8 , 28 : $V9 , 29 : $Va , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg , 38 : $Vh } ) , o ( $Vs , [ 2 , 19 ] , { 20 : $V8 , 28 : $V9 , 29 : $Va , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg , 38 : $Vh } ) , o ( $Vt , [ 2 , 16 ] ) , { 15 : [ 1 , 70 ] , 18 : [ 1 , 69 ] } , o ( $Vn , [ 2 , 14 ] ) , o ( $Vn , [ 2 , 12 ] , { 7 : 32 , 8 : $V7 , 20 : $V8 , 28 : $V9 , 29 : $Va , 32 : $Vb , 33 : $Vc , 34 : $Vd , 35 : $Ve , 36 : $Vf , 37 : $Vg , 38 : $Vh } ) , o ( $Vn , [ 2 , 13 ] ) , o ( $Vk , [ 2 , 7 ] , { 8 : $Vl } ) , o ( $Vi , [ 2 , 23 ] ) , o ( $Vt , [ 2 , 17 ] ) , { 4 : 65 , 6 : 37 , 9 : 13 , 10 : 66 , 11 : 11 , 12 : $V0 , 13 : 71 , 16 : 10 , 17 : $V1 , 19 : 12 , 21 : 9 , 23 : 17 , 24 : $V2 , 25 : $V3 , 26 : 8 , 27 : 6 , 28 : $V4 , 29 : $V5 , 30 : $V6 , 31 : 5 } , o ( $Vn , [ 2 , 15 ] ) ] , defaultActions : { 4 : [ 2 , 3 ] , 21 : [ 2 , 1 ] , 34 : [ 2 , 2 ] } , parseError : function parseError ( str , hash ) { if ( hash . recoverable ) { this . trace ( str ) ; } else { var error = new Error ( str ) ; error . hash = hash ; throw error ; } } , parse : function parse ( input ) { var self = this , stack = [ 0 ] , tstack = [ ] , vstack = [ null ] , lstack = [ ] , table = this . table , yytext = '' , yylineno = 0 , yyleng = 0 , recovering = 0 , TERROR = 2 , EOF = 1 ; var args = lstack . slice . call ( arguments , 1 ) ; var lexer = Object . create ( this . lexer ) ; var sharedState = { yy : { } } ; for ( var k in this . yy ) { if ( Object . prototype . hasOwnProperty . call ( this . yy , k ) ) { sharedState . yy [ k ] = this . yy [ k ] ; } } lexer . setInput ( input , sharedState . yy ) ; sharedState . yy . lexer = lexer ; sharedState . yy . parser = this ; if ( typeof lexer . yylloc == 'undefined' ) { lexer . yylloc = { } ; } var yyloc = lexer . yylloc ; lstack . push ( yyloc ) ; var ranges = lexer . options && lexer . options . ranges ; if ( typeof sharedState . yy . parseError === 'function' ) { this . parseError = sharedState . yy . parseError ; } else { this . parseError = Object . getPrototypeOf ( this ) . parseError ; } function popStack ( n ) { stack . length = stack . length - 2 * n ; vstack . length = vstack . length - n ; lstack . length = lstack . length - n ; } _token_stack : var lex = function ( ) { var token ; token = lexer . lex ( ) || EOF ; if ( typeof token !== 'number' ) { token = self . symbols_ [ token ] || token ; } return token ; } ; var symbol , preErrorSymbol , state , action , a , r , yyval = { } , p , len , newState , expected ; while ( true ) { state = stack [ stack . length - 1 ] ; if ( this . defaultActions [ state ] ) { action = this . defaultActions [ state ] ; } else { if ( symbol === null || typeof symbol == 'undefined' ) { symbol = lex ( ) ; } action = table [ state ] && table [ state ] [ symbol ] ; } if ( typeof action === 'undefined' || ! action . length || ! action [ 0 ] ) { var errStr = '' ; expected = [ ] ; for ( p in table [ state ] ) { if ( this . terminals_ [ p ] && p > TERROR ) { expected . push ( '\'' + this . terminals_ [ p ] + '\'' ) ; } } if ( lexer . showPosition ) { errStr = 'Parse error on line ' + ( yylineno + 1 ) + ':\n' + lexer . showPosition ( ) + '\nExpecting ' + expected . join ( ', ' ) + ', got \'' + ( this . terminals_ [ symbol ] || symbol ) + '\'' ; } else { errStr = 'Parse error on line ' + ( yylineno + 1 ) + ': Unexpected ' + ( symbol == EOF ? 'end of input' : '\'' + ( this . terminals_ [ symbol ] || symbol ) + '\'' ) ; } this . parseError ( errStr , { text : lexer . match , token : this . terminals_ [ symbol ] || symbol , line : lexer . yylineno , loc : yyloc , expected : expected } ) ; } if ( action [ 0 ] instanceof Array && action . length > 1 ) { throw new Error ( 'Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol ) ; } switch ( action [ 0 ] ) { case 1 : stack . push ( symbol ) ; vstack . push ( lexer . yytext ) ; lstack . push ( lexer . yylloc ) ; stack . push ( action [ 1 ] ) ; symbol = null ; if ( ! preErrorSymbol ) { yyleng = lexer . yyleng ; yytext = lexer . yytext ; yylineno = lexer . yylineno ; yyloc = lexer . yylloc ; if ( recovering > 0 ) { recovering -- ; } } else { symbol = preErrorSymbol ; preErrorSymbol = null ; } break ; case 2 : len = this . productions_ [ action [ 1 ] ] [ 1 ] ; yyval . $ = vstack [ vstack . length - len ] ; yyval . _$ = { first_line : lstack [ lstack . length - ( len || 1 ) ] . first_line , last_line : lstack [ lstack . length - 1 ] . last_line , first_column : lstack [ lstack . length - ( len || 1 ) ] . first_column , last_column : lstack [ lstack . length - 1 ] . last_column } ; if ( ranges ) { yyval . _$ . range = [ lstack [ lstack . length - ( len || 1 ) ] . range [ 0 ] , lstack [ lstack . length - 1 ] . range [ 1 ] ] ; } r = this . performAction . apply ( yyval , [ yytext , yyleng , yylineno , sharedState . yy , action [ 1 ] , vstack , lstack ] . concat ( args ) ) ; if ( typeof r !== 'undefined' ) { return r ; } if ( len ) { stack = stack . slice ( 0 , - 1 * len * 2 ) ; vstack = vstack . slice ( 0 , - 1 * len ) ; lstack = lstack . slice ( 0 , - 1 * len ) ; } stack . push ( this . productions_ [ action [ 1 ] ] [ 0 ] ) ; vstack . push ( yyval . $ ) ; lstack . push ( yyval . _$ ) ; newState = table [ stack [ stack . length - 2 ] ] [ stack [ stack . length - 1 ] ] ; stack . push ( newState ) ; break ; case 3 : return true ; } } return true ; } } ; var lexer = ( function ( ) { var lexer = ( { EOF : 1 , parseError : function parseError ( str , hash ) { if ( this . yy . parser ) { this . yy . parser . parseError ( str , hash ) ; } else { throw new Error ( str ) ; } } , setInput : function ( input , yy ) { this . yy = yy || this . yy || { } ; this . _input = input ; this . _more = this . _backtrack = this . done = false ; this . yylineno = this . yyleng = 0 ; this . yytext = this . matched = this . match = '' ; this . conditionStack = [ 'INITIAL' ] ; this . yylloc = { first_line : 1 , first_column : 0 , last_line : 1 , last_column : 0 } ; if ( this . options . ranges ) { this . yylloc . range = [ 0 , 0 ] ; } this . offset = 0 ; return this ; } , input : function ( ) { var ch = this . _input [ 0 ] ; this . yytext += ch ; this . yyleng ++ ; this . offset ++ ; this . match += ch ; this . matched += ch ; var lines = ch . match ( /(?:\r\n?|\n).*/g ) ; if ( lines ) { this . yylineno ++ ; this . yylloc . last_line ++ ; } else { this . yylloc . last_column ++ ; } if ( this . options . ranges ) { this . yylloc . range [ 1 ] ++ ; } this . _input = this . _input . slice ( 1 ) ; return ch ; } , unput : function ( ch ) { var len = ch . length ; var lines = ch . split ( /(?:\r\n?|\n)/g ) ; this . _input = ch + this . _input ; this . yytext = this . yytext . substr ( 0 , this . yytext . length - len ) ; this . offset -= len ; var oldLines = this . match . split ( /(?:\r\n?|\n)/g ) ; this . match = this . match . substr ( 0 , this . match . length - 1 ) ; this . matched = this . matched . substr ( 0 , this . matched . length - 1 ) ; if ( lines . length - 1 ) { this . yylineno -= lines . length - 1 ; } var r = this . yylloc . range ; this . yylloc = { first_line : this . yylloc . first_line , last_line : this . yylineno + 1 , first_column : this . yylloc . first_column , last_column : lines ? ( lines . length === oldLines . length ? this . yylloc . first_column : 0 ) + oldLines [ oldLines . length - lines . length ] . length - lines [ 0 ] . length : this . yylloc . first_column - len } ; if ( this . options . ranges ) { this . yylloc . range = [ r [ 0 ] , r [ 0 ] + this . yyleng - len ] ; } this . yyleng = this . yytext . length ; return this ; } , more : function ( ) { this . _more = true ; return this ; } , reject : function ( ) { if ( this . options . backtrack_lexer ) { this . _backtrack = true ; } else { return this . parseError ( 'Lexical error on line ' + ( this . yylineno + 1 ) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this . showPosition ( ) , { text : "" , token : null , line : this . yylineno } ) ; } return this ; } , less : function ( n ) { this . unput ( this . match . slice ( n ) ) ; } , pastInput : function ( ) { var past = this . matched . substr ( 0 , this . matched . length - this . match . length ) ; return ( past . length > 20 ? '...' : '' ) + past . substr ( - 20 ) . replace ( /\n/g , "" ) ; } , upcomingInput : function ( ) { var next = this . match ; if ( next . length < 20 ) { next += this . _input . substr ( 0 , 20 - next . length ) ; } return ( next . substr ( 0 , 20 ) + ( next . length > 20 ? '...' : '' ) ) . replace ( /\n/g , "" ) ; } , showPosition : function ( ) { var pre = this . pastInput ( ) ; var c = new Array ( pre . length + 1 ) . join ( "-" ) ; return pre + this . upcomingInput ( ) + "\n" + c + "^" ; } , test_match : function ( match , indexed_rule ) { var token , lines , backup ; if ( this . options . backtrack_lexer ) { backup = { yylineno : this . yylineno , yylloc : { first_line : this . yylloc . first_line , last_line : this . last_line , first_column : this . yylloc . first_column , last_column : this . yylloc . last_column } , yytext : this . yytext , match : this . match , matches : this . matches , matched : this . matched , yyleng : this . yyleng , offset : this . offset , _more : this . _more , _input : this . _input , yy : this . yy , conditionStack : this . conditionStack . slice ( 0 ) , done : this . done } ; if ( this . options . ranges ) { backup . yylloc . range = this . yylloc . range . slice ( 0 ) ; } } lines = match [ 0 ] . match ( /(?:\r\n?|\n).*/g ) ; if ( lines ) { this . yylineno += lines . length ; } this . yylloc = { first_line : this . yylloc . last_line , last_line : this . yylineno + 1 , first_column : this . yylloc . last_column , last_column : lines ? lines [ lines . length - 1 ] . length - lines [ lines . length - 1 ] . match ( /\r?\n?/ ) [ 0 ] . length : this . yylloc . last_column + match [ 0 ] . length } ; this . yytext += match [ 0 ] ; this . match += match [ 0 ] ; this . matches = match ; this . yyleng = this . yytext . length ; if ( this . options . ranges ) { this . yylloc . range = [ this . offset , this . offset += this . yyleng ] ; } this . _more = false ; this . _backtrack = false ; this . _input = this . _input . slice ( match [ 0 ] . length ) ; this . matched += match [ 0 ] ; token = this . performAction . call ( this , this . yy , this , indexed_rule , this . conditionStack [ this . conditionStack . length - 1 ] ) ; if ( this . done && this . _input ) { this . done = false ; } if ( token ) { return token ; } else if ( this . _backtrack ) { for ( var k in backup ) { this [ k ] = backup [ k ] ; } return false ; } return false ; } , next : function ( ) { if ( this . done ) { return this . EOF ; } if ( ! this . _input ) { this . done = true ; } var token , match , tempMatch , index ; if ( ! this . _more ) { this . yytext = '' ; this . match = '' ; } var rules = this . _currentRules ( ) ; for ( var i = 0 ; i < rules . length ; i ++ ) { tempMatch = this . _input . match ( this . rules [ rules [ i ] ] ) ; if ( tempMatch && ( ! match || tempMatch [ 0 ] . length > match [ 0 ] . length ) ) { match = tempMatch ; index = i ; if ( this . options . backtrack_lexer ) { token = this . test_match ( tempMatch , rules [ i ] ) ; if ( token !== false ) { return token ; } else if ( this . _backtrack ) { match = false ; continue ; } else { return false ; } } else if ( ! this . options . flex ) { break ; } } } if ( match ) { token = this . test_match ( match , rules [ index ] ) ; if ( token !== false ) { return token ; } return false ; } if ( this . _input === "" ) { return this . EOF ; } else { return this . parseError ( 'Lexical error on line ' + ( this . yylineno + 1 ) + '. Unrecognized text.\n' + this . showPosition ( ) , { text : "" , token : null , line : this . yylineno } ) ; } } , lex : function lex ( ) { var r = this . next ( ) ; if ( r ) { return r ; } else { return this . lex ( ) ; } } , begin : function begin ( condition ) { this . conditionStack . push ( condition ) ; } , popState : function popState ( ) { var n = this . conditionStack . length - 1 ; if ( n > 0 ) { return this . conditionStack . pop ( ) ; } else { return this . conditionStack [ 0 ] ; } } , _currentRules : function _currentRules ( ) { if ( this . conditionStack . length && this . conditionStack [ this . conditionStack . length - 1 ] ) { return this . conditions [ this . conditionStack [ this . conditionStack . length - 1 ] ] . rules ; } else { return this . conditions [ "INITIAL" ] . rules ; } } , topState : function topState ( n ) { n = this . conditionStack . length - 1 - Math . abs ( n || 0 ) ; if ( n >= 0 ) { return this . conditionStack [ n ] ; } else { return "INITIAL" ; } } , pushState : function pushState ( condition ) { this . begin ( condition ) ; } , stateStackSize : function stateStackSize ( ) { return this . conditionStack . length ; } , options : { } , performAction : function anonymous ( yy , yy_ , $avoiding_name_collisions , YY_START ) { var YYSTATE = YY_START ; switch ( $avoiding_name_collisions ) { case 0 : break ; case 1 : return 24 ; break ; case 2 : return 38 ; break ; case 3 : return 22 ; break ; case 4 : return 20 ; break ; case 5 : return 12 ; break ; case 6 : return 5 ; break ; case 7 : return yy_ . yytext [ 0 ] ; break ; } } , rules : [ /^(?:\s+)/ , /^(?:[0-9]+)/ , /^(?:(==|!=|<=|>=|<|>))/ , /^(?:[+\-*/%]?=)/ , /^(?:(\&\&)|\|\|)/ , /^(?:[a-zA-Z_][a-zA-Z0-9._]*)/ , /^(?:$)/ , /^(?:.)/ ] , conditions : { "INITIAL" : { "rules" : [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ] , "inclusive" : true } } } ) ; return lexer ; } ) ( ) ; parser . lexer = lexer ; function Parser ( ) { this . yy = { } ; } Parser . prototype = parser ; parser . Parser = Parser ; return new Parser ; } ) ( ) ; if ( typeof require !== 'undefined' && typeof exports !== 'undefined' ) { exports . parser = parser ; exports . Parser = parser . Parser ; exports . parse = function ( ) { return parser . parse . apply ( parser , arguments ) ; } ; exports . main = ( ) => { } ; if ( typeof module !== 'undefined' && require . main === module ) { exports . main ( process . argv . slice ( 1 ) ) ; } }